cdx-manager 0.12.0 → 0.12.2

package/README.md

@@ -1,6 +1,6 @@
 # CDX Manager
 
-[![License](https://img.shields.io/badge/license-MIT-4C8BF5)](LICENSE) ![Version](https://img.shields.io/badge/version-v0.12.0-4C8BF5) ![Python](https://img.shields.io/badge/python-3.9%2B-3776AB?logo=python&logoColor=white)
+[![License](https://img.shields.io/badge/license-MIT-4C8BF5)](LICENSE) ![Version](https://img.shields.io/badge/version-v0.12.2-4C8BF5) ![Python](https://img.shields.io/badge/python-3.9%2B-3776AB?logo=python&logoColor=white)
 
 **Run multiple Codex, Claude, Antigravity, and Ollama sessions from one terminal. Switch between accounts instantly.**
 
@@ -274,7 +274,7 @@ cdx disk profiles --candidates
 
 ### Next-Ready Notifications
 
-Use `cdx ready` when every useful assistant is cooling down and you want your terminal back. It is shorthand for `cdx notify --schedule --next-ready`: cdx picks the next known reset, registers a native OS notification, and exits immediately.
+Use `cdx ready` when every useful assistant is cooling down and you want your terminal back. It is shorthand for `cdx notify --schedule --next-ready`: cdx picks the next known reset, registers a native OS notification, and exits immediately. If no future reset is known, it exits successfully and explains that no notification was scheduled.
 
 ```bash
 cdx ready
@@ -372,10 +372,11 @@ cdx history --summary --from 2026-05-01 --to 2026-05-28
 | `cdx reset <name> [--yes] [--json]` | Explicitly consume one available banked Codex rate-limit reset; confirmation is required unless `--yes` is supplied |
 | `cdx export <file> [--include-auth] [--sessions a,b] [--passphrase-env VAR\|--passphrase-stdin] [--force] [--json]` | Export sessions to a portable bundle; `--include-auth` encrypts auth data with a passphrase |
 | `cdx import <file> [--sessions a,b] [--passphrase-env VAR\|--passphrase-stdin] [--force] [--json]` | Import sessions from a bundle into the current `CDX_HOME` |
-| `cdx doctor [--json]` | Inspect CLI dependencies, provider CLI versions/capability hints, CDX_HOME permissions, missing state, orphan profiles, and pending quarantines |
+| `cdx doctor [--severity OK|WARN|FAIL[,OK|WARN|FAIL...]] [--json]` | Inspect CLI dependencies, provider CLI versions/capability hints, CDX_HOME permissions, missing state, orphan profiles, and pending quarantines; optionally filter issue severities |
 | `cdx repair [--dry-run] [--force] [--json]` | Plan or apply safe repairs for missing state files, quarantines, and orphan profiles |
 | `cdx view [--json] [--lan] [--lan-rw] [--focus <ref>] [--read] [--port <port>] [--host <host>] [--refresh-interval <s>] [--tls] [--tls-cert <path>] [--tls-key <path>] [--open] [--no-open]` | Open the Logics browser/focus viewer by delegating to `logics-manager view`; all viewer flags are forwarded; JSON mode reports diagnostics without launching it |
 | `cdx update [--check] [--yes] [--json] [--version TAG]` | Update cdx-manager using the installer that matches how it was installed |
+| `cdx update all [--yes] [--json]` | Check installed providers, RTK, and Ponytail across Codex profiles; show the plan and ask once before applying safe native/Homebrew updates and missing RTK/Ponytail setup |
 | `cdx ready [--refresh] [--json]` | Schedule an OS notification for the next cooling-down assistant that becomes ready, then return immediately |
 | `cdx notify <name> --at-reset [--poll seconds] [--once] [--schedule] [--refresh] [--json]` | Wait for a session reset time or schedule an OS wake-up notification when due |
 | `cdx notify --next-ready [--poll seconds] [--once] [--schedule] [--refresh] [--json]` | Wait until the recommended session is usable, or schedule the next known reset notification |

package/changelogs/CHANGELOGS_0_12_1.md

@@ -0,0 +1,25 @@
+# CDX Manager 0.12.1
+
+## Highlights
+
+- Added `cdx update all` to inventory and safely update the installed provider CLIs, RTK, and Ponytail across Codex profiles.
+- Made account handoffs use native provider transcripts before terminal capture, preserving actionable conversation instead of terminal noise.
+
+## Changes
+
+### Workstation updates
+
+`cdx update all` now reports installed versions and session setup, asks once before applying its plan, and shows progress plus the command and error output when an action fails. It follows the actual installer provenance of each CLI, including the Claude Code cask rather than the separate Claude desktop app.
+
+RTK is enabled for sessions that lack it when available. Ponytail marketplaces and plugins are checked per Codex profile; current Codex marketplace caches without a `last_revision` field are resolved from their Git checkout.
+
+### Reliable handoffs
+
+Cross-session handoffs now prefer native JSONL transcripts and retain only user and assistant messages. Script-captured terminal logs remain a fallback, but no longer displace structured provider conversation or tool-output noise into the shared context.
+
+## Validation
+
+- `npm run lint`
+- `npm test`
+- `logics-manager lint --require-status`
+- `logics-manager audit --group-by-doc`

package/changelogs/CHANGELOGS_0_12_2.md

@@ -0,0 +1,28 @@
+# CDX Manager 0.12.2
+
+## Highlights
+
+- `cdx ready` now exits successfully when no future reset is known, clearly reporting that no notification was scheduled.
+- `cdx doctor` can filter diagnostics by severity with `--severity OK|WARN|FAIL`.
+- Unknown `cdx config <name>` sessions now explain how to inspect existing sessions or create the requested one.
+
+## Changes
+
+### Safer ready notifications
+
+When `cdx ready` cannot find an upcoming session reset, it returns a successful unscheduled result instead of failing. Named reset notifications with no known reset remain explicit errors.
+
+### Filterable diagnostics
+
+`cdx doctor --severity` accepts a comma-separated list of `OK`, `WARN`, and `FAIL` statuses. Text and JSON output retain accurate summaries for the filtered report.
+
+### Actionable configuration errors
+
+Unknown-session errors from `cdx config` now direct users to `cdx configs` to inspect available sessions and `cdx add <name>` to create one.
+
+## Validation
+
+- `npm run lint`
+- `npm test`
+- `logics-manager lint --require-status`
+- `logics-manager audit --group-by-doc`

package/checksums/release-archives.json

@@ -148,6 +148,14 @@
     "v0.11.2": {
       "github_tarball_sha256": "513d7c586a662da5ac5daf792fc76f746e924bbd95157a9d0cbbeba34f2991e0",
       "github_zip_sha256": "d6d633efcbdc28818f68bd87efe3f246fe2983a9f4aa24d03868c978645c593e"
+    },
+    "v0.12.0": {
+      "github_tarball_sha256": "de1bac90e790b5d557f90fd22f7dd317c45646d0e07320c05c8b2336ed9bbced",
+      "github_zip_sha256": "213f6217dfd8c7aa979af691c2d63598b4589ca40f36e816f4ae9c9f2da27073"
+    },
+    "v0.12.1": {
+      "github_tarball_sha256": "87e3b11886a8e7fb10233d425f6a1986e62395c89049947678a50cfb20384278",
+      "github_zip_sha256": "249f75eb240de7cc421f17579e0040d35eb06e3213568673f743c92191dda0f0"
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cdx-manager",
-  "version": "0.12.0",
+  "version": "0.12.2",
   "description": "Terminal session manager for Codex and Claude accounts.",
   "license": "MIT",
   "author": "Alexandre Agostini",

package/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "cdx-manager"
-version = "0.12.0"
+version = "0.12.2"
 description = "Terminal session manager for Codex and Claude accounts."
 readme = "README.md"
 requires-python = ">=3.9"

package/src/cli.py

@@ -78,7 +78,7 @@ from .status_view import (
 )
 from .update_check import check_for_update, check_logics_manager_for_update
 
-VERSION = "0.12.0"
+VERSION = "0.12.2"
 
 # Public surface: this module is a facade. Names below are imported above
 # purely to be re-exported (consumed by tests and external callers); listing
@@ -216,10 +216,10 @@ def _print_help(use_color=False):
         f"  {_style('cdx clean profiles (--tmp|--old-logs DAYS) [--yes] [--json]', '36', use_color)}",
         f"  {_style('cdx export <file> [--include-auth] [--sessions a,b] [--passphrase-env VAR|--passphrase-stdin] [--force] [--json]', '36', use_color)}",
         f"  {_style('cdx import <file> [--sessions a,b] [--passphrase-env VAR|--passphrase-stdin] [--force|--merge] [--json]', '36', use_color)}",
-        f"  {_style('cdx doctor [--json]', '36', use_color)}",
+        f"  {_style('cdx doctor [--severity OK|WARN|FAIL[,OK|WARN|FAIL...]] [--json]', '36', use_color)}",
         f"  {_style('cdx repair [--dry-run] [--force] [--json]', '36', use_color)}",
         f"  {_style('cdx view [--json]', '36', use_color)}",
-        f"  {_style('cdx update [--check] [--yes] [--json] [--version TAG]', '36', use_color)}",
+        f"  {_style('cdx update [all] [--check] [--yes] [--json] [--version TAG]', '36', use_color)}",
         f"  {_style('cdx ready [--refresh] [--json]', '36', use_color)}",
         f"  {_style('cdx notify <name> --at-reset [--schedule] [--refresh] [--json]', '36', use_color)}",
         f"  {_style('cdx notify --next-ready [--schedule] [--refresh] [--json]', '36', use_color)}",

package/src/cli_args.py

@@ -12,10 +12,10 @@ from .errors import CdxError
 from .provider_runtime import _normalize_reasoning_effort
 
 STATUS_USAGE = "Usage: cdx status [--json] [--refresh|--cached] [--timeout SECONDS] | cdx status --small|-s [--refresh|--cached] [--timeout SECONDS] | cdx status <name> [--json] [--refresh|--cached] [--timeout SECONDS]"
-DOCTOR_USAGE = "Usage: cdx doctor [--json]"
+DOCTOR_USAGE = "Usage: cdx doctor [--severity OK|WARN|FAIL[,OK|WARN|FAIL...]] [--json]"
 DISK_USAGE = "Usage: cdx disk [profiles] [--candidates] [--json]"
 REPAIR_USAGE = "Usage: cdx repair [--dry-run] [--force] [--json]"
-UPDATE_USAGE = "Usage: cdx update [--check] [--yes] [--json] [--version TAG]"
+UPDATE_USAGE = "Usage: cdx update [all] [--check] [--yes] [--json] [--version TAG]"
 EXPORT_USAGE = "Usage: cdx export <file> [--include-auth] [--force] [--json] [--sessions name1,name2] [--passphrase-env VAR|--passphrase-stdin]"
 IMPORT_USAGE = "Usage: cdx import <file> [--force|--merge] [--allow-authless-force] [--json] [--sessions name1,name2] [--passphrase-env VAR|--passphrase-stdin]"
 CONTEXT_USAGE = "Usage: cdx context show|path|init|edit|clear|set|append [text...] [--json]"
@@ -46,6 +46,35 @@ def _parse_json_flag(args):
     return json_flag, cleaned
 
 
+def _parse_doctor_args(args):
+    parsed = {"json": False, "severity": None}
+    index = 0
+    while index < len(args):
+        arg = args[index]
+        if arg == "--json":
+            parsed["json"] = True
+            index += 1
+            continue
+        if arg == "--severity":
+            if parsed["severity"] is not None or index + 1 >= len(args):
+                raise CdxError(DOCTOR_USAGE)
+            value = args[index + 1]
+            index += 2
+        elif arg.startswith("--severity="):
+            if parsed["severity"] is not None:
+                raise CdxError(DOCTOR_USAGE)
+            value = arg.split("=", 1)[1]
+            index += 1
+        else:
+            raise CdxError(DOCTOR_USAGE)
+
+        values = [item.strip().upper() for item in value.split(",")]
+        if not values or any(item not in {"OK", "WARN", "FAIL"} for item in values):
+            raise CdxError(DOCTOR_USAGE)
+        parsed["severity"] = ",".join(dict.fromkeys(values))
+    return parsed
+
+
 def _parse_flag_args(args, schema, usage, positionals_key=None, max_positionals=0):
     parsed = {spec["key"]: spec.get("default") for spec in schema.values()}
     positionals = []
@@ -594,11 +623,16 @@ def _parse_update_args(args):
         "--json": {"key": "json", "type": "bool", "default": False},
         "--yes": {"key": "yes", "type": "bool", "default": False},
         "--version": {"key": "version", "type": "str", "default": None},
-    }, UPDATE_USAGE)
+    }, UPDATE_USAGE, positionals_key="values", max_positionals=1)
+    if parsed["values"] not in ([], ["all"]):
+        raise CdxError(UPDATE_USAGE)
+    parsed["all"] = bool(parsed["values"])
+    if parsed["all"] and (parsed["check"] or parsed["version"]):
+        raise CdxError("Usage: cdx update all [--yes] [--json]")
     if parsed["check"] and parsed["version"]:
         raise CdxError("Usage: cdx update --check cannot be combined with --version.")
     if parsed["version"] is not None and not parsed["version"].strip():
-        raise CdxError("Usage: cdx update [--check] [--yes] [--json] [--version TAG]")
+        raise CdxError(UPDATE_USAGE)
     return parsed
 
 

package/src/cli_commands.py

@@ -17,7 +17,6 @@ from .cli_args import (
     CAN_RESUME_USAGE,
     CONTEXT_USAGE,
     DISK_USAGE,
-    DOCTOR_USAGE,
     HANDOFF_USAGE,
     LAST_USAGE,
     MEMORY_USAGE,
@@ -33,6 +32,7 @@ from .cli_args import (
     _parse_config_args,
     _parse_configs_args,
     _parse_copy_args,
+    _parse_doctor_args,
     _parse_export_args,
     _parse_flag_args,
     _parse_history_args,
@@ -98,7 +98,7 @@ from .context_store import (
 )
 from .errors import CdxError
 from .fs_utils import atomic_write
-from .health import collect_health_report, format_health_report
+from .health import collect_health_report, filter_health_report, format_health_report
 from .notify import (
     format_notify_event,
     format_scheduled_notification,
@@ -124,10 +124,46 @@ from .run_command import read_run_prompt, run_cdx_error_code, run_result_payload
 from .run_registry import RunRegistry, build_code_review_report
 from .run_usage import extract_run_usage
 from .status_view import _format_status_detail, _format_status_rows, format_priority_instruction, recommend_priority_rows
+from .update_all import apply_update_all_plan, collect_update_all_plan
 from .update_check import LatestReleaseCheckError, fetch_latest_release, fetch_latest_release_or_raise, is_newer_version
 from .update_manager import build_update_plan, format_update_failure, run_update_plan, verify_updated_command
 
 
+def _format_update_all(plan, use_color=False):
+    labels = {
+        "up_to_date": _success("OK", use_color),
+        "update_available": _warn("UPDATE", use_color),
+        "not_installed": _warn("MISSING", use_color),
+        "check_with_native_updater": _info("CHECK", use_color),
+    }
+    rows = [[_style("TOOL", "1", use_color), _style("CURRENT", "1", use_color), _style("LATEST", "1", use_color), _style("STATUS", "1", use_color)]]
+    for item in plan["items"]:
+        rows.append([_info(item["name"], use_color), item.get("version") or _dim("-", use_color), item.get("latest_version") or _dim("-", use_color), labels.get(item["status"], item["status"].replace("_", " "))])
+    lines = [_style("Workstation update", "1", use_color), _dim("Inventory only — nothing has changed.", use_color), "", _pad_table(rows)]
+    missing_rtk = plan["setup"]["rtk_missing_sessions"]
+    setup = [f"RTK: enable for {', '.join(missing_rtk)}" if missing_rtk else "RTK: configured for every session"]
+    setup.extend(f"Ponytail {plugin['session']}: {labels.get(plugin['status'], plugin['status'].replace('_', ' '))}" for plugin in plan["setup"]["ponytail"])
+    lines.extend(["", _style("Session setup", "1", use_color), *setup])
+    if plan["steps"]:
+        lines.extend(["", _warn(f"{len(plan['steps'])} action(s) ready", use_color), _dim("Confirm to update only the tools listed above.", use_color)])
+    else:
+        lines.extend(["", _success("Everything managed by CDX is current and configured.", use_color)])
+    return "\n".join(lines)
+
+
+def _format_update_all_result(result, use_color=False):
+    if result.get("skipped"):
+        return _warn(f"skipped: {result['name']} (blocked by {result['blocked_by']})", use_color)
+    if result.get("returncode") == 0:
+        return _success(f"done: {result['name']}", use_color)
+    detail = str(result.get("stderr") or result.get("stdout") or "No error output.").strip().replace("\n", " ")
+    detail = detail[-500:]
+    command = shlex.join(result.get("command") or [])
+    suffix = f"\n  {_dim(command, use_color)}" if command else ""
+    label = _warn(f"failed: {result['name']} (exit {result.get('returncode')})", use_color)
+    return f"{label}\n  {detail}{suffix}"
+
+
 def _resolve_bundle_passphrase(ctx, env_var, prompt, confirm=False, use_stdin=False):
     env = ctx.get("env", {})
     if env_var:
@@ -1664,7 +1700,10 @@ def handle_config(rest, ctx):
     parsed = _parse_config_args(rest)
     session = ctx["service"]["get_session"](parsed["name"])
     if not session:
-        raise CdxError(f"Unknown session: {parsed['name']}")
+        raise CdxError(
+            f"Unknown session: {parsed['name']}. Run cdx configs to inspect existing sessions or "
+            f"cdx add {parsed['name']} to create it."
+        )
     message = f"Launch settings for {parsed['name']}"
     if parsed["json"]:
         _write_json(ctx, _json_success("config", message, session=session, launch=session.get("launch") or {}))
@@ -1857,17 +1896,15 @@ def handle_clean(rest, ctx):
 
 
 def handle_doctor(rest, ctx):
-    json_flag = "--json" in rest
-    unknown = [arg for arg in rest if arg != "--json"]
-    if unknown:
-        raise CdxError(DOCTOR_USAGE)
+    parsed = _parse_doctor_args(rest)
     report = collect_health_report(
         ctx["service"],
         ctx["service"]["base_dir"],
         env=ctx.get("env"),
         spawn_sync=ctx.get("spawn_sync"),
     )
-    if json_flag:
+    report = filter_health_report(report, parsed["severity"])
+    if parsed["json"]:
         _write_json(ctx, _json_success("doctor", "Collected health report", report=report))
     else:
         ctx["out"](f"{format_health_report(report, use_color=ctx['use_color'])}\n")
@@ -2674,6 +2711,38 @@ def handle_logout(rest, ctx):
 
 def handle_update(rest, ctx):
     parsed = _parse_update_args(rest)
+    if parsed["all"]:
+        plan = collect_update_all_plan(ctx["service"], env=ctx.get("env"), runner=ctx["options"].get("runUpdateAll"))
+        if not parsed["yes"]:
+            if parsed["json"]:
+                _write_json(ctx, _json_success("update.all", "Collected workstation update plan", plan=plan, apply_required=bool(plan["steps"])))
+                return 0
+            ctx["out"](f"{_format_update_all(plan, ctx['use_color'])}\n")
+            if not plan["steps"]:
+                return 0
+            if not ctx["stdin_is_tty"]:
+                raise CdxError("cdx update all requires an interactive terminal or --yes.")
+            if input("Apply this plan? [y/N] ").strip().lower() not in ("y", "yes"):
+                ctx["out"](f"{_warn('Cancelled.', ctx['use_color'])}\n")
+                return 0
+        def progress(event):
+            if parsed["json"]:
+                return
+            step_name = event["step"]["name"]
+            if event["phase"] == "start":
+                progress_label = _info(f"[{event['index']}/{event['total']}]", ctx["use_color"])
+                ctx["out"](f"{progress_label} {step_name}...\n")
+            else:
+                ctx["out"](f"  {_format_update_all_result(event['result'], ctx['use_color'])}\n")
+
+        results = apply_update_all_plan(plan, ctx["service"], env=ctx.get("env"), runner=ctx["options"].get("runUpdateAll"), progress=progress)
+        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)))
+        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
     json_flag = parsed["json"]
     current_version = str(ctx.get("version") or "").strip()
     release_fetcher = ctx["options"].get("fetchLatestRelease") or fetch_latest_release

package/src/cli_helpers.py

@@ -250,11 +250,10 @@ def _collect_native_handoff_transcript_paths(session):
 
 
 def _latest_handoff_transcript_path(session):
-    launch_path = _latest_launch_transcript_path(session)
-    if launch_path:
-        return launch_path
     native_paths = _collect_native_handoff_transcript_paths(session)
-    return native_paths[0] if native_paths else None
+    if native_paths:
+        return native_paths[0]
+    return _latest_launch_transcript_path(session)
 
 
 def _collect_handoff_text_fragments(value):
@@ -281,6 +280,10 @@ def _collect_handoff_text_fragments(value):
 def _jsonl_record_to_handoff_text(record):
     if not isinstance(record, dict):
         return None
+    if record.get("type") == "response_item":
+        record = record.get("payload")
+        if not isinstance(record, dict):
+            return None
     message = record.get("message") if isinstance(record.get("message"), dict) else {}
     role = (
         message.get("role")
@@ -289,6 +292,8 @@ def _jsonl_record_to_handoff_text(record):
         or record.get("sender")
         or "entry"
     )
+    if role not in ("user", "assistant"):
+        return None
     text_sources = []
     for key in ("content", "text", "payload"):
         if key in record:

package/src/health.py

@@ -363,6 +363,19 @@ def summarize_health(issues):
     }
 
 
+def filter_health_report(report, severity):
+    if severity is None:
+        return report
+    severities = set(severity.split(","))
+    issues = [issue for issue in report["issues"] if issue["status"] in severities]
+    return {
+        **report,
+        "issues": issues,
+        "summary": summarize_health(issues),
+        "severity": severity,
+    }
+
+
 def format_health_report(report, use_color=False):
     rows = [["STATUS", "CHECK", "MESSAGE"]]
     for issue in report["issues"]:

package/src/notify.py

@@ -221,6 +221,13 @@ def schedule_notification_event(base_dir, parsed, event, spawn_sync=None, env=No
     now_fn = now_fn or time.time
     target_timestamp = event.get("target_timestamp")
     if target_timestamp is None:
+        if parsed["mode"] == "next-ready":
+            return {
+                "scheduled": False,
+                "backend": "none",
+                "message": event["message"],
+                "target_timestamp": None,
+            }
         raise CdxError(f"Cannot schedule notification: {event['message']}")
     if target_timestamp <= now_fn():
         return {

package/src/update_all.py

@@ -0,0 +1,184 @@
+"""Inventory and apply the safe, known updates for a CDX workstation."""
+
+import json
+import os
+import re
+import shutil
+import subprocess
+
+from .config import PROVIDER_ANTIGRAVITY, PROVIDER_CLAUDE, PROVIDER_CODEX, PROVIDER_OLLAMA
+
+_TOOLS = (
+    (PROVIDER_CODEX, "codex", None, ["codex", "update"]),
+    (PROVIDER_CLAUDE, "claude", "claude", ["brew", "upgrade", "--cask", "claude"]),
+    (PROVIDER_ANTIGRAVITY, "agy", "antigravity", ["brew", "upgrade", "--cask", "antigravity"]),
+    (PROVIDER_OLLAMA, "ollama", "ollama", ["brew", "upgrade", "ollama"]),
+    ("rtk", "rtk", "rtk", ["brew", "upgrade", "rtk"]),
+)
+_PONYTAIL_URL = "https://github.com/DietrichGebert/ponytail.git"
+
+
+def _which(command, env):
+    path = env.get("PATH")
+    resolved = shutil.which(command, path=path)
+    if resolved or not path:
+        return resolved
+    for directory in path.split(os.pathsep):
+        candidate = os.path.join(directory, command)
+        if os.path.isfile(candidate):
+            return candidate
+    return None
+
+
+def _run(command, env, runner=None, timeout=15):
+    runner = runner or subprocess.run
+    try:
+        result = runner(command, env=env, capture_output=True, text=True, check=False, timeout=timeout)
+    except (OSError, subprocess.TimeoutExpired) as error:
+        return {"returncode": 1, "stdout": "", "stderr": str(error)}
+    if isinstance(result, dict):
+        return result
+    return {"returncode": result.returncode, "stdout": result.stdout or "", "stderr": result.stderr or ""}
+
+
+def _version(command, env, runner):
+    result = _run([command, "--version"], env, runner)
+    text = (result["stdout"] or result["stderr"] or "").strip()
+    match = re.search(r"\b(\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?)\b", text)
+    return match.group(1) if match else None
+
+
+def _npm_latest(package, env, runner):
+    if not _which("npm", env):
+        return None
+    result = _run(["npm", "view", package, "version"], env, runner)
+    value = (result["stdout"] or "").strip()
+    return value if re.fullmatch(r"\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?", value) else None
+
+
+def _newer(latest, current):
+    def key(value):
+        return tuple(int(part) for part in str(value).split("-", 1)[0].split("+", 1)[0].split("."))
+    return bool(latest and current and key(latest) > key(current))
+
+
+def _brew_outdated(env, runner):
+    if not _which("brew", env):
+        return {}
+    result = _run(["brew", "outdated", "--json=v2"], env, runner, timeout=30)
+    try:
+        payload = json.loads(result["stdout"])
+    except (TypeError, ValueError):
+        return {}
+    rows = {}
+    for group in ("formulae", "casks"):
+        for item in payload.get(group, []):
+            rows[item.get("name")] = item
+    return rows
+
+
+def _brew_cask_for_path(path):
+    match = re.search(r"/Caskroom/([^/]+)/", os.path.realpath(path or ""))
+    return match.group(1) if match else None
+
+
+def _ponytail_revision(auth_home, env=None, runner=None):
+    try:
+        with open(os.path.join(auth_home, "config.toml"), encoding="utf-8") as handle:
+            text = handle.read()
+    except OSError:
+        text = ""
+    match = re.search(r'\[marketplaces\.ponytail\].*?last_revision\s*=\s*"([0-9a-f]+)"', text, re.S)
+    if match:
+        return match.group(1)
+    cache = os.path.join(auth_home, ".tmp", "marketplaces", "ponytail")
+    result = _run(["git", "-C", cache, "rev-parse", "HEAD"], env or os.environ, runner)
+    revision = (result["stdout"] or "").strip()
+    return revision if re.fullmatch(r"[0-9a-f]{40}", revision) else None
+
+
+def collect_update_all_plan(service, env=None, runner=None):
+    env = dict(env or os.environ)
+    outdated = _brew_outdated(env, runner)
+    items, steps = [], []
+    for name, command, brew_name, update_command in _TOOLS:
+        path = _which(command, env)
+        item = {"name": name, "command": command, "installed": bool(path), "path": path, "version": _version(command, env, runner) if path else None}
+        cask_name = _brew_cask_for_path(path)
+        brew_target = cask_name or brew_name
+        brew_row = outdated.get(brew_target) if brew_target else None
+        if brew_row:
+            command_to_run = ["brew", "upgrade", "--cask", brew_target] if cask_name else update_command
+            item.update({"status": "update_available", "latest_version": brew_row.get("current_version"), "update_command": command_to_run, "package": brew_target})
+            steps.append({"name": name, "command": command_to_run, "env": {}})
+        elif path and name == PROVIDER_CODEX:
+            # Codex owns its installer; it is the only reliable updater across npm, Homebrew and standalone installs.
+            latest = _npm_latest("@openai/codex", env, runner)
+            item.update({"latest_version": latest, "status": "update_available" if _newer(latest, item["version"]) else "up_to_date" if latest else "check_with_native_updater", "update_command": update_command})
+            if item["status"] != "up_to_date":
+                steps.append({"name": name, "command": update_command, "env": {}})
+        else:
+            item["status"] = "up_to_date" if path else "not_installed"
+        items.append(item)
+
+    rtk_available = any(item["name"] == "rtk" and item["installed"] for item in items)
+    missing_rtk = [session["name"] for session in service["list_sessions"]() if not (session.get("launch") or {}).get("rtk")]
+    setup = {"rtk_available": rtk_available, "rtk_missing_sessions": missing_rtk, "ponytail": []}
+    if rtk_available and missing_rtk:
+        steps.append({"name": "enable RTK", "command": None, "sessions": missing_rtk})
+
+    codex_sessions = [session for session in service["list_sessions"]() if session.get("provider") == PROVIDER_CODEX]
+    ponytail_head = None
+    if any(_ponytail_revision(session.get("authHome") or "", env, runner) for session in codex_sessions):
+        remote = _run(["git", "ls-remote", _PONYTAIL_URL, "HEAD"], env, runner)
+        ponytail_head = (remote["stdout"] or "").split("\t", 1)[0].strip() or None
+    for session in codex_sessions:
+        revision = _ponytail_revision(session.get("authHome") or "", env, runner)
+        row = {"session": session["name"], "installed": bool(revision), "revision": revision}
+        if revision:
+            row["latest_revision"] = ponytail_head
+            row["status"] = "update_available" if ponytail_head and not ponytail_head.startswith(revision) else "up_to_date"
+            if row["status"] == "update_available":
+                steps.append({"name": f"update Ponytail ({session['name']})", "command": ["codex", "plugin", "marketplace", "upgrade", "ponytail", "--json"], "env": {"CODEX_HOME": session["authHome"]}})
+        else:
+            row["status"] = "not_installed"
+            marketplace_id = f"ponytail-marketplace:{session['name']}"
+            steps.extend([
+                {"id": marketplace_id, "name": f"add Ponytail marketplace ({session['name']})", "command": ["codex", "plugin", "marketplace", "add", _PONYTAIL_URL], "env": {"CODEX_HOME": session["authHome"]}},
+                {"name": f"install Ponytail ({session['name']})", "command": ["codex", "plugin", "add", "ponytail@ponytail", "--json"], "env": {"CODEX_HOME": session["authHome"]}, "requires": marketplace_id},
+            ])
+        setup["ponytail"].append(row)
+    return {"items": items, "setup": setup, "steps": steps}
+
+
+def apply_update_all_plan(plan, service, env=None, runner=None, progress=None):
+    env = dict(env or os.environ)
+    results = []
+    completed = set()
+    for index, step in enumerate(plan["steps"], start=1):
+        if progress:
+            progress({"phase": "start", "index": index, "total": len(plan["steps"]), "step": step})
+        if step.get("requires") and step["requires"] not in completed:
+            result = {"name": step["name"], "returncode": None, "skipped": True, "blocked_by": step["requires"]}
+            results.append(result)
+            if progress:
+                progress({"phase": "done", "index": index, "total": len(plan["steps"]), "step": step, "result": result})
+            continue
+        if step["command"] is None:
+            for name in step["sessions"]:
+                service["set_launch_settings"](name, {"rtk": True})
+            result = {"name": step["name"], "returncode": 0, "sessions": step["sessions"]}
+            results.append(result)
+            if step.get("id"):
+                completed.add(step["id"])
+            if progress:
+                progress({"phase": "done", "index": index, "total": len(plan["steps"]), "step": step, "result": result})
+            continue
+        result = _run(step["command"], {**env, **step.get("env", {})}, runner, timeout=120)
+        result = {"name": step["name"], "command": step["command"], **result}
+        results.append(result)
+        if result["returncode"] == 0 and step.get("id"):
+            completed.add(step["id"])
+        if progress:
+            progress({"phase": "done", "index": index, "total": len(plan["steps"]), "step": step, "result": result})
+    return results