prizmkit 1.1.159 → 1.1.161

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

@@ -1313,8 +1313,9 @@ 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 paths" in skill_text
-    assert "default-excluded changed paths" in skill_text
+    assert "non-ignored untracked, deleted, renamed, and copied paths" in skill_text
+    assert "Do not maintain excluded-path metadata" in skill_text
+    assert "complete current Git-visible workspace" 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
@@ -2391,7 +2392,7 @@ def test_heartbeat_observation_stale_accumulates_by_elapsed_time_and_resets_on_p
     session_log = tmp_path / "session.log"
     progress = tmp_path / "progress.json"
     session_log.write_text("initial\n", encoding="utf-8")
-    progress.write_text('{"current_phase":"plan","current_tool":"Read","message_count":1,"total_tool_calls":1}\n', encoding="utf-8")
+    progress.write_text('{"current_phase":"plan","current_tool":null,"message_count":1,"total_tool_calls":1}\n', encoding="utf-8")
     config = HeartbeatConfig(
         heartbeat_file=tmp_path / "heartbeat.json",
         session_log=session_log,
@@ -2419,6 +2420,72 @@ def test_heartbeat_observation_stale_accumulates_by_elapsed_time_and_resets_on_p
     assert reset.last_seen_epoch == 1095.0
 
 
+def test_heartbeat_observation_active_tool_resets_stale_until_tool_clears(tmp_path, monkeypatch):
+    import prizmkit_runtime.heartbeat as heartbeat
+    from prizmkit_runtime.heartbeat import HeartbeatConfig, observe_heartbeat_state
+
+    progress = tmp_path / "progress.json"
+    progress.write_text(
+        '{"current_tool":"bash","message_count":1,"total_tool_calls":1}\n',
+        encoding="utf-8",
+    )
+    config = HeartbeatConfig(
+        heartbeat_file=tmp_path / "heartbeat.json",
+        progress_file=progress,
+        stale_after_seconds=60,
+    )
+    ticks = iter([1000.0, 1100.0, 1200.0, 1205.0, 1230.0])
+    monkeypatch.setattr(heartbeat.time, "time", lambda: next(ticks))
+
+    first = observe_heartbeat_state(config)
+    active = observe_heartbeat_state(config, first)
+    still_active = observe_heartbeat_state(config, active)
+    progress.write_text(
+        '{"current_tool":null,"message_count":1,"total_tool_calls":1}\n',
+        encoding="utf-8",
+    )
+    tool_finished = observe_heartbeat_state(config, still_active)
+    idle = observe_heartbeat_state(config, tool_finished)
+
+    assert active.details == "progress"
+    assert active.stale_seconds == 0
+    assert active.last_seen_epoch == 1100.0
+    assert still_active.details == "progress"
+    assert still_active.stale_seconds == 0
+    assert still_active.last_seen_epoch == 1200.0
+    assert tool_finished.details == "progress"
+    assert tool_finished.stale_seconds == 0
+    assert tool_finished.last_seen_epoch == 1205.0
+    assert idle.details == "no progress"
+    assert idle.stale_seconds == 25.0
+
+
+@pytest.mark.parametrize("current_tool", [None, "", "   ", 0, ["bash"]])
+def test_heartbeat_observation_rejects_inactive_or_malformed_tool_values(
+    tmp_path,
+    monkeypatch,
+    current_tool,
+):
+    import prizmkit_runtime.heartbeat as heartbeat
+    from prizmkit_runtime.heartbeat import HeartbeatConfig, observe_heartbeat_state
+
+    progress = tmp_path / "progress.json"
+    progress.write_text(json.dumps({"current_tool": current_tool}), encoding="utf-8")
+    config = HeartbeatConfig(
+        heartbeat_file=tmp_path / "heartbeat.json",
+        progress_file=progress,
+        stale_after_seconds=60,
+    )
+    ticks = iter([1000.0, 1070.0])
+    monkeypatch.setattr(heartbeat.time, "time", lambda: next(ticks))
+
+    first = observe_heartbeat_state(config)
+    stale = observe_heartbeat_state(config, first)
+
+    assert stale.details == "no progress"
+    assert stale.stale is True
+    assert stale.stale_seconds == 70.0
+
 
 def test_heartbeat_state_tracks_progress_json_child_activity(tmp_path, monkeypatch):
     import prizmkit_runtime.heartbeat as heartbeat
@@ -2495,6 +2562,104 @@ def test_heartbeat_monitor_stale_kill_uses_elapsed_no_progress_threshold(tmp_pat
     assert marker_data["stale_seconds"] >= 0
 
 
+def test_heartbeat_monitor_active_tool_defers_stale_kill_until_tool_clears(tmp_path):
+    from prizmkit_runtime.heartbeat import HeartbeatConfig, HeartbeatMonitor
+    from prizmkit_runtime.processes import ProcessSpec, is_process_running, launch_process
+
+    sleeper = tmp_path / "active_tool_sleep.py"
+    sleeper.write_text("import time\ntime.sleep(5)\n", encoding="utf-8")
+    progress = tmp_path / "progress.json"
+    progress.write_text('{"current_tool":"bash"}\n', encoding="utf-8")
+    handle = launch_process(ProcessSpec(command=(sys.executable, str(sleeper)), cwd=tmp_path))
+    monitor = HeartbeatMonitor(
+        handle,
+        HeartbeatConfig(
+            heartbeat_file=tmp_path / "heartbeat.json",
+            session_log=tmp_path / "session.log",
+            progress_file=progress,
+            marker_dir=tmp_path,
+            interval_seconds=0.05,
+            stale_after_seconds=0.1,
+            kill_after_seconds=0.2,
+            grace_seconds=0.1,
+        ),
+    )
+    monitor.start()
+
+    time.sleep(0.5)
+    assert is_process_running(handle)
+    assert not (tmp_path / "stale-kill.json").exists()
+
+    progress.write_text('{"current_tool":null}\n', encoding="utf-8")
+    deadline = time.time() + 3
+    while time.time() < deadline and not (tmp_path / "stale-kill.json").exists():
+        time.sleep(0.05)
+    result = monitor.stop()
+
+    marker = json.loads((tmp_path / "stale-kill.json").read_text(encoding="utf-8"))
+    assert result.killed is True
+    assert result.reason == "stale_session"
+    assert marker["reason"] == "stale_session"
+
+
+def test_pi_session_active_tool_stream_survives_stale_threshold(tmp_path, monkeypatch):
+    import prizmkit_runtime.sessions as sessions
+    from prizmkit_runtime.sessions import AISessionConfig, AISessionLauncher
+
+    parser_classes = sessions._load_stream_parser_classes()
+    monkeypatch.setattr(sessions, "_load_stream_parser_classes", lambda: parser_classes)
+
+    fake_cli = tmp_path / "pi_active_tool_cli.py"
+    fake_cli.write_text(
+        "#!/usr/bin/env python3\n"
+        "import json, sys, time\n"
+        "_prompt = sys.stdin.read(5)\n"
+        "for event in [\n"
+        " {'type':'session','id':'active-tool-session'},\n"
+        " {'type':'agent_start'},\n"
+        " {'type':'turn_start'},\n"
+        " {'type':'tool_execution_start','toolCallId':'call-1','toolName':'long-running-tool','args':{}},\n"
+        "]:\n"
+        " print(json.dumps(event), flush=True)\n"
+        "time.sleep(3.0)\n"
+        "for event in [\n"
+        " {'type':'tool_execution_end','toolCallId':'call-1','toolName':'long-running-tool','result':{'content':[]},'isError':False},\n"
+        " {'type':'message_end','message':{'role':'assistant','content':[{'type':'text','text':'done'}],'stopReason':'stop'}},\n"
+        " {'type':'agent_end','willRetry':False,'messages':[{'role':'assistant','content':[{'type':'text','text':'done'}],'stopReason':'stop'}]},\n"
+        "]:\n"
+        " print(json.dumps(event), flush=True)\n",
+        encoding="utf-8",
+    )
+    fake_cli.chmod(0o755)
+    prompt = tmp_path / "prompt.md"
+    prompt.write_text("hello", encoding="utf-8")
+    session_log = tmp_path / "state" / "sessions" / "active-tool" / "logs" / "session.log"
+    progress = session_log.with_name("progress.json")
+
+    result = AISessionLauncher(
+        AISessionConfig(
+            cli_command=str(fake_cli),
+            platform="pi",
+            model=None,
+            prompt_path=prompt,
+            cwd=tmp_path,
+            log_path=session_log,
+            progress_path=progress,
+            heartbeat_path=session_log.with_name("heartbeat.json"),
+            stale_kill_threshold_seconds=1.5,
+            heartbeat_stale_threshold_seconds=1.0,
+            stale_kill_grace_seconds=0.1,
+            live_progress_interval_seconds=0.05,
+        )
+    ).run()
+
+    final_progress = json.loads(progress.read_text(encoding="utf-8"))
+    assert result.exit_code == 0
+    assert result.termination_reason is None
+    assert final_progress["current_tool"] is None
+    assert not (session_log.parent / "stale-kill.json").exists()
+
+
 def test_stale_marker_preserves_subsecond_threshold(tmp_path):
     from prizmkit_runtime.heartbeat import write_stale_marker
 
@@ -2913,7 +3078,10 @@ def test_heartbeat_fatal_error_writes_shell_compatible_markers(tmp_path):
     sleeper = tmp_path / "fatal_sleep.py"
     sleeper.write_text("import time\ntime.sleep(5)\n", encoding="utf-8")
     progress = tmp_path / "progress.json"
-    progress.write_text('{"fatal_error_code":"context_overflow"}\n', encoding="utf-8")
+    progress.write_text(
+        '{"current_tool":"bash","fatal_error_code":"context_overflow"}\n',
+        encoding="utf-8",
+    )
     handle = launch_process(ProcessSpec(command=(sys.executable, str(sleeper)), cwd=tmp_path))
     monitor = HeartbeatMonitor(
         handle,
@@ -3621,8 +3789,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 +4054,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 +4101,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,17 @@
 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)
+# Commit Workflow
+
+Do not commit after implementation alone.
+
+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 local commit operation and one truthful Conventional Commit message.
+3. The commit candidate is the complete current Git-visible workspace: staged, unstaged, added, deleted, renamed, copied, and non-ignored untracked content, regardless of when or where each valid change originated.
+4. Final Code Review and Test authority must cover every behavior-affecting candidate. Committer inspects the complete final workspace, blocks stale or unsafe evidence, previews every visible change, and waits for explicit interactive confirmation.
+5. Interactive Committer stages the confirmed complete workspace. Headless preparation writes a schema-v2 pathless request, and Python Runtime re-enumerates and stages the complete validated workspace after `COMMIT_PENDING`.
+6. Ignored paths remain local, never block, and are never force-added. Path provenance or namespace alone never admits or excludes content.
+7. Merge conflicts, Secrets, sensitive local content, known incorrect or incoherent changes, and unverifiable content still block. Only the exact active interactive workflow state or Runtime request/checkpoint and post-commit receipt writes may remain outside the snapshot because their causal finalization follows the commit.
+8. Runtime verifies the base, parent, message, non-empty commit, recovery receipt, and checkpoint finalization before integration.
+9. 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.159",
+  "version": "1.1.161",
   "skills": {
     "prizmkit": {
       "description": "Framework introduction and navigation for the formal single-requirement lifecycle, project initialization, Prizm docs, and independent deployment.",

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

@@ -55,19 +55,19 @@ Resolve a compatible Python 3 interpreter through the current Host's executable
 
 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
+## Complete Git-Visible 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 exact caller-supplied `.prizmkit` artifacts such as `spec.md` and `plan.md` as requirement evidence and may write its own `review-report.md`; neither action makes `.prizmkit` content reviewable production change.
+The complete current Git-visible workspace is the correctness scope: staged and unstaged tracked changes, additions, deletions, renames, copies, and non-ignored untracked files. Correct changes that predate the active requirement or implementation session remain in scope. Do not exclude, specially admit, or require a separate support contract solely because a path is under `.prizmkit/**`, generated, an instruction or lock file, a platform directory, local support, or otherwise outside the original requirement namespace.
 
-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.
+Inspect each visible path through the applicable contract: production behavior through code and callers, tests through assertion and boundary quality, instructions through readable structure and referenced-project consistency, lock/generated content through parse or deterministic parity, and binary or specialized content through the available project-native validator. Block when correctness cannot be established safely. Ignored paths remain naturally absent and are not review findings. Artifact files read or written by this stage are evidence/output, but any such file that is Git-visible in the final workspace is still disclosed to the final commit inspection rather than hidden by provenance.
 
 ## 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, 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.
+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 all non-ignored untracked, deleted, renamed, and copied paths in the correctness scope before producing findings.
+5. Append one validated `scope-classification` renderer event containing the exact complete Git-visible in-scope paths. Do not maintain excluded-path metadata or claim ignored content was reviewed.
 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.

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

@@ -62,15 +62,14 @@ The Main Agent supplies:
 
 - original requirement and confirmed clarifications;
 - exact artifact, spec, and plan paths plus current contents;
-- 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;
+- the complete current Git-visible workspace status;
+- all staged and unstaged tracked changes;
+- all non-ignored untracked, deleted, renamed, and copied 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, 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.
+The Main Agent runs Git and captures the authoritative complete Git-visible change without namespace or provenance exclusions. Correct pre-existing, `.prizmkit/**`, generated, instruction, lock, and host-support content remains reviewable. 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 a visible change justifies it. It must not run commands or perform an unconditional repository-wide scan. Ignored content is absent. 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

@@ -18,18 +18,16 @@ Within that execution, append sections only. Never edit or replace an earlier pr
 
 ### Review Scope
 
-Append once after workspace inventory classification and before the first review round:
+Append once after complete workspace inventory 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.>
+- Git-Visible Paths:
+  - <exact staged, unstaged, deleted, renamed, copied, or non-ignored untracked path or None.>
 ```
 
-Paths under `.prizmkit/**` and generated host-support paths are visible exclusions, not reviewed content.
+Every Git-visible path is review scope regardless of provenance. Ignored paths remain absent rather than becoming exclusions.
 
 ### Main-Agent Review Round
 

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

@@ -115,15 +115,12 @@ def _render_event(data: dict[str, Any]) -> str:
 
     if event == "scope-classification":
         in_scope = _require_text_list(data, "in_scope_paths")
-        excluded = _require_text_list(data, "excluded_paths")
         return "\n".join(
             [
                 "## Review Scope",
                 "",
-                "- In-Scope Paths:",
+                "- Git-Visible Paths:",
                 *_render_path_list(in_scope),
-                "- Default-Excluded Changed Paths:",
-                *_render_path_list(excluded),
             ]
         )