prizmkit 1.1.137 → 1.1.138

package/bundled/skills/prizmkit-test/references/boundary-coverage-protocol.md

@@ -35,7 +35,7 @@ Every risk cell is:
 
 - `applicable`: mapped to one or more actual test IDs and execution IDs;
 - `not_applicable`: a structured decision containing behavior-specific rationale, typed evidence, considered signals, and explanations for every detected conflict;
-- `unresolved`: missing truth, testability, execution, or proof.
+- `unresolved`: missing truth, testability, execution, or evidence.
 
 The model decides applicability from project semantics. The validator checks the structure and obvious signal conflicts only: identity/role/tenant suggests permission risk; locks/shared mutable state/workers suggest concurrency; retry/dedup/idempotency keys suggest idempotency; timeout/TTL/expiry suggests time; clients/contracts/network/storage suggest dependency; callers/consumers/shared contracts suggest consumer risk. A detected signal does not force applicability when the structured conflict explanation and evidence establish why it is irrelevant.
 
@@ -91,7 +91,7 @@ The affected module is complete only when:
 1. every observable behavior is represented;
 2. every applicable risk has tests and reliable execution evidence;
 3. every N/A cell has a concrete rationale;
-4. every necessary new/changed test has differential proof;
+4. every necessary behavior is bound to a selected, reliable current-workspace execution;
 5. complete affected-module regression passes;
 6. Regression Ring verification passes;
 7. no verdict-capable unresolved edge remains;

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

@@ -1,6 +1,6 @@
 # Test Evidence Protocol
 
-This reference is normative for behavior-changing `/prizmkit-test` runs. Structured JSON is authoritative; `test-report.md` is a derived view.
+This reference is normative for behavior-changing `/prizmkit-test` runs. Structured JSON is authoritative; `test-report.md` is a derived view. The protocol validates current-workspace test evidence and does not perform historical baseline or mutation testing.
 
 ## Evidence Target and Identity
 
@@ -14,9 +14,9 @@ Store those values as `evidence_id_inputs` in `manifest.json`. Record separate a
 
 Use two separate integrity domains:
 
-- **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.
+- **Evidence package:** hash each evidence record through `manifest.json`; any report, receipt, raw output, request, or evidence 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.
+Runtime-only churn must not invalidate a source evidence package. Drift in an inventoried source, test, contract, or lockfile must still fail live inventory validation. Never replace a completed package's stable snapshot identity with a later hash of the mutable parent workspace.
 
 Hashes and validator receipts provide byte-level binding and drift detection, not cryptographic non-repudiation. A caller with the same OS permissions can replace the runner, requests, project tree, or package before validation. Preserve runner/request hashes and use replay to improve auditability without claiming resistance to a malicious same-privilege producer.
 
@@ -26,7 +26,7 @@ Hashes and validator receipts provide byte-level binding and drift detection, no
 
 The evidence package is an audit of repository behavior, not a request to invent a parallel test suite. Discover and execute the smallest relevant native tests before adding anything. Add, modify, or delete tests only in the target repository. The builder's `prepare-tests` command derives stable test IDs and change status from canonical Git capture, and snapshots only added or modified repository-native tests. `generated-tests/` is an evidence archive, never an execution workspace; it may be empty when existing tests cover the behavior.
 
-The canonical package lifecycle is `init → capture-change → inventory → prepare-tests → execute/differential → finalize → render-report → validate --attest → resume`. Builder commands own `source-change.patch`, native test preparation, receipts, raw outputs, manifest, verdict, and report. The validator alone owns `validation.json`. Inventory must consume a fresh capture and exactly preserve its complete changed-file set. Canonical behavior packages require a schema-valid `test-preparation.json` bound byte-for-byte to the builder-generated `test-plan.json` and its hashed semantic request. Evidence identity is derived from the resolved baseline, canonical patch hash, and scope hash; identity-changing resume creates a new package instead of rewriting the old directory.
+The canonical package lifecycle is `init → capture-change → inventory → prepare-tests → execute → finalize → render-report → validate --attest → resume`. Builder commands own `source-change.patch`, native test preparation, receipts, raw outputs, manifest, verdict, and report. The validator alone owns `validation.json`. Inventory must consume a fresh capture and exactly preserve its complete changed-file set. Canonical behavior packages require a schema-valid `test-preparation.json` bound byte-for-byte to the builder-generated `test-plan.json` and its hashed semantic request. Evidence identity is derived from the resolved baseline, canonical patch hash, and scope hash; identity-changing resume creates a new package instead of rewriting the old directory.
 
 
 Run exactly these states in order:
@@ -131,13 +131,13 @@ Only omit plan-marked non-required layers. Every N/A is structured with rational
 
 Do not overwrite failed or superseded attempts. Do not retry until green. Use a bounded documented recovery attempt; required flakiness, unavailable infrastructure, unreliable execution, or cleanup failure is `TEST_BLOCKED`.
 
-For each added or changed necessary behavior test, prove the test:
+For each necessary behavior, validate the current implementation directly in the project root:
 
-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`.
+1. Execute the planned project-native tests for the behavior and its required layer.
+2. Bind the behavior risk to selected, reliable execution receipts and preserve complete raw output.
+3. Treat a current-state pass as valid evidence; this protocol does not claim historical baseline failure or mutation sensitivity.
 
-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`.
+TDD history, baseline-failure proof, and mutation testing are outside this skill. Missing behavior mappings, unreliable execution, unavailable infrastructure, or budget truncation prevents `TEST_PASS`.
 
 ### EVIDENCE_PACKAGE
 
@@ -185,7 +185,7 @@ Stages are idempotent with respect to the same canonical inputs. Never silently
 
 ## Terminal Semantics
 
-- `TEST_PASS`: all required behavior/risk cells and Regression Ring checks are proven, all required executions are reliable and successful, no verdict-capable unresolved edge remains, cleanup succeeds, code-level requests remain replayable, and deterministic validation passes. This is protocol-validated code-level evidence, not a mathematical proof that no business behavior was omitted.
+- `TEST_PASS`: all required behavior/risk cells and Regression Ring checks are covered, all required executions are reliable and successful, no verdict-capable unresolved edge remains, code-level requests remain replayable, and deterministic validation passes. This is protocol-validated code-level evidence, not a mathematical proof that no business behavior was omitted.
 - `TEST_FAIL`: valid reliable evidence reproduces an implementation or resolved-contract failure. The package must remain complete enough to prove the failure.
 - `TEST_BLOCKED`: scope/truth uncertainty, unavailable execution, necessary flakiness, incomplete evidence, failed cleanup, budget truncation, unproven behavior, conflicting truth, or deterministic validation failure.
 

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

@@ -1,17 +1,17 @@
 # Evidence Request Protocol
 
-Load this reference when writing an inventory, execution, differential, resume, or replay request. Validate every authoritative record against `${SKILL_DIR}/assets/authoritative-records.schema.json`; the validator loads the named `$defs` for each file.
+Load this reference when writing an inventory, execution, resume, or replay request. Validate every authoritative record against `${SKILL_DIR}/assets/authoritative-records.schema.json`; the validator loads the named `$defs` for each file.
 
 ## Canonical Lifecycle Ownership
 
 Start every new package with `init`, then run builder-owned `capture-change` before semantic inventory. `capture-change` is the only producer of `source-change.patch`; it records tracked, untracked, deleted, renamed, and copied paths against the resolved baseline. The Main Agent must not create or edit the patch.
 
