elanous 0.2.29 → 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,6 +5,7 @@ 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';
@@ -49,6 +50,16 @@ export interface SupervisorRound {
   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). */
@@ -64,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 {
@@ -656,6 +648,17 @@ export function appendRound(
   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),
@@ -663,6 +666,8 @@ export function appendRound(
     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 ? {
@@ -687,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[]>;
@@ -870,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

@@ -40,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;
@@ -193,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. */

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

@@ -1,3 +1,5 @@
+import { isGateSpawnLaneFile } from './spawn-lane-files.js';
+
 export interface GateTestShard {
   id: string;
   files: string[];
@@ -5,6 +7,27 @@ export interface GateTestShard {
   plannedSeconds: number;
 }
 
+/** Keep real child/PTY tests out of ordinary self-gate shards, within the caller's shard budget. */
+export function planSelfGateSpawnSeparatedShards(
+  files: readonly string[],
+  rssMb: ReadonlyMap<string, number>,
+  seconds: ReadonlyMap<string, number>,
+  budgetGiB: number,
+  shardCount: number,
+): GateTestShard[] {
+  const unique = [...new Set(files)];
+  const spawn = unique.filter(isGateSpawnLaneFile);
+  const regular = unique.filter((file) => !isGateSpawnLaneFile(file));
+  if (!spawn.length || !regular.length) return planGateTestShards(unique, rssMb, seconds, budgetGiB, shardCount);
+  if (shardCount < 2) throw new Error('self gate spawn lane needs at least two shards when regular and spawn tests coexist');
+  const spawnCount = Math.min(3, spawn.length, shardCount - 1);
+  const planned = [
+    ...planGateTestShards(regular, rssMb, seconds, budgetGiB, shardCount - spawnCount),
+    ...planGateTestShards(spawn, rssMb, seconds, budgetGiB, spawnCount),
+  ];
+  return planned.map((shard, index) => ({ ...shard, id: `shard-${index + 1}` }));
+}
+
 /** RSS values are the per-file rss_mb observations; the budget is in GiB (1 GiB = 1024 MB here). */
 export function planGateTestShards(
   files: readonly string[],
@@ -50,3 +73,27 @@ export function planGateTestShards(
   }
   return shards;
 }
+
+/** OP FU (LAND-TRAIN-LIVE side) — opt-in `--fixed-shard-distribution`: no RSS/seconds measurement. Files are deduplicated,
+ *  sorted by code point (input-order independent) and dealt round-robin into at most `shardCount` shards; real child/PTY
+ *  tests keep their own lane exactly like the measured planner. Not a memory-safety guarantee — an over-budget shard
+ *  surfaces as its own run result (signal/exit/incomplete JUnit ⇒ unmeasured), never as a pass. No empty shards. */
+export function planFixedGateTestShards(files: readonly string[], shardCount: number): GateTestShard[] {
+  if (!Number.isSafeInteger(shardCount) || shardCount < 1) throw new Error('invalid shard count');
+  const sorted = [...new Set(files)].sort((a, b) => (a < b ? -1 : a > b ? 1 : 0));
+  const deal = (subset: readonly string[], count: number): string[][] => {
+    const buckets: string[][] = Array.from({ length: Math.min(count, subset.length) }, () => []);
+    subset.forEach((file, index) => buckets[index % buckets.length]!.push(file));
+    return buckets;
+  };
+  const spawn = sorted.filter(isGateSpawnLaneFile);
+  const regular = sorted.filter((file) => !isGateSpawnLaneFile(file));
+  let groups: string[][];
+  if (!spawn.length || !regular.length) groups = deal(sorted, shardCount);
+  else {
+    if (shardCount < 2) throw new Error('self gate spawn lane needs at least two shards when regular and spawn tests coexist');
+    const spawnCount = Math.min(3, spawn.length, shardCount - 1);
+    groups = [...deal(regular, shardCount - spawnCount), ...deal(spawn, spawnCount)];
+  }
+  return groups.map((group, index) => ({ id: `shard-${index + 1}`, files: group, plannedRssMb: 0, plannedSeconds: 0 }));
+}