prizmkit 1.1.99 → 1.1.100

package/bundled/dev-pipeline-windows/scripts/check-session-status.py

@@ -22,6 +22,77 @@ ID_FIELDS = ["feature_id", "bug_id", "refactor_id"]
 
 LOGGER = setup_logging("check-session-status")
 
+CONTEXT_OVERFLOW_CODE = "context_overflow"
+CONTEXT_CODE_VALUES = {
+    "context_overflow",
+    "context_too_large",
+    "context_length_exceeded",
+    "model_context_window_exceeded",
+}
+CONTEXT_TEXT_PATTERNS = (
+    "input exceeds the context window",
+    "context window of this model",
+    "context window exceeded",
+    "maximum context length exceeded",
+    "prompt is too long",
+    "too many tokens",
+    "input token count exceeds",
+)
+REQUEST_TOO_LARGE_TEXT = "request too large"
+REQUEST_TOO_LARGE_SEMANTICS = ("context", "token", "tokens", "prompt", "input", "model")
+ERROR_LIKE_STATUSES = {"failed", "crashed", "timed_out", "context_overflow"}
+
+
+def _flatten_values(value):
+    if isinstance(value, dict):
+        values = []
+        for child in value.values():
+            values.extend(_flatten_values(child))
+        return values
+    if isinstance(value, list):
+        values = []
+        for child in value:
+            values.extend(_flatten_values(child))
+        return values
+    if value is None:
+        return []
+    return [str(value)]
+
+
+def _is_error_like_status(data):
+    status = str(data.get("status", "")).lower()
+    if status in ERROR_LIKE_STATUSES:
+        return True
+    if data.get("last_result_is_error") is True or data.get("is_error") is True:
+        return True
+    if data.get("api_error_status") not in (None, ""):
+        return True
+    errors = data.get("errors")
+    return isinstance(errors, list) and len(errors) > 0
+
+
+def has_context_overflow_signal(data):
+    """Return true when session-status data carries a context overflow signal.
+
+    Success remains success: direct status handling happens before this helper.
+    Exact machine codes are accepted only from structured code fields. Natural
+    language context/token phrases require a failed/error-like status or an
+    explicit error field to avoid prompt/documentation false positives.
+    """
+    if not isinstance(data, dict):
+        return False
+    for field in ("fatal_error_code", "api_error_code", "error_code", "stop_reason"):
+        value = data.get(field)
+        if isinstance(value, str) and value.lower() in CONTEXT_CODE_VALUES:
+            return True
+    if not _is_error_like_status(data):
+        return False
+    text = " ".join(_flatten_values(data)).lower()
+    if any(pattern in text for pattern in CONTEXT_TEXT_PATTERNS):
+        return True
+    return REQUEST_TOO_LARGE_TEXT in text and any(
+        semantic in text for semantic in REQUEST_TOO_LARGE_SEMANTICS
+    )
 
 def parse_args():
     parser = argparse.ArgumentParser(
@@ -79,12 +150,14 @@ def determine_status(data):
     """Determine the single-line status string from the parsed data.
 
     Returns one of: success, partial_resumable, partial_not_resumable,
-    failed, commit_missing, docs_missing, merge_conflict.
+    failed, commit_missing, docs_missing, merge_conflict, context_overflow.
     """
     status = data.get("status", "")
 
     if status == "success":
         return "success"
+    if status == "context_overflow" or has_context_overflow_signal(data):
+        return "context_overflow"
     elif status == "partial":
         can_resume = data.get("can_resume", False)
         if can_resume:

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

@@ -0,0 +1,374 @@
+"""Continuation prompt and durable handoff helpers for pipeline prompt generators."""
+
+import os
+
+SUPPORTED_CONTINUATION_MODES = {"context_overflow"}
+TASK_TYPES = {"feature", "bugfix", "refactor"}
+
+
+def add_continuation_args(parser, default_task_type):
+    """Add continuation-mode CLI arguments to a prompt generator parser."""
+    parser.add_argument(
+        "--continuation-mode",
+        choices=sorted(SUPPORTED_CONTINUATION_MODES),
+        default="",
+        help="Continuation recovery mode, currently context_overflow.",
+    )
+    parser.add_argument(
+        "--previous-session-id",
+        default="",
+        help="Session ID that triggered this continuation.",
+    )
+    parser.add_argument(
+        "--continuation-count",
+        default="0",
+        help="Cumulative continuation count for this task.",
+    )
+    parser.add_argument(
+        "--context-overflow-count",
+        default="0",
+        help="Cumulative context overflow count for this task.",
+    )
+    parser.add_argument(
+        "--task-type",
+        choices=sorted(TASK_TYPES),
+        default=default_task_type,
+        help="Task type for continuation handoff metadata.",
+    )
+    parser.add_argument(
+        "--active-dev-branch",
+        default="",
+        help="Development branch being reused by the continuation.",
+    )
+    parser.add_argument(
+        "--base-branch",
+        default="",
+        help="Base branch preserved across continuation sessions.",
+    )
+    parser.add_argument(
+        "--continuation-summary-path",
+        default="",
+        help="Durable continuation summary artifact path.",
+    )
+
+
+def is_continuation(args):
+    """Return True when continuation mode is active."""
+    return bool(getattr(args, "continuation_mode", ""))
+
+
+def _safe_int(value, default=0):
+    try:
+        parsed = int(value)
+    except (TypeError, ValueError):
+        return default
+    return parsed if parsed >= 0 else default
+
+
+def _norm(path):
+    return str(path).replace(os.sep, "/")
+
+
+def _rel_path(project_root, path):
+    """Return a stable project-relative path when possible."""
+    if not path:
+        return "(not available)"
+    text = str(path)
+    if text.startswith(".prizmkit/") or text.startswith(".prizmkit\\"):
+        return _norm(text)
+    try:
+        abs_path = os.path.abspath(text)
+        root = os.path.abspath(project_root)
+        rel = os.path.relpath(abs_path, root)
+        if not rel.startswith(".."):  # keep paths under the project concise
+            return _norm(rel)
+    except ValueError:
+        pass
+    return _norm(text)
+
+
+def _dedupe(items):
+    result = []
+    seen = set()
+    for item in items:
+        if not item:
+            continue
+        key = _norm(item)
+        if key in seen:
+            continue
+        seen.add(key)
+        result.append(item)
+    return result
+
+
+def continuation_summary_paths(task_type, task_id, task_slug, override_path=""):
+    """Return all durable continuation summary paths to write."""
+    if task_type == "feature":
+        default_path = os.path.join(
+            ".prizmkit", "specs", task_slug, "continuation-summary.md",
+        )
+        return _dedupe([override_path, default_path])
+
+    task_dir = "bugfix" if task_type == "bugfix" else "refactor"
+    task_local = os.path.join(
+        ".prizmkit", task_dir, task_id, "continuation-summary.md",
+    )
+    specs_path = os.path.join(
+        ".prizmkit", "specs", task_slug or task_id, "continuation-summary.md",
+    )
+    return _dedupe([override_path, specs_path, task_local])
+
+
+def durable_paths(task_type, task_id, task_slug):
+    """Return stable durable artifact paths for a task."""
+    if task_type == "feature":
+        artifact_dir = os.path.join(".prizmkit", "specs", task_slug)
+    elif task_type == "bugfix":
+        artifact_dir = os.path.join(".prizmkit", "bugfix", task_id)
+    else:
+        artifact_dir = os.path.join(".prizmkit", "refactor", task_id)
+
+    return {
+        "artifact_dir": artifact_dir,
+        "checkpoint": os.path.join(artifact_dir, "workflow-checkpoint.json"),
+        "plan": os.path.join(artifact_dir, "plan.md"),
+        "context_snapshot": os.path.join(artifact_dir, "context-snapshot.md"),
+        "failure_log": os.path.join(artifact_dir, "failure-log.md"),
+    }
+
+
+def runtime_paths(args, project_root, task_type, task_id, previous_session_id):
+    """Return fresh runtime paths for the new session and previous log pointer."""
+    output_path = getattr(args, "output", "")
+    session_dir = os.path.dirname(os.path.abspath(output_path)) if output_path else ""
+    logs_dir = os.path.join(session_dir, "logs") if session_dir else ""
+    session_status = os.path.join(session_dir, "session-status.json") if session_dir else ""
+
+    state_dir = getattr(args, "state_dir", "") or os.path.join(
+        ".prizmkit", "state", "features" if task_type == "feature" else task_type,
+    )
+    previous_log = "(unknown)"
+    if previous_session_id:
+        previous_log = os.path.join(
+            state_dir, task_id, "sessions", previous_session_id, "logs", "session.log",
+        )
+
+    return {
+        "session_dir": _rel_path(project_root, session_dir),
+        "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),
+    }
+
+
+def checkpoint_cursor(checkpoint):
+    """Summarize current checkpoint state and cursor."""
+    steps = checkpoint.get("steps", []) if isinstance(checkpoint, dict) else []
+    completed = []
+    skipped = []
+    in_progress = []
+    pending = []
+    failed = []
+    first_cursor = None
+
+    for step in steps:
+        skill = step.get("skill", "unknown")
+        label = "{} ({})".format(step.get("id", "?"), skill)
+        status = step.get("status", "pending")
+        if status == "completed":
+            completed.append(label)
+        elif status == "skipped":
+            skipped.append(label)
+        elif status == "in_progress":
+            in_progress.append(label)
+            if first_cursor is None:
+                first_cursor = label
+        elif status == "failed":
+            failed.append(label)
+            if first_cursor is None:
+                first_cursor = label
+        else:
+            pending.append(label)
+            if first_cursor is None:
+                first_cursor = label
+
+    if first_cursor is None:
+        first_cursor = "(all checkpoint steps completed or skipped)"
+
+    return {
+        "completed": completed,
+        "skipped": skipped,
+        "in_progress": in_progress,
+        "pending": pending,
+        "failed": failed,
+        "first_cursor": first_cursor,
+    }
+
+
+def _list_or_none(values):
+    if not values:
+        return "- (none)"
+    return "\n".join("- {}".format(value) for value in values)
+
+
+def _build_summary(context):
+    cursor = context["cursor"]
+    durable = context["durable"]
+    runtime = context["runtime"]
+    summary_paths = context["summary_paths"]
+    lines = [
+        "# Continuation Summary",
+        "",
+        "## Reason",
+        "",
+        "- Continuation mode: {}".format(context["mode"]),
+        "- This continuation was started after context overflow.",
+        "- This artifact is the durable handoff summary; do not rely on the previous full transcript.",
+        "",
+        "## Previous Session",
+        "",
+        "- Previous session id: {}".format(context["previous_session_id"] or "(unknown)"),
+        "- Previous session log: {}".format(runtime["previous_session_log"]),
+        "- Previous full session.log should only be read if synthesized artifacts are insufficient.",
+        "",
+        "## Task Identity",
+        "",
+        "- Task type: {}".format(context["task_type"]),
+        "- Task id: {}".format(context["task_id"]),
+        "- Task slug: {}".format(context["task_slug"]),
+        "- Active dev branch: {}".format(context["active_dev_branch"] or "(preserve current worktree branch)"),
+        "- Base branch: {}".format(context["base_branch"] or "(unknown)"),
+        "- Continuation count: {}".format(context["continuation_count"]),
+        "- Context overflow count: {}".format(context["context_overflow_count"]),
+        "",
+        "## Observed Partial Progress",
+        "",
+        "- First pending/in-progress checkpoint step: {}".format(cursor["first_cursor"]),
+        "- Completed checkpoint steps:",
+        _list_or_none(cursor["completed"]),
+        "- Skipped checkpoint steps:",
+        _list_or_none(cursor["skipped"]),
+        "- In-progress checkpoint steps:",
+        _list_or_none(cursor["in_progress"]),
+        "- Pending checkpoint steps:",
+        _list_or_none(cursor["pending"]),
+        "- Failed checkpoint steps:",
+        _list_or_none(cursor["failed"]),
+        "",
+        "## Durable Pointers",
+        "",
+        "- Start with current worktree state: `git status` and `git diff`.",
+        "- Durable task artifact directory: {}".format(_norm(durable["artifact_dir"])),
+        "- Workflow checkpoint: {}".format(_norm(durable["checkpoint"])),
+        "- Context snapshot: {}".format(_norm(durable["context_snapshot"])),
+        "- Plan: {}".format(_norm(durable["plan"])),
+        "- Failure log: {}".format(_norm(durable["failure_log"])),
+        "- Continuation summaries:",
+        _list_or_none([_norm(path) for path in summary_paths]),
+        "",
+    ]
+    return "\n".join(lines)
+
+
+def _build_addendum(context):
+    cursor = context["cursor"]
+    durable = context["durable"]
+    runtime = context["runtime"]
+    summary_paths = context["summary_paths"]
+    lines = [
+        "## Continuation Addendum — Context Overflow Recovery",
+        "",
+        "This is an automatic continuation after context overflow.",
+        "This is a fresh headless AI CLI session for the same task.",
+        "Continue on the current branch/worktree.",
+        "Do not reset, clean, switch branches, or discard work.",
+        "",
+        "### Required First Actions",
+        "",
+        "- Start with `git status` and `git diff`.",
+        "- Reuse the same durable task artifact directory: `{}`.".format(_norm(durable["artifact_dir"])),
+        "- Treat completed/skipped checkpoint steps as already done.",
+        "- 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",
+        "",
+        "- Task type: `{}`".format(context["task_type"]),
+        "- Task id: `{}`".format(context["task_id"]),
+        "- Task slug: `{}`".format(context["task_slug"]),
+        "- Dev branch: `{}`".format(context["active_dev_branch"] or "(current branch)"),
+        "- Base branch: `{}`".format(context["base_branch"] or "(unknown)"),
+        "- Checkpoint path: `{}`".format(_norm(durable["checkpoint"])),
+        "- Plan path: `{}`".format(_norm(durable["plan"])),
+        "- Context snapshot path: `{}`".format(_norm(durable["context_snapshot"])),
+        "- Failure log path: `{}`".format(_norm(durable["failure_log"])),
+        "- Continuation summary path(s): `{}`".format(", ".join(_norm(p) for p in summary_paths)),
+        "- Continuation count: `{}`".format(context["continuation_count"]),
+        "- Context overflow count: `{}`".format(context["context_overflow_count"]),
+        "- Previous session id: `{}`".format(context["previous_session_id"] or "(unknown)"),
+        "- Previous session log reference: `{}`".format(runtime["previous_session_log"]),
+        "",
+        "### Fresh Session Runtime Paths",
+        "",
+        "- Fresh session directory: `{}`".format(runtime["session_dir"]),
+        "- 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"]),
+        "",
+    ]
+    return "\n".join(lines)
+
+
+def append_continuation_handoff(rendered_prompt, args, project_root, task_type,
+                                 task_id, task_slug, checkpoint,
+                                 summary_paths=None):
+    """Write continuation summaries and append the addendum to a prompt."""
+    if not is_continuation(args):
+        return rendered_prompt
+
+    mode = getattr(args, "continuation_mode", "")
+    if mode not in SUPPORTED_CONTINUATION_MODES:
+        raise ValueError("Unsupported continuation mode: {}".format(mode))
+
+    durable = durable_paths(task_type, task_id, task_slug)
+    paths = summary_paths or continuation_summary_paths(
+        task_type, task_id, task_slug, getattr(args, "continuation_summary_path", ""),
+    )
+    paths = [_rel_path(project_root, path) for path in paths]
+    previous_session_id = getattr(args, "previous_session_id", "")
+    context = {
+        "mode": mode,
+        "task_type": task_type,
+        "task_id": task_id,
+        "task_slug": task_slug,
+        "previous_session_id": previous_session_id,
+        "continuation_count": _safe_int(getattr(args, "continuation_count", 0)),
+        "context_overflow_count": _safe_int(getattr(args, "context_overflow_count", 0)),
+        "active_dev_branch": getattr(args, "active_dev_branch", ""),
+        "base_branch": getattr(args, "base_branch", ""),
+        "durable": durable,
+        "runtime": runtime_paths(args, project_root, task_type, task_id, previous_session_id),
+        "cursor": checkpoint_cursor(checkpoint or {}),
+        "summary_paths": paths,
+    }
+
+    summary_text = _build_summary(context)
+    for summary_path in paths:
+        abs_summary = os.path.join(project_root, summary_path)
+        os.makedirs(os.path.dirname(abs_summary), exist_ok=True)
+        with open(abs_summary, "w", encoding="utf-8") as f:
+            f.write(summary_text)
+
+    addendum = _build_addendum(context)
+    return rendered_prompt.rstrip() + "\n\n" + addendum

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

