cdx-manager 0.11.2 → 0.12.1

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.11.2-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.12.1-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.**
 
@@ -361,7 +361,8 @@ cdx history --summary --from 2026-05-01 --to 2026-05-28
 | `cdx last [--json]` | Launch the most recent existing session from launch history |
 | `cdx resume <name> [--json]` | Resume the provider-native conversation for a session using the named command form |
 | `cdx can-resume <name> [--json]` | Check whether a session supports native resume without launching the provider |
-| `cdx context show\|path\|init\|edit\|clear\|set [text...] [--json]` | Manage the shared Markdown context for the current workspace |
+| `cdx context show\|path\|init\|edit\|clear\|set\|append [text...] [--json]` | Manage the shared Markdown context for the current workspace |
+| `cdx memory [--global\|--project NAME_OR_PATH] [show\|view\|path\|init\|edit\|clear\|set\|append\|list] [text...] [--json]` | Manage explicit user-controlled memory for the current workspace, global scope, or a named/path project |
 | `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 cross-provider handoff |
 | `cdx rmv <name> [--force] [--json]` | Remove a session and its auth data (prompts for confirmation unless `--force`) |
@@ -371,10 +372,11 @@ cdx history --summary --from 2026-05-01 --to 2026-05-28
 | `cdx reset <name> [--yes] [--json]` | Explicitly consume one available banked Codex rate-limit reset; confirmation is required unless `--yes` is supplied |
 | `cdx export <file> [--include-auth] [--sessions a,b] [--passphrase-env VAR\|--passphrase-stdin] [--force] [--json]` | Export sessions to a portable bundle; `--include-auth` encrypts auth data with a passphrase |
 | `cdx import <file> [--sessions a,b] [--passphrase-env VAR\|--passphrase-stdin] [--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 doctor [--json]` | Inspect CLI dependencies, provider CLI versions/capability hints, 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] [--lan] [--lan-rw] [--focus <ref>] [--read] [--port <port>] [--host <host>] [--refresh-interval <s>] [--tls] [--tls-cert <path>] [--tls-key <path>] [--open] [--no-open]` | Open the Logics browser/focus viewer by delegating to `logics-manager view`; all viewer flags are forwarded; 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 update all [--yes] [--json]` | Check installed providers, RTK, and Ponytail across Codex profiles; show the plan and ask once before applying safe native/Homebrew updates and missing RTK/Ponytail setup |
 | `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 |
 | `cdx notify --next-ready [--poll seconds] [--once] [--schedule] [--refresh] [--json]` | Wait until the recommended session is usable, or schedule the next known reset notification |
@@ -414,6 +416,7 @@ Commands with machine-readable output:
 - `cdx disable ... --json`
 - `cdx enable ... --json`
 - `cdx context ... --json`
+- `cdx memory ... --json`
 - `cdx handoff ... --json`
 - `cdx history ... --json`
 - `cdx stats ... --json`
@@ -558,6 +561,7 @@ Notes:
   - if a compatible `script` command is available and exposed via `CDX_SCRIPT_BIN`, `cdx` uses it
   - otherwise Codex launches without transcript capture and the session still works normally
 - `cdx doctor` reports the transcript-capture fallback explicitly so missing `script` on Windows is visible without being treated as a hard failure.
+- `cdx doctor --json` includes detected `codex --version` and `claude --version` output when available, plus conservative capability hints for recent provider memory, model, and headless diagnostic surfaces. These hints are informational; `cdx` does not edit provider-private memory stores.
 
 ---
 
@@ -605,6 +609,10 @@ All session data lives under `CDX_HOME` (default: `~/.cdx/`):
   state/
     <encoded-name>.json     # Per-session rehydration state
     launch_history.jsonl    # Append-only launch history
+  contexts/
+    <workspace-hash>/context.md     # Current-workspace shared context / memory
+    global/context.md               # Global cdx memory
+    projects/<encoded-name>/context.md  # Named project memory from cdx memory --project NAME
   profiles/
     <encoded-name>/         # Codex session: CODEX_HOME points here
       log/
@@ -617,6 +625,10 @@ All session data lives under `CDX_HOME` (default: `~/.cdx/`):
 
 Session names are URL-encoded when used as directory or file names. CLI command names such as `add`, `disk`, `status`, and `login` are reserved and cannot be used as new session names.
 
+`cdx memory` is the user-facing interface for explicit memory. `--project NAME` uses a stable free-form project name; `--project /path/to/repo` resolves to the same workspace-hash memory that repo would use as the current workspace. `append` adds the text as-is with a clean newline boundary; it does not add dates or headings. `list` reports global memory, named project memories, and the current workspace memory when present; it does not scan your filesystem for repos.
+
+Provider-private memory files, such as Codex SQLite memory databases or Claude Code project memory files, are not edited by `cdx memory`.
+
 ### Disk maintenance
 
 Use `cdx disk` for a total `CDX_HOME` measurement, and `cdx disk profiles` for the `profiles/` total plus a per-profile breakdown.

package/changelogs/CHANGELOGS_0_12_0.md

@@ -0,0 +1,42 @@
+# CDX Manager 0.12.0
+
+## Highlights
+
+- Added explicit `cdx memory` management for current workspace, global, and project-scoped memory.
+- Added append/list workflows for user-controlled Markdown memory without touching provider-private memory stores.
+- Improved `cdx doctor` provider visibility with Codex and Claude CLI versions plus conservative capability hints.
+
+## Changes
+
+### Scoped memory
+
+`cdx memory` now manages explicit local memory using the existing shared context store:
+
+- `cdx memory append <text>` appends to the current workspace memory.
+- `cdx memory --global append <text>` appends to a global operator memory.
+- `cdx memory --project <name> append <text>` appends to a stable named project memory.
+- `cdx memory --project <path> ...` resolves to the same workspace-hash memory used by that repo path.
+- `cdx memory list [--json]` lists global memory, named project memories, and the current workspace memory when present.
+
+Append is intentionally plain text with a clean newline boundary; it does not add dates or headings automatically.
+
+### Context compatibility
+
+`cdx context append <text>` was added for the existing workspace context command. Existing `cdx context` and `cdx handoff` behavior remains compatible.
+
+### Doctor provider versions
+
+`cdx doctor` now records provider CLI versions when available:
+
+- `codex --version`
+- `claude --version`
+
+JSON output includes conservative capability hints for recent provider memory and diagnostic surfaces. These hints are informational; `cdx` still does not read or write Codex SQLite memory, Claude Code project memory, `CLAUDE.md`, or provider plugin files.
+
+## Validation
+
+- `PYTHONPATH=src python3 -m pytest -q`
+- `python3 -m ruff check src test`
+- `logics-manager flow validate req_013_add_a_small_workspace_memory_command_to_cdx`
+- `logics-manager lint --require-status`
+- `logics-manager audit --group-by-doc`

package/changelogs/CHANGELOGS_0_12_1.md

@@ -0,0 +1,25 @@
+# CDX Manager 0.12.1
+
+## Highlights
+
+- Added `cdx update all` to inventory and safely update the installed provider CLIs, RTK, and Ponytail across Codex profiles.
+- Made account handoffs use native provider transcripts before terminal capture, preserving actionable conversation instead of terminal noise.
+
+## Changes
+
+### Workstation updates
+
+`cdx update all` now reports installed versions and session setup, asks once before applying its plan, and shows progress plus the command and error output when an action fails. It follows the actual installer provenance of each CLI, including the Claude Code cask rather than the separate Claude desktop app.
+
+RTK is enabled for sessions that lack it when available. Ponytail marketplaces and plugins are checked per Codex profile; current Codex marketplace caches without a `last_revision` field are resolved from their Git checkout.
+
+### Reliable handoffs
+
+Cross-session handoffs now prefer native JSONL transcripts and retain only user and assistant messages. Script-captured terminal logs remain a fallback, but no longer displace structured provider conversation or tool-output noise into the shared context.
+
+## Validation
+
+- `npm run lint`
+- `npm test`
+- `logics-manager lint --require-status`
+- `logics-manager audit --group-by-doc`

package/checksums/release-archives.json

@@ -144,6 +144,18 @@
     "v0.11.1": {
       "github_tarball_sha256": "33ee5a76cd217007468ea620fa725644dfd62179585551b5703129c00a5094d5",
       "github_zip_sha256": "8b53832ad2af109c22a898782bd36e1408356fc2bd0c3f99ca2ffb1262e2325b"
+    },
+    "v0.11.2": {
+      "github_tarball_sha256": "513d7c586a662da5ac5daf792fc76f746e924bbd95157a9d0cbbeba34f2991e0",
+      "github_zip_sha256": "d6d633efcbdc28818f68bd87efe3f246fe2983a9f4aa24d03868c978645c593e"
+    },
+    "v0.12.0": {
+      "github_tarball_sha256": "de1bac90e790b5d557f90fd22f7dd317c45646d0e07320c05c8b2336ed9bbced",
+      "github_zip_sha256": "213f6217dfd8c7aa979af691c2d63598b4589ca40f36e816f4ae9c9f2da27073"
+    },
+    "v0.12.1": {
+      "github_tarball_sha256": "87e3b11886a8e7fb10233d425f6a1986e62395c89049947678a50cfb20384278",
+      "github_zip_sha256": "249f75eb240de7cc421f17579e0040d35eb06e3213568673f743c92191dda0f0"
     }
   }
 }

