elanous 0.2.24 → 0.2.27

package/scripts/release-loop/ops-upgrade-node.ts

@@ -9,7 +9,7 @@ import { prereleaseKind } from './release-version.js';
 interface HostResult { host: string; ok: boolean; before: string; after: string; error?: string; skipped?: string; hooks?: string; restart?: 'no-service' }
 /** Where the internal feed is packed from: a checkout of the release tag, never the run's working tree. */
 export interface FeedSource { checkout: string; commit: string; deps: 'linked' | 'installed'; cleanup: () => void }
-interface OpsUpgradeDeps { exists?: (path: string) => boolean; installSource?: () => string | null; feedSource?: (version: string) => FeedSource }
+interface OpsUpgradeDeps { exists?: (path: string) => boolean; installSource?: () => string | null; installCommit?: () => string | null; feedSource?: (version: string) => FeedSource }
 
 /** Detached worktree at refs/tags/v<version> with the PWA built — the feed ships what was released (10-04 0.2.11:
  *  packing process.cwd() shipped main HEAD ee689ad2 as «0.2.11» to node-b·cloud-vm instead of the cut 31129c91). */
@@ -52,16 +52,24 @@ export function tagFeedSource(run: CommandRunner, repo: string = process.cwd()):
   };
 }
 
-function localInstallSource(): string | null {
+function installMetadata(text: string): { source: string | null; commit: string | null } {
   try {
-    const data: unknown = JSON.parse(readFileSync(join(homedir(), '.local/share/elanous/install.json'), 'utf8'));
-    return data && typeof data === 'object' && 'source' in data && typeof data.source === 'string' ? data.source : null;
-  } catch { return null; }
+    const data: unknown = JSON.parse(text);
+    if (!data || typeof data !== 'object') return { source: null, commit: null };
+    return {
+      source: 'source' in data && typeof data.source === 'string' ? data.source : null,
+      commit: 'commit' in data && typeof data.commit === 'string' ? data.commit : null,
+    };
+  } catch { return { source: null, commit: null }; }
+}
+
+function localInstallMetadata(): { source: string | null; commit: string | null } {
+  try { return installMetadata(readFileSync(join(homedir(), '.local/share/elanous/install.json'), 'utf8')); }
+  catch { return { source: null, commit: null }; }
 }
 
