langflower 0.0.1

package/vendor/server/skeleton/nodes/my-nodes/README.md

@@ -0,0 +1,212 @@
+# my-nodes — project custom node pack
+
+This folder is your **default** custom-node pack under
+`.langflower/nodes/my-nodes/`. It is a normal npm package: copy it, share it,
+or publish it. Sibling packs live as other folders next to this one, each with
+its own `package.json`.
+
+## Desired layout
+
+```text
+.langflower/nodes/
+  my-nodes/                 ← this pack (default seed)
+    package.json            ← peerDeps: @langflower/node-sdk (+ rxjs when reactive)
+    tsconfig.json           ← IDE / tsc --noEmit
+    README.md               ← this file
+    git-diff.ts             ← export default defineNode({…})
+    git-diff-tool.ts        ← export default defineToolRegistrations({…})
+    review-gate.ts          ← export default defineReactiveNode({…})
+    # add more *.ts files as needed
+  other-pack/               ← optional second shareable pack
+    package.json
+    …
+```
+
+Rules:
+
+- **One pack = one folder** with its own `package.json`.
+- **No required `index.ts`.** Each `*.ts` / `*.tsx` may `export default` a node
+  definition or an array of definitions. Langflower discovers those defaults.
+- Skip `*.test.ts`, `*.d.ts`, `dist/`, and `node_modules/` when scanning.
+- Import from **`@langflower/node-sdk`** directly — not from a root
+  `nodes/types.ts`.
+
+## Install
+
+**Peer-only packs** (this seed: only `peerDependencies` on
+`@langflower/node-sdk`, `rxjs`, `@rx-evo/stateful-observable`) do **not** need
+`npm install` in the pack or in the project folder. Langflower supplies those
+host peers from its own install (including `npm i -g langflower`).
+
+You install dependencies yourself when you add **author** libraries. Langflower
+does **not** run `npm install` on start, bootstrap, or palette reload.
+
+Extra libraries go in this pack’s `dependencies`:
+
+```bash
+npm i lodash
+```
+
+Langflower bundles author dependencies into the pack artifact; the host SDK
+and RxJS stay external.
+
+## Author API
+
+Prefer **`defineNode`** for sync/Promise nodes (no RxJS in the author file).
+
+Use **`defineToolRegistrations`** when the node should emit LLM-callable
+`ToolHandle`s on a `tools` port (wire into an agent / LLM `tools` input).
+
+Use **`defineReactiveNode`** when you need exclusive multi-output branches
+(emit on one port, silence the other), streams, or advanced bind wiring.
+
+| Seed file          | API                       | Role                                      |
+| ------------------ | ------------------------- | ----------------------------------------- |
+| `git-diff.ts`      | `defineNode`              | One output (`diff`) — default author path |
+| `git-diff-tool.ts` | `defineToolRegistrations` | `tools` pack with on-demand `git_diff`    |
+| `review-gate.ts`   | `defineReactiveNode`      | Independent `ok` / `fail` branches        |
+
+### `defineNode` (simple)
+
+```ts
+import { defineNode } from '@langflower/node-sdk';
+
+/** See seed `git-diff.ts` for the full file. */
+export default defineNode({
+	type: 'my-git-diff',
+	displayName: 'Git Diff',
+	uiSchema: [] as const,
+	inputs: {
+		trigger: { wireType: 'any', required: true, dynamic: true },
+	},
+	outputs: {
+		diff: { wireType: 'string' },
+	},
+	async execute(ctx) {
+		/* run `git diff` in ctx.projectDir → { diff: string } */
+		return { diff: '' };
+	},
+});
+```
+
+### `defineToolRegistrations` (LLM tools)
+
+```ts
+import { defineToolRegistrations } from '@langflower/node-sdk';
+
+/** See seed `git-diff-tool.ts` for the full file. */
+export default defineToolRegistrations({
+	type: 'my-git-diff-tool',
+	displayName: 'Git Diff Tool',
+	tools: [
+		{
+			toolId: 'git_diff',
+			description: 'Runs `git diff` in the project directory.',
+			inputSchema: {
+				type: 'object',
+				properties: {
+					path: { type: 'string' },
+				},
+				additionalProperties: false,
+			},
+			handler: async (args, ctx) => {
+				/* run `git diff` in ctx.projectDir → patch string */
+				return '';
+			},
+		},
+	],
+});
+```
+
+Wire the node’s **`tools`** output into an LLM / agent **`tools`** input. The
+model calls `git_diff` on demand (optional `path` scopes the diff). Prefer this
+over `defineNode` when the value should be inventory for the tool loop, not a
+graph wire.
+
+### Common mistake: `defineNode` for `ok` / `fail` gates
+
+**Wrong:** a review / QA gate with `defineNode` that returns `{ ok: true }` or
+`throw`s on failure.
+
+`defineNode` maps one `execute` result onto **all** declared outputs together.
+It cannot emit on `ok` and stay silent on `fail` (or the reverse). Throwing
+fails the node as an error stream — it does **not** drive a separate `fail`
+branch for downstream wiring.
+
+**Right:** `defineReactiveNode` + `combineInputs(...).pipeValue(...)`, then
+split with `of` / `EMPTY` (see seed `review-gate.ts`):
+
+```ts
+import { defineReactiveNode } from '@langflower/node-sdk';
+import { EMPTY, mergeMap, of } from 'rxjs';
+
+export default defineReactiveNode({
+	type: 'my-review-gate',
+	displayName: 'Review Gate',
+	uiSchema: [] as const,
+	bind(ctx, { makeInput, configureOutput, combineInputs }) {
+		const trigger = makeInput<unknown>('trigger', {
+			dynamic: true,
+			required: true,
+			defaultValue: null,
+		});
+		const result$ = combineInputs([trigger, ctx], ([_t, ec]) => ({
+			projectDir: String(ec.projectDir ?? ''),
+		})).pipeValue(
+			mergeMap(async ({ projectDir }) => {
+				/* … → { ok: true } | { ok: false, detail: string } */
+				return { ok: true as const };
+			}),
+		);
+		const ok$ = result$.pipeValue(
+			mergeMap((r) => (r.ok ? of(true) : EMPTY)),
+		);
+		const fail$ = result$.pipeValue(
+			mergeMap((r) => (r.ok ? EMPTY : of(r.detail))),
+		);
+		return {
+			inputs: [trigger],
+			outputs: [
+				configureOutput('ok', ok$, { wireType: 'boolean' }),
+				configureOutput('fail', fail$, { wireType: 'string' }),
+			],
+		};
+	},
+});
+```
+
+If the product needs independent `ok` and `fail` wires, **always** choose
+`defineReactiveNode`. Do not “simplify” to `defineNode`.
+
+## Why TypeScript
+
+TypeScript is your friend: it catches many mistakes in the **IDE** and at
+**compile / check time**, not after a workflow run.
+
+- Open a `*.ts` file with this pack’s `tsconfig.json` wired into the editor —
+  red squiggles and quick-fixes show up **while you edit**.
+- Wrong port shapes, missing `export default`, bad `execute` / `bind` return
+  types, and SDK misuse surface before palette reload or a live run.
+- Prefer fixing those errors in the editor over “happy path” runtime debugging
+  (start workflow → wait → guess which node broke).
+
+`tsconfig.json` here is for IDE highlight and `tsc --noEmit`. Keep using it
+even though Langflower bundles with esbuild for load.
+
+## Add a node
+
+1. Create a `*.ts` file in this pack (or in a sibling pack).
+2. `export default defineNode({ … })`, `defineToolRegistrations({ … })` for an
+   LLM `tools` pack, **or** `defineReactiveNode({ … })` when exclusive `ok` /
+   `fail` (or other silent-branch) ports are required.
+3. Run `npm install` in the pack if peers or deps changed.
+4. In the editor Custom section, click **Update** (or reconnect) — the node
+   appears under **Custom**.
+
+## Second shareable pack
+
+1. Create `.langflower/nodes/<other-pack>/`.
+2. Add its own `package.json` (peer `@langflower/node-sdk`).
+3. Add `*.ts` files with `export default`.
+4. Run `npm install` inside that pack.
+5. Reload the palette.

