cdx-manager 0.6.1 → 0.6.3

package/README.md

@@ -1,8 +1,8 @@
 # CDX Manager
 
-[![License](https://img.shields.io/badge/license-MIT-4C8BF5)](LICENSE) ![Version](https://img.shields.io/badge/version-v0.6.1-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.6.3-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.**
+**Run multiple Codex, Claude, Antigravity, and Ollama sessions from one terminal. Switch between accounts instantly.**
 
 If you use AI coding tools at scale ; multiple accounts, multiple providers : you know the friction: re-authenticating, losing context, juggling environment variables. `cdx` removes all of that.
 
@@ -32,7 +32,7 @@ One command to launch any session. Zero auth juggling.
 
 ## What it does
 
-- **Multiple accounts, one tool.** Register as many Codex or Claude sessions as you need. Each one gets its own isolated auth environment — no cross-contamination between accounts.
+- **Multiple providers, one tool.** Register as many Codex, Claude, Antigravity, or Ollama sessions as you need. Codex and Claude get isolated auth environments; Antigravity is launchable through `agy` with OS-keyring auth; Ollama runs local models through `ollama run`.
 - **Instant launch.** `cdx work` opens your "work" session. `cdx personal` opens another. No config files to edit mid-flow.
 - **Quick relaunch.** `cdx last` reopens the most recently launched assistant profile.
 - **Auth guardrails.** `cdx` checks authentication before launching. If a session is not logged in, it tells you exactly what to run — no silent failures.
@@ -54,7 +54,9 @@ One command to launch any session. Zero auth juggling.
 - Python 3.9+, zero runtime dependencies.
 - Environment isolation per session:
   - Codex sessions override `CODEX_HOME` to a dedicated profile directory.
-  - Claude sessions override `HOME` to a dedicated profile directory.
+  - Claude sessions override `HOME` to a dedicated profile directory and disable Claude Code commit co-author attribution by default.
+  - Antigravity sessions launch `agy` with a dedicated `HOME` for file-based settings; Google account credentials may still be stored in the OS keyring by Antigravity itself.
+  - Ollama sessions use the local Ollama server and launch `ollama run <model>`; set a model with `cdx set <name> --model <model>`.
   - New Codex sessions seed their auth home from your existing global `~/.codex/auth.json` when available, so an already logged-in Codex CLI can be reused without giving up per-session isolation afterward.
 - Persistence:
   - Session registry at `~/.cdx/sessions.json` (versioned JSON store).
@@ -82,7 +84,7 @@ One command to launch any session. Zero auth juggling.
 
 - Node.js 18+ with npm
 - Python 3.9+
-- `codex` and/or `claude` CLI installed and available in your PATH
+- `codex`, `claude`, `agy`, and/or `ollama` CLI installed and available in your PATH
 
 On Windows, the npm launcher looks for Python in this order: `py -3`, `python`, then `python3`. Make sure at least one of those commands resolves to Python 3.
 
@@ -132,7 +134,7 @@ For a specific version:
 
 ```bash
 curl -fsSL https://raw.githubusercontent.com/AlexAgo83/cdx-manager/main/install.sh -o install.sh
-CDX_VERSION=v0.6.1 sh install.sh
+CDX_VERSION=v0.6.3 sh install.sh
 ```
 
 From source:
@@ -227,6 +229,9 @@ cdx add work
 # Register a Claude session
 cdx add claude personal
 
+# Register an Ollama session
+cdx add ollama local --model llama3.2
+
 # List all sessions
 cdx
 
@@ -256,6 +261,11 @@ By default, `cdx` launches provider CLIs without forcing model effort, permissio
 ```bash
 cdx set work --power medium --permission full --fast off
 cdx set personal --power low --permission review
+cdx set --sessions all --permission auto
+cdx set --provider ollama --model llama3.2
+cdx power all low
+cdx perm provider:claude review
+cdx model provider:ollama llama3.2
 cdx config work
 ```
 
@@ -263,7 +273,11 @@ Those values are stored on the session and reapplied every time you run `cdx wor
 
 ```bash
 cdx unset work --power
+cdx unset --sessions work,personal --fast
+cdx unset --provider claude --permission
 cdx unset work --all
+cdx power all default
+cdx model provider:ollama default
 ```
 
 `--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.
@@ -294,7 +308,7 @@ cdx history --summary --from 2026-05-01 --to 2026-05-28
 | `cdx --json` | List all sessions as a machine-readable JSON payload |
 | `cdx <name>` | Launch a session (checks auth first) |
 | `cdx <name> [--json]` | Launch a session; `--json` returns a structured success payload after the interactive run ends |
-| `cdx add [provider] <name> [--json]` | Register a new session (`provider`: `codex` or `claude`, default: `codex`) |
+| `cdx add [provider] <name> [--model MODEL] [--json]` | Register a new session (`provider`: `codex`, `claude`, `antigravity`, or `ollama`; Ollama requires `--model`) |
 | `cdx cp <source> <dest> [--json]` | Copy a session into another session name, overwriting the destination if it exists |
 | `cdx ren <source> <dest> [--json]` | Rename a session and move its auth data |
 | `cdx login <name> [--json]` | Re-authenticate a session (logout + login) |
@@ -302,13 +316,14 @@ cdx history --summary --from 2026-05-01 --to 2026-05-28
 | `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 power\|perm\|fast\|model <name\|all\|provider:PROVIDER\|a,b> <value\|default> [--json]` | Shortcut commands for setting or clearing one launch setting |
+| `cdx set <name>\|--sessions all\|a,b\|--provider PROVIDER [--power low\|medium\|high\|xhigh\|max] [--permission review\|default\|auto\|full] [--fast on\|off] [--model MODEL] [--json]` | Persist launch settings for one or more sessions |
+| `cdx unset <name>\|--sessions all\|a,b\|--provider PROVIDER (--power\|--permission\|--fast\|--model\|--all) [--json]` | Remove persisted launch settings and fall back to provider defaults |
 | `cdx history [name] [--limit N] [--summary] [--since 7d\|today\|DATE] [--from DATE] [--to DATE] [--json]` | Show recent launch history or aggregate total launch time per assistant, optionally filtered by period |
 | `cdx last [--json]` | Launch the most recent existing session from launch history |
 | `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 |
+| `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 cross-provider handoff |
 | `cdx rmv <name> [--force] [--json]` | Remove a session and its auth data (prompts for confirmation unless `--force`) |
 | `cdx clean [name] [--json]` | Clear launch transcript logs for one session or all sessions |
 | `cdx export <file> [--include-auth] [--sessions a,b] [--passphrase-env VAR] [--force] [--json]` | Export sessions to a portable bundle; `--include-auth` encrypts auth data with a passphrase |

package/changelogs/CHANGELOGS_0_6_2.md

@@ -0,0 +1,42 @@
+# Changelog (`0.6.1 -> 0.6.2`)
+
+Release date: 2026-05-29
+
+## Provider Support
+
+- Added Antigravity provider support through the `agy` CLI with isolated session homes, launch settings, and transcript capture.
+- Added Ollama provider support through `ollama run`, including model-backed session configuration and transcript capture.
+- Added explicit `cdx add ollama <name> --model MODEL` registration so Ollama sessions do not depend on ambiguous session-name model defaults.
+
+## Launch Settings
+
+- Added bulk launch setting updates for all sessions, provider-filtered sessions, and named session subsets.
+- Added shortcut launch setting commands for power, permission, fast mode, and model changes.
+- Updated help and README command documentation for provider launch settings.
+
+## Claude Behavior
+
+- Fixed Claude auth reuse and status refresh behavior.
+- Disabled Claude commit attribution by default for managed Claude sessions.
+
+## Runtime Reliability
+
+- Set `OLLAMA_NOHISTORY=1` for Ollama launch, status, and auth-check operations to avoid local history-file permission failures.
+- Preserved provider-specific launch arguments across the transcript wrapper and fallback paths.
+
+## Release Metadata and Documentation
+
+- Updated package metadata, CLI version output, README badge, and pinned installer example to `v0.6.2`.
+
+## Validation and Regression Coverage
+
+- Added coverage for Antigravity launch specs and auth checks.
+- Added coverage for Ollama session creation, model persistence, launch specs, and no-history environment handling.
+- Added coverage for bulk and shortcut launch setting commands.
+- Added coverage for Claude auth/status behavior and commit-attribution defaults.
+
+## Validation and Regression Evidence
+
+- `npm run lint`
+- `npm test`
+- `npm pack --dry-run`

package/changelogs/CHANGELOGS_0_6_3.md

@@ -0,0 +1,28 @@
+# Changelog (`0.6.2 -> 0.6.3`)
+
+Release date: 2026-05-29
+
+## Claude Authentication
+
+- Fixed Claude Code 2.1.145 isolated auth handling by using `ANTHROPIC_CONFIG_DIR` instead of the older `CLAUDE_CONFIG_DIR` override.
+- Removed leaked `CODEX_HOME` from Claude auth, launch, and status environments so Claude sessions do not write nested `.cdx` state inside isolated Claude homes.
+- Stopped running a destructive Claude logout before `cdx login <name>`, preserving existing credentials when reauthenticating a session.
+- Added profile email hints to Claude login so account-specific sessions open the expected Claude account in the browser.
+
+## Claude Token Fallback
+
+- Added automatic `claude setup-token` fallback when browser login completes but does not create isolated credentials.
+- Captured the one-time setup token through a temporary transcript, wrote it to `claude-home/credentials/default.json`, and removed the temporary transcript after extraction.
+- Added support for the new Anthropic `credentials/default.json` OAuth format during auth probes, launches, status refreshes, and auth bundle exports.
+
+## Release Metadata and Documentation
+
+- Updated package metadata, CLI version output, README badge, and pinned installer example to `v0.6.3`.
+
+## Validation and Regression Coverage
+
+- Added regression coverage for Claude login without pre-logout, email-hinted login, setup-token fallback, modern Anthropic credentials, and cleaned Claude environments.
+
+## Validation and Regression Evidence
+
+- `python3 -m unittest discover -s test -p 'test_*_py.py'`

package/checksums/release-archives.json

@@ -8,6 +8,14 @@
     "v0.4.0": {
       "github_tarball_sha256": "47a99ff2663f4fee33339098d2cfe7c27fbd0f74a16a1f6711f3003287409ae8",
       "github_zip_sha256": "ae7eff748e569c621ef203abb6b395fbf893370471e962252e8c781e7751e5c8"
+    },
+    "v0.6.1": {
+      "github_tarball_sha256": "5ae4032894e1806ffb3a713e555c12b2faa3bfa6fd7c9fa468664a8577abe827",
+      "github_zip_sha256": "7949e99dcfe21dc4e2b82f720b515aea8f0ac9f2059142032d488bcfbc4dfaf1"
+    },
+    "v0.6.2": {
+      "github_tarball_sha256": "0a00fba132453d265a72fa551bff750a9a400011f895d9da33149b335324e02e",
+      "github_zip_sha256": "424b1c9652da5054bdc4cf26f31764ea34ddc4609d6eb8075efbf8068112cd50"
     }
   }
 }

