prizmkit 1.1.120 → 1.1.121

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

@@ -0,0 +1,194 @@
+# Test Evidence Protocol
+
+This reference is normative for behavior-changing `/prizmkit-test` runs. Structured JSON is authoritative; `test-report.md` is a derived view.
+
+## Evidence Target and Identity
+
+Write packages under `.prizmkit/test/evidence/<evidence-id>/`. Compute `evidence-id` as lowercase SHA-256 of canonical, key-sorted, compact JSON containing exactly:
+
+- `baseline_commit`
+- `working_diff_sha256`
+- `scope_sha256`
+
+Store those values as `evidence_id_inputs` in `manifest.json`. Record separate aggregate hashes for source, tests, contracts, lockfiles, full environment values, and plan inputs. Hash every evidence file except `manifest.json` in the manifest; do not create a self-referential manifest hash.
+
+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.
+
+`source-change.patch` preserves the complete target diff. Snapshot generated/changed tests under `generated-tests/`, contracts under `contracts/`, and raw stdout/stderr under `raw/`. Never replace old execution/output records.
+
+## Ordered State Machine
+
+Run exactly these states in order:
+
+1. `CHANGE_CLASSIFY`
+2. `SCOPE_DISCOVER`
+3. `CONTRACT_MODEL`
+4. `TEST_PLAN`
+5. `INFRA_READY`
+6. `TEST_BUILD`
+7. `EXECUTE_PROVE`
+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.
+
+### CHANGE_CLASSIFY
+
+Classify `behavior` when executable behavior can change through code, runtime configuration, schemas, migrations, generated runtime assets, lockfiles, or dependency changes. Classify `lightweight` only when the scope is exclusively documentation, comments, or formatting with no generated/runtime behavior effect.
+
+For lightweight changes, record deterministic checks such as patch classification, parser/format validation, and generated-output consistency. Mark behavior-only stages not applicable with rationale. `TEST_PASS` then means only that the lightweight claim was proven; never describe it as complete runtime behavior evidence.
+
+Unknown or mixed classification enters the full protocol; unresolved classification becomes `TEST_BLOCKED`.
+
+### SCOPE_DISCOVER
+
+Record:
+
+- Affected module: explicit module boundary or cohesion-derived files that jointly express one observable responsibility.
+- Primary Scope: every public behavior of the affected module, not only changed lines.
+- Regression Ring: directly affected callers, consumers, shared contracts, and state dependencies.
+- Unresolved Edges: dynamic loading, reflection, generated clients, runtime registration, remote contracts, or coupling that cannot be proven statically.
+
+Record changed files, declared module roots, contract/lockfile/test discovery, evidence-backed exclusions, and Regression Ring mappings in both scope and inventory records. Every changed file must be inventoried or explicitly excluded. The deterministic validator checks these declared relationships and obvious omissions, but inventory cannot prove that the model discovered every semantic behavior or dynamic edge.
+
+Every edge records whether it can change the verdict. A verdict-capable unresolved edge prevents `TEST_PASS`.
+
+### CONTRACT_MODEL
+
+Resolve expected truth in this order:
+
+1. specifications;
+2. machine-readable contracts;
+3. acceptance conditions;
+4. existing trusted tests;
+5. callers/consumers;
+6. current implementation.
+
+Record conflicts rather than silently characterizing current behavior. If higher-precedence sources conflict and cannot be resolved, issue `TEST_BLOCKED`.
+
+Populate `behavior-risk-matrix.json` using `assets/behavior-risk-matrix.schema.json`. Enumerate observable behavior, preconditions, input classes and boundary values, outputs, side effects, state transitions, errors, and every functional, boundary, permission, concurrency, idempotency, time, dependency, and consumer risk. Every risk is applicable, not applicable with concrete rationale, or unresolved.
+
+Coverage percentages are diagnostic omission signals. They can prompt another matrix review but cannot prove or replace behavior-risk completeness.
+
+### TEST_PLAN
+
+Assess all test layers:
+
+1. `focused`
+2. `module-component`
+3. `contract-integration`
+4. `affected-module-regression`
+5. `regression-ring`
+
+Choose unit, module/component, contract, integration, and code-level E2E tests from actual risk. Do not require every test type mechanically. Every omitted layer needs a concrete not-applicable rationale. If a necessary layer cannot be executed within the configured budget, persist progress and issue `TEST_BLOCKED` until complete.
+
+### INFRA_READY
+
+Discover manifests, existing tests, commands, runner configuration, fixtures, and conventions before changing infrastructure. Reuse an adequate native runner. Install only necessary dependencies after registry/version verification. Create only required configuration, fixtures, fakes, contract-backed mock servers, or isolated services. Never delete existing tests.
+
+Record every infrastructure change, command, verification, and cleanup responsibility in `infrastructure-changes.json`. Production credentials, production databases, production APIs, and destructive real-data operations are prohibited.
+
+### TEST_BUILD
+
+Fill the whole affected module's observable gaps: public behavior, contracts, boundaries, invariants, failure paths, state transitions, and coupling risks. Do not stop after the changed happy path and do not mechanically exercise unrelated private lines.
+
+When code has no controllable seam, the test work may make the minimum behavior-preserving production refactor needed for dependency injection, pure-function extraction, adapters, or controllable state. Record the patch and behavior-preservation check. If a public production contract would need to change, stop with `TEST_BLOCKED`.
+
+A valid test that exposes a business/contract defect is evidence for `TEST_FAIL`. Do not repair the business defect inside this skill.
+
+### EXECUTE_PROVE
+
+Run progressively:
+
+1. focused tests;
+2. module/component tests;
+3. contract/integration tests;
+4. complete affected-module regression;
+5. Regression Ring verification.
+
+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;
+- unique selected execution identifier;
+- layer and exact argv;
+- confined working directory;
+- complete effective environment key/value map used by the command;
+- tool/runtime probe results;
+- integer exit code (booleans are invalid);
+- paths and hashes for complete stdout and stderr;
+- reliability/flakiness classification.
+
+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:
+
+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.
+3. Record `PROVEN`, justified `NOT_APPLICABLE`, or `UNPROVEN`.
+
+Record baseline/current/mutation runner receipt IDs, request hash, baseline commit, current and isolation tree hashes, mutation apply/restore hashes, expected failure signal match, and original-tree cleanup result. Necessary `UNPROVEN` behavior prevents `TEST_PASS`.
+
+### EVIDENCE_PACKAGE
+
+Create the complete package from `assets/evidence-package-template.json`, then hash its records. Set:
+
+- `sensitivity=project-controlled`
+- `environment_claim=mocked-code-level-only`
+- `compatibility=legacy-test-report-interface-not-supported`
+
+Preserve complete commands, environment values, stdout, stderr, patches, hashes, and history without automatic redaction. The project owns access control, retention, and upload policy. This does not permit production secrets or services.
+
+Generate `test-report.md` solely from structured records. Regeneration must produce the same evidence pointers and verdict. The report is not independently editable authority.
+
+Prepare `verdict.json` and the derived report, then let the validator finalize the non-circular attestation. Callers must not predeclare validator success as evidence.
+
+### EVIDENCE_VALIDATE
+
+Run:
+
+```bash
+python3 ${SKILL_DIR}/scripts/validate_test_evidence.py \
+  --evidence-dir .prizmkit/test/evidence/<evidence-id> \
+  --project-root <target-project-root> \
+  --attest
+```
+
+`--attest` first validates the immutable payload while excluding only the final attestation/view records, atomically writes `validation.json`, refreshes final file hashes, then immediately performs a complete second validation. Subsequent checks omit `--attest` and verify the stored attestation. This avoids trusting a caller-authored `passed` marker or creating a self-referential manifest. The attestation proves package integrity and protocol consistency only; it is not proof against a same-permission producer.
+
+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.
+
+## Resume and Invalidation
+
+On invocation for an existing evidence target:
+
+1. Validate manifest identity and every recorded file hash.
+2. Recompute source, tests, contracts, lockfiles, environment, and plan target hashes.
+3. Find the first stage whose input hash or output is invalid.
+4. Preserve all prior executions and raw outputs immutably.
+5. Invalidate that stage and every downstream stage; do not reuse their verdict claims.
+6. Resume from the first invalid stage and write new execution identifiers.
+
+Stages are idempotent with respect to the same canonical inputs. Never silently truncate a large module. Persist matrix progress and return `TEST_BLOCKED` until every necessary behavior and Regression Ring cell is complete.
+
+## 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_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.
+
+No conditional pass exists.
+
+## Responsibility Boundary
+
+Return only the testing-domain verdict and evidence pointers. Do not:
+
+- embed an independent AI reviewer or adversarial PASS judge;
+- decide overall code quality;
+- claim broad Spec compliance beyond tested contracts;
+- repair a business defect exposed by a valid test;
+- authorize commit, release, or deployment;
+- claim mocked code-level evidence validates a deployed test or production environment.
+
+The legacy report/verdict interface is intentionally unsupported. Do not migrate Pipeline or other Skill consumers and do not add a compatibility layer in this change.

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

