cdx-manager 0.5.5 → 0.5.7

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.5.5-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.5.7-4C8BF5) ![Python](https://img.shields.io/badge/python-3.9%2B-3776AB?logo=python&logoColor=white)
 
 **Run multiple Codex and Claude sessions from one terminal. Switch between accounts instantly.**
 
@@ -37,6 +37,7 @@ One command to launch any session. Zero auth juggling.
 - **Auth guardrails.** `cdx` checks authentication before launching. If a session is not logged in, it tells you exactly what to run — no silent failures.
 - **Usage at a glance.** `cdx status` shows token usage, 5-hour window quota, weekly quota, last-updated timestamps, priority guidance, and the last launched session in one aligned table.
 - **Session control.** Disable a session without deleting it when an account is temporarily out of credits; disabled sessions remain visible and sort last.
+- **Persistent launch settings.** Pin per-session power, permission, and fast-mode preferences once; `cdx` reapplies them on every launch until you unset them.
 - **Shared handoff context.** Keep a per-workspace Markdown context, or build one from a source session transcript, and install it into another assistant session before switching providers or accounts.
 - **Passive status resolution.** Codex status is read from the local Codex app-server rate-limit API when available, with legacy transcript/history parsing kept as a fallback.
 - **Session transcript capture.** Every launch is recorded to a local log file via `script`, giving you a full terminal transcript for each session.
@@ -126,7 +127,7 @@ For a specific version:
 
 ```bash
 curl -fsSL https://raw.githubusercontent.com/AlexAgo83/cdx-manager/main/install.sh -o install.sh
-CDX_VERSION=v0.5.5 sh install.sh
+CDX_VERSION=v0.5.7 sh install.sh
 ```
 
 From source:
@@ -231,6 +232,25 @@ cdx work
 cdx status
 ```
 
+### Persistent Launch Settings
+
+By default, `cdx` launches provider CLIs without forcing model effort, permission mode, or fast behavior. Set only the values you want to pin:
+
+```bash
+cdx set work --power medium --permission full --fast off
+cdx set personal --power low --permission review
+cdx config work
+```
+
+Those values are stored on the session and reapplied every time you run `cdx work`. Remove overrides to return to provider defaults:
+
+```bash
+cdx unset work --power
+cdx unset work --all
+```
+
+`--power` maps to Codex `model_reasoning_effort` and Claude `--effort`. `--permission` maps to provider-native permission flags. `--fast on` uses low effort when no explicit power is set.
+
 ---
 
 ## All Commands
@@ -248,6 +268,9 @@ cdx status
 | `cdx logout <name> [--json]` | Log out of a session |
 | `cdx disable <name> [--json]` | Disable a session without deleting it; disabled sessions stay visible and cannot launch |
 | `cdx enable <name> [--json]` | Re-enable a disabled session |
+| `cdx config <name> [--json]` | Show persistent launch settings for a session |
+| `cdx set <name> [--power low\|medium\|high\|xhigh\|max] [--permission review\|default\|auto\|full] [--fast on\|off] [--json]` | Persist launch settings for a session |
+| `cdx unset <name> (--power\|--permission\|--fast\|--all) [--json]` | Remove persisted launch settings and fall back to provider defaults |
 | `cdx context show\|path\|init\|edit\|clear\|set [text...] [--json]` | Manage the shared Markdown context for the current workspace |
 | `cdx handoff <name> [--json]` | Install the current workspace context into a target session and launch it unless `--json` is used |
 | `cdx handoff <source> <target> [--json]` | Build shared context from the source session's latest launch transcript, install it into the target session, and launch the target unless `--json` is used; supports Codex and Claude targets, including cross-provider handoff |
@@ -258,8 +281,8 @@ cdx status
 | `cdx doctor [--json]` | Inspect CLI dependencies, CDX_HOME permissions, missing state, orphan profiles, and pending quarantines |
 | `cdx repair [--dry-run] [--force] [--json]` | Plan or apply safe repairs for missing state files, quarantines, and orphan profiles |
 | `cdx update [--check] [--yes] [--json] [--version TAG]` | Update cdx-manager using the installer that matches how it was installed |
-| `cdx notify <name> --at-reset [--poll seconds] [--once] [--json]` | Wait for a session reset time and send a desktop notification when due |
-| `cdx notify --next-ready [--poll seconds] [--once] [--json]` | Wait until the recommended session is usable or needs a refresh after reset |
+| `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 |
 | `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 |

package/changelogs/CHANGELOGS_0_5_6.md

@@ -0,0 +1,42 @@
+# Changelog (`0.5.5 -> 0.5.6`)
+
+Release date: 2026-05-24
+
+## Major Highlights
+
+- Reduced noisy `cdx status` progress output by respecting fresh cached status rows.
+- Stopped probing disabled sessions during status resolution and hid stale quota metrics for disabled rows.
+- Refined `cdx notify --next-ready` so it waits for the next blocked account reset instead of notifying for an account that is already usable.
+
+## Status Output
+
+- Added status-row cache handling so recently resolved rows do not print redundant `Checking ...` progress lines.
+- Kept Claude status cache behavior aligned with the Claude refresh TTL, avoiding unnecessary Claude checks while cached usage is still fresh.
+- Treated disabled sessions as display-only in `cdx status`; disabled sessions remain visible but are not refreshed or re-read from status artifacts.
+- Rendered disabled-session quota columns as `-` for `OK`, `5H`, `WEEK`, `BLOCK`, `CR`, `RESET 5H`, and `RESET WEEK`.
+- Preserved the stored last status internally so re-enabled sessions can resume normal status behavior.
+
+## Notifications
+
+- Added `--refresh` support to `cdx notify` so notification checks can force status refreshes when requested.
+- Added text-mode progress output for notification checks while keeping `--json` output clean.
+- Made `cdx notify --next-ready` ignore disabled sessions.
+- Made `cdx notify --next-ready` ignore sessions that are already usable and instead target the next currently blocked session with a known reset.
+- Returned `No upcoming session reset available` when there is no blocked session with a reset to wait for.
+
+## Documentation
+
+- Updated package metadata, CLI version output, README badge, and pinned installer example to `v0.5.6`.
+- Documented `--refresh` for `cdx notify` command examples.
+
+## Validation and Regression Coverage
+
+- Added regression coverage for cached Codex status rows suppressing redundant checking progress.
+- Added regression coverage for Claude cache TTL behavior.
+- Added regression coverage for disabled sessions skipping refresh and hiding public status metrics.
+- Added regression coverage for `notify --next-ready` ignoring already-available and disabled sessions.
+
+## Validation and Regression Evidence
+
+- `npm run test:py`
+- `./bin/cdx status`

package/changelogs/CHANGELOGS_0_5_7.md

@@ -0,0 +1,45 @@
+# Changelog (`0.5.6 -> 0.5.7`)
+
+Release date: 2026-05-27
+
+## Major Highlights
+
+- Added persistent per-session launch settings for Codex and Claude assistants.
+- Let users pin power, permission, and fast-mode preferences once and have `cdx` reapply them on every launch.
+- Preserved native provider defaults when no launch settings are configured.
+
+## Launch Settings
+
+- Added `cdx set <name>` with `--power`, `--permission`, and `--fast` options.
+- Added `cdx config <name>` to inspect the launch settings stored on a session.
+- Added `cdx unset <name>` to clear individual launch settings or all overrides with `--all`.
+- Stored launch settings directly on each CDX session record.
+- Copied launch settings when copying a session.
+- Exported and imported launch settings with session bundles.
+
+## Provider Runtime
+
+- Mapped Codex power settings to `model_reasoning_effort`.
+- Mapped Claude power settings to `--effort`.
+- Mapped Codex permission presets to sandbox and approval flags.
+- Mapped Claude permission presets to `--permission-mode`.
+- Treated `--fast on` as low effort when no explicit power setting is configured.
+
+## CLI Output and Documentation
+
+- Added launch settings to `cdx --help`.
+- Added a compact launch-settings column to `cdx` session listings when any session has overrides.
+- Documented the persistent launch-settings workflow in the README.
+- Updated package metadata, CLI version output, README badge, and pinned installer example to `v0.5.7`.
+
+## Validation and Regression Coverage
+
+- Added regression coverage for persistent Codex launch settings and `unset --all`.
+- Added regression coverage for persistent Claude launch settings and `cdx config`.
+- Added runtime coverage for `fast on` resolving to low effort when no power is configured.
+
+## Validation and Regression Evidence
+
+- `python -m py_compile bin/cdx src/*.py test/test_*_py.py`
+- `python -m unittest discover -s test -p 'test_*_py.py'`
+- `npm pack --dry-run`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cdx-manager",
-  "version": "0.5.5",
+  "version": "0.5.7",
   "description": "Terminal session manager for Codex and Claude accounts.",
   "license": "MIT",
   "author": "Alexandre Agostini",
@@ -25,6 +25,8 @@
   },
   "files": [
     "bin",
+    "!bin/__pycache__",
+    "!bin/**/*.pyc",
     "checksums",
     "changelogs",
     "src",

package/pyproject.toml

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

package/src/cli.py

@@ -9,6 +9,7 @@ from .cli_commands import (
     STATUS_USAGE,
     handle_add,
     handle_clean,
+    handle_config,
     handle_context,
     handle_copy,
     handle_doctor,
@@ -25,6 +26,8 @@ from .cli_commands import (
     handle_repair,
     handle_rename,
     handle_status,
+    handle_set,
+    handle_unset,
     handle_update,
 )
 from .cli_render import (
@@ -49,7 +52,7 @@ from .status_view import (
 )
 from .update_check import check_for_update
 
-VERSION = "0.5.5"
+VERSION = "0.5.7"
 
 
 # ---------------------------------------------------------------------------
@@ -67,6 +70,9 @@ def _print_help(use_color=False):
         f"  {_style('cdx status --small|-s [--refresh]', '36', use_color)}",
         f"  {_style('cdx status <name> [--json] [--refresh]', '36', use_color)}",
         f"  {_style('cdx context show|path|init|edit|clear|set [text...] [--json]', '36', use_color)}",
+        f"  {_style('cdx config <name> [--json]', '36', use_color)}",
+        f"  {_style('cdx set <name> [--power low|medium|high|xhigh|max] [--permission review|default|auto|full] [--fast on|off] [--json]', '36', use_color)}",
+        f"  {_style('cdx unset <name> (--power|--permission|--fast|--all) [--json]', '36', use_color)}",
         f"  {_style('cdx handoff <name> [--json]', '36', use_color)}",
         f"  {_style('cdx handoff <source> <target> [--json]', '36', use_color)}",
         f"  {_style('cdx add [provider] <name> [--json]', '36', use_color)}",
@@ -83,8 +89,8 @@ def _print_help(use_color=False):
         f"  {_style('cdx doctor [--json]', '36', use_color)}",
         f"  {_style('cdx repair [--dry-run] [--force] [--json]', '36', use_color)}",
         f"  {_style('cdx update [--check] [--yes] [--json] [--version TAG]', '36', use_color)}",
-        f"  {_style('cdx notify <name> --at-reset [--json]', '36', use_color)}",
-        f"  {_style('cdx notify --next-ready [--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)}",
         f"  {_style('cdx <name> [--json]', '36', use_color)}",
         f"  {_style('cdx --help', '36', use_color)}",
         f"  {_style('cdx --version', '36', use_color)}",
@@ -221,7 +227,7 @@ def main(argv, options=None):
         "version": VERSION,
         "cwd": options.get("cwd") or os.getcwd(),
         "update_notice": _get_update_notice(service, env, options) if command not in (
-            "add", "cp", "ren", "rename", "mv", "rmv", "clean", "doctor", "repair", "update", "notify", "status", "context", "handoff", "login", "logout", "disable", "enable", "export", "import", "help", "version"
+            "add", "cp", "ren", "rename", "mv", "rmv", "clean", "doctor", "repair", "update", "notify", "status", "context", "config", "set", "unset", "handoff", "login", "logout", "disable", "enable", "export", "import", "help", "version"
         ) else None,
         "use_color": use_color,
     }
@@ -268,6 +274,15 @@ def main(argv, options=None):
     if command == "context":
         return handle_context(rest, ctx)
 
+    if command == "config":
+        return handle_config(rest, ctx)
+
+    if command == "set":
+        return handle_set(rest, ctx)
+
+    if command == "unset":
+        return handle_unset(rest, ctx)
+
     if command == "handoff":
         return handle_handoff(rest, ctx)
 

package/src/cli_commands.py

@@ -3,6 +3,7 @@ import getpass
 import json
 import os
 import sys
+import time
 from datetime import datetime
 
 from .claude_refresh import _refresh_claude_sessions
@@ -21,7 +22,10 @@ from .errors import CdxError
 from .health import collect_health_report, format_health_report
 from .notify import (
     format_notify_event,
+    format_scheduled_notification,
     parse_notify_args,
+    resolve_notify_event,
+    schedule_notification_event,
     send_desktop_notification,
     wait_for_notification_event,
 )
@@ -45,6 +49,9 @@ EXPORT_USAGE = "Usage: cdx export <file> [--include-auth] [--force] [--json] [--
 IMPORT_USAGE = "Usage: cdx import <file> [--force] [--json] [--sessions name1,name2] [--passphrase-env VAR]"
 CONTEXT_USAGE = "Usage: cdx context show|path|init|edit|clear|set [text...] [--json]"
 HANDOFF_USAGE = "Usage: cdx handoff <name> [--json] | cdx handoff <source> <target> [--json]"
+SET_USAGE = "Usage: cdx set <name> [--power low|medium|high|xhigh|max] [--permission review|default|auto|full] [--fast on|off] [--json]"
+UNSET_USAGE = "Usage: cdx unset <name> (--power|--permission|--fast|--all) [--json]"
+CONFIG_USAGE = "Usage: cdx config <name> [--json]"
 API_SCHEMA_VERSION = 1
 HANDOFF_TRANSCRIPT_CHARS = 120000
 
@@ -139,6 +146,25 @@ def _make_status_progress(ctx):
     return progress
 
 
+def _make_notify_progress(ctx):
+    def progress(event):
+        kind = event.get("event")
+        if kind == "notify_check_started":
+            target = event.get("session_name") or "next ready session"
+            ctx["out"](f"{_info(f'Checking notification target: {target}...', ctx['use_color'])}\n")
+        elif kind == "status_started":
+            message = f"Loading status for {event.get('session_count', 0)} session(s)..."
+            ctx["out"](f"{_dim(message, ctx['use_color'])}\n")
+        elif kind == "session_started":
+            provider = event.get("provider") or "session"
+            message = f"Checking {event.get('session_name')} ({provider})..."
+            ctx["out"](f"{_dim(message, ctx['use_color'])}\n")
+        elif kind == "notify_waiting":
+            message = f"{event.get('message')}; checking again in {event.get('poll')}s..."
+            ctx["out"](f"{_dim(message, ctx['use_color'])}\n")
+    return progress
+
+
 def _latest_launch_transcript_path(session):
     paths = _list_launch_transcript_paths(session)
     if not paths:
@@ -283,6 +309,61 @@ def _parse_toggle_args(args, usage):
     return {"name": parsed["names"][0], "json": parsed["json"]}
 
 
+def _parse_fast_value(value):
+    text = str(value).strip().lower()
+    if text in ("on", "true", "1", "yes"):
+        return True
+    if text in ("off", "false", "0", "no"):
+        return False
+    raise CdxError(SET_USAGE)
+
+
+def _parse_set_args(args):
+    parsed = _parse_flag_args(args, {
+        "--power": {"key": "power", "type": "str", "default": None},
+        "--permission": {"key": "permission", "type": "str", "default": None},
+        "--fast": {"key": "fast", "type": "str", "default": None, "transform": _parse_fast_value},
+        "--json": {"key": "json", "type": "bool", "default": False},
+    }, SET_USAGE, positionals_key="names", max_positionals=1)
+    if len(parsed["names"]) != 1:
+        raise CdxError(SET_USAGE)
+    settings = {
+        key: parsed[key]
+        for key in ("power", "permission", "fast")
+        if parsed[key] is not None
+    }
+    if not settings:
+        raise CdxError(SET_USAGE)
+    return {"name": parsed["names"][0], "settings": settings, "json": parsed["json"]}
+
+
+def _parse_unset_args(args):
+    parsed = _parse_flag_args(args, {
+        "--power": {"key": "power", "type": "bool", "default": False},
+        "--permission": {"key": "permission", "type": "bool", "default": False},
+        "--fast": {"key": "fast", "type": "bool", "default": False},
+        "--all": {"key": "all", "type": "bool", "default": False},
+        "--json": {"key": "json", "type": "bool", "default": False},
+    }, UNSET_USAGE, positionals_key="names", max_positionals=1)
+    if len(parsed["names"]) != 1:
+        raise CdxError(UNSET_USAGE)
+    keys = ["power", "permission", "fast"] if parsed["all"] else [
+        key for key in ("power", "permission", "fast") if parsed[key]
+    ]
+    if not keys:
+        raise CdxError(UNSET_USAGE)
+    return {"name": parsed["names"][0], "keys": keys, "json": parsed["json"]}
+
+
+def _parse_config_args(args):
+    parsed = _parse_flag_args(args, {
+        "--json": {"key": "json", "type": "bool", "default": False},
+    }, CONFIG_USAGE, positionals_key="names", max_positionals=1)
+    if len(parsed["names"]) != 1:
+        raise CdxError(CONFIG_USAGE)
+    return {"name": parsed["names"][0], "json": parsed["json"]}
+
+
 def _read_option_value(args, index, usage):
     if index + 1 >= len(args):
         raise CdxError(usage)
@@ -499,6 +580,53 @@ def handle_enable(rest, ctx):
     return 0
 
 
+def _format_launch_config(session):
+    launch = session.get("launch") or {}
+    return "\n".join([
+        f"{session['name']} ({session['provider']})",
+        f"power:      {launch.get('power') or 'default'}",
+        f"permission: {launch.get('permission') or 'default'}",
+        f"fast:       {'on' if launch.get('fast') is True else 'off' if launch.get('fast') is False else 'default'}",
+    ])
+
+
+def handle_set(rest, ctx):
+    parsed = _parse_set_args(rest)
+    session = ctx["service"]["set_launch_settings"](parsed["name"], parsed["settings"])
+    message = f"Updated launch settings for {parsed['name']}"
+    if parsed["json"]:
+        _write_json(ctx, _json_success("set", message, session=session, launch=session.get("launch") or {}))
+        return 0
+    ctx["out"](f"{_success(message, ctx['use_color'])}\n")
+    ctx["out"](f"{_format_launch_config(session)}\n")
+    return 0
+
+
+def handle_unset(rest, ctx):
+    parsed = _parse_unset_args(rest)
+    session = ctx["service"]["unset_launch_settings"](parsed["name"], parsed["keys"])
+    message = f"Cleared launch settings for {parsed['name']}"
+    if parsed["json"]:
+        _write_json(ctx, _json_success("unset", message, session=session, launch=session.get("launch") or {}))
+        return 0
+    ctx["out"](f"{_success(message, ctx['use_color'])}\n")
+    ctx["out"](f"{_format_launch_config(session)}\n")
+    return 0
+
+
+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']}")
+    message = f"Launch settings for {parsed['name']}"
+    if parsed["json"]:
+        _write_json(ctx, _json_success("config", message, session=session, launch=session.get("launch") or {}))
+        return 0
+    ctx["out"](f"{_format_launch_config(session)}\n")
+    return 0
+
+
 def handle_clean(rest, ctx):
     json_flag, args = _parse_json_flag(rest)
     service = ctx["service"]
@@ -620,12 +748,45 @@ def handle_notify(rest, ctx):
             env=ctx.get("env"),
         )
 
+    if parsed["schedule"]:
+        event = resolve_notify_event(
+            ctx["service"]["get_status_rows"](
+                progress_callback=None if parsed["json"] else _make_notify_progress(ctx),
+                force_refresh=parsed.get("refresh", False),
+            ),
+            parsed,
+            (ctx["options"].get("now") or time.time)(),
+        )
+        if event["ready"]:
+            notifier(event["title"], event["message"])
+            schedule = {
+                "scheduled": False,
+                "backend": "immediate",
+                "message": event["message"],
+                "target_timestamp": event.get("target_timestamp"),
+            }
+        else:
+            schedule = schedule_notification_event(
+                ctx["service"]["base_dir"],
+                parsed,
+                event,
+                spawn_sync=ctx.get("spawn_sync"),
+                env=ctx.get("env"),
+                now_fn=ctx["options"].get("now"),
+            )
+        if parsed["json"]:
+            _write_json(ctx, _json_success("notify", "Scheduled notification event", event=event, schedule=schedule))
+        else:
+            ctx["out"](f"{format_scheduled_notification(schedule)}\n")
+        return 0
+
     event = wait_for_notification_event(
         ctx["service"],
         parsed,
         notifier=notifier,
         sleep_fn=ctx["options"].get("sleep"),
         now_fn=ctx["options"].get("now"),
+        progress_callback=None if parsed["json"] else _make_notify_progress(ctx),
     )
     if parsed["json"]:
         _write_json(ctx, _json_success("notify", "Resolved notification event", event=event))
@@ -767,7 +928,10 @@ def handle_status(rest, ctx):
     ]
 
     status_progress = None if parsed["json"] else _make_status_progress(ctx)
