elanous 0.2.37 → 0.2.40

package/src/git-fs/watcher.ts

@@ -1,6 +1,6 @@
 // ── git-fs watcher ──
 //
-// fs.watchFile() on the small set of files whose change indicates
+// fs.watchFile() polls the small set of entries whose replacement indicates
 // the branch or the current commit moved:
 //
 //   <gitDir>/HEAD                    branch switch / detach
@@ -15,7 +15,7 @@
 // watching the whole working tree. The dirty probe is throttled
 // separately.
 
-import { watch, type FSWatcher } from 'node:fs';
+import { unwatchFile, watchFile, type Stats } from 'node:fs';
 import { join } from 'node:path';
 import type { GitHeadInfo } from './types.js';
 import type { LocatedGit } from './locate.js';
@@ -24,9 +24,9 @@ type Listener = () => void;
 
 export class GitFileWatcher {
   private readonly listeners = new Set<Listener>();
-  private headWatcher: FSWatcher | null = null;
-  private refWatcher: FSWatcher | null = null;
-  private packedRefsWatcher: FSWatcher | null = null;
+  private headWatcher: { stop: () => void } | null = null;
+  private refWatcher: { stop: () => void } | null = null;
+  private packedRefsWatcher: { stop: () => void } | null = null;
   private currentBranch: string | null = null;
   private disposed = false;
 
@@ -54,7 +54,7 @@ export class GitFileWatcher {
     const next = head?.branch ?? null;
     if (next === this.currentBranch) return;
     this.currentBranch = next;
-    if (this.refWatcher) { this.refWatcher.close(); this.refWatcher = null; }
+    if (this.refWatcher) { this.refWatcher.stop(); this.refWatcher = null; }
     this.installRefWatcher();
   }
 
@@ -62,9 +62,9 @@ export class GitFileWatcher {
     if (this.disposed) return;
     this.disposed = true;
     this.listeners.clear();
-    if (this.headWatcher) { try { this.headWatcher.close(); } catch {} }
-    if (this.refWatcher) { try { this.refWatcher.close(); } catch {} }
-    if (this.packedRefsWatcher) { try { this.packedRefsWatcher.close(); } catch {} }
+    if (this.headWatcher) { try { this.headWatcher.stop(); } catch {} }
+    if (this.refWatcher) { try { this.refWatcher.stop(); } catch {} }
+    if (this.packedRefsWatcher) { try { this.packedRefsWatcher.stop(); } catch {} }
     this.headWatcher = null;
     this.refWatcher = null;
     this.packedRefsWatcher = null;
@@ -77,10 +77,22 @@ export class GitFileWatcher {
     }
   }
 
+  private watchPath(path: string): { stop: () => void } {
+    const onChange = (current: Stats, previous: Stats) => {
+      if (current.mtimeMs !== previous.mtimeMs || current.ino !== previous.ino || current.size !== previous.size) {
+        this.fire();
+      }
+    };
+    watchFile(path, { interval: 250, persistent: false }, onChange);
+    return { stop: () => unwatchFile(path, onChange) };
+  }
+
   private installHeadWatcher(): void {
-    const path = join(this.located.gitDir, 'HEAD');
     try {
-      this.headWatcher = watch(path, { persistent: false }, () => this.fire());
+      // Git replaces HEAD atomically via HEAD.lock + rename. fs.watch can stay
+      // attached to the old inode or miss the event on loaded hosts; stat
+      // polling follows the path and observes the replacement.
+      this.headWatcher = this.watchPath(join(this.located.gitDir, 'HEAD'));
     } catch {
       // HEAD may not exist during `git init` transient state; swallow.
     }
@@ -89,19 +101,12 @@ export class GitFileWatcher {
   private installRefWatcher(): void {
     if (!this.currentBranch) return;
     const path = join(this.located.commonGitDir, 'refs', 'heads', ...this.currentBranch.split('/'));
-    try {
-      this.refWatcher = watch(path, { persistent: false }, () => this.fire());
-    } catch {
-      // Loose ref may be packed — rely on packed-refs watcher.
-    }
+    // Loose refs are atomically replaced on commit. Polling the path survives
+    // replacement and also detects a ref that is created after subscription.
+    this.refWatcher = this.watchPath(path);
   }
 
   private installPackedRefsWatcher(): void {
-    const path = join(this.located.commonGitDir, 'packed-refs');
-    try {
-      this.packedRefsWatcher = watch(path, { persistent: false }, () => this.fire());
-    } catch {
-      // No packed-refs yet — not an error.
-    }
+    this.packedRefsWatcher = this.watchPath(join(this.located.commonGitDir, 'packed-refs'));
   }
 }

package/src/git-fs/worktree.ts

@@ -61,13 +61,18 @@ function worktreeAddTimeoutForTrackedFileCount(trackedFileCount: number | null):
   return { ms: Math.min(WORKTREE_ADD_TIMEOUT_MAX_MS, Math.max(WORKTREE_ADD_TIMEOUT_MS, scaledMs)), trackedFileCount, source: 'tracked-files' };
 }
 
+export function worktreeAddTimeoutSec(seconds: number | undefined): number | undefined {
+  return typeof seconds === 'number' && Number.isSafeInteger(seconds) && seconds > 0 && seconds <= 2_147_483
+    ? seconds : undefined;
+}
+
 export function worktreeAddTimeoutForRepo(
   repoRoot: string,
   countTrackedFilesForRepo: (repoRoot: string, ref?: string) => number | null = countTrackedFiles,
   trackedFileRef?: string,
 ): WorktreeAddTimeout {
-  const seconds = getUserConfig().harness?.worktreeAddTimeoutSec;
-  if (typeof seconds === 'number' && Number.isSafeInteger(seconds) && seconds > 0 && seconds <= 2_147_483) {
+  const seconds = worktreeAddTimeoutSec(getUserConfig().harness?.worktreeAddTimeoutSec);
+  if (seconds !== undefined) {
     return { ms: seconds * 1000, trackedFileCount: null, source: 'config' };
   }
   return worktreeAddTimeoutForTrackedFileCount(countTrackedFilesForRepo(repoRoot, trackedFileRef));
@@ -347,7 +352,18 @@ function bakedDependenciesMatch(repoTree: string, bakedTree: string): boolean {
   } catch { return false; }
 }
 
-function prepareWorktreeDependencies(repoRoot: string, worktreePath: string, opts: CreateWorktreeOpts, deps: WorktreeAddDeps): void {
+/** Pod source may omit node_modules while the image carries matching baked dependencies. */
+export function worktreeDependenciesAvailable(repoRoot: string, fallbackRoot = GATE_DEPS_DIR): boolean {
+  for (const tree of GATE_DEPS_TREES) {
+    const repoTree = join(repoRoot, tree);
+    if (!existsSync(join(repoTree, 'package.json')) || !existsSync(join(repoTree, 'bun.lock'))) continue;
+    if (existsSync(join(repoTree, 'node_modules'))) continue;
+    if (!bakedDependenciesMatch(repoTree, join(fallbackRoot, tree))) return false;
+  }
+  return true;
+}
+
+export function prepareWorktreeDependencies(repoRoot: string, worktreePath: string, opts: Pick<CreateWorktreeOpts, 'dependencyFallbackRoot' | 'dependencyInstallTimeoutMs'>, deps: WorktreeAddDeps): void {
   const fallbackRoot = opts.dependencyFallbackRoot?.trim() || GATE_DEPS_DIR;
   const timeoutMs = opts.dependencyInstallTimeoutMs ?? WORKTREE_DEPENDENCY_INSTALL_TIMEOUT_MS;
   if (!Number.isSafeInteger(timeoutMs) || timeoutMs <= 0) throw new Error('dependencyInstallTimeoutMs must be a positive integer');

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/graph-grow.ts

@@ -3,13 +3,10 @@ import { DecisionLedger, type DecisionEntry } from '../decisions/decision-ledger
 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 type { ResearchEdgeDecisionRegistry, ResearchEdgeProposal, ResolvedResearchEdgeDecision } from '../research/edge-decision.js';
 import { createLLMGrowthProposer } from './graph-grow-llm.js';
 
-export interface GrowthProposal {
-  node: GraphNodeSpec;
-  returnTo?: string;
-  reason: string;
-}
+export type GrowthProposal = ResearchEdgeProposal;
 
 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';
@@ -68,10 +65,41 @@ export function growthDecision(input: Parameters<GrowthProposer>[0], proposal: G
 
 export async function proposeGrowth(input: Parameters<GrowthProposer>[0],
   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 }> {
+  decisionDeps: GrowthDecisionDeps = {}, edgeDecisionRegistry?: ResearchEdgeDecisionRegistry): Promise<
+    | { ok: true; graph: GraphTemplateSpec; growth: GraphGrowth; edgeDecision?: ResolvedResearchEdgeDecision }
+    | { ok: false; reason: string; park?: boolean; growth?: GraphGrowth; decisionId?: string; decisionRef?: string; command?: GrowthCommand; approval?: string; edgeDecision?: ResolvedResearchEdgeDecision }
+  > {
   let proposal: GrowthProposal | undefined;
-  try { proposal = await proposer(input); }
-  catch (error) { return { ok: false, reason: `proposer failed: ${String(error)}` }; }
+  const value = input.output;
+  const assessment = value !== null && typeof value === 'object' && !Array.isArray(value)
+    && Array.isArray((value as Record<string, unknown>).gaps)
+    && Array.isArray((value as Record<string, unknown>).contradictions)
+    && Array.isArray((value as Record<string, unknown>).verdicts)
+    ? { gaps: (value as Record<string, unknown>).gaps as unknown[],
+      contradictions: (value as Record<string, unknown>).contradictions as unknown[],
+      verdicts: (value as Record<string, unknown>).verdicts as unknown[] }
+    : undefined;
+  let edgeDecision: ResolvedResearchEdgeDecision | undefined;
+  if (assessment) {
+    const [{ createResearchEdgeDecisionRegistry }, { debug }] = await Promise.all([
+      import('../research/edge-decision.js'), import('../debug/log.js'),
+    ]);
+    edgeDecision = await (edgeDecisionRegistry ?? createResearchEdgeDecisionRegistry()).decide(assessment);
+    try {
+      debug.log('research.edge', 'decision', {
+        provider: edgeDecision.provider,
+        decision: edgeDecision.action,
+        reason: edgeDecision.reason,
+      });
+    } catch { /* observation must not change graph growth */ }
+    if (edgeDecision.action !== 'add') {
+      return { ok: false, reason: `edge decision ${edgeDecision.action}: ${edgeDecision.reason}`, edgeDecision };
+    }
+    proposal = edgeDecision.proposal;
+  } else {
+    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' };
   let result: ReturnType<typeof createGraphVariant>;
@@ -99,5 +127,5 @@ export async function proposeGrowth(input: Parameters<GrowthProposer>[0],
         growth: proposalGrowth(input, proposal) };
     }
   }
-  return { ok: true, graph: result.template, growth: proposalGrowth(input, proposal) };
+  return { ok: true, graph: result.template, growth: proposalGrowth(input, proposal), ...(edgeDecision ? { edgeDecision } : {}) };
 }

package/src/graph-runner/runner.ts

@@ -17,6 +17,7 @@ import { recordFailureEvent } from '../self-implement/heal-intake.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 type { ResearchEdgeDecisionRegistry } from '../research/edge-decision.js';
 import { graphVersionHash, parseGraphTemplateYaml, type GraphEdgeSpec, type GraphNodeSpec, type GraphTemplateSpec } from '../self-implement/graph-yaml.js';
 import { createGraphUnitResolver, resolveGraphUnit, UnitNotFoundError, type ResolvedGraphUnit } from '../self-implement/graph-unit-resolver.js';
 import { flattenGraphUnits } from '../self-implement/graph-unit-flatten.js';
@@ -27,13 +28,14 @@ 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;
 // Independent of graph YAML and recipe snapshots: an already-wrong saved binding must fail closed.
 const RELEASE_NODE_COMMANDS: Readonly<Record<string, { recipe: string; command?: string }>> = {
   'version-release': { recipe: 'cmd:version-release', command: 'bun scripts/release-loop/version-node.ts release --json' },
+  'traffic-cut-start': { recipe: 'cmd:traffic-cut-start', command: 'bun scripts/release-loop/traffic-node.ts traffic-cut-start' },
   cutoff: { recipe: 'cmd:cutoff', command: 'bun scripts/release-loop/node-verdict.ts cutoff' },
   'checklist-gate': { recipe: 'cmd:checklist-gate', command: 'bun scripts/release-loop/checklist-gate-node.ts' },
   prefetch: { recipe: 'cmd:docs', command: 'bun scripts/release-loop/docs-node.ts --json' },
@@ -55,9 +57,11 @@ const RELEASE_NODE_COMMANDS: Readonly<Record<string, { recipe: string; command?:
   'approve-publish': { recipe: 'approval:publish' },
   publish: { recipe: 'cmd:publish-command', command: 'bun scripts/release-loop/publish-node.ts' },
   'npm-publish': { recipe: 'cmd:npm-publish', command: 'bun scripts/release-loop/npm-publish-node.ts' },
+  'traffic-npm-published': { recipe: 'cmd:traffic-npm-published', command: 'bun scripts/release-loop/traffic-node.ts traffic-npm-published' },
   'docs-land': { recipe: 'cmd:docs-land', command: 'bun scripts/release-loop/docs-land-node.ts' },
   verify: { recipe: 'cmd:verify', command: 'bun scripts/release-loop/verify-node.ts' },
   'traffic-verify-complete': { recipe: 'cmd:traffic-verify-complete', command: 'bun scripts/release-loop/traffic-node.ts traffic-verify-complete' },
+  'traffic-failed-restore': { recipe: 'cmd:traffic-failed-restore', command: 'bun scripts/release-loop/traffic-node.ts traffic-failed-restore' },
   'vault-note': { recipe: 'cmd:vault-note', command: 'bun scripts/release-loop/vault-note-node.ts' },
   'release-story': { recipe: 'cmd:release-story', command: 'bun scripts/release-story/draft.ts --graph' },
   'ops-upgrade': { recipe: 'cmd:ops-upgrade', command: 'bun scripts/release-loop/ops-upgrade-node.ts' },
@@ -144,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. */
@@ -166,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;
@@ -237,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 };
@@ -248,6 +255,8 @@ export interface GraphRunOptions {
   pinChildUniverse?: boolean;
   /** Release resume: command checkout and cut tip, checked before every Bash dispatch. */
   releaseCommandSource?: { root: string; cutTip: string; git?: (args: string[]) => string };
+  /** Optional per-run Bloom edge policy hook. */
+  researchEdgeDecisionRegistry?: ResearchEdgeDecisionRegistry;
   deps?: { root?: string; runBash?: BashRun; callLLM?: (prompt: string) => Promise<string>; log?: (event: string, data: Record<string, unknown>) => void; beforeNode?: () => 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[] } };
 }
 
@@ -646,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)) : [];
@@ -712,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) : [];
@@ -839,7 +851,16 @@ export async function runGraph(path: string, options: GraphRunOptions = {}): Pro
         const next = nextNode(graph.edges, prior.nodeId, prior.ok ? 'ok' : 'fail', typeof reported === 'string' ? reported : undefined);
         if (next !== recorded.nodeId) throw new Error('saved run path does not follow graph edges');
       } else if (recorded.nodeId !== unitEntryNode) throw new Error('saved run path does not start at entry node');
