elanous 0.2.38 → 0.2.40

package/src/execution-loop/launch-gate.ts

@@ -1,6 +1,9 @@
 import { createHash } from 'node:crypto';
-import { readFileSync } from 'node:fs';
+import { closeSync, constants, fstatSync, lstatSync, mkdirSync, openSync, readdirSync, readFileSync, writeSync } from 'node:fs';
+import { join, resolve } from 'node:path';
 import { debug } from '../debug/log.js';
+import { effectiveInstanceRoot } from '../instance/resolve.js';
+import { assertLedgerPathPolicy } from '../harness/launch-utterance-ledger.js';
 import { extractVerbatimOriginalAsk } from '../self-implement/goal-author.js';
 import { loadRunLedger } from '../self-implement/run-ledger.js';
 import { queryRunningRuns, type QueriedRunningRunsResult } from '../self-implement/running-runs.js';
@@ -252,6 +255,8 @@ export interface PreLaunchGateInput {
 
 export interface PreLaunchGateDeps extends ActiveRunsForGoalDeps {
   activeRuns?: (goalId: string) => ActiveRunsForGoal;
+  /** LAUNCH-SINGLE-DOOR-1C — 주입 우선 단일문: 시험 우주가 격리 루트의 문을 끼워 생산 배선을 그대로 검증한다. */
+  launchDoor?: LaunchRequestDoor;
 }
 
 export interface PreLaunchGateDecision {
@@ -279,3 +284,203 @@ function decidePreLaunch(input: PreLaunchGateInput, deps: PreLaunchGateDeps): Pr
   }
   return { action: 'proceed', sameGoalActiveRuns, budget, reason: sameGoalActiveRuns === 'unknown' ? 'active runs unknown' : input.forceLaunch && sameGoalActiveRuns.length > 0 ? 'duplicate overridden by force-launch' : 'no confirmed duplicate' };
 }
