prizmkit 1.1.99 → 1.1.101

package/bundled/dev-pipeline/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/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