elanous 0.2.11 → 0.2.13

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

@@ -1,3 +1,6 @@
+import { createHash } from 'node:crypto';
+import { DecisionLedger, type DecisionEntry } from '../decisions/decision-ledger.js';
+import { effectiveInstanceRoot } from '../instance/resolve.js';
 import { createGraphVariant } from '../self-implement/graph-variant.js';
 import type { GraphEdgeSpec, GraphNodeSpec, GraphTemplateSpec } from '../self-implement/graph-yaml.js';
 import { createLLMGrowthProposer } from './graph-grow-llm.js';
@@ -10,6 +13,8 @@ export interface GrowthProposal {
 
 export type GrowthProposer = (input: { graph: GraphTemplateSpec; nodeId: string; outcome: string; runId: string; output?: unknown }) => GrowthProposal | undefined | Promise<GrowthProposal | undefined>;
 export type GrowthRecipeEffect = 'read-only' | 'external-effect' | 'unknown';
+export interface GrowthCommand { command: string; dry_run_command?: string; timeout_ms?: number }
+export interface GrowthRecipeClassification { effect: GrowthRecipeEffect; command?: GrowthCommand; approval?: string }
 
 export interface GraphGrowth {
   node: GraphNodeSpec;
@@ -18,30 +23,81 @@ export interface GraphGrowth {
   undo: { removeNode: string; removeOutcome: { from: string; outcome: string }; removeEdge?: GraphEdgeSpec };
 }
 
+export interface GrowthDecisionDeps {
+  ledger?: Pick<DecisionLedger, 'raiseOnce'>;
+  root?: string;
+  now?: () => Date;
+}
+
+function proposalGrowth(input: Parameters<GrowthProposer>[0], proposal: GrowthProposal): GraphGrowth {
+  const edges: GraphEdgeSpec[] = [
+    { from: input.nodeId, on: 'outcome', map: { [input.outcome]: proposal.node.nodeId } },
+    { from: proposal.node.nodeId, to: proposal.returnTo as string },
+  ];
+  return { node: proposal.node, edges, reason: proposal.reason,
+    undo: { removeNode: proposal.node.nodeId, removeOutcome: { from: input.nodeId, outcome: input.outcome }, removeEdge: edges[1]! } };
+}
+
+/** The card's own ref commits to the entire growth and resolved recipe, independently of the parked run state. */
+export function growthApprovalRef(identity: { graphId: string; runId: string; from: string; outcome: string },
+  growth: GraphGrowth, command?: GrowthCommand, approval?: string): string {
+  const hash = createHash('sha256').update(JSON.stringify({ identity, growth, command, approval })).digest('hex');
+  return `graph-growth:${hash}`;
+}
+
+export function growthDecisionRef(input: Parameters<GrowthProposer>[0], proposal: GrowthProposal, command?: GrowthCommand, approval?: string): string {
+  return growthApprovalRef({ graphId: input.graph.graphId, runId: input.runId, from: input.nodeId, outcome: input.outcome },
+    proposalGrowth(input, proposal), command, approval);
+}
+
+export function growthDecision(input: Parameters<GrowthProposer>[0], proposal: GrowthProposal, deps: GrowthDecisionDeps = {}, command?: GrowthCommand, approval?: string): DecisionEntry {
+  const ledger = deps.ledger ?? new DecisionLedger({ stateDir: deps.root ?? effectiveInstanceRoot() });
+  const ref = growthDecisionRef(input, proposal, command, approval);
+  const summary = `${proposal.node.nodeId} (${proposal.node.kind}, ${proposal.node.recipe}) → ${proposal.returnTo}`;
+  const commandDigest = command ? createHash('sha256').update(JSON.stringify(command)).digest('hex') : undefined;
+  return ledger.raiseOnce({ title: `${input.graph.graphId} / ${input.nodeId} / ${input.outcome} growth approval`, category: 'scope',
+    scqa: { s: `Graph ${input.graph.graphId}, node ${input.nodeId}, outcome ${input.outcome} has no mapped growth edge.`,
+      c: `Proposed node: ${summary}; command SHA-256: ${commandDigest ?? 'unresolved'}; reason: ${proposal.reason}`.slice(0, 240) },
+    options: [{ key: 'a', label: '승인', consequence: `Apply proposed node ${proposal.node.nodeId} and continue the run` },
+      { key: 'b', label: '거절', consequence: 'Keep the original fallback route' }],
+    recommendation: { skipped: true, reason: 'Side-effect recipe requires a human decision' },
+    ...(command || approval ? { pendingQuestion: [approval ? `Approval recipe: ${approval}` : undefined,
+      command ? `Proposed command (${commandDigest}):\n${command.command}` : undefined].filter(Boolean).join('\n') } : {}),
+    raisedBy: { agent: 'graph-runner' }, refs: [ref], dueAt: new Date((deps.now?.() ?? new Date()).getTime() + 8 * 60 * 60 * 1000).toISOString() }, ref);
+}
+
 export async function proposeGrowth(input: Parameters<GrowthProposer>[0],
-  proposer: GrowthProposer = createLLMGrowthProposer(), classifyRecipe?: (node: GraphNodeSpec) => GrowthRecipeEffect): Promise<{ ok: true; graph: GraphTemplateSpec; growth: GraphGrowth } | { ok: false; reason: string; park?: boolean }> {
+  proposer: GrowthProposer = createLLMGrowthProposer(), classifyRecipe?: (node: GraphNodeSpec) => GrowthRecipeEffect | GrowthRecipeClassification,
+  decisionDeps: GrowthDecisionDeps = {}): Promise<{ ok: true; graph: GraphTemplateSpec; growth: GraphGrowth } | { ok: false; reason: string; park?: boolean; growth?: GraphGrowth; decisionId?: string; decisionRef?: string; command?: GrowthCommand; approval?: string }> {
   let proposal: GrowthProposal | undefined;
   try { proposal = await proposer(input); }
   catch (error) { return { ok: false, reason: `proposer failed: ${String(error)}` }; }
   if (!proposal) return { ok: false, reason: 'no proposal' };
   if (!proposal.node || typeof proposal.reason !== 'string' || !proposal.reason.trim()) return { ok: false, reason: 'proposal requires a node and reason' };
-  const result = createGraphVariant({ template: input.graph, goal: `g_${input.runId.replace(/[^a-z0-9_-]/gi, '_')}`,
-    plan: { growth: { node: proposal.node, from: input.nodeId, outcome: input.outcome, returnTo: proposal.returnTo } } });
+  let result: ReturnType<typeof createGraphVariant>;
+  try {
+    result = createGraphVariant({ template: input.graph, goal: `g_${input.runId.replace(/[^a-z0-9_-]/gi, '_')}`,
+      plan: { growth: { node: proposal.node, from: input.nodeId, outcome: input.outcome, returnTo: proposal.returnTo } } });
+  } catch (error) { return { ok: false, reason: `growth rejected: ${String(error)}` }; }
   if (!result.ok) return { ok: false, reason: `growth rejected: ${JSON.stringify(result.rejections)}` };
   // Neither a recipe id nor its declared tools certify arbitrary executable code.
   // Only a trusted classification of the resolved recipe may authorize execution.
   let effect: GrowthRecipeEffect = 'unknown';
   if (proposal.node.recipe !== 'none') {
-    try { effect = classifyRecipe?.(proposal.node) ?? 'unknown'; }
-    catch { effect = 'unknown'; }
-    if (effect !== 'read-only') {
-      return { ok: false, park: true, reason: '사람 확인 필요: external or unclassified side-effect recipe' };
+    let command: GrowthCommand | undefined;
+    let approval: string | undefined;
+    try {
+      const classification = classifyRecipe?.(proposal.node) ?? 'unknown';
+      effect = typeof classification === 'string' ? classification : classification.effect;
+      command = typeof classification === 'string' ? undefined : classification.command;
+      approval = typeof classification === 'string' ? undefined : classification.approval;
+    } catch { effect = 'unknown'; }
+    if (effect !== 'read-only' || approval) {
+      const decision = growthDecision(input, proposal, decisionDeps, command, approval);
+      return { ok: false, park: true, reason: '사람 확인 필요: external or unclassified side-effect recipe',
+        decisionId: decision.id, decisionRef: growthDecisionRef(input, proposal, command, approval), command, approval,
+        growth: proposalGrowth(input, proposal) };
     }
   }
-  const edges: GraphEdgeSpec[] = [
-    { from: input.nodeId, on: 'outcome', map: { [input.outcome]: proposal.node.nodeId } },
-    { from: proposal.node.nodeId, to: proposal.returnTo as string },
-  ];
-  return { ok: true, graph: result.template, growth: { node: proposal.node, edges, reason: proposal.reason,
-    undo: { removeNode: proposal.node.nodeId, removeOutcome: { from: input.nodeId, outcome: input.outcome }, removeEdge: edges[1]! } } };
+  return { ok: true, graph: result.template, growth: proposalGrowth(input, proposal) };
 }

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

@@ -3,6 +3,7 @@ import { join } from 'node:path';
 import { parse as parseYaml } from 'yaml';
 import { debug } from '../debug/log.js';
 import { effectiveInstanceRoot } from '../instance/resolve.js';
+import { DecisionLedger } from '../decisions/decision-ledger.js';
 import { latestGraphRun, runGraph, type GraphRunOptions, type GraphRunState } from './runner.js';
 
 export interface GraphTickOptions {
@@ -35,10 +36,16 @@ export async function graphTick(path: string, options: GraphTickOptions = {}): P
     acquired = true;
     await options.deps?.notify?.();
     const latest = latestGraphRun(graphId, root);
+    const growthCard = latest?.growthPark
+      ? (options.deps?.growthDecision?.list ?? ((filters: { status: 'all' }) => new DecisionLedger({ stateDir: root }).list(filters)))({ status: 'all' })
+        .find(entry => entry.id === latest.growthPark?.decisionId && entry.refs?.includes(latest.growthPark.decisionRef))
+      : undefined;
+    const growthDecided = growthCard?.status === 'decided' && growthCard.decidedBy?.kind === 'human' &&
+      (growthCard.choice === 'a' || growthCard.choice === 'b');
     let result: GraphTickResult;
-    if (latest?.status === 'awaiting-approval' && !latest.pending?.decision) {
+    if (latest?.status === 'awaiting-approval' && !latest.pending?.decision && !growthDecided) {
       result = { action: 'waiting', runId: latest.runId, status: latest.status };
-    } else if (latest?.status === 'running' || (latest?.status === 'awaiting-approval' && latest.pending?.decision)) {
+    } else if (latest?.status === 'running' || (latest?.status === 'awaiting-approval' && (latest.pending?.decision || growthDecided))) {
       const state = await runGraph(path, { resumeRunId: latest.runId, deps: { ...options.deps, root } });
       result = { action: 'resumed', runId: state.runId, status: state.status };
     } else if (options.startIfIdle) {

package/src/graph-runner/runner.ts

@@ -11,7 +11,8 @@ import { listInstalledPlugins } from '../plugins/install/plugin-install.js';
 import { credentialStatus, pluginEnv } from '../plugins/install/plugin-credentials.js';
 import { effectiveInstanceRoot } from '../instance/resolve.js';
 import { loadNodeCatalog } from '../self-implement/graph-catalog.js';
-import { proposeGrowth, type GraphGrowth, type GrowthProposer, type GrowthRecipeEffect } from './graph-grow.js';
+import { growthApprovalRef, proposeGrowth, type GraphGrowth, type GrowthProposer, type GrowthRecipeEffect, type GrowthDecisionDeps, type GrowthCommand } from './graph-grow.js';
+import { DecisionLedger, type DecisionEntry } from '../decisions/decision-ledger.js';
 import { createLLMGrowthProposer } from './graph-grow-llm.js';
 import { parseGraphTemplateYaml, type GraphEdgeSpec, type GraphNodeSpec, type GraphTemplateSpec } from '../self-implement/graph-yaml.js';
 import { createGraphVariant, type GraphVariantPlan } from '../self-implement/graph-variant.js';
@@ -43,7 +44,7 @@ export interface GraphRunState {
   variant?: { overlayId: string; goal: string; plan: GraphVariantPlan };
   growth?: GraphGrowth[];
   growthRejections?: Array<{ from: string; outcome: string; reason: string }>;
-  growthPark?: { from: string; outcome: string; reason: string };
+  growthPark?: { from: string; outcome: string; reason: string; decisionId: string; decisionRef: string; growth: GraphGrowth; command?: GrowthCommand; approval?: string };
   resume?: { from: string; at: string; previousStatus: GraphRunState['status']; graph?: 'snapshot' | 'current' };
   executed: number;
   dryRun: boolean;
@@ -59,7 +60,7 @@ export interface GraphRunOptions {
   resumeGraphId?: string;
   fromNodeId?: string;
   useCurrentGraph?: 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 };
+  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[] } };
 }
 
 function safeSegment(value: string): string {
@@ -69,14 +70,17 @@ function safeSegment(value: string): string {
   return value;
 }
 
-type CommandRecipe = { command: string; timeout_ms?: number };
-type Recipe = CommandRecipe | { approval: string };
+type CommandRecipe = { command: string; dry_run_command?: string; timeout_ms?: number };
+type Recipe = CommandRecipe | ({ approval: string } & Partial<CommandRecipe>);
 
 /** 접두 없는 recipe 가 카탈로그 역할이고, 그래프 옆 recipes.yaml 에 같은 키의 `{ command }` 가 있을 때만 cmd 처럼 실행한다. */
 function roleCommand(recipe: string, recipes: Record<string, Recipe>, catalogRoles: ReadonlySet<string>): CommandRecipe | undefined {
   if (!recipe || recipe === 'none' || recipe.includes(':') || !catalogRoles.has(recipe)) return undefined;
   const entry = recipes[recipe];
-  return entry && 'command' in entry ? entry : undefined;
+  // An entry that carries an approval only runs through `approval:` — never as a bare command.
+  return entry && !('approval' in entry) && typeof entry.command === 'string' ? { command: entry.command,
+    ...(entry.dry_run_command ? { dry_run_command: entry.dry_run_command } : {}),
+    ...(entry.timeout_ms ? { timeout_ms: entry.timeout_ms } : {}) } : undefined;
 }
 
 function resolveNodeRecipe(node: GraphNodeSpec, recipes: Record<string, Recipe>, catalogRoles: ReadonlySet<string>): { command?: CommandRecipe; approval?: { approval: string } } {
@@ -84,12 +88,17 @@ function resolveNodeRecipe(node: GraphNodeSpec, recipes: Record<string, Recipe>,
   if (node.recipe.startsWith('cmd:')) {
     const id = node.recipe.slice(4);
     const entry = recipes[id];
-    return entry && 'command' in entry ? { command: entry } : {};
+    return entry && !('approval' in entry) && typeof entry.command === 'string' ? { command: { command: entry.command,
+      ...(entry.dry_run_command ? { dry_run_command: entry.dry_run_command } : {}),
+      ...(entry.timeout_ms ? { timeout_ms: entry.timeout_ms } : {}) } } : {};
   }
   if (node.recipe.startsWith('approval:')) {
     const id = node.recipe.slice(9);
     const entry = recipes[id];
-    return entry && 'approval' in entry ? { approval: entry } : {};
+    return entry && 'approval' in entry ? { approval: entry,
+      ...('command' in entry && typeof entry.command === 'string' ? { command: { command: entry.command,
+        ...(entry.dry_run_command ? { dry_run_command: entry.dry_run_command } : {}),
+        ...(entry.timeout_ms ? { timeout_ms: entry.timeout_ms } : {}) } } : {}) } : {};
   }
   const command = roleCommand(node.recipe, recipes, catalogRoles);
   return command ? { command } : {};
@@ -113,14 +122,25 @@ function recipesFor(path: string, recipeSource: string): Record<string, Recipe>
     if (!raw || typeof raw !== 'object' || Array.isArray(raw)) throw new Error(`invalid recipe: ${id}`);
     const item = raw as Record<string, unknown>;
     if (Object.hasOwn(item, 'approval')) {
-      if (typeof item.approval !== 'string' || !item.approval.trim() || Object.keys(item).length !== 1) throw new Error(`invalid recipe: ${id}`);
-      recipes[id] = { approval: item.approval };
+      if (typeof item.approval !== 'string' || !item.approval.trim() ||
+        (item.command !== undefined && (typeof item.command !== 'string' || !item.command.trim())) ||
+        (item.timeout_ms !== undefined && (!Number.isSafeInteger(item.timeout_ms) || (item.timeout_ms as number) <= 0)) ||
+        (item.dry_run_command !== undefined && (typeof item.dry_run_command !== 'string' || !item.dry_run_command.trim())) ||
+        (item.command === undefined && (item.timeout_ms !== undefined || item.dry_run_command !== undefined)) ||
+        Object.keys(item).some(key => !['approval', 'command', 'dry_run_command', 'timeout_ms'].includes(key))) throw new Error(`invalid recipe: ${id}`);
+      recipes[id] = { approval: item.approval,
+        ...(item.command === undefined ? {} : { command: item.command as string }),
+        ...(item.dry_run_command === undefined ? {} : { dry_run_command: item.dry_run_command as string }),
+        ...(item.timeout_ms === undefined ? {} : { timeout_ms: item.timeout_ms as number }) };
     } else {
       if (typeof item.command !== 'string' || !item.command.trim() ||
-        (item.timeout_ms !== undefined && (!Number.isSafeInteger(item.timeout_ms) || (item.timeout_ms as number) <= 0))) {
+        (item.timeout_ms !== undefined && (!Number.isSafeInteger(item.timeout_ms) || (item.timeout_ms as number) <= 0)) ||
+        (item.dry_run_command !== undefined && (typeof item.dry_run_command !== 'string' || !item.dry_run_command.trim()))) {
         throw new Error(`invalid recipe: ${id}`);
       }
-      recipes[id] = { command: item.command, ...(item.timeout_ms === undefined ? {} : { timeout_ms: item.timeout_ms as number }) };
+      recipes[id] = { command: item.command,
+        ...(item.dry_run_command === undefined ? {} : { dry_run_command: item.dry_run_command as string }),
+        ...(item.timeout_ms === undefined ? {} : { timeout_ms: item.timeout_ms as number }) };
     }
   }
   return recipes;
@@ -490,8 +510,51 @@ export async function runGraph(path: string, options: GraphRunOptions = {}): Pro
     // Persist the restart boundary before executing it, so previous outputs remain durable.
     persistOwnedRun(state, saved!, true);
   }
+  let resumedGrowth = false;
   if (options.resumeRunId && state.growthPark) {
-    throw new Error(`growth is parked for human confirmation: ${graphId}/${runId}`);
+    if (state.graphId !== graphId || state.runId !== runId || (graphMode === 'current' && state.sourceHash !== approvalSourceHash)) {
+      throw new Error(`growth source changed since run was paused: ${graphId}/${runId}`);
+    }
+    const parked = state.growthPark;
+    const decision = (options.deps?.growthDecision?.list?.({ status: 'all' }) ??
+      new DecisionLedger({ stateDir: root }).list({ status: 'all' }))
+      .find(entry => entry.id === parked.decisionId && entry.refs?.includes(parked.decisionRef));
+    if (!decision || decision.status !== 'decided' || decision.decidedBy?.kind !== 'human' ||
+        (decision.choice !== 'a' && decision.choice !== 'b')) {
+      throw new Error(`growth is parked for human confirmation: ${graphId}/${runId}`);
+    }
+    if (typeof parked.decisionRef !== 'string' ||
+        growthApprovalRef({ graphId, runId, from: parked.from, outcome: parked.outcome },
+          parked.growth, parked.command, parked.approval) !== parked.decisionRef) {
+      throw new Error(`growth approval target changed since card was raised: ${graphId}/${runId}`);
+    }
+    if (state.status !== 'awaiting-approval' || state.dryRun || state.path.at(-1) !== parked.from ||
+        state.path.length !== state.nodes.length || state.nodes.at(-1)?.nodeId !== parked.from ||
+        state.pending?.nodeId !== parked.from || state.growthRejections?.at(-1)?.from !== parked.from ||
+        state.growthRejections.at(-1)?.outcome !== parked.outcome ||
+        parked.growth.undo.removeOutcome.from !== parked.from || parked.growth.undo.removeOutcome.outcome !== parked.outcome) {
+      throw new Error(`invalid parked growth: ${graphId}/${runId}`);
+    }
+    if (decision.choice === 'a') {
+      const currentCommand = resolveNodeRecipe(parked.growth.node, recipes, catalogRoles).command;
+      const currentApproval = resolveNodeRecipe(parked.growth.node, recipes, catalogRoles).approval?.approval;
+      // The approved target is the (approval, command) pair as raised — a command appearing, vanishing or changing all fail.
+      if (parked.growth.node.recipe !== 'none' &&
+          (currentApproval !== parked.approval ||
+            JSON.stringify(currentCommand ?? null) !== JSON.stringify(parked.command ?? null) ||
+            (parked.approval === undefined && !parked.command))) {
+        throw new Error(`growth command changed since approval: ${graphId}/${runId}`);
+      }
+      graph = withGrowth(graph, [parked.growth]);
+      state.growth ??= [];
+      state.growth.push(parked.growth);
+      state.growthRejections!.pop();
+    }
+    resumedGrowth = true;
+    delete state.pending;
+    delete state.growthPark;
+    state.status = 'running';
+    persistOwnedRun(state, saved!);
   }
   if (options.resumeRunId && state.status === 'running' && state.pending) {
     throw new Error(`run is not awaiting approval: ${graphId}/${runId}`);
@@ -590,7 +653,7 @@ export async function runGraph(path: string, options: GraphRunOptions = {}): Pro
     let exit: number | null = null;
     let error: string | undefined;
     let output: unknown;
-    if (command && !state.dryRun && !resumingCompleted) {
+    if (command && (!approval || state.dryRun || ok) && (!state.dryRun || command.dry_run_command) && !resumingCompleted) {
       const outputs: Record<string, unknown> = Object.create(null);
       // 구조 산출(마지막 JSON 줄)이 있으면 그것을, 없으면 원문을 준다 — 다음 노드가 판단을 «값»으로 받는다.
       for (const previous of state.nodes) outputs[previous.nodeId] = lastJsonObject(previous.output) ?? previous.output ?? null;
@@ -635,9 +698,10 @@ export async function runGraph(path: string, options: GraphRunOptions = {}): Pro
         debug.log('graph-runner', 'child-universe-pinned', { graphId, runId, node: current, configDir: env.ELANOUS_CONFIG_DIR, stateDir: env.ELANOUS_STATE_DIR });
       }
       env.ELANOUS_GRAPH_CONTEXT = contextPath;
+      env.ELANOUS_GRAPH_DRY_RUN = state.dryRun ? '1' : '0';
       env.ELANOUS_GRAPH_DIR = dirname(resolve(path));
       const ctx = { arguments: '', artifactsDir: dirname(statePath), outputs: {}, resolvedProvider: undefined, resolvedModel: undefined, toolPolicy: {}, env } as NodeExecContext;
-      const result = await executeBashNode({ id: current, type: 'bash', bash: command.command, ...(command.timeout_ms ? { idle_timeout: command.timeout_ms } : {}) } as BashNode, ctx, { runBash } as WorkflowDeps);
+      const result = await executeBashNode({ id: current, type: 'bash', bash: state.dryRun ? command.dry_run_command! : command.command, ...(command.timeout_ms ? { idle_timeout: command.timeout_ms } : {}) } as BashNode, ctx, { runBash } as WorkflowDeps);
       output = result.output;
       ok = result.ok;
       exit = code;
@@ -654,14 +718,14 @@ export async function runGraph(path: string, options: GraphRunOptions = {}): Pro
       if (approval && !state.dryRun && !command) {
         output = JSON.stringify({ outcome: ok ? 'approved' : 'rejected', ...(state.pending?.decidedBy === undefined ? {} : { decidedBy: state.pending.decidedBy }), decidedAt: state.pending?.decidedAt ?? null });
       }
-      state.nodes.push({ nodeId: current, ok, exit, executed: !!command && !state.dryRun, ...((command || approval) && !state.dryRun && output !== undefined ? { output } : {}), ...(error ? { error } : {}),
+      state.nodes.push({ nodeId: current, ok, exit, executed: !!command && (!state.dryRun || !!command.dry_run_command), ...((command || approval) && (!state.dryRun || !!command?.dry_run_command) && output !== undefined ? { output } : {}), ...(error ? { error } : {}),
         ...(approval && state.pending ? { ...(state.pending.decidedBy === undefined ? {} : { decidedBy: state.pending.decidedBy }), decidedAt: state.pending.decidedAt } : {}) });
     }
     if (approval) {
       delete state.pending;
       delete state.approvalSourceHash;
     }
-    const reported = command && !state.dryRun ? lastJsonObject(resumingCompleted ? completed?.output : output)?.outcome : undefined;
+    const reported = command && (!state.dryRun || command.dry_run_command) ? lastJsonObject(resumingCompleted ? completed?.output : output)?.outcome : undefined;
     const namedOutcome = typeof reported === 'string' ? reported : undefined;
     const seconds = Number(((performance.now() - startedAt) / 1000).toFixed(2));
     console.error(`[graph] ${current} ${ok ? 'ok' : 'fail'} (${seconds.toFixed(2)}s)`);
@@ -677,7 +741,7 @@ export async function runGraph(path: string, options: GraphRunOptions = {}): Pro
     }
     const fromNodeId = current;
     const edge = graph.edges.find((candidate) => candidate.from === current);
-    if (document.grow === 'on' && !state.dryRun && namedOutcome !== undefined &&
+    if (!resumedGrowth && document.grow === 'on' && !state.dryRun && namedOutcome !== undefined &&
         edge?.on === 'outcome' && edge.map && !Object.hasOwn(edge.map, namedOutcome) &&
         !state.growth?.some((item) => item.undo.removeOutcome.from === current && item.undo.removeOutcome.outcome === namedOutcome) &&
         !state.growthRejections?.some((item) => item.from === current && item.outcome === namedOutcome)) {
@@ -685,9 +749,10 @@ export async function runGraph(path: string, options: GraphRunOptions = {}): Pro
         : await proposeGrowth({ graph, nodeId: current, outcome: namedOutcome, runId, output: state.nodes.at(-1)?.output },
           options.deps?.growthProposer ?? createLLMGrowthProposer(options.deps?.growthLLM), (candidate) => {
             const resolved = resolveNodeRecipe(candidate, recipes, catalogRoles);
-            if (resolved.approval || (!resolved.command && candidate.recipe !== 'none')) return 'unknown';
-            return options.deps?.classifyGrowthRecipe?.(candidate, { command: resolved.command?.command }) ?? 'unknown';
-          });
+            if (!resolved.command && !resolved.approval && candidate.recipe !== 'none') return 'unknown';
+            return { effect: resolved.approval ? 'unknown' : options.deps?.classifyGrowthRecipe?.(candidate, { command: resolved.command?.command }) ?? 'unknown',
+              command: resolved.command, approval: resolved.approval?.approval };
+          }, { ...options.deps?.growthDecision, root });
       if (result.ok) {
         graph = result.graph;
         state.growth ??= [];
@@ -699,17 +764,20 @@ export async function runGraph(path: string, options: GraphRunOptions = {}): Pro
       } else {
         state.growthRejections ??= [];
         state.growthRejections.push({ from: current, outcome: namedOutcome, reason: result.reason });
-        if (result.park) {
+        if (result.park && result.growth && result.decisionId && result.decisionRef) {
           state.status = 'awaiting-approval';
           state.pending = { nodeId: current, message: result.reason, since: new Date().toISOString() };
-          state.growthPark = { from: current, outcome: namedOutcome, reason: result.reason };
+          state.growthPark = { from: current, outcome: namedOutcome, reason: result.reason,
+            growth: result.growth, decisionId: result.decisionId, decisionRef: result.decisionRef,
+            ...(result.command ? { command: result.command } : {}), ...(result.approval ? { approval: result.approval } : {}) };
           persist();
           break;
         }
       }
       persist();
     }
-    current = nextNode(graph.edges, current, state.dryRun ? 'ok' : ok ? 'ok' : 'fail', state.dryRun ? undefined : namedOutcome);
+    current = nextNode(graph.edges, current, state.dryRun && !command?.dry_run_command ? 'ok' : ok ? 'ok' : 'fail', namedOutcome);
+    resumedGrowth = false;
     if (current !== undefined) publishInsideEvent({ kind: 'edge', graphId, runId, from: fromNodeId, to: current });
     if (current === undefined) {
       state.status = 'failed';