cdx-manager 0.26.0 → 0.26.1

package/README.md

@@ -4,7 +4,7 @@
 
 <br clear="left"/>
 
-[![License](https://img.shields.io/badge/license-MIT-4C8BF5)](LICENSE) ![Version](https://img.shields.io/badge/version-v0.26.0-4C8BF5) ![Python](https://img.shields.io/badge/python-3.9%2B-3776AB?logo=python&logoColor=white)
+[![License](https://img.shields.io/badge/license-MIT-4C8BF5)](LICENSE) ![Version](https://img.shields.io/badge/version-v0.26.1-4C8BF5) ![Python](https://img.shields.io/badge/python-3.9%2B-3776AB?logo=python&logoColor=white)
 
 **The right AI coding account, when you need it.** CDX Manager keeps your Codex and Claude accounts in separate profiles, shows which ones have quota, and helps you pick the next usable session from your terminal.
 
@@ -78,6 +78,10 @@ cdx run --continue-run RUN_ID --cwd /path/to/repo --prompt "Fix the remaining te
 
 `--continue-run` resumes the exact Claude session or Codex thread and pins the previous run's recorded model and effort, even if the profile settings changed. The profile is inferred from the parent; an explicit session or provider must match. An explicit model or effort must also match. Runs and history record `parent_run_id` and `conversation_id`. Detached continuations use the cdx child supervisor with the same pins. Codex continuation usage is measured between exact transcript snapshots before and after the run, since exec resume can report conversation totals. If either boundary is unavailable, per-run usage stays unknown with `usage_attribution: "continuation_usage_unavailable"` in history instead of counting earlier turns again.
 
+Headless runs, including detached, remote and continued runs, keep their
+conversation identity in run records and history without replacing the profile's
+interactive conversation.
+
 Conservative assumption: a continuation requires a finished Claude or Codex run, a locally available provider transcript, and recorded model and effort settings. Missing runs, profiles, expired sessions, and unavailable settings produce a clear error; the caller can retry without `--continue-run` for a cold run. `--failover` and `--isolate-workspace` cannot be combined with continuation. Capacity recovery and provider model fallback are disabled for continuations so they cannot silently switch model or account. Provider cache retention remains provider-controlled, so resuming does not guarantee a cache hit.
 
 ## Run costs and budgets
@@ -244,8 +248,13 @@ for a fresh credential, and that cleanup works after disconnect and SIGTERM.
 
 `cdx conversation <name> [--conversation ID] [--cursor CURSOR] [--limit N] --json`
 returns a read-only JSON page for the profile's current conversation. An explicit
-conversation ID uses an exact transcript lookup; a profile without a recorded ID
-uses the existing latest-transcript resolver. This fallback is best effort.
+conversation ID uses an exact transcript lookup and never falls back. When the
+profile's recorded ID has no transcript on this host (for example after a remote
+run on another host), or there is no recorded ID, the command uses the existing
+latest local transcript resolver under the profile's auth home. This fallback is
+best effort and does not rewrite the recorded ID. JSON `resolution_method` is
+`conversation_id` for an exact match, `recency` for a local fallback, or `null`
+when no transcript is resolved.
 
 The normal cdx JSON envelope includes `status`, `reason`, `provider`, `session`,
 `entries`, `next_cursor`, and `has_more`. Each entry has exactly `role`

package/VERSION

@@ -1 +1 @@
-0.26.0
+0.26.1

package/changelogs/CHANGELOGS_0_26_1.md

@@ -0,0 +1,21 @@
+# CDX Manager 0.26.1
+
+Release date: 2026-11-03
+
+## Fixes
+
+- Preserve the profile's interactive conversation across local, detached, remote,
+  and continued headless runs. Keep headless Claude identities in run records
+  and history, and skip interactive Codex identity observation for run history.
+  (#103)
+- Let `cdx conversation` use the latest local transcript when the profile's
+  recorded conversation ID has no transcript on this host. Explicit
+  `--conversation` lookups remain exact. Expose `resolution_method` as
+  `conversation_id`, `recency`, or `null`; recency remains best effort. (#103)
+
+## Maintenance
+
+- Record tray companion checksums for v0.26.0.
+  (`c942c9f6fdcfabd1ad0442e46f978da3b548971f`)
+- Record release archive checksums for v0.26.0.
+  (`9a43f53d7294ecb254bd65aea214831bcd1486fb`)

package/changelogs/CHANGELOGS_UNRELEASED.md

@@ -1,5 +1,11 @@
 # Unreleased
 
+## Preserve interactive conversations across headless runs
+
+- Keep fresh Claude run identities in run records and history without changing the profile's interactive conversation. Skip interactive Codex identity observation when recording headless run history, including detached, remote and continued runs.
+- Let `cdx conversation` fall back to the latest local transcript when a profile's recorded ID has no transcript on this host. Explicit `--conversation` lookups remain exact and never fall back. Report `resolution_method` as `conversation_id`, `recency`, or `null`.
+- Cover a remote Claude run followed by local interactive conversation reading, local/continued run identity preservation, missing recorded IDs and missing explicit IDs.
+
 ## Antigravity quota and run usage
 
 - Install a local Antigravity statusLine command in new profiles and on interactive launch, merging settings and relaying the original stdin to any existing command so its output is preserved. Store only the reading time, plan tier and allowlisted quota fields in an atomic mode-600 profile file; never access Google internal endpoints or antigravity-oauth-token.

package/checksums/release-archives.json

@@ -793,6 +793,17 @@
         "x86_64-pc-windows-msvc": "32889713859cf23d4d82647638d909d62075b92d8e6571e32118ebfa208d81b2",
         "x86_64-unknown-linux-musl": "9e94b799fe4b01d95aeb172c1eba28dc011be69cc2b39b5743f0d81986eaa80f"
       }
+    },
+    "v0.26.0": {
+      "github_tarball_sha256": "09903dc1c2bcf3c35ad0d52d1f5af2aa9f65584c07f508986dbf6829737d5eb2",
+      "github_zip_sha256": "e1aa5af189e9591f49aa1873c90cfb3365d3b3e86b4993866599498c21a0f979",
+      "tray_assets": {
+        "aarch64-apple-darwin": "1ee383b3ba75b9a19fee981d39ae8d26228e855933392ceb3d8fa55498da238b",
+        "aarch64-unknown-linux-musl": "832aa41132f900e446adaa8e23072094b6ba42d82315dac9ccd5f75ae623f172",
+        "x86_64-apple-darwin": "791898c594fcb2a0009653b9b50732698c0c451169cf1847a613a8d3e3ab3300",
+        "x86_64-pc-windows-msvc": "24ba2a8ed13de1bdc0401661a51c105c2c7ed186f3b17a871cd721ac8adf4916",
+        "x86_64-unknown-linux-musl": "200c8ab9465625784a32ae326d923bca97b5f9616809c43cb5dc73e0e5d9ca17"
+      }
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cdx-manager",
-  "version": "0.26.0",
+  "version": "0.26.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.26.0"
+version = "0.26.1"
 description = "Terminal session manager for Codex and Claude accounts."
 readme = "README.md"
 requires-python = ">=3.9.2"

package/src/commands/conversation.py

@@ -28,7 +28,7 @@ def handle_conversation(rest, ctx):
     page = read_conversation(
         session["provider"], _get_auth_home(session),
         conversation_id=parsed["conversation"] or (session.get("conversation") or {}).get("id"),
-        cursor=parsed["cursor"], limit=limit,
+        cursor=parsed["cursor"], limit=limit, fallback_to_recency=not parsed["conversation"],
     )
     _write_json(ctx, _json_success("conversation", "Conversation page loaded.", session=session["name"], **page))
     return 0

package/src/commands/runs.py

@@ -763,10 +763,8 @@ def handle_run(rest, ctx):
             # since nothing else frees their slot.
             _reconcile_background_runs(ctx)
             _run_registry(ctx).check_capacity(max_parallel)
-        # Claude needs its conversation id before the spec is built; Codex
-        # records its own afterwards, from the rollout. Without this a headless
-        # Claude run left the session with no identity and `cdx resume` fell
-        # back to recency for Claude while working by id for Codex.
+        # Fresh runs carry their own identity; only interactive launches update
+        # the profile's current conversation. Continuations use the parent run.
         if not parsed.get("continue_run"):
             session = ctx["service"]["begin_conversation"](session["name"])
         run_session = {

package/src/conversation.py

@@ -101,25 +101,31 @@ def _anchor(handle, offset):
 
 
 def read_conversation(provider, auth_home=None, *, conversation_id=None, started_at=None,
-                      terminal_transcript=None, cursor=None, limit=100):
+                      terminal_transcript=None, cursor=None, limit=100, fallback_to_recency=False):
     """Return a JSON-serializable page; pass next_cursor back unchanged to poll.
 
     Entries follow file/block order. Cursors bind a byte offset and block index
     to the resolved file; reset_required means discard the old cursor and page
     again from the beginning. Incomplete trailing lines are retried next time.
+    Only implicit session identities may opt into fallback_to_recency.
     Tool bodies and reasoning blocks are never returned. Ollama PTY captures
     cannot reliably distinguish roles and are explicitly unsupported.
     """
     if not isinstance(limit, int) or isinstance(limit, bool) or not 1 <= limit <= 1000:
         raise CdxError("Conversation limit must be an integer between 1 and 1000.")
-    page = {"status": "ok", "reason": None, "provider": provider, "entries": [], "next_cursor": None, "has_more": False}
+    page = {"status": "ok", "reason": None, "provider": provider, "entries": [], "next_cursor": None, "has_more": False,
+            "resolution_method": None}
     if provider not in PROVIDERS or provider == "ollama":
         return {**page, "status": "unsupported", "reason": "no_structured_transcript_reader"}
     # An explicit conversation must never fall back to an unrelated recent file.
     if conversation_id:
         path = conversation_transcript(provider, auth_home, conversation_id)
+        if path:
+            page["resolution_method"] = "conversation_id"
+        elif fallback_to_recency:
+            path, page["resolution_method"] = resolve_transcript(provider, auth_home)
     else:
-        path, _match = resolve_transcript(provider, auth_home, started_at, terminal_transcript=terminal_transcript)
+        path, page["resolution_method"] = resolve_transcript(provider, auth_home, started_at, terminal_transcript=terminal_transcript)
     if not path:
         return {**page, "status": "unavailable", "reason": "transcript_not_found"}
     try:

package/src/session_service.py

@@ -689,12 +689,13 @@ def record_launch_history(store, name, payload):
         **payload,
     }
     store["append_launch_history"](entry)
-    _observe_codex_conversation(store, session)
+    if entry.get("action") != "run":
+        _observe_codex_conversation(store, session)
     return entry
 
 
 def _observe_codex_conversation(store, session):
-    """Read Codex's conversation id back after a run, if it wrote one.
+    """Read Codex's conversation id back after an interactive launch.
 
     Codex mints the id itself, so unlike Claude this can only be observed once
     the rollout exists. Failing to find one is normal and leaves the session on
@@ -938,26 +939,14 @@ def _conversation_identity_for_launch(session):
 
 
 def begin_conversation(store, name):
-    """Mint the conversation id a Claude run is about to carry, and store it.
-
-    `launch_session` does this for interactive launches, but a headless run
-    never goes through it, so `cdx run` used to leave Claude sessions with no
-    identity at all - `cdx resume` then fell back to recency for Claude while
-    working by id for Codex, which records its own after the fact. Same shape
-    for both providers now: whatever ran last is what resume names.
-
-    Returns the updated session, or the unchanged one for providers that mint
-    nothing here.
-    """
+    """Return a run-local identity without changing the interactive session."""
     session = store["get_session"](name)
     if not session:
         raise CdxError(f"Unknown session: {name}")
     conversation = _conversation_identity_for_launch(session)
     if not conversation:
         return session
-    return store["update_session"](name, lambda s: {
-        **s, "conversation": conversation, "updatedAt": _local_now_iso(),
-    })
+    return {**session, "conversation": conversation}
 
 
 def mark_conversation_rescued(store, name, conversation_id):