elanous 0.2.32 → 0.2.35

package/scripts/graph-units/verbs-envelope.ts

@@ -0,0 +1,139 @@
+import { readFileSync } from 'node:fs';
+
+type JsonMap = Record<string, unknown>;
+interface GraphContext { readonly nodeId?: string; readonly input: unknown; readonly outputs: Record<string, unknown> }
+
+function record(value: unknown): JsonMap {
+  return value && typeof value === 'object' && !Array.isArray(value) ? value as JsonMap : {};
+}
+
+function firstValue(context: GraphContext, key: string): unknown {
+  const input = record(context.input);
+  if (Object.hasOwn(input, key) && input[key] !== undefined && input[key] !== null) return input[key];
+  for (const output of Object.values(context.outputs ?? {})) {
+    const value = record(output)[key];
+    if (value !== undefined && value !== null) return value;
+  }
+  return null;
+}
+
+const VERIFY_INPUTS = ['worktree', 'changed-files', 'diff', 'review-intent', 'must-fix', 'gate-log'] as const;
+const VERIFY_STARTS = new Set(['gate', 'review', 'rework']);
+
+export interface MakeDocInputs {
+  readonly goal: string;
+  readonly worktree: unknown;
+  readonly branch: unknown;
+  readonly 'review-intent': unknown;
+  readonly 'head-sha': unknown;
+  readonly 'base-branch': unknown;
+  readonly prior: unknown;
+}
+
+/** Converts the public make-doc envelope into the existing document-loop recipe contract. */
+export function unpackMakeDocEnvelope(envelope: { readonly ask?: unknown; readonly context?: unknown; readonly prior?: unknown }): MakeDocInputs {
+  const context = record(envelope.context);
+  const contextGoal = context.goal;
+  const ask = typeof envelope.ask === 'string' ? envelope.ask : '';
+  const reviewIntent = context['review-intent'] ?? (ask.trim() ? ask : null);
+  const goal = typeof contextGoal === 'string' && contextGoal.trim() ? contextGoal : ask;
+  return {
+    goal,
+    worktree: context.worktree ?? null,
+    branch: context.branch ?? null,
+    'review-intent': reviewIntent,
+    'head-sha': context['head-sha'] ?? null,
+    'base-branch': context['base-branch'] ?? null,
+    prior: envelope.prior ?? null,
+  };
+}
+
+/** Keeps the make-doc outputs present on every declared exit. */
+export function buildMakeDocOutput(context: GraphContext): JsonMap {
+  const draft = record(context.outputs?.['document-draft']);
+  const input = record(context.input);
+  const prior = record(input.prior);
+  const priorEvidence = record(prior.evidence);
+  const inputEvidence = record(input.evidence);
+  const draftEvidence = record(draft.evidence);
+  const evidence = { ...priorEvidence, ...inputEvidence, ...draftEvidence };
+  if (prior.result !== undefined) evidence['prior-result'] = prior.result;
+  return {
+    result: draft.result ?? draft.summary ?? input.result ?? null,
+    evidence,
+  };
+}
+
+/** Selects a verify entry while keeping every unit input explicit at the call boundary. */
+export function buildVerifyEnvelope(context: GraphContext): JsonMap {
+  const input = record(context.input);
+  const detail = record(input.context);
+  const prior = record(input.prior);
+  const priorResult = record(prior.result);
+  const priorEvidence = record(prior.evidence);
+  const start = detail.start_at ?? detail.startAt;
+  const startAt = typeof start === 'string' && VERIFY_STARTS.has(start) ? start : 'gate';
+  const envelope: JsonMap = {
+    outcome: startAt,
+    ...Object.fromEntries(VERIFY_INPUTS.map(key => [key, detail[key] ?? prior[key] ?? priorEvidence[key] ?? priorResult[key] ?? firstValue(context, key)])),
+  };
+  if (detail['review-intent'] == null && typeof input.ask === 'string' && input.ask.trim()) envelope['review-intent'] = input.ask;
+  return envelope;
+}
+
+/** Emits the complete verify output contract from whichever routes ran. */
+export function buildVerifyOutput(context: GraphContext, outcome: 'done' | 'rework' | 'needs-human' | 'failed'): JsonMap {
+  const input = record(context.input);
+  const prior = record(input.prior);
+  const priorEvidence = record(prior.evidence);
+  const outputsByNode = record(context.outputs);
+  const stageOrder = outcome === 'done'
+    ? ['prepare', 'rework-loop', 'gate', 'review']
+    : outcome === 'rework'
+      ? ['prepare', 'gate', 'review', 'rework-loop']
+      : (() => {
+        const source = ['prepare', 'gate', 'review', 'rework-loop']
+          .find(node => record(outputsByNode[node]).outcome === outcome);
+        if (source === 'gate') return ['prepare', 'review', 'rework-loop', 'gate'];
+        if (source === 'review') return ['prepare', 'rework-loop', 'gate', 'review'];
+        if (source === 'rework-loop') return ['prepare', 'gate', 'review', 'rework-loop'];
+        return ['prepare'];
+      })();
+  const outputs = stageOrder.map(node => record(outputsByNode[node]));
+  const evidence = { ...priorEvidence };
+  for (const output of outputs) Object.assign(evidence, record(output.evidence));
+  const latest = (key: string, aliases: readonly string[] = []): unknown => {
+    let value: unknown = priorEvidence[key] ?? null;
+    for (const output of outputs) {
+      const nodeValue = [key, ...aliases].map(name => output[name]).find(candidate => candidate !== undefined && candidate !== null);
+      const evidenceValue = record(output.evidence)[key];
+      if (nodeValue !== undefined) value = nodeValue;
+      else if (evidenceValue !== undefined && evidenceValue !== null) value = evidenceValue;
+    }
+    return value;
+  };
+  return {
+    result: outcome,
+    evidence: {
+      ...evidence,
+      ...(prior.result === undefined ? {} : { 'prior-result': prior.result }),
+      'review-summary': latest('review-summary', ['review_summary']),
+      'must-fix': outcome === 'done' ? [] : latest('must-fix', ['must_fix']),
+      'gate-log': latest('gate-log', ['gate_log']),
+    },
+  };
+}
+
+if (import.meta.main) {
+  const contextPath = process.env.ELANOUS_GRAPH_CONTEXT;
+  if (!contextPath) throw new Error('ELANOUS_GRAPH_CONTEXT is required');
+  const context = JSON.parse(readFileSync(contextPath, 'utf8')) as GraphContext;
+  const mode = process.argv[2];
+  const output = mode === 'make-doc-input'
+    ? unpackMakeDocEnvelope(record(context.input) as { ask?: unknown; context?: unknown; prior?: unknown })
+    : mode === 'make-doc-output' ? buildMakeDocOutput(context)
+      : mode === 'verify-envelope' ? buildVerifyEnvelope(context)
+      : mode === 'verify-output' ? buildVerifyOutput(context, process.argv[3] as 'done' | 'rework' | 'needs-human' | 'failed') : undefined;
+  if (!output) throw new Error(`unknown verbs-envelope mode: ${mode ?? '<missing>'}`);
+  process.stdout.write(`${JSON.stringify(output)}\n`);
+}

