elanous 0.2.25 → 0.2.28

package/scripts/coord-requests-bridge.ts

@@ -7,10 +7,17 @@ import { registerStandaloneLogSink } from '../src/domains/standalone-log-sink.js
 import { effectiveInstanceRoot } from '../src/instance/resolve.js';
 import trackData from './coord-tracks.json';
 
-type Comment = { id: number; body: string; created_at: string; html_url: string };
+export type CoordChannelComment = { id: number; body: string; created_at: string; html_url: string };
 type Options = { seat: string; channel: string; since?: string; dryRun: boolean; json: boolean };
 const seatIds = new Set(trackData.tracks.map((track) => track.id));
 
+/** Shared channel retrieval. Callers validate the complete result before changing a ledger. */
+export function fetchCoordChannelComments(channel: string, since?: string): CoordChannelComment[] {
+  const endpoint = `repos/{owner}/{repo}/issues/${channel}/comments${since ? `?since=${encodeURIComponent(since)}` : ''}`;
+  const output = execFileSync('gh', ['api', endpoint, '--paginate', '--jq', '.[]'], { encoding: 'utf8', maxBuffer: 64 * 1024 * 1024 });
+  return output.split('\n').filter(Boolean).map((line) => JSON.parse(line) as CoordChannelComment);
+}
+
 function options(args: string[]): Options {
   let seat = '';
   let channel = '23032';
@@ -98,15 +105,13 @@ async function run(args: string[]): Promise<void> {
     seat = selected.seat;
     const { channel, since, dryRun, json } = selected;
     reason = 'gh';
-    const endpoint = `repos/{owner}/{repo}/issues/${channel}/comments${since ? `?since=${encodeURIComponent(since)}` : ''}`;
-    const output = execFileSync('gh', ['api', endpoint, '--paginate', '--jq', '.[]'], { encoding: 'utf8', maxBuffer: 64 * 1024 * 1024 });
-    const comments = output.split('\n').filter(Boolean).map((line) => JSON.parse(line) as unknown);
+    const comments = fetchCoordChannelComments(channel, since);
     reason = 'ledger';
     const path = join(effectiveInstanceRoot(), 'seat-requests', 'requests.jsonl');
     const seen = existingSeatComments(path);
     let picked = 0, added = 0, existing = 0;
     for (const item of comments) {
-      const comment = item as Partial<Comment>;
+      const comment = item as Partial<CoordChannelComment>;
       if (typeof comment.id !== 'number' || !Number.isSafeInteger(comment.id) || typeof comment.body !== 'string'
         || typeof comment.created_at !== 'string' || typeof comment.html_url !== 'string') throw new Error('gh api 댓글 필드가 잘못됐다');
       if (since && Date.parse(comment.created_at) < Date.parse(since)) continue;

package/scripts/detect-test-interference.ts

@@ -26,6 +26,9 @@ export type MeasuredRun = {
   fail: number | null;
   status: 'measured' | 'unmeasurable';
   reason?: string;
+  /** Names observed in Bun's failed-test output. Absent names must not be inferred from the selected files. */
+  failedFiles?: string[];
+  failedTests?: string[];
 };
 
 export type InterferenceReport = {
@@ -61,6 +64,32 @@ export function parseFailureCount(output: string): number | null {
   return Number(failures[0]![1]);
 }
 
+/** Bun prints a file heading before its `(fail) name` lines. Only retain names actually printed by that run. */
+export function parseFailedTestNames(output: string): { files: string[]; tests: string[] } {
+  const files = new Set<string>();
+  const tests = new Set<string>();
+  let currentFile: string | undefined;
+  for (const raw of output.replace(/\x1b\[[0-9;]*m/g, '').split(/\r?\n/)) {
+    const line = raw.trim();
+    if (/^(?:\d+\s+(?:pass|fail|skip)|Ran\s+\d+\s+tests?|Bun test v)/i.test(line)) { currentFile = undefined; continue; }
+    const failure = /^\(fail\)\s+(.+?)(?:\s+\[[^\]]+\])?$/.exec(line);
+    if (failure) {
+      tests.add(failure[1]!.trim());
+      if (currentFile) files.add(currentFile);
+      continue;
+    }
+    const heading = /^(.+):$/.exec(line);
+    if (heading) currentFile = /\.(?:test|spec)\.[cm]?[jt]sx?$/.test(heading[1]!) ? heading[1] : undefined;
+  }
+  return { files: [...files], tests: [...tests] };
+}
+
+export function failedNamesFromStreams(result: RunnerResult): { files: string[]; tests: string[] } {
+  const stdout = parseFailedTestNames(result.stdout);
+  const stderr = parseFailedTestNames(result.stderr);
+  return { files: [...new Set([...stdout.files, ...stderr.files])], tests: [...new Set([...stdout.tests, ...stderr.tests])] };
+}
+
 async function measure(files: readonly string[], runner: TestRunner): Promise<MeasuredRun> {
   try {
     const result = await runner(files);
@@ -68,9 +97,10 @@ async function measure(files: readonly string[], runner: TestRunner): Promise<Me
       return { files: [...files], fail: null, status: 'unmeasurable', reason: result.signal ? `runner terminated by ${result.signal}` : 'runner exit code unavailable' };
     }
     const fail = parseFailureCount(`${result.stdout}${result.stderr}`);
+    const names = fail !== null && fail > 0 ? failedNamesFromStreams(result) : undefined;
     return fail === null
       ? { files: [...files], fail: null, status: 'unmeasurable', reason: 'test summary unavailable, ambiguous, or ran zero files' }
-      : { files: [...files], fail, status: 'measured' };
+      : { files: [...files], fail, status: 'measured', ...(names?.files.length ? { failedFiles: names.files } : {}), ...(names?.tests.length ? { failedTests: names.tests } : {}) };
   } catch (error) {
     return { files: [...files], fail: null, status: 'unmeasurable', reason: error instanceof Error ? error.message : String(error) };
   }

package/scripts/expose-rubric-suggest.ts

@@ -28,7 +28,7 @@ function measure(run: () => Criterion): Criterion {
 export function suggestExposeRubric(root: string, files?: readonly string[], help?: HelpRunner, rulesPath?: string): Suggestion[] {
   const names = files ?? readdirSync(join(root, DOCS)).filter((name) => name.endsWith('.md')).map((name) => `${DOCS}/${name}`);
   const paths = [...new Set(names.map((name) => relative(root, resolve(root, name)).split(sep).join('/')))];
-  if (paths.some((path) => !/^release\/public\/docs\/[^/]+\.md$/.test(path))) throw new Error('문서 경로는 release/public/docs/*.md 이어야 합니다');
+  if (paths.some((path) => !/^(?:release\/public\/docs\/[^/]+|docs\/marketing\/BLOG-[^/]+)\.md$/.test(path))) throw new Error('문서 경로는 release/public/docs/*.md 또는 docs/marketing/BLOG-*.md 이어야 합니다');
   type HelpResult = ReturnType<HelpRunner> & { failure?: string };
   let helpRuns = 0;
   const rootHelp: (args: string[]) => HelpResult = help ?? ((args) => {

package/scripts/measure-tsc-affected-roots.ts

@@ -1,3 +1,10 @@
+/**
+ * Measures the changed-file gate against the whole program on recently merged PRs.
+ * The narrowed run is the gate's default root check (changed .ts ∪ direct importers), so `missed` / `same` judge that mode:
+ * the run pins TSC_GATE_ROOTS to a non-`full` value and disables the rollback switch
+ * even when the caller's shell requests a full run.
+ * `missed > 0` is reverted without a code change by running the gate with env `TSC_GATE_ROOTS=full`.
+ */
 import { spawn } from 'node:child_process';
 import { mkdtempSync, rmSync } from 'node:fs';
 import { tmpdir } from 'node:os';
@@ -223,7 +230,9 @@ async function measurePr(repo: string, pr: Pr, run: Runner, platform: NodeJS.Pla
     const added = compareDiagnostics(current, baseline);
     if (added.kind === 'unavailable') throw new Error(added.reason);
     result.addedDiagnostics = added.added;
-    const gateRun = await timed(run, platform, 'bun', ['scripts/ci-typecheck-changed.ts', '--local'], worktree, { ...process.env, TSC_BASE_REF: base });
+    const gateRun = await timed(run, platform, 'bun', ['scripts/ci-typecheck-changed.ts', '--local'], worktree, {
+      ...process.env, TSC_BASE_REF: base, TSC_GATE_ROOTS: 'affected', ELANOUS_TSC_AFFECTED_ROOTS: '1',
+    });
     result.narrowed = elapsed(gateRun, platform);
     result.gateExitCode = gateRun.status;
     const seen = gateDiagnostics(gateRun, worktree);

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

@@ -130,7 +130,11 @@ export function runDocs(
 const SHA = /^[0-9a-f]{40}$/i;
 const PREFETCH_DEADLINE_MS = 15 * 60_000;
 type Cut = { version: string; commit: string; manifestHash: string };
-type PrefetchCache = Cut & { main: string; tree: string; docs: DocsResult; tui: Record<string, unknown> | null };
+// Two separately published cache files: a finished TUI must survive a docs failure or delay,
+// so it never lives inside the same file as the docs result (should-fix ②).
+type TuiCache = Cut & { tui: Record<string, unknown> };
+type DocsCache = Cut & { main: string; tree: string; docs: DocsResult };
+type PrefetchCache = DocsCache & { tui: Record<string, unknown> | null };
 type Runner = (command: string, args: string[], cwd?: string, timeout?: number, env?: NodeJS.ProcessEnv) => string;
 export const commandRunner: Runner = (command, args, cwd, timeout, env) => {
   const output = spawnSync(command, args, { cwd, env: env ?? process.env, timeout: timeout ?? 15 * 60_000, encoding: 'utf8', maxBuffer: 16 * 1024 * 1024 });
@@ -162,11 +166,27 @@ function claimPrefetch(dir: string, owner: 'worker' | 'docs'): boolean {
 function cacheFile(dir: string, cut: Cut): string {
   return join(dir, `${cut.commit}-${cut.manifestHash}.json`);
 }
-function loadCache(dir: string, cut: Cut): PrefetchCache | null {
+function tuiCacheFile(dir: string, cut: Cut): string {
+  return join(dir, `${cut.commit}-${cut.manifestHash}.tui.json`);
+}
+function loadTuiCache(dir: string, cut: Cut): TuiCache | null {
+  try {
+    const value = JSON.parse(readFileSync(tuiCacheFile(dir, cut), 'utf8')) as TuiCache;
+    if (value.version !== cut.version || value.commit !== cut.commit || value.manifestHash !== cut.manifestHash) return null;
+    return value;
+  } catch { return null; }
+}
+/** Publish `data` to `path` atomically (temp + rename), so a reader never sees a partial file. */
+function publish(path: string, data: unknown): void {
+  const staged = `${path}.${process.pid}.${randomUUID()}.tmp`;
+  writeFileSync(staged, JSON.stringify(data) + '\n');
+  try { renameSync(staged, path); } catch (error) { rmSync(staged, { force: true }); throw error; }
+}
+function loadCache(dir: string, cut: Cut): DocsCache | null {
   try {
-    const value = JSON.parse(readFileSync(cacheFile(dir, cut), 'utf8')) as PrefetchCache;
+    const value = JSON.parse(readFileSync(cacheFile(dir, cut), 'utf8')) as DocsCache;
     if (value.version !== cut.version || value.commit !== cut.commit || value.manifestHash !== cut.manifestHash
-      || !SHA.test(value.main) || value.tree !== join(dir, 'tree') || !existsSync(value.tree)
+      || !SHA.test(value.main) || dirname(value.tree) !== dir || !/^tree-[0-9a-f-]{36}$/.test(basename(value.tree)) || !existsSync(value.tree)
       || value.docs?.outcome !== 'ok' || value.docs.version !== cut.version
       || value.docs.notes !== join(value.tree, 'release/public/docs/releases', `${cut.version}.md`)
       || value.docs.pages !== join(value.tree, 'website/pages.json')
@@ -191,21 +211,34 @@ export function stagePrefetch(context: GraphContext, env: NodeJS.ProcessEnv = pr
   const cut = cutFor(context, stateRoot);
   mkdirSync(dir, { recursive: true });
   const already = loadCache(dir, cut);
-  if (already) return already;
-  const tree = join(dir, 'tree');
+  if (already) return { ...already, tui: loadTuiCache(dir, cut)?.tui ?? null };
+  // An attempt gets its own path. A failed add can only remove a tree belonging to this attempt,
+  // even when an earlier cut or a concurrent worker has a checkout in the same run directory.
+  const tree = join(dir, `tree-${randomUUID()}`);
   let added = false;
+  // `git worktree add` can fail AFTER creating the tree directory (e.g. a failed checkout): clean up
+  // whenever the add succeeded OR the tree is on disk, so a retry of this run is never blocked (should-fix ①).
+  const removeTree = () => {
+    if (!(added || existsSync(tree))) return;
+    try { runner('git', ['worktree', 'remove', '--force', tree], repo, 60_000); } catch { /* preserve original failure */ }
+    // A remove that failed (or could not unregister the tree) must still leave no blocking directory behind.
+    if (existsSync(tree)) rmSync(tree, { recursive: true, force: true });
+  };
   try {
     const main = run('git', ['rev-parse', '--verify', 'origin/main^{commit}'], repo);
     if (!SHA.test(main)) throw new Error('invalid origin/main commit');
-    // TUI runs against the cut, on its own isolated worktree, before touching the docs checkout.
+    const cachedTui = loadTuiCache(dir, cut);
+    // TUI runs against the cut, on its own isolated session, before touching the docs checkout.
     // tui-sim-node.ts prints the RAW result (no `outcome`); judge it the way node-verdict.ts tui would before reuse.
-    const tuiData = deps.tui ? deps.tui(cut.commit) : (() => {
+    // Publish the reusable TUI in its OWN file the moment it is confirmed — a later docs failure or
+    // delay must not throw away a finished TUI (should-fix ②).
+    const tui = cachedTui ? cachedTui.tui : reusableTui(withTuiOutcome(0, deps.tui ? deps.tui(cut.commit) : (() => {
       const tuiRun = spawnSync('bun', ['scripts/release-loop/tui-sim-node.ts', '--commit', cut.commit, '--json'], {
         cwd: repo, timeout: Math.min(6 * 60_000, left()), encoding: 'utf8', maxBuffer: 16 * 1024 * 1024,
       });
       return tuiRun.status === 0 ? lastResult({ status: tuiRun.status, stdout: tuiRun.stdout ?? '', stderr: tuiRun.stderr ?? '' }) ?? null : null;
-    })();
-    const tui = reusableTui(withTuiOutcome(0, tuiData), cut.commit);
+    })()), cut.commit);
+    if (tui && !cachedTui) publish(tuiCacheFile(dir, cut), { ...cut, tui });
     run('git', ['worktree', 'add', '--detach', tree, main], repo);
     added = true;
     run('bun', ['install', '--frozen-lockfile'], tree);
@@ -220,19 +253,14 @@ export function stagePrefetch(context: GraphContext, env: NodeJS.ProcessEnv = pr
     const finalCut = cutFor(context, stateRoot);
     if (finalCut.manifestHash !== cut.manifestHash) throw new Error('manifest changed during prefetch');
     const result: PrefetchCache = { ...cut, main, tree, docs, tui };
-    const final = cacheFile(dir, cut);
-    const staged = `${final}.${process.pid}.${randomUUID()}.tmp`;
-    writeFileSync(staged, JSON.stringify(result) + '\n');
+    const docsCache: DocsCache = { ...cut, main, tree, docs };
     // Publication handshake: whoever creates `claim` first (O_EXCL) wins. The docs node claims before it reads,
     // so a worker that loses can never publish a cache that a docs attempt would consume.
-    if (!claimPrefetch(dir, 'worker')) {
-      rmSync(staged, { force: true });
-      throw new Error('docs node already ran; late prefetch is discarded');
-    }
-    renameSync(staged, final);
+    if (!claimPrefetch(dir, 'worker')) throw new Error('docs node already ran; late prefetch is discarded');
+    publish(cacheFile(dir, cut), docsCache);
     return result;
   } catch (error) {
-    if (added) { try { runner('git', ['worktree', 'remove', '--force', tree], repo, 60_000); } catch { /* preserve original failure */ } }
+    removeTree();
     throw error;
   }
 }
@@ -247,9 +275,10 @@ export function joinTui(context: GraphContext, env: NodeJS.ProcessEnv, repo: str
   }, stateRoot = effectiveInstanceRoot()): Record<string, unknown> {
   if (context.outputs.upgrade?.outcome !== 'ok') throw new Error('upgrade did not pass');
   // Any failure to key the cache (no manifest, cutoff mismatch, no run dir) is a cache miss → original TUI path.
+  // The TUI cache file is independent of docs (should-fix ②): a docs failure or delay never blocks this read.
   let cut: Cut | null = null;
-  let cached: PrefetchCache | null = null;
-  try { cut = cutFor(context, stateRoot); cached = loadCache(runCacheDir(env), cut); } catch { /* cache miss */ }
+  let cached: TuiCache | null = null;
+  try { cut = cutFor(context, stateRoot); cached = loadTuiCache(runCacheDir(env), cut); } catch { /* cache miss */ }
   const reused = cut && cached?.tui && reusableTui(cached.tui, cut.commit);
   if (reused) return { ...reused, outcome: 'ok', summary: `tui ${reused.verdict}` };
   // Preserve node-verdict.ts's exit convention and last-JSON output on a cache miss.
@@ -287,7 +316,7 @@ export function graphDocs(context: GraphContext, env: NodeJS.ProcessEnv, repo: s
   try {
     // No fetch (nor any write to remote) until every gate is verified.
     for (const node of ['gate', 'prepare', 'upgrade', 'tui']) if (context.outputs[node]?.outcome !== 'ok') throw new Error(`${node} did not pass`);
-    let cached: PrefetchCache | null = null;
+    let cached: DocsCache | null = null;
     // A cache key that cannot be computed is a miss — the original fresh-worktree path runs.
     if (mayConsume && cacheDir) { try { const cut = cutFor(context, stateRoot); cached = loadCache(cacheDir, cut); } catch { cached = null; } }
     const branch = `release-docs/${version}`;

package/scripts/release-loop/export-check-node.ts

@@ -48,11 +48,14 @@ export function runExportCheck(run: CommandRunner = runCommand, repoRoot = proce
             const publicDir = join(out, 'export');
             symlinkSync(join(modulesRoot, 'node_modules'), join(publicDir, 'node_modules'), 'dir');
             const pwaModules = join(modulesRoot, 'apps', 'pwa', 'node_modules');
-            if (existsSync(pwaModules) && existsSync(join(publicDir, 'apps', 'pwa'))) symlinkSync(pwaModules, join(publicDir, 'apps', 'pwa', 'node_modules'), 'dir');
-            const built = run('bun', ['bin/elanous.mjs', 'nexus', 'build'], publicDir);
-            result = built.status === 0 && existsSync(join(publicDir, 'apps', 'pwa', 'out', 'index.html'))
-              ? { outcome: 'ok', verdict: 'pass', summary: `public export and PWA build ${commit.slice(0, 12)}`, step: 'build', tail: '' }
-              : failed('build', 'PWA build or out/index.html missing', built);
+            if (!existsSync(pwaModules)) result = failed('build', 'PWA dependencies missing; run bun install --cwd apps/pwa in the release-loop repository');
+            else {
+              if (existsSync(join(publicDir, 'apps', 'pwa'))) symlinkSync(pwaModules, join(publicDir, 'apps', 'pwa', 'node_modules'), 'dir');
+              const built = run('bun', ['bin/elanous.mjs', 'nexus', 'build'], publicDir);
+              result = built.status === 0 && existsSync(join(publicDir, 'apps', 'pwa', 'out', 'index.html'))
+                ? { outcome: 'ok', verdict: 'pass', summary: `public export and PWA build ${commit.slice(0, 12)}`, step: 'build', tail: '' }
+                : failed('build', 'PWA build or out/index.html missing', built);
+            }
           }
         }
       }

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

@@ -117,6 +117,8 @@ export interface GateResult {
 const sha = /^[0-9a-f]{7,40}$/i;
 const versionPattern = /^\d+\.\d+\.\d+(?:-(?:rc|alpha|beta)\.\d+)?$/;
 const failureFile = (root: string, version: string) => join(root, 'release', version, 'gate-failures.json');
+/** Judged identities live beside the machine release ledger; gate-failures.json keeps its raw baseline schema. */
+const verdictFile = (root: string, version: string) => join(root, 'release', version, 'gate-verdict.json');
 const quote = (s: string) => `'${s.replaceAll("'", "'\\''")}'`;
 const defaultRemoteMirror = '~/mirror/elanous-agent.git';
 
@@ -1431,6 +1433,8 @@ export async function judgeGate(opts: GateOptions, runner: GateRunner = createGa
   };
   const repo = resolve(opts.repo ?? process.cwd());
   const result: GateResult = { outcome: 'error', commit: opts.commit, introduced: [], preexisting: 0, fixed: 0, knownEnv: 0, knownEnvCleared: [], stalledEnv: [], rcNonzeroNoFailures: [], durationMs: 0 };
+  const preexistingIds: string[] = [];
+  let knownEnvIds: string[] = [];
   let work: string | undefined;
   let baseSnapshot = false;
   let cutFailures: SweepFailures | undefined;
@@ -1598,11 +1602,13 @@ export async function judgeGate(opts: GateOptions, runner: GateRunner = createGa
     const baselineIds = [...baseline.failures, ...baseline.errors];
     const countedCut = splitKnownEnv(cutIds, known);
     const countedBaseline = splitKnownEnv(baselineIds, known);
-    result.knownEnv = countedCut.knownEnv.length;
+    knownEnvIds = countedCut.knownEnv;
+    result.knownEnv = knownEnvIds.length;
     result.knownEnvCleared = [...new Set(cutRun.passedIds ?? [])].filter((id) => known.has(id) && !cutIds.includes(id) && !cutRun.stalledEnv?.some(({ file }) => fileOf(id) === file)).sort();
     const diff = diffFailures(countedCut.counted, countedBaseline.counted);
     result.fixed = result.baselineDeferred ? null : diff.fixed.length;
-    result.preexisting = diff.common.length;
+    preexistingIds.push(...diff.common);
+    result.preexisting = preexistingIds.length;
     // GATE-BASELINE-CACHE — only the files whose new failures reproduce in isolation reach the baseline, and each
     // (commit, file, host) is run at most once across gates: this gate's cut results also seed the next gate's baseline.
     const cacheHost = opts.remote ?? 'local';
@@ -1703,10 +1709,11 @@ export async function judgeGate(opts: GateOptions, runner: GateRunner = createGa
         debug.log('release-loop.gate', 'isolated-rc-nonzero-no-failures', { file, label: 'cut isolated', rc: rcOnly.rc, pass: rcOnly.pass, baseline });
       }
       for (const id of candidates) {
-        if (oldFailures.has(id)) result.preexisting++;
+        if (oldFailures.has(id)) preexistingIds.push(id);
         else result.introduced.push(id);
       }
     }
+    result.preexisting = preexistingIds.length;
     result.baselineCache = cacheStats;
     debug.log('release.gate', 'baseline-cache', { hits: cacheStats.hits, misses: cacheStats.misses, commit: baseSha });
     result.outcome = result.introduced.length ? 'regression' : 'ok';
@@ -1751,7 +1758,33 @@ export async function judgeGate(opts: GateOptions, runner: GateRunner = createGa
       result.error = `baseline persistence: ${String(error)}`;
     }
   }
-  if (result.outcome !== 'error') debug.log('release-loop.gate', 'judged', { version: opts.version, commit: opts.commit, introduced: result.introduced.length, preexisting: result.preexisting });
+  if (result.outcome !== 'error') {
+    const ids = {
+      introduced: [...result.introduced].sort(),
+      knownEnv: [...knownEnvIds].sort(),
+      preexisting: [...preexistingIds].sort(),
+      loadFlaky: [...(result.loadFlaky ?? [])].sort(),
+    };
+    try {
+      const path = verdictFile(ledger, opts.version);
+      mkdirSync(dirname(path), { recursive: true });
+      const temp = join(dirname(path), `.gate-verdict-${process.pid}-${randomUUID()}.tmp`);
+      try {
+        writeFileSync(temp, JSON.stringify({ version: opts.version, commit: opts.commit, outcome: result.outcome, ...ids }, null, 2) + '\n', { mode: 0o600 });
+        chmodSync(temp, 0o600);
+        renameSync(temp, path);
+      } finally { if (existsSync(temp)) rmSync(temp); }
+    } catch (error) {
+      result.outcome = 'error';
+      result.error = `verdict persistence: ${String(error)}`;
+    }
+    if (result.outcome !== 'error') debug.log('release-loop.gate', 'judged', {
+      version: opts.version, commit: opts.commit,
+      introduced: result.introduced.length, preexisting: result.preexisting,
+      knownEnv: result.knownEnv, loadFlaky: ids.loadFlaky.length,
+      introducedIds: ids.introduced, knownEnvIds: ids.knownEnv, preexistingIds: ids.preexisting, loadFlakyIds: ids.loadFlaky,
+    });
+  }
   // GATE-LIVE-OBS-RC-WORDING ⓒ — the shards board says «판정 전» until this lands; then «새 실패 N» only (UX · gate-shards.ts).
   // Same ledger as the board's own writes (sweep's shardsFile). A write failure is logged and never changes the verdict.
   if (result.outcome !== 'error' && opts.pod) {

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

@@ -7,6 +7,7 @@ import { debug } from '../../src/debug/log.js';
 export type NodeOutcome = 'ok' | 'fail' | 'error';
 export type NodeVerdict = 'pass' | 'flaky' | 'fail';
 export interface GraphContext {
+  nodeId?: string;
   input: { version: string; previousVersion: string; [key: string]: unknown };
   outputs: Record<string, Record<string, unknown>>;
 }
@@ -20,7 +21,8 @@ export function readGraphContext(env: NodeJS.ProcessEnv = process.env): GraphCon
   const input = context.input as Record<string, unknown> | undefined;
   if (!input || typeof input.version !== 'string' || !isReleaseVersion(input.version)
     || typeof input.previousVersion !== 'string' || !/^\d+\.\d+\.\d+$/.test(input.previousVersion)) throw new Error('version and previousVersion required');
-  return { input: input as GraphContext['input'], outputs: context.outputs && typeof context.outputs === 'object' ? context.outputs as GraphContext['outputs'] : {} };
+  return { ...(typeof context.nodeId === 'string' ? { nodeId: context.nodeId } : {}),
+    input: input as GraphContext['input'], outputs: context.outputs && typeof context.outputs === 'object' ? context.outputs as GraphContext['outputs'] : {} };
 }
 
 export function nodeOutput(context: GraphContext, node: string, key: string): string {
@@ -48,9 +50,14 @@ export function lastResult(run: CommandResult): Record<string, unknown> | undefi
   } catch { return undefined; }
 }
 
-export function finishNode(node: string, version: string, result: Record<string, unknown> & { outcome: NodeOutcome; verdict: NodeVerdict; summary: string }): number {
+export function finishNode(node: string, version: string, result: Record<string, unknown> & { outcome: NodeOutcome; verdict: NodeVerdict; summary: string; tail?: string }): number {
   debug.log(`release-loop.${node}`, 'result', { version, outcome: result.outcome });
-  emitNodeResult(result);
+  if (result.outcome === 'fail') {
+    const summary = result.summary.replace(/[\r\n]+/g, ' ').trim();
+    const tail = result.tail?.trim() ? result.tail : summary;
+    debug.log('release.node', 'failed', { node, summary, tail });
+    emitNodeResult({ ...result, summary, tail });
+  } else emitNodeResult(result);
   return result.outcome === 'ok' ? 0 : result.outcome === 'fail' ? 1 : 2;
 }
 

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

@@ -48,6 +48,9 @@ export function waitForAssets(run: CommandRunner, repo: string, tag: string, nam
 export function runPublish(run: CommandRunner = runCommand, prodFreezeRoot?: string,
   clock: { now: () => number; sleep: (ms: number) => void } = { now: Date.now, sleep: Bun.sleepSync }) {
   const context = readGraphContext();
+  // A resumed graph once invoked this irreversible node at npm-publish, docs-land, and failed.
+  // The runner's context is the authority: only the publish visit may publish.
+  if (context.nodeId !== 'publish') throw new Error(`publish node context mismatch: expected publish, got ${context.nodeId ?? 'missing'}`);
   const version = context.input.version;
   // A measured automatic decision or the existing human approval must authorize publication.
   const auto = context.outputs['auto-approve'];

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

@@ -11,6 +11,9 @@ export interface TuiScreens {
 export interface TuiCheck { id: string; pass: boolean; detail: string }
 
 const ERROR_TEXT = /\b(TypeError|ReferenceError|SyntaxError|Unhandled|panic|Segmentation fault)\b|Error: /;
+// The startup band can say "Commands — /help lists every command" (#26954).
+// Only the modal's title proves that the help overlay itself remains on screen.
+const HELP_MODAL_TITLE = 'Dashboard help';
 
 export function tuiChecks(s: TuiScreens, readyLimitMs = 60_000): TuiCheck[] {
   const all = [s.first, s.help, s.afterEsc].join('\n');
@@ -18,8 +21,8 @@ export function tuiChecks(s: TuiScreens, readyLimitMs = 60_000): TuiCheck[] {
     { id: 'boot', pass: s.readyMs !== null && s.readyMs <= readyLimitMs, detail: s.readyMs === null ? 'never ready' : `ready in ${s.readyMs}ms` },
     { id: 'prompt', pass: s.first.includes('❯'), detail: 'input line (❯) on the first screen' },
     { id: 'status-bar', pass: /│.*ctx \d+/.test(s.first), detail: 'status bar with model and ctx' },
-    { id: 'help-opens', pass: s.help.includes('help') && s.help.includes('Commands') && s.help.includes('/help'), detail: '/help shows the help overlay' },
-    { id: 'help-closes', pass: !s.afterEsc.includes('Commands') && s.afterEsc.includes('❯'), detail: 'Esc closes the overlay' },
+    { id: 'help-opens', pass: s.help.includes(HELP_MODAL_TITLE) && s.help.includes('Commands') && s.help.includes('/help'), detail: '/help shows the help overlay' },
+    { id: 'help-closes', pass: !s.afterEsc.includes(HELP_MODAL_TITLE) && s.afterEsc.includes('❯'), detail: 'Esc closes the overlay' },
     { id: 'no-error-text', pass: !ERROR_TEXT.test(all), detail: 'no error text on any screen' },
   ];
 }

package/scripts/skills/public-check.ts

@@ -17,7 +17,9 @@ export interface PublicCheckReport {
   readonly ok: boolean;
 }
 
-const PERSONAL_OR_INTERNAL = /\/Users\/|~\/source(?:\/|\b)|\b(?:INTERNAL_ONLY|ELANOUS_INTERNAL|PRIVATE_INTERNAL|internal-only)\b|@internal\b|내부\s*전용/iu;
+// 개인 경로(`/Users/`·`~/source`)는 대소문자를 가리고, 내부 표지는 기존처럼 `iu`.
+const PERSONAL_PATH = /\/Users\/|~\/source(?:\/|\b)/u;
+const INTERNAL_MARKER = /\b(?:INTERNAL_ONLY|ELANOUS_INTERNAL|PRIVATE_INTERNAL|internal-only)\b|@internal\b|내부\s*전용/iu;
 const EXECUTABLE = /\.(?:ts|tsx|js|mjs|cjs|py|sh|bash)$/iu;
 const ENTRY_DIR = /^(?:scripts|src|bin)\//u;
 const NON_ENTRY = /(?:\.d\.ts|\.(?:test|spec)\.[^.]+)$/iu;
@@ -165,7 +167,8 @@ export function checkPublicSkills(root: string, boundary: SkillBoundaryReport =
       const bytes = readFileSync(file);
       if (bytes.includes(0)) continue;
       try {
-        if (PERSONAL_OR_INTERNAL.test(new TextDecoder('utf-8', { fatal: true }).decode(bytes))) matches.push(relative(root, file));
+        const decoded = new TextDecoder('utf-8', { fatal: true }).decode(bytes);
+        if (PERSONAL_PATH.test(decoded) || INTERNAL_MARKER.test(decoded)) matches.push(relative(root, file));
       } catch {
         // Binary assets are not text; extensionless and dotfiles are checked when decodable.
       }