elanous 0.2.35 → 0.2.36

package/src/self-dev/orchestrate.ts

@@ -204,7 +204,7 @@ interface SelfDevTerminalOutcome {
   stage: string | null;
   merged: boolean | null;
   prUrl: string | null;
-  blockReason?: 'parent-unlanded' | 'dependency-needs-human';
+  blockReason?: 'parent-unlanded' | 'dependency-needs-human' | 'dependency-deferred';
   parentPrNumber?: number | null;
   parentNoPr?: true;
 }
@@ -270,7 +270,8 @@ export function hasDelivered(result: SelfDevJobResult): boolean {
 
 /** 열린 PR 을 사람에게 보여줄 때 분류 칸에 싣는 문면. 없는 mergeReason 은 「사유 모름」— 값을 짓지 않는다. */
 export function openPrAwaitingHumanMessage(result: Pick<SelfDevJobResult, 'prNumber' | 'prUrl' | 'mergeReason'>): string {
-  const pointer = result.prNumber !== undefined ? `#${result.prNumber}` : (result.prUrl ?? '');
+  const pointer = typeof result.prNumber === 'number' && Number.isSafeInteger(result.prNumber) && result.prNumber > 0
+    ? `#${result.prNumber}` : (result.prUrl ?? '');
   const reason = result.mergeReason && result.mergeReason.length > 0 ? result.mergeReason : '사유 모름';
   return `열린 PR ${pointer} · ${reason}`;
 }
@@ -488,17 +489,42 @@ export function queryPreflightWarning(
   }
 }
 
+function hasConcretePrEvidence(result: Pick<SelfDevJobResult, 'prNumber' | 'prUrl'>): boolean {
+  const number = result.prNumber;
+  if (typeof number === 'number' && Number.isSafeInteger(number) && number > 0) return true;
+  if (typeof result.prUrl !== 'string') return false;
+  // Match the raw URL. WHATWG URL normalizes dot segments before exposing
+  // pathname, which would turn a noncanonical pointer into apparent evidence.
+  const match = /^https:\/\/github\.com\/[A-Za-z0-9][A-Za-z0-9_.-]*\/[A-Za-z0-9][A-Za-z0-9_.-]*\/pull\/([1-9]\d*)$/.exec(result.prUrl);
+  return match !== null && Number.isSafeInteger(Number(match[1]));
+}
+
+function hasOpenedPrPointer(result: Pick<SelfDevJobResult, 'prNumber' | 'prUrl'>): boolean {
+  const number = result.prNumber;
+  if (typeof number === 'number' && Number.isSafeInteger(number) && number > 0) return true;
+  if (typeof result.prUrl !== 'string') return false;
+  // `stage=pr-opened` is a separate observation and may come from a non-GitHub
+  // host. Keep its host-neutral pull pointer contract, with no null or issue URL.
+  const match = /^https:\/\/[A-Za-z0-9][A-Za-z0-9.-]*\/(?:[A-Za-z0-9][A-Za-z0-9_.-]*\/)*pull\/([1-9]\d*)$/.exec(result.prUrl);
+  return match !== null && Number.isSafeInteger(Number(match[1]));
+}
+
 export function classifyFailure(
   result: SelfDevJobResult,
   preflightWarning: PreflightWarningObservation = 'unknown',
 ): FailureKind | null {
   if (result.blockReason === 'parent-unlanded') return 'parent-unlanded';
+  // A child may claim no changes after committing and opening its draft. The
+  // parent must retain the PR for review instead of reworking the same goal.
+  if (result.status === 'failed' && result.completionDisposition === 'completed-without-changes'
+    && hasConcretePrEvidence(result)) return 'awaiting-human';
+  if (result.blockReason === 'dependency-deferred' || result.error?.code === 'DEP_BLOCKED_REBASE_READY') return 'blocked-upstream';
   if (result.blockReason === 'dependency-needs-human' || result.error?.code === 'GOAL_DONE_BOUNDARY_MISSING') return 'awaiting-human';
   const ledgerKind = result.failureClassification === undefined
     ? undefined
     : result.failureClassification === 'run-deadline-exceeded'
       // 기한 사망은 transient 가 아니다. 브랜치/PR 이 있으면 수확(false-failure), 없으면 재분해.
-      ? (result.branch || result.prUrl || result.prNumber !== undefined ? 'false-failure' : 'unconverged-decomposable')
+      ? (result.branch || hasOpenedPrPointer(result) ? 'false-failure' : 'unconverged-decomposable')
       : LEDGER_FAILURE_KIND[result.failureClassification];
 
   // ⭐ 수렴 실패인데 하니스가 «쪼개는 법»을 이미 냈으면 그것은 다른 처방이다.
@@ -518,7 +544,7 @@ export function classifyFailure(
     result.status === 'done'
     && result.stage === 'pr-opened'
     && !hasLanded(result)
-    && (Boolean(result.prUrl) || result.prNumber !== undefined)
+    && hasOpenedPrPointer(result)
   ) {
     return 'awaiting-human';
   }
@@ -616,8 +642,15 @@ export function classifyFailures(
     const kind = classifyFailure(result, queryPreflightWarning(preflightIdentifiers, queryPreflight));
     if (kind === null) return [];
     const error = result.error;
-    const awaitingHuman = kind === 'awaiting-human'
-      ? failureObservationFields('AWAITING_HUMAN', openPrAwaitingHumanMessage(result))
+    const prChangeConflict = kind === 'awaiting-human' && result.status === 'failed'
+      && result.completionDisposition === 'completed-without-changes'
+      && hasConcretePrEvidence(result);
+    const prPointer = typeof result.prNumber === 'number' && Number.isSafeInteger(result.prNumber) && result.prNumber > 0
+      ? `#${result.prNumber}` : result.prUrl;
+    const awaitingHuman = prChangeConflict
+      ? failureObservationFields('PR_CHANGE_CONFLICT', `PR ${prPointer} exists while child reported completed-without-changes`)
+      : kind === 'awaiting-human'
+        ? failureObservationFields('AWAITING_HUMAN', openPrAwaitingHumanMessage(result))
       : kind === 'parent-unlanded'
         ? failureObservationFields('PARENT_UNLANDED', parentUnlandedProgressLine(result.feature.split('\n')[0]!, result.parentPrNumber, result.parentNoPr === true))
         : undefined;
@@ -1009,13 +1042,16 @@ export function orchestrateSelfDev(opts: OrchestrateSelfDevOptions): Promise<Sel
           taskId: `boundary:${taskCardId}:blocked:${index + 1}`,
           feature: goal.feature,
           status: 'blocked',
-          blockReason: 'dependency-needs-human',
-          stopReason: 'needs-human',
-          error: { code: 'DEPENDENCY_NEEDS_HUMAN', message: `선행 needs-human: ${predecessor}` },
+          blockReason: 'dependency-deferred',
+          stopReason: 'rebase-ready',
+          error: { code: 'DEP_BLOCKED_REBASE_READY', message: `선행 조각 ${predecessor} 재수복 뒤 다음 런 이월` },
         });
