elanous 0.2.40 → 0.2.42

package/scripts/release-loop/gate-train-receipts.ts

@@ -0,0 +1,122 @@
+/** Safe test carry from passed host-regate receipts into a release cut. */
+import { spawnSync } from 'node:child_process';
+import { join } from 'node:path';
+import { gateAssignableTestsAtCommit } from './gate-baseline-receipt.js';
+import { gitClosureTree, testsReachingChanged } from './gate-closure.js';
+import { changedFilesBetween } from './gate-partial.js';
+import { gateReceiptSelfKey, loadGateReceipts, type GateReceipt } from '../../src/self-implement/gate-receipt-registry.js';
+import { SPAWN_SYNC_MAX_BUFFER } from '../../src/util/spawn-sync-output.js';
+
+const SHA = /^[0-9a-f]{40}$/i;
+const TEST = /^(?:[\w.-]+\/)*[\w.-]+\.test\.(?:tsx?|jsx?|mts|cts)$/;
+const INERT = /\.(?:md|mdx|txt)$/i;
+
+function git(repo: string, args: string[]): string | null {
+  const result = spawnSync('git', args, { cwd: repo, encoding: 'utf8', maxBuffer: 32 * 1024 * 1024 });
+  return result.status === 0 && !result.error ? result.stdout.trim() : null;
+}
+
+function ancestor(repo: string, base: string, head: string): boolean {
+  const result = spawnSync('git', ['merge-base', '--is-ancestor', base, head], { cwd: repo, maxBuffer: SPAWN_SYNC_MAX_BUFFER });
+  return result.status === 0 && !result.error;
+}
+
+function blob(repo: string, commit: string, file: string): string | null {
+  return git(repo, ['rev-parse', `${commit}:${file}`]);
+}
+
+function candidateTests(tree: ReturnType<typeof gitClosureTree>, receipt: GateReceipt): string[] {
+  // The registry stores the changed-file radius, not the expanded importer/neighbor list that the
+  // host gate selected. Only changed test files are certainly in that measurement; never infer
+  // pass evidence for siblings or importers that the receipt did not persist explicitly.
+  return [...new Set(receipt.radiusFiles.filter((file) => TEST.test(file) && tree.files.includes(file)))].sort();
+}
+
+export interface GateTrainReceiptPlan {
+  priorCommit: string;
+  files: string[];
+  carriedFiles: string[];
+  totalFiles: number;
+  reasons: string[];
+  receipts: string[];
+}
+
+/** Missing/invalid evidence only reduces carry; it never makes a gate pass. */
+export function planGateTrainReceiptCarry(input: {
+  repo: string;
+  commit: string;
+  receiptPath: string;
+  bunVersion: string;
+  lockfileHash: string;
+  envFingerprint: string;
+}): GateTrainReceiptPlan | null {
+  if (!SHA.test(input.commit) || !input.bunVersion || !input.lockfileHash || !/^[0-9a-f]{64}$/i.test(input.envFingerprint)) return null;
+  const tests = gateAssignableTestsAtCommit(input.repo, input.commit);
+  if (!tests?.length) return null;
+  const receipts = Object.values(loadGateReceipts(input.receiptPath));
+  const currentTree = gitClosureTree(input.repo, input.commit);
+  const carried = new Set<string>();
+  const accepted: GateReceipt[] = [];
+  const reasons = new Set<string>();
+  const changedByBase = new Map<string, string[]>();
+
+  for (const receipt of receipts) {
+    if (receipt.verdict !== 'passed' || gateReceiptSelfKey(receipt) !== receipt.key) { reasons.add('invalid-or-non-passing receipt'); continue; }
+    if (!receipt.checks.some((check) => check === 'test-interference:with-neighbours' || check === 'test-interference:changed-only')) {
+      reasons.add('receipt lacks passing test-interference check'); continue;
+    }
+    if (receipt.bunVersion !== input.bunVersion || receipt.lockfileHash !== input.lockfileHash
+      || receipt.envFingerprint !== input.envFingerprint) { reasons.add('bun/lockfile/environment differs'); continue; }
+    if (!ancestor(input.repo, receipt.baseCommit, input.commit)) { reasons.add('receipt base is not an ancestor of cut'); continue; }
+    if (receipt.radiusFiles.some((file) => !currentTree.files.includes(file)
+      || blob(input.repo, receipt.headCommit, file) !== blob(input.repo, input.commit, file))) {
+      reasons.add('receipt radius changed or missing at cut'); continue;
+    }
+    let measuredChanges: string[];
+    try { measuredChanges = changedFilesBetween(input.repo, receipt.baseCommit, receipt.headCommit); }
+    catch { reasons.add('receipt base-to-head diff unavailable'); continue; }
+    if (measuredChanges.some((file) => !receipt.radiusFiles.includes(file))) {
+      reasons.add('receipt radius does not cover base-to-head changes'); continue;
+    }
+    const candidates = candidateTests(currentTree, receipt);
+    if (!candidates?.length) { reasons.add('receipt test radius is empty or opaque'); continue; }
+
+    let changed: string[];
+    try {
+      changed = changedByBase.get(receipt.baseCommit) ?? changedFilesBetween(input.repo, receipt.baseCommit, input.commit);
+      changedByBase.set(receipt.baseCommit, changed);
+    } catch { reasons.add('cut diff from receipt base unavailable'); continue; }
+    const outside = changed.filter((file) => !receipt.radiusFiles.includes(file) && !INERT.test(file));
+    const nonCodeOutside = outside.find((file) => !/\.(?:[cm]?[jt]sx?)$/.test(file));
+    if (nonCodeOutside) {
+      reasons.add(`non-code release input changed outside receipt radius: ${nonCodeOutside}`); continue;
+    }
+    let safeCandidates = candidates;
+    if (outside.length) {
+      const affected = testsReachingChanged(currentTree, outside, candidates);
+      if (!affected.ok) { reasons.add('cut import closure opaque'); continue; }
+      const affectedSet = new Set(affected.tests);
+      safeCandidates = candidates.filter((test) => !affectedSet.has(test));
+      if (!safeCandidates.length) { reasons.add('merge-skew changes reach every receipt test'); continue; }
+    }
+    for (const test of safeCandidates) carried.add(test);
+    accepted.push(receipt);
+  }
+
+  const noCarry = (reason: string): GateTrainReceiptPlan => ({ priorCommit: accepted[0]?.baseCommit ?? input.commit,
+    files: [...tests], carriedFiles: [], totalFiles: tests.length,
+    reasons: [...new Set([...reasons, ...(reason === 'no safe receipt coverage' && reasons.size ? [] : [reason])])].sort(),
+    receipts: accepted.map((receipt) => receipt.key).sort() });
+  if (!carried.size || !accepted.length) return noCarry(receipts.length ? 'no safe receipt coverage' : 'gate receipt registry empty');
+  const selected = tests.filter((file) => !carried.has(file));
+  // The caller falls back to a full sweep rather than skipping all test Pods.
+  if (!selected.length) return noCarry('all tests carried; keep at least one measured sweep');
+  const latest = [...accepted].sort((a, b) => b.savedAt.localeCompare(a.savedAt))[0]!;
+  return { priorCommit: latest.baseCommit, files: selected, carriedFiles: [...carried].sort(), totalFiles: tests.length,
+    reasons: [...reasons].sort(), receipts: accepted.map((receipt) => receipt.key).sort() };
+}
+
+export function gateReceiptRegistryPath(repo: string): string | null {
+  const common = git(repo, ['rev-parse', '--path-format=absolute', '--git-common-dir']);
+  return common ? join(common, 'elanous-host-regate', 'gate-receipts.json') : null;
+}

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

