elanous 0.2.22 → 0.2.24

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

@@ -11,6 +11,8 @@ 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';
+import { checkGateExecutorChoice, type GateExecutor } from './gate-executor.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');
@@ -38,8 +40,12 @@ export interface ReleaseRunInput extends ReleaseLoopConfig {
   version: string;
   previousVersion: string;
   cutCommit?: string;
-  gatePodPool: string;
+  /** Required for the pod executor (the default); a host-executor run may have none. */
+  gatePodPool?: string;
+  /** GATE-HOST-EXECUTOR — absent = pod (today's input, byte-identical); `host` sweeps on `gateRemote`. */
+  gateExecutor?: GateExecutor;
   forceFreeze?: boolean;
+  publishAt?: string;
   /** RELEASE-BRANCH: version-release cuts release/<v> from main HEAD and bumps only the branch. */
   branchCut?: boolean;
 }
@@ -102,22 +108,32 @@ export function releaseLoopConfig(configPath = getElanousConfigDirOverride() ? j
   return raw.release?.loop ?? {};
 }
 
-export function buildReleaseRunInput(version: string, deps: UnattendedReleaseDeps = {}, cutCommit?: string): ReleaseRunInput {
+/** GATE-HOST-EXECUTOR — the operator's explicit executor choice (`--gate-executor` / `--gate-host`); absent = pod. */
+export interface GateExecutorRequest { executor?: string; host?: string }
+
+export function buildReleaseRunInput(version: string, deps: UnattendedReleaseDeps = {}, cutCommit?: string, gate: GateExecutorRequest = {}): ReleaseRunInput {
   const config = deps.config ?? releaseLoopConfig(deps.configPath);
+  if (gate.executor === undefined && gate.host !== undefined) throw new Error('--gate-host requires --gate-executor host');
+  const choice = gate.executor === undefined ? undefined
+    : checkGateExecutorChoice(gate.executor, gate.executor === 'host' ? gate.host ?? config.gateRemote : gate.host);
   const pool = config.gatePodPool;
-  if (typeof pool !== 'string' || !pool.trim()) throw new Error('release.loop.gatePodPool is required before graph execution');
+  const hasPool = typeof pool === 'string' && !!pool.trim();
+  // The pod executor (the default) stays fail-closed on a missing pool; an explicit host executor does not need one.
+  if (choice?.executor !== 'host' && !hasPool) throw new Error('release.loop.gatePodPool is required before graph execution');
   const previousVersion = latestPublishedPreviousVersion(baseVersion(version), deps.ledgerRoot);
   return {
     ...config,
     version, previousVersion,
     ...(cutCommit !== undefined ? { cutCommit } : {}),
-    gatePodPool: pool.trim(),
+    ...(hasPool ? { gatePodPool: pool.trim() } : {}),
+    ...(choice ? { gateExecutor: choice.executor } : {}),
+    ...(choice?.host ? { gateRemote: choice.host } : {}),
   };
 }
 
 /** 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; gateExecutor?: string; gateHost?: 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
@@ -133,10 +149,16 @@ export async function runUnattendedRelease(
     }
   }
   const version = resolveRunVersion(opts.version, opts.prerelease, deps);
-  const input = buildReleaseRunInput(version, deps, opts.cutCommit);
+  const input = buildReleaseRunInput(version, deps, opts.cutCommit, { executor: opts.gateExecutor, host: opts.gateHost });
+  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 });
+  debug.log('release.run', 'input', { version, requested: opts.version, branchCut, prerelease: opts.prerelease ?? null, dryRun: opts.dryRun === true,
+    ...(input.gateExecutor ? { gateExecutor: input.gateExecutor, gateHost: input.gateExecutor === 'host' ? input.gateRemote ?? null : null } : {}) });
   if (opts.dryRun) return { input, dryRun: true };
   if (opts.prerelease) {
     // A rehearsal neither judges nor carries the stable version's checklist cells.

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/tsc-baseline-cache.ts

@@ -0,0 +1,147 @@
+/**
+ * 승격 착지의 base 쪽 tsc 진단을 «main 커밋별로 한 번만» 재고 재사용하는 캐시.
+ * 키 = base sha ⊕ tsc 명령 ⊕ 설정 파일(base 커밋에서 git show 로 읽은 내용) 해시 ⊕ tsc 판.
+ * 값 = rebase 전 정규화 진단(워크트리 절대 경로는 «<ROOT>» 자리표로 저장).
+ * ⛔ 캐시 실패는 호출자에게 던지지 않는다 — 읽기·쓰기 모두 miss 로 떨어진다.
+ */
+import { createHash, randomBytes } from 'node:crypto';
+import { execFileSync } from 'node:child_process';
+import { existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statSync, utimesSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { elanousStateRoot } from '../src/autopilot/state-paths.js';
+import type { TypecheckError } from '../src/typecheck-ratchet.js';
+
+export const ROOT_PLACEHOLDER = '<ROOT>';
+export const BASELINE_CACHE_MAX_ENTRIES = 50;
+const CACHE_FORMAT = 1;
+
+/** 키에 들어가는 «기준 커밋의 설정 파일» — 이 중 하나라도 달라지면 같은 sha 라도 다른 진단이다. */
+export const BASELINE_CACHE_CONFIG_FILES = ['tsconfig.gate.json', 'apps/pwa/tsconfig.json', 'tsconfig.pwa-env.json', 'tsconfig.json', 'bun.lock'] as const;
+
+export interface BaselineCacheOptions {
+  /** 캐시 디렉터리. 생략하면 `<상태 디렉터리>/cache/tsc-baseline`. */
+  dir?: string;
+  env?: NodeJS.ProcessEnv;
+  /** git 실행 심 — 출력 바이트를 돌려주고 실패하면 던진다. */
+  git?: (args: string[], cwd: string) => Buffer;
+  /** tsc 판 조회 심. */
+  tscVersion?: (cwd: string) => string;
+  maxEntries?: number;
+}
+
+export type BaselineCacheLookup =
+  | { result: 'hit'; diagnostics: TypecheckError[] }
+  | { result: 'miss' }
+  | { result: 'corrupt' };
+
+export function baselineCacheEnabled(env: NodeJS.ProcessEnv = process.env): boolean {
+  return env.TSC_BASELINE_CACHE?.trim() !== '0';
+}
+
+export function defaultBaselineCacheDir(): string {
+  return join(elanousStateRoot(), 'cache', 'tsc-baseline');
+}
+
+function defaultGit(args: string[], cwd: string): Buffer {
+  const env = { ...process.env };
+  delete env.GIT_DIR;
+  delete env.GIT_WORK_TREE;
+  delete env.GIT_COMMON_DIR;
+  return execFileSync('git', args, { cwd, env, stdio: ['ignore', 'pipe', 'pipe'], maxBuffer: 64 * 1024 * 1024 });
+}
+
+function defaultTscVersion(cwd: string): string {
+  try {
+    const parsed = JSON.parse(readFileSync(join(cwd, 'node_modules', 'typescript', 'package.json'), 'utf8')) as { version?: unknown };
+    return typeof parsed.version === 'string' ? parsed.version : 'unknown';
+  } catch {
+    return 'unknown';
+  }
+}
+
+/** 키를 못 만들면(base 를 sha 로 풀 수 없음 등) undefined — 호출자는 캐시 없이 잰다. */
+export function computeBaselineCacheKey(base: string, command: string, cwd: string, options: BaselineCacheOptions = {}): string | undefined {
+  try {
+    const git = options.git ?? defaultGit;
+    const sha = git(['rev-parse', '--verify', `${base}^{commit}`], cwd).toString('utf8').trim();
+    if (!/^[0-9a-f]{40,64}$/.test(sha)) return undefined;
+    const files: Record<string, string> = {};
+    for (const file of BASELINE_CACHE_CONFIG_FILES) {
+      try {
+        files[file] = createHash('sha256').update(git(['show', `${sha}:${file}`], cwd)).digest('hex');
+      } catch {
+        files[file] = 'absent';
+      }
+    }
+    const tsc = (options.tscVersion ?? defaultTscVersion)(cwd);
+    return createHash('sha256').update(JSON.stringify({ format: CACHE_FORMAT, sha, command, files, tsc })).digest('hex');
+  } catch {
+    return undefined;
+  }
+}
+
+function worktreeRoots(worktree: string): string[] {
+  const real = (() => { try { return realpathSync(worktree); } catch { return worktree; } })();
+  return [...new Set([worktree, real])].sort((left, right) => right.length - left.length);
+}
+
+/** rebase 전 진단의 워크트리 절대 경로를 «<ROOT>» 로 바꾼다(긴 경로 먼저). */
+export function toPlaceholderPaths(diagnostics: readonly TypecheckError[], worktree: string): TypecheckError[] {
+  const roots = worktreeRoots(worktree);
+  const swap = (text: string): string => roots.reduce((acc, root) => acc.split(root).join(ROOT_PLACEHOLDER), text);
+  return diagnostics.map((diagnostic) => ({ ...diagnostic, line: swap(diagnostic.line), file: swap(diagnostic.file) }));
+}
+
+function entryFile(dir: string, key: string): string {
+  return join(dir, `${key}.json`);
+}
+
+function isStoredDiagnostic(value: unknown): value is TypecheckError {
+  if (!value || typeof value !== 'object') return false;
+  const entry = value as Record<string, unknown>;
+  return typeof entry.file === 'string' && typeof entry.line === 'string' && (entry.code === undefined || typeof entry.code === 'string');
+}
+
+export function lookupBaselineCache(key: string, options: BaselineCacheOptions = {}): BaselineCacheLookup {
+  try {
+    const file = entryFile(options.dir ?? defaultBaselineCacheDir(), key);
+    if (!existsSync(file)) return { result: 'miss' };
+    const parsed = JSON.parse(readFileSync(file, 'utf8')) as { format?: unknown; key?: unknown; diagnostics?: unknown };
+    if (parsed.format !== CACHE_FORMAT || parsed.key !== key || !Array.isArray(parsed.diagnostics) || !parsed.diagnostics.every(isStoredDiagnostic)) {
+      return { result: 'corrupt' };
+    }
+    try { const now = new Date(); utimesSync(file, now, now); } catch { /* 보존 순서 갱신 실패는 무해하다 */ }
+    return { result: 'hit', diagnostics: parsed.diagnostics };
+  } catch {
+    return { result: 'corrupt' };
+  }
+}
+
+function pruneBaselineCache(dir: string, keep: number): void {
+  const entries = readdirSync(dir)
+    .filter((name) => name.endsWith('.json'))
+    .map((name) => ({ name, mtimeMs: statSync(join(dir, name)).mtimeMs }))
+    .sort((left, right) => right.mtimeMs - left.mtimeMs || left.name.localeCompare(right.name));
+  for (const stale of entries.slice(keep)) rmSync(join(dir, stale.name), { force: true });
+}
+
+/** `<ROOT>` 자리표가 든 진단을 원자 쓰기(임시→rename)로 저장한다. 성공 여부만 돌려주고 던지지 않는다. */
+export function storeBaselineCache(key: string, command: string, diagnostics: readonly TypecheckError[], options: BaselineCacheOptions = {}): boolean {
+  try {
+    const dir = options.dir ?? defaultBaselineCacheDir();
+    mkdirSync(dir, { recursive: true });
+    const file = entryFile(dir, key);
+    const temporary = `${file}.${process.pid}.${randomBytes(4).toString('hex')}.tmp`;
+    try {
+      writeFileSync(temporary, JSON.stringify({ format: CACHE_FORMAT, key, command, storedAt: new Date().toISOString(), diagnostics }));
+      renameSync(temporary, file);
+    } catch (error) {
+      rmSync(temporary, { force: true });
+      throw error;
+    }
+    try { pruneBaselineCache(dir, options.maxEntries ?? BASELINE_CACHE_MAX_ENTRIES); } catch { /* 정리 실패는 저장 성공을 뒤집지 않는다 */ }
+    return true;
+  } catch {
+    return false;
+  }
+}

package/scripts/tsc-main-safety-net.ts

@@ -0,0 +1,189 @@
+import { spawnSync } from 'node:child_process';
+import { appendFileSync, existsSync, mkdirSync, readFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { debug } from '../src/debug/log.js';
+import { effectiveInstanceRoot } from '../src/instance/resolve.js';
+import { GATE_REMOTE_DEFAULTS, isValidGateHost, resolveGateRemoteSettings, runOnRemote, type ExecResult, type RemoteRunOptions, type RemoteRunOutcome } from '../src/self-implement/gate-remote.js';
+import { getUserConfig } from '../src/user-config.js';
+import { parseTypecheckErrors, tscEnv } from '../src/typecheck-ratchet.js';
+import { compareDiagnostics, normalizeDiagnostics, type NormalizedDiagnostic } from './tsc-baseline-comparison.js';
+
+const TSC_ARGV = ['bunx', 'tsc', '--noEmit', '-p', 'tsconfig.gate.json', '--incremental', 'false'];
+const COMMIT = /^[0-9a-f]{40}$/i;
+const UNMEASURABLE = /\berror TS(?:2688|5083|6053):/;
+
+export interface SafetyNetEntry {
+  at: string;
+  commit: string;
+  outcome: 'clean' | 'added' | 'unmeasured' | 'baseline';
+  total: number;
+  added: NormalizedDiagnostic[];
+  removed: number;
+  ms: number;
+  host: string;
+  /** Full measured snapshot: `added` alone cannot serve as the next day's baseline. */
+  diagnostics?: NormalizedDiagnostic[];
+}
+
+export interface SafetyNetDeps {
+  local?: (cmd: string, args: string[], cwd: string, options?: { env?: NodeJS.ProcessEnv }) => ExecResult;
+  remote?: (options: RemoteRunOptions) => RemoteRunOutcome;
+  compare?: typeof compareDiagnostics;
+  exists?: (path: string) => boolean;
+  instanceRoot?: () => string;
+  settings?: () => ReturnType<typeof resolveGateRemoteSettings>;
+  now?: () => number;
+  observed?: (entry: { commit: string; outcome: SafetyNetEntry['outcome']; total: number; added: number; removed: number; ms: number; host: string }) => void;
+}
+
+const realLocal: NonNullable<SafetyNetDeps['local']> = (cmd, args, cwd, options) => {
+  const result = spawnSync(cmd, args, { cwd, encoding: 'utf8', maxBuffer: 64 * 1024 * 1024, ...(options?.env ? { env: options.env } : {}) });
+  return { rc: result.status, stdout: result.stdout ?? '', stderr: result.stderr ?? '', ...(result.error ? { error: String(result.error) } : {}) };
+};
+
+function flags(argv: readonly string[]): { local: boolean; host?: string; ledger?: string; json: boolean } {
+  let local = false;
+  let host: string | undefined;
+  let ledger: string | undefined;
+  let json = false;
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === '--local') local = true;
+    else if (arg === '--json') json = true;
+    else if (arg === '--remote' || arg === '--ledger') {
+      const value = argv[++i];
+      if (!value || value.startsWith('--')) throw new Error(`${arg} requires a value`);
+      if (arg === '--remote') host = value;
+      else ledger = value;
+    } else throw new Error(`unknown argument: ${arg}`);
+  }
+  if (local && host) throw new Error('--local and --remote cannot be combined');
+  if (host && !isValidGateHost(host)) throw new Error(`invalid --remote host: ${host}`);
+  return { local, host, ledger, json };
+}
+
+function measuredSnapshot(path: string): NormalizedDiagnostic[] | undefined {
+  if (!existsSync(path)) return undefined;
+  const rows = readFileSync(path, 'utf8').trim().split('\n').filter(Boolean);
+  for (let i = rows.length - 1; i >= 0; i--) {
+    const entry = JSON.parse(rows[i]!) as SafetyNetEntry;
+    if (entry.outcome === 'unmeasured') continue;
+    if (!Array.isArray(entry.diagnostics) || !entry.diagnostics.every((d) => d && typeof d.file === 'string' && typeof d.code === 'string' && typeof d.message === 'string')) {
+      throw new Error('last measured ledger entry has no valid diagnostic snapshot');
+    }
+    return entry.diagnostics;
+  }
+  return undefined;
+}
+
+function diagnosticsOf(result: { rc: number | null; stdout: string; stderr: string; error?: string }, root: string): NormalizedDiagnostic[] | undefined {
+  const output = `${result.stdout}\n${result.stderr}`;
+  if (result.error || result.rc === null || (result.rc !== 0 && result.rc !== 1 && result.rc !== 2) || UNMEASURABLE.test(output)
+    || /heap out of memory|Ineffective mark-compacts near heap limit/i.test(output)) return undefined;
+  const parsed = parseTypecheckErrors(output);
+  const errorLines = output.split(/\r?\n/).filter((line) => /\berror TS\d+:/.test(line));
+  if (parsed.length !== errorLines.length || (result.rc === 0 && errorLines.length > 0) || (result.rc !== 0 && parsed.length === 0)) return undefined;
+  if (output.split(/\r?\n/).some((line) => line.trim() && !/^.+\(\d+,\d+\):\s+error\s+TS\d+:/.test(line) && !/^\s+/.test(line)
+    && !/^Found \d+ errors?\.?$/.test(line))) return undefined;
+  return normalizeDiagnostics(parsed, root);
+}
+
+export async function runSafetyNet(repo: string, argv: readonly string[] = [], deps: SafetyNetDeps = {}): Promise<{ exitCode: number; entry: SafetyNetEntry; json: boolean }> {
+  const input = flags(argv);
+  const run = deps.local ?? realLocal;
+  const remote = deps.remote ?? runOnRemote;
+  const exists = deps.exists ?? existsSync;
+  const root = deps.instanceRoot?.() ?? effectiveInstanceRoot();
+  const settings = deps.settings?.() ?? (input.local ? GATE_REMOTE_DEFAULTS : resolveGateRemoteSettings(getUserConfig().gateRemote));
+  const host = input.local ? 'local' : (input.host ?? settings.host ?? GATE_REMOTE_DEFAULTS.host);
+  if (host !== 'local' && !isValidGateHost(host)) throw new Error(`invalid gateRemote host: ${host}`);
+  const ledger = resolve(input.ledger ?? join(root, 'tsc-safety-net', 'ledger.jsonl'));
+  const worktree = join(root, 'tsc-safety-net', 'worktree');
+  const started = (deps.now ?? Date.now)();
+  let commit = '';
+  let diagnostics: NormalizedDiagnostic[] | undefined;
+  let reason: string | undefined;
+  let dependencyFailed = false;
+  const git = (args: string[], cwd: string): ExecResult => {
+    const env = { ...process.env };
+    delete env.GIT_DIR; delete env.GIT_WORK_TREE; delete env.GIT_COMMON_DIR;
+    return run('git', args, cwd, { env });
+  };
+  const checked = (args: string[], cwd: string): ExecResult => {
+    const result = git(args, cwd);
+    if (result.error || result.rc !== 0) throw new Error(`git ${args.join(' ')}: ${result.error ?? result.stderr ?? `rc=${result.rc}`}`);
+    return result;
+  };
+  try {
+    checked(['fetch', 'origin', '+refs/heads/main:refs/remotes/origin/main'], repo);
+    commit = checked(['rev-parse', '--verify', 'origin/main^{commit}'], repo).stdout.trim();
+    if (!COMMIT.test(commit)) throw new Error('origin/main did not resolve to a commit');
+    if (!exists(worktree)) {
+      mkdirSync(dirname(worktree), { recursive: true });
+      checked(['worktree', 'add', '--detach', worktree, commit], repo);
+    } else {
+      const listed = checked(['worktree', 'list', '--porcelain'], repo).stdout;
+      if (!listed.split('\n').some((line) => line === `worktree ${worktree}`)) throw new Error('worktree path is not a registered git worktree');
+    }
+    const status = checked(['status', '--porcelain'], worktree).stdout;
+    if (status.trim()) checked(['reset', '--hard'], worktree);
+    // Porcelain status omits ignored files, including stale .ts files from a previous measurement.
+    checked(['clean', '-fdx', '-e', 'node_modules'], worktree);
+    checked(['checkout', '--detach', 'origin/main'], worktree);
+    if (checked(['rev-parse', 'HEAD'], worktree).stdout.trim() !== commit || checked(['status', '--porcelain'], worktree).stdout.trim()) throw new Error('worktree is not clean at origin/main');
+    if (input.local) {
+      // The retained node_modules may belong to yesterday's lockfile; frozen install reconciles it to this checkout.
+      dependencyFailed = true;
+      const install = run('bun', ['install', '--frozen-lockfile'], worktree);
+      if (install.rc !== 0 || install.error || !exists(join(worktree, 'node_modules'))) {
+        throw new Error(`local dependencies unavailable: ${install.error ?? install.stderr ?? `rc=${install.rc}`}`);
+      }
+      dependencyFailed = false;
+      const result = run(TSC_ARGV[0]!, TSC_ARGV.slice(1), worktree, { env: tscEnv() });
+      diagnostics = diagnosticsOf(result, worktree);
+      if (!diagnostics) reason = 'local tsc did not produce a complete measurement';
+    } else {
+      const result = remote({ repo: worktree, host, mirror: settings.mirror, hostCap: settings.hostCap, argv: TSC_ARGV });
+      if (result.kind === 'ran') {
+        if (result.commit !== commit) throw new Error('remote measured a different commit');
+        diagnostics = diagnosticsOf({ rc: result.rc, stdout: result.stdout.toString('utf8'), stderr: result.stderr.toString('utf8') }, worktree);
+        if (!diagnostics) reason = 'remote tsc did not produce a complete measurement';
+      } else reason = result.kind === 'busy' ? 'remote busy' : `remote infra: ${result.reason}`;
+    }
+  } catch (error) {
+    reason = error instanceof Error ? error.message : String(error);
+  }
+  let previous: NormalizedDiagnostic[] | undefined;
+  try { previous = measuredSnapshot(ledger); }
+  catch (error) { diagnostics = undefined; reason = `ledger unreadable: ${error instanceof Error ? error.message : String(error)}`; }
+  const comparison = diagnostics && previous ? (deps.compare ?? compareDiagnostics)(diagnostics, previous) : undefined;
+  if (comparison?.kind === 'unavailable') reason = `comparison unavailable: ${comparison.reason}`;
+  const outcome: SafetyNetEntry['outcome'] = !diagnostics || comparison?.kind === 'unavailable'
+    ? 'unmeasured' : !previous ? 'baseline' : comparison?.kind === 'added' ? 'added' : 'clean';
+  const entry: SafetyNetEntry = {
+    at: new Date((deps.now ?? Date.now)()).toISOString(), commit, outcome, total: diagnostics?.length ?? 0,
+    added: comparison && comparison.kind !== 'unavailable' ? comparison.added : [],
+    removed: comparison && comparison.kind !== 'unavailable' ? comparison.removed.length : 0,
+    ms: (deps.now ?? Date.now)() - started, host,
+    ...(outcome !== 'unmeasured' && diagnostics ? { diagnostics } : {}),
+  };
+  if (!dependencyFailed) {
+    mkdirSync(dirname(ledger), { recursive: true });
+    appendFileSync(ledger, `${JSON.stringify(entry)}\n`);
+  }
+  const observation = { commit, outcome, total: entry.total, added: entry.added.length, removed: entry.removed, ms: entry.ms, host };
+  (deps.observed ?? ((data) => debug.log('tsc.safety-net', 'run', data)))(observation);
+  if (reason) console.error(`[tsc.safety-net] ${reason}`);
+  return { exitCode: outcome === 'unmeasured' ? 2 : outcome === 'added' ? 1 : 0, entry, json: input.json };
+}
+
+if (import.meta.main) {
+  try {
+    const result = await runSafetyNet(process.cwd(), process.argv.slice(2));
+    console.log(result.json ? JSON.stringify(result.entry) : `[tsc.safety-net] ${result.entry.outcome} commit=${result.entry.commit} total=${result.entry.total} added=${result.entry.added.length} removed=${result.entry.removed} host=${result.entry.host}`);
+    process.exitCode = result.exitCode;
+  } catch (error) {
+    console.error(`[tsc.safety-net] unmeasured: ${error instanceof Error ? error.message : String(error)}`);
+    process.exitCode = 2;
+  }
+}