elanous 0.2.23 → 0.2.25

package/src/cli/pr-land-overlap-evidence.ts

@@ -7,14 +7,21 @@
  * - 무엇을: `--overlap-evidence <file>` 의 JSON 을 «믿지 않고» 잰다.
  *   ① 재기반 — 원격 base 의 «지금» 끝(`git ls-remote`)이 고정 머리의 조상인가(`git merge-base --is-ancestor`).
  *   ② 재게이트 — 증거의 게이트 기록이 «그 머리»를 «그 base 끝» 위에서 통과했다고 말하는가(머리·base 끝이 ① 과 맞물린다).
+ *   ②' 재게이트 뒤 base 가 앞섰다(OVERLAP-EVIDENCE-BASE-WINDOW) — `gate.baseCommit ≠ 지금 끝`이면 «창»을 잰다:
+ *      ⓐ `gate.baseCommit` 이 고정 머리의 조상 ⊕ 지금 끝의 조상이고 ⓑ 창 `gate.baseCommit..지금 끝`의 커밋이 «하나도»
+ *      PR 의 바뀐 파일(머리 vs merge-base)을 안 건드리면 통과(관측 reason `base-advanced-disjoint`).
+ *      겹치면 `base-stale-overlap`(REJUDGE 가 재게이트를 청한다) · 못 재면 `base-window-unmeasured` · ⓐ 가 아니면 종전 사유.
  *   ③ 리뷰 — 증거가 가리키는 `review-results/<card>-<pr>-<head12>.json`(TA 가 받는 `self review --json` stdout)이