@@ -1,6 +1,8 @@
 #!/usr/bin/env bun
-import { readFileSync } from 'node:fs';
+import { readFileSync, readdirSync, statSync } from 'node:fs';
+import { join } from 'node:path';
 import { debug } from '../../src/debug/log.js';
+import { effectiveInstanceRoot } from '../../src/instance/resolve.js';
 import { registerStandaloneLogSink } from '../../src/domains/standalone-log-sink.js';
 import type { GateResult } from './gate-node.js';
 import { emitNodeResult, readGraphContext, type GraphContext } from './node-verdict.js';
@@ -39,8 +41,32 @@ export interface GateTriageShadow {
     loadFlaky: string[] | null;
     stalledEnv: Array<{ file: string; local: string }>;
   };
-  /** Shadow always goes to the existing failure exit. */
-  outcome: 'fail';
+  /** Classification succeeded; the release graph still routes to its failure exit. */
+  outcome: 'ok' | 'error';
+}
+
+/** A prescription is selected from observed gate facts. Execution waits until the failed run is terminal. */
+export type GatePrescription =
+  | { action: 'rerun-pod'; reason: string; runId: string | null; commit: string }
+  | { action: 'repair-card'; reason: string; runId: string | null; commit: string; failureIds: string[] }
+  | { action: 'decision-card'; reason: string; runId: string | null; commit: string }
+  | { action: 'none'; reason: string; runId: string | null; commit: string };
+
+export function chooseGatePrescription(context: GraphContext, triage: GateTriageShadow): GatePrescription {
+  const runId = context.runId ?? null;
+  const common = { runId, commit: triage.commit };
+  const gate = context.outputs.gate;
+  const unattributed = (Array.isArray(gate?.stalledShards)
+    && gate.stalledShards.some((shard: unknown) => shard && typeof shard === 'object'
+      && (shard as { reason?: unknown }).reason === 'unattributed'))
+    || (typeof gate?.error === 'string' && /failure attribution (?:incomplete|summary=)|unattributed/.test(gate.error));
+  if (triage.classification === 'exhausted')
+    return { ...common, action: 'decision-card', reason: 'same gate symptom recurred twice' };
+  if (unattributed && triage.introduced.length === 0 && context.input.gateExecutor === 'host')
+    return { ...common, action: 'rerun-pod', reason: 'host gate attribution incomplete' };
+  if (triage.classification === 'regression' && triage.introduced.length > 0)
+    return { ...common, action: 'repair-card', reason: 'introduced gate regressions', failureIds: [...triage.introduced] };
+  return { ...common, action: 'none', reason: `no evidence-backed automatic remedy for ${triage.classification}` };
 }
 
 function timeoutShape(gate: GateResult): boolean {
@@ -104,11 +130,12 @@ export function classifyGateShadow(gate: GateResult, evidence: GateTriageEvidenc
       environmentFailureIds: evidence.environmentFailureIds ? [...evidence.environmentFailureIds] : null,
       loadFlaky: gate.loadFlaky ? [...gate.loadFlaky] : null,
       stalledEnv: gate.stalledEnv.map((item) => ({ file: item.file, local: item.local })) },
-    outcome: 'fail' };
+    outcome: 'ok' };
 }
 
 /** Read only the completed gate output. The graph wiring is a separate change after M3. */
