prizmkit 1.1.107 → 1.1.108

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

@@ -6,6 +6,7 @@ import importlib.util
 import json
 import os
 import queue
+import shlex
 import shutil
 import subprocess
 import sys
@@ -17,6 +18,7 @@ from dataclasses import dataclass, field
 from pathlib import Path
 
 from .heartbeat import HeartbeatConfig, HeartbeatMonitor, HeartbeatState, observe_heartbeat_state, write_stale_marker
+from .launch_profiles import HeadlessLaunchProfile
 from .processes import ProcessHandle, ProcessSpec, launch_process, terminate_process_tree
 from .status import ProgressSummary
 
@@ -52,12 +54,14 @@ class AISessionConfig:
     permission_mode: str = "dangerously-skip-permissions"
     total_timeout_seconds: float | None = None
     stale_kill_threshold_seconds: float = 0
+    heartbeat_stale_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, ...] = ()
+    launch_profile: HeadlessLaunchProfile | None = None
     environment_overrides: Mapping[str, str] = field(default_factory=dict)
 
 
@@ -69,6 +73,7 @@ class AISessionCommand:
     stdin_text: str | None
     provider: str
     prompt_mode: str
+    prompt_text: str | None = None
 
 
 @dataclass(frozen=True)
@@ -106,7 +111,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"} else "codebuddy"
+    return normalized if normalized in {"claude", "codex", "codebuddy", "custom"} else "codebuddy"
 
 
 def _prompt_text(path: Path) -> str:
@@ -156,6 +161,11 @@ def build_ai_session_command(config: AISessionConfig) -> AISessionCommand:
     """Build provider-specific AI CLI argv without spawning a process."""
     platform = _normalize_platform(config.platform)
     prompt = _prompt_text(config.prompt_path)
