prizmkit 1.1.143 → 1.1.144

package/bundled/VERSION.json

@@ -1,5 +1,5 @@
 {
-  "frameworkVersion": "1.1.143",
-  "bundledAt": "2026-07-21T14:41:54.248Z",
-  "bundledFrom": "1e6fbd1"
+  "frameworkVersion": "1.1.144",
+  "bundledAt": "2026-07-22T02:07:34.475Z",
+  "bundledFrom": "a2ab913"
 }

package/bundled/adapters/pi/paths.js

@@ -0,0 +1,9 @@
+/** Pi platform path constants and conventions. */
+export const PLATFORM_ID = 'pi';
+export const CLI_COMMAND = 'pi';
+export const SKILLS_DIR = '.pi/skills';
+export const RULES_DIR = '.pi/rules';
+export const SETTINGS_FILE = '.pi/settings.json';
+export const PROJECT_MEMORY_FILE = '.pi/APPEND_SYSTEM.md';
+export const SKILL_DEFINITION_FILE = 'SKILL.md';
+export const SKILL_DIR_VAR = '${SKILL_DIR}';

package/bundled/adapters/pi/rules-adapter.js

@@ -0,0 +1,13 @@
+/** Install behavioral Markdown guidance for Pi project sessions. */
+import { mkdirSync } from 'node:fs';
+import { writeFile } from 'node:fs/promises';
+import path from 'node:path';
+
+export async function installRules(targetRoot, ruleFiles) {
+  const rulesDir = path.join(targetRoot, '.pi', 'rules');
+  mkdirSync(rulesDir, { recursive: true });
+  for (const rule of ruleFiles) {
+    const baseName = path.basename(rule.name);
+    await writeFile(path.join(rulesDir, `${baseName}.md`), rule.content);
+  }
+}

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

@@ -0,0 +1,23 @@
+/** Merge the minimal PrizmKit settings required by Pi. */
+import { existsSync, mkdirSync } from 'node:fs';
+import { readFile, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+
+export async function generateSettings(targetRoot) {
+  const settingsPath = path.join(targetRoot, '.pi', 'settings.json');
+  mkdirSync(path.dirname(settingsPath), { recursive: true });
+  let existing = {};
+  if (existsSync(settingsPath)) {
+    const raw = await readFile(settingsPath, 'utf8');
+    try {
+      existing = JSON.parse(raw);
+    } catch (error) {
+      throw new Error(`Refusing to overwrite malformed Pi settings at .pi/settings.json: ${error.message}`);
+    }
+    if (!existing || Array.isArray(existing) || typeof existing !== 'object') {
+      throw new Error('Refusing to overwrite Pi settings because .pi/settings.json is not a JSON object.');
+    }
+  }
+  existing.enableSkillCommands = true;
+  await writeFile(settingsPath, `${JSON.stringify(existing, null, 2)}\n`);
+}

package/bundled/adapters/pi/skill-adapter.js

@@ -0,0 +1,18 @@
+/** Convert canonical PrizmKit skills to Pi project skills. */
+import { parseFrontmatter, buildMarkdown } from '../shared/frontmatter.js';
+
+function applyPiInteractionCompatibility(content) {
+  return content.replace(
+    /\bAskUserQuestion\b/g,
+    'ask the same question directly in chat and wait for explicit user input',
+  );
+}
+
+export function convertSkill(skillContent, skillName) {
+  const { frontmatter, body } = parseFrontmatter(skillContent);
+  if (!frontmatter.name) frontmatter.name = skillName;
+  const convertedBody = applyPiInteractionCompatibility(body)
+    .replace(/\$\{SKILL_DIR\}/g, `.pi/skills/${skillName}`);
+  const note = `> Pi project install: invoke this skill with \`/skill:${skillName}\`. When instructions mention a PrizmKit slash command such as \`/prizmkit-plan\`, load and execute the matching project skill with \`/skill:prizmkit-plan\` from \`.pi/skills/prizmkit-plan/SKILL.md\`.\n>\n> Pi interaction compatibility: in interactive sessions, ask required questions directly in chat and wait for explicit user input. Only true headless runs may use documented conservative defaults.\n\n`;
+  return buildMarkdown(frontmatter, note + convertedBody);
+}

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

@@ -76,12 +76,14 @@ AI_CLIENT_PRECEDENCE = (
     "PATH:claude",
     "PATH:cbc",
     "PATH:codex",
+    "PATH:pi",
 )
 
 _EFFORT_VALUES_BY_PLATFORM = {
     "claude": ("low", "medium", "high", "xhigh", "max"),
     "codex": ("low", "medium", "high", "xhigh"),
     "codebuddy": ("low", "medium", "high", "xhigh"),
+    "pi": ("off", "minimal", "low", "medium", "high", "xhigh", "max"),
 }
 
 
@@ -169,10 +171,12 @@ def _cli_names_for_platform(platform: str | None) -> tuple[str, ...]:
         return ("claude",)
     if normalized == "codebuddy":
         return ("cbc",)
+    if normalized == "pi":
+        return ("pi",)
     if normalized == "both":
         return ("claude", "cbc")
     if normalized == "all":
-        return ("codex", "claude", "cbc")
+        return ("codex", "claude", "cbc", "pi")
     return ()
 
 
@@ -188,6 +192,8 @@ def _known_platform_from_cli(cli_command: str | None) -> str | None:
         return "claude"
     if name == "codex":
         return "codex"
+    if name == "pi":
+        return "pi"
     if name in {"cbc", "codebuddy"}:
         return "codebuddy"
     return None
@@ -195,7 +201,7 @@ def _known_platform_from_cli(cli_command: str | None) -> str | None:
 
 def _concrete_platform(platform: str | None) -> str | None:
     normalized = _normalize_platform(platform)
-    return normalized if normalized in {"claude", "codebuddy", "codex"} else None
+    return normalized if normalized in {"claude", "codebuddy", "codex", "pi"} else None
 
 
 def _resolve_cli_name(cli_name: str, env: Mapping[str, str]) -> str | None:
@@ -269,6 +275,10 @@ def _installed_platform_cli(
     paths: RuntimePaths,
     env: Mapping[str, str],
 ) -> tuple[str | None, str | None]:
+    if (paths.project_root / ".pi" / "skills" / "prizmkit" / "SKILL.md").is_file():
+        resolved = _resolve_cli_name("pi", env)
+        if resolved:
+            return resolved, "installed-platform:pi"
     if (paths.project_root / ".agents" / "skills" / "prizmkit" / "SKILL.md").is_file():
         resolved = _resolve_cli_name("codex", env)
         if resolved:
@@ -379,7 +389,7 @@ def _resolve_ai_client(paths: RuntimePaths, env: Mapping[str, str]) -> AIClientR
             precedence=AI_CLIENT_PRECEDENCE,
         )
 
