@afokapu/atdd-bun 0.10.98 → 0.10.100

package/detectors/bun_interlocking_coverage/_shared/interlocking.mjs

@@ -8,7 +8,7 @@
 // data (snake_case, plan/_trains/_interlockings/**); the e2e tests are Bun/TS under e2e/**.
 
 import { excludedPath } from "../../../lib/scan.mjs";
-import { entryDelegatedAction, provenJourneyAction } from "../../../lib/journey-chain.mjs";
+import { directInterlockingExecutionProofs, entryDelegatedAction, provenJourneyAction } from "../../../lib/journey-chain.mjs";
 import { existsSync, readFileSync, statSync, readdirSync, writeFileSync } from "node:fs";
 import { dirname, join, resolve, sep } from "node:path";
 
@@ -556,9 +556,10 @@ function resolutionTrainExecution(after, resolution) {
 }
 
 export function productionExecutionProofs(text, file, croot) {
-  if (file && croot && !hasResolvedProductionRunnerImports(text, file, croot)) return [];
+  const directProofs = file && croot ? directInterlockingExecutionProofs(text, file, croot) : [];
+  if (file && croot && !hasResolvedProductionRunnerImports(text, file, croot)) return directProofs;
   const receivers = productionReceivers(text);
-  const proofs = [];
+  const proofs = [...directProofs];
   const resolutions = new RegExp(`\\b(?:const|let|var)\\s+(${ident})(?:\\s*:\\s*[^=;\\n]+)?\\s*=\\s*([^=;{}\\n]{0,240}?)\\.resolveTrain\\s*\\(`, "g");
   for (const m of text.matchAll(resolutions)) {
     const [whole, resolution, receiver] = m;
@@ -577,8 +578,16 @@ export function assertsExpression(text, expression, expected = null) {
   return Boolean(m && (!expected || tokenCovered(expected, m[0])));
 }
 
+function directResolutionAssertion(proof, fields, expected = null) {
+  return fields.some((field) => (proof.direct?.resolution[field] ?? [])
+    .some((assertion) => !expected || tokenCovered(expected, assertion)));
+}
+
 export function hasProductionExecutionProof(text, file, croot) {
-  return productionExecutionProofs(text, file, croot).some(({ resolution, execution }) => {
+  return productionExecutionProofs(text, file, croot).some((proof) => {
+    const { resolution, execution, direct } = proof;
+    if (direct) return directResolutionAssertion(proof, ["routeId", "trainId", "selectedTrainId"]) ||
+      direct.execution || direct.traceFields.length > 0;
     if (assertsExpression(text, `${escaped(resolution)}\\.(?:routeId|trainId|selectedTrainId)`) ||
       (execution && assertsExpression(text, escaped(execution)))) return true;
     if (!execution) return false;
@@ -589,16 +598,24 @@ export function hasProductionExecutionProof(text, file, croot) {
 
 export function routeHasProductionProof(route, text, interlockingId = null, file, croot) {
   const slug = interlockingId?.replace(/^interlocking:/, "");
-  return productionExecutionProofs(text, file, croot).some(({ resolution, execution }) => {
-    const assertedRoute = assertsExpression(text, `${escaped(resolution)}\\.routeId`, route.routeId);
-    const assertedTrain = assertsExpression(text, `${escaped(resolution)}\\.(?:trainId|selectedTrainId)`, route.trainId);
+  return productionExecutionProofs(text, file, croot).some((proof) => {
+    const { resolution, execution, direct } = proof;
+    const assertedRoute = direct
+      ? directResolutionAssertion(proof, ["routeId"], route.routeId)
+      : assertsExpression(text, `${escaped(resolution)}\\.routeId`, route.routeId);
+    const assertedTrain = direct
+      ? directResolutionAssertion(proof, ["trainId", "selectedTrainId"], route.trainId)
+      : assertsExpression(text, `${escaped(resolution)}\\.(?:trainId|selectedTrainId)`, route.trainId);
     const scoped = !interlockingId || tokenCovered(interlockingId, text) || tokenCovered(slug, text);
-    return (assertedRoute && scoped) || assertedTrain || Boolean(scoped && execution && assertsExpression(text, escaped(execution)) && (tokenCovered(route.routeId, text) || tokenCovered(route.trainId, text)));
+    const assertedExecution = direct ? direct.execution : execution && assertsExpression(text, escaped(execution));
+    return (assertedRoute && scoped) || assertedTrain || Boolean(scoped && assertedExecution &&
+      (tokenCovered(route.routeId, text) || tokenCovered(route.trainId, text)));
   });
 }
 
 export function traceHasProductionProvenance(text, file, croot) {
-  return productionExecutionProofs(text, file, croot).some(({ execution }) => {
+  return productionExecutionProofs(text, file, croot).some(({ execution, direct }) => {
+    if (direct) return direct.traceBound && REQUIRED_TRACE_FIELDS.every(([field]) => direct.traceFields.includes(field));
     if (!execution) return false;
     const trace = new RegExp(`\\b(?:const|let|var)\\s+(${ident})(?:\\s*:\\s*[^=;\\n]+)?\\s*=\\s*(?:await\\s+)?${escaped(execution)}\\.trace\\b`).exec(text)?.[1];
     return Boolean(trace);
@@ -706,7 +723,10 @@ export function routeHasStationModuleProof(route, text, action, stationText, sta
 // kills reorder/removal mutants, objectContaining records a handoff edge, and at(-1) observes the
 // final wagon.  All three must be about the TrainRunner result, never a hand-built literal.
 export function hasSequenceMutationProof(text, trainId, file, croot) {
-  return productionExecutionProofs(text, file, croot).some(({ resolution, execution }) => {
+  return productionExecutionProofs(text, file, croot).some((proof) => {
+    const { resolution, execution, direct } = proof;
+    if (direct) return directResolutionAssertion(proof, ["trainId", "selectedTrainId"], trainId) &&
+      direct.sequence.ordered && direct.sequence.handoff && direct.sequence.final;
     if (!execution || !assertsExpression(text, `${escaped(resolution)}\\.(?:trainId|selectedTrainId)`, trainId)) return false;
     const result = escaped(execution);
     const ordered = new RegExp(`expect\\s*\\(\\s*${result}\\.(?:steps|sequence|wagons)\\s*\\)\\s*\\.to(?:Equal|StrictEqual)\\s*\\(\\s*\\[`, "s").test(text);

package/integrity.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.10.98",
+  "version": "0.10.100",
   "files": {
     "HOOK_AUDIT.md": "5329d840db37671b1918f688ead26865473b87db73dbc75f7c8b2a8bbe8d6d43",
     "PLANNER_PORT.md": "fb5935bac8b7ac18994de21e43ace3a5ef8cd55f85b0e3349fca261280054f11",
@@ -385,7 +385,7 @@
     "detectors/bun_interlocking_binding/fixtures/dirty_transcribed_runtime/server.ts": "d5bc34c5b1b2b0a511e0c4604ce6f9c77491dca9aee994be720540f3052babc1",
     "detectors/bun_interlocking_binding/fixtures/dirty_transcribed_runtime/src/trains/interlocking.ts": "9bcfdb4ecff6efd1f658b9fd587342615179924e25468c75daa07c2626d4d8ab",
     "detectors/bun_interlocking_binding/fixtures/dirty_transcribed_runtime/src/trains/runner.ts": "0e4b885e50f12cc2a8c8f6740bf83e7b2e7137a28e1e143586e9a8550ea5bd45",
-    "detectors/bun_interlocking_coverage/_shared/interlocking.mjs": "8a90490daaaa6eecf4c971fb569da38156b45969d48755dbcf355175dde0b079",
+    "detectors/bun_interlocking_coverage/_shared/interlocking.mjs": "e4de9503c31ed631e2e6a0bd5b21e78ee8ca1f1186fa93ff65106ff47695013e",
     "detectors/bun_interlocking_coverage/atdd.implementation.yaml": "f160517a8138ba3ca05e3d130e6fbfb796e643376f25743fdef4fc210196525b",
     "detectors/bun_interlocking_coverage/checks/_map.json": "0a218ea319cc6258af7bd721c2154cb9561fe67e80d80ef32d08fc77bc9403c3",
     "detectors/bun_interlocking_coverage/checks/interlocking_production_runner.mjs": "97224d46f0c4c3259f15e41f90bb7f9f5a4e651d4facd41f1e037cac919be500",
@@ -1034,7 +1034,7 @@
     "lib/frontend.mjs": "d6d9b29c3d7f2d162cda03bb34b20a3224a82887b6be3db7cab375510913c9a3",
     "lib/imports.mjs": "3db4979269488fa26f6e7aefded6ece9c646be6587a10e249821a5a208109962",
     "lib/interlocking.mjs": "d0803d080ac7d7477c51be70112df1e85213d339fd3c6b71f75f26145fa8accd",
-    "lib/journey-chain.mjs": "bdafc9cc3da4ade644aebacc6e1015e29285b764465588d764b7c581bade9025",
+    "lib/journey-chain.mjs": "34b1efa073b17940fa398af2970c85bb2fac35e4b2608ce635cfb6c39e3adc53",
     "lib/scan.mjs": "b6973e411ecd14c548a055c871e01e948f002b772042136be8401f38d998e687",
     "planner-nodes/ENFORCEMENT_SCOPE.yaml": "d8ec7039c219857f3d77af5d4d84612b533b69c1a5fcef935fbf46470adafed4",
     "planner-nodes/nodes/planner.acceptance.abstract-fields-required.convention.yaml": "bd565693f0ae861f0561ad2f7a91a8c55f9a209c3acd59c5750cfcffd96a85d8",
@@ -1261,7 +1261,7 @@
     "src/cli.ts": "d93c3aebb78e752fd96347a5b177c0ed0697010c6e2533e116de93e772cd65a8",
     "src/docs-capability.ts": "bdeeb414649049b1cd4fa8008cada3a576318be51c43bec91bfa46a8e250c270",
     "src/enforce.ts": "e0c10519aeecd7080f2900ea230fad2f09482af47c1cee885d5de71573e29732",
-    "src/hooks.ts": "b96b5fee3a03c2f4c317d6725d6d21ed3133db18d0cdcdda72183cf05c7b6639",
+    "src/hooks.ts": "8194c2dec14afc307b5ce9e90f64d8659210c579d8f427492823293f302e2876",
     "src/index.ts": "4081f8b08d1d3ee9e15a9964143e53d9cfb94a5616ab3e58a180d24cc16dc381",
     "src/integrity.ts": "f1ede7cb04924ae88e11917047277e264af6596b9759e381bd9c497cd34a797d",
     "src/journey-docs.ts": "994d229376244c84212cff951032823068a76565dd2fd427b9d44e341bd14853",

package/lib/journey-chain.mjs

@@ -134,7 +134,7 @@ const accessName = (node) =>
 
 // Why the module can replace a runner's behaviour outside its declared method (see the override
 // contract above), or null. Deliberately module-wide: it fails closed.
-function tampered(ctx) {
+function tampered(ctx, allowedRunnerWrite = () => false) {
   let found = null;
   const runnerClass = (node) => (ts.isClassDeclaration(node) || ts.isClassExpression(node)) && RUNNERS.has(node.name?.text);
   const insideRunnerClass = (node) => {
@@ -207,7 +207,8 @@ function tampered(ctx) {
       node.operatorToken.kind <= ts.SyntaxKind.LastAssignment) {
       const target = unwrap(node.left);
       if ((ts.isPropertyAccessExpression(target) || ts.isElementAccessExpression(target)) &&
-        (reachesRunner(target.expression) || (MEMBERS.has(accessName(target)) && prototypeish(target.expression)))) found = "runner write";
+        (reachesRunner(target.expression) || (MEMBERS.has(accessName(target)) && prototypeish(target.expression))) &&
+        !allowedRunnerWrite(node, target)) found = "runner write";
     }
     if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression)) {
       const api = node.expression.name.text;
@@ -612,6 +613,289 @@ function journeyExecutes(croot) {
   };
 }
 
+function importedValue(ctx, identifier, croot) {
+  if (!identifier || !ts.isIdentifier(identifier)) return null;
+  const declaration = declarationOf(ctx, identifier);
+  if (!declaration || !ts.isImportSpecifier(declaration) || declaration.isTypeOnly) return null;
+  const clause = declaration.parent.parent;
+  const statement = clause.parent;
+  if (clause.isTypeOnly || !ts.isStringLiteral(statement.moduleSpecifier)) return null;
+  const file = productionModule(statement.moduleSpecifier.text, ctx.file, croot);
+  return file ? { file, name: (declaration.propertyName ?? declaration.name).text } : null;
+}
+
+function exportedConst(ctx, name) {
+  let found = null;
+  let directlyExported = false;
+  let listed = false;
+  for (const statement of ctx.source.statements) {
+    if (ts.isVariableStatement(statement) && statement.declarationList.flags & ts.NodeFlags.Const) {
+      for (const declaration of statement.declarationList.declarations) {
+        if (!ts.isIdentifier(declaration.name) || declaration.name.text !== name) continue;
+        if (found) return null;
+        found = declaration;
+        directlyExported = Boolean(ts.getCombinedModifierFlags(statement) & ts.ModifierFlags.Export);
+      }
+    }
+    if (ts.isExportDeclaration(statement) && !statement.moduleSpecifier && statement.exportClause && ts.isNamedExports(statement.exportClause)) {
+      listed ||= statement.exportClause.elements.some((element) =>
+        (element.propertyName ?? element.name).text === name && element.name.text === name);
+    }
+  }
+  return found && (directlyExported || listed) ? found : null;
+}
+
+function handlerConfiguration(ctx, expression, seen = new Set()) {
+  const value = unwrap(expression);
+  if (!value) return false;
+  if (ts.isObjectLiteralExpression(value)) return value.properties.length > 0;
+  if (!ts.isIdentifier(value)) return false;
+  const initializer = constInitializer(ctx, value);
+  if (!initializer || seen.has(initializer)) return false;
+  seen.add(initializer);
+  return handlerConfiguration(ctx, initializer, seen);
+}
+
+function injectedTrainField(ctx, cls) {
+  const constructors = cls.members.filter(ts.isConstructorDeclaration);
+  if (constructors.length !== 1 || !constructors[0].body || constructors[0].parameters.length !== 1) return null;
+  const constructor = constructors[0];
+  const parameter = constructor.parameters[0].name;
+  if (!ts.isObjectBindingPattern(parameter)) return null;
+  const binding = parameter.elements.find((element) =>
+    !element.dotDotDotToken && ts.isIdentifier(element.name) &&
+    (element.propertyName ?? element.name).getText() === "trainRunner");
+  if (!binding || !ts.isIdentifier(binding.name)) return null;
+  const parameterSymbol = symbolOf(ctx, binding.name);
+  const assignments = [];
+  walk(constructor.body, (node) => {
+    if (!ts.isBinaryExpression(node) || node.operatorToken.kind !== ts.SyntaxKind.EqualsToken) return;
+    const target = unwrap(node.left);
+    const value = unwrap(node.right);
+    if (ts.isPropertyAccessExpression(target) && target.expression.kind === ts.SyntaxKind.ThisKeyword &&
+      ts.isIdentifier(value) && symbolOf(ctx, value) === parameterSymbol) assignments.push({ node, field: target.name.text });
+  }, false);
+  return assignments.length === 1 ? assignments[0] : null;
+}
+
+function objectProperty(ctx, expression, name, seen = new Set()) {
+  const value = unwrap(expression);
+  if (!value) return null;
+  if (ts.isIdentifier(value)) {
+    const initializer = constInitializer(ctx, value);
+    if (!initializer || seen.has(initializer)) return null;
+    seen.add(initializer);
+    return objectProperty(ctx, initializer, name, seen);
+  }
+  if (!ts.isObjectLiteralExpression(value)) return null;
+  const properties = value.properties.filter((property) => memberName(property) === name);
+  if (properties.length !== 1) return null;
+  const property = properties[0];
+  if (ts.isPropertyAssignment(property)) return property.initializer;
+  if (ts.isShorthandPropertyAssignment(property)) return property.name;
+  return null;
+}
+
+function directInterlockingMethod(ctx, cls, field) {
+  if (!soleMethod(ctx, cls, "resolveTrain")) return null;
+  const method = soleMethod(ctx, cls, "execute");
+  const returns = method && liveReturns(method);
+  if (!method || !returns?.length) return null;
+  const declarations = [];
+  walk(method.body, (node) => {
+    if (!ts.isVariableDeclaration(node) || !ts.isIdentifier(node.name) || !node.initializer) return;
+    const call = unwrap(node.initializer);
+    if (ts.isCallExpression(call) && ts.isPropertyAccessExpression(call.expression) &&
+      call.expression.expression.kind === ts.SyntaxKind.ThisKeyword && call.expression.name.text === "resolveTrain") declarations.push(node);
+  }, false);
+  for (const declaration of declarations) {
+    const symbol = symbolOf(ctx, declaration.name);
+    if (!symbol) continue;
+    const isResolution = (node) => Boolean(node) && ts.isIdentifier(unwrap(node)) && symbolOf(ctx, unwrap(node)) === symbol;
+    const isExecution = (node) => {
+      const call = unwrap(node);
+      return Boolean(call && ts.isCallExpression(call) && ts.isPropertyAccessExpression(call.expression) &&
+        call.expression.name.text === "execute" && ts.isPropertyAccessExpression(call.expression.expression) &&
+        call.expression.expression.expression.kind === ts.SyntaxKind.ThisKeyword &&
+        call.expression.expression.name.text === field && isResolution(call.arguments[0]));
+    };
+    const returned = returns.every((expression) => {
+      const resolution = expression && objectProperty(ctx, expression, "resolution");
+      const trainResult = expression && objectProperty(ctx, expression, "trainResult");
+      return resolution && trainResult && carries(ctx, resolution, isResolution) && carries(ctx, trainResult, isExecution);
+    });
+    if (returned && resolutionUnchanged(ctx, method, declaration, symbol, returns, isExecution)) return method;
+  }
+  return null;
+}
+
+function compositionProof(serverFile, exportName, croot) {
+  const server = analyze(serverFile);
+  const interlocking = exportedConst(server, exportName);
+  const construction = interlocking?.initializer && unwrap(interlocking.initializer);
+  if (!construction || !ts.isNewExpression(construction)) return null;
+  const interlockingFile = importedRunner(server, construction.expression, "InterlockingRunner", croot);
+  const argument = construction.arguments?.[0];
+  const trainReference = argument && objectProperty(server, argument, "trainRunner");
+  if (!interlockingFile || !trainReference || !ts.isIdentifier(unwrap(trainReference))) return null;
+  const trainDeclaration = declarationOf(server, unwrap(trainReference));
+  if (!trainDeclaration || !ts.isVariableDeclaration(trainDeclaration) ||
+    !ts.isVariableDeclarationList(trainDeclaration.parent) || !(trainDeclaration.parent.flags & ts.NodeFlags.Const)) return null;
+  const trainConstruction = trainDeclaration.initializer && unwrap(trainDeclaration.initializer);
+  if (!trainConstruction || !ts.isNewExpression(trainConstruction) ||
+    !handlerConfiguration(server, trainConstruction.arguments?.[0])) return null;
+  const trainFile = importedRunner(server, trainConstruction.expression, "TrainRunner", croot);
+  if (!trainFile) return null;
+
+  const interlockingCtx = analyze(interlockingFile);
+  const interlockingClass = exportedClass(interlockingCtx, "InterlockingRunner");
+  const injection = interlockingClass && injectedTrainField(interlockingCtx, interlockingClass);
+  if (!interlockingClass || !injection || constructorReturnsValue(interlockingClass) ||
+    tampered(interlockingCtx, (node) => node === injection.node) ||
+    !directInterlockingMethod(interlockingCtx, interlockingClass, injection.field)) return null;
+
+  const trainCtx = analyze(trainFile);
+  const trainClass = exportedClass(trainCtx, "TrainRunner");
+  if (!trainClass || constructorReturnsValue(trainClass) || tampered(trainCtx) || !soleMethod(trainCtx, trainClass, "execute")) return null;
+  return { interlockingFile, interlockingCtx, injection, trainFile };
+}
+
+function awaitedCall(expression) {
+  let value = expression;
+  while (value && (ts.isParenthesizedExpression(value) || ts.isAsExpression(value) || ts.isNonNullExpression(value) ||
+    ts.isSatisfiesExpression(value) || ts.isTypeAssertionExpression(value))) value = value.expression;
+  return value && ts.isAwaitExpression(value) ? unwrap(value.expression) : null;
+}
+
+function expectIdentifier(ctx, node) {
+  if (!ts.isIdentifier(node) || node.text !== "expect") return false;
+  const declaration = declarationOf(ctx, node);
+  if (!declaration) return true;
+  const statement = ts.isImportSpecifier(declaration) ? declaration.parent.parent.parent : null;
+  return Boolean(statement && ts.isStringLiteral(statement.moduleSpecifier) && statement.moduleSpecifier.text === "bun:test" &&
+    (declaration.propertyName ?? declaration.name).text === "expect");
+}
+
+function expectAssertion(ctx, node) {
+  if (!ts.isCallExpression(node) || !ts.isPropertyAccessExpression(node.expression)) return null;
+  let access = node.expression;
+  const matcher = access.name.text;
+  let receiver = access.expression, negated = false;
+  if (ts.isPropertyAccessExpression(receiver) && receiver.name.text === "not") {
+    negated = true;
+    receiver = receiver.expression;
+  }
+  if (!MATCHERS.has(matcher) || (negated && !NEGATED_MATCHERS.has(matcher)) ||
+    !ts.isCallExpression(receiver) || !expectIdentifier(ctx, receiver.expression) || !receiver.arguments[0]) return null;
+  return { actual: receiver.arguments[0], matcher, negated, expected: node.arguments[0] ?? null, call: node };
+}
+
+function pathFromSymbol(ctx, expression, symbol) {
+  const node = unwrap(expression);
+  if (!node) return null;
+  if (ts.isIdentifier(node)) return symbolOf(ctx, node) === symbol ? [] : null;
+  if (ts.isPropertyAccessExpression(node)) {
+    const path = pathFromSymbol(ctx, node.expression, symbol);
+    return path && [...path, node.name.text];
+  }
+  if (ts.isElementAccessExpression(node) && node.argumentExpression && ts.isStringLiteralLike(node.argumentExpression)) {
+    const path = pathFromSymbol(ctx, node.expression, symbol);
+    return path && [...path, node.argumentExpression.text];
+  }
+  if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && node.expression.name.text === "at" &&
+    node.arguments.length === 1 && node.arguments[0].getText() === "-1") {
+    const path = pathFromSymbol(ctx, node.expression.expression, symbol);
+    return path && [...path, "at(-1)"];
+  }
+  return null;
+}
+
+function directAssertionFacts(ctx, resolutionSymbol, executionSymbol) {
+  const traceSymbols = new Set();
+  walk(ctx.source, (node) => {
+    if (!ts.isVariableDeclaration(node) || !ts.isIdentifier(node.name) || !node.initializer ||
+      !(ts.isVariableDeclarationList(node.parent) && node.parent.flags & ts.NodeFlags.Const)) return;
+    const path = pathFromSymbol(ctx, node.initializer, executionSymbol);
+    if (path?.length === 1 && path[0] === "trace") traceSymbols.add(symbolOf(ctx, node.name));
+  });
+  const facts = {
+    resolution: { routeId: [], trainId: [], selectedTrainId: [] },
+    execution: false,
+    traceBound: traceSymbols.size > 0,
+    traceFields: [],
+    sequence: { ordered: false, handoff: false, final: false },
+  };
+  walk(ctx.source, (node) => {
+    const assertion = expectAssertion(ctx, node);
+    if (!assertion || dead(node, ctx.source) || insideCatch(node, ctx.source)) return;
+    const resolutionPath = pathFromSymbol(ctx, assertion.actual, resolutionSymbol);
+    if (resolutionPath?.length === 1 && Object.hasOwn(facts.resolution, resolutionPath[0])) {
+      facts.resolution[resolutionPath[0]].push(assertion.call.getText(ctx.source));
+    }
+    const executionPath = pathFromSymbol(ctx, assertion.actual, executionSymbol);
+    if (executionPath?.length === 0) facts.execution = true;
+    if (!assertion.negated && executionPath?.length === 1 && ["steps", "sequence", "wagons"].includes(executionPath[0])) {
+      facts.sequence.ordered ||= ["toEqual", "toStrictEqual"].includes(assertion.matcher) &&
+        Boolean(assertion.expected && ts.isArrayLiteralExpression(unwrap(assertion.expected)));
+      facts.sequence.handoff ||= assertion.matcher === "toContainEqual" &&
+        /\bexpect\.objectContaining\s*\(\s*\{[\s\S]{0,240}?\b(?:from|to)\s*:/.test(assertion.expected?.getText(ctx.source) ?? "");
+    }
+    if (!assertion.negated && executionPath?.length === 2 && executionPath[1] === "at(-1)" &&
+      ["steps", "sequence", "wagons"].includes(executionPath[0]) &&
+      ["toBe", "toEqual", "toStrictEqual", "toMatch"].includes(assertion.matcher)) facts.sequence.final = true;
+    for (const traceSymbol of traceSymbols) {
+      const tracePath = pathFromSymbol(ctx, assertion.actual, traceSymbol);
+      if (tracePath?.length === 1 && !facts.traceFields.includes(tracePath[0])) facts.traceFields.push(tracePath[0]);
+    }
+  });
+  return facts;
+}
+
+// Direct production proof for a test that awaits an imported, server-composed InterlockingRunner,
+// destructures its real resolution/trainResult pair, and leaves the whole local production chain
+// untampered. Assertion facts retain checker-symbol identity so a shadowed same-name literal cannot
+// satisfy any downstream route, runner, trace or sequence proof.
+export function directInterlockingExecutionProofs(testText, testFile, croot) {
+  if (!testText || !testFile || !croot ||
+    !/\bconst\s*\{(?=[^}\n]*\bresolution\b)(?=[^}\n]*\btrainResult\b)[^}\n]*\}[^=;\n]*=\s*await\b/.test(testText)) return [];
+  const ctx = analyze(testFile, testText);
+  const proofs = [];
+  walk(ctx.source, (node) => {
+    if (!ts.isVariableDeclaration(node) || !ts.isObjectBindingPattern(node.name) || !node.initializer ||
+      !(ts.isVariableDeclarationList(node.parent) && node.parent.flags & ts.NodeFlags.Const) ||
+      dead(node, ctx.source) || insideCatch(node, ctx.source)) return;
+    const call = awaitedCall(node.initializer);
+    if (!call || !ts.isCallExpression(call) || !ts.isPropertyAccessExpression(call.expression) ||
+      call.expression.name.text !== "execute" || !ts.isIdentifier(call.expression.expression)) return;
+    const imported = importedValue(ctx, call.expression.expression, croot);
+    if (!imported) return;
+    const composition = compositionProof(imported.file, imported.name, croot);
+    if (!composition) return;
+    const binding = (property) => {
+      const element = node.name.elements.find((candidate) => !candidate.dotDotDotToken &&
+        (candidate.propertyName ?? candidate.name).getText() === property);
+      return element && ts.isIdentifier(element.name) ? element.name : null;
+    };
+    const resolutionBinding = binding("resolution"), executionBinding = binding("trainResult");
+    const resolutionSymbol = resolutionBinding && symbolOf(ctx, resolutionBinding);
+    const executionSymbol = executionBinding && symbolOf(ctx, executionBinding);
+    if (!resolutionBinding || !executionBinding || !resolutionSymbol || !executionSymbol) return;
+    const closure = localImportClosure(testFile, croot);
+    const clean = [...closure].every((file) => {
+      const module = analyze(file);
+      return file === composition.interlockingFile
+        ? !tampered(module, (assignment) => assignment === composition.injection.node)
+        : !tampered(module);
+    });
+    if (clean) proofs.push({
+      resolution: resolutionBinding.text,
+      execution: executionBinding.text,
+      direct: directAssertionFacts(ctx, resolutionSymbol, executionSymbol),
+    });
+  });
+  return proofs;
+}
+
 // Exported functions of the module by name: declarations and const-bound arrow/function expressions.
 function exportedFunctions(ctx) {
   const out = new Map();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@afokapu/atdd-bun",
-  "version": "0.10.98",
+  "version": "0.10.100",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/afokapu/atdd-bun.git"

package/src/hooks.ts

@@ -61,44 +61,49 @@ async function ratchetCommitGate(root: string, staged: string[], registryChanged
   try { candidateConfig = Bun.YAML.parse(stagedConfig.out) as Record<string, unknown>; policy = parseRatchetPolicy(candidateConfig); }
   catch (error) { return bad(`ratchet activation commit gate configuration is invalid: ${String(error)}`); }
   if (policy?.mode !== "reject-new" || !Array.isArray(candidateConfig.profiles) || !candidateConfig.profiles.every(profile => typeof profile === "string")) return null;
-  if ((await git(root, ["diff", "--quiet"])).code !== 0 || (await git(root, ["ls-files", "--others", "--exclude-standard"])).out) return bad("ratchet activation commit gate requires no unstaged or untracked candidate state");
   const head = await git(root, ["rev-parse", "--verify", "HEAD^{commit}"]);
   if (head.code || !/^[0-9a-f]{40}$/i.test(head.out)) return bad("ratchet activation commit gate requires an exact committed HEAD base");
-  const scratch = await mkdtemp(join(tmpdir(), "atdd-ratchet-commit-gate-"));
+  let scratch: string | undefined;
   try {
+    scratch = await mkdtemp(join(tmpdir(), "atdd-ratchet-commit-gate-"));
     const added = await git(root, ["worktree", "add", "--detach", "--no-checkout", scratch, head.out]);
-    if (added.code) return bad(`could not materialize ratchet activation base: ${added.err || added.out}`);
+    if (added.code) throw new Error(`could not materialize ratchet activation base: ${added.err || added.out}`);
     const checkedOut = await git(scratch, ["checkout", "--detach", head.out]);
-    if (checkedOut.code) return bad(`could not checkout ratchet activation base: ${checkedOut.err || checkedOut.out}`);
+    if (checkedOut.code) throw new Error(`could not checkout ratchet activation base: ${checkedOut.err || checkedOut.out}`);
     const baseConfig = await configAt(scratch), candidateProfiles = stable(candidateConfig.profiles.map(normalizeProfileName));
     const baseProfiles = stable(await enabledProfiles(scratch));
     const policyMatches = stable(policy.profiles.map(normalizeProfileName)).join(",") === candidateProfiles.join(",");
     const activation = isStrictProfileExpansion(baseProfiles, candidateProfiles) && activationContextDigest(baseConfig) === activationContextDigest(candidateConfig);
     const unchanged = baseProfiles.join(",") === candidateProfiles.join(",") && contextDigest(baseConfig, baseProfiles) === contextDigest(candidateConfig, candidateProfiles);
     if (candidateProfiles.some(profile => !concreteProfiles.includes(profile as typeof concreteProfiles[number])) || !policyMatches || (!activation && !unchanged)) return bad("ratchet reject-new requires either unchanged explicit profiles/context or an explicit monotonic profile expansion with identical non-profile context");
-    const selectedProfiles = activation || staged.some(needsFullCommitRatchetProfiles) ? candidateProfiles : (await affectedProfiles(root, staged, registryChanged)).filter(profile => candidateProfiles.includes(profile));
     const tree = await git(root, ["write-tree"]);
     if (tree.code || !/^[0-9a-f]{40}$/i.test(tree.out)) return bad(`could not identify staged ratchet activation candidate: ${tree.err || tree.out}`);
     const baseTree = await git(root, ["rev-parse", "--verify", `${head.out}^{tree}`]);
     if (baseTree.code || !/^[0-9a-f]{40}$/i.test(baseTree.out)) return bad(`could not identify ratchet activation base tree: ${baseTree.err || baseTree.out}`);
-    const normalize = (findings: Awaited<ReturnType<typeof enforce>>) => findings.map(finding => ({ ...finding, file: canonicalFindingPath(scratch, finding.file) }));
-    // Scan and cache the unpatched HEAD before materializing the staged candidate; both keys remain exact Git trees.
-    const cacheDirectory = await findingsCacheDirectory(root), toolkit = await toolkitIdentity().catch(() => null);
-    const findingsAt = async (treeId: string) => cachedFindings(cacheDirectory, treeId, toolkit, selectedProfiles, async () => normalize(await enforce({ root: scratch, profiles: selectedProfiles as any })));
-    const baseFindings = selectedProfiles.length ? await findingsAt(baseTree.out) : [];
-    const patch = await git(root, ["diff", "--cached", "--binary"], undefined, true);
-    if (patch.code) return bad(`could not read staged ratchet activation candidate: ${patch.err || patch.out}`);
-    const applied = await git(scratch, ["apply", "--whitespace=nowarn"], patch.out);
-    if (applied.code) return bad(`could not materialize staged ratchet activation candidate: ${applied.err || applied.out}`);
+    // Scan only exact Git trees in private scratch: live unstaged/untracked bytes never enter, and cache keys stay tree IDs.
+    const materialize = async (treeId: string, label: string) => {
+      const reset = await git(scratch!, ["read-tree", "--reset", "-u", treeId]);
+      if (reset.code) throw new Error(`could not materialize ${label}: ${reset.err || reset.out}`);
+      const exact = await git(scratch!, ["write-tree"]);
+      if (exact.code || exact.out !== treeId) throw new Error(`${label} did not materialize exactly: ${exact.err || exact.out}`);
+    };
+    await materialize(tree.out, "staged ratchet activation candidate");
     const materialized = await configAt(scratch), materializedProfiles = stable(await enabledProfiles(scratch));
     const materializedContext = activation ? activationContextDigest(materialized) === activationContextDigest(candidateConfig) : materializedProfiles.join(",") === candidateProfiles.join(",") && contextDigest(materialized, materializedProfiles) === contextDigest(candidateConfig, candidateProfiles);
     if (!materializedContext) return bad("staged ratchet candidate did not materialize exactly");
+    const selectedProfiles = activation || staged.some(needsFullCommitRatchetProfiles) ? candidateProfiles : (await affectedProfiles(scratch, staged, registryChanged)).filter(profile => candidateProfiles.includes(profile));
+    const normalize = (findings: Awaited<ReturnType<typeof enforce>>) => findings.map(finding => ({ ...finding, file: canonicalFindingPath(scratch!, finding.file) }));
+    const cacheDirectory = await findingsCacheDirectory(root), toolkit = await toolkitIdentity().catch(() => null);
+    const findingsAt = async (treeId: string) => cachedFindings(cacheDirectory, treeId, toolkit, selectedProfiles, async () => normalize(await enforce({ root: scratch, profiles: selectedProfiles as any })));
+    await materialize(baseTree.out, "ratchet activation base tree");
+    const baseFindings = selectedProfiles.length ? await findingsAt(baseTree.out) : [];
+    await materialize(tree.out, "staged ratchet activation candidate");
     const candidateFindings = selectedProfiles.length ? await findingsAt(tree.out) : [];
     const delta = compareFindings(baseFindings, candidateFindings);
     const report = JSON.stringify({ schema: "atdd-bun.ratchet-report/v1", mode: policy.mode, base: head.out, candidate: tree.out, profiles: selectedProfiles, context: contextDigest(candidateConfig, candidateProfiles), ...delta });
     return { ok: delta.new.length === 0, message: report };
   } catch (error) { return bad(`ratchet activation commit gate failed closed: ${String(error)}`); }
-  finally { await git(root, ["worktree", "remove", "--force", scratch]); await rm(scratch, { recursive: true, force: true }); }
+  finally { if (scratch) { await git(root, ["worktree", "remove", "--force", scratch]); await rm(scratch, { recursive: true, force: true }); } }
 }
 
 /** A pushed reject-new candidate is judged from its immutable object IDs, never the hook's checkout or index. */