cdx-manager 0.9.4 → 0.9.5

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.9.4-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.9.5-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.**
 
@@ -69,6 +69,7 @@ One command to launch any session. Zero auth juggling.
   - Primary source: recorded status fields on the session record.
   - Codex live source: `codex app-server` JSON-RPC `account/rateLimits/read`, normalized into 5-hour, weekly, reset, credit, and plan fields.
   - Fallback: `status-source` scans provider JSONL history files and terminal log transcripts, strips ANSI/OSC sequences, and extracts `usage%`, `5h remaining%`, and `week remaining%` via pattern matching.
+- Status latency controls: use `cdx status --cached` to skip live probes, `cdx status --timeout SECONDS` for one command, or `CDX_STATUS_TIMEOUT_SECONDS` to lower the default Codex live-probe timeout.
 - Claude status refreshes are cached briefly by default; pass `--refresh` to force a live rate-limit probe.
 - On Linux, transcript capture uses the `util-linux` `script -c` command form.
 - If `script` is unavailable, Codex launch falls back to running without transcript capture.
@@ -364,9 +365,9 @@ cdx history --summary --from 2026-05-01 --to 2026-05-28
 | `cdx select --provider PROVIDER [--min-reasoning-effort minimal\|low\|medium\|high\|xhigh] [--min-power minimal\|low\|medium\|high\|xhigh] [--require-ready] [--refresh] --json` | Select a suitable session for headless automation |
 | `cdx run [session] --cwd PATH (--prompt-file PATH\|--prompt TEXT) [--provider PROVIDER] [--model MODEL] [--reasoning-effort minimal\|low\|medium\|high\|xhigh] [--power minimal\|low\|medium\|high\|xhigh] [--permission MODE] [--timeout-seconds N] --json` | Run one headless task and return a stable JSON result |
 | `cdx stats [name] [--since 7d\|today\|DATE] [--from DATE] [--to DATE] [--json]` | Aggregate launch counts, duration, and known headless token usage by session |
-| `cdx status [--json] [--refresh]` | Show token usage table for all sessions; JSON returns a versioned payload with structured warnings |
-| `cdx status --small [--refresh]` / `cdx status -s [--refresh]` | Show compact token usage table without provider, blocking quota, credits, and updated columns |
-| `cdx status <name> [--json] [--refresh]` | Show detailed usage breakdown for one session |
+| `cdx status [--json] [--refresh\|--cached] [--timeout SECONDS]` | Show token usage table for all sessions; `--cached` skips live provider probes and returns only stored status |
+| `cdx status --small [--refresh\|--cached] [--timeout SECONDS]` / `cdx status -s [--refresh\|--cached] [--timeout SECONDS]` | Show compact token usage table without provider, blocking quota, credits, and updated columns |
+| `cdx status <name> [--json] [--refresh\|--cached] [--timeout SECONDS]` | Show detailed usage breakdown for one session; `--cached` avoids live provider refreshes |
 | `cdx --help` | Show usage |
 | `cdx --version` | Show version |
 
@@ -429,7 +430,7 @@ Most commands use a shared stderr JSON envelope for errors whenever `--json` is
   "ok": false,
   "error": {
     "code": "invalid_usage",
-    "message": "Usage: cdx status [--json] [--refresh] | ...",
+    "message": "Usage: cdx status [--json] [--refresh|--cached] [--timeout SECONDS] | ...",
     "exit_code": 1
   }
 }

package/changelogs/CHANGELOGS_0_9_5.md

