elanous 0.2.34 → 0.2.35

package/src/self-dev/graph-front-nodes.ts

@@ -1,6 +1,10 @@
 import { debug } from '../debug/log.js';
+import type { GoalType } from '../self-implement/goal-author.js';
 import { frontObservationTemplate, visitBudgetOfVisits, type VisitBudgetReading } from '../self-implement/graph-authority.js';
 import { GRAPH_TEMPLATES_SOURCE, graphIdentityOf, pipelineNodeEntryPayload, type GraphTemplate } from '../self-implement/graph-templates.js';
+import { appendRunLedgerEntry, runLedgerDir } from '../self-implement/run-ledger.js';
+import { journeyJoinFields } from './graph-journey-nodes.js';
+import { journeySpec, readJourneyEdge, recordJourneyEdge, type JourneyRoute } from './graph-journey-route.js';
 
 /** ⭐ RFC §5 «5단계» — 전반부(저작·플랜·분해) 노드를 그래프 관측에 «잇는다».
  *
@@ -51,6 +55,25 @@ export function resetFrontVisitCountsForTesting(now?: () => number): void {
   lastFrontVisitPruneMs = Number.NEGATIVE_INFINITY;
 }
 
+/** Record the actual front-half execution boundary, without controlling the stage. */
+export async function observeFrontNodeUnit<T>(node: FrontNodeId, runId: string | undefined, goalType: GoalType | undefined, execute: () => Promise<T>): Promise<T> {
+  const emit = (phase: 'enter' | 'exit'): void => {
+    if (!runId) return;
+    try {
+      const template = frontObservationTemplate(goalType);
+      const contractId = template.nodes.find((item) => item.nodeId === node)?.recipe ?? null;
+      const data = { graphId: template.graphId, nodeId: node, unit: node, contractId, phase };
+      try { appendRunLedgerEntry({ timestamp: new Date().toISOString(), runId, event: 'graph.unit', data }, runLedgerDir()); }
+      catch { /* ledger failure cannot change execution */ }
+      try { debug.log('graph.unit', phase, { ...data, runId }); }
+      catch { /* debug failure cannot change execution */ }
+    } catch { /* template failure cannot change execution */ }
+  };
+  emit('enter');
+  try { return await execute(); }
+  finally { emit('exit'); }
+}
+
 function pruneIdleFrontVisitRuns(nowMs: number): void {
   if (nowMs - lastFrontVisitPruneMs < FRONT_VISIT_PRUNE_INTERVAL_MS) return;
   lastFrontVisitPruneMs = nowMs;
@@ -120,3 +143,92 @@ export function observeFrontNodeEntry(node: FrontNodeId, data: {
     });
   } catch { /* 판독 실패는 fail-soft — 예산은 관측이고 저작을 막지 않는다 */ }
 }
