elanous 0.2.12 → 0.2.13

package/src/graph-kinds/registry.ts

@@ -23,11 +23,11 @@ export interface NodeKindEntry {
 export const HARNESS_CORE_KINDS = ['agent', 'gate', 'git', 'judge', 'observe', 'hitl', 'subgraph'] as const;
 
 // Workflow validation, the palette, and executor variant labels read the same keys.
-export const WORKFLOW_CORE_KINDS = ['prompt', 'bash', 'skill', 'cft', 'approval', 'if', 'switch', 'iteration', 'classify', 'extract', 'set', 'filter', 'template', 'http', 'showroom', 'task', 'scheduleTrigger', 'webhookTrigger', 'discordTrigger', 'telegramTrigger', 'manualTrigger', 'chatTrigger', 'subworkflow'] as const;
+export const WORKFLOW_CORE_KINDS = ['prompt', 'bash', 'skill', 'cft', 'approval', 'if', 'switch', 'iteration', 'classify', 'extract', 'set', 'filter', 'template', 'http', 'showroom', 'task', 'scheduleTrigger', 'webhookTrigger', 'discordTrigger', 'telegramTrigger', 'manualTrigger', 'chatTrigger', 'subworkflow', 'knowledge'] as const;
 
 const descriptions: Record<GraphKind, readonly string[]> = {
   harness: ['Run an agent', 'Check an execution gate', 'Perform git operations', 'Judge an outcome', 'Observe a result', 'Request human input', 'Run a child graph'],
-  workflow: ['Run an LLM prompt', 'Run a shell command', 'Invoke a skill', 'Invoke a CFT method', 'Request approval', 'Branch on a condition', 'Select a case', 'Iterate items', 'Classify input', 'Extract structured data', 'Assign variables', 'Filter items', 'Render a template', 'Make an HTTP request', 'Run a showroom', 'Create a task', 'Start on a schedule', 'Start on a webhook', 'Start on Discord', 'Start on Telegram', 'Start manually', 'Start on chat', 'Call another workflow'],
+  workflow: ['Run an LLM prompt', 'Run a shell command', 'Invoke a skill', 'Invoke a CFT method', 'Request approval', 'Branch on a condition', 'Select a case', 'Iterate items', 'Classify input', 'Extract structured data', 'Assign variables', 'Filter items', 'Render a template', 'Make an HTTP request', 'Run a showroom', 'Create a task', 'Start on a schedule', 'Start on a webhook', 'Start on Discord', 'Start on Telegram', 'Start manually', 'Start on chat', 'Call another workflow', 'Search the vault for context'],
 };
 
 const kinds = new Map<GraphKind, Map<string, NodeKindEntry>>();

package/src/graph-runner/graph-approval-card.ts

@@ -26,7 +26,7 @@ export function raiseApprovalCard(state: GraphRunState, pending: Pending, deps:
   const nodeId = pending.nodeId;
   const identity = { graphId: state.graphId, runId: state.runId, nodeId };
   const visit = state.path.filter(node => node === nodeId).length;
-  if (state.dryRun || state.status !== 'awaiting-approval' || state.pending?.nodeId !== nodeId ||
+  if (state.dryRun || state.growthPark || state.status !== 'awaiting-approval' || state.pending?.nodeId !== nodeId ||
       state.pending.decision || state.path.at(-1) !== nodeId || visit < 1 ||
       existsSync(`${join(root, 'graph-runs', state.graphId, `${state.runId}.json`)}.${state.path.length}.decision.json`)) {
     observation('skipped', identity);
@@ -88,7 +88,7 @@ function applyOne(entry: DecisionEntry, identity: { graphId: string; runId: stri
     observation('skipped', identity, entry.id, entry.choice);
     return false;
   }
-  if (state.graphId !== graphId || state.runId !== runId || state.dryRun || state.status !== 'awaiting-approval' ||
+  if (state.graphId !== graphId || state.runId !== runId || state.dryRun || state.growthPark || state.status !== 'awaiting-approval' ||
       !state.pending || state.pending.nodeId !== nodeId || state.pending.decision || state.path.at(-1) !== nodeId ||
       state.path.filter(node => node === nodeId).length !== visit ||
       existsSync(`${statePath}.${state.path.length}.decision.json`)) {

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,8 +23,52 @@ 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)}` }; }
@@ -35,16 +84,20 @@ export async function proposeGrowth(input: Parameters<GrowthProposer>[0],
   // 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 {
@@ -70,13 +71,16 @@ function safeSegment(value: string): string {
 }
 
 type CommandRecipe = { command: string; dry_run_command?: string; timeout_ms?: number };
-type Recipe = CommandRecipe | { approval: string };
+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,8 +122,16 @@ 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)) ||
@@ -493,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}`);
@@ -593,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 || command.dry_run_command) && !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;
@@ -681,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)) {
@@ -689,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 ??= [];
@@ -703,10 +764,12 @@ 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;
         }
@@ -714,6 +777,7 @@ export async function runGraph(path: string, options: GraphRunOptions = {}): Pro
       persist();
     }
     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';

package/src/harness/harness-cli-command.ts

@@ -29,6 +29,7 @@ import { DEFAULT_FALLBACK_CHAIN } from '../oauth/fallback-chain.js';
 import { installDeliverableVerifyCliCommand, type InstallDeliverableVerifyCliDeps } from './deliverable-verify-cli.js';
 import { getUserConfig } from '../user-config.js';
 import { installHarnessCliSinkHook } from './harness-cli-sink.js';
