prizmkit 1.1.160 → 1.1.161

package/bundled/VERSION.json

@@ -1,5 +1,5 @@
 {
-  "frameworkVersion": "1.1.160",
-  "bundledAt": "2026-07-28T13:41:42.840Z",
-  "bundledFrom": "cd9688c"
+  "frameworkVersion": "1.1.161",
+  "bundledAt": "2026-07-29T09:12:57.978Z",
+  "bundledFrom": "5ba2929"
 }

package/bundled/dev-pipeline/prizmkit_runtime/heartbeat.py

@@ -59,17 +59,19 @@ def _file_size(path: Path | None) -> int:
         return 0
 
 
-def _progress_signature(path: Path | None) -> tuple[str, str]:
+def _progress_signature(path: Path | None) -> tuple[str, str, bool]:
     if path is None or not path.is_file():
-        return "", ""
+        return "", "", False
     try:
         data = json.loads(path.read_text(encoding="utf-8"))
     except (OSError, json.JSONDecodeError):
-        return "", ""
+        return "", "", False
+    current_tool = data.get("current_tool")
+    tool_active = isinstance(current_tool, str) and bool(current_tool.strip())
     child_signature = str(data.get("child_activity_signature") or "")
     signature = json.dumps(
         [
-            data.get("current_tool") or "",
+            current_tool or "",
             int(data.get("message_count") or 0),
             int(data.get("total_tool_calls") or 0),
             int(data.get("active_subagent_count") or 0),
@@ -81,7 +83,7 @@ def _progress_signature(path: Path | None) -> tuple[str, str]:
         ],
         separators=(",", ":"),
     )