@@ -0,0 +1,45 @@
+# CDX Manager 0.9.5
+
+## Highlights
+
+- Made per-session status lookup targeted instead of resolving every configured session.
+- Added fast status controls for automation-heavy workspaces.
+- Added a Logics release contract for the `cdx-manager` release workflow.
+
+## Changes
+
+### Faster per-session status
+
+`cdx status <name>` now resolves only the named session. Previously the command collected all status rows and filtered afterward, so a detail lookup could still trigger live probes for every configured session.
+
+### Cached and bounded status probes
+
+`cdx status --cached` reads stored status only and skips live provider probes. This is intended for AGENTS prompts, health checks, and project scripts that need a quick snapshot without risking provider timeouts.
+
+Live Codex status probes can also be bounded with:
+
+```
+cdx status --timeout 1
+CDX_STATUS_TIMEOUT_SECONDS=1 cdx status
+```
+
+The timeout applies to Codex live rate-limit probes while preserving the existing cached and fallback behavior.
+
+### Release workflow contract
+
+The repository now includes `logics/release/contract.json` and `logics/release/release-contract.v1.schema.json`. The contract records the expected version sources, changelog path, checksum gate, validation commands, GitHub release gate, npm publication, and PyPI publication checks.
+
+## Validation
+
+- `python -m unittest discover -s test -p 'test_session_service_py.py'`
+- `python -m unittest discover -s test -p 'test_cli_py.py' -k 'status'`
+- `npm run lint`
+- JSON Schema validation for `logics/release/contract.json`
+- `logics-manager lint --require-status`
+- `logics-manager audit`
+- `git diff --check`
+- `node bin/cdx.js --version`
+- `python3 bin/cdx --version`
+- `npm --cache /private/tmp/cdx-npm-cache pack --dry-run`
+- `python -m build`
+- `python -m twine check dist/*`

package/checksums/release-archives.json

@@ -80,6 +80,10 @@
     "v0.9.3": {
       "github_tarball_sha256": "cb3cfd9134447d1049b510836014001fb6c38a89de588adc8cdbb1fe5deb4d6d",
       "github_zip_sha256": "056eb2d1a3f0fa721a7a0e597cd0409e496618cfa35791a78d4e184397596754"
+    },
+    "v0.9.4": {
+      "github_tarball_sha256": "fe1c96e612392130a98ec6d9856ec41fb0c055c1a274ee77f143b5e4b8c1fb2f",
+      "github_zip_sha256": "494b84aef93f796d78ef164c7b7670ba3dec1d81f66be966cb7a84d77d5ed6e3"
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cdx-manager",
-  "version": "0.9.4",
+  "version": "0.9.5",
   "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.9.4"
+version = "0.9.5"
 description = "Terminal session manager for Codex and Claude accounts."
 readme = "README.md"
 requires-python = ">=3.9"

package/src/cli.py

@@ -66,7 +66,7 @@ from .status_view import (
 )
 from .update_check import check_for_update, check_logics_manager_for_update
 
-VERSION = "0.9.4"
+VERSION = "0.9.5"
 
 
 # ---------------------------------------------------------------------------
@@ -80,9 +80,9 @@ 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 status [--json] [--refresh]', '36', use_color)}",
-        f"  {_style('cdx status --small|-s [--refresh]', '36', use_color)}",
-        f"  {_style('cdx status <name> [--json] [--refresh]', '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 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] --cwd PATH (--prompt-file PATH|--prompt TEXT) [--provider PROVIDER] [--model MODEL] [--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] --json', '36', use_color)}",

package/src/cli_commands.py

@@ -52,7 +52,7 @@ from .update_check import LatestReleaseCheckError, fetch_latest_release, fetch_l
 from .update_manager import build_update_plan, format_update_failure, run_update_plan, verify_updated_command
 
 
-STATUS_USAGE = "Usage: cdx status [--json] [--refresh] | cdx status --small|-s [--refresh] | cdx status <name> [--json] [--refresh]"
+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]"
 REPAIR_USAGE = "Usage: cdx repair [--dry-run] [--force] [--json]"
 UPDATE_USAGE = "Usage: cdx update [--check] [--yes] [--json] [--version TAG]"
@@ -672,13 +672,13 @@ def _parse_next_args(args):
     return {"json": parsed["json"], "refresh": parsed["refresh"]}
 
 
-def _parse_timeout_seconds(value):
+def _parse_timeout_seconds(value, usage=RUN_USAGE):
     try:
         parsed = float(value)
     except (TypeError, ValueError) as error:
-        raise CdxError(RUN_USAGE) from error
+        raise CdxError(usage) from error
     if parsed <= 0:
-        raise CdxError(RUN_USAGE)
+        raise CdxError(usage)
     return parsed
 
 
