prizmkit 1.1.160 → 1.1.161

package/bundled/rules/prizm/prizm-commit-workflow.md

@@ -2,10 +2,17 @@
 description: "PrizmKit commit workflow rules"
 ---
 
+# Commit Workflow
+
+Do not commit after implementation alone.
+
 For a formal requirement:
 1. Complete `/prizmkit-retrospective` after Test and before Committer; it synchronizes durable documentation or records `NO_DOC_CHANGE` but never stages or commits.
-2. Use `/prizmkit-committer` for one exact local commit operation and Conventional Commit message.
-3. Interactive Committer stages only the user-confirmed exact manifest and verifies staged-set/receipt equality; broad staging and force-add are prohibited.
-4. A Git-visible `.prizmkit/**` requirement path is handled like any other exact intended path and requires no documentation-specific commit evidence. Ignored paths remain absent; project tracking policy is unchanged.
-5. Exact Runtime bookkeeping/support and Secrets remain excluded by semantic role. Secret checks apply globally and no framework-directory exception exists.
-6. Remote publication and deployment remain separate.
+2. Use `/prizmkit-committer` for one local commit operation and one truthful Conventional Commit message.
+3. The commit candidate is the complete current Git-visible workspace: staged, unstaged, added, deleted, renamed, copied, and non-ignored untracked content, regardless of when or where each valid change originated.
+4. Final Code Review and Test authority must cover every behavior-affecting candidate. Committer inspects the complete final workspace, blocks stale or unsafe evidence, previews every visible change, and waits for explicit interactive confirmation.
+5. Interactive Committer stages the confirmed complete workspace. Headless preparation writes a schema-v2 pathless request, and Python Runtime re-enumerates and stages the complete validated workspace after `COMMIT_PENDING`.
+6. Ignored paths remain local, never block, and are never force-added. Path provenance or namespace alone never admits or excludes content.
+7. Merge conflicts, Secrets, sensitive local content, known incorrect or incoherent changes, and unverifiable content still block. Only the exact active interactive workflow state or Runtime request/checkpoint and post-commit receipt writes may remain outside the snapshot because their causal finalization follows the commit.
+8. Runtime verifies the base, parent, message, non-empty commit, recovery receipt, and checkpoint finalization before integration.
+9. Remote publication and deployment remain separate.

package/bundled/skills/_metadata.json

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

package/bundled/skills/prizmkit-code-review/SKILL.md

@@ -55,19 +55,19 @@ Resolve a compatible Python 3 interpreter through the current Host's executable
 
 Review only the caller-supplied `artifact_dir`; never discover a different recent artifact. Missing or inconsistent stage input produces `NEEDS_FIXES` with the exact input blocker.
 
-## Default Correctness Scope
+## Complete Git-Visible Correctness Scope
 
-The current requirement change outside `.prizmkit/**` is the ordinary correctness scope. Every `.prizmkit/**` path is excluded by default from correctness review, including correctness diffs, candidate findings, repairs, and verification scope. The Skill may read only exact caller-supplied `.prizmkit` artifacts such as `spec.md` and `plan.md` as evidence for the outside-framework requirement and may write its own `review-report.md`; it must not assess, report findings against, or repair their content. Neither action makes `.prizmkit` content reviewable production change. Correctness review of any framework/support artifact requires a separate explicit support-artifact review contract naming the exact artifacts and validator.
+The complete current Git-visible workspace is the correctness scope: staged and unstaged tracked changes, additions, deletions, renames, copies, and non-ignored untracked files. Correct changes that predate the active requirement or implementation session remain in scope. Do not exclude, specially admit, or require a separate support contract solely because a path is under `.prizmkit/**`, generated, an instruction or lock file, a platform directory, local support, or otherwise outside the original requirement namespace.
 
-Generated host-support paths are also excluded by default, including `AGENTS.md`, `skills-lock.json`, installed platform directories, and local platform settings. An explicitly owned support change requires a separate explicit support-artifact validation contract; do not pull it into ordinary Code Review through workspace expansion. Record excluded changed paths in the report so exclusion is visible rather than mistaken for reviewed content.
+Inspect each visible path through the applicable contract: production behavior through code and callers, tests through assertion and boundary quality, instructions through readable structure and referenced-project consistency, lock/generated content through parse or deterministic parity, and binary or specialized content through the available project-native validator. Block when correctness cannot be established safely. Ignored paths remain naturally absent and are not review findings. Artifact files read or written by this stage are evidence/output, but any such file that is Git-visible in the final workspace is still disclosed to the final commit inspection rather than hidden by provenance.
 
 ## Phase 0: Initialize Report and Reuse Current Context
 
 1. Resolve `{artifact_dir}` and `{artifact_dir}/review-report.md` from the active requirement context.
 2. At the start of each execution, initialize a replacement report through the Report Renderer Contract and `${SKILL_DIR}/references/review-report-template.md`.
 3. Within that execution, append every review round, repair batch, independent-review event, final verification, and exactly one `## Final Result` through the renderer or its visible equivalent fallback.