@@ -0,0 +1,78 @@
+# 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.
+
+## Request Ownership
+
+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.
+
+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.
+
+## Inventory Request
+
+Place a request under `requests/` with:
+
+- `request_version: "1.0"`;
+- `categories`: project-relative glob arrays for source, tests, contracts, and lockfiles;
+- nonempty `changed_files` and declared `module_roots`;
+- structured `exclusions`, each with path, rationale, and discovery evidence;
+- `discovery_evidence` for manifests, runner configuration, filesystem discovery, contracts, lockfiles, and boundary analysis;
+- nonempty `plan_inputs` carrying the semantic planning inputs whose hash controls resume.
+
+An empty inventory is not evidence of an empty module. Ensure every changed file exists and is either inventoried or explicitly excluded with evidence. The builder independently enumerates every actual file under each model-declared module root; every enumerated file must appear in one inventory category or a structured exclusion. This does not decide whether the model selected the right semantic module boundary, but it prevents silent omission after that boundary is declared.
+
+## Execution Request
+
+Use an argv array so the runner does not interpret a shell string. Required fields are:
+
+- `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`;
+- 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
+
+Record:
+
+- behavior ID and model-selected `baseline` or `controlled-mutation` method;
+- the nested execution request;
+- actual baseline commit and current project-tree hash;
+- mutation patch path when applicable;
+- concrete expected failure signals.
+
+The builder creates isolated copies, executes the failing and current sides, records receipts, binds the differential request hash, and verifies that the original project tree is unchanged. A proof is `PROVEN` only when the intended failure signal appears, the failing side exits nonzero, current exits zero, and cleanup/tree checks pass.
+
+## Structured N/A
+
+Use the same structure for omitted layers, not-applicable risk cells, stage N/A, and proof N/A:
+
+- `rationale`: behavior-specific reasoning;
+- `evidence`: one or more typed discovery records;
+- `considered_signals`: signals examined before deciding N/A;
+- `conflicts`: every detected contradictory signal plus an explanation.
+
+The model retains semantic judgment. The deterministic validator checks shape and obvious signal conflicts only. For example, auth/tenant/role signals conflict with permission N/A; lock/shared-state/worker signals conflict with concurrency N/A; retry/idempotency/dedup signals conflict with idempotency N/A; timeout/TTL/expiry signals conflict with time N/A; clients/contracts/network signals conflict with dependency N/A; callers/consumers/shared-contract mappings conflict with consumer N/A. A conflict can be accepted only when explicitly recorded and explained.
+
+## Record-to-Schema Map
+
+| Authoritative record | Schema definition |
+|---|---|
+| `change-classification.json` | `changeClassification` |
+| `scope.json` | `scope` |
+| `target-inventory.json` | `targetInventory` |
+| `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` |
+| `lightweight-verification.json` | `lightweightVerification` |
+
+`manifest.json` and `behavior-risk-matrix.json` retain their dedicated schemas. All schemas reject unknown fields where the protocol owns the record.

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