package/vendor/server/skeleton/nodes/my-nodes/git-diff-tool.ts

@@ -0,0 +1,73 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { defineToolRegistrations } from '@langflower/node-sdk';
+
+const execFileAsync = promisify(execFile);
+
+const MAX_BUFFER = 2 * 1024 * 1024;
+
+/**
+ * LLM tool pack — wire the `tools` output into an agent / LLM `tools` port.
+ * The model calls `git_diff` on demand (optional `path` scopes the diff).
+ *
+ * Shell is not on the public ExecutionContext yet — uses `child_process`
+ * directly. Prefer Caps / host APIs when they ship.
+ *
+ * For a trigger-driven graph node that emits `diff` as a wire, see
+ * `git-diff.ts` (`defineNode`).
+ */
+export default defineToolRegistrations({
+	type: 'my-git-diff-tool',
+	displayName: 'Git Diff Tool',
+	category: 'Text',
+	description:
+		'Emits a `git_diff` ToolHandle for agent inventory — runs `git diff` in the project directory on demand.',
+	tools: [
+		{
+			toolId: 'git_diff',
+			name: 'git_diff',
+			description:
+				'Runs `git diff` in the Langflower project directory and returns the patch text. Optional `path` scopes the diff to that path. Empty string means a clean working tree.',
+			inputSchema: {
+				type: 'object',
+				properties: {
+					path: {
+						type: 'string',
+						description:
+							'Optional path relative to the project root to scope `git diff -- <path>`.',
+					},
+				},
+				additionalProperties: false,
+			},
+			handler: async (args, ctx) => {
+				const projectDir = String(ctx.projectDir ?? '');
+				if (projectDir.length === 0) {
+					throw new Error('git_diff requires ctx.projectDir.');
+				}
+
+				const pathArg =
+					typeof args.path === 'string' ? args.path.trim() : '';
+				const gitArgs =
+					pathArg.length > 0
+						? (['diff', '--', pathArg] as const)
+						: (['diff'] as const);
+
+				try {
+					const { stdout } = await execFileAsync(
+						'git',
+						[...gitArgs],
+						{
+							cwd: projectDir,
+							maxBuffer: MAX_BUFFER,
+						},
+					);
+					return String(stdout);
+				} catch (err) {
+					const message =
+						err instanceof Error ? err.message : String(err);
+					throw new Error(`git_diff failed: ${message}`);
+				}
+			},
+		},
+	],
+});

