langflower 0.1.0 → 0.1.2

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

@@ -16,41 +16,44 @@ Facts for UI chrome and on-disk paths. Prefer this file over guessing.
   **Settings**. Opening Settings (gear or empty-provider onboarding) swaps out
   feed/inspector; canvas stays. Settings open/close is server-driven.
 - **Composer (bottom)** — **Start** / Hard **Stop** / soft **Pause**; HITL
-  input and actions; `permission.ask` Allow/Deny while a run needs them.
+  input and actions; `ask_user` textarea + Send (question is in the work log);
+  `permission.ask` Allow/Deny while a run needs them.
 
 ## 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**. Prefill lives on the node; Stop then Start reuses it.                                                                                                                                                                                                                                                                                  |
-| 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.                                                                                                                                                                                                                                                                          |
-| See what a built-in node does                    | Hover a palette row (popover) **or** select the node → inspector **description** (markdown).                                                                                                                                                                                                                                                                                   |
-| 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.                                                                                                                                                                                                                                                                |
-| Hide / show the node palette                     | Palette title `<<` / canvas `>>`. Shared across tabs; stored as `paletteVisible` in project `langflower.jsonc`. Allowed during a run.                                                                                                                                                                                                                                          |
-| Add or reload custom nodes                       | Pack under `.langflower/nodes/<pack>/`. Server start compiles existing packs. After file changes: 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.                                                                                                                                                                                                                                                      |
-| Why extra empty ports on Helper / tools / Router | Those inputs are `multi`. Wiring one slot shows the next free slot. **Feedback** = several sources (HITL + auto-review). **Tools** = several packs. **Router** = extra channels (`ch` / `ch@1`). Leave the empty row unwired.                                                                                                                                                  |
-| 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}`)                                                                                                                                                                                                                                                                                             |
+| Store a named secret outside the project         | Gear → **Settings** → **Global** → **Secrets** (write-only). File is `langflower.secrets.json` next to global config — not under the project. Not encryption. Use `{lf_secrets:ID}` or `{env:VAR}` in MCP http `headers`.                                                                                                                                                                                                          |
+| Start a Chat Input graph                         | Composer **Start** — not plain **Run**. Prefill lives on the node; Stop then Start reuses it.                                                                                                                                                                                                                                                                                                                                      |
+| See run output / stream                          | Right aside **feed**                                                                                                                                                                                                                                                                                                                                                                                                               |
+| Answer HITL / send into a waiting node           | Composer + feed context                                                                                                                                                                                                                                                                                                                                                                                                            |
+| Answer an agent's `ask_user` question            | Work log shows the question; composer textarea + **Send** (not Allow/Deny)                                                                                                                                                                                                                                                                                                                                                         |
+| 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.                                                                                                                                                                                                                                                                                                                              |
+| See what a built-in node does                    | Hover a palette row (popover) **or** select the node → inspector **description** (markdown).                                                                                                                                                                                                                                                                                                                                       |
+| 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.                                                                                                                                                                                                                                                                                                                    |
+| Hide / show the node palette                     | Palette title `<<` / canvas `>>`. Shared across tabs; stored as `paletteVisible` in project `langflower.jsonc`. Allowed during a run.                                                                                                                                                                                                                                                                                              |
+| Add or reload custom nodes                       | Pack under `.langflower/nodes/<pack>/`. Server start loads cached packs when fingerprints match, else compiles. After file changes: on starter, Helper / Writer call `compile_custom_nodes` (Langflower Tools is wired). Else Custom → **Update** (always rebuilds). 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.                                                                                                                                                                                                                                                                                                          |
+| Why extra empty ports on Helper / tools / Router | Those inputs are `multi`. Wiring one slot shows the next free slot. **Feedback** = several sources (HITL + auto-review). **Tools** = several packs. **Router** = extra channels (`ch` / `ch@1`). Leave the empty row unwired.                                                                                                                                                                                                      |
+| Project instructions for agents                  | `.langflower/instructions.md`                                                                                                                                                                                                                                                                                                                                                                                                      |
 
 ## On-disk `.langflower/` map
 
-| Path               | Role                                                                                          |
-| ------------------ | --------------------------------------------------------------------------------------------- |
-| `langflower.jsonc` | Providers, secrets refs, project config                                                       |
-| `workflows/`       | Saved workflow graphs                                                                         |
-| `skills/`          | Agent skills (`langflower-helper/`, `langflower-node-writer/`, `langflower-workflow-writer/`) |
-| `nodes/`           | Custom node packs (`my-nodes/`, sample `hello-embed/`)                                        |
-| `instructions.md`  | Project-level agent instructions                                                              |
-| `runs/`            | Run artifacts / checkpoints when created                                                      |
-| `logs/`            | Server bridge diagnostic JSONL logs when the server runs                                      |
+| Path               | Role                                                                                                                                  |
+| ------------------ | ------------------------------------------------------------------------------------------------------------------------------------- |
+| `langflower.jsonc` | Providers, secrets refs, project config                                                                                               |
+| `workflows/`       | Saved workflow graphs                                                                                                                 |
+| `skills/`          | Agent skills (`langflower-helper/`, `langflower-node-writer/`, `langflower-workflow-writer/`, `spec-architect/`)                      |
+| `nodes/`           | Custom node packs — one folder / `package.json` each (`my-nodes/`, sample `hello-embed/`, extra sibling packs; no jsonc registration) |
+| `instructions.md`  | Project-level agent instructions                                                                                                      |
+| `runs/`            | Run artifacts / checkpoints when created                                                                                              |
+| `logs/`            | Server bridge diagnostic JSONL logs when the server runs                                                                              |
 
 ## Out of chrome
 

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

@@ -49,6 +49,75 @@ You help the user write **custom nodes** for Langflower.
   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.
+- Sibling packs: any folder under `.langflower/nodes/` with its own
+  `package.json` is discovered (no `langflower.jsonc` registration). Seed
+  `my-nodes` is the default; extra packs sit next to it (`hello-embed`).
+
+## Author patterns (do not invent forks)
+
+### Factory
+
+| Need                                                                        | Factory                   | Not                                                  |
+| --------------------------------------------------------------------------- | ------------------------- | ---------------------------------------------------- |
+| One `execute` result on **all** outputs together                            | `defineNode`              | Exclusive `ok` / `fail`                              |
+| LLM-callable `ToolHandle[]` on a `tools` port                               | `defineToolRegistrations` | `defineNode` that returns inventory as a string wire |
+| Emit on one port and **stay silent** on the other; streams; `inferTypeFrom` | `defineReactiveNode`      | `defineNode`                                         |
+
+**Wrong:** a review / QA gate with `defineNode` that returns `{ ok: true }`
+or throws on failure. `execute` maps onto every declared output at once.
+Throwing is a node error stream — it does **not** drive a separate `fail`
+branch. **Right:** `defineReactiveNode` + `of` / `EMPTY` (seed
+`review-gate.ts`).
+
+### Multi-file imports
+
+Pack `tsconfig` is NodeNext. Relative `from './lib/x'` **without** a suffix
+fails `tsc` (`TS2835`). Either keep one-file nodes with no local imports
+(seed `git-diff.ts`) **or** `from './lib/x.ts'` plus
+`"allowImportingTsExtensions": true` next to `"noEmit": true` (copy
+`hello-embed/tsconfig.json`).
+
+### LLM tools (`defineToolRegistrations`)
+
+- `handler` returns `Promise<string>`. Expected command / test failure is
+  **text to the model**, not `throw`. Throw only for contract (empty
+  `ctx.projectDir`).
+- Agent-facing text is a **short signal**: success → one line `ok  <toolId>`.
+  Failure → failed tests / `TS####` / ESLint errors only. Strip ANSI. Drop
+  `✓`, coverage tables, npm lifecycle banners, raw stdout dumps. When
+  slicing an `Issues:` block, do **not** use `$` with the `/m` flag (that
+  is end-of-line, so the match stops after the first line).
+- No shell Cap on public `ExecutionContext` yet — `child_process` like seed
+  `git-diff-tool.ts`. `shell: true` only with an **allowlisted literal**
+  (`npm run format`); never splice user paths into a shell string. Resolve
+  user paths under `ctx.projectDir` and reject `..` escapes.
+- Do not register hanging processes (`start`, `dev`, `test:watch`) as tools.
+
+### QA / review gates (`defineReactiveNode`)
+
+- Exclusive ports: pass → emit on `ok`, silent `fail`; fail → emit on
+  `fail`, silent `ok`.
+- Two honest `ok` shapes — pick from the graph, do not mix them:
+    - **Pulse** — seed `review-gate.ts` emits `boolean` `true`
+      (`wireType: 'boolean'`). Downstream only needs “passed”.
+    - **Passthrough** — when the next stage must keep the original payload:
+      `configureOutput('ok', ok$, { inferTypeFrom: trigger })`. Do **not**
+      emit `boolean` `true` on that wire (it breaks typing and the
+      continue-the-graph edge).
+- `fail` is a **string** (prefer stripped tool-handler text, not raw
+  stderr dumps).
+- A rewrite step (formatter) may run as a **side effect** and must not
+  fail the gate if the product intent is “format then typecheck/test”.
+  Typecheck / tests may fail the gate and skip later steps.
+
+### Tests
+
+Pack compile **skips** `*.test.ts`. Drive nodes with
+`createNodeHarness` from `@langflower/node-sdk/testing`. Subscribe to
+exclusive `ok` / `fail` **before** `send('trigger')` or you miss the
+emission. Mock `child_process` — do not spawn a real monorepo `build`
+from a unit test. Host `npm test` only sees pack tests if the project
+Vitest config **includes** that glob; do not assume it.
 
 ## When drafting a node
 

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

