cdx-manager 0.6.0 → 0.6.2

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.0-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.2-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).
@@ -67,6 +69,7 @@ One command to launch any session. Zero auth juggling.
   - Codex live source: `codex app-server` JSON-RPC `account/rateLimits/read`, normalized into 5-hour, weekly, reset, credit, and plan fields.
   - Fallback: `status-source` scans provider JSONL history files and terminal log transcripts, strips ANSI/OSC sequences, and extracts `usage%`, `5h remaining%`, and `week remaining%` via pattern matching.
 - Claude status refreshes are cached briefly by default; pass `--refresh` to force a live rate-limit probe.
+- On Linux, transcript capture uses the `util-linux` `script -c` command form.
 - If `script` is unavailable, Codex launch falls back to running without transcript capture.
 - On Windows, transcript capture is optional. If no compatible `script` wrapper is installed, Codex still launches normally without transcript capture.
 - Auth probe: synchronous subprocess call to `codex login status` or `claude auth status` before any interactive launch.
@@ -81,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.
 
@@ -131,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.0 sh install.sh
+CDX_VERSION=v0.6.2 sh install.sh
 ```
 
 From source:
@@ -226,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
 
@@ -255,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
 ```
 
@@ -262,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.
@@ -293,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) |
@@ -301,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_1.md

@@ -0,0 +1,30 @@
+# Changelog (`0.6.0 -> 0.6.1`)
+
+Release date: 2026-05-28
+
+## Handoff Reliability
+
+- Fixed `cdx handoff <source> <target>` when a source session has no `cdx-session*.log` launch transcript.
+- Added fallback discovery for native provider histories, including Claude project JSONL files under the isolated session home.
+- Converted JSONL message records into readable role-prefixed handoff context instead of requiring raw terminal logs.
+
+## Linux Transcript Capture
+
+- Fixed default transcript capture on Linux and Arch Linux by using the `util-linux` `script -q -F -c "<command>" <transcript>` form.
+- Kept the existing BSD/macOS `script` invocation unchanged.
+- Preserved custom `CDX_SCRIPT_ARGS` behavior for users who explicitly configure their wrapper.
+
+## Release Metadata and Documentation
+
+- Updated package metadata, CLI version output, README badge, and pinned installer example to `v0.6.1`.
+- Documented the Linux-specific transcript capture behavior in the README.
+
+## Validation and Regression Coverage
+
+- Added regression coverage for Claude-to-Claude handoff from native `.claude/projects/*.jsonl` history when no launch log exists.
+- Added runtime coverage for the Linux `script` invocation shape.
+
+## Validation and Regression Evidence
+
+- `npm run lint`
+- `npm test`

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/checksums/release-archives.json

@@ -8,6 +8,10 @@
     "v0.4.0": {
       "github_tarball_sha256": "47a99ff2663f4fee33339098d2cfe7c27fbd0f74a16a1f6711f3003287409ae8",
       "github_zip_sha256": "ae7eff748e569c621ef203abb6b395fbf893370471e962252e8c781e7751e5c8"
+    },
+    "v0.6.1": {
+      "github_tarball_sha256": "5ae4032894e1806ffb3a713e555c12b2faa3bfa6fd7c9fa468664a8577abe827",
+      "github_zip_sha256": "7949e99dcfe21dc4e2b82f720b515aea8f0ac9f2059142032d488bcfbc4dfaf1"
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cdx-manager",
-  "version": "0.6.0",
+  "version": "0.6.2",
   "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.0"
+version = "0.6.2"
 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,6 +11,7 @@ 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):
@@ -21,6 +24,40 @@ def _read_claude_credentials(auth_home):
         return None
 
 
