cdx-manager 0.7.6 → 0.8.0

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.6-4C8BF5) ![Python](https://img.shields.io/badge/python-3.9%2B-3776AB?logo=python&logoColor=white)
+[![License](https://img.shields.io/badge/license-MIT-4C8BF5)](LICENSE) ![Version](https://img.shields.io/badge/version-v0.8.0-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,8 @@ 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`.
+- **Logics viewer shortcut.** `cdx view` opens the Logics browser/focus viewer through `logics-manager view` when the companion CLI is installed; `cdx view --json` reports availability and update diagnostics without opening the viewer.
 - **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 +137,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.6 sh install.sh
+CDX_VERSION=v0.8.0 sh install.sh
 ```
 
 From source:
@@ -189,6 +190,13 @@ Security note:
 - Prefer `npm`, `pipx`, or `uv` when you want registry-backed install flows.
 - If you use the standalone script, download it first, inspect it, and prefer a release with an official checksum entry.
 
+Release maintainer note:
+
+- Before publishing npm or PyPI packages, run `npm run release:validate`.
+- The release tag must match `package.json`, `pyproject.toml`, `src/cli.py`, and `VERSION`.
+- `checksums/release-archives.json` must include the matching `vX.Y.Z` entry with both `github_tarball_sha256` and `github_zip_sha256`.
+- Use `python3 scripts/update_release_checksums.py --tag vX.Y.Z` after the GitHub tag archives exist, commit the checksum update to `main`, then publish the GitHub release only after `npm run release:validate`, `npm run lint`, and `npm test` pass.
+
 ### Environment
 
 By default, `cdx` stores all data under `~/.cdx/`. Override with:
@@ -271,6 +279,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 +295,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 +339,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 |
@@ -342,6 +352,7 @@ cdx history --summary --from 2026-05-01 --to 2026-05-28
 | `cdx import <file> [--sessions a,b] [--passphrase-env VAR] [--force] [--json]` | Import sessions from a bundle into the current `CDX_HOME` |
 | `cdx doctor [--json]` | Inspect CLI dependencies, CDX_HOME permissions, missing state, orphan profiles, and pending quarantines |
 | `cdx repair [--dry-run] [--force] [--json]` | Plan or apply safe repairs for missing state files, quarantines, and orphan profiles |
+| `cdx view [--json]` | Open the Logics browser/focus viewer by delegating to `logics-manager view`; JSON mode reports diagnostics without launching it |
 | `cdx update [--check] [--yes] [--json] [--version TAG]` | Update cdx-manager using the installer that matches how it was installed |
 | `cdx ready [--refresh] [--json]` | Schedule an OS notification for the next cooling-down assistant that becomes ready, then return immediately |
 | `cdx notify <name> --at-reset [--poll seconds] [--once] [--schedule] [--refresh] [--json]` | Wait for a session reset time or schedule an OS wake-up notification when due |
@@ -385,6 +396,7 @@ Commands with machine-readable output:
 - `cdx last --json`
 - `cdx doctor --json`
 - `cdx repair --json`
+- `cdx view --json`
 - `cdx update --json`
 - `cdx ready --json`
 - `cdx notify ... --json`
@@ -498,7 +510,8 @@ Notes:
 
 - `npm test`: run the Python test suite
 - `npm run test:py`: run the Python unit tests through the portable launcher
-- `npm run lint`: check the Node launcher and byte-compile the Python sources and tests
+- `npm run lint`: check project guidance, the Node launcher, and byte-compile the Python sources, scripts, and tests
+- `npm run release:validate`: verify version alignment and required GitHub release archive checksum metadata before publication
 - `npm run link`: link `cdx` globally for local development (`npm link`)
 - `npm run unlink`: remove the global link
 

package/changelogs/CHANGELOGS_0_7_8.md

@@ -0,0 +1,42 @@
+# 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 `cdx view` as a thin shortcut for `logics-manager view`, plus `cdx view --json` diagnostics for companion availability and update suggestions.
+- 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`.
+
+## Release Governance
+
+- Added `npm run release:validate` as the required pre-publication gate for version alignment and GitHub archive checksum metadata.
+- The npm and PyPI publication workflows now run the checksum/version gate before registry upload.
+- Release prep now requires generating `checksums/release-archives.json` entries for the matching `vX.Y.Z` tag before publication.
+
+## Maintainability
+
+- Extracted the `cdx view` command domain into a dedicated module while keeping the existing CLI routing and JSON diagnostics unchanged.
+
+## Validation and Regression Evidence
+
+- `npm run lint`
+- `npm run release:validate`
+- `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/changelogs/CHANGELOGS_0_8_0.md

@@ -0,0 +1,39 @@
+# Changelog (`0.7.8 -> 0.8.0`)
+
+Release date: 2026-06-08
+
+## Release Governance
+
+- Added a pre-publication release checksum gate that validates version alignment across `package.json`, `pyproject.toml`, `src/cli.py`, and `VERSION`.
+- Publication workflows now require matching GitHub archive checksum metadata before npm or PyPI upload.
+- Documented the release ordering for version bump, tag/archive checksum generation, checksum commit, and publication.
+
+## Logics Workflow
+
+- Versioned `LOGICS.md` as normal project guidance instead of treating it as an ignored local artifact.
+- Added project documentation validation to ensure core Logics command families stay documented.
+- Added `cdx view` as a thin shortcut for `logics-manager view`.
+- Added `cdx view --json` diagnostics for companion availability, delegated command details, failure reason, and update suggestions.
+
+## Maintainability
+
+- Extracted the `cdx view` command domain into `src/cli_view.py` while keeping `src/cli_commands.py` as a compatibility facade for handler routing.
+
+## Release Metadata
+
+- Updated package metadata, CLI version output, README badge, pinned installer example, and release changelog to `v0.8.0`.
+
+## Validation and Regression Evidence
+
+- `python -m py_compile bin/cdx src/*.py test/test_*_py.py`
+- `python -m unittest discover -s test -p 'test_*_py.py'`
+- `npm pack --dry-run`
+- `npm run lint`
+- `npm test`
+- `logics-manager lint --require-status`
+- `logics-manager audit`
+- `git diff --check`
+- `node bin/cdx.js --version`
+- `python3 bin/cdx --version`
+- `python -m build`
+- `python -m twine check dist/*`

package/checksums/release-archives.json

@@ -52,6 +52,18 @@
     "v0.7.5": {
       "github_tarball_sha256": "18f5f6230bb5704913a90cfe2bfc5f55599c6ca0813bfd9f4bc97fc9f19e074a",
       "github_zip_sha256": "cafd400c65c255aa9569853ec9d1cc80cf691ff849660496779334ee7abf71b4"
+    },
+    "v0.7.6": {
+      "github_tarball_sha256": "cf6390c2071c710edd7c55d89fd75914e1d94ae5a62330d6fe15029484f88c13",
+      "github_zip_sha256": "f58be3078daaa9523053dab7b59d681dfb359d5f2a94276aa46000dd7f1360ed"
+    },
+    "v0.7.8": {
+      "github_tarball_sha256": "8afa0c1f0293a973973158d249aaa627d3aede785cd5a36941be067633580e2a",
+      "github_zip_sha256": "207e000dc1192d12324616cc4671f42cf07c22e2eb895556117b681ab5a6ab93"
+    },
+    "v0.8.0": {
+      "github_tarball_sha256": "62cd461f9e22636bb85d801e21209b1762859b6662623e74c01fd40c107ea29a",
+      "github_zip_sha256": "4674c8b61110f52b99c76312e9962202a2e8fc6928327f8927781f45eeaa980f"
     }
   }
 }

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.6",
+  "version": "0.8.0",
   "description": "Terminal session manager for Codex and Claude accounts.",
   "license": "MIT",
   "author": "Alexandre Agostini",
@@ -44,8 +44,9 @@
   "scripts": {
     "test": "npm run test:py",
     "test:py": "node bin/python-runner.js -m unittest discover -s test -p test_*_py.py",
-    "lint": "node --check bin/cdx.js && node --check bin/python-runner.js && node bin/python-runner.js -m py_compile bin/cdx src/*.py test/test_*_py.py",
-    "prepublishOnly": "npm run lint && npm test",
+    "lint": "node --check bin/cdx.js && node --check bin/python-runner.js && node bin/python-runner.js scripts/verify_project_docs.py && node bin/python-runner.js -m py_compile bin/cdx src/*.py scripts/*.py test/test_*_py.py",
+    "release:validate": "node bin/python-runner.js scripts/verify_release_checksums.py",
+    "prepublishOnly": "npm run release:validate && npm run lint && npm test",
     "link": "npm link",
     "unlink": "npm unlink -g cdx-manager"
   }

package/pyproject.toml

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

package/src/cli.py

@@ -37,6 +37,7 @@ from .cli_commands import (
     handle_set,
     handle_unset,
     handle_update,
+    handle_view,
 )
 from .cli_render import (
     _format_sessions,
@@ -58,9 +59,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.6"
+VERSION = "0.8.0"
 
 
 # ---------------------------------------------------------------------------
@@ -84,8 +85,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)}",
@@ -104,6 +105,7 @@ def _print_help(use_color=False):
         f"  {_style('cdx import <file> [--sessions a,b] [--passphrase-env VAR] [--force] [--json]', '36', use_color)}",
         f"  {_style('cdx doctor [--json]', '36', use_color)}",
         f"  {_style('cdx repair [--dry-run] [--force] [--json]', '36', use_color)}",
+        f"  {_style('cdx view [--json]', '36', use_color)}",
         f"  {_style('cdx update [--check] [--yes] [--json] [--version TAG]', '36', use_color)}",
         f"  {_style('cdx ready [--refresh] [--json]', '36', use_color)}",
         f"  {_style('cdx notify <name> --at-reset [--schedule] [--refresh] [--json]', '36', use_color)}",
@@ -158,22 +160,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 +248,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,8 +276,8 @@ 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 (
-            "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"
+        "update_notices": _get_update_notices(service, env, options) if command not in (
+            "add", "cp", "ren", "rename", "mv", "rmv", "clean", "doctor", "repair", "view", "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,
     }
@@ -282,6 +315,9 @@ def main(argv, options=None):
     if command == "repair":
         return handle_repair(rest, ctx)
 
+    if command == "view":
+        return handle_view(rest, ctx)
+
     if command == "update":
         return handle_update(rest, ctx)
 
@@ -355,13 +391,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

@@ -21,6 +21,7 @@ from .context_store import (
 )
 from .errors import CdxError
 from .health import collect_health_report, format_health_report
+from .cli_view import handle_view
 from .notify import (
     format_notify_event,
     format_scheduled_notification,
@@ -55,8 +56,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 +110,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 +547,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 +564,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 +584,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 +600,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 +1462,7 @@ def _format_launch_config(session, use_color=False):
         ("permission", "Permission"),
         ("fast", "Fast"),
         ("rtk", "RTK"),
+        ("logics", "Logics"),
         ("model", "Model"),
         ("priority", "Priority"),
     ]:
@@ -1460,16 +1483,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 +1519,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 +1530,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 +2410,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 +2733,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/cli_view.py

@@ -0,0 +1,101 @@
+import json
+
+from .cli_render import _warn
+from .errors import CdxError
+from .logics_view import (
+    LOGICS_MANAGER_INSTALL_HINT,
+    build_viewer_diagnostics,
+    missing_logics_manager_failure,
+    resolve_logics_manager,
+    run_logics_viewer,
+)
+from .update_check import check_logics_manager_for_update
+
+
+VIEW_USAGE = "Usage: cdx view [--json]"
+API_SCHEMA_VERSION = 1
+
+
+def _json_success(action, message, warnings=None, **extra):
+    payload = {
+        "schema_version": API_SCHEMA_VERSION,
+        "ok": True,
+        "action": action,
+        "message": message,
+        "warnings": warnings or [],
+    }
+    payload.update(extra)
+    return payload
+
+
+def _write_json(ctx, payload):
+    ctx["out"](f"{json.dumps(payload, indent=2)}\n")
+
+
+def _update_notice_warnings(notices):
+    warnings = []
+    for notice in notices or []:
+        if not notice:
+            continue
+        tool = notice.get("tool") or "logics-manager"
+        current = notice.get("current_version")
+        command = notice.get("update_command")
+        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": 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 _logics_manager_update_notice(ctx, env):
+    checker = ctx["options"].get("checkLogicsManagerForUpdate") or check_logics_manager_for_update
+    return checker(
+        ctx["service"]["base_dir"],
+        env=env,
+        now_fn=ctx["options"].get("now"),
+        runner=ctx["options"].get("runLogicsVersionCheck"),
+    )
+
+
+def handle_view(rest, ctx):
+    json_flag = "--json" in rest
+    unknown = [arg for arg in rest if arg != "--json"]
+    if unknown:
+        raise CdxError(VIEW_USAGE)
+
+    env = ctx.get("env")
+    cwd = ctx.get("cwd")
+    executable = resolve_logics_manager(env=env)
+    update_notice = _logics_manager_update_notice(ctx, env) if executable else None
+    failure = None if executable else missing_logics_manager_failure()
+    diagnostics = build_viewer_diagnostics(executable, cwd, update_notice=update_notice, failure=failure)
+    warnings = _update_notice_warnings([update_notice])
+
+    if json_flag:
+        _write_json(ctx, _json_success("view", "Collected Logics viewer diagnostics", warnings=warnings, viewer=diagnostics))
+        return 0
+
+    if not executable:
+        raise CdxError(f"logics-manager is required for cdx view. {LOGICS_MANAGER_INSTALL_HINT}")
+
+    for warning in warnings:
+        ctx["out"](f"{_warn(warning['message'], ctx['use_color'])}\n")
+
+    try:
+        result = run_logics_viewer(executable, cwd, env=env, runner=ctx.get("spawn_sync"))
+    except FileNotFoundError as error:
+        raise CdxError(f"logics-manager is required for cdx view. {LOGICS_MANAGER_INSTALL_HINT}") from error
+    returncode = getattr(result, "returncode", 0)
+    if returncode not in (0, None):
+        raise CdxError("logics-manager view failed.", exit_code=returncode)
+    return 0

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/logics_view.py

@@ -0,0 +1,37 @@
+import shutil
+import subprocess
+
+
+LOGICS_MANAGER_INSTALL_HINT = "Install or update it with: npm install -g @grifhinz/logics-manager"
+
+
+def resolve_logics_manager(env=None):
+    env = env or {}
+    return shutil.which("logics-manager", path=env.get("PATH", ""))
+
+
+def build_viewer_diagnostics(executable, cwd, update_notice=None, failure=None):
+    command = [executable or "logics-manager", "view"]
+    return {
+        "available": bool(executable),
+        "executable": executable,
+        "command": command,
+        "cwd": cwd,
+        "update": update_notice,
+        "failure": failure,
+    }
+
+
+def missing_logics_manager_failure():
+    return {
+        "code": "logics_manager_missing",
+        "message": f"logics-manager is required for cdx view. {LOGICS_MANAGER_INSTALL_HINT}",
+    }
+
+
+def run_logics_viewer(executable, cwd, env=None, runner=None):
+    runner = runner or subprocess.run
+    argv = [executable, "view"]
+    if runner is subprocess.run:
+        return subprocess.run(argv, cwd=cwd, env=env)
+    return runner(argv, cwd=cwd, env=env)

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"],
@@ -327,20 +335,40 @@ 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"]]
@@ -418,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")

package/src/session_service.py

@@ -56,6 +56,7 @@ RESERVED_SESSION_NAMES = {
     "status",
     "unset",
     "update",
+    "view",
     "version",
     "--help",
     "-h",
@@ -149,6 +150,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 +852,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