@pixel-point/toolcraft 0.0.18 → 0.0.19

package/templates/starter/scripts/run-delivery-verification.test.mjs

@@ -3,6 +3,7 @@ import test from "node:test";
 
 import { runToolcraftDeliveryVerification } from "./run-delivery-verification.mjs";
 import {
+  TOOLCRAFT_INITIAL_PROOF_ALREADY_COMPLETE,
   executeToolcraftDeliveryLifecycleCore,
 } from "./toolcraft-delivery-lifecycle.mjs";
 import {
@@ -12,35 +13,31 @@ import {
   removeDeliveryFixture,
 } from "./run-delivery-verification-test-helpers.mjs";
 
-test("no-delta delivery returns the exact previous receipt before expensive work", async () => {
-  const previousReceipt = Object.freeze({ kind: "previous-receipt" });
-  const currentInventory = Object.freeze({
-    entries: Object.freeze([]),
-    sourceHash: "a".repeat(64),
-  });
+test("proven product returns before all delivery proof work", async () => {
   const calls = {
     anchorReads: 0,
-    commit: 0,
-    functionalContexts: 0,
-    integrity: 0,
-    inventories: 0,
-    planner: 0,
-    proofExecutions: 0,
+    performanceAuthorityReads: 0,
   };
   const dependencies = Object.freeze({
     collectInventory: async () => {
-      calls.inventories += 1;
-      return currentInventory;
+      throw new Error("inventory must not be collected");
     },
     collectFunctionalContext: async () => {
-      calls.functionalContexts += 1;
       throw new Error("functional context must not be collected");
     },
-    commit: async () => { calls.commit += 1; },
-    createPlan: () => { calls.planner += 1; },
+    commit: async () => {
+      throw new Error("checkpoint must not be committed");
+    },
+    createPlan: () => {
+      throw new Error("plan must not be created");
+    },
     createReceipt: () => { throw new Error("receipt must not be created"); },
-    evaluateIntegrity: async () => { calls.integrity += 1; },
-    executePlan: async () => { calls.proofExecutions += 1; },
+    evaluateIntegrity: async () => {
+      throw new Error("integrity must not be evaluated");
+    },
+    executePlan: async () => {
+      throw new Error("proof must not execute");
+    },
     formatEscalationRecommendation: () => "",
     getEscalationRecommendation: () => null,
     loadPlanningInputs: async () => {
@@ -49,29 +46,136 @@ test("no-delta delivery returns the exact previous receipt before expensive work
     readDeliveryAnchor: async () => {
       calls.anchorReads += 1;
       return {
-        anchor: { sourceHash: currentInventory.sourceHash },
-        receipt: previousReceipt,
+        anchor: Object.freeze({ sourceHash: "a".repeat(64) }),
+        receipt: Object.freeze({ kind: "initial-delivery-receipt" }),
       };
     },
+    readPerformanceAuthority: async () => {
+      calls.performanceAuthorityReads += 1;
+      return null;
+    },
   });
 
-  const receipt = await executeToolcraftDeliveryLifecycleCore({
-    dependencies,
-    projectDir: "/tmp/toolcraft-no-delta",
+  const result = await executeToolcraftDeliveryLifecycleCore({
+    dependencies, projectDir: "/tmp/toolcraft-proven-product",
   });
 
-  assert.equal(receipt, previousReceipt);
+  assert.equal(result, TOOLCRAFT_INITIAL_PROOF_ALREADY_COMPLETE);
+  assert.equal(Object.isFrozen(result), true);
   assert.deepEqual(calls, {
     anchorReads: 1,
-    commit: 0,
-    functionalContexts: 0,
-    integrity: 0,
-    inventories: 1,
-    planner: 0,
-    proofExecutions: 0,
+    performanceAuthorityReads: 1,
   });
 });
 
+test("consumed performance authority returns before all delivery proof work", async () => {
+  const authority = Object.freeze({ hash: "b".repeat(64) });
+  const dependencies = Object.freeze({
+    collectInventory: async () => {
+      throw new Error("inventory must not be collected");
+    },
+    readDeliveryAnchor: async () => ({
+      anchor: Object.freeze({
+        lifecycle: Object.freeze({
+          consumedPerformanceRequestAuthorityHashes: Object.freeze([
+            authority.hash,
+          ]),
+          performanceEscalationOffered: false,
+        }),
+      }),
+      receipt: Object.freeze({ kind: "initial-delivery-receipt" }),
+    }),
+    readPerformanceAuthority: async () => authority,
+  });
+
+  const result = await executeToolcraftDeliveryLifecycleCore({
+    dependencies,
+    projectDir: "/tmp/toolcraft-consumed-performance-authority",
+  });
+
+  assert.equal(result, TOOLCRAFT_INITIAL_PROOF_ALREADY_COMPLETE);
+});
+
+test("missing initial proof still executes the complete delivery lifecycle", async () => {
+  const calls = [];
+  const receipt = Object.freeze({ kind: "initial-delivery-receipt" });
+  const functionalContext = Object.freeze({
+    currentFunctionalProofModel: Object.freeze({ kind: "model" }),
+  });
+  const dependencies = Object.freeze({
+    collectInventory: async () => {
+      calls.push("inventory");
+      return Object.freeze({ entries: Object.freeze([]), sourceHash: "a".repeat(64) });
+    },
+    collectFunctionalContext: async () => {
+      calls.push("functional-context");
+      return functionalContext;
+    },
+    commit: async () => { calls.push("commit"); },
+    createPlan: () => {
+      calls.push("plan");
+      return Object.freeze({ kind: "functional" });
+    },
+    createReceipt: () => {
+      calls.push("receipt");
+      return receipt;
+    },
+    evaluateIntegrity: async () => {
+      calls.push("integrity");
+      return Object.freeze({ manifestHash: "b".repeat(64) });
+    },
+    executePlan: async () => {
+      calls.push("execute");
+      return Object.freeze({ finalInventory: Object.freeze({}) });
+    },
+    formatEscalationRecommendation: () => "",
+    getEscalationRecommendation: () => null,
+    loadPlanningInputs: async ({ authority }) => {
+      calls.push("planning-inputs");
+      assert.equal(authority, null);
+      return Object.freeze({ kind: "inputs" });
+    },
+    readDeliveryAnchor: async () => {
+      calls.push("anchor");
+      return Object.freeze({ missing: true });
+    },
+    readPerformanceAuthority: async () => {
+      calls.push("performance-authority");
+      return null;
+    },
+  });
+
+  const result = await executeToolcraftDeliveryLifecycleCore({
+    dependencies, projectDir: "/tmp/toolcraft-unproven-product",
+  });
+
+  assert.equal(result, receipt);
+  assert.deepEqual(calls, [
+    "anchor",
+    "performance-authority",
+    "inventory",
+    "integrity",
+    "functional-context",
+    "planning-inputs",
+    "plan",
+    "execute",
+    "receipt",
+    "commit",
+  ]);
+});
+
+test("malformed initial proof fails closed before phase resolution", async () => {
+  await assert.rejects(
+    executeToolcraftDeliveryLifecycleCore({
+      dependencies: Object.freeze({
+        readDeliveryAnchor: async () => ({ error: "malformed checkpoint" }),
+      }),
+      projectDir: "/tmp/toolcraft-malformed-product",
+    }),
+    /malformed checkpoint/u,
+  );
+});
+
 test("public delivery accepts only an optional package-manager separator", async (t) => {
   for (const arguments_ of [
     ["--reason=performance-iteration"],

package/templates/starter/scripts/run-feature-verification.mjs

@@ -0,0 +1,212 @@
+#!/usr/bin/env node
+
+import { realpath } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+import {
+  collectToolcraftPlaywrightTestTitles,
+  getToolcraftPlaywrightExactGrepPattern,
+  resolveToolcraftPlaywrightTestTitles,
+} from "./playwright-test-title-selection.mjs";
+import {
+  captureToolcraftProofProcess,
+  ensureToolcraftChromium,
+  getToolcraftBinaryPath,
+  runToolcraftProofProcess,
+} from "./toolcraft-proof-process.mjs";
+import { parseToolcraftFeatureVerificationPlanOutput } from "./toolcraft-feature-verification-plan.mjs";
+
+const modulePath = fileURLToPath(import.meta.url);
+const defaultProjectDir = path.resolve(path.dirname(modulePath), "..");
+
+const proofAuthorityEnvironmentNames = Object.freeze([
+  "TOOLCRAFT_BROWSER_EXECUTION_LEDGER_DIRECTORY",
+  "TOOLCRAFT_BROWSER_EXECUTION_LEDGER_NONCE",
+  "TOOLCRAFT_KERNEL_BENCHMARK_REPORT_NONCE",
+  "TOOLCRAFT_KERNEL_BENCHMARK_REPORT_PATH",
+  "TOOLCRAFT_PERFORMANCE_FIXTURE_RESOLUTION_MODE",
+  "TOOLCRAFT_PERFORMANCE_FIXTURE_SELECTOR",
+  "TOOLCRAFT_PERFORMANCE_REPORT_NONCE",
+  "TOOLCRAFT_PERFORMANCE_REPORT_PATH",
+  "TOOLCRAFT_PERFORMANCE_REPORT_SOURCE_HASH",
+  "TOOLCRAFT_PERFORMANCE_REQUEST_AUTHORITY_HASH",
+  "TOOLCRAFT_TARGETED_PERFORMANCE_PASS_IDS",
+  "TOOLCRAFT_TARGETED_PERFORMANCE_PATH_IDS",
+  "TOOLCRAFT_TARGETED_PERFORMANCE_REPORT_NONCE",
+  "TOOLCRAFT_TARGETED_PERFORMANCE_REPORT_PATH",
+  "TOOLCRAFT_TARGETED_PERFORMANCE_REPORT_SOURCE_HASH",
+]);
+
+const compareCodeUnits = (left, right) =>
+  left < right ? -1 : left > right ? 1 : 0;
+
+function getFeatureVerificationEnvironment(env) {
+  const sanitized = { ...env };
+  delete sanitized.TOOLCRAFT_FEATURE_VERIFICATION_REQUEST;
+  for (const name of proofAuthorityEnvironmentNames) delete sanitized[name];
+  return sanitized;
+}
+
+export function parseToolcraftFeatureVerificationArguments(arguments_) {
+  if (!Array.isArray(arguments_)) {
+    throw new Error(
+      "Toolcraft feature verification requires one or more acceptance ids or --all.",
+    );
+  }
+  const normalizedArguments =
+    arguments_[0] === "--" ? arguments_.slice(1) : arguments_;
+  if (normalizedArguments.length === 0) {
+    throw new Error(
+      "Toolcraft feature verification requires one or more acceptance ids or --all.",
+    );
+  }
+  if (
+    normalizedArguments.length === 1 &&
+    normalizedArguments[0] === "--all"
+  ) {
+    return Object.freeze({ mode: "all", version: 1 });
+  }
+  if (
+    normalizedArguments.some(
+      (argument) =>
+        typeof argument !== "string" ||
+        argument.length === 0 ||
+        argument.trim() !== argument ||
+        argument.startsWith("--"),
+    )
+  ) {
+    throw new Error(
+      "Toolcraft feature verification accepts only trimmed acceptance ids or the sole --all flag.",
+    );
+  }
+  if (new Set(normalizedArguments).size !== normalizedArguments.length) {
+    throw new Error(
+      "Toolcraft feature verification acceptance ids must be unique.",
+    );
+  }
+  return Object.freeze({
+    acceptanceIds: Object.freeze(
+      [...normalizedArguments].sort(compareCodeUnits),
+    ),
+    mode: "ids",
+    version: 1,
+  });
+}
+
+function createDefaultDependencies() {
+  return Object.freeze({
+    captureProcess: captureToolcraftProofProcess,
+    async ensureChromium({ projectDir }) {
+      await ensureToolcraftChromium({
+        playwright: await import("@playwright/test"),
+        projectDir,
+      });
+    },
+    getBinaryPath: getToolcraftBinaryPath,
+    runProcess: runToolcraftProofProcess,
+    writeOutput: (source) => process.stdout.write(source),
+  });
+}
+
+function parsePlaywrightListOutput(output) {
+  let report;
+  try {
+    report = JSON.parse(output);
+  } catch (error) {
+    throw new Error("Playwright test listing must emit valid JSON.", {
+      cause: error,
+    });
+  }
+  return collectToolcraftPlaywrightTestTitles(report);
+}
+
+export async function runToolcraftFeatureVerificationCore({
+  dependencies = createDefaultDependencies(),
+  env = process.env,
+  projectDir = defaultProjectDir,
+  request,
+}) {
+  const resolvedProjectDir = path.resolve(projectDir);
+  const playwrightBin = dependencies.getBinaryPath(
+    resolvedProjectDir,
+    "playwright",
+  );
+  const sanitizedEnv = getFeatureVerificationEnvironment(env);
+  const requestSource = JSON.stringify(request);
+  const [planOutput, listOutput] = await Promise.all([
+    dependencies.captureProcess(
+      playwrightBin,
+      [
+        "test",
+        "--list",
+        "--reporter=./e2e/toolcraft-feature-verification-reporter.ts",
+      ],
+      {
+        cwd: resolvedProjectDir,
+        env: {
+          ...sanitizedEnv,
+          TOOLCRAFT_FEATURE_VERIFICATION_REQUEST: requestSource,
+        },
+      },
+    ),
+    dependencies.captureProcess(
+      playwrightBin,
+      ["test", "--list", "--reporter=json"],
+      { cwd: resolvedProjectDir, env: sanitizedEnv },
+    ),
+  ]);
+  const featurePlan = parseToolcraftFeatureVerificationPlanOutput(planOutput);
+  const selections = resolveToolcraftPlaywrightTestTitles(
+    parsePlaywrightListOutput(listOutput),
+    featurePlan.testNames,
+  );
+
+  dependencies.writeOutput(
+    `[toolcraft] Focused feature verification: ${featurePlan.acceptanceIds.join(", ")}\n`,
+  );
+  dependencies.writeOutput(
+    `[toolcraft] Browser scenarios: ${featurePlan.testNames.join(" | ")}\n`,
+  );
+  await dependencies.ensureChromium({ projectDir: resolvedProjectDir });
+  await dependencies.runProcess(
+    playwrightBin,
+    [
+      "test",
+      "--grep",
+      getToolcraftPlaywrightExactGrepPattern(selections),
+      "--workers=1",
+    ],
+    {
+      cwd: resolvedProjectDir,
+      env: {
+        ...sanitizedEnv,
+        TOOLCRAFT_BROWSER_SERVER_MODE: "dev",
+      },
+    },
+  );
+  return featurePlan;
+}
+
+export async function runToolcraftFeatureVerification({
+  arguments_ = process.argv.slice(2),
+  env = process.env,
+  projectDir = defaultProjectDir,
+} = {}) {
+  return runToolcraftFeatureVerificationCore({
+    env,
+    projectDir,
+    request: parseToolcraftFeatureVerificationArguments(arguments_),
+  });
+}
+
+async function isDirectExecution() {
+  if (!process.argv[1]) return false;
+  try {
+    return (await realpath(process.argv[1])) === (await realpath(modulePath));
+  } catch {
+    return path.resolve(process.argv[1]) === modulePath;
+  }
+}
+
+if (await isDirectExecution()) await runToolcraftFeatureVerification();

package/templates/starter/scripts/run-feature-verification.test.mjs

@@ -0,0 +1,226 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import {
+  parseToolcraftFeatureVerificationArguments,
+  runToolcraftFeatureVerificationCore,
+} from "./run-feature-verification.mjs";
+
+const plan = Object.freeze({
+  acceptanceIds: Object.freeze(["material.layer"]),
+  testNames: Object.freeze(["browser: material.layer"]),
+  version: 1,
+});
+
+const listReport = JSON.stringify({
+  errors: [],
+  suites: [
+    {
+      specs: [
+        {
+          tags: [],
+          tests: [{ projectName: "" }],
+          title: "browser: material.layer",
+        },
+      ],
+      suites: [],
+      title: "",
+    },
+  ],
+});
+
+function createDependencies(overrides = {}) {
+  const calls = {
+    capture: [],
+    chromium: [],
+    output: [],
+    run: [],
+  };
+  let captureIndex = 0;
+  const dependencies = {
+    captureProcess: async (command, arguments_, options) => {
+      calls.capture.push({ arguments_, command, options });
+      captureIndex += 1;
+      return captureIndex === 1 ? `${JSON.stringify(plan)}\n` : listReport;
+    },
+    ensureChromium: async (input) => {
+      calls.chromium.push(input);
+    },
+    getBinaryPath: (projectDir, binary) => `${projectDir}/node_modules/.bin/${binary}`,
+    runProcess: async (command, arguments_, options) => {
+      calls.run.push({ arguments_, command, options });
+    },
+    writeOutput: (source) => calls.output.push(source),
+    ...overrides,
+  };
+  return { calls, dependencies };
+}
+
+test("parses explicit ids and all mode while rejecting ambiguous CLI input", () => {
+  assert.deepEqual(
+    parseToolcraftFeatureVerificationArguments(["material.layer", "lighting.intensity"]),
+    {
+      acceptanceIds: ["lighting.intensity", "material.layer"],
+      mode: "ids",
+      version: 1,
+    },
+  );
+  assert.deepEqual(
+    parseToolcraftFeatureVerificationArguments(["--", "material.layer"]),
+    { acceptanceIds: ["material.layer"], mode: "ids", version: 1 },
+  );
+  assert.deepEqual(parseToolcraftFeatureVerificationArguments(["--all"]), {
+    mode: "all",
+    version: 1,
+  });
+  assert.deepEqual(parseToolcraftFeatureVerificationArguments(["--", "--all"]), {
+    mode: "all",
+    version: 1,
+  });
+
+  for (const arguments_ of [
+    [],
+    ["--"],
+    ["--unknown"],
+    ["--", "--unknown"],
+    ["material.layer", "material.layer"],
+    ["--all", "material.layer"],
+    ["--", "--all", "material.layer"],
+    [" material.layer"],
+  ]) {
+    assert.throws(
+      () => parseToolcraftFeatureVerificationArguments(arguments_),
+      /feature verification/iu,
+    );
+  }
+});
+
+test("collects the semantic plan and title catalog concurrently", async () => {
+  let captureCount = 0;
+  let releaseFirst;
+  const firstCapture = new Promise((resolve) => {
+    releaseFirst = resolve;
+  });
+  const { calls, dependencies } = createDependencies({
+    captureProcess: async (command, arguments_, options) => {
+      calls.capture.push({ arguments_, command, options });
+      captureCount += 1;
+      if (captureCount === 1) return firstCapture;
+      releaseFirst(`${JSON.stringify(plan)}\n`);
+      return listReport;
+    },
+  });
+
+  await runToolcraftFeatureVerificationCore({
+    dependencies,
+    projectDir: "/app",
+    request: parseToolcraftFeatureVerificationArguments(["material.layer"]),
+  });
+
+  assert.equal(captureCount, 2);
+  assert.match(
+    calls.capture[0].options.env.TOOLCRAFT_FEATURE_VERIFICATION_REQUEST,
+    /material\.layer/iu,
+  );
+  assert.equal(
+    calls.capture[1].options.env.TOOLCRAFT_FEATURE_VERIFICATION_REQUEST,
+    undefined,
+  );
+});
+
+test("fails invalid collection before Chromium or browser execution", async () => {
+  for (const outputs of [
+    ["not-json\n", listReport],
+    [
+      `${JSON.stringify(plan)}\n`,
+      JSON.stringify({
+        errors: [],
+        suites: [
+          {
+            specs: [
+              {
+                tags: [],
+                tests: [{ projectName: "first" }, { projectName: "second" }],
+                title: "browser: material.layer",
+              },
+            ],
+            suites: [],
+            title: "",
+          },
+        ],
+      }),
+    ],
+  ]) {
+    let index = 0;
+    const { calls, dependencies } = createDependencies({
+      captureProcess: async () => outputs[index++],
+    });
+    await assert.rejects(
+      runToolcraftFeatureVerificationCore({
+        dependencies,
+        projectDir: "/app",
+        request: parseToolcraftFeatureVerificationArguments(["material.layer"]),
+      }),
+    );
+    assert.equal(calls.chromium.length, 0);
+    assert.equal(calls.run.length, 0);
+  }
+});
+
+test("runs only exact selected Playwright titles with one worker", async () => {
+  const { calls, dependencies } = createDependencies();
+  const result = await runToolcraftFeatureVerificationCore({
+    dependencies,
+    projectDir: "/app",
+    request: parseToolcraftFeatureVerificationArguments(["material.layer"]),
+  });
+
+  assert.deepEqual(result, plan);
+  assert.equal(calls.chromium.length, 1);
+  assert.equal(calls.run.length, 1);
+  assert.equal(calls.run[0].command, "/app/node_modules/.bin/playwright");
+  assert.equal(calls.run[0].arguments_[0], "test");
+  assert.equal(calls.run[0].arguments_.at(-1), "--workers=1");
+  const grepIndex = calls.run[0].arguments_.indexOf("--grep");
+  assert.notEqual(grepIndex, -1);
+  assert.match(calls.run[0].arguments_[grepIndex + 1], /material/iu);
+  assert.equal(calls.run[0].options.env.TOOLCRAFT_BROWSER_SERVER_MODE, "dev");
+  assert.match(calls.output.join(""), /material\.layer/iu);
+});
+
+test("removes inherited proof authority from collection and execution", async () => {
+  const inheritedAuthority = {
+    TOOLCRAFT_BROWSER_EXECUTION_LEDGER_DIRECTORY: "/ledger",
+    TOOLCRAFT_BROWSER_EXECUTION_LEDGER_NONCE: "nonce",
+    TOOLCRAFT_KERNEL_BENCHMARK_REPORT_NONCE: "kernel-nonce",
+    TOOLCRAFT_KERNEL_BENCHMARK_REPORT_PATH: "/kernel",
+    TOOLCRAFT_PERFORMANCE_FIXTURE_RESOLUTION_MODE: "full-certification",
+    TOOLCRAFT_PERFORMANCE_FIXTURE_SELECTOR: "maximum",
+    TOOLCRAFT_PERFORMANCE_REPORT_NONCE: "performance-nonce",
+    TOOLCRAFT_PERFORMANCE_REPORT_PATH: "/performance",
+    TOOLCRAFT_PERFORMANCE_REPORT_SOURCE_HASH: "a".repeat(64),
+    TOOLCRAFT_PERFORMANCE_REQUEST_AUTHORITY_HASH: "b".repeat(64),
+    TOOLCRAFT_TARGETED_PERFORMANCE_PASS_IDS: '["scene"]',
+    TOOLCRAFT_TARGETED_PERFORMANCE_PATH_IDS: '["path"]',
+    TOOLCRAFT_TARGETED_PERFORMANCE_REPORT_NONCE: "targeted-nonce",
+    TOOLCRAFT_TARGETED_PERFORMANCE_REPORT_PATH: "/targeted",
+    TOOLCRAFT_TARGETED_PERFORMANCE_REPORT_SOURCE_HASH: "c".repeat(64),
+  };
+  const env = { KEEP_ME: "yes", ...inheritedAuthority };
+  const { calls, dependencies } = createDependencies();
+
+  await runToolcraftFeatureVerificationCore({
+    dependencies,
+    env,
+    projectDir: "/app",
+    request: parseToolcraftFeatureVerificationArguments(["material.layer"]),
+  });
+
+  for (const call of [...calls.capture, ...calls.run]) {
+    assert.equal(call.options.env.KEEP_ME, "yes");
+    for (const name of Object.keys(inheritedAuthority)) {
+      assert.equal(call.options.env[name], undefined, name);
+    }
+  }
+  assert.deepEqual(env, { KEEP_ME: "yes", ...inheritedAuthority });
+});

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

@@ -16,10 +16,20 @@ function inventoriesEqual(left, right) {
   return JSON.stringify(left) === JSON.stringify(right);
 }
 
-function getPreviousAnchor(previousDeliveryReceipt) {
+function getPreviousAnchor(
+  previousDeliveryReceipt,
+  previousPerformanceReceipt,
+) {
   return previousDeliveryReceipt === undefined
     ? null
-    : normalizeToolcraftDeliveryAnchor(previousDeliveryReceipt);
+    : {
+        ...normalizeToolcraftDeliveryAnchor(previousDeliveryReceipt),
+        lifecycle:
+          previousPerformanceReceipt?.plan?.kind ===
+          "performance-iteration"
+            ? previousPerformanceReceipt.plan.lifecycle
+            : previousDeliveryReceipt.plan.lifecycle,
+      };
 }
 
 function assertDeliveryBasisAnchor({ previousAnchor, receipt }) {
@@ -32,16 +42,15 @@ function assertDeliveryBasisAnchor({ previousAnchor, receipt }) {
     }
     return;
   }
-  const comparison = basis.comparisonInventory;
   if (
     !previousAnchor ||
-    basis.comparisonFunctionalProofModelHash !==
+    basis.kind !== "performance-request" ||
+    basis.initialFunctionalProofModelHash !==
       previousAnchor.functionalProofModelHash ||
-    comparison.sourceHash !== previousAnchor.sourceHash ||
-    !inventoriesEqual(comparison.entries, previousAnchor.files)
+    basis.initialSourceHash !== previousAnchor.sourceHash
   ) {
     throw new Error(
-      "Toolcraft changed delivery basis must match the immediately previous successful delivery inventory and functional proof model.",
+      "Toolcraft performance request basis must match the initial successful delivery identity.",
     );
   }
 }
@@ -90,10 +99,14 @@ export async function assertDeliveryCheckpointState({
   deliveryReceipt,
   finalInventory,
   previousDeliveryReceipt,
+  previousPerformanceReceipt,
 }) {
   const receiptError = getToolcraftDeliveryReceiptShapeError(deliveryReceipt);
   if (receiptError) throw new Error(receiptError);
-  const previousAnchor = getPreviousAnchor(previousDeliveryReceipt);
+  const previousAnchor = getPreviousAnchor(
+    previousDeliveryReceipt,
+    previousPerformanceReceipt,
+  );
   assertDeliveryBasisAnchor({
     previousAnchor,
     receipt: deliveryReceipt,