elanous 0.2.22 → 0.2.24

package/src/self-implement/gate-baseline.ts

@@ -6,6 +6,7 @@ import { prepareDeterministicChildEnvironment } from '../../scripts/lib/determin
 import { debug } from '../debug/log.js';
 import { runGitCommand } from '../git-fs/runner.js';
 import { linkWorktreeDependencies } from '../git-fs/worktree.js';
+import { reapStaleGateWorktrees } from './gate-baseline-reap.js';
 
 export type GateFailureAttribution = 'introduced' | 'preexisting' | 'unknown' | 'precondition-unmet' | 'flaky-timeout' | 'flaky-rerun';
 export type GateBaselinePresence = 'present' | 'missing' | 'unknown';
@@ -25,7 +26,7 @@ export interface GateTestFailure {
   attribution: GateFailureAttribution;
   /** 기준선 실행 산출과 기존 missingAtBase 입력에서 독립적으로 도출한 파일 존재 상태. */
   baselinePresence: GateBaselinePresence;
-  attributedBy?: 'name-across-files';
+  attributedBy?: 'name-across-files' | 'copied-across-files';
   precondition?: GateFailurePrecondition;
   /** 같은 gate 실행 안에서 같은 시험의 통과 기록이 있으면 `may-vary`로 보존한다. 타임아웃은 재실행 결과 변동성도 함께 표현한다. */
   timeoutVariability?: TimeoutVariability;
@@ -564,6 +565,26 @@ export function classifyGateTestFailures(
         debug.log('self-implement.gate', 'attributed-across-files', { name: path, file: failure.file, baselineFile: baseline.file });
         return { ...failure, attribution: 'preexisting' as const, attributedBy: 'name-across-files' as const, baselinePresence };
       }
+      const baseCandidates = path ? baselineFailures.filter((entry) => testPath(entry) === path) : [];
+      const original = baseCandidates.length === 1 ? baseCandidates[0] : undefined;
+      const currentCandidates = path ? worktreeFailures.filter((entry) => testPath(entry) === path) : [];
+      const currentOriginal = original && currentCandidates.length === 2
+        ? currentCandidates.find((entry) => entry.file === original.file)
+        : undefined;
+      const copies = currentCandidates.filter((entry) => entry.file === failure.file);
+      // Only file position tokens (`[file://]<file>.<ext>:<line>:<col>`, any extension) are erased. A token preceded by `:`, `/`,
+      // a word char, `.` or `-` (URL hosts such as `https://a.example.com:443:10`) is part of the message and stays.
+      const comparableDiagnostic = (diagnostic: string): string =>
+        diagnostic.replace(/(?<![:/\w.-])(?:file:\/\/)?(?:\/?[A-Za-z]:)?[^\s():]+\.[A-Za-z][A-Za-z0-9]*:\d+:\d+/g, '');
+      if (original?.file && original.file !== failure.file && currentOriginal && copies.length === 1
+        && original.diagnostic && currentOriginal.diagnostic && failure.diagnostic
+        && ![original, currentOriginal, failure].some((entry) => isTimeoutDiagnostic(entry.diagnostic)
+          || matchedGatePrecondition(entry.diagnostic ?? ''))
+        && comparableDiagnostic(original.diagnostic) === comparableDiagnostic(currentOriginal.diagnostic)
+        && comparableDiagnostic(original.diagnostic) === comparableDiagnostic(failure.diagnostic)) {
+        debug.log('self-implement.gate', 'attributed-copy-across-files', { name: path, file: failure.file, baselineFile: original.file });
+        return { ...failure, attribution: 'preexisting' as const, attributedBy: 'copied-across-files' as const, baselinePresence };
+      }
       return { ...failure, attribution: 'introduced' as const, baselinePresence };
     }
     if (baselineLog === undefined || !failure.file) return { ...failure, attribution: 'unknown' as const, baselinePresence };
@@ -764,11 +785,52 @@ export function classifyBaselineProcess(result: ProcessResult, budget?: { timeou
   };
 }
 