-4. Start from the Main Agent's current requirement context and inspect the complete workspace inventory first: `git status --short`, the staged diff, and the unstaged diff. Include untracked, deleted, and renamed paths in classification, then remove default-excluded `.prizmkit/**` and host-support paths from the correctness scope before producing findings.
-5. Append one validated `scope-classification` renderer event containing exact in-scope paths and exact default-excluded changed paths; do not describe exclusions as reviewed or silently repair them.
+4. Start from the Main Agent's current requirement context and inspect the complete workspace inventory first: `git status --short`, the staged diff, and the unstaged diff. Include all non-ignored untracked, deleted, renamed, and copied paths in the correctness scope before producing findings.
+5. Append one validated `scope-classification` renderer event containing the exact complete Git-visible in-scope paths. Do not maintain excluded-path metadata or claim ignored content was reviewed.
 6. Reuse current context and load only missing or potentially stale material required to resolve a concrete ambiguity, verify an acceptance criterion, or understand a changed contract.
 7. Inspect unchanged callers, dependents, contracts, or tests only when the in-scope diff changes or may violate an interface, shared behavior, or regression boundary. Do not perform an unconditional repository-wide dependency sweep.
 8. For `review_scope=delta`, focus on in-scope files and behavior affected since the prior review pass and expand only across contracts implicated by that delta.

package/bundled/skills/prizmkit-code-review/references/independent-code-review.md

@@ -62,15 +62,14 @@ The Main Agent supplies:
 
 - original requirement and confirmed clarifications;
 - exact artifact, spec, and plan paths plus current contents;
-- current workspace status after the Main Agent classifies default exclusions;
-- staged and unstaged tracked changes in the ordinary correctness scope;
-- relevant in-scope untracked, deleted, and renamed content;
-- exact default-excluded changed paths as visible exclusion metadata, never as reviewed content;
+- the complete current Git-visible workspace status;
+- all staged and unstaged tracked changes;
+- all non-ignored untracked, deleted, renamed, and copied content;
 - implementation task completion and targeted verification results;
 - response number and total budget;
 - prior adjudication, actual repairs, and repair verification on continuation or replacement.
 
-The Main Agent runs Git and captures authoritative current-change state, then applies the Skill's default `.prizmkit/**` and generated host-support exclusions before supplying the correctness change. The Reviewer may read the exact supplied spec/plan artifacts but must not inspect other `.prizmkit` content. It may use structurally read-only checkout access to inspect unchanged callers, consumers, contracts, schemas, types, configurations, fixtures, or tests only when concrete coupling to this requirement justifies it. It must not run commands or perform an unconditional repository-wide scan. Missing or inconsistent required input produces `REVIEW_BLOCKED`, never partial success.
+The Main Agent runs Git and captures the authoritative complete Git-visible change without namespace or provenance exclusions. Correct pre-existing, `.prizmkit/**`, generated, instruction, lock, and host-support content remains reviewable. The Reviewer may use structurally read-only checkout access to inspect unchanged callers, consumers, contracts, schemas, types, configurations, fixtures, or tests only when concrete coupling to a visible change justifies it. It must not run commands or perform an unconditional repository-wide scan. Ignored content is absent. Missing or inconsistent required input produces `REVIEW_BLOCKED`, never partial success.
 
 ## Initial Reviewer Prompt
 

package/bundled/skills/prizmkit-code-review/references/review-report-template.md

@@ -18,18 +18,16 @@ Within that execution, append sections only. Never edit or replace an earlier pr
 
 ### Review Scope
 
-Append once after workspace inventory classification and before the first review round:
+Append once after complete workspace inventory and before the first review round:
 
 ```markdown
 ## Review Scope
 
-- In-Scope Paths:
-  - <exact requirement-owned path or None.>
-- Default-Excluded Changed Paths:
-  - <exact .prizmkit/support path or None.>
+- Git-Visible Paths:
+  - <exact staged, unstaged, deleted, renamed, copied, or non-ignored untracked path or None.>
 ```
 
