prizmkit 1.1.144 → 1.1.146

package/bundled/VERSION.json

@@ -1,5 +1,5 @@
 {
-  "frameworkVersion": "1.1.144",
-  "bundledAt": "2026-07-22T02:07:34.475Z",
-  "bundledFrom": "a2ab913"
+  "frameworkVersion": "1.1.146",
+  "bundledAt": "2026-07-23T01:20:01.078Z",
+  "bundledFrom": "248d714"
 }

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

@@ -43,10 +43,7 @@ class PreflightWorkspace:
 
     @property
     def preservable(self) -> tuple[str, ...]:
-        return _unique_paths(
-            path for path in (*self.tracked, *self.visible_untracked)
-            if path != PIPELINE_MANIFEST_PATH
-        )
+        return _unique_paths((*self.tracked, *self.visible_untracked))
 
 
 @dataclass(frozen=True)
@@ -95,6 +92,23 @@ def _literal_pathspecs(paths: Sequence[str]) -> tuple[str, ...]:
     return tuple(f":(top,literal){path}" for path in paths)
 
 
+def _preflight_add_paths(
+    project_root: Path,
+    paths: Sequence[str],
+) -> tuple[tuple[str, ...], GitCommandResult | None]:
+    """Skip paths already staged as deletions while retaining exact path handling."""
+    indexed_result = run_git_command(project_root, ("ls-files", "-z", "--", *_literal_pathspecs(paths)))
+    if indexed_result.return_code != 0:
+        return (), indexed_result
+    indexed = set(indexed_result.stdout.split("\0"))
+    add_paths = tuple(
+        path
+        for path in paths
+        if path in indexed or (project_root / path).exists() or (project_root / path).is_symlink()
+    )
+    return add_paths, None
+
+
 def _status_record_paths(stdout: str) -> tuple[str, ...]:
     """Decode exact paths from NUL-delimited porcelain-v1 records."""
     records = stdout.split("\0")
@@ -153,12 +167,6 @@ def _preflight_integrity_failure(project_root: Path, workspace: PreflightWorkspa
             return _preflight_failure(
                 f"Refusing to continue because {PIPELINE_MANIFEST_PATH} is not a JSON object"
             )
-    if PIPELINE_MANIFEST_PATH in workspace.tracked:
-        return _preflight_failure(
-            "Refusing to auto-commit installer-owned .prizmkit/manifest.json; "
-            "finish or revert the framework install/upgrade before starting a task"
-        )
-
     marker_paths = []
     for relative in workspace.preservable:
         path = project_root / relative
@@ -257,9 +265,13 @@ def commit_preflight_ready_changes(project_root: Path, item_id: str) -> Bookkeep
     if not paths:
         return BookkeepingResult(attempted=False, committed=False)
     pathspecs = _literal_pathspecs(paths)
-    add_result = run_git_command(project_root, ("add", "-A", "-f", "--", *pathspecs))
-    if add_result.return_code != 0:
-        return BookkeepingResult(attempted=True, committed=False, result=add_result)
+    add_paths, add_paths_failure = _preflight_add_paths(project_root, paths)
+    if add_paths_failure is not None:
+        return BookkeepingResult(attempted=True, committed=False, result=add_paths_failure)
+    if add_paths:
+        add_result = run_git_command(project_root, ("add", "-A", "-f", "--", *_literal_pathspecs(add_paths)))
+        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}", "--", *pathspecs),

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

@@ -399,14 +399,65 @@ def parse_stream_progress_lines(lines: Sequence[str]) -> ProgressSummary:
     )
 
 
-def _load_progress_tracker_class():
+class _FallbackProgressTracker:
+    """Bounded additive progress fallback when the shared parser cannot load."""
+
+    def __init__(self):
+        self._event_type_counts: Counter[str] = Counter()
+        self._summary = ProgressSummary()
+
+    def process_event(self, event: object) -> None:
+        line = json.dumps(event, ensure_ascii=False, default=str) if isinstance(event, dict) else str(event)
+        current = parse_stream_progress_lines((line,))
+        self._event_type_counts.update(current.event_type_counts)
+        self._summary = ProgressSummary(
+            event_type_counts=dict(self._event_type_counts),
+            claude_session_id=current.claude_session_id or self._summary.claude_session_id,
+            cb_session_id=current.cb_session_id or self._summary.cb_session_id,
+            result_subtype=current.result_subtype or self._summary.result_subtype,
+            stop_reason=current.stop_reason or self._summary.stop_reason,
+            has_usage=current.has_usage or self._summary.has_usage,
+            permission_denial_count=self._summary.permission_denial_count + current.permission_denial_count,
+            permission_denials=tuple((*self._summary.permission_denials, *current.permission_denials)[-10:]),
+            fatal_error_code=current.fatal_error_code or self._summary.fatal_error_code,
+            terminal_result_text=current.terminal_result_text or self._summary.terminal_result_text,
+            errors=tuple((*self._summary.errors, *current.errors)[-10:]),
+        )
+
+    def to_dict(self) -> dict[str, object]:
+        return self._summary.to_dict()
+
+
+def _load_stream_parser_classes() -> tuple[type | None, type | None]:
     parser_path = Path(__file__).resolve().parents[1] / "scripts" / "parse-stream-progress.py"
     spec = importlib.util.spec_from_file_location("prizmkit_parse_stream_progress", parser_path)
     if spec is None or spec.loader is None:
-        return None
+        return None, None
     module = importlib.util.module_from_spec(spec)
     spec.loader.exec_module(module)
-    return getattr(module, "ProgressTracker", None)
+    return (
+        getattr(module, "ProgressTracker", None),
+        getattr(module, "SemanticLogNormalizer", None),
+    )
+
+
+def _load_progress_tracker_class():
+    """Backward-compatible access to the shared aggregate tracker class."""
+    tracker_class, _ = _load_stream_parser_classes()
+    return tracker_class
+
+
+def _fallback_semantic_output(line: str, event: object | None) -> str:
+    """Preserve useful output compactly if the shared semantic adapter is unavailable."""
+    if not isinstance(event, dict):
+        text = line.rstrip("\n")
+        return f"[OUTPUT] {text}\n" if text else ""
+    event_type = str(event.get("type") or "event")
+    value = event.get("error") or event.get("result") or event.get("message")
+    if isinstance(value, str) and value.strip():
+        label = "[ERROR]" if event.get("error") else "[OUTPUT]"
+        return f"{label} {value}\n"
+    return f"[OUTPUT] event={event_type}\n"
 
 
 def _write_progress_summary(progress_path: Path | None, summary: ProgressSummary) -> None:
@@ -678,55 +729,85 @@ def _reader_thread(
     pipe,
     session_log: Path,
     backup_log: Path,
-    output_queue: "queue.Queue[str]",
+    result_queue: "queue.Queue[dict[str, object]]",
     progress_path: Path | None = None,
     live_output: bool = False,
 ) -> None:
-    lines: list[str] = []
-    tracker = None
     tracker_lock = threading.Lock()
     progress_refresh_stop = threading.Event()
     progress_refresh_thread: threading.Thread | None = None
     refresh_progress: Callable[[bool], None] | None = None
-    tracker_class = _load_progress_tracker_class() if progress_path is not None else None
-    if tracker_class is not None:
-        try:
-            tracker = tracker_class(session_log)
-        except Exception:
-            tracker = None
-    if progress_path is not None and tracker is not None:
+    tracker_class, normalizer_class = _load_stream_parser_classes()
+    try:
+        tracker = tracker_class(session_log) if tracker_class is not None else _FallbackProgressTracker()
+    except Exception:
+        tracker = _FallbackProgressTracker()
+    try:
+        normalizer = normalizer_class() if normalizer_class is not None else None
+    except Exception:
+        normalizer = None
+    if progress_path is not None:
         progress_refresh_thread, refresh_progress = _start_idle_progress_refresh(
             progress_path,
             tracker,
             tracker_lock,
             progress_refresh_stop,
         )
+    final_data: dict[str, object] = {}
     try:
-        for line in iter(pipe.readline, ""):
-            if not line:
-                break
-            with session_log.open("a", encoding="utf-8") as main_fh:
-                main_fh.write(line)
-            with backup_log.open("a", encoding="utf-8") as backup_fh:
-                backup_fh.write(line)
-            output_queue.put(line)
-            if live_output:
-                _emit_live_output(line)
-            lines.append(line)
-            if progress_path is not None:
-                if tracker is not None:
-                    stripped = line.strip()
-                    with tracker_lock:
-                        if stripped:
-                            try:
-                                tracker.process_event(json.loads(stripped))
-                            except json.JSONDecodeError:
+        with session_log.open("a", encoding="utf-8") as main_fh, backup_log.open("a", encoding="utf-8") as backup_fh:
+            for line in iter(pipe.readline, ""):
+                if not line:
+                    break
+                stripped = line.strip()
+                event: object | None = None
+                tracker_failure = ""
+                if stripped:
+                    try:
+                        event = json.loads(stripped)
+                    except json.JSONDecodeError:
+                        event = None
+                    try:
+                        with tracker_lock:
+                            if isinstance(event, dict):
+                                tracker.process_event(event)
+                            elif isinstance(tracker, _FallbackProgressTracker):
+                                tracker.process_event(stripped)
+                            else:
                                 tracker.last_text_snippet = stripped[:120]
                                 tracker._detect_terminal_error(stripped, require_error_context=True)