@@ -1,145 +1,102 @@
-# Test Examples
+# Test Evidence Examples
 
-## Example 1: Full-Project Quality Check with Test Generation
+## 1. Normally Tested Module Change — TEST_PASS
 
-**User**: `/prizmkit-test`
+Input:
 
-**Phase 0 — Architecture Detection**:
-```
-Detected: Fullstack (React + Express)
-Test framework: Vitest (7 existing test files)
+```text
+/prizmkit-test scope=this-change artifact_dir=<change-artifact>
 ```
 
-**Phase 1 — Scope Selection** (user selects option 1):
-```
-Scope: Full project (all modules, all specs)
-```
+A library parser changes one accepted input form. Scope discovery selects the complete parser module and two direct consumers. Existing module tests already cover most behaviors.
 
-**Phase 2 — Existing Tests**: 7 test files found, 20 tests run, 18 passed, 2 pre-existing failures (recorded, not fixed).
+The run:
 
-**Phase 3 — Gap Analysis** (excerpt):
-| Module | Interface | Type | Status |
-|--------|-----------|------|--------|
-| auth | login() | unit | missing |
-| auth | register() | unit | missing |
-| payment | processPayment() | unit | missing |
-| payment | api/checkout | integration | missing |
-| — | Checkout flow | e2e | missing |
+1. Classifies `behavior`.
+2. Adds the changed parser behavior plus existing observable parser behavior to the matrix.
+3. Selects focused, affected-module regression, and Regression Ring layers; module-component and contract-integration are N/A with concrete pure-library rationale.
+4. Adds missing malformed-input and consumer-shape tests.
+5. Proves changed tests fail on baseline and pass currently.
+6. Packages all command/environment/output history.
+7. Deterministically validates.
 
-**Phase 4 — Boundary Matrix** (excerpt):
-| Module | Interface | Service Type | Happy Path | Request Validation | Auth / Permission / Ownership | Domain Invariants | Dependency Failure | Final Status |
-|--------|-----------|--------------|------------|--------------------|-------------------------------|-------------------|-------------------|--------------|
-| auth | login() | Auth / Session | covered | boundary-missing | boundary-missing | skipped | boundary-missing | boundary-missing |
-| payment | processPayment() | Payment / Billing | covered | boundary-missing | boundary-missing | boundary-missing | boundary-missing | boundary-missing |
+Handoff:
 
-**Phase 5**: Generated 5 unit boundary tests (3 passing, 2 assertion failures marked `needs-review`), 1 integration boundary test (passing), 1 E2E test (passing).
-
-**Phase 6 — Report Summary**:
-```
-Generated: 5 unit (2 needs-review), 1 integration, 1 E2E
-Boundary gate: failed — 2 interfaces need human review
-Report: .prizmkit/test/2026_05_23_14_30_00_testresult/test-report.md
-Needs human review: processPayment (returns 400 for negative amounts, expected 422), refund (missing authorization header causes 500 instead of 401)
+```text
+TEST_PASS
+Evidence: .prizmkit/test/evidence/<evidence-id>/
+Validator: passed
+Mocked code-level evidence does not verify a real deployed environment.
 ```
 
