prizmkit 1.1.156 → 1.1.159

package/bundled/VERSION.json

@@ -1,5 +1,5 @@
 {
-  "frameworkVersion": "1.1.156",
-  "bundledAt": "2026-07-27T23:46:04.550Z",
-  "bundledFrom": "6d92126"
+  "frameworkVersion": "1.1.159",
+  "bundledAt": "2026-07-28T08:35:59.394Z",
+  "bundledFrom": "7908918"
 }

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

@@ -115,7 +115,7 @@ def run_reset_command(kind: str, legacy_args: tuple[str, ...], paths) -> Command
     list_path = _resolve_list_path(options.list_path, paths.project_root)
     if not list_path.is_file():
         return CommandResult(1, f"Python {kind} reset", f"{kind} list not found: {list_path}")
-    if (options.fresh_checkout or options.clean) and not (family.state_dir / "pipeline.json").is_file():
+    if options.fresh_checkout and not (family.state_dir / "pipeline.json").is_file():
         return CommandResult(1, f"Python {kind} reset", f"No pipeline state found. Run the {kind} pipeline first to initialize.")
 
     options = ResetOptions(

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

@@ -92,17 +92,7 @@ def classify_session(
         )
 
     semantic = checkpoint.semantic_snapshot if checkpoint is not None else {}
-    if _is_terminal_success(result):
-        reason = "no_semantic_completion"
-        if checkpoint is not None and checkpoint.semantic.error_code:
-            reason = f"{reason}:{checkpoint.semantic.error_code}"
-        return SessionClassification(
-            WORKFLOW_SKIPPED,
-            reason=reason,
-            progress_fingerprint=fingerprint,
-            checkpoint_state=semantic,
-        )
-    if _is_context_overflow(result):
+    if _is_recoverable_context_interruption(result):
         no_progress_count = _next_no_progress_count(previous_fingerprint, fingerprint, previous_no_progress_count)
         if no_progress_count >= 2:
             return SessionClassification(
@@ -121,6 +111,16 @@ def classify_session(
             no_progress_count=no_progress_count,
             checkpoint_state=semantic,
         )
+    if _is_terminal_success(result):
+        reason = "no_semantic_completion"
+        if checkpoint is not None and checkpoint.semantic.error_code:
+            reason = f"{reason}:{checkpoint.semantic.error_code}"
+        return SessionClassification(
+            WORKFLOW_SKIPPED,
+            reason=reason,
+            progress_fingerprint=fingerprint,
+            checkpoint_state=semantic,
+        )
 
     if result.termination_reason == "stale_session":
         return SessionClassification(
@@ -275,6 +275,15 @@ def _next_no_progress_count(previous: object | None, current: object, count: int
     return 0
 
 
+def _is_recoverable_context_interruption(result: AISessionResult) -> bool:
+    """Recognize provider limits that should continue an incomplete workflow."""
+    if _is_terminal_success(result):
+        # Pi reports a provider token/length limit as a successful result event.
+        # Semantic completion was already handled before this helper is called.
+        return result.progress_summary.stop_reason.strip().lower() == "length"
+    return _is_context_overflow(result)
+
+
 def _is_context_overflow(result: AISessionResult) -> bool:
     if (result.fatal_error_code or "").lower() == CONTEXT_OVERFLOW:
         return True

package/bundled/dev-pipeline/scripts/update-feature-status.py

@@ -1726,6 +1726,13 @@ def action_clean(args, feature_list_path, state_dir):
     fs["last_session_id"] = None
     fs["resume_from_phase"] = None
     reset_continuation_metadata(fs)
+    for stale_field in (
+        "repair_scope",
+        "repair_round",
+        "blocked_reason",
+        "terminal_status",
+    ):
+        fs.pop(stale_field, None)
     fs["updated_at"] = now_iso()
 
     err = save_feature_status(state_dir, feature_id, fs)

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

@@ -4015,7 +4015,7 @@ def test_pi_length_stop_with_nonzero_exit_uses_bounded_crash_path(tmp_path):
     assert classification.fatal_error_code == ""
 
 
-def test_pi_length_stop_with_zero_exit_and_no_checkpoint_uses_no_completion_policy(tmp_path):
+def test_pi_length_stop_with_zero_exit_and_no_checkpoint_uses_recoverable_continuation(tmp_path):
     from dataclasses import replace
 
     from prizmkit_runtime.runner_classification import classify_session
@@ -4029,9 +4029,120 @@ def test_pi_length_stop_with_zero_exit_and_no_checkpoint_uses_no_completion_poli
 
     classification = classify_session(raw, project_root=tmp_path, base_head=base_head)
 
-    assert classification.session_status == "workflow_skipped"
-    assert classification.reason == "no_semantic_completion"
-    assert classification.fatal_error_code == ""
+    assert classification.session_status == "context_overflow"
+    assert classification.reason == "context_overflow"
+    assert classification.fatal_error_code == "context_overflow"
+
+
+def test_pi_length_stop_with_in_progress_checkpoint_uses_recoverable_continuation(tmp_path):
+    from dataclasses import replace
+
+    from prizmkit_runtime.runner_classification import classify_session
+    from prizmkit_runtime.runner_models import PromptGenerationResult
+    from prizmkit_runtime.status import ProgressSummary
+
+    base_head = _init_git_repo_for_invalid_checkpoint_test(tmp_path)
+    artifact_dir = tmp_path / ".prizmkit" / "specs" / "001-length-in-progress"
+    artifact_dir.mkdir(parents=True)
+    checkpoint = artifact_dir / "workflow-checkpoint.json"
+    checkpoint.write_text(
+        json.dumps({
+            "version": 1,
+            "workflow_type": "feature-pipeline",
+            "steps": [
+                {
+                    "id": "S01",
+                    "skill": "context-snapshot-and-plan",
+                    "name": "Specify & Plan",
+                    "status": "completed",
+                    "required_artifacts": [],
+                    "depends_on": None,
+                    "stage_result": "PLAN_READY",
+                },
+                {
+                    "id": "S02",
+                    "skill": "prizmkit-implement",
+                    "name": "Implement",
+                    "status": "completed",
+                    "required_artifacts": [],
+                    "depends_on": "S01",
+                    "stage_result": "IMPLEMENTED",
+                },
+                {
+                    "id": "S03",
+                    "skill": "prizmkit-code-review",
+                    "name": "Code Review",
+                    "status": "in_progress",
+                    "required_artifacts": [],
+                    "depends_on": "S02",
+                },
+                {
+                    "id": "S04",
+                    "skill": "prizmkit-test",
+                    "name": "Test",
+                    "status": "pending",
+                    "required_artifacts": [],
+                    "depends_on": "S03",
+                },
+                {
+                    "id": "S05",
+                    "skill": "completion-summary",
+                    "name": "Completion Summary",
+                    "status": "pending",
+                    "required_artifacts": [],
+                    "depends_on": "S04",
+                },
+                {
+                    "id": "S06",
+                    "skill": "prizmkit-retrospective",
+                    "name": "Retrospective",
+                    "status": "pending",
+                    "required_artifacts": [],
+                    "depends_on": "S05",
+                },
+                {
+                    "id": "S07",
+                    "skill": "prizmkit-committer",
+                    "name": "Runtime Commit Handoff",
+                    "status": "pending",
+                    "required_artifacts": [],
+                    "depends_on": "S06",
+                },
+            ],
+            "feature_state": {
+                "stage": "code-review",
+                "current_stage": "prizmkit-code-review",
+                "status": "in_progress",
+                "repair_scope": None,
+                "repair_round": 0,
+                "next_stage": "prizmkit-code-review",
+                "blocked_reason": None,
+                "terminal_status": None,
+            },
+        }),
+        encoding="utf-8",
+    )
+    prompt = PromptGenerationResult(
+        output_path=tmp_path / "prompt.md",
+        checkpoint_path=checkpoint,
+        artifact_path=artifact_dir,
+    )
+    raw = replace(
+        _terminal_success_result(tmp_path),
+        progress_summary=ProgressSummary(result_subtype="success", stop_reason="length"),
+    )
+
+    classification = classify_session(
+        raw,
+        project_root=tmp_path,
+        base_head=base_head,
+        prompt=prompt,
+    )
+
+    assert classification.session_status == "context_overflow"
+    assert classification.reason == "context_overflow"
+    assert classification.fatal_error_code == "context_overflow"
+    assert classification.checkpoint_state["current_stage"] == "prizmkit-code-review"
 
 
 def test_pi_length_stop_does_not_override_completed_checkpoint(tmp_path):

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_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

package/bundled/skills/_metadata.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.1.156",
+  "version": "1.1.159",
   "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 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.
+
+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

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

@@ -11,6 +11,7 @@ from typing import Any
 
 VERDICTS = {"PASS", "NEEDS_FIXES"}
 EVENTS = {
+    "scope-classification",
     "main-review-round",
     "repair-verification",
     "independent-review-round",
@@ -25,6 +26,8 @@ REVIEWER_RESULTS = {
 }
 ADJUDICATION_DECISIONS = {"accepted", "rejected", "unresolved"}
 RECHECK_STATES = {"yes", "no", "not applicable"}
+ROUND_CONTINUATION_MODES = {"native", "replacement"}
+DOWNGRADE_CONTINUATION_MODES = {"native", "replacement", "mixed", "not-applicable"}
 FINAL_HEADING = "## Final Result"
 
 
@@ -54,6 +57,25 @@ def _require_count(data: dict[str, Any], name: str, *, maximum: int | None = Non
     return value
 
 
+def _require_text_list(data: dict[str, Any], name: str) -> list[str]:
+    value = data.get(name)
+    if not isinstance(value, list):
+        raise ReportStateError(f"{name} must be an array of strings")
+    normalized: list[str] = []
+    for item in value:
+        if not isinstance(item, str) or not item.strip():
+            raise ReportStateError(f"{name} must contain only non-empty strings")
+        text = item.strip()
+        if text in normalized:
+            raise ReportStateError(f"{name} must not contain duplicates")
+        normalized.append(text)
+    return normalized
+
+
+def _render_path_list(paths: list[str]) -> list[str]:
+    return [f"  - {path}" for path in paths] if paths else ["  - None."]
+
+
 def _report_text(path: Path) -> str:
     try:
         return path.read_text(encoding="utf-8")
@@ -91,6 +113,20 @@ def _render_event(data: dict[str, Any]) -> str:
     if event not in EVENTS:
         raise ReportStateError(f"event has invalid value: {event!r}")
 
+    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:",
+                *_render_path_list(in_scope),
+                "- Default-Excluded Changed Paths:",
+                *_render_path_list(excluded),
+            ]
+        )
+
     if event == "main-review-round":
         round_number = _require_count(data, "round", maximum=10)
         if round_number < 1:
@@ -131,6 +167,15 @@ def _render_event(data: dict[str, Any]) -> str:
         response = _require_count(data, "response", maximum=5)
         if response < 1:
             raise ReportStateError("response must be at least 1")
+        capability_basis = _require_text(data, "capability_basis")
+        continuation_mode = _require_text(data, "continuation_mode")
+        if continuation_mode not in ROUND_CONTINUATION_MODES:
+            raise ReportStateError(
+                f"continuation_mode has invalid value: {continuation_mode!r}"
+            )
+        reviewer_replacements = _require_count(
+            data, "reviewer_replacements", maximum=1
+        )
         result = _require_text(data, "result")
         if result not in REVIEWER_RESULTS:
             raise ReportStateError(f"result has invalid value: {result!r}")
@@ -156,6 +201,10 @@ def _render_event(data: dict[str, Any]) -> str:
             [
                 f"## Independent Review Round {response}",
                 "",
+                "- Capability Gate: ENABLED",
+                f"- Capability Basis: {capability_basis}",
+                f"- Continuation Mode: {continuation_mode}",
+                f"- Reviewer Replacements: {reviewer_replacements}",
                 f"- Result: {result}",
                 f"- Corrections: {corrections}",
                 f"- Accepted: {accepted}",
@@ -181,6 +230,15 @@ def _render_event(data: dict[str, Any]) -> str:
         )
 
     if event == "independent-review-downgrade":
+        capability_basis = _require_text(data, "capability_basis")
+        continuation_mode = _require_text(data, "continuation_mode")
+        if continuation_mode not in DOWNGRADE_CONTINUATION_MODES:
+            raise ReportStateError(
+                f"continuation_mode has invalid value: {continuation_mode!r}"
+            )
+        reviewer_replacements = _require_count(
+            data, "reviewer_replacements", maximum=1
+        )
         rechecked = _require_text(data, "final_state_independently_rechecked")
         if rechecked not in RECHECK_STATES:
             raise ReportStateError(
@@ -192,6 +250,9 @@ def _render_event(data: dict[str, Any]) -> str:
                 "## Independent Review Downgrade",
                 "",
                 f"- Reason: {_require_text(data, 'reason')}",
+                f"- Capability Basis: {capability_basis}",
+                f"- Continuation Mode: {continuation_mode}",
+                f"- Reviewer Replacements: {reviewer_replacements}",
                 f"- Fallback: {_require_text(data, 'fallback')}",
                 f"- Final State Independently Rechecked: {rechecked}",
             ]