package/vendor/server/skeleton/nodes/my-nodes/git-diff.ts

@@ -0,0 +1,46 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { defineNode } from '@langflower/node-sdk';
+
+const execFileAsync = promisify(execFile);
+
+/**
+ * Simple sync/Promise node — one output, no exclusive branches.
+ * Prefer `defineNode` for this shape; see `review-gate.ts` for ok/fail.
+ *
+ * Shell is not on the public ExecutionContext yet — uses `child_process`
+ * directly. Prefer Caps / host APIs when they ship.
+ */
+export default defineNode({
+	type: 'my-git-diff',
+	displayName: 'Git Diff',
+	category: 'Text',
+	description:
+		'Runs `git diff` in `ctx.projectDir` and emits the patch text.',
+	uiSchema: [] as const,
+	inputs: {
+		trigger: {
+			wireType: 'any',
+			required: true,
+			dynamic: true,
+			description: 'Emit to run `git diff`.',
+		},
+	},
+	outputs: {
+		diff: {
+			wireType: 'string',
+			description: 'Stdout from `git diff` (empty string if clean).',
+		},
+	},
+	async execute(ctx) {
+		const projectDir = String(ctx.projectDir ?? '');
+		if (projectDir.length === 0) {
+			throw new Error('Git Diff requires ctx.projectDir.');
+		}
+		const { stdout } = await execFileAsync('git', ['diff'], {
+			cwd: projectDir,
+			maxBuffer: 2 * 1024 * 1024,
+		});
+		return { diff: String(stdout) };
+	},
+});

