Przejdź do treści
Biblioteka skilli
Inne · Budowanie i kod

aspen-process-workflow

/aspen-process-workflow

Buduje w Aspen Plus procesy chemiczne: schematy, nowe jednostki i optymalizację kolumn, z etapami i wyborem trybu pracy.

Repozytorium
aspen_co-pilot ↗
Licencja
MIT
Ostatnia zmiana repozytorium
13.11.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
1
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 13.11.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co robi i kiedy

Buduje w Aspen Plus procesy chemiczne: schematy, nowe jednostki i optymalizację kolumn, z etapami i wyborem trybu pracy.

Wyzwalacze z opisu

build me an ethanol plantadd a recycleoptimize this column
Oryginalny opis (EN)

Use whenever the user asks to build, extend or change an Aspen Plus process (a new flowsheet, a new unit, a new route, "build me an ethanol plant", "add a recycle", "optimize this column"). Decides with the user whether to work in the Aspen Workbench (proposals built from blocks, questions as clickable choices) or in the conversation, then runs the work in phases. Do NOT use for a single read-only question about an open model, for run-time errors alone (aspen-error-troubleshooting), or for features no doc covers (observation-knowledge-extraction).

Jak działa

  1. Step 0 -- how to work (once per session)
  2. Looking things up (both modes)
  3. Workbench mode
  4. Chat mode
Sekcje z nagłówków SKILL.md, w oryginale · 166 linii, 1 533 słów
Podgląd SKILL.md
---
name: aspen-process-workflow
description: Use whenever the user asks to build, extend or change an Aspen Plus process (a new flowsheet, a new unit, a new route, "build me an ethanol plant", "add a recycle", "optimize this column"). Decides with the user whether to work in the Aspen Workbench (proposals built from blocks, questions as clickable choices) or in the conversation, then runs the work in phases. Do NOT use for a single read-only question about an open model, for run-time errors alone (aspen-error-troubleshooting), or for features no doc covers (observation-knowledge-extraction).
version: 1.0.0
---

# Aspen process workflow

The user reviews and approves the work; the AI prepares it. In the workbench that means
**proposals built from blocks**, **questions as choices**, and **results shown in the window**.
Everything the user reads -- replies, choices, proposal titles and reasons, a block's `why`,
every tool `reason` -- is written in the user's language.

## Step 0 -- how to work (once per session)

A session that is already open says its mode in its `[workbench]` lines and in
`workbench_read`'s `"mode"`. If it has one, use it and do not ask again.

Otherwise, before `create_new_simulation` / `open_aspen_plus`, ask with the client's question
tool (the workbench is not open yet, so its choices cannot ask this one):