-Use existing project-native tests first. The Main Agent supplies only semantic test paths, behavior mappings, selectors, runner hints, and layer decisions. Run `prepare-tests` after inventory: it derives stable file/test-unit IDs and existing/added/modified status from canonical capture, snapshots added/modified repository tests, and writes normalized `test-plan.json`. The Main Agent must not hand-author IDs, status, snapshot paths, hashes, or receipt fields. Inventory `changed_files` must exactly match the fresh canonical capture, and every live captured path must be inventoried or explicitly excluded. Execution requests may use `test_paths`, `auto_bind: true`, or legacy IDs; `auto_bind` resolves only recognized package-wide commands or explicit file/directory/glob command scope, while ambiguous commands must provide `test_paths`. The builder records canonical test IDs before running. Every changed native test must be bound, and package-wide commands must not silently hide added or modified tests.
+Use existing project-native tests first. The Main Agent supplies only semantic test paths, behavior mappings, selectors, runner hints, and layer decisions. Run `prepare-tests` after inventory: it derives stable file/test-unit IDs and existing/added/modified status from canonical capture, snapshots added/modified repository tests, and writes normalized `test-plan.json`. The Main Agent must not hand-author IDs, status, snapshot paths, hashes, or receipt fields. Inventory `changed_files` must exactly match the fresh canonical capture, and every live captured path must be inventoried or explicitly excluded. Each execution request must use exactly one binding mode: `test_ids`, `test_paths`, or `auto_bind: true`. The builder recomputes command scope; explicit declarations must exactly match it, opaque commands are blocked, recognized package-wide commands cover all prepared tests, and verified requests persist canonical `test_ids` only. Every changed native test must be bound.
 
 `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, worktree-based isolation, 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, current-workspace execution 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.
 
@@ -35,28 +35,22 @@ Use an argv array so the runner does not interpret a shell string. Required fiel
 - `request_version`, `purpose`, `command`, `cwd`;
 - environment additions (the runner starts from a minimal runtime environment and the receipt records every effective value);
 - model-selected `tool_version_commands`;
-- selected `layer` and semantic `test_ids`;
+- selected `layer` and exactly one canonical binding (`test_ids`, `test_paths`, or `auto_bind: true`);
 - structured `external_targets`.
 
 Optional `timeout_seconds`, `attempt_policy`, and `concurrency` remain model-chosen. The builder records them through request binding but does not invent values or silently retry.
 
 The request path must be beneath the evidence directory. `cwd` resolves beneath the selected execution root. Missing commands produce an actual exit 127 receipt; missing cwd or escaped paths block before execution.
 
-## Differential Request
+## Execution Evidence
 
-Record:
+Execute each required native test layer through `build_test_evidence.py execute` in the target project root. The request supplies the project-native argv, cwd, environment additions, tool probes, layer, test binding, timeout, and external-target classification. The builder records the actual process result, complete environment, raw output, hashes, and runner-generated receipt. No historical checkout, mutation patch, test overlay, or separate worktree is created.
 
-- behavior ID and model-selected `baseline` or `controlled-mutation` method;
-- the nested execution request;
-- actual baseline commit;
-- mutation patch path when applicable;
-- concrete expected failure signals.
-
-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).
+Source drift between capture and validation is detected by independently recomputing the complete canonical Git change (including tracked, untracked, deleted, renamed, and copied paths while excluding reserved runtime roots) and comparing both patch hash and changed-file entries.
 
 ## Structured N/A
 
-Use the same structure for omitted layers, not-applicable risk cells, stage N/A, and proof N/A:
+Use the same structure for omitted layers, not-applicable risk cells, and stage N/A:
 
 - `rationale`: behavior-specific reasoning;
 - `evidence`: one or more typed discovery records;
@@ -75,8 +69,6 @@ The model retains semantic judgment. The deterministic validator checks shape an
 | `test-plan.json` | `testPlan` |
 | `requests/*.execution.json` | `executionRequest` |
 | receipt entries in `executions.json` | `executionReceipt` / `executionLog` |
-| `requests/*differential*.json` | `differentialRequest` |
-| `differential-proof.json` | `differentialProof` |
 | `infrastructure-changes.json` | `infrastructureChanges` |
 | `verdict.json` | `verdict` |
 | `validation.json` | `validation` |

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

@@ -35,7 +35,7 @@ A queue worker retry change touches a legacy worker with one happy-path test. Ch
 
 `TEST_BUILD` fills observable gaps across the module, not unrelated private utility lines. It adds deterministic fake-clock and contract-backed queue tests for retry just below/at/above maximum, duplicate delivery, malformed payload, lock failure, no partial side effect, ack/nack calls, and dead-letter transition. Regression Ring runs the scheduler and producer contract checks. Coverage percentage is recorded only as a diagnostic signal.
 
-The run cannot pass until every applicable behavior-risk cell and Regression Ring execution is mapped and proven.
+The run cannot pass until every applicable behavior-risk cell and Regression Ring execution is mapped and covered by reliable current-workspace execution.
 
 ## 3. Contract-Coupled Modules — Contract-Driven Mocks
 
@@ -69,11 +69,9 @@ Blocker: verdict-capable unresolved edge or conflicting truth
 Evidence: .prizmkit/test/evidence/<evidence-id>/
 ```
 
-## 6. Baseline Inapplicable — Controlled Mutation
+## 6. Current-State New Behavior
 
-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`.
+A newly added CLI command has no pre-change interface, so the skill adds a focused native command test and runs it against the current project implementation. The test passes, its behavior-risk and test-plan mappings are complete, and the runner receipt and raw output are preserved. The evidence claims current code-level conformance; it does not claim that the test failed on a historical implementation.
 
 ## 7. Interrupted or Budgeted Run
 

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

@@ -17,7 +17,7 @@ Before writing tests:
 
 1. Inspect manifests, lockfiles, existing test files, runner configuration, scripts, fixtures, and CI commands.
 2. Select the existing adequate runner and naming/import/mock conventions.
-3. Let the target project's semantics determine framework, argv, cwd, timeout, attempts, concurrency, Mock tooling, layers, module roots, inventory patterns, and mutation technology; do not import fixed ecosystem defaults from this skill.
+3. Let the target project's semantics determine framework, argv, cwd, timeout, attempts, concurrency, Mock tooling, layers, module roots, inventory patterns; do not import fixed ecosystem defaults from this skill.
 4. If no adequate infrastructure exists, add only the smallest project-native runner/config/dependencies required for the planned layers.
 5. Verify dependency versions against the package registry before writing manifests.
 6. Record every file/dependency/command change and verification in `infrastructure-changes.json`.
@@ -95,17 +95,17 @@ Distinguish:
 
 Never retry until green or silently weaken an assertion/scope.
 
-## Execution and Differential Proof
+## Current-State Execution Evidence
 
 Run selected tests in order through the bundled evidence builder: focused, module/component, contract/integration, affected-module regression, Regression Ring. The model writes schema-shaped requests; the builder performs the process and appends immutable runner-generated receipts to `executions.json`.
 
 For each new/changed necessary behavior test:
 
-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.
+1. Execute each required layer in order through the builder in the target project root.
+2. Preserve runner-generated receipts and complete stdout/stderr for every selected execution.
+3. Bind each applicable behavior risk to planned tests and selected execution IDs.
+4. Do not create historical checkouts, controlled mutations, or worktrees; current-state conformance is the testing-domain claim.
 
-Necessary `UNPROVEN` evidence blocks. Store complete stdout/stderr in `raw/`; snapshots in `generated-tests/`; do not overwrite previous attempts.
 
 ## Completion Check
 
@@ -114,7 +114,5 @@ Before packaging:
 - no applicable matrix cell lacks test/execution mapping;
 - all required planned layers have reliable selected executions in order;
 - affected-module and Regression Ring regressions are complete;
-- every new/changed necessary behavior has valid differential proof;
-- every isolated resource/mutation is cleaned up;
 - no verdict-capable unresolved edge remains for pass;
 - budgeted/staged work is complete, otherwise `TEST_BLOCKED`.

package/bundled/skills/prizmkit-test/references/test-report-template.md

@@ -11,7 +11,6 @@ Derived from structured evidence. Authoritative package: `{evidence_dir}`
 - Evidence ID: {64-character evidence_id}
 - Protocol Version: {protocol_version}
 - Classification: {behavior / lightweight}
-- Baseline Commit: {baseline_commit}
 - Working Diff SHA-256: {working_diff_sha256}
 - Sensitivity: sensitivity=project-controlled
 - Environment Claim: mocked-code-level-only
@@ -48,13 +47,11 @@ Mocked code-level evidence does not verify a real deployed environment.
 - Infrastructure Changes: `infrastructure-changes.json`
 - Contract Snapshots: `contracts/`
 - Production Resources Used: no
-- Cleanup Succeeded: {yes/no}
 
-## Differential Proof
-- PROVEN: {count}
-- NOT_APPLICABLE: {count with rationale pointers}
-- UNPROVEN: {count}
-- Proof Record: `differential-proof.json`
+## Current-State Execution Evidence
+
+- Selected Receipts: {execution_receipts}
+- Evidence: `executions.json`, `receipts/`, and `raw/`
 
 ## Executions
 - Attempts Preserved: {count}

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

@@ -11,8 +11,8 @@ Inspect the target project and choose these semantically:
 - native test framework, runner, command, flags, and working directory;
 - timeout, attempt/retry policy, concurrency, resource limits, and isolation strategy;
 - unit/module/contract/integration/code-level E2E layers;
-- fixture, fake, Mock, service-double, browser, database, and mutation technology;
-- module roots, public behavior boundary, inventory patterns, exclusions, Regression Ring, and differential method;
+- fixture, fake, Mock, service-double, browser, and database technology;
+- module roots, public behavior boundary, inventory patterns, exclusions, and Regression Ring;
 - environment classification and endpoint allow/deny evidence.
 
 The protocol does not prescribe Jest, pytest, a timeout number, a retry count, coverage threshold, runner flag, or mutation package. Record the reason for each choice in request and planning records.
@@ -29,7 +29,7 @@ The protocol fixes only what trustworthy, replayable packaging needs:
 - complete effective environment and tool-probe capture;
 - runner-generated UUID receipt, request hash, and runner hash;
 - append-only execution history;
-- differential isolation via git worktree and cleanup;
+- direct current-workspace native execution with runner receipts;
 - deterministic resume invalidation calculation;
 - strict schema and cross-record validation.
 
@@ -48,7 +48,6 @@ python3 ${SKILL_DIR}/scripts/build_test_evidence.py --project-root <root> --evid
 python3 ${SKILL_DIR}/scripts/build_test_evidence.py --project-root <root> --evidence-dir <staging> capture-change
 python3 ${SKILL_DIR}/scripts/build_test_evidence.py --project-root <root> --evidence-dir <staging> inventory --request requests/inventory.json
 python3 ${SKILL_DIR}/scripts/build_test_evidence.py --project-root <root> --evidence-dir <staging> execute --request requests/focused.json
-python3 ${SKILL_DIR}/scripts/build_test_evidence.py --project-root <root> --evidence-dir <staging> differential --request requests/differential.json
 python3 ${SKILL_DIR}/scripts/build_test_evidence.py --project-root <root> --evidence-dir <staging> finalize --request requests/finalize.json
 python3 ${SKILL_DIR}/scripts/build_test_evidence.py --project-root <root> --evidence-dir <staging> render-report
 ```
@@ -72,7 +71,7 @@ python3 ${SKILL_DIR}/scripts/build_test_evidence.py \
 python3 ${SKILL_DIR}/scripts/build_test_evidence.py \
   --project-root <target-project-root> \
   --evidence-dir <evidence-dir> \
-  differential --request requests/differential.json
+  execute --request requests/focused.json
 
 python3 ${SKILL_DIR}/scripts/build_test_evidence.py \
   --project-root <target-project-root> \
@@ -83,8 +82,7 @@ python3 ${SKILL_DIR}/scripts/build_test_evidence.py \
 The subcommands cover fixed mechanics only:
 
 - `inventory`: expand model-selected project-relative patterns, independently enumerate all actual files under each declared module root, reject files that are neither categorized nor structurally excluded, hash actual files, and bind discovery inputs;
-- `execute`: run the declared argv in the declared safe cwd and append a runner-generated receipt;
-- `differential`: execute baseline or controlled-mutation proof in isolated copies and verify cleanup/tree binding;
+- `execute`: run the declared native command in the current project workspace and append a runner-generated receipt;
 - `resume`: compare hashes and stage outputs to compute an invalidation decision while retaining `semantic_review_required=true`.
 
 ## Replay