-## Example 2: Single Feature/Spec Targeted Test
+## 2. Incompletely Tested Legacy Module — Whole-Module Gap Filling
 
-This is an interactive selection of one existing spec directory. It is different from headless `scope=this-change`, which is driven by a current change artifact plus changed files.
+A queue worker retry change touches a legacy worker with one happy-path test. Changed lines identify the module, but Primary Scope includes parsing, claim, processing, retry, dead-letter, acknowledgment, idempotency, and dependency-failure behavior.
 
-**User**: `/prizmkit-test`
+`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.
 
-**Phase 0 — Architecture Detection**:
-```
-Detected: Backend (Express)
-Test framework: Vitest
-```
+The run cannot pass until every applicable behavior-risk cell and Regression Ring execution is mapped and proven.
 
-**Phase 1 — Scope Selection** (user selects option 3, then picks "042-payment-gateway"):
-```
-Scope: Single feature — 042-payment-gateway
-Test files in scope: 2
-```
+## 3. Contract-Coupled Modules — Contract-Driven Mocks
 
-**Phase 2 — Existing Tests**: 2 test files, 8 tests, all passing.
+An API client and consumer share OpenAPI. The run snapshots the OpenAPI document into `contracts/`, records its source/hash, and generates mock responses for success, schema error, 429, timeout, malformed body, and pagination token boundaries.
 
-**Phase 3 — Gap Analysis** (excerpt):
-| Module | Interface | Type | Status |
-|--------|-----------|------|--------|
-| payment | processPayment() | unit | boundary-missing |
-| payment | refund() | unit | boundary-missing |
+The mock is rejected if it invents an incompatible field or cannot trace behavior to the contract. Contract and consumer executions pass, and the report states `environment_claim=mocked-code-level-only`; it makes no claim about a deployed SaaS environment.
 
-**Phase 4 — Boundary Matrix**:
-| Module | Interface | Service Type | Happy Path | Request Validation | Auth / Permission / Ownership | Domain Invariants | State Transitions | Dependency Failure | Final Status |
-|--------|-----------|--------------|------------|--------------------|-------------------------------|-------------------|-------------------|-------------------|--------------|
-| payment | processPayment() | Payment / Billing | covered | boundary-missing | boundary-missing | boundary-missing | generated | boundary-missing | boundary-missing |
-| payment | refund() | Payment / Refund | covered | boundary-missing | boundary-missing | boundary-missing | boundary-missing | skipped — provider sandbox unavailable | boundary-missing |
+## 4. Reliable Business Defect — TEST_FAIL
 
-**Phase 5**: Generated 8 unit tests covering amount boundaries, currency mismatch, missing entitlement, duplicate idempotency key, partial refund, full refund, over-refund, and repository failure. All passing.
+Resolved specification and OpenAPI require a negative amount to return a validation error without a write. A generated contract test reliably observes success plus a database-adapter call.
 
-**Phase 6 — Report Summary**:
-```
-Generated: 8 unit tests (all passing)
-Boundary gate: passed
-Report: .prizmkit/test/2026_05_23_15_00_00_testresult/test-report.md
-All tests passing and boundary coverage complete. Ready for commit.
+The test is valid, current and affected-module executions reproduce the failure, and raw output is preserved. `/prizmkit-test` does not change production business behavior. It packages:
+
+```text
+TEST_FAIL
+Reproduced failure: amount-boundary-negative
+Evidence: .prizmkit/test/evidence/<evidence-id>/
 ```
 
