elanous 0.2.19 → 0.2.21

package/src/dashboard/slash-runtime/help-from-registry.ts

@@ -43,11 +43,15 @@ export function buildEssentialHelpLines({
   descriptions,
   width,
   audience = readTuiSlashAudience(),
+  maxRows,
 }: {
   names: readonly string[];
   descriptions: readonly Pick<SlashCommand, 'name' | 'aliases' | 'description'>[];
   width: number;
   audience?: { role: Role; showBeta: boolean };
+  /** The modal's row budget. When the readable layout overflows it, add columns (shorter descriptions)
+   *  before the caller has to fall back to the chat log — TUI-HELP-OVERLAY (0.2.19 tui node «help-closes»). */
+  maxRows?: number;
 }): string[] {
   const registered = new Set(names);
   const entries = descriptions
@@ -67,41 +71,63 @@ export function buildEssentialHelpLines({
   // in each cell. Never trade a missing label for a shorter modal.
   const widestLabel = Math.max(0, ...entries.map(({ label }) => visibleWidth(label)));
   const readableCellWidth = widestLabel + 2 + 28 + 1;
-  const columns = entries.length >= 40 && width >= 100
+  const baseColumns = entries.length >= 40 && width >= 100
     ? Math.max(1, Math.floor(width / (readableCellWidth + 1)))
     : 1;
-  const columnWidth = Math.floor(width / columns);
-  // Task order (TUI-SLASH-DECIDE-NOW C): group head line, then that group's commands by name.
-  // Empty groups print no head; unmapped commands land in «그 밖», so none disappears.
-  const commandLines: string[] = [];
-  for (const group of HELP_GROUP_ORDER) {
-    const members = entries.filter(({ name }) => helpGroupFor(name) === group);
-    if (members.length === 0) continue;
-    commandLines.push(fitLine(helpGroupHeading(group), width));
-    for (let start = 0; start < members.length; start += columns) {
-      const cells = members.slice(start, start + columns).map(({ label, description }) => {
-        const cellWidth = columnWidth - (columns > 1 ? 1 : 0);
-        return visibleWidth(`${label}  `) > cellWidth ? '' : fitLine(`${label}  ${description}`, cellWidth);
-      });
-      commandLines.push(cells.map((cell, index) =>
-        index === cells.length - 1 ? cell : cell + ' '.repeat(columnWidth - visibleWidth(cell)),
-      ).join('').trimEnd());
-    }
+  // Narrowest cell that still shows the whole label and a few description characters.
+  const minCellWidth = widestLabel + 2 + 10 + 1;
+  let lines = layout(baseColumns);
+  for (let columns = baseColumns + 1; maxRows !== undefined && lines.length > maxRows
+    && Math.floor(width / columns) - 1 >= minCellWidth; columns++) {
+    lines = layout(columns);
   }
-  const keyItems = ESSENTIAL_KEYS.map(([key, description]) => `${key}  ${description}`);
-  const keyLines: string[] = [];
-  if (entries.length >= 40 && width >= 100) {
-    let keyRow = '';
-    for (const item of keyItems) {
-      if (keyRow && visibleWidth(keyRow) + 2 + visibleWidth(item) > width) {
-        keyLines.push(keyRow);
-        keyRow = '';
+  return lines;
+
+  function layout(columns: number): string[] {
+    const columnWidth = Math.floor(width / columns);
+    // Task order (TUI-SLASH-DECIDE-NOW C): group head line, then that group's commands by name.
+    // Empty groups print no head; unmapped commands land in «그 밖», so none disappears.
+    const commandLines: string[] = [];
+    const cellWidth = columnWidth - (columns > 1 ? 1 : 0);
+    const cellOf = ({ label, description }: { label: string; description: string }) =>
+      visibleWidth(`${label}  `) > cellWidth ? '' : fitLine(`${label}  ${description}`, cellWidth);
+    const pushRow = (cells: string[]) => commandLines.push(cells.map((cell, index) =>
+      index === cells.length - 1 ? cell : cell + ' '.repeat(columnWidth - visibleWidth(cell)),
+    ).join('').trimEnd());
+    if (columns > 1) {
+      // TUI-HELP-OVERLAY · 2026-10-07 — in columns the group head is a cell and groups flow on: a head line plus a
+      // half-empty last row per group pushed the catalog past the modal's rows, so /help fell back to the chat log
+      // and Esc no longer closed it (0.2.19 release tui node «help-closes»).
+      const cells: string[] = [];
+      for (const group of HELP_GROUP_ORDER) {
+        const members = entries.filter(({ name }) => helpGroupFor(name) === group);
+        if (members.length === 0) continue;
+        cells.push(fitLine(helpGroupHeading(group), cellWidth), ...members.map(cellOf));
+      }
+      for (let start = 0; start < cells.length; start += columns) pushRow(cells.slice(start, start + columns));
+    } else {
+      for (const group of HELP_GROUP_ORDER) {
+        const members = entries.filter(({ name }) => helpGroupFor(name) === group);
+        if (members.length === 0) continue;
+        commandLines.push(fitLine(helpGroupHeading(group), width));
+        for (const member of members) pushRow([cellOf(member)]);
+      }
+    }
+    const keyItems = ESSENTIAL_KEYS.map(([key, description]) => `${key}  ${description}`);
+    const keyLines: string[] = [];
+    if (entries.length >= 40 && width >= 100) {
+      let keyRow = '';
+      for (const item of keyItems) {
+        if (keyRow && visibleWidth(keyRow) + 2 + visibleWidth(item) > width) {
+          keyLines.push(keyRow);
+          keyRow = '';
+        }
+        keyRow += (keyRow ? '  ' : '') + fitLine(item, width);
       }
-      keyRow += (keyRow ? '  ' : '') + fitLine(item, width);
+      if (keyRow) keyLines.push(keyRow);
+    } else {
+      keyLines.push(...keyItems.map((item) => fitLine(item, width)));
     }
-    if (keyRow) keyLines.push(keyRow);
-  } else {
-    keyLines.push(...keyItems.map((item) => fitLine(item, width)));
+    return [fitLine('Commands', width), ...commandLines, '', fitLine('Keys', width), ...keyLines];
   }
-  return [fitLine('Commands', width), ...commandLines, '', fitLine('Keys', width), ...keyLines];
 }

package/src/domains/outbound-log-probe.ts

@@ -2,7 +2,12 @@ import { inQuietHours, kstMinutes, sendOutbound, setInProcessOutbound } from './
 import { setUserConfigOverlay } from '../user-config.js';
 
 // Focused subprocess fixture: isolated state/config roots and a fake curl on PATH.
-setUserConfigOverlay(cfg => ({ ...cfg, telegram: { ...cfg.telegram, botToken: '123456:private-secret', homeChannel: 98765 } }));
+// Hermetic: the shared `.elanous-test` config may carry a routing table another test left behind (a declared
+// `channels` table is authoritative and never falls back to the main home), so the fixture owns every routing key.
+setUserConfigOverlay(cfg => ({ ...cfg, telegram: {
+  ...cfg.telegram, channels: undefined, reportChannel: undefined, testChannel: undefined,
+  botToken: '123456:private-secret', homeChannel: 98765,
+} }));
 process.env.SEND_VIA_ELANOUS = '0';
 // Quiet hours (00:00~06:30 KST) defer instead of sending, so a gate run at night saw no `sent` row.
 // Shift this fixture's clock back to 23:59 KST of the previous day; the shift stays inside this process.

package/src/esc-abort-gate.ts

@@ -55,6 +55,8 @@ export interface EscAbortGateDeps {
   getTheme?: () => ThemeTokens | null | undefined;
   /** Names shown/logged while a turn abort request is waiting for running work to unwind. */
   getWaitingTargetNames?: () => readonly string[];
+  /** Only an identified foreground harness run may bypass the sub-agent confirmation. */
+  shouldAbortImmediately?: () => boolean;
   /** Called before abortTurnOnly so the UI can paint a visible pending state immediately. */
   onAbortPending?: (event: { running: number; repeat: number; targets: readonly string[] }) => void;
   /** Called when another Escape arrives after the first abort request. */
@@ -211,7 +213,7 @@ export function createEscAbortGate(deps: EscAbortGateDeps): EscAbortGate {
         return;
       }
       const running = deps.getRunningCount();
-      if (running <= 0) {
+      if (running <= 0 || deps.shouldAbortImmediately?.()) {
         debug.log('esc.abort', 'abort-immediately', { running, repeat: Math.max(0, escapePresses - 1) });
         abortPendingTurn(running);
         return;

package/src/graph-runner/graph-cli.ts

@@ -94,6 +94,63 @@ export function registerGraphCommands(program: Command, runsDeps: { root?: strin
         process.exitCode = 1;
       }
     });
+  graph.command('wizard <prompt>')
+    .description('말 한 줄로 그래프 YAML 을 짓고 같은 검증기 ⊕ graph run --dry-run 으로 확인한다(저장하지 않는다) — --from 이면 그 그래프를 고친다')
+    .option('--kind <kind>', 'harness | workflow', 'harness')
+    .option('--from <file>', '고칠 그래프 YAML (편집 경로)')
+    .option('--out <file>', 'YAML 을 이 파일에 쓰고, 하니스면 같은 폴더에 recipes.yaml 도 쓴다(있으면 덮지 않는다)')
+    .option('--json', '결과를 JSON 으로')
+    .option('--run', '생성된 그래프의 dry-run 경로를 보여 준다(--dry-run 과 함께만)')
+    .option('--dry-run', '--run 과 함께: 명령을 실행하지 않고 경로만 걷는다')
+    .action(async (prompt: string, opts: { kind: string; from?: string; out?: string; json?: boolean; run?: boolean; dryRun?: boolean }) => {
+      try {
+        if (opts.kind !== 'harness' && opts.kind !== 'workflow') throw new Error('--kind must be harness or workflow');
+        if (opts.run && !opts.dryRun) throw new Error('--run is only supported with --dry-run (run the saved graph with `elanous graph run <file>`)');
+        if (opts.run && opts.kind !== 'harness') throw new Error('--run --dry-run walks harness graphs only');
+        await (await import('../domains/standalone-log-sink.js')).registerStandaloneLogSink('graph');
+        const { generateGraphFromPrompt } = await import('../graph-wizard/generate.js');
+        const currentYaml = opts.from ? readFileSync(opts.from, 'utf8') : undefined;
+        const started = Date.now();
+        const result = await generateGraphFromPrompt({ prompt, kind: opts.kind, ...(currentYaml ? { currentYaml } : {}) });
+        const ms = Date.now() - started;
+        let recipesNote: string | undefined;
+        if (opts.out) {
+          const { writeFileSync } = await import('node:fs');
+          const { dirname } = await import('node:path');
+          writeFileSync(opts.out, result.yaml);
+          if (result.recipes) {
+            const recipesPath = join(dirname(resolve(opts.out)), 'recipes.yaml');
+            if (existsSync(recipesPath) && readFileSync(recipesPath, 'utf8') !== result.recipes) recipesNote = `recipes.yaml 이 이미 있어 덮지 않았다: ${recipesPath}`;
+            else { writeFileSync(recipesPath, result.recipes); recipesNote = `recipes ${recipesPath}`; }
+          }
+        }
+        if (opts.json) {
+          await writeStdoutJson(JSON.stringify({ ...result, ms, ...(recipesNote ? { recipesNote } : {}) }) + '\n');
+        } else {
+          if (!opts.out) process.stdout.write(result.yaml);
+          console.log(`# ${result.ok ? 'ok' : 'invalid'} · id ${result.id} · base ${result.base ?? '-'} · attempts ${result.attempts} · ${(ms / 1000).toFixed(1)}s${opts.out ? ` · saved ${opts.out}` : ''}`);
+          console.log(`# ${result.summary}`);
+          if (recipesNote) console.log(`# ${recipesNote}`);
+          for (const issue of result.issues) console.log(`# issue: ${issue}`);
+          if (result.dryRun && (opts.run || !result.ok)) console.log(`# dry-run ${result.dryRun.status}: ${result.dryRun.path.join(' → ')}`);
+        }
+        if (!result.ok) process.exitCode = 1;
+      } catch (error) {
+        console.error(`graph wizard: ${error instanceof Error ? error.message : String(error)}`);
+        process.exitCode = 1;
+      }
+    });
+  graph.command('step <step>')
+    .description('그래프 마법사 단계 하나를 실행한다(graph run 의 cmd 노드가 부른다 · 마지막 줄 JSON {outcome})')
+    .option('--arg <text>', '단계 인자')
+    .option('--retries <n>', '실패하면 이 횟수만큼 다시 시도', '0')
+    .action(async (step: string, opts: { arg?: string; retries: string }) => {
+      const { runWizardStepWithRetries } = await import('../graph-wizard/steps.js');
+      const result = runWizardStepWithRetries(step, opts.arg, Number.parseInt(opts.retries, 10) || 0);
+      if (result.error) console.error(result.error);
+      console.log(JSON.stringify({ outcome: result.outcome, tries: result.tries, ...(result.text ? { text: result.text.slice(0, 20_000) } : {}), ...(result.error ? { error: result.error } : {}) }));
+      if (result.outcome === 'fail') process.exitCode = 1;
+    });
   graph.command('tick <file>')
     .description('Advance one graph run, resuming a pending decision or starting only when requested')
     .option('--start', 'Start a new run when the graph is idle')

package/src/graph-runner/graph-run-api.ts

@@ -0,0 +1,218 @@
+// CGE-RUN — 편집기에서 «내 그래프»를 실행하고 노드별 상태를 읽는다.
+// 실행은 `elanous graph run` 과 같은 범용 실행기(runGraph)다. 하니스(LLM) 런은 골 종류로만 그래프를 고르므로 여기서 다루지 않는다.
+// 그래프와 레시피는 런마다 작업 폴더로 «복사»해서 돌린다 — 실행 중에 편집기가 파일을 바꿔도 이 런은 시작한 판으로 끝난다.
+// ⛔ 레시피(실제로 도는 명령)는 «저장소»의 편집기 레시피(`graphs/demo/editor-recipes.yaml`)만 쓴다 — «mine» 폴더는 HTTP 로 쓸 수 있으므로
+//    거기 레시피를 읽으면 «편집한 그래프 실행»이 «편집한 명령 실행»이 된다(TC 10-07 19:31). 그래프가 부르는 레시피가 그 목록에 없으면 시작 전에 거부한다.
+import { copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from 'node:fs';
+import { randomBytes } from 'node:crypto';
+import { join } from 'node:path';
+import { parse as parseYaml } from 'yaml';
+import { elanousStateRoot } from '../autopilot/state-paths.js';
+import { debug } from '../debug/log.js';
+import { effectiveInstanceRoot } from '../instance/resolve.js';
+import { jsonResponse } from '../nexus/api/json-response.js';
+import { defaultGraphsDir } from '../self-implement/graph-templates.js';
+import { runGraph, type GraphRunState } from './runner.js';
+import { readWizardSteps, wizardRecipesFor } from '../graph-wizard/saved-steps.js';
+import { stringify as stringifyYaml } from 'yaml';
+
+const GRAPH_ID = /^[a-z0-9-]+$/;
+const RUN_ID = /^ed-[a-z0-9]+-[a-f0-9]{6}$/;
+/** 실행기가 받는 끝 노드 이름(runner.ts — `unsupported terminal node`). 미리 말해 준다. */
+const RUNNABLE_TERMINALS = new Set(['done', 'failed']);
+
+export interface GraphRunApiDeps {
+  mineDir?: string;
+  /** 편집기 실행이 쓰는 레시피 파일(저장소 것만) — 기본 `graphs/demo/editor-recipes.yaml`. */
+  recipesFile?: string;
+  root?: string;
+  run?: typeof runGraph;
+  now?: () => number;
+}
+
+/** 시작 전에 죽은 런(레시피 없음 등)은 원장 파일이 안 생긴다 — 그 이유를 여기 잠깐 들고 있다가 상태 조회에 돌려준다. */
+const startFailures = new Map<string, { error: string; at: string }>();
+
+const mineDirOf = (deps: GraphRunApiDeps) => deps.mineDir ?? join(elanousStateRoot(), 'graphs');
+const rootOf = (deps: GraphRunApiDeps) => deps.root ?? effectiveInstanceRoot();
+
+function decodeId(raw: string, pattern: RegExp): string | null {
+  try {
+    const id = decodeURIComponent(raw);
+    return pattern.test(id) ? id : null;
+  } catch { return null; }
+}
+
+/** 파일 이름이 아니라 선언된 graph_id 로 찾는다(graphs-api 와 같은 규칙). */
+function findMine(dir: string, id: string): { file: string; doc: Record<string, unknown> } | null {
+  let names: string[];
+  try { names = readdirSync(dir).filter((name) => name.endsWith('.yaml') || name.endsWith('.yml')).sort(); }
+  catch { return null; }
+  for (const name of names) {
+    if (name === 'recipes.yaml') continue;
+    try {
+      const doc: unknown = parseYaml(readFileSync(join(dir, name), 'utf8'));
+      if (doc && typeof doc === 'object' && !Array.isArray(doc) && (doc as Record<string, unknown>).graph_id === id) {
+        return { file: join(dir, name), doc: doc as Record<string, unknown> };
+      }
+    } catch { continue; }
+  }
+  return null;
+}
+
+/** 되돌이(순환) 위의 노드가 max_visits 1 이면 두 번째 방문에서 예산 초과로 멈춘다 — 시작 전에 말한다. */
+function loopVisitIssues(doc: Record<string, unknown>): string[] {
+  const next = new Map<string, Set<string>>();
+  for (const edge of Array.isArray(doc.edges) ? doc.edges : []) {
+    if (!edge || typeof edge !== 'object') continue;
+    const { from, to, map } = edge as Record<string, unknown>;
+    if (typeof from !== 'string') continue;
+    const targets = [...(typeof to === 'string' ? [to] : []),
+      ...(map && typeof map === 'object' ? Object.values(map as Record<string, unknown>).filter((v): v is string => typeof v === 'string') : [])];
+    for (const target of targets) (next.get(from) ?? next.set(from, new Set()).get(from)!).add(target);
+  }
+  const reaches = (start: string, goal: string): boolean => {
+    const seen = new Set<string>();
+    const stack = [...(next.get(start) ?? [])];
+    while (stack.length) {
+      const id = stack.pop()!;
+      if (id === goal) return true;
+      if (seen.has(id)) continue;
+      seen.add(id);
+      stack.push(...(next.get(id) ?? []));
+    }
+    return false;
+  };
+  const issues: string[] = [];
+  for (const node of Array.isArray(doc.nodes) ? doc.nodes : []) {
+    if (!node || typeof node !== 'object') continue;
+    const { node_id: id, max_visits: visits } = node as Record<string, unknown>;
+    if (typeof id === 'string' && (typeof visits !== 'number' || visits < 2) && reaches(id, id)) {
+      issues.push(`노드 '${id}' 는 되돌이 위에 있는데 max_visits 가 ${typeof visits === 'number' ? visits : '없음'} 이다 — 두 번째 방문에서 멈춘다 · 2 이상으로`);
+    }
+  }
+  return issues;
+}
+
+/** 실행기가 받지 않을 모양을 시작 «전»에 사람 말로. 빈 배열이면 돌릴 수 있다. */
+export function runnableIssues(doc: Record<string, unknown>, allowedRecipes: ReadonlySet<string>): string[] {
+  const issues: string[] = [];
+  for (const node of Array.isArray(doc.nodes) ? doc.nodes : []) {
+    if (!node || typeof node !== 'object') continue;
+    const { node_id: nodeId, recipe } = node as Record<string, unknown>;
+    if (typeof recipe !== 'string' || recipe === 'none') continue;
+    if (recipe.startsWith('approval:')) { issues.push(`노드 '${String(nodeId)}' 의 승인 레시피 '${recipe}' 는 편집기 데모 실행에서 쓸 수 없다`); continue; }
+    const prefixed = /^cmd:(.*)$/.exec(recipe);
+    if (prefixed && !allowedRecipes.has(prefixed[1]!)) {
+      issues.push(`노드 '${String(nodeId)}' 의 레시피 '${recipe}' 는 편집기 실행 목록에 없다 — 쓸 수 있는 것: ${[...allowedRecipes].map((r) => `cmd:${r}`).join(' · ')}`);
+    }
+  }
+  // grow 는 매핑 안 된 결과에서 LLM 제안기를 부른다 — 데모 실행 범위 밖(하니스 LLM 런은 0.2.21).
+  if (doc.grow !== undefined) issues.push('grow(그래프 자라기)는 편집기 데모 실행에서 쓸 수 없다 — grow 줄을 지우고 저장하라');
+  issues.push(...loopVisitIssues(doc));
+  const terminals = Array.isArray(doc.terminal_nodes) ? doc.terminal_nodes.filter((t): t is string => typeof t === 'string') : [];
+  if (!terminals.length) issues.push('끝 노드가 없다 — done 노드를 잇고 끝으로 지정하라');
+  for (const t of terminals) if (!RUNNABLE_TERMINALS.has(t)) issues.push(`끝 노드 '${t}' 는 실행할 수 없다 — 끝 노드 이름은 done 또는 failed 여야 한다`);
+  return issues;
+}
+
+export interface GraphRunNodeView { nodeId: string; ok: boolean; executed: boolean; startedAt?: string; endedAt?: string; error?: string }
+export interface GraphRunView {
+  graphId: string; runId: string; status: GraphRunState['status'] | 'starting';
+  startedAt?: string; finishedAt?: string; path: string[];
+  nodes: GraphRunNodeView[]; currentNode?: { nodeId: string; startedAt: string }; error?: string;
+}
+
+export function graphRunView(state: GraphRunState): GraphRunView {
+  return {
+    graphId: state.graphId, runId: state.runId, status: state.status,
+    ...(state.startedAt ? { startedAt: state.startedAt } : {}), ...(state.finishedAt ? { finishedAt: state.finishedAt } : {}),
+    path: state.path,
+    nodes: state.nodes.map((node) => ({
+      nodeId: node.nodeId, ok: node.ok, executed: node.executed,
+      ...(node.startedAt ? { startedAt: node.startedAt } : {}), ...(node.endedAt ? { endedAt: node.endedAt } : {}),
+      ...(node.error ? { error: node.error.slice(0, 300) } : {}),
+    })),
+    ...(state.currentNode ? { currentNode: state.currentNode } : {}),
+  };
+}
+
+/** POST /v1/graphs/<id>/run — 내 그래프만 실행한다(핵심 그래프는 복제해서 돌린다). 응답은 기다리지 않는다(202 ⊕ runId). */
+export function handleGraphRunStart(rawId: string, deps: GraphRunApiDeps = {}): Response {
+  const id = decodeId(rawId, GRAPH_ID);
+  if (!id) return jsonResponse({ error: 'bad_request', reason: 'invalid graph id' }, 400);
+  const mine = findMine(mineDirOf(deps), id);
+  if (!mine) return jsonResponse({ error: 'not-found', id, reason: '내 그래프에만 실행이 있다 — 핵심 그래프는 복제해서 돌린다' }, 404);
+  const recipesFile = deps.recipesFile ?? join(defaultGraphsDir(), 'demo', 'editor-recipes.yaml');
+  let recipeText: string;
+  let allowed: Set<string>;
+  try {
+    recipeText = readFileSync(recipesFile, 'utf8');
+    const parsed: unknown = parseYaml(recipeText);
+    allowed = new Set(parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? Object.keys(parsed) : []);
+    // GRAPH-WIZARD-SAVE-RECIPES — a wizard graph's own steps (saved as a validated sidecar) become recipes here,
+    // generated by the server from the step library; they take precedence for the nodes that carry them.
+    const steps = readWizardSteps(mineDirOf(deps), id, readFileSync(mine.file, 'utf8'));
+    const generated = steps ? wizardRecipesFor(readFileSync(mine.file, 'utf8'), steps) : {};
+    if (Object.keys(generated).length) {
+      const base = parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed as Record<string, unknown> : {};
+      const merged = { ...base, ...generated };
+      recipeText = stringifyYaml(merged);
+      allowed = new Set(Object.keys(merged));
+      debug.log('graphs.run', 'wizard-recipes', { id, nodes: Object.keys(generated) });
+    }
+  } catch {
+    return jsonResponse({ error: 'recipes-unavailable' }, 503);
+  }
+  const issues = runnableIssues(mine.doc, allowed);
+  if (issues.length) return jsonResponse({ error: 'not-runnable', id, issues }, 422);
+
+  const now = deps.now?.() ?? Date.now();
+  const runId = `ed-${now.toString(36)}-${randomBytes(3).toString('hex')}`;
+  const root = rootOf(deps);
+  const work = join(root, 'graph-run-work', id, runId);
+  try {
+    mkdirSync(work, { recursive: true });
+    copyFileSync(mine.file, join(work, 'graph.yaml'));
+    writeFileSync(join(work, 'recipes.yaml'), recipeText);
+  } catch (error) {
+    return jsonResponse({ error: 'run-workspace-failed', reason: error instanceof Error ? error.message.slice(0, 200) : 'unknown' }, 500);
+  }
+  debug.log('graphs.run', 'started', { id, runId });
+  void (deps.run ?? runGraph)(join(work, 'graph.yaml'), { runId, input: { source: 'editor' }, deps: { root } })
+    .then((state) => debug.log('graphs.run', 'finished', { id, runId, status: state.status, executed: state.executed }))
+    .catch((error: unknown) => {
+      const message = error instanceof Error ? error.message : String(error);
+      startFailures.set(runId, { error: message.slice(0, 300), at: new Date().toISOString() });
+      if (startFailures.size > 50) startFailures.delete(startFailures.keys().next().value!);
+      debug.log('graphs.run', 'failed', { id, runId, error: message.slice(0, 200) }, { level: 'warn' });
+    });
+  return jsonResponse({ id, runId, demo: true }, 202);
+}
+
+/** GET /v1/graphs/<id>/runs/<runId> — 원장 그대로(노드별 ok·시각 · 지금 노드). 원장이 아직 없으면 starting, 시작 전에 죽었으면 failed ⊕ 이유. */
+export function handleGraphRunGet(rawId: string, rawRunId: string, deps: GraphRunApiDeps = {}): Response {
+  const id = decodeId(rawId, GRAPH_ID);
+  const runId = decodeId(rawRunId, RUN_ID);
+  if (!id || !runId) return jsonResponse({ error: 'bad_request', reason: 'invalid id' }, 400);
+  const file = join(rootOf(deps), 'graph-runs', id, `${runId}.json`);
+  let state: GraphRunState | null = null;
+  try { state = JSON.parse(readFileSync(file, 'utf8')) as GraphRunState; } catch { state = null; }
+  if (state && state.graphId === id && state.runId === runId) return jsonResponse(graphRunView(state));
+  const failed = startFailures.get(runId);
+  if (failed) return jsonResponse({ graphId: id, runId, status: 'failed', path: [], nodes: [], error: failed.error } satisfies GraphRunView);
+  if (!existsSync(join(rootOf(deps), 'graph-run-work', id, runId))) return jsonResponse({ error: 'not-found', id, runId }, 404);
+  return jsonResponse({ graphId: id, runId, status: 'starting', path: [], nodes: [] } satisfies GraphRunView);
+}
+
+const RUN_START = /^\/v1\/graphs\/([^/]+)\/run$/;
+const RUN_GET = /^\/v1\/graphs\/([^/]+)\/runs\/([^/]+)$/;
+
+/** http-server 가 인증 «뒤»에 부른다. 이 두 길이 아니면 null. */
+export function handleGraphRunRoute(method: string, pathname: string, deps: GraphRunApiDeps = {}): Response | null {
+  const start = RUN_START.exec(pathname);
+  if (start && method === 'POST') return handleGraphRunStart(start[1]!, deps);
+  const get = RUN_GET.exec(pathname);
+  if (get && method === 'GET') return handleGraphRunGet(get[1]!, get[2]!, deps);
+  return null;
+}

package/src/graph-runner/runner.ts

@@ -66,6 +66,12 @@ export interface GraphRunOptions {
   resumeGraphId?: string;
   fromNodeId?: string;
   useCurrentGraph?: boolean;
+  /**
+   * RELEASE-LEDGER-UNIVERSE — stamp every cmd: child with this run's ledger root (`ELANOUS_STATE_DIR`).
+   * Without it a child launched from a non-leader tree (`bun scripts/...` with cwd = that tree) re-resolves
+   * its own universe and lands in the tree-derived test universe while the run ledger is prod.
+   */
+  pinChildUniverse?: boolean;
   deps?: { root?: string; runBash?: BashRun; log?: (event: string, data: Record<string, unknown>) => void; processStartMs?: (pid: number) => number | null; growthProposer?: GrowthProposer; growthLLM?: (prompt: string) => Promise<string>; classifyGrowthRecipe?: (node: GraphNodeSpec, resolved: { command?: string; approval?: string }) => GrowthRecipeEffect; growthDecision?: GrowthDecisionDeps & { list?: (filters: { status: 'all' }) => DecisionEntry[] } };
 }
 
@@ -714,7 +720,11 @@ export async function runGraph(path: string, options: GraphRunOptions = {}): Pro
       // state stamp so a cmd: child resolves its default config in the same universe.
       // The ignored config-dir environment variable must not appear to propagate the flag.
       delete env.ELANOUS_CONFIG_DIR;
-      if (getElanousConfigDirOverride()) {
+      if (options.pinChildUniverse) {
+        // The run's own ledger root is the parent universe — the child writes where the run is recorded.
+        env.ELANOUS_STATE_DIR = root;
+        debug.log('graph-runner', 'child-universe-pinned', { graphId, runId, node: current, configDir: getElanousConfigDirOverride() ?? null, stateDir: env.ELANOUS_STATE_DIR, why: 'pinChildUniverse' });
+      } else if (getElanousConfigDirOverride()) {
         env.ELANOUS_STATE_DIR = effectiveInstanceRoot();
         debug.log('graph-runner', 'child-universe-pinned', { graphId, runId, node: current, configDir: getElanousConfigDirOverride(), stateDir: env.ELANOUS_STATE_DIR });
       }

package/src/graph-wizard/archetypes.ts

@@ -0,0 +1,88 @@
+/**
+ * 마법사 «원형» — 사람이 말로 자주 시키는 일의 뼈대 셋. graphs/** 의 운영 템플릿(개발·출시 루프)은
+ * «모아서 요약해 보내기» 같은 말과 낱말이 안 겹쳐 엉뚱한 기반(lecture-note)을 골랐다(10-08 라이브 실측).
+ * 원형은 기반 후보 «맨 앞»에 서고, 키워드가 겹치는 만큼 점수를 얻는다.
+ */
+export interface WizardArchetype { id: string; description: string; keywords: string[]; text: string }
+
+export const WIZARD_ARCHETYPES: readonly WizardArchetype[] = [
+  {
+    id: 'wizard-collect-summarize-send',
+    description: '모아서 요약해 보내기 — 검색·수집 → 요약 → 텔레그램/알림 발송 (브리핑·다이제스트·동향)',
+    keywords: ['뉴스', '모아', '수집', '검색', '찾아', '요약', '정리', '보내', '알려', '텔레그램', '브리핑', '동향', '소식', 'news', 'digest', 'summary'],
+    text: `graph_id: wizard-collect-summarize-send
+loop:
+  title: 모아서 요약해 보내기
+  description: 검색으로 모은 내용을 요약해 텔레그램으로 보낸다
+  trigger:
+    cron: "0 8 * * *"
+version: 1
+entry_node: collect
+terminal_nodes: [done, failed]
+nodes:
+  - { node_id: collect, kind: agent, recipe: 'cmd:collect', max_visits: 1 }  # 수집 | web-search | 검색어
+  - { node_id: summarize, kind: agent, recipe: 'cmd:summarize', max_visits: 1 }  # 요약 | summarize | 핵심 5줄 한국어
+  - { node_id: send, kind: agent, recipe: 'cmd:send', max_visits: 1 }  # 텔레그램 발송 | telegram-send
+  - { node_id: done, kind: gate, recipe: none, max_visits: 1 }  # 완료
+  - { node_id: failed, kind: gate, recipe: none, max_visits: 1 }  # 실패
+edges:
+  - { from: collect, on: outcome, map: { ok: summarize, fail: failed } }
+  - { from: summarize, on: outcome, map: { ok: send, fail: failed } }
+  - { from: send, on: outcome, map: { ok: done, fail: failed } }
+`,
+  },
+  {
+    id: 'wizard-review-merge',
+    description: 'PR 리뷰 후 머지 — 리뷰 → must-fix 없으면 승인 뒤 머지 (있으면 멈추고 알림)',
+    keywords: ['pr', '리뷰', '머지', '병합', '풀리퀘', 'must', 'fix', 'review', 'merge'],
+    text: `graph_id: wizard-review-merge
+loop:
+  title: PR 리뷰 후 머지
+  description: PR 을 리뷰하고 must-fix 가 없으면 머지한다
+  trigger:
+    events: [pr-opened]
+version: 1
+entry_node: review
+terminal_nodes: [done, failed]
+nodes:
+  - { node_id: review, kind: judge, recipe: 'cmd:review', max_visits: 1 }  # PR 리뷰 | gh-pr-review
+  - { node_id: approve-merge, kind: hitl, recipe: 'approval:approve-merge', max_visits: 1 }  # 머지 승인 | approval
+  - { node_id: merge, kind: git, recipe: 'cmd:merge', max_visits: 1 }  # PR 머지 | gh-pr-merge
+  - { node_id: notify, kind: agent, recipe: 'cmd:notify', max_visits: 1 }  # must-fix 알림 | notify-me | PR 에 must-fix 가 있어 머지하지 않았다
+  - { node_id: done, kind: gate, recipe: none, max_visits: 1 }  # 완료
+  - { node_id: failed, kind: gate, recipe: none, max_visits: 1 }  # 실패
+edges:
+  - { from: review, on: outcome, map: { ok: approve-merge, must-fix: notify, fail: failed } }
+  - { from: approve-merge, on: outcome, map: { ok: merge, fail: failed } }
+  - { from: merge, on: outcome, map: { ok: done, fail: failed } }
+  - { from: notify, on: outcome, map: { ok: done, fail: failed } }
+`,
+  },
+  {
+    id: 'wizard-research-approve-publish',
+    description: '조사해 정리하고 승인 뒤 게시 — 조사 → 표/초안 정리 → 사람 승인 → 게시',
+    keywords: ['조사', '가격', '경쟁', '표', '정리', '승인', '올려', '게시', '노션', '초안', '블로그', '보고서'],
+    text: `graph_id: wizard-research-approve-publish
+loop:
+  title: 조사해 정리하고 승인 뒤 게시
+  description: 조사한 내용을 표로 정리하고 사람 승인 뒤 게시한다
+  trigger:
+    events: [manual]
+version: 1
+entry_node: research
+terminal_nodes: [done, failed]
+nodes:
+  - { node_id: research, kind: agent, recipe: 'cmd:research', max_visits: 1 }  # 조사 | web-search | 조사 주제
+  - { node_id: tabulate, kind: agent, recipe: 'cmd:tabulate', max_visits: 1 }  # 표로 정리 | llm | 결과를 마크다운 표로 정리
+  - { node_id: approve, kind: hitl, recipe: 'approval:approve', max_visits: 1 }  # 게시 승인 | approval
+  - { node_id: publish, kind: agent, recipe: 'cmd:publish', max_visits: 1 }  # 게시 | custom | 게시처에 올리기
+  - { node_id: done, kind: gate, recipe: none, max_visits: 1 }  # 완료
+  - { node_id: failed, kind: gate, recipe: none, max_visits: 1 }  # 실패
+edges:
+  - { from: research, on: outcome, map: { ok: tabulate, fail: failed } }
+  - { from: tabulate, on: outcome, map: { ok: approve, fail: failed } }
+  - { from: approve, on: outcome, map: { ok: publish, fail: failed } }
+  - { from: publish, on: outcome, map: { ok: done, fail: failed } }
+`,
+  },
+];