prizmkit 1.1.159 → 1.1.161

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,69 +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 `git add .` or workspace breadth. |
-| `support_validation_evidence` | Interactive conditional | Required when `intended_paths` contains an explicit 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`. |
-| `excluded_paths` | No | Exact caller-owned metadata paths that must remain outside the commit and are also excluded by the selected operation's consumer contract. It is not an allowlist for 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, 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.
 
-## Step 1: Validate Supplied Evidence and Final Change
+## Complete Git-Visible Workspace
 
-1. Resolve `artifact_dir` and every `evidence_paths` entry exactly as supplied by the caller. For interactive operation, also resolve every exact `intended_paths` entry without broadening it.
-2. Reject missing, unreadable, stale, contradictory, blocked, or explicitly non-passing evidence.
-3. Inspect staged, unstaged, untracked, deleted, and renamed files with bounded Git status/diff commands.
-4. Confirm every intended path belongs to the supplied change, a concrete dependency, its tests, durable documentation, or an explicitly caller-owned support artifact. Unknown or unrelated Git-visible changes block rather than entering the manifest.
-5. For every explicit 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. Missing, generic, self-asserted, or non-passing support evidence blocks admission.
-6. Reject unresolved merge state and sensitive files such as real environment files, credentials, secrets, private keys, certificates, or local settings.
-7. Confirm no requested task output remains to be generated after this stage.
-8. Never force-add an ignored file or modify Git/ignore policy. An intended durable documentation path that is not stageable under the project's existing policy blocks with the exact path and policy reason.
+The candidate commit is the complete current Git-visible workspace:
 
-The caller decides which evidence is required and how the returned commit-stage result is used. This Skill validates the supplied evidence but does not infer a larger stage sequence.
+- staged and unstaged tracked changes;
+- added, modified, deleted, renamed, and copied paths;
+- non-ignored untracked files.
 
-## Step 2: Build Commit Message and Intended Path Set
+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.
 
-Generate one concise Conventional Commit message:
+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.
 
-```text
-<type>(<scope>): <description>
-```
+## Step 1: Validate Evidence and the Complete Final Workspace
 
-Classify every observed change before validating either operation.
+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. 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.
 
-- **task-owned**: justified source, tests, product/project documentation, configuration, and dependency changes outside recognized support namespaces;
-- **durable Prizm documentation**: exact stageable `.prizmkit/prizm-docs/**` paths listed by one supplied `retrospective-result.json` whose `outcome=RETRO_COMPLETE`, `result=DOCS_UPDATED`, non-empty `validation`, and `documentation_paths` exactly authorize those paths;
-- **explicit interactive support**: `AGENTS.md`, `skills-lock.json`, or another support path named by the exact spec/plan, covered one-to-one by passing `support_validation_evidence`, labeled separately in the interactive preview, and included in the user's confirmation;
-- **PrizmKit transient/internal**: `.prizmkit/specs/**`, `.prizmkit/state/**`, `.prizmkit/dev-pipeline/**`, config, plans/status, installed Runtime files, checkpoints, and other framework execution data;
-- **generated platform support**: installed platform directories and local platform settings not explicitly owned by the interactive requirement;
-- **project transient**: data the project already excludes through Git ignore rules;
-- **unknown Git-visible**: any remaining path whose task ownership cannot be proven.
+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.
 
-All paths under `.prizmkit/` are framework-internal and remain outside automated task commits.
+## Step 2: Build the Commit Message
 
-For `operation=interactive-commit`, validate the caller-supplied `intended_paths` as the complete approved manifest. It may contain task-owned paths, evidence-backed durable Prizm documentation, and explicitly owned support paths. Every entry must be exact, unique, project-relative, currently changed, stageable without force, and covered by the applicable evidence above. An instruction support file contract must validate readable structure, referenced project paths, consistency with the exact requirement and applicable project conventions, and secret absence. A lockfile support contract must validate parse/schema integrity and owning-installer or deterministic-regeneration parity. Another support class requires the exact project-native semantic validator named by the spec/plan; if no applicable validator exists, support admission blocks. The following remain prohibited: `.git/**`, every PrizmKit transient/internal path, installed platform payloads, local settings, secrets, temporary files, and unrelated or unknown changes.
+Generate one concise single-line Conventional Commit message describing the combined final workspace:
 
-For `operation=prepare-runtime-commit`, preserve the existing automated consumer boundary: construct a unique exact set of task-owned changed paths outside recognized support namespaces, and exclude the complete `.prizmkit/` tree plus platform support and sensitive/unrelated files. Preparation mode preserves the Python Runtime's exact path-coverage contract and does not admit the interactive durable-documentation or support exceptions.
+```text
+<type>(<scope>): <description>
+```
 
-Unknown Git-visible paths block the selected operation; do not silently classify them as transient. Project-specific transient data belongs in the project's Git ignore rules, not caller-provided exclusions. Do not use wildcard pathspecs, `git add .`, or `git add -A`. In preparation mode, reject an `excluded_paths` entry unless the Python Runtime independently excludes that exact caller-owned metadata class; unrelated or user-authored project changes cannot be hidden from exact-path coverage.
+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 the exact `intended_paths`, change summary, sensitive-file warnings, diff statistics, proposed message, intentionally excluded changes, and a separate label for each admitted durable Prizm documentation or explicit support path.
-2. Ask the current user to confirm that exact local commit.
-3. Only after confirmation, stage with `git add -- <exact paths>` semantics: use exact pathspecs for tracked changes, deletions, and explicitly named new files; never stage workspace breadth.
-4. Verify the staged diff exactly matches the confirmed manifest and contains no path added by a hook or incidental operation.
-5. Create the local commit and verify its hash, message, committed paths, and remaining workspace changes against the confirmed manifest.
-6. Return `COMMITTED`, the 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.
 
@@ -89,33 +84,29 @@ 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`.
-2. Read the current full `HEAD` hash as `base_head`.
-3. Write this JSON atomically:
+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": [
-    "src/example.py",
-    "tests/test_example.py"
-  ]
+  "commit_message": "feat(scope): concise description"
 }
 ```
 
 4. Verify:
-   - `artifact_dir` identifies the supplied artifact root;
+   - `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 covers the complete task-owned Git-visible change outside recognized support namespaces;
-   - no path escapes the checkout or enters `.prizmkit/`, another support namespace, or a sensitive location;
-   - every unknown Git-visible path caused a block rather than an implicit exclusion.
-5. Return `COMMIT_REQUEST_READY`, the 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 request is preparation data. Its consumer independently validates it before any Git mutation.
+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
 
@@ -131,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.