@@ -14,8 +14,8 @@ You help the user **author valid Langflower workflow JSON** under
 ## Honesty (do not invent)
 
 - Use only **catalog** node `type` strings that exist in the project palette /
-  common-nodes. Do **not** invent types (e.g. there is no `common-hitl` —
-  use `common-hitl-review-gate`).
+  common-nodes **or compiled custom packs**. Do **not** invent types (e.g.
+  there is no `common-hitl` — use `common-hitl-review-gate`).
 - Use only **real port ids** from each node’s definition / `NODE.md`. Wrong
   ports are stripped on load (graceful repair) — inventing ports breaks the
   graph.
@@ -57,8 +57,10 @@ Schema: `.langflower/schemas/workflow.schema.json`. Samples:
 | --------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | `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-mcp-stdio` / `common-mcp-http`  | out **`tools`** — wire into an agent `tools` port (not a separate `mcp` port). MCP http in **`headers`**: JSON object/string; `{lf_secrets:ID}` / `{env:VAR}` OK                                                       |
 | `common-tool-collection`                | in **`tools`** (multi combine) → out **`tools`** — optional hub; duplicate `toolId` last-wins. Direct pack → agent still OK                                                                                            |
+| `common-tool-invoke`                    | in **`tools`** (single) + **`toolId`** (string) + **`args`** (json, blank default) → out **`result`**. Graph-side `invoke`; unknown id / bad JSON → port error. Empty inventory stays inactive.                        |
+| `common-tool-inspect`                   | in **`tools`** (single) + **`toolId`** (string, empty = all) → out **`text`** — copy-paste dump + `inputSchema`. Not Preview (`common-preview` is string-only).                                                        |
 | `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`                                                                                                                                               |