-Paths under `.prizmkit/**` and generated host-support paths are visible exclusions, not reviewed content.
+Every Git-visible path is review scope regardless of provenance. Ignored paths remain absent rather than becoming exclusions.
 
 ### Main-Agent Review Round
 

package/bundled/skills/prizmkit-code-review/scripts/render_review_report.py

@@ -115,15 +115,12 @@ def _render_event(data: dict[str, Any]) -> str:
 
     if event == "scope-classification":
         in_scope = _require_text_list(data, "in_scope_paths")
-        excluded = _require_text_list(data, "excluded_paths")
         return "\n".join(
             [
                 "## Review Scope",
                 "",
-                "- In-Scope Paths:",
+                "- Git-Visible Paths:",
                 *_render_path_list(in_scope),
-                "- Default-Excluded Changed Paths:",
-                *_render_path_list(excluded),
             ]
         )
 

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

@@ -1,14 +1,14 @@
 ---
 name: "prizmkit-committer"
-description: "Perform one commit stage for a caller-supplied final change. Either preview and create an explicitly confirmed interactive local commit, or validate the final diff and write an exact runtime-commit-request.json without Git mutation. Returns only commit-stage results. (project)"
+description: "Perform one commit stage for a caller-supplied final change. Either review, preview, confirm, and commit the complete Git-visible workspace interactively, or validate it and prepare a pathless Runtime commit request without Git mutation. Returns only commit-stage results. (project)"
 ---
 
 # PrizmKit Committer
 
-`/prizmkit-committer` handles one caller-supplied final change through one explicit operation:
+`/prizmkit-committer` handles one caller-supplied final workspace through one explicit operation:
 
-- `operation=interactive-commit`: preview, confirm, stage, commit, and verify locally.
-- `operation=prepare-runtime-commit`: validate the intended change and write an exact commit request without staging or committing.
+- `operation=interactive-commit`: inspect the complete Git-visible workspace, preview it, confirm it, stage it, commit it, and verify it locally.
+- `operation=prepare-runtime-commit`: validate the complete Git-visible workspace and write a pathless Runtime request without staging or committing.
 
 Remote publication is outside this Skill.
 
@@ -18,75 +18,64 @@ Remote publication is outside this Skill.
 |---|---|---|
 | `artifact_dir` | Yes | Exact caller-supplied artifact root for this commit stage. |
 | `operation` | Yes | `interactive-commit` or `prepare-runtime-commit`. |
-| `evidence_paths` | Yes | Exact caller-supplied project-relative artifacts that establish commit readiness. |
-| `intended_paths` | Interactive only: Yes | Exact unique project-relative final paths approved by the caller for preview and staging. It is never inferred from workspace breadth. |
-| `support_validation_evidence` | Interactive conditional | Required only for an explicit host/platform support path. Supply one exact record per support path with `path`, named semantic `contract`, completed `validation`, `result=PASS`, and an exact `evidence_path` also present in `evidence_paths`. A path is not support merely because it is under `.prizmkit/**`. |
-| `excluded_paths` | No | Exact caller-owned operation metadata that the selected consumer also excludes. It cannot hide unrelated project changes. |
+| `evidence_paths` | Yes | Exact caller-supplied artifacts that establish final Review/Test/Retrospective readiness. |
+| `causal_bookkeeping_path` | Interactive conditional | The one exact caller-owned coordinator state whose truthful finalization must follow this commit. It cannot exclude ordinary content. |
 | `request_path` | Preparation only | Must equal `{artifact_dir}/runtime-commit-request.json`. |
 
-Do not discover another artifact root or infer the operation from provider, platform, prompt style, tracking policy, or human availability.
+There is no caller-supplied commit-path manifest, support-path admission record, or ownership classification. Do not discover another artifact root or infer the operation from provider, platform, prompt style, tracking policy, checkout cleanliness, or human availability.
 
 ## Stage Boundary
 
-This Skill owns only final-change inspection and its selected commit operation. It does not invoke another Skill.
+This Skill owns only final-workspace inspection and its selected commit operation. It does not invoke another Skill or repair incorrect content.
 
-In preparation mode it must not stage, unstage, commit, amend, reset, merge, or push.
+In preparation mode it must not stage, unstage, commit, amend, reset, merge, or push. It may write only the exact Runtime request after validation succeeds.
 
-## Framework Directory and Git Policy
+## Complete Git-Visible Workspace
 
