langflower 0.0.8 → 0.0.10

package/vendor/server/skeleton/skills/langflower-helper/SKILL.md

@@ -13,6 +13,10 @@ provider. They are past bootstrap; do not lead with CLI start or provider setup.
 ## Role and style
 
 - Short, actionable steps. No long essays.
+- On **starter**, **Langflower Tools** is wired to you and Writer — you
+  already have **`compile_custom_nodes`**. After pack file changes, **call
+  it** (no arguments). Do not send the user to Custom → **Update** as the
+  only path.
 - Answer **only** from allowed fact sources: the **Companion docs** (via
   `read` when relevant) and the **Knowledge base** below. If a fact is
   missing, say **not in my facts** (or point at project use-case docs) —
@@ -35,8 +39,8 @@ Bootstrap and provider facts stay in the Knowledge base for when they ask.
 Example opening:
 
 > Glad you got Langflower running and a provider configured. I can explain what
-> Langflower can do and help you set up workflows and nodes for your needs.
-> What do you want to build?
+> Langflower can do, help you set up workflows and custom nodes, and compile
+> packs from this chat (`compile_custom_nodes`). What do you want to build?
 
 ## Companion docs
 
@@ -112,7 +116,11 @@ do not say coding pipelines “don’t exist” or are unavailable.
 - **Can:** Chat Input graphs start from the composer **Start** control. Plain
   **Run** stays disabled for those graphs.
 - **Can:** While running — Hard **Stop**, soft **Pause**, HITL and
-  `permission.ask` in the composer.
+  `permission.ask` in the composer. Work log **clears** on successful
+  workflow load / create / copy (not rename).
+- **Cannot:** Switch, rename, delete, copy, or create a workflow while a run
+  is active — Stop first. Same lock: inspector / canvas inline / palette
+  drag (`cursor-not-allowed`).
 - **Cannot:** Tell users to press plain **Run** to start a Chat Input graph.
 - **Cannot:** Claim the feed after reload must be **richer** than live.
 - **Cannot:** Claim `basic-coder` proves chat-dense mood for the full
@@ -128,36 +136,45 @@ do not say coding pipelines “don’t exist” or are unavailable.
 
 ### 6. Coding workflows
 
-| Name           | Fact                                                                                                                                                                                                                                                                                               |
-| -------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `starter`      | Onboarding chat + this skill + Writer Sub-Agent (`langflower-workflow-writer` + `langflower-node-writer`) — default open after seed                                                                                                                                                                |
-| Skeleton stubs | `simple-coder`, `advanced-coder`, `kb-create`, `kb-navigate`, … seeded on first-run; with provider → Start                                                                                                                                                                                         |
-| `simple-coder` | Plan⇄HITL→Coder⇄HITL→Finish smoke spine + `common-memory-tools` on Plan/Coder/Researcher/Worker; Researcher Sub-Agent under Plan, Worker under Coder — **not** full multi-loop `coding-agent`                                                                                                      |
-| `kb-create`    | Memory / project wiki create: Orchestrator **indexes** the repo with `glob`/`read`, persists `history/work-queue.md`, then **serially** spawns Explorer → Composer **one unit at a time**; `common-memory-tools` writes `core/*` + `modules/*`; Review rejects non-empty Pending or thin overviews |
-| `kb-navigate`  | Memory navigate: Navigator + Searcher + memory tree/grep/section tools; HITL Review Gate for follow-ups                                                                                                                                                                                            |
-| `basic-coder`  | Basic coding harness (Plan⇄HITL→Coder⇄HITL→Finish) — not a toy, **not** full multi-loop `coding-agent`                                                                                                                                                                                             |
-| `coding-agent` | Clarify HITL → red team → plan gate → coder → QA → `common-review` → result HITL; **graph** orders stages                                                                                                                                                                                          |
-| Status         | Use-case **Partial**; real-LLM Implementable bar open; Fake CI ≠ end-user proof — **not** “no templates”                                                                                                                                                                                           |
+| Name           | Fact                                                                                                                                                                                                                                                                                              |
+| -------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `starter`      | Onboarding chat + this skill + Writer Sub-Agent (`langflower-workflow-writer` + `langflower-node-writer`) — default open after seed                                                                                                                                                               |
+| Skeleton stubs | `simple-coder`, `advanced-coder`, `kb-create`, `kb-navigate`, … seeded on first-run; with provider → Start                                                                                                                                                                                        |
+| `simple-coder` | Plan⇄HITL→Coder⇄HITL→Finish smoke spine + `common-memory-tools` on Plan/Coder/Researcher/Worker; Researcher Sub-Agent under Plan, Worker under Coder — **not** full multi-loop `coding-agent`                                                                                                     |
+| `kb-create`    | Memory / project wiki create: Orchestrator **indexes** the repo with `glob`/`read`, persists `history/work-queue.md`, then **serially** calls Explorer → Composer **one unit at a time**; `common-memory-tools` writes `core/*` + `modules/*`; Review rejects non-empty Pending or thin overviews |
+| `kb-navigate`  | Memory navigate: Navigator + Searcher + memory tree/grep/section tools; HITL Review Gate for follow-ups                                                                                                                                                                                           |
+| `basic-coder`  | Basic coding harness (Plan⇄HITL→Coder⇄HITL→Finish) — not a toy, **not** full multi-loop `coding-agent`                                                                                                                                                                                            |
+| `coding-agent` | Clarify HITL → red team → plan gate → coder → QA → `common-review` → result HITL; **graph** orders stages                                                                                                                                                                                         |
+| Status         | Use-case **Partial**; real-LLM Implementable bar open; Fake CI ≠ end-user proof — **not** “no templates”                                                                                                                                                                                          |
 
 ### 7. Run lifecycle
 
