elanous 0.2.21 → 0.2.23

package/scripts/release-loop/resume.ts

@@ -0,0 +1,53 @@
+import type { GraphRunState } from '../../src/graph-runner/runner.js';
+import { publicWaiverReason } from './known-issues-node.js';
+
+export interface AcceptedRegression { id: string; note: string }
+
+/** Merge explicit public issues with the saved release input without changing the ledger shape. */
+export function releaseResumeAcceptedRegressions(state: GraphRunState, additions: AcceptedRegression[], from?: string): AcceptedRegression[] {
+  if (!Array.isArray(additions) || additions.some((issue) => !issue || typeof issue.id !== 'string' || !issue.id.trim() || typeof issue.note !== 'string' || !issue.note.trim())) {
+    throw new Error('acceptedRegressions must be an array of {id, note}');
+  }
+  const input = state.input;
+  if (!input || typeof input !== 'object' || Array.isArray(input) || typeof (input as { version?: unknown }).version !== 'string') throw new Error('release run has no input');
+  const existing = (input as { acceptedRegressions?: unknown }).acceptedRegressions;
+  if (existing !== undefined && (!Array.isArray(existing) || existing.some((issue) => !issue || typeof issue.id !== 'string' || !issue.id.trim() || typeof issue.note !== 'string' || !issue.note.trim()))) {
+    throw new Error('saved acceptedRegressions is invalid');
+  }
+  // A rerun of a formerly waived node supersedes only that node's recorded waiver;
+  // independently supplied accepted issues (including similarly named IDs) are not inferred to be waivers.
+  const prior = (existing ?? []) as AcceptedRegression[];
+  // Every waived record at or after the restart boundary is cut from the ledger, so each one's issue retires too.
+  const start = from === undefined ? -1 : state.path.indexOf(from);
+  const retired = start < 0 ? [] : state.nodes.slice(start)
+    .filter((record) => record.waiver && record.executed === false && record.ok === true)
+    .map((record) => ({ id: `waive:${record.nodeId}`, note: record.waiver!.reason }));
+  const combined = [...prior.filter((issue) => !retired.some((gone) => gone.id === issue.id && gone.note === issue.note)), ...additions];
+  if (new Set(combined.map(({ id }) => id)).size !== combined.length) throw new Error('acceptedRegressions IDs must be unique');
+  return combined;
+}
+
+/** Only the recorded failure at the restart boundary may be waived. `--from` is never a waiver. */
+export function releaseResumeWaiver(
+  state: GraphRunState,
+  opts: { from: string; waive?: string; reason?: string; acceptedRegressions?: AcceptedRegression[] },
+): { nodeId: string; reason: string; acceptedRegressions: AcceptedRegression[] } | undefined {
+  if ((opts.waive === undefined) !== (opts.reason === undefined)) throw new Error('--waive <node> and --reason <text> must be supplied together');
+  if (opts.waive !== undefined && !opts.waive.trim()) throw new Error('--waive must not be empty');
+  if (opts.waive === undefined) return undefined;
+  const reason = opts.reason?.trim();
+  if (!reason) throw new Error('--reason must not be empty');
+  publicWaiverReason(reason);
+  if (opts.from !== opts.waive) throw new Error('--from must name the waived node; --from alone does not waive a failure');
+  const index = state.path.indexOf(opts.waive);
+  if (index < 0 || state.path.lastIndexOf(opts.waive) !== index || state.nodes[index]?.nodeId !== opts.waive || state.nodes[index]?.ok !== false ||
+    state.nodes[index]?.executed !== true || state.path.at(-2) !== opts.waive || state.path.at(-1) !== 'failed' || state.nodes.at(-1)?.nodeId !== 'failed') {
+    throw new Error(`--waive ${opts.waive} requires the failed executable node on the saved path`);
+  }
+  // Only user-visible, non-publication checks can become accepted regressions; build, safety and approval gates stay blocking.
+  if (!['mac-smoke', 'tui'].includes(opts.waive)) {
+    throw new Error(`--waive ${opts.waive} cannot waive a safety, side-effect or approval node`);
+  }
+  return { nodeId: opts.waive, reason, acceptedRegressions: releaseResumeAcceptedRegressions(state,
+    [...(opts.acceptedRegressions ?? []), { id: `waive:${opts.waive}`, note: reason }]) };
+}

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

