elanous 0.2.20 → 0.2.22

package/scripts/nightly-docops.ts

@@ -16,6 +16,7 @@ import { createGitHubIssueCommentFetchStatus, lintDocLinks, lintGitHubIssueComme
 import { proposeWikiClaimsFromHandoff, type Claim } from '../src/autopilot/discovery/wiki-claim-proposer.js';
 import { runNightlyDocOpsCycle, assertLoopbackModelUrl } from '../src/autopilot/discovery/nightly-docops-runner.js';
 import { assessDocsStaleness, defaultStalenessRevisions } from '../src/autopilot/discovery/doc-staleness.js';
+import { defaultManualFiles, scanDocRot } from './docs/doc-rot.js';
 import { debug } from '../src/debug/log.js';
 import { registerStandaloneLogSink } from '../src/domains/standalone-log-sink.js';
 import {
@@ -51,13 +52,27 @@ const githubHeaders: Record<string, string> = { Accept: 'application/vnd.github+
 if (process.env.GITHUB_TOKEN) githubHeaders.Authorization = `Bearer ${process.env.GITHUB_TOKEN}`;
 const issueCommentFetchStatus = createGitHubIssueCommentFetchStatus(fetch, githubHeaders);
 
-export function formatNightlyDocOpsCompletion(metrics: Awaited<ReturnType<typeof runNightlyDocOpsCycle>>): string {
+export type DocRotStageResult =
+  | { status: 'measured'; totals: ReturnType<typeof scanDocRot>['totals']; staleFiles: Array<{
+      file: string;
+      missingPaths: ReturnType<typeof scanDocRot>['files'][number]['missingPaths'];
+      badCommands: ReturnType<typeof scanDocRot>['files'][number]['commands'];
+    }> }
+  | { status: 'failed'; error: string };
+
+export function formatNightlyDocOpsCompletion(
+  metrics: Awaited<ReturnType<typeof runNightlyDocOpsCycle>>,
+  docRot?: DocRotStageResult,
+): string {
   const stalenessLine = metrics.staleness?.status === 'measured'
     ? `늙음 검사 ${metrics.staleness.checked}·사라진 식별자 ${metrics.staleness.byAxis.removedIdentifiers}·깨진 링크 ${metrics.staleness.byAxis.brokenLinks}·superseded ${metrics.staleness.byAxis.supersededMarked}·staleScore ${metrics.staleness.byAxis.staleScoreOverThreshold}·문서목록 ${metrics.staleness.removedIdentifierDocuments.length}${metrics.staleness.removedIdentifierDocumentsTruncated ? '+' : ''}`
     : metrics.staleness?.status === 'failed'
       ? `늙음 측정 실패(${metrics.staleness.error})`
       : '늙음 측정 미지정';
-  return `[nightly-docops] 완료 — 처리 ${metrics.processed}·후보 ${metrics.candidates}·제안 ${metrics.proposals}·억제 ${metrics.suppressed}·에러 ${metrics.errors}·${stalenessLine}·${metrics.durationMs}ms → ${outDir} (HITL 승인 대기)`;
+  const docRotLine = docRot?.status === 'measured'
+    ? `·doc-rot 낡은 파일 ${docRot.totals.staleFiles}·없는 경로 ${docRot.totals.missingPaths}·깨진 명령 ${docRot.totals.badCommands}·못 잰 명령 ${docRot.totals.unmeasured}`
+    : docRot?.status === 'failed' ? `·doc-rot 측정 실패(${docRot.error})` : '';
+  return `[nightly-docops] 완료 — 처리 ${metrics.processed}·후보 ${metrics.candidates}·제안 ${metrics.proposals}·억제 ${metrics.suppressed}·에러 ${metrics.errors}·${stalenessLine}${docRotLine}·${metrics.durationMs}ms → ${outDir} (HITL 승인 대기)`;
 }
 
 /**
@@ -102,6 +117,76 @@ export function stalenessEventName(staleness: { status: string } | undefined): s
   return staleness.status === 'failed' ? 'staleness-failed' : 'staleness-measured';
 }
 
+export function buildDocRotStage(
+  repoRoot: string,
+  deps: { scan?: typeof scanDocRot; files?: () => string[] } = {},
+): () => DocRotStageResult {
+  const scan = deps.scan ?? scanDocRot;
+  const files = deps.files ?? (() => defaultManualFiles(repoRoot));
+  return () => {
+    try {
+      const report = scan({ repoRoot, files: files() });
+      return {
+        status: 'measured',
+        totals: report.totals,
+        staleFiles: report.files.flatMap((entry) => {
+          const badCommands = entry.commands.filter((finding) =>
+            finding.kind === 'unknown-command' || finding.kind === 'unknown-subcommand' || finding.kind === 'unknown-flag');
+          return entry.missingPaths.length || badCommands.length
+            ? [{ file: entry.file, missingPaths: entry.missingPaths, badCommands }]
+            : [];
+        }),
+      };
+    } catch (error) {
+      return { status: 'failed', error: error instanceof Error ? error.message : String(error) };
+    }
+  };
+}
+
+export interface DocRotRecordDeps {
+  outDir: string;
+  nowDate: string;
+  mkdir?: (dir: string) => void;
+  write?: (path: string, body: string) => void;
+  log?: (category: string, event: string, data: Record<string, unknown>) => void;
+}
+
+/**
+ * doc-rot 단계 결과를 ⑴ `doc-rot-<날짜>.json` 보고서 ⑵ `docs.rot` 관측 이벤트로 남긴다.
+ * 보고서·관측 어느 쪽이 실패해도 던지지 않는다 — 야간 사이클의 종료 코드를 바꾸지 않는다.
+ */
+export function recordDocRotStage(
+  docRot: DocRotStageResult,
+  deps: DocRotRecordDeps,
+): { reportPath: string | null; writeError: string | null } {
+  const mkdir = deps.mkdir ?? ((dir: string) => { mkdirSync(dir, { recursive: true }); });
+  const write = deps.write ?? ((path: string, body: string) => { writeFileSync(path, body); });
+  const log = deps.log ?? ((category: string, event: string, data: Record<string, unknown>) => { debug.log(category, event, data); });
+  const reportPath = join(deps.outDir, `doc-rot-${deps.nowDate}.json`);
+  let writeError: string | null = null;
+  try {
+    mkdir(deps.outDir);
+    write(reportPath, JSON.stringify(docRot, null, 2));
+  } catch (error) {
+    // 보고서 파일을 못 써도 측정 결과는 버리지 않는다 — 원인은 관측 이벤트에 따로 싣는다.
+    writeError = error instanceof Error ? error.message : String(error);
+  }
+  try {
+    const totals = docRot.status === 'measured' ? docRot.totals : null;
+    log('docs.rot', docRot.status === 'measured' ? 'nightly-scanned' : 'nightly-failed', {
+      files: totals?.files ?? null,
+      staleFiles: totals?.staleFiles ?? null,
+      missingPaths: totals?.missingPaths ?? null,
+      badCommands: totals?.badCommands ?? null,
+      unmeasured: totals?.unmeasured ?? null,
+      error: docRot.status === 'failed' ? docRot.error : null,
+      reportPath: writeError ? null : reportPath,
+      writeError,
+    });
+  } catch { /* 관측 실패가 야간 사이클의 종료 코드를 바꾸지 않는다 */ }
+  return { reportPath: writeError ? null : reportPath, writeError };
+}
+
 if (import.meta.main) {
 await registerStandaloneLogSink('scheduler');
 mkdirSync(ckDir, { recursive: true });
@@ -156,7 +241,9 @@ const metrics = await runNightlyDocOpsCycle({
   },
 }, { batchLimit: 15, maxRetryPerItem: 1 });
 
-console.log(formatNightlyDocOpsCompletion(metrics));
+const docRot = buildDocRotStage(repoRoot)();
+recordDocRotStage(docRot, { outDir, nowDate });
+console.log(formatNightlyDocOpsCompletion(metrics, docRot));
 }
 
 // ── arc2 되살리기 · 의미 supersede 계층 (gemma-4 · 제목/토픽 클러스터 bounded · 미션 668871) ──

package/scripts/release-loop/gate-node.ts

@@ -20,6 +20,7 @@ import { runPodCommand, parsePodCpu, resolvePodCpu, type RunPodCommandOptions, t
 import { POD_BUN_CACHE_HOST_PATH, parseInstallSeconds, podBunCacheVolume } from '../../src/task-orchestrator/surfaces/pod-bun-cache.js';
 import { PodPoolScheduler, parsePodPool, checkPodPool } from '../../src/task-orchestrator/surfaces/pod-pool.js';
 import { POD_INSTALL_SLOTS_DEFAULT, POD_INSTALL_SLOTS_HOST_PATH, installSlotScript } from '../../src/task-orchestrator/surfaces/pod-install-slots.js';
+import { gateDepsInstallScript, parseGateDeps } from '../../src/task-orchestrator/surfaces/pod-gate-deps.js';
 import { gateShardsPath, writeGateShards, type GateShard } from '../../src/release-loop/gate-shards.js';
 import { defaultKubectl } from '../../src/task-orchestrator/surfaces/self-implement-pod.js';
 
@@ -253,7 +254,7 @@ export function shardParts(paths: readonly string[], seconds: (file: string) =>
  * leaving `install.log`/`install.rc`, `part-<i>.log`/`.rc`/`.junit.xml`, and `shard.timeout` (the part index) when the
  * deadline cut the shard. A part without `.rc` did not finish. The shell itself always exits 0 (as before).
  */
-export function gateShardShell(o: { parts: readonly (readonly string[])[]; cdpPatterns: readonly string[]; softSeconds: number; cachePrefix: string; installSlots: number }): string {
+export function gateShardShell(o: { parts: readonly (readonly string[])[]; cdpPatterns: readonly string[]; softSeconds: number; cachePrefix: string; installSlots: number; depsDir?: string }): string {
   const run = o.parts.map((part, index) => {
     const ignores = o.cdpPatterns.filter((pattern) => part.includes(pattern)).flatMap((pattern) => ['--path-ignore-patterns', pattern]);
     return `run_part ${index} ${['bun', 'run', 'test:deterministic', ...ignores, ...part.map(asPath)].map(quote).join(' ')}`;
@@ -276,9 +277,8 @@ export function gateShardShell(o: { parts: readonly (readonly string[])[]; cdpPa
     '  echo "$prc" > "$O/part-$i.rc"',
     '}',
     'if cd .. && cd repo; then',
-    ...(o.installSlots > 0 ? ['  install_slot_acquire >> "$O/install.log" 2>&1'] : []),
-    '  { bun install && (cd apps/pwa && bun install); } >> "$O/install.log" 2>&1; irc=$?',
-    ...(o.installSlots > 0 ? ['  install_slot_release'] : []),
+    // GATE-IMAGE-DEPS: link the image's baked node_modules when the lockfiles match; only a miss installs (behind a slot).
+    ...gateDepsInstallScript({ log: '"$O/install.log"', installSlots: o.installSlots, ...(o.depsDir ? { depsDir: o.depsDir } : {}) }).split('\n').map((line) => `  ${line}`),
     '  echo "$irc" > "$O/install.rc"',
     `  if [ "$irc" -eq 0 ]; then ${run || 'true'}; fi`,
     'else echo 5 > "$O/install.rc"; fi',
@@ -800,7 +800,7 @@ export function createGateRunner(repo: string, remote?: string, commandOverride?
       }
       const installSeconds = parseInstallSeconds(output ?? '');
       // GATE-TIMEOUT-HEAL ③: a cut shard is «reason: timeout» (with the files that still finished), not a bare rc=null.
-      if (!reused && !descent) debug.log('release-loop.gate', 'pod-shard', { shard, files: paths, durationMs, rc: rc ?? null, attempt: depth + 1, installSeconds, deadlineSeconds: shardDeadline, parts: parts.length,
+      if (!reused && !descent) debug.log('release-loop.gate', 'pod-shard', { shard, files: paths, durationMs, rc: rc ?? null, attempt: depth + 1, installSeconds, gateDeps: parseGateDeps(output ?? ''), deadlineSeconds: shardDeadline, parts: parts.length,
         ...(timedOut ? { reason: 'timeout', finishedFiles: finished.length } : {}) });
       if (!reused && !descent) markShard(shard, { ...(installSeconds !== null ? { installSec: installSeconds } : {}), ...(rc !== undefined ? { rc } : {}), ...(timedOut ? { state: 'timeout' as const } : {}) });
       let clean = output?.replace(/\x1b\[[0-9;]*[A-Za-z]/g, '');

package/scripts/release-loop/shard-plan.ts

@@ -1,15 +1,60 @@
-import { readdirSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
+import { readdirSync, readFileSync, statSync } from 'node:fs';
+import { basename, dirname, join, resolve } from 'node:path';
 import { debug } from '../../src/debug/log.js';
 
 /** Plan weights for a Pod sweep: wall-scaled when the previous cut recorded shard wall times, junit seconds otherwise. */
-export function planDurations(durationSource: string | undefined): { durations: Map<string, number>; wall?: { shards: number; scaledFiles: number } } {
+export function planDurations(durationSource: string | undefined): { durations: Map<string, number>; wall?: { shards: number; scaledFiles: number }; fallback?: string } {
   if (!durationSource) return { durations: new Map() };
-  const junit = readFileDurations(durationSource);
-  const wall = readFileWallWeights(durationSource, junit);
+  const primary = planDurationsFrom(durationSource);
+  if (primary.durations.size) return primary;
+  // GATE-PLAN-TIMINGS: the baseline cut left no reports (0.2.20: baseline 0.2.19 was gated from another universe, so
+  // all 5,585 files were «unknown», planned 3.9 min, measured 13–20 min). Use the most recent sibling cut instead.
+  const fallback = latestSiblingCutDir(durationSource);
+  if (!fallback) {
+    debug.log('release-loop.gate', 'plan-duration-fallback', { source: durationSource, fallback: null });
+    return primary;
+  }
+  const result = planDurationsFrom(fallback);
+  debug.log('release-loop.gate', 'plan-duration-fallback', { source: durationSource, fallback, files: result.durations.size, wall: !!result.wall });
+  return result.durations.size ? { ...result, fallback } : primary;
+}
+
+function planDurationsFrom(dir: string): { durations: Map<string, number>; wall?: { shards: number; scaledFiles: number } } {
+  const junit = readFileDurations(dir);
+  const wall = readFileWallWeights(dir, junit);
   return wall ? { durations: wall.weights, wall: { shards: wall.shards, scaledFiles: wall.scaledFiles } } : { durations: junit };
 }
 
+/**
+ * For a `<root>/<version>/<a>/<b>` duration source (the gate passes `<ledger>/release/<baseline>/gate-logs/cut`), the
+ * sibling `<root>/<other>/<a>/<b>` directory whose newest `*.junit.xml` is the most recent — «the latest gate». The
+ * source itself is skipped. Undefined when the path is too shallow or no sibling holds a junit report.
+ */
+export function latestSiblingCutDir(durationSource: string): string | undefined {
+  const source = resolve(durationSource);
+  const b = basename(source);
+  const a = basename(dirname(source));
+  const root = dirname(dirname(dirname(source)));
+  if (!a || !b || root === dirname(dirname(source))) return undefined;
+  let versions: string[];
+  try { versions = readdirSync(root, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name); }
+  catch { return undefined; }
+  let best: { dir: string; mtimeMs: number } | undefined;
+  for (const version of versions.sort()) {
+    const dir = join(root, version, a, b);
+    if (dir === source) continue;
+    let newest = -1;
+    try {
+      for (const name of readdirSync(dir)) {
+        if (!name.endsWith('.junit.xml')) continue;
+        try { newest = Math.max(newest, statSync(join(dir, name)).mtimeMs); } catch { /* vanished mid-scan */ }
+      }
+    } catch { continue; }
+    if (newest >= 0 && (!best || newest > best.mtimeMs)) best = { dir, mtimeMs: newest };
+  }
+  return best?.dir;
+}
+
 /** Observation for GATE-PLAN-WALLTIME, emitted once the shards are planned so `maxPlannedMin` is the heaviest shard. */
 export function logPlanWalltime(wall: { shards: number; scaledFiles: number } | undefined, shards: ReadonlyArray<{ plannedSeconds: number }>): void {
   if (!wall) return;

package/scripts/research-coo-admin-dates.ts

@@ -0,0 +1,39 @@
+import { readFile } from 'node:fs/promises';
+import { searchFirecrawl } from '../skills/omni-crawl/src/firecrawl.js';
+
+type Check = { identifier: string; query: string; inspectedLead: { url: string } | null };
+type Search = (query: string, options: { limit: number }) => Promise<{ items: Array<{ url?: string }> }>;
+
+export async function recheckCooAdminLeads(checks: Check[], search: Search): Promise<string[]> {
+  let verified = 0;
+  let withUrl = 0;
+  let withoutUrl = 0;
+  const lines: string[] = [];
+  for (const check of checks) {
+    const result = await search(check.query, { limit: 3 });
+    const recordedUrl = check.inspectedLead?.url?.trim();
+    if (!recordedUrl) {
+      withoutUrl++;
+      lines.push(`${check.identifier} hits=${result.items.length} recordedUrl=none (not verified) query=${check.query}`);
+      continue;
+    }
+    withUrl++;
+    const found = result.items.some(item => item.url === recordedUrl);
+    if (found) verified++;
+    lines.push(`${check.identifier} hits=${result.items.length} recordedUrlVerified=${found} query=${check.query}`);
+  }
+  lines.push(`SEARCH checked=${checks.length} recordedUrlVerified=${verified}/${withUrl} noRecordedUrl=${withoutUrl} recordedUrlNotInCurrentTop3=${withUrl - verified} (search rankings change; no official date inferred)`);
+  return lines;
+}
+
+if (import.meta.main) {
+  const evidence = JSON.parse(await readFile(new URL('../src/domains/coo-admin-dates.evidence.json', import.meta.url), 'utf8')) as {
+    verifiedIssues: Array<{ identifier: string }>;
+    research: { issueChecks: Check[] };
+  };
+  const checks = evidence.research.issueChecks;
+  if (checks.length !== 29 || checks.some((check, index) => check.identifier !== evidence.verifiedIssues[index]?.identifier || !check.query)) {
+    throw new Error('29 issue search queries do not match recorded issue identifiers');
+  }
+  for (const line of await recheckCooAdminLeads(checks, searchFirecrawl)) console.log(line);
+}

package/scripts/rhythm/daily.ts

@@ -587,8 +587,9 @@ export async function main(args: string[] = process.argv.slice(2), deps: DailyDe
   for (const arg of args) if (!['--dry-run', '--no-news', '--json'].includes(arg)) throw new Error(`알 수 없는 옵션: ${arg}`);
   const result = await runDaily({ dryRun: args.includes('--dry-run'), noNews: args.includes('--no-news'), stage }, deps);
   (deps.print ?? console.log)(args.includes('--json') ? JSON.stringify(result) : `${result.markdown}\n파일: ${result.file} · ${result.deliveryLine}`);
-  // 발송 설정 OFF 는 degraded 로 기록하고 done 으로 진행한다. 실제 발송 실패·볼트 사본 실패는 그래프를 멈춘다.
+  // 그래프 deliver 는 미발송도 출력·tick 에 기록한 뒤 실패로 종결한다.
   if ((stage === 'compose' || !stage) && result.vaultFatal) throw new Error(`볼트 사본 실패 · ${result.vaultError}`);
+  if (stage === 'deliver' && result.deliveryState === 'send-disabled') throw new Error('발송 실패 · 발송 비활성');
   if (stage === 'deliver' && result.sendError) throw new Error(`발송 실패 · ${result.sendError}`);
   return result;
 }

package/scripts/skills/public-check.ts

@@ -140,10 +140,15 @@ export function checkPublicSkills(root: string, boundary: SkillBoundaryReport =
   const errors = [...boundary.errors];
   const skills: PublicSkillRow[] = [];
   const skillsDir = join(root, 'skills');
-  const addon = new Set(boundary.skills.filter((row) => row.verdict === 'addon').map((row) => row.skill));
+  // Scope discrepancy: the stated 15 public deployments have no named fifteenth
+  // skill in this tree's boundary inventory (14 core, 5 addons). No verified
+  // deployment-name list is available here to justify adding a row. Never use
+  // an addon to fill the gap; keep the existing report shape and exit semantics.
+  // Unclassified folders retain their check rows and boundary errors.
+  const verdicts = new Map(boundary.skills.map((row) => [row.skill, row.verdict]));
   const names = existsSync(skillsDir) ? readdirSync(skillsDir).filter((name) => {
     const dir = join(skillsDir, name);
-    return lstatSync(dir).isDirectory() && !addon.has(name);
+    return lstatSync(dir).isDirectory() && verdicts.get(name) !== 'addon';
   }).sort() : [];
   if (!existsSync(skillsDir)) errors.push('skills/ 디렉터리가 없다');
   for (const row of boundary.skills) {

package/scripts/smart-merge/resync-shadow.ts

@@ -8,7 +8,6 @@ import {
   defaultGitMergeSeam, defaultLlmResolve, mergeMainWithLlmResolve,
   type MergeGitSeam,
 } from '../../src/autopilot/build/llm-conflict-merge.js';
-import { NEXT_MD_PATH } from '../../src/release-loop/next-md-merge.js';
 
 type Command = (cwd: string, program: 'git' | 'gh', args: readonly string[]) => { status: number; stdout: string; stderr: string };
 export type ShadowOutcome = 'clean' | 'resolved-deterministic' | 'resolved-llm' | 'unresolved' | 'unmeasured';
@@ -108,9 +107,12 @@ export async function runResyncShadow(options: ShadowOptions): Promise<ShadowRow
       const result = await mergeMainWithLlmResolve(temp, 'origin/main',
         options.resolve ?? ((file, conflicted) => defaultLlmResolve(file, conflicted, 'origin/main', { worktreePath: temp })), observedGit);
       if (result.status === 'merged' || result.status === 'up-to-date') outcome = 'clean';
-      else if (result.status === 'llm-resolved') {
+      else if (result.status === 'deterministic-resolved') {
         files = result.resolvedFiles ?? files;
-        outcome = files.length > 0 && files.every((file) => file === NEXT_MD_PATH) ? 'resolved-deterministic' : 'resolved-llm';
+        outcome = 'resolved-deterministic';
+      } else if (result.status === 'llm-resolved') {
+        files = result.resolvedFiles ?? files;
+        outcome = 'resolved-llm';
       } else if (result.status === 'conflict-unresolved') outcome = 'unresolved';
       // A git error is a measurement failure, not evidence of an unresolvable conflict.
     } catch {

package/scripts/test-diet/lib.ts

@@ -1,8 +1,88 @@
 // TD2 — a daily look at the test suite, one cost-weighted slice at a time (shadow: it measures and drafts, it
 // never deletes or moves a test). Design: 내부 문서 `TD1-v2-gate-content-review-2026-10-01`.
-import { appendFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync, renameSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 
+/** These were reported as preexisting in the recent gate/harvest; remeasurement, not this list, decides today's count. */
+export const DEFAULT_MAIN_FAILURE_FILES = [
+  'src/task-orchestrator/surfaces/pod-pool-cli.test.ts',
+  'src/self-dev/dev-cli.test.ts',
+  'src/self-dev/dev-pipeline.test.ts',
+  'src/agent-mission/agent-backend-flag-smoke.test.ts',
+  'scripts/release-story/draft.test.ts',
+  'scripts/release-loop/freeze-off-parity.test.ts',
+] as const;
+
+export type MainFailureClass = '시험이 낡음' | '코드 결함' | '환경·부하 의존' | '외부 의존';
+export interface MainFailureResult { file: string; rc: number | null; stdout: string; stderr: string; timedOut?: boolean }
+export interface MainFailureRow { file: string; failures: number; firstError: string; classification: MainFailureClass; draft: '고침' | '격리' }
+export interface MainFailureDay { date: string; at: string; owner: 'TC'; mode: 'shadow'; commit: string; selected: string[]; rows: MainFailureRow[]; unmeasured: { file: string; reason: string }[]; failingFiles: number; previousFailingFiles: number | null; delta: number | null }
+
+export function mainFailureLedgerPath(root: string, date: string): string { return join(root, 'test-diet', 'main-failures', `${date}.json`); }
+export function kstDay(at: Date): string { return new Date(at.getTime() + 9 * 3600_000).toISOString().slice(0, 10); }
+
+export function mainFailureFiles(value: unknown): string[] {
+  const files = value === undefined ? [...DEFAULT_MAIN_FAILURE_FILES] : value;
+  if (!Array.isArray(files) || files.length === 0 || !files.every((file) => typeof file === 'string' && /^(?:src|scripts|test)\/[A-Za-z0-9_./-]+\.test\.tsx?$/.test(file) && !file.split('/').includes('..'))) {
+    throw new Error('main failure files must be nonempty repository-relative test paths');
+  }
+  return [...new Set(files as string[])];
+}
+
+/** A heuristic draft, never a finding about the root cause or permission to skip a test. */
+export function mainFailureRow(result: MainFailureResult): MainFailureRow | null {
+  const text = `${result.stdout}\n${result.stderr}`.replace(/\x1b\[[0-9;]*m/g, '');
+  const count = [...text.matchAll(/^\s*(\d+) fail\b/gm)].at(-1);
+  const failures = count ? Number(count[1]) : 0;
+  const ran = /Ran [1-9]\d* tests? across [1-9]\d* files?/m.test(text);
+  if (result.timedOut || !ran || !Number.isSafeInteger(failures) || (result.rc !== 0 && failures === 0)
+    || (result.rc === 0 && failures > 0) || /^(?:\s*[1-9]\d* errors?\b|# Unhandled error between tests)/m.test(text)) {
+    throw new Error(`test not measured: ${result.file}: ${text.split('\n').map((line) => line.trim()).find((line) => /error:|Error:|timed out|timeout|Cannot find|not found|errors?\b/i.test(line)) ?? 'no completed test result'}`);
+  }
+  if (failures === 0 && result.rc === 0) return null;
+  const firstError = text.split('\n').map((line) => line.trim()).find((line) => /^(?:\(fail\)|error:|\w*Error:|Expected:|Received:|Cannot find|Unable to)/i.test(line))
+    ?? `test exited ${result.rc} without a diagnostic`;
+  const classification: MainFailureClass = /timed out|timeout|load average|resource temporarily unavailable/i.test(firstError) ? '환경·부하 의존'
+    : /codex|--yolo|network|ECONN|API key|Unable to|Cannot find module|ENOENT/i.test(firstError) ? '외부 의존'
+      : /snapshot|next\.md|expected|Received|toEqual|toContain/i.test(firstError) ? '시험이 낡음' : '코드 결함';
+  return { file: result.file, failures, firstError: firstError.slice(0, 240), classification,
+    draft: classification === '환경·부하 의존' || classification === '외부 의존' ? '격리' : '고침' };
+}
+
+/** One KST-day snapshot, replaced on remeasurement. Incomplete runs cannot masquerade as zero failures. */
+export function writeMainFailureDay(root: string, selected: string[], results: MainFailureResult[], commit: string, at = new Date()): MainFailureDay {
+  if (results.length !== selected.length || results.some((r, i) => r.file !== selected[i])) throw new Error('incomplete main failure measurement');
+  const date = kstDay(at);
+  const dir = join(root, 'test-diet', 'main-failures');
+  mkdirSync(dir, { recursive: true });
+  const dates = earlierMainFailureDays(dir, date);
+  const previous = dates.at(-1);
+  const previousDay = previous ? JSON.parse(readFileSync(join(dir, previous), 'utf8')) as MainFailureDay : null;
+  const rows: MainFailureRow[] = [];
+  const unmeasured: MainFailureDay['unmeasured'] = [];
+  for (const result of results) {
+    try {
+      const row = mainFailureRow(result);
+      if (row) rows.push(row);
+    } catch (error) {
+      // 못 잰 파일은 «실패»가 아니다 — 행으로 접으면 측정 실패가 main 결함 1건으로 둔갑한다.
+      unmeasured.push({ file: result.file, reason: (error instanceof Error ? error.message : String(error)).slice(0, 240) });
+    }
+  }
+  const previousFailingFiles = unmeasured.length === 0 && previousDay?.unmeasured?.length === 0
+    && previousDay.selected.join('\0') === selected.join('\0') ? previousDay.failingFiles : null;
+  const line: MainFailureDay = { date, at: at.toISOString(), owner: 'TC', mode: 'shadow', commit, selected, rows, unmeasured, failingFiles: rows.length,
+    previousFailingFiles, delta: previousFailingFiles === null ? null : rows.length - previousFailingFiles };
+  const path = mainFailureLedgerPath(root, date);
+  writeFileSync(`${path}.${process.pid}.tmp`, JSON.stringify(line, null, 2) + '\n');
+  renameSync(`${path}.${process.pid}.tmp`, path);
+  return line;
+}
+
+function earlierMainFailureDays(dir: string, date: string): string[] {
+  return readdirSync(dir).filter((name) => /^\d{4}-\d{2}-\d{2}\.json$/.test(name) && name < `${date}.json`).sort();
+}
+
 export const DEFAULT_COST_SECS = 10;
 export const SLOW_SECS = 60;
 export const HEAVY_MB = 2048;

package/scripts/test-diet/node.ts

@@ -3,13 +3,15 @@
 //   bun scripts/test-diet/node.ts pick|measure|audit|record (test-diet or nightly-audit graph)
 import { spawnSync } from 'node:child_process';
 import { createHash } from 'node:crypto';
-import { appendFileSync, existsSync, mkdirSync, readFileSync } from 'node:fs';
+import { appendFileSync, existsSync, mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { debug } from '../../src/debug/log.js';
 import { effectiveInstanceRoot } from '../../src/instance/resolve.js';
 import { CardStore } from '../../src/task-cards/card-store.js';
 import { GATE_NIGHTLY_AUDITS } from '../release-loop/gate-node.js';
-import { appendLedger, costTable, judge, lastLedgerLine, ledgerPath, nightlyAuditLedgerPath, pickRange, propose, td1Dispositions, writeCardDraft, type LedgerLine, type Measurement, type Td1Disposition } from './lib.js';
+import { isCredentialKey } from '../lib/deterministic-env.js';
+import { appendLedger, costTable, judge, lastLedgerLine, ledgerPath, mainFailureFiles, nightlyAuditLedgerPath, pickRange, propose, td1Dispositions, writeCardDraft, writeMainFailureDay, type LedgerLine, type MainFailureResult, type Measurement, type Td1Disposition } from './lib.js';
 import { fixedCountAssertions, flakeVerdict, sweepSlice, unreachableImports, type Mutation, type TestRun } from './effectiveness.js';
 
 type Context = { graphId?: string; input: Record<string, unknown>; outputs: Record<string, Record<string, unknown> | null> };
@@ -235,6 +237,49 @@ export function record(ctx: Context, deps: { createStore?: (root: string) => Pic
   return emit({ outcome: 'ok', summary: `test-diet ${line.range} · keep ${counts.keep} · review ${counts.review} · failing ${counts.failing}${card ? ' · card draft' : ''}`, range: line.range, ...counts, ...(card ? { card } : {}) });
 }
 
+export function mainFailures(ctx: Context, deps: { root?: string; checkout?: string; runFile?: (file: string, cwd: string) => MainFailureResult; now?: Date } = {}): number {
+  const selected = mainFailureFiles(ctx.input.files);
+  const root = deps.root ?? effectiveInstanceRoot();
+  const guarded = process.env.NODE_ENV === 'test' || !!process.env.ELANOUS_TEST_HOME;
+  const directory = deps.checkout || guarded ? undefined : mkdtempSync(join(tmpdir(), 'test-diet-main-'));
+  try {
+    let checkout = deps.checkout ?? directory ?? '';
+    let commit: string;
+    if (guarded) {
+      // No clone, install, test subprocess or harness dispatch in the test universe.
+      const at = deps.now ?? new Date();
+      const ledger = join(root, 'test-diet', 'main-failures', `${at.toISOString().slice(0, 10)}-guard.json`);
+      mkdirSync(join(root, 'test-diet', 'main-failures'), { recursive: true });
+      writeFileSync(ledger, JSON.stringify({ at: at.toISOString(), selected, measured: false, reason: 'test environment', owner: 'TC', mode: 'shadow' }) + '\n');
+      return emit({ outcome: 'ok', summary: 'main failures record only: test environment (not measured)', ledger, selected, measured: false });
+    } else if (deps.checkout) {
+      const head = spawnSync('git', ['rev-parse', 'HEAD'], { cwd: checkout, encoding: 'utf8' });
+      if (head.status !== 0) throw new Error(`main checkout unreadable: ${checkout}`);
+      commit = head.stdout.trim();
+    } else {
+      const source = process.cwd();
+      const clone = spawnSync('git', ['clone', '--quiet', '--shared', '--single-branch', '--branch', 'main', source, checkout], { encoding: 'utf8', timeout: 120_000 });
+      if (clone.status !== 0) return emit({ outcome: 'error', summary: `main checkout failed: ${clone.stderr || clone.error}` });
+      commit = spawnSync('git', ['rev-parse', 'HEAD'], { cwd: checkout, encoding: 'utf8' }).stdout.trim();
+      const install = spawnSync('bun', ['install', '--frozen-lockfile'], { cwd: checkout, encoding: 'utf8', timeout: 300_000, maxBuffer: 1024 * 1024 });
+      if (install.status !== 0) return emit({ outcome: 'error', summary: `main install failed: ${install.stderr || install.error}` });
+    }
+    const runFile = deps.runFile ?? ((file: string, cwd: string): MainFailureResult => {
+      if (!existsSync(join(cwd, file))) return { file, rc: null, stdout: '', stderr: 'test file not present on main' };
+      const env = Object.fromEntries(Object.entries(process.env).filter(([key]) => !isCredentialKey(key)));
+      const child = spawnSync('bun', ['run', 'test:deterministic', file], {
+        cwd, encoding: 'utf8', timeout: 300_000, maxBuffer: 4 * 1024 * 1024,
+        env: { ...env, NODE_ENV: 'test', ELANOUS_STATE_DIR: join(root, 'test-diet', 'isolated-test-state') },
+      });
+      return { file, rc: child.status, stdout: child.stdout ?? '', stderr: child.stderr ?? String(child.error ?? ''), timedOut: (child.error as NodeJS.ErrnoException | undefined)?.code === 'ETIMEDOUT' };
+    });
+    const results = selected.map((file) => runFile(file, checkout));
+    const day = writeMainFailureDay(root, selected, results, commit, deps.now);
+    debug.log('test-diet.main-failures', 'recorded', { selected: selected.length, failingFiles: day.failingFiles, delta: day.delta, guarded });
+    return emit({ outcome: 'ok', summary: `main failures ${day.failingFiles}/${selected.length} · delta ${day.delta ?? 'n/a'} · shadow TC`, ledger: join(root, 'test-diet', 'main-failures', `${day.date}.json`), ...day });
+  } finally { if (directory) rmSync(directory, { recursive: true, force: true }); }
+}
+
 function status(root: string, options: { json?: boolean; days?: number } = {}): number {
   const path = ledgerPath(root);
   const ledger = existsSync(path) ? readFileSync(path, 'utf8') : '';
@@ -286,6 +331,7 @@ if (import.meta.main) {
       const ctx = context();
       const flags = process.argv.slice(3);
       process.exitCode = step === 'pick' ? pick(ctx, flags.includes('--sweep')) : step === 'measure' ? measure(ctx, false, flags.includes('--effectiveness')) : step === 'audit' ? measure(ctx, true)
+        : step === 'main-failures' ? mainFailures(ctx)
         : step === 'record' ? (ctx.graphId === 'nightly-audit' || Object.hasOwn(ctx.outputs, 'audit') ? recordNightlyAudit(ctx) : record(ctx)) : emit({ outcome: 'error', summary: `unknown step: ${step}` });
     }
   } catch (error) {

package/scripts/verify-coo-admin-evidence.ts

@@ -0,0 +1,83 @@
+import { readFile } from 'node:fs/promises';
+import { fetchLinearProjectIssues, type LinearProjectIssue } from '../src/connectors/linear.js';
+
+type RecordedIssue = {
+  identifier: string; title: string; url: string; createdAt: string; updatedAt: string;
+  existingDueDate: string | null; priority: number;
+};
+type Evidence = {
+  project: string;
+  verifiedIssues: RecordedIssue[];
+  cohort: { excludedCurrentIssues: Array<{identifier: string; url: string; dueDate: string | null; priority: number; createdAt: string}> };
+};
+type LiveIssue = LinearProjectIssue & { createdAt: string };
+
+export function compareCooEvidence(record: Evidence, live: LiveIssue[], truncated: boolean): string[] {
+  const errors: string[] = [];
+  if (truncated) errors.push('Linear result truncated');
+  if (live.length !== 33) errors.push(`current open count: ${live.length} != 33`);
+  if (record.verifiedIssues.length !== 29) errors.push(`recorded count: ${record.verifiedIssues.length} != 29`);
+  const sorted = [...live].sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+  const selected = sorted.slice(0, 29);
+  const excluded = sorted.slice(29);
+  const actual = new Map(live.map(issue => [issue.identifier, issue]));
+  if (actual.size !== live.length) errors.push('duplicate Linear identifier');
+  const seen = new Set<string>();
+  for (const row of record.verifiedIssues) {
+    if (seen.has(row.identifier)) errors.push(`duplicate recorded identifier: ${row.identifier}`);
+    seen.add(row.identifier);
+    const issue = actual.get(row.identifier);
+    if (!issue) { errors.push(`not in Linear: ${row.identifier}`); continue; }
+    for (const [field, expected, value] of [
+      ['title', row.title, issue.title], ['url', row.url, issue.url],
+      ['createdAt', row.createdAt, issue.createdAt], ['updatedAt', row.updatedAt, issue.updatedAt],
+      ['dueDate', row.existingDueDate, issue.dueDate], ['priority', row.priority, issue.priority],
+    ] as const) if (expected !== value) errors.push(`${row.identifier} ${field}: recorded=${String(expected)} Linear=${String(value)}`);
+  }
+  const selectedIds = selected.map(issue => issue.identifier).sort().join(',');
+  if ([...seen].sort().join(',') !== selectedIds) errors.push('recorded identifiers differ from oldest 29 currently open by createdAt');
+  if (selected.filter(issue => issue.dueDate !== null).length !== 4) errors.push('Linear selected dueDate count != 4');
+  if (selected.filter(issue => issue.priority !== 0).length !== 7) errors.push('Linear selected priority count != 7');
+  const excludedRecorded = record.cohort.excludedCurrentIssues;
+  if (excludedRecorded.map(issue => issue.identifier).sort().join(',') !== excluded.map(issue => issue.identifier).sort().join(',')) errors.push('excluded identifiers differ from Linear');
+  for (const row of excludedRecorded) {
+    const issue = actual.get(row.identifier);
+    if (!issue) continue;
+    if (row.url !== issue.url || row.createdAt !== issue.createdAt || row.dueDate !== issue.dueDate || row.priority !== issue.priority) errors.push(`excluded ${row.identifier} differs from Linear`);
+  }
+  return errors;
+}
+
+// Linear GraphQL read-only fetchLinearProjectIssues resolves the project and paginates the open issues.
+// createdAt is queried separately because the shared COO tool's projection does not include it.
+export async function readLiveCooIssues(apiKey: string, project: string): Promise<{ issues: LiveIssue[]; truncated: boolean }> {
+  const issues = await fetchLinearProjectIssues({apiKey, project});
+  const identifiers = issues.map(issue => issue.identifier);
+  if (new Set(identifiers).size !== identifiers.length) throw new Error('duplicate Linear identifier');
+  const query = 'query CooIssueCreation($id: String!) { issue(id: $id) { identifier createdAt } }';
+  const creations = await Promise.all(identifiers.map(async identifier => {
+    const response = await fetch('https://api.linear.app/graphql', {
+      method: 'POST', headers: {Authorization: apiKey, 'Content-Type': 'application/json'},
+      body: JSON.stringify({query, variables: {id: identifier}}),
+    });
+    if (!response.ok) throw new Error(`Linear creation read HTTP ${response.status}`);
+    const body = await response.json() as { errors?: unknown[]; data?: {issue?: {identifier: string; createdAt: string}} };
+    if (body.errors?.length || body.data?.issue?.identifier !== identifier || !body.data.issue.createdAt) throw new Error(`Linear creation read failed: ${identifier}`);
+    return body.data.issue.createdAt;
+  }));
+  return {issues: issues.map((issue, index) => ({...issue, createdAt: creations[index]!})), truncated: issues.truncated};
+}
+
+if (import.meta.main) {
+  const apiKey = process.env.LINEAR_API_KEY?.trim();
+  if (!apiKey) throw new Error('LINEAR_API_KEY absent; cannot compare recorded evidence to live Linear');
+  const record = JSON.parse(await readFile(new URL('../src/domains/coo-admin-dates.evidence.json', import.meta.url), 'utf8')) as Evidence;
+  const {issues, truncated} = await readLiveCooIssues(apiKey, record.project);
+  const errors = compareCooEvidence(record, issues, truncated);
+  if (errors.length) {
+    for (const error of errors) console.error(error);
+    process.exitCode = 1;
+  } else {
+    console.log(`PASS Linear live comparison: open=${issues.length} selected=${record.verifiedIssues.length} dueDates=${record.verifiedIssues.filter(issue => issue.existingDueDate !== null).length} priorities=${record.verifiedIssues.filter(issue => issue.priority !== 0).length} excluded=${record.cohort.excludedCurrentIssues.length}`);
+  }
+}

package/src/acp/client.ts

@@ -371,6 +371,8 @@ export function readClientInfo(
 export interface AcpAgentOpts {
   /** Backend id from ACP_BACKENDS. */
   backendId: string;
+  /** Review-owned ACP executable override; never changes the shared backend registry. */
+  backendSpec?: AcpBackendSpec;
   /** Working directory the agent runs in (cwd argument to spawn).
    *  Affects file-tool resolution. Default: getSessionCwd() so a
    *  Ctrl+W / /wd in the dashboard retargets new ACP agents. */
@@ -443,7 +445,7 @@ export class AcpAgent {
   private authMethods: string[] = [];
 
   constructor(opts: AcpAgentOpts) {
-    this.spec = getAcpBackend(opts.backendId);
+    this.spec = opts.backendSpec ?? getAcpBackend(opts.backendId);
     // WD7 — default to the session working directory; ACP agents
     // inherit the "active project" concept.
     this.cwd = opts.cwd ?? getSessionCwd();
@@ -456,7 +458,7 @@ export class AcpAgent {
     // proactively. Mirrors zed's env-strip pattern for provider
     // tokens (acp.rs:232-243), generalized here for any env that
     // breaks nested agents.
-    const cleanEnv: NodeJS.ProcessEnv = { ...process.env, ...opts.env };
+    const cleanEnv: NodeJS.ProcessEnv = opts.backendSpec && opts.env ? { ...opts.env, NODE_ENV: process.env.NODE_ENV } : { ...process.env, ...opts.env };
     for (const key of Object.keys(cleanEnv)) {
       if (NESTED_AGENT_ENV_BLOCKLIST.has(key) || /^CLAUDE_CODE_/.test(key)) {
         delete cleanEnv[key];

package/src/agent/run-context.ts

@@ -54,6 +54,8 @@ export interface ChildLlmSelection {
   effort?: ChildLlmEffort;
   /** 선택이 CLI 플래그에서 왔나, self-dev 설정에서 왔나. 같은 모델이라도 다른 사실이다. */
   source: 'flag' | 'config';
+  /** Grok weekly cap rerouted this run to Codex: allow prepaid credits even when subscription quota is exhausted. */
+  codexQuotaPolicy?: 'credits';
 }
 
 /** ⭐⭐ **가르는 축은 「키냐 주소냐」가 «아니라» 「그 자격이 «파일»에 사나 «env»에 사나」다**
@@ -91,6 +93,8 @@ export function childLlmSelectionEnv(selection?: ChildLlmSelection): Record<stri
     return {
       ELANOUS_LLM_PROVIDER: provider,
       ELANOUS_LLM_MODEL: childRelayModel(provider, selection.model),
+      ...(selection.codexQuotaPolicy === 'credits' && provider === 'openai-codex'
+        ? { ELANOUS_CODEX_QUOTA_POLICY: 'credits' } : {}),
       // ⛔⭐ 새 env 이름을 «짓지 않는다» — `ELANOUS_ESCALATE_EFFORT` 가 «이미» 있고
       //    `user-config.ts` 가 그것으로 `reasoningLevel`(anthropic)과
       //    `codexReasoning.effort`(openai-codex/sol) 를 ***둘 다*** 덮는다.