prizmkit 1.1.156 → 1.1.160

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

@@ -11,6 +11,7 @@ from typing import Any
 
 VERDICTS = {"PASS", "NEEDS_FIXES"}
 EVENTS = {
+    "scope-classification",
     "main-review-round",
     "repair-verification",
     "independent-review-round",
@@ -25,6 +26,8 @@ REVIEWER_RESULTS = {
 }
 ADJUDICATION_DECISIONS = {"accepted", "rejected", "unresolved"}
 RECHECK_STATES = {"yes", "no", "not applicable"}
+ROUND_CONTINUATION_MODES = {"native", "replacement"}
+DOWNGRADE_CONTINUATION_MODES = {"native", "replacement", "mixed", "not-applicable"}
 FINAL_HEADING = "## Final Result"
 
 
@@ -54,6 +57,25 @@ def _require_count(data: dict[str, Any], name: str, *, maximum: int | None = Non
     return value
 
 
+def _require_text_list(data: dict[str, Any], name: str) -> list[str]:
+    value = data.get(name)
+    if not isinstance(value, list):
+        raise ReportStateError(f"{name} must be an array of strings")
+    normalized: list[str] = []
+    for item in value:
+        if not isinstance(item, str) or not item.strip():
+            raise ReportStateError(f"{name} must contain only non-empty strings")
+        text = item.strip()
+        if text in normalized:
+            raise ReportStateError(f"{name} must not contain duplicates")
+        normalized.append(text)
+    return normalized
+
+
+def _render_path_list(paths: list[str]) -> list[str]:
+    return [f"  - {path}" for path in paths] if paths else ["  - None."]
+
+
 def _report_text(path: Path) -> str:
     try:
         return path.read_text(encoding="utf-8")
@@ -91,6 +113,20 @@ def _render_event(data: dict[str, Any]) -> str:
     if event not in EVENTS:
         raise ReportStateError(f"event has invalid value: {event!r}")
 
+    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:",
+                *_render_path_list(in_scope),
+                "- Default-Excluded Changed Paths:",
+                *_render_path_list(excluded),
+            ]
+        )
+
     if event == "main-review-round":
         round_number = _require_count(data, "round", maximum=10)
         if round_number < 1:
@@ -131,6 +167,15 @@ def _render_event(data: dict[str, Any]) -> str:
         response = _require_count(data, "response", maximum=5)
         if response < 1:
             raise ReportStateError("response must be at least 1")
+        capability_basis = _require_text(data, "capability_basis")
+        continuation_mode = _require_text(data, "continuation_mode")
+        if continuation_mode not in ROUND_CONTINUATION_MODES:
+            raise ReportStateError(
+                f"continuation_mode has invalid value: {continuation_mode!r}"
+            )
+        reviewer_replacements = _require_count(
+            data, "reviewer_replacements", maximum=1
+        )
         result = _require_text(data, "result")
         if result not in REVIEWER_RESULTS:
             raise ReportStateError(f"result has invalid value: {result!r}")
@@ -156,6 +201,10 @@ def _render_event(data: dict[str, Any]) -> str:
             [
                 f"## Independent Review Round {response}",
                 "",
+                "- Capability Gate: ENABLED",
+                f"- Capability Basis: {capability_basis}",
+                f"- Continuation Mode: {continuation_mode}",
+                f"- Reviewer Replacements: {reviewer_replacements}",
                 f"- Result: {result}",
                 f"- Corrections: {corrections}",
                 f"- Accepted: {accepted}",
@@ -181,6 +230,15 @@ def _render_event(data: dict[str, Any]) -> str:
         )
 
     if event == "independent-review-downgrade":
+        capability_basis = _require_text(data, "capability_basis")
+        continuation_mode = _require_text(data, "continuation_mode")
+        if continuation_mode not in DOWNGRADE_CONTINUATION_MODES:
+            raise ReportStateError(
+                f"continuation_mode has invalid value: {continuation_mode!r}"
+            )
+        reviewer_replacements = _require_count(
+            data, "reviewer_replacements", maximum=1
+        )
         rechecked = _require_text(data, "final_state_independently_rechecked")
         if rechecked not in RECHECK_STATES:
             raise ReportStateError(
@@ -192,6 +250,9 @@ def _render_event(data: dict[str, Any]) -> str:
                 "## Independent Review Downgrade",
                 "",
                 f"- Reason: {_require_text(data, 'reason')}",
+                f"- Capability Basis: {capability_basis}",
+                f"- Continuation Mode: {continuation_mode}",
+                f"- Reviewer Replacements: {reviewer_replacements}",
                 f"- Fallback: {_require_text(data, 'fallback')}",
                 f"- Final State Independently Rechecked: {rechecked}",
             ]

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

