elanous 0.2.28 → 0.2.31

package/src/self-dev/local-supervisor-judge.ts

@@ -0,0 +1,185 @@
+/**
+ * 로컬 슈퍼바이저 판정부(local supervisor judge) — 외부 호출 0.
+ *
+ * 외부 LLM/검색/크롤 없이, 슈퍼바이저가 이미 관측한 신호만으로 멈춤 사유를 고른다:
+ *   - 후보(candidates): 호출자가 살아있다고 본 SupervisorStopReason 목록 — 배열 순서가 호출자의 우선순위다.
+ *   - 화면 관측: PTY screen-buffer 의 screenTail · screenOutcome · screenSpace (run-types.ts SelfDevJobResult 와 같은 이름).
+ *   - 진동 신호: ReviewRework 의 trend/signature 와 goal-loop 노드 재방문(walk).
+ *
+ * 순수 함수다 — I/O · 시계 · 난수 · 외부 호출 없다. 같은 입력은 항상 같은 판정을 낸다.
+ * 배선은 별도 샤드가 한다(decideNextRun/superviseRun 봉합); 이 모듈은 run-supervisor.ts 를 고치지 않는다.
+ *
+ * 판정 순위(슈퍼바이저 본 로직과 같은 순서다 — 수확/병합 판정이 진동 판정보다 앞선다):
+ *   ① 명시적 화면 완료(outcome=complete) → 수렴 계열 후보 중 강한 순
+ *   ② 측정된 리뷰 진동(trend=oscillating) → 진동 계열 후보 중 강한 순
+ *   ③ 화면 미완료(outcome=incomplete) → 수렴 계열 후보 기각, 남은 후보가 없으면 판단 불가
+ *   ④ 신호가 판단을 가르지 못하면 → 호출자 후보 순위의 첫 후보
+ */
+import { SUPERVISOR_STOP_REASONS, type SupervisorStopReason } from './run-types.js';
+import type { SupervisorDecision } from './run-supervisor.js';
+
+/** PTY 화면 관측 — run-types.ts SelfDevJobResult 의 screenTail · screenOutcome · screenSpace 와 같은 모양. */
+export interface LocalJudgeScreenObservation {
+  screenTail?: string;
+  screenOutcome?: 'complete' | 'incomplete' | null;
+  screenSpace?: string;
+}
+
+/** goal-loop 노드 방문 기록(walk) — 같은 노드를 서로 다른 회차에 다시 방문하면 진동 신호다. */
+export interface LocalJudgeWalkEntry {
+  node?: string;
+  round?: number;
+}
+
+/** 리뷰 재작업 신호 — run-types.ts ReviewRework 의 관측 필드(구조 호환 — ReviewRework 를 그대로 줘도 된다). */
+export interface LocalJudgeReworkSignal {
+  runs?: number;
+  trend?: 'oscillating' | 'improving' | 'worsening';
+  signature?: string;
+  lastReason?: string;
+}
+
+export interface LocalSupervisorJudgeInput {
+  /** 판정 후보 — 1개 이상 · SUPERVISOR_STOP_REASONS 원소만. 반드시 이 안에서 고른다. */
+  candidates: readonly SupervisorStopReason[];
+  screen?: LocalJudgeScreenObservation;
+  walk?: readonly LocalJudgeWalkEntry[];
+  rework?: LocalJudgeReworkSignal;
+}
+
+export interface LocalSupervisorJudgeVerdict {
+  /** False means the available candidates contradict the screen observation; caller must continue judging. */
+  determined: boolean;
+  stopReason?: SupervisorStopReason;
+  why: string;
+  /** 0..1 — 관측 신호가 이 판정을 받쳤는가(결정적 상수 · 임의성 없다). */
+  confidence: number;
+  /** 판정 근거 신호 목록(사람이 읽는다). */
+  signals: readonly string[];
+  /** 진동 신호를 봤는가 — 후보에 진동 사유가 없으면 신호만 남고 다른 사유를 고른다. */
+  oscillating: boolean;
+  /** SupervisorDecision 호환 stop 조각 — 호출자의 회차 base 와 합쳐 쓴다. */
+  decisionFragment: Pick<SupervisorDecision, 'action' | 'stopReason' | 'why'>;
+}
+
+/** 화면이 완료를 보일 때 먼저 고를 수렴 계열 사유(강한 순). */
+export const LOCAL_JUDGE_CONVERGENCE_ORDER = [
+  'deliverable-merged',
+  'harvestable-awaiting-human',
+  'handed-off-to-salvage',
+  'converged',
+] as const satisfies readonly SupervisorStopReason[];
+
+/** 진동 신호가 보일 때 고를 진동 사유 — SupervisorStopReason 의 진동 계열은 review-oscillating 하나다. */
+export const LOCAL_JUDGE_OSCILLATION_ORDER = [
+  'review-oscillating',
+] as const satisfies readonly SupervisorStopReason[];
+
+const COMPLETION_CONFIDENCE = 0.9;
+const OSCILLATION_TREND_CONFIDENCE = 0.8;
+const VETO_CONFIDENCE = 0.7;
+const FALLBACK_CONFIDENCE = 0.5;
+
+const isConvergence = (reason: SupervisorStopReason): boolean =>
+  (LOCAL_JUDGE_CONVERGENCE_ORDER as readonly string[]).includes(reason);
+
+const firstPresent = (
+  order: readonly SupervisorStopReason[],
+  candidates: readonly SupervisorStopReason[],
+): SupervisorStopReason | undefined => order.find((reason) => candidates.includes(reason));
+
+/** 같은 노드를 서로 다른 회차에서 다시 방문했는가 — 회차 번호 없는 항목은 재방문 판정에 세지 않는다. */
+const repeatedWalkNode = (walk: readonly LocalJudgeWalkEntry[]): { node: string; visits: number } | undefined => {
+  const byNode = new Map<string, Set<number>>();
+  for (const entry of walk) {
+    if (typeof entry?.node !== 'string' || entry.node.length === 0 || typeof entry?.round !== 'number') continue;
+    let rounds = byNode.get(entry.node);
+    if (!rounds) {
+      rounds = new Set<number>();
+      byNode.set(entry.node, rounds);
+    }
+    rounds.add(entry.round);
+  }
+  for (const [node, rounds] of byNode) {
+    if (rounds.size >= 2) return { node, visits: rounds.size };
+  }
+  return undefined;
+};
+
+export function localSupervisorJudge(input: LocalSupervisorJudgeInput): LocalSupervisorJudgeVerdict {
+  const { candidates, screen, walk, rework } = input;
+  if (candidates.length === 0) {
+    throw new Error('local-supervisor-judge: 판정 후보(candidates)가 비었다 — 후보 없이는 판정할 수 없다');
+  }
+  for (const candidate of candidates) {
+    if (!(SUPERVISOR_STOP_REASONS as readonly string[]).includes(candidate)) {
+      throw new Error(`local-supervisor-judge: 후보 '${String(candidate)}' 은(는) SupervisorStopReason 이 아니다`);
+    }
+  }
+
+  const signals: string[] = [];
+  const outcome = screen?.screenOutcome ?? undefined;
+  signals.push(outcome === 'complete' ? 'screen:complete'
+    : outcome === 'incomplete' ? 'screen:incomplete'
+    : 'screen:absent');
+  if (screen?.screenSpace) signals.push(`screen-space:${screen.screenSpace}`);
+  const tail = typeof screen?.screenTail === 'string' ? screen.screenTail : '';
+  const tailSaysComplete = tail.includes('GOAL-COMPLETE');
+  if (tailSaysComplete) signals.push('screen-tail:GOAL-COMPLETE');
+  if (outcome === 'incomplete' && tailSaysComplete) signals.push('screen:conflict-incomplete-over-tail');
+  if (rework?.trend) signals.push(`rework:trend=${rework.trend}`);
+  if (rework?.signature) signals.push(`rework:signature=${rework.signature}`);
+  if (typeof rework?.runs === 'number' && rework.runs >= 2) signals.push(`rework:runs=${rework.runs}`);
+  if (rework?.lastReason) signals.push(`rework:last=${rework.lastReason}`);
+  const walkRepeat = repeatedWalkNode(walk ?? []);
+  if (walkRepeat) signals.push(`walk:repeat:${walkRepeat.node}x${walkRepeat.visits}`);
+
+  // Explicit incomplete outcome is stronger than a marker in buffered text, which may be stale.
+  // A marker in the PTY buffer has no round identity; only the explicit outcome authorizes completion.
+  const screenSaysComplete = outcome === 'complete';
+  // A repeated node and one current signature do not prove that the same finding recurred.
+  // Only the measured review trend can authorize an oscillation stop.
+  const oscillating = rework?.trend === 'oscillating';
+  if (screenSaysComplete) signals.push('signal:completion');
+  if (oscillating) signals.push('signal:oscillation');
+
+  const verdict = (reason: SupervisorStopReason, confidence: number, label: string): LocalSupervisorJudgeVerdict => {
+    const why = `로컬 판정(${label}) — ${reason} · 근거 ${signals.join(' · ')}`;
+    return {
+      stopReason: reason,
+      determined: true,
+      why,
+      confidence,
+      signals,
+      oscillating,
+      decisionFragment: { action: 'stop', stopReason: reason, why },
+    };
+  };
+
+  // ① 화면 완료 — 수렴 계열 후보 중 강한 순.
+  if (screenSaysComplete) {
+    const picked = firstPresent(LOCAL_JUDGE_CONVERGENCE_ORDER, candidates);
+    if (picked !== undefined) return verdict(picked, COMPLETION_CONFIDENCE, 'completion-family');
+  }
+
+  // ② 진동 — 측정된 재작업 추이(trend)만 종료 근거다. 노드 재방문은 진단 신호로 남긴다.
+  if (oscillating) {
+    const picked = firstPresent(LOCAL_JUDGE_OSCILLATION_ORDER, candidates);
+    if (picked !== undefined) {
+      return verdict(picked, OSCILLATION_TREND_CONFIDENCE, 'oscillation-family');
+    }
+  }
+
+  // ③ 화면 미완료 — 아직 끝나지 않았으므로 수렴 계열 후보를 기각한다.
+  if (outcome === 'incomplete') {
+    const survivor = candidates.find((candidate) => !isConvergence(candidate));
+    if (survivor !== undefined) return verdict(survivor, VETO_CONFIDENCE, 'incomplete-veto');
+    signals.push('signal:undetermined');
+    const why = `로컬 판정(undetermined) — incomplete 화면이 모든 수렴 후보를 기각 · 근거 ${signals.join(' · ')}`;
+    return { determined: false, why, confidence: 0, signals, oscillating,
+      decisionFragment: { action: 'relaunch', why } };
+  }
+
+  // ④ 신호가 판단을 가르지 못한다 — 호출자 후보 순위의 첫 후보.
+  return verdict(candidates[0]!, FALLBACK_CONFIDENCE, 'fallback-order');
+}

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

