elanous 0.2.41 → 0.2.43

package/src/self-dev/orchestrate.ts

@@ -147,6 +147,16 @@ function shardIdentityFeature(feature: string, identity: SelfDevShardIdentity |
     : `${feature}\n\n## Shard identity\n${JSON.stringify(identity)}`;
 }
 
+function selfDevGoalFeature(goal: SelfDevGoal): string {
+  const { completionBoundary, mockScenario } = goal;
+  const acceptance: string[] = [];
+  if (completionBoundary?.trim()) acceptance.push(`Completion boundary: ${completionBoundary.trim()}`);
+  if (mockScenario?.id?.trim()) acceptance.push(`Mock scenario: ${mockScenario.id.trim()}`);
+  if (mockScenario?.injection?.trim()) acceptance.push(`Injection: ${mockScenario.injection.trim()}`);
+  if (mockScenario?.observation?.trim()) acceptance.push(`Observation: ${mockScenario.observation.trim()}`);
+  return acceptance.length ? `${goal.feature}\n\n## Slice acceptance\n${acceptance.join('\n')}` : goal.feature;
+}
+
 const SHARD_WORKING_MEMORY_EMIT_HINT =
   '\n\n## Working-memory handoff\nA downstream shard depends on this work. Before your final response, emit the following marker and one JSON object so it can reuse your findings. Put reusable boundaries in `reusables` and your key choices in `decisions`; use empty arrays when there are none.\n[WORKING-MEMORY]\n{"reusables":[],"decisions":[],"summary":"What this shard established for downstream work."}';
 
@@ -1175,7 +1185,7 @@ export function orchestrateSelfDev(opts: OrchestrateSelfDevOptions): Promise<Sel
     const taskId = [...spaceIdByTask.entries()].find(([, id]) => id === input.spaceId)?.[0];
     const goal = taskId ? taskByGoal.get(taskId) : undefined;
     if (cancelling) throw new Error('orchestration cancelled by signal');