-export function gateTriageShadowFromContext(context: GraphContext, evidence?: GateTriageEvidence): GateTriageShadow {
+export function gateTriageShadowFromContext(context: GraphContext, evidence?: GateTriageEvidence,
+  ledgerHistory: NonNullable<GateTriageEvidence['priorDecisions']> = []): GateTriageShadow {
   const value = context.outputs.gate;
   if (!value || typeof value.commit !== 'string' || !Array.isArray(value.introduced)
     || !value.introduced.every((item) => typeof item === 'string')
@@ -140,6 +167,7 @@ export function gateTriageShadowFromContext(context: GraphContext, evidence?: Ga
       && item.failureIds.every((id: unknown) => typeof id === 'string'))
       ? { priorDecisions: supplied.priorDecisions as GateTriageEvidence['priorDecisions'] } : {}),
   };
+  if (!observed.priorDecisions && ledgerHistory.length) observed.priorDecisions = ledgerHistory;
   // The graph adapter maps a measured gate regression to `fail` for edge routing.
   // Restore the gate verdict before classifying the shadow; keep the context untouched.
   const gate = value.outcome === 'fail' ? { ...value, outcome: 'regression' } : value;
@@ -150,6 +178,34 @@ export function logGateTriageShadow(result: GateTriageShadow, version: string):
   debug.log('graph.ground', 'gate-triage-shadow', { version, ...result });
 }
 
