prizmkit 1.1.102 → 1.1.105

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

@@ -8,6 +8,7 @@ import os
 import queue
 import shutil
 import subprocess
+import sys
 import threading
 import time
 from collections import Counter
@@ -45,12 +46,16 @@ class AISessionConfig:
     heartbeat_path: Path | None = None
     effort: str | None = None
     verbose: bool = False
+    live_output: bool = False
     use_stream_json: bool = False
     stream_json_format: str = ""
     permission_mode: str = "dangerously-skip-permissions"
     total_timeout_seconds: float | None = None
     stale_kill_threshold_seconds: float = 0
     stale_kill_grace_seconds: float = 10
+    live_progress_interval_seconds: float = 30
+    live_banner: bool = True
+    suppress_stream_output: bool = False
     codex_subagent_timeout_seconds: int = 3300
     extra_args: tuple[str, ...] = ()
     environment_overrides: Mapping[str, str] = field(default_factory=dict)
@@ -363,12 +368,109 @@ def _write_progress_summary(progress_path: Path | None, summary: ProgressSummary
     progress_path.write_text(json.dumps(summary.to_dict(), indent=2, sort_keys=True) + "\n", encoding="utf-8")
 
 
+def _emit_live_line(message: str) -> None:
+    """Print foreground runner status without interfering with file logging."""
+    print(message, file=sys.stderr, flush=True)
+
+
+def _emit_live_output(line: str) -> None:
+    """Forward AI CLI output for verbose foreground runs."""
+    sys.stdout.write(line)
+    sys.stdout.flush()
+
+
+def _format_bytes(size: int) -> str:
+    if size >= 1024 * 1024:
+        return f"{round(size / (1024 * 1024))}MB"
+    if size >= 1024:
+        return f"{round(size / 1024)}KB"
+    return f"{size}B"
+
+
+def _format_elapsed(seconds: float) -> str:
+    total = max(0, int(seconds))
+    minutes, remainder = divmod(total, 60)
+    return f"{minutes}m{remainder:02d}s"
+
+
+def _read_json_object(path: Path | None) -> dict[str, object]:
+    if path is None or not path.is_file():
+        return {}
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return {}
+    return data if isinstance(data, dict) else {}
+
+
+def _compact_progress_line(started_epoch: float, session_log: Path, progress_path: Path | None) -> str:
+    data = _read_json_object(progress_path)
+    try:
+        log_size = session_log.stat().st_size
+    except OSError:
+        log_size = 0
+    parts = [
+        f"  ▶ [HEARTBEAT] {_format_elapsed(time.time() - started_epoch)}",
+        f"log: {_format_bytes(log_size)}",
+    ]
+    child_bytes = int(data.get("child_total_bytes") or 0)
+    subagents = int(data.get("subagent_spawn_count") or 0)
+    if child_bytes or subagents:
+        child = _format_bytes(child_bytes)
+        if subagents:
+            child = f"{child}/{subagents}"
+        parts.append(f"child: {child}")
+    phase = str(data.get("current_phase") or "").strip()
+    if phase:
+        parts.append(f"phase: {phase}")
+    tool = str(data.get("current_tool") or "").strip()
+    if tool:
+        parts.append(f"tool: {tool}")
+    messages = int(data.get("message_count") or 0)
+    if messages:
+        parts.append(f"msgs: {messages}")
+    tool_calls = int(data.get("total_tool_calls") or 0)
+    if tool_calls:
+        parts.append(f"{tool_calls} tool calls")
+    return " | ".join(parts)
+
+
+def _emit_progress_tick(started_epoch: float, session_log: Path, progress_path: Path | None, last_line: str) -> str:
+    line = _compact_progress_line(started_epoch, session_log, progress_path)
+    if line != last_line:
+        _emit_live_line(line)
+        return line
+    return last_line
+
+
+def _emit_session_start(config: AISessionConfig, command: AISessionCommand, session_log: Path, backup_log: Path) -> None:
+    _emit_live_line("[prizmkit] AI session started")
+    _emit_live_line(f"[prizmkit] Provider: {command.provider}")
+    _emit_live_line(f"[prizmkit] Prompt: {config.prompt_path}")
+    _emit_live_line(f"[prizmkit] Session log: {session_log}")
+    _emit_live_line(f"[prizmkit] Backup log: {backup_log}")
+    if config.progress_path is not None:
+        _emit_live_line(f"[prizmkit] Progress: {config.progress_path}")
+    if config.heartbeat_path is not None:
+        _emit_live_line(f"[prizmkit] Heartbeat: {config.heartbeat_path}")
+    if config.verbose:
+        _emit_live_line("[prizmkit] VERBOSE=1: compact live progress enabled")
+
+
+def _emit_session_finish(result: AISessionResult) -> None:
+    duration = max(0.0, result.ended_epoch - result.started_epoch)
+    status = result.termination_reason or f"exit_code={result.exit_code}"
+    _emit_live_line(f"[prizmkit] AI session finished ({status}, {duration:.1f}s)")
+    _emit_live_line(f"[prizmkit] Session log: {result.session_log}")
+
+
 def _reader_thread(
     pipe,
     session_log: Path,
     backup_log: Path,
     output_queue: "queue.Queue[str]",
     progress_path: Path | None = None,
+    live_output: bool = False,
 ) -> None:
     lines: list[str] = []
     tracker = None
@@ -387,6 +489,8 @@ def _reader_thread(
             with backup_log.open("a", encoding="utf-8") as backup_fh:
                 backup_fh.write(line)
             output_queue.put(line)
+            if live_output:
+                _emit_live_output(line)
             lines.append(line)
             if progress_path is not None:
                 if tracker is not None:
@@ -472,12 +576,22 @@ class AISessionLauncher:
             environment_unsets=("CLAUDECODE",),
             stdin_text=command.stdin_text,
         )
+        if self.config.live_output and self.config.live_banner:
+            _emit_session_start(self.config, command, session_log, backup_log)
+
         handle = launch_process(spec, stderr=subprocess.STDOUT)
         assert handle.popen is not None
         output_queue: queue.Queue[str] = queue.Queue()
         reader = threading.Thread(
             target=_reader_thread,
-            args=(handle.popen.stdout, session_log, backup_log, output_queue, self.config.progress_path),
+            args=(
+                handle.popen.stdout,
+                session_log,
+                backup_log,
+                output_queue,
+                self.config.progress_path,
+                self.config.live_output and self.config.verbose and not self.config.suppress_stream_output,
+            ),
             daemon=True,
         )
         reader.start()
@@ -510,12 +624,34 @@ class AISessionLauncher:
         timed_out = False
         termination_reason = None
         stale_marker = None
+        last_progress_line = ""
+        last_progress_emit = 0.0
         try:
-            handle.popen.wait(timeout=self.config.total_timeout_seconds)
-        except subprocess.TimeoutExpired:
-            timed_out = True
-            termination_reason = "timeout"
-            terminate_process_tree(handle, "timeout", grace_seconds=self.config.stale_kill_grace_seconds)
+            while True:
+                timeout = 0.2
+                if self.config.total_timeout_seconds is not None:
+                    remaining = self.config.total_timeout_seconds - (time.time() - started)
+                    if remaining <= 0:
+                        timed_out = True
+                        termination_reason = "timeout"
+                        terminate_process_tree(handle, "timeout", grace_seconds=self.config.stale_kill_grace_seconds)
+                        break
+                    timeout = min(timeout, remaining)
+                try:
+                    handle.popen.wait(timeout=timeout)
+                    break
+                except subprocess.TimeoutExpired:
+                    if self.config.live_output and (not self.config.verbose or self.config.suppress_stream_output):
+                        interval = max(1.0, float(self.config.live_progress_interval_seconds or 30))
+                        now = time.time()
+                        if last_progress_emit == 0.0 or now - last_progress_emit >= interval:
+                            last_progress_line = _emit_progress_tick(started, session_log, self.config.progress_path, last_progress_line)
+                            last_progress_emit = now
+        except KeyboardInterrupt:
+            terminate_process_tree(handle, "interrupted", grace_seconds=self.config.stale_kill_grace_seconds)
+            raise
+        if self.config.live_output and (not self.config.verbose or self.config.suppress_stream_output):
+            _emit_progress_tick(started, session_log, self.config.progress_path, last_progress_line)
         reader.join(timeout=5)
         heartbeat_result = heartbeat.stop() if heartbeat is not None else None
         if heartbeat_result and heartbeat_result.killed:
@@ -544,7 +680,7 @@ class AISessionLauncher:
             self.config.progress_path.write_text(json.dumps(merged_progress, indent=2, sort_keys=True) + "\n", encoding="utf-8")
         final_summary = _summary_from_progress_dict(merged_progress, summary)
         ended = time.time()
-        return AISessionResult(
+        result = AISessionResult(
             command=command,
             exit_code=handle.popen.returncode,
             timed_out=timed_out,
@@ -558,3 +694,6 @@ class AISessionLauncher:
             started_epoch=started,
             ended_epoch=ended,
         )
+        if self.config.live_output and self.config.live_banner:
+            _emit_session_finish(result)
+        return result

package/bundled/dev-pipeline/scripts/generate-bootstrap-prompt.py

@@ -1296,32 +1296,36 @@ def load_section(sections_dir, name):
         return f.read()
 
 
-def load_agent_prompts(templates_dir):
-    """Load agent prompt templates from agent-prompts/ directory.
+ACTIVE_AGENT_PROMPTS = {
+    "critic-plan-challenge.md": "{{AGENT_PROMPT_CRITIC_PLAN_CHALLENGE}}",
+    "reviewer-review.md": "{{AGENT_PROMPT_REVIEWER_REVIEW}}",
+    "dev-fix.md": "{{AGENT_PROMPT_DEV_FIX}}",
+    "dev-resume.md": "{{AGENT_PROMPT_DEV_RESUME}}",
+}
+
 
-    Returns a dict of {{AGENT_PROMPT_XXX}} -> prompt content replacements.
-    If the directory does not exist, returns an empty dict (backward compat).
+def load_active_agent_prompts(templates_dir):
+    """Load explicit active agent prompt templates.
+
+    The retired top-level Dev implementation prompt is intentionally not loaded;
+    feature implementation is performed by the main orchestrator. Remaining
+    prompt placeholders support Critic/Reviewer and review-fix helper flows.
     """
     agent_prompts_dir = os.path.join(templates_dir, "agent-prompts")
     if not os.path.isdir(agent_prompts_dir):
         LOGGER.debug("No agent-prompts/ directory found, skipping")
         return {}
 
-    # Map filename -> placeholder name
-    # e.g. dev-implement.md -> {{AGENT_PROMPT_DEV_IMPLEMENT}}
     prompt_map = {}
-    for filename in sorted(os.listdir(agent_prompts_dir)):
-        if not filename.endswith(".md"):
-            continue
-        stem = filename[:-3]  # remove .md
-        placeholder = "{{{{AGENT_PROMPT_{}}}}}".format(
-            stem.upper().replace("-", "_")
-        )
+    for filename, placeholder in ACTIVE_AGENT_PROMPTS.items():
         filepath = os.path.join(agent_prompts_dir, filename)
+        if not os.path.isfile(filepath):
+            LOGGER.debug("Active agent prompt not found, skipping: %s", filename)
+            continue
         try:
             with open(filepath, "r", encoding="utf-8") as f:
                 prompt_map[placeholder] = f.read().strip()
-            LOGGER.debug("Loaded agent prompt: %s -> %s", filename, placeholder)
+            LOGGER.debug("Loaded active agent prompt: %s -> %s", filename, placeholder)
         except IOError as exc:
             LOGGER.warning("Failed to load agent prompt %s: %s", filename, exc)
 
@@ -1345,10 +1349,13 @@ def _tier_header(pipeline_mode):
             "orchestrator implements directly (P0-6).\n",
         ),
         "full": (
-            "# Dev-Pipeline Session Bootstrap — Tier 3 (Full Team)\n",
-            "**Tier 3 — Full Team**: For complex features, use the full "
-            "pipeline with Dev + Reviewer agents spawned via the Agent "
-            "tool.\n",
+            "# Dev-Pipeline Session Bootstrap — Tier 3 "
+            "(Orchestrator + Critic/Reviewer)\n",
+            "**Tier 3 — Orchestrator + Critic/Reviewer**: For complex "
+            "features, the main orchestrator handles context, planning, "
+            "and implementation directly. Critic challenges the plan "
+            "when enabled, Reviewer reviews, and no top-level Dev "
+            "implementation subagent is spawned.\n",
         ),
     }
     return headers.get(pipeline_mode, headers["lite"])
@@ -1392,11 +1399,12 @@ def _tier_reminders(pipeline_mode, critic_enabled=False):
         ]
     else:  # full
         specific = [
-            "- Tier 3: full team — Dev (implementation) → Reviewer "
-            "(review + test) — spawn agents directly via Agent tool",
+            "- Tier 3: full orchestration — orchestrator implements "
+            "directly (no top-level Dev subagent), Critic challenges "
+            "plan, Reviewer reviews",
             "- context-snapshot.md is append-only: orchestrator writes "
-            "Sections 1-4, Dev appends Implementation Log, Reviewer "
-            "appends Review Notes",
+            "Sections 1-4 + Implementation Log, Reviewer appends "
+            "Review Notes",
             "- Gate checks enforce Implementation Log and Review Notes are "
             "written before proceeding",
             "- Do NOT use `run_in_background=true` when spawning normal work "
@@ -1638,10 +1646,10 @@ def render_from_sections(sections, replacements):
     """
     content = "\n".join(text for _, text in sections)
 
-    # Replace all placeholders — run twice to handle agent prompt templates
-    # that contain their own {{PLACEHOLDER}} variables.  First pass injects
-    # agent prompt content (e.g. {{AGENT_PROMPT_DEV_IMPLEMENT}} expands to a
-    # block containing {{FEATURE_ID}}).  Second pass replaces the inner vars.
+    # Replace all placeholders — run twice to handle active agent prompt
+    # templates that contain their own {{PLACEHOLDER}} variables. First pass
+    # injects prompt content (for example, Critic plan challenge text); second
+    # pass replaces inner feature/session variables.
     for _pass in range(2):
         for placeholder, value in replacements.items():
             content = content.replace(placeholder, value)
@@ -2077,8 +2085,9 @@ def main():
         args, feature, features, global_context, script_dir
     )
 
-    # Load agent prompt templates and merge into replacements
-    agent_prompt_replacements = load_agent_prompts(templates_dir)
+    # Load active agent prompt templates and merge into replacements.
+    # The retired top-level Dev implementation prompt is intentionally absent.
+    agent_prompt_replacements = load_active_agent_prompts(templates_dir)
     replacements.update(agent_prompt_replacements)
 
     if is_continuation(args):

package/bundled/dev-pipeline/scripts/generate-recovery-prompt.py

@@ -42,10 +42,11 @@ BUGFIX_PHASES = {
         "Branch Setup",
         """\
 Check current branch. You should already be on a fix/* branch from the
-interrupted session. If so, continue on it. If somehow on main, create
-a new fix branch:
+interrupted session. If so, continue on it and do not create an additional
+recovery branch. If somehow on main, create a new fix branch only as a
+last-resort fallback:
 ```bash
-git checkout -b fix/{bug_id}-recovery
+git checkout -b fix/{bug_id}
 ```""",
     ),
     1: (

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

@@ -1,4 +1,4 @@
-# Dev-Pipeline Session Bootstrap — Tier 2 (Dual Agent)
+# Dev-Pipeline Session Bootstrap — Tier 2 (Orchestrator + Critic/Reviewer)
 
 ## Session Context
 
@@ -10,14 +10,14 @@
 
 You are the **session orchestrator**. Implement Feature {{FEATURE_ID}}: "{{FEATURE_TITLE}}".
 
-**CRITICAL**: You MUST NOT exit until ALL work is complete and committed. When you spawn normal work subagents, wait for each to finish (run_in_background=false).
+**CRITICAL**: You MUST NOT exit until ALL work is complete and committed. When you spawn Critic or Reviewer agents, wait for each to finish (run_in_background=false).
 
-**Tier 2 — Dual Agent**: You handle context + planning directly. Then spawn Dev and Reviewer subagents. Spawn Dev and Reviewer agents via the Agent tool.
+**Tier 2 — Orchestrator + Critic/Reviewer**: You handle context, planning, and implementation directly. Critic challenges the plan when enabled, Reviewer reviews. Do not spawn a top-level Dev subagent for implementation.
 
 **Agent spawn failure policy (all Agent tool calls)**:
-- If spawning Dev, Reviewer, or Critic fails with team/config/lock errors, retry at most once.
+- If spawning Reviewer or Critic fails with team/config/lock errors, retry at most once.
 - If the second attempt fails, do not keep spawning variants and do not enter artifact polling for Implementation Log, challenge report, or review report markers.
-- Use the documented inline/recovery fallback for that phase: write the required report yourself where possible, complete remaining Dev work directly in the orchestrator when safe, or write `failure-log.md` with the spawn error and last observable state before stopping for recovery.
+- Use the documented inline/recovery fallback for that phase: write the required report yourself where possible, complete remaining work directly in the orchestrator when safe, or write `failure-log.md` with the spawn error and last observable state before stopping for recovery.
 - Apply the same cap to any re-spawn for report repair or resume prompts; do not burn multiple minutes on identical team/config/lock failures.
 
 ### Feature Description
@@ -71,11 +71,11 @@ You are running in **headless non-interactive mode** with a FINITE context windo
 ## PrizmKit Directory Convention
 
 ```
-.prizmkit/specs/{{FEATURE_SLUG}}/context-snapshot.md  ← orchestrator writes Sections 1-4; Dev appends Implementation Log; Reviewer appends Review Notes
+.prizmkit/specs/{{FEATURE_SLUG}}/context-snapshot.md  ← orchestrator writes Sections 1-4 + Implementation Log; Reviewer appends Review Notes
 .prizmkit/specs/{{FEATURE_SLUG}}/plan.md              ← includes Tasks section
 ```
 
-**`context-snapshot.md`** is the shared knowledge base. Orchestrator writes Sections 1-4; Dev appends Implementation Log; Reviewer appends Review Notes. Append-only after initial creation.
+**`context-snapshot.md`** is the shared knowledge base. Orchestrator writes Sections 1-4 and the Implementation Log; Reviewer appends Review Notes. Append-only after initial creation.
 
 ---
 
@@ -267,38 +267,63 @@ After all critics return, read all 3 reports:
 **CP-2.5**: Plan challenges reviewed and resolved.
 {{END_IF_CRITIC_ENABLED}}
 
-### Phase 4: Implement — Dev Subagent
+### Implement — Orchestrator Direct (no Dev subagent)
 
-**Build artifacts rule** (passed to Dev): After any build/compile command (`go build`, `npm run build`, `tsc`, etc.), ensure the output binary or build directory is in `.gitignore`. Never commit compiled binaries, build output, or generated artifacts.
+**Rationale**: Development is deterministic plan execution — the orchestrator already built full context in Phase 1. Spawning a Dev subagent forces it to rebuild context (re-reading files the orchestrator already read), wastes context, and risks worktree double-edit. The orchestrator implements directly.
 
-Spawn Dev subagent (Agent tool, subagent_type="prizm-dev-team-dev", run_in_background=false).
+Before starting, check plan.md Tasks:
+```bash
+grep -c '^\- \[ \]' .prizmkit/specs/{{FEATURE_SLUG}}/plan.md 2>/dev/null || true
+```
+- If result is `0` (all tasks already `[x]`) → **SKIP to Review**.
+- If non-zero → implement directly below.
 
-Spawn failure cap: for team/config/lock errors, retry at most once for this Dev spawn. If the second attempt fails, do not poll for `## Implementation Log`; write `failure-log.md` and either implement remaining tasks directly in the orchestrator or stop for recovery.
+**Build artifacts rule**: After any build/compile command, ensure output is in `.gitignore`. Never commit binaries/build output.
 
-Prompt:
-> "Read {{DEV_SUBAGENT_PATH}}. Implement feature {{FEATURE_ID}} (slug: {{FEATURE_SLUG}}).
-> **IMPORTANT**: Read `.prizmkit/specs/{{FEATURE_SLUG}}/context-snapshot.md` FIRST — Section 3 has Prizm Context (TRAPS/RULES), Section 4 has File Manifest with paths and interfaces.
-> ⚠️ DO NOT re-read source files already listed in Section 4 File Manifest unless you need implementation detail beyond the interface summary.
-> 1. Read `.prizmkit/specs/{{FEATURE_SLUG}}/context-snapshot.md` for full context.
-> 2. Run `/prizmkit-implement` to execute the tasks in plan.md. Run tests with: `{{TEST_CMD}}`. Known baseline failures (pre-existing, not your fault): `{{BASELINE_FAILURES}}`.
-> 3. If plan.md has more than 5 tasks: update durable checkpoints/artifacts after every 3 tasks, minimize output, and rely on runner continuation if context overflow occurs. In an interactive Claude Code session operated manually outside the headless pipeline, `/compact` may be used as an optional convenience only.
-> 4. **Verification Gate Self-Check (BLOCKING)**: before returning, write a `### Gate Evidence` section to Implementation Log — one evidence line per gate (test name / file:line / fixture path). Any gate without evidence is BLOCKED, not success.
-> 5. **Layered test strategy**: debug with single-file tests (`npx vitest run <file> -t '<name>'`), only run full suite as gate when single-file is green. Never run full suite while a single-file test is still red.
-> 6. **Anti re-read**: 20-step window (full Read forbidden within 20 tool calls of last read), 3-strike (3 full Reads same file → BLOCKED). Use `grep -n`+`sed -n` for specific lines.
-> 7. **Read offset safety**: if Read returns "shorter than offset"/"empty"/"wasted" — run `wc -l` then `sed -n`, do NOT retry same offset. 2 consecutive → STOP Reading that file.
-> 8. **Hard Round Cap**: after 6 total test-fix rounds, STOP trial-and-error. Write failure-log. Switch to read-once-then-rewrite strategy. Do NOT exceed 7 rounds.
-> 9. After implement completes, verify the '## Implementation Log' section (with Gate Evidence) was written to context-snapshot.md.
-> 10. Do NOT execute any git commands (no git add/commit/reset/push).
-> Do NOT exit until all tasks are [x] and the '## Implementation Log' section (with Gate Evidence) is written in context-snapshot.md."
-
-Wait for Dev to return. All tasks must be `[x]`, tests pass.
-
-**Gate Check — Implementation Log**:
-After Dev agent returns, verify the Implementation Log was written:
+**3a.** Detect test commands and record baseline:
 ```bash
-grep -q "## Implementation Log" .prizmkit/specs/{{FEATURE_SLUG}}/context-snapshot.md && echo "GATE:PASS" || echo "GATE:MISSING"
+($TEST_CMD) 2>&1 | tee /tmp/test-baseline.txt | tail -20
+```
+
+**3b.** Run `/prizmkit-implement` directly — you (the orchestrator) execute the full cycle:
+- Read plan.md Tasks from `.prizmkit/specs/{{FEATURE_SLUG}}/`
+- Use context-snapshot.md Section 4 File Manifest for targeted reads — do NOT re-read files already summarized there
+- Implements task-by-task, marking each `[x]` immediately
+- Creates/updates L2 `.prizm` docs when creating new modules
+- Defers scoped/full test execution until after the code-review loop completes
+- If plan.md has >5 tasks: update checkpoints after every 3 tasks
+
+**3c. Focused checks only (no test gate here)**:
+- During implementation, do not run mandatory periodic or full-suite tests.
+- If a tiny targeted check is needed to understand a local failure, run only the smallest relevant command and capture output to `/tmp/test-out.txt`.
+- The scoped feature test gate runs after code review; do not declare implementation success based on an early full-suite run.
+
+**3d. Verification Gate Self-Check (BLOCKING — before declaring implement done)**:
+For each Verification Gate from the Task Contract, write one evidence line to Implementation Log:
+```
+### Gate Evidence
+- [x] G1: <gate text> — Evidence: <test name / file:line / fixture path>
+- [ ] G3: <gate text> — BLOCKED: <reason>  ← no evidence = BLOCKED, not success
 ```
-If GATE:MISSING — send message to Dev (re-spawn if needed): "Write the '## Implementation Log' section to context-snapshot.md before I can proceed to review. Include: files changed/created, key decisions, deviations from plan, notable discoveries."
+
+**3e.** Append `## Implementation Log` (with Gate Evidence) to `context-snapshot.md`:
+- files changed/created
+- key decisions
+- deviations from plan
+- test results
+- Gate Evidence section
+- unresolved blockers
+
+**CP-2**: All tasks `[x]`, Implementation Log written with Gate Evidence, and blocked gates documented in `failure-log.md`. Test execution is deferred until after code review.
+
+**Checkpoint update**:
+```bash
+python3 $PIPELINE_DIR/scripts/update-checkpoint.py \
+  --checkpoint-path .prizmkit/specs/{{FEATURE_SLUG}}/workflow-checkpoint.json \
+  --step prizmkit-implement \
+  --status completed
+```
+
 
 ### Scoped Feature Test Gate — PrizmKit Test
 
@@ -584,7 +609,6 @@ Rules for writing completion notes:
 |----------|------|
 | Feature Artifacts Dir | `.prizmkit/specs/{{FEATURE_SLUG}}/` |
 | Context Snapshot | `.prizmkit/specs/{{FEATURE_SLUG}}/context-snapshot.md` |
-| Dev Agent Def | {{DEV_SUBAGENT_PATH}} |
 | Reviewer Agent Def | {{REVIEWER_SUBAGENT_PATH}} |
 {{IF_CRITIC_ENABLED}}
 | Critic Agent Def | {{CRITIC_SUBAGENT_PATH}} |
@@ -610,11 +634,11 @@ If you encounter an unrecoverable error, context overflow, or are about to exit
 
 ## Reminders
 
-- Tier 2: orchestrator builds context+plan, Analyzer checks consistency, Dev implements, Reviewer reviews — use direct Agent spawn for agents
-- Build context-snapshot.md FIRST; all subagents read it instead of re-reading source files
-- context-snapshot.md is append-only: orchestrator writes Sections 1-4, Dev appends Implementation Log, Reviewer appends Review Notes
+- Tier 2: orchestrator builds context+plan and implements directly; Critic challenges plan when enabled; Reviewer reviews
+- Build context-snapshot.md FIRST; use it throughout instead of re-reading source files
+- context-snapshot.md is append-only: orchestrator writes Sections 1-4 + Implementation Log, Reviewer appends Review Notes
 - Gate checks enforce Implementation Log and Review Notes are written before proceeding
-- Do NOT use `run_in_background=true` when spawning normal work subagents
+- Do NOT use `run_in_background=true` when spawning Critic or Reviewer agents
 - **NEVER delete, modify, or touch any file under `.prizmkit/state/`** — those are pipeline runtime files managed by the runner
 - NEVER run `rm -rf`, `git clean`, or any destructive filesystem operations
 - `/prizmkit-committer` is mandatory, and must not be replaced with manual git commit commands