prizmkit 1.1.136 → 1.1.137

package/bundled/VERSION.json

@@ -1,5 +1,5 @@
 {
-  "frameworkVersion": "1.1.136",
-  "bundledAt": "2026-07-19T13:33:37.114Z",
-  "bundledFrom": "40a6e49"
+  "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.136",
+  "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, 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.
+- 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`.
@@ -220,7 +219,7 @@ python3 ${SKILL_DIR}/scripts/validate_test_evidence.py \
   --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.
+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`):**
 

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

@@ -357,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" },
@@ -385,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"] }
       }
@@ -445,7 +444,7 @@
           "items": {
             "type": "object",
             "additionalProperties": false,
-            "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"],
+            "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"] },
@@ -458,9 +457,6 @@
               "current_execution_id": { "type": ["string", "null"] },
               "failure_reason_matched": { "type": "boolean" },
               "cleanup_succeeded": { "type": "boolean" },
-              "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

@@ -41,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
 
@@ -119,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;
@@ -133,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, isolation hashes, mutation apply/restore hashes, expected failure signal match, and 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
 
@@ -168,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, 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.
 
@@ -52,7 +52,7 @@ Record:
 - mutation patch path when applicable;
 - concrete expected failure signals.
 
-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.
+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

@@ -821,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)
 
@@ -900,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",
@@ -927,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,
     }
@@ -935,47 +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
-            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],
-        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)
@@ -1027,7 +981,6 @@ def run_differential(project_root: Path, evidence_dir: Path, request_path: Path)
             "differential_request_sha256": file_sha256(request_path), "baseline_commit": None,
             "baseline_execution_id": None, "mutation_execution_id": None,
             "current_execution_id": None, "failure_reason_matched": False, "cleanup_succeeded": True,
-            "isolation_tree_sha256": None, "mutation_apply_sha256": None, "mutation_restore_sha256": None,
             "not_applicable": not_applicable,
         }
         append_proof(evidence_dir, proof)
@@ -1051,58 +1004,67 @@ def run_differential(project_root: Path, evidence_dir: Path, request_path: Path)
     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 = _iso_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": _iso_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 = _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": _iso_tree_sha256(failing_root), "patch_sha256": file_sha256(patch_path)},
-                    selected_execution=False,
-                )
-                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": isolation_tree},
+        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:
-        # tempfile.TemporaryDirectory handles cleanup automatically;
-        # cleanup_succeeded is set above because the context manager exited
-        # without exception, meaning isolation was preserved
-        pass
+        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:
@@ -1125,9 +1087,6 @@ def run_differential(project_root: Path, evidence_dir: Path, request_path: Path)
         "current_execution_id": current_receipt["execution_id"] if current_receipt else None,
         "failure_reason_matched": failure_reason_matched,
         "cleanup_succeeded": cleanup_succeeded,
-        "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)
@@ -1481,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,

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

@@ -445,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],
@@ -507,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
@@ -525,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
 
 
@@ -822,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):
@@ -894,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
@@ -906,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()
@@ -1225,10 +1205,6 @@ def validate_matrix_risks(
                     errors.append(f"TEST_PASS has unresolved behavior risk: {behavior_id}/{risk_name}")
 
 
-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,
@@ -1262,7 +1238,6 @@ def validate_differential_proofs(
             for key in (
                 "method", "differential_request_path", "differential_request_sha256", "baseline_commit",
                 "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)
@@ -1280,10 +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)
-        for key in (
-            "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("cleanup_succeeded") is True, f"differential cleanup failed: {behavior_id}", errors)
 
         current = receipts.get(item.get("current_execution_id"))
@@ -1301,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"), 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):
@@ -1314,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.136",
+  "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": {