prizmkit 1.1.145 → 1.1.146

package/bundled/dev-pipeline/tests/live_ai_cli_log_smoke.py

@@ -0,0 +1,206 @@
+#!/usr/bin/env python3
+"""Capability-gated live smoke checks for normalized AI CLI session logging.
+
+The deterministic fixture suite remains authoritative. This script optionally
+exercises locally installed, authenticated, non-interactive-capable adapters in
+isolated temporary Git repositories.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import shutil
+import subprocess
+import sys
+import tempfile
+from dataclasses import asdict, dataclass
+from pathlib import Path
+from typing import Callable, Iterable
+
+PIPELINE_ROOT = Path(__file__).resolve().parents[1]
+if str(PIPELINE_ROOT) not in sys.path:
+    sys.path.insert(0, str(PIPELINE_ROOT))
+
+from prizmkit_runtime.sessions import AISessionConfig, AISessionLauncher  # noqa: E402
+
+
+@dataclass(frozen=True)
+class SmokeProfile:
+    """One installed adapter example to exercise."""
+
+    name: str
+    command: str
+    platform: str
+
+
+@dataclass(frozen=True)
+class SmokeResult:
+    """Machine-readable capability or execution result."""
+
+    name: str
+    status: str
+    reason: str
+    log_path: str = ""
+    exit_code: int | None = None
+
+
+PROFILE_EXAMPLES = (
+    ("pi", "pi", "pi"),
+    ("codebuddy", "cbc", "codebuddy"),
+    ("codex", "codex", "codex"),
+    ("claude", "claude", "claude"),
+)
+
+AUTH_MARKERS = (
+    "authentication",
+    "unauthorized",
+    "not logged in",
+    "login required",
+    "invalid api key",
+    "missing api key",
+    "credential",
+    "billing",
+    "quota",
+    "model access",
+    "model not found",
+    "no access to model",
+    "network is unreachable",
+    "connection refused",
+    "could not resolve",
+    "service unavailable",
+)
+
+REQUIRED_LABELS = (
+    "[ACTION]",
+    "[OBSERVATION]",
+    "[FINAL]",
+    "[SESSION_END]",
+)
+
+
+def discover_profiles(
+    which: Callable[[str], str | None] = shutil.which,
+    examples: Iterable[tuple[str, str, str]] = PROFILE_EXAMPLES,
+) -> tuple[list[SmokeProfile], list[SmokeResult]]:
+    """Return installed profiles and explicit executable-capability skips."""
+    installed = []
+    skipped = []
+    for name, executable, platform in examples:
+        resolved = which(executable)
+        if resolved:
+            installed.append(SmokeProfile(name, resolved, platform))
+        else:
+            skipped.append(SmokeResult(name, "skipped", f"executable not found: {executable}"))
+    return installed, skipped
+
+
+def smoke_prompt() -> str:
+    """Return the isolated harmless tool-and-final-answer prompt."""
+    return (
+        "This is an isolated logging smoke test. Use one local shell tool to run "
+        "`printf 'PRIZMKIT_SMOKE_TOOL_OK\\n'`. Do not read, create, edit, or delete "
+        "project files. After the tool succeeds, answer exactly "
+        "`PRIZMKIT_SMOKE_FINAL_OK`."
+    )
+
+
+def _looks_capability_blocked(text: str) -> bool:
+    lowered = text.lower()
+    return any(marker in lowered for marker in AUTH_MARKERS)
+
+
+def run_profile(profile: SmokeProfile, *, timeout_seconds: float = 180) -> SmokeResult:
+    """Run one live adapter in an isolated temporary repository."""
+    with tempfile.TemporaryDirectory(prefix=f"prizmkit-{profile.name}-smoke-") as temp_dir:
+        root = Path(temp_dir)
+        subprocess.run(
+            ["git", "init", "-b", "main"],
+            cwd=root,
+            check=True,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+        )
+        prompt = root / "prompt.md"
+        prompt.write_text(smoke_prompt(), encoding="utf-8")
+        session_log = root / ".prizmkit" / "state" / "smoke" / "logs" / "session.log"
+        progress = session_log.with_name("progress.json")
+        result = AISessionLauncher(
+            AISessionConfig(
+                cli_command=profile.command,
+                platform=profile.platform,
+                model=None,
+                prompt_path=prompt,
+                cwd=root,
+                log_path=session_log,
+                progress_path=progress,
+                use_stream_json=True,
+                effort="low",
+                total_timeout_seconds=timeout_seconds,
+            )
+        ).run()
+        text = session_log.read_text(encoding="utf-8", errors="replace") if session_log.is_file() else ""
+        missing = [label for label in REQUIRED_LABELS if label not in text]
+        if _looks_capability_blocked(text):
+            return SmokeResult(
+                profile.name,
+                "skipped",
+                "authentication, model, quota, network, or account capability unavailable",
+                str(session_log),
+                result.exit_code,
+            )
+        if result.timed_out:
+            return SmokeResult(profile.name, "failed", "live smoke timed out without a capability-block marker", str(session_log), result.exit_code)
+        if result.exit_code not in (0, None):
+            return SmokeResult(profile.name, "failed", f"AI CLI exited with {result.exit_code}", str(session_log), result.exit_code)
+        if missing:
+            return SmokeResult(
+                profile.name,
+                "failed",
+                "missing normalized labels: " + ", ".join(missing),
+                str(session_log),
+                result.exit_code,
+            )
+        if "PRIZMKIT_SMOKE_TOOL_OK" not in text or "PRIZMKIT_SMOKE_FINAL_OK" not in text:
+            return SmokeResult(
+                profile.name,
+                "failed",
+                "tool or final-answer sentinel missing",
+                str(session_log),
+                result.exit_code,
+            )
+        return SmokeResult(profile.name, "passed", "normalized live tool session verified", str(session_log), result.exit_code)
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--run", action="store_true", help="authorize live AI CLI calls")
+    parser.add_argument("--only", action="append", default=[], help="run only a named installed example")
+    parser.add_argument("--timeout", type=float, default=180, help="per-profile timeout in seconds")
+    args = parser.parse_args(argv)
+
+    installed, results = discover_profiles()
+    selected = set(args.only)
+    if selected:
+        installed = [profile for profile in installed if profile.name in selected]
+        known = {profile.name for profile in installed} | {result.name for result in results}
+        for name in sorted(selected - known):
+            results.append(SmokeResult(name, "skipped", "unknown or unavailable profile example"))
+
+    authorized = args.run or os.environ.get("PRIZMKIT_RUN_LIVE_AI_SMOKE") == "1"
+    if not authorized:
+        results.extend(
+            SmokeResult(profile.name, "skipped", "live calls not authorized; pass --run or set PRIZMKIT_RUN_LIVE_AI_SMOKE=1")
+            for profile in installed
+        )
+    else:
+        results.extend(run_profile(profile, timeout_seconds=args.timeout) for profile in installed)
+
+    payload = {"results": [asdict(result) for result in sorted(results, key=lambda item: item.name)]}
+    print(json.dumps(payload, ensure_ascii=False, indent=2))
+    return 1 if any(result.status == "failed" for result in results) else 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/bundled/dev-pipeline/tests/test_python_runner_parity.py

@@ -2403,7 +2403,133 @@ def test_preflight_ready_commit_includes_tracked_state_but_excludes_untracked_st
     assert untracked_state.relative_to(tmp_path).as_posix() not in _head_files(tmp_path)
 
 
-def test_preflight_ready_commit_excludes_tracked_framework_manifest_but_preserves_other_tracked_support(tmp_path):
+def _track_manifest(project_root):
+    manifest_path = project_root / ".prizmkit" / "manifest.json"
+    manifest_path.parent.mkdir(parents=True, exist_ok=True)
+    manifest_path.write_text('{"version":"baseline"}\n', encoding="utf-8")
+    subprocess.run(["git", "add", ".prizmkit/manifest.json"], cwd=project_root, check=True)
+    subprocess.run(["git", "commit", "-m", "track manifest"], cwd=project_root, check=True, stdout=subprocess.DEVNULL)
+    return manifest_path
+
+
+@pytest.mark.parametrize(
+    ("scenario", "expected_content"),
+    [
+        ("staged_only", '{"version":"staged"}\n'),
+        ("unstaged_only", '{"version":"unstaged"}\n'),
+        ("staged_and_unstaged", '{"version":"working-tree"}\n'),
+    ],
+)
+def test_preflight_ready_commit_preserves_tracked_manifest_modification_state(tmp_path, scenario, expected_content):
+    from prizmkit_runtime.runner_bookkeeping import commit_preflight_ready_changes
+
+    _init_bookkeeping_repo(tmp_path)
+    manifest_path = _track_manifest(tmp_path)
+    if scenario == "staged_only":
+        manifest_path.write_text(expected_content, encoding="utf-8")
+        subprocess.run(["git", "add", ".prizmkit/manifest.json"], cwd=tmp_path, check=True)
+    elif scenario == "unstaged_only":
+        manifest_path.write_text(expected_content, encoding="utf-8")
+    else:
+        manifest_path.write_text('{"version":"index"}\n', encoding="utf-8")
+        subprocess.run(["git", "add", ".prizmkit/manifest.json"], cwd=tmp_path, check=True)
+        manifest_path.write_text(expected_content, encoding="utf-8")
+
+    before_count = _head_commit_count(tmp_path)
+    result = commit_preflight_ready_changes(tmp_path, "F-003")
+    committed_content = subprocess.run(
+        ["git", "show", "HEAD:.prizmkit/manifest.json"],
+        cwd=tmp_path,
+        check=True,
+        stdout=subprocess.PIPE,
+        text=True,
+    ).stdout
+
+    assert result.attempted is True
+    assert result.committed is True
+    assert _head_commit_count(tmp_path) == before_count + 1
+    assert _head_message(tmp_path) == "chore: ready for F-003"
+    assert _head_files(tmp_path) == {".prizmkit/manifest.json"}
+    assert committed_content == expected_content
+    assert subprocess.run(
+        ["git", "status", "--short", "--untracked-files=no"],
+        cwd=tmp_path,
+        check=True,
+        stdout=subprocess.PIPE,
+        text=True,
+    ).stdout == ""
+
+
+@pytest.mark.parametrize("staged", [False, True])
+def test_preflight_ready_commit_preserves_tracked_manifest_deletion(tmp_path, staged):
+    from prizmkit_runtime.runner_bookkeeping import commit_preflight_ready_changes
+
+    _init_bookkeeping_repo(tmp_path)
+    manifest_path = _track_manifest(tmp_path)
+    manifest_path.unlink()
+    if staged:
+        subprocess.run(["git", "add", "-u", "--", ".prizmkit/manifest.json"], cwd=tmp_path, check=True)
+    (tmp_path / "unstaged.txt").write_text("coexisting tracked change\n", encoding="utf-8")
+    (tmp_path / "coexisting.txt").write_text("coexisting untracked change\n", encoding="utf-8")
+
+    before_count = _head_commit_count(tmp_path)
+    result = commit_preflight_ready_changes(tmp_path, "B-003")
+    manifest_at_head = subprocess.run(
+        ["git", "cat-file", "-e", "HEAD:.prizmkit/manifest.json"],
+        cwd=tmp_path,
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL,
+    )
+
+    assert result.attempted is True
+    assert result.committed is True
+    assert _head_commit_count(tmp_path) == before_count + 1
+    assert _head_message(tmp_path) == "chore: ready for B-003"
+    assert _head_files(tmp_path) == {".prizmkit/manifest.json", "coexisting.txt", "unstaged.txt"}
+    assert manifest_at_head.returncode != 0
+    assert subprocess.run(
+        ["git", "status", "--short", "--untracked-files=all"],
+        cwd=tmp_path,
+        check=True,
+        stdout=subprocess.PIPE,
+        text=True,
+    ).stdout == ""
+
+
+@pytest.mark.parametrize(
+    ("payload", "expected_error"),
+    [
+        ("{not-json\n", "not valid JSON"),
+        ("[]\n", "not a JSON object"),
+    ],
+)
+def test_preflight_ready_commit_rejects_unsafe_tracked_manifest_before_any_commit(tmp_path, payload, expected_error):
+    from prizmkit_runtime.runner_bookkeeping import commit_preflight_ready_changes
+
+    _init_bookkeeping_repo(tmp_path)
+    manifest_path = _track_manifest(tmp_path)
+    manifest_path.write_text(payload, encoding="utf-8")
+    (tmp_path / "eligible.txt").write_text("must remain uncommitted\n", encoding="utf-8")
+    before_count = _head_commit_count(tmp_path)
+
+    result = commit_preflight_ready_changes(tmp_path, "R-003")
+
+    assert result.attempted is True
+    assert result.committed is False
+    assert result.result is not None
+    assert expected_error in result.result.stderr
+    assert _head_commit_count(tmp_path) == before_count
+    assert "eligible.txt" not in _head_files(tmp_path)
+    assert subprocess.run(
+        ["git", "status", "--short", "--untracked-files=all"],
+        cwd=tmp_path,
+        check=True,
+        stdout=subprocess.PIPE,
+        text=True,
+    ).stdout.splitlines() == [" M .prizmkit/manifest.json", "?? eligible.txt"]
+
+
+def test_preflight_ready_commit_preserves_tracked_manifest_with_other_tracked_support(tmp_path):
     from prizmkit_runtime.runner_bookkeeping import commit_preflight_ready_changes
 
     _init_bookkeeping_repo(tmp_path)
@@ -2417,8 +2543,9 @@ def test_preflight_ready_commit_excludes_tracked_framework_manifest_but_preserve
     for path in tracked_support_paths:
         path.parent.mkdir(parents=True, exist_ok=True)
         path.write_text("installed\n", encoding="utf-8")
+    tracked_paths = [manifest_path, *tracked_support_paths]
     subprocess.run(
-        ["git", "add", manifest_path.relative_to(tmp_path).as_posix(), *(path.relative_to(tmp_path).as_posix() for path in tracked_support_paths)],
+        ["git", "add", *(path.relative_to(tmp_path).as_posix() for path in tracked_paths)],
         cwd=tmp_path,
         check=True,
     )
@@ -2426,6 +2553,8 @@ def test_preflight_ready_commit_excludes_tracked_framework_manifest_but_preserve
     manifest_path.write_text('{"version":"1.1.128"}\n', encoding="utf-8")
     for path in tracked_support_paths:
         path.write_text("upgraded\n", encoding="utf-8")
+    visible_path = tmp_path / "visible.txt"
+    visible_path.write_text("eligible untracked change\n", encoding="utf-8")
 
     untracked_support_paths = [
         tmp_path / ".claude" / "settings.local.json",
@@ -2436,24 +2565,66 @@ def test_preflight_ready_commit_excludes_tracked_framework_manifest_but_preserve
         path.parent.mkdir(parents=True, exist_ok=True)
         path.write_text("transient\n", encoding="utf-8")
 
+    before_count = _head_commit_count(tmp_path)
     result = commit_preflight_ready_changes(tmp_path, "B-001")
 
     assert result.attempted is True
-    assert result.committed is False
-    assert result.result is not None
-    assert "installer-owned .prizmkit/manifest.json" in result.result.stderr
-    assert _head_message(tmp_path) == "track support"
+    assert result.committed is True
+    assert _head_commit_count(tmp_path) == before_count + 1
+    assert _head_message(tmp_path) == "chore: ready for B-001"
+    assert _head_files(tmp_path) == {
+        *(path.relative_to(tmp_path).as_posix() for path in tracked_paths),
+        visible_path.relative_to(tmp_path).as_posix(),
+    }
     assert subprocess.run(
         ["git", "status", "--short", "--untracked-files=no"],
         cwd=tmp_path,
         check=True,
         stdout=subprocess.PIPE,
         text=True,
-    ).stdout.splitlines() == [
-        " M .claude/commands/prizmkit.md",
-        " M .prizmkit/dev-pipeline/prizmkit_runtime/runners.py",
-        " M .prizmkit/manifest.json",
-    ]
+    ).stdout == ""
+
+
+def test_preflight_manifest_deletion_is_absent_from_linked_worktree_created_from_updated_head(tmp_path):
+    from prizmkit_runtime.gitops import (
+        BranchContext,
+        WorktreePolicy,
+        ensure_linked_worktree,
+        guarded_worktree_remove,
+        worktree_runtime_context,
+    )
+    from prizmkit_runtime.runner_bookkeeping import commit_preflight_ready_changes
+
+    _init_bookkeeping_repo(tmp_path)
+    manifest_path = _track_manifest(tmp_path)
+    manifest_path.unlink()
+
+    result = commit_preflight_ready_changes(tmp_path, "B-003")
+    runtime = worktree_runtime_context(
+        BranchContext("main", "bugfix/B-003-ready", tmp_path),
+        WorktreePolicy(
+            use_worktree=True,
+            cleanup_on_success=True,
+            preserve_on_failure=True,
+            worktree_root=tmp_path.parent / f"{tmp_path.name}-worktrees",
+        ),
+    )
+    setup = ensure_linked_worktree(runtime)
+
+    assert result.committed is True
+    assert setup.ok
+    try:
+        assert not manifest_path.exists()
+        assert not (runtime.worktree_path / ".prizmkit" / "manifest.json").exists()
+        assert subprocess.run(
+            ["git", "status", "--short", "--untracked-files=no"],
+            cwd=tmp_path,
+            check=True,
+            stdout=subprocess.PIPE,
+            text=True,
+        ).stdout == ""
+    finally:
+        assert guarded_worktree_remove(runtime).ok
 
 
 def test_preflight_ready_commit_excludes_untracked_support_assets_and_state(tmp_path):
@@ -2571,6 +2742,8 @@ def test_process_item_creates_one_ready_commit_before_branch_setup_for_all_famil
 
     paths = _make_paths(tmp_path / kind)
     _init_bookkeeping_repo(paths.project_root)
+    manifest_path = _track_manifest(paths.project_root)
+    manifest_path.write_text('{"version":"ready"}\n', encoding="utf-8")
     (paths.project_root / "staged.txt").write_text("staged before run\n", encoding="utf-8")
     subprocess.run(["git", "add", "staged.txt"], cwd=paths.project_root, check=True)
     (paths.project_root / "unstaged.txt").write_text("unstaged before run\n", encoding="utf-8")
@@ -2591,6 +2764,13 @@ def test_process_item_creates_one_ready_commit_before_branch_setup_for_all_famil
                 {
                     "commit_count": _head_commit_count(project_root),
                     "message": _head_message(project_root),
+                    "manifest_content": subprocess.run(
+                        ["git", "show", "HEAD:.prizmkit/manifest.json"],
+                        cwd=project_root,
+                        check=True,
+                        stdout=subprocess.PIPE,
+                        text=True,
+                    ).stdout,
                     "visible_status": subprocess.run(
                         ["git", "status", "--porcelain", "--", ".", *HIDDEN_TOOL_WORKTREE_EXCLUDES],
                         cwd=project_root,
@@ -2611,11 +2791,14 @@ def test_process_item_creates_one_ready_commit_before_branch_setup_for_all_famil
         {
             "commit_count": before_count + 1,
             "message": f"chore: ready for {item_id}",
+            "manifest_content": '{"version":"ready"}\n',
             "visible_status": "",
         }
     ]
     assert _head_commit_count(paths.project_root) == before_count + 1
-    assert {"staged.txt", "unstaged.txt", "untracked.txt"}.issubset(_head_files(paths.project_root))
+    assert {".prizmkit/manifest.json", "staged.txt", "unstaged.txt", "untracked.txt"}.issubset(
+        _head_files(paths.project_root)
+    )
 
 
 
@@ -2811,6 +2994,90 @@ def test_classification_accepts_late_infra_error_with_completed_checkpoint_and_c
     assert classification.reason == "semantic_checkpoint_with_late_runtime_error"
 
 
+def test_classification_accepts_final_success_after_internal_stream_retry(tmp_path):
+    import importlib.util
+
+    from prizmkit_runtime.runner_classification import classify_session
+    from prizmkit_runtime.runner_models import PromptGenerationResult
+    from prizmkit_runtime.sessions import AISessionCommand, AISessionResult
+    from prizmkit_runtime.status import ProgressSummary
+
+    subprocess.run(["git", "init", "-b", "main"], cwd=tmp_path, check=True, stdout=subprocess.DEVNULL)
+    subprocess.run(["git", "config", "user.email", "test@example.com"], cwd=tmp_path, check=True)
+    subprocess.run(["git", "config", "user.name", "Test"], cwd=tmp_path, check=True)
+    (tmp_path / "base.txt").write_text("base", encoding="utf-8")
+    subprocess.run(["git", "add", "base.txt"], cwd=tmp_path, check=True)
+    subprocess.run(["git", "commit", "-m", "base"], cwd=tmp_path, check=True, stdout=subprocess.DEVNULL)
+    base_head = subprocess.run(
+        ["git", "rev-parse", "HEAD"],
+        cwd=tmp_path,
+        check=True,
+        stdout=subprocess.PIPE,
+        text=True,
+    ).stdout.strip()
+    artifact_dir = tmp_path / ".prizmkit" / "bugfix" / "B-004"
+    checkpoint = _write_semantic_completion_checkpoint(tmp_path, artifact_dir, "bugfix-pipeline")
+
+    parser_path = PIPELINE_ROOT / "scripts" / "parse-stream-progress.py"
+    spec = importlib.util.spec_from_file_location("retry_progress_parser", parser_path)
+    module = importlib.util.module_from_spec(spec)
+    assert spec.loader is not None
+    spec.loader.exec_module(module)
+    tracker = module.ProgressTracker()
+    events = [
+        {"type": "session", "id": "pi-session"},
+        {"type": "agent_start"},
+        {"type": "message_end", "message": {"role": "assistant", "content": [], "stopReason": "error", "errorMessage": "Error Code internal_server_error: unexpected EOF"}},
+        {"type": "agent_end", "willRetry": True, "messages": []},
+        {"type": "auto_retry_start", "attempt": 1, "errorMessage": "Error Code internal_server_error: unexpected EOF"},
+        {"type": "agent_start"},
+        {"type": "auto_retry_end", "attempt": 1},
+        {"type": "message_end", "message": {"role": "assistant", "content": [{"type": "text", "text": "WORKFLOW_COMPLETED"}], "stopReason": "stop"}},
+        {"type": "agent_end", "willRetry": False, "messages": [{"role": "assistant", "content": [{"type": "text", "text": "WORKFLOW_COMPLETED"}], "stopReason": "stop"}]},
+    ]
+    for event in events:
+        tracker.process_event(event)
+    data = tracker.to_dict()
+    log = tmp_path / "session.log"
+    log.write_text("[ERROR] transient unexpected EOF\n[SESSION_END] status=success\n", encoding="utf-8")
+    raw = AISessionResult(
+        command=AISessionCommand(("fake",), None, "custom", "stdin"),
+        exit_code=0,
+        timed_out=False,
+        termination_reason=None,
+        stale_marker=None,
+        fatal_error_code=str(data.get("fatal_error_code") or ""),
+        progress_summary=ProgressSummary(
+            result_subtype=str(data.get("result_subtype") or ""),
+            stop_reason=str(data.get("stop_reason") or ""),
+            fatal_error_code=str(data.get("fatal_error_code") or ""),
+            terminal_result_text=str(data.get("terminal_result_text") or ""),
+            errors=tuple(str(item) for item in data.get("errors", [])),
+        ),
+        session_log=log,
+        backup_log=tmp_path / "backup.log",
+        log_recovery=None,
+        started_epoch=0,
+        ended_epoch=1,
+    )
+
+    classification = classify_session(
+        raw,
+        project_root=tmp_path,
+        base_head=base_head,
+        prompt=PromptGenerationResult(
+            output_path=tmp_path / "prompt.md",
+            checkpoint_path=checkpoint,
+            artifact_path=artifact_dir,
+        ),
+    )
+
+    assert data["last_result_is_error"] is False
+    assert any("unexpected EOF" in str(error) for error in data["errors"])
+    assert classification.session_status == "success"
+    assert classification.reason == "terminal_success_with_semantic_checkpoint"
+
+
 def test_classification_rejects_late_infra_with_completion_summary_only(tmp_path):
     from prizmkit_runtime.runner_classification import classify_session
     from prizmkit_runtime.runner_models import PromptGenerationResult