@@ -28,11 +28,11 @@ import re
 import sys
 
 from utils import enrich_global_context, load_json_file, read_platform_conventions, setup_logging
+from continuation import add_continuation_args, append_continuation_handoff, is_continuation
 
 
 DEFAULT_MAX_RETRIES = 3
 DEFAULT_MAX_LOG_SIZE = 2097152
-DEFAULT_LOG_MONITOR_POLL_INTERVAL = 30
 
 LOGGER = setup_logging("generate-bootstrap-prompt")
 
@@ -115,6 +115,8 @@ def parse_args():
         help="Do not write workflow-checkpoint.json (used by pipeline dry-run)",
     )
 
+    add_continuation_args(parser, "feature")
+
     return parser.parse_args()
 
 
@@ -1357,8 +1359,7 @@ def _tier_header(pipeline_mode):
         "lite": (
             "# Dev-Pipeline Session Bootstrap — Tier 1 (Single Agent)\n",
             "**Tier 1 — Single Agent**: You handle everything directly. "
-            "No normal work subagents; the log-size monitor is the only "
-            "allowed persistent background subagent. No TeamCreate.\n",
+            "No normal work subagents. No TeamCreate.\n",
         ),
         "standard": (
             "# Dev-Pipeline Session Bootstrap — Tier 2 (Dual Agent)\n",
@@ -1396,8 +1397,7 @@ def _tier_reminders(pipeline_mode, critic_enabled=False):
     if pipeline_mode == "lite":
         specific = [
             "- Tier 1: you handle everything directly — no normal work "
-            "subagents needed; the log-size monitor is the only allowed "
-            "persistent background subagent",
+            "subagents needed",
         ]
     elif pipeline_mode == "standard":
         specific = [
@@ -1410,8 +1410,7 @@ def _tier_reminders(pipeline_mode, critic_enabled=False):
             "- Gate checks enforce Implementation Log and Review Notes are "
             "written before proceeding",
             "- Do NOT use `run_in_background=true` when spawning normal work "
-            "subagents; the log-size monitor is the only allowed persistent "
-            "background subagent",
+            "subagents",
             "- On timeout: check snapshot + git diff HEAD → model:lite → "
             "remaining steps only → max 2 retries per phase → "
             "orchestrator fallback",
@@ -1426,8 +1425,7 @@ def _tier_reminders(pipeline_mode, critic_enabled=False):
             "- Gate checks enforce Implementation Log and Review Notes are "
             "written before proceeding",
             "- Do NOT use `run_in_background=true` when spawning normal work "
-            "agents; the log-size monitor is the only allowed persistent "
-            "background subagent",
+            "agents",
             "- On timeout: check snapshot → model:lite → remaining steps "
             "only → max 2 retries → orchestrator fallback",
         ]
@@ -1467,8 +1465,7 @@ def assemble_sections(pipeline_mode, sections_dir, init_done, is_resume,
     if pipeline_mode != "lite":
         mission += (
             " When you spawn normal work subagents, wait for each to finish "
-            "(run_in_background=false). The log-size monitor is the only "
-            "allowed persistent background subagent."
+            "(run_in_background=false)."
         )
     if pipeline_mode == "full":
         mission += (
@@ -1969,12 +1966,6 @@ def build_replacements(args, feature, features, global_context, script_dir):
     dev_url = f"http://localhost:{dev_port}"
 
     max_log_size = _parse_non_negative_int_env("MAX_LOG_SIZE", DEFAULT_MAX_LOG_SIZE)
-    if max_log_size == 0:
-        poll_interval = DEFAULT_LOG_MONITOR_POLL_INTERVAL
-    else:
-        poll_interval = _parse_positive_int_env(
-            "LOG_MONITOR_POLL_INTERVAL", DEFAULT_LOG_MONITOR_POLL_INTERVAL,
-        )
 
     replacements = {
         "{{LOG_SIZE_AWARENESS}}": load_log_size_section(script_dir),
@@ -2025,22 +2016,10 @@ def build_replacements(args, feature, features, global_context, script_dir):
         "{{DEV_URL}}": dev_url,
         "{{MAX_LOG_SIZE}}": str(max_log_size),
         "{{MAX_LOG_SIZE_HUMAN}}": _format_bytes(max_log_size),
-        "{{LOG_MONITOR_POLL_INTERVAL}}": str(poll_interval),
-        "{{LOG_MONITOR_STATUS_FILE}}": os.path.join(
-            ".prizmkit", "state", "features", args.feature_id,
-            "sessions", args.session_id, "logs", "log-monitor-status.txt",
-        ),
-        "{{LOG_MONITOR_BASELINE_FILE}}": os.path.join(
-            ".prizmkit", "state", "features", args.feature_id,
-            "sessions", args.session_id, "logs", "log-monitor-baseline.txt",
-        ),
         "{{SESSION_LOG_PATH}}": os.path.join(
             ".prizmkit", "state", "features", args.feature_id,
             "sessions", args.session_id, "logs", "session.log",
         ),
-        "{{LOG_MONITOR_SCRIPT}}": os.path.join(
-            ".prizmkit", "dev-pipeline", "scripts", "monitor-log.ps1",
-        ),
     }
 
     return replacements, effective_resume, browser_enabled, browser_tool
@@ -2127,6 +2106,9 @@ def main():
     agent_prompt_replacements = load_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"
@@ -2146,6 +2128,11 @@ 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(
@@ -2207,6 +2194,7 @@ def main():
     )
     feature_slug = replacements.get("{{FEATURE_SLUG}}", "")
     checkpoint_path = ""
+    checkpoint = {}
 
     if not args.no_checkpoint and use_sections and feature_slug:
         checkpoint = generate_checkpoint_definition(
@@ -2228,7 +2216,7 @@ def main():
         )
 
         # On resume, merge existing completed state (with artifact validation)
-        if is_resume and os.path.exists(checkpoint_path):
+        if (is_resume or is_continuation(args)) and os.path.exists(checkpoint_path):
             try:
                 with open(checkpoint_path, "r", encoding="utf-8") as f:
                     existing = json.load(f)
@@ -2247,6 +2235,15 @@ def main():
             json.dump(checkpoint, f, indent=2, ensure_ascii=False)
         LOGGER.info("Wrote checkpoint to %s", checkpoint_path)
 
+    if is_continuation(args):
+        rendered = append_continuation_handoff(
+            rendered, args, project_root, args.task_type, args.feature_id,
+            feature_slug, checkpoint,
+        )
+        err = write_output(args.output, rendered)
+        if err:
+            emit_failure(err)
+
     # ── Success JSON ───────────────────────────────────────────────────
     feature_model = feature.get("model", "")
     mode_agent_counts = {"lite": 1, "standard": 3, "full": 3}