@@ -2487,18 +2487,26 @@ def handle_status(rest, ctx):
         "--small": {"key": "small", "type": "bool", "default": False},
         "-s": {"key": "small", "type": "bool", "default": False},
         "--refresh": {"key": "refresh", "type": "bool", "default": False},
+        "--cached": {"key": "cached", "type": "bool", "default": False},
+        "--timeout": {"key": "timeout", "type": "str", "default": None, "transform": lambda value: _parse_timeout_seconds(value, STATUS_USAGE)},
     }, STATUS_USAGE, positionals_key="args", max_positionals=1)
     if parsed["json"] and parsed["small"]:
         raise CdxError(STATUS_USAGE)
+    if parsed["refresh"] and parsed["cached"]:
+        raise CdxError(STATUS_USAGE)
     args = parsed["args"]
     if len(args) == 1 and parsed["small"]:
         raise CdxError(STATUS_USAGE)
 
-    auth_refresh = _refresh_claude_auth_states(
-        ctx["service"],
-        target_names=args if len(args) == 1 else None,
-        spawn_sync=ctx.get("spawn_sync"),
-        env_override=ctx.get("env"),
+    auth_refresh = (
+        {"errors": []}
+        if parsed["cached"]
+        else _refresh_claude_auth_states(
+            ctx["service"],
+            target_names=args if len(args) == 1 else None,
+            spawn_sync=ctx.get("spawn_sync"),
+            env_override=ctx.get("env"),
+        )
     )
     warnings = [
         {
@@ -2508,11 +2516,15 @@ def handle_status(rest, ctx):
         }
         for item in auth_refresh.get("errors", [])
     ]
-    refresh_result = _refresh_claude_sessions(
-        ctx["service"],
-        ctx.get("refresh_fn"),
-        target_names=args if len(args) == 1 else None,
-        force=parsed["refresh"],
+    refresh_result = (
+        {"errors": []}
+        if parsed["cached"]
+        else _refresh_claude_sessions(
+            ctx["service"],
+            ctx.get("refresh_fn"),
+            target_names=args if len(args) == 1 else None,
+            force=parsed["refresh"],
+        )
     )
     refresh_errors = [
         {
@@ -2532,26 +2544,32 @@ def handle_status(rest, ctx):
     warnings.extend(_update_notice_warnings(ctx))
 
     status_progress = None if parsed["json"] else _make_status_progress(ctx)
-    rows = ctx["service"]["get_status_rows"](
-        progress_callback=status_progress,
-        force_refresh=parsed["refresh"],
-    )
-    if len(args) == 0:
+    if len(args) == 1:
+        row = ctx["service"]["get_status_row"](
+            args[0],
+            progress_callback=status_progress,
+            force_refresh=parsed["refresh"],
+            cache_only=parsed["cached"],
+            status_timeout_seconds=parsed["timeout"],
+        )
         if parsed["json"]:
-            _write_json(ctx, _json_success("status", "Collected session status rows", warnings=warnings, rows=rows))
+            _write_json(ctx, _json_success("status", f"Collected status for {args[0]}", warnings=warnings, session=row))
             return 0
-        ctx["out"](f"{_format_status_rows(rows, use_color=ctx['use_color'], small=parsed['small'])}\n")
+        ctx["out"](f"{_format_status_detail(row, use_color=ctx['use_color'])}\n")
         _write_refresh_warnings(refresh_errors, ctx)
         _write_update_notice(ctx)
         return 0
 
-    row = next((r for r in rows if r["session_name"] == args[0]), None)
-    if not row:
-        raise CdxError(f"Unknown session: {args[0]}")
+    rows = ctx["service"]["get_status_rows"](
+        progress_callback=status_progress,
+        force_refresh=parsed["refresh"],
+        cache_only=parsed["cached"],
+        status_timeout_seconds=parsed["timeout"],
+    )
     if parsed["json"]:
-        _write_json(ctx, _json_success("status", f"Collected status for {args[0]}", warnings=warnings, session=row))
+        _write_json(ctx, _json_success("status", "Collected session status rows", warnings=warnings, rows=rows))
         return 0
-    ctx["out"](f"{_format_status_detail(row, use_color=ctx['use_color'])}\n")
+    ctx["out"](f"{_format_status_rows(rows, use_color=ctx['use_color'], small=parsed['small'])}\n")
     _write_refresh_warnings(refresh_errors, ctx)
     _write_update_notice(ctx)
     return 0

package/src/session_service.py

@@ -67,6 +67,7 @@ RESERVED_SESSION_NAMES = {
 }
 STATUS_CACHE_TTL_SECONDS = 60
 CLAUDE_STATUS_CACHE_TTL_SECONDS = 10 * 60
+STATUS_PROBE_TIMEOUT_SECONDS = 5
 MAX_STATUS_WORKERS = 8
 LAUNCH_POWER_VALUES = {"minimal", "low", "medium", "high", "xhigh"}
 LAUNCH_REASONING_EFFORT_VALUES = {"minimal", "low", "medium", "high", "xhigh"}
@@ -278,6 +279,18 @@ def _status_cache_ttl_seconds(session, ttl_seconds=STATUS_CACHE_TTL_SECONDS):
     return ttl_seconds
 
 
+def _parse_status_timeout_seconds(value):
+    if value in (None, ""):
+        return None
+    try:
+        parsed = float(value)
+    except (TypeError, ValueError):
+        return None
+    if parsed <= 0:
+        return None
+    return parsed
+
+
 def _is_status_cache_fresh(session, ttl_seconds=STATUS_CACHE_TTL_SECONDS):
     status = session.get("lastStatus") or {}
     if _is_low_confidence_status_source(status):
@@ -433,7 +446,19 @@ def create_session_service(options=None):
     env = options.get("env", os.environ)
     base_dir = options.get("base_dir") or get_cdx_home(env)
     store = options.get("store") or create_session_store(base_dir)
-    codex_status_fetcher = options.get("fetchCodexRateLimits") or fetch_codex_rate_limits
+    custom_codex_status_fetcher = options.get("fetchCodexRateLimits")
+    codex_status_fetcher = custom_codex_status_fetcher or fetch_codex_rate_limits
+    default_status_timeout_seconds = (
+        _parse_status_timeout_seconds(options.get("statusTimeoutSeconds"))
+        or _parse_status_timeout_seconds(env.get("CDX_STATUS_TIMEOUT_SECONDS"))
+        or STATUS_PROBE_TIMEOUT_SECONDS
+    )
+
+    def _fetch_codex_status(session, timeout_seconds=None):
+        if custom_codex_status_fetcher:
+            return custom_codex_status_fetcher(session)
+        timeout = timeout_seconds or default_status_timeout_seconds
+        return codex_status_fetcher(session, timeout=timeout)
 
     def _get_session_root(name):
         return os.path.join(base_dir, "profiles", _encode(name))
@@ -907,17 +932,28 @@ def create_session_service(options=None):
             raise CdxError(f"Unknown session: {name}")
         return store["list_launch_history"](session_name=name, limit=limit)
 
-    def _resolve_session_status(session, force_refresh=False, cache_ttl_seconds=STATUS_CACHE_TTL_SECONDS):
+    def _resolve_session_status(
+        session,
+        force_refresh=False,
+        cache_ttl_seconds=STATUS_CACHE_TTL_SECONDS,
+        cache_only=False,
+        status_timeout_seconds=None,
+    ):
         current_status = session.get("lastStatus")
         if session.get("enabled", True) is False:
             return current_status
+        if cache_only:
+            return current_status
         if current_status and not force_refresh and _is_status_cache_fresh(session, ttl_seconds=cache_ttl_seconds):
             return current_status
         source_root = session.get("authHome") or _get_session_auth_home(
             session["name"], session["provider"]
         )
         if session["provider"] == PROVIDER_CODEX and codex_status_fetcher:
-            live_status = codex_status_fetcher({**session, "authHome": source_root})
+            live_status = _fetch_codex_status(
+                {**session, "authHome": source_root},
+                timeout_seconds=status_timeout_seconds,
+            )
             if live_status:
                 record_status(session["name"], live_status)
                 return live_status
@@ -983,41 +1019,133 @@ def create_session_service(options=None):
             raise CdxError(f"Unknown session: {name}")
         return updated
 
-    def get_status_rows(progress_callback=None, force_refresh=False, cache_ttl_seconds=STATUS_CACHE_TTL_SECONDS):
-        sessions = list_sessions()
-
-        def _status_cache_hit(s):
-            return (
-                s.get("enabled", True) is False
-                or (
-                    s.get("lastStatus")
-                    and not force_refresh
-                    and _is_status_cache_fresh(s, ttl_seconds=cache_ttl_seconds)
-                )
+    def _status_cache_hit(s, force_refresh=False, cache_ttl_seconds=STATUS_CACHE_TTL_SECONDS, cache_only=False):
+        return (
+            cache_only
+            or s.get("enabled", True) is False
+            or (
+                s.get("lastStatus")
+                and not force_refresh
+                and _is_status_cache_fresh(s, ttl_seconds=cache_ttl_seconds)
             )
+        )
 
-        cache_hits = {
-            s["name"]: _status_cache_hit(s)
-            for s in sessions
+    def _resolve_row_session(
+        s,
+        force_refresh=False,
+        cache_ttl_seconds=STATUS_CACHE_TTL_SECONDS,
+        cache_only=False,
+        status_timeout_seconds=None,
+    ):
+        status = _resolve_session_status(
+            s,
+            force_refresh=force_refresh,
+            cache_ttl_seconds=cache_ttl_seconds,
+            cache_only=cache_only,
+            status_timeout_seconds=status_timeout_seconds,
+        )
+        return {
+            **s,
+            "lastStatus": status,
+            "lastStatusAt": (status and status.get("updated_at")) or s.get("lastStatusAt"),
         }
+
+    def _status_row_from_session(s):
+        status = s.get("lastStatus")
+        enabled = s.get("enabled", True) is not False
+        row_status = status if enabled else None
+        return {
+            "session_name": s["name"],
+            "provider": s["provider"],
+            "enabled": enabled,
+            "active": bool(_session_runtime(s["name"])) if enabled else False,
+            "status": "enabled" if enabled else "disabled",
+            "auth_status": (s.get("auth") or {}).get("status") or "unknown",
+            "auth_checked_at": _to_local_iso((s.get("auth") or {}).get("lastCheckedAt")),
+            "remaining_5h_pct": _normalize_pct_value(row_status.get("remaining_5h_pct")) if row_status else None,
+            "remaining_week_pct": _normalize_pct_value(row_status.get("remaining_week_pct")) if row_status else None,
+            "credits": row_status.get("credits") if row_status else None,
+            "available_pct": _compute_available_pct(row_status),
+            "reset_5h_at": row_status.get("reset_5h_at") if row_status else None,
+            "reset_week_at": row_status.get("reset_week_at") if row_status else None,
+            "reset_at": row_status.get("reset_at") if row_status else None,
+            "updated_at": _to_local_iso(s.get("lastStatusAt")),
+            "last_launched_at": _to_local_iso(s.get("lastLaunchedAt")),
+        }
+
+    def get_status_row(
+        name,
+        progress_callback=None,
+        force_refresh=False,
+        cache_ttl_seconds=STATUS_CACHE_TTL_SECONDS,
+        cache_only=False,
+        status_timeout_seconds=None,
+    ):
+        session = store["get_session"](name)
+        if not session:
+            raise CdxError(f"Unknown session: {name}")
+        cache_hit = _status_cache_hit(
+            session,
+            force_refresh=force_refresh,
+            cache_ttl_seconds=cache_ttl_seconds,
+            cache_only=cache_only,
+        )
         if progress_callback:
             progress_callback({
                 "event": "status_started",
-                "session_count": len(sessions),
-                "check_count": sum(1 for cache_hit in cache_hits.values() if not cache_hit),
+                "session_count": 1,
+                "check_count": 0 if cache_hit else 1,
+            })
+            if not cache_hit:
+                progress_callback({
+                    "event": "session_started",
+                    "session_name": session["name"],
+                    "provider": session["provider"],
+                })
+        resolved = _resolve_row_session(
+            session,
+            force_refresh=force_refresh,
+            cache_ttl_seconds=cache_ttl_seconds,
+            cache_only=cache_only,
+            status_timeout_seconds=status_timeout_seconds,
+        )
+        if progress_callback:
+            progress_callback({
+                "event": "session_finished",
+                "session_name": session["name"],
+                "has_status": bool(resolved.get("lastStatus")),
+                "cache_hit": cache_hit,
+            })
+            progress_callback({
+                "event": "status_finished",
+                "row_count": 1,
             })
+        return _status_row_from_session(resolved)
+
+    def get_status_rows(
+        progress_callback=None,
+        force_refresh=False,
+        cache_ttl_seconds=STATUS_CACHE_TTL_SECONDS,
+        cache_only=False,
+        status_timeout_seconds=None,
+    ):
+        sessions = list_sessions()
 
-        def _resolve_row_session(s):
-            status = _resolve_session_status(
+        cache_hits = {
+            s["name"]: _status_cache_hit(
                 s,
                 force_refresh=force_refresh,
                 cache_ttl_seconds=cache_ttl_seconds,
+                cache_only=cache_only,
             )
-            return {
-                **s,
-                "lastStatus": status,
-                "lastStatusAt": (status and status.get("updated_at")) or s.get("lastStatusAt"),
-            }
+            for s in sessions
+        }
+        if progress_callback:
+            progress_callback({
+                "event": "status_started",
+                "session_count": len(sessions),
+                "check_count": sum(1 for cache_hit in cache_hits.values() if not cache_hit),
+            })
 
         resolved_by_name = {}
         if sessions:
@@ -1032,7 +1160,14 @@ def create_session_service(options=None):
                             "session_name": s["name"],
                             "provider": s["provider"],
                         })
-                    futures[executor.submit(_resolve_row_session, s)] = s
+                    futures[executor.submit(
+                        _resolve_row_session,
+                        s,
+                        force_refresh=force_refresh,
+                        cache_ttl_seconds=cache_ttl_seconds,
+                        cache_only=cache_only,
+                        status_timeout_seconds=status_timeout_seconds,
+                    )] = s
                 for future in as_completed(futures):
                     s = futures[future]
                     resolved = future.result()
@@ -1060,27 +1195,7 @@ def create_session_service(options=None):
 
         rows = []
         for s in resolved:
-            status = s.get("lastStatus")
-            enabled = s.get("enabled", True) is not False
-            row_status = status if enabled else None
-            rows.append({
-                "session_name": s["name"],
-                "provider": s["provider"],
-                "enabled": enabled,
-                "active": bool(_session_runtime(s["name"])) if enabled else False,
-                "status": "enabled" if enabled else "disabled",
-                "auth_status": (s.get("auth") or {}).get("status") or "unknown",
-                "auth_checked_at": _to_local_iso((s.get("auth") or {}).get("lastCheckedAt")),
-                "remaining_5h_pct": _normalize_pct_value(row_status.get("remaining_5h_pct")) if row_status else None,
-                "remaining_week_pct": _normalize_pct_value(row_status.get("remaining_week_pct")) if row_status else None,
-                "credits": row_status.get("credits") if row_status else None,
-                "available_pct": _compute_available_pct(row_status),
-                "reset_5h_at": row_status.get("reset_5h_at") if row_status else None,
-                "reset_week_at": row_status.get("reset_week_at") if row_status else None,
-                "reset_at": row_status.get("reset_at") if row_status else None,
-                "updated_at": _to_local_iso(s.get("lastStatusAt")),
-                "last_launched_at": _to_local_iso(s.get("lastLaunchedAt")),
-            })
+            rows.append(_status_row_from_session(s))
         if progress_callback:
             progress_callback({
                 "event": "status_finished",
@@ -1295,6 +1410,7 @@ def create_session_service(options=None):
         "record_launch_history": record_launch_history,
         "get_launch_history": get_launch_history,
         "update_auth_state": update_auth_state,
+        "get_status_row": get_status_row,
         "get_status_rows": get_status_rows,
         "format_list_rows": format_list_rows,
         "get_session_auth_home": get_session_auth_home,