-| Mechanism             | Meaning                                                                                               |
-| --------------------- | ----------------------------------------------------------------------------------------------------- |
-| Hard Stop             | Cancel; does **not** by itself create checkpoint Continue                                             |
-| Soft Pause            | Per-node Steer pause of the last feed agent; siblings keep working; Send / Resume continues that node |
-| Browser close         | If `langflower start` stays up, run continues; reopen live or settled                                 |
-| Process kill / reboot | **Not** detachable resume                                                                             |
-| Checkpoint Continue   | Needs explicit boundary (`common-checkpoint` / `createCheckpoint`); **no** every-node auto Continue   |
+| Mechanism             | Meaning                                                                                                                                                                                                                                                                                                                                                                                      |
+| --------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Hard Stop             | Cancel; does **not** by itself create checkpoint Continue                                                                                                                                                                                                                                                                                                                                    |
+| Soft Pause            | Per-node Steer pause of the last feed agent; siblings keep working; Send / Resume continues that node                                                                                                                                                                                                                                                                                        |
+| Provider recovery     | Idle: default **autokick** (abort, exponential backoff, full-store replay + kick). Dead-loop: abort + short `retryBaseDelayMs` wait (not idle backoff) + kick. 429/5xx/network: short transient budget, then autokick **wait** (no kick, no penalty). `'retry'` banner stays in the feed after reasoning/draft; does not open Steer. Off / cap exhausted → **Steer**. Auth/config stay fatal |
+| Browser close         | If `langflower start` stays up, run continues; reopen live or settled                                                                                                                                                                                                                                                                                                                        |
+| Process kill / reboot | **Not** detachable resume                                                                                                                                                                                                                                                                                                                                                                    |
+| Checkpoint Continue   | Needs explicit boundary (`common-checkpoint` / `createCheckpoint`); **no** every-node auto Continue                                                                                                                                                                                                                                                                                          |
 
 These four are **not** the same thing.
 
 ### 8. Tools, permissions, MCP
 
 - **Can:** Harness builtins + `permission.ask` Allow/Deny for those builtins.
-  Wired pack / MCP tools (including memory writes) do **not** ask — authoring
-  the edge is consent. Write Allow does **not** grant bash. Agents receive
-  **McpHandle**s; system MCP starts only for ids enabled on nodes in the
-  active workflow.
+  Wired pack / MCP tools (including memory writes and **Langflower Tools**)
+  do **not** ask — authoring the edge is consent. Write Allow does **not**
+  grant bash. MCP **nodes** wire `tools` → agent `tools` (`ToolHandle[]`).
+  Optional **Tool collection** (`common-tool-collection`) can merge several
+  `tools` wires into one before the agent. Direct multi-wire into the agent
+  still works. System MCP from `langflower.jsonc` starts only for ids enabled
+  on nodes in the active workflow; those tools land on `EC.toolHandles`,
+  never as raw config.
+- **Can:** `compile_custom_nodes` exists only when **Langflower Tools**
+  (`common-langflower-tools`) is wired into that agent’s `tools` port
+  (starter Helper / Writer). Same intent as Custom → **Update**. Recompile
+  is unsafe — not ambient on every agent.
 - **Can:** First-run `langflower.jsonc` seeds `permission` allow-all (project
   **floor**). Inspector **Tool permissions** table (`tool` / `deny` / `ask` /
   `allow`) sets per-agent `toolPermissions` (cannot loosen past floor). Presets
@@ -171,16 +188,21 @@ These four are **not** the same thing.
 ### 9. Sub-Agent and swarm
 
 Sub-Agent is an **explicit canvas node** for **control and observability**
-(own toolLog/response, visible spawn, `nodeId` filter) — not magic inside one
-LLM turn.
-
-- **Can:** First-class Sub-Agent node + spawn registration / `subagentResult`.
-  Default swarm spawns are **serial**. Wiki/memory create (`kb-create`) uses
-  **serial** scoped spawns driven by a persisted work queue — not parallel
+(own toolLog/response, visible specialist) — not magic inside one LLM turn.
+
+- **Can:** First-class Sub-Agent node. Wire Sub-Agent
+  `subagent-registration` → parent `tools` (one edge). The parent calls the
+  specialist tool (`Writer(subagent)` / `toolId` `Writer_subagent`) with a
+  `task`
+  (optional `skillId` from the Inspector Skills enum). That call closes the
+  parent work-log visit; the specialist streams as its own card. Default swarm
+  invokes are **serial**. Wiki/memory create (`kb-create`) uses **serial**
+  scoped specialist calls driven by a persisted work queue — not parallel
   whole-repo fan-out.
 - **Cannot / not yet:** Hide Sub-Agent work only inside a single LLM turn with
   no graph node (anti-pattern). Parallel fan-out as the **default**. Nested
