prizmkit 1.1.106 → 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
@@ -16,7 +17,8 @@ from collections.abc import Callable, Mapping, Sequence
 from dataclasses import dataclass, field
 from pathlib import Path
 
-from .heartbeat import HeartbeatConfig, HeartbeatMonitor, write_stale_marker
+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)
@@ -393,6 +469,16 @@ def _format_elapsed(seconds: float) -> str:
     return f"{minutes}m{remainder:02d}s"
 
 
+def _format_stale_minutes(seconds: float) -> str:
+    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]:
     if path is None or not path.is_file():
         return {}
@@ -403,14 +489,55 @@ def _read_json_object(path: Path | None) -> dict[str, object]:
     return data if isinstance(data, dict) else {}
 
 
-def _compact_progress_line(started_epoch: float, session_log: Path, progress_path: Path | None) -> str:
+def _display_heartbeat_state(
+    session_log: Path,
+    progress_path: Path | None,
+    monitor_state: HeartbeatState | None,
+    fallback_state: HeartbeatState | None,
+    *,
+    interval_seconds: float,
+    stale_threshold_seconds: float,
+) -> HeartbeatState:
+    if monitor_state is not None and monitor_state.last_seen_epoch is not None:
+        return monitor_state
+    return observe_heartbeat_state(
+        HeartbeatConfig(
+            heartbeat_file=session_log.with_name("heartbeat.json"),
+            session_log=session_log,
+            progress_file=progress_path,
+            interval_seconds=interval_seconds,
+            stale_after_seconds=stale_threshold_seconds,
+            kill_after_seconds=0,
+        ),
+        fallback_state,
+    )
+
+
+def _compact_progress_line(
+    started_epoch: float,
+    session_log: Path,
+    progress_path: Path | None,
+    heartbeat_state: HeartbeatState | None = None,
+    *,
+    stale_threshold_seconds: float = 0,
+) -> str:
     data = _read_json_object(progress_path)
-    try:
-        log_size = session_log.stat().st_size
-    except OSError:
-        log_size = 0
+    if heartbeat_state is not None:
+        log_size = heartbeat_state.log_size
+    else:
+        try:
+            log_size = session_log.stat().st_size
+        except OSError:
+            log_size = 0
+    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"  ▶ [HEARTBEAT] {_format_elapsed(time.time() - started_epoch)}",
+        f"  {glyph} [HEARTBEAT] {_format_elapsed(time.time() - started_epoch)}",
         f"log: {_format_bytes(log_size)}",
     ]
     child_bytes = int(data.get("child_total_bytes") or 0)
@@ -432,15 +559,42 @@ def _compact_progress_line(started_epoch: float, session_log: Path, progress_pat
     tool_calls = int(data.get("total_tool_calls") or 0)
     if tool_calls:
         parts.append(f"{tool_calls} tool calls")
+    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)
 
 
-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)
+def _emit_progress_tick(
+    started_epoch: float,
+    session_log: Path,
+    progress_path: Path | None,
+    last_line: str,
+    *,
+    monitor_state: HeartbeatState | None = None,
+    fallback_state: HeartbeatState | None = None,
+    interval_seconds: float = 30,
+    stale_threshold_seconds: float = 0,
+) -> tuple[str, HeartbeatState]:
+    heartbeat_state = _display_heartbeat_state(
+        session_log,
+        progress_path,
+        monitor_state,
+        fallback_state,
+        interval_seconds=interval_seconds,
+        stale_threshold_seconds=stale_threshold_seconds,
+    )
+    line = _compact_progress_line(
+        started_epoch,
+        session_log,
+        progress_path,
+        heartbeat_state,
+        stale_threshold_seconds=stale_threshold_seconds,
+    )
     if line != last_line:
         _emit_live_line(line)
-        return line
-    return last_line
+        return line, heartbeat_state
+    return last_line, heartbeat_state
 
 
 def _emit_session_start(config: AISessionConfig, command: AISessionCommand, session_log: Path, backup_log: Path) -> None:
@@ -474,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:
@@ -495,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:
@@ -567,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,
@@ -601,8 +774,13 @@ class AISessionLauncher:
             handle.popen.stdin.close()
 
         heartbeat = None
+        live_progress_interval = max(1.0, float(self.config.live_progress_interval_seconds or 30))
+        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(
@@ -613,8 +791,8 @@ class AISessionLauncher:
                     progress_file=self.config.progress_path,
                     marker_dir=session_log.parent,
                     interval_seconds=0.1,
-                    stale_after_seconds=self.config.stale_kill_threshold_seconds,
-                    kill_after_seconds=self.config.stale_kill_threshold_seconds,
+                    stale_after_seconds=stale_threshold_seconds,
+                    kill_after_seconds=kill_threshold_seconds,
                     grace_seconds=self.config.stale_kill_grace_seconds,
                 ),
             )
@@ -626,6 +804,7 @@ class AISessionLauncher:
         stale_marker = None
         last_progress_line = ""
         last_progress_emit = 0.0
+        display_heartbeat_state = None
         try:
             while True:
                 timeout = 0.2
@@ -642,27 +821,54 @@ class AISessionLauncher:
                     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)