package/vendor/server/skeleton/nodes/my-nodes/package.json

@@ -0,0 +1,11 @@
+{
+	"name": "my-nodes",
+	"version": "0.0.0",
+	"private": true,
+	"type": "module",
+	"peerDependencies": {
+		"@langflower/node-sdk": "0.1.0",
+		"@rx-evo/stateful-observable": "^0.5.2",
+		"rxjs": "^7.8.1"
+	}
+}

package/vendor/server/skeleton/nodes/my-nodes/review-gate.ts

@@ -0,0 +1,106 @@
+import { defineReactiveNode } from '@langflower/node-sdk';
+import { spawn } from 'node:child_process';
+import { EMPTY, mergeMap, of } from 'rxjs';
+
+const runNpmTest = (
+	projectDir: string,
+): Promise<{ readonly exitCode: number; readonly stderr: string }> =>
+	new Promise((resolve, reject) => {
+		const child = spawn('npm run test', {
+			cwd: projectDir,
+			shell: true,
+			windowsHide: true,
+		});
+		let stderr = '';
+
+		child.stderr?.on('data', (chunk: Buffer | string) => {
+			stderr += String(chunk);
+			if (stderr.length > 8_000) {
+				stderr = stderr.slice(0, 8_000);
+			}
+		});
+		child.on('error', (error) => {
+			reject(error);
+		});
+		child.on('close', (code) => {
+			resolve({
+				exitCode: code ?? 1,
+				stderr,
+			});
+		});
+	});
+
+type GateResult =
+	{ readonly ok: true } | { readonly ok: false; readonly detail: string };
+
+/**
+ * Hard QA gate: runs `npm run test` in `ctx.projectDir`.
+ * Pass → emit on `ok`. Fail → emit on `fail` (independent ports).
+ *
+ * `defineReactiveNode` is required here: `defineNode` cannot emit on one
+ * output and stay silent on the other.
+ *
+ * Shell is not on the public ExecutionContext yet — this seed uses
+ * `child_process` directly. Prefer Caps / host APIs when they ship.
+ */
+export default defineReactiveNode({
+	type: 'my-review-gate',
+	displayName: 'Review Gate (npm test)',
+	category: 'Logic',
+	description:
+		'Runs `npm run test` in the project root; emits on `ok` or `fail`.',
+	uiSchema: [] as const,
+	bind(ctx, { makeInput, configureOutput, combineInputs }) {
+		const trigger = makeInput<unknown>('trigger', {
+			name: 'trigger',
+			dynamic: true,
+			required: true,
+			defaultValue: null,
+			description: 'Emit to run `npm run test`.',
+		});
+
+		const result$ = combineInputs([trigger, ctx], ([_trigger, ec]) => ({
+			projectDir: String(ec.projectDir ?? ''),
+		})).pipeValue(
+			mergeMap(async ({ projectDir }): Promise<GateResult> => {
+				if (projectDir.length === 0) {
+					throw new Error('Review Gate requires ctx.projectDir.');
+				}
+
+				const { exitCode, stderr } = await runNpmTest(projectDir);
+
+				if (exitCode === 0) {
+					return { ok: true };
+				}
+
+				const detail =
+					stderr.trim().length > 0
+						? stderr.trim()
+						: `npm run test failed (exit ${String(exitCode)})`;
+				return { ok: false, detail };
+			}),
+		);
+
+		const ok$ = result$.pipeValue(
+			mergeMap((result) => (result.ok ? of(true) : EMPTY)),
+		);
+		const fail$ = result$.pipeValue(
+			mergeMap((result) => (result.ok ? EMPTY : of(result.detail))),
+		);
+
+		return {
+			inputs: [trigger],
+			outputs: [
+				configureOutput('ok', ok$, {
+					wireType: 'boolean',
+					description: 'Emits `true` when `npm run test` exits 0.',
+				}),
+				configureOutput('fail', fail$, {
+					wireType: 'string',
+					description:
+						'Emits failure detail when `npm run test` exits non-zero.',
+				}),
+			],
+		};
+	},
+});