- *      같은 PR·같은 머리에 대해 `reviewed:true` · `verdict:pass` · must-fix 0 인가.
+ *      같은 PR·같은 머리에 대해 `reviewed:true` · `verdict ∈ {pass, warn}` · must-fix 가 «잰 수» 0 인가
+ *      (자동 병합 canAuto · TA-LAND-WARN-MUSTFIX0 과 같은 규칙 — must-fix 를 못 셌으면 거부).
  *   ⓐ 이미 조상(TC #26019 실측) — 겹친 최근 착지 커밋이 «전부» 고정 머리의 조상이면 그 겹침은 이미 그 머리의 게이트·리뷰에
  *      반영됐다 ⇒ ①② 없이 ③ 만으로 통과(관측 reason `already-ancestor`). 하나라도 조상이 아니면 ①②③ 전부.
+ *   ⓐ' 증거 파일이 없을 때(`verifyAncestorAutoPass`) — 같은 ⓐ 를 표준 자리 `review-results/*-<pr>-<head12>.json` 만으로 잰다
+ *      (관측 reason `already-ancestor-auto`). 조상이 아닌 착지가 하나라도 있거나 리뷰 결과가 없으면 거부.
  *   하나라도 못 재거나 어긋나면 거부 — 호출부는 종전 거부를 그대로 낸다(fail-closed).
  * - 관측: `pr.land` · `overlap-evidence` (decision · reason · 잰 값).
  */
-import { basename, dirname } from 'node:path';
+import { basename, dirname, join } from 'node:path';
 import { debug } from '../debug/log.js';
 import type { CmdRunner } from '../autopilot/pr-manager.js';
 import { parseReviewResultOutput } from '../task-agent/review-result-capture.js';
@@ -33,6 +40,7 @@ interface OverlapEvidenceFile {
 export type OverlapEvidenceVerdict =
   | { ok: true; mode: 'already-ancestor'; reviewResult: string }
   | { ok: true; mode: 'rebased'; baseTip: string; reviewResult: string }
+  | { ok: true; mode: 'base-advanced-disjoint'; baseTip: string; gateBase: string; windowCommits: number; reviewResult: string }
   | { ok: false; reason: string };
 
 export interface VerifyOverlapEvidenceInput {
@@ -48,9 +56,14 @@ export interface VerifyOverlapEvidenceInput {
   overlappingLandings?: readonly string[];
 }
 
-type Checked = { ok: false; reason: string; baseTip?: string } | (OverlapEvidenceVerdict & { ok: true; baseTip?: string });
+type Checked = { ok: false; reason: string; baseTip?: string; gateBase?: string; windowCommits?: number }
+  | (OverlapEvidenceVerdict & { ok: true; baseTip?: string });
 
-function checkReview(input: VerifyOverlapEvidenceInput, e: Partial<OverlapEvidenceFile>, head: string, baseTip?: string): { ok: false; reason: string; baseTip?: string } | { ok: true; reviewResult: string } {
+/** 리뷰가 받는 판정 — 자동 병합(canAuto)·TA 착지(TA-LAND-WARN-MUSTFIX0)와 같은 집합. */
+const ACCEPTED_REVIEW_VERDICTS: ReadonlySet<string> = new Set(['pass', 'warn']);
+const COMMIT_MARK = '\u0001';
+
+function checkReview(input: Pick<VerifyOverlapEvidenceInput, 'pr' | 'readFile'>, e: Partial<OverlapEvidenceFile>, head: string, baseTip?: string): { ok: false; reason: string; baseTip?: string } | { ok: true; reviewResult: string } {
   if (typeof e.reviewResult !== 'string' || !e.reviewResult) return { ok: false, reason: 'review-missing', baseTip };
   // TA 가 받는 자리(`<state>/review-results/<card>-<pr>-<head12>.json` · reviewResultPath)만 — 아무 디렉터리의 같은 이름은 안 받는다.
   if (basename(dirname(e.reviewResult)) !== 'review-results'
@@ -65,11 +78,67 @@ function checkReview(input: VerifyOverlapEvidenceInput, e: Partial<OverlapEviden
   if (!review.head || review.head.toLowerCase() !== head) return { ok: false, reason: 'review-head-mismatch', baseTip };
   if (review.error) return { ok: false, reason: 'review-error', baseTip };
   if (review.reviewed !== true) return { ok: false, reason: 'review-not-reviewed', baseTip };
-  if (review.verdict !== 'pass') return { ok: false, reason: `review-verdict-${review.verdict ?? 'null'}`, baseTip };
+  if (review.verdict === null || !ACCEPTED_REVIEW_VERDICTS.has(review.verdict)) return { ok: false, reason: `review-verdict-${review.verdict ?? 'null'}`, baseTip };
   if (review.mustFix !== 0) return { ok: false, reason: review.mustFix === null ? 'review-must-fix-unknown' : `review-must-fix-${review.mustFix}`, baseTip };
   return { ok: true, reviewResult: e.reviewResult };
 }
 
+type WindowResult = { ok: true; windowCommits: number } | { ok: false; reason: string; windowCommits?: number };
+
+/**
+ * ②' — 재게이트 뒤 앞선 base 의 창 `gateBase..baseTip` 이 PR 의 바뀐 파일과 «서로소»인가. 읽기 전용 git 만 쓴다
+ * (끝 커밋이 로컬에 없을 때만 ref 를 안 쓰는 fetch). `staleReason` 은 ⓐ(조상 아님)일 때 그대로 내는 종전 사유다.
+ */
+function checkBaseWindow(input: VerifyOverlapEvidenceInput, head: string, baseTip: string, gateBase: string, staleReason: string): WindowResult {
+  const git = (args: string[]) => input.run('git', args, { cwd: input.cwd });
+  const short = (sha: string) => sha.slice(0, 12);
+  if (!git(['merge-base', '--is-ancestor', gateBase, head]).ok) {
+    return { ok: false, reason: `${staleReason} (gate base is not an ancestor of head)` };
+  }
+  if (!git(['cat-file', '-e', `${baseTip}^{commit}`]).ok) {
+    // ref 를 안 바꾸는 fetch — FETCH_HEAD 도 원격 추적 ref 도 안 쓴다.
+    git(['fetch', '--quiet', '--no-write-fetch-head', '--refmap=', input.remote, `refs/heads/${input.branch}`]);
+    if (!git(['cat-file', '-e', `${baseTip}^{commit}`]).ok) {
+      return { ok: false, reason: `base-window-unmeasured: ${input.remote}/${input.branch} ${short(baseTip)} not available locally · ${staleReason}` };
+    }
+  }
+  if (!git(['merge-base', '--is-ancestor', gateBase, baseTip]).ok) {
+    return { ok: false, reason: `${staleReason} (gate base is not an ancestor of ${input.remote}/${input.branch})` };
+  }
+  const mergeBase = git(['merge-base', baseTip, head]);
+  const forkPoint = mergeBase.ok ? mergeBase.out.trim() : '';
+  if (!SHA40.test(forkPoint)) return { ok: false, reason: `base-window-unmeasured: merge-base ${short(baseTip)} ${short(head)} failed · ${staleReason}` };
+  const diff = git(['diff', '--name-only', '--no-renames', forkPoint, head]);
+  if (!diff.ok) return { ok: false, reason: `base-window-unmeasured: diff --name-only ${short(forkPoint)} ${short(head)} failed · ${staleReason}` };
+  const prFiles = new Set(diff.out.split('\n').map((line) => line.trim()).filter(Boolean));
+  if (prFiles.size === 0) return { ok: false, reason: `base-window-unmeasured: PR changed files are empty · ${staleReason}` };
+  // 병합 커밋은 첫 부모 대비 diff(-m --first-parent) — base 에 «들어온» 변경만, 빠짐없이.
+  const log = git(['log', '--first-parent', '-m', '--no-renames', '--name-only', `--format=${COMMIT_MARK}%H`, `${gateBase}..${baseTip}`]);
+  if (!log.ok) return { ok: false, reason: `base-window-unmeasured: log ${short(gateBase)}..${short(baseTip)} failed · ${staleReason}` };
+  const touched = new Map<string, string[]>();
+  let current = '';
+  for (const raw of log.out.split('\n')) {
+    const line = raw.trim();
+    if (!line) continue;
+    if (line.startsWith(COMMIT_MARK)) { current = line.slice(COMMIT_MARK.length); if (!touched.has(current)) touched.set(current, []); continue; }
+    if (current && prFiles.has(line)) touched.get(current)!.push(line);
+  }
+  const windowCommits = touched.size;
+  if (windowCommits === 0 || [...touched.keys()].some((sha) => !SHA40.test(sha))) {
+    return { ok: false, reason: `base-window-unmeasured: window ${short(gateBase)}..${short(baseTip)} listed no commits · ${staleReason}` };
+  }
+  const overlapping = [...touched.entries()].filter(([, files]) => files.length > 0);
+  if (overlapping.length > 0) {
+    const files = [...new Set(overlapping.flatMap(([, f]) => f))];
+    return {
+      ok: false,
+      windowCommits,
+      reason: `base-stale-overlap: gate ${short(gateBase)} ≠ ${input.remote}/${input.branch} ${short(baseTip)} · ${overlapping.length}/${windowCommits} window commits touch PR files (${overlapping.map(([sha]) => short(sha)).slice(0, 5).join(', ')}): ${files.slice(0, 10).join(', ')}`,
+    };
+  }
+  return { ok: true, windowCommits };
+}
+
 function check(input: VerifyOverlapEvidenceInput): Checked {
   const head = input.expectedHead.toLowerCase();
   let raw: unknown;
@@ -94,15 +163,32 @@ function check(input: VerifyOverlapEvidenceInput): Checked {
   const baseTip = remote.ok ? remote.out.trim().split(/\s+/)[0] ?? '' : '';
   if (!SHA40.test(baseTip)) return { ok: false, reason: `rebase-unmeasured: ls-remote ${input.remote} ${input.branch} failed` };
   const ancestor = input.run('git', ['merge-base', '--is-ancestor', baseTip, head], { cwd: input.cwd });
-  if (!ancestor.ok) return { ok: false, reason: `not-rebased: ${input.remote}/${input.branch} ${baseTip.slice(0, 12)} is not an ancestor of ${head.slice(0, 12)}`, baseTip };
+  const gate = e.gate;
+  // ②' 의 입구 — 게이트 기록이 «그 머리»를 통과했고 base 만 지금 끝과 다르다.
+  const gateBase = gate && typeof gate === 'object' && gate.passed === true
+    && typeof gate.head === 'string' && gate.head.toLowerCase() === head
+    && typeof gate.baseCommit === 'string' && SHA40.test(gate.baseCommit) && gate.baseCommit.toLowerCase() !== baseTip.toLowerCase()
+    ? gate.baseCommit.toLowerCase() : undefined;
+  const advanced = (staleReason: string): Checked => {
+    const window = checkBaseWindow(input, head, baseTip, gateBase!, staleReason);
+    if (!window.ok) return { ok: false, reason: window.reason, baseTip, gateBase, windowCommits: window.windowCommits };
+    const review = checkReview(input, e, head, baseTip);
+    return review.ok
+      ? { ok: true, mode: 'base-advanced-disjoint', baseTip, gateBase: gateBase!, windowCommits: window.windowCommits, reviewResult: review.reviewResult }
+      : { ...review, gateBase, windowCommits: window.windowCommits };
+  };
+  if (!ancestor.ok) {
+    const notRebased = `not-rebased: ${input.remote}/${input.branch} ${baseTip.slice(0, 12)} is not an ancestor of ${head.slice(0, 12)}`;
+    return gateBase ? advanced(notRebased) : { ok: false, reason: notRebased, baseTip };
+  }
 
   // ② 재게이트 — 그 머리를, ① 의 그 base 끝 위에서.
-  const gate = e.gate;
   if (!gate || typeof gate !== 'object') return { ok: false, reason: 'gate-missing', baseTip };
   if (gate.passed !== true) return { ok: false, reason: 'gate-not-passed', baseTip };
   if (typeof gate.head !== 'string' || gate.head.toLowerCase() !== head) return { ok: false, reason: 'gate-head-mismatch', baseTip };
   if (typeof gate.baseCommit !== 'string' || gate.baseCommit.toLowerCase() !== baseTip.toLowerCase()) {
-    return { ok: false, reason: `gate-base-stale: gate ${String(gate.baseCommit).slice(0, 12)} ≠ ${input.remote}/${input.branch} ${baseTip.slice(0, 12)}`, baseTip };
+    const stale = `gate-base-stale: gate ${String(gate.baseCommit).slice(0, 12)} ≠ ${input.remote}/${input.branch} ${baseTip.slice(0, 12)}`;
+    return gateBase ? advanced(stale) : { ok: false, reason: stale, baseTip };
   }
 
   // ③ 리뷰 — 그 PR · 그 머리의 pass ⊕ must-fix 0.
@@ -110,22 +196,84 @@ function check(input: VerifyOverlapEvidenceInput): Checked {
   return review.ok ? { ok: true, mode: 'rebased', baseTip, reviewResult: review.reviewResult } : review;
 }
 
+export type AncestorAutoVerdict =
+  | { ok: true; mode: 'already-ancestor-auto'; reviewResult: string }
+  | { ok: false; reason: string };
+
+export interface VerifyAncestorAutoInput {
+  pr: number;
+  expectedHead: string;
+  cwd: string;
+  run: CmdRunner;
+  readFile: (path: string) => string;
+  /** 표준 자리 `<state>/review-results` — 이 안의 `*-<pr>-<head12>.json` 만 본다. */
+  reviewResultsDir: string;
+  listDir: (dir: string) => readonly string[];
+  /** 겹침 관문이 찾은 «겹친» 최근 착지 커밋들. */
+  overlappingLandings: readonly string[];
+}
+
+function checkAncestorAuto(input: VerifyAncestorAutoInput): AncestorAutoVerdict {
+  const head = input.expectedHead.toLowerCase();
+  const landings = input.overlappingLandings;
+  if (landings.length === 0) return { ok: false, reason: 'ancestor-auto-no-overlapping-landings' };
+  const notAncestor = landings.find((sha) => !(/^[0-9a-f]{7,40}$/i.test(sha)
+    && input.run('git', ['merge-base', '--is-ancestor', sha, head], { cwd: input.cwd }).ok));
+  if (notAncestor !== undefined) return { ok: false, reason: `ancestor-auto-not-ancestor: ${notAncestor.slice(0, 12)} is not an ancestor of ${head.slice(0, 12)}` };
+  let names: readonly string[];
+  try { names = input.listDir(input.reviewResultsDir); } catch { return { ok: false, reason: 'review-missing' }; }
+  const suffix = new RegExp(`-${input.pr}-${head.slice(0, 12)}\\.json$`, 'i');
+  // 같은 <pr>-<head12> 리뷰가 여럿이면 «전부» 통과해야 한다 — 하나라도 거부면 거부(fail-closed · 처음 통과한 하나로 승인하지 않는다).
+  let accepted: string | undefined;
+  for (const name of [...names].filter((n) => suffix.test(n)).sort()) {
+    const review = checkReview(input, { reviewResult: join(input.reviewResultsDir, name) }, head);
+    if (!review.ok) return { ok: false, reason: review.reason };
+    accepted = review.reviewResult;
+  }
+  return accepted === undefined ? { ok: false, reason: 'review-missing' } : { ok: true, mode: 'already-ancestor-auto', reviewResult: accepted };
+}
+
+/**
+ * 증거 파일이 없을 때의 already-ancestor 자동 판정 — 겹친 착지가 «전부» 고정 머리의 조상이고 표준 자리의 리뷰 결과가
+ * pass|warn ⊕ must-fix 0 이면 통과. 던지지 않는다 — 어떤 실패도 거부(fail-closed)이고 관측 한 줄을 남긴다.
+ */
+export function verifyAncestorAutoPass(input: VerifyAncestorAutoInput): AncestorAutoVerdict {
+  let verdict: AncestorAutoVerdict;
+  try { verdict = checkAncestorAuto(input); } catch (error) { verdict = { ok: false, reason: `verify-threw: ${String(error).slice(0, 200)}` }; }
+  debug.log('pr.land', 'overlap-evidence', {
+    decision: verdict.ok ? 'accepted' : 'rejected',
+    reason: verdict.ok ? 'already-ancestor-auto' : verdict.reason,
+    overlappingLandings: input.overlappingLandings,
+    pr: input.pr,
+    head: input.expectedHead,
+    evidencePath: null,
+    reviewResultsDir: input.reviewResultsDir,
+  });
+  return verdict;
+}
+
 /** 던지지 않는다 — 어떤 실패도 거부(fail-closed)이고 관측 한 줄을 남긴다. */
 export function verifyOverlapEvidence(input: VerifyOverlapEvidenceInput): OverlapEvidenceVerdict {
   let verdict: Checked;
   try { verdict = check(input); } catch (error) { verdict = { ok: false, reason: `verify-threw: ${String(error).slice(0, 200)}` }; }
   debug.log('pr.land', 'overlap-evidence', {
     decision: verdict.ok ? 'accepted' : 'rejected',
-    reason: verdict.ok ? (verdict.mode === 'already-ancestor' ? 'already-ancestor' : 'rebased+gated+reviewed') : verdict.reason,
+    reason: verdict.ok
+      ? (verdict.mode === 'already-ancestor' ? 'already-ancestor' : verdict.mode === 'base-advanced-disjoint' ? 'base-advanced-disjoint' : 'rebased+gated+reviewed')
+      : verdict.reason,
     overlappingLandings: input.overlappingLandings ?? [],
     pr: input.pr,
     head: input.expectedHead,
     base: `${input.remote}/${input.branch}`,
     baseTip: verdict.baseTip ?? null,
     evidencePath: input.evidencePath,
+    gateBase: (verdict.ok ? (verdict.mode === 'base-advanced-disjoint' ? verdict.gateBase : undefined) : verdict.gateBase) ?? null,
+    windowCommits: (verdict.ok ? (verdict.mode === 'base-advanced-disjoint' ? verdict.windowCommits : undefined) : verdict.windowCommits) ?? null,
   });
   if (!verdict.ok) return { ok: false, reason: verdict.reason };
-  return verdict.mode === 'already-ancestor'
-    ? { ok: true, mode: 'already-ancestor', reviewResult: verdict.reviewResult }
-    : { ok: true, mode: 'rebased', baseTip: verdict.baseTip!, reviewResult: verdict.reviewResult };
+  if (verdict.mode === 'already-ancestor') return { ok: true, mode: 'already-ancestor', reviewResult: verdict.reviewResult };
+  if (verdict.mode === 'base-advanced-disjoint') {
+    return { ok: true, mode: 'base-advanced-disjoint', baseTip: verdict.baseTip!, gateBase: verdict.gateBase, windowCommits: verdict.windowCommits, reviewResult: verdict.reviewResult };
+  }
+  return { ok: true, mode: 'rebased', baseTip: verdict.baseTip!, reviewResult: verdict.reviewResult };
 }

package/src/cli/pr-land-pod-shadow.ts

@@ -0,0 +1,54 @@
+/**
+ * PRLAND-HEAVY-ON-POD-1 — `pr land` 무거운 판정을 Pod 에서 그림자 리허설한다.
+ *
+ * 착지 경로에 아직 잇지 않는다. `--heavy-on-pod-shadow` 플래그·실제 Pod 러너 바인딩은
+ * 다음 조각(pr-cli.ts · pod-command-job.ts 무접촉). 이번 단위는 주입형 순수 함수만:
+ * 켜지면 가짜/실 Pod 러너를 한 번 부르고 `pr.land`/`heavy-on-pod-shadow` 관측 한 줄을 남긴 뒤
+ * 로컬 판정을 그대로 반환한다. 끄면 러너 0회. 러너가 던져도 경고 한 줄만 내고 로컬을 지킨다.
+ */
+
+export interface HeavyOnPodShadowInput<T> {
+  enabled: boolean;
+  pr: number;
+  head: string;
+  local: T;
+  runPod: () => T | Promise<T>;
+  log: (category: string, event: string, data: Record<string, unknown>) => void;
+  warn: (message: string) => void;
+}
+
+function agree(local: unknown, pod: unknown): boolean {
+  if (Object.is(local, pod)) return true;
+  try {
+    return JSON.stringify(local) === JSON.stringify(pod);
+  } catch {
+    return false;
+  }
+}
+
+function elapsedMs(started: number): number {
+  return Math.max(0, performance.now() - started);
+}
+
+export async function runHeavyOnPodShadow<T>(input: HeavyOnPodShadowInput<T>): Promise<T> {
+  const { enabled, pr, head, local, runPod, log, warn } = input;
+  if (!enabled) return local;
+
+  const localMs = 0;
+  const started = performance.now();
+  try {
+    const pod = await runPod();
+    log('pr.land', 'heavy-on-pod-shadow', {
+      pr,
+      head,
+      local,
+      pod,
+      agree: agree(local, pod),
+      podMs: elapsedMs(started),
+      localMs,
+    });
+  } catch (error) {
+    warn(error instanceof Error ? error.message : String(error));
+  }
+  return local;
+}

package/src/cli/release-cli.ts

@@ -5,8 +5,8 @@
 //   elanous release tag --version <x.y.z> --source <commit> [--yes]
 //   elanous release verify  [--version <x.y.z>]
 //   elanous release notes   --from <ref> [--to <ref>]
-//   elanous release run     --version <x.y.z> [--prerelease rc] [--main-cut | --cut-commit <sha>] [--publish-at <iso>] [--dry-run] [--json] [--if-ready]
-//   elanous release resume  --run <runId> --from <node> [--waive <node> --reason <text>] [--accepted-regressions <json>] [--json]
+//   elanous release run     --version <x.y.z> [--prerelease rc] [--main-cut | --cut-commit <sha>] [--publish-at <iso>] [--gate-executor <pod|host> [--gate-host <ssh-host>]] [--dry-run] [--json] [--if-ready]
+//   elanous release resume  --run <runId> --from <node> [--waive <node> --reason <text>] [--accepted-regressions <json>] [--gate-executor <pod|host> [--gate-host <ssh-host>]] [--json]
 //   elanous release auto-start [--window-minutes <n>] [--apply] [--json]
 //   elanous release rehearsal tick [--apply] [--checkout <dir>] [--json]
 //   elanous release preflight --version <x.y.z> [--publish-at <iso>] [--json]   (컷 30분 전 사전 점검 · 읽기 전용 · ⛔ 있으면 exit 1)
@@ -989,7 +989,7 @@ export function registerReleaseCommands(program: Command, releaseRunDeps: Unatte
     .action(async (o: { version: string; base: string; pick: string[]; append?: boolean; dryRun?: boolean; json?: boolean }) => {
       await jsonAction(o.json, async (log) => cutReleaseBranch({ ...o, log }), () => true);
     });
-  const runAction = async (o: { version: string; cutCommit?: string; mainCut?: boolean; prerelease?: string; dryRun?: boolean; ifReady?: boolean; publishAt?: string; forceFreeze?: boolean; json?: boolean }, logRun = console.log): Promise<boolean | AutoStartDeferral | undefined> => {
+  const runAction = async (o: { version: string; cutCommit?: string; mainCut?: boolean; prerelease?: string; dryRun?: boolean; ifReady?: boolean; publishAt?: string; forceFreeze?: boolean; gateExecutor?: string; gateHost?: string; json?: boolean }, logRun = console.log): Promise<boolean | AutoStartDeferral | undefined> => {
       // Only the rc rehearsal channel is operated for now (alpha/beta stay valid version shapes, not run options).
       if (o.prerelease !== undefined && o.prerelease !== 'rc') {
         const message = `--prerelease supports rc only: ${o.prerelease}`;
@@ -1038,7 +1038,7 @@ export function registerReleaseCommands(program: Command, releaseRunDeps: Unatte
           const outcome = await runReleaseIfReady(o.version, {
             ledgerRoot: releaseRunDeps.ledgerRoot,
             readiness: (version, options) => releaseReadiness(version, { ledgerRoot: releaseRunDeps.ledgerRoot, checklist: releaseRunDeps.checklist, ...options }),
-            run: () => runUnattendedRelease({ version: o.version, cutCommit: o.cutCommit, mainCut: o.mainCut, prerelease, forceFreeze: o.forceFreeze, publishAt: o.publishAt }, releaseRunDeps),
+            run: () => runUnattendedRelease({ version: o.version, cutCommit: o.cutCommit, mainCut: o.mainCut, prerelease, forceFreeze: o.forceFreeze, publishAt: o.publishAt, gateExecutor: o.gateExecutor, gateHost: o.gateHost }, releaseRunDeps),
           });
           if (outcome.skipped) {
             if (o.json) await writeStdoutJson(`${JSON.stringify(outcome)}\n`);
@@ -1066,7 +1066,7 @@ export function registerReleaseCommands(program: Command, releaseRunDeps: Unatte
         }
       }
       await jsonAction(o.json, async (log) => {
-        const result = await runUnattendedRelease({ version: o.version, dryRun: o.dryRun, cutCommit: o.cutCommit, mainCut: o.mainCut, prerelease, forceFreeze: o.forceFreeze, publishAt: o.publishAt }, releaseRunDeps);
+        const result = await runUnattendedRelease({ version: o.version, dryRun: o.dryRun, cutCommit: o.cutCommit, mainCut: o.mainCut, prerelease, forceFreeze: o.forceFreeze, publishAt: o.publishAt, gateExecutor: o.gateExecutor, gateHost: o.gateHost }, releaseRunDeps);
         log(`${result.dryRun ? '· 드라이런' : '▶ 릴리스 루프'} ${result.input.version} · 입력 ${JSON.stringify(result.input)}`);
         return result;
       }, (r) => r.dryRun || r.state?.status === 'done' || r.state?.status === 'awaiting-approval');
@@ -1081,8 +1081,10 @@ export function registerReleaseCommands(program: Command, releaseRunDeps: Unatte
     .option('--if-ready', '준비되지 않았으면 사유를 출력하고 성공으로 건너뛴다')
     .option('--publish-at <iso>', '승인·선행 노드 통과 뒤 지정 시각까지 발행 대기(오프셋 포함 ISO 시각)')
     .option('--force-freeze', '동결 중 게이트·발행 강행(관측 기록) — 가지 컷은 동결이 필요 없다 · 동결은 비상 스위치로 남는다')
+    .option('--gate-executor <pod|host>', 'gate 노드 실행기(기본 pod) — host 는 Pod 대신 SSH 호스트의 깨끗한 클론에서 같은 판정(면제 아님)')
+    .option('--gate-host <ssh-host>', '--gate-executor host 의 SSH 호스트(기본 release.loop.gateRemote)')
     .option('--json', '결과 한 줄 JSON(stdout) · 사람 줄은 stderr')
-    .action(async (o: { version: string; cutCommit?: string; mainCut?: boolean; prerelease?: string; dryRun?: boolean; ifReady?: boolean; publishAt?: string; forceFreeze?: boolean; json?: boolean }) => { await runAction(o); });
+    .action(async (o: { version: string; cutCommit?: string; mainCut?: boolean; prerelease?: string; dryRun?: boolean; ifReady?: boolean; publishAt?: string; forceFreeze?: boolean; gateExecutor?: string; gateHost?: string; json?: boolean }) => { await runAction(o); });
   release.command('preflight')
     .description('컷 30분 전 사전 점검(읽기 전용) — 체크리스트 게이트 모의 · 발행 뒤 칸 · run --dry-run 입력 · 동결 · 일정/게이트 실측. ⛔ 있으면 exit 1')
     .requiredOption('--version <v>', '점검할 판(x.y.z)')
@@ -1105,17 +1107,18 @@ export function registerReleaseCommands(program: Command, releaseRunDeps: Unatte
     .description('가벼운 RC 점검 — 직전 판 컷(또는 --base) 이후 변경 범위 self gate ⊕ 상시 목록(release/light-rc-always.txt)을 원격 게이트 호스트에서 · 새 회귀(introduced>0)면 exit 1')
     .requiredOption('--version <v>', '점검할 판(x.y.z)')
     .option('--base <ref>', '비교 기준(기본: git merge-base origin/main origin/release/<원장 직전 판>)')
+    .option('--head <ref>', '잴 커밋(기본: git fetch origin main 뒤 origin/main — 작업 트리 HEAD 가 아니다 · 다르면 분리 체크아웃에서 잰다)')
     .option('--remote <host>', '게이트 호스트(기본 config gateRemote.host)')
     .option('--local', '원격 대신 이 기계에서 돌린다(원격 자식이 이것으로 다시 불린다)')
     .option('--shards <n>', '시험 분할 수', '4')
     .option('--json', '결과 한 줄 JSON(stdout) · 사람 줄은 stderr')
-    .action(async (o: { version: string; base?: string; remote?: string; local?: boolean; shards: string; json?: boolean }) => {
+    .action(async (o: { version: string; base?: string; head?: string; remote?: string; local?: boolean; shards: string; json?: boolean }) => {
       // The root strips `--local` from argv (remote-bookmark attach) before Commander sees it — same read as `self gate`.
       const local = !!o.local || process.argv.slice(2).includes('--local');
       await jsonAction(o.json, async (log) => {
         if (o.remote !== undefined && local) throw new Error('release light-rc: --remote and --local cannot be combined');
         const shards = Number(o.shards);
-        const result = await runLightRc(o.version, { base: o.base, remote: o.remote, local, shards, ledgerRoot: releaseRunDeps.ledgerRoot, log: (l) => console.error(l) }, lightRcDeps);
+        const result = await runLightRc(o.version, { base: o.base, head: o.head, remote: o.remote, local, shards, ledgerRoot: releaseRunDeps.ledgerRoot, log: (l) => console.error(l) }, lightRcDeps);
         for (const line of formatLightRc(result)) log(line);
         return result;
       }, (r) => r.ok);
@@ -1124,12 +1127,15 @@ export function registerReleaseCommands(program: Command, releaseRunDeps: Unatte
     .description('실패한 릴리스 런을 이어 달린다 — cut-branch --append 로 고친 release/<v> 새 끝을 version-release 기록에 반영(빨리감기만·상태 백업) 뒤 --from 노드부터')
     .requiredOption('--run <runId>', '실패한 release-loop 런 ID')
     .requiredOption('--from <node>', '다시 시작할 노드(예: gate)')
-    .option('--partial', 'GATE-PARTIAL — --from gate 에서 앞 게이트 뒤 바뀐 시험 파일 ⊕ 앞 실패 파일만 다시 돈다(시험·문서만 바뀐 경우 · 아니면 전체 게이트로)')
+    .option('--partial', 'GATE-PARTIAL — --from gate 에서 바뀐 시험 ⊕ 앞 실패 ⊕ 바뀐 코드에 import 로 닿는 시험만 다시 돈다(끝이 움직인 --from gate 는 기본 · 의심이면 전체 게이트)')
+    .option('--no-partial', 'GATE-REUSE-BY-DIFF 기본 부분 재검을 끄고 전체 게이트')
     .option('--waive <node>', '저장된 실패 노드 한 개를 면제(--from 은 그 노드 그대로)')
     .option('--reason <text>', '면제 사유 — 공개 알려진 문제에 들어갈 사용자 영향 설명')
     .option('--accepted-regressions <json>', '알려진 문제 추가 입력 JSON 배열 [{"id":"…","note":"…"}]')
+    .option('--gate-executor <pod|host>', '다시 도는 gate 의 실행기 전환(--from gate 이전만) — 런 입력에 기록 · 면제 아님')
+    .option('--gate-host <ssh-host>', '--gate-executor host 의 SSH 호스트(기본 저장된 런 입력 gateRemote)')
     .option('--json', '결과 한 줄 JSON(stdout)')
-    .action(async (o: { run: string; from: string; partial?: boolean; waive?: string; reason?: string; acceptedRegressions?: string; json?: boolean }) => {
+    .action(async (o: { run: string; from: string; partial?: boolean; waive?: string; reason?: string; acceptedRegressions?: string; gateExecutor?: string; gateHost?: string; json?: boolean }) => {
       await jsonAction(o.json, async (log) => {
         let acceptedRegressions: AcceptedRegression[] | undefined;
         if (o.acceptedRegressions !== undefined) {
@@ -1143,12 +1149,17 @@ export function registerReleaseCommands(program: Command, releaseRunDeps: Unatte
         const result = await resumeReleaseRun({ runId: o.run, from: o.from, partial: o.partial,
           ...(o.waive === undefined ? {} : { waive: o.waive }),
           ...(o.reason === undefined ? {} : { reason: o.reason }),
-          ...(o.acceptedRegressions === undefined ? {} : { acceptedRegressions }) });
+          ...(o.acceptedRegressions === undefined ? {} : { acceptedRegressions }),
+          ...(o.gateExecutor === undefined ? {} : { gateExecutor: o.gateExecutor }),
+          ...(o.gateHost === undefined ? {} : { gateHost: o.gateHost }) });
+        const override = result.state.inputOverrides?.at(-1);
+        if (o.gateExecutor !== undefined && override) log(`⇄ gate 실행기 ${override.set.gateExecutor}${override.set.gateRemote ? ` @ ${override.set.gateRemote}` : ''} (런 입력에 기록 · 면제 아님)`);
         if (result.partial.requested) log(result.partial.applied
-          ? `◐ 부분 재검: ${result.partial.files}파일 · 나머지는 앞 게이트(${result.partial.priorCommit.slice(0, 12)}) 결과를 잇는다`
+          ? `◐ 부분 재검${result.partial.auto ? '(기본)' : ''}: ${result.partial.files}파일${result.partial.closure ? ` (코드 닿음 ${result.partial.closure.reached} · 닫힘 불투명 ${result.partial.closure.opaque})` : ''} · 나머지는 앞 게이트(${result.partial.priorCommit.slice(0, 12)}) 결과를 잇는다`
           : `● 전체 게이트로: ${result.partial.reason}`);
         log(`${result.tip.changed ? `↻ ${result.tip.branch} ${result.tip.from.slice(0, 12)} → ${result.tip.to.slice(0, 12)} (백업 ${result.tip.backup})` : `· ${result.tip.branch} 끝 그대로 ${result.tip.to.slice(0, 12)}`} · ${o.from} 부터 → ${result.state.status}`);
-        return { tip: result.tip, partial: result.partial, status: result.state.status, runId: result.state.runId };
+        return { tip: result.tip, partial: result.partial, status: result.state.status, runId: result.state.runId,
+          ...(o.gateExecutor !== undefined && result.state.inputOverrides?.length ? { gateExecutor: result.state.inputOverrides.at(-1) } : {}) };
       }, (r) => r.status === 'done' || r.status === 'awaiting-approval');
     });
   release.command('rehearsal').description('판 일정에서 컷 전 가벼운 RC 두 단계').command('tick')
@@ -1175,14 +1186,14 @@ export function registerReleaseCommands(program: Command, releaseRunDeps: Unatte
         const result = await autoStartScheduledRelease({
           windowMinutes: Number(o.windowMinutes), apply: o.apply, ledgerRoot: scheduleLedgerRoot(),
           readiness: (version, ledgerRoot, now) => releaseReadiness(version, { ledgerRoot, now: () => now, checklist: releaseRunDeps.checklist }),
-          launch: async (version) => {
-            const ran = await runAction({ version, ifReady: true, json: false }, log);
+          launch: async (version, launchOptions) => {
+            const ran = await runAction({ version, ifReady: true, publishAt: launchOptions?.publishAt, json: false }, log);
             if (ran && typeof ran === 'object' && ran.deferred) return ran;
             if (ran !== true) throw new Error(`release run 미시작 또는 실패: ${version}`);
           },
         });
         if (result.status === 'planned') log(`· 미리 보기 ${result.version} · 컷 ${result.cutAt} · 실행하려면 --apply`);
-        else if (result.status === 'started') log(`▶ 릴리스 시작 ${result.version} · 컷 ${result.cutAt}`);
+        else if (result.status === 'started') log(`▶ 릴리스 시작 ${result.version} · 컷 ${result.cutAt}${result.publishAt ? ` · 발행 ${result.publishAt}` : ''}`);
         else if (result.status === 'skipped') log(`· 릴리스 연기 ${result.version} · ${result.reason}`);
         else log('· 선택할 컷 없음');
         return result;

package/src/cli/release-run-if-ready.ts

@@ -2,6 +2,8 @@ import { closeSync, mkdirSync, openSync, rmSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { debug } from '../debug/log.js';
 import { releaseLedgerRoot } from '../instance/resolve.js';
+import { adviseLaunch, compareLaunchAdvice } from '../harness/launch-advice.js';
+import type { QueuePool } from '../harness/harness-queue.js';
 import type { ReleaseReadiness } from '../../scripts/release-loop/release-readiness.js';
 
 export type ReleaseIfReadySkip = { skipped: true; reason: Exclude<ReleaseReadiness, { ready: true }>['reason']; detail: string };
@@ -12,6 +14,8 @@ export async function runReleaseIfReady<T>(version: string, deps: {
   ledgerRoot?: string;
   pid?: number;
   now?: () => Date;
+  advice?: typeof adviseLaunch;
+  pool?: () => QueuePool | undefined;
 }): Promise<ReleaseIfReadySkip | { skipped: false; result: T }> {
   const skip = (readiness: Exclude<ReleaseReadiness, { ready: true }>): ReleaseIfReadySkip => {
     const detail = readiness.reason === 'checklist-blocked'
@@ -40,6 +44,13 @@ export async function runReleaseIfReady<T>(version: string, deps: {
     const insideLock = await deps.readiness(version, { isPidAlive: () => false });
     if (!insideLock.ready) return skip(insideLock);
     debug.log('release-loop.readiness', 'ready', { version });
+    try {
+      const advice = (deps.advice ?? adviseLaunch)({ pool: deps.pool?.(), caller: 'release-run' });
+      const { kind } = compareLaunchAdvice(advice, 'launched');
+      debug.log('resource.advice', 'launch-advice', { caller: 'release-run', verdict: advice.verdict, why: advice.why, actual: 'launched', kind, version });
+    } catch {
+      // Shadow only: a throwing advice seam must never affect the launch decision or result.
+    }
     return { skipped: false, result: await deps.run() };
   } finally {
     closeSync(fd);

package/src/cli/resource-cli.ts

@@ -0,0 +1,48 @@
+import type { Command } from 'commander';
+import { debug } from '../debug/log.js';
+import { TRAFFIC_SEATS, type TrafficResult } from '../loops/orchestrator/traffic.js';
+import { observeLoopResources } from '../nexus/api/loop-resources.js';
+import { writeStdoutJson } from './stdout-json.js';
+
+/** 칸 제목은 여러 줄(«대상 경로:»·«신설:» …)이다 — 표의 한 칸에는 첫 줄만, 상한을 넘으면 «…» 로 자른 것을 표시한다. */
+export const RESOURCE_TITLE_MAX_CHARS = 60;
+export function oneLineTitle(title: string): string {
+  const first = (title.split(/\r?\n/).find((line) => line.trim()) ?? '').replace(/\s+/g, ' ').trim();
+  return first.length > RESOURCE_TITLE_MAX_CHARS ? `${first.slice(0, RESOURCE_TITLE_MAX_CHARS - 1)}…` : first;
+}
+
+/** Read-only CLI view of the same traffic snapshot returned by the Nexus resource GET. */
+export function registerResourceCommands(program: Command, observe: () => TrafficResult = observeLoopResources): void {
+  program.command('resource').description('자리별 루프 자원 관측 (읽기 전용)')
+    .command('status').description('자리별 공급·다음 칸·임대 상태')
+    .option('--json', '관측 스냅샷 JSON 출력')
+    .action(async (opts: { json?: boolean }) => {
+      let resource: TrafficResult;
+      try { resource = observe(); }
+      catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        debug.log('resource.loop', 'status-read', { readStatus: 'unreadable', seats: null, cells: null });
+        process.exitCode = 1;
+        if (opts.json) await writeStdoutJson(JSON.stringify({ readStatus: 'unreadable', reason }) + '\n');
+        else console.error(`resource status: 못 읽음 — ${reason}`);
+        return;
+      }
+      debug.log('resource.loop', 'status-read', {
+        readStatus: 'ok', seats: resource.seats.length,
+        cells: resource.seats.filter(row => row.nextCell !== null).length,
+      });
+      if (opts.json) {
+        await writeStdoutJson(JSON.stringify({ resource, readStatus: 'ok' }) + '\n');
+        return;
+      }
+      console.log('자리\t쓰는 자리/공급\t다음 칸\t임대(빌림/빌려줌)\t대기 이유');
+      for (const seat of TRAFFIC_SEATS) {
+        const row = resource.seats.find(item => item.seat === seat);
+        if (!row) { console.log(`${seat}\t못 읽음\t못 읽음\t못 읽음\t자리 관측 없음`); continue; }
+        const cell = row.nextCell;
+        const reason = !cell ? '다음 칸 없음' : row.launchCap <= row.running ? '발사 자리 없음' : '다음 칸 대기';
+        console.log(`${seat}\t${row.running}/${row.cap}\t${cell ? `1 · ${cell.id} ${oneLineTitle(cell.title)}` : '0'}\t${row.borrowed}/${row.lent}\t${reason}`);
+      }
+      if (resource.unassigned > 0) console.log(`미배정\t${resource.unassigned}`);
+    });
+}

package/src/cli/retro-cli.ts

@@ -1,8 +1,10 @@
 import { existsSync } from 'node:fs';
 import type { Command } from 'commander';
+import { readRunExits } from '../harness/harness-incidents.js';
+import { effectiveInstanceRoot } from '../instance/resolve.js';
 import { LogStore, logsDbPath } from '../mss/logging/log-store.js';
 
-type RetroFact = { store: string; at: string; category: string; event: string; kind: 'draft-birth' | 'draft-death' | 'stop-reason' | 'ta-outcome'; data: unknown };
+type RetroFact = { store: string; at: string; category: string; event: string; kind: 'draft-birth' | 'draft-death' | 'stop-reason' | 'ta-outcome' | 'incident'; data: unknown };
 
 const FACT_EVENTS = new Map<string, RetroFact['kind']>([
   ['rework-blocked-draft-pr', 'draft-birth'],
@@ -21,7 +23,7 @@ export function parseRetroSince(value: string, now = Date.now()): number {
   return now - duration;
 }
 
-export function collectRetroFacts(sinceMs: number, targets: readonly { name: string; dbPath: string }[] = [{ name: 'current', dbPath: logsDbPath() }]): { facts: RetroFact[]; unavailable: string[] } {
+export function collectRetroFacts(sinceMs: number, targets: readonly { name: string; dbPath: string }[] = [{ name: 'current', dbPath: logsDbPath() }], incidentRoot?: string): { facts: RetroFact[]; unavailable: string[] } {
   const facts: RetroFact[] = [];
   const unavailable: string[] = [];
   const untilMs = Date.now();
@@ -53,13 +55,20 @@ export function collectRetroFacts(sinceMs: number, targets: readonly { name: str
       } finally { store.close(); }
     } catch { unavailable.push(target.name); }
   }
+  try {
+    for (const row of readRunExits(incidentRoot ?? effectiveInstanceRoot())) {
+      if (Date.parse(row.at) < sinceMs) continue;
+      facts.push({ store: 'incidents', at: row.at, category: 'harness.incident', event: row.reason, kind: 'incident',
+        data: { runId: row.runId, seat: row.seat, entrance: row.entrance } });
+    }
+  } catch { unavailable.push('incidents'); }
   facts.sort((a, b) => b.at.localeCompare(a.at));
   return { facts, unavailable };
 }
 
 export function registerRetroCommands(program: Command): void {
   program.command('retro').description('Read-only retrospective facts from existing logs')
-    .command('facts').description('Draft births/deaths, stop reasons and task-agent outcomes')
+    .command('facts').description('Draft births/deaths, stop reasons, task-agent outcomes and run incidents')
     .option('--since <duration>', 'Lookback duration', '24h')
     .option('--json', 'JSON output')
     .action((opts: { since: string; json?: boolean }) => {