@@ -78,6 +80,19 @@ Typical HITL revise loop:
 Do **not** feed Merge output into both gates and LLM feedback on every tick
 without a clear phase split.
 
+## Custom QA / review gates
+
+Custom exclusive-branch nodes (`defineReactiveNode`, seed `review-gate.ts`):
+
+- in **`trigger`** (dynamic)
+- out **`ok`** — **pulse** (`boolean` `true`, seed) **or** **passthrough of
+  `trigger`** (`inferTypeFrom`) when the next stage must keep the payload
+- out **`fail`** — string (stripped errors) → Preview / LLM `feedback`
+
+Do **not** emit boolean `true` on `ok` if the downstream graph needs the
+trigger payload. Do not use `defineNode` that returns `{ ok: true }` for
+this shape (`execute` cannot stay silent on `fail`).
+
 ## Sub-Agent (one registration wire)
 
 Mirror `.langflower/workflows/kb-navigate.json`:

package/vendor/server/skeleton/skills/spec-architect/SKILL.md

@@ -0,0 +1,232 @@
+---
+name: spec-architect
+description: >-
+    Discovery skill for the Plan role. Converts a short feature prompt into an
+    explicit specification. When update_plan is wired, the full spec lives in
+    the memory plan (work log) — do not write spec.md into a project folder.
+    Sequences environment audit, requirements, blast radius, dependencies,
+    contracts, mechanics, patterns, and verification.
+---
+
+# Spec architect (Plan)
+
+You convert a short, ambiguous feature request into an explicit specification.
+Do **not** jump into application source implementation, refactoring, or
+unsolicited file creation while this skill is active.
+
+You are a defensive principal architect: uncover hidden constraints, map
+invariants, and force alignment with local patterns. Do not guess when the
+repo shows competing styles — ask.
+
+## Honesty (Langflower, not Cursor)
+
+- There is **no** Cursor Plan mode and **no** `CreatePlan` tool.
+- **Memory plan available** (`update_plan` / `read_plan` in your tool list):
+  deliver the **full** Output Target Layout through `update_plan` so the
+  operator sees it in the work log. Call `read_plan` first if you need the
+  current plan. **Do not** write `spec.md` (or any other spec file) into a
+  project folder. Generic `update_memory_section` on `history/plan.md` does
+  **not** show the plan in the feed.
+- **No memory plan** (`update_plan` not wired): fallback only — write
+  `{designatedBaseFolder}/spec.md` with the same layout via harness `create`
+  / `write` (Plan preset typically **asks** the operator first). Do not
+  `edit` application source (`edit` is denied on Plan).
+- **Clarify** → use `ask_user` when that tool is wired. Otherwise put **one**
+  focused question in the response so the HITL / Clarify Review Gate can
+  reply on feedback. Multiple sequential rounds are allowed; do not dump a
+  questionnaire.
+- **Sub-agents** → if a specialist tool is already wired (for example
+  Researcher on simple-coder), prefer it for long read-only survey. Keep
+  architectural decisions yourself. Do **not** invent extra spawn or
+  un-wired specialists.
+- **MCP / external SoT** → if MCP or other tool packs are wired on this
+  node, use them. If Jira, Confluence, or Figma are missing, note that once
+  (non-blocking) and continue. Do not stall the spec on unconnected servers.
+- Persist heavy artifacts through memory tools when they are wired
+  (`core/project_summary.md`, `core/codebase_map.md`, …). Do not paste entire
+  files into the next-node payload.
+
+## Execution protocol
+
+Work the phases in order. Do not deliver the spec until Phases 1–7 are
+satisfied or the operator explicitly tells you to proceed with stated
+assumptions.
+
+### Phase 1 — Environment audit
+
+Scan wired tools. If ticket/design servers are present, ask for ticket IDs,
+doc URLs, or design links. If they are absent, continue with the repo.
+
+### Phase 2 — Intent, base folder, blast radius
+
+Interview for a verifiable functional checklist. Lock the **Designated Base
+Folder** (where most code changes will land — not a spec.md dump when memory
+plan is available). Classify impact:
+
+1. **New files** — path + architectural purpose.
+2. **Changed files** — path + what logic changes.
+3. **Deleted files** — path + why.
+
+### Phase 3 — Ecosystem
+
+Read package manifests (`package.json`, and others if present). Ask whether
+new dependencies are required. Record version / peer / runtime constraints.
+
+### Phase 4 — Contracts and data access
+
+Find how this repo crosses layers (HTTP, WS, files, stores). Lock:
+
+- DAL / persistence pattern actually used (do not invent a Repository if
+  none exists)
+- Endpoints, routes, wrappers, SDKs
+- Data contracts (types, schemas, DTOs)
+- Authoritative source of truth (OpenAPI, DB schema, code-first types, …)
+- Reuse vs amend vs new wrappers
+- Backward-compatibility breaks
+
+### Phase 5 — Mechanics and risk
+
+Lock dataflow, validation and empty/extreme states, auth/privacy/tenancy,
+concurrency, **complexity (Big-O of hot paths)**, expected failures and
+degradation, and schema/migration needs. Do not skip Big-O: name `n` (and
+other variables), give time and space for each hot path, and call out
+worse-than-linear risks.
+
+### Phase 6 — Patterns and frontend (if UI)
+
+Scan the repo. If several styles coexist, present them as choices — do not
+pick silently. Cite **exact** boilerplate files and which fragments to
+mirror. If a pattern library is missing, note that the team should add one.
+When UI is in scope, ask component-library vs custom, styling rules, i18n,
+and env/config mechanics. Align telemetry with what already exists.
+
+### Phase 7 — Verification
+
+Do not assume test levels. Ask which of unit, integration, E2E, and manual
+apply. Align with local runners (this repo: `npm run test` / full `verify`
+for close-out; `--quick` is intermediate only). If manual is selected, write
+step-by-step scripts with expected results.
+
+### Phase 8 — Deliver
+
+1. If `update_plan` is wired: call it with the **entire** filled Output
+   Target Layout. Do **not** write `spec.md` into the base folder or anywhere
+   else in the project.
+2. If `update_plan` is **not** wired: write that layout to
+   `{baseFolder}/spec.md`.
+3. Put the next-agent directive in the response (paths + headings, not the
+   full spec body). Point at the memory plan (`read_plan` / `history/plan.md`
+   `## Plan`) when that is the SoT.
+
+## Output Target Layout (`update_plan` body; fallback `spec.md`)
+
+```markdown
+# Specification: [Feature Name]
+
+## 1. Executive Summary & Intent
+
+- **Problem Statement:** (What operational pain point, technical debt, or feature deficiency is this fixing?)
+- **User Prompt Source:** (The original raw prompt text or requirement that initiated this blueprint)
+- **External Context:** (Linked tickets, docs, or design files)
+
+## 2. Codebase Guardrails & Local Alignment
+
+- **Designated Base Folder:** (Primary workspace folder where code changes are centered)
+- **Target Directories:** (Explicit paths for new or modified files)
+- **Architectural Patterns & Boilerplates Enforced:** (Required structural patterns)
+- **Pattern & Boilerplate Reference Baseline:**
+    - `[File Path Reference 1]`: (Exact parts to replicate)
+    - `[File Path Reference 2]`: (Exact parts to replicate)
+- **Third-Party Dependencies & Packages:** (New packages, version caps)
+- **Frontend Presentation Strategy (If UI Affected):**
+    - **Component Library Standards:**
+    - **Styling & CSS Architecture Guardrails:**
+- **Shared Utilities & Hooks:** (Existing helpers/types that must be reused)
+- **Internationalization (i18n) Mechanics:**
+- **Environment Configuration (ENV):**
+
+## 3. Deep System Mechanics & System Analysis
+
+### A. Blast Radius & Impact Assessment
+
+- **Affected Modules / Components:**
+- **Affected Files Inventory:**
+    - **New Files:**
+        - `[Proposed File Path 1]`: (Purpose)
+    - **Changed Files:**
+        - `[Existing File Path 1]`: (Targeted logic)
+    - **Deleted Files:**
+        - `[Legacy File Path 1]`: (Deletion reason)
+- **Backward Compatibility Plan:**
+
+### B. API, Data Contracts & DAL Strategy
+
+- **Authoritative Source of Truth:**
+- **Data Access Layer (DAL) Pattern:**
+- **Endpoints & Routes Impacted:**
+- **Data Contracts (Schemas & Type Specs):**
+- **Wrapper Strategy:** (reuse / amend / new)
+- **Reverse Compatibility Risk Matrix:**
+
+### C. Security, Identity & Compliance
+
+- **Authentication & Authorization:**
+- **Data Privacy & Multi-Tenancy:**
+
+### D. Dataflow Architecture & Evolution
+
+- **State Lifecycle & Pipeline:**
+- **State Authority:**
+- **Schema Evolution & Migration:**
+
+### E. Validations & Boundary Conditions
+
+- **Input Validation Schemas:**
+- **Zero / Empty States:**
+- **Extreme Constraints:**
+
+### F. Concurrency & State Collisions
+
+- **Race Condition Mitigation:**
+
+### G. Complexity Estimate (Big-O)
+
+- **Scaling Variables:** (`n`, `m`, … — what each counts: items, nodes, edges, tokens, bytes, concurrent clients)
+- **Hot Paths:**
+    - `[Path / operation 1]`: **Time** `O(…)` · **Space** `O(…)` · (why; dominant term)
+    - `[Path / operation 2]`: **Time** `O(…)` · **Space** `O(…)` · (why; dominant term)
+- **Amortized / Average vs Worst Case:** (if they differ, state both)
+- **I/O & Fan-out:** (network/disk calls per request; N+1; fan-out `O(n)` fan-in)
+- **Unacceptable Bounds:** (paths that must stay `O(1)` / `O(log n)` / linear; anything worse is a spec defect)
+
+### H. Error Handling & Resiliency
+
+- **Expected Failure Modes:**
+- **Graceful Degradation:**
+- **Telemetry, Logging & Observability:**
+
+## 4. Verification & Definition of Done (DoD)
+
+### A. Testing Strategy Matrix
+
+- [ ] **Unit Testing:** -> Isolation: mock DB, storage, and network.
+- [ ] **Integration Testing:** -> Isolation: mock third-party endpoints only.
+- [ ] **E2E / Smoke Testing:** -> Live local environment, minimal mocks.
+- [ ] **Manual Verification:** -> Human UI or terminal script.
+
+### B. Manual Verification Script
+
+_(Mandatory if Manual Verification is checked.)_
+
+#### Test Case 1: [Short Title]
+
+- **Prerequisites:**
+- **Step-by-Step Actions:** 1.
+- **Expected Inputs / Payloads:**
+- **Expected Output / Observable Result:**
+
+### C. Functional Requirements Checklist
+
+- [ ] Requirement 1 (Verifiable functional behavior)
+- [ ] Requirement 2 (Verifiable functional behavior)
+```

