prizmkit 1.1.106 → 1.1.108

package/bin/create-prizmkit.js

@@ -46,6 +46,8 @@ program
   .option('--no-open-cli-auto-download', 'Skip auto-download, show manual steps only')
   .option('--rules <preset>', 'Rules preset: recommended, minimal, or none', 'recommended')
   .option('--ai-cli <command>', 'AI CLI executable command (e.g. cbc, claude, codex)')
+  .option('--headless-prompt-arg <arg>', 'Prompt injection argv token for a custom AI CLI (e.g. -p or -i)')
+  .option('--headless-extra-args <args>', 'Additional headless argv tokens for a custom AI CLI')
   .option('--external-skills <names>', 'Comma-separated external skill names to install (e.g. find-skills,impeccable)')
   .option('--non-interactive', 'Skip interactive prompts (requires --platform)')
   .option('--dry-run', 'Show what would be created without making changes')
@@ -95,6 +97,8 @@ program
   .option('--skills <suite>', 'Skill suite: core, minimal, or recommended:<type>')
   .option('--rules <preset>', 'Rules preset: recommended, minimal, or none')
   .option('--ai-cli <command>', 'AI CLI executable command (e.g. cbc, claude, codex)')
+  .option('--headless-prompt-arg <arg>', 'Prompt injection argv token for a custom AI CLI (e.g. -p or -i)')
+  .option('--headless-extra-args <args>', 'Additional headless argv tokens for a custom AI CLI')
   .option('--team', 'Enable multi-agent team mode')
   .option('--no-team', 'Disable multi-agent team mode')
   .option('--pipeline', 'Enable dev-pipeline')

package/bundled/VERSION.json

@@ -1,5 +1,5 @@
 {
-  "frameworkVersion": "1.1.106",
-  "bundledAt": "2026-07-07T02:54:30.507Z",
-  "bundledFrom": "8e4fe49"
+  "frameworkVersion": "1.1.108",
+  "bundledAt": "2026-07-08T01:30:44.419Z",
+  "bundledFrom": "d04466a"
 }

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

@@ -4,11 +4,13 @@ from __future__ import annotations
 
 import json
 import os
+import shlex
 import shutil
 from collections.abc import Mapping
 from dataclasses import dataclass
 from pathlib import Path
 
+from .launch_profiles import HeadlessLaunchProfile
 from .paths import RuntimePaths
 
 
@@ -33,6 +35,7 @@ class AIClientResolution:
     source: str
     precedence: tuple[str, ...]
     notes: tuple[str, ...] = ()
+    launch_profile: HeadlessLaunchProfile | None = None
 
 
 @dataclass(frozen=True)