-  **workflow files** (far future).
+  **workflow files** (far future). Do not look for `spawn_subagent` or
+  registration / spawn / result ports — those wires are gone.
 
 ### 10. Other demos
 
@@ -209,7 +231,8 @@ When the user asks to “create a project wiki”, “build a knowledge base”,
   → Orchestrator (`common-openai-llm` + builtins `glob`/`read`/`grep` + wired
   `common-memory-tools`) → Sub-Agents Explorer (read) + Composer (write) →
   `common-review` with readiness criteria → Finish. Persist a work queue in
-  memory **before** deep survey; `spawn_subagent` **one unit at a time**.
+  memory **before** deep survey; call the Explorer / Composer specialist
+  tools **one unit at a time**.
 - **Cannot:** Recommend one LLM that “reads the whole repo once and dumps a
   wiki”. Claim vector/embedding KB as base. Claim Obsidian vault helpers as
   shipped.
@@ -217,17 +240,38 @@ When the user asks to “create a project wiki”, “build a knowledge base”,
 ### 11. Custom nodes
 
 - **Can:** **TypeScript** via `@langflower/node-sdk` — first-class language;
-  `tsc` / IDE types act as compile-time validators before Custom → **Update**.
-  Packs under `.langflower/nodes/<pack>/`; user runs `npm install` in the pack.
-  See `instructions.md` and `nodes/my-nodes/README.md`.
+  `tsc` / IDE types act as compile-time validators. After file changes call
+  **`compile_custom_nodes`** (no args) or Custom → **Update** — same
+  composer. On starter you already have the tool (Langflower Tools wired).
+  Stop is not required for already-placed custom types (hot-swap).
+  An already-wired custom tools pack can be invoked later in the **same run**
+  after compile. New types appear under **Custom**; Langflower does **not**
+  auto-place or auto-wire them mid-run.
+  Packs under `.langflower/nodes/<pack>/`; user runs `npm install` in the pack
+  when adding author deps. See `instructions.md` and `nodes/my-nodes/README.md`.
   Nodes may **intentionally keep in-memory internal state across runs**
   (Stop / done / Start) until the user loads another workflow or shuts down
   Langflower — not the same as Checkpoint resume after process kill.
 - **Cannot:** Plain JS as the authoring path, Go, Python, or other languages.
   Server auto-install. Sandboxed arbitrary user-node execution as shipped.
-  Custom-pack compiler as product-Implementable.
-  Claim that every node always resets on Stop, or that in-memory node state
-  survives process restart without Checkpoints.
+  Ambient compile without Langflower Tools wired. Canvas add/remove node or
+  edge tools (not shipped). Claim that every node always resets on Stop, or
+  that in-memory node state survives process restart without Checkpoints.
+
+### 11a. Recipe — write / reload a custom node
+
+When the user asks to add or change a custom node from this starter chat:
+
+1. Call Writer (or edit `.langflower/nodes/<pack>/*.ts` yourself).
+2. Call **`compile_custom_nodes`** (no args). Report `status` / `nodeTypes` /
+   `errors` from the tool text. Pack failures also write
+   `COMPILATION_ERRORS.md`.
+3. **Already on the canvas** → live now, no Stop. **New type** → user places
+   it from Custom and wires it; this tool does not drop nodes on the canvas.
+4. If a custom tools pack is already wired into this agent, you may call those
+   `toolId`s later in **this run** after compile.
+
+Do **not** treat Custom → Update as the only reload path on starter.
 
 ### 12. Status vocabulary
 

package/vendor/server/skeleton/skills/langflower-helper/architecture.md

@@ -57,11 +57,18 @@ Project product data for Langflower lives under **`.langflower/`**.
 - **HITL loops** (Review Gate, feedback ports, composer Start/Send) are normal
   **internal waiting state of nodes**, not a separate product “interrupt the
   engine” mechanism.
-- LLM provider idle/HTTP 5xx/network failures retry from the last committed
-  round, then keep the node alive for **Steer / Resume** (recovery notices on
-  the `recovery` port; suspend opens the Steer composer). Partial draft text is
-  telemetry, not committed history. Authentication/configuration failures are
-  terminal. Generic reload of any failed non-LLM node is not yet shipped.
+- LLM provider idle **aborts** the in-flight request, then default
+  **autokick** (exponential backoff, full stored messages + kick user
+  turn). Dead-loop aborts the same way but waits **`retryBaseDelayMs`**
+  (not idle backoff) before that replay. HTTP 429 / 5xx / network use the
+  short transient budget, then join the idle autokick wait **without** a
+  kick turn or penalty bump. `'retry'` notices on the `recovery` port stay
+  in the feed after reasoning/draft, tick locally on the visit tail, and
+  do **not** open Steer. Autokick off or a finite cap exhausted keep the
+  node alive for **Steer / Resume** (`'suspended'`).
+  Partial draft text is telemetry, not committed history.
+  Authentication/configuration failures are terminal. Generic reload of any
+  failed non-LLM node is not yet shipped.
 - Also on the bus: runner start / resume / interrupt intents, `permission.ask`,
   and related facts.
 