package/package.json

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

package/src/claude_usage.py

@@ -1,5 +1,7 @@
 import json
 import os
+import subprocess
+import sys
 import urllib.request
 import urllib.error
 from datetime import datetime, timezone
@@ -9,9 +11,20 @@ from .errors import CdxError
 MONTH_ABBR = ["Jan", "Feb", "Mar", "Apr", "May", "Jun",
               "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"]
 CLAUDE_STATUS_PROBE_MODEL = os.environ.get("CDX_CLAUDE_STATUS_MODEL", "claude-haiku-4-5-20251001")
+CLAUDE_AUTH_STATUS_TIMEOUT_SECONDS = 15
 
 
 def _read_claude_credentials(auth_home):
+    anthropic_cred_path = os.path.join(auth_home, "credentials", "default.json")
+    try:
+        with open(anthropic_cred_path, "r", encoding="utf-8") as f:
+            data = json.load(f)
+        token = data.get("access_token") if isinstance(data, dict) else None
+        if token:
+            return {"accessToken": token}
+    except (FileNotFoundError, json.JSONDecodeError, OSError):
+        pass
+
     cred_path = os.path.join(auth_home, ".claude", ".credentials.json")
     try:
         with open(cred_path, "r", encoding="utf-8") as f:
@@ -21,6 +34,40 @@ def _read_claude_credentials(auth_home):
         return None
 
 
