elanous 0.2.40 → 0.2.42

package/scripts/public-copy-lint.ts

@@ -1,7 +1,7 @@
 #!/usr/bin/env bun
 /** Warning-only public-copy shadow scan. It never edits source or exposes private candidate text. */
-import { existsSync, readFileSync } from 'node:fs';
-import { extname, normalize, relative, resolve, sep } from 'node:path';
+import { readFileSync, readdirSync, statSync } from 'node:fs';
+import { extname, join, normalize, relative, resolve, sep } from 'node:path';
 import { PatentLedger } from '../src/patents/ledger.js';
 import { checkBrandText } from './brand/check.js';
 
@@ -10,7 +10,8 @@ export type PublicCopyFinding = { source: string; line: number; rule: string };
 export type PatentLineMatcher = (text: string) => number[];
 export type PublicCopyScan = {
   findings: PublicCopyFinding[];
-  excludedSources: Array<{ source: string; reason: 'internal-goal-document' }>;
+  excludedSources: Array<{ source: string; reason: 'internal-goal-document' | 'internal-marketing-source' | 'asset-manifest' }>;
+  documents: Array<{ source: string; findings: number; companyNameMentions: number; placeholderMentions: number }>;
   brandRulesAvailable: boolean;
   patentLedgerAvailable: boolean;
 };
@@ -23,9 +24,113 @@ function normalizedLabel(label: string): string | undefined {
   return normalized;
 }
 
