elanous 0.2.28 → 0.2.31

package/scripts/coord-role-pack.ts

@@ -0,0 +1,222 @@
+#!/usr/bin/env bun
+import { createHash } from 'node:crypto';
+import { existsSync, readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { KnowhowLintError, lintKnowhow } from '../src/seat-loop/knowhow-lint.js';
+
+export type RolePackRole = 'coordinator' | 'guardian';
+
+export interface RolePack {
+  role: RolePackRole;
+  version: string;
+  sha256: string;
+  body: string;
+  /** Built-in C/G rule identifiers; verified KNOWHOW identifiers appear in the body. */
+  includedCardIds: string[];
+  excludedCardIds: string[];
+  sources: Array<{ path: string; sha256: string }>;
+  /** Source docs absent from this root, e.g. the published package ships no internal docs. */
+  missingSources: string[];
+}
+
+const KNOWHOW_PATH = 'docs/roles/OP/KNOWHOW.md';
+
+/**
+ * KNOWHOW.md 를 `##` 제목 단위 카드로 자른다(코드 울타리 안은 본문으로 본다).
+ * 유효한 `## K-<role>-<number>` 제목을 가진 카드만 반환한다.
+ */
+export function splitKnowhowCards(body: string): Array<{ id: string; title: string; text: string }> {
+  const segments: Array<{ heading: string | null; lines: string[] }> = [{ heading: null, lines: [] }];
+  let fence: { marker: string; length: number } | null = null;
+  for (const line of body.split(/\r?\n/u)) {
+    const fenceLine = line.match(/^ {0,3}(`{3,}|~{3,})(.*)$/u);
+    if (fence) {
+      if (fenceLine && fenceLine[1]![0] === fence.marker && fenceLine[1]!.length >= fence.length && /^[ \t]*$/u.test(fenceLine[2]!)) fence = null;
+      segments.at(-1)!.lines.push(line);
+      continue;
+    }
+    if (fenceLine) {
+      fence = { marker: fenceLine[1]![0]!, length: fenceLine[1]!.length };
+      segments.at(-1)!.lines.push(line);
+      continue;
+    }
+    if (/^##\s/u.test(line)) {
+      segments.push({ heading: line, lines: [] });
+      continue;
+    }
+    segments.at(-1)!.lines.push(line);
+  }
+  const cards: Array<{ id: string; title: string; text: string }> = [];
+  for (const segment of segments) {
+    if (!segment.heading) continue;
+    const heading = segment.heading.match(/^##\s+(K-[A-Za-z]+-\d+)\s*(.*)$/u);
+    if (!heading) continue;
+    cards.push({ id: heading[1]!, title: heading[2]!.trim(), text: [segment.heading, ...segment.lines].join('\n') });
+  }
+  return cards;
+}
+
+/**
+ * KNOWHOW 카드 중 src/seat-loop/knowhow-lint.ts 의 린트를 통과한 항목만 검증된 출처로 싣는다.
+ * 실패 항목(비밀값 포함)은 제외하고 그 아이디만 남긴다. 파일이 없으면 아무것도 싣지 않는다.
+ */
+export function collectVerifiedKnowhow(repo: string): {
+  included: Array<{ id: string; title: string; text: string }>;
+  excluded: string[];
+  fileBody: string | null;
+} {
+  let body: string;
+  try {
+    body = readFileSync(resolve(repo, KNOWHOW_PATH), 'utf8');
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT') return { included: [], excluded: [], fileBody: null };
+    throw error;
+  }
+  const included: Array<{ id: string; title: string; text: string }> = [];
+  const excluded: string[] = [];
+  for (const card of splitKnowhowCards(body)) {
+    try {
+      lintKnowhow(card.text, KNOWHOW_PATH);
+      included.push({ id: card.id, title: card.title, text: card.text });
+    } catch (error) {
+      if (error instanceof KnowhowLintError) {
+        excluded.push(card.id);
+        continue;
+      }
+      throw error;
+    }
+  }
+  return { included, excluded, fileBody: body };
+}
+
+const SOURCE_PATHS = [
+  'AGENTS.md',
+  'docs/roles/OP.md',
+  'docs/handbook/LOOP-AGENTS.md',
+  'docs/handbook/OPERATIONS.md',
+  'scripts/coord-role-pack.ts',
+] as const;
+
+// OP's 2026-10-14 verified C/G harvest. These are guidance, never an L0 grant.
+// Moving thresholds, dates, paths, and host capacity must be checked in live state.
+const COORDINATOR_CARDS = [
+  ['C1', '기둥 우선순위는 루프 에이전트(L1) > 그래프 엔지니어링(L2) > TUI > 마찰 없는 SETUP > 받침 > 바닥으로 제안한다.'],
+  ['C2', '조율자·수호자·과제 담당 칸의 조기 전력화를 우선한다. M4 전 배치는 현 판 일정과 대표 결정을 다시 확인한다.'],
+  ['C3', '가속 칸은 루브릭 점수가 낮아도 앞 판 후보가 된다. 승인된 점수 밖 이동은 근거에 배치 덮어씀과 결정 출처를 남긴다.'],
+  ['C4', '판 용량은 고정값으로 보지 않는다. 착지 속도를 재고 뒤 판을 당길지 제안한다.'],
+  ['C5', '판과 발행 날짜의 대응은 현 일정 정본에서 확인한다. 과거 날짜 공식만으로 이동을 결정하지 않는다.'],
+  ['C6', '선행 칸의 판은 후행 칸보다 늦지 않게 제안한다. 컷 중인 판과 도는 런 칸은 옮기기 전 상태를 다시 확인한다.'],
+  ['C7', '일반 리뷰는 2라운드째 전제·요구·분할을 적고, 3라운드에 must-fix가 남거나 같은 지적이 2회면 쪼개기·부분 착지·연결골로 트리아지한다.'],
+  ['C8', '조각 착지 뒤에는 착지한 범위로 원 칸을 다시 이름 붙여 green을 제안하고, 잔여는 원 칸 선행과 남은 조각 근거를 가진 새 yellow 칸에 둔다.'],
+  ['C9', '서로 기다리는 PR은 통합 착지 또는 무해한 독립 조각의 순차 착지를 제안한다. 미설정이면 몸이 0인지를 계약으로 확인한다.'],
+  ['C10', 'TA 칸 첫 줄 대상 경로는 origin/main에 실제 있는 저장소 상대 파일로 확인한다. 신설 파일은 별도 신설 줄에 둔다.'],
+  ['C11', '관측·A/B 운영만 하는 칸은 구현 대상 경로를 억지로 넣지 말고 명시적 hold와 판정 근거를 제안한다.'],
+  ['C12', '여러 실패의 공용 원인이 확인되면 수리 칸을 컷 판의 P0·가속 후보로 제안하고, 영향 칸은 사유 있는 hold 뒤 수리 반영을 확인해 재발사를 제안한다.'],
+  ['C13', '최우선은 순서의 맨 앞이라는 뜻이다. 다른 일을 멈추는 조정은 자원이 실제로 부딪칠 때만 제안한다.'],
+  ['C14', '대표가 지정한 관심 태스크는 일반 리뷰 트리아지 상한 밖에서 지적 지점만 최소 수리하며 착지까지 추적한다. 막히면 다른 자리를 붙이도록 제안하고 추적 간격은 현재 지시를 확인한다.'],
+] as const;
+
+const GUARDIAN_CARDS = [
+  ['G1', '착지와 TA 발사의 부하선은 서로 다를 수 있다. 현재 설정과 1분·5분 추세를 함께 재고 대기 루프에서 다시 판정한다.'],
+  ['G2', 'mbp의 무거운 타입검사·게이트·리뷰·빌드는 승인된 원격 호스트에 배치한다. worktree 전수 검색을 피하고 무거운 로그 조회는 자리당 동시 1로 제한한다.'],
+  ['G3', 'node-b의 착지·TUI 전용 슬롯과 일반 게이트 호스트의 현재 임대를 확인한다. 말로만 예약하지 말고 토큰·잠금으로 충돌을 막도록 제안한다.'],
+  ['G4', 'TA 부모와 Pod의 원격 배치, 호스트별 상한, 자리별 주기 한도는 현재 설정과 런 상태로 확인한다.'],
+  ['G5', '착지 슬롯은 전역으로 세고 OP 착지는 한 번에 하나씩 제안한다. 실행기 종료 뒤 고아 표지는 현 슬롯 원장에서 대조한다.'],
+  ['G6', 'heavy-remote의 gate-host-busy는 착지 실패로 단정하지 말고 현재 실행기 규약의 대기·재시도 경로로 보낸다. mbp 로컬 폴백은 제안하지 않는다.'],
+  ['G7', 'macOS 정기 작업의 gh 인증 실패는 keyring 접근 여부를 확인한다. 측정 실패는 못 잼과 종료 코드를 남기고 로그인 세션 루프를 제안한다.'],
+  ['G8', '시험이 운영 상태에 쓴 흔적은 우주 격리 결함으로 기록한다. 격리 수리와 운영 흔적 확인 뒤에만 청소를 제안한다.'],
+  ['G9', '운영 설정 변경은 사전 백업과 사후 diff를 요구한다. 문자열 SHA의 JSON 인용을 확인하고 비밀값은 출력하지 않는다.'],
+  ['G10', '같은 날 shadow→live 전환과 루프 상태 파일이 어긋나면 틱 실패를 의심한다. 임시 복구와 mode별 상태 분리 수리를 구별한다.'],
+  ['G11', '상주 감시는 세션 밖에서 돌리고 Monitor 만료 시 재무장과 심장박동을 확인한다.'],
+  ['G12', 'smbd·Finder의 지속 CPU 점유는 mbp 기저 부하 후보로 관측하고, 본부 이전 전 재측정할 항목으로 남긴다.'],
+] as const;
+
+function sha256(body: string): string {
+  return createHash('sha256').update(body).digest('hex');
+}
+
+/** Deterministic, read-only L0 role pack. Knowledge cards require a separate verified source. */
+export function buildCoordRolePackManifest(role: RolePackRole, root = resolve(import.meta.dir, '..')): RolePack {
+  const repo = resolve(root);
+  // The pack body is inline. Source docs only contribute hashes, so an installed package without them still builds.
+  const present = SOURCE_PATHS.filter((path) => existsSync(resolve(repo, path)));
+  const missingSources = SOURCE_PATHS.filter((path) => !present.includes(path));
+  const sources = present.map((path) => ({ path, sha256: sha256(readFileSync(resolve(repo, path), 'utf8')) }));
+  const knowhow = collectVerifiedKnowhow(repo);
+  if (knowhow.fileBody !== null) sources.push({ path: KNOWHOW_PATH, sha256: sha256(knowhow.fileBody) });
+  const packageJson = resolve(repo, 'package.json');
+  const version = existsSync(packageJson)
+    ? (JSON.parse(readFileSync(packageJson, 'utf8')) as { version: string }).version : 'unknown';
+  const roleText = role === 'coordinator'
+    ? [
+        '## 역할: 조율자',
+        '- 전체 칸과 자리의 관측을 모아 우선순위·분배·보류를 제안한다. 칸의 실제 판정은 담당 자리의 근거와 대조한다.',
+        '- 질문에 답하기 전에 메시지, 확인표, 과제 카드, 로그를 읽는다. 못 읽은 값은 측정 불가로 밝힌다.',
+        '- 세 번 실패하거나 새 경계가 반복되면 전제·요구·분할을 먼저 적는다. 핵심은 칸 판정에 필요한 것, 확장은 나머지다.',
+        '- 막힌 칸 하나가 착지 줄 전체를 멈추게 하지 않는다. 다음 준비 완료 칸을 본다.',
+      ]
+    : [
+        '## 역할: 수호자',
+        '- 전체 자원·호스트·임대·계정·과금·무결성을 관측하고 입장 또는 대기를 제안한다.',
+        '- 부하는 1분·5분 추세를 함께 보고, 한 번의 스파이크만으로 창을 닫지 않는다.',
+        '- 무거운 게이트는 원격 호스트에서 한 번만 실행한다. host slot busy는 실행 전 거부이며 그동안 가벼운 검토를 먼저 한다.',
+        '- 실제 공급자 크레딧과 경유 공급자의 비용을 구별하고, 비밀값은 출력하지 않는다.',
+      ];
+  const cards = role === 'coordinator' ? COORDINATOR_CARDS : GUARDIAN_CARDS;
+  const lines = [
+    '# 금지 목록',
+    '- 돈·보안 설정·자격·계정·외부 공개·되돌릴 수 없는 일은 사람 승인 없이 실행하지 않는다.',
+    '- L0에서는 우편 답글 제안만 한다. 칸 변경·잠금·착지·코드 쓰기는 하지 않는다.',
+    '- `pr land` 거부를 우회하거나 `gh pr merge`·force push·rebase를 실행하지 않는다.',
+    '- 자격 파일·토큰 원문을 읽거나 메시지·로그·팩에 싣지 않는다.',
+    '- 관측 실패를 성공 또는 0건으로 바꾸지 않는다.',
+    '',
+    `# ${role} 역할 팩`,
+    `판: ${version}`,
+    '출처: AGENTS.md 요지 · docs/roles/OP.md §1~2 · docs/handbook/LOOP-AGENTS.md §0,§5,§10 · docs/handbook/OPERATIONS.md §2~5 · scripts/coord-role-pack.ts 운영 지식 v1',
+    '권한과 현재 값은 코드·설정·운영 원장으로 다시 확인한다. 이 팩은 권한을 부여하지 않는다.',
+    '',
+    ...roleText,
+    '',
+    '## 검증된 운영 지식 v1',
+    '각 줄은 판단 제안이며 현재 값·권한은 운영 원장과 설정에서 다시 확인한다.',
+    '재는 명령: `eln release checklist status --version <판> --json`(칸·선행·판) · `eln config get harness.podPool`(Pod 풀) · `uptime`(부하 추세) · `eln self gate --help`(호스트·게이트 옵션). 명령이 못 재는 슬롯·런 상태는 담당 원장의 현행 명령을 확인한다.',
+    ...cards.map(([id, rule]) => `- ${id} · ${rule} → 팩 ${role === 'coordinator' ? '조율자' : '수호자'} v1`),
+    '',
+    '## KNOWHOW — 검증된 출처',
+    `docs/roles/OP/KNOWHOW.md 항목 중 src/seat-loop/knowhow-lint.ts 의 린트를 통과한 항목만 싣는다. 실패 항목·비밀값은 제외한다.`,
+    ...knowhow.included.map((card) => `- ${card.id} · ${card.title}`),
+    ...knowhow.included.flatMap((card) => ['', card.text]),
+    '',
+    '## 판단 순서',
+    '1. 원 요청과 지금의 우편 스레드·확인표 칸을 대조한다.',
+    '2. 코드·설정·실행 결과를 읽고, 문서와 충돌하면 현재 실행 결과를 따른다.',
+    '3. 관측·판단 근거·다음 행동을 분리해 답한다. 쓰기는 현재 확인 단계가 허용한 명령으로만 한다.',
+    '4. 근거가 없거나 안전 난간과 충돌하면 보류하고 담당 자리 또는 사람에게 올린다.',
+    '',
+    '위에 명시한 검증된 C/G 카드와 KNOWHOW 린트 통과 항목 외의 노하우는 포함하지 않는다. 현재 관측과 담당 자리의 검증된 원장을 직접 확인한다.',
+    '## 출처 해시',
+    ...sources.map((source) => `- ${source.path}: ${source.sha256}`),
+    ...missingSources.map((path) => `- ${path}: 없음(이 설치본에 미포함)`),
+    '',
+  ];
+  const body = lines.join('\n');
+  return { role, version, sha256: sha256(body), body, includedCardIds: cards.map(([id]) => id), excludedCardIds: knowhow.excluded, sources, missingSources };
+}
+
+/** Prompt body consumed by coordinator and guardian agents. */
+export function buildCoordRolePack(role: RolePackRole, root = resolve(import.meta.dir, '..')): string {
+  return buildCoordRolePackManifest(role, root).body;
+}
+
+if (import.meta.main) {
+  const roleArg = process.argv.indexOf('--role');
+  const role = process.argv[roleArg + 1];
+  if (roleArg < 0 || (role !== 'coordinator' && role !== 'guardian')) {
+    console.error('usage: bun scripts/coord-role-pack.ts --role coordinator|guardian [--json]');
+    process.exitCode = 2;
+  } else {
+    const pack = buildCoordRolePackManifest(role);
+    process.stdout.write(process.argv.includes('--json') ? `${JSON.stringify(pack)}\n` : pack.body);
+  }
+}

package/scripts/cron-run.ts

@@ -16,7 +16,7 @@ import { ensureCronNodePath } from '../src/domains/cron-path.js';
 ensureCronNodePath();
 
 async function main(): Promise<void> {
-  const argv = process.argv.slice(2);
+  const { argv, maxRuntimeMs } = extractMaxRuntimeArgs(process.argv.slice(2)); // 래퍼 옵션은 대상 앞에서만 소비한다.
   const hasScheduleId = argv[0] === '--schedule-id';
   const scheduleId = hasScheduleId ? argv.splice(0, 2)[1] : undefined;
   if (hasScheduleId && (!scheduleId?.trim() || scheduleId === '--shell')) {
@@ -90,6 +90,9 @@ async function main(): Promise<void> {
   const child = spawn(interpreter, [target, ...targetArgs], {
     stdio: ['ignore', 'inherit', 'pipe'],
     env: { ...process.env },
+    // ⓐ detached — 자식이 프로세스 그룹 리더가 된다. 상한 초과 kill 은 그룹 전체
+    // (자식의 자식까지)를 죽린다: process.kill(-pid).
+    detached: true,
   });
   let errTail = '';
   child.stderr?.on('data', (chunk: Buffer) => {
@@ -97,14 +100,53 @@ async function main(): Promise<void> {
     errTail = (errTail + chunk.toString()).slice(-2000); // 바운디드
   });
 
+  // ⓐ 상한 타이머 — 넘으면 자식 프로세스 그룹 전체를 SIGKILL 하고 관측 플래그를 올린다.
+  // 진단(stderr 한 줄)은 여기서, 관측 기록은 기존 finish() 경로가 그대로 맡는다(fail-open 불변).
+  // ⚠ 리더가 이미 종료했다고 조기 반환하지 않는다(리뷰 must-fix): 리더만 죽고 손자가 stderr
+  //   파이프를 쥔 채 남으면 close 가 영영 안 와 관측도 반환도 없다. 이 경로에서도 그룹(트리)
+  //   종료를 시도하고, close 가 오지 않으면 finish 를 직접 불러 관측·반환을 마무리한다.
+  let overrun = false;
+  let finished = false;
+  let forwardedExit: number | null = null;
+  let signalKillTimer: ReturnType<typeof setTimeout> | null = null;
+  const timer: ReturnType<typeof setTimeout> | null = maxRuntimeMs > 0
+    ? setTimeout(() => {
+        if (child.pid === undefined || finished) return;
+        overrun = true;
+        const leaderGone = child.exitCode !== null || child.signalCode !== null;
+        try { process.stderr.write(`cron-run overrun: ${maxRuntimeMs}ms 상한 초과 — 자식 트리(pid ${child.pid}) 종료${leaderGone ? ' — 리더 이미 종료, 파이프를 쥔 손자 정리' : ''}\n`); } catch { /* */ }
+        try { process.kill(-child.pid, 'SIGKILL'); }
+        catch { try { child.kill('SIGKILL'); } catch { /* 이미 종료 */ } }
+        // 그룹 밖(setsid) 잔존자가 파이프를 계속 쥐면 close 가 오지 않는다 — 관측까지 여기서
+        // 마무리한다. close 가 정상적으로 오면 finish 의 멱등 가드가 이 호출을 흡수한다.
+        setTimeout(() => finish(child.exitCode), OVERRUN_CLOSE_GRACE_MS);
+      }, maxRuntimeMs)
+    : null;
+
   const finish = (code: number | null): void => {
-    const exit = code ?? 0;
+    if (finished) return; // 멱등 — close·error·상한 유예 경로가 겹쳐도 관측·반환은 1회
+    finished = true;
+    // 신호를 받은 뒤 리더가 먼저 닫혀도, SIGTERM을 무시하고 stdio를 닫은 손자가
+    // 그룹에 남을 수 있다. close가 온 시점에도 그룹 전체를 마지막으로 거둔다.
+    if (forwardedExit !== null && child.pid !== undefined) {
+      try { process.kill(-child.pid, 'SIGKILL'); } catch { /* 그룹 이미 종료 */ }
+    }
+    if (timer !== null) clearTimeout(timer);
+    if (signalKillTimer !== null) clearTimeout(signalKillTimer);
+    process.removeListener('SIGINT', onSigInt);
+    process.removeListener('SIGTERM', onSigTerm);
+    const exit = overrun ? 124 : forwardedExit ?? code ?? 0;
     try {
       const durationMs = Date.now() - start;
       const status: 'ok' | 'error' = exit === 0 ? 'ok' : 'error';
+      const overrunNote = overrun
+        ? `cron-run overrun: killed ${target} (pid ${child.pid ?? '?'}) after ${durationMs}ms — cap ${maxRuntimeMs}ms`
+        : null;
       const record = {
         status, exit, durationMs, via: 'crontab' as const,
-        error: exit === 0 ? null : errTail.trim().split('\n').slice(-3).join('\n') || `exit ${exit}`,
+        error: overrunNote
+          ? [overrunNote, ...errTail.trim().split('\n').slice(-3).filter(Boolean)].join('\n')
+          : exit === 0 ? null : errTail.trim().split('\n').slice(-3).join('\n') || `exit ${exit}`,
       };
       const options = { ...(db ? { db } : {}), ...(id ? { id } : {}), prevStatus };
       const diagnostic = (kind: 'prerequisite' | 'registry record skipped' | 'registry selection ambiguous' | 'import' | 'record', error: unknown): Promise<void> => {
@@ -144,8 +186,59 @@ async function main(): Promise<void> {
       process.exit(exit);
     }
   };
+  const forwardSignal = (signal: 'SIGINT' | 'SIGTERM'): void => {
+    if (finished || forwardedExit !== null) return;
+    forwardedExit = signal === 'SIGINT' ? 130 : 143;
+    if (child.pid === undefined) { finish(forwardedExit); return; }
+    try { process.kill(-child.pid, signal); }
+    catch { try { child.kill(signal); } catch { /* 이미 종료 */ } }
+    signalKillTimer = setTimeout(() => {
+      try { process.kill(-child.pid!, 'SIGKILL'); }
+      catch { try { child.kill('SIGKILL'); } catch { /* 이미 종료 */ } }
+      finish(forwardedExit);
+    }, OVERRUN_CLOSE_GRACE_MS);
+  };
+  const onSigInt = (): void => forwardSignal('SIGINT');
+  const onSigTerm = (): void => forwardSignal('SIGTERM');
+  process.on('SIGINT', onSigInt);
+  process.on('SIGTERM', onSigTerm);
   child.on('close', finish);
   child.on('error', (e) => { process.stderr.write(`cron-run spawn error: ${e.message}\n`); finish(1); });
 }
 
+const MAX_TIMER_MS = 2_147_483_647;
 void main().catch(() => process.exit(0));
+
+// ⓐ LOGS-RETENTION-46MIN: 실행 시간 상한 — 상한 없이 살아남은 옛 판 크론이 6시간마다
+// «오래된 행 50%» 삭제를 겹쳐 돌려 보존 창을 무너뜨린 사고(10-12)의 재발 방지.
+// 우선순위: --max-runtime-ms > CRON_RUN_MAX_RUNTIME_MS > 기본 30분. 0 이하는 상한 끔.
+//
+// 래퍼 플래그는 대상 앞에서만 읽는다. 대상 뒤의 같은 이름은 자식 인자다.
+// ⚠ main() 안쪽이 아니라 여기(helper)에 두는 이유: main() 머리에 줄을 늘리면 위쪽
+//   registerLogStoreSink 호출의 줄번호가 움직여 log-store-retention-callers.test.ts
+//   가 git 색인과 대비하는 검사를 깬다(부메랑).
+function extractMaxRuntimeArgs(argv: string[]): { argv: string[]; maxRuntimeMs: number } {
+  const args = [...argv];
+  if (args[0] === '--schedule-id') args.splice(0, 2);
+  if (args[0] === '--max-runtime-ms') {
+    const raw = args[1];
+    const parsed = Number(raw);
+    if (!raw || !Number.isSafeInteger(parsed) || parsed < 0 || parsed > MAX_TIMER_MS) {
+      process.stderr.write(`cron-run: --max-runtime-ms 인자는 0~${MAX_TIMER_MS} 사이의 정수여야 합니다\n`);
+      process.exit(2);
+    }
+    const flagIndex = argv.indexOf('--max-runtime-ms');
+    return { argv: argv.filter((_, index) => index !== flagIndex && index !== flagIndex + 1), maxRuntimeMs: parsed };
+  }
+  const rawEnv = process.env.CRON_RUN_MAX_RUNTIME_MS;
+  const fromEnv = Number(rawEnv);
+  if (rawEnv?.trim() && fromEnv > MAX_TIMER_MS) {
+    process.stderr.write(`cron-run: CRON_RUN_MAX_RUNTIME_MS 인자는 0~${MAX_TIMER_MS} 사이의 정수여야 합니다\n`);
+    process.exit(2);
+  }
+  return { argv, maxRuntimeMs: rawEnv?.trim() && Number.isSafeInteger(fromEnv) && fromEnv >= 0 && fromEnv <= MAX_TIMER_MS ? fromEnv : 30 * 60_000 };
+}
+
+// ⓐ 상한 시점의 그룹 종료 뒤에도 close 가 오지 않는 경로(파이프를 쥔 그룹 밖 손자)에서
+// 관측(finish)을 마무리할 때까지 기다리는 유예.
+const OVERRUN_CLOSE_GRACE_MS = 2_000;

package/scripts/detect-test-interference.ts

@@ -1,4 +1,9 @@
 #!/usr/bin/env bun
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { prepareIsolatedTestEnv } from './lib/deterministic-env.js';
+
 export const EXIT_NO_INTERFERENCE = 0;
 export const EXIT_INTERFERENCE = 1;
 export const EXIT_INVALID_INPUT = 2;
@@ -19,7 +24,7 @@ export type BunTestChild = {
   exited: Promise<number>;
   signalCode: string | null;
 };
-export type BunSpawn = (options: { cmd: string[]; cwd: string; stdout: 'pipe'; stderr: 'pipe' }) => BunTestChild;
+export type BunSpawn = (options: { cmd: string[]; cwd: string; env: NodeJS.ProcessEnv; stdout: 'pipe'; stderr: 'pipe' }) => BunTestChild;
 
 export type MeasuredRun = {
   files: string[];
@@ -45,10 +50,38 @@ export const MAX_ISOLATED_FAILURE_FILES = 8;
 
 const defaultBunSpawn: BunSpawn = (options) => Bun.spawn(options) as unknown as BunTestChild;
 
-export async function runBunTest(files: readonly string[], spawn: BunSpawn = defaultBunSpawn, cwd: string = process.cwd()): Promise<RunnerResult> {
-  const child = spawn({ cmd: [process.execPath, 'test', ...files], cwd, stdout: 'pipe', stderr: 'pipe' });
-  const [stdout, stderr, exitCode] = await Promise.all([new Response(child.stdout).text(), new Response(child.stderr).text(), child.exited]);
-  return { stdout, stderr, exitCode, signal: child.signalCode };
+/**
+ * ⛔ 2026-10-16 사고(R7 · OP #8751) — 이 러너가 `bun test` 를 env 지정 없이 띄워 호스트 재게이트가 mbp 의 실 HOME·운영
+ * config 를 시험에 물려줬다. seam 이 빠진 시험 둘(tasks-cli · COORD-ONE)이 운영 `taskAgent.parentHost` 목록으로 진짜 ssh
+ * 발사를 해 원격 prod 런 25 · draft PR 11 이 생겼다.
+ * ⇒ 시험은 «게이트와 같은» 격리 env 로 띄운다(`prepareIsolatedTestEnv` — 임시 HOME ⊕ 임시 ELANOUS_STATE_DIR ⊕ 자격·실행
+ *   정체성·`ELANOUS_STATE_DIR_SOURCE` 제거 · PATH 보존) ⊕ 원격 부모 끔(`ELANOUS_TA_PARENT_HOST=off`).
+ */
+export async function isolatedBunTestEnv(sourceEnv: NodeJS.ProcessEnv = process.env): Promise<{ env: NodeJS.ProcessEnv; cleanup: () => void }> {
+  // ⛔ Import the side-effect-free lib, never `test-deterministic.ts`: that file pulls `typescript` and Bun stream
+  //    types into every graph that reaches this runner — the PWA tsc program failed on it (#28474 train · 10-16).
+  const root = mkdtempSync(join(tmpdir(), 'elanous-interference-test-'));
+  const cleanup = (): void => {
+    try { rmSync(root, { recursive: true, force: true }); }
+    catch (error) {
+      // 판정은 막지 않되 숨기지 않는다 — 남은 임시 뿌리는 경로로 찾을 수 있게 한 줄 남긴다(리뷰 should-fix).
+      try { process.stderr.write(`[detect-test-interference] temp env root cleanup failed: ${root}: ${error instanceof Error ? error.message : String(error)}\n`); } catch { /* ignore */ }
+    }
+  };
+  try {
+    return { env: { ...prepareIsolatedTestEnv(sourceEnv, root), ELANOUS_TA_PARENT_HOST: 'off' }, cleanup };
+  } catch (error) { cleanup(); throw error; }
+}
+
+export async function runBunTest(files: readonly string[], spawn: BunSpawn = defaultBunSpawn, cwd: string = process.cwd(), sourceEnv: NodeJS.ProcessEnv = process.env): Promise<RunnerResult> {
+  const isolated = await isolatedBunTestEnv(sourceEnv);
+  try {
+    const child = spawn({ cmd: [process.execPath, 'test', ...files], cwd, env: isolated.env, stdout: 'pipe', stderr: 'pipe' });
+    const [stdout, stderr, exitCode] = await Promise.all([new Response(child.stdout).text(), new Response(child.stderr).text(), child.exited]);
+    return { stdout, stderr, exitCode, signal: child.signalCode };
+  } finally {
+    isolated.cleanup();
+  }
 }
 
 export function parseFailureCount(output: string): number | null {

package/scripts/gate-pr-cache.ts

@@ -0,0 +1,65 @@
+#!/usr/bin/env bun
+/** Read-only OP train adapter: one JSON decision, never launches a gate or edits a queue. */
+import { readFileSync } from 'node:fs';
+import { spawnSync } from 'node:child_process';
+import { resolve } from 'node:path';
+import { decidePrGateCache } from './release-loop/gate-pr-cache.js';
+import { buildClosureGraph, gitClosureTree, testsReachingChanged } from './release-loop/gate-closure.js';
+
+const SHA = /^[0-9a-f]{40}$/i;
+const argv = process.argv.slice(2);
+const option = (name: string): string | undefined => {
+  const index = argv.indexOf(name);
+  return index >= 0 ? argv[index + 1] : undefined;
+};
+const summaryPath = option('--summary');
+const repo = option('--repo');
+const head = option('--head')?.toLowerCase();
+const main = option('--main')?.toLowerCase();
+const singlePr = argv.includes('--single-pr');
+if (!summaryPath || !repo || !head || !main || !SHA.test(head) || !SHA.test(main) || !singlePr) {
+  console.error('usage: bun scripts/gate-pr-cache.ts --summary <author-summary.json> --repo <git-repo> --head <PR-head40> --main <main40> --single-pr');
+  process.exit(2);
+}
+const git = (args: string[]): { status: number | null; stdout: string } => {
+  // git-spawn-allow: read-only object ancestry and path diff; this adapter never checks out or mutates.
+  const result = spawnSync('git', args, { cwd: resolve(repo), encoding: 'utf8', maxBuffer: 16 * 1024 * 1024 });
+  return { status: result.status, stdout: result.stdout ?? '' };
+};
+let summary: unknown;
+try { summary = JSON.parse(readFileSync(summaryPath, 'utf8')); } catch { summary = null; }
+const base = summary && typeof summary === 'object' && 'base40' in summary && typeof summary.base40 === 'string'
+  ? summary.base40.toLowerCase() : '';
+const baseAncestorOfHead = SHA.test(base) && git(['merge-base', '--is-ancestor', base, head]).status === 0;
+const baseAncestorOfMain = SHA.test(base) && git(['merge-base', '--is-ancestor', base, main]).status === 0;
+const diff = baseAncestorOfMain ? git(['-c', 'core.quotepath=off', 'diff', '--name-only', '--no-renames', `${base}..${main}`]) : null;
+const mainChangedFiles = diff?.status === 0 ? diff.stdout.split(/\r?\n/).filter(Boolean) : null;
+const docs = mainChangedFiles?.filter((file) => /\.md$/.test(file));
+const added = docs?.length ? git(['-c', 'core.quotepath=off', 'diff', '--name-only', '--no-renames', '--diff-filter=A', `${base}..${main}`]) : null;
+const inertDocsAddedOnly = docs ? (!docs.length || (added?.status === 0 && docs.every((file) => added.stdout.split(/\r?\n/).includes(file)))) : null;
+let affectedTests: string[] | null = null;
+let sourceDependencyOverlap: boolean | null = null;
+if (mainChangedFiles && summary && typeof summary === 'object' && 'cohort' in summary && Array.isArray(summary.cohort)) {
+  const code = mainChangedFiles.filter((file) => /\.[cm]?[jt]sx?$/.test(file));
+  if (!code.length) { affectedTests = []; sourceDependencyOverlap = false; }
+  else try {
+    const tree = gitClosureTree(resolve(repo), head);
+    const prDiff = SHA.test(base) ? git(['-c', 'core.quotepath=off', 'diff', '--name-only', '--no-renames', `${base}..${head}`]) : null;
+    const prChanged = prDiff?.status === 0 ? prDiff.stdout.split(/\r?\n/).filter(Boolean) : null;
+    if (prChanged && code.every((file) => tree.files.includes(file))
+      && prChanged.every((file) => /\.[cm]?[jt]sx?$/.test(file) || (/\.md$/.test(file) && !/(?:^|\/)(?:test|tests|__tests__|fixtures|__fixtures__|__snapshots__|__mocks__)\//.test(file)))) {
+      const graph = buildClosureGraph(tree);
+      const seen = new Set(prChanged.filter((file) => /\.[cm]?[jt]sx?$/.test(file)));
+      const pending = [...seen];
+      while (pending.length) for (const dependency of graph.forward.get(pending.pop()!) ?? []) {
+        if (!seen.has(dependency)) { seen.add(dependency); pending.push(dependency); }
+      }
+      if ([...seen].some((file) => graph.opaque.has(file) || !graph.tracked.has(file))) throw new Error('PR source closure opaque');
+      sourceDependencyOverlap = code.some((file) => seen.has(file));
+      const closure = testsReachingChanged(tree, code, summary.cohort);
+      if (closure.ok) affectedTests = closure.tests;
+    }
+  } catch { /* unknown radius means full gate */ }
+}
+console.log(JSON.stringify(decidePrGateCache({ summary, head, main, singlePr,
+  baseAncestorOfHead, baseAncestorOfMain, mainChangedFiles, inertDocsAddedOnly, affectedTests, sourceDependencyOverlap }), null, 2));

package/scripts/gh-surface/capture.ts

@@ -0,0 +1,126 @@
+import { closeSync, constants, openSync, writeSync } from 'node:fs';
+
+// Only fixed gh vocabulary and validated field identifiers may cross this boundary.
+// Do not add positional arguments or error messages to the persisted record.
+const SUBCOMMANDS: Record<string, ReadonlySet<string>> = {
+  auth: new Set(['status', 'login', 'logout', 'token', 'refresh', 'setup-git']),
+  project: new Set(['list', 'view', 'create', 'edit', 'delete', 'close', 'field-list', 'item-list']),
+  cache: new Set(['list', 'delete']),
+  codespace: new Set(['list', 'view', 'create', 'delete', 'ssh']),
+  'ssh-key': new Set(['list', 'add', 'delete']),
+  api: new Set(['graphql']),
+  issue: new Set(['list', 'view', 'create', 'edit', 'close', 'reopen', 'comment', 'status']),
+  pr: new Set(['list', 'view', 'create', 'edit', 'checkout', 'merge', 'close', 'reopen', 'comment', 'checks', 'diff', 'status', 'ready', 'review']),
+  repo: new Set(['view', 'list', 'clone', 'create', 'edit', 'fork', 'sync']),
+  run: new Set(['list', 'view', 'watch', 'rerun', 'cancel', 'download']),
+  workflow: new Set(['list', 'view', 'run', 'enable', 'disable']),
+  release: new Set(['list', 'view', 'create', 'edit', 'delete', 'download', 'upload']),
+  label: new Set(['list', 'create', 'edit', 'delete', 'clone']),
+  search: new Set(['code', 'commits', 'issues', 'prs', 'repos']),
+  gist: new Set(['list', 'view', 'create', 'edit', 'delete', 'clone']),
+  secret: new Set(['list', 'set', 'delete']),
+  variable: new Set(['list', 'set', 'delete']),
+};
+// A syntactically valid identifier can still be a token passed as a --json value.
+// Unknown names are counted, never copied into the log. Extend only from gh's documented fields.
+const FIELDS = new Set([
+  'additions', 'assignees', 'author', 'baseRefName', 'body', 'changedFiles', 'closed',
+  'closedAt', 'comments', 'commits', 'createdAt', 'databaseId', 'deletions', 'files',
+  'headRefName', 'headRepository', 'id', 'isDraft', 'isPrivate', 'labels', 'latestReviews',
+  'maintainerCanModify', 'mergeCommit', 'mergeStateStatus', 'mergeable', 'mergedAt',
+  'mergedBy', 'milestone', 'name', 'number', 'owner', 'projectCards', 'projectItems',
+  'reactionGroups', 'reviewDecision', 'reviewRequests', 'reviews', 'state', 'status',
+  'title', 'updatedAt', 'url', 'viewerCanUpdate', 'viewerDidAuthor', 'workflowName',
+]);
+const MAX_FIELDS = 100;
+// Option arity is command-specific. Unsupported forms must not silently hide --json.
+// This is deliberately a narrow allowlist, not a global inventory of gh flags.
+const VALUE_OPTIONS_BY_COMMAND: Record<string, ReadonlySet<string>> = {
+  'api graphql': new Set(['--field', '--raw-field', '-H', '--header', '--method', '-X', '--input']),
+  'pr list': new Set(['-R', '--repo', '--limit', '-L', '--state', '-s', '--author', '--base', '--head', '--search', '-S', '--label', '-l', '--assignee', '-a', '--jq', '-q', '--template', '-t']),
+  'pr view': new Set(['-R', '--repo', '--jq', '-q', '--template', '-t']),
+  'issue list': new Set(['-R', '--repo', '--limit', '-L', '--state', '-s', '--author', '--assignee', '-a', '--label', '-l', '--search', '-S', '--jq', '-q', '--template', '-t']),
+  'run list': new Set(['-R', '--repo', '--limit', '-L', '-w', '--workflow', '--branch', '--jq', '-q', '--template', '-t']),
+};
+const SWITCH_OPTIONS_BY_COMMAND: Record<string, ReadonlySet<string>> = {
+  'repo list': new Set(['-s', '--source']),
+  'pr create': new Set(['-w', '--web']),
+};
+const UNIVERSAL_SWITCH_OPTIONS = new Set(['--help', '-h']);
+
+type CaptureRow = { command: string; fields: string[] | 'unknown'; unknown: boolean };
+
+export function classifyGhCall(args: readonly string[]): CaptureRow {
+  const root = args[0];
+  const sub = args[1];
+  const command = root && Object.hasOwn(SUBCOMMANDS, root)
+    ? root === 'api' ? (sub === 'graphql' ? 'api graphql' : 'api')
+      : sub && SUBCOMMANDS[root]!.has(sub) ? `${root} ${sub}` : 'unknown'
+    : 'unknown';
+  let unknown = command === 'unknown';
+  let fields: string[] = [];
+  let seen = false;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i]!;
+    if (arg === '--') break;
+    if (VALUE_OPTIONS_BY_COMMAND[command]?.has(arg)) {
+      const value = args[++i];
+      if (!value || value.startsWith('-')) unknown = true;
+      continue;
+    }
+    if (SWITCH_OPTIONS_BY_COMMAND[command]?.has(arg) || UNIVERSAL_SWITCH_OPTIONS.has(arg)) continue;
+    // Sensitive payload options consume one argument without inspecting or retaining its contents.
+    if (arg === '--body' || arg === '-f' || arg === '-F') {
+      const value = args[++i];
+      if (value === undefined || value.startsWith('-')) {
+        unknown = true;
+        i--; // Parse the next option too; a missing payload must never hide --json.
+      }
+      continue;
+    }
+    if (arg === '--json' || arg.startsWith('--json=')) {
+      if (seen || root === 'api') unknown = true;
+      seen = true;
+      const value = arg === '--json' ? args[++i] : arg.slice('--json='.length);
+      const parts = value?.split(',');
+      if (!parts?.length || parts.length > MAX_FIELDS || parts.some((part) => !FIELDS.has(part))) {
+        unknown = true;
+      } else {
+        fields = parts;
+      }
+    } else if (arg.startsWith('--json')) {
+      unknown = true;
+    } else if (arg.startsWith('-') && arg !== '-') {
+      // Unknown options can consume arguments; fail closed rather than infer fields.
+      unknown = true;
+    }
+  }
+  return { command, fields: unknown ? 'unknown' : fields, unknown };
+}
+
+export function captureGhCall(args: readonly string[], file: string): void {
+  const row = JSON.stringify(classifyGhCall(args)) + '\n';
+  const fd = openSync(file, constants.O_WRONLY | constants.O_APPEND | constants.O_CREAT, 0o600);
+  try {
+    // One bounded append per invocation: concurrent children cannot interleave JSONL fragments.
+    if (writeSync(fd, row) !== Buffer.byteLength(row)) throw new Error('short JSONL write');
+  } finally {
+    closeSync(fd);
+  }
+}
+
+if (import.meta.main) {
+  const file = process.env.ELANOUS_GH_SURFACE_JSONL;
+  if (!file) {
+    console.error('gh-surface: JSONL destination not configured');
+    process.exitCode = 70;
+  } else {
+    try {
+      captureGhCall(process.argv.slice(2), file);
+    } catch {
+      // Filesystem exception text can contain a path or user input.
+      console.error('gh-surface: capture failed');
+      process.exitCode = 70;
+    }
+  }
+}