+def _home_env_overrides(auth_home):
+    overrides = {
+        "HOME": auth_home,
+        "ANTHROPIC_CONFIG_DIR": auth_home,
+        "CLAUDE_CODE_DISABLE_GIT_INSTRUCTIONS": "1",
+    }
+    if sys.platform == "win32":
+        overrides["USERPROFILE"] = auth_home
+        overrides["HOMEDRIVE"] = os.path.splitdrive(auth_home)[0] or "C:"
+        overrides["HOMEPATH"] = os.path.splitdrive(auth_home)[1] or auth_home
+    return overrides
+
+
+def _refresh_claude_cli_credentials(auth_home, runner=None, env=None):
+    if not auth_home:
+        return
+    if os.environ.get("CDX_CLAUDE_SKIP_AUTH_STATUS_REFRESH") == "1":
+        return
+    runner = runner or subprocess.run
+    command = ["claude", "auth", "status"]
+    run_env = {**(env or os.environ), **_home_env_overrides(auth_home)}
+    try:
+        runner(
+            command,
+            env=run_env,
+            capture_output=True,
+            text=True,
+            timeout=CLAUDE_AUTH_STATUS_TIMEOUT_SECONDS,
+            check=False,
+        )
+    except (FileNotFoundError, subprocess.SubprocessError, OSError):
+        return
+
+
 def _format_reset_date(unix_seconds):
     dt = datetime.fromtimestamp(unix_seconds, tz=timezone.utc).astimezone()
     return f"{MONTH_ABBR[dt.month - 1]} {dt.day} {str(dt.hour).zfill(2)}:{str(dt.minute).zfill(2)}"
@@ -109,8 +156,11 @@ def fetch_claude_rate_limit_headers(access_token):
     }
 
 
-def refresh_claude_session_status(session):
-    creds = _read_claude_credentials(session.get("authHome", ""))
+def refresh_claude_session_status(session, auth_refresher=None):
+    auth_home = session.get("authHome", "")
+    refresher = auth_refresher or _refresh_claude_cli_credentials
+    refresher(auth_home)
+    creds = _read_claude_credentials(auth_home)
     if not creds or not creds.get("accessToken"):
         return None
     return fetch_claude_rate_limit_headers(creds["accessToken"])

package/src/cli.py

@@ -23,6 +23,7 @@ from .cli_commands import (
     handle_launch,
     handle_login,
     handle_logout,
+    handle_launch_setting_alias,
     handle_notify,
     handle_remove,
     handle_repair,
@@ -54,7 +55,7 @@ from .status_view import (
 )
 from .update_check import check_for_update
 
-VERSION = "0.6.1"
+VERSION = "0.6.3"
 
 
 # ---------------------------------------------------------------------------
@@ -73,13 +74,14 @@ def _print_help(use_color=False):
         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 power|perm|fast|model <name|all|provider:PROVIDER|a,b> <value|default> [--json]', '36', use_color)}",
+        f"  {_style('cdx set <name>|--sessions all|a,b|--provider PROVIDER [--power low|medium|high|xhigh|max] [--permission review|default|auto|full] [--fast on|off] [--model MODEL] [--json]', '36', use_color)}",
+        f"  {_style('cdx unset <name>|--sessions all|a,b|--provider PROVIDER (--power|--permission|--fast|--model|--all) [--json]', '36', use_color)}",
         f"  {_style('cdx history [name] [--limit N] [--summary] [--since 7d|today|DATE] [--from DATE] [--to DATE] [--json]', '36', use_color)}",
         f"  {_style('cdx last [--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)}",
+        f"  {_style('cdx add [provider] <name> [--model MODEL] [--json]', '36', use_color)}",
         f"  {_style('cdx cp <source> <dest> [--json]', '36', use_color)}",
         f"  {_style('cdx ren <source> <dest> [--json]', '36', use_color)}",
         f"  {_style('cdx login <name> [--json]', '36', use_color)}",
@@ -231,7 +233,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", "ready", "notify", "context", "config", "set", "unset", "history", "handoff", "login", "logout", "disable", "enable", "export", "import", "help", "version"
+            "add", "cp", "ren", "rename", "mv", "rmv", "clean", "doctor", "repair", "update", "ready", "notify", "context", "config", "set", "unset", "power", "perm", "fast", "model", "history", "handoff", "login", "logout", "disable", "enable", "export", "import", "help", "version"
         ) else None,
         "use_color": use_color,
     }
@@ -292,6 +294,9 @@ def main(argv, options=None):
     if command == "unset":
         return handle_unset(rest, ctx)
 
+    if command in ("power", "perm", "fast", "model"):
+        return handle_launch_setting_alias(command, rest, ctx)
+
     if command == "history":
         return handle_history(rest, ctx)
 

package/src/cli_commands.py

@@ -9,7 +9,7 @@ from datetime import datetime, timedelta
 
 from .claude_refresh import _refresh_claude_sessions
 from .cli_render import _dim, _info, _success, _warn
-from .config import PROVIDER_CODEX
+from .config import PROVIDER_ANTIGRAVITY, PROVIDER_CLAUDE, PROVIDER_CODEX, PROVIDER_OLLAMA, PROVIDERS
 from .context_store import (
     clear_context,
     edit_context,
@@ -50,8 +50,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]"
+SET_USAGE = "Usage: cdx set <name>|--sessions all|a,b|--provider PROVIDER [--power low|medium|high|xhigh|max] [--permission review|default|auto|full] [--fast on|off] [--model MODEL] [--json]"
+UNSET_USAGE = "Usage: cdx unset <name>|--sessions all|a,b|--provider PROVIDER (--power|--permission|--fast|--model|--all) [--json]"
+SETTING_ALIAS_USAGE = "Usage: cdx power|perm|fast|model <name|all|provider:PROVIDER|a,b> <value|default> [--json]"
 CONFIG_USAGE = "Usage: cdx config <name> [--json]"
 HISTORY_USAGE = "Usage: cdx history [name] [--limit N] [--summary] [--since 7d|today|DATE] [--from DATE] [--to DATE] [--json]"
 LAST_USAGE = "Usage: cdx last [--json]"