+
+// ─────────────────────────────────────────────────────────────────────────────────────
+// LAUNCH-SINGLE-DOOR-1C — 발사 요청의 단일 문.
+// ─────────────────────────────────────────────────────────────────────────────────────
+
+/** Env contract: hand 가 소비한 requestId 를 자식 say 가 물려받아 같은 문을 다시 두드리지 않게 한다(한 번만 상속). */
+export const LAUNCH_DOOR_RECEIPT_ENV = 'ELANOUS_LAUNCH_DOOR_RECEIPT';
+
+/** append 전용 요청 원장의 행 종류 — 요청(중복 포함)·소비·거절·강제·실패·단일문 사용 불가 관측. */
+export type LaunchRequestLedgerEvent = 'requested' | 'consumed' | 'refused-duplicate' | 'forced-duplicate' | 'launch-failed' | 'door-unavailable';
+
+/** append 전용 요청 원장의 한 행 — 행은 지우거나 고치지 않는다(관측 전용). */
+export interface LaunchRequestLedgerRow {
+  readonly event: LaunchRequestLedgerEvent;
+  readonly requestId: string;
+  readonly at: string;
+  readonly source?: string;
+  readonly receiptId?: string;
+  readonly reason?: string;
+}
+
+/** requestId 단위 소비 영수증 — 최초 1회만 발급된다(O_EXCL 파일이 곧 영수증이다). */
+export interface LaunchRequestReceipt {
+  readonly requestId: string;
+  readonly receiptId: string;
+  readonly at: string;
+  readonly source?: string;
+}
+
+/** `consume` 의 답 — `refused` 는 기존 영수증을 읽어 사유와 함께 거절한 것이다. */
+export type LaunchRequestConsumption =
+  | { readonly status: 'consumed'; readonly requestId: string; readonly receiptId: string; readonly receiptAt: string; readonly inherited?: true }
+  | { readonly status: 'forced'; readonly requestId: string; readonly receiptId: string | null; readonly receiptAt: string | null; readonly reason: string }
+  | { readonly status: 'refused'; readonly requestId: string; readonly receiptId: string | null; readonly receiptAt: string | null; readonly reason: string }
+  | { readonly status: 'unavailable'; readonly requestId: string; readonly reason: string };
+
+/** 발사 요청의 단일 문 — 원장 append · 단일 소비 · 실패 기록 · 원장 조회. */
+export interface LaunchRequestDoor {
+  /** 요청 한 건을 원장에 append 하고 그 requestId 를 돌려준다(중복 재요청도 매번 append 된다). */
+  requestId(ask: string): string;
+  /** requestId 단위 단일 소비 — 영수증은 최초 1회만 발급된다(두 번째는 기존 영수증과 사유로 거절). */
+  consume(requestId: string, opts?: { readonly force?: boolean; readonly inheritedReceipt?: string }): LaunchRequestConsumption;
+  /** 발사 실패 사유를 원장에 append 한다(관측 — 발사를 막지 않는다). */
+  fail(requestId: string, reason: string): void;
+  /** 원장 조회 — 중복 거절·실패·재시도 사유를 읽는다(인자를 주면 그 requestId 의 행만). */
+  rows(requestId?: string): readonly LaunchRequestLedgerRow[];
+}
+
+/** 단일문 deps — 원장 뿌리(기본 = 이 우주의 실효 인스턴스 루트)·시계·요청 출처 표지. */
+export interface LaunchRequestDoorDeps {
+  readonly root?: string;
+  readonly now?: () => Date;
+  readonly source?: string;
+}
+
+const LAUNCH_REQUEST_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
+const LAUNCH_REQUEST_DATE_FILE = /^\d{4}-\d{2}-\d{2}\.jsonl$/;
+
+function launchRequestLedgerDir(root: string): string {
+  return join(resolve(root), 'launch-requests');
+}
+
+/** 단일문을 연다 — 문 자체는 상태를 갖지 않고, 원장·영수증은 이 우주의 인스턴스 루트 아래 파일로 남는다. */
+export function openLaunchRequestDoor(deps: LaunchRequestDoorDeps = {}): LaunchRequestDoor {
+  const dir = launchRequestLedgerDir(deps.root ?? effectiveInstanceRoot());
+  const receiptsDir = join(dir, 'receipts');
+  const now = deps.now ?? (() => new Date());
+  const source = deps.source;
+
+  const observe = (event: string, data: Record<string, unknown>): void => {
+    try { debug.log('execution-loop.launch-gate', event, data, { level: 'warn' }); } catch { /* 관측은 fail-soft */ }
+  };
+
+  const appendRow = (row: LaunchRequestLedgerRow): boolean => {
+    try {
+      assertLedgerPathPolicy(dir);
+      mkdirSync(dir, { recursive: true, mode: 0o700 });
+      assertLedgerPathPolicy(dir);
+      if (!lstatSync(dir).isDirectory()) throw new Error(`launch request ledger dir is not a directory: ${dir}`);
+      const file = join(dir, `${row.at.slice(0, 10)}.jsonl`);
+      const fd = openSync(file, constants.O_WRONLY | constants.O_APPEND | constants.O_CREAT | constants.O_NOFOLLOW, 0o600);
+      try {
+        if (!fstatSync(fd).isFile()) throw new Error(`launch request ledger file is not a regular file: ${file}`);
+        writeSync(fd, `${JSON.stringify(row)}\n`);
+      } finally { closeSync(fd); }
+      return true;
+    } catch (error) {
+      observe('request-ledger-unwritten', { event: row.event, requestId: row.requestId, reason: error instanceof Error ? error.message : String(error) });
+      return false;
+    }
+  };
+
+  const readReceipt = (requestId: string): LaunchRequestReceipt | null => {
+    try {
+      const fd = openSync(join(receiptsDir, `${requestId}.json`), constants.O_RDONLY | constants.O_NOFOLLOW);
+      try {
+        if (!fstatSync(fd).isFile()) return null;
+        const parsed = JSON.parse(readFileSync(fd, 'utf8')) as LaunchRequestReceipt;
+        return parsed && typeof parsed === 'object' && parsed.requestId === requestId
+          && typeof parsed.receiptId === 'string' && typeof parsed.at === 'string' ? parsed : null;
+      } finally { closeSync(fd); }
+    } catch { return null; }
+  };
+
+  const requestId = (ask: string): string => {
+    const id = launchRequestId(ask);
+    appendRow({ event: 'requested', requestId: id, at: now().toISOString(), ...(source ? { source } : {}) });
+    return id;
+  };
+
+  const consume = (id: string, opts: { readonly force?: boolean; readonly inheritedReceipt?: string } = {}): LaunchRequestConsumption => {
+    if (!LAUNCH_REQUEST_ID_PATTERN.test(id)) {
+      return { status: 'unavailable', requestId: id, reason: `requestId 가 원장 키로 쓸 수 없다: ${JSON.stringify(id)}` };
+    }
+    const at = now().toISOString();
+    // 부모(hand)가 같은 requestId 를 이미 소비했다면 상속 영수증으로 지나간다 — 새 영수증을 만들지 않는다.
+    if (opts.inheritedReceipt !== undefined && opts.inheritedReceipt === id) {
+      const inherited = readReceipt(id);
+      if (inherited !== null) {
+        try { debug.log('execution-loop.launch-gate', 'request-consumption-inherited', { requestId: id, receiptId: inherited.receiptId }); } catch { /* 관측은 fail-soft */ }
+        return { status: 'consumed', requestId: id, receiptId: inherited.receiptId, receiptAt: inherited.at, inherited: true };
+      }
+    }
+    const receipt: LaunchRequestReceipt = { requestId: id,
+      receiptId: `receipt-${createHash('sha256').update(`${id}:${at}`).digest('hex').slice(0, 12)}`, at,
+      ...(source ? { source } : {}) };
+    let created = true;
+    try {
+      assertLedgerPathPolicy(receiptsDir);
+      mkdirSync(receiptsDir, { recursive: true, mode: 0o700 });
+      assertLedgerPathPolicy(receiptsDir);
+      const fd = openSync(join(receiptsDir, `${id}.json`), constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 0o600);
+      try {
+        if (!fstatSync(fd).isFile()) throw new Error(`소비 영수증이 일반 파일이 아니다: ${id}`);
+        writeSync(fd, JSON.stringify(receipt));
+      } finally { closeSync(fd); }
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException)?.code !== 'EEXIST') {
+        const reason = error instanceof Error ? error.message : String(error);
+        observe('request-receipt-unavailable', { requestId: id, reason });
+        appendRow({ event: 'door-unavailable', requestId: id, at, ...(source ? { source } : {}), reason });
+        return { status: 'unavailable', requestId: id, reason: `소비 영수증을 만들지 못했다 — 발사를 막지 않는다: ${reason}` };
+      }
+      created = false;
+    }
+    if (created) {
+      appendRow({ event: 'consumed', requestId: id, at, ...(source ? { source } : {}), receiptId: receipt.receiptId });
+      return { status: 'consumed', requestId: id, receiptId: receipt.receiptId, receiptAt: receipt.at };
+    }
+    const existing = readReceipt(id);
+    if (existing === null) {
+      const reason = `requestId ${id} 의 소비 영수증이 이미 있지만 읽지 못했다 — 중복 발사 거절`;
+      appendRow({ event: 'refused-duplicate', requestId: id, at, ...(source ? { source } : {}), reason });
+      return { status: 'refused', requestId: id, receiptId: null, receiptAt: null, reason };
+    }
+    if (opts.force === true) {
+      const reason = `requestId ${id} 는 영수증 ${existing.receiptId} (${existing.at}) 로 이미 소비됐다 — force 로 다시 띄운다`;
+      appendRow({ event: 'forced-duplicate', requestId: id, at, ...(source ? { source } : {}), receiptId: existing.receiptId, reason });
+      return { status: 'forced', requestId: id, receiptId: existing.receiptId, receiptAt: existing.at, reason };
+    }
+    const reason = `requestId ${id} 는 영수증 ${existing.receiptId} (${existing.at}) 로 이미 소비됐다 — 중복 발사 거절`;
+    appendRow({ event: 'refused-duplicate', requestId: id, at, ...(source ? { source } : {}), receiptId: existing.receiptId, reason });
+    return { status: 'refused', requestId: id, receiptId: existing.receiptId, receiptAt: existing.at, reason };
+  };
+
+  const fail = (id: string, reason: string): void => {
+    appendRow({ event: 'launch-failed', requestId: id, at: now().toISOString(),
+      ...(source ? { source } : {}), reason: reason.trim() || '사유 없음' });
+  };
+
+  const rows = (requestId?: string): readonly LaunchRequestLedgerRow[] => {
+    const result: LaunchRequestLedgerRow[] = [];
+    let names: string[];
+    try {
+      assertLedgerPathPolicy(dir);
+      names = readdirSync(dir);
+    } catch { return result; }
+    for (const name of names.filter((candidate) => LAUNCH_REQUEST_DATE_FILE.test(candidate)).sort()) {
+      let text: string;
+      try {
+        const fd = openSync(join(dir, name), constants.O_RDONLY | constants.O_NOFOLLOW);
+        try {
+          if (!fstatSync(fd).isFile()) continue;
+          text = readFileSync(fd, 'utf8');
+        } finally { closeSync(fd); }
+      } catch { continue; }
+      for (const line of text.split('\n')) {
+        if (!line) continue;
+        try {
+          const row = JSON.parse(line) as LaunchRequestLedgerRow;
+          if (row && typeof row === 'object' && typeof row.event === 'string' && typeof row.requestId === 'string'
+            && typeof row.at === 'string' && (requestId === undefined || row.requestId === requestId)) result.push(row);
+        } catch { /* 찢어진 줄은 건너뛴다 */ }
+      }
+    }
+    return result;
+  };
+
+  return { requestId, consume, fail, rows };
+}

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