-      if (i < from && !recorded.ok) throw new Error('cannot preserve a failed predecessor when resuming');
+      if (i < from && !recorded.ok) {
+        // A warning-only node explicitly sends every outcome to the same next
+        // node. Its truthful failed record is safe to preserve when retrying a
+        // later release step; a branching failure is still a hard stop.
+        const edge = graph.edges.find((candidate) => candidate.from === recorded.nodeId);
+        const next = state.path[i + 1];
+        if (edge?.on !== 'outcome' || !next || !(['ok', 'fail', 'error'] as const).every((outcome) => edge.map?.[outcome] === next)) {
+          throw new Error('cannot preserve a failed predecessor when resuming');
+        }
+      }
       const approved = resolveNodeRecipe(spec, recipes, catalogRoles).approval;
       if (approved && i >= from) throw new Error('cannot restart across an approval decision');
       if (approved && i < from) {
@@ -906,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 => {
@@ -1087,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
@@ -1228,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 });
@@ -1311,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 });
@@ -1327,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.
@@ -1363,7 +1400,7 @@ export async function runGraph(path: string, options: GraphRunOptions = {}): Pro
             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 });
+          }, { ...options.deps?.growthDecision, root }, options.researchEdgeDecisionRegistry);
       if (result.ok) {
         graph = result.graph;
         state.growth ??= [];

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;