@@ -1,6 +1,7 @@
 import { readdirSync, readFileSync, statSync } from 'node:fs';
 import { basename, dirname, join, resolve } from 'node:path';
 import { debug } from '../../src/debug/log.js';
+import { readJunitFileSeconds } from './gate-method';
 
 /** 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 }; fallback?: string } {
@@ -66,21 +67,12 @@ export function logPlanWalltime(wall: { shards: number; scaledFiles: number } |
 export function readFileDurations(dir: string): Map<string, number> {
   const durations = new Map<string, number>();
   let names: string[];
-  const entities: Record<string, string> = { '&amp;': '&', '&quot;': '"', '&apos;': "'", '&lt;': '<', '&gt;': '>' };
   try { names = readdirSync(dir).filter((name) => name.endsWith('.junit.xml')).sort(); }
   catch { return durations; }
   for (const name of names) {
     try {
-      const xml = readFileSync(join(dir, name), 'utf8');
-      for (const match of xml.matchAll(/<testsuite\b([^>]*)>/g)) {
-        const attrs = match[1]!;
-        const file = /\bfile="([^"]+)"/.exec(attrs)?.[1];
-        const rawTime = /\btime="([^"]+)"/.exec(attrs)?.[1];
-        if (!file || rawTime === undefined) continue;
-        const seconds = Number(rawTime);
-        if (!Number.isFinite(seconds) || seconds < 0) continue;
-        const path = file.replace(/&(?:amp|quot|apos|lt|gt);/g, (entity) => entities[entity]!);
-        durations.set(path, Math.max(durations.get(path) ?? 0, seconds));
+      for (const [file, seconds] of readJunitFileSeconds(readFileSync(join(dir, name), 'utf8'))) {
+        durations.set(file, Math.max(durations.get(file) ?? 0, seconds));
       }
     } catch { /* One unreadable report must not discard the others. */ }
   }

package/scripts/release-loop/tui-node-checks.ts

@@ -28,6 +28,28 @@ export function tuiVerdict(checks: readonly TuiCheck[]): 'pass' | 'fail' {
   return checks.every((c) => c.pass) ? 'pass' : 'fail';
 }
 