-    rows = ctx["service"]["get_status_rows"](progress_callback=status_progress)
+    rows = ctx["service"]["get_status_rows"](
+        progress_callback=status_progress,
+        force_refresh=parsed["refresh"],
+    )
     if len(args) == 0:
         if parsed["json"]:
             _write_json(ctx, _json_success("status", "Collected session status rows", warnings=warnings, rows=rows))

package/src/cli_render.py

@@ -105,10 +105,13 @@ def format_error(error, env=None, stderr=None):
 def _format_sessions(service, use_color=False):
     rows = service["format_list_rows"]()
     has_provider = any(r.get("provider") for r in rows)
+    has_launch = any(r.get("launch") for r in rows)
     headers = ["SESSION"]
     if has_provider:
         headers.append("PROVIDER")
     headers.append("STATUS")
+    if has_launch:
+        headers.append("LAUNCH")
     headers.append("UPDATED")
     headers = [_style(header, "1", use_color) for header in headers]
     table_rows = []
@@ -118,6 +121,17 @@ def _format_sessions(service, use_color=False):
             parts.append(r.get("provider") or "n/a")
         status = r.get("enabled_status") or ("enabled" if r.get("enabled", True) else "disabled")
         parts.append(_style(status, "2" if status == "disabled" else "32", use_color))