package/scripts/hq/standby-snapshot.ts

@@ -193,8 +193,38 @@ function pushSurvival(target: string, local: string, manifest: Manifest, root: s
   rmSync(staging, { recursive: true, force: true });
 }
 
+/** Flags that need a value before any snapshot work (STANDBY-SURVIVAL-KEEP-ARGS · mirror parseVerifyArgs / parsePromoteArgs). */
+export const SURVIVAL_VALUE_FLAGS = ['--survival-keep', '--survival-keep-daily', '--prune-survival'] as const;
+
+/** Throw when a survival-keep / prune-survival flag is present without its value/target — same rule as `${flag} requires a value`. */
+export function assertSurvivalKeepArgs(argv: string[]): void {
+  for (let i = 0; i < argv.length; i += 1) {
+    const token = argv[i];
+    const equalsAt = token.indexOf('=');
+    const flag = equalsAt < 0 ? token : token.slice(0, equalsAt);
+    if (!SURVIVAL_VALUE_FLAGS.some(candidate => candidate === flag)) continue;
+    if (equalsAt >= 0) {
+      if (token.slice(equalsAt + 1).length === 0) throw new Error(`${flag} requires a value`);
+      continue;
+    }
+    const value = argv[i + 1];
+    if (!value || value.startsWith('--')) throw new Error(`${flag} requires a value`);
+  }
+}
+
+function preflightStandbySnapshotArgs(argv: string[]): void {
+  // Preflight survival argument values before tier selection, staging, or snapshot work.
+  try {
+    assertSurvivalKeepArgs(argv);
+  } catch (error) {
+    console.error(`standby-snapshot: ${String(error)}`);
+    process.exit(2);
+  }
+}
+
 if (import.meta.main) {
   const argv = process.argv.slice(2);
+  preflightStandbySnapshotArgs(argv);
   const val = (k: string) => { const i = argv.indexOf(k); return i >= 0 ? argv[i + 1] : undefined; };
   const tier = (val('--tier') ?? 'core') as Tier;
   if (tier !== 'core' && tier !== 'big' && tier !== 'obs') { console.error('--tier core|big|obs'); process.exit(2); }

package/scripts/public-export.ts

@@ -283,6 +283,45 @@ export function scanLeaks(root: string, files: readonly string[], markers = LEAK
   return hits;
 }
 
+/** Code literals are reported separately for the crown marker: they are not document/comment leakage. */
+function codeLiteralRanges(file: string, text: string): Array<[number, number]> {
+  if (!/\.(?:ts|tsx|mts|cts|js|jsx|mjs|cjs)$/iu.test(file)) return [];
+  const scanner = ts.createScanner(ts.ScriptTarget.Latest, false, /\.(?:tsx|jsx)$/iu.test(file) ? ts.LanguageVariant.JSX : ts.LanguageVariant.Standard, text);
+  const ranges: Array<[number, number]> = [];
+  for (let token = scanner.scan(); token !== ts.SyntaxKind.EndOfFileToken; token = scanner.scan()) {
+    if (token === ts.SyntaxKind.StringLiteral || token === ts.SyntaxKind.NoSubstitutionTemplateLiteral ||
+        token === ts.SyntaxKind.TemplateHead || token === ts.SyntaxKind.TemplateMiddle || token === ts.SyntaxKind.TemplateTail) {
+      ranges.push([scanner.getTokenPos(), scanner.getTextPos()]);
+    }
+  }
+  return ranges;
+}
+
+export function splitCodeLiteralCeoMarks(files: readonly string[], contents: ReadonlyMap<string, string>, hits: readonly LeakHit[]): { leaks: LeakHit[]; codeLiterals: LeakHit[] } {
+  const leaks: LeakHit[] = [];
+  const codeLiterals: LeakHit[] = [];
+  const fileSet = new Set(files);
+  const classification = new Map<string, Set<number>>();
+  for (const file of new Set(hits.filter((hit) => hit.marker === 'ceo-mark' && !/\.(?:test|spec)\.(?:ts|tsx|mts|cts|js|jsx|mjs|cjs)$/iu.test(hit.file)).map((hit) => hit.file))) {
+    const text = contents.get(file);
+    if (text === undefined || !fileSet.has(file)) continue;
+    const ranges = codeLiteralRanges(file, text);
+    const lines = new Set<number>();
+    let offset = 0;
+    text.split('\n').forEach((line, index) => {
+      const marks = [...line.matchAll(/\u{1F451}/gu)];
+      if (marks.length && marks.every((mark) => ranges.some(([from, to]) => offset + mark.index! >= from && offset + mark.index! + mark[0].length <= to))) lines.add(index + 1);
+      offset += line.length + 1;
+    });
+    classification.set(file, lines);
+  }
+  for (const hit of hits) {
+    if (hit.marker !== 'ceo-mark' || /\.(?:test|spec)\.(?:ts|tsx|mts|cts|js|jsx|mjs|cjs)$/iu.test(hit.file)) { leaks.push(hit); continue; }
+    (classification.get(hit.file)?.has(hit.line) ? codeLiterals : leaks).push(hit);
+  }
+  return { leaks, codeLiterals };
+}
+
 /**
  * 🆕 `runtime-path-outside-export` — 공개되는 «코드»가 공개본에 «없는» 저장소 경로를 문자열로 쥐고 있다.
  * 계기: `docs/graph-templates/**` 가 허용 목록에서 빠져 공개본 영상 라인이 실행 중에 죽을 뻔했다(🅣 · `#20098`).
@@ -448,12 +487,13 @@ export function run(argv: readonly string[], root = resolve(import.meta.dir, '..
       }
       console.error(`exported ${files.length} files (+${Object.keys(config.replace).length} replaced) → ${target}`);
     }
-    const hits = [
+    const rawHits = [
       ...gitIgnoredExportFiles(root, files).filter(inScope).map((file) => ({ marker: 'export-gitignored', file, line: 0, text: '공개본 .gitignore 에 걸린다 — 커밋하면 사라진다' })),
       ...scanLeaks(root, scanned, LEAK_MARKERS, transformed.contents, realDocs),
       ...(redactions ? scanLeaks(root, scanned, privateIdentifierMarkers(redactions), transformed.contents, realDocs) : []),
       ...(!redactions && !noPrivateList ? [{ marker: 'private-identifiers-unchecked', file: privateRedactionsPath(), line: 0, text: 'private redaction list missing' }] : []),
     ];
+    const { leaks: hits, codeLiterals } = splitCodeLiteralCeoMarks(scanned, transformed.contents, rawHits);
     const advisory = scanRuntimePaths(root, files, tracked, transformed.contents).filter((h) => inScope(h.file));
     const summary = summarizeLeaks(hits);
     const advisorySummary = summarizeLeaks(advisory);
@@ -464,6 +504,7 @@ export function run(argv: readonly string[], root = resolve(import.meta.dir, '..
     if (json) {
       console.log(JSON.stringify({
         files: scanned.length, leaks: hits.length, summary, before: { leaks: before.length, summary: beforeSummary }, transforms: transformed.counts, privateRedactions,
+        codeLiterals: { hits: codeLiterals.length, summary: summarizeLeaks(codeLiterals), items: all ? codeLiterals : codeLiterals.slice(0, limit) },
         shownHits: shown.length, truncated, omittedHits: hits.length - shown.length,
         ...(pathPrefix ? { pathPrefix } : {}), hits: shown,
         advisory: { hits: advisory.length, summary: advisorySummary, judge: RUNTIME_PATH_JUDGE, items: all ? advisory : advisory.slice(0, limit) },
@@ -473,6 +514,7 @@ export function run(argv: readonly string[], root = resolve(import.meta.dir, '..
       console.log(`leak check — ${scanned.length} files${pathPrefix ? ` under ${pathPrefix}` : ''} · ${hits.length} hits`);
       for (const [marker, s] of Object.entries(summary)) console.log(`  ${marker.padEnd(20)} ${String(s.files).padStart(5)} files  ${String(s.hits).padStart(6)} lines`);
       for (const hit of shown) console.log(`  ${hit.marker}  ${hit.file}:${hit.line}  ${hit.text}`);
+      if (codeLiterals.length) console.log(`code literals (not document/comment leakage) — ceo-mark ${codeLiterals.length} lines`);
       if (truncated) console.log(`  … ${hits.length - shown.length} more hits not shown — use --all, or narrow with --path <prefix> (⛔ «not in this list» ≠ «no leak»)`);
       if (advisory.length) console.log(`advisory (not counted) — runtime-path-outside-export ${advisory.length} lines · ${advisorySummary['runtime-path-outside-export']?.files ?? 0} files · judge = ${RUNTIME_PATH_JUDGE}`);
     }

package/scripts/ratchets/train-side-invariants.sh

@@ -0,0 +1,45 @@
+#!/usr/bin/env bash
+# Train-side sentinel for the eight real HARD 0.2.32 regressions. Run on the
+# merged side tree before the changed-file gate; never interpret a missing test
+# or an incomplete run as a pass.
+set -u
+
+files=(
+  scripts/ratchets/test-interference-patterns.test.ts
+  src/domains/finance-cli.test.ts
+  src/instance/state-dir-provenance-ratchet.test.ts
+  src/self-implement/graph-yaml.test.ts
+  src/self-implement/self-cli-sink-surface.test.ts
+  test/identity-env.test.ts
+  test/no-absolute-path-imports.test.ts
+  test/scenarios/integration.test.ts
+)
+
+if [[ ${1:-} == --list ]]; then
+  printf '%s\n' "${files[@]}"
+  exit 0
+fi
+if [[ $# -gt 1 ]]; then
+  echo 'TRAIN_INVARIANTS_UNMEASURED invalid-arguments'
+  exit 2
+fi
+cd "${1:-.}" || { echo 'TRAIN_INVARIANTS_UNMEASURED repo-unreadable'; exit 2; }
+command -v bun >/dev/null 2>&1 || { echo 'TRAIN_INVARIANTS_UNMEASURED bun-missing'; exit 2; }
+
+for file in "${files[@]}"; do
+  if [[ ! -f $file ]]; then
+    echo "TRAIN_INVARIANTS_UNMEASURED missing-file=$file"
+    exit 2
+  fi
+done
+
+for file in "${files[@]}"; do
+  echo "TRAIN_INVARIANTS_START $file"
+  bun test "$file"
+  rc=$?
+  if [[ $rc -ne 0 ]]; then
+    echo "TRAIN_INVARIANTS_FAIL file=$file rc=$rc"
+    exit 1
+  fi
+done
+echo "TRAIN_INVARIANTS_PASS files=${#files[@]}"

package/scripts/release-loop/auto-approve-node.ts

@@ -15,8 +15,12 @@ const outcomeMetric = (name: string, node: Record<string, unknown> | undefined):
   verdict: node?.outcome === undefined ? 'unmeasured' : node.outcome === 'ok' ? 'pass' : 'fail',
 });
 
-/** Rows shown in auto-approval.md but never counted toward the 8 blocking metrics. */
+/** Rows outside the original eight fixed metrics. TUI regressions have their own HITL gate below. */
 export const WARNING_ONLY = new Set(['tui-regress', 'mac-smoke']);
+export const BLOCKING_METRIC_NAMES = [
+  'gate regressions and measurement', 'bun version', 'upgrade', 'tui', 'notes-check',
+  'public leak and prepare completeness', 'docs notes page', 'installation files',
+] as const;
 
 /** `ok` · `warn` (a failure) · `unmeasured` (error or no output) — the macOS smoke never blocks publishing. */
 function macSmokeLevel(node: Record<string, unknown> | undefined): 'ok' | 'warn' | 'unmeasured' {
@@ -42,40 +46,50 @@ export function runAutoApprove(context: GraphContext = readGraphContext(), deps:
     catch { distCount = undefined; }
   }
   const gateErrorAbsent = gate && !Object.hasOwn(gate, 'error');
-  const regressStatus = regressWarning(validatedTuiRegress(context.outputs.tui?.regress));
+  const regress = validatedTuiRegress(context.outputs.tui?.regress);
+  const regressStatus = regressWarning(regress);
+  const failedCheckIds = 'unmeasured' in regress ? null : regress.results.filter((result) => !result.ok).map((result) => result.id);
+  const failedLabel = failedCheckIds === null ? 'unmeasured' : `${failedCheckIds.length} [${failedCheckIds.join(', ') || '-'}]`;
+  const regressNeedsApproval = regressStatus.level !== 'ok';
   const macSmoke = context.outputs['mac-smoke'];
   const metrics: ApprovalMetric[] = [
-    { name: 'gate regressions and measurement', value: JSON.stringify({ outcome: gate?.outcome ?? null, introduced: gate?.introduced ?? null, error: gate?.error ?? null }),
+    { name: BLOCKING_METRIC_NAMES[0], value: JSON.stringify({ outcome: gate?.outcome ?? null, introduced: gate?.introduced ?? null, error: gate?.error ?? null }),
       verdict: !gate || gate.outcome === undefined || !Array.isArray(gate.introduced) ? 'unmeasured'
         : gate.outcome === 'ok' && gate.introduced.length === 0 && gateErrorAbsent ? 'pass' : 'fail' },
-    { name: 'bun version', value: `running=${bunVersion}; pinned=${pinned ?? 'missing'}`,
+    { name: BLOCKING_METRIC_NAMES[1], value: `running=${bunVersion}; pinned=${pinned ?? 'missing'}`,
       verdict: !pinned ? 'unmeasured' : bunVersion === pinned ? 'pass' : 'fail' },
-    outcomeMetric('upgrade', context.outputs.upgrade),
-    outcomeMetric('tui', context.outputs.tui),
-    outcomeMetric('notes-check', context.outputs['notes-check']),
-    { name: 'public leak and prepare completeness', value: `prepare=${prepare?.outcome ?? 'missing'}`,
+    outcomeMetric(BLOCKING_METRIC_NAMES[2], context.outputs.upgrade),
+    outcomeMetric(BLOCKING_METRIC_NAMES[3], context.outputs.tui),
+    outcomeMetric(BLOCKING_METRIC_NAMES[4], context.outputs['notes-check']),
+    { name: BLOCKING_METRIC_NAMES[5], value: `prepare=${prepare?.outcome ?? 'missing'}`,
       verdict: prepare?.outcome === undefined ? 'unmeasured' : prepare.outcome === 'ok' ? 'pass' : 'fail' },
-    { name: 'docs notes page', value: `docs=${context.outputs.docs?.outcome ?? 'missing'}; notes=${String(context.outputs.docs?.notes ?? 'missing')}`,
+    { name: BLOCKING_METRIC_NAMES[6], value: `docs=${context.outputs.docs?.outcome ?? 'missing'}; notes=${String(context.outputs.docs?.notes ?? 'missing')}`,
       verdict: context.outputs.docs?.outcome === undefined || context.outputs.docs.notes === undefined ? 'unmeasured'
         : context.outputs.docs.outcome === 'ok' && typeof context.outputs.docs.notes === 'string' && context.outputs.docs.notes.trim() ? 'pass' : 'fail' },
-    { name: 'installation files', value: `dist files=${distCount ?? 'missing'}; prepare.out=${String(out ?? 'missing')}`,
+    { name: BLOCKING_METRIC_NAMES[7], value: `dist files=${distCount ?? 'missing'}; prepare.out=${String(out ?? 'missing')}`,
       verdict: prepare?.outcome !== 'ok' ? prepare?.outcome === undefined ? 'unmeasured' : 'fail'
         : distCount === undefined ? 'unmeasured' : distCount === 5 ? 'pass' : 'fail' },
-    // Warning-only and last, so the numbered rows 1–8 keep their places in auto-approval.md (V1g follow-up).
-    { name: 'tui-regress', value: regressStatus.level, reason: regressStatus.line, verdict: 'pass' },
+    // Kept after the eight fixed metrics; a failed or unmeasured subcheck requires the existing approve-publish HITL node.
+    { name: 'tui-regress', value: regressStatus.level, reason: regressStatus.line,
+      verdict: regressStatus.level === 'ok' ? 'pass' : regressStatus.level === 'warn' ? 'fail' : 'unmeasured' },
     // MAC1: the macOS smoke is warning-only too (ship with known issues) — shown, never counted.
     { name: 'mac-smoke', value: macSmokeLevel(macSmoke), reason: typeof macSmoke?.summary === 'string' ? macSmoke.summary : undefined, verdict: 'pass' },
   ];
-  const outcome = metrics.filter((metric) => !WARNING_ONLY.has(metric.name)).every((metric) => metric.verdict === 'pass') ? 'ok' as const : 'fail' as const;
+  const outcome = metrics.filter((metric) => !WARNING_ONLY.has(metric.name)).every((metric) => metric.verdict === 'pass')
+    && !regressNeedsApproval ? 'ok' as const : 'fail' as const;
   const report = join(root, 'release', version, 'auto-approval.md');
   const lines = [`# v${version} auto-approval`, '', `Outcome: ${outcome}`, '', '| # | Metric | Value | Verdict |', '|---|---|---|---|',
     ...metrics.map((metric, i) => `| ${i + 1} | ${metric.name} | ${[metric.value, metric.reason].filter(Boolean).join(' — ').replaceAll('|', '\\|').replace(/[\r\n]/g, ' ')} | ${metric.verdict} |`),
+    '', `TUI subcheck: ${regressStatus.level} · failed ${failedLabel} · ${regressNeedsApproval ? 'HITL 수용/정지 필요' : '자동 판정 가능'}`,
     '', '## 되돌리는 법', `gh release edit v${version} --draft`, `git tag -d v${version} && git push origin :refs/tags/v${version}`, '해당 docs PR revert', ''];
   mkdirSync(dirname(report), { recursive: true });
   writeFileSync(report, lines.join('\n'));
-  debug.log('release-loop.approve', 'auto-decision', { version, outcome, metrics });
-  return { outcome, verdict: outcome === 'ok' ? 'pass' as const : 'fail' as const, summary: `auto approval ${outcome}: ${metrics.filter((metric) => !WARNING_ONLY.has(metric.name) && metric.verdict === 'pass').length}/8`,
-    ...(outcome === 'ok' ? { decidedBy: 'release-loop metrics' as const } : {}), metrics, report };
+  const tuiSubcheck = { runId: context.runId ?? null, level: regressStatus.level,
+    fail: failedCheckIds?.length ?? null, failedCheckIds, approvalRequired: regressNeedsApproval };
+  debug.log('release-loop.approve', 'auto-decision', { version, outcome, metrics, tuiSubcheck });
+  return { outcome, verdict: outcome === 'ok' ? 'pass' as const : 'fail' as const,
+    summary: `auto approval ${outcome}: ${metrics.filter((metric) => !WARNING_ONLY.has(metric.name) && metric.verdict === 'pass').length}/8${regressNeedsApproval ? ` · tui-regress ${regressStatus.level} failed ${failedLabel} → HITL` : ''}`,
+    runId: context.runId ?? null, tuiSubcheck, ...(outcome === 'ok' ? { decidedBy: 'release-loop metrics' as const } : {}), metrics, report };
 }
 
 if (import.meta.main) {

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

@@ -1,14 +1,28 @@
 #!/usr/bin/env bun
-import { existsSync, mkdtempSync, readFileSync, rmSync } from 'node:fs';
+import { existsSync, mkdtempSync, readFileSync, realpathSync, rmSync } from 'node:fs';
 import { effectiveInstanceRoot, releaseLedgerRoot } from '../../src/instance/resolve.js';
 import { listChecklist } from '../../src/release-loop/checklist.js';
 import type { ReleaseManifest } from '../../src/release-loop/manifest.js';
 import { recordDocsFollow, type DocsFollowItem } from './release-docs.js';
-import { dirname, join } from 'node:path';
+import { basename, dirname, join } from 'node:path';
 import { tmpdir } from 'node:os';
-import { errorResult, finishNode, nodeOutput, readGraphContext, runCommand, type CommandRunner } from './node-verdict.js';
+import { errorResult, finishNode, nodeOutput, readGraphContext, runCommand, type CommandRunner, type GraphContext } from './node-verdict.js';
 import { prereleaseKind } from './release-version.js';
 
+function isRunOwnedDocsPrefetchTree(worktree: string, context: GraphContext, ledgerRoot: string): boolean {
+  const runId = context.runId;
+  if (!runId || !/^[A-Za-z0-9._-]+$/.test(runId)) return false;
+  const prefetchRoot = join(ledgerRoot, 'graph-runs', 'release-loop', `${runId}.json.contexts`, 'docs-prefetch');
+  try {
+    // Resolve symlinks too: an in-run path that points outside this run does not establish ownership.
+    const owner = realpathSync(prefetchRoot);
+    const tree = realpathSync(worktree);
+    return dirname(tree) === owner && /^tree(?:-[0-9a-f-]{36})?$/.test(basename(tree));
+  } catch {
+    return false;
+  }
+}
+
 export function runDocsLand(run: CommandRunner = runCommand, stateRoot = effectiveInstanceRoot(), ledgerRoot = releaseLedgerRoot()) {
   const context = readGraphContext();
   const version = context.input.version;
@@ -18,7 +32,9 @@ export function runDocsLand(run: CommandRunner = runCommand, stateRoot = effecti
   if (branch !== `release-docs/${version}`) throw new Error('docs branch/version mismatch');
   const worktree = nodeOutput(context, 'docs', 'worktree');
   const scratch = dirname(worktree);
-  if (dirname(scratch) !== tmpdir() || !/^release-docs-[A-Za-z0-9]+$/.test(scratch.split('/').at(-1) ?? '') || worktree !== join(scratch, 'tree')) throw new Error('invalid docs worktree');
+  const tmpWorktree = dirname(scratch) === tmpdir() && /^release-docs-[A-Za-z0-9]+$/.test(basename(scratch))
+    && worktree === join(scratch, 'tree');
+  if (!tmpWorktree && !isRunOwnedDocsPrefetchTree(worktree, context, ledgerRoot)) throw new Error('invalid docs worktree');
   const recordFollow = (deployed: boolean) => {
     const releaseDir = join(stateRoot, 'release', version);
     const manifest: ReleaseManifest = JSON.parse(readFileSync(join(releaseDir, 'manifest.json'), 'utf8'));
@@ -88,7 +104,7 @@ export function runDocsLand(run: CommandRunner = runCommand, stateRoot = effecti
       const remove = run('git', ['worktree', 'remove', '--force', worktree]);
       if (remove.status !== 0) throw new Error(`docs worktree cleanup failed: ${remove.stderr}`);
     }
-    rmSync(scratch, { recursive: true, force: true });
+    if (tmpWorktree) rmSync(scratch, { recursive: true, force: true });
     // 배포 성공 — 후속 기록 실패(manifest 없음 등)는 결과를 «실패»로 바꾸지 않는다. 알리고 넘어간다.
     let follow: ReturnType<typeof recordFollow> | undefined;
     try { follow = recordFollow(true); }

package/scripts/release-loop/gate-baseline-receipt.ts

@@ -0,0 +1,155 @@
+/** A full gate's reusable identity. Missing evidence is recorded, never promoted to a clean baseline. */
+import { createHash } from 'node:crypto';
+import { spawnSync } from 'node:child_process';
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { gateTestBaseline } from '../lib/gate-test-env.js';
+
+const SHA256 = /^[0-9a-f]{64}$/i;
+const IMAGE_DIGEST = /^sha256:[0-9a-f]{64}$/i;
+export const POD_SWEEP_INTEGRATION_ONLY: readonly string[] = ['scripts/install.test.ts', 'scripts/review-model-ab.test.ts'];
+
+/** Reconstruct the producer's tracked test selection at its pinned commit. Missing Git evidence is not a smaller set. */
+export function gateAssignableTestsAtCommit(repo: string, commit: string): string[] | null {
+  if (!/^[0-9a-f]{40}$/i.test(commit)) return null;
+  const tree = spawnSync('git', ['ls-tree', '-r', '--name-only', commit], { cwd: repo, encoding: 'utf8', maxBuffer: 32 * 1024 * 1024 });
+  const cdp = spawnSync('git', ['grep', '-l', '-e', 'requireCdpBase', '-e', '9333', commit, '--', 'test', 'scripts'],
+    { cwd: repo, encoding: 'utf8', maxBuffer: 32 * 1024 * 1024 });
+  if (tree.status !== 0 || tree.error || (cdp.status !== 0 && cdp.status !== 1) || cdp.error) return null;
+  const cdpFiles = new Set(cdp.stdout.split(/\r?\n/).filter(Boolean).map((line) => line.slice(commit.length + 1))
+    .filter((file) => file.endsWith('.test.ts')));
+  return tree.stdout.split(/\r?\n/).filter((file) => /\.test\.(?:tsx?|jsx?|mts|cts)$/.test(file)
+    && !cdpFiles.has(file) && !POD_SWEEP_INTEGRATION_ONLY.includes(file)
+    && !file.split('/').some((part) => part.startsWith('.'))).sort();
+}
+
+export interface GateBaselineReceipt {
+  schema: 1;
+  valid: boolean;
+  reason: string;
+  version: string;
+  commit: string;
+  graphSha: string | null;
+  recipeSha: string | null;
+  envFingerprint: string;
+  imageDigest: string | null;
+  files: number;
+  shards: number;
+}
+
+/** A direct hard rehearsal has no graph run state. Pin the graph and recipe bytes at its Git SHA. */
+export function gateSourcePins(repo: string, commit: string): { graphSha: string; recipeSha: string } | null {
+  if (!/^[0-9a-f]{40}$/i.test(commit)) return null;
+  const read = (file: string): string | null => {
+    const result = spawnSync('git', ['show', `${commit}:${file}`], { cwd: repo, encoding: 'utf8', maxBuffer: 8 * 1024 * 1024 });
+    return result.status === 0 && !result.error ? result.stdout : null;
+  };
+  const graph = read('graphs/release/release-loop.yaml');
+  const recipe = read('graphs/release/recipes.yaml');
+  return graph === null || recipe === null ? null : {
+    graphSha: createHash('sha256').update(graph).digest('hex'),
+    recipeSha: createHash('sha256').update(recipe).digest('hex'),
+  };
+}
+
+/** Only Kubernetes' observed child container imageID is evidence; the requested image tag is not. */
+export function actualGatePodImageDigest(podJson: string): string | null {
+  try {
+    const pods = JSON.parse(podJson) as { items?: Array<{ status?: { containerStatuses?: Array<{ name?: string; imageID?: string }> } }> };
+    // A retry can create more than one Pod; collected test bytes are not bound to one of their UIDs.
+    if (pods.items?.length !== 1) return null;
+    const id = pods.items[0]?.status?.containerStatuses?.find((row) => row.name === 'child')?.imageID;
+    const digest = typeof id === 'string' ? /(?:^|@|:\/\/)(sha256:[0-9a-f]{64})$/i.exec(id)?.[1] : undefined;
+    return digest && IMAGE_DIGEST.test(digest) ? digest.toLowerCase() : null;
+  } catch { return null; }
+}
+
+export function gateEnvFingerprint(env: NodeJS.ProcessEnv): string {
+  const baseline = gateTestBaseline(env);
+  return createHash('sha256').update(JSON.stringify(Object.fromEntries(Object.entries(baseline).sort(([a], [b]) => a.localeCompare(b))))).digest('hex');
+}
+
+/** Graph runner pins these bytes in its run state. A direct gate without that state cannot mint a reusable receipt. */
+export function gateGraphPins(root: string, runId: string | undefined): { graphSha: string; recipeSha: string } | null {
+  if (!runId || !/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(runId)) return null;
+  try {
+    const state = JSON.parse(readFileSync(join(root, 'graph-runs', 'release-loop', `${runId}.json`), 'utf8')) as
+      { graphId?: string; runId?: string; graphSnapshot?: { graphSha?: string; recipesSha?: string } };
+    const graphSha = state.graphSnapshot?.graphSha;
+    const recipeSha = state.graphSnapshot?.recipesSha;
+    return state.graphId === 'release-loop' && state.runId === runId && graphSha && recipeSha
+      && SHA256.test(graphSha) && SHA256.test(recipeSha) ? { graphSha, recipeSha } : null;
+  } catch { return null; }
+}
+
+export function gateBaselineReceipt(input: { root: string; version: string; commit: string; fullSweep: boolean;
+  graphPins: { graphSha: string; recipeSha: string } | null; envFingerprint: string }): GateBaselineReceipt {
+  const { root, version, commit, graphPins, envFingerprint } = input;
+  const base = { schema: 1 as const, version, commit, graphSha: graphPins?.graphSha ?? null,
+    recipeSha: graphPins?.recipeSha ?? null, envFingerprint, imageDigest: null as string | null, files: 0, shards: 0 };
+  const invalid = (reason: string): GateBaselineReceipt => ({ ...base, valid: false, reason });
+  if (!input.fullSweep) return invalid('gate was not a complete clean full sweep');
+  if (!graphPins) return invalid('pinned graph or recipe SHA absent');
+  if (!SHA256.test(envFingerprint)) return invalid('gate environment fingerprint absent');
+  try {
+    const dir = join(root, 'release', version, 'gate-logs', 'cut');
+    if (!existsSync(dir)) return invalid('cut Pod logs absent');
+    const names = readdirSync(dir).filter((name) => /^pod-\d+(?:-[\w-]+)?\.json$/.test(name));
+    const roots = new Map<number, { files: string[]; shardCount: number; sweepId: string; attemptId: string }>();
+    const descendants: Array<{ name: string; commit?: string; imageDigest?: string; sweepId?: string; parentAttempt?: string; attemptId?: string }> = [];
+    const images = new Set<string>();
+    for (const name of names) {
+      const row = JSON.parse(readFileSync(join(dir, name), 'utf8')) as
+        { commit?: string; files?: unknown; shardCount?: number; sweepId?: string; imageDigest?: string; parentAttempt?: string; attemptId?: string };
+      const match = /^pod-(\d+)\.json$/.exec(name);
+      if (match) {
+        if (row.commit !== commit) return invalid(`root cut Pod ${name} belongs to another commit`);
+        if (!Array.isArray(row.files) || !row.files.length || !row.files.every((file) => typeof file === 'string'))
+          return invalid(`root cut Pod ${name} has no file list`);
+        if (!row.attemptId) return invalid(`root cut Pod ${name} has no attempt`);
+        if (!row.sweepId) return invalid(`root cut Pod ${name} has no sweep identity`);
+        roots.set(Number(match[1]), { files: row.files as string[], shardCount: row.shardCount ?? 0, sweepId: row.sweepId, attemptId: row.attemptId });
+      } else descendants.push({ name, commit: row.commit, imageDigest: row.imageDigest, sweepId: row.sweepId,
+        parentAttempt: row.parentAttempt, attemptId: row.attemptId });
+      if (match) {
+        if (!row.imageDigest || !IMAGE_DIGEST.test(row.imageDigest)) return invalid(`actual Pod image digest absent: ${name}`);
+        images.add(row.imageDigest.toLowerCase());
+      }
+    }
+    if (!roots.size) return invalid('root cut shards absent');
+    const count = roots.get(0)?.shardCount;
+    if (!count || !Number.isSafeInteger(count) || count !== roots.size
+      || [...roots.keys()].some((index) => index < 0 || index >= count)) return invalid('root cut shard set incomplete');
+    const sweepId = roots.get(0)!.sweepId;
+    if ([...roots.values()].some((row) => row.shardCount !== count || row.sweepId !== sweepId))
+      return invalid('root cut shards belong to different sweeps');
+    const files = [...roots.values()].flatMap((row) => row.files);
+    if (new Set(files).size !== files.length) return invalid('root cut file lists overlap');
+    // A new cut can leave older split descendants in the same directory. Bind only the current roots' attempt tree.
+    const attempts = new Set([...roots.values()].map((row) => row.attemptId));
+    let pending = descendants;
+    for (; pending.length;) {
+      const next = pending.filter((row) => !row.parentAttempt || !attempts.has(row.parentAttempt));
+      if (next.length === pending.length) break;
+      for (const row of pending) {
+        if (!row.parentAttempt || !attempts.has(row.parentAttempt)) continue;
+        if (row.commit !== commit) return invalid(`cut Pod ${row.name} belongs to another commit`);
+        if (row.sweepId !== sweepId) return invalid(`cut Pod ${row.name} belongs to another sweep`);
+        if (!row.imageDigest || !IMAGE_DIGEST.test(row.imageDigest)) return invalid(`actual Pod image digest absent: ${row.name}`);
+        if (!row.attemptId) return invalid(`cut Pod ${row.name} has no attempt`);
+        images.add(row.imageDigest.toLowerCase());
+        attempts.add(row.attemptId);
+      }
+      pending = next;
+    }
+    // A child carrying this sweep's identity must be connected to a root,
+    // even when its parentAttempt is missing or corrupt. Otherwise its image
+    // evidence is silently omitted and a mixed-image receipt can look valid.
+    for (const row of pending) {
+      if (row.sweepId === sweepId) return invalid(`cut Pod ${row.name} has no connected parent attempt`);
+      if (row.commit === commit && !row.sweepId) return invalid(`cut Pod ${row.name} has no sweep identity`);
+    }
+    if (images.size !== 1) return invalid('cut Pods used different image digests');
+    return { ...base, valid: true, reason: 'complete clean full sweep', imageDigest: [...images][0]!, files: files.length, shards: count };
+  } catch (error) { return invalid(`cut Pod evidence unreadable: ${String(error)}`); }
+}

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

@@ -11,6 +11,9 @@ import { sourceCandidates } from '../../src/self-implement/importer-test-index.j
 
 /** Files the closure follows (code). Changing anything else that is not a test or inert Markdown is a full gate. */
 export const CODE_FILE = /\.(?:[cm]?[jt]sx?)$/;
+/** One release input whose readers use a literal basename in readFileSync(join(import.meta.dir, ...)).
+ *  Other JSON stays a full gate until its dependency edge is proved. */
+export const TRACEABLE_RELEASE_JSON = 'scripts/release-loop/known-issues-0.2.33-approved.json';
 const TEST_FILE = /^(?:[\w.-]+\/)*[\w.-]+\.test\.(?:tsx?|jsx?|mts|cts)$/;
 /** Test-side helpers: their filesystem scans and unresolved code paths make a test opaque (production code is trusted to
  *  reach code only through imports and the literal paths below). */
@@ -159,7 +162,8 @@ export function buildClosureGraph(tree: ClosureTree, options: ClosureOptions = {
     for (const match of code.matchAll(LITERAL)) {
       const value = match[2]!;
       if (!value || value.length > 300 || value.includes('${') || /\s/.test(value) || /^[a-z]+:/i.test(value)) continue;
-      const pathLike = value.startsWith('./') || value.startsWith('../') || (value.includes('/') && /^[\w@.-]+(?:\/[\w@.-]+)+\/?$/.test(value)) || CODE_FILE.test(value);
+      const pathLike = value.startsWith('./') || value.startsWith('../') || (value.includes('/') && /^[\w@.-]+(?:\/[\w@.-]+)+\/?$/.test(value)) || CODE_FILE.test(value)
+        || value === TRACEABLE_RELEASE_JSON.split('/').at(-1);
       if (!pathLike) continue;
       const plain = value.replace(/\/$/, '');
       const hit = resolveLiteral(file, plain);

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

@@ -12,7 +12,7 @@ export function parseFailures(output: string): string[] {
     const line = raw.trim();
     const header = /^(?:\.\/)?((?:[\w.-]+\/)+[\w.-]+\.test\.tsx?):(?:\s|$)/.exec(line);
     if (header) { file = header[1]; continue; }
-    const failed = /^\(fail\)[ \t]+(.+?)(?:[ \t]+\[[\d.]+(?:ms|s)\])?$/.exec(line);
+    const failed = /^\(fail\)[ \t]+(.+?)(?:[ \t]+\[[\d.]+(?:ms|s)\])?[ \t]*$/.exec(raw);
     if (failed && file) failures.add(`${file} > ${failed[1]!.trim()}`);
   }
   return [...failures].sort();