-`.prizmkit/**` is the PrizmKit framework directory, not a blanket Git exclusion. The project alone decides which paths are ignored, untracked, or tracked. A Git-visible intended path must not be rejected, specially admitted, or require documentation-specific evidence solely because it is under `.prizmkit/**`.
+The candidate commit is the complete current Git-visible workspace:
 
-Ignored paths remain naturally absent. Never force-add a path, add/remove/interpret `.gitignore` entries, or require a project to track framework artifacts. Exact Runtime request/checkpoint paths and installed Runtime/state may remain outside a task commit only because of their concrete operation-owned support/bookkeeping role. Global Secret and sensitive-content checks apply to every intended path, including framework paths; this contract creates no Secret exception.
+- staged and unstaged tracked changes;
+- added, modified, deleted, renamed, and copied paths;
+- non-ignored untracked files.
 
-## Step 1: Validate Supplied Evidence and Final Change
+Ignored files remain naturally absent, stay local, do not block, and are never force-added. Git visibility is independent of path provenance: product, test, documentation, `.prizmkit`, generated, instruction, lock, host-support, or previously existing content receives no namespace-based admission or exclusion. A non-clean starting checkout is acceptable when the combined final workspace is correct and fully validated.
 
-1. Resolve `artifact_dir` and every `evidence_paths` entry exactly as supplied. For interactive operation, also resolve every exact `intended_paths` entry without broadening it.
+The only non-final Git-visible content that may remain outside a commit snapshot is exact active coordinator/Runtime bookkeeping whose final mutation cannot truthfully precede the commit: one validated caller-supplied interactive coordinator-state path, or the automated request/checkpoint and post-commit receipt. This is a causal operation boundary, not a directory allowlist, denylist, or general exclusion mechanism.
+
+## Step 1: Validate Evidence and the Complete Final Workspace
+
+1. Resolve `artifact_dir`, every `evidence_paths` entry, the optional interactive `causal_bookkeeping_path`, and preparation `request_path` exactly as supplied. Reject any causal path not proven to be the active caller-owned coordinator state finalized after this operation.
 2. Reject missing, unreadable, stale, contradictory, blocked, or explicitly non-passing readiness evidence.
-3. Inspect staged, unstaged, untracked, deleted, and renamed Git-visible files with bounded Git status/diff commands. Ignored files are not discovered.
-4. Confirm every intended path belongs to the supplied requirement, a concrete dependency, its tests, project documentation/configuration, a framework-managed requirement output, or an explicitly caller-owned support artifact. Unknown or unrelated Git-visible changes block rather than entering or disappearing from the manifest.
-5. For each explicit host/platform support path, require one unique `support_validation_evidence` record whose `path` equals that manifest entry, whose `evidence_path` is supplied and readable, and whose named contract, completed validation, and `result=PASS` agree with that evidence. Do not apply this requirement to a path merely because its prefix is `.prizmkit/` or `.prizmkit/prizm-docs/`.
-6. Reject unresolved merge state and scan all intended content/diffs for real environment files, credentials, Secrets, private keys, certificates, local settings, and other sensitive material.
-7. Confirm no requested task output remains to be generated after this stage.
-8. Require every intended path to be Git-visible and stageable under existing project policy. If an exact path is ignored or otherwise not stageable, report its ordinary Git visibility/policy result; never force-add or change policy.
+3. Inventory staged, unstaged, untracked, deleted, renamed, and copied Git-visible files with bounded Git status and diff commands. Do not discover ignored files. Identify only the exact active causal bookkeeping path for the selected operation; every other visible path remains a candidate.
+4. Inspect every candidate path and its relevant diff/content. Correct pre-existing or requirement-adjacent changes may be included even when they were not created in the current implementation session.
+5. Require behavior-affecting content to be covered by the supplied final Code Review and Test authority. If production behavior changed after authoritative Review/Test, block with the exact stale-evidence reason so the caller can re-enter those stages.
+6. Reject unresolved merge state, known incorrect or incoherent changes, unreadable or unverifiable final content, real environment files, credentials, Secrets, private keys/certificates, dangerous local settings, and other sensitive material. Safety checks apply globally without namespace exceptions.
+7. Confirm no requested final output remains to be generated and that at least one commit candidate exists.
+8. Never force-add, change or interpret ignore policy, or reject a valid candidate merely because it is unrelated to the original requirement or came from a dirty checkout.
 
-The caller decides which readiness evidence is required and how the returned stage result is used. The Skill validates supplied evidence but does not infer a larger lifecycle.
+The caller decides which readiness evidence is required and how the returned stage result is routed. This Skill validates supplied evidence and current content but does not infer a larger lifecycle.
 