@@ -5,12 +5,14 @@ import type { DeployVerifyFinding } from '../harness/browser-verify.js';
 import type { SelfDevJobResult, SupervisorStopReason, SupervisorNext, ReviewRework } from './run-types.js';
 import { authorRepairGoal } from '../harness/helper-repair.js';
 export type { SupervisorStopReason } from './run-types.js';
+export { SUPERVISOR_STOP_REASONS } from './run-types.js';
 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 { cardPrNumber, taskAgentStatePath } from '../task-agent/task-hand.js';
+import { classifyMustFixRound, inferMustFixEvidence, type MustFixRoundClassification, type MustFixRoundObservation } from '../self-implement/review-mustfix-class.js';
 
 export interface SupervisorRound {
   round: number;
@@ -46,6 +48,18 @@ export interface SupervisorRound {
    * streak pairs rounds by this key. Omitted on older history — the guard then pairs by taskId as before.
    */
   noPrFeatureKeys?: string[];
+  /** REVIEW-MUSTFIX-CLASSIFY — that round's observed must-fix items; pairs the next round's classification. */
+  mustFix?: MustFixRoundObservation;
+  /**
+   * PATTERN-MINE LOST-TIME — ms that round's undelivered results spent, banked into the ledger when their
+   * generation is replaced by a rerun (failures and re-runs both count — «잃은 시간» is not only the last round).
+   * A task held for a human (`decision.oscillation.heldTaskIds`) survives into the next round as the same
+   * execution, so its time banks only when it leaves or at the terminal mine — never twice. Omitted when
+   * nothing banked, so older history and rounds without a measured duration stay comparable.
+   */
+  lostTimeMsByTask?: Record<string, number>;
+  /** Tasks that left this round without a measured duration; a later measured rerun cannot make their total known. */
+  unknownTimeTaskIds?: string[];
 }
 
 /** Failed without a PR — a result that carries either a PR number or a PR URL has one (fixtures and older producers set only one). */
@@ -61,25 +75,6 @@ export function noPrStreakKey(feature: unknown): string {
   return typeof feature === 'string' ? resumeKey(feature).replace(/[\s.,;:!?。…·]+$/u, '') : '';
 }
 
-export const SUPERVISOR_STOP_REASONS = [
-  'converged',
-  'human-stopped',
-  'parent-signals-red',
-  'needs-human',
-  'no-actionable-work',
-  'harvestable-awaiting-human',
-  'handed-off-to-salvage',
-  'max-rounds',
-  'no-progress',
-  'provider-exhausted',
-  'step-timeout',
-  'decomposable-no-progress',
-  'review-unobserved',
-  'review-oscillating',
-  'deliverable-unobserved',
-  'deliverable-merged',
-] as const satisfies readonly SupervisorStopReason[];
-
 export const SUPERVISOR_ACTIONS = ['relaunch', 'add-repair-task', 'stop'] as const;
 
 export interface DecomposePromotionOutcome {
@@ -116,6 +111,10 @@ export interface SupervisorDecision {
   deliverableUnmeasured: boolean;
   deliverableMergeCompleteness: 'unmeasured' | 'complete' | 'incomplete';
   reviewMustFixTrend: ReviewRework['trend'];
+  /** REVIEW-MUSTFIX-CLASSIFY — this round's leading must-fix class (② › ③ observed › ①); omitted when unmeasured (지금 동작 그대로). */
+  mustFix?: MustFixRoundClassification;
+  /** REVIEW-MUSTFIX-CLASSIFY — every oscillating task's measured class, so a mixed round keeps each task's decision. */
+  mustFixByTask?: Record<string, MustFixRoundClassification>;
   oscillation?: { taskIds: string[]; helper: 'review-oscillation'; signature: string; repairGoals?: Record<string, string>; heldTaskIds?: string[] };
   pendingDecision?: 'attempt-care-escalation';
 }
@@ -234,6 +233,41 @@ export function aggregateReviewTrend(results: readonly SelfDevJobResult[]): Revi
   return severity[Math.max(...trends.map((trend) => severity.indexOf(trend)))];
 }
 
+/**
+ * REVIEW-MUSTFIX-CLASSIFY — this round's must-fix observation from the results' verbatim `reviewMustFix`.
+ * Each item carries its `taskId` so the next round pairs per task (one task's recurrence never holds another).
+ */
+function mustFixFromResults(results: readonly SupervisorJobResult[]): MustFixRoundObservation {
+  const items = results.flatMap((result) => (result.reviewMustFix ?? []).map((text) => {
+    const evidence = inferMustFixEvidence(text);
+    return { text, taskId: result.taskId, ...(evidence === undefined ? {} : { evidence }) };
+  }));
+  return items.length > 0 ? { items } : {};
+}
+
+/**
+ * REVIEW-MUSTFIX-CLASSIFY — per-task class. `prev` is the preceding round's items of the same task or its repair
+ * lineage (`oscillationRepairOf`), and only when that preceding round authored a repair for it — «수리 뒤 같은 지적»
+ * means a repair ran between the last observation and this one, not «repaired at any time». Lineage items are
+ * re-scoped to this task so the pure pairing accepts them; unrelated tasks never pair.
+ */
+function classifyTaskMustFix(result: SupervisorJobResult, preceding: SupervisorRound | undefined): MustFixRoundClassification {
+  const pairIds = new Set([result.taskId, ...(result.oscillationRepairOf ? [result.oscillationRepairOf] : [])]);
+  const repairedSincePrev = (preceding?.oscillationRepairTaskIds ?? []).some((id) => pairIds.has(id));
+  const prevItems = repairedSincePrev
+    ? (preceding?.mustFix?.items ?? []).filter((item) => item.taskId !== undefined && pairIds.has(item.taskId))
+      .map((item) => ({ ...item, taskId: result.taskId }))
+    : [];
+  return classifyMustFixRound(prevItems.length > 0 ? { items: prevItems } : undefined, mustFixFromResults([result]));
+}
+
+/**
+ * Classes that hold a task out of this round's same-run repair. Only ② acts in this slice; ③ recurring is
+ * observed (decision `mustFix`/`mustFixByTask` · crossReview suggestion) but behaves as ① — acting on it is a
+ * follow-up cell (REVIEW-MUSTFIX-CLASSIFY partial landing).
+ */
+const MUST_FIX_HELD = new Set<MustFixRoundClassification['class']>(['post-land-evidence']);
+
 export function decideNextRun(input: {
   results: readonly SupervisorJobResult[];
   history?: readonly SupervisorRound[];
@@ -520,8 +554,27 @@ export function decideNextRun(input: {
         || (entry.oscillationRepairFeatures?.[index] !== undefined && entry.oscillationRepairFeatures[index] === result.feature
           && Object.values(entry.oscillationRepairGoals ?? {}).includes(result.feature))));
     // Per task: a task that already got its one oscillation repair is held for a human; a fresh one may get it.
-    const fresh = oscillating.filter((result) => !isRepaired(result));
-    const held = [...new Set(oscillating.filter(isRepaired).map((result) => result.taskId))];
+    // REVIEW-MUSTFIX-CLASSIFY — 슈퍼바이저는 추이 대신 회차 분류를 먼저 본다(대표 10-12 «노하우가 아니라 로직으로» · 임의 임계 없음).
+    //   ① new-defect — 그대로 수렴(진동 수리 유지).
+    //   ② post-land-evidence — 증거는 착지 뒤에만 난다 ⇒ 같은 런 재수리 0, «그림자 착지 → 관측 → live» 쪼개기 결정.
+    //   ③ recurring — 수리 뒤 같은 지적 ⇒ 이 조각에선 관측만(교차 리뷰 제안을 결정에 싣고 동작은 ① 그대로 · 후속 칸).
+    //   unmeasured — 분류 불가 ⇒ 지금 동작 그대로. 분류는 조각마다 — 한 조각의 분류가 다른 조각의 수리를 끊지 않는다.
+    const taskClasses = new Map(oscillating.map((result) => [result.taskId, classifyTaskMustFix(result, preceding)]));
+    const fresh = oscillating.filter((result) => !isRepaired(result) && !MUST_FIX_HELD.has(taskClasses.get(result.taskId)!.class));
+    const classes = [...taskClasses.values()];
+    // Decision-level class: ② (the only acting class) first, then observed ③, else ①.
+    const mustFixClass = classes.find((c) => c.class === 'post-land-evidence') ?? classes.find((c) => c.class === 'recurring')
+      ?? classes.find((c) => c.class === 'new-defect');
+    // Held = already repaired once, or classified ② — either way it never rides this round's rerun.
+    const classHeld = [...new Set(oscillating.filter((result) => !isRepaired(result)
+      && MUST_FIX_HELD.has(taskClasses.get(result.taskId)!.class)).map((result) => result.taskId))];
+    const held = [...new Set([...oscillating.filter(isRepaired).map((result) => result.taskId), ...classHeld])];
+    const repairedHeld = held.filter((id) => !classHeld.includes(id));
+    // Every task's measured class survives in the decision — a mixed round keeps ② split and the observed ③ cross-review suggestion both.
+    const mustFixByTask: Record<string, MustFixRoundClassification> = Object.fromEntries(
+      [...taskClasses].filter(([, c]) => c.class !== 'unmeasured'));
+    const heldReasons = [...new Set(classes.filter((c) => MUST_FIX_HELD.has(c.class)).map((c) => c.reason))];
+    const heldReasonSuffix = heldReasons.length ? ` · ${heldReasons.join(' · ')}` : '';
     const repairGoals: Record<string, string> = Object.fromEntries(fresh.flatMap((result) => {
       const goal = result.prNumber && result.reviewMustFix?.length
         ? authorRepairGoal({ pr: result.prNumber, category: 'review-oscillation', originalRequest: result.feature,
@@ -551,14 +604,16 @@ export function decideNextRun(input: {
       } : {}),
       action,
       ...(action === 'stop' ? { stopReason: 'review-oscillating' as const } : {}),
+      ...(mustFixClass ? { mustFix: mustFixClass } : {}),
+      ...(Object.keys(mustFixByTask).length ? { mustFixByTask } : {}),
       oscillation: { taskIds, helper: 'review-oscillation', signature, ...(Object.keys(repairGoals).length ? { repairGoals } : {}),
         ...(action === 'add-repair-task' && held.length ? { heldTaskIds: held } : {}) },
       pendingDecision: 'attempt-care-escalation',
       why: fresh.length === 0
-        ? `리뷰 진동 반복 — ${signatureOf(oscillating)} · 사람 결정 필요(같은 전략 재발사 금지)`
+        ? `리뷰 진동 반복 — ${signatureOf(oscillating)} · 사람 결정 필요(같은 전략 재발사 금지)${heldReasonSuffix}`
         : cannotRepair
-          ? `리뷰 진동 — ${signatureOf(oscillating)} · ${input.repairGoalExecution === false ? '이 감독 경로가 수리 골 실행을 선언하지 않았다(미선언 또는 불가)' : '수리 원문/PR 관측 불가'} · 사람 결정 필요(같은 전략 재발사 금지)`
-          : `리뷰 진동 — ${signatureOf(fresh)} · review-oscillation 수리 조각을 한 번 붙인다${input.repairGoalExecution === true ? '' : '(실행 배선 미선언 — 결정 칸만)'}${held.length ? ` · 이미 수리한 조각 ${held.join(', ')} 은 사람 결정 대기` : ''}`,
+          ? `리뷰 진동 — ${signatureOf(oscillating)} · ${input.repairGoalExecution === false ? '이 감독 경로가 수리 골 실행을 선언하지 않았다(미선언 또는 불가)' : '수리 원문/PR 관측 불가'} · 사람 결정 필요(같은 전략 재발사 금지)${heldReasonSuffix}`
+          : `리뷰 진동 — ${signatureOf(fresh)} · review-oscillation 수리 조각을 한 번 붙인다${input.repairGoalExecution === true ? '' : '(실행 배선 미선언 — 결정 칸만)'}${repairedHeld.length ? ` · 이미 수리한 조각 ${repairedHeld.join(', ')} 은 사람 결정 대기` : ''}${classHeld.length ? ` · 분류로 보류한 조각 ${classHeld.join(', ')}` : ''}${heldReasonSuffix}`,
     };
   }
 
@@ -588,15 +643,31 @@ export function appendRound(
   const t = triageRun(results.filter((result) => result.salvage !== 'launched'), undefined, false, undefined, mainSyncRelaunchSpent(history));
   const baseCompleted = countBaseCompleted(results);
   const base = roundBase(results);
+  // REVIEW-MUSTFIX-CLASSIFY — 회차 원장에 관측을 실어 다음 회차 짝으로 쓴다(관측 없는 옛 원장은 그대로).
+  const mustFix = mustFixFromResults(results.filter((result) => result.salvage !== 'launched'));
   const noPrResults = results.filter(failedWithoutPr);
   const noPrTaskIds = noPrResults.map((result) => result.taskId);
   const noPrFeatureKeys = noPrResults.map((result) => noPrStreakKey(result.feature));
+  // PATTERN-MINE LOST-TIME — 이 회차의 배달 안 된 실행 시간을 원장에 은행한다(실패·재실행 모두).
+  //   진동 보류(held) 조각은 다음 회차로 «같은 실행»으로 살아 남으므로 여기서는 안 세고,
+  //   떠나는 회차나 종단에서 한 번만 센다. durationMs 를 안 잰 결과는 지어내지 않는다(모르는 시간은 0 이 아니다).
+  const heldTaskIds = new Set(decision?.oscillation?.heldTaskIds ?? []);
+  const lostTimeMsByTask: Record<string, number> = {};
+  const unknownTimeTaskIds = new Set<string>();
+  for (const result of results) {
+    if (heldTaskIds.has(result.taskId) || hasDelivered(result)) continue;
+    if (result.durationMs === undefined) { unknownTimeTaskIds.add(result.taskId); continue; }
+    lostTimeMsByTask[result.taskId] = (lostTimeMsByTask[result.taskId] ?? 0) + result.durationMs;
+  }
   return [...history, {
     round: history.length,
     landed: countLanded(results),
     ...(baseCompleted > 0 || base !== undefined ? { baseCompleted, ...(base === undefined ? {} : { base }) } : {}),
     actionable: countActionable(t),
     ...(reviewMustFixTrend === undefined ? {} : { reviewMustFixTrend }),
+    ...((mustFix.items ?? []).length > 0 ? { mustFix } : {}),
+    ...(Object.keys(lostTimeMsByTask).length > 0 ? { lostTimeMsByTask } : {}),
+    ...(unknownTimeTaskIds.size > 0 ? { unknownTimeTaskIds: [...unknownTimeTaskIds] } : {}),
     ...(results.some((result) => result.rework?.signature)
       ? { signatures: Object.fromEntries(results.filter((result) => result.rework?.signature).map((result) => [result.taskId, result.rework!.signature])) } : {}),
     ...(decision && decision.action !== 'stop' && decision.relaunchOnMain.length > 0 ? {
@@ -621,6 +692,195 @@ export function appendRound(
   }];
 }
 
+/** PATTERN-MINE — 생애 기록부 한 줄. `struggled`·`watch` 원문과 그 생애가 잃은 시간. */
+export interface PatternMineLifeRecord {
+  readonly lifeId: string;
+  readonly struggled?: string;
+  readonly watch?: string;
+  readonly lostTimeMs?: number;
+}
+
+/** PATTERN-MINE — decideNextRun 종단 서명(멈춤 어휘 · 진동 서명 · 실패 분류 · must-fix). */
+export interface PatternMineTerminalSignature {
+  readonly lifeId?: string;
+  readonly stopReason?: string;
+  readonly oscillationSignature?: string;
+  readonly classificationKind?: string;
+  readonly mustFix?: string;
+}
+
+export interface MinedFailurePattern {
+  readonly pattern: string;
+  readonly frequency: number;
+  readonly lifeCount: number;
+  /** Known only when every life bound to this pattern carried a time; null preserves unknown — never a default 0. */
+  readonly lostTimeMs: number | null;
+}
+
+export interface PatternMineAggregate {
+  readonly patterns: readonly MinedFailurePattern[];
+  readonly lifeCount: number;
+  /** Known only when every life carried a time; null preserves unknown — a missing input time is never summed as 0. */
+  readonly lostTimeMs: number | null;
+}
+
+function patternMineLifePart(life: PatternMineLifeRecord): string {
+  return [life.struggled, life.watch].filter((part): part is string => !!part && part.length > 0).join(' · ');
+}
+
+function patternMineSignaturePart(signature: PatternMineTerminalSignature | undefined): string {
+  if (!signature) return '';
+  return [signature.stopReason, signature.oscillationSignature, signature.classificationKind, signature.mustFix]
+    .filter((part): part is string => !!part && part.length > 0).join(' · ');
+}
+
+/** Bind struggled/watch with a terminal signature. Empty both sides is not a pattern. */
+export function bindPatternMineKey(life: PatternMineLifeRecord, signature?: PatternMineTerminalSignature): string {
+  const lifePart = patternMineLifePart(life);
+  const signaturePart = patternMineSignaturePart(signature);
+  if (!lifePart && !signaturePart) return '';
+  return signaturePart ? `${lifePart || '(기록 없음)'} ⊕ ${signaturePart}` : lifePart;
+}
+
+/**
+ * PATTERN-MINE — 순수 집계. 생애 기록부 struggled·watch 를 종단 서명과 묶어
+ * 패턴 빈도·생애 수·잃은 시간을 낸다. 입력이 비면 전부 0 이고 지어내지 않는다.
+ * 잃은 시간을 모르는 생애가 하나라도 섞이면 그 합은 unknown(null)을 보존한다 — 0 으로 확정하지 않는다.
+ */
+export function mineFailurePatterns(input: {
+  readonly lives: readonly PatternMineLifeRecord[];
+  readonly signatures?: readonly PatternMineTerminalSignature[];
+}): PatternMineAggregate {
+  const lives = input.lives;
+  const signatures = input.signatures ?? [];
+  const runLevel = signatures.find((signature) => !signature.lifeId);
+  const byLife = new Map(signatures.flatMap((signature) => signature.lifeId ? [[signature.lifeId, signature] as const] : []));
+  const groups = new Map<string, { lives: Set<string>; frequency: number; lostTimeMs: number | undefined }>();
+
+  const add = (pattern: string, lifeId: string | undefined, lostTimeMs: number | undefined): void => {
+    if (!pattern) return;
+    const group = groups.get(pattern) ?? { lives: new Set<string>(), frequency: 0, lostTimeMs: 0 };
+    group.frequency += 1;
+    if (lifeId) group.lives.add(lifeId);
+    // UNKNOWN 보존 — 모르는 시간(전달 안 됨)은 0 이 아니라 unknown 이고, 한 번 섞이면 그 합은 끝까지 unknown 이다.
+    if (lostTimeMs === undefined) group.lostTimeMs = undefined;
+    else if (group.lostTimeMs !== undefined) group.lostTimeMs += lostTimeMs;
+    groups.set(pattern, group);
+  };
+
+  for (const life of lives) {
+    add(bindPatternMineKey(life, (life.lifeId ? byLife.get(life.lifeId) : undefined) ?? runLevel), life.lifeId, life.lostTimeMs);
+  }
+  for (const signature of signatures) {
+    if (signature.lifeId ? lives.some((life) => life.lifeId === signature.lifeId) : lives.length > 0) continue;
+    add(bindPatternMineKey({ lifeId: signature.lifeId ?? '' }, signature), signature.lifeId, undefined);
+  }
+
+  const lifeIds = new Set(lives.map((life) => life.lifeId));
+  for (const signature of signatures) if (signature.lifeId) lifeIds.add(signature.lifeId);
+  const signatureWithoutLife = signatures.some((signature) => signature.lifeId && !lives.some((life) => life.lifeId === signature.lifeId));
+  const patternWithoutLife = groups.size > 0 && lives.length === 0;
+
+  return {
+    patterns: [...groups].map(([pattern, group]) => ({
+      pattern, frequency: group.frequency, lifeCount: group.lives.size, lostTimeMs: group.lostTimeMs ?? null,
+    })).sort((a, b) => b.frequency - a.frequency || a.pattern.localeCompare(b.pattern)),
+    lifeCount: lifeIds.size,
+    lostTimeMs: !signatureWithoutLife && !patternWithoutLife && lives.every((life) => life.lostTimeMs !== undefined)
+      ? lives.reduce((sum, life) => sum + (life.lostTimeMs ?? 0), 0)
+      : null,
+  };
+}
+
+interface PatternMineLifeAccumulator {
+  struggled: string[];
+  watch: string[];
+  lostTimeMs: number;
+  /** True once any duration-carrying fact touched this life — a delivered result counts as known 0. */
+  timeKnown: boolean;
+  /** True when a contributing execution's duration was not measured — unknown wins over any known sum. */
+  timeUnknown: boolean;
+}
+
+function patternMineRow(byLife: Map<string, PatternMineLifeAccumulator>, lifeId: string): PatternMineLifeAccumulator {
+  const row = byLife.get(lifeId) ?? { struggled: [], watch: [], lostTimeMs: 0, timeKnown: false, timeUnknown: false };
+  if (!byLife.has(lifeId)) byLife.set(lifeId, row);
+  return row;
+}
+
+/** appendRound 회차 원장 ⊕ 이번 결과에서 struggled·watch 생애 기록부를 읽는다. */
+export function patternMineLivesFromRounds(
+  rounds: readonly SupervisorRound[],
+  results: readonly SupervisorJobResult[],
+): PatternMineLifeRecord[] {
+  const byLife = new Map<string, PatternMineLifeAccumulator>();
+
+  for (const result of results) {
+    const row = patternMineRow(byLife, result.taskId);
+    if (result.rework?.trend === 'oscillating' && result.rework.signature) {
+      row.struggled.push(`리뷰 진동 ${result.rework.signature}`);
+    }
+    for (const text of result.reviewMustFix ?? []) {
+      row.struggled.push(text);
+      row.watch.push(text);
+    }
+    // PATTERN-MINE LOST-TIME — 종단 세대의 실행 시간. 배달된 결과는 잃은 시간이 0(known)이고,
+    //   durationMs 를 안 실은 실패는 unknown 을 보존한다(0 이 아니다).
+    if (hasDelivered(result)) row.timeKnown = true;
+    else if (result.durationMs === undefined) row.timeUnknown = true;
+    else {
+      row.lostTimeMs += result.durationMs;
+      row.timeKnown = true;
+    }
+  }
+
+  for (const round of rounds) {
+    for (const taskId of round.unknownTimeTaskIds ?? []) patternMineRow(byLife, taskId).timeUnknown = true;
+    for (const [taskId, signature] of Object.entries(round.signatures ?? {})) {
+      patternMineRow(byLife, taskId).struggled.push(`서명 ${signature}`);
+    }
+    for (const item of round.mustFix?.items ?? []) {
+      const row = patternMineRow(byLife, item.taskId ?? `round-${round.round}`);
+      row.struggled.push(item.text);
+      if (item.evidence) row.watch.push(item.evidence);
+    }
+    for (const taskId of round.noPrTaskIds ?? []) patternMineRow(byLife, taskId).struggled.push('PR 없이 실패');
+    // PATTERN-MINE LOST-TIME — 앞선 회차가 원장에 은행한 실패·재실행 시간을 생애에 합산한다.
+    for (const [taskId, lostTimeMs] of Object.entries(round.lostTimeMsByTask ?? {})) {
+      const row = patternMineRow(byLife, taskId);
+      row.lostTimeMs += lostTimeMs;
+      row.timeKnown = true;
+    }
+  }
+
+  return [...byLife].map(([lifeId, row]) => ({
+    lifeId,
+    ...(row.struggled.length ? { struggled: [...new Set(row.struggled)].join(' · ') } : {}),
+    ...(row.watch.length ? { watch: [...new Set(row.watch)].join(' · ') } : {}),
+    // 아는 입력에 대해서만 시간을 낸다 — unknown 이 섞였거나 아는 것이 없으면 칸 자체를 안 만든다(0 이 아니다).
+    ...(row.timeUnknown || !row.timeKnown ? {} : { lostTimeMs: row.lostTimeMs }),
+  }));
+}
+
+/** decideNextRun 종단 결정에서 서명(실패 분류 · must-fix · 멈춤 어휘 · 진동 서명)을 읽는다. */
+export function patternMineSignaturesFromDecision(decision: SupervisorDecision): PatternMineTerminalSignature[] {
+  const shared = {
+    ...(decision.stopReason ? { stopReason: decision.stopReason } : {}),
+    ...(decision.oscillation?.signature ? { oscillationSignature: decision.oscillation.signature } : {}),
+  };
+  const perTask = decision.classifications.map((classification) => {
+    const mustFix = decision.mustFixByTask?.[classification.taskId]?.class ?? decision.mustFix?.class;
+    return {
+      lifeId: classification.taskId,
+      ...shared,
+      classificationKind: classification.kind,
+      ...(mustFix ? { mustFix } : {}),
+    };
+  });
+  if (perTask.length > 0) return perTask;
+  return shared.stopReason || shared.oscillationSignature ? [{ ...shared }] : [];
+}
+
 export interface SuperviseRunOptions {
   initial: readonly SupervisorJobResult[];
   rerun: (previous: readonly SupervisorJobResult[], invocation: { relaunch: true; repairGoals?: Record<string, string> }) => Promise<readonly SupervisorJobResult[]>;
@@ -804,6 +1064,22 @@ export async function superviseRun(opts: SuperviseRunOptions): Promise<Superviso
       const reason = decision.stopReason ?? 'unregistered-stop';
       const next = routeSupervisorVerdict(reason, results).next;
       try { debug.log('self-dev.supervisor', 'verdict-edge', { runId, reason, next }); } catch { /* observation must not interrupt supervision */ }
+      // PATTERN-MINE — 종단에서만 채굴한다. 판정·원장 형식은 그대로이고 관측만 남긴다.
+      const patternMine = mineFailurePatterns({
+        lives: patternMineLivesFromRounds(history, results),
+        signatures: patternMineSignaturesFromDecision(decision),
+      });
+      try {
+        opts.observe?.('pattern-mine', {
+          runId,
+          stopReason: decision.stopReason ?? null,
+          lifeCount: patternMine.lifeCount,
+          lostTimeMs: patternMine.lostTimeMs,
+          frequency: patternMine.patterns.reduce((sum, mined) => sum + mined.frequency, 0),
+          patterns: patternMine.patterns,
+        });
+      } catch { /* fail-open */ }
+      try { debug.log('self-dev.supervisor', 'pattern-mine', { runId, lifeCount: patternMine.lifeCount, lostTimeMs: patternMine.lostTimeMs, frequency: patternMine.patterns.reduce((sum, mined) => sum + mined.frequency, 0), patterns: patternMine.patterns }); } catch { /* fail-open */ }
       results = results.map((result) => ({ ...result, next }));
       if (runId && decision.stopReason) {
         const storage = resolveSupervisorStopStorage(opts.runStore);

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

@@ -188,4 +188,24 @@ export type SupervisorStopReason =
   | 'deliverable-unobserved'
   | 'deliverable-merged';
 
+/** Lightweight runtime catalogue shared by the supervisor and pure local judge. */
+export const SUPERVISOR_STOP_REASONS = [
+  'converged',
+  'human-stopped',
+  'parent-signals-red',
+  'needs-human',
+  'no-actionable-work',
+  'harvestable-awaiting-human',
+  'handed-off-to-salvage',
+  'max-rounds',
+  'no-progress',
+  'provider-exhausted',
+  'step-timeout',
+  'decomposable-no-progress',
+  'review-unobserved',
+  'review-oscillating',
+  'deliverable-unobserved',
+  'deliverable-merged',
+] as const satisfies readonly SupervisorStopReason[];
+
 export type SupervisorNext = 'harvest' | 'scope-decompose' | 'self-review' | 'human-gate' | 'proposal';

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

@@ -16,6 +16,8 @@ export interface GateShardAttempt {
   baselineExitCode: number | null;
   currentSignal?: string | null;
   baselineSignal?: string | null;
+  currentDiagnostic?: string;
+  baselineDiagnostic?: string;
   /** 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[];
@@ -38,13 +40,13 @@ const decode = (text: string): string => text.replace(/&(#x[0-9a-f]+|#\d+|amp|lt
   return ({ amp: '&', lt: '<', gt: '>', quot: '"', apos: "'" } as Record<string, string>)[key.toLowerCase()] ?? entity;
 });
 
-interface XmlElement { name: string; attrs: Record<string, string>; children: XmlElement[]; text: string }
+export interface XmlElement { name: string; attrs: Record<string, string>; children: XmlElement[]; text: string }
 
 /** Strict, dependency-free XML reader for JUnit reports: the whole document must be well formed
  *  (one root, balanced tags, nothing but whitespace/comments after the root). CDATA and comments are
  *  text, never elements — so a `<testcase>` inside a failure message is not a test case, and a report
  *  followed by a truncated tail is rejected as unmeasured rather than read as complete. */
-function parseXml(xml: string): XmlElement | undefined {
+export function parseXml(xml: string): XmlElement | undefined {
   const stack: XmlElement[] = [];
   let root: XmlElement | undefined;
   let i = xml.charCodeAt(0) === 0xfeff ? 1 : 0;
@@ -191,6 +193,17 @@ function readJUnit(xml: string, files: readonly string[]): JUnitCase[] | undefin
   return cases;
 }
 
+/** Reuse the gate XML count checks, then require zero skips for a one-file warm-worker artifact. */
+export function isCompleteOneFileGateJunit(xml: string, file: string): boolean {
+  const root = parseXml(xml);
+  if (!root) return false;
+  const noDeclaredSkips = (element: XmlElement): boolean =>
+    (element.attrs.skipped === undefined || element.attrs.skipped === '0') && element.children.every(noDeclaredSkips);
+  if (!noDeclaredSkips(root)) return false;
+  const cases = readJUnit(xml, [file]);
+  return !!cases && cases.every(item => !item.skipped);
+}
+
 const SKIPPED_PASSED_AT_BASE = 'skipped now · passed at base — a skip must not hide a regression (LIGHT-RC-MEASURE ②)';
 
 /** Cases that passed at the baseline but were skipped now are counted as `unknown` failures — never green. */