elanous 0.2.42 → 0.2.43

package/src/self-dev/graph-journey-route.ts

@@ -4,6 +4,8 @@ import { applyGraphOverlays, defaultOverlaysDir, loadGraphOverlays, selectOverla
 import { L1_PROTECTED_ROUTE_NODES, type GraphTemplateSpec } from '../self-implement/graph-yaml.js';
 import { evaluateOverlayCondition } from '../self-implement/graph-overlay-condition.js';
 import { journeyJoinFields } from './graph-journey-nodes.js';
+import { defaultProfilesDir, loadGraphProfiles, selectGraphProfiles, type GraphProfileSpec } from '../self-implement/graph-profile-yaml.js';
+import { appendRunLedgerEntry, runLedgerDir } from '../self-implement/run-ledger.js';
 
 /** ⭐ HARNESS-FULL-GRAPH 2판 — 「다음 노드」를 코드가 아니라 «그래프»가 정한다.
  *
@@ -29,11 +31,14 @@ export interface JourneyRoute {
   readonly skippedNode?: string;
   readonly skipCondition?: string;
   readonly skippedNodes?: readonly { readonly node: string; readonly condition: string }[];
+  readonly profileIds?: readonly string[];
+  readonly profileRejections?: readonly string[];
 }
 
 /** ⛔ 캐시하지 않는다 — 여러 런을 처리하는 프로세스(데몬·대기열 tick)가 다음 발사에서 오버레이 변경을 봐야 한다.
  *  여정 판정은 발사당 몇 번뿐이라 디렉터리 한 번 읽기가 싸다. */
 let overlaysForTesting: readonly GraphOverlaySpec[] | undefined;
+let profilesForTesting: readonly GraphProfileSpec[] | undefined;
 function launchOverlays(): readonly GraphOverlaySpec[] {
   if (overlaysForTesting !== undefined) return overlaysForTesting;
   try { return loadGraphOverlays(defaultOverlaysDir()).overlays; }
@@ -45,21 +50,50 @@ export function setJourneyOverlaysForTesting(overlays: readonly GraphOverlaySpec
   overlaysForTesting = overlays;
 }
 
+/** Test seam for a stable profile set; undefined reads the profile directory beside the graph sources. */
+export function setJourneyProfilesForTesting(profiles: readonly GraphProfileSpec[] | undefined): void {
+  profilesForTesting = profiles;
+}
+
+function launchProfiles(): { readonly profiles: readonly GraphProfileSpec[]; readonly errors: readonly string[] } {
+  if (profilesForTesting !== undefined) return { profiles: profilesForTesting, errors: [] };
+  const loaded = loadGraphProfiles(defaultProfilesDir());
+  return { profiles: loaded.profiles, errors: loaded.errors.map((issue) => `${issue.path}: ${issue.message}`) };
+}
+
 /** 상태 값으로 고른 «이 런의 여정 선언» — 기준 YAML ⊕ 조건이 맞는 launch 오버레이. */
 export function journeySpec(
   state: Readonly<Record<string, unknown>>,
   base: GraphTemplateSpec | undefined = GRAPH_SPECS['self-implement'],
   overlays: readonly GraphOverlaySpec[] = launchOverlays(),
-): { readonly spec: GraphTemplateSpec | undefined; readonly applied: readonly string[] } {
-  if (base === undefined) return { spec: undefined, applied: [] };
+  profiles: readonly GraphProfileSpec[] = launchProfiles().profiles,
+  profileLoadErrors: readonly string[] = [],
+): { readonly spec: GraphTemplateSpec | undefined; readonly applied: readonly string[]; readonly profileIds: readonly string[]; readonly profileRejections: readonly string[] } {
+  if (base === undefined) return { spec: undefined, applied: [], profileIds: [], profileRejections: [] };
   try {
-    const { applied } = selectOverlays(overlays, { graphId: base.graphId, stage: 'launch', state });
-    if (applied.length === 0) return { spec: base, applied: [] };
+    const selection = selectGraphProfiles(profiles, state);
+    const profileIds = selection.applied.map((profile) => profile.profileId);
+    const profileOverlayIds = new Set(selection.applied.flatMap((profile) => profile.overlays));
+    const overlayRejections = [...profileOverlayIds].flatMap((id) => {
+      const overlay = overlays.find((candidate) => candidate.overlayId === id);
+      if (!overlay) return [`profile overlay not found: ${id}`];
+      if (overlay.target !== base.graphId) return [`profile overlay target mismatch: ${id} (${overlay.target})`];
+      if (overlay.stage !== 'launch') return [`profile overlay wrong stage: ${id} (${overlay.stage})`];
+      return [];
+    });
+    const profileRejections = [...profileLoadErrors, ...selection.errors, ...overlayRejections];
+    if (profileRejections.length > 0) return { spec: base, applied: [], profileIds: [], profileRejections };
+    const { applied: candidates } = selectOverlays(overlays, { graphId: base.graphId, stage: 'launch', state: selection.state });
+    const ownedState = Object.assign({}, ...selection.applied.map((profile) => profile.state));
+    const applied = candidates.filter((overlay) => !profileOverlayIds.has(overlay.overlayId)
+      || evaluateOverlayCondition(overlay.appliesWhen, ownedState).kind === 'applies');
+    if (applied.length === 0) return { spec: base, applied: [], profileIds, profileRejections: [] };
     const result = applyGraphOverlays(base, applied);
     // ⛔ 거절된 오버레이는 길을 바꾸지 않는다 — 기준 선언으로 간다.
-    return result.ok ? { spec: result.template, applied: result.overlayIds } : { spec: base, applied: [] };
+    return result.ok ? { spec: result.template, applied: result.overlayIds, profileIds, profileRejections: [] }
+      : { spec: base, applied: [], profileIds: [], profileRejections: result.rejections.map((item) => `${item.kind}: ${item.overlayId}`) };
   } catch {
-    return { spec: base, applied: [] };
+    return { spec: base, applied: [], profileIds: [], profileRejections: ['profile selection failed'] };
   }
 }
 
@@ -69,10 +103,11 @@ export function readJourneyEdge(
   from: string,
   label: string,
   state: Readonly<Record<string, unknown>> = {},
-  deps: { readonly base?: GraphTemplateSpec; readonly overlays?: readonly GraphOverlaySpec[] } = {},
+  deps: { readonly base?: GraphTemplateSpec; readonly overlays?: readonly GraphOverlaySpec[]; readonly profiles?: readonly GraphProfileSpec[] } = {},
 ): JourneyRoute {
-  const { spec, applied } = journeySpec(state, deps.base ?? GRAPH_SPECS['self-implement'], deps.overlays ?? launchOverlays());
-  let route: JourneyRoute = { from, on: null, label, to: null, source: 'code-default', overlays: applied };
+  const profileSet = deps.profiles === undefined ? launchProfiles() : { profiles: deps.profiles, errors: [] as readonly string[] };
+  const { spec, applied, profileIds, profileRejections } = journeySpec(state, deps.base ?? GRAPH_SPECS['self-implement'], deps.overlays ?? launchOverlays(), profileSet.profiles, profileSet.errors);
+  let route: JourneyRoute = { from, on: null, label, to: null, source: 'code-default', overlays: applied, profileIds, profileRejections };
   const outgoing = (spec?.edges ?? []).filter(edge => edge.from === from);
   const protectedFrom = L1_PROTECTED_ROUTE_NODES.has(from) || spec?.nodes.some(node => node.nodeId === from && node.kind === 'gate') ||
     spec?.terminalNodes.includes(from);
@@ -80,14 +115,14 @@ export function readJourneyEdge(
   const matching = conditions.filter(({ verdict }) => verdict.kind === 'applies').map(({ edge }) => edge);
   const unobservedConditions = conditions.filter(({ verdict }) => verdict.kind === 'key-absent').map(({ edge }) => edge.when!);
   if (matching.length === 1 && unobservedConditions.length === 0 && matching[0]!.to !== undefined) {
-    route = { from, on: null, label, to: matching[0]!.to!, source: 'graph', overlays: applied,
+    route = { ...route, from, on: null, label, to: matching[0]!.to!, source: 'graph', overlays: applied,
       via: 'when', condition: matching[0]!.when };
   } else {
     const mapped = outgoing.find(edge => edge.when === undefined && edge.map !== undefined && Object.hasOwn(edge.map, label));
     const defaultEdge = mapped ?? outgoing.find(edge => edge.when === undefined && edge.to !== undefined);
-    if (defaultEdge?.map !== undefined) route = { from, on: defaultEdge.on ?? null, label,
+    if (defaultEdge?.map !== undefined) route = { ...route, from, on: defaultEdge.on ?? null, label,
       to: defaultEdge.map[label]!, source: 'graph', overlays: applied, via: 'outcome' };
-    else if (defaultEdge?.to !== undefined) route = { from, on: null, label,
+    else if (defaultEdge?.to !== undefined) route = { ...route, from, on: null, label,
       to: defaultEdge.to, source: 'graph', overlays: applied, via: 'outcome' };
     if (matching.length > 1) route = { ...route, ambiguousConditions: matching.map(edge => edge.when!) };
     if (unobservedConditions.length > 0) route = { ...route, unobservedConditions };
@@ -129,31 +164,51 @@ export interface JourneyEdgeFields {
   readonly [key: string]: unknown;
 }
 
+function recordGraphPathEvent(event: string, data: Record<string, unknown>, runId?: string): void {
+  try { debug.log('graph.path', event, data); } catch { /* fail-soft */ }
+  if (!runId) return;
+  try { appendRunLedgerEntry({ timestamp: new Date().toISOString(), runId, event: 'graph.path', data: { event, ...data } }, runLedgerDir()); }
+  catch { /* path observation must not change execution */ }
+}
+
 /** 실제로 탄 간선을 남긴다 — `taken` 은 실제 다음 노드(그래프 답과 다르면 `honored: false` · 그 이유를 `reason` 에). */
 export function recordJourneyEdge(route: JourneyRoute, taken: string, reason?: string, data: JourneyEdgeFields = {}): void {
   try {
+    const runId = typeof data.runId === 'string' ? data.runId : undefined;
+    for (const rejection of route.profileRejections ?? []) recordGraphPathEvent('profile-rejected', {
+      graphId: 'self-implement', reason: rejection, profileIds: route.profileIds ?? [],
+      ...(runId === undefined ? {} : { runId }), ...journeyJoinFields(),
+    }, runId);
     if (route.ambiguousConditions?.length) debug.log('self-implement', 'edge-ambiguous', {
       graphId: 'self-implement', from: route.from, conditions: route.ambiguousConditions,
       fallback: taken, ...journeyJoinFields(),
     });
+    if (route.ambiguousConditions?.length) recordGraphPathEvent('edge-ambiguous', {
+      graphId: 'self-implement', from: route.from, conditions: route.ambiguousConditions,
+      fallback: taken, profileIds: route.profileIds ?? [], ...(runId === undefined ? {} : { runId }), ...journeyJoinFields(),
+    }, runId);
     if (route.unobservedConditions?.length) debug.log('self-implement', 'edge-unobserved', {
       graphId: 'self-implement', from: route.from, conditions: route.unobservedConditions,
       fallback: taken, ...journeyJoinFields(),
     });
-    if (route.to === taken) for (const skipped of route.skippedNodes ?? []) debug.log('self-implement', 'node-skipped', {
-      graphId: 'self-implement', node: skipped.node, reason: 'condition', condition: skipped.condition,
-      ...journeyJoinFields(),
-    });
+    if (route.to === taken) for (const skipped of route.skippedNodes ?? []) {
+      const skippedData = { graphId: 'self-implement', node: skipped.node, reason: 'condition', condition: skipped.condition,
+        profileIds: route.profileIds ?? [], ...(runId === undefined ? {} : { runId }), ...journeyJoinFields() };
+      debug.log('self-implement', 'node-skipped', skippedData);
+      recordGraphPathEvent('node-skipped', skippedData, runId);
+    }
     // Evidence never overrides an edge field: the later spread wins. Explicit repair join keys win over ambient context.
     const { reason: _reservedReason, journeyKey: _reservedJourney, queueLaunchId: _reservedLaunch,
-      runId, card, pr, head, moveId, ...evidence } = data ?? {};
-    debug.log('self-implement', 'graph-edge-taken', {
+      runId: _reservedRunId, card, pr, head, moveId, ...evidence } = data ?? {};
+    const edgeData = {
       ...evidence, graphId: 'self-implement', ...route, taken, honored: route.to === null || route.to === taken,
       ...(reason === undefined ? {} : { reason }), ...journeyJoinFields(),
       ...(runId === undefined ? {} : { runId }), ...(card === undefined ? {} : { card }),
       ...(pr === undefined ? {} : { pr }), ...(head === undefined ? {} : { head }),
       ...(moveId === undefined ? {} : { moveId }),
-    });
+    };
+    debug.log('self-implement', 'graph-edge-taken', edgeData);
+    recordGraphPathEvent('edge-taken', edgeData, runId);
   } catch { /* 관측은 fail-soft */ }
 }
 
@@ -162,10 +217,10 @@ export function routeJourneyEdge(
   from: string,
   label: string,
   state: Readonly<Record<string, unknown>> = {},
-  deps: { readonly base?: GraphTemplateSpec; readonly overlays?: readonly GraphOverlaySpec[] } = {},
+  deps: { readonly base?: GraphTemplateSpec; readonly overlays?: readonly GraphOverlaySpec[]; readonly profiles?: readonly GraphProfileSpec[]; readonly runId?: string } = {},
 ): JourneyRoute {
   const route = readJourneyEdge(from, label, state, deps);
-  recordJourneyEdge(route, route.to ?? label);
+  recordJourneyEdge(route, route.to ?? label, undefined, deps.runId === undefined ? {} : { runId: deps.runId });
   return route;
 }
 

package/src/self-dev/launch-preflight.ts

@@ -340,6 +340,64 @@ export interface LaunchPreflightInput {
 /** AUTO-TARGET: blocker name for a NOT-GROUNDED goal whose only target paths were machine-suggested (a scope card). */
 export const NOT_GROUNDED_SCOPE_CARD_BLOCKER = '(NOT-GROUNDED 범위 카드)';
 
+/** CARD-TARGET-PATHS 가 읽기 전용으로 제공하는 같은-경로 카드 맥락. */
+export interface SiblingContextCard {
+  readonly cardId: string;
+  readonly runId?: string;
+  readonly overlapPaths: readonly string[];
+}
+
+function siblingContextPaths(result: LaunchPreflightResult, warning: LaunchPreflightBlocker): readonly string[] {
+  return warning.overlapPaths?.map(({ path }) => path)
+    ?? result.paths.filter((path) => warning.detail.includes(path));
+}
+
+function siblingContextAxis(
+  label: string,
+  status: PreflightAxisStatus,
+  entries: readonly string[],
+): string {
+  if (status.state === 'unknown') return `[sibling-context] ${label}: 못 쟀다 (${status.reason})`;
+  if (entries.length === 0) return `[sibling-context] ${label}: 없음`;
+  const partial = status.state === 'truncated' ? ` · 부분 측정(상한 ${status.limit})` : '';
+  return `[sibling-context] ${label}: ${entries.join(' · ')}${partial}`;
+}
+
+/** 같은 대상 경로의 비차단 형제 관측을 골 문서 머리에 넣을 정확히 세 줄로 렌더한다. */
+export function renderSiblingContextLines(
+  result: LaunchPreflightResult,
+  cards: readonly SiblingContextCard[] = [],
+): readonly [string, string, string] {
+  const liveRuns = result.warnings
+    .filter((warning) => warning.kind === 'live-run')
+    .map((warning) => {
+      const paths = siblingContextPaths(result, warning);
+      const cardIds = cards
+        .filter((card) => card.runId === warning.name && card.overlapPaths.some((path) => paths.includes(path)))
+        .map((card) => card.cardId);
+      return [warning.name, ...cardIds.map((cardId) => `카드 ${cardId}`), ...paths].join(' · ');
+    });
+  const openPrs = result.warnings
+    .filter((warning) => warning.kind === 'open-pr' || warning.kind === 'sibling-pr')
+    .map((warning) => {
+      const draft = /\bdraft\b|초안/u.test(warning.detail) ? ' (draft)' : '';
+      const paths = siblingContextPaths(result, warning);
+      return `${warning.name}${draft}${paths.length > 0 ? ` · ${paths.join(', ')}` : ''}`;
+    });
+  const recentLanded = result.warnings
+    .filter((warning) => warning.kind === 'recent-change' && result.paths.includes(warning.name))
+    .map((warning) => {
+      const count = /최근 \d+일 안에 (\d+)건 변경됨/u.exec(warning.detail)?.[1];
+      return `sha·PR 미상 · ${warning.name}${count === undefined ? '' : ` ${count}건`}`;
+    });
+
+  return [
+    siblingContextAxis('같은 경로 도는 런', result.liveRuns, liveRuns),
+    siblingContextAxis('같은 경로 열린 PR', result.openPrs, openPrs),
+    siblingContextAxis(`같은 경로 최근 ${result.recentChangeWindowDays}일 착지`, result.recentChanges, recentLanded),
+  ];
+}
+
 export function evaluateLaunchPreflight(input: LaunchPreflightInput): LaunchPreflightResult {
   const paths = [...new Set(input.paths.filter((path) => path.trim().length > 0))];
   const blockers: LaunchPreflightBlocker[] = [];

package/src/self-dev/orchestrate.ts

@@ -1185,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 */ }

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]