prizmkit 1.1.135 → 1.1.137

package/bundled/VERSION.json

@@ -1,5 +1,5 @@
 {
-  "frameworkVersion": "1.1.135",
-  "bundledAt": "2026-07-19T07:16:08.201Z",
-  "bundledFrom": "9dfbbdb"
+  "frameworkVersion": "1.1.137",
+  "bundledAt": "2026-07-19T22:45:14.904Z",
+  "bundledFrom": "c036667"
 }

package/bundled/dev-pipeline/scripts/generate-bootstrap-prompt.py

@@ -993,7 +993,6 @@ def validate_feature_test_evidence(project_root, artifact_dir):
         return None
     for stage in stages:
         if (not isinstance(stage, dict) or stage.get("status") not in {"complete", "not_applicable"} or
-                not _is_sha256(stage.get("input_sha256")) or
                 not isinstance(stage.get("outputs"), list)):
             return None
     if (not _is_sha256(manifest.get("working_diff_sha256")) or

package/bundled/dev-pipeline/tests/test_generate_bootstrap_prompt.py

@@ -246,7 +246,7 @@ def write_fresh_structured_evidence(project_root):
         "EVIDENCE_VALIDATE",
     ]
     for name in stage_names:
-        stages.append({"name": name, "status": "complete", "input_sha256": zero_hash, "outputs": []})
+        stages.append({"name": name, "status": "complete", "outputs": []})
     manifest = {
         "protocol_version": "1.0",
         "evidence_id": evidence_id,

package/bundled/skills/_metadata.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.1.135",
+  "version": "1.1.137",
   "skills": {
     "prizmkit": {
       "description": "Framework introduction and navigation for the formal single-requirement lifecycle, project initialization, Prizm docs, and independent deployment.",

package/bundled/skills/prizmkit-test/SKILL.md

@@ -13,7 +13,7 @@ This skill orchestrates each target project's native runners and conventions. It
 
 Choose project-semantic parameters from the target project: framework, commands, cwd, timeout, retry/attempt policy, concurrency, Mock tools, test layers, module boundary, inventory patterns, mutation technology, and environment classification. Do not hard-code ecosystem-specific defaults when the project can decide them.
 
-Fix only the protocol mechanisms needed for safe, replayable evidence: project/evidence/request locators, schema-shaped requests, path confinement, real process execution, complete raw capture, runner-generated chained receipts, hash binding, append-only history, differential isolation/cleanup, and resume invalidation. Read `${SKILL_DIR}/references/trusted-evidence-execution.md` before inventory, execution, differential proof, resume, or replay; it defines the trust boundary and builder commands. Read `${SKILL_DIR}/references/evidence-request-protocol.md` when authoring any request or authoritative JSON record; it defines request ownership, structured N/A, and the schema map.
+Fix only the protocol mechanisms needed for safe, replayable evidence: project/evidence/request locators, schema-shaped requests, path confinement, real process execution, complete raw capture, runner-generated receipts, append-only history, and resume invalidation. Read `${SKILL_DIR}/references/trusted-evidence-execution.md` before inventory, execution, differential proof, resume, or replay; it defines the trust boundary and builder commands. Read `${SKILL_DIR}/references/evidence-request-protocol.md` when authoring any request or authoritative JSON record; it defines request ownership, structured N/A, and the schema map.
 
 ## Canonical Evidence Builder Lifecycle
 
@@ -174,15 +174,14 @@ If a valid test reveals a business/contract defect, do not fix production behavi
 
 ### 7. EXECUTE_PROVE
 
-Run required layers in plan order through `${SKILL_DIR}/scripts/build_test_evidence.py execute`. Use `test_paths` or `auto_bind=true` for new requests; the builder resolves and persists canonical test IDs before the native command runs. The model selects project-native argv, cwd, timeout, attempts, concurrency, layer, environment classification, and tool probes in schema-shaped requests. The runner performs the actual process execution and appends complete environment/tool versions, raw stdout/stderr hashes, request hash, runner hash, unique receipt, and receipt-chain binding to `executions.json`. Do not accept caller-authored execution JSON and do not retry until green.
+Run required layers in plan order through `${SKILL_DIR}/scripts/build_test_evidence.py execute`. Use `test_paths` or `auto_bind=true` for new requests; the builder resolves and persists canonical test IDs before the native command runs. The model selects project-native argv, cwd, timeout, attempts, concurrency, layer, environment classification, and tool probes in schema-shaped requests. The runner performs the actual process execution and appends complete environment/tool versions, raw stdout/stderr hashes, request hash, runner hash, and unique receipt to `executions.json`. Do not accept caller-authored execution JSON and do not retry until green.
 
 Differentially prove each added/changed necessary behavior test:
 
-- Prefer baseline failure plus current success in an isolated/uncontaminated environment.
-- If baseline is inapplicable, use a minimal controlled mutation tied to the same risk.
-- Bind proof to runner receipts, baseline commit, a stable source-snapshot hash, mutation apply/restore hashes, and complete cleanup. The source snapshot excludes runtime-managed `.prizmkit/state/`, evidence output under `.prizmkit/test/evidence/`, `.claude/worktrees/`, Git metadata, and Python bytecode caches because those paths change while the tested code remains identical.
-- Keep source identity separate from evidence integrity: the stable snapshot detects behavior-bearing project drift, while `manifest.json` hashes every evidence file and detects report/output tampering.
-- Completely remove mutations and verify the stable source snapshot is unchanged. Never rebind completed proof to the mutable live project tree.
+- Prefer baseline failure plus current success: for existing behavior, the test fails against the pre-change baseline (via `git worktree`) and passes against the current project.
+- If baseline is inapplicable (new behavior), use a minimal controlled mutation tied to the same risk, applied in a `git worktree`.
+- The current (success) side executes directly in the project root — tests and behavior under proof belong in the main repository, not an isolated copy.
+- Bind proof to runner receipts, baseline commit, and worktree cleanup. Never rebind completed proof to the mutable live project tree.
 - Classify each proof as `PROVEN`, structured `NOT_APPLICABLE`, or `UNPROVEN`.
 
 Necessary `UNPROVEN` behavior, required flakiness, unavailable infrastructure after bounded recovery, failed cleanup, unreliable execution, or budget truncation yields `TEST_BLOCKED`.
@@ -206,11 +205,23 @@ Create `.prizmkit/test/evidence/<evidence-id>/` from the package template with:
 - `contracts/` snapshots
 - derived `test-report.md`
 
-Hash baseline, diff, the stable source snapshot, inventoried source/tests/contracts/lockfiles, environment, plan, and every evidence file. Runtime state, evidence output, linked Agent worktrees, Git metadata, and bytecode caches are outside source identity; evidence files remain independently content-addressed through `manifest.json`. Set `environment_claim=mocked-code-level-only`.
+Hash baseline, diff, inventoried source/tests/contracts/lockfiles, environment, plan, and every evidence file. Evidence files remain individually content-addressed through `manifest.json`. Set `environment_claim=mocked-code-level-only`.
 
 ### 9. EVIDENCE_VALIDATE
 
-Run:
+The validator runs in two passes:
+
+**First pass (pre-check, no `--attest`):**
+
+```bash
+python3 ${SKILL_DIR}/scripts/validate_test_evidence.py \
+  --evidence-dir .prizmkit/test/evidence/<evidence-id> \
+  --project-root <target-project-root>
+```
+
+If this pre-check finds errors, fix them in the package before the second pass. The validator checks every authoritative record against its shipped schema, live target inventories, patch/diff binding, changed-file/module-root/exclusion/Regression Ring cross-links, generated-test snapshots, planned-test execution links, runner-generated receipts/request/raw-output hashes, successful behavior-risk mappings, production/unknown external-target safety, and package integrity.
+
+**Second pass (attestation, with `--attest`):**
 
 ```bash
 python3 ${SKILL_DIR}/scripts/validate_test_evidence.py \
@@ -219,7 +230,7 @@ python3 ${SKILL_DIR}/scripts/validate_test_evidence.py \
   --attest
 ```
 
-The validator checks every authoritative record against its shipped schema, live target inventories, patch/diff binding, stage dependencies, changed-file/module-root/exclusion/Regression Ring cross-links, generated-test snapshots, planned-test execution links, runner-generated receipts/request/raw-output hashes, successful behavior-risk mappings, proof-linked isolated failures/current successes, production/unknown external-target safety, cleanup, and package integrity. `--attest` writes an integrity/protocol attestation, not proof against a malicious same-permission producer. Use builder replay when feasible to rerun recorded requests and create new linked receipts. Store validation output. Tampering, schema/identity/hash mismatch, source/test/lockfile drift, missing matrix mappings, wrong execution order, invalid differential proof, cleanup failure, unjustified structured N/A, unresolved risk, or a false real-environment claim fails validation. `TEST_PASS` requires validator success and means code-level evidence is replayable and validated under this protocol.
+`--attest` writes an integrity/protocol attestation into `validation.json`, re-derives `test-report.md`, re-hashes final records in `manifest.json`, then runs a **second** strict validation against the refreshed package. A package is not a `TEST_PASS` until this second strict validation succeeds. Use builder replay when feasible to rerun recorded requests and create new linked receipts. Store validation output. Tampering, schema/identity/hash mismatch, source/test/lockfile drift, missing matrix mappings, wrong execution order, invalid differential proof, cleanup failure, unjustified structured N/A, unresolved risk, or a false real-environment claim fails validation.
 
 ## Resume and Idempotency
 

package/bundled/skills/prizmkit-test/assets/authoritative-records.schema.json

@@ -20,7 +20,7 @@
       "additionalProperties": false,
       "required": ["kind", "source", "observations"],
       "properties": {
-        "kind": { "enum": ["manifest", "runner-config", "filesystem", "contract", "lockfile", "import-graph", "caller-analysis", "project-doc", "model-analysis"] },
+        "kind": { "enum": ["manifest", "runner-config", "filesystem", "contract", "lockfile", "import-graph", "caller-analysis", "project-doc", "model-analysis", "shared-contract", "source-inspection", "field-analysis", "runner-inspection", "dependency-scan", "audit-log", "api-spec", "tool-probe"] },
         "source": { "type": "string", "minLength": 1 },
         "observations": { "$ref": "#/$defs/stringArray" }
       }
@@ -104,7 +104,7 @@
             "required": ["name", "kind", "files", "planned_test_ids", "discovery_evidence"],
             "properties": {
               "name": { "type": "string", "minLength": 1 },
-              "kind": { "enum": ["caller", "consumer", "shared-contract", "state-dependency"] },
+              "kind": { "enum": ["caller", "consumer", "shared-contract", "state-dependency", "api-spec", "documentation"] },
               "files": { "$ref": "#/$defs/stringArray" },
               "planned_test_ids": { "$ref": "#/$defs/stringArray" },
               "discovery_evidence": { "type": "array", "minItems": 1, "items": { "$ref": "#/$defs/discoveryEvidence" } }
@@ -218,7 +218,7 @@
     "changeCapture": {
       "type": "object",
       "additionalProperties": false,
-      "required": ["capture_format", "baseline_commit", "patch_path", "patch_sha256", "changed_files", "source_tree_sha256"],
+      "required": ["capture_format", "baseline_commit", "patch_path", "patch_sha256", "changed_files"],
       "properties": {
         "capture_format": { "const": "prizmkit-canonical-change-v1" },
         "baseline_commit": { "type": "string", "minLength": 1 },
@@ -237,8 +237,7 @@
               "role": { "const": "source" }
             }
           }
-        },
-        "source_tree_sha256": { "$ref": "#/$defs/sha256" }
+        }
       }
     },
     "testPlan": {
@@ -358,7 +357,7 @@
     "executionReceipt": {
       "type": "object",
       "additionalProperties": false,
-      "required": ["receipt_format", "runner_path", "runner_sha256", "execution_id", "attempt_index", "request_path", "request_sha256", "purpose", "command", "cwd", "environment", "tool_versions", "layer", "test_ids", "external_targets", "exit_code", "stdout_path", "stderr_path", "stdout_sha256", "stderr_sha256", "selected_execution", "reliable", "started_at", "finished_at", "previous_receipt_sha256"],
+      "required": ["receipt_format", "runner_path", "runner_sha256", "execution_id", "attempt_index", "request_path", "request_sha256", "purpose", "command", "cwd", "environment", "tool_versions", "layer", "test_ids", "external_targets", "exit_code", "stdout_path", "stderr_path", "stdout_sha256", "stderr_sha256", "selected_execution", "reliable", "started_at", "finished_at"],
       "properties": {
         "receipt_format": { "const": "prizmkit-runner-generated-v1" },
         "runner_path": { "$ref": "#/$defs/path" },
@@ -386,7 +385,6 @@
         "reliable": { "type": "boolean" },
         "started_at": { "type": "string", "minLength": 1 },
         "finished_at": { "type": "string", "minLength": 1 },
-        "previous_receipt_sha256": { "type": ["string", "null"] },
         "replay_of": { "type": ["string", "null"] },
         "isolation": { "type": ["object", "null"] }
       }
@@ -398,14 +396,13 @@
         {
           "type": "object",
           "additionalProperties": false,
-          "required": ["request_version", "behavior_id", "method", "execution_request", "baseline_commit", "current_tree_sha256", "mutation_patch_path", "test_overlay_paths", "expected_failure_signals"],
+          "required": ["request_version", "behavior_id", "method", "execution_request", "baseline_commit", "mutation_patch_path", "test_overlay_paths", "expected_failure_signals"],
           "properties": {
             "request_version": { "const": "1.0" },
             "behavior_id": { "type": "string", "minLength": 1 },
             "method": { "enum": ["baseline", "controlled-mutation"] },
             "execution_request": { "$ref": "#/$defs/executionRequest" },
             "baseline_commit": { "type": "string", "minLength": 1 },
-            "current_tree_sha256": { "$ref": "#/$defs/sha256" },
             "mutation_patch_path": { "type": ["string", "null"] },
             "test_overlay_paths": { "$ref": "#/$defs/stringArray" },
             "expected_failure_signals": { "$ref": "#/$defs/stringArray" }
@@ -447,7 +444,7 @@
           "items": {
             "type": "object",
             "additionalProperties": false,
-            "required": ["behavior_id", "classification", "method", "differential_request_path", "differential_request_sha256", "baseline_commit", "current_tree_sha256", "baseline_execution_id", "mutation_execution_id", "current_execution_id", "failure_reason_matched", "cleanup_succeeded", "project_tree_before_sha256", "project_tree_after_sha256", "isolation_tree_sha256", "mutation_apply_sha256", "mutation_restore_sha256", "not_applicable"],
+            "required": ["behavior_id", "classification", "method", "differential_request_path", "differential_request_sha256", "baseline_commit", "baseline_execution_id", "mutation_execution_id", "current_execution_id", "failure_reason_matched", "cleanup_succeeded", "not_applicable"],
             "properties": {
               "behavior_id": { "type": "string", "minLength": 1 },
               "classification": { "enum": ["PROVEN", "NOT_APPLICABLE", "UNPROVEN"] },
@@ -455,17 +452,11 @@
               "differential_request_path": { "type": ["string", "null"] },
               "differential_request_sha256": { "type": ["string", "null"] },
               "baseline_commit": { "type": ["string", "null"] },
-              "current_tree_sha256": { "type": ["string", "null"] },
               "baseline_execution_id": { "type": ["string", "null"] },
               "mutation_execution_id": { "type": ["string", "null"] },
               "current_execution_id": { "type": ["string", "null"] },
               "failure_reason_matched": { "type": "boolean" },
               "cleanup_succeeded": { "type": "boolean" },
-              "project_tree_before_sha256": { "type": ["string", "null"] },
-              "project_tree_after_sha256": { "type": ["string", "null"] },
-              "isolation_tree_sha256": { "type": ["string", "null"] },
-              "mutation_apply_sha256": { "type": ["string", "null"] },
-              "mutation_restore_sha256": { "type": ["string", "null"] },
               "not_applicable": { "type": ["object", "null"] }
             }
           }

package/bundled/skills/prizmkit-test/assets/evidence-manifest.schema.json

@@ -67,7 +67,7 @@
     "stage": {
       "type": "object",
       "additionalProperties": false,
-      "required": ["name", "status", "input_sha256", "outputs"],
+      "required": ["name", "status", "outputs"],
       "properties": {
         "name": {
           "enum": [
@@ -83,7 +83,6 @@
           ]
         },
         "status": { "enum": ["complete", "not_applicable"] },
-        "input_sha256": { "$ref": "#/$defs/sha256" },
         "outputs": { "type": "array", "items": { "type": "string", "minLength": 1 } },
         "not_applicable": {
           "type": ["object", "null"],

package/bundled/skills/prizmkit-test/assets/evidence-package-template.json

@@ -38,60 +38,15 @@
     "contract_snapshots": "contracts/"
   },
   "stage_statuses": [
-    {
-      "name": "CHANGE_CLASSIFY",
-      "status": "pending",
-      "input_sha256": "<sha256>",
-      "outputs": []
-    },
-    {
-      "name": "SCOPE_DISCOVER",
-      "status": "pending",
-      "input_sha256": "<sha256>",
-      "outputs": []
-    },
-    {
-      "name": "CONTRACT_MODEL",
-      "status": "pending",
-      "input_sha256": "<sha256>",
-      "outputs": []
-    },
-    {
-      "name": "TEST_PLAN",
-      "status": "pending",
-      "input_sha256": "<sha256>",
-      "outputs": []
-    },
-    {
-      "name": "INFRA_READY",
-      "status": "pending",
-      "input_sha256": "<sha256>",
-      "outputs": []
-    },
-    {
-      "name": "TEST_BUILD",
-      "status": "pending",
-      "input_sha256": "<sha256>",
-      "outputs": []
-    },
-    {
-      "name": "EXECUTE_PROVE",
-      "status": "pending",
-      "input_sha256": "<sha256>",
-      "outputs": []
-    },
-    {
-      "name": "EVIDENCE_PACKAGE",
-      "status": "pending",
-      "input_sha256": "<sha256>",
-      "outputs": []
-    },
-    {
-      "name": "EVIDENCE_VALIDATE",
-      "status": "pending",
-      "input_sha256": "<sha256>",
-      "outputs": []
-    }
+    { "name": "CHANGE_CLASSIFY",      "status": "pending", "outputs": [] },
+    { "name": "SCOPE_DISCOVER",       "status": "pending", "outputs": [] },
+    { "name": "CONTRACT_MODEL",       "status": "pending", "outputs": [] },
+    { "name": "TEST_PLAN",            "status": "pending", "outputs": [] },
+    { "name": "INFRA_READY",          "status": "pending", "outputs": [] },
+    { "name": "TEST_BUILD",           "status": "pending", "outputs": [] },
+    { "name": "EXECUTE_PROVE",        "status": "pending", "outputs": [] },
+    { "name": "EVIDENCE_PACKAGE",     "status": "pending", "outputs": [] },
+    { "name": "EVIDENCE_VALIDATE",    "status": "pending", "outputs": [] }
   ],
   "resume": {
     "last_valid_stage": null,

package/bundled/skills/prizmkit-test/references/evidence-protocol.md

@@ -14,7 +14,6 @@ Store those values as `evidence_id_inputs` in `manifest.json`. Record separate a
 
 Use two separate integrity domains:
 
-- **Stable source snapshot:** hash behavior-bearing project files while excluding runtime-managed `.prizmkit/state/`, evidence output under `.prizmkit/test/evidence/`, linked `.claude/worktrees/`, Git metadata, and Python bytecode caches. Builder and validator use the same deterministic exclusion policy, and isolated current execution is copied from that same snapshot scope.
 - **Evidence package:** hash each evidence record through `manifest.json`; any report, receipt, raw output, request, or proof mutation remains detectable even though evidence output is outside source identity.
 
 Runtime-only churn must not invalidate a source proof. Drift in an inventoried source, test, contract, or lockfile must still fail live inventory validation. Never replace a completed proof's stable snapshot identity with a later hash of the mutable parent workspace.
@@ -42,7 +41,7 @@ Run exactly these states in order:
 8. `EVIDENCE_PACKAGE`
 9. `EVIDENCE_VALIDATE`
 
-Each manifest stage records `name`, `status`, `input_sha256`, and output paths. A stage may be `not_applicable` only with a concrete rationale. A later state cannot complete until every applicable predecessor output exists, validates, and matches its recorded input hash.
+Each manifest stage records `name`, `status`, and output paths. A stage may be `not_applicable` only with a concrete rationale. A later state cannot complete until every applicable predecessor output exists and validates.
 
 ### CHANGE_CLASSIFY
 
@@ -120,7 +119,7 @@ Run progressively:
 
 Only omit plan-marked non-required layers. Every N/A is structured with rationale, typed evidence, considered signals, and explanations for detected conflicts. The model retains semantic judgment; validation checks structure and obvious signal conflicts, not hidden intent. Append only runner-generated execution receipts containing:
 
-- runner-generated receipt format, runner hash, request path/hash, and receipt-chain predecessor hash;
+- runner-generated receipt format, runner hash, request path/hash, and unique execution identifier;
 - unique selected execution identifier;
 - layer and exact argv;
 - confined working directory;
@@ -134,11 +133,11 @@ Do not overwrite failed or superseded attempts. Do not retry until green. Use a
 
 For each added or changed necessary behavior test, prove the test:
 
-1. Prefer an isolated checkout or equivalent uncontaminated environment where the test fails against the pre-change baseline and passes against current code.
-2. If baseline execution is inapplicable (for example, the public behavior did not exist), apply a minimal controlled mutation tied to the same matrix risk, observe failure, restore it completely, and observe current success.
+1. Prefer baseline failure plus current success: for existing behavior, the test fails against the pre-change baseline (via `git worktree`) and passes against the current project.
+2. If baseline execution is inapplicable (new behavior), apply a minimal controlled mutation tied to the same matrix risk in a `git worktree`, observe failure, restore it completely, and observe current success.
 3. Record `PROVEN`, justified `NOT_APPLICABLE`, or `UNPROVEN`.
 
-Record baseline/current/mutation runner receipt IDs, request hash, baseline commit, stable source-snapshot and isolation hashes, mutation apply/restore hashes, expected failure signal match, and source-snapshot cleanup result. Necessary `UNPROVEN` behavior prevents `TEST_PASS`.
+Record baseline/mutation runner receipt IDs, current runner receipt IDs, request hash, baseline commit, expected failure signal match, and worktree cleanup result. Necessary `UNPROVEN` behavior prevents `TEST_PASS`.
 
 ### EVIDENCE_PACKAGE
 
@@ -169,7 +168,7 @@ python3 ${SKILL_DIR}/scripts/validate_test_evidence.py \
 
 When feasible, replay recorded requests through `build_test_evidence.py execute --replay-receipt ...`. Replay performs a new real execution and emits a new linked receipt; it does not pretend the attestation establishes what historically ran.
 
-The validator checks all shipped JSON schemas, evidence-directory identity, live target-project inventories and aggregate hashes, stable source-snapshot identity with runtime paths excluded, changed-file/module-root/exclusion/Regression Ring cross-links, patch/diff binding, stage output ownership and predecessor hashes, generated-test snapshot existence, planned test/inventory/execution linkage, module/matrix completeness, successful selected runner receipts with request/raw-output binding, proof-linked isolated failures/current successes, controlled-mutation apply/restoration hashes, cleanup, structured N/A and obvious signal conflicts, production/unknown external-target safety, strict verdict semantics, and honest mocked-versus-real claims. `TEST_PASS` requires deterministic validator success.
+The validator checks all shipped JSON schemas, evidence-directory identity, live target-project inventories and aggregate hashes, changed-file/module-root/exclusion/Regression Ring cross-links, patch/diff binding, stage ordering and output ownership, generated-test snapshot existence, planned test/inventory/execution linkage, module/matrix completeness, successful selected runner receipts with request/raw-output binding, structured N/A and obvious signal conflicts, production/unknown external-target safety, strict verdict semantics, and honest mocked-versus-real claims. `TEST_PASS` requires deterministic validator success.
 
 ## Resume and Invalidation
 

package/bundled/skills/prizmkit-test/references/evidence-request-protocol.md

@@ -11,7 +11,7 @@ Use existing project-native tests first. The Main Agent supplies only semantic t
 `finalize` creates the manifest, stage dependency hashes, verdict, evidence identity, and deterministic report inputs. `render-report` only renders the derived Markdown view. The validator alone creates `validation.json` during `--attest`; never hand-author a validation attestation or rebind a finalized package after identity inputs change.
 
 
-The model writes project-semantic requests after inspecting manifests, runner configuration, contracts, test conventions, changed files, and module boundaries. The bundled builder owns process execution, raw output, receipts, isolation, tree hashes, and invalidation calculations.
+The model writes project-semantic requests after inspecting manifests, runner configuration, contracts, test conventions, changed files, and module boundaries. The bundled builder owns process execution, raw output, receipts, worktree-based isolation, and invalidation calculations.
 
 Never hand-author `executions.json` receipt fields. Never copy a command's claimed output into `raw/`. Invoke the builder so provenance is linked to the actual process.
 
@@ -48,11 +48,11 @@ Record:
 
 - behavior ID and model-selected `baseline` or `controlled-mutation` method;
 - the nested execution request;
-- actual baseline commit and the stable source-snapshot hash produced with the builder's runtime exclusions;
+- actual baseline commit;
 - mutation patch path when applicable;
 - concrete expected failure signals.
 
-The builder creates isolated copies from the same stable source-snapshot scope, executes the failing and current sides, records receipts, binds the differential request hash, and verifies that behavior-bearing project content is unchanged. Runtime state, evidence output, linked Agent worktrees, Git metadata, and Python bytecode caches do not participate in source identity. A proof is `PROVEN` only when the intended failure signal appears, the failing side exits nonzero, current exits zero, and cleanup/snapshot checks pass.
+The builder uses `git worktree add --detach` for the failing side (baseline commit or controlled mutation) and executes the current side directly in the project root. Differential proofs compare receipt outcomes (exit codes, expected failure signals) between the failing side and the current side. Worktrees are cleaned up with `git worktree remove --force` after execution. Source drift between capture and validation is detected through change-capture freshness checks (inventory changed_files vs canonical capture) and resume invalidation (live target hashes vs manifest).
 
 ## Structured N/A
 

package/bundled/skills/prizmkit-test/references/examples.md

@@ -71,7 +71,7 @@ Evidence: .prizmkit/test/evidence/<evidence-id>/
 
 ## 6. Baseline Inapplicable — Controlled Mutation
 
-A newly added CLI command has no pre-change interface, so baseline execution is justified `NOT_APPLICABLE` as a direct proof method. In an uncontaminated checkout, the run applies a minimal mutation that removes the command registration, observes the command test fail for that risk, restores the patch, verifies source hashes and cleanup, then observes current success. The behavior is `PROVEN` by `controlled-mutation`.
+A newly added CLI command has no pre-change interface, so baseline execution is justified `NOT_APPLICABLE` as a direct proof method. The run creates a `git worktree` for the mutation, applies a minimal patch that removes the command registration, observes the command test fail for that risk, cleans up the worktree, and observes current success. The behavior is `PROVEN` by `controlled-mutation`.
 
 If restoration cannot be proven, the verdict is `TEST_BLOCKED`.
 

package/bundled/skills/prizmkit-test/references/test-generation-steps.md

@@ -101,8 +101,8 @@ Run selected tests in order through the bundled evidence builder: focused, modul
 
 For each new/changed necessary behavior test:
 
-1. In an isolated checkout/equivalent, run it against the actual baseline commit and require failure for the intended recorded signal, then current success.
-2. If baseline proof is genuinely inapplicable, apply one model-selected minimal controlled mutation tied to the risk, require failure, restore it, and verify request/receipt, mutation apply/restore, isolation tree, and original project tree hashes.
+1. For existing behavior, run it against the pre-change baseline (via `git worktree`) and require failure for the intended recorded signal, then current success against the project root.
+2. If baseline proof is genuinely inapplicable, apply one model-selected minimal controlled mutation tied to the risk in a `git worktree`, require failure, restore and clean up the worktree, and verify current success against the project root.
 3. Record `PROVEN`, structured `NOT_APPLICABLE`, or `UNPROVEN` with runner receipt IDs.
 
 Necessary `UNPROVEN` evidence blocks. Store complete stdout/stderr in `raw/`; snapshots in `generated-tests/`; do not overwrite previous attempts.

package/bundled/skills/prizmkit-test/references/trusted-evidence-execution.md

@@ -27,9 +27,9 @@ The protocol fixes only what trustworthy, replayable packaging needs:
 - actual child-process execution without a shell;
 - complete stdout/stderr capture and output hashes;
 - complete effective environment and tool-probe capture;
-- runner-generated UUID receipt, request hash, runner hash, and receipt-chain hash;
+- runner-generated UUID receipt, request hash, and runner hash;
 - append-only execution history;
-- differential isolation, cleanup, and tree hashes;
+- differential isolation via git worktree and cleanup;
 - deterministic resume invalidation calculation;
 - strict schema and cross-record validation.
 

package/bundled/skills/prizmkit-test/scripts/build_test_evidence.py

@@ -46,7 +46,7 @@ LAYERS = (
     "affected-module-regression", "regression-ring",
 )
 BLOCKED_EXTERNAL_CLASSES = {"production", "unknown"}
-SNAPSHOT_VOLATILE_ROOTS = (
+INVENTORY_RESERVED_ROOTS = (
     ".prizmkit/state",
     ".prizmkit/test/evidence",
     ".prizmkit/" + "dev-" + "pipeline",
@@ -55,8 +55,8 @@ SNAPSHOT_VOLATILE_ROOTS = (
     ".codebuddy/worktrees",
     ".codex/worktrees",
 )
-SNAPSHOT_VOLATILE_NAMES = {".git", "__pycache__", ".pytest_cache", ".mypy_cache"}
-INVENTORY_RESERVED_ROOTS = SNAPSHOT_VOLATILE_ROOTS
+
+_IGNORED_DIR_NAMES = {".git", "__pycache__", ".pytest_cache", ".mypy_cache"}
 FINAL_RECORDS = {"manifest.json", "validation.json", "verdict.json", "test-report.md"}
 
 
@@ -152,7 +152,7 @@ def normalize_relative(value: str) -> str:
 
 def is_reserved_inventory_path(relative: str) -> bool:
     path = Path(relative)
-    if any(part in SNAPSHOT_VOLATILE_NAMES for part in path.parts):
+    if any(part in _IGNORED_DIR_NAMES for part in path.parts):
         return True
     return any(path == Path(prefix) or Path(prefix) in path.parents for prefix in INVENTORY_RESERVED_ROOTS)
 
@@ -355,7 +355,6 @@ def load_change_capture(
         if (
             live_patch_sha256 != capture["patch_sha256"]
             or live_entries != capture["changed_files"]
-            or tree_sha256(project_root, [evidence_dir]) != capture.get("source_tree_sha256")
         ):
             raise RequestError(
                 "canonical change capture is stale; rerun capture-change and inventory after repository changes"
@@ -558,28 +557,6 @@ def resolve_execution_test_ids(project_root: Path, evidence_dir: Path, request:
     return request
 
 
-def is_volatile_snapshot_path(root: Path, candidate: Path, excluded: list[Path] | None = None) -> bool:
-    try:
-        relative = candidate.relative_to(root)
-    except ValueError:
-        return True
-    if any(part in SNAPSHOT_VOLATILE_NAMES for part in relative.parts):
-        return True
-    if any(relative == Path(prefix) or Path(prefix) in relative.parents for prefix in SNAPSHOT_VOLATILE_ROOTS):
-        return True
-    resolved = candidate.resolve()
-    return any(resolved == item.resolve() or item.resolve() in resolved.parents for item in (excluded or []))
-
-
-def tree_sha256(root: Path, excluded: list[Path] | None = None) -> str:
-    entries: list[dict[str, str]] = []
-    for candidate in sorted(root.rglob("*")):
-        if not candidate.is_file() or is_volatile_snapshot_path(root, candidate, excluded):
-            continue
-        entries.append({"path": candidate.relative_to(root).as_posix(), "sha256": file_sha256(candidate)})
-    return canonical_sha256(entries)
-
-
 def collect_matches(project_root: Path, patterns: list[str], exclusions: set[str]) -> list[dict[str, str]]:
     project_resolved = project_root.resolve()
     paths: set[Path] = set()
@@ -844,9 +821,6 @@ def append_receipt(evidence_dir: Path, receipt: dict[str, Any]) -> None:
     existing: Any = load_json(path) if path.exists() else []
     if not isinstance(existing, list):
         raise RequestError("executions.json must remain an array")
-    previous = canonical_sha256(existing[-1]) if existing else None
-    if receipt["previous_receipt_sha256"] != previous:
-        raise RequestError("receipt chain mismatch")
     existing.append(receipt)
     write_json_atomic(path, existing)
 
@@ -923,7 +897,6 @@ def execute_request(
     existing = load_json(evidence_dir / "executions.json") if (evidence_dir / "executions.json").exists() else []
     if not isinstance(existing, list):
         raise RequestError("executions.json must remain an array")
-    previous = canonical_sha256(existing[-1]) if existing else None
     same_request_attempts = sum(1 for item in existing if isinstance(item, dict) and item.get("request_sha256") == file_sha256(request_path))
     receipt = {
         "receipt_format": "prizmkit-runner-generated-v1",
@@ -950,7 +923,6 @@ def execute_request(
         "reliable": probes_reliable and not timed_out and not execution_error,
         "started_at": started,
         "finished_at": finished,
-        "previous_receipt_sha256": previous,
         "replay_of": replay_of,
         "isolation": isolation,
     }
@@ -958,33 +930,6 @@ def execute_request(
     return receipt
 
 
-def copy_project_tree(project_root: Path, destination: Path, evidence_dir: Path) -> None:
-    def ignore(directory: str, names: list[str]) -> set[str]:
-        directory_relative = Path(directory).resolve().relative_to(project_root.resolve())
-        ignored: set[str] = set()
-        for name in names:
-            relative = directory_relative / name
-            candidate = project_root / relative
-            if is_volatile_snapshot_path(project_root, candidate, [evidence_dir]):
-                ignored.add(name)
-        return ignored
-
-    shutil.copytree(project_root, destination, ignore=ignore)
-
-
-def git_archive_baseline(project_root: Path, baseline_commit: str, destination: Path) -> None:
-    result = subprocess.run(
-        ["git", "-C", str(project_root), "archive", "--format=tar", baseline_commit],
-        capture_output=True, check=False,
-    )
-    if result.returncode != 0:
-        raise RequestError(f"cannot archive baseline commit {baseline_commit}: {result.stderr.decode(errors='replace')}")
-    destination.mkdir(parents=True)
-    extracted = subprocess.run(["tar", "-xf", "-", "-C", str(destination)], input=result.stdout, capture_output=True, check=False)
-    if extracted.returncode != 0:
-        raise RequestError(f"cannot extract baseline archive: {extracted.stderr.decode(errors='replace')}")
-
-
 def materialize_request(evidence_dir: Path, name: str, request: dict[str, Any]) -> Path:
     path = evidence_dir / "requests" / name
     write_json_atomic(path, request)
@@ -1024,7 +969,7 @@ def append_proof(evidence_dir: Path, proof: dict[str, Any]) -> None:
 
 def run_differential(project_root: Path, evidence_dir: Path, request_path: Path) -> dict[str, Any]:
     request = ensure_object(load_json(request_path), "differential request")
-    required = {"request_version", "behavior_id", "method", "execution_request", "baseline_commit", "current_tree_sha256", "mutation_patch_path", "test_overlay_paths", "expected_failure_signals"}
+    required = {"request_version", "behavior_id", "method", "execution_request", "baseline_commit", "mutation_patch_path", "test_overlay_paths", "expected_failure_signals"}
     na_required = {"request_version", "behavior_id", "method", "not_applicable"}
     if set(request) == na_required:
         if request["request_version"] != "1.0" or request["method"] != "not-applicable":
@@ -1034,10 +979,9 @@ def run_differential(project_root: Path, evidence_dir: Path, request_path: Path)
             "behavior_id": request["behavior_id"], "classification": "NOT_APPLICABLE",
             "method": None, "differential_request_path": evidence_relative(evidence_dir, request_path),
             "differential_request_sha256": file_sha256(request_path), "baseline_commit": None,
-            "current_tree_sha256": None, "baseline_execution_id": None, "mutation_execution_id": None,
+            "baseline_execution_id": None, "mutation_execution_id": None,
             "current_execution_id": None, "failure_reason_matched": False, "cleanup_succeeded": True,
-            "project_tree_before_sha256": None, "project_tree_after_sha256": None, "isolation_tree_sha256": None,
-            "mutation_apply_sha256": None, "mutation_restore_sha256": None, "not_applicable": not_applicable,
+            "not_applicable": not_applicable,
         }
         append_proof(evidence_dir, proof)
         return proof
@@ -1056,62 +1000,71 @@ def run_differential(project_root: Path, evidence_dir: Path, request_path: Path)
     overlay_paths = ensure_string_list(request["test_overlay_paths"], "test_overlay_paths")
     for relative in overlay_paths:
         confined(project_root, relative, must_exist=True)
-    project_before = tree_sha256(project_root, [evidence_dir])
-    if project_before != request["current_tree_sha256"]:
-        raise RequestError("current project tree does not match differential request")
     current_request_path = materialize_request(evidence_dir, f"differential-{uuid.uuid4().hex}.execution.json", execution_request)
     baseline_receipt = None
     mutation_receipt = None
     current_receipt = None
-    isolation_tree = None
-    mutation_apply_sha = None
-    mutation_restore_sha = None
     cleanup_succeeded = False
+    worktree_path = None
     try:
-        with tempfile.TemporaryDirectory(prefix="prizmkit-differential-") as temporary:
-            temporary_root = Path(temporary)
-            current_root = temporary_root / "current"
-            copy_project_tree(project_root, current_root, evidence_dir)
-            isolation_tree = tree_sha256(current_root)
-            if request["method"] == "baseline":
-                failing_root = temporary_root / "baseline"
-                git_archive_baseline(project_root, request["baseline_commit"], failing_root)
-                for relative in overlay_paths:
-                    source = confined(project_root, relative, must_exist=True)
-                    destination = confined(failing_root, relative)
-                    destination.parent.mkdir(parents=True, exist_ok=True)
-                    shutil.copy2(source, destination)
-                baseline_receipt = execute_request(
-                    project_root, evidence_dir, current_request_path, execution_root=failing_root,
-                    isolation={"kind": "baseline", "tree_sha256": tree_sha256(failing_root), "baseline_commit": request["baseline_commit"]},
-                    selected_execution=False,
-                )
-            elif request["method"] == "controlled-mutation":
-                failing_root = temporary_root / "mutation"
-                shutil.copytree(current_root, failing_root)
-                patch_value = request["mutation_patch_path"]
-                if not isinstance(patch_value, str) or not patch_value:
-                    raise RequestError("controlled mutation requires mutation_patch_path")
-                patch_path = request_file(evidence_dir, patch_value)
-                applied = subprocess.run(["git", "apply", "--whitespace=nowarn", str(patch_path)], cwd=failing_root, capture_output=True, check=False)
-                if applied.returncode != 0:
-                    raise RequestError(f"controlled mutation could not be applied: {applied.stderr.decode(errors='replace')}")
-                mutation_apply_sha = tree_sha256(failing_root)
-                mutation_receipt = execute_request(
-                    project_root, evidence_dir, current_request_path, execution_root=failing_root,
-                    isolation={"kind": "controlled-mutation", "tree_sha256": tree_sha256(failing_root), "patch_sha256": file_sha256(patch_path)},
-                    selected_execution=False,
-                )
-                mutation_restore_sha = tree_sha256(current_root)
-            else:
-                raise RequestError("differential method must be baseline or controlled-mutation")
-            current_receipt = execute_request(
-                project_root, evidence_dir, current_request_path, execution_root=current_root,
-                isolation={"kind": "current", "tree_sha256": tree_sha256(current_root)},
+        if request["method"] == "baseline":
+            worktree_path = tempfile.mkdtemp(prefix="prizmkit-baseline-")
+            result = subprocess.run(
+                ["git", "-C", str(project_root), "worktree", "add", "--detach", str(worktree_path), request["baseline_commit"]],
+                capture_output=True, check=False,
+            )
+            if result.returncode != 0:
+                raise RequestError(f"cannot create baseline worktree: {result.stderr.decode(errors='replace')}")
+            for relative in overlay_paths:
+                source = confined(project_root, relative, must_exist=True)
+                destination = Path(worktree_path) / relative
+                destination.parent.mkdir(parents=True, exist_ok=True)
+                shutil.copy2(source, destination)
+            baseline_receipt = execute_request(
+                project_root, evidence_dir, current_request_path, execution_root=Path(worktree_path),
+                isolation={"kind": "baseline", "baseline_commit": request["baseline_commit"]},
+                selected_execution=False,
+            )
+        elif request["method"] == "controlled-mutation":
+            worktree_path = tempfile.mkdtemp(prefix="prizmkit-mutation-")
+            result = subprocess.run(
+                ["git", "-C", str(project_root), "worktree", "add", "--detach", str(worktree_path), "HEAD"],
+                capture_output=True, check=False,
+            )
+            if result.returncode != 0:
+                raise RequestError(f"cannot create mutation worktree: {result.stderr.decode(errors='replace')}")
+            patch_value = request["mutation_patch_path"]
+            if not isinstance(patch_value, str) or not patch_value:
+                raise RequestError("controlled mutation requires mutation_patch_path")
+            patch_path = request_file(evidence_dir, patch_value)
+            applied = subprocess.run(
+                ["git", "apply", "--whitespace=nowarn", str(patch_path)],
+                cwd=worktree_path, capture_output=True, check=False,
             )
+            if applied.returncode != 0:
+                raise RequestError(f"controlled mutation could not be applied: {applied.stderr.decode(errors='replace')}")
+            mutation_receipt = execute_request(
+                project_root, evidence_dir, current_request_path, execution_root=Path(worktree_path),
+                isolation={"kind": "controlled-mutation", "patch_sha256": file_sha256(patch_path)},
+                selected_execution=False,
+            )
+        else:
+            raise RequestError("differential method must be baseline or controlled-mutation")
+        current_receipt = execute_request(
+            project_root, evidence_dir, current_request_path, execution_root=project_root,
+            isolation={"kind": "project-direct"},
+        )
         cleanup_succeeded = True
     finally:
-        project_after = tree_sha256(project_root, [evidence_dir])
+        if worktree_path and Path(worktree_path).exists():
+            subprocess.run(
+                ["git", "-C", str(project_root), "worktree", "remove", "--force", str(worktree_path)],
+                capture_output=True, check=False,
+            )
+            try:
+                shutil.rmtree(worktree_path, ignore_errors=True)
+            except OSError:
+                pass
     failing_receipt = baseline_receipt or mutation_receipt
     failing_output = b""
     if failing_receipt:
@@ -1120,7 +1073,7 @@ def run_differential(project_root: Path, evidence_dir: Path, request_path: Path)
     proven = bool(
         failing_receipt and current_receipt and failing_receipt["exit_code"] != 0
         and current_receipt["exit_code"] == 0 and failure_reason_matched
-        and cleanup_succeeded and project_before == project_after
+        and cleanup_succeeded
     )
     proof = {
         "behavior_id": request["behavior_id"],
@@ -1129,17 +1082,11 @@ def run_differential(project_root: Path, evidence_dir: Path, request_path: Path)
         "differential_request_path": evidence_relative(evidence_dir, request_path),
         "differential_request_sha256": file_sha256(request_path),
         "baseline_commit": request["baseline_commit"],
-        "current_tree_sha256": request["current_tree_sha256"],
         "baseline_execution_id": baseline_receipt["execution_id"] if baseline_receipt else None,
         "mutation_execution_id": mutation_receipt["execution_id"] if mutation_receipt else None,
         "current_execution_id": current_receipt["execution_id"] if current_receipt else None,
         "failure_reason_matched": failure_reason_matched,
         "cleanup_succeeded": cleanup_succeeded,
-        "project_tree_before_sha256": project_before,
-        "project_tree_after_sha256": project_after,
-        "isolation_tree_sha256": isolation_tree,
-        "mutation_apply_sha256": mutation_apply_sha,
-        "mutation_restore_sha256": mutation_restore_sha,
         "not_applicable": None,
     }
     append_proof(evidence_dir, proof)
@@ -1163,7 +1110,6 @@ def run_capture_change(
         "patch_path": evidence_relative(evidence_dir, patch_path),
         "patch_sha256": file_sha256(patch_path),
         "changed_files": status_entries,
-        "source_tree_sha256": tree_sha256(project_root, [evidence_dir]),
     }
     output = confined(evidence_dir, output_name)
     write_json_atomic(output, capture)
@@ -1494,25 +1440,15 @@ def build_manifest(evidence_dir: Path, *, evidence_id: str, identity: dict[str,
     outputs_by_stage = {stage: [] for stage in STAGES}
     for entry in files:
         outputs_by_stage.setdefault(entry["produced_by"], []).append(entry["path"])
-    predecessor_files: list[dict[str, str]] = []
     stages = []
     for stage in STAGES:
         outputs = sorted(outputs_by_stage.get(stage, []))
         stages.append({
             "name": stage,
             "status": "complete",
-            "input_sha256": canonical_sha256({
-                "stage": stage,
-                "target_hashes": target_hashes,
-                "predecessor_outputs": sorted(predecessor_files, key=lambda item: item["path"]),
-            }),
             "outputs": outputs,
             "not_applicable": None,
         })
-        predecessor_files.extend(
-            {"path": output, "sha256": next(item["sha256"] for item in files if item["path"] == output)}
-            for output in outputs if output not in FINAL_RECORDS
-        )
     return {
         "protocol_version": "1.0",
         "evidence_id": evidence_id,
@@ -1641,6 +1577,7 @@ def run_finalize(project_root: Path, evidence_dir: Path, request: dict[str, Any]
         "finalized": False,
         "immutable_identity": identity,
     })
+    # First manifest: pinned before render-report so the report can reference it.
     manifest = build_manifest(
         evidence_dir, evidence_id=evidence_id, identity=identity,
         target_hashes=target_hashes, change_class=change_class,
@@ -1664,6 +1601,7 @@ def run_finalize(project_root: Path, evidence_dir: Path, request: dict[str, Any]
         "validation_path": "validation.json",
         "next": "validate_test_evidence.py --attest",
     })
+    # Second manifest: re-hashes after render-report produces test-report.md.
     manifest = build_manifest(
         evidence_dir, evidence_id=evidence_id, identity=identity,
         target_hashes=target_hashes, change_class=change_class,
@@ -1673,6 +1611,13 @@ def run_finalize(project_root: Path, evidence_dir: Path, request: dict[str, Any]
     destination = evidence_dir.parent / evidence_id
     if destination != evidence_dir:
         if destination.exists():
+            try:
+                existing_man = load_json(destination / "manifest.json")
+                if isinstance(existing_man, dict) and existing_man.get("final_verdict") == "TEST_PASS":
+                    write_handoff_pointer(destination, lifecycle.get("artifact_dir"), project_root)
+                    return destination / output_name
+            except Exception:
+                pass
             raise RequestError(
                 f"evidence identity already exists at {destination}; re-init a new package"
             )
@@ -1796,7 +1741,10 @@ def main() -> int:
     try:
         if not project_root.is_dir():
             raise RequestError(f"project root does not exist: {project_root}")
-        evidence_dir.relative_to(project_root)
+        try:
+            evidence_dir.relative_to(project_root)
+        except ValueError:
+            raise RequestError(f"evidence directory must be under project root: {evidence_dir}")
         if args.subcommand == "init":
             output = run_init(project_root, evidence_dir, args.baseline, args.output)
             print(f"Evidence initialized: {output}")

package/bundled/skills/prizmkit-test/scripts/validate_test_evidence.py

@@ -52,16 +52,6 @@ LIGHTWEIGHT_RECORDS = {"lightweight-verification.json"}
 SHA256_RE = re.compile(r"^[a-f0-9]{64}$")
 UUID_RE = re.compile(r"^[a-f0-9-]{36}$")
 BLOCKED_EXTERNAL_CLASSES = {"production", "unknown"}
-SNAPSHOT_VOLATILE_ROOTS = (
-    ".prizmkit/state",
-    ".prizmkit/test/evidence",
-    ".prizmkit/" + "dev-" + "pipeline",
-    ".claude/worktrees",
-    ".agents/worktrees",
-    ".codebuddy/worktrees",
-    ".codex/worktrees",
-)
-SNAPSHOT_VOLATILE_NAMES = {".git", "__pycache__", ".pytest_cache", ".mypy_cache"}
 RISK_CONFLICT_PATTERNS = {
     "permission": re.compile(r"auth|tenant|role|permission|access|acl|rbac", re.I),
     "concurrency": re.compile(r"lock|shared[ _-]?state|worker|queue|concurr|parallel|race", re.I),
@@ -455,14 +445,6 @@ def validate_external_targets(value: Any, location: str, errors: list[str]) -> N
         require(isinstance(deny_evidence, list) and not deny_evidence, f"{target_location}: external target has deny evidence", errors)
 
 
-def stage_input_sha(stage_name: str, target_hashes: dict[str, str], predecessor_files: list[dict[str, str]]) -> str:
-    return canonical_sha256({
-        "stage": stage_name,
-        "target_hashes": target_hashes,
-        "predecessor_outputs": sorted(predecessor_files, key=lambda item: item["path"]),
-    })
-
-
 def validate_manifest(
     root: Path,
     manifest: dict[str, Any],
@@ -517,7 +499,6 @@ def validate_manifest(
         return entry_map
     names = [stage.get("name") for stage in stages if isinstance(stage, dict)]
     require(names == STAGES, "stages are missing or out of order", errors)
-    predecessor_files: list[dict[str, str]] = []
     for stage in stages:
         if not isinstance(stage, dict):
             continue
@@ -535,13 +516,6 @@ def validate_manifest(
             require(entry is not None, f"stage output is not a hashed evidence file: {name}/{output}", errors)
             if entry is not None:
                 require(entry.get("produced_by") == name, f"stage output producer mismatch: {name}/{output}", errors)
-        if isinstance(name, str) and isinstance(manifest.get("target_hashes"), dict):
-            expected_input = stage_input_sha(name, manifest["target_hashes"], predecessor_files)
-            require(stage.get("input_sha256") == expected_input, f"stage input dependency hash mismatch: {name}", errors)
-        predecessor_files.extend(
-            {"path": output, "sha256": entry_map[output]["sha256"]}
-            for output in outputs if isinstance(outputs, list) and output in entry_map and output not in FINAL_RECORDS
-        )
     return entry_map
 
 
@@ -832,7 +806,6 @@ def validate_requests_and_receipts(
     receipt_by_id: dict[str, dict[str, Any]] = {}
     seen_receipt_paths: set[str] = set()
     attempts_by_request: dict[str, int] = {}
-    previous_receipt: dict[str, Any] | None = None
     for index, receipt in enumerate(executions):
         location = f"executions[{index}]"
         if not isinstance(receipt, dict):
@@ -904,8 +877,6 @@ def validate_requests_and_receipts(
                 errors.append(str(exc))
         seen_receipt_paths.add(recorded_receipt_path)
 
-        expected_previous = canonical_sha256(previous_receipt) if previous_receipt is not None else None
-        require(receipt.get("previous_receipt_sha256") == expected_previous, f"{location}: receipt chain mismatch", errors)
         request_hash = receipt.get("request_sha256")
         if isinstance(request_hash, str):
             attempts_by_request[request_hash] = attempts_by_request.get(request_hash, 0) + 1
@@ -916,7 +887,6 @@ def validate_requests_and_receipts(
             require(previous is not None, f"{location}: replay source is missing", errors)
             if previous is not None:
                 require(previous.get("request_sha256") == request_hash, f"{location}: replay request differs from source", errors)
-        previous_receipt = receipt
 
     receipt_files = {
         path.relative_to(root).as_posix()
@@ -985,11 +955,6 @@ def validate_canonical_capture(
     require(patch_relative == "source-change.patch", "canonical capture patch_path must be source-change.patch", errors)
     if patch is not None:
         require(file_sha256(patch) == capture.get("patch_sha256"), "canonical capture patch hash mismatch", errors)
-    require(
-        capture.get("source_tree_sha256") == tree_sha256(project_root, root),
-        "canonical change capture source tree is stale",
-        errors,
-    )
     captured_paths = {
         item.get("path")
         for item in capture.get("changed_files", [])
@@ -1240,33 +1205,6 @@ def validate_matrix_risks(
                     errors.append(f"TEST_PASS has unresolved behavior risk: {behavior_id}/{risk_name}")
 
 
-def is_volatile_snapshot_path(root: Path, candidate: Path, evidence_root: Path) -> bool:
-    try:
-        relative = candidate.relative_to(root)
-    except ValueError:
-        return True
-    if any(part in SNAPSHOT_VOLATILE_NAMES for part in relative.parts):
-        return True
-    if any(relative == Path(prefix) or Path(prefix) in relative.parents for prefix in SNAPSHOT_VOLATILE_ROOTS):
-        return True
-    resolved = candidate.resolve()
-    excluded = evidence_root.resolve()
-    return resolved == excluded or excluded in resolved.parents
-
-
-def tree_sha256(root: Path, evidence_root: Path) -> str:
-    entries: list[dict[str, str]] = []
-    for candidate in sorted(root.rglob("*")):
-        if not candidate.is_file() or is_volatile_snapshot_path(root, candidate, evidence_root):
-            continue
-        entries.append({"path": candidate.relative_to(root).as_posix(), "sha256": file_sha256(candidate)})
-    return canonical_sha256(entries)
-
-
-def require_sha_or_null(value: Any, location: str, errors: list[str]) -> None:
-    require(value is None or is_sha256(value), f"{location} must be a sha256 or null", errors)
-
-
 def validate_differential_proofs(
     root: Path,
     project_root: Path,
@@ -1283,7 +1221,6 @@ def validate_differential_proofs(
     receipts = {item.get("execution_id"): item for item in executions if isinstance(item.get("execution_id"), str)}
     behavior_ids = {item.get("id") for item in matrix.get("behaviors", []) if isinstance(item, dict)}
     proof_by_behavior: dict[str, dict[str, Any]] = {}
-    live_tree_hash = tree_sha256(project_root, root)
     proofs = proof.get("proofs")
     if not isinstance(proofs, list):
         return
@@ -1300,9 +1237,7 @@ def validate_differential_proofs(
             validate_differential_na(item.get("not_applicable"), f"differential proof {behavior_id} not_applicable", errors)
             for key in (
                 "method", "differential_request_path", "differential_request_sha256", "baseline_commit",
-                "current_tree_sha256", "baseline_execution_id", "mutation_execution_id", "current_execution_id",
-                "project_tree_before_sha256", "project_tree_after_sha256", "isolation_tree_sha256",
-                "mutation_apply_sha256", "mutation_restore_sha256",
+                "baseline_execution_id", "mutation_execution_id", "current_execution_id",
             ):
                 require(item.get(key) is None, f"N/A differential proof must clear {key}: {behavior_id}", errors)
             require(item.get("failure_reason_matched") is False, f"N/A differential proof cannot claim a failure match: {behavior_id}", errors)
@@ -1320,14 +1255,6 @@ def validate_differential_proofs(
         method = item.get("method")
         require(method == request.get("method") and method in {"baseline", "controlled-mutation"}, f"differential method mismatch: {behavior_id}", errors)
         require(item.get("baseline_commit") == request.get("baseline_commit") == manifest.get("baseline_commit"), f"differential baseline commit mismatch: {behavior_id}", errors)
-        require(item.get("current_tree_sha256") == request.get("current_tree_sha256") == live_tree_hash, f"differential current tree hash mismatch: {behavior_id}", errors)
-        for key in (
-            "differential_request_sha256", "current_tree_sha256", "project_tree_before_sha256",
-            "project_tree_after_sha256", "isolation_tree_sha256", "mutation_apply_sha256", "mutation_restore_sha256",
-        ):
-            require_sha_or_null(item.get(key), f"differential proof {behavior_id}.{key}", errors)
-        require(item.get("project_tree_before_sha256") == live_tree_hash, f"differential project tree before mismatch: {behavior_id}", errors)
-        require(item.get("project_tree_after_sha256") == live_tree_hash, f"differential project tree after mismatch: {behavior_id}", errors)
         require(item.get("cleanup_succeeded") is True, f"differential cleanup failed: {behavior_id}", errors)
 
         current = receipts.get(item.get("current_execution_id"))
@@ -1345,10 +1272,8 @@ def validate_differential_proofs(
             require(failing.get("selected_execution") is False and failing.get("reliable") is True and failing.get("exit_code") != 0, f"differential failing side is not a reliable failure: {behavior_id}", errors)
             current_isolation = current.get("isolation")
             failing_isolation = failing.get("isolation")
-            require(isinstance(current_isolation, dict) and current_isolation.get("kind") == "current", f"differential current receipt lacks current isolation: {behavior_id}", errors)
+            require(isinstance(current_isolation, dict) and current_isolation.get("kind") == "project-direct", f"differential current receipt lacks project-direct isolation: {behavior_id}", errors)
             require(isinstance(failing_isolation, dict) and failing_isolation.get("kind") == method, f"differential failing receipt isolation mismatch: {behavior_id}", errors)
-            if isinstance(current_isolation, dict):
-                require(current_isolation.get("tree_sha256") == item.get("isolation_tree_sha256") == live_tree_hash, f"differential current isolation hash mismatch: {behavior_id}", errors)
             if method == "baseline" and isinstance(failing_isolation, dict):
                 require(failing_isolation.get("baseline_commit") == request.get("baseline_commit"), f"baseline receipt commit mismatch: {behavior_id}", errors)
             if method == "controlled-mutation" and isinstance(failing_isolation, dict):
@@ -1358,12 +1283,9 @@ def validate_differential_proofs(
                 if patch_path is not None:
                     patch_hash = file_sha256(patch_path)
                     require(failing_isolation.get("patch_sha256") == patch_hash, f"controlled mutation receipt patch hash mismatch: {behavior_id}", errors)
-                require(item.get("mutation_apply_sha256") == failing_isolation.get("tree_sha256"), f"controlled mutation apply hash mismatch: {behavior_id}", errors)
-                require(item.get("mutation_restore_sha256") == item.get("isolation_tree_sha256"), f"controlled mutation restore hash mismatch: {behavior_id}", errors)
         if method == "baseline":
             require(item.get("mutation_execution_id") is None, f"baseline proof has mutation receipt: {behavior_id}", errors)
             require(request.get("mutation_patch_path") is None, f"baseline request has mutation patch: {behavior_id}", errors)
-            require(item.get("mutation_apply_sha256") is None and item.get("mutation_restore_sha256") is None, f"baseline proof has mutation hashes: {behavior_id}", errors)
         elif method == "controlled-mutation":
             require(item.get("baseline_execution_id") is None, f"mutation proof has baseline receipt: {behavior_id}", errors)
             require(isinstance(request.get("mutation_patch_path"), str) and bool(request.get("mutation_patch_path")), f"mutation request lacks patch: {behavior_id}", errors)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prizmkit",
-  "version": "1.1.135",
+  "version": "1.1.137",
   "description": "Create a new PrizmKit-powered project with clean initialization — no framework dev files, just what you need.",
   "type": "module",
   "bin": {