@@ -69,7 +76,13 @@ Project product data for Langflower lives under **`.langflower/`**.
 
 - LLM / agent nodes use **skills** and harness tools as wired in the graph.
 - **Sub-Agent** is an **explicit canvas node** for control and observability
-  (own toolLog/response, visible spawn) — not hidden work inside one LLM turn.
+  (own toolLog/response). Wire `subagent-registration` into the parent
+  `tools` — not hidden work inside one LLM turn. The announced tool is
+  `{name}(subagent)` (`toolId` slug `Name_subagent`). Calling that tool closes
+  the parent work-log visit; the specialist streams as its own card, and
+  the parent continues in a new visit below. Optional **Tool collection**
+  (`common-tool-collection`) can merge several `tools` wires; direct
+  multi-wire into the agent still works.
 - **Graph order** stages the pipeline; the model does not invent the stage
   sequence outside the graph.
 - Project memory / wiki create is **queue-driven**: index with harness `glob`,
@@ -80,11 +93,17 @@ Project product data for Langflower lives under **`.langflower/`**.
 ## Extensibility
 
 - Custom nodes use the same **`@langflower/node-sdk`** path as built-ins.
-- **TypeScript** is first-class; `tsc` / IDE types act as compile-time gates
-  before Custom → **Update**.
+- **TypeScript** is first-class; `tsc` / IDE types act as compile-time gates.
+  After file changes call `compile_custom_nodes` (only if **Langflower
+  Tools** is wired — starter Helper / Writer already are) or Custom →
+  **Update**. Same composer: typecheck + bundle + hot-swap live custom
+  instances + refresh the Custom palette.
+  Stop is not required for already-placed custom types.
+  An already-wired custom tools pack can be invoked later in the same run
+  after compile. Do not auto-place or auto-wire a new type mid-run.
 - Plain JS / Go / Python are not the authoring path. Sandboxed arbitrary
-  user-node execution and a custom-pack compiler are **not** claimed as
-  shipped Implementable here.
+  user-node execution is **not** shipped. Canvas add/remove node or edge
+  tools are **not** shipped (later rows on Langflower Tools).
 
 ## What stays local
 

package/vendor/server/skeleton/skills/langflower-helper/layout.md

@@ -17,21 +17,22 @@ Facts for UI chrome and on-disk paths. Prefer this file over guessing.
 
 ## Where can I…?
 
-| Goal                                   | Where                                                                                                                                  |
-| -------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------- |
-| Change provider / API key              | Gear → **Settings** (right aside; Global auto-opens when none configured), or edit `.langflower/langflower.jsonc` (prefer `{env:VAR}`) |
-| Start a Chat Input graph               | Composer **Start** — not plain **Run** (Run stays disabled for those graphs)                                                           |
-| See run output / stream                | Right aside **feed**                                                                                                                   |
-| Answer HITL / send into a waiting node | Composer + feed context                                                                                                                |
-| Allow or Deny `permission.ask`         | Composer permission controls                                                                                                           |
-| Soft-pause last feed agent / continue  | Composer **Pause** (per-node) / Send or Resume (soft pause ≠ Hard Stop)                                                                |
-| Hard-stop a run                        | Composer **Stop**                                                                                                                      |
-| Edit selected node params / ports      | Select node → right aside **inspector** (not Settings)                                                                                 |
-| Add or reload custom nodes             | Put pack under `.langflower/nodes/<pack>/`, then Custom → **Update**                                                                   |
-| Switch workflow                        | Topbar workflow list                                                                                                                   |
-| Open Settings without leaving canvas   | Gear — Settings in right aside                                                                                                         |
-| Find sample coding graphs              | Skeleton / demo-project workflow files — **manual copy** into project, then load → Start. No Sample workflows catalog UI.              |
-| Project instructions for agents        | `.langflower/instructions.md`                                                                                                          |
+| Goal                                   | Where                                                                                                                                                                                                                                                                                                                |
+| -------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Change provider / API key              | Gear → **Settings** (right aside; Global auto-opens when none configured), or edit `.langflower/langflower.jsonc` (prefer `{env:VAR}`)                                                                                                                                                                               |
+| Start a Chat Input graph               | Composer **Start** — not plain **Run** (Run stays disabled for those graphs)                                                                                                                                                                                                                                         |
+| See run output / stream                | Right aside **feed**                                                                                                                                                                                                                                                                                                 |
+| Answer HITL / send into a waiting node | Composer + feed context                                                                                                                                                                                                                                                                                              |
+| Allow or Deny `permission.ask`         | Composer permission controls                                                                                                                                                                                                                                                                                         |
+| Soft-pause last feed agent / continue  | Composer **Pause** (per-node) / Send or Resume (soft pause ≠ Hard Stop)                                                                                                                                                                                                                                              |
+| Hard-stop a run                        | Composer **Stop**                                                                                                                                                                                                                                                                                                    |
+| Edit selected node params / ports      | Select node → right aside **inspector** (not Settings). Read-only while a run is active — Stop first.                                                                                                                                                                                                                |
+| Add a node from the palette            | Drag from the left palette onto the canvas. Disabled while a run is active (`cursor-not-allowed`) — Stop first.                                                                                                                                                                                                      |
+| Add or reload custom nodes             | Pack under `.langflower/nodes/<pack>/`. On starter, Helper / Writer call `compile_custom_nodes` (Langflower Tools is wired). Else Custom → **Update**. Hot-swap already-placed types; already-wired custom tools work later in the same run. New types: user places from Custom (no auto-place / auto-wire mid-run). |
+| Switch workflow                        | Topbar workflow list. Load / New / Copy / rename / Delete are locked while a run is active — Stop first.                                                                                                                                                                                                             |
+| Open Settings without leaving canvas   | Gear — Settings in right aside                                                                                                                                                                                                                                                                                       |
+| Find sample coding graphs              | Skeleton / demo-project workflow files — **manual copy** into project, then load → Start. No Sample workflows catalog UI.                                                                                                                                                                                            |
+| Project instructions for agents        | `.langflower/instructions.md`                                                                                                                                                                                                                                                                                        |
 
 ## On-disk `.langflower/` map
 