+let lastGateWorktreeReapAt = 0;
+
+function reapBeforeGateAdd(cwd: string): void {
+  const now = Date.now();
+  if (now - lastGateWorktreeReapAt < 10 * 60_000) return;
+  lastGateWorktreeReapAt = now;
+  try {
+    reapStaleGateWorktrees(cwd);
+  } catch (error) {
+    debug.log('self-implement.gate-baseline', 'reap', { ok: false, error: String(error) });
+  }
+}
+
+function gateWorktreeAddArgs(dir: string, ref: string): string[] {
+  return ['worktree', 'add', '--detach', '--lock', '--reason', `elanous-gate pid=${process.pid} started=${Date.now()}`, dir, ref];
+}
+
+function removeGateWorktree(cwd: string, dir: string, addFailed: boolean): void {
+  try {
+    const registered = addFailed
+      ? runGitCommand(cwd, ['worktree', 'list', '--porcelain'], { encoding: 'utf8', timeout: 60_000 })
+      : undefined;
+    if (addFailed) {
+      // git lists real paths (macOS tmpdir() is /var/… while git prints /private/var/…).
+      let real = dir;
+      try { real = realpathSync(dir); } catch { /* dir already gone: compare the spelling we have */ }
+      const lines = registered?.status === 0 ? (registered.stdout ?? '').split('\n') : [];
+      if (!lines.includes(`worktree ${dir}`) && !lines.includes(`worktree ${real}`)) return;
+    }
+    const removed = runGitCommand(cwd, ['worktree', 'remove', '--force', '--force', dir], { encoding: 'utf8', timeout: 60_000 });
+    if (removed.status !== 0) debug.log('self-implement', 'gate.baseline.cleanup', {
+      stage: addFailed ? 'add-failed-remove' : 'worktree-remove', dir, status: removed.status,
+    });
+  } catch (error) {
+    debug.log('self-implement', 'gate.baseline.cleanup', {
+      stage: addFailed ? 'add-failed-remove' : 'worktree-remove', dir, status: null, error: String(error),
+    });
+  }
+}
+
 export function withBaselineWorktree<T>(cwd: string, baseRef: string, run: (baselineDir: string) => T): T | BaselineProcessResult {
+  reapBeforeGateAdd(cwd);
   const baselineDir = mkdtempSync(join(tmpdir(), 'elanous-gate-baseline-'));
   let attached = false;
   try {
-    const add = runGitCommand(cwd, ['worktree', 'add', '--detach', baselineDir, baseRef], { encoding: 'utf8', timeout: 60_000 });
+    const add = runGitCommand(cwd, gateWorktreeAddArgs(baselineDir, baseRef), { encoding: 'utf8', timeout: 60_000 });
     if (add.status !== 0) return classifyBaselineProcess({ status: add.status, stdout: add.stdout, stderr: add.stderr });
     attached = true;
     linkDependencies(cwd, baselineDir);
@@ -781,8 +843,12 @@ export function withBaselineWorktree<T>(cwd: string, baseRef: string, run: (base
       log: `baseline setup failed: ${String(error)}`,
     };
   } finally {
-    if (attached) runGitCommand(cwd, ['worktree', 'remove', '--force', baselineDir], { encoding: 'utf8', timeout: 60_000 });
-    rmSync(baselineDir, { recursive: true, force: true });
+    removeGateWorktree(cwd, baselineDir, !attached);
+    try {
+      rmSync(baselineDir, { recursive: true, force: true });
+    } catch (error) {
+      debug.log('self-implement', 'gate.baseline.cleanup', { stage: 'exception', dir: baselineDir, error: String(error) });
+    }
   }
 }
 
@@ -792,11 +858,12 @@ function linkDependencies(cwd: string, dir: string): void {
 }
 
 function withVerifyWorktree<T>(cwd: string, baseRef: string, run: (dir: string) => T): T | BaselineProcessResult {
+  reapBeforeGateAdd(cwd);
   let dir = '';
   let attached = false;
   try {
     dir = mkdtempSync(join(tmpdir(), 'elanous-gate-baseline-'));
-    const add = runGitCommand(cwd, ['worktree', 'add', '--detach', dir, baseRef], { encoding: 'utf8', timeout: 60_000 });
+    const add = runGitCommand(cwd, gateWorktreeAddArgs(dir, baseRef), { encoding: 'utf8', timeout: 60_000 });
     if (add.status !== 0) return classifyBaselineProcess({ status: add.status, stdout: add.stdout, stderr: add.stderr });
     attached = true;
     linkDependencies(cwd, dir);
@@ -805,20 +872,15 @@ function withVerifyWorktree<T>(cwd: string, baseRef: string, run: (dir: string)
     const reason = `baseline setup failed: ${String(error)}`;
     return { status: 'unknown', log: reason, output: reason };
   } finally {
-    try {
-      const removed = attached
-        ? runGitCommand(cwd, ['worktree', 'remove', '--force', dir], { encoding: 'utf8', timeout: 60_000 })
-        : undefined;
-      if (removed && removed.status !== 0) {
+    if (dir) {
+      removeGateWorktree(cwd, dir, !attached);
+      try {
+        rmSync(dir, { recursive: true, force: true });
+      } catch (error) {
         debug.log('self-implement', 'gate.verify-by-breaking.cleanup', {
-          stage: 'worktree-remove', dir, status: removed.status, stderr: (removed.stderr ?? '').slice(0, 300),
+          stage: 'exception', dir, error: String(error).slice(0, 300),
         }, { level: 'warn' });
       }
-      if (dir) rmSync(dir, { recursive: true, force: true });
-    } catch (error) {
-      debug.log('self-implement', 'gate.verify-by-breaking.cleanup', {
-        stage: 'exception', dir, error: String(error).slice(0, 300),
-      }, { level: 'warn' });
     }
   }
 }

package/src/self-implement/gate-cli.ts

@@ -118,6 +118,9 @@ export interface SelfGateCliResult {
   /** New vs. already-present failures (unknown/preconditionUnmet = failures it could not classify). Absent = the test
    *  step did not produce a measurement (e.g. shards unmeasured). */
   baseline?: { introduced: number; preexisting: number; unknown: number; preconditionUnmet: number };
+  /** LIGHT-RC-MEASURE ③ — why the sharded test step produced no measurement (the same text as the
+   *  `shards: unmeasured (…)` line). Absent when it measured, or on the unsharded path. */
+  unmeasuredReason?: string;
 }
 
 /** 시험 단계와 독립인 정책 관문 넷. skipTestStep 이든 시험 통과든 같은 함수를 부른다. */
@@ -667,10 +670,16 @@ export function runSelfGateCli(cwd: string, options: SelfGateCliOptions = {}, de
   if (options.shards !== undefined) {
     const sharded = (deps.runShards ?? runShardedGateTests)(cwd, testFiles, selection.baseRef, options.shards);
     lines.push(`shards: ${sharded.shards.length} (${sharded.shards.map((shard) => `${shard.id}=${shard.files.join(',')}`).join('; ')})${sharded.measurementFailures ? ` · 측정 실패 ${sharded.measurementFailures}` : ''}`);
-    for (const attempt of sharded.attempts) lines.push(`shard attempt: ${attempt.shardId} #${attempt.attempt}`);
+    // 조각이 «못 쟀다»일 때 이유가 줄에 없으면 자리·시간 초과·죽음을 가를 수 없다(OP 10-09 light RC) — 종료 코드·신호를 같이 싣는다.
+    const side = (code: number | null, signal: string | null | undefined, junit: string | undefined) => signal ? `signal ${signal}` : code === null ? 'exit ?' : `exit ${code}${junit === undefined ? ' · junit 없음' : ''}`;
+    for (const attempt of sharded.attempts) lines.push(`shard attempt: ${attempt.shardId} #${attempt.attempt} · 지금 ${side(attempt.currentExitCode, attempt.currentSignal, attempt.currentJUnit)} · 기준 ${side(attempt.baselineExitCode, attempt.baselineSignal, attempt.baselineJUnit)}`);
     const { aggregate } = sharded;
     let shardBaseline: SelfGateCliResult['baseline'];
-    if (aggregate.status === 'unmeasured') lines.push(`shards: unmeasured (${aggregate.retryShardIds.join(', ') || sharded.reason || 'no complete JUnit'})`);
+    let unmeasuredReason: string | undefined;
+    if (aggregate.status === 'unmeasured') {
+      unmeasuredReason = aggregate.retryShardIds.join(', ') || sharded.reason || 'no complete JUnit';
+      lines.push(`shards: unmeasured (${unmeasuredReason})`);
+    }
     else if (aggregate.report) {
       const report = aggregate.report;
       logGateCliBaseline(cwd, {
@@ -692,6 +701,7 @@ export function runSelfGateCli(cwd: string, options: SelfGateCliOptions = {}, de
       lines, changedFiles: selection.files, testFiles, unverified: scope.unverified,
       documentPaths: scope.documentPaths, documentsWithoutDerivedTests: scope.documentsWithoutDerivedTests,
       alwaysIncludeMissing, ...(shardBaseline ? { baseline: shardBaseline } : {}),
+      ...(unmeasuredReason !== undefined ? { unmeasuredReason } : {}),
     };
   }
 

package/src/self-implement/gate-remote.ts

@@ -156,6 +156,8 @@ export interface RemoteRunOptions {
   repo: string;
   host: string;
   mirror: string;
+  /** Exact local commit to run instead of HEAD; permits a dirty worktree. */
+  commit?: string;
   /** argv run from the remote checkout root, e.g. ['bun', 'bin/elanous.mjs', 'self', 'gate', ...]; a function receives
    *  `sha(ref)` for each of `refs` so the remote command names the exact commit, not a ref the host may not have. */
   argv: RemoteArgv;
@@ -233,12 +235,21 @@ function revParse(runner: GateRemoteRunner, repo: string, ref: string): string |
 
 export function runOnRemote(opts: RemoteRunOptions, runner: GateRemoteRunner = realGateRemoteRunner): RemoteRunOutcome {
   const started = Date.now();
-  const status = runner.local('git', ['status', '--porcelain'], opts.repo);
-  if (status.rc !== 0) return { kind: 'infra', reason: 'git-status-failed' };
-  // A remote checkout can only reproduce a commit — uncommitted or untracked files would silently not be measured.
-  if (status.stdout.trim()) return { kind: 'infra', reason: 'dirty-tree' };
-  const commit = revParse(runner, opts.repo, 'HEAD');
-  if (!commit) return { kind: 'infra', reason: 'head-unresolved' };
+  let commit: string;
+  if (opts.commit !== undefined) {
+    if (!shaPattern.test(opts.commit)) return { kind: 'infra', reason: 'invalid-commit' };
+    const object = runner.local('git', ['cat-file', '-t', opts.commit], opts.repo);
+    if (object.rc !== 0 || object.stdout.trim() !== 'commit') return { kind: 'infra', reason: 'commit-missing' };
+    commit = opts.commit;
+  } else {
+    const status = runner.local('git', ['status', '--porcelain'], opts.repo);
+    if (status.rc !== 0) return { kind: 'infra', reason: 'git-status-failed' };
+    // A remote checkout can only reproduce a commit — uncommitted or untracked files would silently not be measured.
+    if (status.stdout.trim()) return { kind: 'infra', reason: 'dirty-tree' };
+    const head = revParse(runner, opts.repo, 'HEAD');
+    if (!head) return { kind: 'infra', reason: 'head-unresolved' };
+    commit = head;
+  }
   // Every check measures against merge-base(origin/main); without the local one the host would fall back to its mirror's
   // (possibly stale) branch — not the same measurement.
   const mainSha = revParse(runner, opts.repo, 'origin/main');

package/src/self-implement/goal-author-decompose.ts

@@ -5,6 +5,7 @@ import { llmDecomposeSteps } from '../harness/llm-decompose.js';
 import { GOAL_AUTHOR_COARSE_MAX_SLICES } from '../task-orchestrator/generator-prompt.js';
 import { getDefaultLogStore } from '../mss/logging/log-store.js';
 import { emitDecision } from '../live/detail-switch.js';
+import { selectPlanningLlm } from '../prompt-enhance/enhance.js';
 import type { GoalAuthorDeps } from './goal-author.js';
 
 const GOAL_STEPS_DECOMPOSED_EVENT = 'goal-steps-decomposed';
@@ -64,10 +65,17 @@ export function createGoalAuthorDecomposeSteps(
 ): NonNullable<GoalAuthorDeps['decomposeSteps']> {
   return async (objective, options) => {
     const { streamLLM } = await import('../llm.js');
+    // ⭐ AUTHOR-DECOMPOSE-KNOB(0.2.24 · G7 #25848) — 쪼개기·적대 비평의 두 streamLLM 호출이 인핸서와
+    //   «같은 규칙»으로 planning 노브(roleLlm.planning ⊕ ELANOUS_PROMPT_ENHANCE_MODEL/EFFORT)를 따른다.
+    //   미설정이면 종전 그대로 — model 은 아예 전달하지 않는다(streamLLM 기본 모델) ⊕ effort 는 high.
+    const { model, effort } = selectPlanningLlm();
+    const llmOpts: { model?: string; reasoningEffort: 'low' | 'medium' | 'high' } = model === undefined
+      ? { reasoningEffort: effort }
+      : { model, reasoningEffort: effort };
     let decompositionRationale: string | undefined;
     const steps = await llmDecomposeSteps(
       objective,
-      (input) => streamLLM([{ role: 'user', content: input.prompt }], () => {}, { reasoningEffort: 'high' }).then((text) => ({ text })),
+      (input) => streamLLM([{ role: 'user', content: input.prompt }], () => {}, llmOpts).then((text) => ({ text })),
       { ...(options?.context ? { context: options.context } : {}), maxTasks: GOAL_AUTHOR_COARSE_MAX_SLICES, promptProfile: 'goal-author-coarse', ...(signal ? { signal } : {}), onRationale: (rationale) => { decompositionRationale = rationale; } },
     );
     const heft = classifyHeft(objective);
@@ -120,7 +128,7 @@ export function createGoalAuthorDecomposeSteps(
       return finalSteps;
     };
     if (!reviewExecuted) return finalize(steps, decompositionRationale);
-    const critic = (prompt: string) => streamLLM([{ role: 'user', content: prompt }], () => {}, { reasoningEffort: 'high' });
+    const critic = (prompt: string) => streamLLM([{ role: 'user', content: prompt }], () => {}, llmOpts);
 
     try {
       const critique = await adversarialPlanCritique(objective, steps, critic, options?.context);

package/src/self-implement/goal-author.ts

@@ -3,7 +3,7 @@ import { existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, realpathSy
 import { spawn } from 'node:child_process';
 import { createHash, randomBytes } from 'node:crypto';
 import { dirname, isAbsolute, join, normalize, relative, resolve, sep } from 'node:path';
-import { groundMissionInCodebase, isRepositoryImplementationCandidate, type CodebaseGrounding } from '../autopilot/mission-codebase-gate.js';
+import { isRepositoryImplementationCandidate, type CodebaseGrounding } from '../autopilot/codebase-grounding.js';
 import { extractSlugSource, generateMissionSlug, slugify } from '../autopilot/mission-registry.js';
 import { enhancePrompt, type EnhanceOpts, type EnhanceResult } from '../prompt-enhance/enhance.js';
 import type { LLMUsage } from '../prompt-cache/types.js';
@@ -44,7 +44,7 @@ import { extractGoalDocSections, type GoalDocSourceLine } from './goal-doc/secti
 import { isGoalAuthorFileName } from './goal-document.js';
 import { resolveGoalDocumentsDir } from './goal-documents-dir.js';
 import { REQUIRED_EVIDENCE_COMMAND_SEPARATOR } from './off-diff-evidence.js';
-import { renderLaunchPreflight, siblingTestPath, type LaunchPreflightResult } from '../self-dev/launch-preflight.js';
+import { renderLaunchPreflight, siblingTestPath, type LaunchPreflightResult } from '../self-dev/launch-preflight-text.js';
 import { quoteShellArg } from '../cli/logs-cli.js';
 import type { HarnessGroundingProvenance } from './context-capsule.js';
 import { hasGoalStepCodeName } from './goal-step-code-name.js';
@@ -121,6 +121,21 @@ export interface GoalAuthorGroundingResult {
   facts: CodebaseGrounding;
 }
 
+// A function-local slot is initialized only on access, after cyclic ESM evaluation has finished.
+function goalAuthorGroundMissionSlot(): { fn?: NonNullable<GoalAuthorGroundingDeps['groundMission']> } {
+  const key = Symbol.for('elanous.goalAuthor.groundMission');
+  const registry = globalThis as typeof globalThis & { [key: symbol]: { fn?: NonNullable<GoalAuthorGroundingDeps['groundMission']> } };
+  return registry[key] ??= {};
+}
+
+export function registerGoalAuthorGroundMission(fn: NonNullable<GoalAuthorGroundingDeps['groundMission']> | undefined): void {
+  goalAuthorGroundMissionSlot().fn = fn;
+}
+
+export function hasGoalAuthorGroundMission(): boolean {
+  return goalAuthorGroundMissionSlot().fn !== undefined;
+}
+
 export interface GoalAuthorPersistentGroundingDecision {
   readonly enabled: boolean;
   readonly source: ObserveOnlySource;
@@ -1218,6 +1233,21 @@ function countAddressableLines(contents: string): number {
 }
 
 const TRACED_PATH_LIST_ITEM = /^\s*(?:[-*+]|\d+[.)])\s+(.+)$/;
+const TRACED_PATH_LEADING_LIST_MARKERS = /^(?:\s*(?:[-*+]|\d+[.)])\s+)+/;
+const TRACED_PATH_EVIDENCE_TAG = /^\[(?:code|skill|memory|doc|pty|unknown)\]\s+/;
+// 2026-10-11 — 저작기가 «목록 기호 두 겹»(`- - src/x.ts` · `- 1. src/x.ts` · `- [code] - src/x.ts`)을 쓰면
+//   한 겹만 벗긴 남은 «- src/…» 를 경로로 읽어 `traced path does not exist: - src/…` ERROR 를 냈다
+//   (Pod 저작에서 자식이 결과 줄 없이 죽음 · 오늘 no-result-line 18건의 공용 원인). 기호·태그를 반복해서 벗긴다.
+function tracedPathListItem(line: string): string | undefined {
+  const item = TRACED_PATH_LIST_ITEM.exec(line)?.[1];
+  if (item === undefined) return undefined;
+  let evidence = item;
+  for (;;) {
+    const next = evidence.replace(TRACED_PATH_LEADING_LIST_MARKERS, '').replace(TRACED_PATH_EVIDENCE_TAG, '');
+    if (next === evidence) return evidence;
+    evidence = next;
+  }
+}
 // ⛔⭐⭐⭐ 2026-08-11 — 이 문면은 «통하지 않는 처방»을 첫 번째로 권하고 있었다.
 //   옛 문면: *"Re-authoring the same input may produce different evidence; **retry before changing the ask**."*
 //   📏 실측(두 트랙 합산): 그 말대로 «재저작»만 반복했더니 ***0/4***. ask 에 «식별자 앵커»를 넣자 ***2/2***.
@@ -1340,9 +1370,8 @@ export function tracedPathReferences(document: string): TracedPathReference[] {
   if (!section) return [];
   const references: TracedPathReference[] = [];
   for (const line of section.split(/\r?\n/)) {
-    const item = TRACED_PATH_LIST_ITEM.exec(line)?.[1];
-    if (!item) continue;
-    const evidence = item.replace(/^\[(?:code|skill|memory|doc|pty|unknown)\]\s+/, '');
+    const evidence = tracedPathListItem(line);
+    if (!evidence) continue;
     if (isTracedPathsEvidenceUnavailable(evidence) || isTracedPathExclusionDescription(evidence)) continue;
     // 설명 구분자는 **공백으로 둘러싼** em dash 또는 hyphen 뿐이다 — 파일명 안의 dash 를 설명 구분자로 오인하지 않는다.
     // 경로 칸 안의 복수 경로는 **공백으로 둘러싼** 가운뎃점만 본다 — 파일명 안의 `·` 를 가르지 않는다.
@@ -1352,10 +1381,12 @@ export function tracedPathReferences(document: string): TracedPathReference[] {
     for (const fragment of pathField.split(' · ')) {
       const trimmed = fragment.trim();
       if (!trimmed) continue;
-      const unwrapped = stripInlineCode(trimmed);
+      // 10-11 재발 — 저작기가 «`- src/…`» 처럼 목록 기호를 백틱 «안»에 쓰면 바깥 기호만 벗긴 뒤 백틱을 벗겨
+      //   «- src/…» 가 경로로 남았다(AUTHOR-DECOMPOSE-KNOB · MODEL-BENCH-SCORES 부검). 백틱을 벗긴 뒤 한 번 더 벗긴다.
+      const unwrapped = stripInlineCode(trimmed).replace(TRACED_PATH_LEADING_LIST_MARKERS, '');
       const match = TRACED_PATH_LINE.exec(unwrapped);
       // 두 번 벗긴다 — 줄번호가 백틱 **안**(`p:42`)일 수도 **밖**(`p`:42)일 수도 있다.
-      const path = match ? stripInlineCode(match[1].trim()) : undefined;
+      const path = match ? stripInlineCode(match[1].trim()).replace(TRACED_PATH_LEADING_LIST_MARKERS, '') : undefined;
       if (!path) continue;
       references.push({ path, line: match?.[2] ? Number(match[2]) : null, endLine: match?.[3] ? Number(match[3]) : null });
     }
@@ -1446,9 +1477,8 @@ export function lintGoalFile(document: string, branch: string, deps: GoalFileLin
   const { prohibitionSymbolStartingLineCount, permissionSymbolStartingLineCount, mixedSymbolLineCount } = symbolStartingLineCounts(document);
   const { exhaustiveRequestWordingCount, blanketBehaviorPreservationCount, namedPreservationTargetCount, removalFormDecisionConditionCount } = goalAuthorKnownShapeCounts(ask);
   const tracedPathExclusionCount = (markdownSection(document, 'TRACED PATHS')?.split(/\r?\n/) ?? [])
-    .map((line) => TRACED_PATH_LIST_ITEM.exec(line)?.[1])
-    .filter((item): item is string => item !== undefined
-      && isTracedPathExclusionDescription(item.replace(/^\[(?:code|skill|memory|doc|pty|unknown)\]\s+/, ''))).length;
+    .map((line) => tracedPathListItem(line))
+    .filter((item): item is string => item !== undefined && isTracedPathExclusionDescription(item)).length;
   const selfQuestionSubjectViolations = detectSelfQuestionSubjectViolations(document);
   const launchDeclarationClassification = artifactLaunchDeclarationClassification(document);
   const headings = canonicalBlocks(document);
@@ -1679,7 +1709,7 @@ export function lintGoalFile(document: string, branch: string, deps: GoalFileLin
     });
   }
   const unavailableTracedPathEvidence = markdownSection(document, 'TRACED PATHS')?.split(/\r?\n/)
-    .map((line) => TRACED_PATH_LIST_ITEM.exec(line)?.[1])
+    .map((line) => tracedPathListItem(line))
     .find((item): item is string => item !== undefined && isTracedPathsEvidenceUnavailable(item));
   if (unavailableTracedPathEvidence) {
     const requiresTracedPaths = goalType === null || goalType === 'implement';
@@ -5583,12 +5613,17 @@ export async function groundForGoalAuthor(
   cwd: string,
   deps: GoalAuthorGroundingDeps = {},
 ): Promise<GoalAuthorGroundingResult> {
+  const groundMission = deps.groundMission ?? goalAuthorGroundMissionSlot().fn;
+  if (!groundMission) {
+    debug.log('goal-author.grounding', 'route-unregistered', { cwd });
+    throw new Error('route-unregistered: mission-codebase-gate 를 로드하라');
+  }
   return {
     path: 'groundMissionInCodebase',
     // ⛔⭐ 사람이 ask 에 «이름을 댄» 경로를 접지에 «넘긴다» — 접지가 그것을 후보로 쓴다.
     //   ⛔ 추출기를 «새로 만들지 않는다» — 이 파일이 이미 갖고 있는 askPathTokens 하나를 쓴다
     //     (2026-08-11 72차: 같은 것에 두 이름을 준 병을 하루에 여섯 번 셌다).
-    facts: await (deps.groundMission ?? groundMissionInCodebase)(ask, {
+    facts: await groundMission(ask, {
       cwd,
       seedPaths: askPathTokens(ask),
       ...(deps.persistent !== undefined ? { persistent: deps.persistent } : {}),
@@ -5694,7 +5729,7 @@ export function defaultGoalAuthorDeps(cwd: string): GoalAuthorDeps {
      *   이 칸을 «안 주므로» 기본값 `coverage-gate` 로 종전 문면을 그대로 받는다.
      */
     enhance(ask, opts) {
-      return enhancePrompt(ask, { ...opts, checklistUse: 'authoring' });
+      return enhancePrompt(ask, { ...opts, checklistUse: 'authoring', config: opts?.config ?? getUserConfig() });
     },
     readSourceFile: createRepositoryReferencedFileReader(cwd),
     runHelpProbe: (argv) => runDefaultHelpProbe(cwd, argv),

package/src/self-implement/goal-digest.ts

@@ -89,6 +89,25 @@ function scaled(limit: number): { reserved: number; minSection: number } {
   return { reserved: Math.floor(RESERVED_FOR_NOTICE * k), minSection: Math.max(40, Math.floor(MIN_SECTION_CHARS * k)) };
 }
 
+/** 골 문서에서 `판정 신호` 절만 뽑아 리뷰 acceptance 로 쓴다. 계보 = self-implement seams. */
+export function extractHarnessReviewAcceptance(goalDocument: string | undefined): { goal: string | undefined; acceptance: string | undefined } {
+  let goal: string | undefined;
+  try {
+    goal = goalDocument?.trim() || undefined;
+  } catch {
+    return { goal: undefined, acceptance: undefined };
+  }
+  if (!goal) return { goal: undefined, acceptance: undefined };
+  try {
+    const acceptance = splitGoalSections(supervisorGoalDigest(goal, 3000).text)
+      .find((section) => isSupervisorDecisionSection(section.title) && section.title.includes('판정 신호'))
+      ?.body.trim() || undefined;
+    return { goal, acceptance };
+  } catch {
+    return { goal, acceptance: undefined };
+  }
+}
+
 /** `## <제목>` 기준으로 절을 가른다. 헤더 앞 서두는 제목 `''` 로 담는다. */
 export function splitGoalSections(goal: string): Section[] {
   return extractGoalDocSections(goal, {

package/src/self-implement/graph-overlay-condition.ts

@@ -1,3 +1,5 @@
+import type { RunStopClass } from './run-stop.js';
+
 /** ⭐ RFC §5 «4단계» — `applies_when` 을 «코드»가 판정한다.
  *
  *  ⛔⭐ **표현식 엔진을 만들지 않는다.** 문법이 넓어지면 오버레이가 «작은 프로그램»이 되고,
@@ -31,6 +33,32 @@ export function parseOverlayCondition(source: string): OverlayConditionParse {
   return { ok: true, condition: { key: key!, operator: operator as OverlayConditionOperator, literal } };
 }
 
+/** Inputs known at a runtime overlay decision. Every field except `attempts` may be unknown. */
+export interface RuntimeOverlayStateInput {
+  readonly attempts: number;
+  readonly goalId?: string;
+  readonly stopClass?: RunStopClass;
+  readonly reviewRepeat?: number;
+  /** Only a real boolean is a measurement. */
+  readonly siblingOverlap?: unknown;
+  readonly mainSyncConflict?: unknown;
+  /** Only a non-empty string is a measurement. */
+  readonly authorGrade?: unknown;
+}
+
+/** ⛔ 아는 값만 싣는다 — 모르면 키를 «뺀다». 0·false·빈 문자열을 지어내지 않는다. */
+export function buildRuntimeOverlayState(input: RuntimeOverlayStateInput): Record<string, unknown> {
+  return {
+    attempts: input.attempts,
+    ...(input.goalId === undefined ? {} : { goal_id: input.goalId }),
+    ...(input.stopClass === undefined ? {} : { stop_class: input.stopClass }),
+    ...(typeof input.reviewRepeat === 'number' && Number.isFinite(input.reviewRepeat) ? { review_repeat: input.reviewRepeat } : {}),
+    ...(typeof input.siblingOverlap === 'boolean' ? { sibling_overlap: input.siblingOverlap } : {}),
+    ...(typeof input.mainSyncConflict === 'boolean' ? { main_sync_conflict: input.mainSyncConflict } : {}),
+    ...(typeof input.authorGrade === 'string' && input.authorGrade.length > 0 ? { author_grade: input.authorGrade } : {}),
+  };
+}
+
 export type OverlayConditionVerdict =
   /** 조건이 참이다 — 얹는다. */
   | { readonly kind: 'applies' }
@@ -53,6 +81,10 @@ export function evaluateOverlayCondition(
   const { key, operator, literal } = parsed.condition;
   if (!(key in state)) return { kind: 'key-absent', key };
   const actual = state[key];
+  if (actual === undefined || actual === null) return { kind: 'key-absent', key };
+  // Measured boolean branch keys accept only a real boolean observation — any textual lookalike
+  // ('true', 'TRUE', 'yes', 1) is unknown, whatever the literal spelling in the condition.
+  if ((key === 'sibling_overlap' || key === 'main_sync_conflict') && typeof actual !== 'boolean') return { kind: 'key-absent', key };
 
   if (typeof literal === 'number') {
     // ⛔ 수 비교인데 값이 수가 아니면 「비교 불가」다 — 거짓으로 접지 않는다.

package/src/self-implement/graph-overlay-yaml.ts

@@ -1,7 +1,7 @@
 import { readFileSync, readdirSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { parse as parseYaml } from 'yaml';
+import { parse as parseYaml, parseAllDocuments } from 'yaml';
 import { inspectPipelineGraph, type PipelineGraphDefect } from './pipeline-shape.js';
 import { edgeMapOf, type GraphParseIssue, type GraphTemplateSpec } from './graph-yaml.js';
 import { evaluateOverlayCondition } from './graph-overlay-condition.js';
@@ -15,7 +15,8 @@ import type { OverlayPatch } from './graph-overlay.js';
  *    ⑴ 얹은 «결과»에 위상 검사를 다시 건다 — 노드 집합이 그대로여도 도달 가능성은 바뀐다
  *    ⑵ 계약이 빠진 노드를 «거부»한다 — 권한 없는 노드가 조용히 들어오는 것을 막는다
  *    ⑶ 무엇을 얹었는지를 «값»으로 낸다 — 사후에 「왜 이 걸음인가」를 답하려면 필요하다 */
-export type OverlayStage = 'launch' | 'runtime';
+/** `heal` = 멈춤 갈래 사다리 전용 — `stop-autoheal.ts` 만 고른다. 실행기의 launch·runtime 선택에는 «안» 잡힌다. */
+export type OverlayStage = 'launch' | 'runtime' | 'heal';
 
 export interface OverlayPatchOp {
   readonly op: 'add' | 'replace' | 'remove';
@@ -33,19 +34,52 @@ export interface GraphOverlaySpec {
 }
 
 export interface OverlayParseResult {
+  /** 첫 오버레이 — 한 파일에 하나만 둔 기존 선언의 읽기 자리. */
   readonly overlay?: GraphOverlaySpec;
+  /** 파일이 선언한 오버레이 전부. `---` 로 문서를 나누면 한 파일에 여럿이다. 오류가 하나라도 있으면 비어 있다. */
+  readonly overlays: readonly GraphOverlaySpec[];
   readonly errors: readonly GraphParseIssue[];
 }
 
-const STAGES = new Set<OverlayStage>(['launch', 'runtime']);
+const STAGES = new Set<OverlayStage>(['launch', 'runtime', 'heal']);
 const OPS = new Set(['add', 'replace', 'remove']);
 
-/** ⛔ 던지지 않는다 — 파서 계약은 `graph-yaml.ts` 와 같다. */
+/** ⛔ 던지지 않는다 — 파서 계약은 `graph-yaml.ts` 와 같다.
+ *  한 파일 = 문서 하나가 기본이다. `---` 로 나눈 여러 문서는 문서마다 오버레이 하나로 읽는다
+ *  (오류 경로는 `<label>#<문서 번호>`). 문서가 하나면 읽는 법도 오류 문면도 예전과 같다. */
 export function parseGraphOverlayYaml(source: string, label = '<inline>'): OverlayParseResult {
-  const errors: GraphParseIssue[] = [];
   let raw: unknown;
   try { raw = parseYaml(source); }
-  catch (error) { return { errors: [{ path: label, message: `YAML 파싱 실패: ${error instanceof Error ? error.message : String(error)}` }] }; }
+  catch (error) {
+    const documents = parseAllDocuments(source);
+    if (documents.length > 1 && documents.every((document) => document.errors.length === 0)) {
+      return overlaysFromDocuments(documents.map((document) => document.toJS() as unknown), label);
+    }
+    return { overlays: [], errors: [{ path: label, message: `YAML 파싱 실패: ${error instanceof Error ? error.message : String(error)}` }] };
+  }
+  const parsed = overlayFromRaw(raw, label);
+  return { ...(parsed.overlay ? { overlay: parsed.overlay } : {}), overlays: parsed.overlay ? [parsed.overlay] : [], errors: parsed.errors };
+}
+
+function overlaysFromDocuments(raws: readonly unknown[], label: string): OverlayParseResult {
+  const errors: GraphParseIssue[] = [];
+  const overlays: GraphOverlaySpec[] = [];
+  for (const [index, raw] of raws.entries()) {
+    const parsed = overlayFromRaw(raw, `${label}#${index}`);
+    errors.push(...parsed.errors);
+    if (parsed.overlay) overlays.push(parsed.overlay);
+  }
+  const seen = new Set<string>();
+  for (const overlay of overlays) {
+    if (seen.has(overlay.overlayId)) errors.push({ path: `${label}/overlay_id`, message: `overlay_id '${overlay.overlayId}' 가 한 파일에서 중복이다` });
+    seen.add(overlay.overlayId);
+  }
+  if (errors.length > 0) return { overlays: [], errors };
+  return { overlay: overlays[0]!, overlays, errors };
+}
+
+function overlayFromRaw(raw: unknown, label: string): { overlay?: GraphOverlaySpec; errors: GraphParseIssue[] } {
+  const errors: GraphParseIssue[] = [];
   if (raw === null || typeof raw !== 'object') return { errors: [{ path: label, message: 'YAML 최상위가 맵이 아니다' }] };
   const doc = raw as Record<string, unknown>;
 
@@ -198,7 +232,7 @@ export function loadGraphOverlays(dir: string): OverlayLoadResult {
     catch (error) { errors.push({ path: file, message: `읽기 실패: ${error instanceof Error ? error.message : String(error)}` }); continue; }
     const result = parseGraphOverlayYaml(source, file);
     errors.push(...result.errors);
-    if (result.overlay) overlays.push(result.overlay);
+    overlays.push(...result.overlays);
   }
   return { overlays, errors, scannedFiles: files.length };
 }

package/src/self-implement/graph-templates.ts

@@ -23,6 +23,7 @@ export interface GraphTemplateNode {
   readonly kind: GraphNodeSpec['kind'];
   /** 그 노드의 재방문 상한. ⛔ 지금의 rework 상한이 «여기로 올라올» 자리다(RFC §4.1). */
   readonly maxVisits: number;
+  readonly journeyStage?: string;
   /** YAML recipe identifier; existing orchestrator does not execute it. */
   readonly recipe?: string;
   /** YAML이 선언한 선택 계약. 관측용이며 실행 권한을 강제하지 않는다. */
@@ -34,6 +35,7 @@ export interface GraphTemplate {
   readonly version: string;
   readonly entryNode: string;
   readonly terminalNodes: readonly string[];
+  readonly journeyStages?: readonly string[];
   /** YAML 템플릿이 선언한 문서 전용 변경의 gate 건너뛰기 정책. */
   readonly docsOnlyGateSkip?: boolean;
   /** 선언된 런 계약(선택) — 런 시작 때 발사 인자·부모 계약과 함께 한 번 해석된다. */
@@ -104,7 +106,7 @@ export function defaultGraphsDir(): string {
   return join(dirname(fileURLToPath(import.meta.url)), '..', '..', 'graphs');
 }
 
-export type DiscardedGraphNodeField = Exclude<keyof GraphNodeSpec, 'nodeId' | 'kind' | 'maxVisits' | 'recipe' | 'contract'>;
+export type DiscardedGraphNodeField = Exclude<keyof GraphNodeSpec, 'nodeId' | 'kind' | 'maxVisits' | 'journeyStage' | 'recipe' | 'contract'>;
 
 export interface GraphTemplateCompilation {
   readonly template: GraphTemplate;
@@ -129,12 +131,14 @@ export function compileGraphTemplate(spec: GraphTemplateSpec): GraphTemplateComp
       version: String(spec.version),
       entryNode: spec.entryNode,
       terminalNodes: spec.terminalNodes,
+      ...(spec.journeyStages === undefined ? {} : { journeyStages: spec.journeyStages }),
       ...(spec.docsOnlyGateSkip !== undefined ? { docsOnlyGateSkip: spec.docsOnlyGateSkip } : {}),
       ...(spec.runContract !== undefined ? { runContract: spec.runContract } : {}),
       nodes: spec.nodes.map((n) => ({
         nodeId: n.nodeId,
         kind: n.kind,
         maxVisits: n.maxVisits,
+        ...(n.journeyStage === undefined ? {} : { journeyStage: n.journeyStage }),
         ...(n.recipe === undefined ? {} : { recipe: n.recipe }),
         ...(n.contract === undefined ? {} : { contract: n.contract }),
       })),
@@ -324,6 +328,34 @@ export function inspectAllTemplates(): Array<{ graphId: string; defects: Pipelin
     .map((t) => ({ graphId: t.graphId, defects: inspectPipelineGraph(t.edges, t.entryNode) }));
 }
 
+/** L0 ratios are distinct: stages represented by nodes, and nodes accounted for by this run. */
+export function measureL0Coverage(
+  template: GraphTemplate,
+  enteredNodes: Iterable<string>,
+  skippedNodes: Iterable<string>,
+): {
+  declarationCoverage: number | null;
+  traversalCoverage: number | null;
+  declaredStageCount: number;
+  listedStageCount: number;
+  accountedNodeCount: number;
+  declaredNodeCount: number;
+} {
+  const stages = template.journeyStages ?? [];
+  const declaredStages = new Set(template.nodes.map((node) => node.journeyStage).filter((stage): stage is string => stage !== undefined && stages.includes(stage)));
+  const accounted = new Set([...enteredNodes, ...skippedNodes]);
+  const declaredNodeCount = template.nodes.length;
+  const accountedNodeCount = template.nodes.filter((node) => accounted.has(node.nodeId)).length;
+  return {
+    declarationCoverage: stages.length ? declaredStages.size / stages.length : null,
+    traversalCoverage: declaredNodeCount ? accountedNodeCount / declaredNodeCount : null,
+    declaredStageCount: declaredStages.size,
+    listedStageCount: stages.length,
+    accountedNodeCount,
+    declaredNodeCount,
+  };
+}
+
 /** ⭐ 원장에 실을 «그래프 신원» — ⛔ 옛 TS 상수가 아니라 «지금 도는 템플릿»을 따른다.
  *
  *  🩸 계기(2026-09-08): 승격을 켠 research 런이 `investigate` 를 밟았는데 원장의