-## Example 3: Existing Happy Path Is Not Enough
+## 5. Unknown Coupling or Conflicting Truth — TEST_BLOCKED
 
-**User**: `/prizmkit-test user module`
+A dynamically loaded plugin may consume the changed result shape, but its registry is generated remotely and unavailable. The edge can change the verdict, so it remains verdict-capable and unresolved.
 
-**Existing tests found**:
-```
-TestHandler_UpdateProfile_Success
-TestHandler_GetProfile_Success
-```
+Alternatively, specification and shared schema disagree on nullability with no authoritative resolution. The skill does not freeze current behavior into a characterization test.
 
-**Boundary Matrix result**:
-| Module | Interface | Service Type | Happy Path | Request Validation | Auth / Permission / Ownership | Domain Invariants | Dependency Failure | Final Status |
-|--------|-----------|--------------|------------|--------------------|-------------------------------|-------------------|-------------------|--------------|
-| user | POST /user/update-profile | Validation / CRUD | covered | boundary-missing | boundary-missing | boundary-missing | boundary-missing | boundary-missing |
-| user | POST /user/get-profile | CRUD / Auth | covered | N/A — empty request | boundary-missing | N/A — no domain input | boundary-missing | boundary-missing |
+Both produce:
 
-**Correct action**:
-Generate tests for:
-- missing auth,
-- invalid gender,
-- invalid activity level,
-- implausible height/weight when specified by service contract,
-- user not found,
-- repository failure,
-- response envelope shape.
+```text
+TEST_BLOCKED
+Blocker: verdict-capable unresolved edge or conflicting truth
+Evidence: .prizmkit/test/evidence/<evidence-id>/
+```
 
-**Incorrect action**:
-Do not report `user` as covered just because both endpoints have success tests.
+## 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`.
 
-## Example 4: Change Artifact this-change Run
+If restoration cannot be proven, the verdict is `TEST_BLOCKED`.
 
-**Caller**: `/prizmkit-test scope=this-change artifact_dir=.prizmkit/specs/{{FEATURE_SLUG}}/`
+## 7. Interrupted or Budgeted Run
 
-For non-feature changes, use the same command shape with any explicit change artifact directory that contains `spec.md` + `plan.md` and has a changed-files source. The `{{FEATURE_SLUG}}` path below is a compatibility example for existing feature artifacts; it does not limit `scope=this-change` to feature work.
+On recovery, the skill validates stage outputs and target hashes. A changed lockfile invalidates `INFRA_READY` and every downstream stage but preserves earlier execution history immutably. The run resumes there.
 