-## Step 2: Classify Paths and Build the Exact Manifest
+## Step 2: Build the Commit Message
 
-Generate one concise Conventional Commit message:
+Generate one concise single-line Conventional Commit message describing the combined final workspace:
 
 ```text
 <type>(<scope>): <description>
 ```
 
-Classify observed changes by semantic role, not by a blanket `.prizmkit/**` prefix:
-
-- **task-owned**: justified source, tests, documentation, configuration, dependencies, and framework-managed requirement output, including safe Git-visible `.prizmkit/**` paths when they belong to the supplied change;
-- **explicit interactive support**: host instruction/lock/config support named by the exact spec/plan, validated one-to-one, labeled separately, and confirmed by the user;
-- **operation-owned Runtime bookkeeping/support**: exact request/checkpoint/caller-state paths, installed `.prizmkit/dev-pipeline/**`, Runtime state, installed host payloads, and local host settings that the active consumer contract identifies as support rather than task output;
-- **project transient**: data naturally absent because the project's existing ignore policy excludes it;
-- **sensitive**: Secrets, credentials, private environment, private keys/certificates, or local settings;
-- **unknown Git-visible**: any remaining path whose task or explicit support ownership cannot be proven.
-
-A Prizm documentation path has no separate commit-ownership class and requires no `retrospective-result.json` authorization. Retrospective may have created it, but Committer handles a Git-visible path through the same task justification, exact manifest, Secret scan, and receipt verification as any other path.
-
-For `operation=interactive-commit`, validate caller-supplied `intended_paths` as the complete approved manifest. Every entry must be exact, unique, project-relative, currently Git-visible, stageable without force, and task-owned or explicitly validated support. Prohibit `.git/**`, exact operation-owned Runtime bookkeeping, installed host payload/state, Secrets, temporary files, and unrelated/unknown changes. Label explicit host support separately; do not label `.prizmkit/**` specially.
-
-For `operation=prepare-runtime-commit`, construct a unique exact set of all justified task-owned Git-visible changed paths, including safe `.prizmkit/**` task output. Exclude only consumer-recognized semantic support/bookkeeping, sensitive, unrelated, or naturally ignored data. Exact caller metadata in `excluded_paths` is valid only when the Python Runtime independently excludes that same semantic role. Unknown Git-visible changes block.
-
-Never use wildcard pathspecs, broad `git add .`, broad `git add -A`, or force-add. Exact literal path staging may use Git's update semantics for a listed deletion, but the path set must remain exactly the manifest.
+A heterogeneous but coherent workspace may use the narrowest truthful shared scope and description. If no truthful single commit description exists, block as incoherent content rather than silently omit files.
 
 ## Step 3A: Interactive Commit
 
 For `operation=interactive-commit`:
 
-1. Present exact `intended_paths`, change summary, Secret/sensitive warnings, diff statistics, proposed message, intentionally excluded semantic support, and separate labels only for admitted host support.
-2. Ask the current user to confirm that exact local commit.
-3. Only after confirmation, stage with `git add -- <exact paths>` semantics using literal exact pathspecs for tracked changes, deletions, and explicitly named Git-visible new files; never stage workspace breadth or force-add ignored content.
-4. Verify the staged path set exactly equals the confirmed manifest and no hook/incidental operation added a path.
-5. Re-run global Secret checks against the exact staged snapshot.
-6. Create the local commit and verify its hash, message, parent, committed path set, and remaining workspace changes against the confirmed manifest.
-7. Return `COMMITTED`, commit hash/message, committed paths, and intentional remaining changes.
+1. Present the complete Git-visible candidate set, the exact validated interactive causal bookkeeping path retained locally when visible, change summary, diff statistics, sensitive-content result, proposed message, and a clear statement that confirmation covers every candidate while ignored files stay local.
+2. Ask the current user to confirm that complete local commit.
+3. If the workspace changes after preview, repeat whole-workspace validation and preview before using the confirmation.
+4. Only after confirmation, stage the complete workspace with ordinary `git add -A -- .` semantics, then reset only the validated `causal_bookkeeping_path` in the index to `HEAD` when it is Git-visible. Never force-add ignored content or accept any other exclusion.
+5. Verify that the staged paths equal the in-memory confirmed candidate set, no non-ignored unstaged/untracked candidate remains outside the exact causal state, no incidental path appeared, and the staged snapshot still passes global sensitive-content checks.
+6. Create the local commit and verify its hash, single parent, message, committed path set, and remaining Git-visible workspace against the confirmed snapshot.
+7. Return `COMMITTED`, commit hash/message, committed paths, and any remaining ignored or causal bookkeeping content that is intentionally local.
 
 If confirmation is declined, return `COMMIT_DECLINED` without Git mutation.
 