-    for candidate in ("claude", "cbc", "codex"):
+    for candidate in ("claude", "cbc", "codex", "pi"):
         resolved = _resolve_cli_name(candidate, env)
         if resolved:
             return AIClientResolution(
@@ -424,6 +434,7 @@ def validate_effort(effort: str | None, platform: str | None) -> EffortValidatio
             "claude": "Claude Code",
             "codex": "Codex",
             "codebuddy": "CodeBuddy",
+            "pi": "Pi",
         }.get(_concrete_platform(platform) or "codebuddy", "CodeBuddy")
         message = (
             f"PRIZMKIT_EFFORT='{normalized_effort}' is not supported by the detected CLI "
@@ -453,6 +464,7 @@ def load_runtime_config(paths: RuntimePaths, env: Mapping[str, str] | None = Non
             paths.project_root / ".codebuddy",
             paths.project_root / ".claude",
             paths.project_root / ".codex",
+            paths.project_root / ".pi",
         ),
         path_entries=_path_entries(runtime_env),
         sources=("environment", "prizmkit-env", "prizmkit-config", "installed-platform-markers", "PATH"),

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

@@ -33,6 +33,8 @@ HIDDEN_TOOL_WORKTREE_EXCLUDES = (
     ":(top,exclude,glob).codex/**",
     ":(top,exclude).agents",
     ":(top,exclude,glob).agents/**",
+    ":(top,exclude).pi",
+    ":(top,exclude,glob).pi/**",
 )
 
 UNTRACKED_TRANSIENT_EXCLUDES = (
@@ -45,7 +47,7 @@ UNTRACKED_TRANSIENT_EXCLUDES = (
 PIPELINE_FALLBACK_GIT_NAME = "PrizmKit Pipeline"
 PIPELINE_FALLBACK_GIT_EMAIL = "prizmkit-pipeline@example.invalid"
 
-WORKTREE_PLATFORM_SUPPORT_DIRS = (".claude", ".codebuddy", ".codex", ".agents")
+WORKTREE_PLATFORM_SUPPORT_DIRS = (".claude", ".codebuddy", ".codex", ".agents", ".pi")
 WORKTREE_ROOT_SUPPORT_FILES = ("skills-lock.json", "AGENTS.md")
 WORKTREE_PRIZMKIT_SUPPORT_ENTRIES = ("prizm-docs", "config.json", "manifest.json")
 WORKTREE_SUPPORT_IGNORE_NAMES = {"__pycache__", ".DS_Store", "settings.local.json"}

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

@@ -8,7 +8,7 @@ from collections.abc import Mapping
 from dataclasses import dataclass
 from pathlib import Path
 
-SUPPORTED_PLATFORMS = ("claude", "codex", "codebuddy")
+SUPPORTED_PLATFORMS = ("claude", "codex", "codebuddy", "pi")
 
 
 @dataclass(frozen=True)
@@ -44,6 +44,7 @@ _PLATFORM_MARKERS = {
     "claude": (".claude/commands", ".claude/skills"),
     "codex": (".agents/skills",),
     "codebuddy": (".codebuddy/skills",),
+    "pi": (".pi/skills",),
 }
 
 
@@ -63,6 +64,11 @@ _PLATFORM_SKILL_PATTERNS = {
         ("home-skill", "~/.codebuddy/skills/{skill}"),
         ("legacy-home-skill", "~/.cbc/skills/{skill}"),
     ),
+    "pi": (
+        ("project-skill", ".pi/skills/{skill}"),
+        ("project-agent-skill", ".agents/skills/{skill}"),
+        ("home-skill", "~/.pi/agent/skills/{skill}"),
+    ),
 }
 
 
@@ -88,6 +94,8 @@ def platform_from_command(command: object) -> str:
         return "codex"
     if base in ("cbc", "codebuddy") or "codebuddy" in base:
         return "codebuddy"
+    if base == "pi":
+        return "pi"
     return ""
 
 
@@ -144,7 +152,7 @@ def resolve_platform(project_root: str | Path, env: Mapping[str, str] | None = N
         "unresolved",
         (
             "No supported platform marker found. Set PRIZMKIT_PLATFORM, configure .prizmkit/config.json, "
-            "or install Claude/Codex/CodeBuddy platform files.",
+            "or install Claude/Codex/CodeBuddy/Pi platform files.",
         ),
     )
 

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

@@ -27,6 +27,7 @@ LOCAL_ONLY_PLATFORM_PATHS = (
     ".codebuddy/settings.local.json",
     ".codex/settings.local.json",
     ".agents/settings.local.json",
+    ".pi/settings.local.json",
 )
 PIPELINE_MANIFEST_PATH = ".prizmkit/manifest.json"
 CONFLICT_MARKERS = (b"<<<<<<< ", b"=======", b">>>>>>> ")

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

@@ -28,6 +28,7 @@ class RecoveryDetectorResolver:
             project / ".agents" / "skills" / "recovery-workflow" / "scripts" / "detect-recovery-state.py",
             project / ".claude" / "command-assets" / "recovery-workflow" / "scripts" / "detect-recovery-state.py",
             project / ".codebuddy" / "skills" / "recovery-workflow" / "scripts" / "detect-recovery-state.py",
+            project / ".pi" / "skills" / "recovery-workflow" / "scripts" / "detect-recovery-state.py",
             project
             / "core"
             / "skills"

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

@@ -113,7 +113,7 @@ HelpRunner = Callable[[Sequence[str]], str]
 
 def _normalize_platform(platform: str | None) -> str:
     normalized = (platform or "").strip().lower()
-    return normalized if normalized in {"claude", "codex", "codebuddy", "custom"} else "codebuddy"
+    return normalized if normalized in {"claude", "codex", "codebuddy", "pi", "custom"} else "codebuddy"
 
 
 def _prompt_text(path: Path) -> str:
@@ -139,9 +139,16 @@ def detect_stream_json_support(
     """Detect stream-json support using shell-compatible provider rules."""
     normalized = _normalize_platform(platform)
     command_name = Path(str(cli_command).split()[0].strip("'\"")).name.lower()
+    runner = help_runner or _default_help_runner
     if normalized == "codebuddy" or command_name == "cbc":
         return StreamJsonSupport(True, "stream-json", "codebuddy-default")
-    runner = help_runner or _default_help_runner
+    if normalized == "pi" or command_name == "pi":
+        help_output = runner((cli_command, "--help"))
+        required = ("--mode", "--approve", "--no-session", "--tools", "--model", "--thinking")
+        missing = tuple(flag for flag in required if flag not in help_output)
+        if not missing:
+            return StreamJsonSupport(True, "pi-json", "pi-help")
+        return StreamJsonSupport(False, "", "pi-help", tuple(f"{flag} not found" for flag in missing))
     if normalized == "codex":
         help_output = runner((cli_command, "exec", "--help"))
         if "--json" in help_output:
@@ -168,6 +175,23 @@ def build_ai_session_command(config: AISessionConfig) -> AISessionCommand:
         argv.extend(config.launch_profile.extra_args)
         argv.extend(config.extra_args)
         return AISessionCommand(tuple(argv), None, "custom", "argument", prompt)
+    if platform == "pi":
+        argv = [
+            config.cli_command,
+            "--mode",
+            "json",
+            "--approve",
+            "--no-session",
+            "--tools",
+            "read,bash,edit,write,grep,find,ls",
+        ]
+        if config.model:
+            argv.extend(["--model", config.model])
+        if config.effort:
+            argv.extend(["--thinking", config.effort])
+        argv.extend(config.extra_args)
+        return AISessionCommand(tuple(argv), prompt, "pi", "stdin", prompt)
+
     if platform == "claude":
         argv = [
             config.cli_command,

package/bundled/dev-pipeline/scripts/parse-stream-progress.py

@@ -258,13 +258,7 @@ class ProgressTracker:
     def process_event(self, event):
         """Process a single stream-json event and update state.
 
-        Supports three formats:
-        1. Claude API raw stream: message_start, content_block_start, content_block_delta, etc.
-        2. Claude Code verbose stream-json: assistant, user, tool_result, system, etc.
-           (produced by claude/claude-internal --verbose --output-format stream-json)
-        3. CodeBuddy stream-json: message/function_call/function_call_result events
-           (produced by cbc --print -y --output-format stream-json — message type
-           with sessionId/cwd metadata, function_call for tool invocations).
+        Supports Claude API/CLI, CodeBuddy, Codex JSONL, and Pi JSONL formats.
         """
         event_type = event.get("type", "")
         if event_type:
@@ -288,6 +282,66 @@ class ProgressTracker:
 
         self._record_structured_subagent_metadata(event)
 
+        # ── Pi --mode json JSONL format ─────────────────────────────
+        pi_event_types = {
+            "session", "agent_start", "agent_end", "turn_start", "turn_end",
+            "message_start", "message_update", "message_end",
+            "tool_execution_start", "tool_execution_update", "tool_execution_end",
+            "queue_update", "compaction_start", "compaction_end",
+            "auto_retry_start", "auto_retry_end",
+        }
+        if event_type == "session" or (self.event_format == "pi-json" and event_type in pi_event_types):
+            self.event_format = "pi-json"
+            if event_type in {"agent_start", "turn_start", "message_start", "message_update", "tool_execution_start", "tool_execution_update", "compaction_start", "auto_retry_start"}:
+                self.is_active = True
+            if event_type == "turn_start":
+                self.message_count += 1
+            elif event_type in {"message_update", "message_end"}:
+                assistant_event = event.get("assistantMessageEvent")
+                text = ""
+                if isinstance(assistant_event, dict):
+                    text = str(assistant_event.get("delta") or assistant_event.get("text") or "")
+                if not text:
+                    message = event.get("message")
+                    if isinstance(message, dict):
+                        content = message.get("content")
+                        if isinstance(content, str):
+                            text = content
+                        elif isinstance(content, list):
+                            text = "\n".join(
+                                str(item.get("text") or "")
+                                for item in content if isinstance(item, dict)
+                            )
+                if text.strip():
+                    self.last_text_snippet = text.strip()[-120:]
+                    self._detect_phase(text)
+                    self._detect_terminal_error(text, require_error_context=True)
+            elif event_type == "tool_execution_start":
+                tool_name = str(event.get("toolName") or "unknown")
+                self.current_tool = tool_name
+                self.tool_call_counts[tool_name] += 1
+                self.total_tool_calls += 1
+                args = event.get("args")
+                if isinstance(args, dict):
+                    self._extract_tool_summary_from_dict(args)
+                    self._detect_phase(json.dumps(args, ensure_ascii=False)[:500])
+            elif event_type == "tool_execution_end":
+                self.current_tool = None
+                if event.get("isError"):
+                    result = event.get("result")
+                    error_text = json.dumps(result, ensure_ascii=False, default=str)
+                    self.errors.append(error_text[:500])
+                    self._detect_terminal_error(error_text, require_error_context=True)
+            elif event_type in {"compaction_end", "auto_retry_end"}:
+                error_text = str(event.get("errorMessage") or event.get("finalError") or "")
+                if error_text:
+                    self.errors.append(error_text[:500])
+                    self._detect_terminal_error(error_text, require_error_context=True)
+            elif event_type == "agent_end":
+                self.current_tool = None
+                self.is_active = False
+            return
+
         # ── Codex exec --json JSONL format ──────────────────────────
         if event_type in (
             "thread.started", "turn.started", "turn.completed",

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

@@ -547,6 +547,30 @@ def test_runtime_config_loads_prizmkit_env_and_validates_effort(tmp_path):
     assert config.effort_validation.valid is True
     assert validate_effort("max", "codex").valid is False
     assert "Codex" in validate_effort("max", "codex").message
+    assert validate_effort("max", "pi").valid is True
+    assert validate_effort("minimal", "pi").valid is True
+
+
+def test_runtime_config_resolves_pi_from_config_and_installed_marker(tmp_path):
+    from prizmkit_runtime.config import resolve_ai_client
+    from prizmkit_runtime.paths import resolve_runtime_paths
+
+    project = tmp_path / "project"
+    pipeline = project / ".prizmkit" / "dev-pipeline"
+    pipeline.mkdir(parents=True)
+    (project / ".prizmkit" / "config.json").write_text('{"ai_cli":"pi"}', encoding="utf-8")
+    paths = resolve_runtime_paths(pipeline_root=pipeline)
+    configured = resolve_ai_client(paths, env={"PATH": ""})
+    assert configured.command == "pi"
+    assert configured.platform == "pi"
+    assert configured.launch_profile is None
+
+    (project / ".prizmkit" / "config.json").unlink()
+    marker = project / ".pi" / "skills" / "prizmkit"
+    marker.mkdir(parents=True)
+    (marker / "SKILL.md").write_text("---\nname: prizmkit\ndescription: test\n---\n", encoding="utf-8")
+    unresolved = resolve_ai_client(paths, env={"PATH": ""})
+    assert unresolved.command is None
 
 
 def test_stream_json_support_detection_matches_provider_rules():
@@ -557,16 +581,21 @@ def test_stream_json_support_detection_matches_provider_rules():
             return "Usage: codex exec --json"
         if tuple(command) == ("claude", "--help"):
             return "--output-format stream-json"
+        if tuple(command) == ("pi", "--help"):
+            return "--mode --approve --no-session --tools --model --thinking"
         return ""
 
     codebuddy = detect_stream_json_support("cbc", "codebuddy", help_runner)
     codex = detect_stream_json_support("codex", "codex", help_runner)
     claude = detect_stream_json_support("claude", "claude", help_runner)
+    pi = detect_stream_json_support("pi", "pi", help_runner)
     unsupported = detect_stream_json_support("other", "claude", lambda _cmd: "plain help")
 
     assert codebuddy.enabled and codebuddy.format == "stream-json"
     assert codex.enabled and codex.format == "codex-json"
     assert claude.enabled and claude.format == "stream-json"
+    assert pi.enabled and pi.format == "pi-json"
+    assert detect_stream_json_support("pi", "pi", lambda _cmd: "--mode").enabled is False
     assert unsupported.enabled is False
 
 
@@ -628,6 +657,27 @@ def test_ai_session_command_builders_match_unix_runtime_snapshot(tmp_path):
     assert codebuddy.argv[1:] == expected_codebuddy
     assert codebuddy.stdin_text == "hello"
 
+    pi = build_ai_session_command(
+        AISessionConfig(
+            cli_command="pi",
+            platform="pi",
+            model="anthropic/sonnet",
+            prompt_path=prompt,
+            cwd=project,
+            effort="max",
+            use_stream_json=True,
+        )
+    )
+    assert pi.argv == (
+        "pi", "--mode", "json", "--approve", "--no-session", "--tools",
+        "read,bash,edit,write,grep,find,ls", "--model", "anthropic/sonnet",
+        "--thinking", "max",
+    )
+    assert pi.stdin_text == "hello"
+    assert pi.prompt_mode == "stdin"
+    assert "hello" not in pi.argv
+    assert not ({"--effort", "--sandbox", "--output-format", "--disallowedTools", "-y"} & set(pi.argv))
+
 
 def test_custom_ai_session_command_builder_injects_prompt_and_tokenizes_extra_args(tmp_path):
     from prizmkit_runtime.launch_profiles import HeadlessLaunchProfile
@@ -717,6 +767,20 @@ def test_start_command_serialization_redacts_prompt_and_preserves_provider_flags
     assert codex.endswith(" -")
     assert secret_prompt not in codex
 
+    pi = format_start_command(
+        build_ai_session_command(
+            AISessionConfig(
+                cli_command="pi",
+                platform="pi",
+                model=None,
+                prompt_path=prompt,
+                cwd=project,
+            )
+        )
+    )
+    assert pi.startswith("pi --mode json --approve --no-session")
+    assert secret_prompt not in pi
+
     custom = format_start_command(
         build_ai_session_command(
             AISessionConfig(
@@ -877,6 +941,30 @@ def test_progress_parser_adds_required_metadata(tmp_path):
 
 
 
+def test_progress_parser_normalizes_pi_json_events():
+    module = _load_progress_parser_module()
+    tracker = module.ProgressTracker()
+    tracker.process_event({"type": "session", "version": 3, "id": "pi-session", "cwd": "/tmp/project"})
+    tracker.process_event({"type": "agent_start"})
+    tracker.process_event({"type": "turn_start"})
+    tracker.process_event({
+        "type": "message_update",
+        "assistantMessageEvent": {"type": "text_delta", "delta": "Running prizmkit-implement"},
+    })
+    tracker.process_event({"type": "tool_execution_start", "toolName": "edit", "args": {"path": "src/a.js"}})
+    tracker.process_event({"type": "tool_execution_end", "toolName": "edit", "result": {"ok": True}, "isError": False})
+    tracker.process_event({"type": "compaction_start", "reason": "threshold"})
+    tracker.process_event({"type": "compaction_end", "reason": "threshold", "aborted": False, "willRetry": False})
+    tracker.process_event({"type": "agent_end", "messages": []})
+    data = tracker.to_dict()
+    assert data["event_format"] == "pi-json"
+    assert data["message_count"] == 1
+    assert data["total_tool_calls"] == 1
+    assert {item["name"]: item["count"] for item in data["tool_calls"]}["edit"] == 1
+    assert data["current_phase"] == "implement"
+    assert data["is_active"] is False
+
+
 def test_progress_parser_normalizes_claude_subagents_without_double_counting(tmp_path):
     module = _load_progress_parser_module()
     tracker = module.ProgressTracker()

package/bundled/skills/_metadata.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.1.143",
+  "version": "1.1.144",
   "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

@@ -119,11 +119,11 @@ Run only after the Main-Agent review and repair loop converges with no unresolve
 
 1. Read `${SKILL_DIR}/references/independent-code-review.md` and follow its complete contract.
 2. Apply its all-or-nothing semantic Host Capability Gate. If any required structural capability is unavailable or unproven, create no Reviewer, append `independent-review-downgrade`, and preserve the valid completed Main-Agent review.
-3. When the gate passes, capture bounded immutable input for the complete current change and create exactly one Code Reviewer with the reference's Initial Reviewer Prompt.
+3. When the gate passes, provide exact artifact/spec/plan paths and contents, Main-Agent-captured complete current changes, implementation context, and verification results to one active Code Reviewer with the reference's Initial Reviewer Prompt.
 4. Use maximum five Reviewer responses. Append `independent-review-round` and `independent-adjudication` events. The Main Agent adjudicates every correction as `accepted`, `rejected`, or `unresolved` and retains all mutation authority.
 5. For accepted corrections, repair directly in the active checkout, run targeted verification, and inspect the complete resulting change.
-6. When responses remain, capture the complete fresh state and natively resume the exact same Reviewer. Never create a replacement Reviewer or simulate continuation with a fresh Reviewer plus summary.
-7. If native resume fails after repair, append downgrade and rerun the Main-Agent review over that repair within the existing ten-round safety fuse.
+6. When responses remain, prepare complete latest state and prefer native continuation. If unavailable, the reference permits one compliant replacement with complete latest state, prior adjudication, and the same remaining budget.
+7. If neither compliant continuation nor replacement is available after repair, append downgrade and rerun the Main-Agent review over that repair within the existing ten-round safety fuse.
 8. If the fifth response causes a repair, run targeted verification, inspect the complete final change, record `Final State Independently Rechecked: no`, and do not send a sixth response.
 9. `NO_CORRECTION_NEEDED` or all corrections rejected with evidence converges independent review. Any unresolved correction produces `NEEDS_FIXES`.