-**Expected behavior**:
-- Reads the change artifact's `spec.md`, `plan.md`, and optional `context-snapshot.md`.
-- Builds in-scope files from changed files and the change artifact.
-- Generates or updates only tests for this change's files, public interfaces, and acceptance criteria.
-- Records unrelated historical gaps under `Out of Scope Gaps`.
-- Does not generate tests for unrelated modules.
-- The change artifact may represent a feature, bug fix, refactor, migration, or other scoped change.
+If the budget ends after half a large module's required matrix is tested, progress persists and the result is `TEST_BLOCKED`; no scope is silently truncated.
 
-**Report excerpt**:
-```markdown
-## Scope
-- Mode: this-change
-- Artifact Dir: .prizmkit/specs/{{CHANGE_SLUG}}/
-- Generation Policy: in-scope-only
+## 8. Tampering
 
-## Out of Scope Gaps
-- payment: missing legacy tests, but this change did not affect payment code.
+After packaging, changing `raw/execution-003.stdout`, a contract snapshot, generated test, source patch, or derived report produces a content-hash mismatch. Changing identity inputs without recomputing the canonical evidence ID also fails.
 
-## Verdict
-PASS
+```bash
+python3 ${SKILL_DIR}/scripts/validate_test_evidence.py \
+  --evidence-dir .prizmkit/test/evidence/<evidence-id> \
+  --project-root <target-project-root>
 ```
 
-**HANDOFF**: Independent skill — no handoff. User may proceed to `/prizmkit-committer` only if tests pass and the boundary completion gate passes, or fix issues manually if tests are marked `needs-review`.
+Result: non-zero with `Test evidence validation: FAIL`. A tampered package cannot retain `TEST_PASS`.
+
+## 9. Lightweight Change
+
+A comments-only diff is deterministically classified and parser/format/generated-output checks pass. Behavior-only stages are marked not applicable with reasons. `TEST_PASS` means the lightweight claim is proven; the report explicitly does not claim full runtime test evidence.
+
+## Compatibility Notice
+
+The legacy `PASS | NEEDS_FIXES | BLOCKED` Markdown report interface is intentionally not preserved. Existing Pipeline and Skill consumers are not migrated here and may be temporarily incompatible after installation.

package/bundled/skills/prizmkit-test/references/service-boundary-test-catalog.md

@@ -1,14 +1,17 @@
-# Service Boundary Test Catalog
+# Service Behavior-Risk Catalog
 
-Use this catalog during `/prizmkit-test` Phase 4a when generating unit tests for service-like functions or class methods. The goal is to turn "write boundary tests" into service-specific scenarios that match the unit's business responsibility.
+Use this catalog during `CONTRACT_MODEL` and `TEST_BUILD` to discover domain-specific observable risks. It supplies questions, not truth: every expected value must come from the recorded truth precedence and every external dependency double must follow `references/contract-mock-protocol.md`.
 
 ## How to Use This Catalog
 
-1. Classify the tested unit by reading its name, module path, parameters, dependencies, state changes, and related Prizm docs/spec acceptance criteria.
-2. Select every service type that applies. A function can be both a payment service and an idempotency service, or both a repository and pagination service.
-3. Map candidate boundaries to the actual contract in code/docs. Assert behavior that is specified or clearly implied; if expected behavior is unclear, mark the case as `needs-review` instead of inventing production behavior.
-4. Mock external dependencies for unit tests: databases, network calls, file storage, queues, payment gateways, email providers, clocks, and random ID generators.
-5. Record non-applicable categories as `N/A` with a short reason in the boundary coverage report so skipped categories are explicit.
+1. Classify the affected module by its public behavior, dependencies, state changes, and resolved contracts.
+2. Select every service type that applies; one behavior can combine several types.
+3. Add applicable cases to `behavior-risk-matrix.json` and map them to test/execution IDs.
+4. Derive mock requests/responses from shared machine-readable or locally snapshotted contracts. Never independently invent provider/database/queue behavior.
+5. Record a concrete rationale for every non-applicable risk.
+6. Treat coverage metrics as diagnostic only; complete observable behavior and risk rather than private lines.
+
+Code-level tests are mock-first and must state that they do not verify a real deployed environment. Production credentials, services, and data are prohibited.
 
 ## Service Type Detection