prizmkit 1.1.159 → 1.1.160

package/bundled/VERSION.json

@@ -1,5 +1,5 @@
 {
-  "frameworkVersion": "1.1.159",
-  "bundledAt": "2026-07-28T08:35:59.394Z",
-  "bundledFrom": "7908918"
+  "frameworkVersion": "1.1.160",
+  "bundledAt": "2026-07-28T13:41:42.840Z",
+  "bundledFrom": "cd9688c"
 }

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/runtime_commit.py

@@ -106,9 +106,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")
@@ -133,7 +133,15 @@ def finalize_runtime_commit(
         staged = _stage_intended_paths(root, request.intended_paths)
         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(request.intended_paths):
+            return RuntimeCommitResult("failed", "staged_paths_mismatch")
+        if not staged_set:
             return RuntimeCommitResult("failed", "empty_staged_change")
         committed = _git(
             root,
@@ -320,7 +328,21 @@ def _known_support_path(lower_path: str) -> bool:
         and parts[1] in {"worktree", "worktrees"}
     ):
         return True
-    return lower_path == ".prizmkit" or lower_path.startswith(".prizmkit/")
+    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 _status_record_paths(stdout: str) -> tuple[str, ...]:
@@ -342,8 +364,21 @@ def _status_record_paths(stdout: str) -> tuple[str, ...]:
 
 
 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)
+    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 _matches_prepared_commit(project_root: Path, request: RuntimeCommitRequest, head: str) -> bool:
@@ -378,14 +413,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, 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.
 
 ## Failure Capture
 

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

@@ -448,7 +448,7 @@ 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, 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.
 
 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`.
 

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

@@ -11,11 +11,11 @@ After Code Review, all configured verification, `TEST_PASS`, family reports/summ
    /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
    ```
 
-3. The committer validates only the supplied evidence and final diff, then classifies paths before writing the request:
-   - all `.prizmkit/**` paths are PrizmKit-internal and stay outside the task commit, including config, plans, Prizm docs, lifecycle Artifacts, Runtime files, and state;
-   - `AGENTS.md`, `skills-lock.json`, installed platform directories, and local platform settings are support data and stay outside the task commit;
-   - project-specific transient data must already be covered by Git ignore rules;
-   - every other Git-visible path must be justified task output and included exactly, otherwise the handoff blocks.
+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:
 
@@ -32,4 +32,4 @@ After Code Review, all configured verification, `TEST_PASS`, family reports/summ
 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.
 
-The runtime validates exact task-owned path coverage outside recognized internal/support namespaces, rejects a request that explicitly names one of those namespaces, stages only the requested literal paths, executes and verifies the local commit, finalizes the Runtime-owned checkpoint to `COMMITTED`, and then performs its configured merge/publication behavior. 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 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.

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

@@ -1556,9 +1556,10 @@ class TestFeatureBootstrapShellExtraction:
         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 "all `.prizmkit/**` paths are PrizmKit-internal" in tier3
-        assert "project-specific transient data must already be covered by git ignore rules" in tier3.lower()
-        assert "Unknown Git-visible paths are not silently ignored" 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 "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,8 @@ 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 "all `.prizmkit/**` paths are PrizmKit-internal" in prompt
-        assert "Unknown Git-visible paths are not silently ignored" in prompt
+        assert "safe Git-visible `.prizmkit/**` requirement output is admitted" in prompt
+        assert "unknown Git-visible path blocks" 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,8 @@ 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 "all `.prizmkit/**` paths are PrizmKit-internal" in prompt
-        assert "Unknown Git-visible paths are not silently ignored" in prompt
+        assert "safe Git-visible `.prizmkit/**` requirement output is admitted" in prompt
+        assert "unknown Git-visible path blocks" 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()

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

@@ -229,18 +229,18 @@ def test_runtime_commit_executes_exact_request_and_finalizes_only_checkpoint(tmp
         ".prizmkit/prizm-docs/src/counter.prizm",
     ],
 )
