cdx-manager 0.5.6 → 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.6-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.6 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] [--refresh] [--json]` | Wait for a session reset time and send a desktop notification when due |
-| `cdx notify --next-ready [--poll seconds] [--once] [--refresh] [--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_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.6",
+  "version": "0.5.7",
   "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.5.6"
+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.6"
+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 [--refresh] [--json]', '36', use_color)}",
-        f"  {_style('cdx notify --next-ready [--refresh] [--json]', '36', use_color)}",
+        f"  {_style('cdx notify <name> --at-reset [--schedule] [--refresh] [--json]', '36', use_color)}",
+        f"  {_style('cdx notify --next-ready [--schedule] [--refresh] [--json]', '36', use_color)}",
         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
 
@@ -302,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)
@@ -518,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"]
@@ -639,6 +748,38 @@ 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,

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,7 +1,9 @@
 import json
 import os
+import shlex
 import subprocess
 import time
+from datetime import datetime, timedelta
 
 from .errors import CdxError
 from .status_view import (
@@ -12,23 +14,27 @@ from .status_view import (
 )
 
 
+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):
     json_flag = "--json" in 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", "--refresh"):
+        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] [--refresh] | cdx notify --next-ready [--poll seconds] [--once] [--refresh]")
+                raise CdxError(NOTIFY_USAGE)
             try:
                 poll = max(1, int(args[i + 1]))
             except ValueError as error:
@@ -43,15 +49,15 @@ def parse_notify_args(args):
             i += 1
             continue
         if arg.startswith("-"):
-            raise CdxError("Usage: cdx notify <name> --at-reset [--poll seconds] [--once] [--refresh] | cdx notify --next-ready [--poll seconds] [--once] [--refresh]")
+            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] [--refresh] | cdx notify --next-ready [--poll seconds] [--once] [--refresh]")
+        raise CdxError(NOTIFY_USAGE)
     if at_reset and len(cleaned) != 1:
-        raise CdxError("Usage: cdx notify <name> --at-reset [--poll seconds] [--once] [--refresh]")
+        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] [--refresh]")
+        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",
@@ -59,6 +65,7 @@ def parse_notify_args(args):
         "once": once,
         "json": json_flag,
         "refresh": refresh,
+        "schedule": schedule,
     }
 
 
@@ -212,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",
@@ -47,6 +50,8 @@ RESERVED_SESSION_NAMES = {
 }
 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):
@@ -78,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()
 
@@ -312,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"),
         }
 
@@ -459,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,
@@ -581,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: {
@@ -764,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]
 
@@ -918,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,