+
+/** GRAPH-AUTHOR-FAIL-EDGE — author 결과가 고르는 «앞단 결과 노드». ⛔ 런타임 값 — YAML 이 더한 노드를 시험이 센다. */
+export const AUTHOR_OUTCOME_NODE_IDS = ['re-ground', 'needs-human'] as const;
+
+/** author 노드의 결과 라벨 — implement-loop.yaml `from: author · on: outcome` 의 map 키와 «같은» 닫힌 집합. */
+export const AUTHOR_EXIT_OUTCOMES = ['ok', 're-authored', 'not-grounded', 'fail'] as const;
+export type AuthorExitOutcome = typeof AUTHOR_EXIT_OUTCOMES[number];
+
+export type FrontNodeExit =
+  | { readonly node: 'author'; readonly outcome: AuthorExitOutcome }
+  | { readonly node: 're-ground'; readonly outcome: 'retry' };
+
+export interface FrontNodeExitData {
+  /** 1 = 첫 저작 · 2 = 자동 재저작(re-ground 를 한 번 지난 뒤). */
+  readonly attempt: number;
+  /** 코드가 «실제로» 간 다음 노드 — 그래프 답과 다르면 graph-edge-taken 이 honored:false 로 남긴다. 없으면 그래프 답. */
+  readonly taken?: string;
+  readonly reason?: string;
+  readonly runId?: string;
+  readonly goalId?: string;
+  readonly goalType?: string;
+  readonly goalFile?: string;
+  /** 근거 카드 — needs-human 으로 갈 때 사람이 «무엇 때문에»를 다시 캐지 않게 막힘을 그대로 싣는다. */
+  readonly blockers?: readonly { readonly kind: string; readonly name: string; readonly detail?: string }[];
+}
+
+const EVIDENCE_DETAIL_CHARS = 400;
+
+/** 그래프가 고른 다음 노드에 «방문 예산»을 겹친다 — re-ground(max_visits 1)를 이미 지났으면 같은 결과의
+ *  두 번째는 re-ground 가 아니라 author 의 `fail` 출구(needs-human)로 간다. ⛔ 노드 이름·예산은 선언에서 읽는다. */
+function withVisitBudget(route: JourneyRoute, exit: FrontNodeExit, attempt: number): { readonly to: string | null; readonly budgetReason?: string } {
+  // ⛔ 예산을 겹치는 대상은 re-ground 뿐이다 — attempt-1 은 «re-ground 를 지난 횟수»이지 다른 노드의 방문 수가 아니다.
+  if (exit.node !== 'author' || route.to !== 're-ground') return { to: route.to };
+  const target = journeySpec({}).spec?.nodes.find((node) => node.nodeId === route.to);
+  const priorVisits = Math.max(0, attempt - 1);
+  if (target === undefined || priorVisits < target.maxVisits) return { to: route.to };
+  const exhausted = readJourneyEdge('author', 'fail');
+  return { to: exhausted.to, budgetReason: `${route.to}-visit-budget-exhausted (max_visits ${target.maxVisits})` };
+}
+
+/** ⭐ GRAPH-AUTHOR-FAIL-EDGE ① — 앞 노드의 «나감»을 결과와 함께 남긴다(진입만 있던 자리).
+ *  호출부(실행 경로): src/self-dev/ask-launch-flow.ts — 저작 끝(author ok · not-grounded · re-authored) ·
+ *    저작기 throw(author fail) · 자동 재저작 시작(re-ground retry).
+ *  🔎 관측: `self-implement` / `front-node-exit` ⊕ 같은 자리의 `graph-edge-taken`(from author|re-ground).
+ *  ⛔ 관측이지 제어가 아니다 — 다음 걸음은 여전히 코드가 정하고, 그래프 답과 다르면 honored:false 로 남는다.
+ *  ⛔ fail-soft — 관측 실패가 저작을 죽이지 않는다. */
+export function observeFrontNodeExit(exit: FrontNodeExit, data: FrontNodeExitData): JourneyRoute | null {
+  let recorded: JourneyRoute | null = null;
+  try {
+    const route = readJourneyEdge(exit.node, exit.outcome);
+    const budget = withVisitBudget(route, exit, data.attempt);
+    const graphRoute: JourneyRoute = { ...route, to: budget.to };
+    const taken = data.taken ?? budget.to ?? exit.outcome;
+    const reason = [budget.budgetReason, data.reason].filter((part): part is string => part !== undefined).join(' · ');
+    recordJourneyEdge(graphRoute, taken, reason.length > 0 ? reason : undefined);
+    recorded = graphRoute;
+    const payload = {
+      graphId: 'self-implement',
+      node: exit.node,
+      outcome: exit.outcome,
+      attempt: data.attempt,
+      to: budget.to,
+      taken,
+      honored: budget.to === null || budget.to === taken,
+      ...(reason.length > 0 ? { reason } : {}),
+      ...(data.runId === undefined ? {} : { runId: data.runId }),
+      ...(data.goalId === undefined ? {} : { goalId: data.goalId }),
+      ...(data.goalType === undefined ? {} : { goalType: data.goalType }),
+      ...(data.goalFile === undefined ? {} : { goalFile: data.goalFile }),
+      ...(data.blockers === undefined || data.blockers.length === 0 ? {} : {
+        evidenceCard: data.blockers.map((blocker) => ({
+          kind: blocker.kind, name: blocker.name,
+          ...(blocker.detail === undefined ? {} : { detail: blocker.detail.slice(0, EVIDENCE_DETAIL_CHARS) }),
+        })),
+      }),
+      phase: 'front',
+      graphTemplatesSource: GRAPH_TEMPLATES_SOURCE,
+      ...journeyJoinFields(),
+    };
+    try { debug.log('self-implement', 'front-node-exit', payload); }
+    catch { /* debug failure cannot change authoring */ }
+    // Pod 의 logs.db 는 Job 과 사라진다 — 원장에도 남겨 호스트가 NOT-GROUNDED 의 길을 사후에 읽게 한다.
+    if (data.runId !== undefined) {
+      try { appendRunLedgerEntry({ timestamp: new Date().toISOString(), runId: data.runId, event: 'front-node-exit', data: payload }, runLedgerDir()); }
+      catch { /* ledger failure cannot change authoring */ }
+    }
+  } catch { /* 관측은 fail-soft — 저작을 죽이지 않는다 */ }
+  return recorded;
+}

