cdx-manager 0.7.5 → 0.7.8

package/README.md

@@ -1,6 +1,6 @@
 # CDX Manager
 
-[![License](https://img.shields.io/badge/license-MIT-4C8BF5)](LICENSE) ![Version](https://img.shields.io/badge/version-v0.7.5-4C8BF5) ![Python](https://img.shields.io/badge/python-3.9%2B-3776AB?logo=python&logoColor=white)
+[![License](https://img.shields.io/badge/license-MIT-4C8BF5)](LICENSE) ![Version](https://img.shields.io/badge/version-v0.7.8-4C8BF5) ![Python](https://img.shields.io/badge/python-3.9%2B-3776AB?logo=python&logoColor=white)
 
 **Run multiple Codex, Claude, Antigravity, and Ollama sessions from one terminal. Switch between accounts instantly.**
 
@@ -41,7 +41,7 @@ One command to launch any session. Zero auth juggling.
 - **Session control.** Disable a session without deleting it when an account is temporarily out of credits; disabled sessions remain visible and sort last.
 - **Persistent launch settings.** Pin per-session power, permission, and fast-mode preferences once; `cdx` reapplies them on every launch until you unset them.
 - **Launch history.** Inspect recent launches with provider, result, duration, working directory, launch settings, and transcript path.
-- **Update prompts.** Periodic update checks surface `cdx update` directly in the `cdx`, `cdx status`, and launch output when a newer release is available.
+- **Update prompts.** Periodic update checks surface `cdx update` directly in the `cdx`, `cdx status`, and launch output when a newer release is available. When `logics-manager` is installed, `cdx` can also suggest `logics-manager self-update`.
 - **Shared handoff context.** Keep a per-workspace Markdown context, or build one from a source session transcript, and install it into another assistant session before switching providers or accounts.
 - **Passive status resolution.** Codex status is read from the local Codex app-server rate-limit API when available, with legacy transcript/history parsing kept as a fallback.
 - **Session transcript capture.** Every launch is recorded to a local log file via `script`, giving you a full terminal transcript for each session.
@@ -136,7 +136,7 @@ For a specific version:
 
 ```bash
 curl -fsSL https://raw.githubusercontent.com/AlexAgo83/cdx-manager/main/install.sh -o install.sh
-CDX_VERSION=v0.7.5 sh install.sh
+CDX_VERSION=v0.7.8 sh install.sh
 ```
 
 From source:
@@ -271,6 +271,7 @@ cdx set --sessions all --permission auto
 cdx set --provider ollama --model llama3.2
 cdx set work --priority 80
 cdx set work --rtk on
+cdx set work --logics off
 cdx power all low
 cdx perm provider:claude review
 cdx model provider:ollama llama3.2
@@ -286,12 +287,13 @@ cdx unset --sessions work,personal --fast
 cdx unset --provider claude --permission
 cdx unset work --priority
 cdx unset work --rtk
+cdx unset work --logics
 cdx unset work --all
 cdx power all default
 cdx model provider:ollama default
 ```
 
-`--model` maps to Codex `--model`, Claude `--model`, and Ollama `ollama run <model>`. `--power` maps to Codex `model_reasoning_effort` and Claude `--effort`. `--permission` maps to provider-native permission flags. `--fast on` clears the stored power setting and uses low effort; setting `--power` again disables fast mode. `--priority` is a 0..100 selector preference used as a tie-breaker after readiness and availability. `--rtk on` injects a launch instruction that encourages assistants to use RTK (`rtk <command>`) for noisy terminal commands when RTK is available, while keeping raw commands for exact output.
+`--model` maps to Codex `--model`, Claude `--model`, and Ollama `ollama run <model>`. `--power` maps to Codex `model_reasoning_effort` and Claude `--effort`. `--permission` maps to provider-native permission flags. `--fast on` clears the stored power setting and uses low effort; setting `--power` again disables fast mode. `--priority` is a 0..100 selector preference used as a tie-breaker after readiness and availability. `--rtk on` injects a launch instruction that encourages assistants to use RTK (`rtk <command>`) for noisy terminal commands when RTK is available, while keeping raw commands for exact output. Logics guidance is auto-enabled when `logics-manager` is available; use `--logics off` to disable that guidance for a session, or `--logics on` to pin it explicitly.
 
 ### Launch History
 
@@ -329,8 +331,8 @@ cdx history --summary --from 2026-05-01 --to 2026-05-28
 | `cdx config <name> [--json]` | Show persistent launch settings for a session |
 | `cdx configs [--json]` | Show persistent launch settings for all sessions in one table |
 | `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] [--rtk on\|off] [--model MODEL] [--priority 0..100] [--json]` | Persist launch settings for one or more sessions |
-| `cdx unset <name>\|--sessions all\|a,b\|--provider PROVIDER (--power\|--permission\|--fast\|--rtk\|--model\|--priority\|--all) [--json]` | Remove persisted launch settings and fall back to provider defaults |
+| `cdx set <name>\|--sessions all\|a,b\|--provider PROVIDER [--power low\|medium\|high\|xhigh\|max] [--permission review\|default\|auto\|full] [--fast on\|off] [--rtk on\|off] [--logics on\|off] [--model MODEL] [--priority 0..100] [--json]` | Persist launch settings for one or more sessions |
+| `cdx unset <name>\|--sessions all\|a,b\|--provider PROVIDER (--power\|--permission\|--fast\|--rtk\|--logics\|--model\|--priority\|--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 |

package/changelogs/CHANGELOGS_0_7_6.md

@@ -0,0 +1,37 @@
+# Changelog (`0.7.5 -> 0.7.6`)
+
+Release date: 2026-06-05
+
+## Claude Launches
+
+- Normalized Claude model names before invoking Claude Code so persisted API-style IDs such as `claude-sonnet-4-5-20250929` launch as the Claude Code CLI form `claude-sonnet-4-5`.
+- Added compatibility for marketing-style Claude model values such as `sonnet-4.5` while preserving unknown custom model values unchanged.
+- Applied the same Claude model normalization to both interactive launches and headless `cdx run` launches.
+
+## Release Integrity
+
+- Added official standalone release archive checksums for `v0.7.5` so verified installer upgrades can resolve the previous release.
+- Added regression coverage for the `v0.7.5` release checksum metadata.
+
+## CI Hardening
+
+- Restricted GitHub Actions workflow token permissions for the CI workflow.
+
+## Coverage and Tests
+
+- Added regression coverage for Claude CLI model normalization in runtime launch specs and interactive CLI launch behavior.
+- Increased the Python test suite to 285 tests.
+
+## Release Metadata
+
+- Updated package metadata, CLI version output, README badge, pinned installer example, and release changelog to `v0.7.6`.
+
+## Validation and Regression Evidence
+
+- `npm run lint`
+- `npm test`
+- `node bin/cdx.js --version`
+- `npm audit --omit=dev --json`
+- `sh -n install.sh`
+- PowerShell parser check for `install.ps1`
+- `python3 -m logics_manager lint --require-status`

package/changelogs/CHANGELOGS_0_7_8.md

@@ -0,0 +1,30 @@
+# Changelog (`0.7.6 -> 0.7.8`)
+
+Release date: 2026-06-08
+
+## Launch Guidance
+
+- Added update guidance for `logics-manager` so `cdx` can surface a newer companion CLI version alongside the existing `cdx-manager` update notice.
+- Added RTK launch preference handling so noisy assistant shell commands can be wrapped with `rtk` when the session setting asks for filtered command output.
+- Extended provider launch metadata and health checks so companion tool hints appear without making `logics-manager` or RTK hard runtime dependencies.
+
+## Coverage and Tests
+
+- Added regression coverage for multi-tool update warnings, launch notice rendering, provider runtime launch metadata, and RTK preference handling.
+
+## Release Metadata
+
+- Updated package metadata, CLI version output, README badge, pinned installer example, and release changelog to `v0.7.8`.
+
+## Validation and Regression Evidence
+
+- `npm run lint`
+- `npm test`
+- `python -m unittest discover -s test -p 'test_*_py.py'`
+- `python3 -m logics_manager lint --require-status`
+- `git diff --check`
+- `node bin/cdx.js --version`
+- `python3 bin/cdx --version`
+- `npm --cache /private/tmp/cdx-npm-cache pack --dry-run`
+- `python -m build`
+- `python -m twine check dist/*`

package/checksums/release-archives.json

@@ -48,6 +48,14 @@
     "v0.7.4": {
       "github_tarball_sha256": "02b399899e611300ddf367bfb8c22ad57b499e94265e50256c8afe3f4bd73851",
       "github_zip_sha256": "87043d49cdd50dcd7d51349984ea4abfb1a2ff50f2eab69c75a421bedd2f2fe8"
+    },
+    "v0.7.5": {
+      "github_tarball_sha256": "18f5f6230bb5704913a90cfe2bfc5f55599c6ca0813bfd9f4bc97fc9f19e074a",
+      "github_zip_sha256": "cafd400c65c255aa9569853ec9d1cc80cf691ff849660496779334ee7abf71b4"
+    },
+    "v0.7.6": {
+      "github_tarball_sha256": "cf6390c2071c710edd7c55d89fd75914e1d94ae5a62330d6fe15029484f88c13",
+      "github_zip_sha256": "f58be3078daaa9523053dab7b59d681dfb359d5f2a94276aa46000dd7f1360ed"
     }
   }
 }

package/install.ps1

@@ -11,6 +11,12 @@ $repo = "AlexAgo83/cdx-manager"
 if (-not $ChecksumsUrl) {
     $ChecksumsUrl = "https://raw.githubusercontent.com/$repo/main/checksums/release-archives.json"
 }
+$defaultChecksumsUrl = "https://raw.githubusercontent.com/$repo/main/checksums/release-archives.json"
+$checksumsApiUrl = if ($env:CDX_CHECKSUMS_API_URL) {
+    $env:CDX_CHECKSUMS_API_URL
+} else {
+    "https://api.github.com/repos/$repo/contents/checksums/release-archives.json?ref=main"
+}
 
 function Has-Command {
     param([string]$Name)
@@ -56,6 +62,15 @@ try {
         } catch {
         }
     }
+    if ((-not $Sha256) -and ($ChecksumsUrl -eq $defaultChecksumsUrl)) {
+        try {
+            $checksumsResponse = Invoke-RestMethod -Uri $checksumsApiUrl
+            $checksumsJson = [System.Text.Encoding]::UTF8.GetString([System.Convert]::FromBase64String($checksumsResponse.content))
+            $checksums = $checksumsJson | ConvertFrom-Json
+            $Sha256 = $checksums.releases.$tag.github_zip_sha256
+        } catch {
+        }
+    }
     if ($Sha256) {
         $actualSha256 = (Get-FileHash -Algorithm SHA256 -Path $archivePath).Hash.ToLowerInvariant()
         if ($actualSha256 -ne $Sha256.ToLowerInvariant()) {

package/install.sh

@@ -6,7 +6,9 @@ VERSION="${CDX_VERSION:-}"
 PREFIX="${PREFIX:-$HOME/.local}"
 BIN_DIR="${BIN_DIR:-$PREFIX/bin}"
 INSTALL_ROOT="${CDX_INSTALL_ROOT:-$PREFIX/share/cdx-manager}"
-CHECKSUMS_URL="${CDX_CHECKSUMS_URL:-https://raw.githubusercontent.com/$REPO/main/checksums/release-archives.json}"
+DEFAULT_CHECKSUMS_URL="https://raw.githubusercontent.com/$REPO/main/checksums/release-archives.json"
+CHECKSUMS_URL="${CDX_CHECKSUMS_URL:-$DEFAULT_CHECKSUMS_URL}"
+CHECKSUMS_API_URL="${CDX_CHECKSUMS_API_URL:-https://api.github.com/repos/$REPO/contents/checksums/release-archives.json?ref=main}"
 
 need() {
   if ! command -v "$1" >/dev/null 2>&1; then
@@ -51,6 +53,27 @@ if value:
 ' "$1"
 }
 
+resolve_expected_sha256_from_api() {
+  curl -fsSL "$CHECKSUMS_API_URL" |
+    python3 -c '
+import base64
+import json
+import sys
+
+tag = sys.argv[1]
+try:
+    response = json.load(sys.stdin)
+    payload = json.loads(base64.b64decode(response.get("content") or b"").decode("utf-8"))
+except Exception:
+    raise SystemExit(1)
+
+release = (payload.get("releases") or {}).get(tag) or {}
+value = release.get("github_tarball_sha256")
+if value:
+    print(value)
+' "$1"
+}
+
 if [ -z "$VERSION" ]; then
   VERSION="$(
     curl -fsSL "https://api.github.com/repos/$REPO/releases/latest" |
@@ -76,6 +99,9 @@ EXPECTED_SHA256="${CDX_SHA256:-}"
 if [ -z "$EXPECTED_SHA256" ]; then
   EXPECTED_SHA256="$(resolve_expected_sha256 "$TAG" 2>/dev/null || true)"
 fi
+if [ -z "$EXPECTED_SHA256" ] && [ "$CHECKSUMS_URL" = "$DEFAULT_CHECKSUMS_URL" ]; then
+  EXPECTED_SHA256="$(resolve_expected_sha256_from_api "$TAG" 2>/dev/null || true)"
+fi
 
 if [ -n "$EXPECTED_SHA256" ]; then
   ACTUAL_SHA256="$(sha256_file "$TMP_DIR/cdx-manager.tar.gz")"

package/package.json

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

package/src/cli.py

@@ -58,9 +58,9 @@ from .status_view import (
     _format_status_detail,
     _format_status_rows,
 )
-from .update_check import check_for_update
+from .update_check import check_for_update, check_logics_manager_for_update
 
-VERSION = "0.7.5"
+VERSION = "0.7.8"
 
 
 # ---------------------------------------------------------------------------
@@ -84,8 +84,8 @@ def _print_help(use_color=False):
         f"  {_style('cdx config <name> [--json]', '36', use_color)}",
         f"  {_style('cdx configs [--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] [--rtk on|off] [--model MODEL] [--priority 0..100] [--json]', '36', use_color)}",
-        f"  {_style('cdx unset <name>|--sessions all|a,b|--provider PROVIDER (--power|--permission|--fast|--rtk|--model|--priority|--all) [--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] [--rtk on|off] [--logics on|off] [--model MODEL] [--priority 0..100] [--json]', '36', use_color)}",
+        f"  {_style('cdx unset <name>|--sessions all|a,b|--provider PROVIDER (--power|--permission|--fast|--rtk|--logics|--model|--priority|--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 stats [name] [--since 7d|today|DATE] [--from DATE] [--to DATE] [--json]', '36', use_color)}",
         f"  {_style('cdx last [--json]', '36', use_color)}",
@@ -158,22 +158,52 @@ def _get_update_notice(service, env, options):
     )
 
 
-def _update_warning_payload(notice):
-    if not notice:
-        return []
-    message = f"Update available: cdx-manager {notice['latest_version']} (current {VERSION})"
-    return [{
-        "code": "update_available",
-        "message": message,
-        "latest_version": notice["latest_version"],
-        "url": notice.get("url"),
-    }]
+def _get_update_notices(service, env, options):
+    notices = []
+    cdx_notice = _get_update_notice(service, env, options)
+    if cdx_notice:
+        notices.append({"tool": "cdx-manager", **cdx_notice})
+    checker = options.get("checkLogicsManagerForUpdate") or check_logics_manager_for_update
+    logics_notice = checker(
+        service["base_dir"],
+        env=env,
+        now_fn=options.get("now"),
+    )
+    if logics_notice:
+        notices.append(logics_notice)
+    return notices
 
 
-def _update_warning_text(notice):
-    if not notice:
+def _update_warning_payload(notices):
+    if isinstance(notices, dict):
+        notices = [notices]
+    if not notices:
+        return []
+    warnings = []
+    for notice in notices:
+        tool = notice.get("tool") or "cdx-manager"
+        current = notice.get("current_version") or VERSION
+        command = notice.get("update_command") or ("cdx update" if tool == "cdx-manager" else None)
+        message = f"Update available: {tool} {notice['latest_version']} (current {current})"
+        if command:
+            message = f"{message}. Run: {command}"
+        warnings.append({
+            "code": "update_available" if tool == "cdx-manager" else f"{tool.replace('-', '_')}_update_available",
+            "message": message,
+            "tool": tool,
+            "latest_version": notice["latest_version"],
+            "current_version": current,
+            "update_command": command,
+            "url": notice.get("url"),
+        })
+    return warnings
+
+
+def _update_warning_text(notices):
+    payloads = _update_warning_payload(notices)
+    if not payloads:
         return None
-    return f"Update available: cdx-manager {notice['latest_version']} (current {VERSION}). Run: cdx update"
+    return "\n".join(payload["message"] for payload in payloads)
 
 
 # ---------------------------------------------------------------------------
@@ -216,15 +246,16 @@ def main(argv, options=None):
 
     if argv == ["--json"]:
         rows = service["format_list_rows"]()
-        notice = _get_update_notice(service, env, options)
-        out(f"{json.dumps(_list_json_payload(rows, notice=notice), indent=2)}\n")
+        notices = _get_update_notices(service, env, options)
+        out(f"{json.dumps(_list_json_payload(rows, notices=notices), indent=2)}\n")
         return 0
 
     if not argv:
-        notice = _get_update_notice(service, env, options)
+        notices = _get_update_notices(service, env, options)
         out(f"{_format_sessions(service, use_color=use_color)}\n")
-        if notice:
-            out(f"{_style(_update_warning_text(notice), '33', use_color)}\n")
+        warning_text = _update_warning_text(notices)
+        if warning_text:
+            out(f"{_style(warning_text, '33', use_color)}\n")
         return 0
 
     command, *rest = argv
@@ -243,7 +274,7 @@ def main(argv, options=None):
         "stdin_is_tty": stdin_is_tty,
         "version": VERSION,
         "cwd": options.get("cwd") or os.getcwd(),
-        "update_notice": _get_update_notice(service, env, options) if command not in (
+        "update_notices": _get_update_notices(service, env, options) if command not in (
             "add", "cp", "ren", "rename", "mv", "rmv", "clean", "doctor", "repair", "update", "ready", "notify", "next", "context", "config", "configs", "set", "unset", "power", "perm", "fast", "model", "history", "stats", "handoff", "login", "logout", "disable", "enable", "export", "import", "select", "run", "help", "version"
         ) else None,
         "use_color": use_color,
@@ -355,13 +386,13 @@ def main(argv, options=None):
     raise CdxError(f"Unknown command: {command}. Use cdx --help.")
 
 
-def _list_json_payload(rows, notice=None):
+def _list_json_payload(rows, notices=None):
     return {
         "schema_version": API_SCHEMA_VERSION,
         "ok": True,
         "action": "list",
         "message": "Listed known sessions",
-        "warnings": _update_warning_payload(notice),
+        "warnings": _update_warning_payload(notices),
         "sessions": rows,
     }
 

package/src/cli_commands.py

@@ -55,8 +55,8 @@ 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>|--sessions all|a,b|--provider PROVIDER [--power low|medium|high|xhigh|max] [--permission review|default|auto|full] [--fast on|off] [--rtk on|off] [--model MODEL] [--priority 0..100] [--json]"
-UNSET_USAGE = "Usage: cdx unset <name>|--sessions all|a,b|--provider PROVIDER (--power|--permission|--fast|--rtk|--model|--priority|--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] [--rtk on|off] [--logics on|off] [--model MODEL] [--priority 0..100] [--json]"
+UNSET_USAGE = "Usage: cdx unset <name>|--sessions all|a,b|--provider PROVIDER (--power|--permission|--fast|--rtk|--logics|--model|--priority|--all) [--json]"
 SETTING_ALIAS_USAGE = "Usage: cdx power|perm|fast|model <name|all|provider:PROVIDER|a,b> <value|default> [--json]"
 CONFIG_USAGE = "Usage: cdx config <name> [--json]"
 CONFIGS_USAGE = "Usage: cdx configs [--json]"
@@ -109,23 +109,42 @@ def _write_json(ctx, payload):
 
 
 def _update_notice_warning(ctx):
-    notice = ctx.get("update_notice")
-    if not notice:
+    notices = ctx.get("update_notices") or []
+    if not notices:
         return None
-    return {
-        "code": "update_available",
-        "message": f"Update available: cdx-manager {notice['latest_version']}",
-        "latest_version": notice["latest_version"],
-        "url": notice.get("url"),
-    }
+    warnings = _update_notice_warnings(ctx)
+    return warnings[0] if warnings else None
+
+
+def _update_notice_warnings(ctx):
+    warnings = []
+    for notice in ctx.get("update_notices") or []:
+        tool = notice.get("tool") or "cdx-manager"
+        current = notice.get("current_version") or ctx.get("version")
+        command = notice.get("update_command") or ("cdx update" if tool == "cdx-manager" else None)
+        message = f"Update available: {tool} {notice['latest_version']}"
+        if current:
+            message = f"{message} (current {current})"
+        if command:
+            message = f"{message}. Run: {command}"
+        warnings.append({
+            "code": "update_available" if tool == "cdx-manager" else f"{tool.replace('-', '_')}_update_available",
+            "message": message,
+            "tool": tool,
+            "latest_version": notice["latest_version"],
+            "current_version": current,
+            "update_command": command,
+            "url": notice.get("url"),
+        })
+    return warnings
 
 
 def _write_update_notice(ctx):
-    notice = ctx.get("update_notice")
-    if not notice:
+    warnings = _update_notice_warnings(ctx)
+    if not warnings:
         return
-    text = f"Update available: cdx-manager {notice['latest_version']} (current version installed may be older). Run: cdx update"
-    ctx["out"](f"{_warn(text, ctx['use_color'])}\n")
+    for warning in warnings:
+        ctx["out"](f"{_warn(warning['message'], ctx['use_color'])}\n")
 
 
 def _format_bytes(value):
@@ -527,6 +546,7 @@ def _parse_set_args(args):
         "--permission": {"key": "permission", "type": "str", "default": None},
         "--fast": {"key": "fast", "type": "str", "default": None, "transform": _parse_fast_value},
         "--rtk": {"key": "rtk", "type": "str", "default": None, "transform": _parse_fast_value},
+        "--logics": {"key": "logics", "type": "str", "default": None, "transform": _parse_fast_value},
         "--model": {"key": "model", "type": "str", "default": None},
         "--priority": {"key": "priority", "type": "str", "default": None, "transform": _parse_priority_value},
         "--sessions": {"key": "sessions", "type": "str", "default": None, "transform": _parse_set_unset_sessions},
@@ -543,7 +563,7 @@ def _parse_set_args(args):
         raise CdxError(SET_USAGE)
     settings = {
         key: parsed[key]
-        for key in ("power", "permission", "fast", "rtk", "model", "priority")
+        for key in ("power", "permission", "fast", "rtk", "logics", "model", "priority")
         if parsed[key] is not None
     }
     if not settings:
@@ -563,6 +583,7 @@ def _parse_unset_args(args):
         "--permission": {"key": "permission", "type": "bool", "default": False},
         "--fast": {"key": "fast", "type": "bool", "default": False},
         "--rtk": {"key": "rtk", "type": "bool", "default": False},
+        "--logics": {"key": "logics", "type": "bool", "default": False},
         "--model": {"key": "model", "type": "bool", "default": False},
         "--priority": {"key": "priority", "type": "bool", "default": False},
         "--all": {"key": "all", "type": "bool", "default": False},
@@ -578,8 +599,8 @@ def _parse_unset_args(args):
         raise CdxError(UNSET_USAGE)
     if not parsed["names"] and not parsed["sessions"] and not parsed["provider"]:
         raise CdxError(UNSET_USAGE)
-    keys = ["power", "permission", "fast", "rtk", "model", "priority"] if parsed["all"] else [
-        key for key in ("power", "permission", "fast", "rtk", "model", "priority") if parsed[key]
+    keys = ["power", "permission", "fast", "rtk", "logics", "model", "priority"] if parsed["all"] else [
+        key for key in ("power", "permission", "fast", "rtk", "logics", "model", "priority") if parsed[key]
     ]
     if not keys:
         raise CdxError(UNSET_USAGE)
@@ -1440,6 +1461,7 @@ def _format_launch_config(session, use_color=False):
         ("permission", "Permission"),
         ("fast", "Fast"),
         ("rtk", "RTK"),
+        ("logics", "Logics"),
         ("model", "Model"),
         ("priority", "Priority"),
     ]:
@@ -1460,16 +1482,18 @@ def _format_launch_config(session, use_color=False):
 def _format_launch_settings_hint(name="<name>"):
     return (
         f"Set a value: cdx set {name} --power medium --permission auto "
-        "--fast on --rtk on --model MODEL --priority 80"
+        "--fast on --rtk on --logics on --model MODEL --priority 80"
     )
 
 
 def _format_launch_setting_value(launch, key, use_color=False):
-    if key == "fast" or key == "rtk":
+    if key in ("fast", "rtk", "logics"):
         if launch.get(key) is True:
             return _style("on", "32", use_color)
         if launch.get(key) is False:
             return _style("off", "2", use_color)
+        if key == "logics":
+            return _dim("auto", use_color)
         return _dim("default", use_color)
     value = launch.get(key)
     if value is None or value == "":
@@ -1494,7 +1518,7 @@ def _format_launch_configs(sessions, use_color=False):
             _dim(_format_launch_settings_hint(), use_color),
         ])
     rows = [[_style(value, "1", use_color) for value in [
-        "SESSION", "PROVIDER", "POWER", "PERMISSION", "FAST", "RTK", "MODEL", "PRIORITY"
+        "SESSION", "PROVIDER", "POWER", "PERMISSION", "FAST", "RTK", "LOGICS", "MODEL", "PRIORITY"
     ]]]
     for session in sessions:
         launch = session.get("launch") or {}
@@ -1505,6 +1529,7 @@ def _format_launch_configs(sessions, use_color=False):
             _format_launch_setting_value(launch, "permission", use_color),
             _format_launch_setting_value(launch, "fast", use_color),
             _format_launch_setting_value(launch, "rtk", use_color),
+            _format_launch_setting_value(launch, "logics", use_color),
             _format_launch_setting_value(launch, "model", use_color),
             _format_launch_setting_value(launch, "priority", use_color),
         ])