package/vendor/server/skeleton/skills/langflower-node-writer/SKILL.md

@@ -3,7 +3,7 @@ name: Langflower node writer
 description: >-
     Guides authors writing project custom nodes under .langflower/nodes packs
     (defineNode / defineToolRegistrations / defineReactiveNode, ADR-030 layout,
-    reload via Custom Update).
+    reload via compile_custom_nodes or Custom Update).
 ---
 
 # Langflower node writer
@@ -16,10 +16,14 @@ You help the user write **custom nodes** for Langflower.
   language; `tsc` / IDE types are the compile-time validators. **Not** plain JS
   as the authoring path, Go, Python, Rust, or other runtimes.
 - Do **not** claim sandboxed execution of arbitrary user-node code is shipped.
-- Do **not** claim a custom-pack compiler epic is product-Implementable unless
-  the user’s docs say so — packs reload via Custom → **Update** /
-  `COMPILATION_ERRORS.md` today.
+- After file changes **call `compile_custom_nodes` yourself** (no args) — on
+  starter, Writer has it because **Langflower Tools** is wired. Custom →
+  **Update** is the same composer. Failures land in `COMPILATION_ERRORS.md`.
+  Do **not** only remind the user to click Update.
 - Langflower does **not** auto-`npm install` pack dependencies.
+- Do **not** claim you can place a newly compiled type on the canvas or wire
+  it mid-run. Already-placed types hot-swap; already-wired custom tools can
+  be invoked later in the **same run**.
 
 ## Contract (do not invent forks)
 
@@ -34,8 +38,12 @@ You help the user write **custom nodes** for Langflower.
   Skip `*.test.ts`, `*.d.ts`, `dist/`, `node_modules/`.
 - Peer deps on the host SDK / RxJS are supplied by Langflower; author libs go
   in pack `dependencies`. The user runs `npm install` in the pack.
-- After file changes: Custom section → **Update**. Failures land in
-  `COMPILATION_ERRORS.md` in that pack.
+- After file changes: call **`compile_custom_nodes`** (wired on starter
+  Helper / Writer via **Langflower Tools** — not ambient on every agent) or
+  Custom section → **Update**. Stop is not required for already-placed
+  custom types. An already-wired custom tools pack can be invoked later in
+  the **same run** after compile. Failures land in `COMPILATION_ERRORS.md`
+  in that pack.
 
 ## When drafting a node
 
@@ -44,9 +52,11 @@ You help the user write **custom nodes** for Langflower.
    (`defineToolRegistrations` owns a `tools` output — no custom inputs).
 3. Implement `execute` (`defineNode`), `tools` handlers
    (`defineToolRegistrations`), or `bind` (`defineReactiveNode`).
-4. Show the full file the user can paste into `my-nodes/`.
-5. Remind them to Update Custom and fix compile errors from
-   `COMPILATION_ERRORS.md` if present.
+4. Show the full file the user can paste into `my-nodes/` **or write it**
+   under `.langflower/nodes/<pack>/`.
+5. Call **`compile_custom_nodes`**. If the snapshot lists errors, `read`
+   that pack’s `COMPILATION_ERRORS.md`, fix, and compile again. Tell the
+   user to place **new** types from Custom; already-placed types are live.
 
 ## References in the project
 

package/vendor/server/skeleton/skills/langflower-workflow-writer/SKILL.md

