cdx-manager 0.26.6 → 0.26.8

package/src/cli_args.py

@@ -22,6 +22,7 @@ from .config import (
 )
 from .errors import CdxArgumentError, CdxError
 from .provider_runtime import _normalize_reasoning_effort
+from .session_service import _normalize_launch_settings
 
 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 [--severity OK|WARN|FAIL[,OK|WARN|FAIL...]] [--check-provider-flags] [--json]"
@@ -35,8 +36,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] [--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]"
+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] [--status-line 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|--status-line|--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,7 +50,7 @@ CAN_RESUME_USAGE = "Usage: cdx can-resume <name> [--conversation <id>] [--json]"
 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 = "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] [--extra-args 'ARGS'] [--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."
@@ -278,6 +279,7 @@ def _parse_set_args(args):
         "--logics": {"key": "logics", "type": "str", "default": None, "transform": _on_off("logics")},
         "--notify": {"key": "notify", "type": "str", "default": None, "transform": _on_off("notify")},
         "--agent-state": {"key": "agent_state", "type": "str", "default": None, "transform": _on_off("agent state")},
+        "--status-line": {"key": "status_line", "type": "str", "default": None, "transform": _on_off("status line")},
         "--notify-preview": {"key": "notify_preview", "type": "str", "default": None, "transform": _on_off("notify preview")},
         "--scrub-env": {"key": "scrub_env", "type": "str", "default": None, "transform": _on_off("scrub env")},
         "--shared-memory": {"key": "shared_memory", "type": "str", "default": None, "transform": _on_off("shared memory")},
@@ -305,7 +307,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", "max_parallel")
+        for key in ("power", "permission", "fast", "rtk", "logics", "notify", "agent_state", "status_line", "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:
@@ -329,6 +331,7 @@ def _parse_unset_args(args):
         "--logics": {"key": "logics", "type": "bool", "default": False},
         "--notify": {"key": "notify", "type": "bool", "default": False},
         "--agent-state": {"key": "agent_state", "type": "bool", "default": False},
+        "--status-line": {"key": "status_line", "type": "bool", "default": False},
         "--notify-preview": {"key": "notify_preview", "type": "bool", "default": False},
         "--scrub-env": {"key": "scrub_env", "type": "bool", "default": False},
         "--shared-memory": {"key": "shared_memory", "type": "bool", "default": False},
@@ -356,7 +359,7 @@ def _parse_unset_args(args):
     if not parsed["names"] and not parsed["sessions"] and not parsed["provider"]:
         raise CdxError(UNSET_USAGE)
     _UNSET_KEYS = (
-        "power", "reasoning_effort", "permission", "fast", "rtk", "logics", "notify", "agent_state", "notify_preview", "scrub_env", "shared_memory", "retro",
+        "power", "reasoning_effort", "permission", "fast", "rtk", "logics", "notify", "agent_state", "status_line", "notify_preview", "scrub_env", "shared_memory", "retro",
         "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]]
@@ -503,13 +506,13 @@ def cdx_schema():
             "kind": {"accepted": list(RUN_KIND_VALUES)},
             "provider": {"accepted": list(PROVIDERS)},
         },
-        # Passthrough arguments are deliberately absent from this contract.
-        # `cdx set --extra-args` reaches the provider unchanged and cdx never
-        # validates it, so publishing it here would claim a guarantee that does
-        # not exist. A caller must treat it as opaque.
+        # Provider flag semantics remain opaque; only the argument string's
+        # syntax and size are checked by cdx.
         "unvalidated": {
             "extra_args": {
-                "reason": "Passed to the provider CLI unchanged; cdx neither parses nor verifies these arguments.",
+                "commands": ["set", "run"],
+                "option": "--extra-args",
+                "reason": "Split into literal argv entries; cdx does not verify provider flag semantics.",
                 "not_checked_by": ["cdx schema", "cdx doctor --check-provider-flags"],
             },
         },
@@ -695,6 +698,7 @@ def _parse_run_args(args):
         "--provider": {"key": "provider", "type": "str", "default": None, "transform": _parse_run_provider},
         "--model": {"key": "model", "type": "str", "default": None},
         "--continue-run": {"key": "continue_run", "type": "str", "default": None},
+        "--extra-args": {"key": "extra_args", "type": "str", "default": None},
         "--kind": {"key": "kind", "type": "str", "default": "assistant"},
         "--reasoning-effort": {"key": "reasoning_effort", "type": "str", "default": None},
         "--power": {"key": "power", "type": "str", "default": None},
@@ -753,6 +757,7 @@ def _parse_run_args(args):
         raise CdxArgumentError("cdx run: --remote-prefix requires --remote and a nonempty command.",
                                code=ARG_CODE_INVALID_VALUE, arguments=["--remote-prefix"])
     effort = _parse_run_effort(parsed["reasoning_effort"], parsed["power"])
+    extra = _normalize_launch_settings({"extra_args": parsed["extra_args"]}).get("extra_args")
     return {
         "name": name,
         "remote": parsed["remote"],
@@ -763,6 +768,7 @@ def _parse_run_args(args):
         "prompt_file": parsed["prompt_file"],
         "prompt": parsed["prompt"],
         "continue_run": parsed["continue_run"],
+        "extra_args": extra,
         "kind": parsed["kind"],
         "model": parsed["model"],
         "permission": parsed["permission"],

package/src/cli_helpers.py

@@ -313,6 +313,7 @@ def _format_launch_config(session, use_color=False):
         ("logics", "Logics"),
         ("notify", "Agent alerts"),
         ("agent_state", "Agent state"),
+        ("status_line", "Claude quota status line"),
         ("notify_preview", "Response preview"),
         ("scrub_env", "Scrub agent env"),
         ("shared_memory", "Shared memory"),
@@ -325,6 +326,8 @@ def _format_launch_config(session, use_color=False):
         ("policy", "Policy"),
         ("max_parallel", "Max parallel"),
     ]:
+        if key == "status_line" and session["provider"] != "claude":
+            continue
         rows.append([
             _dim(label, use_color),
             _format_launch_setting_value(launch, key, use_color=use_color),
@@ -345,14 +348,16 @@ def _format_launch_settings_hint(name="<name>"):
     )
 
 def _format_launch_setting_value(launch, key, use_color=False):
-    if key in ("fast", "rtk", "logics", "notify", "agent_state", "notify_preview", "scrub_env", "shared_memory", "retro"):
+    if key in ("fast", "rtk", "logics", "notify", "agent_state", "status_line", "notify_preview", "scrub_env", "shared_memory", "retro"):
         if launch.get(key) is True:
             return _style("on", "32", use_color)
         if launch.get(key) is False:
             return _style("off", "2", use_color)
+        if key == "status_line":
+            return _dim("on (Claude)", use_color)
         if key == "logics":
             return _dim("auto", use_color)
-        if key in ("notify", "agent_state", "notify_preview", "scrub_env", "shared_memory", "retro"):
+        if key in ("notify", "agent_state", "status_line", "notify_preview", "scrub_env", "shared_memory", "retro"):
             return _style("off", "2", use_color)
         return _dim("default", use_color)
     value = launch.get(key)

package/src/codex_usage.py

@@ -7,6 +7,7 @@ import threading
 import time
 from datetime import datetime, timezone
 
+from .quota_provenance import quota_windows
 from .status_source import _is_zero_credit_balance
 
 try:
@@ -139,7 +140,7 @@ def normalize_codex_rate_limit_snapshot(snapshot, reset_credits=None):
         })
 
     raw_status_text = json.dumps(snapshot, sort_keys=True)
-    return {
+    status = {
         "remaining_5h_pct": _remaining_from_used_percent(
             five_hour.get("usedPercent", five_hour.get("used_percent"))
         ),
@@ -156,6 +157,8 @@ def normalize_codex_rate_limit_snapshot(snapshot, reset_credits=None):
         "raw_status_text": raw_status_text,
         "source_ref": "api:codex-app-server-rate-limits",
     }
+    status["quota_windows"] = quota_windows(status, "codex")
+    return status
 
 
 def _reader_thread(stream, output):
@@ -305,13 +308,18 @@ def _request_codex_app_server(auth_home, method, params, failure_reason, timeout
                     pass
 
 
-def fetch_codex_rate_limits(session, timeout=5, popen_factory=None):
-    diagnostic = fetch_codex_rate_limit_diagnostic(
+def fetch_codex_rate_limits(session, timeout=5, popen_factory=None, diagnostic=False):
+    result = fetch_codex_rate_limit_diagnostic(
         session,
         timeout=timeout,
         popen_factory=popen_factory,
     )
-    return diagnostic.get("status") if diagnostic.get("ok") else None
+    if result.get("ok"):
+        return result.get("status")
+    if diagnostic:
+        reason = "login_expired" if diagnostic_needs_codex_login(result) else result.get("reason")
+        return {"_quota_error": reason or "probe_failed"}
+    return None
 
 
 def consume_codex_rate_limit_reset_credit(session, idempotency_key, credit_id=None, timeout=5, popen_factory=None):

package/src/commands/backup.py

@@ -103,12 +103,15 @@ def handle_import(rest, ctx):
     payload = _json_success(
         "import",
         message,
+        warnings=result.get("status_line_warnings", []),
         bundle=result,
     )
     if parsed["json"]:
         _write_json(ctx, payload)
         return 0
     ctx["out"](f"{_success(message, ctx['use_color'])}\n")
+    for warning in result.get("status_line_warnings", []):
+        ctx["out"](f"{warning}\n")
     retained = result.get("retained_local_credentials") or []
     if retained:
         # Merge keeps local values, so say which sessions kept their own login

package/src/commands/conversation.py

@@ -6,13 +6,15 @@ from ..conversation import read_conversation
 from ..errors import CdxError
 from ..provider_runtime import _get_auth_home
 
-CONVERSATION_USAGE = "Usage: cdx conversation <name> [--conversation ID] [--cwd PATH] [--since ISO] [--cursor CURSOR | --tail N | --before CURSOR] [--limit N] --json"
+CONVERSATION_USAGE = "Usage: cdx conversation <name> [--conversation ID | --pid PID | --process-identity ID] [--cwd PATH] [--since ISO] [--cursor CURSOR | --tail N | --before 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"},
+        "--pid": {"key": "pid", "type": "str"},
+        "--process-identity": {"key": "process_identity", "type": "str"},
         "--cwd": {"key": "cwd", "type": "str"},
         "--since": {"key": "since", "type": "str"},
         "--tail": {"key": "tail", "type": "str"},
@@ -26,15 +28,20 @@ def handle_conversation(rest, ctx):
     if not session:
         raise CdxError(f"Unknown session: {parsed['names'][0]}")
     try:
+        pid = int(parsed["pid"]) if parsed["pid"] is not None else None
         limit = int(parsed["limit"])
         tail = int(parsed["tail"]) if parsed["tail"] is not None else None
     except ValueError:
         raise CdxError(CONVERSATION_USAGE) from None
+    process_selected = parsed["pid"] is not None or parsed["process_identity"] is not None
+    if parsed["pid"] is not None and parsed["process_identity"] is not None:
+        raise CdxError(CONVERSATION_USAGE)
     page = read_conversation(
         session["provider"], _get_auth_home(session),
-        conversation_id=parsed["conversation"] or (session.get("conversation") or {}).get("id"),
+        conversation_id=parsed["conversation"] or (None if process_selected else (session.get("conversation") or {}).get("id")),
+        pid=pid, process_identity=parsed["process_identity"],
         cwd=parsed["cwd"], started_at=parsed["since"],
-        cursor=parsed["cursor"], limit=limit, tail=tail, before=parsed["before"], fallback_to_recency=not parsed["conversation"],
+        cursor=parsed["cursor"], limit=limit, tail=tail, before=parsed["before"], fallback_to_recency=not process_selected and not parsed["conversation"],
     )
     _write_json(ctx, _json_success("conversation", "Conversation page loaded.", session=session["name"], **page))
     return 0

package/src/commands/launch.py

@@ -308,6 +308,13 @@ def handle_launch(command, ctx, initial_prompt=None, resume=False, force_json=No
     if not json_flag:
         ctx["out"](f"{_info(message, ctx['use_color'])}\n")
         _write_update_notice(ctx)
+    from ..claude_status_line import provision as provision_status_line
+
+    status_line_notice = provision_status_line(session, ctx["service"]["base_dir"])
+    if status_line_notice:
+        warnings.append(status_line_notice)
+        if not json_flag:
+            ctx["out"](f"{status_line_notice}\n")
     alerts_allowed = _notification_provisioning_enabled(session, ctx, json_flag)
     keep_state = agent_state_enabled(session)
     installed = provision(

package/src/commands/lifecycle.py

@@ -3,6 +3,7 @@
 Split out of cli_commands.py. Moved verbatim; re-exported by cli_commands.
 """
 
+from ..claude_status_line import provision as provision_status_line
 from ..cli_args import (
     _parse_add_args,
     _parse_copy_args,
@@ -70,6 +71,7 @@ def handle_copy(rest, ctx):
     json_flag, args = _parse_json_flag(rest)
     parsed = _parse_copy_args(args)
     result = ctx["service"]["copy_session"](parsed["source"], parsed["dest"])
+    warning = provision_status_line(result["session"], ctx["service"]["base_dir"])
     overwritten = " (overwritten)" if result["overwritten"] else ""
     message = f"Copied session {parsed['source']} to {parsed['dest']}{overwritten}"
     if json_flag:
@@ -78,20 +80,26 @@ def handle_copy(rest, ctx):
             message,
             session=result["session"],
             overwritten=result["overwritten"],
+            warnings=[warning] if warning else [],
         ))
         return 0
     ctx["out"](f"{_success(message, ctx['use_color'])}\n")
+    if warning:
+        ctx["out"](f"{warning}\n")
     return 0
 
 def handle_rename(rest, ctx):
     json_flag, args = _parse_json_flag(rest)
     parsed = _parse_rename_args(args)
     session = ctx["service"]["rename_session"](parsed["source"], parsed["dest"])
+    warning = provision_status_line(session, ctx["service"]["base_dir"])
     message = f"Renamed session {parsed['source']} to {parsed['dest']}"
     if json_flag:
-        _write_json(ctx, _json_success("rename", message, session=session))
+        _write_json(ctx, _json_success("rename", message, session=session, warnings=[warning] if warning else []))
         return 0
     ctx["out"](f"{_success(message, ctx['use_color'])}\n")
+    if warning:
+        ctx["out"](f"{warning}\n")
     return 0
 
 def handle_label(rest, ctx):

package/src/commands/runs.py

@@ -209,6 +209,7 @@ def _detached_child_argv(parsed, prompt_path, session_name, cwd):
         ("--project", "project"),
         ("--budget", "budget"),
         ("--continue-run", "continue_run"),
+        ("--extra-args", "extra_args"),
         ("--model", "model"),
         ("--kind", "kind"),
         ("--permission", "permission"),
@@ -216,7 +217,8 @@ def _detached_child_argv(parsed, prompt_path, session_name, cwd):
     ):
         value = parsed.get(key)
         if value:
-            argv += [flag, str(value)]
+            # A literal provider flag may also be a cdx flag, so bind the value.
+            argv += [f"{flag}={value}"] if key == "extra_args" else [flag, str(value)]
     # reasoning_effort and power are normalized to the same value upstream;
     # passing one back is enough and avoids re-tripping the must-match check.
     if parsed.get("reasoning_effort"):
@@ -612,6 +614,14 @@ def _budget_observation(session, paths, baseline):
     return observation
 
 
+def _run_session(session, launch_updates, extra_args):
+    """Apply run-only settings without mutating the profile or its successors."""
+    launch = {**(session.get("launch") or {}), **launch_updates}
+    if extra_args is not None:
+        launch["extra_args"] = " ".join(value for value in (launch.get("extra_args"), extra_args) if value)
+    return {**session, "launch": launch}
+
+
 def _continue_run_session(parsed, ctx):
     """Resolve only the parent's profile and exact persisted conversation."""
     previous = _run_registry(ctx).get(parsed["continue_run"])
@@ -651,7 +661,7 @@ def _continue_run_session(parsed, ctx):
         pinned_options = {"--model", "--effort", "--fallback-model", "--resume", "--continue",
                           "--session-id", "--fork-session", "--resume-session-at", "--from-pr",
                           "--settings", "--agent", "--agents"}
-        for arg in split_extra_args((session.get("launch") or {}).get("extra_args")) or []:
+        for arg in split_extra_args(_run_session(session, {}, parsed.get("extra_args"))["launch"].get("extra_args")) or []:
             if arg.split("=", 1)[0] in pinned_options or arg.startswith(("-r", "-c")):
                 raise CdxError("--continue-run cannot use Claude extra_args that override model, effort, or conversation.",
                                code="continue_run_settings_mismatch")
@@ -767,13 +777,7 @@ def handle_run(rest, ctx):
         # the profile's current conversation. Continuations use the parent run.
         if not parsed.get("continue_run"):
             session = ctx["service"]["begin_conversation"](session["name"])
-        run_session = {
-            **session,
-            "launch": {
-                **(session.get("launch") or {}),
-                **launch_updates,
-            },
-        }
+        run_session = _run_session(session, launch_updates, parsed.get("extra_args"))
         if not parsed.get("remote"):
             _ensure_session_authentication(
                 run_session,
@@ -970,7 +974,7 @@ def handle_run(rest, ctx):
                     else:
                         selection_row = successor.get("row") or {}
                         next_session = successor["session"]
-                        run_session = {**next_session, "launch": {**(next_session.get("launch") or {}), **launch_updates}}
+                        run_session = _run_session(next_session, launch_updates, parsed.get("extra_args"))
                         # Each new profile starts with the requested model, or its own default.
                         models = capacity_models(run_session)
                         model_index = capacity_retries = 0
@@ -1025,10 +1029,7 @@ def handle_run(rest, ctx):
                 failover_error_code = "failover_exhausted"
                 break
             selection_row = successor.get("row") or {}
-            run_session = {
-                **successor["session"],
-                "launch": {**(successor["session"].get("launch") or {}), **launch_updates},
-            }
+            run_session = _run_session(successor["session"], launch_updates, parsed.get("extra_args"))
             attempted.append(run_session["name"])
             models = capacity_models(run_session)
             model_index = capacity_retries = 0

package/src/commands/settings.py

@@ -4,6 +4,7 @@ Split out of cli_commands.py. Moved verbatim; re-exported by cli_commands.
 """
 
 from ..agent_notify import supports_agent_alerts
+from ..claude_status_line import provision as provision_status_line
 from ..cli_args import _parse_launch_setting_alias_args, _parse_set_args, _parse_unset_args
 from ..cli_helpers import _format_launch_config, _json_success, _write_json
 from ..cli_render import _success
@@ -70,6 +71,7 @@ def _apply_launch_settings(parsed, ctx, action="set"):
         ctx["service"]["set_launch_settings"](session["name"], parsed["settings"])
         for session in targets
     ]
+    warnings = [notice for session in sessions if (notice := provision_status_line(session, ctx["service"]["base_dir"]))]
     if len(sessions) == 1:
         session = sessions[0]
         message = f"Updated launch settings for {session['name']}"
@@ -80,6 +82,7 @@ def _apply_launch_settings(parsed, ctx, action="set"):
             action,
             message,
             updated_count=len(sessions),
+            warnings=warnings,
             session=sessions[0] if len(sessions) == 1 else None,
             sessions=sessions,
             launch=sessions[0].get("launch") or {} if len(sessions) == 1 else None,
@@ -87,6 +90,8 @@ def _apply_launch_settings(parsed, ctx, action="set"):
         _write_json(ctx, payload)
         return 0
     ctx["out"](f"{_success(message, ctx['use_color'])}\n")
+    for warning in warnings:
+        ctx["out"](f"{warning}\n")
     notice = _notification_setting_notice(parsed["settings"], sessions, action)
     if notice:
         ctx["out"](f"{notice}\n")
@@ -100,6 +105,7 @@ def _clear_launch_settings(parsed, ctx, action="unset"):
         ctx["service"]["unset_launch_settings"](session["name"], parsed["keys"])
         for session in targets
     ]
+    warnings = [notice for session in sessions if (notice := provision_status_line(session, ctx["service"]["base_dir"]))]
     if len(sessions) == 1:
         session = sessions[0]
         message = f"Cleared launch settings for {session['name']}"
@@ -110,6 +116,7 @@ def _clear_launch_settings(parsed, ctx, action="unset"):
             action,
             message,
             updated_count=len(sessions),
+            warnings=warnings,
             session=sessions[0] if len(sessions) == 1 else None,
             sessions=sessions,
             launch=sessions[0].get("launch") or {} if len(sessions) == 1 else None,
@@ -117,6 +124,8 @@ def _clear_launch_settings(parsed, ctx, action="unset"):
         _write_json(ctx, payload)
         return 0
     ctx["out"](f"{_success(message, ctx['use_color'])}\n")
+    for warning in warnings:
+        ctx["out"](f"{warning}\n")
     notice = _notification_setting_notice({key: False for key in parsed["keys"]}, sessions, action)
     if notice:
         ctx["out"](f"{notice}\n")

package/src/commands/status.py

@@ -51,6 +51,7 @@ from ..provider_runtime import (
     _has_local_claude_auth,
     _probe_provider_auth_status,
 )
+from ..quota_provenance import mark_quota_unavailable
 from ..rtk_savings import rtk_saved
 from ..run_usage import (
     TOKEN_USAGE_KEYS,
@@ -856,6 +857,8 @@ def handle_status(rest, ctx):
         }
         for item in refresh_result.get("errors", [])
     ]
+    quota_errors = {item["session"]: item.get("reason") or "quota_read_failed" for item in refresh_result.get("errors", [])}
+    quota_errors.update({item["session"]: "auth_probe_failed" for item in auth_refresh.get("errors", [])})
     status_progress = None if parsed["json"] else _make_status_progress(ctx)
     if len(args) == 1:
         row = ctx["service"]["get_status_row"](
@@ -865,6 +868,8 @@ def handle_status(rest, ctx):
             cache_only=parsed["cached"],
             status_timeout_seconds=parsed["timeout"],
         )
+        if row.get("session_name") in quota_errors:
+            mark_quota_unavailable(row, quota_errors[row["session_name"]])
         output_warnings = [
             *warnings,
             *_refresh_warning_payloads(refresh_errors, [row]),
@@ -885,6 +890,9 @@ def handle_status(rest, ctx):
         cache_only=parsed["cached"],
         status_timeout_seconds=parsed["timeout"],
     )
+    for row in rows:
+        if row.get("session_name") in quota_errors:
+            mark_quota_unavailable(row, quota_errors[row["session_name"]])
     output_warnings = [
         *warnings,
         *_refresh_warning_payloads(refresh_errors, rows),

package/src/conversation.py

@@ -379,7 +379,47 @@ def _read_tail(handle, stat, identity, provider, page, count, before):
     return page
 
 
+def _validate_page_options(limit, tail, cursor, before):
+    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.")
+    if tail is not None and (type(tail) is not int or not 1 <= tail <= 1000):
+        raise CdxError("Conversation tail must be an integer between 1 and 1000.")
+    if cursor is not None and (tail is not None or before is not None):
+        raise CdxError("Conversation --cursor cannot be combined with --tail or --before.")
+
+
 def read_conversation(provider, auth_home=None, *, conversation_id=None, started_at=None,
+                      terminal_transcript=None, cursor=None, limit=100, fallback_to_recency=False,
+                      tail=None, before=None, cwd=None, pid=None, process_identity=None):
+    """Read a conversation page, optionally bound to a live native process.
+
+    Process selection never uses saved session IDs or recency. Keep the returned
+    opaque process_identity for later polls to detect PID reuse. Unknown evidence
+    returns no entries. See docs/cli.md for platform and snapshot limitations.
+    """
+    _validate_page_options(limit, tail, cursor, before)
+    options = dict(conversation_id=conversation_id, started_at=started_at,
+                   terminal_transcript=terminal_transcript, cursor=cursor, limit=limit,
+                   fallback_to_recency=fallback_to_recency, tail=tail, before=before, cwd=cwd)
+    if pid is None and process_identity is None:
+        return _read_conversation_page(provider, auth_home, **options)
+    if conversation_id is not None or cwd is not None or started_at is not None or terminal_transcript is not None:
+        raise CdxError("Process selection cannot be combined with conversation, cwd, since or terminal transcript selection.")
+    from .process_conversation import resolve_process_conversation
+
+    resolution = resolve_process_conversation(provider, auth_home, pid=pid, process_identity=process_identity)
+    page = {"status": "unavailable", "provider": provider, "entries": [], "next_cursor": None,
+            "has_more": False, "resolution_scope": None, **resolution}
+    if tail is not None or before is not None:
+        page["before_cursor"] = None
+    # No process-bound cursor is issued until native selected-thread evidence
+    # exists. Never replay an explicit-ID or recency cursor through this mode.
+    if cursor is not None or before is not None:
+        page["status"] = "reset_required"
+    return page
+
+
+def _read_conversation_page(provider, auth_home=None, *, conversation_id=None, started_at=None,
                       terminal_transcript=None, cursor=None, limit=100, fallback_to_recency=False, tail=None, before=None, cwd=None):
     """Return a JSON-serializable page; pass next_cursor back unchanged to poll.
 
@@ -394,12 +434,7 @@ def read_conversation(provider, auth_home=None, *, conversation_id=None, started
     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.")
-    if tail is not None and (type(tail) is not int or not 1 <= tail <= 1000):
-        raise CdxError("Conversation tail must be an integer between 1 and 1000.")
-    if cursor is not None and (tail is not None or before is not None):
-        raise CdxError("Conversation --cursor cannot be combined with --tail or --before.")
+    _validate_page_options(limit, tail, cursor, before)
     if started_at is not None:
         try:
             datetime.fromisoformat(started_at.replace("Z", "+00:00"))

package/src/process_conversation.py

@@ -0,0 +1,81 @@
+"""Bounded Linux process identity, without guessing a selected conversation.
+
+No argv, environment, credential stores, transcript searches or parent/child
+heuristics participate in identity resolution.
+"""
+
+import hashlib
+import os
+import re
+import sys
+from pathlib import Path
+
+PROC_ROOT = Path("/proc")
+_UUID = r"[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}"
+_IDENTITY = re.compile(r"linux:(\d+):[0-9a-f]{64}")
+
+
+class _Unknown(Exception):
+    pass
+
+
+def _bounded(path, limit=8192):
+    with open(path, "rb") as handle:
+        value = handle.read(limit + 1)
+    if len(value) > limit:
+        raise _Unknown("evidence_limit")
+    return value.decode("utf-8")
+
+
+def _process(pid):
+    root = PROC_ROOT / str(pid)
+    fields = _bounded(root / "stat").rsplit(")", 1)[1].split()
+    if fields[0] in ("Z", "X", "x"):
+        raise _Unknown("process_not_running")
+    uids = next(line.split()[1:] for line in _bounded(root / "status").splitlines() if line.startswith("Uid:"))
+    if len(uids) != 4 or any(int(uid) != os.getuid() for uid in uids):
+        raise _Unknown("unrelated_user")
+    executable = os.readlink(root / "exe")
+    if Path(executable).name != "codex":
+        raise _Unknown("unrelated_process")
+    exe = os.stat(root / "exe")
+    boot = _bounded(PROC_ROOT / "sys/kernel/random/boot_id").strip()
+    if not re.fullmatch(_UUID, boot):
+        raise _Unknown("invalid_evidence")
+    digest = hashlib.sha256(f"{boot}:{pid}:{fields[19]}:{uids}:{exe.st_dev}:{exe.st_ino}".encode()).hexdigest()
+    return f"linux:{pid}:{digest}"
+
+
+def resolve_process_conversation(provider, auth_home, *, pid=None, process_identity=None):
+    """Return explicit unknown when the native selected-thread link is absent.
+
+    A bare PID means the process alive *now*. Persist process_identity to reject
+    reuse on subsequent calls. The identity is an opaque guard, not a secret or
+    authorization grant. Only Linux /proc and interactive Codex are supported.
+    """
+    result = {"resolution_status": "unknown", "resolution_method": None,
+              "conversation_id": None, "process_identity": None, "reason": None}
+    if provider != "codex" or sys.platform != "linux":
+        return {**result, "reason": "unsupported_process_resolution"}
+    if process_identity is not None:
+        match = _IDENTITY.fullmatch(process_identity) if isinstance(process_identity, str) and len(process_identity) <= 100 else None
+        if not match or pid is not None:
+            return {**result, "reason": "invalid_process_identity"}
+        pid = int(match[1])
+    if type(pid) is not int or not 0 < pid < 2**31 or not auth_home:
+        return {**result, "reason": "invalid_process_identity"}
+    try:
+        identity = _process(pid)
+        if process_identity is not None and identity != process_identity:
+            raise _Unknown("process_identity_changed")
+        result["process_identity"] = identity
+        if _process(pid) != identity:
+            raise _Unknown("evidence_changed")
+        # Even a sole writable rollout may belong to a retained thread while
+        # another thread is selected but has not created its rollout. Neither
+        # that descriptor nor resume argv is a native selected-thread event.
+        return {**result, "reason": "native_conversation_identity_unavailable"}
+    except _Unknown as exc:
+        return {**result, "reason": str(exc)}
+    except (OSError, ValueError, KeyError, IndexError, TypeError, StopIteration, UnicodeError, RecursionError):
+        return {**result, "reason": "native_evidence_unavailable"}

package/src/quota_gauge.txt

@@ -0,0 +1,2 @@
+████████
+▁▁▁▁▁▁▁▁