-    return signature, child_signature
+    return signature, child_signature, tool_active
 
 
 def observe_heartbeat_state(
@@ -91,13 +93,14 @@ def observe_heartbeat_state(
     """Observe log/progress activity and compute staleness."""
     now = time.time()
     log_size = _file_size(config.session_log)
-    progress_signature, child_signature = _progress_signature(config.progress_file)
+    progress_signature, child_signature, tool_active = _progress_signature(config.progress_file)
     prev_log_size = previous.log_size if previous else 0
     progressed = (
         previous is None
         or log_size > prev_log_size
         or (progress_signature and progress_signature != previous.progress_signature)
         or (child_signature and child_signature != previous.child_activity_signature)
+        or tool_active
     )
     if progressed:
         last_seen_epoch = now

package/bundled/dev-pipeline/prizmkit_runtime/runtime_commit.py

@@ -9,17 +9,15 @@ import subprocess
 import tempfile
 from dataclasses import dataclass
 from pathlib import Path, PurePosixPath
-from typing import Mapping, Sequence
+from typing import Mapping
 
 from .checkpoint_state import (
     load_checkpoint_state,
     semantic_state_key,
     validate_checkpoint_data,
 )
-from .gitops import HIDDEN_TOOL_WORKTREE_EXCLUDES
-
 REQUEST_FILENAME = "runtime-commit-request.json"
-REQUEST_SCHEMA_VERSION = 1
+REQUEST_SCHEMA_VERSION = 2
 _HEX_COMMIT = re.compile(r"^[0-9a-fA-F]{40,64}$")
 _FORBIDDEN_EXACT_PATHS = {
     ".claude/settings.local.json",
@@ -37,8 +35,6 @@ _SENSITIVE_NAMES = {
     "secrets.json",
 }
 _SENSITIVE_SUFFIXES = {".pem", ".p12", ".pfx"}
-_SUPPORT_ROOT_FILES = {"agents.md", "skills-lock.json"}
-_SUPPORT_ROOT_DIRS = {".claude", ".codebuddy", ".codex", ".agents", ".pi"}
 
 
 @dataclass(frozen=True)
@@ -48,7 +44,6 @@ class RuntimeCommitRequest:
     artifact_dir: str
     base_head: str
     commit_message: str
-    intended_paths: tuple[str, ...]
     runtime_commit_hash: str = ""
 
 
@@ -120,17 +115,37 @@ def finalize_runtime_commit(
             return RuntimeCommitResult("failed", "premature_runtime_commit_hash")
         if state.semantic_complete:
             return RuntimeCommitResult("failed", "completed_checkpoint_without_commit")
-        changed, status_error = _task_visible_changed_paths(
+        unmerged = _git(root, "ls-files", "-u")
+        if unmerged.return_code != 0:
+            return RuntimeCommitResult("failed", "git_unmerged_state_unavailable")
+        if unmerged.stdout.strip():
+            return RuntimeCommitResult("failed", "unresolved_merge_state")
+        changed, status_error = _workspace_changed_paths(
             root,
-            artifact_dir=artifact,
             checkpoint_path=checkpoint,
             request_path=request_path,
         )
         if status_error:
             return RuntimeCommitResult("failed", status_error)
-        if set(changed) != set(request.intended_paths):
-            return RuntimeCommitResult("failed", "intended_paths_mismatch")
-        staged = _stage_intended_paths(root, request.intended_paths)
+        if not changed:
+            return RuntimeCommitResult("failed", "empty_workspace_change")
+        unsafe = next((path for path in changed if _sensitive_commit_path(path)), "")
+        if unsafe:
+            return RuntimeCommitResult("failed", "sensitive_workspace_path")
+        bookkeeping_staged = _staged_bookkeeping_paths(
+            root,
+            checkpoint_path=checkpoint,
+            request_path=request_path,
+        )
+        if bookkeeping_staged is None:
+            return RuntimeCommitResult("failed", "git_staged_set_unavailable")
+        if bookkeeping_staged:
+            return RuntimeCommitResult("failed", "runtime_bookkeeping_staged")
+        staged = _stage_workspace(
+            root,
+            checkpoint_path=checkpoint,
+            request_path=request_path,
+        )
         if staged.return_code != 0:
             return RuntimeCommitResult("failed", "git_stage_failed")
         staged_paths = _git(
@@ -139,10 +154,19 @@ def finalize_runtime_commit(
         if staged_paths.return_code != 0:
             return RuntimeCommitResult("failed", "git_staged_set_unavailable")
         staged_set = {path for path in staged_paths.stdout.split("\0") if path}
-        if staged_set != set(request.intended_paths):
-            return RuntimeCommitResult("failed", "staged_paths_mismatch")
+        if staged_set != set(changed):
+            return RuntimeCommitResult("failed", "staged_workspace_mismatch")
         if not staged_set:
             return RuntimeCommitResult("failed", "empty_staged_change")
+        unstaged_candidates = _workspace_has_unstaged_candidates(
+            root,
+            checkpoint_path=checkpoint,
+            request_path=request_path,
+        )
+        if unstaged_candidates is None:
+            return RuntimeCommitResult("failed", "git_workspace_verification_failed")
+        if unstaged_candidates:
+            return RuntimeCommitResult("failed", "workspace_changed_during_staging")
         committed = _git(
             root,
             "-c", "core.hooksPath=/dev/null",
@@ -204,7 +228,7 @@ def _load_request(
     if not isinstance(raw, Mapping) or raw.get("schema_version") != REQUEST_SCHEMA_VERSION:
         return None, "commit_request_invalid_schema"
     required_keys = {
-        "schema_version", "artifact_dir", "base_head", "commit_message", "intended_paths",
+        "schema_version", "artifact_dir", "base_head", "commit_message",
     }
     allowed_keys = required_keys | {"runtime_commit_hash"}
     if not required_keys.issubset(raw) or not set(raw).issubset(allowed_keys):
@@ -223,18 +247,6 @@ def _load_request(
     if not message or "\n" in message or len(message) > 240:
         return None, "commit_request_message_invalid"
 
-    raw_paths = raw.get("intended_paths")
-    if not isinstance(raw_paths, list) or not raw_paths:
-        return None, "commit_request_paths_invalid"
-    intended: list[str] = []
-    for value in raw_paths:
-        relative = _safe_relative_path(value)
-        if relative is None or _forbidden_commit_path(relative, expected_artifact):
-            return None, "commit_request_path_unsafe"
-        intended.append(relative)
-    if len(intended) != len(set(intended)):
-        return None, "commit_request_paths_duplicate"
-
     runtime_commit_hash = str(raw.get("runtime_commit_hash") or "").strip()
     if runtime_commit_hash and not _HEX_COMMIT.fullmatch(runtime_commit_hash):
         return None, "runtime_commit_hash_invalid"
@@ -243,45 +255,25 @@ def _load_request(
         artifact_dir=expected_artifact,
         base_head=base_head.lower(),
         commit_message=message,
-        intended_paths=tuple(intended),
         runtime_commit_hash=runtime_commit_hash.lower(),
     ), ""
 
 
-def _safe_relative_path(value: object) -> str | None:
-    text = str(value or "").strip().replace("\\", "/")
-    if not text or text.startswith("/") or re.match(r"^[A-Za-z]:/", text):
-        return None
-    path = PurePosixPath(text)
-    if path.is_absolute() or any(part in {"", ".", ".."} for part in path.parts):
-        return None
-    return path.as_posix()
-
-
-def _forbidden_commit_path(path: str, artifact_dir: str) -> bool:
+def _sensitive_commit_path(path: str) -> bool:
     lower = path.lower()
     name = PurePosixPath(lower).name
     if lower in _FORBIDDEN_EXACT_PATHS:
         return True
     if lower == ".git" or lower.startswith(".git/"):
         return True
-    if _known_support_path(lower):
-        return True
-    artifact_prefix = artifact_dir.lower().rstrip("/") + "/"
-    if lower in {
-        artifact_prefix + REQUEST_FILENAME,
-        artifact_prefix + "workflow-checkpoint.json",
-    }:
-        return True
     if name in _SENSITIVE_NAMES or (name.startswith(".env.") and name != ".env.example"):
         return True
     return PurePosixPath(lower).suffix in _SENSITIVE_SUFFIXES
 
 
-def _task_visible_changed_paths(
+def _workspace_changed_paths(
     project_root: Path,
     *,
-    artifact_dir: Path,
     checkpoint_path: Path,
     request_path: Path,
 ) -> tuple[tuple[str, ...], str]:
@@ -293,56 +285,31 @@ def _task_visible_changed_paths(
         "--untracked-files=all",
         "--",
         ".",
-        *HIDDEN_TOOL_WORKTREE_EXCLUDES,
     )
     if result.return_code != 0:
         return (), "git_status_failed"
-    local_paths = {
-        checkpoint_path.relative_to(project_root).as_posix(),
-        request_path.relative_to(project_root).as_posix(),
-    }
-    visible = []
-    for path in _status_record_paths(result.stdout):
-        if path in local_paths:
-            continue
-        if _known_support_path(path.lower()) or path.lower() in _FORBIDDEN_EXACT_PATHS:
-            continue
-        visible.append(path)
+    local_paths = _runtime_bookkeeping_paths(
+        project_root,
+        checkpoint_path=checkpoint_path,
+        request_path=request_path,
+    )
+    visible = [
+        path for path in _status_record_paths(result.stdout)
+        if path not in local_paths
+    ]
     return tuple(dict.fromkeys(visible)), ""
 
 
-def _known_support_path(lower_path: str) -> bool:
-    path = PurePosixPath(lower_path)
-    parts = path.parts
-    if lower_path in _SUPPORT_ROOT_FILES:
-        return True
-    if parts and parts[0] in _SUPPORT_ROOT_DIRS:
-        return True
-    if lower_path == ".prizmkit-worktree" or lower_path.startswith(
-        ".prizmkit-worktree/"
-    ):
-        return True
-    if (
-        len(parts) >= 2
-        and parts[0].startswith(".")
-        and parts[1] in {"worktree", "worktrees"}
-    ):
-        return True
-    if lower_path in {".prizmkit/manifest.json"}:
-        return True
-    if any(
-        lower_path == prefix or lower_path.startswith(prefix + "/")
-        for prefix in (
-            ".prizmkit/dev-pipeline",
-            ".prizmkit/state",
-            ".prizmkit/scripts",
-        )
-    ):
-        return True
-    return (
-        lower_path.startswith(".prizmkit/specs/")
-        and path.name in {REQUEST_FILENAME, "workflow-checkpoint.json"}
-    )
+def _runtime_bookkeeping_paths(
+    project_root: Path,
+    *,
+    checkpoint_path: Path,
+    request_path: Path,
+) -> set[str]:
+    return {
+        checkpoint_path.relative_to(project_root).as_posix(),
+        request_path.relative_to(project_root).as_posix(),
+    }
 
 
 def _status_record_paths(stdout: str) -> tuple[str, ...]:
@@ -363,22 +330,85 @@ def _status_record_paths(stdout: str) -> tuple[str, ...]:
     return tuple(dict.fromkeys(path for path in changed if path))
 
 
-def _stage_intended_paths(project_root: Path, paths: Sequence[str]) -> _GitResult:
-    tracked: list[str] = []
-    untracked: list[str] = []
-    for path in paths:
-        pathspec = f":(top,literal){path}"
-        indexed = _git(project_root, "ls-files", "--error-unmatch", "--", pathspec)
-        (tracked if indexed.return_code == 0 else untracked).append(pathspec)
-    if tracked:
-        updated = _git(project_root, "add", "-u", "--", *tracked)
-        if updated.return_code != 0:
-            return updated
-    if untracked:
-        added = _git(project_root, "add", "--", *untracked)
-        if added.return_code != 0:
-            return added
-    return _GitResult(0, "", "")
+def _staged_bookkeeping_paths(
+    project_root: Path,
+    *,
+    checkpoint_path: Path,
+    request_path: Path,
+) -> tuple[str, ...] | None:
+    staged = _git(
+        project_root,
+        "diff",
+        "--cached",
+        "--name-only",
+        "--no-renames",
+        "-z",
+    )
+    if staged.return_code != 0:
+        return None
+    local_paths = _runtime_bookkeeping_paths(
+        project_root,
+        checkpoint_path=checkpoint_path,
+        request_path=request_path,
+    )
+    return tuple(
+        path for path in staged.stdout.split("\0")
+        if path and path in local_paths
+    )
+
+
+def _stage_workspace(
+    project_root: Path,
+    *,
+    checkpoint_path: Path,
+    request_path: Path,
+) -> _GitResult:
+    staged = _git(project_root, "add", "-A", "--", ".")
+    if staged.return_code != 0:
+        return staged
+    local_pathspecs = [
+        f":(top,literal){path}"
+        for path in sorted(
+            _runtime_bookkeeping_paths(
+                project_root,
+                checkpoint_path=checkpoint_path,
+                request_path=request_path,
+            )
+        )
+    ]
+    return _git(project_root, "reset", "-q", "HEAD", "--", *local_pathspecs)
+
+
+def _workspace_has_unstaged_candidates(
+    project_root: Path,
+    *,
+    checkpoint_path: Path,
+    request_path: Path,
+) -> bool | None:
+    local_paths = _runtime_bookkeeping_paths(
+        project_root,
+        checkpoint_path=checkpoint_path,
+        request_path=request_path,
+    )
+    unstaged = _git(project_root, "diff", "--name-only", "--no-renames", "-z")
+    untracked = _git(
+        project_root,
+        "ls-files",
+        "--others",
+        "--exclude-standard",
+        "-z",
+        "--",
+        ".",
+    )
+    if unstaged.return_code != 0 or untracked.return_code != 0:
+        return None
+    candidates = {
+        path
+        for output in (unstaged.stdout, untracked.stdout)
+        for path in output.split("\0")
+        if path and path not in local_paths
+    }
+    return bool(candidates)
 
 
 def _matches_prepared_commit(project_root: Path, request: RuntimeCommitRequest, head: str) -> bool:
@@ -392,12 +422,17 @@ def _matches_prepared_commit(project_root: Path, request: RuntimeCommitRequest,
         return False
     parent_list = parents.stdout.strip().split()
     changed = {path for path in paths.stdout.split("\0") if path}
+    artifact_prefix = request.artifact_dir.rstrip("/") + "/"
+    causal_bookkeeping = {
+        artifact_prefix + REQUEST_FILENAME,
+        artifact_prefix + "workflow-checkpoint.json",
+    }
     return (
         len(parent_list) == 1
         and parent_list[0].lower() == request.base_head.lower()
         and subject.stdout.strip() == request.commit_message
         and bool(changed)
-        and changed == set(request.intended_paths)
+        and changed.isdisjoint(causal_bookkeeping)
     )
 
 

package/bundled/dev-pipeline/templates/bootstrap-prompt.md

@@ -38,7 +38,7 @@ Complete the feature in headless non-interactive mode using the active atomic sk
 5. Invoke `/prizmkit-test scope=this-change artifact_dir=.prizmkit/specs/{{FEATURE_SLUG}}/`. Validate its report/result pair. For `TEST_NEEDS_FIXES`, classify the concrete correction into an allowed `repair_scope`; unknown/unsafe scope blocks, while a safe in-budget route re-enters Implement and requires fresh Review, configured verification, and Test. Do not duplicate the Skill's internal repair loop.
 6. Write `completion-summary.json` before retrospective and commit preparation.
 7. Invoke `/prizmkit-retrospective` with the exact artifact root, non-`.prizmkit/` `change_paths`, and `change_summary`; validate `outcome=RETRO_COMPLETE`.
-8. Before commit preparation, classify paths by semantic role rather than a blanket `.prizmkit/**` rule. Safe Git-visible framework paths may be exact task output; ignored paths remain absent, and exact Runtime bookkeeping/installed support, host support, Secrets, unrelated, or unknown paths remain excluded or blocking. No path is force-added and no ignore policy is changed. After validating every required artifact, invoke `/prizmkit-committer operation=prepare-runtime-commit artifact_dir=.prizmkit/specs/{{FEATURE_SLUG}}/ evidence_paths=<exact paths> excluded_paths=.prizmkit/specs/{{FEATURE_SLUG}}/workflow-checkpoint.json request_path=.prizmkit/specs/{{FEATURE_SLUG}}/runtime-commit-request.json`. Require `COMMIT_REQUEST_READY`; this session then records `COMMIT_PENDING` and stops. The Python runtime executes and verifies the local commit.
+8. Before commit preparation, validate the complete Git-visible workspace regardless of when or where each correct change originated. Final Review/Test authority must cover every behavior-affecting visible change; ignored paths remain local, while merge conflicts, Secrets, sensitive content, stale evidence, and known incorrect or unverifiable content block. After validating every required artifact, invoke `/prizmkit-committer operation=prepare-runtime-commit artifact_dir=.prizmkit/specs/{{FEATURE_SLUG}}/ evidence_paths=<exact paths> request_path=.prizmkit/specs/{{FEATURE_SLUG}}/runtime-commit-request.json`. Require a schema-v2 pathless request and `COMMIT_REQUEST_READY`; this session then records `COMMIT_PENDING` and stops. The Python runtime re-enumerates and commits the complete non-ignored workspace with only exact causal request/checkpoint bookkeeping omitted.
 
 ## Failure Capture
 

package/bundled/dev-pipeline/templates/bootstrap-tier3.md

@@ -448,9 +448,9 @@ Invoke `/prizmkit-retrospective` with the exact artifact root, exact non-`.prizm
 
 **6c. Runtime commit preparation**
 
-Before commit preparation, classify paths by semantic role rather than a blanket `.prizmkit/**` exclusion. Safe Git-visible framework paths may be justified and included as exact task output; ignored paths remain naturally absent. Exact Runtime request/checkpoint/state and installed Runtime/host support stay outside `intended_paths`; Secrets, unrelated, and unknown Git-visible paths block. Never force-add or change/interpret project ignore policy.
+Before commit preparation, validate the complete Git-visible workspace regardless of when or where each correct change originated. Code Review and Test authority must cover every behavior-affecting visible change. Ignored paths remain naturally absent; merge conflicts, Secrets, sensitive content, stale evidence, and known incorrect or unverifiable content block. Never force-add or change/interpret project ignore policy.
 
-After this injected session validates every required artifact, invoke `/prizmkit-committer operation=prepare-runtime-commit artifact_dir=.prizmkit/specs/{{FEATURE_SLUG}}/ evidence_paths=<exact paths> excluded_paths=.prizmkit/specs/{{FEATURE_SLUG}}/workflow-checkpoint.json request_path=.prizmkit/specs/{{FEATURE_SLUG}}/runtime-commit-request.json`. Require `COMMIT_REQUEST_READY`; this session records `COMMIT_PENDING` and stops. The Python runtime validates the request, executes/verifies the local commit, and finalizes checkpoint `COMMITTED`.
+After this injected session validates every required artifact, invoke `/prizmkit-committer operation=prepare-runtime-commit artifact_dir=.prizmkit/specs/{{FEATURE_SLUG}}/ evidence_paths=<exact paths> request_path=.prizmkit/specs/{{FEATURE_SLUG}}/runtime-commit-request.json`. Require a schema-v2 pathless request and `COMMIT_REQUEST_READY`; this session records `COMMIT_PENDING` and stops. The Python runtime re-enumerates and commits the complete non-ignored workspace, omitting only exact causal request/checkpoint bookkeeping, then verifies the local commit and finalizes checkpoint `COMMITTED`.
 
 ## Critical Paths
 

package/bundled/dev-pipeline/templates/bugfix-bootstrap-prompt.md

@@ -245,7 +245,7 @@ Invoke `/prizmkit-retrospective` with the exact artifact root, exact non-`.prizm
 
 **c. Runtime commit preparation**
 
-After this injected session validates every required artifact, invoke `/prizmkit-committer operation=prepare-runtime-commit artifact_dir=.prizmkit/bugfix/{{BUG_ID}}/ evidence_paths=<exact paths> excluded_paths=.prizmkit/bugfix/{{BUG_ID}}/workflow-checkpoint.json request_path=.prizmkit/bugfix/{{BUG_ID}}/runtime-commit-request.json`. Require `COMMIT_REQUEST_READY`; this session records `COMMIT_PENDING` and stops. The Python runtime validates the request, executes/verifies the local commit, finalizes checkpoint `COMMITTED`, and controls any later publication.
+After this injected session validates every required artifact and confirms final Review/Test authority covers the complete behavior-affecting Git-visible workspace, invoke `/prizmkit-committer operation=prepare-runtime-commit artifact_dir=.prizmkit/bugfix/{{BUG_ID}}/ evidence_paths=<exact paths> request_path=.prizmkit/bugfix/{{BUG_ID}}/runtime-commit-request.json`. Require a schema-v2 pathless request and `COMMIT_REQUEST_READY`; this session records `COMMIT_PENDING` and stops. Ignored files remain local. The Python runtime re-enumerates and commits the complete non-ignored workspace with only exact causal request/checkpoint bookkeeping omitted, verifies the local commit, finalizes checkpoint `COMMITTED`, and controls any later publication.
 
 ---
 

package/bundled/dev-pipeline/templates/refactor-bootstrap-prompt.md

@@ -210,7 +210,7 @@ Write `.prizmkit/refactor/{{REFACTOR_ID}}/completion-summary.json` for downstrea
 
 Complete `refactor-report` and `completion-summary` before retrospective. Then invoke `/prizmkit-retrospective` with the exact artifact root, exact non-`.prizmkit/` `change_paths`, and a concise `change_summary`. Validate `outcome=RETRO_COMPLETE`; do not stage or commit.
 
-After this injected session validates every required artifact, invoke `/prizmkit-committer operation=prepare-runtime-commit artifact_dir=.prizmkit/refactor/{{REFACTOR_ID}}/ evidence_paths=<exact paths> excluded_paths=.prizmkit/refactor/{{REFACTOR_ID}}/workflow-checkpoint.json request_path=.prizmkit/refactor/{{REFACTOR_ID}}/runtime-commit-request.json`. Require `COMMIT_REQUEST_READY`; this session records `COMMIT_PENDING` and stops. The Python runtime executes/verifies the local commit, finalizes checkpoint `COMMITTED`, and controls any later publication.
+After this injected session validates every required artifact and confirms final Review/Test authority covers the complete behavior-affecting Git-visible workspace, invoke `/prizmkit-committer operation=prepare-runtime-commit artifact_dir=.prizmkit/refactor/{{REFACTOR_ID}}/ evidence_paths=<exact paths> request_path=.prizmkit/refactor/{{REFACTOR_ID}}/runtime-commit-request.json`. Require a schema-v2 pathless request and `COMMIT_REQUEST_READY`; this session records `COMMIT_PENDING` and stops. Ignored files remain local. The Python runtime re-enumerates and commits the complete non-ignored workspace with only exact causal request/checkpoint bookkeeping omitted, verifies the local commit, finalizes checkpoint `COMMITTED`, and controls any later publication.
 
 ---
 

package/bundled/dev-pipeline/templates/sections/runtime-commit-handoff.md

@@ -5,31 +5,25 @@ The Python runtime, not the AI session, executes the pipeline's local Git commit
 After Code Review, all configured verification, `TEST_PASS`, family reports/summaries, and retrospective have completed:
 
 1. As the session orchestrator, validate every required stage artifact and result first. Atomic Skills do not perform this sequencing check.
-2. Invoke `/prizmkit-committer` with the same artifact root, exact readiness evidence, and request path:
+2. Re-inventory the complete final Git-visible workspace: staged, unstaged, added, deleted, renamed, copied, and non-ignored untracked content. Confirm Code Review and Test authority covers every behavior-affecting change, including correct work that predated this session or lives in framework, generated, instruction, lock, or host-support paths. If production behavior changed after those gates, re-enter them before commit preparation.
+3. Invoke `/prizmkit-committer` with the same artifact root, exact readiness evidence, and request path:
 
    ```text
-   /prizmkit-committer operation=prepare-runtime-commit artifact_dir={{ARTIFACT_DIR}} evidence_paths=<exact validated artifact paths> excluded_paths={{ARTIFACT_DIR}}/workflow-checkpoint.json request_path={{ARTIFACT_DIR}}/runtime-commit-request.json
+   /prizmkit-committer operation=prepare-runtime-commit artifact_dir={{ARTIFACT_DIR}} evidence_paths=<exact validated artifact paths> request_path={{ARTIFACT_DIR}}/runtime-commit-request.json
    ```
 
-3. The committer validates only the supplied evidence and final diff, then classifies paths by semantic role before writing the request:
-   - safe Git-visible `.prizmkit/**` requirement output is admitted like any other exact task path and needs no documentation-specific evidence;
-   - ignored paths remain absent and are never force-added; project ignore policy is not changed or interpreted;
-   - exact Runtime request/checkpoint/state, installed Runtime/host payloads, and local host settings remain support/bookkeeping outside the task commit;
-   - global Secret checks still apply, and every unrelated or unknown Git-visible path blocks rather than disappearing.
-
-   It then rejects sensitive/unrelated/unknown paths, generates one Conventional Commit message, and writes this request without staging or committing:
+4. The committer validates the complete final workspace without a caller-supplied path manifest or provenance classification. Ignored paths remain local and never block or require force-add. Merge conflicts, Secrets, sensitive local content, known incorrect or incoherent changes, unverifiable content, and stale readiness evidence still block. It generates one truthful Conventional Commit message and writes this request without staging or committing:
 
    ```json
    {
-     "schema_version": 1,
+     "schema_version": 2,
      "artifact_dir": "{{ARTIFACT_DIR}}",
      "base_head": "<current HEAD commit hash>",
-     "commit_message": "<type>(<scope>): <description>",
-     "intended_paths": ["<exact project-relative changed path>"]
+     "commit_message": "<type>(<scope>): <description>"
    }
    ```
 
-4. Require the stage-local result `COMMIT_REQUEST_READY`. Then this injected session—not the Skill—marks `prizmkit-committer` `in_progress` with `stage_result=COMMIT_PENDING` through the checkpoint helper. Do not mark it completed or write `COMMITTED`.
-5. Stop normal work after the valid request and checkpoint handoff exist. Do not run `git add`, `git commit`, `git commit --amend`, merge, push, or create additional files.
+5. Require the stage-local result `COMMIT_REQUEST_READY`. Then this injected session—not the Skill—marks `prizmkit-committer` `in_progress` with `stage_result=COMMIT_PENDING` through the checkpoint helper. Do not mark it completed or write `COMMITTED`.
+6. Stop normal work after the valid request and checkpoint handoff exist. Do not run `git add`, `git commit`, `git commit --amend`, merge, push, or create additional task files.
 
-The Runtime validates exact task-owned path coverage outside recognized semantic support/bookkeeping, does not reject a safe path solely because it is under `.prizmkit/**`, stages only requested literal paths, verifies staged/committed set equality and the Git receipt, and only then writes the Runtime-owned receipt/checkpoint and performs configured integration. Those post-commit writes are never inserted retroactively into the committed snapshot or allowed to falsify integration. Unknown Git-visible paths are not silently ignored: they produce a mismatch and preserve the task checkout for recovery. A malformed, stale, unsafe, incomplete, or contradictory request also blocks without deleting user data.
+The Runtime validates the pathless schema, base, complete non-ignored workspace, sensitive path safeguards, merge state, and causal bookkeeping boundary. It stages the complete workspace, omitting only the exact active request/checkpoint whose final receipt cannot truthfully precede the commit; verifies a non-empty commit with the expected parent and message; records its Git receipt; and only then finalizes `COMMITTED` and performs configured integration. A malformed, stale, unsafe, incomplete, or contradictory handoff blocks without deleting user data.

package/bundled/dev-pipeline/tests/test_generate_bootstrap_prompt.py

@@ -1381,6 +1381,9 @@ class TestHeadlessPromptCleanupF033:
                 assert artifact in prompt
             assert "Atomic Skills write only their stage-owned artifacts and domain results" in prompt
             assert "COMMIT_REQUEST_READY" in prompt
+            assert '"schema_version": 2' in prompt
+            assert '"intended_paths"' not in prompt
+            assert "complete final Git-visible workspace" in prompt
             assert "workflow_state_path" not in prompt
             assert "outcome=RETRO_COMPLETE" in prompt
             assert "Never recreate the testing-local repair loop" in prompt
@@ -1554,12 +1557,12 @@ class TestFeatureBootstrapShellExtraction:
         assert "text search . --pattern \"123-prompt-cleanup\" --json" in tier3
         assert "text count .prizmkit/specs/123-prompt-cleanup/plan.md --pattern \"- [ ]\"" in tier3
         assert "/prizmkit-committer operation=prepare-runtime-commit" in tier3
-        assert "Require `COMMIT_REQUEST_READY`; this session records `COMMIT_PENDING`" in tier3
-        assert "The Python runtime validates the request" in tier3
-        assert "classify paths by semantic role rather than a blanket `.prizmkit/**` exclusion" in tier3
-        assert "Safe Git-visible framework paths" in tier3
+        assert "Require a schema-v2 pathless request and `COMMIT_REQUEST_READY`" in tier3
+        assert "The Python runtime re-enumerates and commits the complete non-ignored workspace" in tier3
+        assert "validate the complete Git-visible workspace" in tier3
+        assert "Code Review and Test authority must cover every behavior-affecting visible change" in tier3
+        assert "Ignored paths remain naturally absent" in tier3
         assert "Never force-add or change/interpret project ignore policy" in tier3
-        assert "unknown Git-visible paths block" in tier3
         assert "git add" not in tier3
         assert "git commit" not in tier3
 

package/bundled/dev-pipeline/tests/test_generate_bugfix_prompt.py

@@ -596,8 +596,10 @@ class TestBugfixCheckpointGeneration:
         assert "operation=prepare-runtime-commit" in prompt
         assert "NEVER ask for user confirmation" in prompt
         assert "The Python runtime, not the AI session, executes" in prompt
-        assert "safe Git-visible `.prizmkit/**` requirement output is admitted" in prompt
-        assert "unknown Git-visible path blocks" in prompt
+        assert "complete final Git-visible workspace" in prompt
+        assert '"schema_version": 2' in prompt
+        assert '"intended_paths"' not in prompt
+        assert "Ignored paths remain local" in prompt
         assert "push_authorized\": true" not in prompt
         assert ".prizmkit/bugfix/B-001/" in prompt
         assert "write the session status" not in prompt.lower()

package/bundled/dev-pipeline/tests/test_generate_refactor_prompt.py

@@ -435,8 +435,10 @@ class TestRefactorCheckpointGeneration:
         assert "local_commit_authorized" not in prompt
         assert "operation=prepare-runtime-commit" in prompt
         assert "The Python runtime, not the AI session, executes" in prompt
-        assert "safe Git-visible `.prizmkit/**` requirement output is admitted" in prompt
-        assert "unknown Git-visible path blocks" in prompt
+        assert "complete final Git-visible workspace" in prompt
+        assert '"schema_version": 2' in prompt
+        assert '"intended_paths"' not in prompt
+        assert "Ignored paths remain local" in prompt
         assert "automatic push" not in prompt.lower()
         assert "push_authorized\": true" not in prompt
         assert "write the session status" not in prompt.lower()