@@ -94,20 +83,16 @@ If confirmation is declined, return `COMMIT_DECLINED` without Git mutation.
 
 For `operation=prepare-runtime-commit`:
 
-1. Require `request_path={artifact_dir}/runtime-commit-request.json` and exclude that exact operation-owned request plus the caller-supplied Runtime checkpoint from `intended_paths`.
-2. Read current full `HEAD` as `base_head`.
+1. Require `request_path={artifact_dir}/runtime-commit-request.json`.
+2. Read the current full `HEAD` as `base_head`.
 3. Write this JSON atomically without Git mutation:
 
 ```json
 {
-  "schema_version": 1,
+  "schema_version": 2,
   "artifact_dir": ".prizmkit/specs/example",
   "base_head": "<full current HEAD hash>",
-  "commit_message": "feat(scope): concise description",
-  "intended_paths": [
-    ".prizmkit/prizm-docs/example.prizm",
-    "src/example.py"
-  ]
+  "commit_message": "feat(scope): concise description"
 }
 ```
 
@@ -115,14 +100,13 @@ For `operation=prepare-runtime-commit`:
    - `artifact_dir` equals the supplied artifact root;
    - `base_head` equals current `HEAD`;
    - `commit_message` is one non-empty line;
-   - `intended_paths` is non-empty, unique, exact, project-relative, and equals the complete task-owned Git-visible change outside exact semantic support/bookkeeping;
-   - no path escapes the checkout, enters `.git/**`, names exact Runtime-owned request/checkpoint data, or contains sensitive content;
-   - no path was rejected solely because it is under `.prizmkit/**`;
-   - every unknown Git-visible path caused a block rather than implicit exclusion.
-5. Return `COMMIT_REQUEST_READY`, request path, message, intended paths, and explicit confirmation that no Git mutation occurred.
+   - the request has no path manifest or caller-owned commit receipt;
+   - the complete current Git-visible workspace passed Step 1;
+   - the exact request and workflow checkpoint are treated only as causal Runtime bookkeeping when Git-visible.
+5. Return `COMMIT_REQUEST_READY`, request path, message, and explicit confirmation that no Git staging or commit mutation occurred.
 6. Stop.
 
-The Python Runtime independently revalidates exact changed/staged/committed sets, safety, base/message/receipt, and post-commit bookkeeping order.
+Schema version 1 path-manifest requests are not silently reinterpreted as workspace authorization. The Python Runtime independently validates the schema, base, final workspace, safety, commit identity, recovery receipt, and post-commit checkpoint order.
 
 ## Output
 
@@ -138,4 +122,4 @@ Preparation operation returns exactly one of:
 COMMIT_REQUEST_READY | COMMIT_BLOCKED
 ```
 
-Every blocked result includes concrete missing evidence, unsafe paths, or validation errors. Return only the listed commit-operation outputs.
+Every blocked result includes concrete missing evidence, unsafe or incorrect content, stale authority, or validation errors. Return only the listed commit-operation outputs.

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

@@ -34,7 +34,7 @@ After writing its result, this Skill stops. It owns only testing-local source/te
 |---|---|---|
 | `scope` | No | `full-project`, `module:<name>`, `feature:<slug>`, or `this-change`. Defaults to `this-change` when current change context exists, otherwise `full-project`. |
 | `artifact_dir` | Yes | Exact caller-supplied project-relative directory for the two terminal artifacts and any available specification, plan, and behavior context. Reuse it unchanged. |
-| `changed_files` | No | Explicit current changed paths. Highest-priority scope locator. |
+| `changed_files` | No | Explicit complete Git-visible changed paths. Highest-priority scope locator; callers coordinating a commit supply every behavior-affecting visible path regardless of provenance. |
 | `diff_base` | No | Git comparison base when explicit changed paths are absent. |
 | `test_commands` | No | Project-native commands when repository conventions are ambiguous. |
 
@@ -54,7 +54,7 @@ Do not create `.prizmkit/test/evidence/`, manifests, hashes, attestations, packa
 
 1. Reuse current requirement and workspace context already loaded by the Main Agent.
 2. Load `root.prizm`, the relevant module indexes, and the applicable detail docs before modifying source or tests.
-3. Inspect current staged, unstaged, untracked, deleted, and renamed paths. Changed lines locate impact but never define completeness.
+3. Inspect every current staged, unstaged, non-ignored untracked, deleted, renamed, and copied path. Treat every behavior-affecting Git-visible change, including correct pre-existing or framework/support content, as current Test scope; changed lines locate impact but never define completeness.
 4. Read the available specification, acceptance criteria, plan, and caller-supplied behavior context only as needed to establish expected behavior.
 5. Inspect manifests, runner configuration, CI conventions, existing test assertions, fixtures, fakes, mocks, contracts, and coverage support.
 6. If necessary scope cannot be determined safely, report the precise missing input and return `TEST_BLOCKED` in the resolved artifact pair.

package/bundled/skills/prizmkit-test/references/test-coverage-model.md

@@ -18,7 +18,7 @@ business capability or acceptance criterion
 └── callers, consumers, shared contracts, and shared state
 ```
 
