elanous 0.2.42 → 0.2.44

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

@@ -8,7 +8,7 @@ export type { SupervisorStopReason } from './run-types.js';
 export { SUPERVISOR_STOP_REASONS } from './run-types.js';
 import { recordSelfDevRunSupervisorStop, selfDevRunsDir } from './run-store.js';
 import { readRunChart, recordRunChartDecision } from '../self-implement/run-chart.js';
-import { runLedgerDir } from '../self-implement/run-ledger.js';
+import { loadRunLedger, runLedgerDir } from '../self-implement/run-ledger.js';
 import { debug } from '../debug/log.js';
 import { sweepFrozenMerges } from '../self-implement/frozen-merges.js';
 import { selectKnowhowPack } from '../self-implement/knowhow-pack.js';
@@ -105,6 +105,25 @@ interface DecomposePromotionObservation {
   hotPathEdges?: number;
 }
 
+export interface SupervisorReauthorObservation {
+  round: number;
+  classifications: Array<{ taskId: string; text: string; kind: 'code-defect' | 'authorship-defect'; action: 'must-fix' | 'scope-reduction-fu' }>;
+  prescription: {
+    outcome: '부분 착지 + FU';
+    narrowedProposal: string;
+    partialLanding: string;
+    followUp: {
+      lane: 'REVIEW-ROUND-REAUTHOR-FU';
+      goalId: string;
+      feature: string;
+      targetPaths: string[];
+      completionBoundary: string;
+      mockScenarioId: string;
+      mockScenario: { id: string; injection: string; observation: string };
+    };
+  };
+}
+
 export interface SupervisorDecision {
   action: 'relaunch' | 'add-repair-task' | 'stop';
   stopReason?: SupervisorStopReason;
@@ -130,6 +149,8 @@ export interface SupervisorDecision {
   reviewMustFixTrend: ReviewRework['trend'];
   /** REVIEW-MUSTFIX-CLASSIFY — this round's leading must-fix class (② › ③ observed › ①); omitted when unmeasured (지금 동작 그대로). */
   mustFix?: MustFixRoundClassification;
+  /** REVIEW-ROUND-REAUTHOR — supervisory reauthoring decision, omitted for ordinary/legacy rounds. */
+  reauthor?: SupervisorReauthorObservation;
   /** REVIEW-MUSTFIX-CLASSIFY — every oscillating task's measured class, so a mixed round keeps each task's decision. */
   mustFixByTask?: Record<string, MustFixRoundClassification>;
   /**
@@ -367,6 +388,70 @@ function mustFixFromResults(results: readonly SupervisorJobResult[]): MustFixRou
   return items.length > 0 ? { items } : {};
 }
 
+function authoringDefect(text: string): boolean {
+  return /(?:불필요한\s*(?:경계|목표)|아직\s*없는\s*(?:부품|운영|배선)|미구현\s*(?:부품|운영|배선)|실물\s*전제|미래\s*가정|out[- ]of[- ]scope|not yet existing|future assumption)/iu.test(text);
+}
+
+function repeatedMustFix(text: string, taskId: string, history: readonly SupervisorRound[]): boolean {
+  const normalized = text.trim().replace(/\s+/gu, ' ').toLowerCase();
+  return history.filter((round) => round.mustFix?.items?.some((item) => item.taskId === taskId
+    && item.text.trim().replace(/\s+/gu, ' ').toLowerCase() === normalized)).length >= 1;
+}
+
+function reauthorObservation(results: readonly SupervisorJobResult[], history: readonly SupervisorRound[]): SupervisorReauthorObservation | undefined {
+  const reviewed = results.flatMap((result) => (result.reviewMustFix ?? []).map((text) => ({ result, text })));
+  if (!reviewed.length) return undefined;
+  const rounds = Math.max(...reviewed.map(({ result }) => result.rework?.rounds ?? 0));
+  const classified = reviewed.map(({ result, text }) => ({ result, text, authored: authoringDefect(text) }));
+  const triggered = classified.some(({ result, text }) => (result.rework?.rounds ?? 0) > 3
+    || repeatedMustFix(text, result.taskId, history));
+  if (!triggered) return undefined;
+  const round = Math.max(rounds, history.length + 1);
+  const classifications = classified.map(({ result, text, authored }) => ({
+    taskId: result.taskId, text, kind: authored ? 'authorship-defect' as const : 'code-defect' as const,
+    action: authored ? 'scope-reduction-fu' as const : 'must-fix' as const,
+  }));
+  const authored = classified.filter((item) => item.authored);
+  const targetPaths = [...new Set(authored.flatMap(({ result }) => result.targetPaths ?? []))];
+  const narrowedProposal = authored.length
+    ? `골·칸·시험에서 제거: ${authored.map(({ text }) => text).join(' · ')}`
+    : '현재 목표와 완료 경계에 한정하고 리뷰에서 확인된 코드 결함만 수정한다';
+  return {
+    round, classifications,
+    prescription: {
+      outcome: '부분 착지 + FU', narrowedProposal,
+      partialLanding: `현재 완결 가능한 범위만 착지한다${targetPaths.length ? ` — ${targetPaths.join(', ')}` : ''}`,
+      followUp: {
+        lane: 'REVIEW-ROUND-REAUTHOR-FU',
+        goalId: `reauthor-fu-${authored[0]?.result.prNumber ?? authored[0]?.result.taskId ?? 'unbound'}`,
+        feature: `저작 결함을 제외한 완결 범위를 구현하고 검증한다 — ${narrowedProposal}`,
+        targetPaths,
+        completionBoundary: targetPaths.length ? `대상 경로: ${targetPaths.join(', ')}; 완료 경계: 해당 경로 내 범위` : '대상 경로 및 완료 경계는 다음 저작에서 재접지한다',
+        mockScenarioId: 'MS-03',
+        mockScenario: {
+          id: 'MS-03',
+          injection: `기존 리뷰 결과 주입: ${authored.map(({ text }) => text).join(' · ') || '반복 must-fix 재검토'}`,
+          observation: '제외된 저작 결함이 must-fix 목록에 없고, 부분 착지 및 FU 완료 경계가 관측된다',
+        },
+      },
+    },
+  };
+}
+
+function reauthorMustFixes(results: readonly SupervisorJobResult[], observation: SupervisorReauthorObservation | undefined): SupervisorJobResult[] {
+  if (!observation) return [...results];
+  const excluded = new Map<string, Set<string>>();
+  for (const item of observation.classifications) {
+    if (item.kind !== 'authorship-defect') continue;
+    const texts = excluded.get(item.taskId) ?? new Set<string>();
+    texts.add(item.text);
+    excluded.set(item.taskId, texts);
+  }
+  return results.map((result) => ({ ...result,
+    reviewMustFix: (result.reviewMustFix ?? []).filter((text) => !excluded.get(result.taskId)?.has(text)),
+  }));
+}
+
 /**
  * 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 — «수리 뒤 같은 지적»
@@ -470,8 +555,9 @@ type DecideNextRunInput = {
 };
 
 function decideNextRunCore(input: DecideNextRunInput): SupervisorDecision {
-  const results = [...input.results];
   const history = [...(input.history ?? [])];
+  const reauthor = reauthorObservation(input.results, history);
+  const results = reauthorMustFixes(input.results, reauthor);
   const maxRounds = input.limits?.maxRounds ?? DEFAULT_MAX_ROUNDS;
   const stallRounds = input.limits?.stallRounds ?? DEFAULT_STALL_ROUNDS;
   const observation = input.deliverableObservation
@@ -537,6 +623,7 @@ function decideNextRunCore(input: DecideNextRunInput): SupervisorDecision {
     deliverableUnmeasured: t.deliverableUnmeasured,
     deliverableMergeCompleteness,
     reviewMustFixTrend,
+    ...(reauthor ? { reauthor } : {}),
     rerunnable: t.rerunnable,
     reworkable: t.reworkable,
     decomposable: t.decomposable,
@@ -983,6 +1070,7 @@ export function appendRound(
     ...(baseCompleted > 0 || base !== undefined ? { baseCompleted, ...(base === undefined ? {} : { base }) } : {}),
     actionable: countActionable(t),
     ...(reviewMustFixTrend === undefined ? {} : { reviewMustFixTrend }),
+    ...(decision?.reauthor ? { reauthor: decision.reauthor } : {}),
     ...((mustFix.items ?? []).length > 0 ? { mustFix } : {}),
     ...(Object.keys(lostTimeMsByTask).length > 0 ? { lostTimeMsByTask } : {}),
     ...(unknownTimeTaskIds.size > 0 ? { unknownTimeTaskIds: [...unknownTimeTaskIds] } : {}),
@@ -1250,6 +1338,55 @@ export interface SuperviseRunOptions {
   }>;
 }
 
+/** Adapt REVIEW-ROUND-REAUTHOR's decision into an observation without duplicating its classification logic. */
+export function supervisorReauthorRequestObservations(
+  decision: SupervisorDecision,
+  parentRunId: string | null,
+  results: readonly SupervisorJobResult[],
+  resolveAuthorRunId: (ledgerRunId: string) => string | null = (ledgerRunId) => {
+    try {
+      const entries = loadRunLedger(ledgerRunId);
+      for (const entry of [...(entries ?? [])].reverse()) {
+        const authorRunId = entry.event === 'goal-authored' ? entry.data.authorRunId : undefined;
+        if (typeof authorRunId === 'string' && authorRunId.trim()) return authorRunId;
+      }
+    } catch { /* an absent or unreadable lineage ledger leaves this event unjoined */ }
+    return null;
+  },
+): Array<{ event: 'supervisor.reauthor-request' | 'supervisor.reauthor-unjoined'; data: Record<string, unknown> }> {
+  const reauthor = decision.reauthor;
+  if (!reauthor) return [];
+  return reauthor.classifications.flatMap((classification): Array<{ event: 'supervisor.reauthor-request' | 'supervisor.reauthor-unjoined'; data: Record<string, unknown> }> => {
+    if (classification.kind !== 'authorship-defect') return [];
+    const result = results.find((candidate) => candidate.taskId === classification.taskId);
+    const sourceReviewRunId = result?.runId;
+    const authorRunId = (parentRunId ? resolveAuthorRunId(parentRunId) : null)
+      ?? (sourceReviewRunId ? resolveAuthorRunId(sourceReviewRunId) : null);
+    if (!authorRunId) return [{
+      event: 'supervisor.reauthor-unjoined',
+      data: {
+        ...(parentRunId ? { parentRunId } : {}),
+        ...(sourceReviewRunId ? { sourceReviewRunId } : {}),
+        taskId: classification.taskId,
+        attempt: reauthor.round,
+        classification: 'authorship-defect',
+        reason: 'author-run-id-unresolved',
+      },
+    }];
+    return [{
+      event: 'supervisor.reauthor-request' as const,
+      data: {
+        conversationId: authorRunId,
+        runId: authorRunId,
+        ...(parentRunId ? { parentRunId } : {}),
+        ...(sourceReviewRunId ? { sourceReviewRunId } : {}),
+        attempt: reauthor.round,
+        classification: 'authorship-defect',
+      },
+    }];
+  });
+}
+
 type SupervisorStopStorageSource = 'operator-dir' | 'run-store-dir' | 'process-default';
 
 function resolveSupervisorStopStorage(runStore: SuperviseRunOptions['runStore']): {
@@ -1345,6 +1482,15 @@ export async function superviseRun(opts: SuperviseRunOptions): Promise<Superviso
         ...(allUnreviewedAreNoDiff ? { reviewReason: 'no-diff' } : {}),
       } : {}),
     });