-    const started = baseSpawn({ ...input, feature: dependencyOutputFeature(input.spaceId, input.feature) });
+    const started = baseSpawn({ ...input, ...(taskId ? { taskId } : {}), feature: dependencyOutputFeature(input.spaceId, input.feature) });
     if (goal && taskId) {
       try { opts.onTaskLaunched?.(goal, taskId, priorByResumeKey.get(resumeKey(goal.feature))?.taskId); }
       catch { /* observation must not interrupt execution */ }
@@ -1236,7 +1246,7 @@ export function orchestrateSelfDev(opts: OrchestrateSelfDevOptions): Promise<Sel
     surfaceKind: 'self-implement',
     surface: (goal) => ({
       kind: 'self-implement',
-      feature: goal.feature,
+      feature: selfDevGoalFeature(goal),
       ...(goal.after !== undefined ? { after: goal.after } : {}),
       ...(goal.base !== undefined ? { base: goal.base } : {}),
       ...(goal.autoMerge !== undefined ? { autoMerge: goal.autoMerge } : {}),
@@ -1386,7 +1396,7 @@ export function orchestrateSelfDev(opts: OrchestrateSelfDevOptions): Promise<Sel
       const task = graph.getTask(taskId);
       if (task?.surface.kind === 'self-implement') {
         graph.updateTask(taskId, {
-          surface: { ...task.surface, feature: shardIdentityFeature(shard.goal.feature, identity) },
+          surface: { ...task.surface, feature: shardIdentityFeature(selfDevGoalFeature(shard.goal), identity) },
         }, { now: now() });
       }
     }

package/src/self-dev/review-provider-fallback.ts

@@ -230,6 +230,7 @@ export async function runSubscriptionReviewer(
 }
 
 export type ReviewFailureReason =
+  | 'credentials-unavailable'
   | 'overloaded'
   | 'rate-limited'
   | 'server-error'
@@ -238,11 +239,17 @@ export type ReviewFailureReason =
   | 'unknown-model-provider'
   | 'other';
 
-export type ReviewFallbackReason = Extract<ReviewFailureReason, 'overloaded' | 'rate-limited' | 'server-error' | 'timeout'>;
+export type ReviewFallbackReason = Extract<ReviewFailureReason, 'credentials-unavailable' | 'overloaded' | 'rate-limited' | 'server-error' | 'timeout'>;
 
 /** 실패 사유는 집계 가능한 유한 값으로 남긴다. */
 export function classifyReviewProviderFailure(message: string): ReviewFailureReason {
   const m = message.toLowerCase();
+  // Credential absence is provider-local: move to the next configured provider, then let the caller
+  // preserve its current artifact if every configured provider is keyless.
+  if ((m.includes('unavailable') && /(api\s*key|credentials?)/.test(m))
+    || /configure\s+(?:an?\s+)?api\s*key/.test(m)
+    || /(?:missing|no)\s+(?:provider\s+)?(?:api\s*)?key\b/.test(m)
+    || /credentials?\s+(?:are\s+)?unavailable/.test(m)) return 'credentials-unavailable';
   // ⭐ 실물 문면을 먼저 둔다 — `#10069` 가 낸 그 문장이다.
   if (m.includes('overloaded') || m.includes('server_overloaded')) return 'overloaded';
   if (m.includes('rate limit') || m.includes('rate_limit') || m.includes('429')) return 'rate-limited';
@@ -253,7 +260,7 @@ export function classifyReviewProviderFailure(message: string): ReviewFailureRea
 }
 
 function isReviewFallbackReason(reason: ReviewFailureReason): reason is ReviewFallbackReason {
-  return reason === 'overloaded' || reason === 'rate-limited' || reason === 'server-error' || reason === 'timeout';
+  return reason === 'credentials-unavailable' || reason === 'overloaded' || reason === 'rate-limited' || reason === 'server-error' || reason === 'timeout';
 }
 
 export interface ReviewProviderAttempt {

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

@@ -7,6 +7,8 @@ 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 { readRunChart, recordRunChartDecision } from '../self-implement/run-chart.js';
+import { 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';
@@ -215,8 +217,8 @@ export function needsHumanRepairGoal(result: SupervisorJobResult, reason: NeedsH
   const outside = expandedBeyondTargetPaths(result);
   const repairTargets = result.targetPaths?.length ? result.targetPaths : undefined;
   return [
-    `[supervisor-needs-human-repair:${reason}] ${NEEDS_HUMAN_REPAIR_INSTRUCTION[reason]}`,
     ...(repairTargets?.length ? [`대상 경로: ${repairTargets.join(', ')}`] : []),
+    `[supervisor-needs-human-repair:${reason}] ${NEEDS_HUMAN_REPAIR_INSTRUCTION[reason]}`,
     ...(outside.length ? [`대상 경로 밖 변경: ${outside.join(', ')}`] : []),
     ...(result.error?.message ? [`이전 실패: ${result.error.message.slice(0, 200)}`] : []),
     result.feature,
@@ -447,7 +449,7 @@ function mustFixScopeDecision(
   return { byTask, ...(split.length ? { split } : {}), ...(askOwner.length ? { askOwner } : {}) };
 }
 
-export function decideNextRun(input: {
+type DecideNextRunInput = {
   results: readonly SupervisorJobResult[];
   history?: readonly SupervisorRound[];
   limits?: SupervisorLimits;
@@ -463,7 +465,11 @@ export function decideNextRun(input: {
   needsHumanReasonRepairExecution?: boolean;
   /** 분해 제안을 실제 조각 실행으로 승격할 수 있는 supervisor 경로에만 true. */
   decompositionExecution?: boolean;
-}): SupervisorDecision {
+  /** Chart context available to the outer-supervisor judgment; pulled from this same run only. */
+  runChart?: readonly { device: string; stopKey: string; observed: string; verdict: string; action: string; handoff: string | null; why: string; readStopKeys: readonly string[] }[];
+};
+
+function decideNextRunCore(input: DecideNextRunInput): SupervisorDecision {
   const results = [...input.results];
   const history = [...(input.history ?? [])];
   const maxRounds = input.limits?.maxRounds ?? DEFAULT_MAX_ROUNDS;
@@ -923,6 +929,26 @@ export function decideNextRun(input: {
   };
 }
 
+/** Consume an unread doctor→reauthor chart handoff before returning a terminal exit. */
+export function decideNextRun(input: DecideNextRunInput): SupervisorDecision {
+  const decision = decideNextRunCore(input);
+  if (decision.action !== 'stop' || decision.stopReason === 'max-rounds') return decision;
+  const pendingReauthor = [...(input.runChart ?? [])].reverse().find((cell) => cell.handoff === 'reauthor'
+    && !input.runChart?.some((later) => later.device === 'outer-supervisor' && later.readStopKeys.includes(cell.stopKey)));
+  if (!pendingReauthor) return decision;
+  const eligible = input.results.filter((result) => decision.needsHuman.includes(result.taskId)
+    && result.status === 'failed' && result.feature.trim() && result.prNumber === undefined && !result.prUrl);
+  if (eligible.length === 0 || decision.round > (input.limits?.maxRounds ?? DEFAULT_MAX_ROUNDS)) return decision;
+  const taskIds = eligible.map((result) => result.taskId);
+  return { ...decision, action: 'relaunch', stopReason: undefined,
+    rerunnable: [...new Set([...decision.rerunnable, ...taskIds])],
+    needsHuman: decision.needsHuman.filter((taskId) => !taskIds.includes(taskId)),
+    classifications: decision.classifications.map((classification) => taskIds.includes(classification.taskId)
+      ? { ...classification, action: 'rerun' as const } : classification),
+    why: `run-chart handoff=reauthor consumed (${pendingReauthor.stopKey}) — needs-human 조각 ${taskIds.length}개를 재발사`,
+  };
+}
+
 export function appendRound(
   history: readonly SupervisorRound[],
   results: readonly SupervisorJobResult[],
@@ -1298,6 +1324,10 @@ export async function superviseRun(opts: SuperviseRunOptions): Promise<Superviso
     const allUnreviewedAreNoDiff = unreviewed.length > 0
       && unreviewed.every((result) => result.reviewReason === 'no-diff');
 
+    const chartRunId = opts.runStore?.runId ?? results.find((result) => result.runId?.trim())?.runId ?? null;
+    const chartDir = opts.runStore?.dir ?? runLedgerDir();
+    const chartBeforeJudgment = chartRunId ? readRunChart(chartRunId, 'outer-supervisor', chartDir) : [];
+
     let decision = decideNextRun({
       results,
       history,
@@ -1309,11 +1339,19 @@ export async function superviseRun(opts: SuperviseRunOptions): Promise<Superviso
       ...(opts.limits ? { limits: opts.limits } : {}),
       ...(observed.deployFindings ? { deployFindings: observed.deployFindings } : {}),
       deliverableObservation: observed.state,
+      runChart: chartBeforeJudgment,
       ...(unreviewed.length > 0 ? {
         reviewed: false,
         ...(allUnreviewedAreNoDiff ? { reviewReason: 'no-diff' } : {}),
       } : {}),
     });
+    if (chartRunId) {
+      recordRunChartDecision({ runId: chartRunId, device: 'outer-supervisor',
+        stopKey: `${chartRunId}:outer-supervisor:${history.length + 1}`, observed: `results=${results.length}`,
+        verdict: decision.action, action: decision.action === 'stop' ? decision.stopReason ?? 'stop' : 'relaunch',
+        handoff: decision.action === 'stop' ? 'human' : 'macrophage', why: decision.why,
+        readStopKeys: chartBeforeJudgment.map((cell) => cell.stopKey), dir: chartDir });
+    }
 
     const reasonRepairSkipped = decision.action !== 'stop' || decision.stopReason !== 'needs-human' || history.length + 1 > maxRounds
       ? [] : results.flatMap((result) => {
@@ -1342,7 +1380,7 @@ export async function superviseRun(opts: SuperviseRunOptions): Promise<Superviso
       }
     }
 
-    const runId = opts.runStore?.runId ?? results.find((result) => result.runId?.trim())?.runId ?? null;
+    const runId = chartRunId;
 
     let decomposePromotion: DecomposePromotionObservation = decision.decomposable.length === 0
       ? { attempted: false, reason: 'no-decomposable-decision' }

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

@@ -27,6 +27,10 @@ export interface SelfDevGoal {
   kind?: JobKind;
   /** Decomposition intent; deliberately distinct from executable `kind`. */
   goalType?: SelfDevGoalType;
+  /** Required for default-LLM decomposition slices; included in the child task prompt. */
+  completionBoundary?: string;
+  /** Existing simulation evidence required to make a decomposed slice independently reviewable. */
+  mockScenario?: { id: string; injection: string; observation: string };
   /** Feature/goal text → `elanous self implement <feature>` for dev jobs. */
   feature: string;
   /** Pod lease predecessor goal ID or PR number. */

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';
   }