prizmkit 1.1.135 → 1.1.136

package/bundled/VERSION.json

@@ -1,5 +1,5 @@
 {
-  "frameworkVersion": "1.1.135",
-  "bundledAt": "2026-07-19T07:16:08.201Z",
-  "bundledFrom": "9dfbbdb"
+  "frameworkVersion": "1.1.136",
+  "bundledAt": "2026-07-19T13:33:37.114Z",
+  "bundledFrom": "40a6e49"
 }

package/bundled/skills/_metadata.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.1.135",
+  "version": "1.1.136",
   "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

@@ -180,9 +180,9 @@ 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.
+- Bind proof to runner receipts, baseline commit, mutation apply/restore hashes, and complete cleanup. The builder isolates tests to temporary directories so live-workspace drift cannot interfere with differential execution.
+- Keep source identity separate from evidence integrity: the change capture (patch + changed_files) detects behavior-bearing project drift, while `manifest.json` hashes every evidence file and detects report/output tampering.
+- Completely remove mutations and verify the isolated current copy is unchanged. 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 +206,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, 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.
+
+**Second pass (attestation, with `--attest`):**
 
 ```bash
 python3 ${SKILL_DIR}/scripts/validate_test_evidence.py \
@@ -219,7 +231,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": {
@@ -398,14 +397,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 +445,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", "isolation_tree_sha256", "mutation_apply_sha256", "mutation_restore_sha256", "not_applicable"],
             "properties": {
               "behavior_id": { "type": "string", "minLength": 1 },
               "classification": { "enum": ["PROVEN", "NOT_APPLICABLE", "UNPROVEN"] },
@@ -455,14 +453,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"] },

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.
@@ -138,7 +137,7 @@ For each added or changed necessary behavior test, prove the test:
 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.
 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/current/mutation runner receipt IDs, request hash, baseline commit, isolation hashes, mutation apply/restore hashes, expected failure signal match, and 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 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.
 
 ## Resume and Invalidation
 

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

@@ -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 copies project content into isolated temporary directories for differential execution, hashes each isolated tree via `isolation_tree_sha256`, and records the hashed evidence files in `manifest.json`. 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). Runtime state, evidence output, linked Agent worktrees, Git metadata, and Python bytecode caches are excluded from the isolated copy. The builder does not hash the mutable live project tree during differential execution.
 
 ## Structured N/A
 

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()
@@ -964,14 +941,28 @@ def copy_project_tree(project_root: Path, destination: Path, evidence_dir: Path)
         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]):
+            if any(part in _IGNORED_DIR_NAMES for part in relative.parts):
+                ignored.add(name)
+                continue
+            if any(relative == Path(prefix) or Path(prefix) in relative.parents for prefix in INVENTORY_RESERVED_ROOTS):
+                ignored.add(name)
+            elif (project_root / relative).resolve() == evidence_dir.resolve() or evidence_dir.resolve() in (project_root / relative).resolve().parents:
                 ignored.add(name)
         return ignored
 
     shutil.copytree(project_root, destination, ignore=ignore)
 
 
+def _iso_tree_sha256(root: Path) -> str:
+    """Hash an isolated temp tree (not the live project)."""
+    entries: list[dict[str, str]] = []
+    for candidate in sorted(root.rglob("*")):
+        if not candidate.is_file():
+            continue
+        entries.append({"path": candidate.relative_to(root).as_posix(), "sha256": file_sha256(candidate)})
+    return canonical_sha256(entries)
+
+
 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],
@@ -1024,7 +1015,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 +1025,10 @@ 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,
+            "isolation_tree_sha256": None, "mutation_apply_sha256": None, "mutation_restore_sha256": None,
+            "not_applicable": not_applicable,
         }
         append_proof(evidence_dir, proof)
         return proof
@@ -1056,9 +1047,6 @@ 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
@@ -1072,7 +1060,7 @@ def run_differential(project_root: Path, evidence_dir: Path, request_path: Path)
             temporary_root = Path(temporary)
             current_root = temporary_root / "current"
             copy_project_tree(project_root, current_root, evidence_dir)
-            isolation_tree = tree_sha256(current_root)
+            isolation_tree = _iso_tree_sha256(current_root)
             if request["method"] == "baseline":
                 failing_root = temporary_root / "baseline"
                 git_archive_baseline(project_root, request["baseline_commit"], failing_root)
@@ -1083,7 +1071,7 @@ def run_differential(project_root: Path, evidence_dir: Path, request_path: Path)
                     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"]},
+                    isolation={"kind": "baseline", "tree_sha256": _iso_tree_sha256(failing_root), "baseline_commit": request["baseline_commit"]},
                     selected_execution=False,
                 )
             elif request["method"] == "controlled-mutation":
@@ -1096,22 +1084,25 @@ def run_differential(project_root: Path, evidence_dir: Path, request_path: Path)
                 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_apply_sha = _iso_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)},
+                    isolation={"kind": "controlled-mutation", "tree_sha256": _iso_tree_sha256(failing_root), "patch_sha256": file_sha256(patch_path)},
                     selected_execution=False,
                 )
-                mutation_restore_sha = tree_sha256(current_root)
+                mutation_restore_sha = isolation_tree
             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)},
+                isolation={"kind": "current", "tree_sha256": isolation_tree},
             )
         cleanup_succeeded = True
     finally:
-        project_after = tree_sha256(project_root, [evidence_dir])
+        # tempfile.TemporaryDirectory handles cleanup automatically;
+        # cleanup_succeeded is set above because the context manager exited
+        # without exception, meaning isolation was preserved
+        pass
     failing_receipt = baseline_receipt or mutation_receipt
     failing_output = b""
     if failing_receipt:
@@ -1120,7 +1111,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,14 +1120,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,
@@ -1163,7 +1151,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)
@@ -1641,6 +1628,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 +1652,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 +1662,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 +1792,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),
@@ -985,11 +975,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,29 +1225,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)
 
@@ -1283,7 +1245,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 +1261,8 @@ 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",
+                "isolation_tree_sha256", "mutation_apply_sha256", "mutation_restore_sha256",
             ):
                 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 +1280,10 @@ 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",
+            "differential_request_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"))
@@ -1348,7 +1304,7 @@ def validate_differential_proofs(
             require(isinstance(current_isolation, dict) and current_isolation.get("kind") == "current", f"differential current receipt lacks current 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)
+                require(current_isolation.get("tree_sha256") == item.get("isolation_tree_sha256"), 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):

package/package.json

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