package/package.json

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

package/src/cli.py

@@ -32,6 +32,7 @@ from .cli_commands import (
     handle_launch_setting_alias,
     handle_login,
     handle_logout,
+    handle_memory,
     handle_next,
     handle_notify,
     handle_remove,
@@ -77,7 +78,7 @@ from .status_view import (
 )
 from .update_check import check_for_update, check_logics_manager_for_update
 
-VERSION = "0.11.2"
+VERSION = "0.12.1"
 
 # Public surface: this module is a facade. Names below are imported above
 # purely to be re-exported (consumed by tests and external callers); listing
@@ -117,6 +118,7 @@ _COMMAND_HANDLERS = {
     "last": handle_last,
     "login": handle_login,
     "logout": handle_logout,
+    "memory": handle_memory,
     "next": handle_next,
     "notify": handle_notify,
     "repair": handle_repair,
@@ -185,7 +187,8 @@ def _print_help(use_color=False):
         f"  {_style('cdx runs [--limit N] --json', '36', use_color)}",
         f"  {_style('cdx run-status <run_id> --json', '36', use_color)}",
         f"  {_style('cdx run-report <run_id> --json', '36', use_color)}",
-        f"  {_style('cdx context show|path|init|edit|clear|set [text...] [--json]', '36', use_color)}",
+        f"  {_style('cdx context show|path|init|edit|clear|set|append [text...] [--json]', '36', use_color)}",
+        f"  {_style('cdx memory [--global|--project NAME_OR_PATH] [show|view|path|init|edit|clear|set|append|list] [text...] [--json]', '36', use_color)}",
         f"  {_style('cdx disk [profiles] [--candidates] [--json]', '36', use_color)}",
         f"  {_style('cdx config <name> [--json]', '36', use_color)}",
         f"  {_style('cdx configs [--json]', '36', use_color)}",
@@ -216,7 +219,7 @@ def _print_help(use_color=False):
         f"  {_style('cdx doctor [--json]', '36', use_color)}",
         f"  {_style('cdx repair [--dry-run] [--force] [--json]', '36', use_color)}",
         f"  {_style('cdx view [--json]', '36', use_color)}",
-        f"  {_style('cdx update [--check] [--yes] [--json] [--version TAG]', '36', use_color)}",
+        f"  {_style('cdx update [all] [--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)}",
         f"  {_style('cdx notify --next-ready [--schedule] [--refresh] [--json]', '36', use_color)}",

package/src/cli_args.py

@@ -15,10 +15,11 @@ STATUS_USAGE = "Usage: cdx status [--json] [--refresh|--cached] [--timeout SECON
 DOCTOR_USAGE = "Usage: cdx doctor [--json]"
 DISK_USAGE = "Usage: cdx disk [profiles] [--candidates] [--json]"
 REPAIR_USAGE = "Usage: cdx repair [--dry-run] [--force] [--json]"
-UPDATE_USAGE = "Usage: cdx update [--check] [--yes] [--json] [--version TAG]"
+UPDATE_USAGE = "Usage: cdx update [all] [--check] [--yes] [--json] [--version TAG]"
 EXPORT_USAGE = "Usage: cdx export <file> [--include-auth] [--force] [--json] [--sessions name1,name2] [--passphrase-env VAR|--passphrase-stdin]"
 IMPORT_USAGE = "Usage: cdx import <file> [--force|--merge] [--allow-authless-force] [--json] [--sessions name1,name2] [--passphrase-env VAR|--passphrase-stdin]"
-CONTEXT_USAGE = "Usage: cdx context show|path|init|edit|clear|set [text...] [--json]"
+CONTEXT_USAGE = "Usage: cdx context show|path|init|edit|clear|set|append [text...] [--json]"
+MEMORY_USAGE = "Usage: cdx memory [--global|--project NAME_OR_PATH] [show|view|path|init|edit|clear|set|append|list] [text...] [--json]"
 HANDOFF_USAGE = "Usage: cdx handoff <name> [--json] | cdx handoff <source> <target> [--json]"
 LABEL_USAGE = "Usage: cdx label <name> <label> [--json] | cdx label <name> --clear [--json]"
 SET_USAGE = "Usage: cdx set <name>|--sessions all|a,b|--provider PROVIDER [--power minimal|low|medium|high|xhigh] [--permission review|default|auto|full] [--fast on|off] [--rtk on|off] [--logics on|off] [--model MODEL] [--priority 0..100] [--json]"
@@ -593,11 +594,16 @@ def _parse_update_args(args):
         "--json": {"key": "json", "type": "bool", "default": False},
         "--yes": {"key": "yes", "type": "bool", "default": False},
         "--version": {"key": "version", "type": "str", "default": None},
-    }, UPDATE_USAGE)
+    }, UPDATE_USAGE, positionals_key="values", max_positionals=1)
+    if parsed["values"] not in ([], ["all"]):
+        raise CdxError(UPDATE_USAGE)
+    parsed["all"] = bool(parsed["values"])
+    if parsed["all"] and (parsed["check"] or parsed["version"]):
+        raise CdxError("Usage: cdx update all [--yes] [--json]")
     if parsed["check"] and parsed["version"]:
         raise CdxError("Usage: cdx update --check cannot be combined with --version.")
     if parsed["version"] is not None and not parsed["version"].strip():