+import { addHarnessQueue, listHarnessQueue, reconcileHarnessQueue, removeHarnessQueue, tickHarnessQueue, type HarnessQueueDeps } from './harness-queue.js';
 import { resolveHarnessSubstrate, type ResolvedHarnessSubstrate } from './harness-substrate-default.js';
 import { runHarnessPlanRfc } from './harness-plan-rfc.js';
 import { classifyGarbage, isGarbageProcessTarget, type GarbageProcess } from './process-garbage.js';
@@ -1471,7 +1472,7 @@ export function readProcessOwnership(
   }
 }
 
-function defaultListHarnessProcesses(): HarnessProcessListObservation {
+export function defaultListHarnessProcesses(): HarnessProcessListObservation {
   let out: string;
   try {
     out = execFileSync('ps', ['-axo', 'pid=,ppid=,pcpu=,etime=,command='], {
@@ -2104,6 +2105,7 @@ export interface HarnessCliCommandDeps {
   deliverableVerify?: InstallDeliverableVerifyCliDeps;
   processObservation?: HarnessProcessObservationDeps;
   draftSweep?: HarnessDraftSweepDeps;
+  queue?: HarnessQueueDeps;
   ask?: HarnessAskHandler;
   say?: HarnessSayHandler;
   /** Observe-only Pod host dispatch seam. */
@@ -2156,6 +2158,30 @@ export function installHarnessCliCommand(program: Command, deps: HarnessCliComma
   installHarnessProcessObservationCommand(harnessCmd, deps.processObservation);
   installHarnessBudgetCommand(harnessCmd);
   installHarnessDraftSweepCommand(harnessCmd, deps.draftSweep);
+  const queue = harnessCmd.command('queue').description('자리별 영속 발사 대기열');
+  const queueDeps = deps.queue ?? {};
+  const queueAction = (action: () => Promise<void>): Promise<void> => runInjectedHarnessHandler(action);
+  queue.command('add').requiredOption('--seat <seat>', 'OP|TC|MK|UX')
+    .option('--say <sentence>', '원문 문장').option('--ask <goal-path>', '골 문서 경로')
+    .option('--hold', '자동 병합 금지').option('--heavy', 'Pod high 메모리')
+    .action((opts: { seat: string; say?: string; ask?: string; hold?: boolean; heavy?: boolean }) => queueAction(async () => {
+      const row = await addHarnessQueue(opts, queueDeps);
+      console.log(`${row.id} ${row.seat} ${row.kind} queued`);
+    }));
+  queue.command('list').description('대기·발사 원장 조회').action(() => queueAction(async () => {
+    for (const row of listHarnessQueue(queueDeps)) console.log(`${row.id} ${row.seat} ${row.status} ${row.kind} ${row.input}`);
+  }));
+  queue.command('remove <id>').description('대기 중 또는 종료 확인된 항목 제거').action((id: string) => queueAction(async () => {
+    if (!await removeHarnessQueue(id, queueDeps)) throw new Error(`queue item active or not found: ${id}`);
+    console.log(`${id} removed`);
+  }));
+  queue.command('reconcile <id>').description('불확정 발사를 확인하고 종료 또는 미발사 증거가 있으면 예약 해소').action((id: string) => queueAction(async () => {
+    console.log(`${id} ${await reconcileHarnessQueue(id, queueDeps)}`);
+  }));
+  queue.command('tick').description('맨 앞 한 건의 자리 몫과 Pod 풀 여유를 확인하고 발사').action(() => queueAction(async () => {
+    const result = await tickHarnessQueue(queueDeps);
+    console.log(`${result.outcome}${result.item ? ` ${result.item.id}` : ''}: ${result.reason}`);
+  }));
 
   const ask = deps.ask;
   if (ask) {

package/src/harness/harness-queue-child.ts

@@ -0,0 +1,37 @@
+import { spawn } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
+import { renameSync, writeFileSync } from 'node:fs';
+
+/** Only a confirmed terminal observation allows reconciliation to release an uncertain launch. */
+export function writeHarnessQueueReceipt(receiptPath: string, state: 'started' | 'finished' | 'not-started'): void {
+  const temp = `${receiptPath}.${randomUUID()}.tmp`;
+  writeFileSync(temp, JSON.stringify({ state, at: new Date().toISOString() }), { flag: 'wx', mode: 0o600 });
+  renameSync(temp, receiptPath);
+}
+
+export async function runHarnessQueueChild(
+  receiptPath: string, command: string, args: string[],
+  start: typeof spawn = spawn,
+): Promise<number> {
+  const record = (state: 'started' | 'finished' | 'not-started') => writeHarnessQueueReceipt(receiptPath, state);
+  let child: ReturnType<typeof spawn>;
+  try { child = start(process.execPath, [command, ...args], { stdio: 'inherit', env: process.env }); }
+  catch { record('not-started'); return 1; }
+  return await new Promise<number>((done) => {
+    let started = false;
+    child.once('spawn', () => {
+      started = true;
+      record('started');
+      child.once('exit', (code) => { record('finished'); done(code ?? 1); });
+    });
+    child.once('error', () => {
+      if (!started) { record('not-started'); done(1); }
+    });
+  });
+}
+
+if (import.meta.main) {
+  const [receiptPath, command, ...args] = process.argv.slice(2);
+  if (!receiptPath || !command) throw new Error('queue child requires receipt path and command');
+  process.exitCode = await runHarnessQueueChild(receiptPath, command, args);
+}