-function installedMatches(installed: unknown, version: string, checkout: boolean): boolean {
-  return installed === version || checkout && typeof installed === 'string'
-    && installed.startsWith(`${version}-`) && /^[0-9a-f]{12}$/.test(installed.slice(version.length + 1));
+function installedMatches(installed: unknown, version: string): boolean {
+  return installed === version;
 }
 
 function missingService(data: Record<string, unknown> | undefined): boolean {
@@ -116,17 +124,21 @@ export function runOpsUpgrade(run: CommandRunner = runCommand, deps: OpsUpgradeD
   }
   const results: HostResult[] = [];
   for (const host of hosts as string[]) {
-    const source = host === 'local' ? (deps.installSource ?? localInstallSource)() : null;
-    const checkout = host === 'local' && source !== null && isAbsolute(source);
-    const path = checkout ? 'checkout' as const : 'release' as const;
+    // Injected install metadata replaces the machine's install.json entirely — a test that injects only the source
+    //   must not inherit this machine's real commit (that turned update cases into kept-ahead skips).
+    const injected = deps.installSource !== undefined || deps.installCommit !== undefined;
+    let metadata: { source: string | null; commit: string | null } = host !== 'local'
+      ? { source: null, commit: null }
+      : injected
+        ? { source: deps.installSource?.() ?? null, commit: deps.installCommit?.() ?? null }
+        : localInstallMetadata();
+    let source = metadata.source;
+    let railSource = false;
+    let path: 'checkout' | 'release' = 'release';
     const record = (result: HostResult) => {
       results.push(result);
       debug.log('release-loop.ops-upgrade', 'host', { host, path, restart: result.restart ?? (context.input.opsRestart === true ? result.ok ? 'ok' : 'failed' : 'skipped'), ok: result.ok });
     };
-    if (host !== 'local' && feedError) {
-      record({ host, ok: false, before: '', after: '', skipped: '내부 피드 발행 실패', error: feedError });
-      continue;
-    }
     const command = (args: string[]): CommandResult => host === 'local'
       ? run('elanous', args)
       // The installer's own bin dir comes first — a --no-modify-path install (the bot VM) has elanous only there.
@@ -134,35 +146,41 @@ export function runOpsUpgrade(run: CommandRunner = runCommand, deps: OpsUpgradeD
     let before = '';
     let after = '';
     try {
+      if (host !== 'local') {
+        const installed = run('ssh', [host, `cat "$HOME/.local/share/elanous/install.json" 2>/dev/null || true`]);
+        if (installed.status === 0) metadata = installMetadata(installed.stdout);
+      }
+      source = metadata.source;
+      if (source !== null && isAbsolute(source)) {
+        const repository = host === 'local'
+          ? run('git', ['rev-parse', '--is-inside-work-tree'], source)
+          : run('ssh', [host, `git -C ${quote(source)} rev-parse --is-inside-work-tree`]);
+        railSource = repository.status === 0 && firstLine(repository.stdout) === 'true';
+      }
+      path = railSource ? 'checkout' : 'release';
       const previous = command(['--version']);
       if (previous.status === 0) before = firstLine(previous.stdout);
-      if (checkout) {
-        const git = (args: string[]) => run('git', args, source!);
-        const dirty = git(['status', '--porcelain', '--untracked-files=all']);
-        if (dirty.status !== 0 || dirty.stdout.trim()) {
-          record({ host, ok: false, before, after, error: dirty.status === 0 ? '체크아웃 변경 있음' : `체크아웃 상태 확인 실패: ${reason(dirty)}` });
-          continue;
-        }
-        const fetched = git(['fetch', '--tags']);
-        if (fetched.status !== 0) {
-          record({ host, ok: false, before, after, error: `태그 가져오기 실패: ${reason(fetched)}` });
-          continue;
-        }
-        const tag = git(['rev-parse', '--verify', `refs/tags/v${version}^{commit}`]);
-        if (tag.status !== 0 || !tag.stdout.trim()) {
-          record({ host, ok: false, before, after, error: `태그 없음: v${version}` });
-          continue;
-        }
-        const moved = git(['checkout', '--detach', `v${version}`]);
-        if (moved.status !== 0) {
-          record({ host, ok: false, before, after, error: `체크아웃 전환 실패: ${reason(moved)}` });
+      if (railSource) {
+        record({ host, ok: true, before, after: before, skipped: 'rail-source' });
+        continue;
+      }
+      const installedCommit = metadata.commit;
+      if (installedCommit && /^[0-9a-f]{40,64}$/.test(installedCommit)) {
+        const ahead = run('git', ['merge-base', '--is-ancestor', `refs/tags/v${version}`, installedCommit]);
+        // Only exit 1 proves non-ancestry; missing local objects must not permit a potentially destructive downgrade.
+        if (ahead.status !== 1) {
+          record({ host, ok: true, before, after: before, skipped: 'kept-ahead' });
           continue;
         }
       }
-      const updated = command(['update', ...(checkout || host !== 'local' && feedPath !== undefined ? [] : ['--version', version]), '--json', ...(context.input.opsRestart === true ? ['--restart'] : [])]);
+      if (host !== 'local' && feedError) {
+        record({ host, ok: false, before, after: '', skipped: '내부 피드 발행 실패', error: feedError });
+        continue;
+      }
+      const updated = command(['update', ...(host !== 'local' && feedPath !== undefined ? [] : ['--version', version]), '--json', ...(context.input.opsRestart === true ? ['--restart'] : [])]);
       const updateResult = lastResult(updated);
       const noService = host !== 'local' && context.input.opsRestart === true && updateResult?.exitCode === 1 && missingService(updateResult);
-      if ((!noService && (updated.status !== 0 || updateResult?.exitCode !== 0)) || !installedMatches(updateResult?.installedVersion, version, checkout)) {
+      if ((!noService && (updated.status !== 0 || updateResult?.exitCode !== 0)) || !installedMatches(updateResult?.installedVersion, version)) {
         const error = (updated.status === 0 && updateResult?.exitCode === 0 || noService)
           ? `설치판 불일치 (기대 ${version}, 실제 ${String(updateResult?.installedVersion)})` : reason(updated);
         record({ host, ok: false, before, after, error });
@@ -174,7 +192,7 @@ export function runOpsUpgrade(run: CommandRunner = runCommand, deps: OpsUpgradeD
         continue;
       }
       after = firstLine(current.stdout);
-      if (!installedMatches(after.split(/\s+/)[0], version, checkout)) {
+      if (!installedMatches(after.split(/\s+/)[0], version)) {
         record({ host, ok: false, before, after, error: `올렸는데 판이 그대로 (기대 ${version}, 실제 ${after || '없음'})` });
         continue;
       }
@@ -198,14 +216,17 @@ export function runOpsUpgrade(run: CommandRunner = runCommand, deps: OpsUpgradeD
     feed: feedError ? 'failed' as const : feedPath === undefined ? 'skipped-no-path' as const : 'published' as const, hosts: results };
 }
 
-if (import.meta.main) {
+function main(): void {
   let version = '';
   try {
     version = readGraphContext().input.version;
     // RELEASE-REHEARSAL-RC: a prerelease never lands docs on main or upgrades the operating hosts.
-    process.exitCode = finishNode('ops-upgrade', version, prereleaseKind(version) !== null
-      ? { outcome: 'ok', verdict: 'pass', summary: `ops-upgrade skipped — ${version} is a prerelease`, skipped: 'prerelease' }
-      : runOpsUpgrade());
+    const result = prereleaseKind(version) !== null
+      ? { outcome: 'ok' as const, verdict: 'pass' as const, summary: `ops-upgrade skipped — ${version} is a prerelease`, skipped: 'prerelease' }
+      : runOpsUpgrade(runCommand);
+    process.exitCode = finishNode('ops-upgrade', version, result);
   }
   catch (error) { process.exitCode = finishNode('ops-upgrade', version, errorResult(error)); }
 }
+
+if (import.meta.main) main();

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

@@ -5,6 +5,7 @@ import { join } from 'node:path';
 import { WARNING_ONLY } from './auto-approve-node.js';
 import { beginLandingMerge, landingFreezeMessage } from '../../src/release-loop/landing-freeze.js';
 import { debug } from '../../src/debug/log.js';
+import { registerStandaloneLogSink } from '../../src/domains/standalone-log-sink.js';
 import { prereleaseKind } from './release-version.js';
 import { publishAtError } from './publish-at.js';
 import { errorResult, finishNode, lastResult, nodeOutput, readGraphContext, runCommand, type CommandRunner } from './node-verdict.js';
@@ -115,6 +116,11 @@ export function runPublish(run: CommandRunner = runCommand, prodFreezeRoot?: str
 }
 
 if (import.meta.main) {
+  // GATE-OBS2-2 — the release graph spawns this node as its own process, which inherits no daemon sink. Without this the
+  // `release-loop.publish / result` event (the one that says whether the irreversible publication actually happened) stayed
+  // in the file trail and `elanous logs` read 0 rows. Same pattern as gate-node.ts and auto-approve-node.ts (GATE-OBS2-1).
+  // Observability must never stop the publication node — a failed sink registration is skipped (fail-soft).
+  try { await registerStandaloneLogSink('release-loop'); } catch { /* fail-soft: the verdict still goes to stdout */ }
   let version = '';
   try { version = readGraphContext().input.version; process.exitCode = finishNode('publish', version, runPublish()); }
   catch (error) { process.exitCode = finishNode('publish', version, errorResult(error)); }

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

@@ -10,6 +10,7 @@ import { lastJsonObject, runGraph, type GraphRunState } from '../../src/graph-ru
 import { releaseRunUniverse } from './release-universe.js';
 import { isReleaseVersion } from './release-version.js';
 import { changedFilesBetween, clearPartialPlan, planPartialRegate, writePartialPlan } from './gate-partial.js';
+import { gitClosureTree, testsReachingChanged, type ClosureTree } from './gate-closure.js';
 import { releaseResumeAcceptedRegressions, releaseResumeGateExecutor, releaseResumeWaiver, type AcceptedRegression } from './resume.js';
 
 const GRAPH = join(import.meta.dir, '../../graphs/release/release-loop.yaml');
@@ -29,8 +30,15 @@ export interface ResumeReleaseDeps {
   now?: () => Date;
   /** Machine release ledger (gate-failures.json of the prior gate) — default releaseLedgerRoot(). */
   ledgerRoot?: string;
+  /** GATE-REUSE-BY-DIFF: the tip tree for the import closure — default read from git objects of the tip commit. */
+  closureTree?: (commit: string) => ClosureTree;
 }
 
+/** CLI entry files: a production file that only names one (help text, a goal's command line) does not run it. */
+const CLI_ENTRIES = ['bin/elanous.mjs', 'src/index.ts'] as const;
+/** The gate's own test-file set (gate-node sweep: `git ls-files '*.test.*'` filtered by this). */
+const GATE_TEST = /\.test\.(?:tsx?|jsx?|mts|cts)$/;
+
 export interface TipRefresh { version: string; branch: string; from: string; to: string; changed: boolean; statePath: string; backup?: string }
 
 function gitRunner(repo: string) {
@@ -114,18 +122,25 @@ export function refreshReleaseBranchTip(runId: string, deps: ResumeReleaseDeps =
   return { version, branch, from: recorded, to, changed: true, statePath, backup };
 }
 
-/** GATE-PARTIAL outcome of a resume — applied (plan written) or the reason it fell back to a full gate. */
-export type PartialOutcome = { requested: false } | { requested: true; applied: true; files: number; priorCommit: string } | { requested: true; applied: false; reason: string };
+/** GATE-PARTIAL outcome of a resume — applied (plan written) or the reason it fell back to a full gate. `auto` marks the
+ *  default plan of `--from gate` (GATE-REUSE-BY-DIFF); `closure` is set when code changes were followed. */
+export type PartialOutcome = { requested: false }
+  | { requested: true; applied: true; files: number; priorCommit: string; auto?: true; closure?: { reached: number; opaque: number } }
+  | { requested: true; applied: false; reason: string; auto?: true };
 
-/** Build (or clear) the partial re-gate plan for the new tip. Fail-closed: any doubt leaves a full gate. */
+/** Build (or clear) the partial re-gate plan for the new tip. Fail-closed: any doubt leaves a full gate.
+ *  GATE-REUSE-BY-DIFF: `--from gate` on a moved tip plans by default (`partial: undefined`); `partial: false` opts out. */
 function preparePartial(tip: TipRefresh, opts: { from: string; partial?: boolean }, deps: ResumeReleaseDeps): PartialOutcome {
   const root = deps.root ?? effectiveInstanceRoot();
-  // Any resume starts from no plan: one without --partial (from whatever node) never inherits an older plan.
+  // Any resume starts from no plan: one without a partial plan (from whatever node) never inherits an older plan.
   clearPartialPlan(root, tip.version);
-  if (!opts.partial) return { requested: false };
+  const auto = opts.partial === undefined;
+  // The default applies only where it can help: a gate re-run on a tip that moved. An unchanged tip re-uses its own
+  // shard results by commit already.
+  if (opts.partial === false || (auto && (opts.from !== 'gate' || !tip.changed))) return { requested: false };
   const fallback = (reason: string): PartialOutcome => {
-    debug.log('release-loop.resume', 'partial-fallback', { version: tip.version, reason });
-    return { requested: true, applied: false, reason };
+    debug.log('release-loop.resume', 'partial-fallback', { version: tip.version, reason, auto });
+    return { requested: true, applied: false, reason, ...(auto ? { auto: true as const } : {}) };
   };
   if (opts.from !== 'gate') return fallback('--partial only applies to --from gate');
   if (!tip.changed) return fallback('release branch tip unchanged — nothing new to re-check');
@@ -151,12 +166,23 @@ function preparePartial(tip: TipRefresh, opts: { from: string; partial?: boolean
     // The tip is already refreshed — a failed diff must not strand the resume: run the full gate and say why.
     return fallback(`changed files unreadable: ${String(error instanceof Error ? error.message : error).slice(0, 200)}`);
   }
+  // The tip tree (git objects of tip.to, never the working tree): existence of planned tests ⊕ the import closure.
+  let tree: ClosureTree;
+  try { tree = (deps.closureTree ?? ((commit: string) => gitClosureTree(deps.repo ?? process.cwd(), commit)))(tip.to); }
+  catch (error) { return fallback(`tip tree unreadable: ${String(error instanceof Error ? error.message : error).slice(0, 200)}`); }
+  const tracked = new Set(tree.files);
+  const tests = tree.files.filter((file) => GATE_TEST.test(file));
   const planned = planPartialRegate({ version: tip.version, priorCommit: tip.from, forCommit: tip.to, changedFiles: changed,
-    priorFailures: prior.failures as string[], priorErrors: (prior.errors ?? []) as string[] });
+    priorFailures: prior.failures as string[], priorErrors: (prior.errors ?? []) as string[],
+    existsAtTip: (file) => tracked.has(file),
+    closure: (changedCode) => testsReachingChanged(tree, changedCode, tests, { cliEntries: CLI_ENTRIES }) });
   if (!planned.ok) return fallback(planned.reason);
+  if (planned.plan.files.length >= tests.length) return fallback(`every test is re-run (${tests.length}) — full gate`);
   const path = writePartialPlan(root, planned.plan);
-  debug.log('release-loop.resume', 'partial-planned', { version: tip.version, priorCommit: tip.from, commit: tip.to, files: planned.plan.files.length, path });
-  return { requested: true, applied: true, files: planned.plan.files.length, priorCommit: tip.from };
+  debug.log('release-loop.resume', 'partial-planned', { version: tip.version, priorCommit: tip.from, commit: tip.to, files: planned.plan.files.length,
+    tests: tests.length, auto, path, ...(planned.closure ? { reached: planned.closure.reached, opaque: planned.closure.opaque } : {}) });
+  return { requested: true, applied: true, files: planned.plan.files.length, priorCommit: tip.from,
+    ...(auto ? { auto: true as const } : {}), ...(planned.closure ? { closure: planned.closure } : {}) };
 }
 
 /** The graph file the run started from — a snapshot run refuses any other path (the installed CLI's own copy differs). */
@@ -183,6 +209,7 @@ export async function resumeReleaseRun(opts: { runId: string; from: string; part
   if (gateExecutor) debug.log('release-loop.resume', 'gate-executor', { runId: opts.runId, from: opts.from, executor: gateExecutor.set.gateExecutor, host: gateExecutor.set.gateRemote ?? null, previous: gateExecutor.previous });
   const waiver = original && (opts.waive !== undefined || opts.reason !== undefined)
     ? releaseResumeWaiver(original, opts) : undefined;
+  if (waiver) debug.log('release-loop.resume', 'waiver', { runId: opts.runId, node: waiver.nodeId, reason: waiver.reason, unmeasured: waiver.unmeasured ?? null });
   const acceptedRegressions = original && opts.acceptedRegressions !== undefined && !waiver
     ? releaseResumeAcceptedRegressions(original, opts.acceptedRegressions, opts.from) : undefined;
   // A waived verdict may reuse its original commit. A moved tip still requires a full re-gate.

package/scripts/release-loop/resume.ts

@@ -1,4 +1,4 @@
-import type { GraphRunState } from '../../src/graph-runner/runner.js';
+import { lastJsonObject, STOPPED_NODE_ERROR, type GraphRunState } from '../../src/graph-runner/runner.js';
 import { publicWaiverReason } from './known-issues-node.js';
 import { checkGateExecutorChoice, type GateExecutor } from './gate-executor.js';
 
@@ -28,11 +28,66 @@ export function releaseResumeAcceptedRegressions(state: GraphRunState, additions
   return combined;
 }
 
+const SWEEP_INCOMPLETE = /^(?:pod sweep incomplete|sweep incomplete|[\w-]+ shard incomplete)\b/;
+
+/**
+ * RELEASE-WAIVE-UNMEASURED — why the saved gate record at `index` carries no verdict, or undefined when it does (or may).
+ * Fail-closed: only three shapes count, each read from what the runner and gate-node actually write:
+ *  ① stopped — `graph runs stop` wrote {ok:false, executed:false, exit:null, error:STOPPED_NODE_ERROR} as the run's last record;
+ *  ② no verdict — the gate process ended with exit null (signal, idle timeout, or a spawn that failed) and printed no result line at
+ *     all (no output line is a JSON object with an `outcome`), so the run went gate → failed. A verdict followed by more
+ *     log lines and then a kill is still a verdict: refused;
+ *  ③ sweep incomplete — gate-node printed outcome `error` (no verdict: the baseline comparison never ran, so `introduced`
+ *     is still the empty initial list) and the error is an incomplete sweep (stalled shards / no tests ran). The finished
+ *     shards' counts go into the detail. Any other error (cleanup, baseline persistence, …) may follow a verdict: refused.
+ * An `outcome: fail` (introduced > 0), an introduced list that is not empty, or an already-waived record is never unmeasured.
+ */
+/** Any output line that is a JSON object naming an `outcome` — a verdict was printed, whatever came after it. */
+function printedVerdict(output: unknown): boolean {
+  if (typeof output !== 'string') return false;
+  return output.split('\n').some((line) => {
+    const text = line.trim();
+    if (!text.startsWith('{')) return false;
+    try { const value = JSON.parse(text) as unknown; return !!value && typeof value === 'object' && 'outcome' in value; } catch { return false; }
+  });
+}
+
+export function gateUnmeasuredDetail(state: GraphRunState, index: number): string | undefined {
+  const record = state.nodes[index];
+  if (!record || record.nodeId !== 'gate' || state.path[index] !== 'gate' || record.ok !== false || record.waiver !== undefined) return undefined;
+  if (state.nodes.some((saved) => saved.nodeId === 'gate' && saved !== record)) return undefined;
+  const last = index === state.path.length - 1 && index === state.nodes.length - 1;
+  if (last && record.executed === false && record.exit === null && record.error === STOPPED_NODE_ERROR && record.output === undefined) {
+    return `stopped: ${STOPPED_NODE_ERROR}${typeof record.seconds === 'number' ? ` after ${record.seconds}s` : ''}`;
+  }
+  const failedAfter = index === state.path.length - 2 && state.path.at(-1) === 'failed' && state.nodes.at(-1)?.nodeId === 'failed'
+    && state.nodes.length === state.path.length;
+  if (!failedAfter || record.executed !== true) return undefined;
+  const result = lastJsonObject(record.output);
+  if (result === undefined) {
+    if (record.exit !== null || printedVerdict(record.output)) return undefined;
+    return `no-verdict: gate process ended with exit null and no result line${record.error ? ` — ${record.error.split('\n')[0]!.slice(0, 120)}` : ''}`;
+  }
+  if (result.outcome !== 'error' || !Array.isArray(result.introduced) || result.introduced.length !== 0) return undefined;
+  const error = typeof result.error === 'string' ? result.error : '';
+  if (!SWEEP_INCOMPLETE.test(error)) return undefined;
+  // The detail keeps what WAS measured: each stalled shard's reason and the finished shards' counts (failures there are
+  // not yet split into introduced vs pre-existing — the baseline comparison never ran).
+  const stalled = Array.isArray(result.stalledShards) ? result.stalledShards as Array<{ reason?: unknown }> : [];
+  const reasons = new Map<string, number>();
+  for (const shard of stalled) reasons.set(String(shard?.reason ?? 'unknown'), (reasons.get(String(shard?.reason ?? 'unknown')) ?? 0) + 1);
+  const summary = result.partialSummary as { pass?: unknown; fail?: unknown; errors?: unknown; ran?: unknown } | undefined;
+  const measured = summary && typeof summary === 'object'
+    ? ` · finished shards measured pass ${String(summary.pass)} fail ${String(summary.fail)} errors ${String(summary.errors)} ran ${String(summary.ran)}` : '';
+  return `sweep incomplete: ${error.split('\n')[0]!.slice(0, 200)}`
+    + (stalled.length ? ` · stalled shards ${stalled.length} (${[...reasons].map(([reason, count]) => `${reason}×${count}`).join(', ')})` : '') + measured;
+}
+
 /** Only the recorded failure at the restart boundary may be waived. `--from` is never a waiver. */
 export function releaseResumeWaiver(
   state: GraphRunState,
   opts: { from: string; waive?: string; reason?: string; acceptedRegressions?: AcceptedRegression[] },
-): { nodeId: string; reason: string; acceptedRegressions: AcceptedRegression[] } | undefined {
+): { nodeId: string; reason: string; acceptedRegressions: AcceptedRegression[]; unmeasured?: string } | undefined {
   if ((opts.waive === undefined) !== (opts.reason === undefined)) throw new Error('--waive <node> and --reason <text> must be supplied together');
   if (opts.waive !== undefined && !opts.waive.trim()) throw new Error('--waive must not be empty');
   if (opts.waive === undefined) return undefined;
@@ -41,13 +96,23 @@ export function releaseResumeWaiver(
   publicWaiverReason(reason);
   if (opts.from !== opts.waive) throw new Error('--from must name the waived node; --from alone does not waive a failure');
   const index = state.path.indexOf(opts.waive);
-  if (index < 0 || state.path.lastIndexOf(opts.waive) !== index || state.nodes[index]?.nodeId !== opts.waive || state.nodes[index]?.ok !== false ||
+  const unique = index >= 0 && state.path.lastIndexOf(opts.waive) === index;
+  // RELEASE-WAIVE-UNMEASURED (OP 10-12): a gate cut before any verdict is the only gate that may be waived — a measured gate
+  // failure or an already-waived gate stays refused (fail-closed below), and the ledger records why it was unmeasured.
+  const unmeasured = opts.waive === 'gate' && unique ? gateUnmeasuredDetail(state, index) : undefined;
+  if (unmeasured !== undefined) {
+    return { nodeId: opts.waive, reason, unmeasured, acceptedRegressions: releaseResumeAcceptedRegressions(state,
+      [...(opts.acceptedRegressions ?? []), { id: `waive:${opts.waive}`, note: reason }]) };
+  }
+  if (!unique || state.path.lastIndexOf(opts.waive) !== index || state.nodes[index]?.nodeId !== opts.waive || state.nodes[index]?.ok !== false ||
     state.nodes[index]?.executed !== true || state.path.at(-2) !== opts.waive || state.path.at(-1) !== 'failed' || state.nodes.at(-1)?.nodeId !== 'failed') {
     throw new Error(`--waive ${opts.waive} requires the failed executable node on the saved path`);
   }
   // Only user-visible, non-publication checks can become accepted regressions; build, safety and approval gates stay blocking.
+  // A measured gate failure (outcome fail / introduced > 0, or any error that is not an incomplete sweep) lands here too.
   if (!['mac-smoke', 'tui'].includes(opts.waive)) {
-    throw new Error(`--waive ${opts.waive} cannot waive a safety, side-effect or approval node`);
+    throw new Error(`--waive ${opts.waive} cannot waive a safety, side-effect or approval node`
+      + (opts.waive === 'gate' ? ' (only an unmeasured gate — stopped, killed or sweep incomplete — may be waived)' : ''));
   }
   return { nodeId: opts.waive, reason, acceptedRegressions: releaseResumeAcceptedRegressions(state,
     [...(opts.acceptedRegressions ?? []), { id: `waive:${opts.waive}`, note: reason }]) };

package/scripts/tsc-baseline-cache.ts

@@ -1,6 +1,6 @@
 /**
  * 승격 착지의 base 쪽 tsc 진단을 «main 커밋별로 한 번만» 재고 재사용하는 캐시.
- * 키 = base sha ⊕ tsc 명령 ⊕ 설정 파일(base 커밋에서 git show 로 읽은 내용) 해시 ⊕ tsc 판.
+ * 키 = base sha ⊕ tsc 명령 ⊕ 설정 파일(base 커밋에서 git show 로 읽은 내용) 해시 ⊕ 작업 트리 설치 키(bun.lock 실물) ⊕ tsc 판.
  * 값 = rebase 전 정규화 진단(워크트리 절대 경로는 «<ROOT>» 자리표로 저장).
  * ⛔ 캐시 실패는 호출자에게 던지지 않는다 — 읽기·쓰기 모두 miss 로 떨어진다.
  */
@@ -13,7 +13,7 @@ import type { TypecheckError } from '../src/typecheck-ratchet.js';
 
 export const ROOT_PLACEHOLDER = '<ROOT>';
 export const BASELINE_CACHE_MAX_ENTRIES = 50;
-const CACHE_FORMAT = 1;
+const CACHE_FORMAT = 2;
 
 /** 키에 들어가는 «기준 커밋의 설정 파일» — 이 중 하나라도 달라지면 같은 sha 라도 다른 진단이다. */
 export const BASELINE_CACHE_CONFIG_FILES = ['tsconfig.gate.json', 'apps/pwa/tsconfig.json', 'tsconfig.pwa-env.json', 'tsconfig.json', 'bun.lock'] as const;
@@ -24,6 +24,8 @@ export interface BaselineCacheOptions {
   env?: NodeJS.ProcessEnv;
   /** git 실행 심 — 출력 바이트를 돌려주고 실패하면 던진다. */
   git?: (args: string[], cwd: string) => Buffer;
+  /** 작업 트리 설치 파일 읽기 심 — 파일 바이트를 돌려주고 읽을 수 없으면 던진다. */
+  readInstallFile?: (path: string) => Buffer;
   /** tsc 판 조회 심. */
   tscVersion?: (cwd: string) => string;
   maxEntries?: number;
@@ -59,6 +61,27 @@ function defaultTscVersion(cwd: string): string {
   }
 }
 
+/** 키에 들어가는 «작업 트리에 실제로 깔린 판» — base 쪽 bun.lock 이 같아도 설치가 다르면 진단이 다르다. */
+const BASELINE_CACHE_INSTALL_FILES = ['bun.lock', 'apps/pwa/bun.lock'] as const;
+
+/**
+ * 지금 트리에 실제로 깔린 판의 키 — 작업 트리 루트 `bun.lock`(⊕ 있으면 `apps/pwa/bun.lock`) 파일 해시.
+ * 루트 `bun.lock` 을 못 읽으면 undefined(호출자는 캐시 없이 잰다 — base 키 규율과 같다) · `apps/pwa/bun.lock` 은 못 읽으면 absent.
+ */
+export function workingTreeInstallKey(cwd: string, options: Pick<BaselineCacheOptions, 'readInstallFile'> = {}): string | undefined {
+  const read = options.readInstallFile ?? ((path: string) => readFileSync(path));
+  const files: Record<string, string> = {};
+  for (const file of BASELINE_CACHE_INSTALL_FILES) {
+    try {
+      files[file] = createHash('sha256').update(read(join(cwd, file))).digest('hex');
+    } catch {
+      if (file === 'bun.lock') return undefined;
+      files[file] = 'absent';
+    }
+  }
+  return createHash('sha256').update(JSON.stringify(files)).digest('hex');
+}
+
 /** 키를 못 만들면(base 를 sha 로 풀 수 없음 등) undefined — 호출자는 캐시 없이 잰다. */
 export function computeBaselineCacheKey(base: string, command: string, cwd: string, options: BaselineCacheOptions = {}): string | undefined {
   try {
@@ -73,8 +96,10 @@ export function computeBaselineCacheKey(base: string, command: string, cwd: stri
         files[file] = 'absent';
       }
     }
+    const install = workingTreeInstallKey(cwd, options);
+    if (install === undefined) return undefined;
     const tsc = (options.tscVersion ?? defaultTscVersion)(cwd);
-    return createHash('sha256').update(JSON.stringify({ format: CACHE_FORMAT, sha, command, files, tsc })).digest('hex');
+    return createHash('sha256').update(JSON.stringify({ format: CACHE_FORMAT, sha, command, files, install, tsc })).digest('hex');
   } catch {
     return undefined;
   }

package/scripts/usage-rollup.ts

@@ -15,8 +15,11 @@ export interface UsageRow { site: string; provider: string; model: string; calls
 
 type UsageData = { site?: string; provider?: string; billingProvider?: string; model?: string; inputTokens?: number; outputTokens?: number; cacheReadInputTokens?: number; cacheCreationInputTokens?: number; cost?: { kind?: string; usd?: number }; podRollupKey?: string; partial?: boolean; partialSeq?: number; partialAt?: string };
 
+/** 재방출 행 dedup 에 필요한 칸만 — 호스트 소비처(bench-report · `elanous usage`)도 같은 규칙을 쓴다. */
+export type PodRollupKeyed = { podRollupKey?: unknown; partial?: unknown; partialSeq?: unknown; partialAt?: unknown };
+
 /** 같은 podRollupKey 두 행 중 어느 쪽이 더 완전한가 — 최종 > 부분 · 부분끼리는 seq 큰 쪽 · 같으면 at 늦은 쪽. 완전히 같으면 앞 행을 둔다. */
-function rollupRowBeats(next: UsageData, kept: UsageData): boolean {
+function rollupRowBeats(next: PodRollupKeyed, kept: PodRollupKeyed): boolean {
   const nextFinal = next.partial !== true;
   const keptFinal = kept.partial !== true;
   if (nextFinal !== keptFinal) return nextFinal;
@@ -27,31 +30,42 @@ function rollupRowBeats(next: UsageData, kept: UsageData): boolean {
   return String(next.partialAt ?? '') > String(kept.partialAt ?? '');
 }
 
+/** ⭐ METER-POD-ROLLUP-GAP-2 — 같은 Pod 사용량의 재방출(부분 ⊕ 최종 · abort ⊕ resume)을 podRollupKey 로 한 번만 남긴다.
+ *  들어온 순서가 아니라 «더 완전한 행»을 남기고(rollupRowBeats), 키 없는 행은 그대로 다 둔다(순서 보존). */
+export function dedupePodRollupRows<T>(rows: readonly T[], dataOf: (row: T) => PodRollupKeyed = (row) => row as PodRollupKeyed): T[] {
+  const kept: T[] = [];
+  const keptIndexByKey = new Map<string, number>();
+  for (const row of rows) {
+    const d = dataOf(row);
+    if (typeof d.podRollupKey === 'string') {
+      const at = keptIndexByKey.get(d.podRollupKey);
+      if (at !== undefined) {
+        if (rollupRowBeats(d, dataOf(kept[at]!))) kept[at] = row;
+        continue;
+      }
+      keptIndexByKey.set(d.podRollupKey, kept.length);
+    }
+    kept.push(row);
+  }
+  return kept;
+}
+
 export function rollup(lines: readonly string[]): { rows: UsageRow[]; truncated: boolean } {
   const by = new Map<string, UsageRow>();
   // ⭐ MF-3c0d253e — 같은 Pod 사용량의 재방출(부분 ⊕ 최종 · abort ⊕ resume)은 podRollupKey 로 한 번만 센다(이중계상 방지).
   //   들어온 순서가 아니라 «더 완전한 행»을 남긴다(최종 > 부분 · seq · at — rollupRowBeats).
   //   키가 없는 행(기존 경로 전부)은 종전과 동작·바이트 그대로다.
   let truncated = false;
-  const entries: UsageData[] = [];
-  const keptIndexByPodRollupKey = new Map<string, number>();
+  const parsed: UsageData[] = [];
   for (const line of lines) {
     if (/limitReached=true|truncated/.test(line) && !line.startsWith('{')) truncated = true;
     if (!line.startsWith('{')) continue;
     let r: { event?: string; data?: Record<string, unknown> };
     try { r = JSON.parse(line); } catch { continue; }
     if (r.event !== 'llm-usage' || !r.data) continue;
-    const d = r.data as UsageData;
-    if (typeof d.podRollupKey === 'string') {
-      const keptIndex = keptIndexByPodRollupKey.get(d.podRollupKey);
-      if (keptIndex !== undefined) {
-        if (rollupRowBeats(d, entries[keptIndex]!)) entries[keptIndex] = d;
-        continue;
-      }
-      keptIndexByPodRollupKey.set(d.podRollupKey, entries.length);
-    }
-    entries.push(d);
+    parsed.push(r.data as UsageData);
   }
+  const entries = dedupePodRollupRows(parsed);
   for (const d of entries) {
     const provider = d.billingProvider ?? d.provider ?? '?';   // ⭐ 과금 주체 우선(B10)
     const key = `${d.site ?? '?'}|${provider}|${d.model ?? '?'}`;

package/scripts/ux-sim.ts

@@ -13,6 +13,9 @@
 //   bun scripts/ux-sim.ts --computer-use normal --from-run <runId> --save-trajectory <name> # 이름으로 저장
 //   bun scripts/ux-sim.ts --computer-use normal --trajectory <name> # 저장한 궤적을 재생
 //   bun scripts/ux-sim.ts --list-trajectories # 저장한 궤적과 출처 목록
+//   bun scripts/ux-sim.ts --fault cred-expiry # 결함 주입: grok 구독 만료 임박 × 갱신 결과 → 디스패처·발사 판정
+//   bun scripts/ux-sim.ts --fault pod-death   # 결함 주입: PARTIAL 줄을 남긴 Pod 가 SIGTERM 으로 지워짐 → 호스트 재방출 판정
+//   bun scripts/ux-sim.ts --fault pool-cap    # 결함 주입: --pod-pool 에 :N 이 빠진 풀 → 승인 판정(limitedBy)
 //
 // ⛔ 이 CLI 는 «실제 위젯 render()» 를 부른다 — 흉내 렌더러가 아니다.
 import { simRenderLogFrame } from '../src/ux-sim/render-frame.js';
@@ -33,7 +36,7 @@ const argv = process.argv.slice(2);
 //  ⛔ 그래서 「알려진 플래그」를 «한 곳»에 두고, 그 밖의 `--` 인자는 거부한다.
 const KNOWN_FLAGS = new Set([
   '--list', '--list-trajectories', '--computer-use', '--trajectory', '--from-run',
-  '--save-trajectory', '--esc', '--queue', '--width', '--height', '--draft',
+  '--save-trajectory', '--esc', '--queue', '--width', '--height', '--draft', '--fault',
 ]);
 {
   const unknown = argv.filter((a) => a.startsWith('--') && !KNOWN_FLAGS.has(a.split('=')[0]));
@@ -46,6 +49,32 @@ const KNOWN_FLAGS = new Set([
 }
 if (argv.includes('--list')) { console.log([...PHASES, 'computer-use: normal | capture-stalls | capture-fails | target-missing'].join('\n')); process.exit(0); }
 
+{
+  // `--fault=<이름>` 꼴도 받는다 — KNOWN_FLAGS 는 등호 꼴을 통과시키므로 여기서 놓치면 조용히 기본 국면으로 빠진다.
+  const eq = argv.find((a) => a.startsWith('--fault='));
+  if (eq) argv.splice(argv.indexOf(eq), 1, '--fault', eq.slice('--fault='.length));
+}
+if (argv.includes('--fault')) {
+  const fault = argv[argv.indexOf('--fault') + 1];
+  if (fault === 'cred-expiry') {
+    const { credExpirySweep, renderCredExpiry } = await import('../src/ux-sim/fault-cred-expiry.js');
+    console.log(renderCredExpiry(credExpirySweep()).join('\n'));
+    process.exit(0);
+  }
+  if (fault === 'pod-death') {
+    const { simPodDeath, renderPodDeath } = await import('../src/ux-sim/fault-pod-death.js');
+    console.log(renderPodDeath(simPodDeath()).join('\n'));
+    process.exit(0);
+  }
+  if (fault === 'pool-cap') {
+    const { poolCapSweep, renderPoolCap } = await import('../src/ux-sim/fault-pool-cap.js');
+    console.log(renderPoolCap(poolCapSweep()).join('\n'));
+    process.exit(0);
+  }
+  console.error(`⛔ 모르는 결함이다: ${fault ?? '(없음)'} — 아는 것: cred-expiry · pod-death · pool-cap`);
+  process.exit(2);
+}
+
 if (argv.includes('--list-trajectories')) {
   const { listSavedBrowserActionTrajectories } = await import('../src/harness/browser-trajectory.js');
   const saved = listSavedBrowserActionTrajectories();

package/skills/youtube-master/scripts/main.ts

@@ -10,7 +10,7 @@ import { fetchSupadataTranscript, judgeTranscriptSufficiency } from '../src/tran
 import { downloadAudio, splitAudio } from '../src/audio.js';
 import { transcribeChunks } from '../src/stt.js';
 import { summarize, parseMetaFromSummary } from '../src/summarize.js';
-import { getSaveDir, saveMarkdown, prepareRunDir, persistArtifacts } from '../src/obsidian.js';
+import { getSaveDir, saveMarkdown, prepareRunDir, persistArtifacts, saveSkipNotice } from '../src/obsidian.js';
 import { classifyDomain, stagingEnabled, stagingSubdir } from '../src/domain-staging.js';
 import { buildStudyNote } from '../src/study-note.js';
 import { decideRoute } from '../src/router.js';
@@ -203,6 +203,7 @@ async function main() {
     });
     console.log(`  저장 완료: ${savedPath}`);
   }
+  const skipNotice = savedPath === null ? saveSkipNotice(route.target, saveDir) : null;
 
   if (flags.print) {
     console.log('\n---BEGIN_YOUTUBE_MASTER_MARKDOWN---\n');
@@ -211,6 +212,8 @@ async function main() {
   }
 
   outputSignals(route);
+
+  if (skipNotice) console.log(skipNotice);
 }
 
 // ── Transcript acquisition (auto-fallback) ──

package/skills/youtube-master/src/obsidian.ts

@@ -21,6 +21,15 @@ export function getStudyNoteSaveDir(): string | null {
   return join(vaultRoot, ...sub.split('/'));
 }
 
+const SAVE_SKIP_NOTICE =
+  '저장 안 됨 · OBSIDIAN_VAULT_ROOT 가 없다 · 고칠 한 줄: export OBSIDIAN_VAULT_ROOT=<vault 경로>';
+
+/** target 이 obsidian 인데 saveDir 이 없으면 세 칸 안내, 아니면 null. */
+export function saveSkipNotice(target: string, saveDir: string | null): string | null {
+  if (target === 'obsidian' && saveDir == null) return SAVE_SKIP_NOTICE;
+  return null;
+}
+
 /* ── Artifact persistence (Cloud STT path) ── */
 
 export async function prepareRunDir(saveDir: string, meta: VideoMeta, videoId: string): Promise<string> {