+        try { debug.log('self-dev.slice', 'dep-blocked', { slice: goal.id ?? String(index), blockedBy: predecessor,
+          reason: 'GOAL_DONE_BOUNDARY_MISSING', disposition: 'rebase-ready' }); } catch { /* observation is fail-soft */ }
       }
       const withheld = [...blockedGoalIndexes].map((index) => index + 1);
-      try { debug.log('self-dev.orchestrate', 'done-boundary-missing', { taskCardId, boundaryMissing, withheld, action: 'needs-human', eligibleToLaunch: opts.goals.length - blockedGoalIndexes.size }); } catch { /* fail-soft */ }
+      try { debug.log('self-dev.orchestrate', 'done-boundary-missing', { taskCardId, boundaryMissing, withheld,
+        action: 'partial-needs-human', dependentDisposition: 'rebase-ready', eligibleToLaunch: opts.goals.length - blockedGoalIndexes.size }); } catch { /* fail-soft */ }
       opts = { ...opts, goals: opts.goals.flatMap((goal, index) => blockedGoalIndexes.has(index)
         ? []
         : [{ ...goal, id: goal.id ?? String(index) }]) };
@@ -1290,6 +1326,7 @@ export function orchestrateSelfDev(opts: OrchestrateSelfDevOptions): Promise<Sel
   const taskIdByLocal = new Map<string, string>();         // goal-local id → live taskId
   const taskIdByGoal = new Map<SelfDevGoal, string>();      // original shard → current or resumed taskId
   const created: Array<{ task: ReturnType<typeof createTask>; goal: SelfDevGoal }> = [];
+  const repairedGoals = new Set<SelfDevGoal>();
   opts.goals.forEach((g, i) => {
     const prior = resumedByGoal.get(g);
     if (prior) {
@@ -1762,8 +1799,38 @@ export function orchestrateSelfDev(opts: OrchestrateSelfDevOptions): Promise<Sel
               dispStage: fDisp?.stage ?? 'none', screenSpace: fScreen.screenSpace,
             });
           }
+          const failedGoal = taskByGoal.get(ev.taskId);
+          const failedTask = graph.getTask(ev.taskId);
           const failedResult = results.get(ev.taskId)!;
           const stopReason = opts.stopAfterFailure?.(failedResult) ?? null;