+        if has_launch:
+            launch = r.get("launch") or {}
+            if launch:
+                launch_text = "/".join([
+                    launch.get("power") or "-",
+                    launch.get("permission") or "-",
+                    "fast-on" if launch.get("fast") is True else "fast-off" if launch.get("fast") is False else "-",
+                ])
+            else:
+                launch_text = "default"
+            parts.append(_dim(launch_text, use_color))
         parts.append(_dim(_format_relative_age(r.get("updated_at")), use_color))
         table_rows.append(parts)
     lines = [_style("Known sessions:", "1", use_color), _pad_table([headers] + table_rows), ""]
@@ -127,6 +141,8 @@ def _format_sessions(service, use_color=False):
         f"  {_style('cdx <name>', '36', use_color)}",
         f"  {_style('cdx login <name>', '36', use_color)}",
         f"  {_style('cdx logout <name>', '36', use_color)}",
+        f"  {_style('cdx config <name>', '36', use_color)}",
+        f"  {_style('cdx set <name> --power medium --permission default --fast off', '36', use_color)}",
         f"  {_style('cdx context show', '36', use_color)}",
         f"  {_style('cdx handoff <name>', '36', use_color)}",
         f"  {_style('cdx handoff <source> <target>', '36', use_color)}",

package/src/notify.py