@@ -413,17 +414,17 @@ def _parse_flag_args(args, schema, usage, positionals_key=None, max_positionals=
 def _parse_add_args(args):
     parsed = _parse_flag_args(
         args,
-        {},
-        "Usage: cdx add [provider] <name> [--json]",
+        {"--model": {"key": "model", "type": "str", "default": None}},
+        "Usage: cdx add [provider] <name> [--model MODEL] [--json]",
         positionals_key="values",
         max_positionals=2,
     )
     values = parsed["values"]
     if len(values) == 1:
-        return {"provider": PROVIDER_CODEX, "name": values[0]}
+        return {"provider": PROVIDER_CODEX, "name": values[0], "model": parsed["model"]}
     if len(values) == 2:
-        return {"provider": values[0], "name": values[1]}
-    raise CdxError("Usage: cdx add [provider] <name> [--json]")
+        return {"provider": values[0], "name": values[1], "model": parsed["model"]}
+    raise CdxError("Usage: cdx add [provider] <name> [--model MODEL] [--json]")
 
 
 def _parse_copy_args(args):
@@ -470,18 +471,33 @@ def _parse_set_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},
+        "--model": {"key": "model", "type": "str", "default": None},
+        "--sessions": {"key": "sessions", "type": "str", "default": None, "transform": _parse_set_unset_sessions},
+        "--provider": {"key": "provider", "type": "str", "default": None, "transform": lambda value: _parse_provider_filter(value, SET_USAGE)},
         "--json": {"key": "json", "type": "bool", "default": False},
     }, SET_USAGE, positionals_key="names", max_positionals=1)
-    if len(parsed["names"]) != 1:
+    if len(parsed["names"]) > 1:
+        raise CdxError(SET_USAGE)
+    if parsed["names"] and parsed["sessions"]:
+        raise CdxError(SET_USAGE)
+    if parsed["names"] and parsed["provider"]:
+        raise CdxError(SET_USAGE)
+    if not parsed["names"] and not parsed["sessions"] and not parsed["provider"]:
         raise CdxError(SET_USAGE)
     settings = {
         key: parsed[key]
-        for key in ("power", "permission", "fast")
+        for key in ("power", "permission", "fast", "model")
         if parsed[key] is not None
     }
     if not settings:
         raise CdxError(SET_USAGE)
-    return {"name": parsed["names"][0], "settings": settings, "json": parsed["json"]}
+    return {
+        "name": parsed["names"][0] if parsed["names"] else None,
+        "sessions": parsed["sessions"],
+        "provider": parsed["provider"],
+        "settings": settings,
+        "json": parsed["json"],
+    }
 
 
 def _parse_unset_args(args):
@@ -489,17 +505,32 @@ def _parse_unset_args(args):
         "--power": {"key": "power", "type": "bool", "default": False},
         "--permission": {"key": "permission", "type": "bool", "default": False},
         "--fast": {"key": "fast", "type": "bool", "default": False},
+        "--model": {"key": "model", "type": "bool", "default": False},
         "--all": {"key": "all", "type": "bool", "default": False},
+        "--sessions": {"key": "sessions", "type": "str", "default": None, "transform": _parse_set_unset_sessions},
+        "--provider": {"key": "provider", "type": "str", "default": None, "transform": lambda value: _parse_provider_filter(value, UNSET_USAGE)},
         "--json": {"key": "json", "type": "bool", "default": False},
     }, UNSET_USAGE, positionals_key="names", max_positionals=1)
-    if len(parsed["names"]) != 1:
+    if len(parsed["names"]) > 1:
+        raise CdxError(UNSET_USAGE)
+    if parsed["names"] and parsed["sessions"]:
+        raise CdxError(UNSET_USAGE)
+    if parsed["names"] and parsed["provider"]:
+        raise CdxError(UNSET_USAGE)
+    if not parsed["names"] and not parsed["sessions"] and not parsed["provider"]:
         raise CdxError(UNSET_USAGE)