+    if config.launch_profile is not None and config.launch_profile.is_custom:
+        argv = [config.cli_command, config.launch_profile.prompt_arg, prompt]
+        argv.extend(config.launch_profile.extra_args)
+        argv.extend(config.extra_args)
+        return AISessionCommand(tuple(argv), None, "custom", "argument", prompt)
     if platform == "claude":
         argv = [
             config.cli_command,
@@ -174,7 +184,7 @@ def build_ai_session_command(config: AISessionConfig) -> AISessionCommand:
         if config.model:
             argv.extend(["--model", config.model])
         argv.extend(config.extra_args)
-        return AISessionCommand(tuple(argv), None, "claude", "argument")
+        return AISessionCommand(tuple(argv), None, "claude", "argument", prompt)
 
     if platform == "codex":
         argv = [
@@ -197,7 +207,7 @@ def build_ai_session_command(config: AISessionConfig) -> AISessionCommand:
             argv.extend(["--config", f"model_reasoning_effort={config.effort}"])
         argv.extend(config.extra_args)
         argv.append("-")
-        return AISessionCommand(tuple(argv), prompt, "codex", "stdin")
+        return AISessionCommand(tuple(argv), prompt, "codex", "stdin", prompt)
 
     argv = [config.cli_command, "--print", "-y", "--disallowedTools", "EnterWorktree"]
     if config.verbose:
@@ -209,7 +219,18 @@ def build_ai_session_command(config: AISessionConfig) -> AISessionCommand:
     if config.model:
         argv.extend(["--model", config.model])
     argv.extend(config.extra_args)
-    return AISessionCommand(tuple(argv), prompt, "codebuddy", "stdin")
+    return AISessionCommand(tuple(argv), prompt, "codebuddy", "stdin", prompt)
+
+
+def format_start_command(command: AISessionCommand) -> str:
+    """Return a readable command string with the injected prompt redacted."""
+    redacted: list[str] = []
+    for token in command.argv:
+        if command.prompt_text is not None and token == command.prompt_text:
+            redacted.append("<prompt>")
+        else:
+            redacted.append(token)
+    return " ".join("<prompt>" if token == "<prompt>" else shlex.quote(token) for token in redacted)
 
 
 def default_backup_log_path(session_log: Path, home: Path | None = None) -> Path:
@@ -220,15 +241,16 @@ def default_backup_log_path(session_log: Path, home: Path | None = None) -> Path
     return root / ".prizmkit" / "session-backups" / f"{session_id}.log"
 
 
-def write_session_preamble(session_log: Path, backup_log: Path, prompt_path: Path, model: str | None) -> None:
+def write_session_preamble(session_log: Path, backup_log: Path, command: AISessionCommand, model: str | None) -> None:
     """Write the session preamble to both primary and backup logs."""
     session_log.parent.mkdir(parents=True, exist_ok=True)
     backup_log.parent.mkdir(parents=True, exist_ok=True)
     preamble = "\n".join(
         [
             "=== PRIZMKIT SESSION START ===",
-            f"Prompt: {prompt_path}",
+            "Prompt: <prompt>",
             f"Model: {model or 'default'}",
+            f"StartCommand： {format_start_command(command)}",
             f"Started at epoch: {time.time():.6f}",
             "--- OUTPUT BELOW ---",
             "",
@@ -368,6 +390,60 @@ 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 _progress_refresh_key(data: Mapping[str, object]) -> tuple[object, ...]:
+    event_counts = data.get("event_type_counts")
+    return (
+        int(data.get("message_count") or 0),
+        tuple(sorted(event_counts.items())) if isinstance(event_counts, Mapping) else (),
+        str(data.get("current_tool") or ""),
+        str(data.get("current_phase") or ""),
+        int(data.get("total_tool_calls") or 0),
+        int(data.get("active_subagent_count") or 0),
+        int(data.get("subagent_spawn_count") or 0),
+        str(data.get("child_activity_signature") or ""),
+        int(data.get("child_total_bytes") or 0),
+        str(data.get("fatal_error_code") or ""),
+        str(data.get("terminal_result_text") or ""),
+        tuple(str(item) for item in data.get("errors", []) if item) if isinstance(data.get("errors"), list) else (),
+    )
+
+
+def _write_progress_data(progress_path: Path, data: Mapping[str, object]) -> None:
+    progress_path.parent.mkdir(parents=True, exist_ok=True)
+    progress_path.write_text(json.dumps(data, indent=2, sort_keys=True) + "\n", encoding="utf-8")
+
+
+def _start_idle_progress_refresh(
+    progress_path: Path,
+    tracker: object,
+    tracker_lock: threading.Lock,
+    stop_event: threading.Event,
+    interval_seconds: float = 1.0,
+) -> tuple[threading.Thread, Callable[[bool], None]]:
+    """Refresh progress.json from child activity while parent output is idle."""
+    last_key: tuple[object, ...] | None = None
+
+    def maybe_write(force: bool = False) -> None:
+        nonlocal last_key
+        with tracker_lock:
+            data = tracker.to_dict()
+        key = _progress_refresh_key(data)
+        if force or key != last_key:
+            _write_progress_data(progress_path, data)
+            last_key = key
+
+    def refresh_loop() -> None:
+        while not stop_event.wait(max(0.1, interval_seconds)):
+            try:
+                maybe_write(False)
+            except Exception:
+                continue
+
+    thread = threading.Thread(target=refresh_loop, name="prizmkit-progress-refresh", daemon=True)
+    thread.start()
+    return thread, maybe_write
+
+
 def _emit_live_line(message: str) -> None:
     """Print foreground runner status without interfering with file logging."""
     print(message, file=sys.stderr, flush=True)
@@ -394,7 +470,13 @@ def _format_elapsed(seconds: float) -> str:
 
 
 def _format_stale_minutes(seconds: float) -> str:
-    return f"{max(0, int(seconds)) // 60}m"
+    total = max(0, int(seconds))
+    minutes, remainder = divmod(total, 60)
+    if minutes == 0:
+        return f"{remainder}s"
+    if remainder == 0:
+        return f"{minutes}m"
+    return f"{minutes}m{remainder:02d}s"
 
 
 def _read_json_object(path: Path | None) -> dict[str, object]:
@@ -447,8 +529,13 @@ def _compact_progress_line(
             log_size = session_log.stat().st_size
         except OSError:
             log_size = 0
-    glyph = "⏸" if heartbeat_state is not None and heartbeat_state.details == "no progress" else "▶"
     stale_seconds = heartbeat_state.stale_seconds if heartbeat_state is not None else 0
+    show_stale = bool(
+        heartbeat_state is not None
+        and heartbeat_state.details == "no progress"
+        and (heartbeat_state.stale or (stale_threshold_seconds > 0 and stale_seconds >= stale_threshold_seconds))
+    )
+    glyph = "⏸" if show_stale else "▶"
     parts = [
         f"  {glyph} [HEARTBEAT] {_format_elapsed(time.time() - started_epoch)}",
         f"log: {_format_bytes(log_size)}",
@@ -472,7 +559,9 @@ def _compact_progress_line(
     tool_calls = int(data.get("total_tool_calls") or 0)
     if tool_calls:
         parts.append(f"{tool_calls} tool calls")
-    parts.append(f"stale: {_format_stale_minutes(stale_seconds)}/{_format_stale_minutes(stale_threshold_seconds)}")
+    if show_stale:
+        threshold = f"/{_format_stale_minutes(stale_threshold_seconds)}" if stale_threshold_seconds > 0 else ""
+        parts.append(f"stale: {_format_stale_minutes(stale_seconds)}{threshold}")
     return " | ".join(parts)
 
 
@@ -539,12 +628,23 @@ def _reader_thread(
 ) -> None:
     lines: list[str] = []
     tracker = None
+    tracker_lock = threading.Lock()
+    progress_refresh_stop = threading.Event()
+    progress_refresh_thread: threading.Thread | None = None
+    refresh_progress: Callable[[bool], None] | None = None
     tracker_class = _load_progress_tracker_class() if progress_path is not None else None
     if tracker_class is not None:
         try:
             tracker = tracker_class(session_log)
         except Exception:
             tracker = None
+    if progress_path is not None and tracker is not None:
+        progress_refresh_thread, refresh_progress = _start_idle_progress_refresh(
+            progress_path,
+            tracker,
+            tracker_lock,
+            progress_refresh_stop,
+        )
     try:
         for line in iter(pipe.readline, ""):
             if not line:
@@ -560,18 +660,26 @@ def _reader_thread(
             if progress_path is not None:
                 if tracker is not None:
                     stripped = line.strip()
-                    if stripped:
-                        try:
-                            tracker.process_event(json.loads(stripped))
-                        except json.JSONDecodeError:
-                            tracker.last_text_snippet = stripped[:120]
-                            tracker._detect_terminal_error(stripped, require_error_context=True)
-                    data = tracker.to_dict()
-                    progress_path.parent.mkdir(parents=True, exist_ok=True)
-                    progress_path.write_text(json.dumps(data, indent=2, sort_keys=True) + "\n", encoding="utf-8")
+                    with tracker_lock:
+                        if stripped:
+                            try:
+                                tracker.process_event(json.loads(stripped))
+                            except json.JSONDecodeError:
+                                tracker.last_text_snippet = stripped[:120]
+                                tracker._detect_terminal_error(stripped, require_error_context=True)
+                        data = tracker.to_dict()
+                    _write_progress_data(progress_path, data)
                 else:
                     _write_progress_summary(progress_path, parse_stream_progress_lines(lines))
     finally:
+        if refresh_progress is not None:
+            try:
+                refresh_progress(True)
+            except Exception:
+                pass
+        progress_refresh_stop.set()
+        if progress_refresh_thread is not None:
+            progress_refresh_thread.join(timeout=2)
         try:
             pipe.close()
         except Exception:
@@ -632,7 +740,7 @@ class AISessionLauncher:
         command = build_ai_session_command(self.config)
         session_log = self.config.log_path or self.config.cwd / ".prizmkit" / "state" / "session.log"
         backup_log = self.config.backup_log_path or default_backup_log_path(session_log)
-        write_session_preamble(session_log, backup_log, self.config.prompt_path, self.config.model)
+        write_session_preamble(session_log, backup_log, command, self.config.model)
 
         spec = ProcessSpec(
             command=command.argv,
@@ -667,9 +775,12 @@ class AISessionLauncher:
 
         heartbeat = None
         live_progress_interval = max(1.0, float(self.config.live_progress_interval_seconds or 30))
-        stale_threshold_seconds = max(0.0, float(self.config.stale_kill_threshold_seconds or 0))
+        kill_threshold_seconds = max(0.0, float(self.config.stale_kill_threshold_seconds or 0))
+        stale_threshold_seconds = max(0.0, float(self.config.heartbeat_stale_threshold_seconds or 0))
+        if stale_threshold_seconds <= 0:
+            stale_threshold_seconds = kill_threshold_seconds
         heartbeat_path = self.config.heartbeat_path
-        if heartbeat_path is None and self.config.stale_kill_threshold_seconds > 0:
+        if heartbeat_path is None and kill_threshold_seconds > 0:
             heartbeat_path = session_log.with_name("heartbeat.json")
         if heartbeat_path is not None:
             heartbeat = HeartbeatMonitor(
@@ -681,7 +792,7 @@ class AISessionLauncher:
                     marker_dir=session_log.parent,
                     interval_seconds=0.1,
                     stale_after_seconds=stale_threshold_seconds,
-                    kill_after_seconds=stale_threshold_seconds,
+                    kill_after_seconds=kill_threshold_seconds,
                     grace_seconds=self.config.stale_kill_grace_seconds,
                 ),
             )
@@ -727,27 +838,37 @@ class AISessionLauncher:
             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):
-            last_progress_line, display_heartbeat_state = _emit_progress_tick(
-                started,
+            final_heartbeat_state = _display_heartbeat_state(
                 session_log,
                 self.config.progress_path,
-                last_progress_line,
-                monitor_state=heartbeat.state if heartbeat is not None else None,
-                fallback_state=display_heartbeat_state,
+                heartbeat.state if heartbeat is not None else None,
+                display_heartbeat_state,
                 interval_seconds=live_progress_interval,
                 stale_threshold_seconds=stale_threshold_seconds,
             )
+            display_heartbeat_state = final_heartbeat_state
+            if final_heartbeat_state.details == "progress":
+                final_line = _compact_progress_line(
+                    started,
+                    session_log,
+                    self.config.progress_path,
+                    final_heartbeat_state,
+                    stale_threshold_seconds=stale_threshold_seconds,
+                )
+                if final_line != last_progress_line:
+                    _emit_live_line(final_line)
+                    last_progress_line = final_line
         reader.join(timeout=5)
         heartbeat_result = heartbeat.stop() if heartbeat is not None else None
         if heartbeat_result and heartbeat_result.killed:
             termination_reason = heartbeat_result.reason
             stale_marker = heartbeat_result.marker_path
-        if termination_reason is None and self.config.stale_kill_threshold_seconds > 0 and handle.popen.returncode is None:
+        if termination_reason is None and kill_threshold_seconds > 0 and handle.popen.returncode is None:
             stale_marker = write_stale_marker(
                 session_log.parent,
                 reason="stale_session",
-                stale_seconds=self.config.stale_kill_threshold_seconds,
-                threshold=self.config.stale_kill_threshold_seconds,
+                stale_seconds=kill_threshold_seconds,
+                threshold=kill_threshold_seconds,
             )
             termination_reason = "stale_session"
         recovery = recover_session_log(session_log, backup_log)

package/bundled/dev-pipeline/scripts/continuation.py

@@ -294,7 +294,6 @@ def _build_addendum(context):
         "- Continue from the first pending/in-progress checkpoint step: `{}`.".format(cursor["first_cursor"]),
         "- Do not read the previous full `session.log` unless explicitly necessary.",
         "- If previous runtime context is needed, prefer synthesized artifacts and summaries over logs.",
-        "- Do not attempt `/compact` as the recovery mechanism.",
         "",
         "### Preserved Durable Context",
         "",

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

@@ -27,7 +27,7 @@ import os
 import re
 import sys
 
-from utils import enrich_global_context, load_json_file, read_platform_conventions, setup_logging
+from utils import enrich_global_context, load_json_file, resolve_prompt_platform, setup_logging
 from continuation import add_continuation_args, append_continuation_handoff, is_continuation
 
 
@@ -173,16 +173,6 @@ def _parse_positive_int_env(name, default):
 
 
 
-def load_log_size_section(script_dir):
-    """Load passive checkpoint guidance for normal prompt generation."""
-    section_path = os.path.join(
-        script_dir, "..", "templates", "sections", "log-size-awareness.md",
-    )
-    content, err = read_text_file(section_path)
-    if err:
-        return ""
-    return content
-
 def format_acceptance_criteria(criteria):
     """Format acceptance criteria as a markdown bullet list."""
     if not criteria:
@@ -650,7 +640,7 @@ def determine_pipeline_mode(complexity):
 SECTION_TO_SKILL = {
     "phase0-init": ("prizmkit-init", "Project Bootstrap",
                     [".prizmkit/prizm-docs/root.prizm", ".prizmkit/config.json"]),
-    "phase0-test-baseline": ("test-baseline", "Detect Test Commands", []),
+    "phase0-test-baseline": None,
     "phase-context-snapshot": ("context-snapshot", "Build Context Snapshot",
                                [".prizmkit/specs/{slug}/context-snapshot.md"]),
     "phase-specify-plan": ("context-snapshot-and-plan", "Specify & Plan",
@@ -1443,11 +1433,6 @@ def assemble_sections(pipeline_mode, sections_dir, init_done, is_resume,
     sections.append(("context-budget-rules",
                       load_section(sections_dir, "context-budget-rules.md")))
 
-    # --- Session checkpoint guidance ---
-    if os.path.isfile(os.path.join(sections_dir, "log-size-awareness.md")):
-        sections.append(("log-size-awareness",
-                          load_section(sections_dir, "log-size-awareness.md")))
-
     # --- Directory Convention (tier-specific) ---
     if pipeline_mode == "lite":
         dc_file = "directory-convention-lite.md"
@@ -1692,27 +1677,12 @@ def build_replacements(args, feature, features, global_context, script_dir):
     """Build the full dict of placeholder -> replacement value."""
     project_root = _args_project_root(args, script_dir)
 
-    # Resolve paths - platform-aware agent/team resolution
-    platform = os.environ.get("PRIZMKIT_PLATFORM", "")
+    # Resolve paths - platform-aware agent/team resolution.
+    # Mixed `--platform all` installs must render commands for the actual AI
+    # environment, not whichever platform directory happens to be checked first.
+    platform = resolve_prompt_platform(project_root)
     home_dir = os.path.expanduser("~")
 
-    # Auto-detect platform if not set
-    if not platform:
-        has_codex = os.path.isdir(os.path.join(project_root, ".codex", "agents"))
-        has_claude = os.path.isdir(os.path.join(project_root, ".claude", "agents"))
-        has_codebuddy = os.path.isdir(os.path.join(project_root, ".codebuddy", "agents"))
-        if has_codex:
-            platform = "codex"
-        elif has_claude:
-            platform = "claude"
-        elif has_codebuddy:
-            platform = "codebuddy"
-        else:
-            raise RuntimeError(
-                "PrizmKit agents not found. None of .codex/agents/, .claude/agents/, or .codebuddy/agents/ exists. "
-                "Run `npx prizmkit install` first, or set PRIZMKIT_PLATFORM=codex|claude|codebuddy explicitly."
-            )
-
     if platform == "claude":
         # Claude Code: agents in .claude/agents/, no native team config
         agents_dir = os.path.join(project_root, ".claude", "agents")
@@ -1922,7 +1892,6 @@ def build_replacements(args, feature, features, global_context, script_dir):
     dev_url = f"http://localhost:{dev_port}"
 
     replacements = {
-        "{{LOG_SIZE_AWARENESS}}": load_log_size_section(script_dir),
         "{{RUN_ID}}": args.run_id,
         "{{SESSION_ID}}": args.session_id,
         "{{FEATURE_ID}}": args.feature_id,
@@ -1938,7 +1907,6 @@ def build_replacements(args, feature, features, global_context, script_dir):
         ),
         "{{GLOBAL_CONTEXT}}": format_global_context(global_context, project_root),
         "{{PROJECT_BRIEF}}": _read_project_brief(project_root),
-        "{{PLATFORM_CONVENTIONS}}": read_platform_conventions(project_root),
         "{{TEAM_CONFIG_PATH}}": team_config_path,
         "{{DEV_SUBAGENT_PATH}}": dev_subagent,
         "{{REVIEWER_SUBAGENT_PATH}}": reviewer_subagent,
@@ -2058,9 +2026,6 @@ def main():
     agent_prompt_replacements = load_active_agent_prompts(templates_dir)
     replacements.update(agent_prompt_replacements)
 
-    if is_continuation(args):
-        replacements["{{LOG_SIZE_AWARENESS}}"] = ""
-
     # Extract state needed for assembly
     pipeline_mode = replacements.get("{{PIPELINE_MODE}}", "lite")
     init_done = replacements.get("{{INIT_DONE}}", "false") == "true"
@@ -2080,11 +2045,6 @@ def main():
                 retry_count=int(args.retry_count),
                 browser_tool=browser_tool,
             )
-            if is_continuation(args):
-                sections = [
-                    (name, content) for name, content in sections
-                    if name != "log-size-awareness"
-                ]
             rendered = render_from_sections(sections, replacements)
         except FileNotFoundError as exc:
             LOGGER.warning(

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

@@ -19,7 +19,7 @@ import os
 import re
 import sys
 
-from utils import enrich_global_context, load_json_file, read_platform_conventions, setup_logging
+from utils import enrich_global_context, load_json_file, read_checkpoint_system_section, resolve_prompt_platform, setup_logging
 from continuation import add_continuation_args, append_continuation_handoff, is_continuation
 
 
@@ -77,19 +77,6 @@ def _parse_positive_int_env(name, default):
     return parsed
 
 
-def load_log_size_section(script_dir):
-    """Load passive checkpoint guidance for normal prompt generation."""
-    section_path = os.path.join(
-        script_dir, "..", "templates", "sections", "log-size-awareness.md",
-    )
-    if not os.path.isfile(section_path):
-        return ""
-
-    content, err = read_text_file(section_path)
-    if err:
-        return ""
-    return content
-
 def find_bug(bugs, bug_id):
     """Find and return the bug dict matching the given ID."""
     for bug in bugs:
@@ -261,17 +248,9 @@ def build_replacements(args, bug, global_context, script_dir):
     project_root = _args_project_root(args, script_dir)
 
     # Platform-aware agent/team path resolution
-    platform = os.environ.get("PRIZMKIT_PLATFORM", "")
+    platform = resolve_prompt_platform(project_root)
     home_dir = os.path.expanduser("~")
 
-    if not platform:
-        if os.path.isdir(os.path.join(project_root, ".codex", "agents")):
-            platform = "codex"
-        elif os.path.isdir(os.path.join(project_root, ".claude", "agents")):
-            platform = "claude"
-        else:
-            platform = "codebuddy"
-
     if platform == "claude":
         agents_dir = os.path.join(project_root, ".claude", "agents")
         team_config_path = os.path.join(project_root, ".claude", "team-info.json")
@@ -348,7 +327,6 @@ def build_replacements(args, bug, global_context, script_dir):
             browser_verify_steps = "   # (reproduce bug and verify fix)"
 
     replacements = {
-        "{{LOG_SIZE_AWARENESS}}": load_log_size_section(script_dir),
         "{{SESSION_LOG_PATH}}": os.path.join(
             ".prizmkit", "state", "bugfix", args.bug_id,
             "sessions", args.session_id, "logs", "session.log",
@@ -368,12 +346,15 @@ def build_replacements(args, bug, global_context, script_dir):
         ),
         "{{ENVIRONMENT}}": format_environment(bug.get("environment")),
         "{{GLOBAL_CONTEXT}}": format_global_context(global_context, project_root),
-        "{{PLATFORM_CONVENTIONS}}": read_platform_conventions(project_root),
         "{{TEAM_CONFIG_PATH}}": team_config_path,
         "{{DEV_SUBAGENT_PATH}}": dev_subagent,
         "{{REVIEWER_SUBAGENT_PATH}}": reviewer_subagent,
         "{{SESSION_STATUS_PATH}}": session_status_path,
         "{{PROJECT_ROOT}}": project_root,
+        "{{CHECKPOINT_PATH}}": os.path.join(
+            ".prizmkit", "bugfix", args.bug_id, "workflow-checkpoint.json",
+        ),
+        "{{CHECKPOINT_SYSTEM}}": read_checkpoint_system_section(script_dir),
         "{{FIX_SCOPE}}": fix_scope,
         "{{TIMESTAMP}}": "",  # Placeholder, agent fills in the timestamp
         "{{BROWSER_ENABLED}}": "true" if browser_enabled else "false",
@@ -629,15 +610,6 @@ def main():
 
     # Build replacements
     replacements = build_replacements(args, bug, global_context, script_dir)
-    if is_continuation(args):
-        replacements["{{LOG_SIZE_AWARENESS}}"] = ""
-
-    # Add checkpoint path to replacements
-    checkpoint_rel = os.path.join(
-        ".prizmkit", "bugfix", args.bug_id, "workflow-checkpoint.json",
-    )
-    replacements["{{CHECKPOINT_PATH}}"] = checkpoint_rel
-
     # Render the template
     rendered = render_template(template_content, replacements, bug)
 
@@ -648,6 +620,7 @@ def main():
 
     # Generate checkpoint file
     project_root = _args_project_root(args, script_dir)
+    checkpoint_rel = replacements["{{CHECKPOINT_PATH}}"]
     checkpoint_path = os.path.join(project_root, checkpoint_rel)
     checkpoint_dir = os.path.dirname(checkpoint_path)
     os.makedirs(checkpoint_dir, exist_ok=True)