+def _home_env_overrides(auth_home):
+    overrides = {
+        "HOME": auth_home,
+        "CLAUDE_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 +146,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.0"
+VERSION = "0.6.2"
 
 
 # ---------------------------------------------------------------------------
@@ -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

@@ -2,13 +2,14 @@ import asyncio
 import getpass
 import json
 import os
+import re
 import sys
 import time
 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_CODEX, PROVIDER_OLLAMA, PROVIDERS
 from .context_store import (
     clear_context,
     edit_context,
@@ -37,7 +38,7 @@ from .provider_runtime import (
 from .repair import format_repair_report, repair_health
 from .backup_bundle import read_bundle_meta
 from .status_view import _format_status_detail, _format_status_rows
-from .update_check import fetch_latest_release, is_newer_version
+from .update_check import LatestReleaseCheckError, fetch_latest_release, fetch_latest_release_or_raise, is_newer_version
 from .update_manager import build_update_plan, format_update_failure, run_update_plan
 
 
@@ -49,13 +50,15 @@ 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]"
 API_SCHEMA_VERSION = 1
 HANDOFF_TRANSCRIPT_CHARS = 120000
+HANDOFF_NATIVE_TRANSCRIPT_CANDIDATES = 64
 
 
 def _local_now_iso():
@@ -194,9 +197,132 @@ def _latest_launch_transcript_path(session):
     return max(paths, key=lambda path: (os.path.getmtime(path), path))
 
 
-def _read_handoff_transcript(path):
+def _get_session_home(session):
+    return session.get("authHome") or session.get("sessionRoot") or session.get("codexHome", "")
+
+
+def _safe_stat(path):
+    try:
+        return os.stat(path)
+    except OSError:
+        return None
+
+
+def _sort_recent_paths(paths):
+    stats = {path: stat for path, stat in ((_path, _safe_stat(_path)) for _path in set(paths)) if stat}
+    return sorted(stats, key=lambda path: (stats[path].st_mtime, path), reverse=True)
+
+
+def _collect_native_handoff_transcript_paths(session):
+    root = _get_session_home(session)
+    if not root:
+        return []
+    candidates = []
+    direct = [
+        os.path.join(root, "history.jsonl"),
+        os.path.join(root, "session_index.jsonl"),
+    ]
+    candidates.extend(path for path in direct if _safe_stat(path))
+
+    scan_roots = [
+        os.path.join(root, "sessions"),
+        os.path.join(root, ".claude", "projects"),
+        os.path.join(root, "projects"),
+    ]
+    skip_dirs = {"cache", "plugins", "skills", "memories", "sqlite", "shell_snapshots", "tmp", "__pycache__"}
+    for scan_root in scan_roots:
+        if not os.path.isdir(scan_root):
+            continue
+        for dirpath, dirnames, filenames in os.walk(scan_root):
+            dirnames[:] = [name for name in dirnames if not name.startswith(".") and name not in skip_dirs]
+            for filename in filenames:
+                if filename.endswith(".jsonl") or filename.endswith(".log"):
+                    candidates.append(os.path.join(dirpath, filename))
+    return _sort_recent_paths(candidates)[:HANDOFF_NATIVE_TRANSCRIPT_CANDIDATES]
+
+
+def _latest_handoff_transcript_path(session):
+    launch_path = _latest_launch_transcript_path(session)
+    if launch_path:
+        return launch_path
+    native_paths = _collect_native_handoff_transcript_paths(session)
+    return native_paths[0] if native_paths else None
+
+
+def _collect_handoff_text_fragments(value):
+    fragments = []
+    if isinstance(value, str):
+        text = value.strip()
+        if text:
+            fragments.append(text)
+    elif isinstance(value, list):
+        for item in value:
+            fragments.extend(_collect_handoff_text_fragments(item))
+    elif isinstance(value, dict):
+        if isinstance(value.get("text"), str):
+            fragments.extend(_collect_handoff_text_fragments(value.get("text")))
+        if isinstance(value.get("content"), (str, list, dict)):
+            fragments.extend(_collect_handoff_text_fragments(value.get("content")))
+        if isinstance(value.get("message"), dict):
+            fragments.extend(_collect_handoff_text_fragments(value.get("message")))
+        if isinstance(value.get("payload"), dict):
+            fragments.extend(_collect_handoff_text_fragments(value.get("payload")))
+    return fragments
+
+
+def _jsonl_record_to_handoff_text(record):
+    if not isinstance(record, dict):
+        return None
+    message = record.get("message") if isinstance(record.get("message"), dict) else {}
+    role = (
+        message.get("role")
+        or record.get("role")
+        or record.get("type")
+        or record.get("sender")
+        or "entry"
+    )
+    text_sources = []
+    for key in ("content", "text", "payload"):
+        if key in record:
+            text_sources.append(record.get(key))
+    for key in ("content", "text"):
+        if key in message:
+            text_sources.append(message.get(key))
+    fragments = []
+    for value in text_sources:
+        fragments.extend(_collect_handoff_text_fragments(value))
+    text = "\n".join(fragment for fragment in fragments if fragment).strip()
+    if not text:
+        return None
+    role = re.sub(r"[^A-Za-z0-9_-]+", "-", str(role).strip()).strip("-") or "entry"
+    return f"[{role}]\n{text}"
+
+
+def _read_jsonl_handoff_transcript(path):
+    entries = []
     with open(path, "r", encoding="utf-8", errors="replace") as handle:
-        content = handle.read()
+        for line in handle:
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                text = _jsonl_record_to_handoff_text(json.loads(line))
+            except json.JSONDecodeError:
+                text = None
+            if text:
+                entries.append(text)
+    if entries:
+        return "\n\n".join(entries)
+    with open(path, "r", encoding="utf-8", errors="replace") as handle:
+        return handle.read()
+
+
+def _read_handoff_transcript(path):
+    if path.endswith(".jsonl"):
+        content = _read_jsonl_handoff_transcript(path)
+    else:
+        with open(path, "r", encoding="utf-8", errors="replace") as handle:
+            content = handle.read()
     if len(content) <= HANDOFF_TRANSCRIPT_CHARS:
         return content, False
     return content[-HANDOFF_TRANSCRIPT_CHARS:], True
@@ -288,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):
@@ -345,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):
@@ -364,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)
-    keys = ["power", "permission", "fast"] if parsed["all"] else [
-        key for key in ("power", "permission", "fast") if parsed[key]
+    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", "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):
@@ -549,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},
@@ -641,7 +840,13 @@ def _resolve_confirmation(confirm_fn, name):
 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,