-    keys = ["power", "permission", "fast"] if parsed["all"] else [
-        key for key in ("power", "permission", "fast") if parsed[key]
+    keys = ["power", "permission", "fast", "model"] if parsed["all"] else [
+        key for key in ("power", "permission", "fast", "model") if parsed[key]
     ]
     if not keys:
         raise CdxError(UNSET_USAGE)
-    return {"name": parsed["names"][0], "keys": keys, "json": parsed["json"]}
+    return {
+        "name": parsed["names"][0] if parsed["names"] else None,
+        "sessions": parsed["sessions"],
+        "provider": parsed["provider"],
+        "keys": keys,
+        "json": parsed["json"],
+    }
 
 
 def _parse_config_args(args):
@@ -674,6 +705,49 @@ def _parse_session_names(value):
     return names
 
 
+def _parse_set_unset_sessions(value):
+    text = str(value or "").strip()
+    if not text:
+        raise CdxError("At least one session name is required in --sessions.")
+    if text.lower() == "all":
+        return "all"
+    return _parse_session_names(text)
+
+
+def _parse_provider_filter(value, usage):
+    provider = str(value or "").strip()
+    if provider not in PROVIDERS:
+        raise CdxError(usage)
+    return provider
+
+
+def _parse_launch_setting_target(value, usage):
+    text = str(value or "").strip()
+    if not text:
+        raise CdxError(usage)
+    if text == "all":
+        return {"name": None, "sessions": "all", "provider": None}
+    if text.startswith("provider:"):
+        return {"name": None, "sessions": None, "provider": _parse_provider_filter(text.split(":", 1)[1], usage)}
+    if "," in text:
+        return {"name": None, "sessions": _parse_session_names(text), "provider": None}
+    return {"name": text, "sessions": None, "provider": None}
+
+
+def _parse_launch_setting_alias_args(kind, args):
+    json_flag, cleaned = _parse_json_flag(args)
+    if len(cleaned) != 2:
+        raise CdxError(SETTING_ALIAS_USAGE)
+    target = _parse_launch_setting_target(cleaned[0], SETTING_ALIAS_USAGE)
+    value = cleaned[1]
+    field = "permission" if kind == "perm" else kind
+    if value == "default":
+        return {**target, "keys": [field], "json": json_flag, "alias": kind}
+    if field == "fast":
+        value = _parse_fast_value(value)
+    return {**target, "settings": {field: value}, "json": json_flag, "alias": kind}
+
+
 def _parse_update_args(args):
     parsed = _parse_flag_args(args, {
         "--check": {"key": "check", "type": "bool", "default": False},
@@ -763,10 +837,82 @@ def _resolve_confirmation(confirm_fn, name):
     return confirmed
 
 
+def _extract_claude_oauth_token(text):
+    if not text:
+        return None
+    patterns = [
+        r"CLAUDE_CODE_OAUTH_TOKEN=([^\s\"']+)",
+        r"(sk-ant-oat[0-9A-Za-z._-]+)",
+    ]
+    for pattern in patterns:
+        match = re.search(pattern, text)
+        if match:
+            return match.group(1).strip()
+    return None
+
+
+def _write_claude_oauth_token(auth_home, token):
+    cred_dir = os.path.join(auth_home, "credentials")
+    os.makedirs(cred_dir, exist_ok=True)
+    cred_path = os.path.join(cred_dir, "default.json")
+    payload = {
+        "version": "1.0",
+        "type": "oauth_token",
+        "access_token": token,
+    }
+    with open(cred_path, "w", encoding="utf-8") as handle:
+        json.dump(payload, handle, indent=2)
+        handle.write("\n")
+    try:
+        os.chmod(cred_path, 0o600)
+    except OSError:
+        pass
+    return cred_path
+
+
+def _bootstrap_claude_setup_token(session, ctx):
+    ctx["out"](
+        "Claude login did not create isolated credentials; falling back to claude setup-token.\n"
+    )
+    run_info = _run_interactive_provider_command(
+        session,
+        "setup-token",
+        spawn=ctx.get("spawn"),
+        env_override=ctx.get("env"),
+        signal_emitter=ctx.get("signal_emitter"),
+    )
+    transcript_path = run_info.get("transcript_path")
+    if not transcript_path or not os.path.isfile(transcript_path):
+        raise CdxError(
+            "Claude setup-token completed, but cdx could not capture the token. "
+            "Run claude setup-token and save the token under credentials/default.json."
+        )
+    try:
+        with open(transcript_path, "r", encoding="utf-8", errors="replace") as handle:
+            transcript = handle.read()
+    finally:
+        try:
+            os.remove(transcript_path)
+        except OSError:
+            pass
+    token = _extract_claude_oauth_token(transcript)
+    if not token:
+        raise CdxError(
+            "Claude setup-token completed, but cdx could not find CLAUDE_CODE_OAUTH_TOKEN in the output."
+        )
+    return _write_claude_oauth_token(session.get("authHome") or "", token)
+
+
 def handle_add(rest, ctx):
     json_flag, args = _parse_json_flag(rest)
     parsed = _parse_add_args(args)
+    if parsed["provider"] == PROVIDER_OLLAMA and not parsed.get("model"):
+        raise CdxError("Usage: cdx add ollama <name> --model MODEL [--json]")
+    if parsed.get("model") and parsed["provider"] != PROVIDER_OLLAMA:
+        raise CdxError("--model is only supported when adding an ollama session.")
     session = ctx["service"]["create_session"](parsed["name"], parsed["provider"])
+    if parsed.get("model"):
+        session = ctx["service"]["set_launch_settings"](parsed["name"], {"model": parsed["model"]})
     message = f"Created session {parsed['name']} ({parsed['provider']})"
     _ensure_session_authentication(
         session,
@@ -882,9 +1028,43 @@ def _format_launch_config(session):
         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'}",
+        f"model:      {launch.get('model') or 'default'}",
     ])
 
 
+def _resolve_bulk_launch_targets(parsed, service):
+    sessions = service["list_sessions"]()
+    by_name = {session["name"]: session for session in sessions}
+    if parsed.get("name"):
+        session = by_name.get(parsed["name"])
+        if not session:
+            raise CdxError(f"Unknown session: {parsed['name']}")
+        targets = [session]
+    elif parsed.get("sessions") == "all":
+        targets = sessions
+    elif parsed.get("sessions"):
+        targets = []
+        for name in parsed["sessions"]:
+            session = by_name.get(name)
+            if not session:
+                raise CdxError(f"Unknown session: {name}")
+            targets.append(session)
+    else:
+        targets = sessions
+    if parsed.get("provider"):
+        targets = [session for session in targets if session["provider"] == parsed["provider"]]
+    if not targets:
+        raise CdxError("No sessions matched.")
+    return targets
+
+
+def _format_bulk_launch_summary(sessions):
+    names = [session["name"] for session in sessions]
+    if len(names) <= 8:
+        return ", ".join(names)
+    return ", ".join(names[:8]) + f", +{len(names) - 8} more"
+
+
 def _format_duration_ms(value):
     if value is None:
         return "-"
@@ -1002,30 +1182,77 @@ def _format_history(entries, use_color=False):
     ])
 
 
-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']}"
+def _apply_launch_settings(parsed, ctx, action="set"):
+    targets = _resolve_bulk_launch_targets(parsed, ctx["service"])
+    sessions = [
+        ctx["service"]["set_launch_settings"](session["name"], parsed["settings"])
+        for session in targets
+    ]
+    if len(sessions) == 1:
+        session = sessions[0]
+        message = f"Updated launch settings for {session['name']}"
+    else:
+        message = f"Updated launch settings for {len(sessions)} sessions: {_format_bulk_launch_summary(sessions)}"
     if parsed["json"]:
-        _write_json(ctx, _json_success("set", message, session=session, launch=session.get("launch") or {}))
+        payload = _json_success(
+            action,
+            message,
+            updated_count=len(sessions),
+            session=sessions[0] if len(sessions) == 1 else None,
+            sessions=sessions,
+            launch=sessions[0].get("launch") or {} if len(sessions) == 1 else None,
+        )
+        _write_json(ctx, payload)
         return 0
     ctx["out"](f"{_success(message, ctx['use_color'])}\n")