@@ -2,7 +2,8 @@
 name: Langflower workflow writer
 description: >-
     Guides authors writing and editing `.langflower/workflows/*.json` graphs
-    (catalog node types, real ports, Soft↔Hard loops, Sub-Agent L0 wiring).
+    (catalog node types, real ports, Soft↔Hard loops, Sub-Agent
+    `subagent-registration` wiring).
 ---
 
 # Langflower workflow writer
@@ -24,6 +25,9 @@ You help the user **author valid Langflower workflow JSON** under
   `write`, `create`, `delete`, `bash` — never `Bash(ls)`-style strings.
 - LLM `rolePreset` values are only: `custom` | `plan` | `coder` | `explorer`.
   Unknown values silently become `custom`.
+- Recompile is opt-in: wire `common-langflower-tools` `tools` → agent
+  `tools`. Do **not** add that pack to every agent unless the user wants
+  `compile_custom_nodes`. Do not invent editor mutation tools on that pack.
 
 ## On-disk shape
 
@@ -49,16 +53,19 @@ Schema: `.langflower/schemas/workflow.schema.json`. Samples:
 
 ## Ports you must get right
 
-| Node type                               | Key ports                                                                                                            |
-| --------------------------------------- | -------------------------------------------------------------------------------------------------------------------- |
-| `common-chat-input`                     | out `message` (no wireable in)                                                                                       |
-| `common-openai-llm` / `common-fake-llm` | in `userPrompt`, `systemPrompt`, `feedback`, `subagentRegistration`, `subagentResult`; out `response`, `subagent`, … |
-| `common-hitl-review-gate`               | in `result`; out `response`, `feedback`                                                                              |
-| `common-merge`                          | in/out **`value`** only (not `step` / `output`)                                                                      |
-| `common-review`                         | in `task`, `result`, `systemPrompt`; out `response`, `feedback`                                                      |
-| `common-sub-agent`                      | out `registration`, `result`; in `task`, `systemPrompt`                                                              |
-| `common-finish`                         | in `value`                                                                                                           |
-| `common-string`                         | in/out `value`                                                                                                       |
+| Node type                               | Key ports                                                                                                                                                                                                              |
+| --------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `common-chat-input`                     | out `message` (no wireable in)                                                                                                                                                                                         |
+| `common-openai-llm` / `common-fake-llm` | in `userPrompt`, `systemPrompt`, `feedback`, `tools`; out `response`, `toolLog`, …                                                                                                                                     |
+| `common-mcp-stdio` / `common-mcp-http`  | out **`tools`** — wire into an agent `tools` port (not a separate `mcp` port)                                                                                                                                          |
+| `common-tool-collection`                | in **`tools`** (multi combine) → out **`tools`** — optional hub; duplicate `toolId` last-wins. Direct pack → agent still OK                                                                                            |
+| `common-hitl-review-gate`               | in `result`; out `response`, `feedback`                                                                                                                                                                                |
+| `common-merge`                          | in/out **`value`** only (not `step` / `output`)                                                                                                                                                                        |
+| `common-review`                         | in `task`, `result`, `systemPrompt`, `tools`; out `response`, `feedback`                                                                                                                                               |
+| `common-sub-agent`                      | out **`subagent-registration`** (one specialist handle) → parent `tools`; in `systemPrompt`, `tools`                                                                                                                   |
+| `common-finish`                         | in `value`                                                                                                                                                                                                             |
+| `common-string`                         | in/out `value`                                                                                                                                                                                                         |
+| `common-langflower-tools`               | out **`tools`** only — wire into an agent `tools` port to opt in to **`compile_custom_nodes`** (unsafe; starter Helper / Writer already wired). Not ambient. Canvas add/remove node or edge tools are **not** shipped. |
 
 ## Soft↔Hard loops
 
@@ -71,13 +78,14 @@ Typical HITL revise loop:
 Do **not** feed Merge output into both gates and LLM feedback on every tick
 without a clear phase split.
 
-## Sub-Agent L0 (registration + spawn)
+## Sub-Agent (one registration wire)
 
 Mirror `.langflower/workflows/kb-navigate.json`:
 
-- Sub-Agent `registration` → parent `subagentRegistration`
-- Parent `subagent` → Sub-Agent `task`
-- Sub-Agent `result` → parent `subagentResult`
+- Sub-Agent `subagent-registration` → parent `tools`
+- Parent calls the specialist tool (`task`, optional `skillId` enum)
+- Do **not** draw `registration` / `subagent` / `task` / `result` /
+  `subagentResult` — those ports are gone
 
 ## Load repair (product fact)
 

package/vendor/server/skeleton/workflows/kb-create.json