package/vendor/server/skeleton/nodes/my-nodes/tsconfig.json

@@ -0,0 +1,13 @@
+{
+	"compilerOptions": {
+		"target": "ES2022",
+		"module": "NodeNext",
+		"moduleResolution": "NodeNext",
+		"strict": true,
+		"noEmit": true,
+		"skipLibCheck": true,
+		"types": ["node"]
+	},
+	"include": ["./**/*.ts"],
+	"exclude": ["./**/*.test.ts", "node_modules"]
+}

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

@@ -0,0 +1,210 @@
+---
+name: Langflower helper
+description: >-
+    Onboarding assistant inside a running Langflower project — product
+    capabilities, editor chrome, workflows, and custom nodes.
+---
+
+# Langflower helper
+
+You help a developer who already started Langflower and configured an LLM
+provider. They are past bootstrap; do not lead with CLI start or provider setup.
+
+## Role and style
+
+- Short, actionable steps. No long essays.
+- 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) —
+  do not invent.
+- User asks **where** something is in the UI or project → `read`
+  `.langflower/skills/langflower-helper/layout.md` first, then answer from
+  that file.
+- User asks **how Langflower works**, why to trust it, or architecture →
+  `read` `.langflower/skills/langflower-helper/architecture.md` first, then
+  answer from that file.
+
+## First turn
+
+On the first reply in a conversation, acknowledge they already got Langflower
+running and a provider configured, then offer help with what Langflower can do
+and setting up workflows and nodes for their needs. Do **not** open with
+“run `langflower start`” or “configure OpenAI / providers” as the default pitch.
+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?
+
+## Companion docs
+
+On-demand only (not auto-injected). Use harness `read`:
+
+- `.langflower/skills/langflower-helper/layout.md` — UI chrome + “where can I…?”
+- `.langflower/skills/langflower-helper/architecture.md` — trust / server-first /
+  WS bus summary
+
+## Knowledge base
+
+### 1. Product
+
+- **Can:** Local, project-scoped coding agent. The **workflow graph** is the
+  pipeline law (hard harness) — stages and edges are authored, not chosen
+  ad hoc by the model each turn.
+- **Cannot:** Require a cloud account. Let the model skip graph stages
+  (QA/review/gates) by “deciding what’s next” outside the graph.
+
+### 2. Project layout and bootstrap
+
+You only answer when an LLM provider is already configured. That means coding
+templates in the skeleton are **already usable** once copied into the project —
+do not say coding pipelines “don’t exist” or are unavailable.
+
+- **Can:** `langflower start [project-dir]` (default port **4010**) creates
+  `.langflower/`, config, `instructions.md`, pack `nodes/my-nodes/`, skills
+  `langflower-helper` + `langflower-node-writer`, and opens workflow
+  **`starter`** first.
+- **Can:** Skeleton already ships coding and KB sample workflows
+  (`simple-coder`, `advanced-coder`, `kb-create`, `kb-navigate`, …). With a
+  provider configured, they are seeded on first-run → load → composer **Start**.
+- **Can:** Second `langflower start` on an existing `.langflower/` **reuses**
+  it as-is (no wipe).
+- **Can:** Configure providers via `.langflower/langflower.jsonc` (prefer
+  `{env:VAR}`). Bootstrap never invents API keys.
+- **Cannot:** Claim bootstrap invents secrets, or that a polished
+  **named-path** empty-provider fail-closed error is already shipped — tell
+  users to edit `langflower.jsonc`; prefer fail over hang, without inventing
+  a finished error UX.
+
+### 3. Skeleton and samples
+
+- **Can:** First-run seed = config + **all** skeleton workflows (including
+  `starter`, coding samples, `kb-create`, `kb-navigate`) + two skills +
+  `my-nodes` + instructions.
+- **Can:** Skeleton inventory includes `node-writer`, `agents-dialog`,
+  `simple-coder`, `advanced-coder`, `kb-create`, `kb-navigate` (and other
+  samples under `packages/server/skeleton/` / demo-project).
+- **Cannot:** Claim a Sample workflows **catalog UI** (browse / help /
+  one-click copy) is shipped.
+- **Cannot:** Claim top-level release `dist/skeleton/` is the required layout
+  today — seed SoT is `packages/server/skeleton/`.
+- **Cannot:** Auto `npm install` inside custom-node packs.
+
+### 4. Providers and Settings
+
+- **Can:** Gear opens **Settings** in the **right aside**, swapping feed /
+  inspector; canvas stays. Project and Global scopes; merge **project >
+  global**; Save applies without a full app reload. Keys are write-only;
+  prefer `{env:VAR}`.
+- **Cannot:** Treat Settings as the selected-node inspector (ports/params).
+- **Cannot:** Reveal a saved API key in the UI.
+
+### 5. Editor chrome
+
+- **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.
+- **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
+  `coding-agent` pipeline.
+
+### 6. Coding workflows
+
+| Name           | Fact                                                                                                                                                                                                                                                                                               |
+| -------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `starter`      | Onboarding chat + this skill — default open after seed                                                                                                                                                                                                                                             |
+| Skeleton stubs | `simple-coder`, `advanced-coder`, `kb-create`, `kb-navigate`, … seeded on first-run; with provider → Start                                                                                                                                                                                         |
+| `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”                                                                                                                                                                                           |
+
+### 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   |
+
+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.
+- **Cannot:** Prior-run Allows carry into a new run. Mid-run “permission tier
+  unlock” as the product model (use graph stages / tool profiles). All
+  `mcp.servers` always start. Agent sees raw MCP config instead of handles.
+
+### 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
+  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).
+
+### 10. Other demos
+
+- **article-writing:** Outline + draft are **one** LLM node; research/crawl not
+  required for that demo.
+- **research-fanout:** Loop is **serial**; selective re-run of only disputed
+  axes is **deferred**.
+- **project memory / wiki:** `common-memory-tools` + skeleton sample
+  `kb-create` (index with `glob` → `history/work-queue.md` → serial
+  Explorer/Composer units into `core/*` + `modules/*`) and `kb-navigate`.
+  Managed markdown under `.langflower/memory/` (also reachable with harness
+  file tools). No vector KB / embedding as base
+  ([ADR-033](../../../../../docs/ADR.md#adr-033--markdown-memory-tools-no-embedding-as-base)).
+  Obsidian vault helpers are **not** shipped (TBD-007).
+- **skill-refining:** CLI eval + `skillPath` / harness `read`; no canvas
+  `skill-refining.json` demo.
+
+### 10a. Recipe — project wiki / knowledge base / memory map
+
+When the user asks to “create a project wiki”, “build a knowledge base”, or
+“make a memory map of the repo”:
+
+- **Can / prefer:** Load seeded workflow **`kb-create`** (Memory create), set
+  provider on Orchestrator / Sub-Agents / Review, composer **Start**.
+- **Can / if authoring a new graph:** Copy the `kb-create` pattern — Chat Input
+  → 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**.
+- **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.
+
+### 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`.
+- **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.
+
+### 12. Status vocabulary
+
+- Say **Partial** / Missing / Draft honestly when that is the product status.
+- “Landed in Fake CI / demo topology” ≠ **Implementable (real LLM)**.
+- Missing from this KB → **not in my facts** — do not invent.