-    ctx["out"](f"{_format_launch_config(session)}\n")
+    if len(sessions) == 1:
+        ctx["out"](f"{_format_launch_config(sessions[0])}\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']}"
+def _clear_launch_settings(parsed, ctx, action="unset"):
+    targets = _resolve_bulk_launch_targets(parsed, ctx["service"])
+    sessions = [
+        ctx["service"]["unset_launch_settings"](session["name"], parsed["keys"])
+        for session in targets
+    ]
+    if len(sessions) == 1:
+        session = sessions[0]
+        message = f"Cleared launch settings for {session['name']}"
+    else:
+        message = f"Cleared launch settings for {len(sessions)} sessions: {_format_bulk_launch_summary(sessions)}"
     if parsed["json"]:
-        _write_json(ctx, _json_success("unset", message, session=session, launch=session.get("launch") or {}))
+        payload = _json_success(
+            action,
+            message,
+            updated_count=len(sessions),
+            session=sessions[0] if len(sessions) == 1 else None,
+            sessions=sessions,
+            launch=sessions[0].get("launch") or {} if len(sessions) == 1 else None,
+        )
+        _write_json(ctx, payload)
         return 0
     ctx["out"](f"{_success(message, ctx['use_color'])}\n")
-    ctx["out"](f"{_format_launch_config(session)}\n")
+    if len(sessions) == 1:
+        ctx["out"](f"{_format_launch_config(sessions[0])}\n")
     return 0
 
 
+def handle_set(rest, ctx):
+    return _apply_launch_settings(_parse_set_args(rest), ctx)
+
+
+def handle_unset(rest, ctx):
+    return _clear_launch_settings(_parse_unset_args(rest), ctx)
+
+
+def handle_launch_setting_alias(kind, rest, ctx):
+    parsed = _parse_launch_setting_alias_args(kind, rest)
+    if parsed.get("settings"):
+        return _apply_launch_settings(parsed, ctx, action=kind)
+    return _clear_launch_settings(parsed, ctx, action=kind)
+
+
 def handle_config(rest, ctx):
     parsed = _parse_config_args(rest)
     session = ctx["service"]["get_session"](parsed["name"])
@@ -1505,14 +1732,35 @@ def handle_login(rest, ctx):
     session = ctx["service"]["get_session"](args[0])
     if not session:
         raise CdxError(f"Unknown session: {args[0]}")
-    _run_interactive_provider_command(
-        session, "logout", spawn=ctx.get("spawn"), env_override=ctx.get("env"),
-        signal_emitter=ctx.get("signal_emitter")
-    )
+    if session["provider"] == PROVIDER_CODEX:
+        _run_interactive_provider_command(
+            session, "logout", spawn=ctx.get("spawn"), env_override=ctx.get("env"),
+            signal_emitter=ctx.get("signal_emitter")
+        )
     _run_interactive_provider_command(
         session, "login", spawn=ctx.get("spawn"), env_override=ctx.get("env"),
         signal_emitter=ctx.get("signal_emitter")
     )
+    auth_probe = _ensure_session_authentication(
+        session,
+        ctx["service"],
+        spawn_sync=ctx.get("spawn_sync"),
+        env_override=ctx.get("env"),
+        behavior="probe-only",
+    )
+    if not auth_probe.get("authenticated") and session["provider"] == PROVIDER_CLAUDE:
+        _bootstrap_claude_setup_token(session, ctx)
+        auth_probe = _ensure_session_authentication(
+            session,
+            ctx["service"],
+            spawn_sync=ctx.get("spawn_sync"),
+            env_override=ctx.get("env"),
+            behavior="probe-only",
+        )
+    if not auth_probe.get("authenticated"):
+        raise CdxError(
+            f"Login command completed, but session {session['name']} is still not authenticated."
+        )
     now = _local_now_iso()
     ctx["service"]["update_auth_state"](args[0], lambda auth: {
         **auth, "status": "authenticated",
@@ -1533,6 +1781,10 @@ def handle_logout(rest, ctx):
     session = ctx["service"]["get_session"](args[0])
     if not session:
         raise CdxError(f"Unknown session: {args[0]}")
+    if session["provider"] == PROVIDER_ANTIGRAVITY:
+        raise CdxError("Antigravity logout is managed inside agy. Launch the session and run /logout.")
+    if session["provider"] == PROVIDER_OLLAMA:
+        raise CdxError("Ollama sessions do not use cdx-managed authentication.")
     _run_interactive_provider_command(
         session, "logout", spawn=ctx.get("spawn"), env_override=ctx.get("env"),
         signal_emitter=ctx.get("signal_emitter")

package/src/cli_render.py

@@ -145,7 +145,7 @@ def _format_sessions(service, use_color=False):
         _style("Next actions:", "1", use_color),
         f"  {_style('cdx status', '36', use_color)}",
         f"  {_style('cdx ready', '36', use_color)}",
-        f"  {_style('cdx set <name> --power medium --permission default --fast off', '36', use_color)}",
+        f"  {_style('cdx perm all default', '36', use_color)}",
         f"  {_style('cdx handoff <source> <target>', '36', use_color)}",
         f"  {_style('cdx history', '36', use_color)}",
         f"  {_style('cdx help', '36', use_color)}",

package/src/config.py

@@ -3,7 +3,9 @@ from pathlib import Path
 
 PROVIDER_CODEX = "codex"
 PROVIDER_CLAUDE = "claude"
-PROVIDERS = (PROVIDER_CODEX, PROVIDER_CLAUDE)
+PROVIDER_ANTIGRAVITY = "antigravity"
+PROVIDER_OLLAMA = "ollama"
+PROVIDERS = (PROVIDER_CODEX, PROVIDER_CLAUDE, PROVIDER_ANTIGRAVITY, PROVIDER_OLLAMA)
 
 
 def get_cdx_home(env=None):

package/src/provider_runtime.py

@@ -7,7 +7,7 @@ import subprocess
 import sys
 from datetime import datetime, timezone
 
-from .config import PROVIDER_CLAUDE, PROVIDER_CODEX
+from .config import PROVIDER_ANTIGRAVITY, PROVIDER_CLAUDE, PROVIDER_CODEX, PROVIDER_OLLAMA
 from .errors import CdxError
 
 
@@ -31,10 +31,68 @@ LAUNCH_PERMISSION_ARGS = {
 def _home_env_overrides(auth_home):
     """Return env vars that point the claude CLI to the given home directory.
 
-    On Unix, only HOME is needed.  On Windows, Node.js resolves the home
-    directory via USERPROFILE (and falls back to HOMEDRIVE+HOMEPATH), so we
-    set all three to ensure profile isolation works regardless of the platform.
+    On Unix, only HOME is needed. Claude Code resolves its auth files relative
+    to HOME; forcing CLAUDE_CONFIG_DIR to this directory makes current Claude
+    Code builds ignore otherwise valid isolated credentials. On Windows, Node.js
+    resolves the home directory via USERPROFILE (and falls back to
+    HOMEDRIVE+HOMEPATH), so we set all three to ensure profile isolation works
+    regardless of the platform.
     """
+    overrides = {
+        "HOME": auth_home,
+        "ANTHROPIC_CONFIG_DIR": auth_home,
+        "CLAUDE_CODE_DISABLE_GIT_INSTRUCTIONS": "1",
+    }
+    if sys.platform == "win32":
+        overrides["USERPROFILE"] = auth_home
+        overrides["HOMEDRIVE"] = os.path.splitdrive(auth_home)[0] or "C:"
+        overrides["HOMEPATH"] = os.path.splitdrive(auth_home)[1] or auth_home
+    return overrides
+
+
+def _anthropic_profile_name():
+    return "default"
+
+
+def _anthropic_credentials_path(auth_home):
+    return os.path.join(auth_home, "credentials", f"{_anthropic_profile_name()}.json")
+
+
+def _claude_env(base_env, auth_home):
+    env = {**base_env, **_home_env_overrides(auth_home)}
+    env.pop("CLAUDE_CONFIG_DIR", None)
+    env.pop("CODEX_HOME", None)
+    env.setdefault("ANTHROPIC_PROFILE", _anthropic_profile_name())
+    return env
+
+
+def _read_anthropic_oauth_token(auth_home):
+    try:
+        with open(_anthropic_credentials_path(auth_home), "r", encoding="utf-8") as handle:
+            credentials = json.load(handle)
+    except (FileNotFoundError, OSError, json.JSONDecodeError):
+        return None
+    token = credentials.get("access_token") if isinstance(credentials, dict) else None
+    if not token:
+        return None
+    return str(token)
+
+
+def _read_claude_account_email(auth_home):
+    config_path = os.path.join(auth_home, ".claude.json")
+    try:
+        with open(config_path, "r", encoding="utf-8") as handle:
+            config = json.load(handle)
+    except (FileNotFoundError, OSError, json.JSONDecodeError):
+        return None
+    account = config.get("oauthAccount") if isinstance(config, dict) else None
+    email = account.get("emailAddress") if isinstance(account, dict) else None
+    if not email:
+        return None
+    return str(email).strip()
+
+
+def _antigravity_env_overrides(auth_home):
     overrides = {"HOME": auth_home}
     if sys.platform == "win32":
         overrides["USERPROFILE"] = auth_home
@@ -85,6 +143,18 @@ def _launch_config_args(session):
         if permission:
             args += LAUNCH_PERMISSION_ARGS[PROVIDER_CLAUDE].get(permission, [])
         return args
+    if provider == PROVIDER_ANTIGRAVITY:
+        if permission == "review":
+            args += ["--sandbox"]
+        if permission == "full":
+            args += ["--dangerously-skip-permissions"]
+        return args
+    if provider == PROVIDER_OLLAMA:
+        if power:
+            args += ["--think", power if power in ("low", "medium", "high") else "high"]
+        if permission == "full":
+            args += ["--experimental-yolo"]
+        return args
     if power:
         args += ["-c", f'model_reasoning_effort="{power}"']
     if permission:
@@ -162,15 +232,49 @@ def _build_launch_spec(session, cwd=None, env_override=None, initial_prompt=None
         args = ["--name", session["name"]] + _launch_config_args(session)
         if initial_prompt:
             args.append(initial_prompt)
+        auth_home = _get_auth_home(session)
+        claude_env = _claude_env(env, auth_home)
+        oauth_token = _read_anthropic_oauth_token(auth_home)
+        if oauth_token:
+            claude_env["CLAUDE_CODE_OAUTH_TOKEN"] = oauth_token
         return _wrap_launch_with_transcript(session, {
             "command": "claude",
             "args": args,
             "options": {
                 "cwd": cwd,
-                "env": {**env, **_home_env_overrides(_get_auth_home(session))},
+                "env": claude_env,
             },
             "label": "claude",
         }, env=env)
+    if session["provider"] == PROVIDER_ANTIGRAVITY:
+        args = _launch_config_args(session)
+        if initial_prompt:
+            args += ["--prompt-interactive", initial_prompt]
+        return _wrap_launch_with_transcript(session, {
+            "command": "agy",
+            "args": args,
+            "options": {
+                "cwd": cwd,
+                "env": {**env, **_antigravity_env_overrides(_get_auth_home(session))},
+            },
+            "label": "antigravity",
+        }, env=env)
+    if session["provider"] == PROVIDER_OLLAMA:
+        launch = session.get("launch") or {}
+        model = launch.get("model") or session["name"]
+        ollama_env = {**env, "OLLAMA_NOHISTORY": "1"}
+        args = ["run", model] + _launch_config_args(session)
+        if initial_prompt:
+            args.append(initial_prompt)
+        return _wrap_launch_with_transcript(session, {
+            "command": "ollama",
+            "args": args,
+            "options": {
+                "cwd": cwd,
+                "env": ollama_env,
+            },
+            "label": "ollama",
+        }, env=env)
     args = ["--no-alt-screen", "--cd", cwd] + _launch_config_args(session)
     if initial_prompt:
         args.append(initial_prompt)
@@ -187,7 +291,11 @@ def _build_launch_spec(session, cwd=None, env_override=None, initial_prompt=None
 def _build_login_status_spec(session, env_override=None):
     env = {**os.environ, **(env_override or {})}
     if session["provider"] == PROVIDER_CLAUDE:
-        env.update(_home_env_overrides(_get_auth_home(session)))
+        auth_home = _get_auth_home(session)
+        env = _claude_env(env, auth_home)
+        oauth_token = _read_anthropic_oauth_token(auth_home)
+        if oauth_token:
+            env["CLAUDE_CODE_OAUTH_TOKEN"] = oauth_token
 
         def parser(output):
             try:
@@ -197,6 +305,13 @@ def _build_login_status_spec(session, env_override=None):
 
         return {"command": "claude", "args": ["auth", "status"], "env": env,
                 "parser": parser, "label": "claude auth status"}
+    if session["provider"] == PROVIDER_ANTIGRAVITY:
+        env.update(_antigravity_env_overrides(_get_auth_home(session)))
+        return {"command": "agy", "args": ["--version"], "env": env,
+                "parser": lambda _output: True, "label": "antigravity cli"}
+    if session["provider"] == PROVIDER_OLLAMA:
+        return {"command": "ollama", "args": ["--version"], "env": {**env, "OLLAMA_NOHISTORY": "1"},
+                "parser": lambda _output: True, "label": "ollama cli"}
     env["CODEX_HOME"] = _get_auth_home(session)
 
     def parser(output):
@@ -212,9 +327,31 @@ def _build_auth_action_spec(session, action, cwd=None, env_override=None):
     cwd = cwd or os.getcwd()
     env = {**os.environ, **(env_override or {})}
     if session["provider"] == PROVIDER_CLAUDE:
-        env.update(_home_env_overrides(_get_auth_home(session)))
-        return {"command": "claude", "args": ["auth", action],
-                "options": {"cwd": cwd, "env": env}, "label": f"claude auth {action}"}
+        auth_home = _get_auth_home(session)
+        env = _claude_env(env, auth_home)
+        args = ["auth", action]
+        label = f"claude auth {action}"
+        if action == "setup-token":
+            spec = {"command": "claude", "args": ["setup-token"],
+                    "options": {"cwd": cwd, "env": env}, "label": "claude setup-token"}
+            return _wrap_launch_with_transcript(session, spec, env=env)
+        if action == "login":
+            email = _read_claude_account_email(auth_home)
+            if email:
+                args += ["--email", email]
+        return {"command": "claude", "args": args,
+                "options": {"cwd": cwd, "env": env}, "label": label}
+    if session["provider"] == PROVIDER_ANTIGRAVITY:
+        if action == "logout":
+            raise CdxError("Antigravity logout is managed inside agy. Launch the session and run /logout.")
+        env.update(_antigravity_env_overrides(_get_auth_home(session)))
+        return {"command": "agy", "args": [],
+                "options": {"cwd": cwd, "env": env}, "label": "antigravity"}
+    if session["provider"] == PROVIDER_OLLAMA:
+        if action == "logout":
+            raise CdxError("Ollama sessions do not use cdx-managed authentication.")
+        return {"command": "ollama", "args": ["list"],
+                "options": {"cwd": cwd, "env": {**env, "OLLAMA_NOHISTORY": "1"}}, "label": "ollama"}
     env["CODEX_HOME"] = _get_auth_home(session)
     return {"command": "codex", "args": [action],
             "options": {"cwd": cwd, "env": env}, "label": f"codex {action}"}

package/src/session_service.py

@@ -9,7 +9,7 @@ from datetime import datetime, timezone
 from urllib.parse import quote
 
 from .backup_bundle import decode_bundle, encode_bundle
-from .config import PROVIDER_CLAUDE, PROVIDER_CODEX, PROVIDERS, get_cdx_home
+from .config import PROVIDER_ANTIGRAVITY, PROVIDER_CLAUDE, PROVIDER_CODEX, PROVIDERS, get_cdx_home
 from .codex_usage import fetch_codex_rate_limits
 from .errors import CdxError
 from .session_store import create_session_store
@@ -55,6 +55,7 @@ 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"}
+MAX_LAUNCH_MODEL_LENGTH = 128
 
 
 def _encode(name):
@@ -112,6 +113,13 @@ def _normalize_launch_settings(settings):
                 normalized["fast"] = False
             else:
                 raise CdxError(f"Unsupported fast value: {settings['fast']}")
+    if "model" in settings and settings["model"] is not None:
+        model = str(settings["model"]).strip()
+        if not model:
+            raise CdxError("Model cannot be empty.")
+        if len(model) > MAX_LAUNCH_MODEL_LENGTH or any(ord(ch) < 32 or ord(ch) == 127 for ch in model):
+            raise CdxError("Model contains unsupported characters.")
+        normalized["model"] = model
     return normalized
 
 
@@ -322,6 +330,29 @@ def _read_expected_account_email(auth_home):
     return None
 
 
+def _ensure_claude_attribution_disabled(auth_home):
+    settings_dir = os.path.join(auth_home, ".claude")
+    settings_path = os.path.join(settings_dir, "settings.json")
+    try:
+        os.makedirs(settings_dir, exist_ok=True)
+        with open(settings_path, "r", encoding="utf-8") as handle:
+            settings = json.load(handle)
+    except FileNotFoundError:
+        settings = {}
+    except (OSError, json.JSONDecodeError):
+        settings = {}
+    if not isinstance(settings, dict):
+        settings = {}
+    settings["includeCoAuthoredBy"] = False
+    try:
+        with open(settings_path, "w", encoding="utf-8") as handle:
+            json.dump(settings, handle, indent=2, sort_keys=True)
+            handle.write("\n")
+    except OSError:
+        return False
+    return True
+
+
 def create_session_service(options=None):
     if options is None:
         options = {}
@@ -337,6 +368,8 @@ def create_session_service(options=None):
         root = _get_session_root(name)
         if provider == PROVIDER_CLAUDE:
             return os.path.join(root, "claude-home")
+        if provider == PROVIDER_ANTIGRAVITY:
+            return os.path.join(root, "antigravity-home")
         return root
 
     def _normalize_provider(provider):
@@ -400,6 +433,8 @@ def create_session_service(options=None):
     def _auth_bundle_paths(provider):
         if provider == PROVIDER_CLAUDE:
             return [
+                "claude-home/configs/default.json",
+                "claude-home/credentials/default.json",
                 "claude-home/.claude/.credentials.json",
                 "claude-home/.claude.json",
                 "claude-home/auth.json",
@@ -454,6 +489,8 @@ def create_session_service(options=None):
         _ensure_private_dir(auth_home)
         if normalized_provider == PROVIDER_CODEX:
             _seed_codex_auth_from_global(auth_home, env=env)
+        if normalized_provider == PROVIDER_CLAUDE:
+            _ensure_claude_attribution_disabled(auth_home)
         now = _local_now_iso()
         session = {
             "name": name,
@@ -736,7 +773,7 @@ def create_session_service(options=None):
             raise CdxError(f"Unknown session: {name}")
         if not keys:
             raise CdxError("At least one launch setting is required.")
-        allowed = {"power", "permission", "fast"}
+        allowed = {"power", "permission", "fast", "model"}
         unknown = [key for key in keys if key not in allowed]
         if unknown:
             raise CdxError(f"Unsupported launch setting: {', '.join(unknown)}")