-        raise CdxError("Usage: cdx update [--check] [--yes] [--json] [--version TAG]")
+        raise CdxError(UPDATE_USAGE)
     return parsed
 
 

package/src/cli_commands.py

@@ -20,6 +20,7 @@ from .cli_args import (
     DOCTOR_USAGE,
     HANDOFF_USAGE,
     LAST_USAGE,
+    MEMORY_USAGE,
     REPAIR_USAGE,
     RESUME_USAGE,
     RUN_REPORT_USAGE,
@@ -77,13 +78,23 @@ from .cli_view import handle_view as handle_view  # re-export for cli.py / tests
 from .codex_usage import consume_codex_rate_limit_reset_credit
 from .config import PROVIDER_ANTIGRAVITY, PROVIDER_CLAUDE, PROVIDER_CODEX, PROVIDER_OLLAMA
 from .context_store import (
+    append_context,
+    append_context_path,
     clear_context,
+    clear_context_path,
     edit_context,
+    edit_context_path,
     get_context_path,
+    get_global_context_path,
+    get_named_project_context_path,
     init_context,
+    init_context_path,
     install_context_for_session,
+    list_named_project_contexts,
     read_context,
+    read_context_path,
     write_context,
+    write_context_path,
 )
 from .errors import CdxError
 from .fs_utils import atomic_write
@@ -113,10 +124,46 @@ from .run_command import read_run_prompt, run_cdx_error_code, run_result_payload
 from .run_registry import RunRegistry, build_code_review_report
 from .run_usage import extract_run_usage
 from .status_view import _format_status_detail, _format_status_rows, format_priority_instruction, recommend_priority_rows
+from .update_all import apply_update_all_plan, collect_update_all_plan
 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, verify_updated_command
 
 
+def _format_update_all(plan, use_color=False):
+    labels = {
+        "up_to_date": _success("OK", use_color),
+        "update_available": _warn("UPDATE", use_color),
+        "not_installed": _warn("MISSING", use_color),
+        "check_with_native_updater": _info("CHECK", use_color),
+    }
+    rows = [[_style("TOOL", "1", use_color), _style("CURRENT", "1", use_color), _style("LATEST", "1", use_color), _style("STATUS", "1", use_color)]]
+    for item in plan["items"]:
+        rows.append([_info(item["name"], use_color), item.get("version") or _dim("-", use_color), item.get("latest_version") or _dim("-", use_color), labels.get(item["status"], item["status"].replace("_", " "))])
+    lines = [_style("Workstation update", "1", use_color), _dim("Inventory only — nothing has changed.", use_color), "", _pad_table(rows)]
+    missing_rtk = plan["setup"]["rtk_missing_sessions"]
+    setup = [f"RTK: enable for {', '.join(missing_rtk)}" if missing_rtk else "RTK: configured for every session"]
+    setup.extend(f"Ponytail {plugin['session']}: {labels.get(plugin['status'], plugin['status'].replace('_', ' '))}" for plugin in plan["setup"]["ponytail"])
+    lines.extend(["", _style("Session setup", "1", use_color), *setup])
+    if plan["steps"]:
+        lines.extend(["", _warn(f"{len(plan['steps'])} action(s) ready", use_color), _dim("Confirm to update only the tools listed above.", use_color)])
+    else:
+        lines.extend(["", _success("Everything managed by CDX is current and configured.", use_color)])
+    return "\n".join(lines)
+
+
+def _format_update_all_result(result, use_color=False):
+    if result.get("skipped"):
+        return _warn(f"skipped: {result['name']} (blocked by {result['blocked_by']})", use_color)
+    if result.get("returncode") == 0:
+        return _success(f"done: {result['name']}", use_color)
+    detail = str(result.get("stderr") or result.get("stdout") or "No error output.").strip().replace("\n", " ")
+    detail = detail[-500:]
+    command = shlex.join(result.get("command") or [])
+    suffix = f"\n  {_dim(command, use_color)}" if command else ""
+    label = _warn(f"failed: {result['name']} (exit {result.get('returncode')})", use_color)
+    return f"{label}\n  {detail}{suffix}"
+
+
 def _resolve_bundle_passphrase(ctx, env_var, prompt, confirm=False, use_stdin=False):
     env = ctx.get("env", {})
     if env_var:
@@ -2038,9 +2085,228 @@ def handle_context(rest, ctx):
         ctx["out"](f"{_success(text, ctx['use_color'])}\n")
         return 0
 
+    if action == "append":
+        note = " ".join(args[1:])
+        if not note.strip():
+            raise CdxError("Usage: cdx context append <text> [--json]")
+        result = append_context(base_dir, note, cwd)
+        if json_flag:
+            _write_json(ctx, _json_success("context.append", "Appended shared context", context=result))
+            return 0
+        text = f"Appended shared context: {result['path']}"
+        ctx["out"](f"{_success(text, ctx['use_color'])}\n")
+        return 0
+
     raise CdxError(CONTEXT_USAGE)
 
 
+def _parse_memory_args(rest):
+    json_flag, args = _parse_json_flag(rest)
+    scope = "current"
+    project = None
+    cleaned = []
+    index = 0
+    while index < len(args):
+        arg = args[index]
+        if arg == "--global":
+            if scope != "current":
+                raise CdxError(MEMORY_USAGE)
+            scope = "global"
+            index += 1
+            continue
+        if arg == "--project":
+            if scope != "current" or index + 1 >= len(args) or not args[index + 1].strip():
+                raise CdxError(MEMORY_USAGE)
+            scope = "project"
+            project = args[index + 1].strip()
+            index += 2
+            continue
+        if arg.startswith("--project="):
+            if scope != "current":
+                raise CdxError(MEMORY_USAGE)
+            project = arg.split("=", 1)[1].strip()
+            if not project:
+                raise CdxError(MEMORY_USAGE)
+            scope = "project"
+            index += 1
+            continue
+        cleaned.append(arg)
+        index += 1
+    if not cleaned:
+        cleaned = ["show"]
+    if cleaned[0] == "view":
+        cleaned[0] = "show"
+    return json_flag, scope, project, cleaned
+
+
+def _memory_target(base_dir, cwd, scope, project):
+    if scope == "global":
+        return {"scope": "global", "path": get_global_context_path(base_dir)}
+    if scope == "project":
+        if os.path.exists(project):
+            return {
+                "scope": "project",
+                "project": project,
+                "project_kind": "path",
+                "path": get_context_path(base_dir, project),
+            }
+        return {
+            "scope": "project",
+            "project": project,
+            "project_kind": "name",
+            "path": get_named_project_context_path(base_dir, project),
+        }
+    return {"scope": "current", "path": get_context_path(base_dir, cwd)}
+
+
+def _memory_payload(target, content=None):
+    payload = {
+        "scope": target["scope"],
+        "path": target["path"],
+        "exists": os.path.isfile(target["path"]),
+    }
+    if target.get("project") is not None:
+        payload["project"] = target["project"]
+        payload["project_kind"] = target.get("project_kind")
+    if payload["exists"]:
+        payload["bytes"] = os.path.getsize(target["path"])
+    if content is not None:
+        payload["content"] = content
+    return payload
+
+
+def _list_memory_entries(base_dir, cwd):
+    entries = []
+    global_path = get_global_context_path(base_dir)
+    if os.path.isfile(global_path):
+        entries.append({"scope": "global", "path": global_path, "bytes": os.path.getsize(global_path)})
+    entries.extend(list_named_project_contexts(base_dir))
+    current_path = get_context_path(base_dir, cwd)
+    if os.path.isfile(current_path):
+        entries.append({"scope": "current", "path": current_path, "bytes": os.path.getsize(current_path)})
+    return entries
+
+
+def handle_memory(rest, ctx):
+    json_flag, scope, project, args = _parse_memory_args(rest)
+    action = args[0]
+    base_dir = ctx["service"]["base_dir"]
+    cwd = ctx.get("cwd")
+
+    if action == "list":
+        if len(args) != 1 or scope != "current":
+            raise CdxError(MEMORY_USAGE)
+        entries = _list_memory_entries(base_dir, cwd)
+        if json_flag:
+            _write_json(ctx, _json_success("memory.list", "Listed memory scopes", memories=entries))
+            return 0
+        if not entries:
+            ctx["out"](f"{_dim('No cdx memory files found.', ctx['use_color'])}\n")
+            return 0
+        rows = [["SCOPE", "PROJECT", "SIZE", "PATH"]]
+        for entry in entries:
+            rows.append([
+                entry["scope"],
+                entry.get("project") or "-",
+                _format_bytes(entry.get("bytes") or 0),
+                entry["path"],
+            ])
+        ctx["out"](_pad_table(rows) + "\n")
+        return 0
+
+    target = _memory_target(base_dir, cwd, scope, project)
+    path = target["path"]
+
+    if action == "show":
+        if len(args) != 1:
+            raise CdxError(MEMORY_USAGE)
+        content = read_context_path(path)
+        payload = _memory_payload(target, content=content)
+        if json_flag:
+            _write_json(ctx, _json_success("memory.show", "Loaded memory", memory=payload))
+            return 0
+        if content.strip():
+            ctx["out"](content if content.endswith("\n") else f"{content}\n")
+        else:
+            ctx["out"](f"{_dim('No memory for this scope. Run: cdx memory append <text>', ctx['use_color'])}\n")
+        return 0
+
+    if action == "path":
+        if len(args) != 1:
+            raise CdxError(MEMORY_USAGE)
+        if json_flag:
+            _write_json(ctx, _json_success("memory.path", "Resolved memory path", memory=_memory_payload(target)))
+            return 0
+        ctx["out"](f"{path}\n")
+        return 0
+
+    if action == "init":
+        if len(args) != 1:
+            raise CdxError(MEMORY_USAGE)
+        result = init_context_path(path)
+        result = {**result, **{key: value for key, value in target.items() if key != "path"}}
+        message = "Created memory" if result.get("created") else "Memory already exists"
+        if json_flag:
+            _write_json(ctx, _json_success("memory.init", message, memory=result))
+            return 0
+        ctx["out"](f"{_success(f'{message}: {path}', ctx['use_color'])}\n")
+        return 0
+
+    if action == "edit":
+        if len(args) != 1:
+            raise CdxError(MEMORY_USAGE)
+        result = edit_context_path(path, env=ctx.get("env"), spawn_sync=ctx.get("spawn_sync"))
+        result = {**result, **{key: value for key, value in target.items() if key != "path"}}
+        if json_flag:
+            _write_json(ctx, _json_success("memory.edit", "Edited memory", memory=result))
+            return 0
+        ctx["out"](f"{_success(f'Edited memory: {path}', ctx['use_color'])}\n")
+        return 0
+
+    if action == "clear":
+        if len(args) != 1:
+            raise CdxError(MEMORY_USAGE)
+        result = clear_context_path(path)
+        result = {**result, **{key: value for key, value in target.items() if key != "path"}}
+        message = "Cleared memory" if result["removed"] else "No memory to clear"
+        if json_flag:
+            _write_json(ctx, _json_success("memory.clear", message, memory=result))
+            return 0
+        ctx["out"](f"{_success(message, ctx['use_color'])}\n")
+        return 0
+
+    if action == "set":
+        content_args = args[1:]
+        if content_args:
+            content = " ".join(content_args)
+        else:
+            stdin = ctx["options"].get("stdin_data")
+            if stdin is None and not ctx.get("stdin_is_tty"):
+                stdin = sys.stdin.read()
+            if stdin is None:
+                raise CdxError("Usage: cdx memory set <text> [--json]")
+            content = stdin
+        result = write_context_path(path, content)
+        result = {**result, **{key: value for key, value in target.items() if key != "path"}}
+        if json_flag:
+            _write_json(ctx, _json_success("memory.set", "Saved memory", memory=result))
+            return 0
+        ctx["out"](f"{_success(f'Saved memory: {path}', ctx['use_color'])}\n")
+        return 0
+
+    if action == "append":
+        note = " ".join(args[1:])
+        result = append_context_path(path, note)
+        result = {**result, **{key: value for key, value in target.items() if key != "path"}}
+        if json_flag:
+            _write_json(ctx, _json_success("memory.append", "Appended memory", memory=result))
+            return 0
+        ctx["out"](f"{_success(f'Appended memory: {path}', ctx['use_color'])}\n")
+        return 0
+
+    raise CdxError(MEMORY_USAGE)
+
+
 def handle_status(rest, ctx):
     parsed = _parse_flag_args(rest, {
         "--json": {"key": "json", "type": "bool", "default": False},
@@ -2444,6 +2710,38 @@ def handle_logout(rest, ctx):
 
 def handle_update(rest, ctx):
     parsed = _parse_update_args(rest)
+    if parsed["all"]:
+        plan = collect_update_all_plan(ctx["service"], env=ctx.get("env"), runner=ctx["options"].get("runUpdateAll"))
+        if not parsed["yes"]:
+            if parsed["json"]:
+                _write_json(ctx, _json_success("update.all", "Collected workstation update plan", plan=plan, apply_required=bool(plan["steps"])))
+                return 0
+            ctx["out"](f"{_format_update_all(plan, ctx['use_color'])}\n")
+            if not plan["steps"]:
+                return 0
+            if not ctx["stdin_is_tty"]:
+                raise CdxError("cdx update all requires an interactive terminal or --yes.")
+            if input("Apply this plan? [y/N] ").strip().lower() not in ("y", "yes"):
+                ctx["out"](f"{_warn('Cancelled.', ctx['use_color'])}\n")
+                return 0
+        def progress(event):
+            if parsed["json"]:
+                return
+            step_name = event["step"]["name"]
+            if event["phase"] == "start":
+                progress_label = _info(f"[{event['index']}/{event['total']}]", ctx["use_color"])
+                ctx["out"](f"{progress_label} {step_name}...\n")
+            else:
+                ctx["out"](f"  {_format_update_all_result(event['result'], ctx['use_color'])}\n")
+
+        results = apply_update_all_plan(plan, ctx["service"], env=ctx.get("env"), runner=ctx["options"].get("runUpdateAll"), progress=progress)
+        failed = [row for row in results if row.get("returncode") != 0]
+        message = "Applied workstation update plan" if not failed else "Workstation update plan completed with failures"
+        if parsed["json"]:
+            _write_json(ctx, _json_success("update.all", message, plan=plan, results=results, failed=len(failed)))
+        else:
+            ctx["out"](f"{_success(message, ctx['use_color']) if not failed else _warn(message, ctx['use_color'])}\n")
+        return 1 if failed else 0
     json_flag = parsed["json"]
     current_version = str(ctx.get("version") or "").strip()
     release_fetcher = ctx["options"].get("fetchLatestRelease") or fetch_latest_release

package/src/cli_helpers.py

@@ -250,11 +250,10 @@ def _collect_native_handoff_transcript_paths(session):
 
 
 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
+    if native_paths:
+        return native_paths[0]
+    return _latest_launch_transcript_path(session)
 
 
 def _collect_handoff_text_fragments(value):
@@ -281,6 +280,10 @@ def _collect_handoff_text_fragments(value):
 def _jsonl_record_to_handoff_text(record):
     if not isinstance(record, dict):
         return None
+    if record.get("type") == "response_item":
+        record = record.get("payload")
+        if not isinstance(record, dict):
+            return None
     message = record.get("message") if isinstance(record.get("message"), dict) else {}
     role = (
         message.get("role")
@@ -289,6 +292,8 @@ def _jsonl_record_to_handoff_text(record):
         or record.get("sender")
         or "entry"
     )
+    if role not in ("user", "assistant"):
+        return None
     text_sources = []
     for key in ("content", "text", "payload"):
         if key in record:

package/src/context_store.py

@@ -3,6 +3,7 @@ import os
 import shlex
 import subprocess
 from datetime import datetime
+from urllib.parse import quote, unquote
 
 from .errors import CdxError
 from .fs_utils import atomic_write
@@ -42,12 +43,43 @@ def get_context_path(base_dir, cwd=None):
     return os.path.join(_context_dir(base_dir, cwd), "context.md")
 
 
+def get_global_context_path(base_dir):
+    return os.path.join(base_dir, "contexts", "global", "context.md")
+
+
+def get_named_project_context_path(base_dir, project):
+    return os.path.join(base_dir, "contexts", "projects", quote(project, safe=""), "context.md")
+
+
+def list_named_project_contexts(base_dir):
+    root = os.path.join(base_dir, "contexts", "projects")
+    try:
+        names = sorted(os.listdir(root))
+    except FileNotFoundError:
+        return []
+    rows = []
+    for name in names:
+        path = os.path.join(root, name, "context.md")
+        if not os.path.isfile(path):
+            continue
+        rows.append({
+            "scope": "project",
+            "project": unquote(name),
+            "path": path,
+            "bytes": os.path.getsize(path),
+        })
+    return rows
+
+
 def get_context_meta_path(base_dir, cwd=None):
     return os.path.join(_context_dir(base_dir, cwd), "meta.json")
 
 
 def read_context(base_dir, cwd=None):
-    path = get_context_path(base_dir, cwd)
+    return read_context_path(get_context_path(base_dir, cwd))
+
+
+def read_context_path(path):
     try:
         with open(path, encoding="utf-8") as handle:
             return handle.read()
@@ -56,7 +88,10 @@ def read_context(base_dir, cwd=None):
 
 
 def write_context(base_dir, content, cwd=None):
-    path = get_context_path(base_dir, cwd)
+    return write_context_path(get_context_path(base_dir, cwd), content)
+
+
+def write_context_path(path, content):
     _ensure_dir(os.path.dirname(path))
     atomic_write(path, content.rstrip() + "\n", mode=0o644)
     return {
@@ -66,20 +101,40 @@ def write_context(base_dir, content, cwd=None):
     }
 
 
+def append_context(base_dir, note, cwd=None):
+    return append_context_path(get_context_path(base_dir, cwd), note)
+
+
+def append_context_path(path, note):
+    note = str(note or "").strip()
+    if not note:
+        raise CdxError("Memory append requires text.")
+    current = read_context_path(path).rstrip()
+    content = f"{current}\n{note}" if current else note
+    return write_context_path(path, content)
+
+
 def init_context(base_dir, cwd=None):
-    current = read_context(base_dir, cwd)
+    return init_context_path(get_context_path(base_dir, cwd))
+
+
+def init_context_path(path):
+    current = read_context_path(path)
     if current.strip():
         return {
-            "path": get_context_path(base_dir, cwd),
+            "path": path,
             "created": False,
             "bytes": len(current.encode("utf-8")),
         }
-    result = write_context(base_dir, DEFAULT_CONTEXT_TEMPLATE, cwd)
+    result = write_context_path(path, DEFAULT_CONTEXT_TEMPLATE)
     return {**result, "created": True}
 
 
 def clear_context(base_dir, cwd=None):
-    path = get_context_path(base_dir, cwd)
+    return clear_context_path(get_context_path(base_dir, cwd))
+
+
+def clear_context_path(path):
     try:
         os.remove(path)
         removed = True
@@ -89,7 +144,11 @@ def clear_context(base_dir, cwd=None):
 
 
 def edit_context(base_dir, cwd=None, editor=None, env=None, spawn_sync=None):
-    result = init_context(base_dir, cwd)
+    return edit_context_path(get_context_path(base_dir, cwd), editor=editor, env=env, spawn_sync=spawn_sync)
+
+
+def edit_context_path(path, editor=None, env=None, spawn_sync=None):
+    result = init_context_path(path)
     path = result["path"]
     env = env or os.environ
     editor = editor or env.get("VISUAL") or env.get("EDITOR")

package/src/health.py

@@ -1,6 +1,8 @@
 import json
 import os
+import re
 import shutil
+import subprocess
 import sys
 import tempfile
 from datetime import datetime, timezone
@@ -42,6 +44,8 @@ def collect_health_report(service, base_dir, env=None, spawn_sync=None):
         path = shutil.which(command, path=env.get("PATH"))
         status = "OK" if path else "WARN"
         issues.append(_issue(status, f"{command}_cli", f"{command} CLI {'found' if path else 'not found'}", path))
+        if path:
+            issues.append(_provider_cli_version_issue(command, path, env, spawn_sync))
 
     rtk_path = shutil.which("rtk", path=env.get("PATH"))
     issues.append(_issue(
@@ -95,6 +99,66 @@ def collect_health_report(service, base_dir, env=None, spawn_sync=None):
     return {"base_dir": base_dir, "issues": issues, "summary": summarize_health(issues)}
 
 
+def _provider_cli_version_issue(command, path, env, spawn_sync=None):
+    result = _run_version_command(command, env, spawn_sync)
+    raw = (result.get("stdout") or result.get("stderr") or "").strip()
+    version = _extract_version(raw)
+    detail = {
+        "command": command,
+        "path": path,
+        "version": version,
+        "raw": raw,
+        "capabilities": _provider_capability_hints(command),
+    }
+    if version:
+        return _issue("OK", f"{command}_cli_version", f"{command} CLI version detected: {version}", detail)
+    return _issue("WARN", f"{command}_cli_version", f"{command} CLI version could not be detected", detail)
+
+
+def _run_version_command(command, env, spawn_sync=None):
+    try:
+        if spawn_sync:
+            result = spawn_sync(command, ["--version"], {"env": env, "timeout": 5})
+            if isinstance(result, dict):
+                return result
+            return {
+                "stdout": getattr(result, "stdout", "") or "",
+                "stderr": getattr(result, "stderr", "") or "",
+            }
+        completed = subprocess.run(
+            [command, "--version"],
+            env=env,
+            capture_output=True,
+            text=True,
+            timeout=5,
+            check=False,
+        )
+        return {"stdout": completed.stdout or "", "stderr": completed.stderr or ""}
+    except (OSError, subprocess.TimeoutExpired):
+        return {"stdout": "", "stderr": ""}
+
+
+def _extract_version(text):
+    match = re.search(r"\b(\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?)\b", text or "")
+    return match.group(1) if match else None
+
+
+def _provider_capability_hints(command):
+    if command == "codex":
+        return [
+            "version_inventory",
+            "provider_memory_import_surfaces_may_exist_in_recent_codex",
+            "provider_memory_is_not_modified_by_cdx_memory",
+        ]
+    if command == "claude":
+        return [
+            "version_inventory",
+            "project_memory_and_stream_json_diagnostics_may_exist_in_recent_claude_code",
+            "provider_memory_is_not_modified_by_cdx_memory",
+        ]
+    return ["version_inventory"]
+
+
 def _codex_auth_issues(session, diag):
     name = session["name"]
     identity = diag.get("account_email") or diag.get("observed_account") or "unknown account"

package/src/session_service.py

@@ -44,6 +44,7 @@ RESERVED_SESSION_NAMES = {
     "label",
     "login",
     "logout",
+    "memory",
     "model",
     "mv",
     "next",

package/src/update_all.py

@@ -0,0 +1,184 @@
+"""Inventory and apply the safe, known updates for a CDX workstation."""
+
+import json
+import os
+import re
+import shutil
+import subprocess
+
+from .config import PROVIDER_ANTIGRAVITY, PROVIDER_CLAUDE, PROVIDER_CODEX, PROVIDER_OLLAMA
+
+_TOOLS = (
+    (PROVIDER_CODEX, "codex", None, ["codex", "update"]),
+    (PROVIDER_CLAUDE, "claude", "claude", ["brew", "upgrade", "--cask", "claude"]),
+    (PROVIDER_ANTIGRAVITY, "agy", "antigravity", ["brew", "upgrade", "--cask", "antigravity"]),
+    (PROVIDER_OLLAMA, "ollama", "ollama", ["brew", "upgrade", "ollama"]),
+    ("rtk", "rtk", "rtk", ["brew", "upgrade", "rtk"]),
+)
+_PONYTAIL_URL = "https://github.com/DietrichGebert/ponytail.git"
+
+
+def _which(command, env):
+    path = env.get("PATH")
+    resolved = shutil.which(command, path=path)
+    if resolved or not path:
+        return resolved
+    for directory in path.split(os.pathsep):
+        candidate = os.path.join(directory, command)
+        if os.path.isfile(candidate):
+            return candidate
+    return None
+
+
+def _run(command, env, runner=None, timeout=15):
+    runner = runner or subprocess.run
+    try:
+        result = runner(command, env=env, capture_output=True, text=True, check=False, timeout=timeout)
+    except (OSError, subprocess.TimeoutExpired) as error:
+        return {"returncode": 1, "stdout": "", "stderr": str(error)}
+    if isinstance(result, dict):
+        return result
+    return {"returncode": result.returncode, "stdout": result.stdout or "", "stderr": result.stderr or ""}
+
+
+def _version(command, env, runner):
+    result = _run([command, "--version"], env, runner)
+    text = (result["stdout"] or result["stderr"] or "").strip()
+    match = re.search(r"\b(\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?)\b", text)
+    return match.group(1) if match else None
+
+
+def _npm_latest(package, env, runner):
+    if not _which("npm", env):
+        return None
+    result = _run(["npm", "view", package, "version"], env, runner)
+    value = (result["stdout"] or "").strip()
+    return value if re.fullmatch(r"\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?", value) else None
+
+
+def _newer(latest, current):
+    def key(value):
+        return tuple(int(part) for part in str(value).split("-", 1)[0].split("+", 1)[0].split("."))
+    return bool(latest and current and key(latest) > key(current))
+
+
+def _brew_outdated(env, runner):
+    if not _which("brew", env):
+        return {}
+    result = _run(["brew", "outdated", "--json=v2"], env, runner, timeout=30)
+    try:
+        payload = json.loads(result["stdout"])
+    except (TypeError, ValueError):
+        return {}
+    rows = {}
+    for group in ("formulae", "casks"):
+        for item in payload.get(group, []):
+            rows[item.get("name")] = item
+    return rows
+
+
+def _brew_cask_for_path(path):
+    match = re.search(r"/Caskroom/([^/]+)/", os.path.realpath(path or ""))
+    return match.group(1) if match else None
+
+
+def _ponytail_revision(auth_home, env=None, runner=None):
+    try:
+        with open(os.path.join(auth_home, "config.toml"), encoding="utf-8") as handle:
+            text = handle.read()
+    except OSError:
+        text = ""
+    match = re.search(r'\[marketplaces\.ponytail\].*?last_revision\s*=\s*"([0-9a-f]+)"', text, re.S)
+    if match:
+        return match.group(1)
+    cache = os.path.join(auth_home, ".tmp", "marketplaces", "ponytail")
+    result = _run(["git", "-C", cache, "rev-parse", "HEAD"], env or os.environ, runner)
+    revision = (result["stdout"] or "").strip()
+    return revision if re.fullmatch(r"[0-9a-f]{40}", revision) else None
+
+
+def collect_update_all_plan(service, env=None, runner=None):
+    env = dict(env or os.environ)
+    outdated = _brew_outdated(env, runner)
+    items, steps = [], []
+    for name, command, brew_name, update_command in _TOOLS:
+        path = _which(command, env)
+        item = {"name": name, "command": command, "installed": bool(path), "path": path, "version": _version(command, env, runner) if path else None}
+        cask_name = _brew_cask_for_path(path)
+        brew_target = cask_name or brew_name
+        brew_row = outdated.get(brew_target) if brew_target else None
+        if brew_row:
+            command_to_run = ["brew", "upgrade", "--cask", brew_target] if cask_name else update_command
+            item.update({"status": "update_available", "latest_version": brew_row.get("current_version"), "update_command": command_to_run, "package": brew_target})
+            steps.append({"name": name, "command": command_to_run, "env": {}})
+        elif path and name == PROVIDER_CODEX:
+            # Codex owns its installer; it is the only reliable updater across npm, Homebrew and standalone installs.
+            latest = _npm_latest("@openai/codex", env, runner)
+            item.update({"latest_version": latest, "status": "update_available" if _newer(latest, item["version"]) else "up_to_date" if latest else "check_with_native_updater", "update_command": update_command})
+            if item["status"] != "up_to_date":
+                steps.append({"name": name, "command": update_command, "env": {}})
+        else:
+            item["status"] = "up_to_date" if path else "not_installed"
+        items.append(item)
+
+    rtk_available = any(item["name"] == "rtk" and item["installed"] for item in items)
+    missing_rtk = [session["name"] for session in service["list_sessions"]() if not (session.get("launch") or {}).get("rtk")]
+    setup = {"rtk_available": rtk_available, "rtk_missing_sessions": missing_rtk, "ponytail": []}
+    if rtk_available and missing_rtk:
+        steps.append({"name": "enable RTK", "command": None, "sessions": missing_rtk})
+
+    codex_sessions = [session for session in service["list_sessions"]() if session.get("provider") == PROVIDER_CODEX]
+    ponytail_head = None
+    if any(_ponytail_revision(session.get("authHome") or "", env, runner) for session in codex_sessions):
+        remote = _run(["git", "ls-remote", _PONYTAIL_URL, "HEAD"], env, runner)
+        ponytail_head = (remote["stdout"] or "").split("\t", 1)[0].strip() or None
+    for session in codex_sessions:
+        revision = _ponytail_revision(session.get("authHome") or "", env, runner)
+        row = {"session": session["name"], "installed": bool(revision), "revision": revision}
+        if revision:
+            row["latest_revision"] = ponytail_head
+            row["status"] = "update_available" if ponytail_head and not ponytail_head.startswith(revision) else "up_to_date"
+            if row["status"] == "update_available":
+                steps.append({"name": f"update Ponytail ({session['name']})", "command": ["codex", "plugin", "marketplace", "upgrade", "ponytail", "--json"], "env": {"CODEX_HOME": session["authHome"]}})
+        else:
+            row["status"] = "not_installed"
+            marketplace_id = f"ponytail-marketplace:{session['name']}"
+            steps.extend([
+                {"id": marketplace_id, "name": f"add Ponytail marketplace ({session['name']})", "command": ["codex", "plugin", "marketplace", "add", _PONYTAIL_URL], "env": {"CODEX_HOME": session["authHome"]}},
+                {"name": f"install Ponytail ({session['name']})", "command": ["codex", "plugin", "add", "ponytail@ponytail", "--json"], "env": {"CODEX_HOME": session["authHome"]}, "requires": marketplace_id},
+            ])
+        setup["ponytail"].append(row)
+    return {"items": items, "setup": setup, "steps": steps}
+
+
+def apply_update_all_plan(plan, service, env=None, runner=None, progress=None):
+    env = dict(env or os.environ)
+    results = []
+    completed = set()
+    for index, step in enumerate(plan["steps"], start=1):
+        if progress:
+            progress({"phase": "start", "index": index, "total": len(plan["steps"]), "step": step})
+        if step.get("requires") and step["requires"] not in completed:
+            result = {"name": step["name"], "returncode": None, "skipped": True, "blocked_by": step["requires"]}
+            results.append(result)
+            if progress:
+                progress({"phase": "done", "index": index, "total": len(plan["steps"]), "step": step, "result": result})
+            continue
+        if step["command"] is None:
+            for name in step["sessions"]:
+                service["set_launch_settings"](name, {"rtk": True})
+            result = {"name": step["name"], "returncode": 0, "sessions": step["sessions"]}
+            results.append(result)
+            if step.get("id"):
+                completed.add(step["id"])
+            if progress:
+                progress({"phase": "done", "index": index, "total": len(plan["steps"]), "step": step, "result": result})
+            continue
+        result = _run(step["command"], {**env, **step.get("env", {})}, runner, timeout=120)
+        result = {"name": step["name"], "command": step["command"], **result}
+        results.append(result)
+        if result["returncode"] == 0 and step.get("id"):
+            completed.add(step["id"])
+        if progress:
+            progress({"phase": "done", "index": index, "total": len(plan["steps"]), "step": step, "result": result})
+    return results