@@ -31,19 +31,21 @@ export function registerGraphCommands(program: Command, runsDeps: { root?: strin
   graph.command('adapt-report')
     .description('Measure recorded graph path diversity, unit calls, adaptations and landings for one goal')
     .requiredOption('--goal <id>', 'Goal ID to measure')
+    .option('--from <timestamp>', 'Include runs started at or after this ISO timestamp')
+    .option('--to <timestamp>', 'Exclude runs started at or after this ISO timestamp')
     .option('--json', 'Print measurement as JSON')
-    .action(async (opts: { goal: string; json?: boolean }) => {
+    .action(async (opts: { goal: string; from?: string; to?: string; json?: boolean }) => {
       try {
         const { queryGraphAdaptReport } = await import('../self-implement/run-ledger.js');
-        const report = queryGraphAdaptReport(opts.goal);
+        const report = queryGraphAdaptReport(opts.goal, undefined, { since: opts.from, until: opts.to });
         if (opts.json) await writeStdoutJson(JSON.stringify(report) + '\n');
-        else if (report.runCount === 0) console.log(`graph adapt-report: ${opts.goal} · 표본 0 · 제외 ${report.excludedCount} ${JSON.stringify(report.exclusionReasons)}`);
+        else if (report.runCount === 0) console.log(`graph adapt-report: ${opts.goal} · 표본 0 · 제외 ${report.excludedCount} ${JSON.stringify(report.exclusionReasons)} · 미측정 ${report.unmeasuredCount} ${JSON.stringify(report.unmeasuredReasons)}`);
         else {
           const landing = (group: typeof report.adapted) => group.denominator
             ? `${group.landed}/${group.denominator} (${(group.rate! * 100).toFixed(1)}%)` : '표본 0';
           console.log(`graph adapt-report: ${opts.goal} · 경로 ${report.uniquePathSignatures} · 유닛 호출 ${report.unitCallCount} · 적응 ${report.adaptationCount}`);
           console.log(`적응 착지율 ${landing(report.adapted)} · 비적응 착지율 ${landing(report.nonAdapted)}`);
-          console.log(`제외 ${report.excludedCount} ${JSON.stringify(report.exclusionReasons)}`);
+          console.log(`제외 ${report.excludedCount} ${JSON.stringify(report.exclusionReasons)} · 미측정 ${report.unmeasuredCount} ${JSON.stringify(report.unmeasuredReasons)}`);
         }
       } catch (error) {
         console.error(`graph adapt-report: ${error instanceof Error ? error.message : String(error)}`);

package/src/graph-runner/runner.ts

@@ -28,7 +28,7 @@ import { executeBashNode } from '../workflow-runtime/nodes/bash.js';
 import { executeClassifyNode } from '../workflow-runtime/nodes/classify.js';
 import { interpolate } from '../workflow-runtime/variables.js';
 import type { BashNode, ClassifyNode, NodeExecContext, NodeOutput, WorkflowDeps } from '../workflow-runtime/types.js';
-import { releaseResumeAcceptedRegressions, releaseResumeGateExecutor, releaseResumeGatePodPool, releaseResumeWaiver, type AcceptedRegression, type GateExecutorOverride, type GatePodPoolOverride } from '../../scripts/release-loop/resume.js';
+import { releaseResumeAcceptedRegressions, releaseResumeGateExecutor, releaseResumeGatePodPool, releaseResumeGateShardReroute, releaseResumeWaiver, type AcceptedRegression, type GateExecutorOverride, type GatePodPoolOverride, type GateShardRerouteOverride } from '../../scripts/release-loop/resume.js';
 
 type BashRun = WorkflowDeps['runBash'];
 const DEFAULT_BASH_TIMEOUT_MS = 5 * 60 * 1_000;
@@ -148,7 +148,8 @@ export interface GraphRunState {
   reason?: string;
   path: string[];
   /** startedAt/endedAt (ISO) and seconds are written when the node runs; ledgers before GRAPH-NODE-TIMES (0.2.19) have none. */
-  nodes: Array<{ nodeId: string; ok: boolean; exit: number | null; executed: boolean; output?: unknown; error?: string; reason?: string; decidedBy?: string; decidedAt?: string;
+  nodes: Array<{ nodeId: string; ok: boolean; exit: number | null; executed: boolean; output?: unknown; error?: string; reason?: string;
+    failure?: { errorCode: string; message: string; stage: string }; decidedBy?: string; decidedAt?: string;
     startedAt?: string; endedAt?: string; seconds?: number;
     waiver?: { reason: string; at: string; /** RELEASE-WAIVE-UNMEASURED — why the waived gate had no verdict. */ unmeasured?: string; original: { exit: number | null; output?: unknown; error?: string } } }>;
   /** The node now running and when it started; cleared when its record is written. */
@@ -170,7 +171,7 @@ export interface GraphRunState {
   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' };
   /** GATE-HOST-EXECUTOR — every explicit input change a resume made (what was set and what it replaced), oldest first. */
-  inputOverrides?: Array<GateExecutorOverride | GatePodPoolOverride>;
+  inputOverrides?: Array<GateExecutorOverride | GatePodPoolOverride | GateShardRerouteOverride>;
   executed: number;
   dryRun: boolean;
   statePath: string;
@@ -241,6 +242,8 @@ export interface GraphRunOptions {
   releaseGateExecutor?: { executor: string; host?: string };
   /** Release-only (RESUME-GATE-POOL-OVERRIDE): replace the saved gate pool for this resumed gate. */
   releaseGatePodPool?: string;
+  /** Release-only: remeasure a shard after the same-commit resume preflight. */
+  releaseGateShardReroute?: { shard: string; host?: string; os?: 'darwin' | 'linux' };
   useCurrentGraph?: boolean;
   /** Internal unit invocation context, propagated only by runGraph. */
   unitContext?: { parentRunId: string; ancestors: readonly string[]; remainingSteps: number; entryNodeId?: string };
@@ -652,6 +655,7 @@ export async function runGraph(path: string, options: GraphRunOptions = {}): Pro
   if (options.releaseAcceptedRegressions && (!options.resumeRunId || !options.fromNodeId || options.releaseWaiver)) throw new Error('accepted regressions require a release resume boundary');
   if (options.releaseGateExecutor && (!options.resumeRunId || !options.fromNodeId)) throw new Error('gate executor override requires a release resume boundary');
   if (options.releaseGatePodPool !== undefined && (!options.resumeRunId || !options.fromNodeId)) throw new Error('gate pod pool override requires a release resume boundary');
+  if (options.releaseGateShardReroute && (!options.resumeRunId || options.fromNodeId !== 'gate')) throw new Error('shard reroute requires release resume --from gate');
   const root = options.deps?.root ?? effectiveInstanceRoot();
   const matchingRuns = options.resumeRunId && !options.resumeGraphId
     ? listGraphRuns(root).runs.filter((run) => run.runId === options.resumeRunId && run.graphPath === resolve(path)) : [];
@@ -718,6 +722,8 @@ export async function runGraph(path: string, options: GraphRunOptions = {}): Pro
     return existsSync(graphsDir) && graphFile.startsWith(`${realpathSync(graphsDir)}${sep}`);
   });
   const credentials = owner ? pluginEnv(owner.name, pluginRoot) : {};
+  const redactCredentials = (text: string) => Object.values(credentials).filter(value => value.length > 0)
+    .reduce((safe, value) => safe.replaceAll(value, '[REDACTED]'), text);
   const declaredEnv = [...new Set(installed.map(item => item.name))]
     .flatMap(name => credentialStatus(name, pluginRoot).fields.map(field => field.env));
   const credentialFields = owner ? credentialStatus(owner.name, pluginRoot).fields.filter(field => field.set).map(field => field.name) : [];
@@ -921,6 +927,13 @@ export async function runGraph(path: string, options: GraphRunOptions = {}): Pro
       state.inputOverrides = [...(state.inputOverrides ?? []), override];
       debug.log('graph.runs', 'input-override', { graphId, runId, ...override });
     }
+    if (options.releaseGateShardReroute) {
+      if (graphId !== 'release-loop') throw new Error('shard reroute requires the release-loop graph');
+      const override = releaseResumeGateShardReroute(state, { from: options.fromNodeId, ...options.releaseGateShardReroute });
+      state.input = { ...(state.input as Record<string, unknown>), ...override.set };
+      state.inputOverrides = [...(state.inputOverrides ?? []), override];
+      debug.log('graph.runs', 'input-override', { graphId, runId, ...override });
+    }
     if (state.unitCalls) {
       const calls = state.unitCalls;
       state.unitCalls = calls.filter(call => {
@@ -1102,8 +1115,6 @@ export async function runGraph(path: string, options: GraphRunOptions = {}): Pro
       mkdirSync(dirname(contextPath), { recursive: true });
       writeFileSync(contextPath, JSON.stringify({ graphId, runId, startedAt: state.startedAt, nodeId: current, input: state.input ?? null, outputs }, null, 2) + '\n');
       let code: number | null = null;
-      const redactCredentials = (text: string) => Object.values(credentials).filter(value => value.length > 0)
-        .reduce((safe, value) => safe.replaceAll(value, '[REDACTED]'), text);
       const runBash: BashRun = async (body, opts) => {
         const commandRoot = verifyReleaseSource();
         // Hash the actual /bin/bash argv after interpolation. Keep the command text (which may contain
@@ -1243,7 +1254,7 @@ export async function runGraph(path: string, options: GraphRunOptions = {}): Pro
         log('graph.unit', { ...info, phase: 'exit', exit: childExit, steps });
       } catch (cause) {
         ok = false;
-        error = cause instanceof Error ? cause.message : String(cause);
+        error = redactCredentials(cause instanceof Error ? cause.message : String(cause));
         if (entered) {
           debug.log('graph.unit', 'exit', { ...info, error });
           log('graph.unit', { ...info, phase: 'exit', error });
@@ -1326,7 +1337,16 @@ export async function runGraph(path: string, options: GraphRunOptions = {}): Pro
         output = JSON.stringify({ outcome: ok ? 'approved' : 'rejected', graphId, runId, nodeId: current,
           ...(state.pending?.decidedBy === undefined ? {} : { decidedBy: state.pending.decidedBy }), decidedAt: state.pending?.decidedAt ?? null });
       }
-      state.nodes.push({ nodeId: current, ok, exit, executed: !waiving && ((!!command && (!state.dryRun || !!command.dry_run_command)) || (!!prompt && !state.dryRun) || (node.kind === 'classify' && !state.dryRun) || unitExecuted), ...((waiving || harnessLoopRoute || units.has(current) || ((command || prompt || approval || node.kind === 'classify') && (!state.dryRun || !!command?.dry_run_command))) && output !== undefined ? { output } : {}), ...(error ? { error } : {}), ...(commandFailureReason ? { reason: commandFailureReason } : {}),
+      const failureMessage = !ok
+        ? redactCredentials(commandFailureReason ?? error ?? `Node ${current} failed without a diagnostic.`)
+        : undefined;
+      const failure = failureMessage === undefined ? undefined : {
+        errorCode: error?.startsWith('unit input missing:') ? 'GRAPH_UNIT_INPUT_MISSING' : 'GRAPH_NODE_FAILED',
+        message: failureMessage,
+        stage: units.has(current) ? 'unit-invocation' : command ? 'command-execution' : prompt ? 'prompt-execution' : 'node-execution',
+      };
+      state.nodes.push({ nodeId: current, ok, exit, executed: !waiving && ((!!command && (!state.dryRun || !!command.dry_run_command)) || (!!prompt && !state.dryRun) || (node.kind === 'classify' && !state.dryRun) || unitExecuted), ...((waiving || harnessLoopRoute || units.has(current) || ((command || prompt || approval || node.kind === 'classify') && (!state.dryRun || !!command?.dry_run_command))) && output !== undefined ? { output } : {}), ...(error ? { error } : {}),
+        ...(failure ? { reason: failure.message, failure } : {}), ...(commandFailureReason && !failure ? { reason: commandFailureReason } : {}),
         ...(waiving ? { waiver: { reason: options.releaseWaiver!.reason, at: nodeEndedAt, ...(options.releaseWaiver!.unmeasured === undefined ? {} : { unmeasured: options.releaseWaiver!.unmeasured }), original: { exit: waivedRecord!.exit, ...(waivedRecord!.output === undefined ? {} : { output: waivedRecord!.output }), ...(waivedRecord!.error === undefined ? {} : { error: waivedRecord!.error }) } } } : {}),
         ...(approval && state.pending ? { ...(state.pending.decidedBy === undefined ? {} : { decidedBy: state.pending.decidedBy }), decidedAt: state.pending.decidedAt } : {}),
         startedAt: nodeStartedAt, endedAt: nodeEndedAt, seconds });
@@ -1342,12 +1362,14 @@ export async function runGraph(path: string, options: GraphRunOptions = {}): Pro
     const reported: unknown = waiving || harnessLoopRoute || units.has(current) || (prompt && !state.dryRun) || (command && (!state.dryRun || command.dry_run_command)) ? lastJsonObject(resumingCompleted ? completed?.output : output)?.outcome : undefined;
     const namedOutcome: string | undefined = typeof reported === 'string' ? reported : undefined;
     if (!options.quiet) console.error(`[graph] ${current} ${ok ? 'ok' : 'fail'} (${seconds.toFixed(2)}s)`);
+    const nodeFailure = state.nodes.at(-1)?.nodeId === current ? state.nodes.at(-1)?.failure : undefined;
+    const nodeReason = state.nodes.at(-1)?.nodeId === current ? state.nodes.at(-1)?.reason : undefined;
     debug.log('graph.run', 'node', { graphId, runId, nodeId: current, phase: ok ? 'ok' : 'fail', seconds, exit,
-      ...(commandFailureReason ? { reason: commandFailureReason } : {}) });
+      ...(nodeReason ? { reason: nodeReason } : {}), ...(nodeFailure ? { failure: nodeFailure } : {}) });
     publishInsideEvent({ kind: 'node', graphId, runId, nodeId: current, phase: ok ? 'ok' : 'fail', seconds });
     publishInsideEvent({ kind: 'verdict', graphId, runId, nodeId: current, verdict: ok ? 'ok' : 'fail', ...(namedOutcome === undefined ? {} : { outcome: namedOutcome }) });
     log('node-end', { graphId, runId, nodeId: current, ok, exit,
-      ...(commandFailureReason ? { reason: commandFailureReason } : {}),
+      ...(nodeReason ? { reason: nodeReason } : {}), ...(nodeFailure ? { failure: nodeFailure } : {}),
       ...(namedOutcome === undefined ? {} : { outcome: namedOutcome }), dryRun: state.dryRun });
     if (!resumingCompleted) {
       // Recipe commands expose stdout/exit but no provider usage; never infer zero from success.

package/src/graph-wizard/generate.ts

@@ -34,6 +34,8 @@ export interface GraphWizardRequest {
   history?: GraphWizardTurn[];
   /** Installed pack selected for a knowledge (RAG) node. */
   packId?: string;
+  /** Task hand composition: only existing verb units and terminal gates, never free-form commands. */
+  missionBase?: { id: string; text: string };
 }
 
 export interface GraphWizardResult {
@@ -653,6 +655,11 @@ function buildPrompt(input: {
   if (req.history?.length) {
     lines.push('', '지금까지의 대화:', ...req.history.slice(-10).map((t) => `${t.role === 'user' ? '사용자' : '마법사'}: ${t.text.slice(0, 500)}`));
   }
+  if (req.missionBase) {
+    lines.push('', '미션 조합: 기존 graphs/work 표준 조합의 동사 단위(subgraph call: verb-…@정수판)와 끝 gate 만 사용한다.',
+      'cmd·새 권한·외부 효과를 추가하지 마라. merge 앞에는 gate·freeze-check·review 가 모든 경로에서 먼저 와야 한다.',
+      `표준 조합 ${req.missionBase.id}:`, '```yaml', req.missionBase.text.trim(), '```');
+  }
   if (editing) {
     lines.push('', '지금 그래프(이것을 고친다 — 바뀌지 않는 노드의 id 는 그대로 둔다):', '```yaml', req.currentYaml!.trim(), '```',
       '', `사용자의 수정 지시: ${req.prompt}`,
@@ -705,7 +712,7 @@ export async function generateGraphFromPrompt(req: GraphWizardRequest, deps: Gra
   let id = editing ? currentId! : wizardGraphId(prompt, undefined, taken);
   const callLLM = deps.callLLM ?? defaultCallLLM;
   const maxAttempts = Math.max(1, deps.maxAttempts ?? GRAPH_WIZARD_MAX_ATTEMPTS);
-  let base = keywordBase?.id;
+  let base = req.missionBase?.id ?? keywordBase?.id;
   let yaml = '';
   let issues: string[] = [];
   let llmSummary: string | undefined;
@@ -726,7 +733,7 @@ export async function generateGraphFromPrompt(req: GraphWizardRequest, deps: Gra
     }
     if (attempts === 1 && !editing) {
       const picked = lineValue(text, 'BASE');
-      if (picked && picked !== base && templates.some((t) => t.id === picked)) { base = picked; baseReason = `LLM 재선택 (키워드 후보 ${keywordBase?.id ?? '-'})`; }
+      if (!req.missionBase && picked && picked !== base && templates.some((t) => t.id === picked)) { base = picked; baseReason = `LLM 재선택 (키워드 후보 ${keywordBase?.id ?? '-'})`; }
       const slug = lineValue(text, 'SLUG');
       if (slug && !currentId) id = wizardGraphId(prompt, slug, taken);
     }
@@ -746,13 +753,15 @@ export async function generateGraphFromPrompt(req: GraphWizardRequest, deps: Gra
     recipes = undefined;
     dryRun = undefined;
     if (kind === 'harness' && issues.length === 0) {
-      issues = stepIssues(yaml, steps);
+      if (!req.missionBase) issues = stepIssues(yaml, steps);
       const nodes = ((parseYaml(yaml) as { nodes?: Array<{ node_id?: unknown; recipe?: unknown }> }).nodes ?? [])
         .map((n) => ({ nodeId: String(n.node_id), recipe: typeof n.recipe === 'string' ? n.recipe : '' }));
-      recipes = recipesYamlFor(nodes, steps);
-      const walked = await dryRunWizardGraph(yaml, recipes);
-      dryRun = { status: walked.status, path: walked.path };
-      if (walked.status !== 'done') issues.push(`graph run --dry-run: ${walked.status}${walked.error ? ` — ${walked.error}` : ''} (경로 ${walked.path.join(' → ')})`);
+      if (!req.missionBase) {
+        recipes = recipesYamlFor(nodes, steps);
+        const walked = await dryRunWizardGraph(yaml, recipes);
+        dryRun = { status: walked.status, path: walked.path };
+        if (walked.status !== 'done') issues.push(`graph run --dry-run: ${walked.status}${walked.error ? ` — ${walked.error}` : ''} (경로 ${walked.path.join(' → ')})`);
+      }
     }
     debug.log('graph.wizard', 'attempt', { id, attempt: attempts, base, ok: issues.length === 0, issues: issues.slice(0, 10) });
     if (issues.length === 0) break;

package/src/graph-wizard/mission-compose.ts

@@ -0,0 +1,201 @@
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { parse as parseYaml } from 'yaml';
+import { validateGraphYaml } from '../nexus/api/graph-kinds.js';
+import { edgeMapOf, parseGraphTemplateYaml, type GraphTemplateSpec } from '../self-implement/graph-yaml.js';
+import { resolveGraphUnit } from '../self-implement/graph-unit-resolver.js';
+import { inspectPipelineGraph } from '../self-implement/pipeline-shape.js';
+import { debug } from '../debug/log.js';
+import { generateGraphFromPrompt, type GraphWizardDeps } from './generate.js';
+import type { CompletionKind, CompositionSelection } from '../task-agent/task-hand.js';
+
+export interface MissionComposeInput {
+  text: string;
+  completion: CompletionKind;
+  root: string;
+  ledgerPath: string;
+  cardId: string;
+  standard: CompositionSelection;
+}
+
+/** The LLM may choose the order of existing verb calls, but not their authority or the hand's launcher. */
+export function missionGraphIssues(yaml: string, baseYaml: string, root: string, generatedPath?: string): string[] {
+  const checked = validateGraphYaml('harness', yaml);
+  const issues = checked.errors.map(error => typeof error === 'string' ? error : JSON.stringify(error));
+  const parsed = parseGraphTemplateYaml(yaml);
+  const base = parseGraphTemplateYaml(baseYaml);
+  issues.push(...parsed.errors.map(error => `${error.path}: ${error.message}`));
+  if (!parsed.template || !base.template) return issues;
+  const graph = parsed.template;
+  const standard = base.template;
+  const raw = parseYaml(yaml) as Record<string, unknown>;
+  const baseRaw = parseYaml(baseYaml) as Record<string, unknown>;
+  if (raw.launcher !== baseRaw.launcher) issues.push('I6: 표준 launcher 제어를 바꿀 수 없다');
+  for (const key of new Set([...Object.keys(baseRaw), ...Object.keys(raw)])) {
+    if (['graph_id', 'loop', 'nodes', 'edges'].includes(key)) continue;
+    if (JSON.stringify(raw[key]) !== JSON.stringify(baseRaw[key])) issues.push(`I6: 표준 제어 ${key} 변경 금지`);
+  }
+  if (raw.entry_node !== baseRaw.entry_node) issues.push('I6: 표준 진입 노드를 바꿀 수 없다');
+  if (JSON.stringify(raw.terminal_nodes) !== JSON.stringify(baseRaw.terminal_nodes)) issues.push('I4: 표준 종료 노드를 바꿀 수 없다');
+  const baseLoop = baseRaw.loop as { trigger?: unknown } | undefined;
+  const loop = raw.loop as { trigger?: unknown } | undefined;
+  if (JSON.stringify(loop?.trigger) !== JSON.stringify(baseLoop?.trigger)) issues.push('I6: 표준 트리거 변경 금지');
+  const rawNodes = Array.isArray(raw.nodes) ? raw.nodes as Array<Record<string, unknown>> : [];
+  const baseNodes = Array.isArray(baseRaw.nodes) ? baseRaw.nodes as Array<Record<string, unknown>> : [];
+  for (const node of rawNodes) {
+    const original = baseNodes.find(candidate => candidate.call && candidate.call === node.call)
+      ?? baseNodes.find(candidate => candidate.node_id === node.node_id && candidate.kind === 'gate');
+    if (!original) continue;
+    const keys = new Set([...Object.keys(node), ...Object.keys(original)]);
+    for (const key of keys) {
+      if (key === 'node_id' || key === 'max_visits') continue;
+      if (JSON.stringify(node[key]) !== JSON.stringify(original[key])) issues.push(`I6: ${String(node.node_id)} 권한 ${key} 변경 금지`);
+    }
+  }
+  const rawEdges = Array.isArray(raw.edges) ? raw.edges as Array<Record<string, unknown>> : [];
+  if (rawEdges.some(edge => Object.keys(edge).some(key => !['from', 'to', 'on', 'map'].includes(key))))
+    issues.push('I6: 간선 조건·폴백 권한 추가 금지');
+  const allowed = new Map(standard.nodes.filter(n => n.kind === 'subgraph' && n.call?.startsWith('verb-')).map(n => [n.call!, n]));
+  const standardById = new Map(standard.nodes.map(n => [n.nodeId, n]));
+  const seenCalls = new Set<string>();
+  for (const node of graph.nodes) {
+    const original = standardById.get(node.nodeId);
+    if (!original && /(?:merge|publish|send|pay|charge|deploy|release)/i.test(`${node.nodeId} ${node.call ?? ''}`))
+      issues.push(`I5: 외부 효과 동사 추가 금지 (${node.nodeId})`);
+    if (original?.kind === 'gate' && node.kind === 'gate'
+      && JSON.stringify(node) === JSON.stringify(original)) continue;
+    const known = node.kind === 'subgraph' && node.call ? allowed.get(node.call) : undefined;
+    if (!known || node.recipe !== 'none' || node.maxVisits > known.maxVisits
+      || JSON.stringify(node.contract) !== JSON.stringify(known.contract)
+      || JSON.stringify(node.budget) !== JSON.stringify(known.budget)
+      || node.skipWhen !== undefined || node.callEntry !== undefined)
+      issues.push(`권한 표: ${node.nodeId} 는 허용된 동사 단위가 아니다`);
+    if (node.call) seenCalls.add(node.call);
+  }
+  for (const call of allowed.keys()) if (!seenCalls.has(call)) issues.push(`권한 표: 표준 동사 단위 ${call} 누락`);
+  for (const required of standard.nodes.filter(n => n.kind === 'gate' || ['gate', 'freeze-check', 'review'].includes(n.nodeId))) {
+    if (!graph.nodes.some(n => n.nodeId === required.nodeId && JSON.stringify(n) === JSON.stringify(required))) issues.push(`권한 표: 보호 노드 ${required.nodeId} 누락 또는 변경`);
+  }
+  for (const terminal of standard.terminalNodes) if (!graph.terminalNodes.includes(terminal)) issues.push(`I4: 종료 ${terminal} 누락`);
+  const edges = edgeMapOf(graph);
+  issues.push(...inspectPipelineGraph(edges, graph.entryNode).map(defect => `I4: ${JSON.stringify(defect)}`));
+  for (const node of graph.nodes) {
+    const reachable = new Set<string>();
+    const queue = [node.nodeId];
+    while (queue.length) {
+      const id = queue.shift()!;
+      if (reachable.has(id)) continue;
+      reachable.add(id);
+      queue.push(...(edges[id] ?? []));
+    }
+    if (![...reachable].some(id => graph.terminalNodes.includes(id))) issues.push(`I4: ${node.nodeId} 에서 종료 불가`);
+  }
+  const mergeNodes = graph.nodes.filter(n => n.nodeId.includes('merge') || n.call?.includes('merge'));
+  for (const merge of mergeNodes) {
+    const prerequisites = ['gate', 'freeze-check', 'review'];
+    const walk = (id: string, seen: Set<string>, met: Set<string>): void => {
+      if (id === merge.nodeId) {
+        for (const required of prerequisites) if (!met.has(required)) issues.push(`I1~I3: merge 앞 ${required} 없음`);
+        return;
+      }
+      if (seen.has(id)) return;
+      const nextMet = new Set(met);
+      if (prerequisites.includes(id)) nextMet.add(id);
+      const nextSeen = new Set(seen).add(id);
+      for (const target of edges[id] ?? []) walk(target, nextSeen, nextMet);
+    };
+    walk(graph.entryNode, new Set(), new Set());
+  }
+  for (const node of graph.nodes.filter(n => n.kind === 'subgraph')) {
+    if (!node.call || !allowed.has(node.call)) continue;
+    try {
+      const canonical = resolveGraphUnit(node.call, join(root, 'graphs/work', 'generated.yaml'));
+      const actual = resolveGraphUnit(node.call, generatedPath ?? join(root, 'graphs/work', 'generated.yaml'));
+      const unit = actual.template;
+      if (actual.hash !== canonical.hash || `${unit.graphId}@${unit.version}` !== node.call || !unit.unit ||
+        JSON.stringify(unit.unit.inputs) !== JSON.stringify(node.contract?.inputs) ||
+        JSON.stringify(unit.unit.outputs) !== JSON.stringify(node.contract?.outputs)) issues.push(`권한 표: 동사 단위 미해석 ${node.call}`);
+    } catch { issues.push(`권한 표: 동사 단위 미해석 ${node.call}`); }
+  }
+  return [...new Set(issues)];
+}
+
+export async function composeMissionGraph(input: MissionComposeInput, deps: Pick<GraphWizardDeps, 'callLLM'> & { deferPersistence?: boolean } = {}): Promise<{
+  selection: CompositionSelection; reason: string; persist: () => void;
+}> {
+  const fallback = input.standard;
+  let files: string[] = [];
+  try { files = readdirSync(join(input.root, 'graphs/work')).filter(name => name.endsWith('.yaml') && name !== 'recipes.yaml'); }
+  catch { /* The fixed selection already carries the missing or unreadable-template reason. */ }
+  const candidates = files.flatMap(file => {
+    const path = join(input.root, 'graphs/work', file);
+    try {
+      const yaml = readFileSync(path, 'utf8');
+      const parsed = parseGraphTemplateYaml(yaml, path);
+      return parsed.template && !parsed.errors.length && (parseYaml(yaml) as { launcher?: unknown }).launcher
+        ? [{ file: `graphs/work/${file}`, yaml, template: parsed.template }] : [];
+    } catch { return []; }
+  });
+  const standardFile = fallback.composition?.file;
+  const words = input.text.toLowerCase().match(/[\p{L}\p{N}]+/gu) ?? [];
+  const score = (item: { file: string; template: GraphTemplateSpec }) => {
+    const label = `${item.file} ${item.template.graphId} ${item.template.loop?.title ?? ''} ${item.template.loop?.description ?? ''}`.toLowerCase();
+    return words.reduce((total, word) => total + (word.length > 1 && label.includes(word) ? 1 : 0), 0);
+  };
+  const standardLauncher = standardFile ? candidates.find(item => item.file === standardFile) : undefined;
+  const compatible = candidates.filter(item => (parseYaml(item.yaml) as { launcher: unknown }).launcher ===
+    (standardLauncher ? (parseYaml(standardLauncher.yaml) as { launcher: unknown }).launcher : undefined)
+    && item.template.nodes.every(node => node.kind === 'gate' || node.kind === 'subgraph' && node.call?.startsWith('verb-')));
+  const base = compatible.sort((a, b) => score(b) - score(a) || Number(b.file === standardFile) - Number(a.file === standardFile))[0];
+  const prefix = base ? `문면 선택 ${base.file} (일치 ${score(base)})` : '표준 조합 없음';
+  let generated = '';
+  let issues: string[] = [];
+  let selection = fallback;
+  if (base && base.file !== standardFile && fallback.launcher === 'graph-run' && !fallback.error) {
+    const missingUnits: string[] = [];
+    const { validateUnitCalls } = await import('../graph-runner/runner.js');
+    try { validateUnitCalls(base.template, join(input.root, base.file), [], call => missingUnits.push(call)); }
+    catch (error) { issues.push(`표준 조합 단위 해석 오류: ${error instanceof Error ? error.message : String(error)}`); }
+    if (!issues.length && !missingUnits.length) selection = {
+      composition: { file: base.file, version: base.template.version }, launcher: 'graph-run', unitsResolved: true, missingUnits: [],
+    };
+    else if (missingUnits.length) issues.push(`표준 조합 단위 미해석: ${missingUnits.join(', ')}`);
+  }
+  if (base && selection.composition && !selection.error && !issues.length &&
+    (base.file === standardFile || selection.launcher === 'graph-run')) {
+    try {
+      const proposal = await generateGraphFromPrompt({ prompt: input.text, kind: 'harness', missionBase: { id: base.template.graphId, text: base.yaml } },
+        { callLLM: deps.callLLM, graphsDir: join(input.root, 'graphs'), existingIds: () => new Set(), maxAttempts: 1 });
+      generated = proposal.yaml;
+      const launcher = (parseYaml(base.yaml) as { launcher: string }).launcher;
+      if (!(parseYaml(generated) as { launcher?: unknown }).launcher)
+        generated = generated.replace(/^(graph_id:\s*[^\n]+\n)/, `$1launcher: ${launcher}\n`);
+      issues = missionGraphIssues(generated, base.yaml, input.root,
+        join(dirname(input.ledgerPath), `${input.cardId}.generated.yaml`));
+      if (!proposal.ok) issues.push(...proposal.issues);
+      if (launcher !== 'graph-run') issues.push('권한 표: harness-say 는 생성된 graph-run 조합으로 전환할 수 없다');
+      const directory = dirname(input.ledgerPath);
+      const recipePath = join(directory, 'recipes.yaml');
+      if (existsSync(recipePath) && readFileSync(recipePath, 'utf8') !== readFileSync(join(input.root, 'graphs/work/recipes.yaml'), 'utf8'))
+        issues.push('권한 표: 원장 옆 recipes.yaml 이 표준과 다르다');
+      if (!issues.length) {
+        const target = join(dirname(input.ledgerPath), `${input.cardId}.generated.yaml`);
+        selection = { composition: { file: target, version: parseGraphTemplateYaml(generated).template!.version },
+          launcher: launcher as 'graph-run' | 'harness-say', unitsResolved: true, missingUnits: [] };
+      }
+    } catch (error) { issues.push(`생성 실패: ${error instanceof Error ? error.message : String(error)}`); }
+  } else if (!issues.length) issues.push('표준 조합을 읽을 수 없다');
+  const reason = issues.length ? `${prefix} → fallback-standard: ${issues.join('; ')}` : `${prefix} → composed: 동사 단위 검증 통과`;
+  const persist = (): void => {
+    const directory = dirname(input.ledgerPath);
+    mkdirSync(directory, { recursive: true });
+    if (generated) writeFileSync(join(directory, `${input.cardId}.generated.yaml`), generated);
+    if (selection.composition?.file === join(directory, `${input.cardId}.generated.yaml`) && !existsSync(join(directory, 'recipes.yaml')))
+      writeFileSync(join(directory, 'recipes.yaml'), readFileSync(join(input.root, 'graphs/work/recipes.yaml'), 'utf8'), { flag: 'wx' });
+    writeFileSync(join(directory, `${input.cardId}.composition.json`), JSON.stringify({ base: base?.file ?? null,
+      selected: selection.composition?.file ?? null, reason, issues, generated: generated ? `${input.cardId}.generated.yaml` : null }));
+  };
+  if (!deps.deferPersistence) persist();
+  debug.log('graph.compose', issues.length ? 'fallback-standard' : 'composed', { card: input.cardId, base: base?.file ?? null, reason });
+  return { selection, reason, persist };
+}