-Changed lines locate possible impact. They do not define completeness.
+Changed lines locate possible impact. They do not define completeness. When the caller intends to commit a combined workspace, every behavior-affecting Git-visible change belongs to this scope regardless of whether it predates the active requirement or resides in product, framework, generated, instruction, lock, or host-support paths. Ignored content remains absent.
 
 ## Affected Business Module
 

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

@@ -211,15 +211,13 @@ The internal `prizmkit-code-review` limit of ten completed review rounds remains
 
 The composite reaches `/prizmkit-committer operation=interactive-commit` but must not silently create a Git commit.
 
-The composite must validate all prior stage artifacts, derive exact non-`.prizmkit/` source-change paths for retrospective input, and validate its result. It then assembles one exact interactive `intended_paths` manifest from every final Git-visible requirement output, regardless of whether a justified path is under `.prizmkit/**`. Ignored paths remain naturally absent. Prizm documentation has no separate commit-ownership or retrospective-evidence admission rule.
+The composite must validate all prior stage artifacts, derive exact non-`.prizmkit/` source-change paths for retrospective input, and validate its result. Code Review and Test must have treated the complete behavior-affecting Git-visible workspace as their final scope, including correct changes that predated this implementation session or live in framework, generated, instruction, lock, or host-support namespaces. If production behavior changes after those final gates, re-enter Review/Test rather than carrying stale authority into Committer.
 
-`.prizmkit/**` remains the framework capability boundary and ordinary Code Review black box, but project Git tracking is independent. The composite must not force-add a framework path, modify or interpret ignore policy, broadly stage, or reject a Git-visible intended path solely by directory name. Exact Runtime request/checkpoint/state and installed Runtime/host payloads remain outside the manifest because of their semantic support/bookkeeping role, not a blanket framework-directory rule. Global Secret checks apply equally to every intended path.
+Invoke Committer with the same `artifact_dir`, exact `evidence_paths`, `operation=interactive-commit`, and `causal_bookkeeping_path` equal to this workflow's exact state path. Do not assemble or pass `intended_paths`, support-path admission records, namespace classifications, or ordinary content exclusions. Committer inventories and validates the complete current Git-visible workspace, presents all of it with one truthful message, waits for confirmation, and stages and creates the complete commit only after approval. A non-clean starting checkout is not a blocker when the combined final content is correct and validated.
 
-For each explicit host/platform support path, select and execute its applicable semantic contract before invoking Committer: instruction files require readable structure, resolvable project references, consistency with the exact requirement and applicable project conventions, and Secret scanning; lockfiles require parse/schema checks plus owning-installer or deterministic-regeneration parity; any other support class requires an exact project-native semantic validator named by the spec/plan. User confirmation alone is not support validation. A path is not host support merely because it is under `.prizmkit/**`.
+Ignored paths remain naturally absent, stay local, and never block or require force-add. Global Secret, sensitive-content, merge-state, evidence-freshness, and content-correctness checks apply to every Git-visible candidate without provenance exceptions. The exact `.prizmkit/state/workflows/<requirement-identity>.json` remains local during the interactive commit because this coordinator must finalize it after Committer returns. Exact active Runtime request/checkpoint and post-commit receipt writes follow the same causal rule in automation; no broader or caller-selected exclusion is allowed.
 