@@ -2384,9 +2409,7 @@ def handle_status(rest, ctx):
         }
         for item in refresh_errors
     ])
-    update_warning = _update_notice_warning(ctx)
-    if update_warning:
-        warnings.append(update_warning)
+    warnings.extend(_update_notice_warnings(ctx))
 
     status_progress = None if parsed["json"] else _make_status_progress(ctx)
     rows = ctx["service"]["get_status_rows"](
@@ -2709,10 +2732,7 @@ def handle_update(rest, ctx):
 
 def handle_launch(command, ctx, initial_prompt=None):
     json_flag = "--json" in ctx.get("raw_args", ctx["options"].get("raw_args", []))
-    update_notice = ctx.get("update_notice")
-    warnings = []
-    if update_notice:
-        warnings.append(_update_notice_warning(ctx))
+    warnings = _update_notice_warnings(ctx)
     session = ctx["service"]["launch_session"](command)
     _ensure_session_authentication(
         session,

package/src/cli_render.py

@@ -110,6 +110,10 @@ def _format_launch_text(launch):
         parts.append(launch["permission"])
     if launch.get("fast") is True:
         parts.append("fast-on")
+    if launch.get("logics") is True:
+        parts.append("logics-on")
+    elif launch.get("logics") is False:
+        parts.append("logics-off")
     return "/".join(parts) or "default"
 
 

package/src/health.py

@@ -47,6 +47,18 @@ def collect_health_report(service, base_dir, env=None):
         rtk_path,
     ))
 
