cdx-manager 0.25.8 → 0.26.0

package/src/cli.py

@@ -21,6 +21,7 @@ from .cli_commands import (
     handle_config,
     handle_configs,
     handle_context,
+    handle_conversation,
     handle_copy,
     handle_disable,
     handle_disk,
@@ -167,6 +168,7 @@ _COMMAND_HANDLERS = {
     "export": handle_export,
     "handoff": handle_handoff,
     "history": handle_history,
+    "conversation": handle_conversation,
     "import": handle_import,
     "label": handle_label,
     "last": handle_last,
@@ -201,6 +203,7 @@ _COMMAND_HANDLERS = {
 }
 
 _COMMAND_ALIASES = {
+    "show": "config",
     "ren": "rename",
     "mv": "rename",
 }
@@ -237,15 +240,18 @@ def _print_help(use_color=False):
         _style("Usage:", "1", use_color),
         f"  {_style('cdx', '36', use_color)}",
         f"  {_style('cdx --json', '36', use_color)}",
+        f"  {_style('cdx ls [--json]', '36', use_color)}",
         f"  {_style('cdx status [--json] [--refresh|--cached] [--timeout SECONDS]', '36', use_color)}",
         f"  {_style('cdx status --small|-s [--refresh|--cached] [--timeout SECONDS]', '36', use_color)}",
         f"  {_style('cdx status <name> [--json] [--refresh|--cached] [--timeout SECONDS]', '36', use_color)}",
         f"  {_style('cdx next [--json] [--refresh]', '36', use_color)}",
         f"  {_style('cdx agents [--max-age-hours N] [--json]', '36', use_color)}",
         f"  {_style('cdx reset <name> [--yes] [--json]', '36', use_color)}",
+        f"  {_style('cdx auth claude-token <profile> [--json]', '36', use_color)}",
         f"  {_style('cdx auth refresh <name|all> [--json]', '36', use_color)}",
         f"  {_style('cdx select --provider PROVIDER [--min-reasoning-effort minimal|low|medium|high|xhigh] [--min-power minimal|low|medium|high|xhigh] [--require-ready] [--refresh] --json', '36', use_color)}",
         f"  {_style('cdx run [session] [--remote SSH_TARGET] --cwd PATH [--project PATH] (--prompt-file PATH|--prompt TEXT|--prompt-file -) [--provider PROVIDER] [--model MODEL] [--kind assistant|code-review|retro] [--reasoning-effort minimal|low|medium|high|xhigh] [--power minimal|low|medium|high|xhigh] [--permission review|default|auto|full|workspace-write|read-only|danger-full-access] [--timeout-seconds N] [--label TEXT] [--max-parallel N] [--continue-run RUN_ID] [--detach] [--failover] [--refresh] --json', '36', use_color)}",
+        "    Remote Ollama: text generation only, not an autonomous coding agent; no repository edits. Requires an installed worker model; no authentication.",
         f"  {_style('cdx runs [--limit N] [--since 7d|today|DATE] [--running] --json', '36', use_color)}",
         f"  {_style('cdx run-status <run_id> --json', '36', use_color)}",
         f"  {_style('cdx run-report <run_id> --json', '36', use_color)}",
@@ -256,15 +262,17 @@ def _print_help(use_color=False):
         f"  {_style('cdx memory [--global|--project NAME_OR_PATH] [show|view|path|init|edit|clear|set|append|list] [text...] [--json]', '36', use_color)}",
         f"  {_style('cdx disk [profiles] [--candidates] [--json]', '36', use_color)}",
         f"  {_style('cdx config <name> [--json]', '36', use_color)}",
+        f"  {_style('cdx show <name> [--json]', '36', use_color)}",
         f"  {_style('cdx configs [--json]', '36', use_color)}",
         f"  {_style('cdx power|perm|fast|model <name|all|provider:PROVIDER|a,b> <value|default> [--json]', '36', use_color)}",
         f"  {_style(SET_USAGE[len('Usage: '):], '36', use_color)}",
-        f"  {_style('cdx unset <name>|--sessions all|a,b|--provider PROVIDER (--power|--permission|--fast|--rtk|--logics|--notify|--notify-preview|--model|--priority|--all) [--json]', '36', use_color)}",
+        f"  {_style('cdx unset <name>|--sessions all|a,b|--provider PROVIDER (--power|--permission|--fast|--rtk|--logics|--notify|--notify-preview|--model|--priority|--max-parallel|--all) [--json]', '36', use_color)}",
         f"  {_style('cdx history backfill-projects [--mapping FILE] [--dry-run|--apply] [--json]', '36', use_color)}",
         f"  {_style('cdx history [name] [--limit N] [--summary] [--since 7d|today|DATE] [--from DATE] [--to DATE] [--json]', '36', use_color)}",
         f"  {_style('cdx stats [name] [--since 7d|today|DATE] [--from DATE] [--to DATE] [--by session|project|model] [--json]', '36', use_color)}",
         f"  {_style('cdx last [--json]', '36', use_color)}",
         f"  {_style('cdx resume <name> [--project PATH] [--conversation <id>] [--json]', '36', use_color)}",
+        f"  {_style('cdx conversation <name> [--conversation ID] [--cursor CURSOR] [--limit N] --json', '36', use_color)}",
         f"  {_style('cdx can-resume <name> [--conversation <id>] [--json]', '36', use_color)}",
         f"  {_style('cdx rescue [<session>] [--to <target>] [--yes] [--dry-run] [--json]', '36', use_color)}",
         f"  {_style('cdx retro [--limit N] [--json]', '36', use_color)}",
@@ -578,6 +586,11 @@ def main(argv, options=None):
     # directory cannot be resolved (a service or task with a minimal environment).
     service = options.get("service") or create_session_service({"env": env})
 
+    if argv[:1] == ["ls"]:
+        if argv[1:] not in ([], ["--json"]):
+            raise CdxError("Usage: cdx ls [--json]")
+        argv = argv[1:]
+
     if argv == ["--json"]:
         rows = service["format_list_rows"]()
         notices = _get_update_notices(service, env, options)

package/src/cli_args.py

@@ -16,6 +16,7 @@ from .config import (
     PROVIDER_CODEX,
     PROVIDERS,
     REASONING_EFFORT_VALUES,
+    normalize_launch_max_parallel,
     normalize_permission,
     parse_on_off,
 )
@@ -34,8 +35,8 @@ CONTEXT_USAGE = "Usage: cdx context show|path|init|edit|clear|set|append [text..
 MEMORY_USAGE = "Usage: cdx memory [--global|--project NAME_OR_PATH] [show|view|path|init|edit|clear|set|append|list] [text...] [--json]"
 HANDOFF_USAGE = "Usage: cdx handoff <name> [--json] | cdx handoff <source> <target> [--source-conversation ID | --source-native-transcript PATH | --source-transcript PATH] [--json]"
 LABEL_USAGE = "Usage: cdx label <name> <label> [--json] | cdx label <name> --clear [--json]"
-SET_USAGE = "Usage: cdx set <name>|--sessions all|a,b|--provider PROVIDER [--power minimal|low|medium|high|xhigh] [--permission review|default|auto|full] [--fast on|off] [--rtk on|off] [--logics on|off] [--notify on|off] [--agent-state on|off] [--notify-preview on|off] [--scrub-env on|off] [--shared-memory on|off] [--retro on|off] [--policy use|ask-first|never] [--model MODEL] [--fallback-model MODEL[,MODEL...]] [--budget USD] [--extra-args 'ARGS'] [--priority 0..100] [--json]"
-UNSET_USAGE = "Usage: cdx unset <name>|--sessions all|a,b|--provider PROVIDER (--power|--reasoning-effort|--permission|--fast|--rtk|--logics|--notify|--agent-state|--notify-preview|--scrub-env|--shared-memory|--retro|--policy|--model|--fallback-model|--budget|--extra-args|--priority|--all) [--json]"
+SET_USAGE = "Usage: cdx set <name>|--sessions all|a,b|--provider PROVIDER [--power minimal|low|medium|high|xhigh] [--permission review|default|auto|full] [--fast on|off] [--rtk on|off] [--logics on|off] [--notify on|off] [--agent-state on|off] [--notify-preview on|off] [--scrub-env on|off] [--shared-memory on|off] [--retro on|off] [--policy use|ask-first|never] [--model MODEL] [--fallback-model MODEL[,MODEL...]] [--budget USD] [--extra-args 'ARGS'] [--priority 0..100] [--max-parallel 0..5] [--json]"
+UNSET_USAGE = "Usage: cdx unset <name>|--sessions all|a,b|--provider PROVIDER (--power|--reasoning-effort|--permission|--fast|--rtk|--logics|--notify|--agent-state|--notify-preview|--scrub-env|--shared-memory|--retro|--policy|--model|--fallback-model|--budget|--extra-args|--priority|--max-parallel|--all) [--json]"
 SETTING_ALIAS_USAGE = "Usage: cdx power|perm|fast|model <name|all|provider:PROVIDER|a,b> <value|default> [--json]"
 CONFIG_USAGE = "Usage: cdx config <name> [--json]"
 CONFIGS_USAGE = "Usage: cdx configs [--json]"
@@ -49,6 +50,7 @@ SESSIONS_USAGE = "Usage: cdx sessions [--all] --json"
 SELECT_USAGE = "Usage: cdx select --provider PROVIDER [--min-reasoning-effort minimal|low|medium|high|xhigh] [--min-power minimal|low|medium|high|xhigh] [--require-ready] [--refresh] --json"
 NEXT_USAGE = "Usage: cdx next [--json] [--refresh]"
 RUN_USAGE = "Usage: cdx run [session] [--remote SSH_TARGET] [--remote-prefix COMMAND] (--cwd|--dir) PATH [--project PATH] (--prompt-file PATH|--prompt TEXT|--prompt-file -) [--provider PROVIDER] [--model MODEL] [--kind assistant|code-review|retro] [--reasoning-effort minimal|low|medium|high|xhigh] [--power minimal|low|medium|high|xhigh] [--permission review|default|auto|full|workspace-write|read-only|danger-full-access] [--network-access] [--isolate-workspace] [--timeout-seconds N] [--budget USD] [--label TEXT] [--max-parallel N] [--continue-run RUN_ID] [--detach] [--failover] [--refresh] --json"
+RUN_USAGE += "\nRemote Ollama generates text only; it is not an autonomous coding agent and does not edit the repository. Requires an installed worker model; no authentication."
 RUN_JSON_REQUIRED = "cdx run: --json is required."
 RUN_TARGET_REQUIRED = "cdx run: specify a session name or --provider PROVIDER."
 RUN_SESSION_PROVIDER_CONFLICT = "cdx run: cannot specify both a session name and --provider."
@@ -285,6 +287,7 @@ def _parse_set_args(args):
         "--budget": {"key": "budget", "type": "str", "default": None, "transform": _parse_budget_value},
         "--extra-args": {"key": "extra_args", "type": "str", "default": None},
         "--priority": {"key": "priority", "type": "str", "default": None, "transform": _parse_priority_value},
+        "--max-parallel": {"key": "max_parallel", "type": "str", "default": None, "transform": normalize_launch_max_parallel},
         "--policy": {"key": "policy", "type": "str", "default": None},
         "--sessions": {"key": "sessions", "type": "str", "default": None, "transform": _parse_set_unset_sessions},
         "--provider": {"key": "provider", "type": "str", "default": None, "transform": lambda value: _parse_provider_filter(value, SET_USAGE)},
@@ -302,7 +305,7 @@ def _parse_set_args(args):
         raise CdxError(SET_USAGE)
     settings = {
         key: parsed[key]
-        for key in ("power", "permission", "fast", "rtk", "logics", "notify", "agent_state", "notify_preview", "scrub_env", "shared_memory", "retro", "model", "fallback_model", "budget", "extra_args", "priority", "policy")
+        for key in ("power", "permission", "fast", "rtk", "logics", "notify", "agent_state", "notify_preview", "scrub_env", "shared_memory", "retro", "model", "fallback_model", "budget", "extra_args", "priority", "policy", "max_parallel")
         if parsed[key] is not None
     }
     if not settings:
@@ -335,6 +338,7 @@ def _parse_unset_args(args):
         "--budget": {"key": "budget", "type": "bool", "default": False},
         "--extra-args": {"key": "extra_args", "type": "bool", "default": False},
         "--priority": {"key": "priority", "type": "bool", "default": False},
+        "--max-parallel": {"key": "max_parallel", "type": "bool", "default": False},
         "--policy": {"key": "policy", "type": "bool", "default": False},
         "--all": {"key": "all", "type": "bool", "default": False},
         "--sessions": {"key": "sessions", "type": "str", "default": None, "transform": _parse_set_unset_sessions},
@@ -353,7 +357,7 @@ def _parse_unset_args(args):
         raise CdxError(UNSET_USAGE)
     _UNSET_KEYS = (
         "power", "reasoning_effort", "permission", "fast", "rtk", "logics", "notify", "agent_state", "notify_preview", "scrub_env", "shared_memory", "retro",
-        "model", "fallback_model", "budget", "extra_args", "priority", "policy",
+        "model", "fallback_model", "budget", "extra_args", "priority", "policy", "max_parallel",
     )
     keys = list(_UNSET_KEYS) if parsed["all"] else [key for key in _UNSET_KEYS if parsed[key]]
     if not keys:
@@ -593,6 +597,7 @@ def cdx_schema():
             "logics_manager_update_available",
             "update_version_check_failed",
             "update_version_mismatch",
+            "update_unverified",
             "logics_manager_missing",
             "logics_viewer_failed",
             "logics_viewer_root_invalid",

package/src/cli_commands.py

@@ -57,8 +57,6 @@ from .commands.backup import (  # noqa: F401
     handle_export,
     handle_import,
 )
-
-# Re-exported for cli.py and tests; see src/commands/__init__.py.
 from .commands.context_memory import (  # noqa: F401
     _list_memory_entries,
     _memory_payload,
@@ -67,6 +65,9 @@ from .commands.context_memory import (  # noqa: F401
     handle_context,
     handle_memory,
 )
+
+# Re-exported for cli.py and tests; see src/commands/__init__.py.
+from .commands.conversation import handle_conversation as handle_conversation
 from .commands.launch import (  # re-export for cli.py / tests
     _format_resume_capability as _format_resume_capability,
 )

package/src/cli_helpers.py

@@ -323,6 +323,7 @@ def _format_launch_config(session, use_color=False):
         ("extra_args", "Extra args"),
         ("priority", "Priority"),
         ("policy", "Policy"),
+        ("max_parallel", "Max parallel"),
     ]:
         rows.append([
             _dim(label, use_color),

package/src/commands/auth.py

@@ -3,6 +3,7 @@
 Split out of cli_commands.py. Moved verbatim; re-exported by cli_commands.
 """
 
+import sys
 import time
 import uuid
 
@@ -53,6 +54,30 @@ def _refresh_result(session, diagnostic):
 
 
 def handle_auth(rest, ctx):
+    if rest and rest[0] == "claude-token":
+        json_flag, args = _parse_json_flag(rest[1:])
+        if len(args) != 1:
+            raise CdxError("Usage: cdx auth claude-token <profile> [--json]")
+        session = ctx["service"]["get_session"](args[0])
+        if not session or session["provider"] != PROVIDER_CLAUDE:
+            raise CdxError("Select an existing Claude profile for cdx auth claude-token.")
+        if ctx["stdin_is_tty"]:
+            raise CdxError("Read the Claude setup token from standard input, without an interactive terminal.")
+        from ..claude_remote_token import store_token
+        stream = ctx.get("prompt_stdin") or sys.stdin
+        token = stream.read(16385)
+        if isinstance(token, bytes):
+            try:
+                token = token.decode("utf-8")
+            except UnicodeDecodeError as error:
+                raise CdxError("Provide one Claude setup token on standard input.") from error
+        store_token(session, token)
+        message = f"Stored remote Claude setup token for {session['name']}"
+        if json_flag:
+            _write_json(ctx, _json_success("auth.claude-token", message))
+        else:
+            ctx["out"](message + "\n")
+        return 0
     parsed = _parse_auth_args(rest)
     target = parsed["target"]
     if target == "all":

package/src/commands/conversation.py

@@ -0,0 +1,34 @@
+"""JSON conversation pages for interactive sessions."""
+
+from ..cli_args import _parse_flag_args
+from ..cli_helpers import _json_success, _write_json
+from ..conversation import read_conversation
+from ..errors import CdxError
+from ..provider_runtime import _get_auth_home
+
+CONVERSATION_USAGE = "Usage: cdx conversation <name> [--conversation ID] [--cursor CURSOR] [--limit N] --json"
+
+
+def handle_conversation(rest, ctx):
+    parsed = _parse_flag_args(rest, {
+        "--json": {"key": "json", "type": "bool", "default": False},
+        "--conversation": {"key": "conversation", "type": "str"},
+        "--cursor": {"key": "cursor", "type": "str"},
+        "--limit": {"key": "limit", "type": "str", "default": "100"},
+    }, CONVERSATION_USAGE, positionals_key="names", max_positionals=1)
+    if not parsed["json"] or len(parsed["names"]) != 1:
+        raise CdxError(CONVERSATION_USAGE)
+    session = ctx["service"]["get_session"](parsed["names"][0])
+    if not session:
+        raise CdxError(f"Unknown session: {parsed['names'][0]}")
+    try:
+        limit = int(parsed["limit"])
+    except ValueError:
+        raise CdxError(CONVERSATION_USAGE) from None
+    page = read_conversation(
+        session["provider"], _get_auth_home(session),
+        conversation_id=parsed["conversation"] or (session.get("conversation") or {}).get("id"),
+        cursor=parsed["cursor"], limit=limit,
+    )
+    _write_json(ctx, _json_success("conversation", "Conversation page loaded.", session=session["name"], **page))
+    return 0

package/src/commands/maintenance.py

@@ -53,6 +53,8 @@ def _format_update_all_result(result, use_color=False):
         return _warn(f"skipped: {result['name']} (blocked by {result['blocked_by']})", use_color)
     if result.get("returncode") == 0:
         versions = f" ({result['version_before']} -> {result['version_after']})" if "version_after" in result else ""
+        if result.get("warning"):
+            return _warn(f"done: {result['name']}{versions}\n  {result['warning']['message']}", use_color)
         return _success(f"done: {result['name']}{versions}", use_color)
     detail = str(result.get("stderr") or result.get("stdout") or "No error output.").strip().replace("\n", " ")
     detail = detail[-500:]
@@ -709,7 +711,8 @@ def handle_update(rest, ctx):
         failed = [row for row in results if row.get("returncode") != 0]
         message = "Applied workstation update plan" if not failed else "Workstation update plan completed with failures"
         if parsed["json"]:
-            _write_json(ctx, _json_success("update.all", message, plan=plan, results=results, failed=len(failed)))
+            warnings = [dict(row["warning"], name=row["name"]) for row in results if row.get("warning")]
+            _write_json(ctx, _json_success("update.all", message, warnings=warnings, plan=plan, results=results, failed=len(failed)))
         else:
             ctx["out"](f"{_success(message, ctx['use_color']) if not failed else _warn(message, ctx['use_color'])}\n")
         return 1 if failed else 0

package/src/commands/runs.py

@@ -713,16 +713,26 @@ def handle_run(rest, ctx):
             session = selected["session"]
             selection_row = selected.get("row") or {}
 
+        if parsed.get("remote") and session["provider"] == "antigravity":
+            parsed["isolate_workspace"] = True
         remote_version = None
         if parsed.get("remote"):
-            if session["provider"] != "codex":
-                raise CdxError("--remote is only available for Codex profiles.", code="remote_provider_unsupported")
+            if session["provider"] not in ("codex", "claude", "ollama", "antigravity"):
+                raise CdxError("--remote is only available for Codex, Claude, Ollama and Antigravity profiles.", code="remote_provider_unsupported")
             if parsed.get("continue_run"):
                 raise CdxError("--remote requires a fresh run without --continue-run.")
+            if session["provider"] == "ollama" and not (parsed.get("model") or (session.get("launch") or {}).get("model")):
+                raise CdxError("Remote Ollama text generation requires --model or a configured local model.")
+            if session["provider"] == "claude":
+                from ..claude_remote_token import read_token
+                read_token(session)
+                parsed["isolate_workspace"] = True
             remote_version = preflight(
                 parsed["remote"], {**os.environ, **(ctx.get("env") or {})},
                 remote_prefix=parsed.get("remote_prefix"), isolate_workspace=parsed.get("isolate_workspace", False),
-                cwd=parsed["cwd"], network=parsed.get("network_access", False), writable=parsed.get("permission") != "review")
+                cwd=parsed["cwd"], network=parsed.get("network_access", False), writable=parsed.get("permission") != "review",
+                **({"provider": "ollama", "model": parsed.get("model") or (session.get("launch") or {}).get("model")}
+                   if session["provider"] == "ollama" else {"provider": session["provider"]}))
         cwd = os.path.abspath(parsed["cwd"])
         if not parsed.get("remote") and not os.path.isdir(cwd):
             raise CdxError(f"Invalid cwd: {parsed['cwd']}", code="invalid_cwd")
@@ -1074,6 +1084,9 @@ def handle_run(rest, ctx):
             message = f"Every eligible session was rate limited: {', '.join(attempted)}."
         elif failover_error_code == "failover_limit_reached":
             message = f"Failover stopped after {MAX_FAILOVER_TRANSITIONS} transitions: {', '.join(attempted)}."
+        elif run_info.get("provider_error"):
+            failover_error_code = run_info["provider_error"]
+            message = run_info["provider_message"]
         elif run_info.get("timed_out"):
             message = "Provider process timed out."
         else:

package/src/config.py

@@ -78,6 +78,21 @@ def normalize_permission(value):
     return text if text in PERMISSION_VALUES else None
 
 
+def normalize_launch_max_parallel(value):
+    """Validate the optional per-profile automatic mission limit."""
+    from .errors import CdxError
+
+    if isinstance(value, bool) or not isinstance(value, (int, str)):
+        raise CdxError("Max parallel must be an integer from 0 to 5.")
+    try:
+        limit = int(value)
+    except ValueError as error:
+        raise CdxError("Max parallel must be an integer from 0 to 5.") from error
+    if not 0 <= limit <= 5:
+        raise CdxError("Max parallel must be an integer from 0 to 5.")
+    return limit
+
+
 def get_cdx_home(env=None):
     if env is None:
         env = os.environ

package/src/conversation.py

@@ -0,0 +1,181 @@
+"""Incremental, read-only conversation pages from provider JSONL transcripts."""
+
+import base64
+import hashlib
+import json
+import os
+import re
+from datetime import datetime
+
+from .config import PROVIDERS
+from .errors import CdxError
+from .interactive_usage import conversation_transcript, resolve_transcript
+
+MAX_LINE_BYTES = 1024 * 1024
+MAX_PAGE_BYTES = 8 * 1024 * 1024
+REDACTED = "[REDACTED]"
+
+
+def _redact(text):
+    # There is no shared transcript redactor; launch argument redaction only
+    # hides prompt argv. Do not read credential stores to discover secrets.
+    text = re.sub(r"-----BEGIN [^-]*PRIVATE KEY-----.*?(?:-----END [^-]*PRIVATE KEY-----|$)", REDACTED, text, flags=re.S)
+    text = re.sub(r"(?i)\b(?:[\w.-]*(?:password|passwd|secret|api[_-]?key|token)|authorization)\b[\"']?\s*[:=]\s*(?:\"[^\"]*\"|'[^']*'|[^\s,;}]+)", REDACTED, text)
+    text = re.sub(r"(?i)\b(?:bearer|basic)\s+[a-z0-9._~+/=-]+", REDACTED, text)
+    text = re.sub(r"\b(?:sk-[a-zA-Z0-9_-]+|gh[pousr]_[a-zA-Z0-9]+|github_pat_[a-zA-Z0-9_]+|AKIA[A-Z0-9]{16}|ASIA[A-Z0-9]{16}|xox[baprs]-[a-zA-Z0-9-]+|AIza[a-zA-Z0-9_-]+)\b", REDACTED, text)
+    text = re.sub(r"\beyJ[a-zA-Z0-9_-]+\.[a-zA-Z0-9_-]+\.[a-zA-Z0-9_-]+\b", REDACTED, text)
+    text = re.sub(r"https?://(?:hooks\.slack\.com/services|(?:discord(?:app)?\.com)/api/webhooks)/[^\s\"'<>]+", REDACTED, text)
+    return re.sub(r"(https?://)[^\s/@]+:[^\s/@]+@", r"\1[REDACTED]@", text)
+
+
+def _entry(role, text="", name=None, summary=None, at=None):
+    return {"role": role, "text": _redact(text), "tool_name": _redact(name) if name else None,
+            "tool_summary": summary, "at": at, "id": None}
+
+
+def _tool_name(message, names, result=False):
+    identifier = message.get("call_id") or message.get("tool_use_id") or message.get("id")
+    key = hashlib.sha256(identifier.encode()).hexdigest() if isinstance(identifier, str) else None
+    name = message.get("name") or (names.get(key) if result else None)
+    name = _redact(name) if isinstance(name, str) else "tool"
+    if not re.fullmatch(r"[a-zA-Z_][a-zA-Z0-9_.:/-]{0,99}", name):
+        name = "tool"
+    if key and not result:
+        if len(names) >= 100:
+            names.pop(next(iter(names)))
+        names[key] = name
+    return name
+
+
+def _entries(provider, record, names):
+    if not isinstance(record, dict):
+        return []
+    stamp = record.get("timestamp")
+    try:
+        datetime.fromisoformat(stamp.replace("Z", "+00:00"))
+    except (AttributeError, TypeError, ValueError):
+        stamp = None
+    if provider == "codex":
+        # event_msg repeats response_item messages; consume only canonical items.
+        if record.get("type") != "response_item":
+            return []
+        message = record.get("payload")
+    else:
+        message = record.get("message")
+    if not isinstance(message, dict):
+        return []
+    kind = message.get("type")
+    if isinstance(kind, str) and (kind.endswith("_call") or kind.endswith("_call_output")):
+        result = kind.endswith("output")
+        tool = message
+        if not message.get("name") and kind not in ("function_call", "custom_tool_call", "function_call_output", "custom_tool_call_output"):
+            tool = {**message, "name": kind.removesuffix("_output").removesuffix("_call")}
+        name = _tool_name(tool, names, result)
+        return [_entry("tool", name=name, summary="Result recorded" if result else "Call recorded", at=stamp)]
+    role = message.get("role") or record.get("type")
+    if role not in ("user", "assistant", "tool"):
+        return []
+    if role == "tool":
+        return [_entry("tool", name=_tool_name(message, names, True), summary="Result recorded", at=stamp)]
+    content = message.get("content")
+    if isinstance(content, str):
+        return [_entry(role, content, at=stamp)]
+    if not isinstance(content, list):
+        return []
+    entries = []
+    for block in content:
+        if not isinstance(block, dict):
+            continue
+        kind = block.get("type")
+        if kind in ("text", "input_text", "output_text") and isinstance(block.get("text"), str):
+            entries.append(_entry(role, block["text"], at=stamp))
+        elif kind in ("tool_use", "tool_result"):
+            name = _tool_name(block, names, kind == "tool_result")
+            entries.append(_entry("tool", name=name, summary="Call recorded" if kind == "tool_use" else "Result recorded", at=stamp))
+    return entries
+
+
+def _anchor(handle, offset):
+    handle.seek(max(0, offset - 128))
+    return hashlib.sha256(handle.read(min(offset, 128))).hexdigest()
+
+
+def read_conversation(provider, auth_home=None, *, conversation_id=None, started_at=None,
+                      terminal_transcript=None, cursor=None, limit=100):
+    """Return a JSON-serializable page; pass next_cursor back unchanged to poll.
+
+    Entries follow file/block order. Cursors bind a byte offset and block index
+    to the resolved file; reset_required means discard the old cursor and page
+    again from the beginning. Incomplete trailing lines are retried next time.
+    Tool bodies and reasoning blocks are never returned. Ollama PTY captures
+    cannot reliably distinguish roles and are explicitly unsupported.
+    """
+    if not isinstance(limit, int) or isinstance(limit, bool) or not 1 <= limit <= 1000:
+        raise CdxError("Conversation limit must be an integer between 1 and 1000.")
+    page = {"status": "ok", "reason": None, "provider": provider, "entries": [], "next_cursor": None, "has_more": False}
+    if provider not in PROVIDERS or provider == "ollama":
+        return {**page, "status": "unsupported", "reason": "no_structured_transcript_reader"}
+    # An explicit conversation must never fall back to an unrelated recent file.
+    if conversation_id:
+        path = conversation_transcript(provider, auth_home, conversation_id)
+    else:
+        path, _match = resolve_transcript(provider, auth_home, started_at, terminal_transcript=terminal_transcript)
+    if not path:
+        return {**page, "status": "unavailable", "reason": "transcript_not_found"}
+    try:
+        with open(path, "rb") as handle:
+            stat = os.fstat(handle.fileno())
+            identity = hashlib.sha256(f"{provider}:{os.path.realpath(path)}:{stat.st_dev}:{stat.st_ino}".encode()).hexdigest()
+            offset, index, names = 0, 0, {}
+            if cursor is not None:
+                try:
+                    if not isinstance(cursor, str) or len(cursor) > 65536:
+                        raise ValueError
+                    state = json.loads(base64.urlsafe_b64decode(cursor.encode("ascii")))
+                    offset, index = state["offset"], state["index"]
+                    names = state["names"]
+                    if (not isinstance(names, dict) or len(names) > 100
+                            or any(not isinstance(k, str) or not re.fullmatch(r"[0-9a-f]{64}", k)
+                                   or not isinstance(v, str) or not re.fullmatch(r"[a-zA-Z_][a-zA-Z0-9_.:/-]{0,99}", v)
+                                   or _redact(v) != v for k, v in names.items())):
+                        raise ValueError
+                    if (state["v"] != 1 or state["file"] != identity
+                            or type(offset) is not int or type(index) is not int
+                            or not 0 <= offset <= stat.st_size or not 0 <= index <= MAX_LINE_BYTES
+                            or state["anchor"] != _anchor(handle, offset)):
+                        raise ValueError
+                except (ValueError, TypeError, KeyError, AttributeError, UnicodeError):
+                    return {**page, "status": "reset_required", "reason": "invalid_or_stale_cursor"}
+            handle.seek(offset)
+            scanned = 0
+            while len(page["entries"]) < limit and scanned < MAX_PAGE_BYTES:
+                start = handle.tell()
+                line = handle.readline(MAX_LINE_BYTES + 1)
+                if len(line) > MAX_LINE_BYTES:
+                    return {**page, "status": "unavailable", "reason": "record_too_large", "entries": []}
+                if not line or not line.endswith(b"\n"):
+                    break
+                scanned += len(line)
+                try:
+                    entries = _entries(provider, json.loads(line), names)
+                except (ValueError, UnicodeError):
+                    entries = []
+                for block_index in range(index, len(entries)):
+                    entry = entries[block_index]
+                    entry["id"] = f"{identity[:16]}:{start}:{block_index}"
+                    page["entries"].append(entry)
+                    if len(page["entries"]) == limit:
+                        index = block_index + 1
+                        break
+                else:
+                    index = len(entries)
+                if index < len(entries):
+                    offset = start
+                    break
+                offset, index = handle.tell(), 0
+            page["has_more"] = offset < stat.st_size
+            state = {"v": 1, "file": identity, "offset": offset, "index": index, "anchor": _anchor(handle, offset), "names": names}
+            page["next_cursor"] = base64.urlsafe_b64encode(json.dumps(state, separators=(",", ":")).encode()).decode()
+            return page
+    except OSError:
+        return {**page, "status": "unavailable", "reason": "transcript_unreadable", "entries": []}

package/src/interactive_usage.py

@@ -1,17 +1,11 @@
 """Best-effort usage readers for interactive provider sessions.
 
-Three providers report usage and one does not:
-
-- Claude and Codex write their own JSONL transcripts, resolved by the
-  conversation id cdx already holds.
-- Ollama writes nothing. Its counts exist only in `--verbose` terminal output,
-  so they are parsed out of the PTY capture cdx takes for every launch.
-- Antigravity has no retrievable source. Its conversation history is
-  schema-less binary protobuf under `~/.gemini/antigravity-cli/conversations/`
-  with no `.proto` available to decode field numbers into token counts, and its
-  logs are plain glog with no usage-bearing line at any verbosity `agy --help`
-  exposes. This was investigated and is a dead end, not an oversight -- do not
-  spend the afternoon rediscovering it.
+- Claude and Codex expose per-session token counts in JSONL transcripts.
+- Ollama exposes counts in the verbose terminal output captured by cdx.
+- Antigravity exposes quota through interactive statusLine stdin (collected by
+  antigravity_status), and per-run tokens through `agy -p --output-format json`
+  (read by run_usage). Interactive per-run token counts remain unavailable;
+  quota changes are not token measurements.
 """
 
 import json