+/** Last two completed triage facts from distinct release runs on this exact cut commit. */
+export function priorGateDecisionsFromLedger(context: GraphContext, root = effectiveInstanceRoot()): NonNullable<GateTriageEvidence['priorDecisions']> {
+  const commit = context.outputs.gate?.commit;
+  if (typeof commit !== 'string' || !commit) return [];
+  const dir = join(root, 'graph-runs', 'release-loop');
+  try {
+    const files = readdirSync(dir).filter(name => name.endsWith('.json'))
+      .map(name => ({ name, mtime: statSync(join(dir, name)).mtimeMs }))
+      .sort((a, b) => b.mtime - a.mtime).slice(0, 200);
+    const prior: NonNullable<GateTriageEvidence['priorDecisions']> = [];
+    for (const { name } of files) {
+      try {
+        const state = JSON.parse(readFileSync(join(dir, name), 'utf8')) as Record<string, unknown>;
+        if (state.runId === context.runId || (state.input as Record<string, unknown> | undefined)?.version !== context.input.version) continue;
+        const nodes = Array.isArray(state.nodes) ? state.nodes as Array<Record<string, unknown>> : [];
+        const node = [...nodes].reverse().find(item => item.nodeId === 'gate-triage' && item.executed === true);
+        const raw = node?.output;
+        const output = typeof raw === 'string' ? JSON.parse(raw) as Record<string, unknown> : raw as Record<string, unknown> | undefined;
+        if (output?.commit !== commit || !['unmeasured', 'load', 'env', 'regression', 'clean'].includes(String(output.classification))
+          || !Array.isArray(output.failureIds) || !output.failureIds.every(id => typeof id === 'string')) continue;
+        prior.push({ classification: output.classification as GateTriageClass, commit, failureIds: output.failureIds as string[] });
+        if (prior.length === 2) break;
+      } catch { /* Other runs may be incomplete while their ledger is being written. */ }
+    }
+    return prior.reverse();
+  } catch { return []; }
+}
+
 /** A saved verdict has fewer fields than the live gate output. Keep the absent evidence absent. */
 export function gateTriageShadowFromSavedVerdict(value: unknown): { version: string; result: GateTriageShadow } {
   if (!value || typeof value !== 'object' || Array.isArray(value)) throw new Error('invalid saved gate verdict');
@@ -174,20 +230,24 @@ if (import.meta.main) {
   try {
     const savedPath = process.argv[2] === '--gate-verdict' ? process.argv[3] : undefined;
     if (process.argv[2] && !savedPath) throw new Error('usage: gate-triage-node.ts [--gate-verdict <path>]');
+    const context = savedPath ? undefined : readGraphContext();
+    const history = context ? priorGateDecisionsFromLedger(context) : [];
     const { version, result } = savedPath
       ? gateTriageShadowFromSavedVerdict(JSON.parse(readFileSync(savedPath, 'utf8')))
-      : (() => { const context = readGraphContext(); return { version: context.input.version,
-        result: gateTriageShadowFromContext(context) }; })();
+      : { version: context!.input.version, result: gateTriageShadowFromContext(context!, undefined, history) };
     logGateTriageShadow(result, version);
-    emitNodeResult({ ...result, verdict: 'fail', summary: `gate-triage shadow: ${result.classification} — ${result.reason}` });
+    const prescription = context ? chooseGatePrescription(context, result) : undefined;
+    if (prescription) debug.log('release-loop.heal', 'prescribed-shadow', { version, ...prescription });
+    emitNodeResult({ ...result, ...(prescription ? { prescription } : {}), verdict: 'ok',
+      summary: `gate-triage shadow: ${result.classification} — ${result.reason}` });
   } catch (error) {
     const reason = error instanceof Error ? error.message : String(error);
-    const result: GateTriageShadow = { outcome: 'fail', classification: 'unmeasured', reason,
+    const result: GateTriageShadow = { outcome: 'error', classification: 'unmeasured', reason,
       commit: 'unknown', introduced: [], stalledFiles: [], failureIds: [],
       evidence: { highLoad: null, isolatedReproductions: null, isolatedCheckedFailureIds: null,
         isolatedPassedFiles: null, environmentFailureIds: null, loadFlaky: null, stalledEnv: [] } };
     logGateTriageShadow(result, 'unknown');
     emitNodeResult({ ...result, verdict: 'fail', summary: `gate-triage shadow: ${reason}` });
+    process.exitCode = 1;
   }
-  process.exitCode = 1;
 }