package/vendor/server/skeleton/workflows/advanced-coder.json

@@ -33,6 +33,7 @@
 				"type": "common-openai-llm",
 				"params": {
 					"rolePreset": "plan",
+					"skillId": "spec-architect",
 					"providerId": "",
 					"model": "",
 					"maxIterations": 8,

package/vendor/server/skeleton/workflows/simple-coder.json

@@ -46,6 +46,7 @@
 				"type": "common-openai-llm",
 				"params": {
 					"rolePreset": "plan",
+					"skillId": "spec-architect",
 					"providerId": "",
 					"model": "",
 					"maxIterations": 8

package/dist/cli.d.ts

@@ -1 +0,0 @@
-export declare const runCli: (argv: readonly string[]) => void;

package/dist/cli.js

@@ -1,13 +0,0 @@
-import { Command } from 'commander';
-import { registerEvalCommand } from './eval-command.js';
-import { registerStartCommand } from './start-command.js';
-export const runCli = (argv) => {
-    const program = new Command();
-    program
-        .name('langflower')
-        .description('Visual LLM-chain builder')
-        .version('0.1.0');
-    registerStartCommand(program);
-    registerEvalCommand(program);
-    program.parse(argv);
-};

package/dist/create-fake-skill-case-runner.d.ts

@@ -1,9 +0,0 @@
-import type { EvalCaseRunner } from '@langflower/eval/run-eval-suite';
-/**
- * Fake agent-under-test for CLI eval when `--replay` is omitted.
- *
- * Reads skill markdown for per-line `answer exactly: \`TOKEN\`` rules and
- * picks the token whose line context best overlaps the case input. No LLM —
- * composed in the CLI, not inside `@langflower/eval`.
- */
-export declare const createFakeSkillCaseRunner: () => EvalCaseRunner;

package/dist/create-fake-skill-case-runner.js

@@ -1,73 +0,0 @@
-const LINE_TOKEN_RULE = /^(.*)answer\s+exactly:\s*`([^`]+)`/i;
-const STOP_WORDS = new Set([
-    'a',
-    'an',
-    'and',
-    'answer',
-    'asked',
-    'do',
-    'exactly',
-    'for',
-    'from',
-    'not',
-    'of',
-    'or',
-    'say',
-    'the',
-    'to',
-    'token',
-    'when',
-]);
-const tokenize = (text) => text
-    .toLowerCase()
-    .split(/[^a-z0-9_]+/)
-    .filter((part) => part.length > 0 && !STOP_WORDS.has(part));
-const parseSkillTokenRules = (skillMarkdown) => skillMarkdown.split(/\r?\n/).flatMap((line) => {
-    const match = line.match(LINE_TOKEN_RULE);
-    if (match === null) {
-        return [];
-    }
-    const context = match[1]?.trim() ?? '';
-    const token = match[2]?.trim() ?? '';
-    if (token.length === 0) {
-        return [];
-    }
-    return [{ context, token }];
-});
-const scoreOverlap = (inputTokens, contextTokens) => {
-    if (contextTokens.length === 0) {
-        return 0;
-    }
-    const inputSet = new Set(inputTokens);
-    return contextTokens.filter((token) => inputSet.has(token)).length;
-};
-/**
- * Fake agent-under-test for CLI eval when `--replay` is omitted.
- *
- * Reads skill markdown for per-line `answer exactly: \`TOKEN\`` rules and
- * picks the token whose line context best overlaps the case input. No LLM —
- * composed in the CLI, not inside `@langflower/eval`.
- */
-export const createFakeSkillCaseRunner = () => {
-    return async ({ case: evalCase, skillMarkdown }) => {
-        if (skillMarkdown === null || skillMarkdown.trim().length === 0) {
-            throw new Error('Fake skill agent requires pack skillPath markdown; use --replay for packs without a skill');
-        }
-        const rules = parseSkillTokenRules(skillMarkdown);
-        if (rules.length === 0) {
-            throw new Error('Fake skill agent found no "answer exactly: `TOKEN`" rules in skill markdown');
-        }
-        const inputTokens = tokenize(evalCase.input);
-        const ranked = rules
-            .map((rule) => ({
-            rule,
-            score: scoreOverlap(inputTokens, tokenize(rule.context)),
-        }))
-            .sort((a, b) => b.score - a.score);
-        const best = ranked[0];
-        if (best === undefined || best.score <= 0) {
-            throw new Error(`Fake skill agent could not match case "${evalCase.id}" input to a skill token rule`);
-        }
-        return best.rule.token;
-    };
-};