+    logics_path = shutil.which("logics-manager", path=env.get("PATH"))
+    issues.append(_issue(
+        "OK" if logics_path else "WARN",
+        "logics_manager_cli",
+        (
+            "logics-manager CLI found"
+            if logics_path
+            else "logics-manager CLI not found; Logics workflow guidance will not be auto-enabled"
+        ),
+        logics_path,
+    ))
+
     script_bin = env.get("CDX_SCRIPT_BIN", "script")
     script_path = shutil.which(script_bin, path=env.get("PATH"))
     issues.append(_issue(

package/src/provider_runtime.py

@@ -19,6 +19,14 @@ RTK_PROMPT = (
     "When running noisy shell commands, prefer RTK wrappers (`rtk <command>`) if `rtk` is available. "
     "Use raw commands when exact, unfiltered output is required."
 )
+LOGICS_PROMPT = (
+    "When `logics-manager` is available, prefer it for Logics workflow operations: use "
+    "`logics-manager status`, `health`, `audit`, and `lint` for workflow state and validation; "
+    "`logics-manager view` for the browser viewer and focus workflows; "
+    "`logics-manager sync read-doc|list-docs|search-docs|context-pack` for bounded document context; "
+    "`logics-manager flow ...` for request/backlog/task lifecycle changes; and `logics-manager mcp ...` "
+    "when an MCP surface is the right fit."
+)
 LAUNCH_PERMISSION_ARGS = {
     PROVIDER_CLAUDE: {
         "review": ["--permission-mode", "plan"],
@@ -40,6 +48,14 @@ HEADLESS_CODEX_PERMISSION_ARGS = {
     "full": ["--dangerously-bypass-approvals-and-sandbox"],
 }
 REDACTED_PROMPT_ARG = "[prompt redacted]"
+CLAUDE_CLI_MODEL_ALIASES = {
+    "claude-sonnet": "sonnet",
+    "claude-opus": "opus",
+    "claude-haiku": "haiku",
+    "sonnet-latest": "sonnet",
+    "opus-latest": "opus",
+    "haiku-latest": "haiku",
+}
 
 
 def _home_env_overrides(auth_home):
@@ -207,6 +223,26 @@ def _normalize_reasoning_effort(reasoning_effort=None, power=None, usage="Unsupp
     }
 
 
+def _claude_cli_model(model):
+    if not model:
+        return model
+    raw = str(model).strip()
+    normalized = raw.lower().replace("_", "-")
+    if normalized in CLAUDE_CLI_MODEL_ALIASES:
+        return CLAUDE_CLI_MODEL_ALIASES[normalized]
+
+    marketing = re.fullmatch(r"(?:claude-)?(sonnet|opus|haiku)-(\d+)(?:[.-](\d+))?", normalized)
+    if marketing:
+        family, major, minor = marketing.groups()
+        return f"claude-{family}-{major}-{minor}" if minor else family
+
+    dated = re.fullmatch(r"(claude-(?:sonnet|opus|haiku)-4(?:-\d+)*)-\d{8}", normalized)
+    if dated:
+        return dated.group(1)
+
+    return raw
+
+
 def _launch_config_args(session):
     launch = session.get("launch") or {}
     args = []
@@ -299,25 +335,45 @@ def _rtk_enabled(session):
     return (session.get("launch") or {}).get("rtk") is True
 
 
-def _with_launch_preferences(session, initial_prompt=None):
-    if not _rtk_enabled(session):
+def _logics_manager_available(path=None):
+    return shutil.which("logics-manager", path=path) is not None
+
+
+def _logics_enabled(session, env=None):
+    launch = session.get("launch") or {}
+    if launch.get("logics") is False:
+        return False
+    if launch.get("logics") is True:
+        return True
+    env = env or os.environ
+    return _logics_manager_available(path=env.get("PATH"))
+
+
+def _with_launch_preferences(session, initial_prompt=None, env=None):
+    prompts = []
+    if _rtk_enabled(session):
+        prompts.append(RTK_PROMPT)
+    if _logics_enabled(session, env=env):
+        prompts.append(LOGICS_PROMPT)
+    if not prompts:
         return initial_prompt
     if initial_prompt:
-        return f"{RTK_PROMPT}\n\n{initial_prompt}"
-    return RTK_PROMPT
+        prompts.append(initial_prompt)
+    return "\n\n".join(prompts)
 
 
 def _build_launch_spec(session, cwd=None, env_override=None, initial_prompt=None, capture_transcript=True):
-    initial_prompt = _with_launch_preferences(session, initial_prompt)
     _validate_initial_prompt(initial_prompt)
     cwd = cwd or os.getcwd()
     env_override = env_override or {}
     env = {**os.environ, **env_override}
+    initial_prompt = _with_launch_preferences(session, initial_prompt, env=env)
+    _validate_initial_prompt(initial_prompt)
     if session["provider"] == PROVIDER_CLAUDE:
         launch = session.get("launch") or {}
         args = ["--name", session["name"]]
         if launch.get("model"):
-            args += ["--model", launch["model"]]
+            args += ["--model", _claude_cli_model(launch["model"])]
         args += _launch_config_args(session)
         if initial_prompt:
             args.append(initial_prompt)
@@ -390,10 +446,11 @@ def _validate_initial_prompt(initial_prompt):
 
 
 def _build_headless_launch_spec(session, cwd=None, env_override=None, initial_prompt=None):
-    initial_prompt = _with_launch_preferences(session, initial_prompt)
     _validate_initial_prompt(initial_prompt)
     cwd = cwd or os.getcwd()
     env = {**os.environ, **(env_override or {})}
+    initial_prompt = _with_launch_preferences(session, initial_prompt, env=env)
+    _validate_initial_prompt(initial_prompt)
     launch = session.get("launch") or {}
     power = _launch_power(session)
     permission = launch.get("permission")
@@ -402,7 +459,7 @@ def _build_headless_launch_spec(session, cwd=None, env_override=None, initial_pr
     if session["provider"] == PROVIDER_CLAUDE:
         args = ["--print", "--output-format", "json", "--name", session["name"]]
         if model:
-            args += ["--model", model]
+            args += ["--model", _claude_cli_model(model)]
         args += _launch_config_args(session)
         if initial_prompt:
             args.append(initial_prompt)

package/src/session_service.py

@@ -149,6 +149,18 @@ def _normalize_launch_settings(settings):
                 normalized["rtk"] = False
             else:
                 raise CdxError(f"Unsupported rtk value: {settings['rtk']}")
+    if "logics" in settings and settings["logics"] is not None:
+        value = settings["logics"]
+        if isinstance(value, bool):
+            normalized["logics"] = value
+        else:
+            text = str(value).strip().lower()
+            if text in ("on", "true", "1", "yes"):
+                normalized["logics"] = True
+            elif text in ("off", "false", "0", "no"):
+                normalized["logics"] = False
+            else:
+                raise CdxError(f"Unsupported logics value: {settings['logics']}")
     if "model" in settings and settings["model"] is not None:
         model = str(settings["model"]).strip()
         if not model:
@@ -839,7 +851,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", "rtk", "model", "priority"}
+        allowed = {"power", "permission", "fast", "rtk", "logics", "model", "priority"}
         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

@@ -1,5 +1,7 @@
 import json
 import os
+import shutil
+import subprocess
 import urllib.error
 import urllib.request
 from datetime import datetime, timezone
@@ -7,6 +9,7 @@ from datetime import datetime, timezone
 
 UPDATE_CHECK_TTL_SECONDS = 12 * 60 * 60
 LATEST_RELEASE_URL = "https://api.github.com/repos/AlexAgo83/cdx-manager/releases/latest"
+LOGICS_MANAGER_LATEST_URL = "https://registry.npmjs.org/@grifhinz%2Flogics-manager/latest"
 
 
 class LatestReleaseCheckError(Exception):
@@ -40,6 +43,10 @@ def _cache_path(base_dir):
     return os.path.join(base_dir, "state", "update-check.json")
 
 
+def _tool_cache_path(base_dir, tool):
+    return os.path.join(base_dir, "state", f"{tool}-update-check.json")
+
+
 def _read_cache(path):
     try:
         with open(path, "r", encoding="utf-8") as handle:
@@ -106,6 +113,50 @@ def fetch_latest_release(env=None):
         return None
 
 
+def _fetch_latest_npm_package_version(url=LOGICS_MANAGER_LATEST_URL):
+    request = urllib.request.Request(
+        url,
+        headers={
+            "Accept": "application/json",
+            "User-Agent": "cdx-manager-update-check",
+        },
+    )
+    with urllib.request.urlopen(request, timeout=1) as response:
+        payload = json.loads(response.read().decode("utf-8"))
+    version = payload.get("version") if isinstance(payload, dict) else None
+    return str(version).strip() if version else None
+
+
+def fetch_latest_logics_manager_version(env=None):
+    try:
+        return _fetch_latest_npm_package_version()
+    except (urllib.error.URLError, TimeoutError, ValueError, OSError):
+        return None
+
+
+def _installed_logics_manager_version(env=None, runner=None):
+    env = env or os.environ
+    executable = shutil.which("logics-manager", path=env.get("PATH", ""))
+    if not executable:
+        return None
+    runner = runner or subprocess.run
+    try:
+        result = runner(
+            [executable, "--version"],
+            capture_output=True,
+            text=True,
+            timeout=2,
+            env=env,
+        )
+    except (OSError, subprocess.SubprocessError):
+        return None
+    if getattr(result, "returncode", 0) not in (0, None):
+        return None
+    output = (getattr(result, "stdout", "") or getattr(result, "stderr", "") or "").strip()
+    parts = output.split()
+    return parts[-1].lstrip("v") if parts else None
+
+
 def fetch_latest_release_or_raise(env=None):
     try:
         return _fetch_latest_release(env=env)
@@ -154,3 +205,55 @@ def check_for_update(base_dir, current_version, env=None, now_fn=None):
             "cached": False,
         }
     return None
+
+
+def check_logics_manager_for_update(base_dir, env=None, now_fn=None, runner=None):
+    env = env or os.environ
+    now_fn = now_fn or (lambda: datetime.now(timezone.utc).timestamp())
+    if env.get("CDX_DISABLE_UPDATE_CHECK") in {"1", "true", "TRUE", "yes", "YES"}:
+        return None
+    if env.get("LOGICS_MANAGER_NO_UPDATE_CHECK") in {"1", "true", "TRUE", "yes", "YES"}:
+        return None
+
+    current_version = _installed_logics_manager_version(env=env, runner=runner)
+    if not current_version:
+        return None
+
+    path = _tool_cache_path(base_dir, "logics-manager")
+    now_ts = float(now_fn())
+    cached = _read_cache(path) or {}
+    checked_at = cached.get("checked_at")
+    if isinstance(checked_at, (int, float)) and (now_ts - checked_at) < UPDATE_CHECK_TTL_SECONDS:
+        latest_version = cached.get("latest_version")
+        if _is_newer_version(current_version, latest_version):
+            return {
+                "tool": "logics-manager",
+                "latest_version": latest_version,
+                "current_version": current_version,
+                "update_command": "logics-manager self-update",
+                "url": cached.get("url"),
+                "cached": True,
+            }
+        return None
+
+    latest_version = fetch_latest_logics_manager_version(env=env)
+    payload = {
+        "checked_at": now_ts,
+        "latest_version": latest_version,
+        "url": "https://www.npmjs.com/package/@grifhinz/logics-manager",
+    }
+    try:
+        _write_cache(path, payload)
+    except OSError:
+        pass
+
+    if _is_newer_version(current_version, latest_version):
+        return {
+            "tool": "logics-manager",
+            "latest_version": latest_version,
+            "current_version": current_version,
+            "update_command": "logics-manager self-update",
+            "url": payload["url"],
+            "cached": False,
+        }
+    return None