+                        if last_progress_emit == 0.0 or now - last_progress_emit >= live_progress_interval:
+                            last_progress_line, display_heartbeat_state = _emit_progress_tick(
+                                started,
+                                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,
+                                interval_seconds=live_progress_interval,
+                                stale_threshold_seconds=stale_threshold_seconds,
+                            )
                             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)
+            final_heartbeat_state = _display_heartbeat_state(
+                session_log,
+                self.config.progress_path,
+                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

@@ -158,8 +158,6 @@ def runtime_paths(args, project_root, task_type, task_id, previous_session_id):
         "bootstrap_prompt": _rel_path(project_root, output_path),
         "session_log": _rel_path(project_root, os.path.join(logs_dir, "session.log")),
         "progress_json": _rel_path(project_root, os.path.join(logs_dir, "progress.json")),
-        "log_monitor_status": _rel_path(project_root, os.path.join(logs_dir, "log-monitor-status.txt")),
-        "log_monitor_baseline": _rel_path(project_root, os.path.join(logs_dir, "log-monitor-baseline.txt")),
         "pid_file": _rel_path(project_root, os.path.join(logs_dir, "ai.pid")),
         "session_status": _rel_path(project_root, session_status),
         "previous_session_log": _rel_path(project_root, previous_log),
@@ -296,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",
         "",
@@ -321,8 +318,6 @@ def _build_addendum(context):
         "- Generated bootstrap prompt path: `{}`".format(runtime["bootstrap_prompt"]),
         "- Session log path: `{}`".format(runtime["session_log"]),
         "- Progress JSON path: `{}`".format(runtime["progress_json"]),
-        "- Log monitor status path: `{}`".format(runtime["log_monitor_status"]),
-        "- Log monitor baseline path: `{}`".format(runtime["log_monitor_baseline"]),
         "- PID file: `{}`".format(runtime["pid_file"]),
         "- Session status file: `{}`".format(runtime["session_status"]),
         "",

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

@@ -27,12 +27,11 @@ 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
 
 
 DEFAULT_MAX_RETRIES = 3
-DEFAULT_MAX_LOG_SIZE = 2097152
 
 LOGGER = setup_logging("generate-bootstrap-prompt")
 
@@ -161,27 +160,6 @@ def compute_feature_slug(feature_id, title):
     return "{}-{}".format(numeric, slug)
 
 
-def _format_bytes(n):
-    """Format a byte count to a human-readable string."""
-    if n >= 1048576:
-        return "{}MB".format(n // 1048576)
-    elif n >= 1024:
-        return "{}KB".format(n // 1024)
-    return "{}B".format(n)
-
-
-def _parse_non_negative_int_env(name, default):
-    """Parse a non-negative integer environment variable."""
-    value = os.environ.get(name, str(default))
-    try:
-        parsed = int(value)
-    except ValueError:
-        emit_failure("{} must be a non-negative integer".format(name))
-    if parsed < 0:
-        emit_failure("{} must be a non-negative integer".format(name))
-    return parsed
-
-
 def _parse_positive_int_env(name, default):
     """Parse a positive integer environment variable."""
     value = os.environ.get(name, str(default))
@@ -195,20 +173,6 @@ def _parse_positive_int_env(name, default):
 
 
 
-def load_log_size_section(script_dir):
-    """Load the optional log-size awareness prompt section."""
-    max_log_size = _parse_non_negative_int_env("MAX_LOG_SIZE", DEFAULT_MAX_LOG_SIZE)
-    if max_log_size == 0:
-        return ""
-
-    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:
@@ -676,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",
@@ -1299,17 +1263,16 @@ def load_section(sections_dir, name):
 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}}",
 }
 
 
 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.
+    Retired Dev implementation and review-fix prompts are intentionally not
+    loaded; feature implementation and accepted review fixes are performed by
+    the main orchestrator. Remaining prompt placeholders support Critic and
+    read-only Reviewer handoffs.
     """
     agent_prompts_dir = os.path.join(templates_dir, "agent-prompts")
     if not os.path.isdir(agent_prompts_dir):
@@ -1470,12 +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")))
 
-    # --- Log Size Awareness (only disabled when MAX_LOG_SIZE is explicitly 0) ---
-    max_log_size = _parse_non_negative_int_env("MAX_LOG_SIZE", DEFAULT_MAX_LOG_SIZE)
-    if max_log_size != 0 and 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"
@@ -1720,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")
@@ -1949,10 +1891,7 @@ def build_replacements(args, feature, features, global_context, script_dir):
         pass  # Keep default 3000 on any error
     dev_url = f"http://localhost:{dev_port}"
 
-    max_log_size = _parse_non_negative_int_env("MAX_LOG_SIZE", DEFAULT_MAX_LOG_SIZE)
-
     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,
@@ -1968,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,
@@ -1997,8 +1935,6 @@ def build_replacements(args, feature, features, global_context, script_dir):
         "{{COVERAGE_TARGET}}": coverage_target,
         "{{DEV_PORT}}": dev_port,
         "{{DEV_URL}}": dev_url,
-        "{{MAX_LOG_SIZE}}": str(max_log_size),
-        "{{MAX_LOG_SIZE_HUMAN}}": _format_bytes(max_log_size),
         "{{SESSION_LOG_PATH}}": os.path.join(
             ".prizmkit", "state", "features", args.feature_id,
             "sessions", args.session_id, "logs", "session.log",
@@ -2090,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"
@@ -2112,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(