package/dist/create-fake-skill-case-runner.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/create-fake-skill-case-runner.test.js

@@ -1,60 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { createFakeSkillCaseRunner } from './create-fake-skill-case-runner.js';
-const TRIAGE_SKILL = `# Triage skill (eval fixture)
-
-When asked for the greeting token, answer exactly: \`HELLO_OK\`.
-
-When asked for the farewell token, answer exactly: \`BYE_OK\`.
-
-Do not add punctuation or extra words.
-`;
-const packStub = {
-    id: 'golden-sample',
-    threshold: 1,
-    scorer: 'exact',
-    cases: [],
-};
-describe('createFakeSkillCaseRunner', () => {
-    const runCase = createFakeSkillCaseRunner();
-    it('returns greeting token from skill for greet-style input', async () => {
-        const actual = await runCase({
-            pack: packStub,
-            case: {
-                id: 'greet',
-                input: 'Say the greeting token from the skill.',
-                expected: 'HELLO_OK',
-            },
-            skillMarkdown: TRIAGE_SKILL,
-            projectRoot: '.',
-            harness: null,
-        });
-        expect(actual).toBe('HELLO_OK');
-    });
-    it('returns farewell token from skill for farewell-style input', async () => {
-        const actual = await runCase({
-            pack: packStub,
-            case: {
-                id: 'farewell',
-                input: 'Say the farewell token from the skill.',
-                expected: 'BYE_OK',
-            },
-            skillMarkdown: TRIAGE_SKILL,
-            projectRoot: '.',
-            harness: null,
-        });
-        expect(actual).toBe('BYE_OK');
-    });
-    it('fails closed when skill markdown is missing', async () => {
-        await expect(runCase({
-            pack: packStub,
-            case: {
-                id: 'greet',
-                input: 'Say the greeting token from the skill.',
-                expected: 'HELLO_OK',
-            },
-            skillMarkdown: null,
-            projectRoot: '.',
-            harness: null,
-        })).rejects.toThrow(/skillPath markdown/);
-    });
-});