@@ -1,10 +1,20 @@
 import json
 import os
+import shlex
 import subprocess
 import time
+from datetime import datetime, timedelta
 
 from .errors import CdxError
-from .status_view import _parse_reset_timestamp, _recommend_priority_sessions
+from .status_view import (
+    PRIORITY_EMPTY_AVAILABLE_THRESHOLD,
+    _parse_reset_timestamp,
+    _priority_reset_timestamp,
+    _recommend_priority_sessions,
+)
+
+
+NOTIFY_USAGE = "Usage: cdx notify <name> --at-reset [--poll seconds] [--once] [--schedule] [--refresh] | cdx notify --next-ready [--poll seconds] [--once] [--schedule] [--refresh]"
 
 
 def parse_notify_args(args):
@@ -12,17 +22,19 @@ def parse_notify_args(args):
     once = "--once" in args
     at_reset = "--at-reset" in args
     next_ready = "--next-ready" in args
+    refresh = "--refresh" in args
+    schedule = "--schedule" in args
     poll = 60
     cleaned = []
     i = 0
     while i < len(args):
         arg = args[i]
-        if arg in ("--json", "--once", "--at-reset", "--next-ready"):
+        if arg in ("--json", "--once", "--at-reset", "--next-ready", "--refresh", "--schedule"):
             i += 1
             continue
         if arg == "--poll":
             if i + 1 >= len(args):
-                raise CdxError("Usage: cdx notify <name> --at-reset [--poll seconds] [--once] | cdx notify --next-ready [--poll seconds] [--once]")
+                raise CdxError(NOTIFY_USAGE)
             try:
                 poll = max(1, int(args[i + 1]))
             except ValueError as error:
@@ -37,48 +49,69 @@ def parse_notify_args(args):
             i += 1
             continue
         if arg.startswith("-"):
-            raise CdxError("Usage: cdx notify <name> --at-reset [--poll seconds] [--once] | cdx notify --next-ready [--poll seconds] [--once]")
+            raise CdxError(NOTIFY_USAGE)
         cleaned.append(arg)
         i += 1
     if at_reset == next_ready:
-        raise CdxError("Usage: cdx notify <name> --at-reset [--poll seconds] [--once] | cdx notify --next-ready [--poll seconds] [--once]")
+        raise CdxError(NOTIFY_USAGE)
     if at_reset and len(cleaned) != 1:
-        raise CdxError("Usage: cdx notify <name> --at-reset [--poll seconds] [--once]")
+        raise CdxError("Usage: cdx notify <name> --at-reset [--poll seconds] [--once] [--schedule] [--refresh]")
     if next_ready and cleaned:
-        raise CdxError("Usage: cdx notify --next-ready [--poll seconds] [--once]")
+        raise CdxError("Usage: cdx notify --next-ready [--poll seconds] [--once] [--schedule] [--refresh]")
     return {
         "name": cleaned[0] if cleaned else None,
         "mode": "at-reset" if at_reset else "next-ready",
         "poll": poll,
         "once": once,
         "json": json_flag,
+        "refresh": refresh,
+        "schedule": schedule,
     }
 
 
-def wait_for_notification_event(service, parsed, notifier=None, sleep_fn=None, now_fn=None):
+def wait_for_notification_event(service, parsed, notifier=None, sleep_fn=None, now_fn=None, progress_callback=None):
     notifier = notifier or send_desktop_notification
     sleep_fn = sleep_fn or time.sleep
     now_fn = now_fn or time.time
     while True:
-        event = resolve_notify_event(service["get_status_rows"](), parsed, now_fn())
+        if progress_callback:
+            progress_callback({"event": "notify_check_started", "mode": parsed["mode"], "session_name": parsed["name"]})
+        event = resolve_notify_event(
+            service["get_status_rows"](
+                progress_callback=progress_callback,
+                force_refresh=parsed.get("refresh", False),
+            ),
+            parsed,
+            now_fn(),
+        )
         if event["ready"] or parsed["once"]:
             if event["ready"]:
                 notifier(event["title"], event["message"])
             return event
+        if progress_callback:
+            progress_callback({
+                "event": "notify_waiting",
+                "message": event["message"],
+                "poll": parsed["poll"],
+                "session_name": event.get("session"),
+                "target_timestamp": event.get("target_timestamp"),
+            })
         sleep_fn(parsed["poll"])
 
 
 def resolve_notify_event(rows, parsed, now_ts=None):
     now_ts = time.time() if now_ts is None else now_ts
     if parsed["mode"] == "next-ready":
-        priority = _recommend_priority_sessions(rows)
+        active_rows = [row for row in rows if row.get("enabled", True) is not False]
+        priority = _recommend_priority_sessions([
+            row for row in active_rows
+            if not _is_usable_now(row) and _priority_reset_timestamp(row) is not None
+        ])
         if not priority:
-            return _event(False, "cdx", "No session status available", None)
+            return _event(False, "cdx", "No upcoming session reset available", None)
         first = priority[0]
-        if _is_available(first):
-            return _event(True, "cdx", f"{first['session_name']} is ready", first["session_name"])
-        timestamp = _next_reset_timestamp(first)
-        if timestamp is not None and timestamp <= now_ts:
+        timestamp = _priority_reset_timestamp(first)
+        if _needs_refresh(first, timestamp, now_ts):
             return _event(True, "cdx", f"{first['session_name']} reset is due; refresh status", first["session_name"])
         return _event(False, "cdx", f"Waiting for {first['session_name']}", first["session_name"], timestamp)
 
@@ -93,9 +126,16 @@ def resolve_notify_event(rows, parsed, now_ts=None):
     return _event(False, "cdx", f"Waiting for {row['session_name']} reset", row["session_name"], timestamp)
 
 
-def _is_available(row):
+def _is_usable_now(row):
     value = row.get("available_pct")
-    return value is not None and value > 0
+    return value is not None and value > PRIORITY_EMPTY_AVAILABLE_THRESHOLD
+
+
+def _needs_refresh(row, reset_timestamp, now_ts):
+    value = row.get("available_pct")
+    if value is None or value > PRIORITY_EMPTY_AVAILABLE_THRESHOLD:
+        return False
+    return reset_timestamp is not None and reset_timestamp < now_ts
 
 
 def _next_reset_timestamp(row):
@@ -179,9 +219,225 @@ def _escape_applescript(value):
     return str(value).replace("\\", "\\\\").replace('"', '\\"')
 
 