-Invoke Committer with the same `artifact_dir`, exact `evidence_paths`, exact caller-state/bookkeeping paths in `excluded_paths`, exact `intended_paths`, conditional one-to-one host `support_validation_evidence`, and `operation=interactive-commit`. Committer validates the exact manifest and staged-set equality, presents it, waits for confirmation, and creates it only after approval.
-
-External headless orchestration supplies explicit readiness evidence to `operation=prepare-runtime-commit`, maps `COMMIT_REQUEST_READY` to its own pending state, and lets Python Runtime validate and execute the request. Safe Git-visible `.prizmkit/**` task output may appear in Runtime `intended_paths`; exact Runtime bookkeeping/support, Secrets, unrelated paths, and ignored paths do not. Remote publication remains separate.
+External headless orchestration supplies explicit readiness evidence to `operation=prepare-runtime-commit`, maps `COMMIT_REQUEST_READY` to its own pending state, and lets Python Runtime validate and execute the schema-v2 pathless request. Runtime commits the complete validated Git-visible workspace with only exact causal bookkeeping omitted, then verifies Git and finalizes `COMMITTED`. Remote publication remains separate.
 
 ## Automatic Handoff and Manual Fallback
 

package/bundled/skills/prizmkit-workflow/references/workflow-state-protocol.md

@@ -158,26 +158,28 @@ Any outer repair or continuation policy is independently owned by the caller and
 Interactive execution:
 
 ```text
-coordinator assembles exact intended_paths from all final Git-visible requirement paths, including justified `.prizmkit/**` output
-  + separately labeled explicitly owned host support paths with one-to-one passing support_validation_evidence
-→ committer validates ordinary task ownership, global Secret safety, and the exact files/message
+coordinator validates final Review, Test, and Retrospective authority for the complete behavior-affecting Git-visible workspace
+→ committer inventories and inspects the complete current Git-visible workspace without caller-supplied paths
+→ committer applies global correctness, freshness, merge-state, and Secret checks
+→ committer previews every visible change and one truthful message
 → waits for explicit current-user confirmation
-→ stages exact pathspecs, creates, and verifies the local commit
+→ stages the complete workspace, creates, and verifies the local commit
 ```
 
-The framework directory is not a blanket allowlist or denylist: a Git-visible `.prizmkit/**` path uses the same exact manifest, task justification, staged-set equality, Secret checks, and receipt verification as any other path, with no documentation-specific evidence. Ignored files remain absent and are never force-added. Exact Runtime request/checkpoint/state, installed Runtime/host payloads, sensitive, unknown, and unrelated paths remain excluded or blocking because of their semantic role. User confirmation alone is not host-support validation.
+Git visibility, validated final content, and confirmation determine commit scope; path provenance does not. Correct changes may predate the active requirement or live under `.prizmkit/**`, generated, instruction, lock, or host-support namespaces. Ignored files remain absent, stay local, never block, and are never force-added. If behavior-affecting content appears after final Review/Test, the evidence is stale and the workflow re-enters those gates. Sensitive, conflicted, incorrect, incoherent, unreadable, or unverifiable content blocks on its actual state rather than an unknown-path category. The exact active workflow-state path derived from the artifact basename remains outside the interactive snapshot only because the coordinator finalizes it after Committer returns; it is not a general framework exclusion.
 
 Pipeline execution:
 
 ```text
 external coordinator validates its required gates and supplies exact readiness evidence
-→ committer validates only that evidence and writes an exact runtime-commit-request.json
+→ committer validates the complete Git-visible workspace and writes a schema-v2 pathless runtime-commit-request.json without Git mutation
 → external coordinator maps COMMIT_REQUEST_READY to its checkpoint's in_progress/COMMIT_PENDING state
-→ Python runtime validates the request, commits, verifies Git, and writes checkpoint completed/COMMITTED
+→ Python runtime re-enumerates and stages the complete non-ignored workspace
+→ Python runtime verifies the commit, writes its receipt, and finalizes checkpoint completed/COMMITTED
 → remote publication remains separate
 ```
 
-The preparation request is data for Runtime validation, not prompt-level authorization. The committer must not stage, commit, or predeclare COMMITTED in preparation mode. Safe Git-visible `.prizmkit/**` task output may appear in Runtime `intended_paths`; ignored paths remain absent, while exact Runtime bookkeeping/support and Secrets remain excluded. Runtime verifies the commit before writing its post-commit receipt/checkpoint and never retroactively inserts those writes into the committed snapshot.
+The preparation request carries artifact identity, base head, and commit message, not path authorization. The committer must not stage, commit, or predeclare COMMITTED in preparation mode. Exact active request/checkpoint and post-commit receipt mutations may remain outside the committed snapshot only because their causal Runtime bookkeeping cannot truthfully precede the commit. Runtime verifies the base, non-empty commit, parent, message, receipt, and checkpoint order before integration; it never retroactively inserts post-commit writes into the snapshot.
 
 ## Recovery
 

package/package.json

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