prizmkit 1.1.100 → 1.1.101

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

@@ -1,374 +0,0 @@
-"""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