+def schedule_notification_event(base_dir, parsed, event, spawn_sync=None, env=None, now_fn=None):
+    import sys
+    spawn_sync = spawn_sync or subprocess.run
+    env = env or os.environ
+    now_fn = now_fn or time.time
+    target_timestamp = event.get("target_timestamp")
+    if target_timestamp is None:
+        raise CdxError(f"Cannot schedule notification: {event['message']}")
+    if target_timestamp <= now_fn():
+        return {
+            "scheduled": False,
+            "backend": "immediate",
+            "message": event["message"],
+            "target_timestamp": target_timestamp,
+        }
+
+    argv = _scheduled_notify_argv(parsed, env)
+    if sys.platform == "darwin":
+        result = _schedule_macos_launchd(base_dir, parsed, event, argv, spawn_sync, env)
+    elif sys.platform == "win32":
+        result = _schedule_windows_task(parsed, event, argv, spawn_sync, env)
+    else:
+        result = _schedule_linux(parsed, event, argv, spawn_sync, env)
+    result["target_timestamp"] = target_timestamp
+    result["target_iso"] = _timestamp_to_local_iso(target_timestamp)
+    return result
+
+
+def _scheduled_notify_argv(parsed, env):
+    executable = env.get("CDX_BIN") or shutil_which("cdx", env) or "cdx"
+    argv = [executable, "notify"]
+    if parsed["mode"] == "at-reset":
+        argv.append(parsed["name"])
+        argv.append("--at-reset")
+    else:
+        argv.append("--next-ready")
+    argv.append("--once")
+    argv.append("--refresh")
+    return argv
+
+
+def _schedule_macos_launchd(base_dir, parsed, event, argv, spawn_sync, env):
+    label = _schedule_id("com.cdx-manager.notify", parsed, event)
+    schedule_dir = os.path.join(base_dir, "state", "notifications")
+    os.makedirs(schedule_dir, mode=0o700, exist_ok=True)
+    script_path = os.path.join(schedule_dir, f"{label}.sh")
+    launch_agents = os.path.join(os.path.expanduser("~"), "Library", "LaunchAgents")
+    os.makedirs(launch_agents, exist_ok=True)
+    plist_path = os.path.join(launch_agents, f"{label}.plist")
+    target = _round_up_to_next_minute(datetime.fromtimestamp(event["target_timestamp"]).astimezone())
+    script = _macos_schedule_script(argv, env, label, plist_path, script_path)
+    with open(script_path, "w", encoding="utf-8") as f:
+        f.write(script)
+    try:
+        os.chmod(script_path, 0o700)
+    except OSError:
+        pass
+    with open(plist_path, "w", encoding="utf-8") as f:
+        f.write(_launchd_plist(label, script_path, target))
+    result = _run_scheduler_command(["launchctl", "bootstrap", f"gui/{os.getuid()}", plist_path], spawn_sync, env)
+    if not result["ok"]:
+        if _scheduler_error_means_exists(result["error"]):
+            return {"scheduled": True, "existing": True, "backend": "launchd", "id": label, "path": plist_path}
+        result = _run_scheduler_command(["launchctl", "load", plist_path], spawn_sync, env)
+    if not result["ok"]:
+        if _scheduler_error_means_exists(result["error"]):
+            return {"scheduled": True, "existing": True, "backend": "launchd", "id": label, "path": plist_path}
+        raise CdxError(f"Failed to schedule notification with launchd: {result['error']}")
+    return {"scheduled": True, "existing": False, "backend": "launchd", "id": label, "path": plist_path}
+
+
+def _macos_schedule_script(argv, env, label, plist_path, script_path):
+    lines = ["#!/bin/sh", f"export PATH={shlex.quote(env.get('PATH', '/usr/local/bin:/usr/bin:/bin'))}"]
+    if env.get("CDX_HOME"):
+        lines.append(f"export CDX_HOME={shlex.quote(env['CDX_HOME'])}")
+    lines.extend([
+        f"{' '.join(shlex.quote(str(part)) for part in argv)}",
+        "status=$?",
+        f"launchctl bootout {shlex.quote('gui/' + str(os.getuid()) + '/' + label)} >/dev/null 2>&1 || launchctl unload {shlex.quote(plist_path)} >/dev/null 2>&1 || true",
+        f"rm -f {shlex.quote(plist_path)} {shlex.quote(script_path)}",
+        "exit $status",
+        "",
+    ])
+    return "\n".join(lines)
+
+
+def _launchd_plist(label, script_path, target):
+    return f"""<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>{_escape_xml(label)}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>/bin/sh</string>
+    <string>{_escape_xml(script_path)}</string>
+  </array>
+  <key>StartCalendarInterval</key>
+  <dict>
+    <key>Month</key><integer>{target.month}</integer>
+    <key>Day</key><integer>{target.day}</integer>
+    <key>Hour</key><integer>{target.hour}</integer>
+    <key>Minute</key><integer>{target.minute}</integer>
+  </dict>
+</dict>
+</plist>
+"""
+
+
+def _schedule_linux(parsed, event, argv, spawn_sync, env):
+    unit = _schedule_id("cdx-manager-notify", parsed, event)
+    target = _round_up_to_next_minute(datetime.fromtimestamp(event["target_timestamp"]).astimezone())
+    if shutil_which("systemd-run", env):
+        calendar = target.strftime("%Y-%m-%d %H:%M:%S")
+        result = _run_scheduler_command(
+            ["systemd-run", "--user", f"--unit={unit}", f"--on-calendar={calendar}", *argv],
+            spawn_sync,
+            env,
+        )
+        if result["ok"]:
+            return {"scheduled": True, "existing": False, "backend": "systemd", "id": unit}
+        if _scheduler_error_means_exists(result["error"]):
+            return {"scheduled": True, "existing": True, "backend": "systemd", "id": unit}
+        raise CdxError(f"Failed to schedule notification with systemd-run: {result['error']}")
+    if shutil_which("at", env):
+        at_time = target.strftime("%Y%m%d%H%M.%S")
+        command = " ".join(shlex.quote(str(part)) for part in argv)
+        result = _run_scheduler_command(["at", "-t", at_time], spawn_sync, env, input_text=f"{command}\n")
+        if result["ok"]:
+            return {"scheduled": True, "existing": False, "backend": "at", "id": unit}
+        raise CdxError(f"Failed to schedule notification with at: {result['error']}")
+    raise CdxError("Cannot schedule notification: install systemd-run or at, or run cdx notify without --schedule")
+
+
+def _schedule_windows_task(parsed, event, argv, spawn_sync, env):
+    name = _schedule_id("cdx-manager-notify", parsed, event)
+    target = datetime.fromtimestamp(event["target_timestamp"]).astimezone()
+    command = subprocess.list2cmdline([str(part) for part in argv])
+    result = _run_scheduler_command([
+        "schtasks",
+        "/Create",
+        "/SC",
+        "ONCE",
+        "/TN",
+        name,
+        "/TR",
+        command,
+        "/ST",
+        target.strftime("%H:%M"),
+        "/SD",
+        target.strftime("%m/%d/%Y"),
+        "/F",
+        "/Z",
+    ], spawn_sync, env)
+    if not result["ok"]:
+        raise CdxError(f"Failed to schedule notification with Task Scheduler: {result['error']}")
+    return {"scheduled": True, "existing": False, "backend": "schtasks", "id": name}
+
+
+def _run_scheduler_command(argv, spawn_sync, env, input_text=None):
+    try:
+        completed = spawn_sync(
+            argv,
+            env=env,
+            input=input_text,
+            capture_output=True,
+            text=True,
+            timeout=10,
+        )
+    except (FileNotFoundError, OSError) as error:
+        return {"ok": False, "error": str(error)}
+    return {
+        "ok": getattr(completed, "returncode", 0) == 0,
+        "error": (getattr(completed, "stderr", "") or getattr(completed, "stdout", "") or "").strip(),
+    }
+
+
+def _schedule_id(prefix, parsed, event):
+    session = parsed.get("name") or event.get("session") or "next-ready"
+    safe_session = "".join(ch if ch.isalnum() else "-" for ch in str(session).lower()).strip("-") or "session"
+    return f"{prefix}.{parsed['mode']}.{safe_session}.{int(event['target_timestamp'])}"
+
+
+def _scheduler_error_means_exists(error):
+    normalized = str(error or "").lower()
+    return any(fragment in normalized for fragment in (
+        "already exists",
+        "file exists",
+        "unit exists",
+        "unit already",
+        "service already",
+        "bootstrap failed: 5",
+    ))
+
+
+def _timestamp_to_local_iso(timestamp):
+    return datetime.fromtimestamp(timestamp).astimezone().isoformat()
+
+
+def _round_up_to_next_minute(value):
+    if value.second == 0 and value.microsecond == 0:
+        return value
+    return (value + timedelta(minutes=1)).replace(second=0, microsecond=0)
+
+
+def _escape_xml(value):
+    return str(value).replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;").replace('"', "&quot;")
+
+
 def format_notify_event(event):
     return event["message"]
 
 