@@ -757,9 +962,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 "-"
@@ -877,30 +1116,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"])
@@ -1380,10 +1666,11 @@ 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"] not in (PROVIDER_ANTIGRAVITY, PROVIDER_OLLAMA):
+        _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")
@@ -1408,6 +1695,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")
@@ -1437,7 +1728,14 @@ def handle_update(rest, ctx):
     if parsed["version"] is not None:
         target_version = str(parsed["version"]).strip().lstrip("v")
     else:
-        latest = release_fetcher()
+        try:
+            latest = (
+                release_fetcher()
+                if ctx["options"].get("fetchLatestRelease")
+                else fetch_latest_release_or_raise(env=ctx.get("env"))
+            )
+        except LatestReleaseCheckError as error:
+            raise CdxError(str(error)) from error
         if not latest:
             raise CdxError("Unable to check for the latest cdx-manager release. Check your network and try again.")
         target_version = str(latest.get("latest_version") or "").strip()
@@ -1613,9 +1911,9 @@ def handle_handoff(rest, ctx):
     target = ctx["service"]["get_session"](target_name)
     if not target:
         raise CdxError(f"Unknown session: {target_name}")
-    transcript_path = _latest_launch_transcript_path(source)
+    transcript_path = _latest_handoff_transcript_path(source)
     if not transcript_path:
-        raise CdxError(f"No launch transcript found for session: {source_name}")
+        raise CdxError(f"No transcript found for session: {source_name}")
     transcript, truncated = _read_handoff_transcript(transcript_path)
     context = _build_handoff_context(source, target, transcript_path, transcript, truncated=truncated)
     write_result = write_context(ctx["service"]["base_dir"], context, ctx.get("cwd"))

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
 
 
@@ -35,6 +35,19 @@ def _home_env_overrides(auth_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,
+        "CLAUDE_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 _antigravity_env_overrides(auth_home):
     overrides = {"HOME": auth_home}
     if sys.platform == "win32":
         overrides["USERPROFILE"] = auth_home
@@ -85,6 +98,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:
@@ -131,7 +156,7 @@ def _wrap_launch_with_transcript(session, spec, capture_transcript=True, env=Non
             args = args + [transcript_path]
         args = args + [spec["command"]] + spec["args"]
     else:
-        args = ["-q", "-F", transcript_path, spec["command"]] + spec["args"]
+        args = _default_script_args(transcript_path, spec)
     return {
         "command": script_bin,
         "args": args,
@@ -142,6 +167,13 @@ def _wrap_launch_with_transcript(session, spec, capture_transcript=True, env=Non
     }
 
 
+def _default_script_args(transcript_path, spec):
+    if sys.platform.startswith("linux"):
+        command = shlex.join([spec["command"]] + spec["args"])
+        return ["-q", "-F", "-c", command, transcript_path]
+    return ["-q", "-F", transcript_path, spec["command"]] + spec["args"]
+
+
 def _build_launch_spec(session, cwd=None, env_override=None, initial_prompt=None):
     if initial_prompt is not None:
         if not isinstance(initial_prompt, str):
@@ -164,6 +196,35 @@ def _build_launch_spec(session, cwd=None, env_override=None, initial_prompt=None
             },
             "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)
@@ -190,6 +251,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):
@@ -208,6 +276,17 @@ def _build_auth_action_spec(session, action, cwd=None, env_override=None):
         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}"}
+    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):
@@ -454,6 +487,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 +771,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)}")

