prizmkit 1.1.145 → 1.1.146

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

@@ -994,6 +994,328 @@ def test_progress_parser_does_not_mark_failed_pi_agent_end_as_success():
     assert "provider request failed" in data["errors"]
 
 
+def test_progress_parser_recovers_from_retrying_pi_attempt_before_final_success():
+    module = _load_progress_parser_module()
+    tracker = module.ProgressTracker()
+    tracker.process_event({"type": "session", "version": 3, "id": "pi-session", "cwd": "/tmp/project"})
+    tracker.process_event({"type": "agent_start"})
+    tracker.process_event({
+        "type": "message_end",
+        "message": {
+            "role": "assistant",
+            "content": [],
+            "stopReason": "error",
+            "errorMessage": "Error Code internal_server_error: unexpected EOF",
+        },
+    })
+    tracker.process_event({"type": "agent_end", "willRetry": True, "messages": []})
+    tracker.process_event({
+        "type": "auto_retry_start",
+        "attempt": 1,
+        "delayMs": 2000,
+        "errorMessage": "Error Code internal_server_error: unexpected EOF",
+    })
+    tracker.process_event({"type": "agent_start"})
+    tracker.process_event({"type": "auto_retry_end", "attempt": 1})
+    tracker.process_event({
+        "type": "message_end",
+        "message": {
+            "role": "assistant",
+            "content": [{"type": "text", "text": "WORKFLOW_COMPLETED"}],
+            "stopReason": "stop",
+        },
+    })
+    tracker.process_event({
+        "type": "agent_end",
+        "willRetry": False,
+        "messages": [{
+            "role": "assistant",
+            "content": [{"type": "text", "text": "WORKFLOW_COMPLETED"}],
+            "stopReason": "stop",
+        }],
+    })
+
+    data = tracker.to_dict()
+
+    assert data["result_subtype"] == "success"
+    assert data["last_result_is_error"] is False
+    assert data["stop_reason"] == "stop"
+    assert data["fatal_error_code"] == ""
+    assert data["terminal_success_at"]
+    assert any("unexpected EOF" in str(error) for error in data["errors"])
+
+
+def test_progress_parser_keeps_final_error_after_internal_retry_exhausts():
+    module = _load_progress_parser_module()
+    tracker = module.ProgressTracker()
+    tracker.process_event({"type": "session", "id": "pi-session"})
+    tracker.process_event({"type": "agent_start"})
+    tracker.process_event({
+        "type": "message_end",
+        "message": {"role": "assistant", "content": [], "stopReason": "error", "errorMessage": "temporary error"},
+    })
+    tracker.process_event({"type": "agent_end", "willRetry": True, "messages": []})
+    tracker.process_event({"type": "auto_retry_start", "attempt": 1, "errorMessage": "temporary error"})
+    tracker.process_event({"type": "agent_start"})
+    tracker.process_event({
+        "type": "message_end",
+        "message": {"role": "assistant", "content": [], "stopReason": "error", "errorMessage": "final error"},
+    })
+    tracker.process_event({
+        "type": "agent_end",
+        "willRetry": False,
+        "messages": [{"role": "assistant", "content": [], "stopReason": "error", "errorMessage": "final error"}],
+    })
+
+    data = tracker.to_dict()
+
+    assert data["result_subtype"] == "error"
+    assert data["last_result_is_error"] is True
+    assert data["stop_reason"] == "error"
+    assert data["terminal_success_at"] == ""
+    assert "final error" in data["terminal_result_text"]
+
+
+def test_progress_parser_clears_retrying_fatal_marker_on_new_pi_attempt():
+    module = _load_progress_parser_module()
+    tracker = module.ProgressTracker()
+    tracker.process_event({"type": "session", "id": "pi-session"})
+    tracker.process_event({"type": "agent_start"})
+    tracker.process_event({
+        "type": "message_end",
+        "message": {
+            "role": "assistant",
+            "content": [],
+            "stopReason": "error",
+            "errorMessage": "API Error: Your input exceeds the context window",
+        },
+    })
+    tracker.process_event({"type": "agent_end", "willRetry": True, "messages": []})
+    failed_attempt = tracker.to_dict()
+
+    tracker.process_event({"type": "agent_start"})
+    next_attempt = tracker.to_dict()
+
+    assert failed_attempt["fatal_error_code"] == "context_overflow"
+    assert failed_attempt["last_result_is_error"] is True
+    assert next_attempt["fatal_error_code"] == ""
+    assert next_attempt["result_subtype"] == ""
+    assert next_attempt["last_result_is_error"] is False
+    assert any("context window" in str(error) for error in next_attempt["errors"])
+    assert next_attempt["is_active"] is True
+
+
+def test_semantic_log_normalizer_compacts_pi_cumulative_stream():
+    module = _load_progress_parser_module()
+    normalizer = module.SemanticLogNormalizer()
+    events = [
+        {"type": "session", "id": "session-1"},
+        {"type": "message_start", "message": {"role": "user"}},
+        {"type": "message_end", "message": {"role": "user", "content": [{"type": "text", "text": "SECRET PROMPT"}]}},
+        {"type": "turn_start"},
+        {"type": "message_update", "assistantMessageEvent": {"type": "thinking_start", "contentIndex": 0}},
+        {"type": "message_update", "assistantMessageEvent": {"type": "thinking_delta", "contentIndex": 0, "delta": "Inspecting"}},
+        {"type": "message_update", "assistantMessageEvent": {"type": "thinking_delta", "contentIndex": 0, "delta": " state"}},
+        {"type": "message_update", "assistantMessageEvent": {"type": "thinking_end", "contentIndex": 0, "content": "Inspecting state"}},
+        {"type": "tool_execution_start", "toolCallId": "call-1", "toolName": "bash", "args": {"command": "printf ABC"}},
+        {"type": "tool_execution_update", "toolCallId": "call-1", "toolName": "bash", "partialResult": {"content": [{"type": "text", "text": "A"}]}},
+        {"type": "tool_execution_update", "toolCallId": "call-1", "toolName": "bash", "partialResult": {"content": [{"type": "text", "text": "AB"}]}},
+        {"type": "tool_execution_update", "toolCallId": "call-1", "toolName": "bash", "partialResult": {"content": [{"type": "text", "text": "ABC"}]}},
+        {"type": "tool_execution_end", "toolCallId": "call-1", "toolName": "bash", "result": {"content": [{"type": "text", "text": "ABC"}]}, "isError": False},
+        {"type": "message_start", "message": {"role": "toolResult"}},
+        {"type": "message_end", "message": {"role": "toolResult", "toolCallId": "call-1", "toolName": "bash", "content": [{"type": "text", "text": "ABC"}]}},
+        {"type": "message_update", "assistantMessageEvent": {"type": "text_start", "contentIndex": 1}},
+        {"type": "message_update", "assistantMessageEvent": {"type": "text_delta", "contentIndex": 1, "delta": "Done"}},
+        {"type": "message_update", "assistantMessageEvent": {"type": "text_end", "contentIndex": 1, "content": "Done"}},
+        {"type": "message_end", "message": {"role": "assistant", "content": [{"type": "text", "text": "Done"}], "stopReason": "stop"}},
+        {"type": "turn_end", "message": {"role": "assistant", "content": [{"type": "text", "text": "Done"}], "stopReason": "stop"}},
+        {"type": "agent_end", "willRetry": False, "messages": [{"role": "assistant", "content": [{"type": "text", "text": "Done"}], "stopReason": "stop"}]},
+        {"type": "agent_settled"},
+    ]
+
+    rendered = "".join(normalizer.process_event(event) for event in events) + normalizer.finish()
+
+    assert rendered.count("[THINK]") == 1
+    assert "[THINK] Inspecting state\n" in rendered
+    assert rendered.count("[ACTION]") == 1
+    assert "bash" in rendered and "printf ABC" in rendered
+    assert rendered.count("[OBSERVATION]") == 1
+    assert "[OBSERVATION] ABC\n" in rendered
+    assert rendered.count("[FINAL]") == 1
+    assert "[FINAL] Done\n" in rendered
+    assert rendered.count("[SESSION_END]") == 1
+    assert "message_update" not in rendered
+    assert "SECRET PROMPT" not in rendered
+
+
+def test_semantic_log_normalizer_ignores_user_prompt_but_keeps_nested_tool_results():
+    module = _load_progress_parser_module()
+    normalizer = module.SemanticLogNormalizer()
+    rendered = normalizer.process_event({
+        "type": "user",
+        "message": {
+            "content": [
+                {"type": "text", "text": "SECRET PROMPT"},
+                {"type": "tool_result", "tool_use_id": "tool-1", "content": "tool output"},
+            ]
+        },
+    })
+    rendered += normalizer.finish()
+
+    assert "SECRET PROMPT" not in rendered
+    assert "[OBSERVATION] tool output" in rendered
+
+
+def test_semantic_log_normalizer_preserves_repeated_plain_and_tool_output_records():
+    module = _load_progress_parser_module()
+    normalizer = module.SemanticLogNormalizer()
+    rendered = normalizer.process_text("same\n")
+    rendered += normalizer.process_text("same\n")
+    rendered += normalizer.process_event({"type": "function_call_result", "id": "one", "output": "same result"})
+    rendered += normalizer.process_event({"type": "function_call_result", "id": "two", "output": "same result"})
+    rendered += normalizer.finish()
+
+    assert rendered.count("[OUTPUT] same") == 2
+    assert rendered.count("[OBSERVATION] same result") == 2
+
+
+def test_semantic_log_normalizer_emits_terminal_metadata_once():
+    module = _load_progress_parser_module()
+    normalizer = module.SemanticLogNormalizer()
+    rendered = normalizer.process_event({"type": "turn.completed"})
+    rendered += normalizer.process_event({"type": "result", "subtype": "success", "result": "Done"})
+    rendered += normalizer.finish()
+
+    assert rendered.count("[SESSION_END]") == 1
+    assert "[FINAL] Done" in rendered
+
+
+def test_semantic_log_normalizer_preserves_identical_text_from_distinct_turns():
+    module = _load_progress_parser_module()
+    normalizer = module.SemanticLogNormalizer()
+    events = [
+        {"type": "turn_start"},
+        {"type": "message_end", "message": {"role": "assistant", "content": [{"type": "text", "text": "Done"}], "stopReason": "stop"}},
+        {"type": "turn_start"},
+        {"type": "message_end", "message": {"role": "assistant", "content": [{"type": "text", "text": "Done"}], "stopReason": "stop"}},
+    ]
+
+    rendered = "".join(normalizer.process_event(event) for event in events) + normalizer.finish()
+
+    assert rendered.count("[FINAL] Done") == 2
+
+
+def test_semantic_log_normalizer_size_tracks_unique_cumulative_content():
+    module = _load_progress_parser_module()
+    normalizer = module.SemanticLogNormalizer()
+    chunks = []
+    payload = ""
+    chunks.append(normalizer.process_event({"type": "tool_execution_start", "toolCallId": "call-1", "toolName": "read", "args": {"path": "sample"}}))
+    for index in range(1, 501):
+        payload += chr(64 + ((index - 1) % 26) + 1)
+        chunks.append(normalizer.process_event({
+            "type": "tool_execution_update",
+            "toolCallId": "call-1",
+            "toolName": "read",
+            "partialResult": {"content": [{"type": "text", "text": payload}]},
+        }))
+    assert sum(len(value) for value in normalizer._snapshots.values()) == len(payload)
+    assert not any(stream_id.startswith("tool:call-1:output") for stream_id in normalizer._stream_buffers)
+    chunks.append(normalizer.process_event({
+        "type": "tool_execution_end",
+        "toolCallId": "call-1",
+        "toolName": "read",
+        "result": {"content": [{"type": "text", "text": payload}]},
+        "isError": False,
+    }))
+    rendered = "".join(chunks) + normalizer.finish()
+
+    assert rendered.count(payload) == 1
+    assert len(rendered.encode("utf-8")) <= len(payload.encode("utf-8")) + 256
+
+
+@pytest.mark.parametrize(
+    ("events", "expected_labels"),
+    [
+        (
+            [
+                {"type": "assistant", "message": {"content": [{"type": "text", "text": "Answer"}, {"type": "tool_use", "id": "tool-1", "name": "Read", "input": {"path": "a"}}]}},
+                {"type": "user", "message": {"content": [{"type": "tool_result", "tool_use_id": "tool-1", "content": "result"}]}},
+                {"type": "result", "subtype": "success", "stop_reason": "end_turn", "result": "Answer"},
+            ],
+            {"[FINAL]", "[ACTION]", "[OBSERVATION]", "[SESSION_END]"},
+        ),
+        (
+            [
+                {"type": "message", "sessionId": "cb-1", "role": "assistant", "content": [{"type": "text", "text": "Answer"}]},
+                {"type": "function_call", "sessionId": "cb-1", "id": "call-1", "name": "read", "arguments": "{\"path\":\"a\"}"},
+                {"type": "function_call_result", "sessionId": "cb-1", "id": "call-1", "output": "result"},
+                {"type": "result", "subtype": "success", "result": "Answer"},
+            ],
+            {"[FINAL]", "[ACTION]", "[OBSERVATION]", "[SESSION_END]"},
+        ),
+        (
+            [
+                {"type": "turn.started"},
+                {"type": "item.completed", "item": {"id": "reason-1", "type": "reasoning", "text": "Think"}},
+                {"type": "item.started", "item": {"id": "cmd-1", "type": "command_execution", "command": "printf result"}},
+                {"type": "item.completed", "item": {"id": "cmd-1", "type": "command_execution", "command": "printf result", "aggregated_output": "result", "status": "completed"}},
+                {"type": "item.completed", "item": {"id": "answer-1", "type": "agent_message", "text": "Answer"}},
+                {"type": "turn.completed", "usage": {"input_tokens": 1}},
+            ],
+            {"[THINK]", "[FINAL]", "[ACTION]", "[OBSERVATION]", "[SESSION_END]"},
+        ),
+    ],
+)
+def test_semantic_log_normalizer_has_cross_format_contract(events, expected_labels):
+    module = _load_progress_parser_module()
+    normalizer = module.SemanticLogNormalizer()
+
+    rendered = "".join(normalizer.process_event(event) for event in events) + normalizer.finish()
+
+    for label in expected_labels:
+        assert label in rendered
+    assert not any(json.dumps(event, ensure_ascii=False) in rendered for event in events)
+
+
+def test_live_smoke_harness_reports_capability_skips_without_running(tmp_path, monkeypatch, capsys):
+    import importlib.util
+
+    script = PIPELINE_ROOT / "tests" / "live_ai_cli_log_smoke.py"
+    spec = importlib.util.spec_from_file_location("live_ai_cli_log_smoke_test", script)
+    module = importlib.util.module_from_spec(spec)
+    assert spec.loader is not None
+    sys.modules[spec.name] = module
+    try:
+        spec.loader.exec_module(module)
+    finally:
+        sys.modules.pop(spec.name, None)
+
+    fake_command = tmp_path / "fake-cli"
+    fake_command.write_text("#!/bin/sh\nexit 0\n", encoding="utf-8")
+    fake_command.chmod(0o755)
+    profile = module.SmokeProfile("example", str(fake_command), "custom")
+    monkeypatch.setattr(module, "discover_profiles", lambda: ([profile], [module.SmokeResult("missing", "skipped", "executable not found")]))
+    monkeypatch.delenv("PRIZMKIT_RUN_LIVE_AI_SMOKE", raising=False)
+
+    code = module.main([])
+    payload = json.loads(capsys.readouterr().out)
+
+    assert code == 0
+    assert {item["name"]: item["status"] for item in payload["results"]} == {
+        "example": "skipped",
+        "missing": "skipped",
+    }
+    reasons = {item["name"]: item["reason"] for item in payload["results"]}
+    assert "not authorized" in reasons["example"]
+    assert "executable not found" in reasons["missing"]
+    assert "Do not read, create, edit, or delete project files" in module.smoke_prompt()
+    assert module._looks_capability_blocked("login required") is True
+    assert module._looks_capability_blocked("network is unreachable") is True
+    assert module._looks_capability_blocked("model not found") is True
+    assert module._looks_capability_blocked("ordinary tool failure") is False
+
+
 def test_progress_parser_normalizes_claude_subagents_without_double_counting(tmp_path):
     module = _load_progress_parser_module()
     tracker = module.ProgressTracker()