+def format_scheduled_notification(schedule):
+    if schedule.get("scheduled"):
+        return f"Scheduled notification via {schedule['backend']} for {schedule['target_iso']}"
+    return schedule["message"]
+
+
 def notify_json(event):
     return json.dumps(event, indent=2)

package/src/provider_runtime.py

@@ -12,6 +12,20 @@ from .errors import CdxError
 
 
 LOG_ROTATE_BYTES = 10 * 1024 * 1024  # 10 MB
+LAUNCH_PERMISSION_ARGS = {
+    PROVIDER_CLAUDE: {
+        "review": ["--permission-mode", "plan"],
+        "default": ["--permission-mode", "default"],
+        "auto": ["--permission-mode", "auto"],
+        "full": ["--permission-mode", "bypassPermissions"],
+    },
+    PROVIDER_CODEX: {
+        "review": ["-s", "read-only", "-a", "on-request"],
+        "default": ["-s", "workspace-write", "-a", "on-request"],
+        "auto": ["-s", "workspace-write", "-a", "never"],
+        "full": ["-s", "danger-full-access", "-a", "never"],
+    },
+}
 
 
 def _home_env_overrides(auth_home):
@@ -49,6 +63,35 @@ def _build_launch_transcript_path(session):
     )
 
 
+def _launch_power(session):
+    launch = session.get("launch") or {}
+    power = launch.get("power")
+    if power:
+        return power
+    if launch.get("fast") is True:
+        return "low"
+    return None
+
+
+def _launch_config_args(session):
+    launch = session.get("launch") or {}
+    args = []
+    power = _launch_power(session)
+    permission = launch.get("permission")
+    provider = session["provider"]
+    if provider == PROVIDER_CLAUDE:
+        if power:
+            args += ["--effort", power]
+        if permission:
+            args += LAUNCH_PERMISSION_ARGS[PROVIDER_CLAUDE].get(permission, [])
+        return args
+    if power:
+        args += ["-c", f'model_reasoning_effort="{power}"']
+    if permission:
+        args += LAUNCH_PERMISSION_ARGS[PROVIDER_CODEX].get(permission, [])
+    return args
+
+
 def _list_launch_transcript_paths(session, glob_fn=None):
     import glob
 