+function publicCopyExclusion(normalized: string): PublicCopyScan['excludedSources'][number]['reason'] | undefined {
+  if (normalized.startsWith('docs/goals/')) return 'internal-goal-document';
+  if (!normalized.startsWith('docs/marketing/')) return undefined;
+  const relativePath = normalized.slice('docs/marketing/'.length);
+  const basename = relativePath.split('/').at(-1) ?? '';
+  // These files are published records or release-specific source notes, not
+  // current copy candidates. Preserve their exact product names and evidence.
+  if (/^(?:BLOG-02-the-agent-drives-the-agent-|BLOG-03-it-drives-the-terminal-itself-|DRAFT-0\.2\.(?:7|8)-announcement-|DRAFT-0\.2\.7-known-issues-public-wording-|DRAFT-0\.2\.10-announcement-|PRFAQ-release-0\.2\.4-|SCRIPT-ax-demo-1008-|VO-teaser-v2-)/i.test(basename)
+    || /^docs\/marketing\/launch\/(?:0\.2\.8-loop-final\/|0\.2\.8-rehearsal\/PRFAQ-generated\.md$|0\.2\.11-cut-)/i.test(normalized)) {
+    return 'internal-marketing-source';
+  }
+  if (normalized.startsWith('docs/marketing/') && /^(?:BRIEF-|DOCS-|EVENT-|GUIDE-|MANUAL-|MAP-|MATURITY-|PLAN-|RESEARCH-|RFC-|SCENARIO-|STORYBOARD-|STORYLINE-|STRATEGY-|SOURCES-)/i.test(basename)) {
+    return 'internal-marketing-source';
+  }
+  if (normalized.startsWith('docs/marketing/') && /^DRAFT-persona-/i.test(basename)) return 'internal-marketing-source';
+  if (/^docs\/marketing\/teaser-v\d+\/MANIFEST\.md$/i.test(normalized) || normalized === 'docs/marketing/decks/media/README.md') {
+    return 'asset-manifest';
+  }
+  return undefined;
+}
+
+function isRequestedPublicCopyPath(normalized: string): boolean {
+  return normalized === 'README.md' || normalized.startsWith('docs/marketing/');
+}
+
+function maskSpan(text: string, start: number, end: number): string {
+  return text.slice(start, end).replace(/[^\r\n]/g, ' ');
+}
+
+/** Keep line offsets while limiting brand checks to visible prose, not code, comments, metadata, or link targets. */
+function visibleMarkdownProse(text: string): string {
+  let visible = text;
+  const masks: RegExp[] = [
+    /^---\r?\n[\s\S]*?\r?\n---\s*$/gm,
+    /<!--[\s\S]*?-->/g,
+    /^\s*(```|~~~)[^\r\n]*\r?\n[\s\S]*?^\s*\1\s*$/gm,
+    /`[^`\r\n]*`/g,
+    /\]\((?:\\.|[^)])*\)/g,
+    /^>\s*🧾\s*\*\*공개 전 할 일\*\*[\s\S]*?(?=^[^>\r\n]|$(?![\s\S]))/gm,
+    /^##\s*(?:\d+\.\s*)?(?:칸|출처 목록|sources|evidence|게시 직전 다시 잴 것|기준선|올리기 전 확인)(?:\s|$)[\s\S]*?(?=^##\s|$(?![\s\S]))/gim,
+    /^>\s*✏️\s*\*\*착지·실측된 것만\.[^\r\n]*$/gm,
+    /https?:\/\/[^\s)>]+/gi,
+    /\b(?:[A-Za-z0-9-]+\.)+[A-Za-z]{2,}(?:\/[^\s)>]*)?/g,
+  ];
+  for (const pattern of masks) {
+    const matches = [...visible.matchAll(pattern)].map((match) => ({ start: match.index!, end: match.index! + match[0].length }));
+    for (const match of matches.reverse()) visible = visible.slice(0, match.start) + maskSpan(visible, match.start, match.end) + visible.slice(match.end);
+  }
+  return visible;
+}
+
+const PUBLIC_COMPANY_NAMES = /\b(?:OpenAI|ChatGPT|Codex|Claude(?:\s+Code)?|Anthropic|Gemini|Google|Grok|xAI|Devin|Cognition|OpenHands|Replit(?:\s+Agent(?:\s+\d+)?)?|Factory(?:\s+AI)?|Hermes|OpenClaw|Manus)\b/gi;
+const PUBLIC_PLACEHOLDER = /\b(?:another coding agent|another agent platform)\b/gi;
+const PUBLIC_PLACEHOLDER_LIST = /\ba coding tool\s*[,·]\s*the coding CLI\s*[,·]\s*an AI model\s*[,·]\s*a model provider\b/gi;
+const UNSUPPORTED_COMPARISON = /\b(?:better|faster|cheaper|safer|worse|superior|inferior)\s+than\b|\b(?:vs\.?|versus|compared\s+(?:with|to))\b|(?:보다\s*(?:낫|빠르|저렴|좋|강력|안전|우수))/i;
+
+function companyNameMentions(text: string): number {
+  return [...text.matchAll(PUBLIC_COMPANY_NAMES)].length;
+}
+
+function placeholderMentions(text: string): number {
+  return [...text.matchAll(PUBLIC_PLACEHOLDER)].length + [...text.matchAll(PUBLIC_PLACEHOLDER_LIST)].length;
+}
+
+function hasSupportedComparisonEvidence(text: string): boolean {
+  const hasSource = /\b(?:source|citation)\b|출처/i.test(text);
+  const hasMeasurement = /\b(?:measur|benchmark|tested|test conditions?)\w*\b|실측|측정|측정 조건/i.test(text);
+  return hasSource && hasMeasurement;
+}
+
+function measuredScopeMatchesClaim(claim: string): boolean {
+  const quantity = String.raw`(\d+(?:\.\d+)?)`;
+  const unit = String.raw`(jobs?|tasks?|workflows?|items?|건|개|작업)`;
+  const claimScope = new RegExp(String.raw`(?:completes?|processes?|handles?|완료|처리)\s*${quantity}\s*${unit}`, 'i').exec(claim);
+  const measuredScope = new RegExp(String.raw`(?:measured|measurement|실측|측정).*?(?:scope|range|범위).*?(?:limited to|only|한정|범위 내)\s*${quantity}\s*${unit}`, 'i').exec(claim);
+  if (!claimScope || !measuredScope) return false;
+  const normalizeUnit = (value: string): string => {
+    const normalized = value.toLowerCase();
+    if (normalized === 'job' || normalized === 'jobs' || normalized === 'task' || normalized === 'tasks' || normalized === 'workflow' || normalized === 'workflows' || normalized === 'item' || normalized === 'items') return normalized.replace(/s$/, '');
+    return normalized;
+  };
+  return claimScope[1] === measuredScope[1] && normalizeUnit(claimScope[2]!) === normalizeUnit(measuredScope[2]!);
+}
+
+function oneClickFindings(text: string, source: string): PublicCopyFinding[] {
+  const lines = text.split(/\r?\n/);
+  const findings: PublicCopyFinding[] = [];
+  for (let index = 0; index < lines.length; index++) {
+    const claims = lines[index]!.split(/(?<=[.!?。！？;；])\s*/).filter((segment) => /\bone[ -]click\b|원\s*클릭/i.test(segment));
+    for (const claim of claims) {
+      const hasLimitedClaimScope = !/(?:every|all|entire|unlimited|모든|전체|무제한)/i.test(claim)
+        && /(?:completes?|processes?|handles?|완료|처리)/i.test(claim)
+        && /\b\d+(?:\.\d+)?\s+(?:jobs?|tasks?|workflows?|items?)\b|\d+(?:\.\d+)?\s*(?:건|개|작업)/i.test(claim);
+      const hasMeasuredScope = hasLimitedClaimScope
+        && measuredScopeMatchesClaim(claim)
+        && !/(?:no|not|without|unmeasured|측정되지 않|범위 없음|범위가 없|한정되지 않)/i.test(claim);
+      if (!hasMeasuredScope) findings.push({ source, line: index + 1, rule: 'ONE-CLICK-MEASURED-SCOPE' });
+      const hasPublicationApprovalStatus = /(?:approved for publication|publication approved|publication approval pending|publication not approved|not approved for publication|unapproved|pending|게시\s*승인(?:됨|완료)?|게시\s*미승인|게시\s*승인\s*보류|게시\s*승인\s*상태\s*:\s*(?:승인|미승인|보류)|승인되지 않)/i.test(claim);
+      if (!hasPublicationApprovalStatus) findings.push({ source, line: index + 1, rule: 'ONE-CLICK-APPROVAL-STATUS' });
+    }
+  }
+  return findings;
+}
+
 function allowedNormalizedLabel(normalized: string | undefined): boolean {
   if (!normalized) return false;
-  if (normalized === 'PR-BODY') return true;
+  if (normalized === 'PR-BODY' || normalized === 'README.md') return true;
   if (normalized.split('/').some((part) => part === '..' || part === '')) return false;
   if (!['.md', '.mdx', '.txt', '.html', '.htm'].includes(extname(normalized).toLowerCase())) return false;
   return ['docs/', 'release/public/docs/', 'blog/', 'posts/', 'content/blog/', 'content/posts/']
@@ -36,30 +141,49 @@ function allowedNormalizedLabel(normalized: string | undefined): boolean {
 export function scanPublicCopy(inputs: readonly PublicCopyInput[], matchPrivateCandidate: PatentLineMatcher, rulesPath?: string): PublicCopyScan {
   const findings: PublicCopyFinding[] = [];
   const excludedSources: PublicCopyScan['excludedSources'] = [];
+  const documents: PublicCopyScan['documents'] = [];
   let brandRulesAvailable = true;
   let patentLedgerAvailable = true;
   for (const input of inputs) {
     const label = normalizedLabel(input.label);
     if (!allowedNormalizedLabel(label)) throw new Error(`공개 문면 입력 경로가 허용 목록 밖입니다: ${input.label}`);
-    // Goal specs are internal execution artifacts, not customer-facing copy.
-    // Counting their acceptance criteria as marketing measurements created a
-    // high false-positive rate in the 30-PR audit.
-    if (label?.startsWith('docs/goals/')) {
-      excludedSources.push({ source: input.label, reason: 'internal-goal-document' });
+    const excludedReason = label ? publicCopyExclusion(label) : undefined;
+    if (excludedReason) {
+      excludedSources.push({ source: input.label, reason: excludedReason });
       continue;
     }
+    const before = findings.length;
+    const prose = visibleMarkdownProse(input.text);
+    if (label && isRequestedPublicCopyPath(label)) findings.push(...oneClickFindings(prose, input.label));
     try {
-      const brandFindings = checkBrandText(input.text, input.label, 'public-docs', rulesPath);
+      const brandFindings = checkBrandText(prose, input.label, 'public-docs', rulesPath)
+        .filter((hit) => hit.id !== 'BRAND-COMPETITOR-NAME');
       // Publication-specific promise/measurement rules apply to this explicit
       // shadow scan without changing the existing generic brand-check scopes.
-      const publicationFindings = checkBrandText(input.text, input.label, 'release-notes', rulesPath)
+      const publicationFindings = checkBrandText(prose, input.label, 'release-notes', rulesPath)
         .filter((hit) => hit.id === 'BRAND-SOON' || hit.id === 'B4-NUMBER-SOURCE');
-      for (const hit of [...brandFindings, ...publicationFindings]) {
-        findings.push({ source: input.label, line: hit.line, rule: hit.id });
+      const brandLines = new Set([...brandFindings, ...publicationFindings].map((hit) => `${hit.line}:${hit.id}`));
+      for (const line of prose.split(/\r?\n/).map((text, index) => ({ text, line: index + 1 }))) {
+        if (UNSUPPORTED_COMPARISON.test(line.text) && PUBLIC_COMPANY_NAMES.test(line.text)
+          && !hasSupportedComparisonEvidence(line.text)) {
+          brandLines.add(`${line.line}:BRAND-UNSUPPORTED-COMPARISON`);
+        }
+        PUBLIC_COMPANY_NAMES.lastIndex = 0;
+        UNSUPPORTED_COMPARISON.lastIndex = 0;
+        if (PUBLIC_PLACEHOLDER.test(line.text) || PUBLIC_PLACEHOLDER_LIST.test(line.text)) {
+          brandLines.add(`${line.line}:PUBLIC-COPY-PLACEHOLDER`);
+        }
+        PUBLIC_PLACEHOLDER.lastIndex = 0;
+        PUBLIC_PLACEHOLDER_LIST.lastIndex = 0;
+      }
+      for (const key of brandLines) {
+        const [line, rule] = key.split(':');
+        findings.push({ source: input.label, line: Number(line), rule: rule! });
       }
     } catch { brandRulesAvailable = false; }
     try { for (const line of matchPrivateCandidate(input.text)) findings.push({ source: input.label, line, rule: 'PRIVATE-PATENT-CANDIDATE' }); }
     catch { patentLedgerAvailable = false; }
+    documents.push({ source: input.label, findings: findings.length - before, companyNameMentions: companyNameMentions(prose), placeholderMentions: placeholderMentions(prose) });
   }
   if (inputs.length === 0 || excludedSources.length === inputs.length) {
     // No scanner ran, so availability must not claim a successful measurement.
@@ -69,6 +193,7 @@ export function scanPublicCopy(inputs: readonly PublicCopyInput[], matchPrivateC
   return {
     findings: findings.sort((a, b) => a.source.localeCompare(b.source) || a.line - b.line || a.rule.localeCompare(b.rule)),
     excludedSources,
+    documents,
     brandRulesAvailable, patentLedgerAvailable,
   };
 }
@@ -77,6 +202,26 @@ export function lintPublicCopy(inputs: readonly PublicCopyInput[], matchPrivateC
   return scanPublicCopy(inputs, matchPrivateCandidate).findings;
 }
 
+function collectPublicCopyFiles(paths: readonly string[], root: string): string[] {
+  const collected = new Set<string>();
+  const visit = (path: string): void => {
+    const absolute = resolve(root, path);
+    const stat = statSync(absolute);
+    if (stat.isDirectory()) {
+      for (const entry of readdirSync(absolute, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+        if (entry.isDirectory()) visit(relative(root, join(absolute, entry.name)));
+        else if (entry.isFile() && ['.md', '.mdx', '.txt', '.html', '.htm'].includes(extname(entry.name).toLowerCase())) {
+          collected.add(relative(root, join(absolute, entry.name)));
+        }
+      }
+      return;
+    }
+    collected.add(relative(root, absolute));
+  };
+  for (const path of paths) visit(path);
+  return [...collected].sort();
+}
+
 export function run(argv: readonly string[], root = process.cwd(), ledger = new PatentLedger()): number {
   const files: string[] = [];
   let bodyFile: string | undefined;
@@ -97,15 +242,14 @@ export function run(argv: readonly string[], root = process.cwd(), ledger = new
     } else throw new Error(`알 수 없는 옵션: ${arg}`);
   }
   if (!files.length && !bodyFile) throw new Error('usage: bun scripts/public-copy-lint.ts [--files <docs...>] [--pr-body-file <file> [--pr-body-label <repo-relative-label>]] [--json]');
-  const inputs: PublicCopyInput[] = files.map((file) => ({
-    label: relative(root, resolve(root, file)).split(sep).join('/'), text: readFileSync(resolve(root, file), 'utf8'),
+  const inputs: PublicCopyInput[] = collectPublicCopyFiles(files, root).map((file) => ({
+    label: file.split(sep).join('/'), text: readFileSync(resolve(root, file), 'utf8'),
   }));
   if (bodyFile) inputs.push({ label: bodyLabel, text: readFileSync(resolve(root, bodyFile), 'utf8') });
-  const matchPrivateCandidate: PatentLineMatcher = (text) => {
-    return ledger.unapprovedCandidateLineNumbers(text);
-  };
+  const matchPrivateCandidate: PatentLineMatcher = (text) => ledger.unapprovedCandidateLineNumbers(text);
+  // The CLI caller uses the same scope-aware production scanner covered by focused tests.
   const scan = scanPublicCopy(inputs, matchPrivateCandidate);
-  if (json) console.log(JSON.stringify({ mode: 'warning-only', ...scan }));
+  if (json) console.log(JSON.stringify({ mode: 'warning-only', documentsScanned: scan.documents.length, ...scan }));
   else {
     for (const finding of scan.findings) console.log(`${finding.source}:${finding.line}:WARN:${finding.rule}`);
     for (const excluded of scan.excludedSources) console.log(`${excluded.source}:SKIP:${excluded.reason}`);

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

@@ -6,7 +6,6 @@ set -u
 
 files=(
   scripts/ratchets/test-interference-patterns.test.ts
-  scripts/ratchets/next-tui-entry-budget.test.ts
   src/domains/finance-cli.test.ts
   src/instance/state-dir-provenance-ratchet.test.ts
   src/self-implement/graph-yaml.test.ts

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

@@ -0,0 +1,117 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { acquireLockSync } from '../../src/storage/file-lock.js';
+
+/** Deterministic recovery policy for release gate incidents. Side effects are supplied by callers. */
+export type GateAutohealCause = 'shard-pod-death' | 'timeout' | 'host-down' | 'interference' | 'true-regression' | 'environment';
+export type GateAutohealAction = 'reroute-shard' | 'retry-shard' | 'partial-resume' | 'host-switch' | 'hitl';
+
+export interface GateAutohealInput {
+  cause: GateAutohealCause;
+  signature: string;
+  shardElapsedMs: number;
+  overallElapsedMs: number;
+  priorSameSignatureCount?: number;
+  shardKeys?: readonly string[];
+}
+
+export interface GateAutohealDecision {
+  action: GateAutohealAction;
+  cause: GateAutohealCause;
+  signature: string;
+  reason: string;
+  shardElapsedMs: number;
+  overallElapsedMs: number;
+  shardKey?: string;
+}
+
+export interface GateResultForAutoheal {
+  outcome: 'ok' | 'regression' | 'error';
+  introduced?: readonly string[];
+  error?: string;
+  durationMs: number;
+  stalledShards?: readonly { shard: number; files: readonly string[]; reason: string; detail?: string; stall?: { sinceCheckoutMs: number } }[];
+  interferenceErrors?: readonly string[];
+  loadFlaky?: readonly string[];
+}
+
+interface GateAutohealLedger {
+  schema: 1;
+  overallElapsedMs: number;
+  shards: Record<string, number>;
+  signatures: Record<string, number>;
+}
+
+const emptyLedger = (): GateAutohealLedger => ({ schema: 1, overallElapsedMs: 0, shards: {}, signatures: {} });
+
+/** Persist the incident budget across graph-node process restarts, keyed by release version and run id. */
+export function decideAndRecordGateAutoheal(input: GateAutohealInput & { version: string; runId: string; shardKey: string; storeRoot: string }): GateAutohealDecision {
+  const path = join(input.storeRoot, 'release', input.version, 'gate-autoheal', `${input.runId.replace(/[^a-zA-Z0-9_.-]/g, '_')}.json`);
+  mkdirSync(dirname(path), { recursive: true });
+  const unlock = acquireLockSync(`${path}.lock`, { breakDeadHolder: true });
+  try {
+    let ledger = emptyLedger();
+    if (existsSync(path)) {
+      try {
+      const parsed = JSON.parse(readFileSync(path, 'utf8')) as GateAutohealLedger;
+      if (parsed.schema !== 1 || !Number.isFinite(parsed.overallElapsedMs) || !parsed.shards || !parsed.signatures) throw new Error('invalid ledger');
+      ledger = parsed;
+      } catch {
+        return { action: 'hitl', cause: input.cause, signature: input.signature, reason: 'autoheal history unreadable; refusing another automatic action', shardElapsedMs: 0, overallElapsedMs: 0, shardKey: input.shardKey };
+      }
+    }
+    const shardKeys = [...new Set(input.shardKeys?.length ? input.shardKeys : [input.shardKey])];
+    const signatureKey = `${input.shardKey}:${input.signature}`;
+    const priorSameSignatureCount = ledger.signatures[signatureKey] ?? 0;
+    const elapsed = Math.max(0, input.shardElapsedMs);
+    const shards = { ...ledger.shards };
+    for (const key of shardKeys) shards[key] = (shards[key] ?? 0) + elapsed;
+    const shardElapsedMs = Math.max(0, ...shardKeys.map((key) => shards[key] ?? 0));
+    const overallElapsedMs = ledger.overallElapsedMs + Math.max(0, input.overallElapsedMs);
+    const decision = decideGateAutoheal({ ...input, shardElapsedMs, overallElapsedMs, priorSameSignatureCount });
+    ledger = { schema: 1, overallElapsedMs, shards,
+      signatures: { ...ledger.signatures, [signatureKey]: priorSameSignatureCount + 1 } };
+    const temp = `${path}.${process.pid}.tmp`;
+    writeFileSync(temp, `${JSON.stringify(ledger, null, 2)}\n`, { mode: 0o600 });
+    renameSync(temp, path);
+    return { ...decision, shardKey: input.shardKey };
+  } finally { unlock(); }
+}
+
+export const GATE_AUTOHEAL_SHARD_CAP_MS = 60 * 60 * 1000;
+export const GATE_AUTOHEAL_OVERALL_CAP_MS = 90 * 60 * 1000;
+
+/** One signature may be acted on once; seeing it again, or crossing either timebox, stops in HITL. */
+export function decideGateAutoheal(input: GateAutohealInput): GateAutohealDecision {
+  const shardElapsedMs = Math.max(0, input.shardElapsedMs);
+  const overallElapsedMs = Math.max(0, input.overallElapsedMs);
+  let action: GateAutohealAction;
+  let reason: string;
+  if (shardElapsedMs >= GATE_AUTOHEAL_SHARD_CAP_MS) {
+    action = 'hitl'; reason = 'per-shard timebox exceeded';
+  } else if (overallElapsedMs >= GATE_AUTOHEAL_OVERALL_CAP_MS) {
+    action = 'hitl'; reason = 'overall timebox exceeded';
+  } else if ((input.priorSameSignatureCount ?? 0) >= 1) {
+    action = 'hitl'; reason = 'same incident signature repeated';
+  } else {
+    switch (input.cause) {
+      case 'shard-pod-death': action = 'reroute-shard'; reason = 'replace failed shard Pod'; break;
+      case 'timeout': action = 'retry-shard'; reason = 'retry the timed-out shard within its budget'; break;
+      case 'host-down': action = 'host-switch'; reason = 'move the gate to a healthy host'; break;
+      case 'interference': action = 'partial-resume'; reason = 'resume only the unmeasured or affected work'; break;
+      case 'true-regression': action = 'hitl'; reason = 'measured regression requires a human decision'; break;
+      case 'environment': action = 'hitl'; reason = 'environment cause is not safe to repair automatically'; break;
+    }
+  }
+  return { action, cause: input.cause, signature: input.signature, reason, shardElapsedMs, overallElapsedMs };
+}
+
+export function gateAutohealCause(result: GateResultForAutoheal): GateAutohealCause | undefined {
+  if (result.outcome === 'ok') return undefined;
+  if (result.outcome === 'regression' && (result.introduced?.length ?? 0) > 0) return 'true-regression';
+  if (/host.*(?:down|unreachable)|(?:down|unreachable).*host|ssh.*(?:failed|timeout)/i.test(result.error ?? '')) return 'host-down';
+  if (result.stalledShards?.some((shard) => /timeout/.test(shard.reason))) return 'timeout';
+  if ((result.interferenceErrors?.length ?? 0) > 0 || (result.loadFlaky?.length ?? 0) > 0) return 'interference';
+  if (result.stalledShards?.some((shard) => /pod.*(?:deleted|evicted|terminated|lost|not found)|(?:pod-dead|pod-evicted|pod-deleted)/i.test(`${shard.reason} ${shard.detail ?? ''}`))) return 'shard-pod-death';
+  return 'environment';
+}

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

@@ -24,7 +24,7 @@ export function gateAssignableTestsAtCommit(repo: string, commit: string): strin
 }
 
 export interface GateBaselineReceipt {
-  schema: 1;
+  schema: 2;
   valid: boolean;
   reason: string;
   version: string;
@@ -33,8 +33,35 @@ export interface GateBaselineReceipt {
   recipeSha: string | null;
   envFingerprint: string;
   imageDigest: string | null;
+  executionIdentity: GatePodRuntimeIdentity | null;
   files: number;
   shards: number;
+  attributionRecheck?: { summary: number; observed: number; identified: number; baselineResult: string; targetFiles: string[] };
+}
+
+export interface GatePodRuntimeIdentity {
+  bunVersion: string;
+  platform: string;
+  architecture: string;
+  envFingerprint: string;
+}
+
+const validRuntimeIdentity = (value: unknown): value is GatePodRuntimeIdentity => {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
+  const row = value as Partial<GatePodRuntimeIdentity>;
+  return Object.keys(value).sort().join(',') === 'architecture,bunVersion,envFingerprint,platform'
+    && typeof row.bunVersion === 'string' && /^\d+\.\d+\.\d+(?:[-+][\w.-]+)?$/.test(row.bunVersion)
+    && typeof row.platform === 'string' && /^[a-z0-9_-]{1,32}$/.test(row.platform)
+    && typeof row.architecture === 'string' && /^[a-z0-9_-]{1,32}$/.test(row.architecture)
+    && typeof row.envFingerprint === 'string' && SHA256.test(row.envFingerprint);
+};
+
+/** Parse runtime facts written by the gate Pod before its tests start. */
+export function parseGatePodRuntimeIdentity(text: string): GatePodRuntimeIdentity | null {
+  try {
+    const value: unknown = JSON.parse(text);
+    return validRuntimeIdentity(value) ? value : null;
+  } catch { return null; }
 }
 
 /** A direct hard rehearsal has no graph run state. Pin the graph and recipe bytes at its Git SHA. */
@@ -83,11 +110,18 @@ export function gateGraphPins(root: string, runId: string | undefined): { graphS
 }
 
 export function gateBaselineReceipt(input: { root: string; version: string; commit: string; fullSweep: boolean;
-  graphPins: { graphSha: string; recipeSha: string } | null; envFingerprint: string }): GateBaselineReceipt {
+  graphPins: { graphSha: string; recipeSha: string } | null; envFingerprint: string;
+  attributionRecheck?: { summary: number; observed: number; identified: number; baselineResult: string; targetFiles: 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 base = { schema: 2 as const, version, commit, graphSha: graphPins?.graphSha ?? null,
+    recipeSha: graphPins?.recipeSha ?? null, envFingerprint, imageDigest: null as string | null,
+    executionIdentity: null as GatePodRuntimeIdentity | null, files: 0, shards: 0 };
   const invalid = (reason: string): GateBaselineReceipt => ({ ...base, valid: false, reason });
+  if (input.attributionRecheck) {
+    const evidence = input.attributionRecheck;
+    return { ...invalid(`failure attribution unresolved after baseline recheck (${evidence.baselineResult}): summary=${evidence.summary}, observed=${evidence.observed}, identified=${evidence.identified}`),
+      attributionRecheck: { ...evidence, targetFiles: [...evidence.targetFiles].sort() } };
+  }
   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');
@@ -95,12 +129,14 @@ export function gateBaselineReceipt(input: { root: string; version: string; comm
     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 roots = new Map<number, { files: string[]; shardCount: number; sweepId: string; attemptId: string; runtimeIdentity?: GatePodRuntimeIdentity }>();
+    const descendants: Array<{ name: string; commit?: string; imageDigest?: string; sweepId?: string; parentAttempt?: string; attemptId?: string; runtimeIdentity?: GatePodRuntimeIdentity }> = [];
     const images = new Set<string>();
+    const identities = new Map<string, GatePodRuntimeIdentity>();
     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 };
+        { commit?: string; files?: unknown; shardCount?: number; sweepId?: string; imageDigest?: string; parentAttempt?: string; attemptId?: string; runtimeIdentity?: unknown };
+      const runtimeIdentity = validRuntimeIdentity(row.runtimeIdentity) ? row.runtimeIdentity : undefined;
       const match = /^pod-(\d+)\.json$/.exec(name);
       if (match) {
         if (row.commit !== commit) return invalid(`root cut Pod ${name} belongs to another commit`);
@@ -108,12 +144,16 @@ export function gateBaselineReceipt(input: { root: string; version: string; comm
           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 });
+        roots.set(Number(match[1]), { files: row.files as string[], shardCount: row.shardCount ?? 0,
+          sweepId: row.sweepId, attemptId: row.attemptId, runtimeIdentity });
       } else descendants.push({ name, commit: row.commit, imageDigest: row.imageDigest, sweepId: row.sweepId,
-        parentAttempt: row.parentAttempt, attemptId: row.attemptId });
+        parentAttempt: row.parentAttempt, attemptId: row.attemptId, runtimeIdentity });
       if (match) {
         if (!row.imageDigest || !IMAGE_DIGEST.test(row.imageDigest)) return invalid(`actual Pod image digest absent: ${name}`);
+        if (!runtimeIdentity) return invalid(`actual Pod runtime identity absent: ${name}`);
+        if (runtimeIdentity.envFingerprint !== envFingerprint) return invalid(`actual Pod environment differs: ${name}`);
         images.add(row.imageDigest.toLowerCase());
+        identities.set(JSON.stringify(runtimeIdentity), runtimeIdentity);
       }
     }
     if (!roots.size) return invalid('root cut shards absent');
@@ -137,7 +177,10 @@ export function gateBaselineReceipt(input: { root: string; version: string; comm
         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`);
+        if (!row.runtimeIdentity) return invalid(`actual Pod runtime identity absent: ${row.name}`);
+        if (row.runtimeIdentity.envFingerprint !== envFingerprint) return invalid(`actual Pod environment differs: ${row.name}`);
         images.add(row.imageDigest.toLowerCase());
+        identities.set(JSON.stringify(row.runtimeIdentity), row.runtimeIdentity);
         attempts.add(row.attemptId);
       }
       pending = next;
@@ -150,6 +193,8 @@ export function gateBaselineReceipt(input: { root: string; version: string; comm
       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 };
+    if (identities.size !== 1) return invalid('cut Pods used different runtime identities');
+    return { ...base, valid: true, reason: 'complete clean full sweep', imageDigest: [...images][0]!,
+      executionIdentity: identities.values().next().value!, files: files.length, shards: count };
   } catch (error) { return invalid(`cut Pod evidence unreadable: ${String(error)}`); }
 }

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

@@ -4,9 +4,28 @@ export interface FailureDiff {
   common: string[];
 }
 
+/** One failure identity may be printed more than once when a host retries or concatenates a test run. */
+export function collapseGateFailureAttempts(ids: readonly string[]): { failures: string[]; observed: number; collapsed: number } {
+  const failures = [...new Set(ids)].sort();
+  return { failures, observed: ids.length, collapsed: ids.length - failures.length };
+}
+
+export class GateFailureAttributionMismatch extends Error {
+  constructor(readonly label: string, readonly summary: number, readonly observed: number,
+    readonly identified: number, readonly collapsed: number, readonly failures: readonly string[]) {
+    super(`${label} incomplete (failure attribution mismatch: summary=${summary}, observed=${observed}, identified=${identified})`);
+    this.name = 'GateFailureAttributionMismatch';
+  }
+}
+
 /** Bun's file header followed by `(fail) name` lines is the identity source. */
 export function parseFailures(output: string): string[] {
-  const failures = new Set<string>();
+  return [...new Set(parseFailureAttempts(output))].sort();
+}
+
+/** Raw reporter rows, retaining repeated identities so gate attribution can distinguish retries from missing names. */
+export function parseFailureAttempts(output: string): string[] {
+  const failures: string[] = [];
   let file: string | undefined;
   for (const raw of output.replace(/\x1b\[[0-9;]*[A-Za-z]/g, '').split(/\r?\n/)) {
     const line = raw.trim();
@@ -14,9 +33,9 @@ export function parseFailures(output: string): string[] {
     if (header) { file = header[1]; continue; }
     // Line-start only: a title/body `(fail)` is not a reporter row. Trailing CR is still a real Bun fail row.
     const failed = /^\(fail\)[ \t]+(.+?)(?:[ \t]+\[[\d.]+(?:ms|s)\])?[ \t]*\r?$/.exec(raw);
-    if (failed && file) failures.add(`${file} > ${failed[1]!.trim()}`);
+    if (failed && file) failures.push(`${file} > ${failed[1]!.trim()}`);
   }
-  return [...failures].sort();
+  return failures;
 }
 
 /** GATE-INTRO-RECHECK (0.2.19) — the failures that are bun's «timed out» shape: a `(fail) name` line whose next line is

package/scripts/release-loop/gate-image-pin.ts

@@ -0,0 +1,81 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+
+/** A gate run may execute only against one immutable image identity and its exact source tag. */
+export interface GateImagePin { runId: string; digest: string; image: string; commit: string }
+
+export type GateImagePinResolution =
+  | { ok: true; digest: string; eligiblePools: string[] }
+  | { ok: false; reason: 'saved-image-digest-invalid' | 'initial-image-digest-invalid' | 'initial-image-digest-missing' | 'pinned-image-unavailable' };
+
+export interface ResolveGateImagePinOptions {
+  /** Persisted at the run boundary; takes precedence over any newly probed default. */
+  savedDigest?: string | null;
+  /** Used only to create the pin for a new run. */
+  initialDigest?: string | null;
+  /** Exact immutable digest selected by the gate image probe in each pool. */
+  poolImages: ReadonlyMap<string, readonly string[]>;
+}
+
+function normalizeGateImageDigest(value: unknown): string | null {
+  if (typeof value !== 'string' || !/^sha256:[a-f0-9]{64}$/i.test(value.trim())) return null;
+  return value.trim().toLowerCase();
+}
+
+/**
+ * Resolve the durable run pin and fail closed unless at least one pool can prove it has that exact image.
+ * Callers must filter placement to `eligiblePools`; a mutable tag is never a substitute.
+ */
+export function resolveGateImagePin(options: ResolveGateImagePinOptions): GateImagePinResolution {
+  const hasSaved = options.savedDigest !== undefined && options.savedDigest !== null;
+  const rawDigest = hasSaved ? options.savedDigest : options.initialDigest;
+  if (!hasSaved && (rawDigest === undefined || rawDigest === null || rawDigest.trim() === '')) {
+    return { ok: false, reason: 'initial-image-digest-missing' };
+  }
+  const digest = normalizeGateImageDigest(rawDigest);
+  if (!digest) return { ok: false, reason: hasSaved ? 'saved-image-digest-invalid' : 'initial-image-digest-invalid' };
+  const eligiblePools = [...options.poolImages]
+    .filter(([, images]) => images.some((image) => normalizeGateImageDigest(image) === digest))
+    .map(([pool]) => pool);
+  if (!eligiblePools.length) return { ok: false, reason: 'pinned-image-unavailable' };
+  return { ok: true, digest, eligiblePools };
+}
+
+/** The pin is immutable for one graph gate run; absence on resume is a hard refusal. */
+export function readGateImagePin(path: string, expectedRunId: string, expectedImage: string, expectedCommit: string): GateImagePin | null {
+  if (!existsSync(path)) return null;
+  const parsed = JSON.parse(readFileSync(path, 'utf8')) as { version?: unknown; runId?: unknown; digest?: unknown; image?: unknown; commit?: unknown };
+  const normalizedCommit = expectedCommit.toLowerCase();
+  if (parsed.version !== 2 || parsed.runId !== expectedRunId || parsed.image !== expectedImage || parsed.commit !== normalizedCommit
+    || !normalizeGateImageDigest(parsed.digest))
+    throw new Error(`invalid gate image pin: ${path}`);
+  return { runId: expectedRunId, digest: normalizeGateImageDigest(parsed.digest)!, image: expectedImage, commit: normalizedCommit };
+}
+
+export function writeGateImagePin(path: string, runId: string, digest: string, image: string, commit: string): void {
+  const normalized = normalizeGateImageDigest(digest);
+  if (!runId || !normalized || !image.trim() || !/^[0-9a-f]{40}$/i.test(commit)) throw new Error('invalid gate image pin identity');
+  mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+  const value = JSON.stringify({ version: 2, runId, digest: normalized, image, commit: commit.toLowerCase() });
+  if (existsSync(path)) {
+    const prior = JSON.parse(readFileSync(path, 'utf8')) as { runId?: unknown; digest?: unknown; image?: unknown; commit?: unknown };
+    if (prior.runId !== runId || normalizeGateImageDigest(prior.digest) !== normalized || prior.image !== image
+      || prior.commit !== commit.toLowerCase())
+      throw new Error(`gate image pin is immutable: ${path}`);
+    return;
+  }
+  try { writeFileSync(path, `${value}\n`, { mode: 0o600, flag: 'wx' }); }
+  catch (error) {
+    if ((error as NodeJS.ErrnoException).code !== 'EEXIST') throw error;
+    const prior = JSON.parse(readFileSync(path, 'utf8')) as { runId?: unknown; digest?: unknown; image?: unknown; commit?: unknown };
+    if (prior.runId === runId && normalizeGateImageDigest(prior.digest) === normalized && prior.image === image
+      && prior.commit === commit.toLowerCase()) return;
+    throw new Error(`gate image pin is immutable: ${path}`);
+  }
+}
+
+export function gateImagePinPath(root: string, version: string, runId: string): string {
+  if (!/^\d+\.\d+\.\d+(?:-rc\.\d+)?$/.test(version) || !/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(runId))
+    throw new Error('invalid gate image pin path identity');
+  return `${root.replace(/\/$/, '')}/release/${version}/gate-image-pin-${runId}.json`;
+}