elanous 0.2.34 → 0.2.36

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

@@ -10,7 +10,7 @@ import { recordSelfDevRunSupervisorStop, selfDevRunsDir } from './run-store.js';
 import { debug } from '../debug/log.js';
 import { sweepFrozenMerges } from '../self-implement/frozen-merges.js';
 import { routeSupervisorVerdict } from './supervisor-verdict-edges.js';
-import { recordTaskAgentShadowMove, runCardFor, type TaskAgentShadowInput } from '../task-agent/shadow.js';
+import type { TaskAgentShadowInput } from '../task-agent/shadow.js';
 import { cardPrNumber, taskAgentStatePath } from '../task-agent/task-hand.js';
 import {
   classifyMustFixRound, inferMustFixEvidence, judgeMustFixScope, proposeMustFixSplit,
@@ -40,6 +40,8 @@ export interface SupervisorRound {
   mainSyncRelaunchTaskIds?: string[];
   /** Original feature and relaunch goal text of those tasks — a rerun may mint a new taskId, so the piece is also found by goal. */
   mainSyncRelaunchFeatures?: string[];
+  /** PR 없는 미분류 실패에 대해 실제 분해 실행기로 수복한 원래 골. 새 taskId에도 한 번 상한을 지킨다. */
+  selfHealDecomposeFeatures?: string[];
   /**
    * Tasks of this round that ended `status=failed` without a PR. Omitted when there are none — and on older
    * history, which never measured it, so the no-PR streak guard reads it as «not measured» and stays off.
@@ -130,6 +132,7 @@ export interface SupervisorDecision {
   };
   oscillation?: { taskIds: string[]; helper: 'review-oscillation'; signature: string; repairGoals?: Record<string, string>; heldTaskIds?: string[] };
   pendingDecision?: 'attempt-care-escalation';
+  selfHeal?: { reason: 'supervisor-unclassified-decompose'; attempt: 1; taskIds: string[] };
 }
 
 export interface SupervisorLimits {
@@ -352,6 +355,8 @@ export function decideNextRun(input: {
   reviewMustFixTrend?: ReviewRework['trend'];
   /** True: the rerun consumes the authored goal. False: it cannot, so oscillation stops for a human. Undefined: pure decision. */
   repairGoalExecution?: boolean;
+  /** 분해 제안을 실제 조각 실행으로 승격할 수 있는 supervisor 경로에만 true. */
+  decompositionExecution?: boolean;
 }): SupervisorDecision {
   const results = [...input.results];
   const history = [...(input.history ?? [])];
@@ -502,6 +507,29 @@ export function decideNextRun(input: {
   }
 
   if (!t.actionable) {
+    const spent = new Set(history.flatMap((entry) => entry.selfHealDecomposeFeatures ?? []).map(resumeKey));
+    const candidates = input.decompositionExecution === true && round + 1 <= maxRounds
+      ? activeResults.filter((result) => result.status === 'failed' && result.prNumber === undefined && !result.prUrl
+        && !result.providerErrors && !result.blockReason
+        && (result.decomposeProposal?.pieces.length ?? 0) >= 2
+        && t.needsHuman.includes(result.taskId)
+        && t.classifications.some((classification) => classification.taskId === result.taskId && classification.kind === 'unclassified')
+        && !spent.has(resumeKey(result.feature)))
+      : [];
+    // rerun은 라운드 전체를 받는다. 다른 needs-human 조각을 함께 다시 띄우지 않도록 첫 조각은 단독 후보로만 허용한다.
+    const candidate = candidates.length === 1 && t.needsHuman.every((id) => id === candidates[0]!.taskId)
+      ? candidates[0] : undefined;
+    if (candidate) {
+      const taskIds = [candidate.taskId];
+      return { ...base, action: 'relaunch',
+        decomposable: taskIds,
+        needsHuman: t.needsHuman.filter((id) => !taskIds.includes(id)),
+        classifications: t.classifications.map((classification) => taskIds.includes(classification.taskId)
+          ? { ...classification, action: 'decompose-and-retry' as const } : classification),
+        selfHeal: { reason: 'supervisor-unclassified-decompose', attempt: 1, taskIds },
+        why: `supervisor-unclassified-decompose (attempt: 1/1) — PR 없는 미분류 조각 ${taskIds.length}개를 실증된 분해 제안으로 한 번 재걸기`,
+      };
+    }
     if (t.needsHuman.length > 0) {
       return {
         ...base,
@@ -772,6 +800,12 @@ export function appendRound(
         decision.relaunchGoals?.[id],
       ].filter((feature): feature is string => feature !== undefined)),
     } : {}),
+    ...(decision?.action !== 'stop' && decision?.selfHeal ? {
+      selfHealDecomposeFeatures: decision.selfHeal.taskIds.flatMap((id) => {
+        const feature = results.find((result) => result.taskId === id)?.feature;
+        return feature === undefined ? [] : [feature];
+      }),
+    } : {}),
     ...(decision?.action === 'add-repair-task' && decision.oscillation ? (() => {
       // Each repaired task is recorded under its original goal feature and, when a rerun runs the authored goal as
       // the piece's new feature (orchestrate), under that repair text too — so the repair's own oscillation stops.
@@ -1028,6 +1062,7 @@ export async function rejudgeTerminalTaskCard(runId: string | null, deps: {
   external?: Parameters<typeof import('../task-agent/rejudge-on-head.js').rejudgeAsyncResultCard>[2];
 } = {}): Promise<void> {
   const statePath = deps.statePath ?? taskAgentStatePath();
+  const { runCardFor } = await import('../task-agent/shadow.js');
   const card = runCardFor(runId, { statePath, ...(deps.env ? { env: deps.env } : {}) });
   if (!card || card.status !== 'launched' || card.taLand !== true || cardPrNumber(card) === undefined) return;
   const { rejudgeAsyncResultCard } = await import('../task-agent/rejudge-on-head.js');
@@ -1081,9 +1116,10 @@ export async function superviseRun(opts: SuperviseRunOptions): Promise<Superviso
     const allUnreviewedAreNoDiff = unreviewed.length > 0
       && unreviewed.every((result) => result.reviewReason === 'no-diff');
 
-    const decision = decideNextRun({
+    let decision = decideNextRun({
       results,
       history,
+      decompositionExecution: opts.promoteDecomposition !== undefined,
       // Undeclared = cannot run the repair goal: an add-repair-task would otherwise be a same-strategy relaunch.
       repairGoalExecution: opts.repairGoalExecution === true,
       ...(aggregateReviewTrend(results) ? { reviewMustFixTrend: aggregateReviewTrend(results) } : {}),
@@ -1118,6 +1154,20 @@ export async function superviseRun(opts: SuperviseRunOptions): Promise<Superviso
         decomposePromotion = { attempted: true, reason: `shim-failed: ${String(error)}` };
       }
     }
+    if (decision.selfHeal) {
+      const promoted = decomposePromotion.attempted && (decomposePromotion.pieceCount ?? 0) >= 2;
+      try { opts.observe?.('supervisor-self-heal', { runId, reason: decision.selfHeal.reason,
+        attempt: decision.selfHeal.attempt, taskIds: decision.selfHeal.taskIds,
+        outcome: promoted ? 'promoted' : 'needs-human', promotionReason: decomposePromotion.reason }); } catch { /* fail-open */ }
+      if (!promoted) {
+        decision = { ...decision, action: 'stop', stopReason: 'needs-human',
+          decomposable: decision.decomposable.filter((id) => !decision.selfHeal!.taskIds.includes(id)),
+          needsHuman: [...new Set([...decision.needsHuman, ...decision.selfHeal.taskIds])],
+          classifications: decision.classifications.map((classification) => decision.selfHeal!.taskIds.includes(classification.taskId)
+            ? { ...classification, action: 'needs-human' as const } : classification),
+          why: `${decision.selfHeal.reason} (attempt: 1/1) — 분해 승격 실패(${decomposePromotion.reason}); 자동 재실행 없이 사람 확인` };
+      }
+    }
 
     try {
       const walkSummary = results.some((r) => r.walk !== undefined)
@@ -1145,6 +1195,7 @@ export async function superviseRun(opts: SuperviseRunOptions): Promise<Superviso
         kinds: decision.classifications.map((c) => `${c.kind}:${c.action}`),
         decomposePromotionAttempted: decomposePromotion.attempted,
         decomposePromotionReason: decomposePromotion.reason,
+        ...(decision.selfHeal ? { selfHealReason: decision.selfHeal.reason, selfHealAttempt: decision.selfHeal.attempt } : {}),
         ...(decomposePromotion.pieceCount === undefined ? {} : { decomposePieceCount: decomposePromotion.pieceCount }),
         ...(decomposePromotion.dependsOnEdges === undefined ? {} : { decomposeDependsOnEdges: decomposePromotion.dependsOnEdges }),
         ...(decomposePromotion.hotPathEdges === undefined ? {} : { decomposeHotPathEdges: decomposePromotion.hotPathEdges }),
@@ -1188,6 +1239,7 @@ export async function superviseRun(opts: SuperviseRunOptions): Promise<Superviso
             runId,
             reason: decision.stopReason,
             outcome: persistence.outcome,
+            ...(decision.selfHeal ? { selfHealReason: decision.selfHeal.reason, selfHealAttempt: decision.selfHeal.attempt } : {}),
             ...storageObservation,
           });
         } catch { /* fail-open */ }
@@ -1195,6 +1247,7 @@ export async function superviseRun(opts: SuperviseRunOptions): Promise<Superviso
       if (decision.stopReason && opts.taskAgentShadow !== false) {
         // TASK-AGENT-SHADOW — 판단부를 그림자로 부른다(실행 0). 어떤 오류도 런의 결말을 바꾸지 않는다.
         try {
+          const { recordTaskAgentShadowMove } = await import('../task-agent/shadow.js');
           const pr = results.find((result) => typeof result.prNumber === 'number' && result.prNumber > 0)?.prNumber;
           const reviewed = results.filter((result) => result.prNumber === pr && result.selfReview && result.merged !== true);
           const selfReview = pr && reviewed.length === 1 ? reviewed[0]!.selfReview : undefined;

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

@@ -98,7 +98,7 @@ export interface SelfDevJobResult {
   /** Commits this child added against its own `--base`. 0 is not completion progress. */
   commitsAheadOfBase?: number;
   /** A dependency is done but its result is not on main; no child was launched. */
-  blockReason?: 'parent-unlanded' | 'dependency-needs-human';
+  blockReason?: 'parent-unlanded' | 'dependency-needs-human' | 'dependency-deferred';
   parentPrNumber?: number;
   /** The upstream completed in a worktree without opening a PR. */
   parentNoPr?: true;

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-health/autoheal.ts

@@ -0,0 +1,153 @@
+// ── 자동 회복 (TUI-400-AUTOHEAL-FALLBACK · 대표 10-22) ──
+//
+// 대표 «400 같은 오류로 멈추면 스스로 회복 · 자동 provider fallback 이 없으면 작업을 못 잇는다».
+// 실측(10-22 07:1x OPT): TUI 턴이 «Codex API 400(대화 기록 어긋남 의심)» 로 끝나고 멈췄다 — 지문
+// `codex-400-bad-request` 는 «/session new 뒤 다시» 를 사람에게 «보여줄» 뿐이었고, OP 가 손으로 쳐서 회복했다.
+//
+// 이 모듈은 «판정»만 갖는다(순수 · 관측·화면은 호출부가 남긴다). 사다리:
+//   ① 같은 턴 400(대화 기록) → 새 백엔드 세션 ⊕ 직전 요약(짧게)으로 1회 재시도
+//   ② 그래도 400 → `llm.fallbackChain` 다음 공급자로 그 턴 재시도
+//   ③ 그래도 실패 → 턴당 2회 상한에서 멈추고 사람에게 이유 한 줄
+// ⛔ 답·도구 호출이 이미 흘렀으면 다시 보내지 않는다(중복 출력·부작용). ⛔ 무한 반복 금지(AUTOHEAL_MAX_ATTEMPTS).
+// 📋 관측 = `debug.log('self-health.autoheal', attempt|recovered|exhausted|skipped, …)` — 호출부(plain-turn 런타임).
+
+import { matchFailureText, type FailureSignature } from './signatures.js';
+
+/** 턴당 자동 회복 상한 — ① 새 세션 ② 공급자. ⛔ 늘리면 «무한 반복 금지» 판정선이 같이 움직인다. */
+export const AUTOHEAL_MAX_ATTEMPTS = 2;
+
+export type AutohealStep = 'new-session' | 'provider-fallback';
+
+/** 재시도 요청에 실리는 ACP `_meta` 키 — 서버 다리(`core-turn-bridge`)가 «이 턴은 다음 공급자로» 를 읽는다.
+ *  ⛔ 공급자 «이름»은 싣지 않는다 — 고르는 것은 서버가 자기 `llm.fallbackChain` 으로 한다(클라이언트가 지갑을 못 고른다). */
+export const AUTOHEAL_META_KEY = 'elanousAutoheal';
+
+export interface AutohealProviderFallbackMeta {
+  readonly providerFallback: true;
+}
+
+export function autohealProviderFallbackMeta(): Record<string, AutohealProviderFallbackMeta> {
+  return { [AUTOHEAL_META_KEY]: { providerFallback: true } };
+}
+
+/** 프롬프트 `_meta` 에 «다음 공급자로» 표지가 있나. */
+export function readAutohealProviderFallback(meta: Readonly<Record<string, unknown>> | undefined): boolean {
+  const value = meta?.[AUTOHEAL_META_KEY];
+  return typeof value === 'object' && value !== null
+    && (value as { providerFallback?: unknown }).providerFallback === true;
+}
+
+/** 자동 회복을 거는 지문 — 오류 «원문»으로 판정한다(지문 번역문으로 판정하면 안 걸린다 · #27452 교훈). */
+export function autohealSignatureFor(detail: string): FailureSignature | null {
+  const sig = matchFailureText(detail);
+  return sig?.autoheal ? sig : null;
+}
+
+export type AutohealStopReason =
+  | 'not-autoheal-signature'
+  | 'output-emitted'
+  | 'tool-dispatched'
+  | 'aborted'
+  | 'history-changed'
+  | 'no-fallback-provider'
+  | 'max-attempts';
+
+export type AutohealDecision =
+  | { readonly kind: 'retry'; readonly step: AutohealStep; readonly attempt: number; readonly provider?: string }
+  | { readonly kind: 'stop'; readonly reason: AutohealStopReason };
+
+export interface AutohealDecisionInput {
+  /** 이번 실패의 오류 원문. */
+  readonly detail: string;
+  /** 이미 한 자동 회복 횟수(0 = 첫 실패). */
+  readonly attemptsDone: number;
+  /** 이 턴에서 답·도구 호출이 화면/서버로 흘렀나. */
+  readonly emitted: boolean;
+  /** 도구 실행 수가 바뀌었나(모르면 false — 그때는 emitted 로만 가른다). */
+  readonly toolDispatched: boolean;
+  readonly aborted: boolean;
+  /** ② 칸에서 쓸 다음 공급자(없으면 null). ① 칸에서는 안 본다. */
+  readonly fallbackProvider: string | null;
+}
+
+/** 다음 한 걸음. 순수 — 같은 입력이면 같은 답. */
+export function decideAutohealStep(input: AutohealDecisionInput): AutohealDecision {
+  if (!autohealSignatureFor(input.detail)) return { kind: 'stop', reason: 'not-autoheal-signature' };
+  if (input.aborted) return { kind: 'stop', reason: 'aborted' };
+  if (input.emitted) return { kind: 'stop', reason: 'output-emitted' };
+  if (input.toolDispatched) return { kind: 'stop', reason: 'tool-dispatched' };
+  if (input.attemptsDone >= AUTOHEAL_MAX_ATTEMPTS) return { kind: 'stop', reason: 'max-attempts' };
+  if (input.attemptsDone === 0) return { kind: 'retry', step: 'new-session', attempt: 1 };
+  if (!input.fallbackProvider) return { kind: 'stop', reason: 'no-fallback-provider' };
+  return { kind: 'retry', step: 'provider-fallback', attempt: 2, provider: input.fallbackProvider };
+}
+
+/** 화면 한 줄 — 시도할 때. */
+export function formatAutohealAttemptLine(decision: Extract<AutohealDecision, { kind: 'retry' }>): string {
+  const what = decision.step === 'new-session' ? '새 세션 ⊕ 요약으로' : `공급자 ${decision.provider ?? '?'} 로`;
+  return `자동 회복: ${what} 다시 시도 (${decision.attempt}/${AUTOHEAL_MAX_ATTEMPTS})`;
+}
+
+export interface AutohealAttemptRecord {
+  readonly step: AutohealStep;
+  readonly provider?: string;
+}
+
+/** 화면 한 줄 — 상한에서 멈출 때. 한글 두 칸으로 130칸 안(지문 한 줄과 같은 규율). */
+export function formatAutohealExhaustedNotice(
+  attempts: readonly AutohealAttemptRecord[],
+  reason: AutohealStopReason,
+  opts: { rawHint?: string } = {},
+): string {
+  const steps = attempts.map((a) => (a.step === 'new-session' ? '새 세션' : `공급자 ${a.provider ?? '?'}`)).join(' → ');
+  const why = reason === 'no-fallback-provider' ? `${steps} · 대체 공급자 없음` : steps;
+  const raw = opts.rawHint ? ` · 원문 ${opts.rawHint}` : '';
+  return `⚠ 자동 회복 ${attempts.length}회 실패(${why}) → 잠시 뒤 다시 · eln usage${raw}`;
+}
+
+/** 상한에서 멈춘 턴 — 메시지는 «원문 그대로»(지문·#27452 판정이 원문으로 돈다), 회복 이력은 따로 싣는다. */
+export class AutohealExhaustedError extends Error {
+  constructor(
+    readonly original: unknown,
+    readonly attempts: readonly AutohealAttemptRecord[],
+    readonly reason: AutohealStopReason,
+  ) {
+    super(original instanceof Error ? original.message : String(original));
+    this.name = 'AutohealExhaustedError';
+  }
+}
+
+/** 직전 요약을 «짧게» — 이미 있는 압축 요약(`compactConversation`)을 쓰고, 실패·시간 초과면
+ *  같은 압축 모듈의 대화록(`buildCompactTranscript`) 꼬리로 대신한다. ⛔ 여기서 요약을 다시 만들지 않는다. */
+export async function summarizeForAutoheal<T>(
+  prior: readonly T[],
+  deps: {
+    compact: (history: readonly T[]) => Promise<{ summary: string }>;
+    transcript: (history: readonly T[]) => string;
+    timeoutMs?: number;
+    maxChars?: number;
+  },
+): Promise<{ summary: string; source: 'compact' | 'transcript-tail' | 'empty' }> {
+  const maxChars = deps.maxChars ?? 1_200;
+  const clip = (text: string, tail: boolean): string => {
+    const trimmed = text.trim();
+    if (trimmed.length <= maxChars) return trimmed;
+    return tail ? `…${trimmed.slice(-maxChars)}` : `${trimmed.slice(0, maxChars)}…`;
+  };
+  try {
+    let timer: ReturnType<typeof setTimeout> | undefined;
+    const timeout = new Promise<never>((_, reject) => {
+      timer = setTimeout(() => reject(new Error('autoheal summary timed out')), deps.timeoutMs ?? 20_000);
+    });
+    try {
+      const { summary } = await Promise.race([deps.compact(prior), timeout]);
+      if (summary.trim()) return { summary: clip(summary, false), source: 'compact' };
+    } finally {
+      if (timer) clearTimeout(timer);
+    }
+  } catch { /* 요약 실패는 대화록 꼬리로 — 회복을 막지 않는다 */ }
+  const transcript = deps.transcript(prior);
+  return transcript.trim()
+    ? { summary: clip(transcript, true), source: 'transcript-tail' }
+    : { summary: '', source: 'empty' };
+}

package/src/self-health/signatures.ts

@@ -34,6 +34,9 @@ export interface FailureSignature {
   readonly cause: string;
   /** 다음 행동 — 한국어 한 줄. */
   readonly next: string;
+  /** 자동 수복 — 있으면 TUI 턴이 사람에게 넘기기 «전에» 스스로 회복을 시도한다(`self-health/autoheal.ts`).
+   *  `new-session-then-provider` = ① 새 백엔드 세션 ⊕ 직전 요약 → ② fallbackChain 다음 공급자(턴당 2회 상한). */
+  readonly autoheal?: 'new-session-then-provider';
 }
 
 /** 이벤트 루프 정지를 «지문»으로 볼 문턱 — 0.25s 표본은 잦아 소음이고, 결함 #1(14s)·#14(최대 2.35s)는 이 위다. */
@@ -48,6 +51,9 @@ export const FAILURE_SIGNATURES: readonly FailureSignature[] = [
     text: [/\b(?:Codex|LLM) API 400\b/],
     cause: '모델 API 가 요청을 400 으로 거절(대화 기록 어긋남 의심)',
     next: '/session new 뒤 짧게 다시 묻기',
+    // TUI-400-AUTOHEAL-FALLBACK(대표 10-22) — 위 처방을 사람이 치기 전에 TUI 가 먼저 스스로 해 본다.
+    //   처방 한 줄은 자동 회복이 «안 걸린» 경우(답이 이미 흐름·배선 없음)에만 보인다.
+    autoheal: 'new-session-then-provider',
   },
   {
     id: 'provider-fallback-exhausted',

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,