@@ -19,10 +19,12 @@ 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. |
-| `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. |
+| `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. |
 | `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.
+Do not discover another artifact root or infer the operation from provider, platform, prompt style, tracking policy, or human availability.
 
 ## Stage Boundary
 
@@ -30,18 +32,26 @@ This Skill owns only final-change inspection and its selected commit operation.
 
 In preparation mode it must not stage, unstage, commit, amend, reset, merge, or push.
 
+## Framework Directory and Git Policy
+
+`.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/**`.
+
+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.
+
 ## Step 1: Validate Supplied Evidence and Final Change
 
-1. Resolve `artifact_dir` and every `evidence_paths` entry exactly as supplied by the caller.
-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 changed path belongs to the supplied change, a concrete dependency, its tests, durable documentation, or caller-required artifacts.
-5. Reject unresolved merge state and sensitive files such as real environment files, credentials, secrets, private keys, certificates, or local settings.
-6. Confirm no requested task output remains to be generated after this stage.
+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.
+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.
 
-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.
+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.
 
-## Step 2: Build Commit Message and Intended Path Set
+## Step 2: Classify Paths and Build the Exact Manifest
 
 Generate one concise Conventional Commit message:
 
@@ -49,33 +59,34 @@ Generate one concise Conventional Commit message:
 <type>(<scope>): <description>
 ```
 
-Classify every observed change before constructing the request. All paths under `.prizmkit/` are framework-internal and remain outside automated task commits.
+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.
 
-- **task-owned**: justified source, tests, product/project documentation, configuration, and dependency changes outside recognized support namespaces;
-- **PrizmKit-internal**: every path under `.prizmkit/`, including config, plans, Prizm docs, lifecycle Artifacts, installed Runtime files, and state;
-- **platform support**: `AGENTS.md`, `skills-lock.json`, installed platform directories, and local platform settings;
-- **project transient**: data the project already excludes through Git ignore rules;
-- **unknown Git-visible**: any remaining path whose task 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.
 
-Build a unique set of exact project-relative **task-owned** changed paths. Include intended tracked modifications, deletions, renames, new source/tests, and justified project documentation outside support namespaces. Exclude:
+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.
 
-- `.git/`;
-- the complete `.prizmkit/` tree;
-- `AGENTS.md`, `skills-lock.json`, installed platform directories, and local platform settings;
-- sensitive or unrelated files.
+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.
 
-Unknown Git-visible paths block the 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` as an intended-path description. 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.
+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.
 
 ## Step 3A: Interactive Commit
 
 For `operation=interactive-commit`:
 
-1. Present intended paths, change summary, sensitive-file warnings, diff statistics, proposed message, and intentionally excluded changes.
+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 tracked changes safely and new files explicitly.
-4. Verify the staged diff exactly matches the confirmed path set.
-5. Create the local commit and verify its hash, committed paths, and remaining workspace changes.
-6. Return `COMMITTED`, the commit hash/message, committed paths, and intentional remaining changes.
+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.
 
 If confirmation is declined, return `COMMIT_DECLINED` without Git mutation.
 
@@ -83,9 +94,9 @@ 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:
+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`.
+3. Write this JSON atomically without Git mutation:
 
 ```json
 {
@@ -94,23 +105,24 @@ For `operation=prepare-runtime-commit`:
   "base_head": "<full current HEAD hash>",
   "commit_message": "feat(scope): concise description",
   "intended_paths": [
-    "src/example.py",
-    "tests/test_example.py"
+    ".prizmkit/prizm-docs/example.prizm",
+    "src/example.py"
   ]
 }
 ```
 
 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.
+   - `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.
 6. Stop.
 
-The request is preparation data. Its consumer independently validates it before any Git mutation.
+The Python Runtime independently revalidates exact changed/staged/committed sets, safety, base/message/receipt, and post-commit bookkeeping order.
 
 ## Output