okstra 0.144.0 → 0.146.0

package/runtime/python/okstra_token_usage/collect.py

@@ -15,11 +15,13 @@ from .claude import (
 )
 from .codex import codex_session_total, find_codex_sessions
 from .antigravity import (
+    PRINT_MODE_USAGE_NOTE,
     antigravity_session_total,
     find_antigravity_sessions,
 )
 from .paths import claude_project_dir, utc_now
 from .pricing import codex_cost_usd, antigravity_cost_usd
+from okstra_ctl.wrapper_status import read_wrapper_status, status_path_for_prompt
 
 
 def match_prefixes(worker_id: str) -> list[str]:
@@ -434,7 +436,7 @@ def _codex_worker_windows(project_root: Path, state: dict) -> dict[str, list[tup
     running_workers = {
         str(worker.get("workerId") or "").strip()
         for worker in state.get("workers", [])
-        if isinstance(worker, dict) and worker.get("status") == "running"
+        if isinstance(worker, dict) and worker.get("status") in {"running", "in-progress"}
     }
     if running_workers:
         open_until = utc_now()
@@ -512,12 +514,116 @@ def _cli_usage_block(provider: str, totals: dict, session_paths: list[Path]) ->
     return block
 
 
+def _epoch_iso(value: object) -> str | None:
+    if not isinstance(value, (int, float)) or isinstance(value, bool):
+        return None
+    return datetime.fromtimestamp(value, timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+
+def wrapper_execution(status_path: Path | None) -> dict:
+    """Read wrapper execution evidence without inferring token availability."""
+    if status_path is None or not status_path.is_file():
+        return {"status": "not-started"}
+    status = read_wrapper_status(status_path)
+    if status is None:
+        return {"status": "failed", "statusPath": str(status_path)}
+
+    if status.timeout:
+        execution_status = "timeout"
+    elif status.stage == "started":
+        execution_status = "started"
+    elif status.stage == "exited" and status.exit_code == 0:
+        execution_status = "exited"
+    else:
+        execution_status = "failed"
+
+    execution = {
+        "status": execution_status,
+        "statusPath": str(status_path),
+        "startedAt": _epoch_iso(status.raw.get("started_ts")),
+        "endedAt": _epoch_iso(status.raw.get("ended_ts")),
+    }
+    if status.exit_code is not None:
+        execution["exitCode"] = status.exit_code
+    return execution
+
+
+def _execution_note(execution: dict) -> str:
+    status = execution["status"]
+    if status == "exited":
+        return f"wrapper exited {execution.get('exitCode', 0)}"
+    if status == "timeout":
+        return "wrapper timed out"
+    if status == "failed":
+        exit_code = execution.get("exitCode")
+        if exit_code is not None:
+            return f"wrapper failed with exit code {exit_code}"
+        return "wrapper status is invalid"
+    if status == "started":
+        return "wrapper started and has not recorded an exit"
+    return "wrapper status sidecar is unavailable"
+
+
+def collect_cli_usage(
+    *,
+    provider: str,
+    status_path: Path | None,
+    sessions: list[Path],
+    fallback_window_used: bool = False,
+) -> dict:
+    """Collect attributable CLI usage while retaining execution evidence."""
+    execution = wrapper_execution(status_path)
+    execution_note = _execution_note(execution)
+
+    if provider == "antigravity":
+        block = na_block(f"{PRINT_MODE_USAGE_NOTE}; {execution_note}")
+        block["cliNote"] = block["note"]
+    else:
+        totals = _cli_session_totals(provider, sessions)
+        if not sessions:
+            block = na_block(
+                f"{execution_note}; CLI usage attribution unavailable because no transcript was found"
+            )
+            block["cliNote"] = block["note"]
+        elif not totals:
+            block = na_block(
+                f"{execution_note}; transcript found but no final token snapshot was recorded"
+            )
+            block["cliNote"] = block["note"]
+            block["cliSessionPaths"] = [str(path) for path in sessions]
+        else:
+            block = _cli_usage_block(provider, _aggregate_totals(totals), sessions)
+
+    block["cliExecutionStatus"] = execution["status"]
+    if fallback_window_used:
+        fallback_note = "wrapper status sidecar unavailable; used aggregate wrapper window fallback"
+        prior_note = block.get("cliNote")
+        block["cliNote"] = f"{prior_note}; {fallback_note}" if prior_note else fallback_note
+    return block
+
+
+def _worker_cli_windows(
+    project_root: Path,
+    worker: dict,
+    fallback_windows: list[tuple[str, str]],
+) -> tuple[list[tuple[str, str]], Path | None, bool]:
+    prompt_path = _resolve_project_path(project_root, str(worker.get("promptPath") or ""))
+    status_path = status_path_for_prompt(prompt_path) if prompt_path is not None else None
+    execution = wrapper_execution(status_path)
+    started_at = execution.get("startedAt")
+    ended_at = execution.get("endedAt")
+    if started_at:
+        return [(started_at, ended_at or utc_now())], status_path, False
+    return fallback_windows, status_path, True
+
+
 def _attach_cli_usage(
     block: dict,
     provider: str,
     project_root: Path,
-    wrapper_start: str,
-    wrapper_end: str,
+    windows: list[tuple[str, str]],
+    status_path: Path | None,
+    fallback_window_used: bool,
 ) -> None:
     """Layer aggregated CLI token/cost onto a Claude-side worker ``block``.
 
@@ -528,19 +634,21 @@ def _attach_cli_usage(
     CLI spend is fully reported. (agy print mode leaves no transcript, so the
     antigravity path still resolves to "session not found" → na cost.)
     """
-    session_paths = _cli_sessions_for_windows(
-        provider, project_root, [(wrapper_start, wrapper_end)]
+    session_paths = _cli_sessions_for_windows(provider, project_root, windows)
+    cli = collect_cli_usage(
+        provider=provider,
+        status_path=status_path,
+        sessions=session_paths,
+        fallback_window_used=fallback_window_used,
     )
-    if not session_paths:
-        block["cliNote"] = f"{provider} CLI session not found in wrapper window (fallback or never invoked)"
-        return
-    block["cliSessionPaths"] = [str(path) for path in session_paths]
-    totals = _cli_session_totals(provider, session_paths)
-    if not totals:
-        block["cliNote"] = f"{provider} CLI session found but no usage recorded (likely errored before completion)"
-        return
-    cli = _cli_usage_block(provider, _aggregate_totals(totals), session_paths)
-    for key in ("cliTotalTokens", "cliEstimatedCostUsd", "cliModel"):
+    for key in (
+        "cliTotalTokens",
+        "cliEstimatedCostUsd",
+        "cliModel",
+        "cliSessionPaths",
+        "cliNote",
+        "cliExecutionStatus",
+    ):
         if key in cli:
             block[key] = cli[key]
 
@@ -560,23 +668,17 @@ def _collect_codex_runtime_usage(state: dict, project_root: Path) -> dict:
             )
             continue
         worker_id = str(worker.get("workerId") or "").strip()
-        windows = windows_by_worker.get(worker_id, [])
-        if not windows:
-            worker["usage"] = na_block(
-                f"no lead-events dispatch window found for workerId={worker_id}"
-            )
-            continue
+        windows, status_path, used_fallback = _worker_cli_windows(
+            project_root,
+            worker,
+            windows_by_worker.get(worker_id, []),
+        )
         session_paths = _cli_sessions_for_windows(provider, project_root, windows)
-        totals = _cli_session_totals(provider, session_paths)
-        if not totals:
-            worker["usage"] = na_block(
-                f"no {provider} CLI session found in lead-events dispatch window"
-            )
-            continue
-        worker["usage"] = _cli_usage_block(
-            provider,
-            _aggregate_totals(totals),
-            session_paths,
+        worker["usage"] = collect_cli_usage(
+            provider=provider,
+            status_path=status_path,
+            sessions=session_paths,
+            fallback_window_used=used_fallback,
         )
     _populate_usage_summary(state, team_name=resolve_team_name(state),
                             sessions_found=0, needle_source="none")
@@ -779,12 +881,18 @@ def collect(team_state_path: Path, project_root: Path | None = None, *,
         # For codex/antigravity workers, sum every CLI session that fell inside
         # the aggregated wrapper window (re-dispatches leave one rollout each).
         if agent in ("codex", "antigravity"):
+            windows, status_path, used_fallback = _worker_cli_windows(
+                cwd,
+                worker,
+                [(aggregate.get("startedAt") or "", aggregate.get("endedAt") or "")],
+            )
             _attach_cli_usage(
                 block,
                 agent,
                 cwd,
-                aggregate.get("startedAt") or "",
-                aggregate.get("endedAt") or "",
+                windows,
+                status_path,
+                used_fallback,
             )
         worker["usage"] = block
 

package/runtime/python/okstra_token_usage/paths.py

@@ -1,8 +1,10 @@
 """Filesystem locations for agent session transcripts and time helpers."""
 from __future__ import annotations
 
+import os
 from datetime import datetime, timezone
 from pathlib import Path
+from typing import Mapping
 
 
 HOME = Path.home()
@@ -10,6 +12,31 @@ CLAUDE_PROJECTS = HOME / ".claude" / "projects"
 CODEX_SESSIONS = HOME / ".agent" / "sessions"
 
 
+def codex_session_roots(
+    home: Path,
+    env: Mapping[str, str],
+) -> tuple[Path, ...]:
+    """Return Codex transcript roots in configuration precedence order."""
+    candidates: list[Path] = []
+    configured_home = env.get("CODEX_HOME", "").strip()
+    if configured_home:
+        candidates.append(Path(configured_home).expanduser() / "sessions")
+    candidates.extend((
+        home / ".codex" / "sessions",
+        home / ".agent" / "sessions",
+    ))
+
+    roots: list[Path] = []
+    seen: set[Path] = set()
+    for candidate in candidates:
+        normalized = Path(os.path.abspath(candidate))
+        if normalized in seen:
+            continue
+        seen.add(normalized)
+        roots.append(candidate)
+    return tuple(roots)
+
+
 def utc_now() -> str:
     return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
 

package/runtime/python/okstra_vendor/__init__.py

@@ -26,12 +26,25 @@ imports find them deterministically.
 
 import sys as _sys
 
+
+def _alias_loaded_submodules(package: object, canonical_name: str) -> None:
+    """Expose one vendored package tree under its canonical import name."""
+    vendored_name = package.__name__
+    _sys.modules[canonical_name] = package
+    vendored_prefix = f"{vendored_name}."
+    for module_name, module in tuple(_sys.modules.items()):
+        if module is None or not module_name.startswith(vendored_prefix):
+            continue
+        suffix = module_name[len(vendored_name):]
+        _sys.modules[f"{canonical_name}{suffix}"] = module
+
+
 # Register markupsafe alias BEFORE importing jinja2 — jinja2's __init__
 # evaluates `from .environment import ...`, which does `from markupsafe
 # import Markup` at module-load time. Reversing the order would crash
 # the import chain before the alias was registered.
 from . import markupsafe as _markupsafe
-_sys.modules.setdefault("markupsafe", _markupsafe)
+_alias_loaded_submodules(_markupsafe, "markupsafe")
 
 from . import jinja2 as _jinja2  # noqa: E402
-_sys.modules.setdefault("jinja2", _jinja2)
+_alias_loaded_submodules(_jinja2, "jinja2")

package/runtime/schemas/convergence-groups-v1.0.schema.json

@@ -51,7 +51,6 @@
         "category": { "type": "string", "pattern": "\\S" },
         "ticketIds": {
           "type": "array",
-          "minItems": 1,
           "items": { "type": "string", "pattern": "\\S" }
         },
         "originWorker": { "type": "string", "pattern": "\\S" },