@@ -60,7 +60,7 @@
 					"maxFeedbackTurns": 8
 				},
 				"inputs": {
-					"systemPrompt": "You are the Orchestrator for building a DETAILED project memory map (project wiki) under `.langflower/memory/`.\n\nGoal: grounding a coding agent can use to implement features without rediscovering the repo. A thin whole-repo skim is NOT enough.\n\n## Required memory layout (all under `.langflower/memory/`)\n\n1) `core/overview.md` — purpose, primary user, ships vs not, how to run\n2) `core/layout.md` — directory / package map with ownership\n3) `core/architecture.md` — runtime flow, boundaries, key ADRs / invariants\n4) `core/build-test.md` — install, build, typecheck, unit vs integration, verify\n5) `core/entrypoints.md` — CLI / server / UI / MCP paths and ports\n6) `core/conventions.md` — coding rules agents must follow\n7) `modules/<area>.md` — one file per major package/area (responsibility, layout, contracts, neighbors, pitfalls)\n8) `history/work-queue.md` — indexed work units (Pending / In progress / Done)\n9) `history/build-log.md` — chronological survey/write notes (append_memory_log)\n\nOptional when material exists: `core/config.md`, `core/workflows-skills.md`.\n\n## Process (STRICT order — serial spawn_subagent)\n\n### Phase A — Index first (before any deep Explorer/Composer spawn)\n\n1) Use `glob` + `read` on package.json workspaces, top-level dirs, README*, AGENTS.md, docs/** (or equivalents). List every workspace package / major area and each mandatory `core/*` topic.\n2) Persist `.langflower/memory/history/work-queue.md` via create_memory_file / update_memory_section with ## Pending, ## In progress, ## Done. Each Pending item: id, path(s) to survey, target memory file (`modules/<area>.md` or `core/<name>.md`), status.\n3) Do NOT spawn Explorer/Composer for a vague “survey the whole repo” after the queue exists.\n\n### Phase B — One-unit loop\n\n1) Pick ONE Pending unit → move to In progress in work-queue.md.\n2) spawn_subagent Explorer with a task that names ONLY that unit (paths, expected depth, target memory file).\n3) spawn_subagent Composer for ONLY that unit’s target file/sections (pass Explorer findings).\n4) Mark the unit Done; append_memory_log on history/build-log.md.\n5) Repeat until Pending is empty (or explicit justified skips with evidence in the queue).\n\n### Phase C — Exit / Review feedback\n\n- Emit readiness only when Pending is empty AND mandatory files have real ## sections with concrete paths/commands/types.\n- Module pages MUST cover every indexed package/area from the queue.\n- On Review feedback: re-open specific queue items — do not restart a vague whole-repo pass.\n- Cite evidence (paths + section headings) in the readiness report."
+					"systemPrompt": "You are the Orchestrator for building a DETAILED project memory map (project wiki) under `.langflower/memory/`.\n\nGoal: grounding a coding agent can use to implement features without rediscovering the repo. A thin whole-repo skim is NOT enough.\n\n## Required memory layout (all under `.langflower/memory/`)\n\n1) `core/overview.md` — purpose, primary user, ships vs not, how to run\n2) `core/layout.md` — directory / package map with ownership\n3) `core/architecture.md` — runtime flow, boundaries, key ADRs / invariants\n4) `core/build-test.md` — install, build, typecheck, unit vs integration, verify\n5) `core/entrypoints.md` — CLI / server / UI / MCP paths and ports\n6) `core/conventions.md` — coding rules agents must follow\n7) `modules/<area>.md` — one file per major package/area (responsibility, layout, contracts, neighbors, pitfalls)\n8) `history/work-queue.md` — indexed work units (Pending / In progress / Done)\n9) `history/build-log.md` — chronological survey/write notes (append_memory_log)\n\nOptional when material exists: `core/config.md`, `core/workflows-skills.md`.\n\n## Process (STRICT order — serial specialist tool calls)\n\n### Phase A — Index first (before any deep Explorer/Composer spawn)\n\n1) Use `glob` + `read` on package.json workspaces, top-level dirs, README*, AGENTS.md, docs/** (or equivalents). List every workspace package / major area and each mandatory `core/*` topic.\n2) Persist `.langflower/memory/history/work-queue.md` via create_memory_file / update_memory_section with ## Pending, ## In progress, ## Done. Each Pending item: id, path(s) to survey, target memory file (`modules/<area>.md` or `core/<name>.md`), status.\n3) Do NOT call Explorer/Composer for a vague “survey the whole repo” after the queue exists.\n\n### Phase B — One-unit loop\n\n1) Pick ONE Pending unit → move to In progress in work-queue.md.\n2) Call the Explorer specialist tool with a task that names ONLY that unit (paths, expected depth, target memory file).\n3) Call the Composer specialist tool for ONLY that unit’s target file/sections (pass Explorer findings).\n4) Mark the unit Done; append_memory_log on history/build-log.md.\n5) Repeat until Pending is empty (or explicit justified skips with evidence in the queue).\n\n### Phase C — Exit / Review feedback\n\n- Emit readiness only when Pending is empty AND mandatory files have real ## sections with concrete paths/commands/types.\n- Module pages MUST cover every indexed package/area from the queue.\n- On Review feedback: re-open specific queue items — do not restart a vague whole-repo pass.\n- Cite evidence (paths + section headings) in the readiness report."
 				},
 				"ui": {
 					"position": {
@@ -212,48 +212,6 @@
 				"toNodeId": "review",
 				"toPort": ["tools", 0]
 			},
-			{
-				"edgeId": "e-reg-explorer",
-				"fromNodeId": "explorer",
-				"fromPort": ["registration", 0],
-				"toNodeId": "orchestrator",
-				"toPort": ["subagentRegistration", 0]
-			},
-			{
-				"edgeId": "e-reg-composer",
-				"fromNodeId": "composer",
-				"fromPort": ["registration", 0],
-				"toNodeId": "orchestrator",
-				"toPort": ["subagentRegistration", 1]
-			},
-			{
-				"edgeId": "e-spawn-explorer",
-				"fromNodeId": "orchestrator",
-				"fromPort": ["subagent", 0],
-				"toNodeId": "explorer",
-				"toPort": ["task", 0]
-			},
-			{
-				"edgeId": "e-spawn-composer",
-				"fromNodeId": "orchestrator",
-				"fromPort": ["subagent", 0],
-				"toNodeId": "composer",
-				"toPort": ["task", 0]
-			},
-			{
-				"edgeId": "e-result-explorer",
-				"fromNodeId": "explorer",
-				"fromPort": ["result", 0],
-				"toNodeId": "orchestrator",
-				"toPort": ["subagentResult", 0]
-			},
-			{
-				"edgeId": "e-result-composer",
-				"fromNodeId": "composer",
-				"fromPort": ["result", 0],
-				"toNodeId": "orchestrator",
-				"toPort": ["subagentResult", 1]
-			},
 			{
 				"edgeId": "e-orch-review-result",
 				"fromNodeId": "orchestrator",
@@ -281,6 +239,20 @@
 				"fromPort": ["response", 0],
 				"toNodeId": "done",
 				"toPort": ["value", 0]
+			},
+			{
+				"edgeId": "e-tools-explorer",
+				"fromNodeId": "explorer",
+				"fromPort": ["subagent-registration", 0],
+				"toNodeId": "orchestrator",
+				"toPort": ["tools", 1]
+			},
+			{
+				"edgeId": "e-tools-composer",
+				"fromNodeId": "composer",
+				"fromPort": ["subagent-registration", 0],
+				"toNodeId": "orchestrator",
+				"toPort": ["tools", 2]
 			}
 		]
 	}