-                        data = tracker.to_dict()
-                    _write_progress_data(progress_path, data)
-                else:
-                    _write_progress_summary(progress_path, parse_stream_progress_lines(lines))
+                    except Exception as exc:
+                        tracker_failure = f"[ERROR] progress parser rejected event={str(event.get('type') or 'unknown') if isinstance(event, dict) else 'text'}: {type(exc).__name__}\n"
+                try:
+                    if normalizer is not None:
+                        rendered = normalizer.process_event(event) if isinstance(event, dict) else normalizer.process_text(line)
+                    else:
+                        rendered = _fallback_semantic_output(line, event)
+                except Exception as exc:
+                    event_name = str(event.get("type") or "unknown") if isinstance(event, dict) else "text"
+                    rendered = (
+                        f"[ERROR] semantic log adapter rejected event={event_name}: {type(exc).__name__}\n"
+                        + _fallback_semantic_output(line, event)
+                    )
+                rendered = tracker_failure + rendered
+                if rendered:
+                    main_fh.write(rendered)
+                    backup_fh.write(rendered)
+                    main_fh.flush()
+                    backup_fh.flush()
+                    if live_output:
+                        _emit_live_output(rendered)
+            if normalizer is not None:
+                trailing = normalizer.finish()
+                if trailing:
+                    main_fh.write(trailing)
+                    backup_fh.write(trailing)
+                    main_fh.flush()
+                    backup_fh.flush()
+                    if live_output:
+                        _emit_live_output(trailing)
+        with tracker_lock:
+            final_data = tracker.to_dict()
     finally:
         if refresh_progress is not None:
             try:
@@ -736,6 +817,16 @@ def _reader_thread(
         progress_refresh_stop.set()
         if progress_refresh_thread is not None:
             progress_refresh_thread.join(timeout=2)
+        if not final_data:
+            try:
+                with tracker_lock:
+                    final_data = tracker.to_dict()
+            except Exception:
+                final_data = {}
+        try:
+            result_queue.put_nowait(final_data)
+        except queue.Full:
+            pass
         try:
             pipe.close()
         except Exception:
@@ -810,14 +901,14 @@ class AISessionLauncher:
 
         handle = launch_process(spec, stderr=subprocess.STDOUT)
         assert handle.popen is not None
-        output_queue: queue.Queue[str] = queue.Queue()
+        reader_result_queue: queue.Queue[dict[str, object]] = queue.Queue(maxsize=1)
         reader = threading.Thread(
             target=_reader_thread,
             args=(
                 handle.popen.stdout,
                 session_log,
                 backup_log,
-                output_queue,
+                reader_result_queue,
                 self.config.progress_path,
                 self.config.live_output and self.config.verbose and not self.config.suppress_stream_output,
             ),
@@ -931,19 +1022,24 @@ class AISessionLauncher:
             )
             termination_reason = "stale_session"
         recovery = recover_session_log(session_log, backup_log)
-        lines = session_log.read_text(encoding="utf-8", errors="ignore").splitlines()
-        summary = parse_stream_progress_lines(lines)
-        merged_progress: dict[str, object] = summary.to_dict()
+        try:
+            reader_progress = reader_result_queue.get_nowait()
+        except queue.Empty:
+            reader_progress = {}
+        existing_progress: dict[str, object] = {}
+        if self.config.progress_path is not None and self.config.progress_path.is_file():
+            try:
+                loaded_progress = json.loads(self.config.progress_path.read_text(encoding="utf-8"))
+                if isinstance(loaded_progress, dict):
+                    existing_progress = loaded_progress
+            except (OSError, json.JSONDecodeError):
+                existing_progress = {}
+        merged_progress = dict(existing_progress)
+        merged_progress.update(reader_progress)
+        fallback_summary = ProgressSummary()
         if self.config.progress_path is not None:
-            existing_progress = {}
-            if self.config.progress_path.is_file():
-                try:
-                    existing_progress = json.loads(self.config.progress_path.read_text(encoding="utf-8"))
-                except (OSError, json.JSONDecodeError):
-                    existing_progress = {}
-            merged_progress = _merged_progress(existing_progress, summary)
             self.config.progress_path.write_text(json.dumps(merged_progress, indent=2, sort_keys=True) + "\n", encoding="utf-8")
-        final_summary = _summary_from_progress_dict(merged_progress, summary)
+        final_summary = _summary_from_progress_dict(merged_progress, fallback_summary)
         ended = time.time()
         result = AISessionResult(
             command=command,