+          // A child without a PR gets one supervised, narrower attempt. Keep the original
+          // failure in the checkpoint; redirect only its actual dependents to the replacement.
+          if (stopReason === null && taskCardId?.trim() && failedGoal && failedTask?.surface.kind === 'self-implement' && !repairedGoals.has(failedGoal)
+            && !fDisp?.prUrl && fDisp?.merged !== true && fDisp?.harvestable !== true) {
+            repairedGoals.add(failedGoal);
+            const reason = `${ev.errorCode}: ${ev.errorMessage}`.slice(0, FAILURE_MESSAGE_MAX_LENGTH);
+            const repairFeature = `${failedGoal.feature.trimEnd()}\n\n## 자동 수복 1회\n앞선 조각 실패: ${reason}\n실패 범위만 좁혀 재시도하고 원래 완료 경계를 보존한다.`;
+            const replacement = createTask({
+              title: goalTitle(failedGoal),
+              description: repairFeature.slice(0, TASK_DEFAULTS.descriptionMaxLen),
+              surface: failedTask.surface.kind === 'self-implement'
+                ? { ...failedTask.surface, feature: repairFeature }
+                : failedTask.surface,
+              isolation: failedTask.isolation,
+            }, { now: now() });
+            graph.addTask(replacement);
+            graph.updateTask(replacement.id, { dependsOn: [...failedTask.dependsOn] }, { now: now() });
+            taskByGoal.set(replacement.id, failedGoal);
+            spaceIdByTask.set(replacement.id, spaceIdForTask(replacement));
+            taskIdByGoal.set(failedGoal, replacement.id);
+            created.push({ task: replacement, goal: failedGoal });
+            graph.supersede(ev.taskId, [replacement.id], { now: now() });
+            results.set(ev.taskId, { ...results.get(ev.taskId)!, status: 'superseded' });
+            try { debug.log('self-dev.slice', 'repair-retry', { slice: failedGoal.id ?? ev.taskId, failedTaskId: ev.taskId,
+              replacementTaskId: replacement.id, reason, attempt: 1 }); } catch { /* observation is fail-soft */ }
+            scheduleTick();
+            break;
+          }
           if (stopReason !== null) {
             let remainingGoals = 0;
             for (const task of created.map(({ task }) => graph.getTask(task.id)).filter((task): task is NonNullable<typeof task> => task !== undefined)) {
@@ -1781,24 +1848,56 @@ export function orchestrateSelfDev(opts: OrchestrateSelfDevOptions): Promise<Sel
             }
             if (remainingGoals > 0) opts.onStopAfterFailure?.({ reason: stopReason, remainingGoals });
           }
-          // S3 cascade — dependents of a failed task can never become
-          // ready (a dep will never be `done`) → cancel them honestly
-          // instead of leaving them `blocked` (which stalls the run onto
-          // the stuck-guard). subtree() = failed task + its downstream.
+          // A hot-file edge only serializes execution. It does not make the later
+          // slice depend on the earlier slice's result. Cancel only the explicit
+          // dependency closure; release hot-only edges so independent PRs proceed.
+          const localGoalId = (goal: SelfDevGoal): string => goal.id ?? String(opts.goals.indexOf(goal));
+          const blockedGoalIds = new Set<string>(failedGoal ? [localGoalId(failedGoal)] : []);
+          let expanded = true;
+          while (expanded) {
+            expanded = false;
+            for (const { goal } of created) {
+              const localId = localGoalId(goal);
+              if (blockedGoalIds.has(localId)) continue;
+              if ((goal.dependsOn ?? []).some((id) => blockedGoalIds.has(id))) {
+                blockedGoalIds.add(localId);
+                expanded = true;
+              }
+            }
+          }
           let cascaded = 0;
-          for (const t of graph.subtree(ev.taskId)) {
-            if (t.id === ev.taskId || isTerminalStatus(t.status)) continue;
+          for (const { task, goal } of created) {
+            const t = graph.getTask(task.id);
+            if (!t || t.id === ev.taskId || isTerminalStatus(t.status)) continue;
+            const localId = localGoalId(goal);
+            if (!blockedGoalIds.has(localId)) continue;
             try {
               graph.updateTask(t.id, { status: 'cancelled' }, { now: now() });
               results.set(t.id, {
                 taskId: t.id,
                 feature: taskByGoal.get(t.id)?.feature ?? '',
                 status: 'cancelled',
-                error: { code: 'DEP_FAILED', message: `dependency ${ev.taskId} failed` },
+                error: taskCardId?.trim()
+                  ? { code: 'DEP_BLOCKED_REBASE_READY', message: `dependency ${ev.taskId} failed; rebase-ready next run` }
+                  : { code: 'DEP_FAILED', message: `dependency ${ev.taskId} failed` },
               });
+              try { debug.log('self-dev.slice', 'dep-blocked', { slice: localId, blockedBy: failedGoal?.id ?? ev.taskId,
+                reason: ev.errorCode, disposition: 'rebase-ready' }); } catch { /* observation is fail-soft */ }
               cascaded++;
             } catch { /* best-effort */ }
           }
+          for (const { task, goal } of created) {
+            const current = graph.getTask(task.id);
+            if (!current || isTerminalStatus(current.status)) continue;
+            const independent = current.dependsOn.filter((id) => {
+              const parent = graph.getTask(id);
+              return parent && (parent.status === 'failed' || parent.status === 'cancelled' || parent.status === 'superseded')
+                && !(goal.dependsOn ?? []).includes(taskByGoal.has(id) ? localGoalId(taskByGoal.get(id)!) : '');
+            });
+            if (independent.length) graph.updateTask(task.id, {
+              dependsOn: current.dependsOn.filter((id) => !independent.includes(id)),
+            }, { now: now() });
+          }
           debug.log('self-dev.orchestrate', 'job.failed', {
             taskId: ev.taskId,
             feature: shortFeature(ev.taskId),

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-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',