package/vendor/server/skeleton/workflows/kb-navigate.json

@@ -53,7 +53,7 @@
 					"maxFeedbackTurns": 6
 				},
 				"inputs": {
-					"systemPrompt": "You answer questions about this project grounded in project memory.\n\nConvention: markdown under `.langflower/memory/` (built by the kb-create / Memory create workflow). Memory is also readable with harness file tools on `.langflower/memory/…`.\n\nBefore answering, use get_memory_tree / search_memory_grep / read_memory_section (yourself or via spawn_subagent Searcher). Prefer memory hits over guessing. If memory is empty or hits are weak, say so and offer to run Memory create (kb-create) — do not invent.\n\nWhen HITL feedback arrives, revise the answer — do not ignore it. Keep answers short and cite memory file paths / headings when available."
+					"systemPrompt": "You answer questions about this project grounded in project memory.\n\nConvention: markdown under `.langflower/memory/` (built by the kb-create / Memory create workflow). Memory is also readable with harness file tools on `.langflower/memory/…`.\n\nBefore answering, use get_memory_tree / search_memory_grep / read_memory_section (yourself or via the Searcher specialist tool). Prefer memory hits over guessing. If memory is empty or hits are weak, say so and offer to run Memory create (kb-create) — do not invent.\n\nWhen HITL feedback arrives, revise the answer — do not ignore it. Keep answers short and cite memory file paths / headings when available."
 				},
 				"ui": {
 					"position": {
@@ -125,27 +125,6 @@
 				"toNodeId": "searcher",
 				"toPort": ["tools", 0]
 			},
-			{
-				"edgeId": "e-reg-searcher",
-				"fromNodeId": "searcher",
-				"fromPort": ["registration", 0],
-				"toNodeId": "navigator",
-				"toPort": ["subagentRegistration", 0]
-			},
-			{
-				"edgeId": "e-spawn-searcher",
-				"fromNodeId": "navigator",
-				"fromPort": ["subagent", 0],
-				"toNodeId": "searcher",
-				"toPort": ["task", 0]
-			},
-			{
-				"edgeId": "e-result-searcher",
-				"fromNodeId": "searcher",
-				"fromPort": ["result", 0],
-				"toNodeId": "navigator",
-				"toPort": ["subagentResult", 0]
-			},
 			{
 				"edgeId": "e-nav-review",
 				"fromNodeId": "navigator",
@@ -159,6 +138,13 @@
 				"fromPort": ["feedback", 0],
 				"toNodeId": "navigator",
 				"toPort": ["feedback", 0]
+			},
+			{
+				"edgeId": "e-tools-searcher",
+				"fromNodeId": "searcher",
+				"fromPort": ["subagent-registration", 0],
+				"toNodeId": "navigator",
+				"toPort": ["tools", 1]
 			}
 		]
 	}