-def test_runtime_commit_excludes_tracked_prizmkit_internal_paths(tmp_path, durable_path):
+def test_runtime_commit_admits_tracked_prizmkit_path_in_exact_request(tmp_path, durable_path):
     _init_repo(tmp_path)
     durable = tmp_path / durable_path
     durable.parent.mkdir(parents=True, exist_ok=True)
     durable.write_text("before\n", encoding="utf-8")
     _git(tmp_path, "add", "-f", durable_path)
-    _git(tmp_path, "commit", "-m", "track durable PrizmKit project data")
+    _git(tmp_path, "commit", "-m", "track project-selected PrizmKit data")
     base_head = _git(tmp_path, "rev-parse", "HEAD")
     artifact_dir, checkpoint_path = _write_commit_ready_checkpoint(tmp_path)
     (tmp_path / "tracked.txt").write_text("after\n", encoding="utf-8")
     durable.write_text("after\n", encoding="utf-8")
-    _write_request(tmp_path, artifact_dir, base_head, ["tracked.txt"])
+    _write_request(tmp_path, artifact_dir, base_head, ["tracked.txt", durable_path])
 
     result = finalize_runtime_commit(
         tmp_path,
@@ -249,21 +249,16 @@ def test_runtime_commit_excludes_tracked_prizmkit_internal_paths(tmp_path, durab
     )
 
     assert result.status == "committed", result
-    assert _git(
+    changed = set(_git(
         tmp_path,
         "diff-tree",
         "--no-commit-id",
         "--name-only",
         "-r",
         "HEAD",
-    ) == "tracked.txt"
+    ).splitlines())
+    assert changed == {"tracked.txt", durable_path}
     assert durable.read_text(encoding="utf-8") == "after\n"
-    assert durable_path in _git(
-        tmp_path,
-        "status",
-        "--short",
-        "--untracked-files=all",
-    )
 
 
 def test_runtime_commit_ignores_runner_support_paths_but_leaves_them_unmodified(tmp_path):
@@ -520,8 +515,7 @@ def test_runtime_commit_handles_rename_as_exact_delete_and_add(tmp_path):
         "skills-lock.json",
         ".codex/config.toml",
         ".CLAUDE/settings.local.json",
-        ".prizmkit/config.json",
-        ".prizmkit/prizm-docs/src/counter.prizm",
+        ".prizmkit/prizm-docs/.env",
         ".prizmkit/state/runtime.json",
         ".prizmkit/dev-pipeline/cli.py",
         ".prizmkit/scripts/helper.py",
@@ -547,6 +541,67 @@ def test_runtime_commit_rejects_unsafe_intended_paths(tmp_path, unsafe_path):
     assert _git(tmp_path, "rev-parse", "HEAD") == base_head
 
 
+def test_runtime_commit_verifies_staged_set_before_commit(tmp_path):
+    _init_repo(tmp_path)
+    support = tmp_path / "AGENTS.md"
+    support.write_text("before\n", encoding="utf-8")
+    _git(tmp_path, "add", "AGENTS.md")
+    _git(tmp_path, "commit", "-m", "track support")
+    base_head = _git(tmp_path, "rev-parse", "HEAD")
+    artifact_dir, checkpoint_path = _write_commit_ready_checkpoint(tmp_path)
+    (tmp_path / "tracked.txt").write_text("after\n", encoding="utf-8")
+    support.write_text("after\n", encoding="utf-8")
+    _git(tmp_path, "add", "AGENTS.md")
+    _write_request(tmp_path, artifact_dir, base_head, ["tracked.txt"])
+
+    result = finalize_runtime_commit(
+        tmp_path,
+        artifact_dir=artifact_dir,
+        checkpoint_path=checkpoint_path,
+    )
+
+    assert result.status == "failed"
+    assert result.reason == "staged_paths_mismatch"
+    assert _git(tmp_path, "rev-parse", "HEAD") == base_head
+
+
+def test_runtime_commit_keeps_tracked_post_commit_bookkeeping_out_of_snapshot(tmp_path):
+    from prizmkit_runtime.gitops import HIDDEN_TOOL_WORKTREE_EXCLUDES
+
+    initial_head = _init_repo(tmp_path)
+    artifact_dir, checkpoint_path = _write_commit_ready_checkpoint(tmp_path)
+    request_path = _write_request(tmp_path, artifact_dir, initial_head, ["tracked.txt"])
+    checkpoint_rel = checkpoint_path.relative_to(tmp_path).as_posix()
+    request_rel = request_path.relative_to(tmp_path).as_posix()
+    _git(tmp_path, "add", "-f", checkpoint_rel, request_rel)
+    _git(tmp_path, "commit", "-m", "track runtime bookkeeping by project policy")
+    base_head = _git(tmp_path, "rev-parse", "HEAD")
+    _write_request(tmp_path, artifact_dir, base_head, ["tracked.txt"])
+    (tmp_path / "tracked.txt").write_text("after\n", encoding="utf-8")
+
+    result = finalize_runtime_commit(
+        tmp_path,
+        artifact_dir=artifact_dir,
+        checkpoint_path=checkpoint_path,
+    )
+
+    assert result.status == "committed", result
+    assert _git(tmp_path, "diff-tree", "--no-commit-id", "--name-only", "-r", "HEAD") == "tracked.txt"
+    assert checkpoint_rel not in _git(tmp_path, "diff-tree", "--no-commit-id", "--name-only", "-r", "HEAD")
+    visible = _git(
+        tmp_path,
+        "status",
+        "--porcelain",
+        "--",
+        ".",
+        *HIDDEN_TOOL_WORKTREE_EXCLUDES,
+    )
+    assert visible == ""
+    raw_status = _git(tmp_path, "status", "--porcelain", "--", checkpoint_rel, request_rel)
+    assert checkpoint_rel in raw_status
+    assert request_rel in raw_status
+
+
 def test_runtime_commit_rejects_caller_orchestration_fields(tmp_path):
     base_head = _init_repo(tmp_path)
     artifact_dir, checkpoint_path = _write_commit_ready_checkpoint(tmp_path)

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

@@ -3621,8 +3621,11 @@ def test_git_status_safe_ignores_worktree_support_assets(monkeypatch, tmp_path):
     joined = " ".join(status_args)
     assert ":(top,exclude).prizmkit-worktree" in status_args
     assert ":(top,exclude).claude" in status_args
-    assert ":(top,exclude).prizmkit" in status_args
-    assert ":(top,exclude,glob).prizmkit/**" in status_args
+    assert ":(top,exclude).prizmkit" not in status_args
+    assert ":(top,exclude,glob).prizmkit/**" not in status_args
+    assert ":(top,exclude,glob).prizmkit/dev-pipeline/**" in status_args
+    assert ":(top,exclude,glob).prizmkit/state/**" in status_args
+    assert ":(top,exclude,glob).prizmkit/specs/**/workflow-checkpoint.json" in status_args
     assert all(exclude in status_args for exclude in HIDDEN_TOOL_WORKTREE_EXCLUDES)
     assert ".prizmkit-worktree" in joined
 
@@ -3883,7 +3886,7 @@ def test_materialize_worktree_support_assets_copies_ignored_assets_without_retir
     assert guarded_worktree_remove(runtime, delete_branch=False).ok
 
 
-def test_linked_worktree_fast_forwards_with_dirty_prizmkit_internal_state(tmp_path):
+def test_linked_worktree_rejects_dirty_tracked_prizmkit_config(tmp_path):
     from prizmkit_runtime.gitops import (
         BranchContext,
         WorktreePolicy,
@@ -3930,10 +3933,11 @@ def test_linked_worktree_fast_forwards_with_dirty_prizmkit_internal_state(tmp_pa
     assert branch_fast_forward_possible(repo, runtime.context) is True
     result = merge_linked_worktree(runtime)
 
-    assert result.ok is True
-    assert not any(item.args and item.args[0] == "rebase" for item in result.results)
-    assert (repo / "feature.txt").read_text(encoding="utf-8") == "done\n"
+    assert result.ok is False
+    assert result.reason == "dirty_task_checkout"
+    assert not (repo / "feature.txt").exists()
     assert json.loads(worktree_config.read_text(encoding="utf-8"))["mode"] == "session-local"
+    worktree_config.write_text('{"mode":"base"}\n', encoding="utf-8")
     assert guarded_worktree_remove(runtime, delete_branch=True).ok
 
 

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

@@ -2,10 +2,10 @@
 description: "PrizmKit commit workflow rules"
 ---
 
-Before any git commit in this project:
-1. Run `/prizmkit-retrospective` to sync `.prizmkit/prizm-docs/` (architecture index with TRAPS/RULES/DECISIONS)
-2. Use Conventional Commits format: type(scope): description
-3. Bug fixes use `fix()` prefix, not `feat()`
-4. Bug fixes run retrospective with structural sync only (Job 1)
-5. Use `/prizmkit-committer` command for the pure commit workflow
-6. After commit, `/prizmkit-committer` generates `session-summary.md` (lightweight cross-session handoff, not committed to git)
+For a formal requirement:
+1. Complete `/prizmkit-retrospective` after Test and before Committer; it synchronizes durable documentation or records `NO_DOC_CHANGE` but never stages or commits.
+2. Use `/prizmkit-committer` for one exact local commit operation and Conventional Commit message.
+3. Interactive Committer stages only the user-confirmed exact manifest and verifies staged-set/receipt equality; broad staging and force-add are prohibited.
+4. A Git-visible `.prizmkit/**` requirement path is handled like any other exact intended path and requires no documentation-specific commit evidence. Ignored paths remain absent; project tracking policy is unchanged.
+5. Exact Runtime bookkeeping/support and Secrets remain excluded by semantic role. Secret checks apply globally and no framework-directory exception exists.
+6. Remote publication and deployment remain separate.

package/bundled/rules/prizm/prizm-documentation.md

@@ -11,68 +11,27 @@ globs:
   - "**/*.java"
 ---
 
-WHEN TO UPDATE .prizmkit/prizm-docs/:
-- Feature development (new interface, new module, new behavior) → UPDATE .prizmkit/prizm-docs/
-- Bug fix (fixing broken logic, no structural change) → SKIP, do NOT update
-- Rationale: bugs are incomplete features. Recording bug details causes doc bloat with no AI value.
-- Before modifying any source file, read `.prizmkit/prizm-docs/root.prizm` if it exists to understand project structure.
-
-FORMAT RULES (enforced by pre-commit hook — violations block commit):
-- ALL CAPS section headers: MODULE:, FILES:, RESPONSIBILITY:, etc.
-- KEY: value pairs and dash-prefixed lists only
-- PROHIBITED: prose paragraphs, markdown headers (##/###), code blocks (```), emoji, ASCII art
-- No UPDATED timestamps — git is the authoritative source for temporal information
-- PROHIBITED: CHANGELOG sections/files, UPDATED/date metadata, feature/bug/refactor/task/session/run/pipeline/workflow IDs, branch names, absolute worktree paths, and `.prizmkit/specs` / `.prizmkit/dev-pipeline` artifact paths
-- This format is designed for AI token efficiency, not human readability. Do not add human-friendly formatting.
-
-SIZE LIMITS (hard — pre-commit hook blocks commits exceeding these):
-- L0 root.prizm: 4KB max
-- L1 module.prizm: 4KB max
-- L2 detail.prizm: 5KB max
-
-SIZE OVERFLOW HANDLING:
-- L0 approaching 4KB: if MODULE_INDEX has > 15 entries, convert to MODULE_GROUPS format (group by domain). Otherwise consolidate descriptions, keep only top-5 RULES, remove PATTERNS detail.
-- L1 approaching 4KB: trim KEY_FILES descriptions, ensure RULES <= 3 entries, move detail to L2
-- L2 approaching 5KB: remove stale or trivially derivable entries; never create changelog-archive.prizm
-- NEVER exceed hard limits — pre-commit hook will block the commit
-
-REQUIRED FIELDS PER LEVEL:
-
-L0 root.prizm:
-- PRIZM_VERSION
-- PROJECT
-- LANG
-- MODULE_INDEX or MODULE_GROUPS (with -> pointers to L1 files)
-- RULES (top-level project rules)
-
-L1 module.prizm (structural index only):
-- MODULE
-- FILES
-- RESPONSIBILITY
-- DEPENDENCIES
-- L1 does NOT contain: INTERFACES, DATA_FLOW, TRAPS, DECISIONS (those belong in L2)
-
-L2 detail.prizm:
-- MODULE
-- FILES
-- KEY_FILES
-- DEPENDENCIES
-- INTERFACES
-- TRAPS (with severity prefix: [CRITICAL], [HIGH], or [LOW])
-
-L2 GENERATION TEMPLATE (use when AI first touches a sub-module with no L2 doc):
-
-MODULE: <path>
-FILES: <comma-separated file list>
-RESPONSIBILITY: <one-line>
-KEY_FILES:
-- <file>: <role, line count, complexity note>
-DEPENDENCIES:
-- uses: <lib>: <why>
-- imports: <module>: <what>
-INTERFACES:
-- <exported function/class>: <signature and purpose>
-TRAPS:
-- [LOW] <gotcha, race condition, or non-obvious coupling> | FIX: <approach>
-
-TRAPS is critical — always record gotchas, race conditions, non-obvious behavior, and surprising coupling between modules. Every TRAP must have a severity prefix ([CRITICAL], [HIGH], or [LOW]).
+WHEN TO UPDATE `.prizmkit/prizm-docs/`:
+- Use `/prizmkit-retrospective` after a validated change affects structure, interfaces, dependencies, behavior, or durable TRAPS/RULES/DECISIONS.
+- Skip documentation writes when no current durable non-obvious fact passes the Value Gate.
+- Before source modification, read exact root, the relevant direct-child L1, the complete relevant nested L2, and complete resolving pointer documents.
+- If relevant L2 is absent, inspect bounded relevant source without creating a placeholder.
+
+FRAMEWORK DIRECTORY AND GIT POLICY:
+- `.prizmkit/**` is framework-owned capability/artifact space; an owner may read/write only its managed paths.
+- The project decides whether framework paths are ignored, untracked, or tracked. Do not add, remove, force-add, stage, commit, or interpret `.gitignore` entries as part of documentation maintenance.
+- Validation/generation/reconciliation behavior is identical across tracking states apart from ordinary Git visibility; Git history is not required.
+
+FORMAT RULES:
+- New roots use `PRIZM_VERSION: 4`.
+- Only exact `.prizmkit/prizm-docs/root.prizm` is L0; direct `.prizm` children other than root are L1; every nested `.prizm` document is L2.
+- ALL CAPS section headers, KEY: value pairs, and dash-prefixed lists only.
+- PROHIBITED: CHANGELOG sections/files, prose paragraphs, markdown headers, code blocks, horizontal rules, UPDATED/date metadata, feature/bug/refactor/task/session/run/pipeline/workflow IDs, branch names, absolute worktree paths, and `.prizmkit/specs` / `.prizmkit/dev-pipeline` artifact paths.
+- L1 is structural and must not contain INTERFACES, DATA_FLOW, TRAPS, DECISIONS, CONCERN, or full RULES.
+- Mirrored L2 requires MODULE, FILES, RESPONSIBILITY, INTERFACES, KEY_FILES, DEPENDENCIES, and TRAPS. Semantic L2 also requires deterministic CONCERN/SLUG, DATA_FLOW, RULES, DECISIONS, exact parent DETAILS pointer, and non-overlapping FILES ownership.
+
+CAPACITY AND WRITES:
+- Raw UTF-8 hard limits: L0 4096B, L1 4096B, L2 5120B. Existing warning bands remain advisory; hard-limit violations fail.
+- Apply Value/Cleanup gates and protect still-valid contracts, constraints, dependencies, traps, decisions, side effects, and safety/integrity rules.
+- Build complete candidates and write bottom-up. Skip byte-identical replacements, re-read actual bytes/pointers, and restore exact prior bytes or remove invalid new targets after any failed post-write check.
+- Never add L3, a documentation state machine, task-named shards, or placeholder L2 documents.