prizmkit 1.1.159 → 1.1.161

package/bundled/VERSION.json

@@ -1,5 +1,5 @@
 {
-  "frameworkVersion": "1.1.159",
-  "bundledAt": "2026-07-28T08:35:59.394Z",
-  "bundledFrom": "7908918"
+  "frameworkVersion": "1.1.161",
+  "bundledAt": "2026-07-29T09:12:57.978Z",
+  "bundledFrom": "5ba2929"
 }

package/bundled/adapters/codebuddy/settings-adapter.js

@@ -1,15 +1,78 @@
 /**
- * CodeBuddy Settings Adapter
- * Generates .codebuddy/settings.json with PrizmKit hooks and permissions.
+ * CodeBuddy settings adapter.
+ * Replaces only deterministic PrizmKit-managed hook entries and preserves user settings.
  */
 
 import { existsSync, mkdirSync } from 'node:fs';
 import { readFile, writeFile } from 'node:fs/promises';
-import path from 'path';
+import path from 'node:path';
+
+const MANAGED_MARKERS = [
+  '.prizmkit/scripts/commit-intent-status.py',
+  '.prizmkit/scripts/post-command-prizm-drift.py',
+  'PRIZMKIT_DOC_UPDATE_REQUIRED',
+];
+
+function isManaged(entry) {
+  let serialized;
+  try {
+    serialized = JSON.stringify(entry);
+  } catch {
+    return false;
+  }
+  return MANAGED_MARKERS.some(marker => serialized.includes(marker));
+}
+
+function mergeManagedHooks(existingHooks = {}, managedHooks = {}) {
+  if (!existingHooks || typeof existingHooks !== 'object' || Array.isArray(existingHooks)) {
+    throw new Error('Cannot preserve malformed CodeBuddy hooks: hooks must be an object');
+  }
+  const merged = {};
+  for (const [event, entries] of Object.entries(existingHooks)) {
+    if (!Array.isArray(entries)) {
+      throw new Error(`Cannot preserve malformed CodeBuddy hooks: ${event} must be an array`);
+    }
+    merged[event] = entries.filter(entry => !isManaged(entry));
+  }
+  for (const [event, entries] of Object.entries(managedHooks)) {
+    if (!Array.isArray(entries)) {
+      throw new Error(`Managed CodeBuddy hook template is invalid: ${event} must be an array`);
+    }
+    merged[event] = [
+      ...(Array.isArray(merged[event]) ? merged[event] : []),
+      ...entries,
+    ];
+  }
+  return merged;
+}
+
+const MANAGED_HOOKS = {
+  UserPromptSubmit: [
+    {
+      matcher: '(?i)\\b(commit|push|finish|ship|merge|pull request|pr)\\b|提交|推送|收尾|完成任务|合并|发版|发布',
+      hooks: [
+        {
+          type: 'command',
+          command: 'node .prizmkit/scripts/run-python-hook.cjs .prizmkit/scripts/commit-intent-status.py',
+        },
+      ],
+    },
+  ],
+  PostToolUse: [
+    {
+      matcher: '.*',
+      hooks: [
+        {
+          type: 'command',
+          command: 'node .prizmkit/scripts/run-python-hook.cjs .prizmkit/scripts/post-command-prizm-drift.py',
+        },
+      ],
+    },
+  ],
+};
 
 /**
- * Generate CodeBuddy settings.json for a PrizmKit-enabled project.
- * @param {string} targetRoot - Target project root
+ * @param {string} targetRoot
  * @param {Object} options - { hooks: boolean }
  */
 export async function generateSettings(targetRoot, options = {}) {
@@ -20,28 +83,16 @@ export async function generateSettings(targetRoot, options = {}) {
   if (existsSync(settingsPath)) {
     try {
       existing = JSON.parse(await readFile(settingsPath, 'utf8'));
-    } catch {
-      existing = {};
+    } catch (error) {
+      throw new Error(`Cannot preserve malformed CodeBuddy settings: ${error.message}`);
     }
-  }
-
-  // Merge PrizmKit hooks
-  if (options.hooks !== false) {
-    if (!existing.hooks) existing.hooks = {};
-    if (!existing.hooks.UserPromptSubmit) {
-      existing.hooks.UserPromptSubmit = [
-        {
-          matcher: '(?i)\\b(commit|push|finish|ship|merge|pull request|pr)\\b|提交|推送|收尾|完成任务|合并|发版|发布',
-          hooks: [
-            {
-              type: 'prompt',
-              prompt: 'You are a commit-intent detector for PrizmKit. Analyze the user prompt and determine if the user intends to COMMIT, PUSH, FINISH, SHIP, MERGE, or create a PULL REQUEST.\n\nUser prompt: $ARGUMENTS\n\nIF commit intent detected, respond with:\n{"ok": true, "reason": "PRIZMKIT_DOC_UPDATE_REQUIRED: Before committing, you MUST update .prizmkit/prizm-docs/ per Prizm auto-update protocol. Steps: 1) Run git diff --cached --name-status. 2) Map changed files to modules via root.prizm MODULE_INDEX. 3) Read and update affected .prizm files (only changed sections). 4) Append to changelog.prizm. 5) Stage .prizm files with git add .prizmkit/prizm-docs/. 6) Then proceed with commit using prizmkit-committer workflow. RULES: Never rewrite entire .prizm files. Never add prose. Only update affected sections."}\n\nIF no commit intent, respond with:\n{"ok": true}\n\nRespond with JSON only. No explanation.',
-            },
-          ],
-        },
-      ];
+    if (!existing || typeof existing !== 'object' || Array.isArray(existing)) {
+      throw new Error('Cannot preserve malformed CodeBuddy settings: root must be an object');
     }
   }
 
-  await writeFile(settingsPath, JSON.stringify(existing, null, 2));
+  const settings = options.hooks === false
+    ? existing
+    : { ...existing, hooks: mergeManagedHooks(existing.hooks, MANAGED_HOOKS) };
+  await writeFile(settingsPath, JSON.stringify(settings, null, 2));
 }

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

@@ -17,8 +17,15 @@ PIPELINE_METADATA_EXCLUDES = (
     ":(top,exclude,glob).*/worktree/**",
     ":(top,exclude,glob).*/worktrees",
     ":(top,exclude,glob).*/worktrees/**",
-    ":(top,exclude).prizmkit",
-    ":(top,exclude,glob).prizmkit/**",
+    ":(top,exclude).prizmkit/dev-pipeline",
+    ":(top,exclude,glob).prizmkit/dev-pipeline/**",
+    ":(top,exclude).prizmkit/state",
+    ":(top,exclude,glob).prizmkit/state/**",
+    ":(top,exclude).prizmkit/scripts",
+    ":(top,exclude,glob).prizmkit/scripts/**",
+    ":(top,exclude).prizmkit/manifest.json",
+    ":(top,exclude,glob).prizmkit/specs/**/workflow-checkpoint.json",
+    ":(top,exclude,glob).prizmkit/specs/**/runtime-commit-request.json",
 )
 
 HIDDEN_TOOL_WORKTREE_EXCLUDES = (

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 = ""
 
 
@@ -106,9 +101,9 @@ def finalize_runtime_commit(
             return RuntimeCommitResult("not_ready", "runtime_commit_already_finalized")
         return RuntimeCommitResult("failed", error or "invalid_commit_request")
 
-    if any(_is_tracked(root, path) for path in (request_path, checkpoint)):
-        return RuntimeCommitResult("failed", "runtime_metadata_must_be_untracked")
-
+    # Request/checkpoint paths are excluded by their exact Runtime bookkeeping role.
+    # They may be project-tracked; commit verification below ensures their pre/post-
+    # commit writes never enter the prepared snapshot.
     current_head = _git(root, "rev-parse", "HEAD")
     if current_head.return_code != 0:
         return RuntimeCommitResult("failed", "git_head_unavailable")
@@ -120,21 +115,58 @@ 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")
-        if _git(root, "diff", "--cached", "--quiet", "--exit-code").return_code == 0:
+        staged_paths = _git(
+            root, "diff", "--cached", "--name-only", "--no-renames", "-z",
+        )
+        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(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",
@@ -196,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):
@@ -215,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"
@@ -235,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]:
@@ -285,42 +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
-    return lower_path == ".prizmkit" or lower_path.startswith(".prizmkit/")
+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, ...]:
@@ -341,9 +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:
-    pathspecs = tuple(f":(top,literal){path}" for path in paths)
-    return _git(project_root, "add", "-A", "--", *pathspecs)
+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:
@@ -357,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)
     )
 
 
@@ -378,14 +448,6 @@ def _record_runtime_commit_hash(path: Path, commit_hash: str) -> str:
     return "commit_request_hash_record_failed" if error else ""
 
 
-def _is_tracked(project_root: Path, path: Path) -> bool:
-    try:
-        relative = path.relative_to(project_root).as_posix()
-    except ValueError:
-        return True
-    return _git(project_root, "ls-files", "--error-unmatch", "--", relative).return_code == 0
-
-
 def _finalize_checkpoint(
     path: Path,
     *,

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, all `.prizmkit/**` paths are PrizmKit-internal and stay outside `intended_paths` together with recognized platform support; project-specific transient data must already be Git-ignored, while unknown Git-visible paths block. 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, all `.prizmkit/**` paths are PrizmKit-internal and stay outside `intended_paths`, together with `AGENTS.md`, `skills-lock.json`, installed platform directories, and local platform settings. Project-specific transient data must already be covered by Git ignore rules. Unknown Git-visible paths are not silently ignored: justify and include them as task output or block.
+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.
 
 ---