package/src/update_check.py

@@ -9,6 +9,10 @@ UPDATE_CHECK_TTL_SECONDS = 12 * 60 * 60
 LATEST_RELEASE_URL = "https://api.github.com/repos/AlexAgo83/cdx-manager/releases/latest"
 
 
+class LatestReleaseCheckError(Exception):
+    pass
+
+
 def _parse_version(value):
     raw = str(value or "").strip().lstrip("v")
     parts = raw.split(".")
@@ -51,13 +55,22 @@ def _write_cache(path, payload):
         handle.write("\n")
 
 
-def _fetch_latest_release():
+def _github_token(env=None):
+    env = env or os.environ
+    return env.get("GH_TOKEN") or env.get("GITHUB_TOKEN")
+
+
+def _fetch_latest_release(env=None):
+    headers = {
+        "Accept": "application/vnd.github+json",
+        "User-Agent": "cdx-manager-update-check",
+    }
+    token = _github_token(env)
+    if token:
+        headers["Authorization"] = f"Bearer {token}"
     request = urllib.request.Request(
         LATEST_RELEASE_URL,
-        headers={
-            "Accept": "application/vnd.github+json",
-            "User-Agent": "cdx-manager-update-check",
-        },
+        headers=headers,
     )
     with urllib.request.urlopen(request, timeout=5) as response:
         payload = json.loads(response.read().decode("utf-8"))
@@ -67,13 +80,39 @@ def _fetch_latest_release():
     }
 
 
-def fetch_latest_release():
+def _format_fetch_error(error):
+    if isinstance(error, urllib.error.HTTPError):
+        if error.code == 403:
+            return (
+                "GitHub API rate limit reached while checking the latest cdx-manager release. "
+                "Try again later, set GH_TOKEN or GITHUB_TOKEN, or run cdx update --version <version>."
+            )
+        if error.code == 404:
+            return "Unable to find the latest cdx-manager release on GitHub."
+        return f"GitHub returned HTTP {error.code} while checking the latest cdx-manager release."
+    if isinstance(error, urllib.error.URLError):
+        reason = getattr(error, "reason", None)
+        suffix = f" ({reason})" if reason else ""
+        return f"Unable to reach GitHub while checking the latest cdx-manager release{suffix}."
+    if isinstance(error, TimeoutError):
+        return "Timed out while checking the latest cdx-manager release."
+    return "Unable to check for the latest cdx-manager release."
+
+
+def fetch_latest_release(env=None):
     try:
-        return _fetch_latest_release()
+        return _fetch_latest_release(env=env)
     except (urllib.error.URLError, TimeoutError, ValueError, OSError):
         return None
 
 
+def fetch_latest_release_or_raise(env=None):
+    try:
+        return _fetch_latest_release(env=env)
+    except (urllib.error.URLError, TimeoutError, ValueError, OSError) as error:
+        raise LatestReleaseCheckError(_format_fetch_error(error)) from error
+
+
 def check_for_update(base_dir, current_version, env=None, now_fn=None):
     env = env or os.environ
     now_fn = now_fn or (lambda: datetime.now(timezone.utc).timestamp())
@@ -94,7 +133,7 @@ def check_for_update(base_dir, current_version, env=None, now_fn=None):
             }
         return None
 
-    latest = fetch_latest_release()
+    latest = fetch_latest_release(env=env)
     if not latest:
         return None