@pixel-point/toolcraft 0.0.18 → 0.0.19

package/templates/starter/scripts/toolcraft-checkpoint-delivery-state.test.mjs

@@ -22,7 +22,6 @@ import {
   createToolcraftDeliveryReceipt,
 } from "./toolcraft-delivery-receipt.mjs";
 import {
-  createInventory,
   createFunctionalProofModelFixture,
   createPlanReceiptFixture,
 } from "./toolcraft-delivery-receipt-test-helpers.mjs";
@@ -43,32 +42,6 @@ function deepFreeze(value) {
   return value;
 }
 
-function createStateFixtures() {
-  const changedFixture = createPlanReceiptFixture("functional-changed");
-  const comparisonInventory =
-    changedFixture.plan.basis.comparisonInventory;
-  const initialFixture = createPlanReceiptFixture("functional-initial");
-  const previousPlan = deepFreeze({
-    ...initialFixture.plan,
-    sourceHash: comparisonInventory.sourceHash,
-  });
-  const previousReceipt = createToolcraftDeliveryReceipt({
-    functionalProofModel: initialFixture.functionalProofModel,
-    plan: previousPlan,
-    result: {
-      ...initialFixture.result,
-      finalInventory: comparisonInventory,
-    },
-  });
-  return {
-    changedFixture,
-    changedReceipt: createToolcraftDeliveryReceipt(changedFixture),
-    initialFixture,
-    initialReceipt: createToolcraftDeliveryReceipt(initialFixture),
-    previousReceipt,
-  };
-}
-
 async function executeInitialFixture(rootDir) {
   const finalInventory =
     await collectToolcraftVerificationInputs(rootDir);
@@ -76,6 +49,7 @@ async function executeInitialFixture(rootDir) {
     { kind: "docs" },
     { kind: "code-health" },
     {
+      acceptanceIds: null,
       files: ["src/app/schema.test.ts"],
       kind: "product-tests",
     },
@@ -117,7 +91,8 @@ async function executeInitialFixture(rootDir) {
 }
 
 test("genuinely absent previous receipt permits an initial basis", async () => {
-  const { initialFixture, initialReceipt } = createStateFixtures();
+  const initialFixture = createPlanReceiptFixture("functional-initial");
+  const initialReceipt = createToolcraftDeliveryReceipt(initialFixture);
   await assert.doesNotReject(assertDeliveryCheckpointState({
     deliveryReceipt: initialReceipt,
     finalInventory: initialFixture.result.finalInventory,
@@ -181,18 +156,16 @@ test("real initial functional delivery commits only without a predecessor", asyn
 });
 
 test("present malformed, unsupported, and legacy receipts fail closed", async () => {
-  const {
-    initialFixture,
-    initialReceipt,
-    previousReceipt,
-  } = createStateFixtures();
+  const initialFixture = createPlanReceiptFixture("functional-initial");
+  const initialReceipt = createToolcraftDeliveryReceipt(initialFixture);
+  const previousReceipt = initialReceipt;
   const legacyPlan = deepFreeze({
     ...previousReceipt.plan,
     kind: "legacy-delivery",
   });
   for (const [previousDeliveryReceipt, expected] of [
-    [{ version: 5 }, /unsupported version/iu],
     [{ version: 6 }, /unsupported version/iu],
+    [{ version: 7 }, /unsupported version/iu],
     [{ ...previousReceipt, plan: legacyPlan }, /delivery plan is malformed/iu],
   ]) {
     await assert.rejects(
@@ -210,70 +183,37 @@ test("present malformed, unsupported, and legacy receipts fail closed", async ()
   }
 });
 
-test("a valid current previous receipt requires an exact changed basis", async () => {
-  const {
-    changedFixture,
-    changedReceipt,
-    initialFixture,
-    initialReceipt,
-    previousReceipt,
-  } = createStateFixtures();
-  await assert.doesNotReject(assertDeliveryCheckpointState({
-    deliveryReceipt: changedReceipt,
-    finalInventory: changedFixture.result.finalInventory,
-    previousDeliveryReceipt: previousReceipt,
-  }));
-  await assert.rejects(
-    assertDeliveryCheckpointState({
-      deliveryReceipt: initialReceipt,
-      finalInventory: initialFixture.result.finalInventory,
-      previousDeliveryReceipt: previousReceipt,
-    }),
-    /initial delivery basis requires no previous/iu,
-  );
-
-  const mismatchedComparison = createInventory({
-    "src/app/app-schema.ts": hash("9"),
-  });
-  const mismatchedPlan = deepFreeze({
-    ...changedFixture.plan,
-    basis: {
-      ...changedFixture.plan.basis,
-      comparisonInventory: mismatchedComparison,
-    },
-  });
-  const mismatchedReceipt = createToolcraftDeliveryReceipt({
-    functionalProofModel: changedFixture.functionalProofModel,
-    plan: mismatchedPlan,
-    result: changedFixture.result,
-  });
-  await assert.rejects(
-    assertDeliveryCheckpointState({
-      deliveryReceipt: mismatchedReceipt,
-      finalInventory: changedFixture.result.finalInventory,
-      previousDeliveryReceipt: previousReceipt,
-    }),
-    /changed delivery basis must match/iu,
-  );
-
-  const wrongPreviousModelPlan = deepFreeze({
-    ...changedFixture.plan,
+test("targeted performance basis must match the initial proof identity", async () => {
+  const initialFixture = createPlanReceiptFixture("functional-initial");
+  const initialReceipt = createToolcraftDeliveryReceipt(initialFixture);
+  const targetedFixture = createPlanReceiptFixture("performance-iteration");
+  const targetedPlan = deepFreeze({
+    ...targetedFixture.plan,
     basis: {
-      ...changedFixture.plan.basis,
-      comparisonFunctionalProofModelHash: hash("f"),
+      ...targetedFixture.plan.basis,
+      initialFunctionalProofModelHash:
+        initialReceipt.functionalProofModelHash,
+      initialSourceHash: initialReceipt.sourceHash,
     },
   });
-  const wrongPreviousModelReceipt = createToolcraftDeliveryReceipt({
-    functionalProofModel: changedFixture.functionalProofModel,
-    plan: wrongPreviousModelPlan,
-    result: changedFixture.result,
+  const targetedReceipt = createToolcraftDeliveryReceipt({
+    ...targetedFixture,
+    plan: targetedPlan,
   });
+  await assert.doesNotReject(assertDeliveryCheckpointState({
+    deliveryReceipt: targetedReceipt,
+    finalInventory: targetedFixture.result.finalInventory,
+    previousDeliveryReceipt: initialReceipt,
+  }));
   await assert.rejects(
     assertDeliveryCheckpointState({
-      deliveryReceipt: wrongPreviousModelReceipt,
-      finalInventory: changedFixture.result.finalInventory,
-      previousDeliveryReceipt: previousReceipt,
+      deliveryReceipt: targetedReceipt,
+      finalInventory: targetedFixture.result.finalInventory,
+      previousDeliveryReceipt: {
+        ...initialReceipt,
+        sourceHash: hash("9"),
+      },
     }),
-    /previous functional proof model|immediately previous/iu,
+    /source|inventory|plan/iu,
   );
 });

package/templates/starter/scripts/toolcraft-checkpoint-transaction.mjs

@@ -6,6 +6,9 @@ import {
   writeToolcraftCheckpointBundle,
 } from "./toolcraft-checkpoint-bundle.mjs";
 import { assertDeliveryCheckpointState } from "./toolcraft-checkpoint-delivery-state.mjs";
+import {
+  getToolcraftDeliveryReceiptShapeError,
+} from "./toolcraft-delivery-receipt.mjs";
 import {
   finalizeToolcraftPlanExecutionAuthority,
   releaseToolcraftPlanExecutionAuthority,
@@ -44,6 +47,28 @@ function getExistingAuthority(loaded) {
   return loaded.bundle;
 }
 
+function createCheckpointCandidate(existing, receipt) {
+  const receiptError = getToolcraftDeliveryReceiptShapeError(receipt);
+  if (receiptError) throw new Error(receiptError);
+  if (receipt.plan.kind === "performance-iteration") {
+    if (!existing.delivery) {
+      throw new Error(
+        "Toolcraft targeted performance requires an initial delivery receipt.",
+      );
+    }
+    return createToolcraftCheckpointBundle({
+      currentPerformance: receipt,
+      delivery: existing.delivery,
+      performanceBaseline: existing.performanceBaseline,
+    });
+  }
+  return createToolcraftCheckpointBundle({
+    currentPerformance: existing.currentPerformance,
+    delivery: receipt,
+    performanceBaseline: existing.performanceBaseline,
+  });
+}
+
 export async function commitToolcraftDeliveryCheckpoint(options) {
   assertCommitOptions(options);
   const {
@@ -57,11 +82,7 @@ export async function commitToolcraftDeliveryCheckpoint(options) {
   const loaded = await readToolcraftCheckpointBundle(resolvedProjectDir);
   const existing = getExistingAuthority(loaded);
   const previousDeliveryReceipt = existing.delivery;
-  const candidate = createToolcraftCheckpointBundle({
-    currentPerformance: existing.currentPerformance,
-    delivery: deliveryReceipt,
-    performanceBaseline: existing.performanceBaseline,
-  });
+  const candidate = createCheckpointCandidate(existing, deliveryReceipt);
 
   let planExecutionReservation = reserveToolcraftPlanExecutionAuthority({
     authority: planExecutionAuthority,
@@ -71,9 +92,10 @@ export async function commitToolcraftDeliveryCheckpoint(options) {
   let durablyCommitted = false;
   try {
     await assertDeliveryCheckpointState({
-      deliveryReceipt: candidate.delivery,
+      deliveryReceipt,
       finalInventory,
       previousDeliveryReceipt,
+      previousPerformanceReceipt: existing.currentPerformance,
     });
     await writeToolcraftCheckpointBundle({
       bundle: candidate,

package/templates/starter/scripts/toolcraft-checkpoint-transaction.test.mjs

@@ -5,35 +5,17 @@ import test from "node:test";
 
 import { getToolcraftCheckpointBundlePath } from "./toolcraft-checkpoint-paths.mjs";
 import { commitToolcraftDeliveryCheckpoint } from "./toolcraft-checkpoint-transaction.mjs";
-import {
-  EMPTY_TOOLCRAFT_DELIVERY_LIFECYCLE_STATE,
-} from "./toolcraft-delivery-lifecycle-state.mjs";
 import { createToolcraftDeliveryReceipt } from "./toolcraft-delivery-receipt.mjs";
 import {
-  createFunctionalProofModelFixture,
+  createPlanReceiptFixture,
 } from "./toolcraft-delivery-receipt-test-helpers.mjs";
-import {
-  createToolcraftFunctionalProofModelHash,
-} from "./toolcraft-functional-proof-model.mjs";
 import {
   createCheckpointFixture,
 } from "./toolcraft-checkpoint-transaction-test-helpers.mjs";
-import {
-  collectToolcraftVerificationInputs,
-  createToolcraftVerificationSourceHash,
-} from "./toolcraft-verification-inventory.mjs";
 import {
   createReceiptFixture,
 } from "./toolcraft-verification-receipt-test-helpers.mjs";
 
-function deepFreeze(value) {
-  if (value && typeof value === "object" && !Object.isFrozen(value)) {
-    Object.values(value).forEach(deepFreeze);
-    Object.freeze(value);
-  }
-  return value;
-}
-
 test("commit module exports only the delivery-specific checkpoint writer", async () => {
   const transactionModule = await import("./toolcraft-checkpoint-transaction.mjs");
   assert.deepEqual(Object.keys(transactionModule), [
@@ -79,7 +61,7 @@ test("malformed delivery input cannot mutate checkpoint authority", async (t) =>
       deliveryReceipt: {},
       projectDir: rootDir,
     }),
-    /protected plan execution authority/iu,
+    /malformed|unsupported/iu,
   );
   await assert.rejects(
     commitToolcraftDeliveryCheckpoint({
@@ -102,10 +84,10 @@ test("unsupported delivery versions cannot cross execution authority", async (t)
 
   await assert.rejects(
     commitToolcraftDeliveryCheckpoint({
-      deliveryReceipt: { version: 5 },
+      deliveryReceipt: { version: 7 },
       projectDir: rootDir,
     }),
-    /protected plan execution authority/iu,
+    /malformed|unsupported/iu,
   );
   await assert.rejects(
     fs.access(getToolcraftCheckpointBundlePath(rootDir)),
@@ -113,53 +95,16 @@ test("unsupported delivery versions cannot cross execution authority", async (t)
   );
 });
 
-test("caller-authored current v7 receipt cannot be promoted without plan execution authority", async (t) => {
+test("caller-authored current v8 receipt cannot be promoted without plan execution authority", async (t) => {
   const rootDir = await createReceiptFixture();
   t.after(() => fs.rm(rootDir, { force: true, recursive: true }));
-  const finalInventory = await collectToolcraftVerificationInputs(rootDir);
-  const comparisonEntries = finalInventory.entries.map((entry, index) =>
-    index === 0 ? { ...entry, sha256: "0".repeat(64) } : entry
-  );
-  const comparisonInventory = {
-    entries: comparisonEntries,
-    sourceHash: createToolcraftVerificationSourceHash(comparisonEntries),
-  };
-  const previousFunctionalProofModel = createFunctionalProofModelFixture({
-    contractHash: "b".repeat(64),
-  });
-  const functionalProofModel = createFunctionalProofModelFixture({
-    contractHash: "c".repeat(64),
-  });
-  const plan = deepFreeze({
-    basis: {
-      changedFiles: [comparisonEntries[0].path],
-      comparisonFunctionalProofModelHash:
-        createToolcraftFunctionalProofModelHash(
-          previousFunctionalProofModel,
-        ),
-      comparisonInventory,
-      kind: "changed",
-    },
-    functionalProofModelHash:
-      createToolcraftFunctionalProofModelHash(functionalProofModel),
-    kind: "functional",
-    lifecycle: EMPTY_TOOLCRAFT_DELIVERY_LIFECYCLE_STATE,
-    manifestHash: "a".repeat(64),
-    sourceHash: finalInventory.sourceHash,
-    steps: [{ kind: "docs" }],
-  });
-  const receipt = createToolcraftDeliveryReceipt({
-    functionalProofModel,
-    plan,
-    result: {
-      evidence: [{ kind: "docs" }],
-      finalInventory,
-    },
-  });
+  const fixture = createPlanReceiptFixture("functional-initial");
+  const receipt = createToolcraftDeliveryReceipt(fixture);
 
   await assert.rejects(
     commitToolcraftDeliveryCheckpoint({
       deliveryReceipt: receipt,
+      finalInventory: fixture.result.finalInventory,
       projectDir: rootDir,
     }),
     /protected plan execution authority/iu,

package/templates/starter/scripts/toolcraft-delivery-anchor.mjs

@@ -9,9 +9,6 @@ import {
 import {
   createToolcraftTargetedPerformanceComparisonHash,
 } from "./toolcraft-targeted-performance-report.mjs";
-import {
-  collectToolcraftVerificationInputs,
-} from "./toolcraft-verification-inventory.mjs";
 
 function createPerformanceAnchor(receipt) {
   const evidence = receipt.evidence.find(
@@ -49,6 +46,32 @@ export function normalizeToolcraftDeliveryAnchor(receipt) {
   });
 }
 
+function createBundleAnchor(bundle) {
+  const initial = normalizeToolcraftDeliveryAnchor(bundle.delivery);
+  if (bundle.currentPerformance === null) return initial;
+  const error = getToolcraftDeliveryReceiptShapeError(
+    bundle.currentPerformance,
+  );
+  if (error) throw new Error(error);
+  if (
+    bundle.currentPerformance.kind !==
+      "targeted-performance-verification" ||
+    bundle.currentPerformance.plan.kind !== "performance-iteration"
+  ) {
+    throw new Error(
+      "Toolcraft current performance checkpoint must be a targeted performance receipt.",
+    );
+  }
+  return createToolcraftDeliveryAnchorState({
+    files: initial.files,
+    functionalProofModel: initial.functionalProofModel,
+    functionalProofModelHash: initial.functionalProofModelHash,
+    lifecycle: bundle.currentPerformance.plan.lifecycle,
+    performance: createPerformanceAnchor(bundle.currentPerformance),
+    sourceHash: initial.sourceHash,
+  });
+}
+
 export function getToolcraftDeliveryAnchorShapeError(receipt) {
   try {
     normalizeToolcraftDeliveryAnchor(receipt);
@@ -63,7 +86,7 @@ export async function readToolcraftDeliveryAnchor(rootDir) {
   if (loaded.missing || loaded.error) return loaded;
   try {
     return {
-      anchor: normalizeToolcraftDeliveryAnchor(loaded.bundle.delivery),
+      anchor: createBundleAnchor(loaded.bundle),
       receipt: loaded.bundle.delivery,
     };
   } catch (error) {
@@ -77,8 +100,5 @@ export async function validateToolcraftDeliveryAnchor({ rootDir }) {
   const loaded = await readToolcraftDeliveryAnchor(rootDir);
   if (loaded.missing) return ["Toolcraft delivery receipt is missing."];
   if (loaded.error) return [loaded.error];
-  const inventory = await collectToolcraftVerificationInputs(rootDir);
-  return loaded.anchor.sourceHash === inventory.sourceHash
-    ? []
-    : ["Toolcraft delivery receipt is stale for the current source."];
+  return [];
 }

package/templates/starter/scripts/toolcraft-delivery-anchor.test.mjs

@@ -2,6 +2,10 @@ import assert from "node:assert/strict";
 import fs from "node:fs/promises";
 import test from "node:test";
 
+import {
+  createToolcraftCheckpointBundle,
+  writeToolcraftCheckpointBundle,
+} from "./toolcraft-checkpoint-bundle.mjs";
 import {
   getToolcraftDeliveryAnchorShapeError,
   normalizeToolcraftDeliveryAnchor,
@@ -9,7 +13,6 @@ import {
 } from "./toolcraft-delivery-anchor.mjs";
 import {
   createPlanReceiptFixture,
-  writeDeliveryReceiptFixture,
 } from "./toolcraft-delivery-receipt-test-helpers.mjs";
 import {
   createToolcraftDeliveryReceipt,
@@ -21,74 +24,41 @@ import {
   createReceiptFixture,
 } from "./toolcraft-verification-receipt-test-helpers.mjs";
 
-const forbiddenAnchorKeys = [
-  "baselineEvidenceHash",
-  "baselineSourceHash",
-  "mode",
-  "version",
-];
-
-function assertClosedAnchor(anchor) {
-  assert.equal(Object.isFrozen(anchor), true);
-  for (const key of forbiddenAnchorKeys) {
-    assert.equal(Object.hasOwn(anchor, key), false);
-  }
-  assert.deepEqual(Object.keys(anchor).sort(), [
-    "files",
-    "functionalProofModel",
-    "functionalProofModelHash",
-    "lifecycle",
-    "performance",
-    "sourceHash",
-  ]);
-}
-
-test("normalizes current receipt inventory and lifecycle", () => {
+test("initial receipt is the durable product proof anchor", () => {
   const receipt = createToolcraftDeliveryReceipt(
-    createPlanReceiptFixture("functional-changed"),
+    createPlanReceiptFixture("functional-initial"),
   );
-
   const anchor = normalizeToolcraftDeliveryAnchor(receipt);
 
-  assertClosedAnchor(anchor);
+  assert.equal(Object.isFrozen(anchor), true);
   assert.deepEqual(anchor.files, receipt.files);
   assert.equal(anchor.functionalProofModel, receipt.functionalProofModel);
-  assert.equal(
-    anchor.functionalProofModelHash,
-    receipt.functionalProofModelHash,
-  );
   assert.deepEqual(anchor.lifecycle, receipt.plan.lifecycle);
   assert.deepEqual(anchor.performance, { kind: "none" });
   assert.equal(anchor.sourceHash, receipt.sourceHash);
 });
 
-test("derives a current performance comparison hash from the report alone", () => {
+test("targeted performance receipt carries exact comparison evidence", () => {
   const receipt = createToolcraftDeliveryReceipt(
     createPlanReceiptFixture("performance-iteration"),
   );
-  const performanceEvidence = receipt.evidence.find(
+  const evidence = receipt.evidence.find(
     ({ kind }) => kind === "browser-performance",
   );
-
   const anchor = normalizeToolcraftDeliveryAnchor(receipt);
 
-  assertClosedAnchor(anchor);
   assert.deepEqual(anchor.performance, {
-    kind: "performance-iteration-report",
-    report: performanceEvidence.report,
     comparisonHash: createToolcraftTargetedPerformanceComparisonHash(
-      performanceEvidence.report,
+      evidence.report,
     ),
+    kind: "performance-iteration-report",
+    report: evidence.report,
     requestAuthorityHash: receipt.plan.requestAuthorityHash,
   });
-  assert.notEqual(
-    anchor.performance.comparisonHash,
-    performanceEvidence.evidenceHash,
-  );
 });
 
-test("rejects obsolete delivery receipt versions 2 through 6", () => {
-  for (const version of [2, 3, 4, 5, 6]) {
+test("rejects obsolete delivery receipt and plan versions", () => {
+  for (const version of [2, 3, 4, 5, 6, 7]) {
     assert.throws(
       () => normalizeToolcraftDeliveryAnchor({ version }),
       /unsupported version/iu,
@@ -98,34 +68,53 @@ test("rejects obsolete delivery receipt versions 2 through 6", () => {
       /unsupported version/iu,
     );
   }
-});
-
-test("rejects a current receipt with an obsolete plan version", () => {
   const receipt = createToolcraftDeliveryReceipt(
-    createPlanReceiptFixture("functional-changed"),
+    createPlanReceiptFixture("functional-initial"),
   );
-
   assert.throws(
-    () =>
-      normalizeToolcraftDeliveryAnchor({
-        ...receipt,
-        planVersion: 2,
-      }),
+    () => normalizeToolcraftDeliveryAnchor({ ...receipt, planVersion: 5 }),
     /unsupported|malformed/iu,
   );
 });
 
-test("reads a current receipt through the canonical checkpoint bundle", async (t) => {
+test("bundle anchor preserves initial proof and overlays targeted lifecycle", async (t) => {
   const rootDir = await createReceiptFixture();
   t.after(() => fs.rm(rootDir, { force: true, recursive: true }));
-  const receipt = createToolcraftDeliveryReceipt(
+  const initial = createToolcraftDeliveryReceipt(
+    createPlanReceiptFixture("functional-initial"),
+  );
+  const targeted = createToolcraftDeliveryReceipt(
     createPlanReceiptFixture("performance-iteration"),
   );
-  await writeDeliveryReceiptFixture(rootDir, receipt);
+  await writeToolcraftCheckpointBundle({
+    bundle: createToolcraftCheckpointBundle({
+      currentPerformance: targeted,
+      delivery: initial,
+    }),
+    rootDir,
+  });
 
-  const anchor = normalizeToolcraftDeliveryAnchor(receipt);
-  assert.deepEqual(await readToolcraftDeliveryAnchor(rootDir), {
-    anchor,
-    receipt,
+  const loaded = await readToolcraftDeliveryAnchor(rootDir);
+  assert.deepEqual(loaded.receipt, initial);
+  assert.equal(loaded.anchor.sourceHash, initial.sourceHash);
+  assert.deepEqual(loaded.anchor.lifecycle, targeted.plan.lifecycle);
+  assert.equal(loaded.anchor.performance.kind, "performance-iteration-report");
+});
+
+test("bundle anchor fails closed on malformed current performance state", async (t) => {
+  const rootDir = await createReceiptFixture();
+  t.after(() => fs.rm(rootDir, { force: true, recursive: true }));
+  const initial = createToolcraftDeliveryReceipt(
+    createPlanReceiptFixture("functional-initial"),
+  );
+  await writeToolcraftCheckpointBundle({
+    bundle: createToolcraftCheckpointBundle({
+      currentPerformance: { kind: "candidate" },
+      delivery: initial,
+    }),
+    rootDir,
   });
+
+  const loaded = await readToolcraftDeliveryAnchor(rootDir);
+  assert.match(loaded.error, /malformed|unsupported/iu);
 });

package/templates/starter/scripts/toolcraft-delivery-architecture-inventory.mjs

@@ -10,7 +10,6 @@ export const canonicalDeliveryModules = freeze([
   "toolcraft-delivery-anchor.mjs",
   "toolcraft-plan-execution-authority.mjs",
   "toolcraft-proof-process.mjs",
-  "toolcraft-verification-impact.mjs",
 ]);
 
 export const obsoleteDeliveryBasenames = freeze([
@@ -80,7 +79,4 @@ export const deliveryBehaviorModules = freeze([
   "toolcraft-typescript-analysis.mjs",
   "toolcraft-typescript-callables.mjs",
   "toolcraft-typescript-module-shape.mjs",
-  "toolcraft-verification-impact.mjs",
-  "toolcraft-verification-impact-inventory.mjs",
-  "toolcraft-verification-input-roles.mjs",
 ]);

package/templates/starter/scripts/toolcraft-delivery-architecture-policy.mjs

@@ -54,7 +54,6 @@ const defaultDirectionRules = Object.freeze([
       "toolcraft-delivery-anchor.mjs",
       "toolcraft-delivery-lifecycle.mjs",
       "toolcraft-delivery-receipt.mjs",
-      "toolcraft-verification-impact.mjs",
     ],
     from: "toolcraft-delivery-executor.mjs",
   },

package/templates/starter/scripts/toolcraft-delivery-evidence.test.mjs

@@ -81,8 +81,7 @@ function createDependencyFixture() {
   };
 }
 
-for (const fixture of ["functional-initial", "functional-changed",
-  "performance-iteration"]) {
+for (const fixture of ["functional-initial", "performance-iteration"]) {
   test(`accepts exact ${fixture} execution evidence`, () => {
     const { plan, result } = createPlanReceiptFixture(fixture);
     assert.equal(
@@ -242,7 +241,7 @@ test("rejects unknown browser step evidence", () => {
 });
 
 test("rejects source and final inventory mismatch deterministically", () => {
-  const { plan, result } = createPlanReceiptFixture("functional-changed");
+  const { plan, result } = createPlanReceiptFixture("functional-initial");
   assert.equal(
     getToolcraftExecutionEvidenceError({
       evidence: result.evidence,

package/templates/starter/scripts/toolcraft-delivery-executor.mjs

@@ -30,6 +30,7 @@ import {
 } from "./toolcraft-verification-inventory.mjs";
 import {
   getToolcraftProductTestProcessArgs,
+  getToolcraftProductTestProcessEnvironment,
 } from "./toolcraft-vitest-runtime-contract.mjs";
 import {
   runToolcraftProtectedBrowserBuild,
@@ -271,7 +272,10 @@ function createToolcraftProofOperations() {
       runToolcraftProofProcess(
         getToolcraftBinaryPath(projectDir, "vitest"),
         getToolcraftProductTestProcessArgs(step.files),
-        { cwd: projectDir },
+        {
+          cwd: projectDir,
+          env: getToolcraftProductTestProcessEnvironment(step.acceptanceIds),
+        },
       ),
   });
 }