- **Workbench (recommended)** -- the AI writes proposals, the user reviews and approves them
  in the window; questions are buttons to click. By default (the plugin's hooks) Ask AI
  requests arrive when the AI's turn ends or the user next types -- that works everywhere.
  Arriving at once is opt-in: on Claude Code through channels, a research preview that needs
  a development flag (see the workbench docs, requests.md, and mention it only if the user
  wants it); on Codex by starting Codex with `%USERPROFILE%\.aspen-mcp\codex-aspen.cmd`.
- **This conversation** -- the AI does the work here with the MCP tools; no window opens.

Pass the answer as `mode="workbench"` or `mode="chat"`. It is recorded for the session.
`open_workbench` later switches a session to workbench mode.

In the same question round, ask anything else the first step needs (route, scale) if the
request leaves it open. After that, in workbench mode, every question goes through the window.

## Looking things up (both modes)

Look up every Aspen path and parameter before using it with `doc_lookup` (a block type or
object and a few words). For what it does not answer -- how a feature works, which fields go
together -- use the `aspen-doc` subagent: put both `ASPEN_DOCS_ROOT` and `ASPEN_USER_DATA` from
the server instructions in its prompt; it does not see them. If you may not delegate, ask the user once to allow the subagent (the cheaper
route) and wait. If they decline, read the docs yourself: follow `aspen.md` to the one file
you need and take only the section the task calls for, never whole files (the tree is ~1 MB).

## Workbench mode

### 1. Clarify with choices

Ask only decisions that have real alternatives and change the result -- route, capacity,
product spec, which improvements to pursue. Ask them in the window:

```
workbench_edit(session_name, note_replies=[{"id": <the request's note id>,
  "reply": "<the question>",
  "choices": [{"label": "<option> (recommended)", "detail": "<one line: what it means>"}, ...],
  "multi": <true when several may be picked>}])
```

2-6 options, the recommended one first, labels short (the rest goes in `detail`). The pick
arrives as a new request with `answer_to` and `picked`. The user may type instead; treat
that as the answer. A question that has no request to answer yet goes on the request that
started the work.

Never ask the user about *how* something is configured (tree paths, table rows, tool names).
They cannot judge it and would only click "yes".

### 2. Look up every path first

Look up every path (see *Looking things up*) before writing any step. A proposal with a wrong path fails its check. The user then sees an error they
cannot fix.

### 3. Build in phases, one proposal each

A proposal is a program that opens as a sub-tab of the model's tab. Only the user runs it.
Finished proposals move to the History list; a revision by tab id reopens one. Pressing
*Approve and run* takes a restore point first, so one approval covers the whole phase, and
the phase can be undone as one group.

```
workbench_edit(session_name, proposal={"title": "<phase, in the user's language>",
  "reason": "<what this phase does to the process and why>"}, program=[...])
```

Give every step that changes the model a `"why"` (learning mode requires it).

Keep reasons short; the window already shows each step's field and value beside them.

- A `why` -- a step's or a group heading's -- is one clause with the engineering reason: about
  20 Chinese characters or 12 English words. Do not restate the value, the unit or the field, and
  leave out numbers and arithmetic (they go in the reply).
- A proposal `reason` is one or two sentences: what the phase changes and what it is for. Do
  not list the steps; the steps list shows them.
- A derivation the user may want to check goes in the reply, once, not in every `why`.
- Head each purpose with `{"do": "group", "title", "why"}` (a new unit with its streams and
  settings; one change of conditions), at most 8 per proposal; its steps follow it. The user
  can apply it group by group.
- In learning mode, give a group the idea it rests on: `"principle": ["<key>"]` on the heading
  (at most 2 keys from docs/principles/index.md; none fits: leave it off, never invent one).
  The card explains the idea; the group's `why` says what it means for this change.
- Give the proposal `"watch": [{"path", "label"?}]` (at most 3, looked up like any path):
  the goal result first (the purity or rate the phase is for). The window tags their values
  measured before and after the run.
- While the user applies it group by group, post no line per group ("group 1 applied"): the
  window's group card shows where it is. After the run, say only what the flowsheet does not
  show (a yearly capacity, your judgement), not the values it already tags
  (`workbench_read` → `proposals[].effects`).
- When a tool's answer says a run's results are tagged, you may explain how the change reached
  each: `proposal={"explain": {"run", "items": [{"result", "via"?, "words"?, "text"?}]}}`
  (docs/mcp/workbench/proposals.md, *Explaining the tags*). Words name the mechanism; never a number.

| Phase | Steps (blocks) | Ends with |
|---|---|---|
| 1 Skeleton | `component` add, `method`, `place` blocks and streams, `connect` | the flowsheet exists |
| 2 Specs and run | `set` feed and unit specs, `run`, `table` of the key results | a converged base case |
| 3+ Improve | `sweep`, `seek`, `optimize`, `pinch`, each with a `table` or `plot` | a better operating point |

Split a phase further when it is long or risky. Do not merge phases 1 and 2: a check
cannot see a block's inputs before the block exists.

### 4. Between phases: the gap steps

When an approved proposal ends, the AI is told by a workbench event (`event:
"proposal_end"`, `outcome` applied / partial / failed). No user message is needed. Close the
event with `note_replies=[{"id", "done": true}]`.

- **applied** -- do the phase's **gap steps**, then send the next proposal.
- **partial / failed** -- read why (`workbench_read`: the run log, `diagnosis`). If the
  cause is a run error, follow aspen-error-troubleshooting. Then revise **the same proposal**
  (`workbench_edit(tab=<its tab id>, program=...)`, which makes rev 2) and say what changed.
  Send the whole program: steps that applied in the failed run and are unchanged start turned
  off for the user by themselves. Do not patch the model around it with MCP calls.

**Gap steps** are what no block can do yet. Do them with MCP tools right after the phase
they belong to, without asking:

- Henry components (a dissolved gas: `add_element` under `Henry-Comps`, `GHEN`)
- RStoic / RYield stoichiometry and other table rows (`insert_row`, `set_label`)
- reaction sets and reactions (`add_reaction_set`, `add_reaction`)
- node attributes such as a flow basis (`set_node_attribute`)
- Aspen's own drawing (`layout_flowsheet`, once, after the skeleton)

Rules for gap steps:

- Say the **engineering decision** in process words, never the mechanism. The best place is
  the reason of the proposal it belongs to ("the fermentation reaction C6H12O6 -> 2 ethanol
  + 2 CO2 is entered after the skeleton"; "CO2 is treated as a dissolved gas (Henry's law)").
  Each call's `reason` explains the process principle, in the user's language.
- Ask only when the decision itself has alternatives that change the results, and then as
  choices (e.g. how to model the dissolved gas). Never ask whether to run a gap step.
- Taking back a table row the AI inserted itself asks no card. Other removals still do.

### 5. Report in the window

- Put the results in the proposal's `table` / `plot`.
- Mark the streams and blocks that matter with `highlight` (a `note` on each: one sentence
  on why).
- Reply to the request in two or three sentences, pointing at them.
- A reply sent while more work follows (a subagent, a long call, the next proposal) carries
  `"working": true`, so the window shows you still working; the final reply leaves it out.

The conversation gets one line and nothing more: what was done, and what the user should
look at.

## Chat mode

Work in the conversation with the MCP tools, looking every path up first (see *Looking things
up*). No window opens.
Ask decisions with the client's question tool. Still write every `reason` in the user's
language. If the user later wants the window, `open_workbench` switches the session to
workbench mode. From then on, follow the workbench mode above.

Wersje

W bazie nie ma innych skilli o nazwie aspen-process-workflow.

Migawka bazy z 13.11.2026 · wersja paczki 1dff8bc2d786 (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 100aspen-error-troubleshooting
    Diagnozuje błędy i ostrzeżenia symulacji Aspen Plus, od przyczyny po poprawkę, i zapisuje wynik zgodnie z zasadami prywatności.
  • 90observation-knowledge-extraction
    Uczy się konfigurować Aspen Plus, obserwując demonstrację w GUI, odtwarza ją i zapisuje jako dokumentację na przyszłość.
  • 89neqsim-unisim-reader
    Odczytuje pliki UniSim Design i Aspen HYSYS przez COM i zamienia je na modele NeqSim, a potem porównuje wyniki z oryginałem.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.