@@ -109,7 +152,7 @@ def _build_launch_spec(session, cwd=None, env_override=None, initial_prompt=None
     env_override = env_override or {}
     env = {**os.environ, **env_override}
     if session["provider"] == PROVIDER_CLAUDE:
-        args = ["--name", session["name"]]
+        args = ["--name", session["name"]] + _launch_config_args(session)
         if initial_prompt:
             args.append(initial_prompt)
         return _wrap_launch_with_transcript(session, {
@@ -121,7 +164,7 @@ def _build_launch_spec(session, cwd=None, env_override=None, initial_prompt=None
             },
             "label": "claude",
         }, env=env)
-    args = ["--no-alt-screen", "--cd", cwd]
+    args = ["--no-alt-screen", "--cd", cwd] + _launch_config_args(session)
     if initial_prompt:
         args.append(initial_prompt)
     return _wrap_launch_with_transcript(session, {

package/src/session_service.py

@@ -37,7 +37,10 @@ RESERVED_SESSION_NAMES = {
     "ren",
     "rename",
     "rmv",
+    "config",
+    "set",
     "status",
+    "unset",
     "update",
     "version",
     "--help",
@@ -45,6 +48,10 @@ RESERVED_SESSION_NAMES = {
     "--version",
     "-v",
 }
+STATUS_CACHE_TTL_SECONDS = 60
+CLAUDE_STATUS_CACHE_TTL_SECONDS = 10 * 60
+LAUNCH_POWER_VALUES = {"low", "medium", "high", "xhigh", "max"}
+LAUNCH_PERMISSION_VALUES = {"review", "default", "auto", "full"}
 
 
 def _encode(name):
@@ -76,6 +83,35 @@ def _seed_codex_auth_from_global(auth_home, env=None):
     return True
 
 
+def _normalize_launch_settings(settings):
+    normalized = {}
+    if not settings:
+        return normalized
+    if "power" in settings and settings["power"] is not None:
+        power = str(settings["power"]).strip().lower()
+        if power not in LAUNCH_POWER_VALUES:
+            raise CdxError(f"Unsupported power: {settings['power']}")
+        normalized["power"] = power
+    if "permission" in settings and settings["permission"] is not None:
+        permission = str(settings["permission"]).strip().lower()
+        if permission not in LAUNCH_PERMISSION_VALUES:
+            raise CdxError(f"Unsupported permission: {settings['permission']}")
+        normalized["permission"] = permission
+    if "fast" in settings and settings["fast"] is not None:
+        value = settings["fast"]
+        if isinstance(value, bool):
+            normalized["fast"] = value
+        else:
+            text = str(value).strip().lower()
+            if text in ("on", "true", "1", "yes"):
+                normalized["fast"] = True
+            elif text in ("off", "false", "0", "no"):
+                normalized["fast"] = False
+            else:
+                raise CdxError(f"Unsupported fast value: {settings['fast']}")
+    return normalized
+
+
 def _local_now_iso():
     return datetime.now().astimezone().isoformat()
 
@@ -133,6 +169,24 @@ def _parse_status_timestamp(value):
         return None
 
 
+def _status_cache_ttl_seconds(session, ttl_seconds=STATUS_CACHE_TTL_SECONDS):
+    if session.get("provider") == PROVIDER_CLAUDE and ttl_seconds == STATUS_CACHE_TTL_SECONDS:
+        return CLAUDE_STATUS_CACHE_TTL_SECONDS
+    return ttl_seconds
+
+
+def _is_status_cache_fresh(session, ttl_seconds=STATUS_CACHE_TTL_SECONDS):
+    status = session.get("lastStatus") or {}
+    if _is_low_confidence_status_source(status):
+        return False
+    updated_at = _parse_status_timestamp(status.get("updated_at") or session.get("lastStatusAt"))
+    if not updated_at:
+        return False
+    now = datetime.now(timezone.utc).astimezone()
+    ttl_seconds = _status_cache_ttl_seconds(session, ttl_seconds)
+    return (now - updated_at.astimezone(now.tzinfo)).total_seconds() < ttl_seconds
+
+
 def _is_status_newer(candidate, current):
     if not candidate:
         return False
@@ -292,6 +346,7 @@ def create_session_service(options=None):
             "lastLaunchedAt": session.get("lastLaunchedAt"),
             "lastStatusAt": session.get("lastStatusAt"),
             "lastStatus": session.get("lastStatus"),
+            "launch": session.get("launch"),
             "auth": session.get("auth"),
         }
 
@@ -439,6 +494,7 @@ def create_session_service(options=None):
             "lastLaunchedAt": None,
             "lastStatusAt": None,
             "lastStatus": None,
+            **({"launch": source.get("launch")} if source.get("launch") else {}),
             "auth": {
                 "status": "unknown",
                 "lastCheckedAt": None,
@@ -561,6 +617,47 @@ def create_session_service(options=None):
             "updatedAt": now,
         })
 
+    def set_launch_settings(name, settings):
+        session = store["get_session"](name)
+        if not session:
+            raise CdxError(f"Unknown session: {name}")
+        updates = _normalize_launch_settings(settings)
+        if not updates:
+            raise CdxError("At least one launch setting is required.")
+        current = _normalize_launch_settings(session.get("launch") or {})
+        launch = {**current, **updates}
+        now = _local_now_iso()
+        return store["update_session"](name, lambda s: {
+            **s,
+            "launch": launch,
+            "updatedAt": now,
+        })
+
+    def unset_launch_settings(name, keys):
+        session = store["get_session"](name)
+        if not session:
+            raise CdxError(f"Unknown session: {name}")
+        if not keys:
+            raise CdxError("At least one launch setting is required.")
+        allowed = {"power", "permission", "fast"}
+        unknown = [key for key in keys if key not in allowed]
+        if unknown:
+            raise CdxError(f"Unsupported launch setting: {', '.join(unknown)}")
+        current = dict(session.get("launch") or {})
+        for key in keys:
+            current.pop(key, None)
+        now = _local_now_iso()
+
+        def updater(s):
+            updated = {**s, "updatedAt": now}
+            if current:
+                updated["launch"] = current
+            else:
+                updated.pop("launch", None)
+            return updated
+
+        return store["update_session"](name, updater)
+
     def record_status(name, payload):
         normalized = _normalize_status_payload(payload)
         updated = store["update_session"](name, lambda s: {
@@ -572,8 +669,12 @@ def create_session_service(options=None):
             raise CdxError(f"Unknown session: {name}")
         return updated
 
-    def _resolve_session_status(session):
+    def _resolve_session_status(session, force_refresh=False, cache_ttl_seconds=STATUS_CACHE_TTL_SECONDS):
         current_status = session.get("lastStatus")
+        if session.get("enabled", True) is False:
+            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"]
         )
@@ -644,7 +745,7 @@ def create_session_service(options=None):
             raise CdxError(f"Unknown session: {name}")
         return updated
 
-    def get_status_rows(progress_callback=None):
+    def get_status_rows(progress_callback=None, force_refresh=False, cache_ttl_seconds=STATUS_CACHE_TTL_SECONDS):
         sessions = list_sessions()
         if progress_callback:
             progress_callback({
@@ -653,13 +754,25 @@ def create_session_service(options=None):
             })
         resolved = []
         for s in sessions:
-            if progress_callback:
+            cache_hit = (
+                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)
+                )
+            )
+            if progress_callback and not cache_hit:
                 progress_callback({
                     "event": "session_started",
                     "session_name": s["name"],
                     "provider": s["provider"],
                 })
-            status = _resolve_session_status(s)
+            status = _resolve_session_status(
+                s,
+                force_refresh=force_refresh,
+                cache_ttl_seconds=cache_ttl_seconds,
+            )
             if progress_callback:
                 progress_callback({
                     "event": "session_finished",
@@ -687,18 +800,20 @@ 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": s.get("enabled", True) is not False,
-                "status": "disabled" if s.get("enabled", True) is False else "enabled",
-                "remaining_5h_pct": status.get("remaining_5h_pct") if status else None,
-                "remaining_week_pct": status.get("remaining_week_pct") if status else None,
-                "credits": status.get("credits") if status else None,
-                "available_pct": _compute_available_pct(status),
-                "reset_5h_at": status.get("reset_5h_at") if status else None,
-                "reset_week_at": status.get("reset_week_at") if status else None,
-                "reset_at": status.get("reset_at") if status else None,
+                "enabled": enabled,
+                "status": "enabled" if enabled else "disabled",
+                "remaining_5h_pct": row_status.get("remaining_5h_pct") if row_status else None,
+                "remaining_week_pct": 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")),
             })
@@ -726,6 +841,7 @@ def create_session_service(options=None):
             "enabled": s.get("enabled", True) is not False,
             "enabled_status": "disabled" if s.get("enabled", True) is False else "enabled",
             "status": s.get("lastStatus"),
+            "launch": s.get("launch") or {},
             "updated_at": _to_local_iso(s.get("updatedAt")),
         } for s in sessions]
 
@@ -880,6 +996,8 @@ def create_session_service(options=None):
         "list_sessions": list_sessions,
         "get_session": get_session,
         "set_session_enabled": set_session_enabled,
+        "set_launch_settings": set_launch_settings,
+        "unset_launch_settings": unset_launch_settings,
         "record_status": record_status,
         "update_auth_state": update_auth_state,
         "get_status_rows": get_status_rows,

package/src/status_view.py

@@ -82,17 +82,20 @@ def _format_status_rows(rows, use_color=False, small=False):
             base.append(r.get("provider") or "n/a")
         status = r.get("status") or ("enabled" if r.get("enabled", True) else "disabled")
         base.append(_style(status, "2" if status == "disabled" else "32", use_color))
-        usage_columns = [
-            _style_pct(r.get("available_pct"), use_color),
-            _style_pct(r.get("remaining_5h_pct"), use_color),
-            _style_pct(r.get("remaining_week_pct"), use_color),
-            _style_reset_time(r.get("reset_5h_at"), use_color),
-            _style_reset_time(r.get("reset_week_at"), use_color),
-        ]
+        if r.get("enabled", True) is False:
+            usage_columns = [_style("-", "2", use_color)] * 5
+        else:
+            usage_columns = [
+                _style_pct(r.get("available_pct"), use_color),
+                _style_pct(r.get("remaining_5h_pct"), use_color),
+                _style_pct(r.get("remaining_week_pct"), use_color),
+                _style_reset_time(r.get("reset_5h_at"), use_color),
+                _style_reset_time(r.get("reset_week_at"), use_color),
+            ]
         if small:
             base += usage_columns
         else:
-            block = _format_blocking_quota(r)
+            block = "-" if r.get("enabled", True) is False else _format_blocking_quota(r)
             credits = str(r["credits"]) if r.get("credits") is not None else "-"
             base += usage_columns[:3] + [
                 _style(block, "33" if block not in ("?", "-") else "2", use_color),