prizmkit 1.1.156 → 1.1.160

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

@@ -670,6 +670,143 @@ def test_fresh_checkout_and_clean_keep_id_range_and_filter_selection(
     assert all(entry[3] is (mode == "--clean") for entry in captured)
 
 
+@pytest.mark.parametrize("kind", ("feature", "bugfix", "refactor"))
+def test_clean_uses_item_state_without_pipeline_state_but_fresh_checkout_still_requires_it(
+    monkeypatch,
+    tmp_path,
+    kind,
+):
+    from prizmkit_runtime import reset as reset_runtime
+    from prizmkit_runtime.reset import run_reset_command
+    from prizmkit_runtime.task_checkout import TaskCheckout, persist_task_checkout
+
+    paths = _make_paths(tmp_path / kind)
+    contract = FAMILY_CONTRACTS[kind]
+    item_id = f"{contract['prefix']}001"
+    family, plan_path = _family_and_plan(paths, kind, [_item(item_id, "in_progress")])
+    status_path, _ = _write_runtime_status(
+        family,
+        item_id,
+        active_dev_branch=f"{contract['branch_prefix']}/{item_id}-clean",
+        base_branch="main",
+    )
+    checkout_path = persist_task_checkout(
+        family.state_dir,
+        TaskCheckout.active(
+            family.task_type,
+            item_id,
+            f"{contract['branch_prefix']}/{item_id}-clean",
+            "main",
+        ),
+    )
+    captured = []
+
+    def fake_reset_one(received_family, item, options, project_root, return_branch, lines):
+        captured.append((received_family.kind, item.item_id, options.clean))
+        return True
+
+    monkeypatch.setattr(reset_runtime, "_reset_one", fake_reset_one)
+    monkeypatch.setattr(reset_runtime, "default_branch", lambda _root: "main")
+
+    fresh_result = run_reset_command(
+        kind,
+        (item_id, "--fresh-checkout", str(plan_path)),
+        paths,
+    )
+
+    assert fresh_result.exit_code != 0
+    assert "No pipeline state found" in fresh_result.render()
+    assert captured == []
+    assert status_path.is_file()
+    assert checkout_path.is_file()
+    assert not (family.state_dir / "pipeline.json").exists()
+
+    clean_result = run_reset_command(
+        kind,
+        (item_id, "--clean", str(plan_path)),
+        paths,
+    )
+
+    assert clean_result.exit_code == 0, clean_result.render()
+    assert captured == [(kind, item_id, True)]
+
+
+def test_feature_clean_removes_stale_workflow_fields_and_preserves_diagnostics(tmp_path):
+    paths = _make_paths(tmp_path)
+    family, plan_path = _family_and_plan(
+        paths,
+        "feature",
+        [_item("F-001", "failed")],
+    )
+    status_path, _ = _write_runtime_status(
+        family,
+        "F-001",
+        repair_scope="production",
+        repair_round=2,
+        blocked_reason="test_blocked",
+        terminal_status="WORKFLOW_BLOCKED",
+    )
+    session_dir = family.state_dir / "F-001" / "sessions" / "old-session"
+    session_dir.mkdir(parents=True)
+    (session_dir / "session.log").write_text("old session\n", encoding="utf-8")
+    feature_slug = "001-f-001"
+    specs_dir = paths.project_root / ".prizmkit" / "specs" / feature_slug
+    specs_dir.mkdir(parents=True)
+    (specs_dir / "spec.md").write_text("old spec\n", encoding="utf-8")
+    (specs_dir / "continuation-summary.md").write_text(
+        "old continuation\n",
+        encoding="utf-8",
+    )
+
+    result = subprocess.run(
+        [
+            sys.executable,
+            str(PIPELINE_ROOT / "scripts" / "update-feature-status.py"),
+            "--feature-list",
+            str(plan_path),
+            "--state-dir",
+            str(family.state_dir),
+            "--feature-id",
+            "F-001",
+            "--feature-slug",
+            feature_slug,
+            "--project-root",
+            str(paths.project_root),
+            "--action",
+            "clean",
+        ],
+        cwd=paths.project_root,
+        text=True,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        check=False,
+    )
+
+    assert result.returncode == 0, (result.stdout, result.stderr)
+    payload = json.loads(result.stdout)
+    assert payload["action"] == "clean"
+    assert payload["new_status"] == "pending"
+    updated_list = json.loads(plan_path.read_text(encoding="utf-8"))
+    assert updated_list["features"][0]["status"] == "pending"
+    updated_status = json.loads(status_path.read_text(encoding="utf-8"))
+    for stale_field in (
+        "repair_scope",
+        "repair_round",
+        "blocked_reason",
+        "terminal_status",
+    ):
+        assert stale_field not in updated_status
+    assert updated_status["retry_count"] == 0
+    assert updated_status["infra_error_count"] == 0
+    assert updated_status["sessions"] == []
+    assert updated_status["last_session_id"] is None
+    assert updated_status["resume_from_phase"] is None
+    assert updated_status["custom_diagnostic"] == {"keep": True}
+    assert "continuation_pending" not in updated_status
+    assert not session_dir.exists()
+    assert not specs_dir.exists()
+
+
 def _valid_bug(bug_id, status="pending", dependencies=None):
     return {
         "id": bug_id,

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

@@ -1313,7 +1313,8 @@ def test_headless_review_guidance_maps_stage_local_skill_result():
 
     skill_text = skill_path.read_text(encoding="utf-8")
     assert "the staged diff, and the unstaged diff" in skill_text
-    assert "untracked, deleted, and renamed files" in skill_text
+    assert "untracked, deleted, and renamed paths" in skill_text
+    assert "default-excluded changed paths" in skill_text
     assert "accepted = 0" in skill_text
     assert "ten completed review rounds" in skill_text
     assert "## Phase 3: Independent Code Review" in skill_text
@@ -3620,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
 
@@ -3882,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,
@@ -3929,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.

package/bundled/rules/prizm/prizm-progressive-loading.md

@@ -3,11 +3,12 @@ description: "PrizmKit progressive context loading protocol"
 ---
 
 This project uses PrizmKit's progressive loading protocol:
-- ON SESSION START: Read `.prizmkit/prizm-docs/root.prizm` (L0 — project map)
-- ON RESUME (feature/bugfix directory has session-summary.md): Read session-summary.md first for prior context, then load only L1/L2 for modules mentioned in it
-- ON TASK: Read L1 (`.prizmkit/prizm-docs/<module>.prizm`) for relevant modules. If MODULE_INDEX entries have keyword tags (e.g., `[login, jwt, oauth]`), match user's task description against tags to prioritize which modules' L1 to load first. If root.prizm uses MODULE_GROUPS, identify the relevant domain first, then load L1 only for modules in that domain.
-- ON FILE EDIT: Read L2 (`.prizmkit/prizm-docs/<module>/<submodule>.prizm`) before modifying
-- NEVER load all .prizm docs at once
-- Arrow notation (->) in .prizm files indicates load pointers
-- .prizm files do not contain CHANGELOG sections/files, UPDATED/date metadata, feature/bug/refactor/task/session/run/pipeline/workflow IDs, branch names, absolute worktree paths, or `.prizmkit/specs` / `.prizmkit/dev-pipeline` artifact paths
-- Update stale durable knowledge in place; git history is the change log
+- ON SESSION START: Read exact `.prizmkit/prizm-docs/root.prizm` (L0 project map) when it exists.
+- ON TASK: Read only relevant direct-child L1 documents (`.prizmkit/prizm-docs/<module>.prizm`) selected through root MODULE_INDEX/MODULE_GROUPS pointers.
+- ON FILE EDIT: Read the complete relevant nested L2 document and complete parent/child documents needed to resolve its SUBDIRS or DETAILS pointer before modification. Grep-only fragments are insufficient modification context.
+- IF L2 IS ABSENT: Inspect only bounded target source and narrowly implicated contracts; proceed without creating a placeholder. Documentation creation belongs to Retrospective or explicit documentation repair and requires complete Value-Gate-qualified content.
+- NEVER load all L1/L2 documents at session start, create L3, or load unrelated modules.
+- PATH LEVELS: only exact `root.prizm` is L0; every other direct `.prizm` child is L1; every nested `.prizm` document is L2.
+- Arrow notation (`->`) identifies resolving documentation pointers.
+- Memory files do not contain CHANGELOG sections/files, UPDATED/date metadata, feature/bug/refactor/task/session/run/pipeline/workflow IDs, branch names, absolute worktree paths, or `.prizmkit/specs` / `.prizmkit/dev-pipeline` artifact paths.
+- `.prizmkit/**` is the framework directory. Its owning capabilities may read/write managed artifacts, but project Git tracking/ignore policy is independent and must not alter documentation behavior.

package/bundled/skills/_metadata.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.1.156",
+  "version": "1.1.160",
   "skills": {
     "prizmkit": {
       "description": "Framework introduction and navigation for the formal single-requirement lifecycle, project initialization, Prizm docs, and independent deployment.",

package/bundled/skills/prizmkit/SKILL.md

@@ -18,7 +18,7 @@ description: "PrizmKit framework introduction and lifecycle navigator. Explains
 ## When NOT to Use
 
 - User already knows the required skill; invoke that skill directly.
-- A formal requirement is already in progress; continue from its workflow state and current stage.
+- A formal requirement is already in progress; continue through its owning coordinator or current atomic stage.
 - User wants an immediate low-risk direct edit; perform the edit and its specific verification.
 
 ## Responsibility Map
@@ -125,18 +125,6 @@ The active coordinator validates all required evidence before invoking `prizmkit
 
 Pushing to a remote is a separate explicit action. Deployment is always a separate invocation of `/prizmkit-deploy`.
 
-## Workflow State
-
-An active requirement may use:
-
-```text
-.prizmkit/state/workflows/<requirement-identity>.json
-```
-
-`<requirement-identity>` is the validated exact basename of the active artifact directory. An existing state file that records a different artifact directory is a blocking collision and is never silently overwritten or suffixed. This coordinator-owned state records current stage, terminal status, repair scope, repair round, and resume entry. Atomic Skills do not read or write it. The target project controls whether the file is committed, ignored, or shared.
-
-Read `${SKILL_DIR}/references/workflow-state-protocol.md` for the state protocol. If the state file is missing or stale, use `spec.md`, `plan.md`, the review report, `test-report.md`, and `test-result.json` to reconstruct the safest recoverable stage and report that reconstruction.
-
 ## Quick Start
 
 Install the skills through the host's skills installer, for example:

package/bundled/skills/prizmkit-code-review/SKILL.md

@@ -18,6 +18,18 @@ description: "Review one supplied complete change with a bounded Main-Agent revi
 - Review repairs use targeted verification appropriate to each accepted finding.
 - `{artifact_dir}/review-report.md` is the only persisted review artifact for this execution.
 
+## Report Renderer Contract
+
+Use `${SKILL_DIR}/scripts/render_review_report.py` as the canonical executable writer for report initialization, validated progress append, and finalization:
+
+```text
+resolved Python 3 interpreter + render_review_report.py init <report>
+resolved Python 3 interpreter + render_review_report.py append <report>  ← validated event JSON on standard input
+resolved Python 3 interpreter + render_review_report.py finalize <report> ← validated final JSON on standard input
+```
+
+Resolve a compatible Python 3 interpreter through the current Host's executable capability; do not require one operating-system-specific command name. If no compatible interpreter is available, follow `${SKILL_DIR}/references/review-report-template.md` directly, record the renderer fallback in Final Verification evidence, and apply every equivalent count, ordering, field, and terminal-shape check before returning a verdict. Never silently omit renderer-owned fields or claim executable validation occurred during fallback.
+
 ## Atomic Stage Boundary
 
 `prizmkit-code-review` owns the complete review, accepted-correction repairs, targeted verification, and `review-report.md` for one supplied change. It returns `PASS` or `NEEDS_FIXES` and stops.
@@ -43,16 +55,23 @@ description: "Review one supplied complete change with a bounded Main-Agent revi
 
 Review only the caller-supplied `artifact_dir`; never discover a different recent artifact. Missing or inconsistent stage input produces `NEEDS_FIXES` with the exact input blocker.
 
+## Default Correctness Scope
+
+The current requirement change outside `.prizmkit/**` is the ordinary correctness scope. Every `.prizmkit/**` path is excluded by default from correctness review, including correctness diffs, candidate findings, repairs, and verification scope. The Skill may read only exact caller-supplied `.prizmkit` artifacts such as `spec.md` and `plan.md` as evidence for the outside-framework requirement and may write its own `review-report.md`; it must not assess, report findings against, or repair their content. Neither action makes `.prizmkit` content reviewable production change. Correctness review of any framework/support artifact requires a separate explicit support-artifact review contract naming the exact artifacts and validator.
+
+Generated host-support paths are also excluded by default, including `AGENTS.md`, `skills-lock.json`, installed platform directories, and local platform settings. An explicitly owned support change requires a separate explicit support-artifact validation contract; do not pull it into ordinary Code Review through workspace expansion. Record excluded changed paths in the report so exclusion is visible rather than mistaken for reviewed content.
+
 ## Phase 0: Initialize Report and Reuse Current Context
 
 1. Resolve `{artifact_dir}` and `{artifact_dir}/review-report.md` from the active requirement context.
-2. At the start of each execution, replace any prior report with a new execution header using `${SKILL_DIR}/references/review-report-template.md`.
-3. Within that execution, append progress after every review round, repair batch, final verification, and exactly one `## Final Result`.
-4. Start from the Main Agent's current requirement context and inspect the complete workspace change first: `git status --short`, the staged diff, and the unstaged diff. Include untracked, deleted, and renamed files in the review scope.
-5. Reuse current context and load only missing or potentially stale material required to resolve a concrete ambiguity, verify an acceptance criterion, or understand a changed contract.
-6. Inspect unchanged callers, dependents, contracts, or tests only when the diff changes or may violate an interface, shared behavior, or regression boundary. Do not perform an unconditional repository-wide dependency sweep.
-7. For `review_scope=delta`, focus on files and behavior affected since the prior review pass and expand only across contracts implicated by that delta.
-8. If no changes exist, record final verification and `PASS` only when the current requirement context and prior implementation state prove there is nothing left to review.
+2. At the start of each execution, initialize a replacement report through the Report Renderer Contract and `${SKILL_DIR}/references/review-report-template.md`.
+3. Within that execution, append every review round, repair batch, independent-review event, final verification, and exactly one `## Final Result` through the renderer or its visible equivalent fallback.
+4. Start from the Main Agent's current requirement context and inspect the complete workspace inventory first: `git status --short`, the staged diff, and the unstaged diff. Include untracked, deleted, and renamed paths in classification, then remove default-excluded `.prizmkit/**` and host-support paths from the correctness scope before producing findings.
+5. Append one validated `scope-classification` renderer event containing exact in-scope paths and exact default-excluded changed paths; do not describe exclusions as reviewed or silently repair them.
+6. Reuse current context and load only missing or potentially stale material required to resolve a concrete ambiguity, verify an acceptance criterion, or understand a changed contract.
+7. Inspect unchanged callers, dependents, contracts, or tests only when the in-scope diff changes or may violate an interface, shared behavior, or regression boundary. Do not perform an unconditional repository-wide dependency sweep.
+8. For `review_scope=delta`, focus on in-scope files and behavior affected since the prior review pass and expand only across contracts implicated by that delta.
+9. If no in-scope changes exist, record final verification and `PASS` only when the current requirement context and prior implementation state prove there is nothing left to review.
 
 ## Phase 1: Main-Agent Review Loop
 
@@ -77,7 +96,7 @@ For every candidate finding:
    - `unresolved`: correctness or safe repair cannot be established.
 3. Treat Missing tools, permissions, environment, or required evidence as an unresolved finding when they prevent review verification.
 4. If a repair cannot be completed safely, record an unresolved finding and return `NEEDS_FIXES`.
-5. Append the review round to `review-report.md`.
+5. Append the validated review-round event through the Report Renderer Contract.
 
 Round behavior:
 
@@ -105,7 +124,7 @@ For accepted findings while the round limit remains:
 1. Repair directly in the active workspace.
 2. Run targeted tests, static checks, or other verification appropriate to each repair.
 3. Inspect the complete resulting diff for unrelated changes and regressions.
-4. Append repair verification and continue the review loop.
+4. Append validated repair-verification evidence through the Report Renderer Contract and continue the review loop.
 
 Do not turn review verification into a broad unrelated test campaign; use targeted checks that establish each repair.
 
@@ -131,7 +150,7 @@ Before completing:
 
 1. Confirm the final workspace is the complete reviewed change.
 2. Confirm all accepted findings are fixed and no unresolved finding remains for `PASS`.
-3. Append final verification and exactly one final result.
+3. Append final verification and exactly one final result through the Report Renderer Contract or its visibly recorded equivalent fallback.
 
 Valid results:
 

package/bundled/skills/prizmkit-code-review/references/independent-code-review.md

@@ -62,14 +62,15 @@ The Main Agent supplies:
 
 - original requirement and confirmed clarifications;
 - exact artifact, spec, and plan paths plus current contents;
-- current workspace status;
-- staged and unstaged tracked changes;
-- relevant untracked, deleted, and renamed content;
+- current workspace status after the Main Agent classifies default exclusions;
+- staged and unstaged tracked changes in the ordinary correctness scope;
+- relevant in-scope untracked, deleted, and renamed content;
+- exact default-excluded changed paths as visible exclusion metadata, never as reviewed content;
 - implementation task completion and targeted verification results;
 - response number and total budget;
 - prior adjudication, actual repairs, and repair verification on continuation or replacement.
 
-The Main Agent runs Git and captures authoritative current-change state. The Reviewer may use structurally read-only checkout access to inspect unchanged callers, consumers, contracts, schemas, types, configurations, fixtures, or tests only when concrete coupling to this requirement justifies it. It must not run commands or perform an unconditional repository-wide scan. Missing or inconsistent required input produces `REVIEW_BLOCKED`, never partial success.
+The Main Agent runs Git and captures authoritative current-change state, then applies the Skill's default `.prizmkit/**` and generated host-support exclusions before supplying the correctness change. The Reviewer may read the exact supplied spec/plan artifacts but must not inspect other `.prizmkit` content. It may use structurally read-only checkout access to inspect unchanged callers, consumers, contracts, schemas, types, configurations, fixtures, or tests only when concrete coupling to this requirement justifies it. It must not run commands or perform an unconditional repository-wide scan. Missing or inconsistent required input produces `REVIEW_BLOCKED`, never partial success.
 
 ## Initial Reviewer Prompt
 

package/bundled/skills/prizmkit-code-review/references/review-report-template.md

@@ -16,6 +16,21 @@ Within that execution, append sections only. Never edit or replace an earlier pr
 
 ## Progress Sections
 
+### Review Scope
+
+Append once after workspace inventory classification and before the first review round:
+
+```markdown
+## Review Scope
+
+- In-Scope Paths:
+  - <exact requirement-owned path or None.>
+- Default-Excluded Changed Paths:
+  - <exact .prizmkit/support path or None.>
+```
+
+Paths under `.prizmkit/**` and generated host-support paths are visible exclusions, not reviewed content.
+
 ### Main-Agent Review Round
 
 ```markdown