@@ -1090,10 +1412,14 @@ def test_progress_parser_normalizes_codex_collab_metadata_with_missing_fields():
         },
     })
     tracker.process_event({"type": "item.completed", "item": {"type": "collab_tool_call", "tool": "delegate"}})
+    tracker.process_event({"type": "turn.completed", "usage": {"input_tokens": 1}})
 
     data = tracker.to_dict()
 
     assert data["event_format"] == "codex-json"
+    assert data["result_subtype"] == "success"
+    assert data["stop_reason"] == "completed"
+    assert data["is_active"] is False
     assert data["child_thread_ids"] == ["thread-a", "thread-b"]
     assert data["subagent_spawn_count"] == 2
     assert data["active_subagent_count"] == 1
@@ -1184,6 +1510,135 @@ def test_session_dual_writes_progress_and_recovers_backup(tmp_path):
     assert second_log.read_text(encoding="utf-8") == "larger recovered log"
 
 
+def test_session_reader_does_not_retain_or_reread_raw_history():
+    import inspect
+    import prizmkit_runtime.sessions as sessions
+
+    reader_source = inspect.getsource(sessions._reader_thread)
+    run_source = inspect.getsource(sessions.AISessionLauncher.run)
+
+    assert "lines.append" not in reader_source
+    assert "output_queue" not in reader_source
+    assert "session_log.read_text" not in run_source
+    assert "splitlines()" not in run_source
+    assert "maxsize=1" in run_source
+
+
+def test_session_reader_contains_parser_failures_and_continues_draining(tmp_path, monkeypatch):
+    import io
+    import queue
+    import prizmkit_runtime.sessions as sessions
+
+    class FailingTracker:
+        def __init__(self, _session_log):
+            pass
+
+        def process_event(self, _event):
+            raise ValueError("unsupported shape")
+
+        def to_dict(self):
+            return {"event_type_counts": {}, "errors": []}
+
+    class FailingNormalizer:
+        def process_event(self, _event):
+            raise ValueError("unsupported shape")
+
+        def process_text(self, text):
+            return f"[OUTPUT] {text.strip()}\n"
+
+        def finish(self):
+            return "[SESSION_END] status=stream_closed\n"
+
+    monkeypatch.setattr(sessions, "_load_stream_parser_classes", lambda: (FailingTracker, FailingNormalizer))
+    session_log = tmp_path / "session.log"
+    backup_log = tmp_path / "backup.log"
+    session_log.write_text("", encoding="utf-8")
+    backup_log.write_text("", encoding="utf-8")
+    result_queue = queue.Queue(maxsize=1)
+    pipe = io.StringIO('{"type":"result","subtype":"success","result":"done"}\nplain\n')
+
+    sessions._reader_thread(pipe, session_log, backup_log, result_queue)
+
+    text = session_log.read_text(encoding="utf-8")
+    assert "[ERROR] progress parser rejected event=result: ValueError" in text
+    assert "[ERROR] semantic log adapter rejected event=result: ValueError" in text
+    assert "[OUTPUT] done" in text
+    assert "[OUTPUT] plain" in text
+    assert "[SESSION_END] status=stream_closed" in text
+    assert backup_log.read_text(encoding="utf-8") == text
+    assert result_queue.get_nowait()["event_type_counts"] == {}
+
+
+def test_session_persists_normalized_stream_without_raw_history(tmp_path, monkeypatch):
+    import prizmkit_runtime.sessions as sessions
+
+    fake_cli = tmp_path / "pi_like_cli.py"
+    fake_cli.write_text(
+        "#!/usr/bin/env python3\n"
+        "import json, sys\n"
+        "_prompt = sys.stdin.read()\n"
+        "events = [\n"
+        " {'type':'session','id':'s1'},\n"
+        " {'type':'agent_start'},\n"
+        " {'type':'turn_start'},\n"
+        " {'type':'message_update','assistantMessageEvent':{'type':'thinking_start','contentIndex':0}},\n"
+        " {'type':'message_update','assistantMessageEvent':{'type':'thinking_delta','contentIndex':0,'delta':'Think'}},\n"
+        " {'type':'message_update','assistantMessageEvent':{'type':'thinking_end','contentIndex':0,'content':'Think'}},\n"
+        " {'type':'tool_execution_start','toolCallId':'c1','toolName':'bash','args':{'command':'printf ABC'}},\n"
+        " {'type':'tool_execution_update','toolCallId':'c1','toolName':'bash','partialResult':{'content':[{'type':'text','text':'A'}]}},\n"
+        " {'type':'tool_execution_update','toolCallId':'c1','toolName':'bash','partialResult':{'content':[{'type':'text','text':'ABC'}]}},\n"
+        " {'type':'tool_execution_end','toolCallId':'c1','toolName':'bash','result':{'content':[{'type':'text','text':'ABC'}]},'isError':False},\n"
+        " {'type':'message_update','assistantMessageEvent':{'type':'text_start','contentIndex':1}},\n"
+        " {'type':'message_update','assistantMessageEvent':{'type':'text_delta','contentIndex':1,'delta':'Done'}},\n"
+        " {'type':'message_update','assistantMessageEvent':{'type':'text_end','contentIndex':1,'content':'Done'}},\n"
+        " {'type':'message_end','message':{'role':'assistant','content':[{'type':'text','text':'Done'}],'stopReason':'stop'}},\n"
+        " {'type':'agent_end','willRetry':False,'messages':[{'role':'assistant','content':[{'type':'text','text':'Done'}],'stopReason':'stop'}]},\n"
+        "]\n"
+        "for event in events: print(json.dumps(event), flush=True)\n",
+        encoding="utf-8",
+    )
+    fake_cli.chmod(0o755)
+    prompt = tmp_path / "prompt.md"
+    prompt.write_text("hello", encoding="utf-8")
+    session_log = tmp_path / "state" / "sessions" / "sess-normalized" / "logs" / "session.log"
+    backup_log = tmp_path / "home" / ".prizmkit" / "session-backups" / "sess-normalized.log"
+    progress = session_log.with_name("progress.json")
+    captured_backup = {}
+    original_recover = sessions.recover_session_log
+
+    def capture_recovery(primary, backup, min_size=1024):
+        captured_backup["text"] = backup.read_text(encoding="utf-8")
+        return original_recover(primary, backup, min_size)
+
+    monkeypatch.setattr(sessions, "recover_session_log", capture_recovery)
+    result = sessions.AISessionLauncher(
+        sessions.AISessionConfig(
+            cli_command=str(fake_cli),
+            platform="pi",
+            model=None,
+            prompt_path=prompt,
+            cwd=tmp_path,
+            log_path=session_log,
+            backup_log_path=backup_log,
+            progress_path=progress,
+        )
+    ).run()
+
+    text = session_log.read_text(encoding="utf-8")
+    assert result.exit_code == 0
+    assert result.progress_summary.result_subtype == "success"
+    assert "[THINK] Think" in text
+    assert "[ACTION] bash" in text
+    assert "[OBSERVATION] ABC" in text
+    assert "[FINAL] Done" in text
+    assert "[SESSION_END] status=success" in text
+    assert text.count("ABC") == 2  # one action argument and one observation
+    assert '"type": "message_update"' not in text
+    assert '"type":"message_update"' not in text
+    assert captured_backup["text"] == text
+    assert not backup_log.exists()
+
+
 def test_custom_session_launch_writes_existing_logs_and_progress(tmp_path):
     from prizmkit_runtime.launch_profiles import HeadlessLaunchProfile
     from prizmkit_runtime.sessions import AISessionConfig, AISessionLauncher

package/bundled/skills/_metadata.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.1.145",
+  "version": "1.1.146",
   "skills": {
     "prizmkit": {
       "description": "Framework introduction and navigation for the formal single-requirement lifecycle, project initialization, Prizm docs, and independent deployment.",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prizmkit",
-  "version": "1.1.145",
+  "version": "1.1.146",
   "description": "Create a new PrizmKit-powered project with clean initialization — no framework dev files, just what you need.",
   "type": "module",
   "bin": {