+    if (decision.reauthor) {
+      try {
+        opts.observe?.('review.reauthor', {
+          round: decision.reauthor.round,
+          classifications: decision.reauthor.classifications,
+          prescription: decision.reauthor.prescription,
+        });
+      } catch { /* fail-open */ }
+    }
     if (chartRunId) {
       recordRunChartDecision({ runId: chartRunId, device: 'outer-supervisor',
         stopKey: `${chartRunId}:outer-supervisor:${history.length + 1}`, observed: `results=${results.length}`,
@@ -1382,6 +1528,10 @@ export async function superviseRun(opts: SuperviseRunOptions): Promise<Superviso
 
     const runId = chartRunId;
 
+    for (const request of supervisorReauthorRequestObservations(decision, runId, results)) {
+      try { opts.observe?.(request.event, request.data); } catch { /* observation is fail-soft */ }
+    }
+
     let decomposePromotion: DecomposePromotionObservation = decision.decomposable.length === 0
       ? { attempted: false, reason: 'no-decomposable-decision' }
       : decision.action === 'stop'

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

@@ -12,6 +12,10 @@ import type { GateTestShard } from './shard-plan.js';
 export interface GateShardAttempt {
   shardId: string;
   attempt: number;
+  /** Wall time for this shard attempt across current and baseline processes. */
+  elapsedMs?: number;
+  currentUnmeasuredReason?: string;
+  baselineUnmeasuredReason?: string;
   /** A process death, missing report, or incomplete XML is not a test failure. */
   currentJUnit?: string;
   baselineJUnit?: string;

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

@@ -130,6 +130,8 @@ export function maxAutomaticShardCount(requested: number, budgetGiB: number, res
 export type ShardProcess = (cwd: string, files: readonly string[]) => {
   exitCode: number | null;
   signal?: string | null;
+  elapsedMs?: number;
+  unmeasuredReason?: string;
   junit?: string;
   rssMb?: number;
   seconds?: number;
@@ -337,12 +339,16 @@ function runPlannedShards(
         if (baselineFiles.length < shard.files.length) {
           debug.log('self-dev.shard', 'baseline-files-absent', { shardId: shard.id, round, absent: shard.files.filter((file) => !baselineFiles.includes(file)) });
         }
+        const shardStartedAt = performance.now();
         const current = runSafely(cwd, shard.files);
         const base = baselineFiles.length ? runSafely(dir, baselineFiles) : { exitCode: 0 };
         keepFailure(shard.id, 'current', round, shard.files, current);
         keepFailure(shard.id, 'baseline', round, baselineFiles, base);
         attempts.push({
           shardId: shard.id, attempt: round,
+          elapsedMs: Math.round(performance.now() - shardStartedAt),
+          currentUnmeasuredReason: current.unmeasuredReason,
+          baselineUnmeasuredReason: base.unmeasuredReason,
           currentJUnit: current.junit, baselineJUnit: base.junit,
           currentExitCode: current.exitCode, baselineExitCode: base.exitCode,
           currentSignal: current.signal, baselineSignal: base.signal,
@@ -471,6 +477,8 @@ export async function runShardedGateTestsAsync(
           if (concurrency > 1 && baselineFiles.length && base.exitCode === 0 && !base.signal && base.junit) baselinePassCache.set(shard.id, base);
           roundAttempts[index] = {
             shardId: shard.id, attempt: round, currentJUnit: current.junit, baselineJUnit: base.junit,
+            elapsedMs: Math.round(performance.now() - currentStartedAt),
+            currentUnmeasuredReason: current.unmeasuredReason, baselineUnmeasuredReason: base.unmeasuredReason,
             currentExitCode: current.exitCode, baselineExitCode: base.exitCode,
             currentSignal: current.signal, baselineSignal: base.signal,
             currentDiagnostic: current.diagnostic, baselineDiagnostic: base.diagnostic,
@@ -523,23 +531,31 @@ function incompleteShardReasons(shardIds: readonly string[], attempts: readonly
   return Object.fromEntries(shardIds.map((id) => {
     const latest = attempts.filter((attempt) => attempt.shardId === id).at(-1);
     if (!latest) return [id, 'no shard attempt recorded'];
-    const side = (name: string, rc: number | null, signal: string | null | undefined, junit: string | undefined, diagnostic: string | undefined): string => {
+    const side = (name: string, rc: number | null, signal: string | null | undefined, junit: string | undefined, diagnostic: string | undefined, unmeasuredReason?: string): string => {
+      if (unmeasuredReason) return `${name}: ${unmeasuredReason}`;
       const safeDiagnostic = diagnostic ? redactSecretText(diagnostic).replace(/[\r\n\t\x00-\x1f\x7f]+/g, ' ').slice(0, 500) : undefined;
       return `${name}: exit ${rc ?? 'unavailable'}, signal ${signal ?? 'none'}, JUnit ${junit === undefined ? 'missing' : 'present'}`
         + (safeDiagnostic ? `; ${safeDiagnostic}` : '');
     };
     const statuses = [
-      side('current', latest.currentExitCode, latest.currentSignal, latest.currentJUnit, latest.currentDiagnostic),
-      ...(latest.baselineFiles?.length === 0 ? [] : [side('baseline', latest.baselineExitCode, latest.baselineSignal, latest.baselineJUnit, latest.baselineDiagnostic)]),
+      side('current', latest.currentExitCode, latest.currentSignal, latest.currentJUnit, latest.currentDiagnostic, latest.currentUnmeasuredReason),
+      ...(latest.baselineFiles?.length === 0 ? [] : [side('baseline', latest.baselineExitCode, latest.baselineSignal, latest.baselineJUnit, latest.baselineDiagnostic, latest.baselineUnmeasuredReason)]),
     ];
     return [id, `${statuses.join(' · ')} · aggregate rejected (incomplete, malformed JUnit, or exit/JUnit mismatch)`];
   }));
 }
 
-export function selfGateShardTimeoutMs(files: readonly string[]): number {
+export const DEFAULT_SELF_GATE_SHARD_TIMEOUT_MS = 900_000;
+export const SELF_GATE_SHARD_TIMEOUT_ENV = 'ELANOUS_SELF_GATE_SHARD_TIMEOUT_MS';
+
+export function selfGateShardTimeoutMs(files: readonly string[], env: NodeJS.ProcessEnv = process.env): number {
   const spawnFiles = files.filter(isGateSpawnLaneFile);
   if (spawnFiles.length && spawnFiles.length !== files.length) throw new Error('self gate spawn lane mixed with regular tests');
-  return spawnFiles.length ? 120_000 : 300_000;
+  const configured = env[SELF_GATE_SHARD_TIMEOUT_ENV];
+  if (configured !== undefined && (!/^\d+$/.test(configured) || !Number.isSafeInteger(Number(configured)) || Number(configured) < 1)) {
+    throw new Error(`${SELF_GATE_SHARD_TIMEOUT_ENV} must be a positive integer number of milliseconds`);
+  }
+  return configured === undefined ? (spawnFiles.length ? 120_000 : DEFAULT_SELF_GATE_SHARD_TIMEOUT_MS) : Number(configured);
 }
 
 export function runBunShard(cwd: string, files: readonly string[]): ReturnType<ShardProcess> {
@@ -547,25 +563,29 @@ export function runBunShard(cwd: string, files: readonly string[]): ReturnType<S
 }
 
 /** Child launch seam for verifying the actual command and process timeout. */
-export function runBunShardWithSpawn(cwd: string, files: readonly string[], spawn: typeof Bun.spawnSync): ReturnType<ShardProcess> {
-  const timeout = selfGateShardTimeoutMs(files);
-  const spawnLane = timeout === 120_000;
+export function runBunShardWithSpawn(cwd: string, files: readonly string[], spawn: typeof Bun.spawnSync, env: NodeJS.ProcessEnv = process.env): ReturnType<ShardProcess> {
+  const timeout = selfGateShardTimeoutMs(files, env);
+  const spawnLane = files.some(isGateSpawnLaneFile);
   const dir = mkdtempSync(join(tmpdir(), 'elanous-shard-junit-'));
   const report = join(dir, 'result.xml');
   const isolated = prepareDeterministicChildEnvironment('elanous-shard-test-env-', { env: withGateTestEnv(process.env) });
   try {
     const measured = files.length === 1;
-    const args = ['test', ...(spawnLane ? ['--timeout=120000'] : []), '--reporter=junit', `--reporter-outfile=${report}`, ...files];
+    const args = ['test', ...(spawnLane ? [`--timeout=${timeout}`] : []), '--reporter=junit', `--reporter-outfile=${report}`, ...files];
     const started = performance.now();
     const result = spawn(['bun', ...args], {
       cwd, env: isolated.env, stdout: 'pipe', stderr: 'pipe', timeout,
     });
     const durationMs = performance.now() - started;
     const junit = existsSync(report) ? readFileSync(report, 'utf8') : undefined;
+    const timedOut = (result as typeof result & { error?: { code?: string } }).error?.code === 'ETIMEDOUT'
+      || (durationMs >= timeout && (result.exitCode !== 0 || !!result.signalCode));
     const failed = result.exitCode !== 0 || !!result.signalCode || junit === undefined;
     return {
       exitCode: result.exitCode,
-      signal: result.signalCode ? String(result.signalCode) : undefined,
+      signal: timedOut ? undefined : result.signalCode ? String(result.signalCode) : undefined,
+      elapsedMs: Math.round(durationMs),
+      ...(timedOut ? { unmeasuredReason: `timeout ${timeout / 1000}s 초과` } : {}),
       junit,
       ...(junit === undefined && (result.exitCode !== 0 || result.signalCode)
         ? { diagnostic: boundedDiagnostic(result.stdout, result.stderr) } : {}),
@@ -580,9 +600,9 @@ export function runBunShardWithSpawn(cwd: string, files: readonly string[], spaw
 }
 
 /** Nonblocking child runner; each bundle still owns its own deterministic environment and JUnit path. */
-export async function runBunShardAsync(cwd: string, files: readonly string[], drainTimeoutMs = 5_000): Promise<ReturnType<ShardProcess>> {
-  const timeout = selfGateShardTimeoutMs(files);
-  const spawnLane = timeout === 120_000;
+export async function runBunShardAsync(cwd: string, files: readonly string[], drainTimeoutMs = 5_000, env: NodeJS.ProcessEnv = process.env): Promise<ReturnType<ShardProcess>> {
+  const timeout = selfGateShardTimeoutMs(files, env);
+  const spawnLane = files.some(isGateSpawnLaneFile);
   const dir = mkdtempSync(join(tmpdir(), 'elanous-shard-junit-'));
   const report = join(dir, 'result.xml');
   const isolated = prepareDeterministicChildEnvironment('elanous-shard-test-env-', { env: withGateTestEnv(process.env) });
@@ -590,7 +610,7 @@ export async function runBunShardAsync(cwd: string, files: readonly string[], dr
   let drainTimer: ReturnType<typeof setTimeout> | undefined;
   const drainAbort = new AbortController();
   try {
-    const args = ['test', ...(spawnLane ? ['--timeout=120000'] : []), '--reporter=junit', `--reporter-outfile=${report}`, ...files];
+    const args = ['test', ...(spawnLane ? [`--timeout=${timeout}`] : []), '--reporter=junit', `--reporter-outfile=${report}`, ...files];
     const started = performance.now();
     const child = Bun.spawn(['bun', ...args], { cwd, env: isolated.env, stdout: 'pipe', stderr: 'pipe' });
     let timedOut = false;
@@ -624,7 +644,8 @@ export async function runBunShardAsync(cwd: string, files: readonly string[], dr
     const signal = drainTimedOut ? 'DRAIN_TIMEOUT' : timedOut ? 'SIGKILL' : child.signalCode ? String(child.signalCode) : undefined;
     const failed = exitCode !== 0 || !!signal || junit === undefined;
     return {
-      exitCode, signal, junit,
+      exitCode, signal: timedOut ? undefined : signal, elapsedMs: Math.round(durationMs),
+      ...(timedOut ? { unmeasuredReason: `timeout ${timeout / 1000}s 초과` } : {}), junit,
       ...(files.length === 1 ? { rssMb: usage ? usage.maxRSS / (1024 * 1024) : undefined, seconds: durationMs / 1000 } : {}),
       ...(junit === undefined && (exitCode !== 0 || signal) ? { diagnostic: boundedDiagnostic(stdout, stderr) } : {}),
       ...(failed ? { failure: { durationMs: Math.round(durationMs), stdoutTail: outputTail(stdout), stderrTail: outputTail(stderr) } } : {}),

package/src/self-implement/abandoned-classification.ts

@@ -68,6 +68,7 @@ type AbandonedClassificationBasis =
   | 'merge-approval-received'
   // 기한 사망은 호스트가 읽은 Job 종료 이유다. 사후 쿼터 상관보다 앞선다.
   | 'substrate-deadline-outranks-postmortem-quota'
+  | 'tdd-evidence-missing'
   // 🩸 2026-09-20: 이 셋은 분류 «이름을 되풀이»했다 — 근거 칸이 동어반복이면 중재를 못 한다.
   //   📏 실물(block 아티팩트)에서 네 칸이 2:2 로 갈렸다:
   //        reason·stage = 게이트   ↔   중단원인·classification = 쿼타
@@ -115,6 +116,8 @@ interface AbandonedClassificationInput {
   /** 호스트가 k8s Job 종료 reason `DeadlineExceeded` 를 읽었을 때만 참이다.
    *  ⛔ 사후 쿼터 상관(`quotaExhausted`)보다 앞선다 — 기한 사망을 할당량 소진으로 읽지 않는다. */
   readonly substrateDeadlineExceeded?: boolean;
+  /** Structured child termination cause survives classification instead of being flattened into report-deficit. */
+  readonly terminationReason?: 'tdd-evidence-missing';
   /** ⭐ provider 쿼터가 «찬 것으로 관측»되었을 때만 참이다.
    *  ⛔ 이 값은 «추론하지 않는다» — 호출자가 provider 응답(`rateLimitReachedType`)을 읽어 넘긴다.
    *  ⚠️ 그 읽기는 런이 죽은 «뒤»에 일어나므로 「죽은 원인」이 아니라 「죽을 무렵 쿼터가 찼다」는 상관이다.
@@ -151,6 +154,7 @@ export interface AbandonedClassificationResult {
   readonly classification: AbandonedClassification;
   /** The condition that selected `classification`, so consumers need not reconstruct the branch. */
   readonly classificationBasis: AbandonedClassificationBasis;
+  readonly terminationReason?: 'tdd-evidence-missing';
   readonly worktreeClean: boolean | undefined;
   readonly completionDisposition?: SelfImplementCompletionDisposition;
   readonly supervisorVerdict?: ReworkBudgetVerdict;
@@ -221,6 +225,8 @@ export function classifyAbandonedRun(input: AbandonedClassificationInput): Aband
         ? 'credential-failure'
         : input.providerError === true
         ? 'provider-error'
+        : input.terminationReason === 'tdd-evidence-missing'
+        ? 'implementation-deficit'
         // A candidate is selected only from two structured observations. This deliberately does not prove a defect.
         : input.supervisorVerdict === 'UNCONVERGEABLE' && input.goalCauseObserved === true
         ? 'goal-unconvergeable-candidate'
@@ -247,6 +253,11 @@ export function classifyAbandonedRun(input: AbandonedClassificationInput): Aband
       case 'provider-error': return input.providerErrorCategory === 'request'
         ? 'provider-request-rejection-outranks-account-availability'
         : 'environment-provider-error-outranks-run-stage-evidence';
+      case 'implementation-deficit': return input.terminationReason === 'tdd-evidence-missing'
+        ? 'tdd-evidence-missing'
+        : mustFixReported
+          ? 'must-fix-reported'
+          : 'no-must-fix-without-clean-worktree-or-completed-without-changes';
       case 'already-satisfied': return 'cited-evidence-exists-without-changes';
       case 'report-deficit': return input.reviewResultObserved === true
         ? input.citedEvidenceExists === false
@@ -259,9 +270,6 @@ export function classifyAbandonedRun(input: AbandonedClassificationInput): Aband
         : input.reviewResultObserved === false
           ? 'terminal-state-not-reviewed'
           : 'review-result-observation-unmeasured';
-      case 'implementation-deficit': return mustFixReported
-        ? 'must-fix-reported'
-        : 'no-must-fix-without-clean-worktree-or-completed-without-changes';
     }
   })();
 
@@ -269,6 +277,7 @@ export function classifyAbandonedRun(input: AbandonedClassificationInput): Aband
   return {
     classification,
     classificationBasis,
+    ...(input.terminationReason ? { terminationReason: input.terminationReason } : {}),
     worktreeClean,
     ...(input.completionDisposition ? { completionDisposition: input.completionDisposition } : {}),
     ...(input.supervisorVerdict ? { supervisorVerdict: input.supervisorVerdict } : {}),

package/src/self-implement/budget-gate.ts

@@ -71,6 +71,7 @@ function budgetCreditReserve(config: ChildLlmPreferenceInput): number {
 }
 
 const WEEKLY_WINDOW_MINUTES = 7 * 24 * 60;
+const UNMEASURED_API_KEY_PROVIDERS = new Set(['glm', 'openrouter']);
 
 function capFor(maxUsedPercent: BudgetGateMaxUsedPercent, provider: string): number | undefined {
   if (!Object.prototype.hasOwnProperty.call(maxUsedPercent, provider)) {
@@ -179,6 +180,12 @@ function slotUsable(
       ...(unmeasured ? { unmeasured: true } : {}),
     };
   }
+  // The launch gate has no usage meter for API-key providers such as GLM/OpenRouter.
+  // A provider explicitly selected in the resolved child chain may launch, with the
+  // missing measurement surfaced; ordinary budget decisions remain fail-closed.
+  if (allowUnmeasured && UNMEASURED_API_KEY_PROVIDERS.has(provider)) {
+    return { usable: true, reason: `${provider}: 예산 미측정`, unmeasured: true };
+  }
   return { usable: false, reason: `${provider}: 예산 판정 없음` };
 }
 

package/src/self-implement/child-llm-preference.ts

@@ -10,6 +10,7 @@ import type {
 } from '../user-config.js';
 import { DEFAULT_BUDGET_GATE } from '../user-config.js';
 import { debug } from '../debug/log.js';
+import { fallbackChainForProvider, normalizeFallbackChain } from '../oauth/fallback-chain.js';
 
 /** 체인 한 칸. `codexCredits` = `llm.fallbackChain` 의 `codex-credits` 칸(codex 를 선불 크레딧으로 · 마지막 수단). */
 export type ChildLlmChainSlot = ChildLlmChainEntry & { readonly codexCredits?: true };
@@ -32,6 +33,8 @@ const FALLBACK_NAME_TO_PROVIDER: Readonly<Record<string, string>> = {
   grok: 'grok',
   // CODEX-CREDITS-STEP — provider 는 같은 codex 지만 «크레딧 칸»이라 따로 센다(아래 중복 판정).
   'codex-credits': 'openai-codex',
+  zai: 'glm',
+  openrouter: 'openrouter',
 };
 
 function warnPreference(detail: string): void {
@@ -83,7 +86,13 @@ export function resolveChildLlmPreference(config: ChildLlmPreferenceInput): Reso
     }));
     chainSource = 'config';
   } else {
-    chain = chainFromFallbackNames(config.llm.fallbackChain);
+    const configuredFallback = config.llm.fallbackChain;
+    const derived = normalizeFallbackChain(configuredFallback, config.llm.provider);
+    // Preserve auto's empty preference: the launch gate applies its legacy code
+    // default there. An explicitly selected provider gets its own derived chain.
+    const steps = configuredFallback === undefined && !fallbackChainForProvider(config.llm.provider)
+      ? [] : derived.chain;
+    chain = chainFromFallbackNames(steps);
     chainSource = 'fallbackChain';
   }
 

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

@@ -483,6 +483,26 @@ export interface DoctorComparisonRecord {
   opResult: string;
 }
 
+/**
+ * 하류 계약: 비교 판정의 명명된 실패는 message 문자열이 아니라 typed identity(`reason`)로도 도착한다.
+ * 사람이 읽는 문면은 종전과 같은 문장 그대로다(문장 접두사 = reason). 실제로 없는 원장만
+ * `run-ledger-missing` 이고, 운영/시험 원장 쓰기 거부는 이 클래스가 아니라
+ * `DoctorComparisonLedgerWriteRefusedError` 다.
+ */
+export type DoctorComparisonFailureReason =
+  | 'run-ledger-missing'
+  | 'shadow-rx-missing'
+  | 'visit-missing'
+  | 'comparison-corrupt'
+  | 'comparison-conflict';
+
+export class DoctorComparisonFailureError extends Error {
+  constructor(readonly reason: DoctorComparisonFailureReason, message: string) {
+    super(message);
+    this.name = 'DoctorComparisonFailureError';
+  }
+}
+
 /**
  * 하류 계약: 운영/시험 원장 쓰기 거부는 message 문자열이 아니라 typed identity(`reason`·`runId`·
  * `ledgerDir`)로 도착한다. 사람이 읽는 문면은 종전과 같은 문장 그대로다.
@@ -507,8 +527,10 @@ export class DoctorComparisonLedgerWriteRefusedError extends Error {
  * 하류 계약(typed identity) — ① 원장 쓰기 거부는 DoctorComparisonLedgerWriteRefusedError
  * (`reason='ledger-write-refused'`·`runId`·`ledgerDir`), ② runId 불일치는 원장 바이트와 checked
  * append 양쪽 모두 RunLedgerCheckedAppendRunIdMismatchError(`reason='runId-mismatch'`·
- * `decisionRunId`·`lockedRunId`)로 도착한다. 문자열 파싱 없이 분류하고, 실제로 없는 원장만
- * `run-ledger-missing` 이다.
+ * `decisionRunId`·`lockedRunId`)로 도착한다, ③ 나머지 명명된 실패(run-ledger-missing·
+ * shadow-rx-missing·visit-missing·comparison-corrupt·comparison-conflict)는
+ * DoctorComparisonFailureError(`reason` = 그 이름, 사람 문면은 접두사 그대로)로 도착한다.
+ * 문자열 파싱 없이 분류하고, 실제로 없는 원장만 `run-ledger-missing` 이다.
  *
  * 배선 경계(의도적): 이 슬라이스의 호출자는 시험 경로뿐이다 — live dispatch·stall-watch retirement
  * 은 후속 cross-judgment 증거 슬라이스에서 붙는다(현행 `eln doctor status --json` = total 0
@@ -531,7 +553,7 @@ export function recordDoctorComparison(input: RecordDoctorComparisonInput): Doct
   // lock 안에서 appendRunLedgerEntry 를 다시 부르지 않는다(중첩 lock 시간초과).
   const outcome: RunLedgerCheckedAppendOutcome<DoctorComparisonRecord> = appendRunLedgerEntryChecked<DoctorComparisonRecord>(runId, (entries) => {
     if (entries === null) {
-      throw new Error(`run-ledger-missing: 런 원장이 없습니다 (runId=${runId}) — 새 원장을 만들지 않습니다`);
+      throw new DoctorComparisonFailureError('run-ledger-missing', `run-ledger-missing: 런 원장이 없습니다 (runId=${runId}) — 새 원장을 만들지 않습니다`);
     }
     let shadowRxIndex = -1;
     for (let index = 0; index < entries.length; index++) {
@@ -539,7 +561,7 @@ export function recordDoctorComparison(input: RecordDoctorComparisonInput): Doct
       if (entry.event === 'doctor-rx' && entry.data.shadow === true) shadowRxIndex = index;
     }
     if (shadowRxIndex < 0) {
-      throw new Error(`shadow-rx-missing: 이 runId 의 shadow doctor-rx 가 없습니다 (runId=${runId}) — shadow 결과를 지어내지 않습니다`);
+      throw new DoctorComparisonFailureError('shadow-rx-missing', `shadow-rx-missing: 이 runId 의 shadow doctor-rx 가 없습니다 (runId=${runId}) — shadow 결과를 지어내지 않습니다`);
     }
     const shadowRx = entries[shadowRxIndex]!;
     const rx = typeof shadowRx.data.rx === 'string' ? shadowRx.data.rx : null;
@@ -547,17 +569,17 @@ export function recordDoctorComparison(input: RecordDoctorComparisonInput): Doct
     const visitIndex = typeof shadowRx.data.visitIndex === 'number' ? shadowRx.data.visitIndex : -1;
     const visit = visitIndex >= 0 && visitIndex < entries.length ? entries[visitIndex] : undefined;
     if (visit === undefined || visit.event !== 'doctor-visit' || visit.runId !== runId) {
-      throw new Error(`visit-missing: shadow doctor-rx 가 가리키는 doctor-visit 행이 없습니다 (runId=${runId}, visitIndex=${visitIndex})`);
+      throw new DoctorComparisonFailureError('visit-missing', `visit-missing: shadow doctor-rx 가 가리키는 doctor-visit 행이 없습니다 (runId=${runId}, visitIndex=${visitIndex})`);
     }
     const existing = entries.find((entry) => entry.event === 'doctor-compare' && entry.data.shadowRxIndex === shadowRxIndex);
     if (existing !== undefined) {
       const stored = existing.data.opJudgment as { timestamp?: unknown; result?: unknown };
       if (typeof stored?.timestamp !== 'string' || stored.timestamp.length === 0
         || typeof stored?.result !== 'string' || stored.result.length === 0) {
-        throw new Error(`comparison-corrupt: 이미 기록된 doctor-compare 의 저장 판단이 손상됐습니다 (runId=${runId}, shadowRxIndex=${shadowRxIndex}, stored=${JSON.stringify(stored)}) — 거짓 already-recorded 를 승인하지 않습니다`);
+        throw new DoctorComparisonFailureError('comparison-corrupt', `comparison-corrupt: 이미 기록된 doctor-compare 의 저장 판단이 손상됐습니다 (runId=${runId}, shadowRxIndex=${shadowRxIndex}, stored=${JSON.stringify(stored)}) — 거짓 already-recorded 를 승인하지 않습니다`);
       }
       if (stored.timestamp !== judgment.timestamp || stored.result !== judgment.result) {
-        throw new Error(`comparison-conflict: 이미 기록된 doctor-compare 와 손판정이 다릅니다 (runId=${runId}, shadowRxIndex=${shadowRxIndex}, stored=${JSON.stringify(stored)}, received=${JSON.stringify(judgment)}) — 기존 행을 유지합니다`);
+        throw new DoctorComparisonFailureError('comparison-conflict', `comparison-conflict: 이미 기록된 doctor-compare 와 손판정이 다릅니다 (runId=${runId}, shadowRxIndex=${shadowRxIndex}, stored=${JSON.stringify(stored)}, received=${JSON.stringify(judgment)}) — 기존 행을 유지합니다`);
       }
       return { append: false as const, result: { status: 'already-recorded' as const, visitIndex, shadowRxIndex, rx, outcome: shadowOutcome, opResult: judgment.result } };
     }
@@ -579,7 +601,7 @@ export function recordDoctorComparison(input: RecordDoctorComparisonInput): Doct
     return outcome.result;
   }
   if (holder.recorded === undefined) {
-    throw new Error(`run-ledger-missing: 런 원장이 없습니다 (runId=${runId}) — 새 원장을 만들지 않습니다`);
+    throw new DoctorComparisonFailureError('run-ledger-missing', `run-ledger-missing: 런 원장이 없습니다 (runId=${runId}) — 새 원장을 만들지 않습니다`);
   }
   const record = holder.recorded;
   debug.log('run-doctor', 'compare', { runId, visitIndex: record.visitIndex, shadowRxIndex: record.shadowRxIndex, opResult: judgment.result, executed: false });

package/src/self-implement/elanous-tui-spawn.ts

@@ -17,6 +17,9 @@ import { debug } from '../debug/log.js';
  *  같은 값인지는 elanous-tui-spawn-identity.test.ts 가 잡는다. */
 export const PREAMBLE_SYNC_BLOCK_ENV = 'ELANOUS_TEST_PREAMBLE_SYNC_BLOCK_MS';
 
+/** Bare held TUI startup includes Nexus/test-universe initialization; 30s is below observed cold-start latency. */
+export const DEFAULT_TUI_TEST_READY_TIMEOUT_MS = 180_000;
+
 export interface ElanousTuiSpawnOptions {
   readonly repoRoot: string;
   readonly cwd: string;

package/src/self-implement/fixtures/tdd-green-missing-passing-child-transcript.txt

@@ -0,0 +1,2 @@
+⏺ Bash({\"command\":\"bun test -- 'src/ux-sim/service-key-setup.test.ts'\",\"timeout\":120000,\"sandbox\":\"off\",\"network\":\"inherit\"})
+     ↳ bun test v1.4.2 (744846f84) --- stderr --- 2 pass 0 fail 32 expect() calls Ran 2 tests across 1 file. [1099.00ms]

package/src/self-implement/gate-artifacts.ts

@@ -52,6 +52,7 @@ export interface GateArtifactRun {
 export interface GateArtifactShard {
   shardId: string;
   attempt: number;
+  elapsedMs?: number;
   files: string[];
   current: GateArtifactRun;
   baseline: GateArtifactRun;
@@ -210,7 +211,7 @@ export function writeGateArtifacts(input: GateArtifactInput): { summaryPath: str
       return run;
     };
     shardsDetail.push({
-      shardId: attempt.shardId, attempt: attempt.attempt, files, current: side('current'), baseline: side('baseline'),
+      shardId: attempt.shardId, attempt: attempt.attempt, ...(attempt.elapsedMs !== undefined ? { elapsedMs: attempt.elapsedMs } : {}), files, current: side('current'), baseline: side('baseline'),
       ...(input.sharded?.unmeasuredByShard?.[attempt.shardId] !== undefined
         && attempt === input.sharded.attempts.filter((item) => item.shardId === attempt.shardId).at(-1)
         ? { unmeasuredReason: input.sharded.unmeasuredByShard[attempt.shardId] } : {}),

package/src/self-implement/goal-author-cli.ts

@@ -19,6 +19,7 @@ import {
   type GoalAuthorDeps,
   type GoalAuthorGradeSelection,
   resolveGoalAuthorGrade,
+  resolveGoalAuthorReviewerPrecheckEnabled,
   type GoalType,
   type GoalFileLintFinding,
 } from './goal-author.js';
@@ -292,9 +293,10 @@ export async function runGoalAuthorCli(
     ? { passed: false }
     : { passed: true, titleChars: proseTitle.length });
   const gradeDeps = authorGrade.grade === 'lite' || opts.authorGrade ? { authorGrade } : {};
+  const reviewerPrecheckDeps = { reviewerPrecheckEnabled: resolveGoalAuthorReviewerPrecheckEnabled() };
   const authorDeps: Partial<GoalAuthorDeps> = parentGoalFile && parentQuestionId
-    ? { parent: { goalFile: parentGoalFile, questionId: parentQuestionId }, parentDocument, clarificationAnswers, ...(decomposeSteps ? { decomposeSteps } : {}), ...gradeDeps, ...selfResolutionDeps, ...progressDeps, ...launchPreflightDeps, ...(opts.rootIntent !== undefined && { rootIntent: opts.rootIntent }), ...(goalType !== undefined && { goalType }), ...goalTitleDeps }
-    : { ...(clarificationAnswers && { clarificationAnswers }), ...(decomposeSteps ? { decomposeSteps } : {}), ...gradeDeps, ...selfResolutionDeps, ...progressDeps, ...launchPreflightDeps, ...(opts.rootIntent !== undefined && { rootIntent: opts.rootIntent }), ...(goalType !== undefined && { goalType }), ...goalTitleDeps };
+    ? { parent: { goalFile: parentGoalFile, questionId: parentQuestionId }, parentDocument, clarificationAnswers, ...(decomposeSteps ? { decomposeSteps } : {}), ...gradeDeps, ...selfResolutionDeps, ...progressDeps, ...launchPreflightDeps, ...reviewerPrecheckDeps, ...(opts.rootIntent !== undefined && { rootIntent: opts.rootIntent }), ...(goalType !== undefined && { goalType }), ...goalTitleDeps }
+    : { ...(clarificationAnswers && { clarificationAnswers }), ...(decomposeSteps ? { decomposeSteps } : {}), ...gradeDeps, ...selfResolutionDeps, ...progressDeps, ...launchPreflightDeps, ...reviewerPrecheckDeps, ...(opts.rootIntent !== undefined && { rootIntent: opts.rootIntent }), ...(goalType !== undefined && { goalType }), ...goalTitleDeps };
   const write = deps.write ?? writeAuthoredGoal;
   const result = opts.groundingCwd === undefined
     ? await write(ask, opts.cwd, authorDeps, superseded ? { supersedes: superseded } : undefined)