package/src/self-dev/graph-journey-nodes.ts

@@ -39,6 +39,7 @@ export const JOURNEY_NODE_IDS = [
   'salvage',
   'heal',
   'next-move',
+  'decision-card',
   'ready',
   'pr-head-checkout',
   'stopped',

package/src/self-dev/harness-run-cli.ts

@@ -1,28 +1,16 @@
 import { buildHarnessRunDevSpec, runDevPipeline, type DevHarnessDispatchArgs, type DevPipelineDeps } from './dev-pipeline.js';
 import type { SurfaceUxSource } from '../agent/surface-ux/build.js';
 import { debug } from '../debug/log.js';
-import { CLI_HARNESS_RUN_ENTRANCE, describeEntranceCommand, retiredEntranceNotice } from './entrance-registry.js';
+import { CLI_HARNESS_RUN_ENTRANCE, retiredEntranceNotice } from './entrance-registry.js';
+import { HARNESS_RUN_REPLACEMENT } from './cli-help-text.js';
+export { HARNESS_RUN_REPLACEMENT, HARNESS_RUN_DEPRECATION_HELP } from './cli-help-text.js';
 
 /** `elanous logs --category`로 레거시 입구의 제거 안전시점을 조회하는 브레드크럼. */
 export const HARNESS_RUN_DEPRECATION_LOG_CATEGORY = 'harness-cli.deprecated';
-export const HARNESS_RUN_REPLACEMENT = 'elanous harness say <objective>';
 /** 실행 «중»에 사람에게 내는 한 줄. ⛔ `--help` 용은 아래 HARNESS_RUN_DEPRECATION_HELP 다 —
  *  그쪽은 레지스트리가 은퇴 표시와 «갈 곳»을 이미 붙이므로 여기서 그것을 되풀이하지 않는다. */
 export const HARNESS_RUN_DEPRECATION_NOTICE = `ℹ️  \`elanous harness run\`은 deprecated 입구입니다 — \`${HARNESS_RUN_REPLACEMENT}\`로 이행하세요.`;
 
-/** `--help` 머리에 붙는 은퇴 표시.
- *
- *  ⛔⭐ **문면을 «손으로 짓지 않는다»** — 레지스트리가 낸다(RFC-one-door-many-entrances P2).
- *  📏 2026-08-20 실측: 은퇴로 «선언»된 입구 셋 중 `--help` 가 그 사실을 말한 것은 하나뿐이었고,
- *  ***그 하나(여기)조차 문면을 레지스트리와 «따로» 들고 있었다.***
- *  ⇒ 🔑 선언과 표면이 «두 곳»에 살면 한쪽만 고쳐지고 다른 쪽이 조용히 늙는다.
- *  ⚠️ 상수 «이름»은 유지한다 — 시험과 index.ts 가 이 이름으로 읽는다(뜻이 좁아지지 않는다). */
-export const HARNESS_RUN_DEPRECATION_HELP = describeEntranceCommand(
-  CLI_HARNESS_RUN_ENTRANCE,
-  HARNESS_RUN_REPLACEMENT,
-  '이 입구는 더 이상 실행되지 않습니다.',
-).trimEnd();
-
 /** ⭐ 진행 릴레이를 «단 곳» — 하니스 시퀀서가 스테이지마다 내는 progress 를 CLI 부모 stdout 까지 잇는다.
  *
  *  ⛔ **왜 `ctx` 가 아니라 `deps.uxSource` 인가**: `dispatchRunDevHarness` 의 detached 가드가

package/src/self-dev/orchestrate-cli-text.ts

@@ -0,0 +1,10 @@
+/** Shared, dependency-free text rules for both orchestrate CLI entrances. */
+export function splitOrchestrateGoalTexts(parts: readonly string[]): string[] {
+  const joined = parts.join(' ');
+  return (joined.includes(';;') ? joined.split(';;') : parts).map((goal) => goal.trim()).filter(Boolean);
+}
+
+export function normalizeOrchestrateRequest(input: readonly string[] | string): string {
+  const joined = typeof input === 'string' ? input : input.join(' ');
+  return joined.replace(/;;/g, ' ').trim();
+}

package/src/self-dev/review-provider-fallback.ts

@@ -107,6 +107,36 @@ export function parseTeamclaudeBaseUrl(stdout: string): string | undefined {
   return match?.[1];
 }
 
+export interface TeamclaudeReviewRoute {
+  /** Present only when teamclaude printed its proxy base URL: the cct ACP spawn (billing scrub ⊕ base-url). */
+  spawn?: ReturnType<typeof subscriptionReviewerSpawn>;
+  reason: 'teamclaude-base-url' | 'teamclaude-no-base-url' | 'teamclaude-unavailable';
+  exit?: number | null;
+}
+
+/**
+ * ACP-REVIEW-VIA-TEAMCLAUDE (0.2.35): the explicit `--acp-backend claude` review reuses the cct route of the
+ * subscription lane — `teamclaude env --no-mitm` → base URL → `subscriptionReviewerSpawn` — without the quota gate
+ * (an explicit flag is the operator's choice). teamclaude missing or silent = no spawn; the caller keeps its prior path.
+ */
+export function resolveTeamclaudeReviewRoute(
+  env: NodeJS.ProcessEnv = process.env,
+  runStatus: NonNullable<SubscriptionReviewerDeps['runStatus']> = (command, args, cleanEnv) =>
+    spawnSync(command, args, { env: { ...cleanEnv, NODE_ENV: process.env.NODE_ENV }, encoding: 'utf8', timeout: 5_000 }),
+): TeamclaudeReviewRoute {
+  const spec: SubscriptionReviewerSpec = { provider: 'claude-acp', executor: 'cct' };
+  try {
+    const proxy = runStatus('teamclaude', ['env', '--no-mitm'], subscriptionReviewerSpawn(spec, env).env);
+    // Bun reports a missing binary as `status: undefined` (Node: null) — both mean «no teamclaude here».
+    if (proxy.status == null) return { reason: 'teamclaude-unavailable' };
+    const baseUrl = proxy.status === 0 ? parseTeamclaudeBaseUrl(String(proxy.stdout ?? '')) : undefined;
+    if (!baseUrl) return { reason: 'teamclaude-no-base-url', exit: proxy.status };
+    return { spawn: subscriptionReviewerSpawn(spec, env, baseUrl), reason: 'teamclaude-base-url' };
+  } catch {
+    return { reason: 'teamclaude-unavailable' };
+  }
+}
+
 /** Guard the ACP review before spawning. An unmeasured quota never authorizes subscription use. */
 export function subscriptionReviewerAvailability(
   spec: SubscriptionReviewerSpec,
@@ -291,7 +321,7 @@ export interface ReviewFallbackObservation {
 export async function runReviewWithFallback(
   attempts: readonly ReviewProviderAttempt[],
   call: (attempt: ReviewProviderAttempt, observeResolvedProvider: (provider?: string) => void) => Promise<string>,
-  observe: (event: 'attempt' | 'resolved' | 'fallback' | 'exhausted', data: ReviewFallbackObservation) => void = () => {},
+  observe: (event: 'attempt' | 'resolved' | 'completed' | 'fallback' | 'exhausted', data: ReviewFallbackObservation) => void = () => {},
 ): Promise<{ text: string; used: ReviewProviderAttempt; attemptIndex: number }> {
   if (attempts.length === 0) throw new Error('review fallback: no attempts configured');
   let lastError: unknown;
@@ -318,6 +348,10 @@ export async function runReviewWithFallback(
       if (resolvedProvider) {
         try { observe('resolved', { ...base, resolvedProvider }); } catch { /* fail-soft */ }
       }
+      // Provider calls are attempts; only a non-empty artifact completes a logical review round.
+      if (text.trim()) {
+        try { observe('completed', { ...base, ...(resolvedProvider ? { resolvedProvider } : {}) }); } catch { /* fail-soft */ }
+      }
       return { text, used: attempt, attemptIndex: i };
     } catch (error) {
       lastError = error;

package/src/self-dev/self-orchestrate-runtime.ts

@@ -329,17 +329,7 @@ type OrchestrateRunIdentityResolver = (input: { explicit?: string; inherited?: s
 type OrchestrateResumeDisposition = 'skip' | 'rerun' | 'rerun-duplicate-risk';
 type OrchestrateResumeDispositionClassifier<T> = (result: T) => OrchestrateResumeDisposition;
 
-/** `harness orchestrate` 와 `self orchestrate` 가 공유하는 `;;` goal 분리 규칙. */
-export function splitOrchestrateGoalTexts(parts: readonly string[]): string[] {
-  const joined = parts.join(' ');
-  return (joined.includes(';;') ? joined.split(';;') : parts).map((goal) => goal.trim()).filter(Boolean);
-}
-
-/** `harness orchestrate` 와 `self orchestrate` 가 공유하는 `;;` 요청 문자열 결합 규칙. */
-export function normalizeOrchestrateRequest(input: readonly string[] | string): string {
-  const joined = typeof input === 'string' ? input : input.join(' ');
-  return joined.replace(/;;/g, ' ').trim();
-}
+export { splitOrchestrateGoalTexts, normalizeOrchestrateRequest } from './orchestrate-cli-text.js';
 
 /** `harness orchestrate` 와 `self orchestrate` 가 공유하는 분해 준비 인자 조립 규칙. */
 export function buildOrchestrateDecomposePrepareArgs<

package/src/self-dev/shard-aggregate.ts

@@ -1,3 +1,6 @@
+import { realpathSync } from 'node:fs';
+import { isAbsolute, relative, resolve, sep } from 'node:path';
+import { debug } from '../debug/log.js';
 import {
   allowsBaselineOnlyFailure,
   buildGateBaselineReport,
@@ -21,6 +24,10 @@ export interface GateShardAttempt {
   /** LIGHT-RC-MEASURE — the shard files that exist in the baseline tree, i.e. what the baseline side actually ran.
    *  Absent = every shard file (the old shape). Empty = the baseline side was not run and contributes zero cases. */
   baselineFiles?: readonly string[];
+  /** SHARD-JUNIT-ABS-PATH — the tree each side ran in. bun writes an absolute JUnit `file` once a test process.chdir()s;
+   *  such a path under this root is read as the cohort-relative file. Absent = absolute paths stay rejected (old shape). */
+  currentRoot?: string;
+  baselineRoot?: string;
 }
 
 export interface GateShardAggregate {
@@ -125,7 +132,32 @@ function textOf(element: XmlElement): string {
   return element.text + element.children.map(textOf).join('');
 }
 
-function readJUnit(xml: string, files: readonly string[]): JUnitCase[] | undefined {
+const realOrResolved = (path: string): string => {
+  try { return realpathSync(path); } catch { return resolve(path); }
+};
+
+/** SHARD-JUNIT-ABS-PATH — an absolute JUnit `file` under `root` becomes the cohort-relative path. Both sides are
+ *  realpath'd (macOS /tmp ↔ /private/tmp). A path outside the root is returned unchanged, so the cohort check rejects it. */
+function junitPathNormalizer(root: string | undefined): (file: string | undefined) => string | undefined {
+  if (!root) return (file) => file;
+  const realRoot = realOrResolved(root);
+  const seen = new Map<string, string>();
+  return (file) => {
+    if (file === undefined || !isAbsolute(file)) return file;
+    const cached = seen.get(file);
+    if (cached !== undefined) return cached;
+    const rel = relative(realRoot, realOrResolved(file));
+    const inside = rel !== '' && !rel.startsWith('..') && !isAbsolute(rel);
+    const to = inside ? rel.split(sep).join('/') : file;
+    seen.set(file, to);
+    if (inside) debug.log('gate.shard', 'junit-path-normalized', { from: file, to });
+    else debug.log('gate.shard', 'junit-path-outside-root', { from: file, root: realRoot });
+    return to;
+  };
+}
+
+function readJUnit(xml: string, files: readonly string[], treeRoot?: string): JUnitCase[] | undefined {
+  const normalize = junitPathNormalizer(treeRoot);
   const root = parseXml(xml);
   if (!root || (root.name !== 'testsuites' && root.name !== 'testsuite')) return undefined;
   const expected = new Set(files);
@@ -140,7 +172,7 @@ function readJUnit(xml: string, files: readonly string[]): JUnitCase[] | undefin
     || (/^(0|[1-9]\d*)$/.test(value) && Number(value) === actual);
   // Each suite's tests attribute covers its descendants too: compare subtree totals.
   const walkSuite = (suite: XmlElement, parentFile: string | undefined): { tests: number; failures: number; errors: number } | undefined => {
-    const file = suite.attrs.file ?? parentFile;
+    const file = normalize(suite.attrs.file) ?? parentFile;
     const declared = Number(suite.attrs.tests);
     if ((file && !expected.has(file)) || !Number.isSafeInteger(declared) || declared < 0) return undefined;
     const total = { tests: 0, failures: 0, errors: 0 };
@@ -150,7 +182,7 @@ function readJUnit(xml: string, files: readonly string[]): JUnitCase[] | undefin
         if (!sub) return undefined;
         total.tests += sub.tests; total.failures += sub.failures; total.errors += sub.errors;
       } else if (child.name === 'testcase') {
-        const caseFile = child.attrs.file ?? file;
+        const caseFile = normalize(child.attrs.file) ?? file;
         const leaf = child.attrs.name;
         if (!caseFile || !expected.has(caseFile) || !leaf || (file && file !== caseFile)) return undefined;
         total.tests++;
@@ -245,14 +277,16 @@ export function aggregateGateTestShards(shards: readonly GateTestShard[], attemp
   const retryShardIds: string[] = [];
   const current: JUnitCase[] = [];
   const baseline: JUnitCase[] = [];
+  // 기준선 JUnit 전체 testcase(통과·실패·스킵 포함). 귀속 일치 확인용이라 판정 재료인 `baseline`(스킵 제외)과 분리한다.
+  const baselineTestCases: JUnitCase[] = [];
   const skippedRegressions: JUnitCase[] = [];
   for (const shard of shards) {
     const attempt = selected.get(shard.id);
-    const head = attempt?.currentJUnit === undefined ? undefined : readJUnit(attempt.currentJUnit, shard.files);
+    const head = attempt?.currentJUnit === undefined ? undefined : readJUnit(attempt.currentJUnit, shard.files, attempt.currentRoot);
     // LIGHT-RC-MEASURE ① — the baseline side reads only the files that exist in the baseline tree; none = not run.
     const baselineFiles = attempt?.baselineFiles ?? shard.files;
     const baselineSkipped = baselineFiles.length === 0;
-    const base = baselineSkipped ? [] : attempt?.baselineJUnit === undefined ? undefined : readJUnit(attempt.baselineJUnit, baselineFiles);
+    const base = baselineSkipped ? [] : attempt?.baselineJUnit === undefined ? undefined : readJUnit(attempt.baselineJUnit, baselineFiles, attempt.baselineRoot);
     if (!attempt || attempt.currentExitCode === null || attempt.currentSignal
       || ![0, 1].includes(attempt.currentExitCode)
       || baselineFiles.some((file) => !shard.files.includes(file))
@@ -267,6 +301,7 @@ export function aggregateGateTestShards(shards: readonly GateTestShard[], attemp
     }
     current.push(...head.filter((test) => !test.skipped));
     baseline.push(...base.filter((test) => !test.skipped));
+    baselineTestCases.push(...base);
     const passedAtBase = new Set(base.filter((test) => !test.skipped && test.failure === undefined).map((test) => `${test.file}\u0000${test.name}`));
     skippedRegressions.push(...head.filter((test) => test.skipped && passedAtBase.has(`${test.file}\u0000${test.name}`)));
   }
@@ -279,6 +314,8 @@ export function aggregateGateTestShards(shards: readonly GateTestShard[], attemp
   const passedTestEvidence: GatePassedTestEvidence = {
     status: 'available',
     tests: baseline.filter((test) => test.failure === undefined).map(({ file, name }) => ({ file, name: `${file} > ${name}` })),
+    // #27844 귀속 불일치 — 비샤드 경로(runBaselineBunTest)와 같은 계약으로 기준선 전체 testcase 를 넘긴다.
+    testCases: baselineTestCases.map(({ file, name }) => ({ file, name: `${file} > ${name}` })),
   };
   const report = buildGateBaselineReport(asGateLog(current), {
     status: baselineStatus,

package/src/self-dev/shard-run.ts

@@ -25,6 +25,8 @@ export interface ShardRunResult {
   failureEvidence?: ShardFailureEvidence[];
   /** Latest failed attempt's reason for each incomplete shard; copied into the gate artifact summary. */
   unmeasuredByShard?: Record<string, string>;
+  /** git stderr tail (redacted · ≤2KB · one line) when the baseline worktree could not be added. */
+  baselineStderrTail?: string;
 }
 
 /** What a failed shard process leaves behind so «test failure vs runner error» can be told apart after the fact. */
@@ -275,6 +277,7 @@ function runPlannedShards(
           currentSignal: current.signal, baselineSignal: base.signal,
           currentDiagnostic: current.diagnostic, baselineDiagnostic: base.diagnostic,
           baselineFiles,
+          currentRoot: cwd, baselineRoot: dir,
         });
       }
       const retry = new Set(aggregateGateTestShards(shards, attempts).retryShardIds);
@@ -288,9 +291,13 @@ function runPlannedShards(
     ...(baseline.retryShardIds.length ? { unmeasuredByShard: incompleteShardReasons(baseline.retryShardIds, attempts) } : {}),
   };
   const retryShardIds = shards.map((shard) => shard.id);
+  // The stderr tail has its own budget (≤2KB, already redacted) so the 500-char log cut cannot drop it.
+  const stderrTail = baseline.gitStderrTail;
+  const stderrPart = stderrTail ? ` · git stderr: ${stderrTail}` : '';
   return {
     aggregate: { status: 'unmeasured', retryShardIds }, shards, attempts, reason: baseline.log, ...evidence,
-    unmeasuredByShard: Object.fromEntries(retryShardIds.map((id) => [id, `baseline worktree: ${redactSecretText(baseline.log).replace(/[\r\n\t\x00-\x1f\x7f]+/g, ' ').slice(0, 500)}`])),
+    unmeasuredByShard: Object.fromEntries(retryShardIds.map((id) => [id, `baseline worktree: ${redactSecretText(baseline.log).replace(/[\r\n\t\x00-\x1f\x7f]+/g, ' ').slice(0, 500)}${stderrPart}`])),
+    ...(stderrTail ? { baselineStderrTail: stderrTail } : {}),
   };
 }
 

package/src/self-implement/blocked-draft-policy.ts

@@ -89,3 +89,23 @@ export function salvageBranchForRun(runId: string, branch: string): string {
   const leaf = branch.replace(/[^A-Za-z0-9._-]+/g, '-').replace(/^[-.]+|[-.]+$/g, '').replace(/\.\.+/g, '.').replace(/\.lock$/i, '-lock') || 'branch';
   return `salvage/${runShort}/${leaf}`;
 }
+
+/** REPAIR-BLOCKED-DRAFT-LINK-ORIGINAL — commit-only 수리 런의 base 는 합성 로컬 가지 `pr-<N>`(harness-pod-dispatch 가 넘긴다).
+ *  ⛔ origin 에 없는 가지라 그 base 로 새 draft 를 열면 반드시 실패한다. 이 꼴이면 원 PR 번호를 낸다. */
+export function syntheticRepairBasePr(base: string | undefined): number | undefined {
+  const match = /^pr-([1-9]\d*)$/.exec(base ?? '');
+  return match ? Number(match[1]) : undefined;
+}
+
+export type BlockedDraftTarget = { action: 'open-draft' } | { action: 'link-original'; originalPr: number };
+
+/** 중단 산출물을 어디에 남기나 — 합성 base `pr-<N>` 이면 새 draft 대신 «기존 PR #N 에 수확 가지 연결». */
+export function blockedDraftTargetFor(base: string | undefined): BlockedDraftTarget {
+  const originalPr = syntheticRepairBasePr(base);
+  return originalPr === undefined ? { action: 'open-draft' } : { action: 'link-original', originalPr };
+}
+
+/** 원 PR 에 다는 한 줄 — 수확 가지 이름·sha·런. (force push 없음 · 원 PR 가지는 그대로) */
+export function repairSalvageLinkComment(input: { salvageRef: string; sha?: string; runId: string; stage: string }): string {
+  return `수리 산출물 salvage ${input.salvageRef}${input.sha ? ` @ ${input.sha.slice(0, 12)}` : ''} — 런 ${input.runId} 이 ${input.stage} 로 멈춰 새 PR 대신 이 PR 에 잇는다(원 PR 가지 무변경)`;
+}

package/src/self-implement/classify-shadow.ts

@@ -1,5 +1,5 @@
-import { executeClassifyNode } from '../workflow-runtime/nodes/classify.js';
-import type { ClassifyNode, NodeExecContext, NodeOutput, WorkflowDeps } from '../workflow-runtime/types.js';
+import { runGraphClassifyNode } from '../graph-runner/runner.js';
+import type { ClassifyNode, NodeExecContext, WorkflowDeps } from '../workflow-runtime/types.js';
 import { REWORK_BUDGET_VERDICTS, type ReworkBudgetVerdict } from './run-outcome.js';
 
 export type ClassifyShadowCallLLM = WorkflowDeps['callLLM'];
@@ -36,11 +36,7 @@ export async function classifyReworkBudgetShadow(
       resolvedModel: undefined,
       toolPolicy: {},
     };
-    const deps: WorkflowDeps = {
-      callLLM,
-      runBash: async () => ({ stdout: '', stderr: '', exitCode: 0 }),
-    };
-    const result: NodeOutput = await executeClassifyNode(node, context, deps);
+    const result = await runGraphClassifyNode(node, context, callLLM, { caller: 'rework-budget-shadow' });
     const picked = isReworkBudgetVerdict(result.output) ? result.output : 'unknown';
     return {
       picked,

package/src/self-implement/doctor-visit.ts

@@ -1,4 +1,6 @@
 import { debug } from '../debug/log.js';
+import { findIncidentPrecedents, type IncidentPrecedent } from '../harness/harness-incidents.js';
+import { elanousStateRoot } from '../autopilot/state-paths.js';
 import {
   appendRunLedgerEntry,
   listRunLedgers,
@@ -6,6 +8,10 @@ import {
   lookupRunLedger,
   type RunLedgerLookupOptions,
 } from './run-ledger.js';
+/** 사고 원장 루트 기본값 — 운영/시험 우주 상태 디렉터리(없으면 빈 선례 · fail-soft). */
+export function doctorVisitIncidentRoot(): string {
+  return elanousStateRoot();
+}
 
 /** DOCTOR-VISIT 증상 닫힌 목록 — 이 밖의 값은 기록·조회 모두 거부한다. */
 export const DOCTOR_SYMPTOMS = [
@@ -49,6 +55,8 @@ export interface RecordDoctorVisitInput {
   evidence?: string;
   /** 원장 디렉터리(시험 seam) — 기본 = `runLedgerDir()`. */
   dir?: string;
+  /** 사고 원장 루트(시험 seam) — 기본 = `doctorVisitIncidentRoot()`. `null` 이면 선례 연결을 건너뛴다. */
+  incidentRoot?: string | null;
 }
 
 export interface DoctorVisit {
@@ -57,6 +65,8 @@ export interface DoctorVisit {
   symptom: DoctorSymptom;
   evidence?: string;
   timestamp?: string;
+  /** 사고 선례 연결 — 같은 reason 으로 이전에 기록된 실제 exit(기록 없으면 빈 배열). */
+  incidentPrecedents?: IncidentPrecedent[];
 }
 
 /**
@@ -74,15 +84,22 @@ export function recordDoctorVisit(visit: RecordDoctorVisitInput): DoctorVisit {
     throw new Error(`없음: 런 원장이 없습니다 (runId=${visit.runId}) — 새 원장을 만들지 않습니다`);
   }
   const timestamp = new Date().toISOString();
+  // 사고 선례 연결 — 기록된 실제 exit 만(지어내기 금지). 원장이 없으면 빈 배열(fail-soft).
+  const incidentRoot = 'incidentRoot' in visit ? visit.incidentRoot ?? null : doctorVisitIncidentRoot();
+  const incidentPrecedents = incidentRoot === null
+    ? []
+    : findIncidentPrecedents({ reason: visit.symptom, at: timestamp, runId: visit.runId }, incidentRoot);
   const data: Record<string, unknown> = { from: visit.from, symptom: visit.symptom };
   if (typeof visit.evidence === 'string' && visit.evidence.length > 0) data.evidence = visit.evidence;
+  if (incidentPrecedents.length > 0) data.incidentPrecedents = incidentPrecedents;
   appendRunLedgerEntry({ timestamp, runId: visit.runId, event: 'doctor-visit', data }, visit.dir);
-  debug.log('run-doctor', 'visit', { runId: visit.runId, from: visit.from, symptom: visit.symptom });
+  debug.log('run-doctor', 'visit', { runId: visit.runId, from: visit.from, symptom: visit.symptom, incidentPrecedents: incidentPrecedents.length });
   return {
     runId: visit.runId,
     from: visit.from,
     symptom: visit.symptom,
     ...(typeof visit.evidence === 'string' && visit.evidence.length > 0 ? { evidence: visit.evidence } : {}),
+    ...(incidentPrecedents.length > 0 ? { incidentPrecedents } : {}),
     timestamp,
   };
 }