@@ -65,6 +68,7 @@ class RuntimeConfig:
 AI_CLIENT_PRECEDENCE = (
     "AI_CLI",
     ".prizmkit/config.json:ai_cli",
+    ".prizmkit/config.json:ai_cli_launch",
     ".prizmkit/manifest.json:platform",
     ".prizmkit/config.json:platform",
     "CODEBUDDY_CLI",
@@ -137,13 +141,18 @@ def _int_from_env(env: Mapping[str, str], name: str, default: int) -> int:
         return default
 
 
-def _read_json_value(path: Path, key: str) -> str | None:
+def _read_json_object(path: Path) -> dict[str, object]:
     if not path.is_file():
-        return None
+        return {}
     try:
         data = json.loads(path.read_text(encoding="utf-8"))
     except (OSError, json.JSONDecodeError):
-        return None
+        return {}
+    return data if isinstance(data, dict) else {}
+
+
+def _read_json_value(path: Path, key: str) -> str | None:
+    data = _read_json_object(path)
     value = data.get(key)
     return value if isinstance(value, str) and value.strip() else None
 
@@ -170,13 +179,16 @@ def _cli_names_for_platform(platform: str | None) -> tuple[str, ...]:
 def _known_platform_from_cli(cli_command: str | None) -> str | None:
     if not cli_command:
         return None
-    token = cli_command.split()[0].strip("'\"")
+    try:
+        token = shlex.split(cli_command)[0]
+    except ValueError:
+        token = cli_command.split()[0].strip("'\"")
     name = Path(token).name.lower()
-    if "claude" in name:
+    if name == "claude":
         return "claude"
-    if "codex" in name:
+    if name == "codex":
         return "codex"
-    if "cbc" in name or "codebuddy" in name:
+    if name in {"cbc", "codebuddy"}:
         return "codebuddy"
     return None
 
@@ -204,24 +216,73 @@ def _expected_cli_text(platform: str | None) -> str:
     return ", ".join(_cli_names_for_platform(platform))
 
 
+def _normalize_extra_args(value: object) -> tuple[str, ...]:
+    if value is None:
+        return ()
+    if isinstance(value, list):
+        if not all(isinstance(item, str) for item in value):
+            raise RuntimeConfigError("Custom AI CLI extra arguments must be strings.")
+        return tuple(value)
+    if isinstance(value, str):
+        if not value.strip():
+            return ()
+        try:
+            return tuple(shlex.split(value))
+        except ValueError as exc:
+            raise RuntimeConfigError(f"Invalid custom AI CLI extra arguments: {exc}") from exc
+    raise RuntimeConfigError("Custom AI CLI extra arguments must be an array of argv tokens.")
+
+
+def _one_token(value: object, label: str) -> str:
+    text = value.strip() if isinstance(value, str) else ""
+    if not text:
+        raise RuntimeConfigError("Custom AI CLI requires both executable and prompt injection argument.")
+    try:
+        tokens = shlex.split(text)
+    except ValueError as exc:
+        raise RuntimeConfigError(f"Invalid custom AI CLI {label}: {exc}") from exc
+    if len(tokens) != 1 or not tokens[0]:
+        raise RuntimeConfigError(f"Custom AI CLI {label} must be exactly one argv token.")
+    return tokens[0]
+
+
+def _custom_launch_profile(config_data: Mapping[str, object], config_ai_cli: str | None) -> HeadlessLaunchProfile | None:
+    launch = config_data.get("ai_cli_launch")
+    custom_cli = bool(config_ai_cli) and _known_platform_from_cli(config_ai_cli) is None
+    if not custom_cli:
+        return None
+    if launch is None:
+        raise RuntimeConfigError("Custom AI CLI requires both executable and prompt injection argument in .prizmkit/config.json:ai_cli_launch.prompt_arg.")
+    if not isinstance(launch, Mapping):
+        raise RuntimeConfigError(".prizmkit/config.json:ai_cli_launch must be an object.")
+    if launch.get("profile") != "custom":
+        raise RuntimeConfigError("Custom AI CLI requires .prizmkit/config.json:ai_cli_launch.profile to be 'custom'.")
+    prompt_arg = _one_token(launch.get("prompt_arg"), "prompt injection argument")
+    return HeadlessLaunchProfile(
+        profile="custom",
+        prompt_arg=prompt_arg,
+        extra_args=_normalize_extra_args(launch.get("extra_args")),
+    )
+
+
 def _installed_platform_cli(
     paths: RuntimePaths,
     env: Mapping[str, str],
 ) -> tuple[str | None, str | None]:
     if (
         (paths.project_root / ".codex" / "agents" / "prizm-dev-team-dev.toml").is_file()
-        or (paths.project_root / ".agents" / "skills" / "prizm-kit" / "SKILL.md").is_file()
+        or (paths.project_root / ".agents" / "skills" / "prizmkit" / "SKILL.md").is_file()
     ):
         resolved = _resolve_cli_name("codex", env)
         if resolved:
             return resolved, "installed-platform:codex"
-    if (paths.project_root / ".claude" / "commands" / "prizm-kit.md").is_file():
+    if (paths.project_root / ".claude" / "commands" / "prizmkit.md").is_file():
         resolved = _resolve_cli_name("claude", env)
         if resolved:
             return resolved, "installed-platform:claude"
     if (
         (paths.project_root / ".codebuddy" / "agents" / "prizm-dev-team-dev.md").is_file()
-        or (paths.project_root / ".codebuddy" / "skills" / "prizm-kit" / "SKILL.md").is_file()
+        or (paths.project_root / ".codebuddy" / "skills" / "prizmkit" / "SKILL.md").is_file()
     ):
         resolved = _resolve_cli_name("cbc", env)
         if resolved:
@@ -255,8 +316,12 @@ def resolve_ai_client(
 
 
 def _resolve_ai_client(paths: RuntimePaths, env: Mapping[str, str]) -> AIClientResolution:
-    config_ai_cli = _read_json_value(paths.prizmkit_dir / "config.json", "ai_cli")
-    config_platform = _read_json_value(paths.prizmkit_dir / "config.json", "platform")
+    config_path = paths.prizmkit_dir / "config.json"
+    config_data = _read_json_object(config_path)
+    config_ai_cli_value = config_data.get("ai_cli")
+    config_ai_cli = config_ai_cli_value if isinstance(config_ai_cli_value, str) and config_ai_cli_value.strip() else None
+    config_platform_value = config_data.get("platform")
+    config_platform = config_platform_value if isinstance(config_platform_value, str) and config_platform_value.strip() else None
     manifest_platform = _read_json_value(paths.prizmkit_dir / "manifest.json", "platform")
 
     explicit_command = env.get("AI_CLI")
@@ -269,11 +334,13 @@ def _resolve_ai_client(paths: RuntimePaths, env: Mapping[str, str]) -> AIClientR
         )
 
     if config_ai_cli:
+        custom_launch = _custom_launch_profile(config_data, config_ai_cli)
         return AIClientResolution(
             command=config_ai_cli,
-            platform=_project_platform_for_cli(config_ai_cli, env, manifest_platform, config_platform),
-            source="prizmkit-config:ai_cli",
+            platform="custom" if custom_launch is not None else _project_platform_for_cli(config_ai_cli, env, manifest_platform, config_platform),
+            source="prizmkit-config:ai_cli_launch" if custom_launch is not None else "prizmkit-config:ai_cli",
             precedence=AI_CLIENT_PRECEDENCE,
+            launch_profile=custom_launch,
         )
 
     for platform, source, configured_label in (

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

@@ -100,11 +100,16 @@ def observe_heartbeat_state(
         or (progress_signature and progress_signature != previous.progress_signature)
         or (child_signature and child_signature != previous.child_activity_signature)
     )
-    stale_seconds = 0 if progressed else (previous.stale_seconds + config.interval_seconds if previous else 0)
+    if progressed:
+        last_seen_epoch = now
+        stale_seconds = 0.0
+    else:
+        last_seen_epoch = previous.last_seen_epoch if previous and previous.last_seen_epoch is not None else now
+        stale_seconds = max(0.0, now - last_seen_epoch)
     stale = bool(config.stale_after_seconds > 0 and stale_seconds >= config.stale_after_seconds)
     details = "progress" if progressed else "no progress"
     return HeartbeatState(
-        last_seen_epoch=now if progressed else (previous.last_seen_epoch if previous else now),
+        last_seen_epoch=last_seen_epoch,
         stale=stale,
         details=details,
         stale_seconds=stale_seconds,
@@ -118,6 +123,11 @@ def _utc_marker_time() -> str:
     return time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
 
 
+def _marker_number(value: float) -> int | float:
+    normalized = max(0.0, float(value))
+    return int(normalized) if normalized.is_integer() else normalized
+
+
 def _progress_fatal_error_code(path: Path | None) -> str:
     if path is None or not path.is_file():
         return ""
@@ -142,8 +152,8 @@ def write_stale_marker(
     payload = {
         "killed_at": _utc_marker_time(),
         "reason": reason,
-        "stale_seconds": int(stale_seconds),
-        "threshold": int(threshold),
+        "stale_seconds": _marker_number(stale_seconds),
+        "threshold": _marker_number(threshold),
     }
     if fatal_error_code:
         payload["fatal_error_code"] = fatal_error_code
@@ -164,8 +174,8 @@ def write_fatal_marker(
         "killed_at": _utc_marker_time(),
         "reason": fatal_error_code,
         "fatal_error_code": fatal_error_code,
-        "stale_seconds": int(stale_seconds),
-        "threshold": int(threshold),
+        "stale_seconds": _marker_number(stale_seconds),
+        "threshold": _marker_number(threshold),
     }
     fatal_path = marker_dir / "fatal-error.json"
     stale_path = marker_dir / "stale-kill.json"
@@ -231,13 +241,14 @@ class HeartbeatMonitor:
                 self._killed = True
                 self._reason = fatal_error_code
                 break
-            if self._state.stale and self.config.kill_after_seconds > 0:
+            should_kill = bool(self.config.kill_after_seconds > 0 and self._state.stale_seconds >= self.config.kill_after_seconds)
+            if should_kill:
                 marker_dir = self.config.marker_dir or (self.config.session_log.parent if self.config.session_log else self.config.heartbeat_file.parent)
                 self._marker_path = write_stale_marker(
                     marker_dir,
                     reason="stale_session",
                     stale_seconds=self._state.stale_seconds,
-                    threshold=self.config.stale_after_seconds,
+                    threshold=self.config.kill_after_seconds,
                 )
                 terminate_process_tree(self.handle, "stale_session", grace_seconds=self.config.grace_seconds)
                 self._killed = True

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

@@ -24,7 +24,6 @@ UTILITY_ENTRYPOINTS = {
     "init-refactor-pipeline": "scripts/init-refactor-pipeline.py",
     "parse-stream-progress": "scripts/parse-stream-progress.py",
     "patch-completion-notes": "scripts/patch-completion-notes.py",
-    "prizmkit-test-gate": "scripts/prizmkit-test-gate.py",
     "update-bug-status": "scripts/update-bug-status.py",
     "update-checkpoint": "scripts/update-checkpoint.py",
     "update-feature-status": "scripts/update-feature-status.py",

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

@@ -0,0 +1,18 @@
+"""Provider-neutral headless launch profile models."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class HeadlessLaunchProfile:
+    """Custom AI CLI headless prompt injection contract."""
+
+    profile: str
+    prompt_arg: str
+    extra_args: tuple[str, ...] = ()
+
+    @property
+    def is_custom(self) -> bool:
+        return self.profile == "custom"

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

@@ -67,7 +67,21 @@ def commit_bookkeeping_changes(
     if not paths:
         return BookkeepingResult(attempted=False, committed=False)
     run_git_command(project_root, ("add", "-A", "--", *paths))
-    result = run_git_command(project_root, ("commit", "--no-verify", "-m", message))
+    result = run_git_command(project_root, ("commit", "--no-verify", "-m", message, "--", *paths))
+    return BookkeepingResult(attempted=True, committed=result.return_code == 0, result=result)
+
+
+def commit_preflight_ready_changes(project_root: Path, item_id: str) -> BookkeepingResult:
+    """Preserve visible pre-existing changes before task branch setup."""
+    if not git_status_safe(project_root).strip():
+        return BookkeepingResult(attempted=False, committed=False)
+    add_result = run_git_command(project_root, ("add", "-A", "--", ".", *HIDDEN_TOOL_WORKTREE_EXCLUDES))
+    if add_result.return_code != 0:
+        return BookkeepingResult(attempted=True, committed=False, result=add_result)
+    result = run_git_command(
+        project_root,
+        ("commit", "--no-verify", "-m", f"chore: ready for {item_id}", "--", ".", *HIDDEN_TOOL_WORKTREE_EXCLUDES),
+    )
     return BookkeepingResult(attempted=True, committed=result.return_code == 0, result=result)
 
 
@@ -84,7 +98,10 @@ def commit_task_branch_changes(
     if not git_status_safe(project_root).strip():
         return BookkeepingResult(attempted=False, committed=False)
     run_git_command(project_root, ("add", "-A", "--", ".", *HIDDEN_TOOL_WORKTREE_EXCLUDES))
-    result = run_git_command(project_root, ("commit", "--no-verify", "-m", message))
+    result = run_git_command(
+        project_root,
+        ("commit", "--no-verify", "-m", message, "--", ".", *HIDDEN_TOOL_WORKTREE_EXCLUDES),
+    )
     return BookkeepingResult(attempted=True, committed=result.return_code == 0, result=result)
 
 
@@ -107,6 +124,9 @@ def commit_wip_changes(
             f"wip({item_id}): preserve {family.kind} {status} state",
             "-m",
             "Pipeline preserved task branch work without merging it to the base branch.",
+            "--",
+            ".",
+            *HIDDEN_TOOL_WORKTREE_EXCLUDES,
         ),
     )
     return BookkeepingResult(attempted=True, committed=result.return_code == 0, result=result)

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

@@ -29,6 +29,10 @@ INFRA_MARKERS = (
     "authentication",
     "unauthorized",
     "api error",
+    "quota",
+    "usage limit",
+    "credit balance",
+    "billing",
 )
 
 
@@ -52,6 +56,13 @@ def classify_session(
             progress_fingerprint=fingerprint,
         )
 
+    if _has_late_runtime_error_after_completion(result, prompt, has_commit_since_base):
+        return SessionClassification(
+            "success",
+            reason="completed_checkpoint_with_late_runtime_error",
+            progress_fingerprint=fingerprint,
+        )
+
     if _is_context_overflow(result):
         if has_commit_since_base:
             return SessionClassification("success", reason="commit_since_base", progress_fingerprint=fingerprint)
@@ -121,6 +132,16 @@ def _is_terminal_success(result: AISessionResult) -> bool:
     )
 
 
+def _has_late_runtime_error_after_completion(
+    result: AISessionResult,
+    prompt: PromptGenerationResult | None,
+    has_commit_since_base: bool,
+) -> bool:
+    if not has_commit_since_base or not _has_completed_workflow_artifact(prompt):
+        return False
+    return _is_context_overflow(result) or _is_infra_error(result)
+
+
 def _has_completed_workflow_artifact(prompt: PromptGenerationResult | None) -> bool:
     if prompt is None:
         return False
@@ -131,11 +152,32 @@ def _has_completed_workflow_artifact(prompt: PromptGenerationResult | None) -> b
             data = {}
         if isinstance(data, dict) and _checkpoint_cursor(data) == "complete":
             return True
-    if prompt.artifact_path and (prompt.artifact_path / "completion-summary.json").is_file():
+    if prompt.artifact_path and has_completed_artifact_path(prompt.artifact_path):
         return True
     return False
 
 
+def has_branch_completion_evidence(project_root: Path, base_branch: str, working_branch: str, artifact_path: Path | None) -> bool:
+    """Return true when a recorded task branch already has completed work to merge."""
+    if not base_branch or not working_branch or not has_completed_artifact_path(artifact_path):
+        return False
+    return _has_commit_range(project_root, base_branch, working_branch)
+
+
+def has_completed_artifact_path(artifact_path: Path | None) -> bool:
+    if artifact_path is None:
+        return False
+    checkpoint = artifact_path / "workflow-checkpoint.json"
+    if checkpoint.is_file():
+        try:
+            data = json.loads(checkpoint.read_text(encoding="utf-8"))
+        except (OSError, json.JSONDecodeError):
+            data = {}
+        if isinstance(data, dict) and _checkpoint_cursor(data) == "complete":
+            return True
+    return (artifact_path / "completion-summary.json").is_file()
+
+
 def _next_no_progress_count(previous: object | None, current: object, count: int) -> int:
     if previous and previous == current:
         return max(0, count) + 1
@@ -161,11 +203,20 @@ def _is_infra_error(result: AISessionResult) -> bool:
     return bool(result.fatal_error_code and result.fatal_error_code != CONTEXT_OVERFLOW) or any(marker in text for marker in INFRA_MARKERS)
 
 
-def _has_commit_since(project_root: Path, base_head: str) -> bool:
-    if not base_head:
+def _has_commit_range(project_root: Path, start_ref: str, end_ref: str = "HEAD") -> bool:
+    if not start_ref or not end_ref:
         return False
-    current = run_git_command(project_root, ("rev-parse", "HEAD")).stdout.strip()
-    return bool(current and current != base_head)
+    result = run_git_command(project_root, ("rev-list", "--count", f"{start_ref}..{end_ref}"))
+    if result.return_code != 0:
+        return False
+    try:
+        return int(result.stdout.strip() or "0") > 0
+    except ValueError:
+        return False
+
+
+def _has_commit_since(project_root: Path, base_head: str) -> bool:
+    return _has_commit_range(project_root, base_head, "HEAD")
 
 
 def _has_workspace_changes(project_root: Path) -> bool:

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

@@ -45,7 +45,6 @@ class RunnerEnvironment:
     heartbeat_interval_seconds: int = 30
     heartbeat_stale_threshold_seconds: int = 600
     stale_kill_threshold_seconds: int = 600
-    max_log_size: int | None = None
     max_retries: int = 3
     strict_behavior_check: bool = True
 
@@ -67,7 +66,6 @@ class RunnerEnvironment:
                 _int_value(values, "HEARTBEAT_TIMEOUT_SECONDS", 600),
             ),
             stale_kill_threshold_seconds=_int_value(values, "STALE_KILL_THRESHOLD", 600),
-            max_log_size=_optional_int(values.get("MAX_LOG_SIZE")),
             max_retries=max(0, _int_value(values, "MAX_RETRIES", 3)),
             strict_behavior_check=not _falsey(values.get("STRICT_BEHAVIOR_CHECK")),
         )
@@ -349,9 +347,3 @@ def _safe_int(value: str | None, default: int) -> int:
 
 def _int_value(values: Mapping[str, str], name: str, default: int) -> int:
     return _safe_int(values.get(name), default)
-
-
-def _optional_int(value: str | None) -> int | None:
-    if value is None or str(value).strip() == "":
-        return None
-    return _safe_int(value, 0)

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

@@ -12,7 +12,7 @@ from pathlib import Path
 from .config import load_runtime_config
 from .paths import RuntimePaths
 from .runner_models import RunnerEnvironment, SessionPaths
-from .sessions import AISessionConfig, AISessionLauncher
+from .sessions import AISessionConfig, AISessionLauncher, detect_stream_json_support
 
 
 @dataclass(frozen=True)
@@ -122,6 +122,9 @@ def run_recovery(paths: RuntimePaths, legacy_args: tuple[str, ...] = ()) -> tupl
     if not config.ai_client.command:
         return 1, "", "No supported AI CLI command was found for recovery\n"
     env = RunnerEnvironment.from_env()
+    stream_json = False
+    if env.live_output and getattr(config.ai_client, "launch_profile", None) is None:
+        stream_json = detect_stream_json_support(config.ai_client.command, config.ai_client.platform).enabled
     launcher = AISessionLauncher(
         AISessionConfig(
             cli_command=config.ai_client.command,
@@ -134,7 +137,14 @@ def run_recovery(paths: RuntimePaths, legacy_args: tuple[str, ...] = ()) -> tupl
             heartbeat_path=session_paths.heartbeat_json,
             effort=config.effort,
             verbose=env.verbose,
+            live_output=env.live_output,
+            use_stream_json=stream_json,
+            launch_profile=getattr(config.ai_client, "launch_profile", None),
             stale_kill_threshold_seconds=env.stale_kill_threshold_seconds,
+            heartbeat_stale_threshold_seconds=env.heartbeat_stale_threshold_seconds,
+            live_progress_interval_seconds=env.heartbeat_interval_seconds,
+            live_banner=False,
+            suppress_stream_output=True,
         )
     )
     result = launcher.run()