+/** `tui-sim-node.ts --json` prints the raw result (no `outcome`); `node-verdict.ts tui` adds it. Same rule here so a
+ *  prefetched raw result is judged exactly like the wrapped node result: exit 0 with pass|flaky → ok. */
+export function withTuiOutcome(status: number | null, data: Record<string, unknown> | null): Record<string, unknown> | null {
+  if (!data) return null;
+  const outcome = status === 0 && (data.verdict === 'pass' || data.verdict === 'flaky') ? 'ok' : status === 1 ? 'fail' : 'error';
+  return { ...data, outcome };
+}
+
+export function reusableTui(data: unknown, commit: string): Record<string, unknown> | null {
+  if (!data || typeof data !== 'object' || Array.isArray(data)) return null;
+  const value = data as Record<string, unknown>;
+  if (value.outcome !== 'ok' || value.commit !== commit || (value.verdict !== 'pass' && value.verdict !== 'flaky')
+    || (value.verdict === 'pass' ? value.attempts !== 1 : value.attempts !== 2)
+    || !Array.isArray(value.checks) || value.checks.length !== 6) return null;
+  const ids = ['boot', 'prompt', 'status-bar', 'help-opens', 'help-closes', 'no-error-text'];
+  if (value.checks.some((check: unknown, i: number) => !check || typeof check !== 'object'
+    || (check as TuiCheck).id !== ids[i] || (check as TuiCheck).pass !== true
+    || typeof (check as TuiCheck).detail !== 'string')) return null;
+  if (value.regress === null || typeof value.regress !== 'object' || Array.isArray(value.regress)) return null;
+  return value;
+}
+
 export type TuiRegress = {
   pass: number;
   fail: number;

package/scripts/release-loop/unattended-release.ts

@@ -11,6 +11,7 @@ import { debug } from '../../src/debug/log.js';
 import { runGraph, type GraphRunState } from '../../src/graph-runner/runner.js';
 import { releaseRunUniverse } from './release-universe.js';
 import { baseVersion, isStableVersion, nextPrereleaseVersion, type PrereleaseKind } from './release-version.js';
+import { publishAtError } from './publish-at.js';
 
 const VERSION = /^(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)$/;
 const GRAPH = join(import.meta.dir, '../../graphs/release/release-loop.yaml');
@@ -40,6 +41,7 @@ export interface ReleaseRunInput extends ReleaseLoopConfig {
   cutCommit?: string;
   gatePodPool: string;
   forceFreeze?: boolean;
+  publishAt?: string;
   /** RELEASE-BRANCH: version-release cuts release/<v> from main HEAD and bumps only the branch. */
   branchCut?: boolean;
 }
@@ -117,7 +119,7 @@ export function buildReleaseRunInput(version: string, deps: UnattendedReleaseDep
 
 /** Fail closed at the entry boundary, before any graph node can change a release. */
 export async function runUnattendedRelease(
-  opts: { version: string; dryRun?: boolean; cutCommit?: string; forceFreeze?: boolean; mainCut?: boolean; prerelease?: PrereleaseKind },
+  opts: { version: string; dryRun?: boolean; cutCommit?: string; forceFreeze?: boolean; mainCut?: boolean; prerelease?: PrereleaseKind; publishAt?: string },
   deps: UnattendedReleaseDeps = {},
 ): Promise<{ input: ReleaseRunInput; dryRun: boolean; state?: GraphRunState }> {
   // RELEASE-BRANCH (10-06): the default cut is a release branch, so main keeps landing and the run no longer needs a
@@ -134,6 +136,11 @@ export async function runUnattendedRelease(
   }
   const version = resolveRunVersion(opts.version, opts.prerelease, deps);
   const input = buildReleaseRunInput(version, deps, opts.cutCommit);
+  if (opts.publishAt !== undefined) {
+    const invalid = publishAtError(opts.publishAt);
+    if (invalid) throw new Error(invalid);
+    input.publishAt = new Date(opts.publishAt).toISOString();
+  }
   if (opts.forceFreeze) input.forceFreeze = true;
   if (branchCut) input.branchCut = true;
   debug.log('release.run', 'input', { version, requested: opts.version, branchCut, prerelease: opts.prerelease ?? null, dryRun: opts.dryRun === true });

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

@@ -17,6 +17,7 @@ import { recordOutbound } from '../../src/domains/outbound-alert.js';
 import { listSelfDevRuns, runSummaryLine, selfDevRunsDir } from '../../src/self-dev/run-store.js';
 import { runDraftSweep } from '../../src/self-dev/draft-sweep.js';
 import { retroBriefingLines } from '../../src/retro/daily.js';
+import { dispatchCooAdmin } from '../../src/domains/coo-admin-tool.js';
 
 export type Section<T> = { status: 'ok'; value: T } | { status: 'unreadable'; reason: string };
 export type Landing = { title: string; seat: string; mergedAt: string; prNumber?: number };
@@ -348,6 +349,47 @@ function sendReview(file: string, text: string, target: { chatId: number; botTok
   finally { db.close(); }
 }
 
+function adminSection(markdown: string): string {
+  return markdown.split('## ⑧ 행정\n')[1]?.split('\n\n## ')[0]?.trim() ?? '측정 불가 · 행정 절 없음';
+}
+
+function adminMessage(markdown: string): string {
+  const text = adminSection(markdown);
+  if (text.length <= 1_800) return `## ⑧ 행정\n${text}`;
+  // Keep the full ordered read in the report. Reserve one dated link from each required
+  // category before spending the remaining transport budget on earlier deadlines.
+  const groups: { heading: string; items: string[] }[] = [];
+  for (const line of text.split('\n')) {
+    if (/^(?:지난 기한|14일 안 기한) \d+건$/.test(line) || line.startsWith('그 밖 · ')) {
+      groups.push({ heading: line, items: [] });
+    } else if (line.startsWith('- ') && groups.length) {
+      groups.at(-1)!.items.push(line);
+    } else if (line.startsWith('  https://') && groups.at(-1)?.items.length) {
+      const group = groups.at(-1)!;
+      group.items[group.items.length - 1] += `\n${line}`;
+    }
+  }
+  if (!groups.some(group => group.heading.startsWith('지난 기한 ')) || !groups.some(group => group.heading.startsWith('14일 안 기한 ')))
+    return `## ⑧ 행정\n${text.slice(0, 1_800)}\n… 전체 목록은 리뷰 파일 참조`;
+  const compact = (item: string) => item.replace(/^(- [^\n]*? · (?:Urgent|High|우선순위 [^ ·]+) · )([^\n]*?)( · 대표 손이 필요한 날 \d{4}-\d{2}-\d{2})?(\n  https:\/\/[^\n]+)$/, (_match, prefix: string, title: string, action: string | undefined, link: string) =>
+    `${prefix}${title.length > 90 ? `${title.slice(0, 89)}…` : title}${action ?? ''}${link}`);
+  const selected = groups.map(group => ({ heading: group.heading, items: group.items.length ? [compact(group.items[0]!)] : [] }));
+  const warning = text.startsWith('조회 상한 250건 ·') ? `${text.split('\n', 1)[0]}\n` : '';
+  const render = () => warning + selected.map(group => `${group.heading}\n${group.items.join('\n') || '없음'}`).join('\n');
+  const priorityOrder = [...groups.keys()].sort((a, b) =>
+    Number(!groups[a]!.heading.startsWith('14일 안 기한 ')) - Number(!groups[b]!.heading.startsWith('14일 안 기한 ')) || a - b);
+  for (const i of priorityOrder) {
+    const source = groups[i]!;
+    for (const item of source.items.slice(selected[i]!.items.length)) {
+      const next = compact(item);
+      if (render().length + next.length + 1 + '\n… 전체 목록은 리뷰 파일 참조'.length > 1_800) break;
+      selected[i]!.items.push(next);
+    }
+  }
+  const omitted = groups.some((group, i) => group.items.length > selected[i]!.items.length);
+  return `## ⑧ 행정\n${render()}${omitted ? '\n… 전체 목록은 리뷰 파일 참조' : ''}`;
+}
+
 function newsMessage(markdown: string): string | null {
   const section = markdown.split('## ⑦ 외부 동향\n')[1]?.split('\n\n## ')[0];
   if (!section || section.startsWith('못 읽음 ·')) return null;
@@ -366,6 +408,7 @@ function sendNewsAfterReview(delivery: DeliveryResult, file: string, markdown: s
 export type DailyDeps = { now?: () => Date; root?: string; vaultRoot?: string | null; sendEnabled?: boolean; repoRoot?: string; repoName?: string;
   landings?: (now: Date) => Promise<Landing[]>; release?: () => Promise<Release>; loops?: () => Promise<Loop[]>;
   grid?: () => Promise<Seat[]>; decisions?: () => Promise<Pending[]>; news?: () => Promise<News[]>;
+  cooAdmin?: (now: Date) => Promise<string>;
   target?: { chatId: number; botToken: string };
   send?: (request: DailySendRequest) => DailySendConfirmation | null; receipt?: (key: string) => DeliveryReceipt;
   recordDelivery?: (text: string, kind: 'ops-report') => void;
@@ -426,7 +469,7 @@ export async function runDaily(options: { dryRun?: boolean; noNews?: boolean; st
       catch (error) { sendError = `발송 설정 못 읽음 · ${shortReason(reasonOf(error))}`; deliveryState = 'unknown'; }
     }
     if (options.stage === 'deliver' && !options.dryRun && enabled) {
-      const text = `${header}\n\n## 위험 톱 5\n${riskBlock}${suggestionBlock ? `\n\n## PROACT1-LITE 제안\n${suggestionBlock}` : ''}\n\n${file}`;
+      const text = `${header}\n\n## 위험 톱 5\n${riskBlock}${suggestionBlock ? `\n\n## PROACT1-LITE 제안\n${suggestionBlock}` : ''}\n\n${adminMessage(markdown)}\n\n${file}`;
       chars = `${text}\n${receiptKey}`.length;
       let resolved: ReturnType<typeof recipient> = null;
       try { resolved = recipient(deps); }
@@ -468,6 +511,12 @@ export async function runDaily(options: { dryRun?: boolean; noNews?: boolean; st
     news: options.noNews ? unreadable('건너뜀 (--no-news)') : await safe(async () => cleanNews(await (deps.news ?? collectNews)())),
   };
   const review = composeDaily(parts, now);
+  const readAdmin = deps.cooAdmin ?? ((date: Date) => dispatchCooAdmin({}, { now: date, briefing: true }));
+  const admin = await safe(() => readAdmin(now));
+  const adminText = admin.status === 'unreadable' ? `측정 불가 · ${admin.reason}`
+    : admin.value.startsWith('Linear 키가 없습니다') || admin.value.startsWith('못 읽었습니다(')
+      ? `측정 불가 · ${shortReason(admin.value)}` : admin.value;
+  review.markdown += `\n## ⑧ 행정\n${adminText}\n`;
   const root = deps.root ?? effectiveInstanceRoot();
   const observed = await safe(async (): Promise<ProactSignals> => {
     if (deps.proactSignals) return deps.proactSignals();
@@ -553,7 +602,7 @@ export async function runDaily(options: { dryRun?: boolean; noNews?: boolean; st
   let chars = 0;
   let target = 'unknown';
   if (!options.dryRun && options.stage !== 'collect' && enabled) {
-    const text = `${review.header}\n\n## 위험 톱 5\n${review.risks.map((r, i) => `${i + 1}. ${r.name} — ${r.score}점 · ${r.reason}`).join('\n') || '확인된 위험 없음'}${recorded ? `\n\n## PROACT1-LITE 제안\n${recorded}` : ''}${retroBlock}\n\n${file}`;
+    const text = `${review.header}\n\n## 위험 톱 5\n${review.risks.map((r, i) => `${i + 1}. ${r.name} — ${r.score}점 · ${r.reason}`).join('\n') || '확인된 위험 없음'}${recorded ? `\n\n## PROACT1-LITE 제안\n${recorded}` : ''}${retroBlock}\n\n${adminMessage(review.markdown)}\n\n${file}`;
     chars = `${text}\n${receiptKey}`.length;
     let resolved: ReturnType<typeof recipient> = null;
     try { resolved = recipient(deps); }

package/scripts/rhythm/weekly.ts

@@ -135,7 +135,8 @@ function compose(parts: WeeklyParts, key: string, now: Date, versions: Section<s
     `# 주간 미팅 — ${key} (KST)`, header,
     section('landings', parts.landings, list => {
       const seats = [...new Set(list.map(i => i.seat))].sort(sortNames).map(s => `${s} ${list.filter(i => i.seat === s).length}`).join(' · ');
-      return `총 ${list.length}건 · 자리별 ${seats || '없음'}\n발행된 판: ${versions.status === 'ok' ? versions.value.join(', ') || '없음' : `못 읽음 · ${versions.reason}`}`;
+      const shown = list.slice(0, 10);
+      return `총 ${list.length}건 · 자리별 ${seats || '없음'}\n발행된 판: ${versions.status === 'ok' ? versions.value.join(', ') || '없음' : `못 읽음 · ${versions.reason}`}\n지난주 지표: 착지 ${list.length}건 · 발행 ${versions.status === 'ok' ? `${versions.value.length}판` : `못 읽음 · ${versions.reason}`}\n지난주 착지:\n${shown.map(i => `- ${i.title} (${i.seat} · ${i.mergedAt})`).join('\n') || '없음'}${list.length > shown.length ? `\n외 ${list.length - shown.length}건` : ''}`;
     }),
     section('release', parts.release, r => `${r.version}: green ${r.green}/${r.total} · 다음 판 ${r.nextVersion ?? '미정'} ${r.nextGreen ?? '못 읽음'}/${r.nextTotal ?? '못 읽음'} · 다음 컷 ${r.cutAt ?? '미정'}\nred 칸: ${r.red.map(i => i.name).join(', ') || '없음'}`),
     section('issues', parts.issues, list => list.map(i => `- ${i.id} ${i.title} · ${i.owner} · 기한 ${i.due}`).join('\n') || '열린 현안 없음'),
@@ -226,7 +227,7 @@ export async function runWeekly(options: { dryRun?: boolean; stage?: 'collect' |
     };
     const issues = await safe(async () => issueHistory(root));
     const parts: WeeklyParts = {
-      landings: await safe(() => deps.landings ? deps.landings(now, { from, to }) : collectLandings(now, { from, to }, { repoRoot: deps.repoRoot, repoName: deps.repoName })),
+      landings: await safe(() => deps.landings ? deps.landings(now, { from, to }) : collectLandings(now, { from, to }, { repoRoot: deps.repoRoot, repoName: deps.repoName, stateRoot: root })),
       release: await safe(deps.release ?? (() => collectWeeklyRelease(now, root))),
       issues: issues.status === 'ok' ? { status: 'ok', value: [...latest(issues.value).values()].filter(i => i.status === 'open') } : issues,
       followThrough: issues.status === 'ok' ? { status: 'ok', value: [...new Set([

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) {