cdx-manager 0.26.8 → 0.26.9

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.8-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.9-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.
 

package/VERSION

@@ -1 +1 @@
-0.26.8
+0.26.9

package/changelogs/CHANGELOGS_0_26_9.md

@@ -0,0 +1,16 @@
+# CDX Manager 0.26.9
+
+Release date: 2026-11-08
+
+## Fixes
+
+- Resolve the conversation of a live interactive Codex process from the
+  rollout file it holds open (#126, `abb19e0`). `cdx conversation <profile>
+  --pid PID` no longer answers `native_conversation_identity_unavailable`
+  for an interactive Codex session whose native process writes an exact
+  rollout; it still refuses workspace or recency guesses.
+
+## Maintenance
+
+- Record tray companion checksums for v0.26.8 (`e04fae8`).
+- Record release archive checksums for v0.26.8 (`f41f2b3`).

package/checksums/release-archives.json

@@ -881,6 +881,17 @@
         "x86_64-pc-windows-msvc": "098c27b535f041b72b6aac89d2c34464a986178be881336b89f99c8dfb5fdb5d",
         "x86_64-unknown-linux-musl": "195737be7f25dc30bab676f53aed2c426612aee55de4cfc95a55a5b2d8ca9b76"
       }
+    },
+    "v0.26.8": {
+      "github_tarball_sha256": "528b9147a815bbe8565e63dc7089951691427cdbf0ec7c2c4a5740029c68d612",
+      "github_zip_sha256": "1f829aa5f889663e4b974d5ad91a3160418252d9349afd5899afaa27084cf4cb",
+      "tray_assets": {
+        "aarch64-apple-darwin": "947ca5e15d9ef9db080eb33e1a09376420118e4af0c9fc049c12d2e8ae9649c5",
+        "aarch64-unknown-linux-musl": "004e423dcff66cef815140ca96d516089306bc6e8e940a4d2f6f657eeb2f9f6b",
+        "x86_64-apple-darwin": "b5780dcff73502155fc8c24f1b3bdd9f18cea129c7a24c017d40168ee5ba8867",
+        "x86_64-pc-windows-msvc": "f68d4fb19c4e94b31662cd46eb9ae8aa2b3e4bf53d3bde4fce1b540df7719e26",
+        "x86_64-unknown-linux-musl": "ada7fcbd0c9202cad8a5e55b60a6b85af34210157a4d7352451bcb95bbb103cd"
+      }
     }
   }
 }

package/docs/cli.md

@@ -710,48 +710,57 @@ Process-selected pages expose:
 
 | Field | Current contract |
 | --- | --- |
-| `resolution_status` | `unknown` until native selected-conversation evidence is available |
-| `resolution_method` | `null`; kernel process identity alone is not a conversation resolution method |
-| `conversation_id` | `null`; no candidate or guessed ID is exposed |
+| `resolution_status` | `resolved` for verified native rollout evidence, otherwise `unknown` |
+| `resolution_method` | `process_open_rollout` when resolved, otherwise `null` |
+| `conversation_id` | Native `session_meta.payload.id`, checked against the open rollout filename |
 | `process_identity` | Opaque Linux lifetime guard when process validation succeeds |
-| `reason` | Explicit evidence boundary or process validation failure |
-
-**Current measured boundary:** process-to-selected-conversation resolution is not
-available. Even a sole open writable rollout proves only that a process owns a
-thread. During a TUI conversation switch it may belong to a retained thread while
-the selected thread has no rollout yet. Resume argv, session/profile state, cwd,
-mtime, a unique new transcript, and fuzzy text also cannot prove the current
-selection. This implementation deliberately returns
-`native_conversation_identity_unavailable` after validating a live Codex process;
-it does not claim that an open file establishes the selected conversation.
-Remote-ops must treat this as an explicit unknown, never retry via recency.
-
-Process mode returns `status: "unavailable"`, empty entries, null conversation ID
-and no cursors. With `--cursor` or `--before`, it returns `reset_required` and no
-entries: a cursor from an explicit-ID or recency lookup cannot cross into process
-mode. No process cursor is issued until it can be bound to both a verified process
-lifetime and a native conversation selection/generation. Existing explicit-ID,
-recency, forward, tail and backward pagination contracts remain unchanged.
-
-Only Linux `/proc` process identity is currently supported. Each validation reads
-at most 8 KiB each from process `stat`, `status` and kernel `boot_id`, twice, plus
-the executable symlink/stat. The guard includes PID, start ticks, boot ID, all
+| `reason` | `null` on success; explicit evidence boundary or process validation failure otherwise |
+
+On Linux, CDX inspects only the supplied PID's open descriptors. A unique writable
+`rollout-…-UUID.jsonl` under the selected profile's `sessions/` directory supplies
+the native identity. Its first record must be a complete `session_meta` with a
+matching UUID and `source: "cli"`. Duplicate descriptors for the same file count
+once; read-only descriptors do not establish the active writer. Multiple distinct
+writable rollouts return `ambiguous_native_rollouts`, even if one is newer. A
+rollout outside the selected profile returns `profile_boundary_mismatch` before
+its contents are read. Resolved symlinks must remain inside the profile, including
+the `sessions/` root. No workspace, mtime, saved resume ID or recency fallback is
+used, even if `fallback_to_recency=True` is supplied through Python.
+
+This is a snapshot of the process's sole native rollout writer. A rollout must
+already exist and remain open for writing; a fresh thread before its first
+rollout returns `native_conversation_identity_unavailable`. A retained writer
+and another open writer are ambiguous. The resolver does not infer TUI focus
+from file timestamps or claim to observe selection changes without a writer
+change. Consumers must treat unknown as unknown and must not retry via recency.
+
+The exact open file's device/inode is checked against its profile path before
+reading. CDX rechecks the lifetime guard and native rollout evidence before and
+after the message read. A detected exit, PID reuse, switch, replacement or lost
+proof discards all entries. These checks are snapshots, not an atomic provider
+selection subscription; the process can change after the final check.
+
+Resolved requests return `status: "ok"` and normalized entries, including support
+for `--tail`. Unknown requests return `status: "unavailable"`, no entries and a
+null conversation ID. Process pagination remains disabled: no cursors are issued,
+`has_more` is false, and `--cursor` or `--before` returns `reset_required` without
+entries. Poll again using the retained process identity and `--tail`; an
+explicit-ID or recency cursor cannot cross into process mode. Existing explicit-ID
+and recency pagination contracts are unchanged.
+
+Only Linux `/proc` and interactive Codex are supported. Each evidence pass reads
+at most 8 KiB each from `stat`, `status`, kernel `boot_id` and each candidate's
+`fdinfo`, enumerates at most 512 descriptors, and reads at most 64 KiB of each
+candidate's metadata header. Message reads use the existing bounded conversation
+reader and redaction. The lifetime guard includes PID, start ticks, boot ID, all
 four target UIDs and executable device/inode. Wrong user, a non-`codex` executable,
 dead/reused PID, inaccessible/oversized/malformed evidence, or unsupported
-provider/platform fails closed. Other reasons include `unrelated_user`,
+provider/platform fails closed. Reasons include `unrelated_user`,
 `unrelated_process`, `process_not_running`, `process_identity_changed`,
-`native_evidence_unavailable`, `evidence_limit`, and
-`unsupported_process_resolution`. No argv, environment, credential store,
-transcript file, directory scan or history database is read in process mode.
-A process identity does not prove profile ownership; missing native profile and
-thread association therefore remains unknown even for an existing profile.
-
-The smallest required launch-time tracking is a provider-native event containing
-the selected conversation ID on fresh start, resume and every selection change.
-The launcher must bind each event atomically to the child's boot ID/PID/start ticks,
-profile and a monotonic selection generation; invalidate it on exit. A future
-resolver can consume that bounded record and bind cursors to the same generation.
-An original resume ID or launch timestamp alone is insufficient. No launch/resume
-flags or dependencies are changed here; implementing this requires a verified
-provider lifecycle event source, which the inspected interactive interface does
-not supply. See the mission fragment for the local native probe and Tower checks.
+`native_evidence_unavailable`, `invalid_native_rollout`, `evidence_changed`,
+`evidence_limit`, and `unsupported_process_resolution`. No argv, environment,
+credential store, descendant traversal, profile transcript search or history
+database participates in process resolution. No launch flags or dependencies
+change. Tower's authenticated TUI still requires a measured comparison of the
+returned UUID with its selected native conversation after launch, resume and
+switch, especially with concurrent sessions.

package/package.json

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

package/src/conversation.py

@@ -407,20 +407,33 @@ def read_conversation(provider, auth_home=None, *, conversation_id=None, started
         raise CdxError("Process selection cannot be combined with conversation, cwd, since or terminal transcript selection.")
     from .process_conversation import resolve_process_conversation
 
-    resolution = resolve_process_conversation(provider, auth_home, pid=pid, process_identity=process_identity)
+    resolution, evidence = resolve_process_conversation(provider, auth_home, pid=pid, process_identity=process_identity)
     page = {"status": "unavailable", "provider": provider, "entries": [], "next_cursor": None,
             "has_more": False, "resolution_scope": None, **resolution}
     if tail is not None or before is not None:
         page["before_cursor"] = None
-    # No process-bound cursor is issued until native selected-thread evidence
-    # exists. Never replay an explicit-ID or recency cursor through this mode.
+    # Process pagination remains disabled: an unbound explicit-ID or recency
+    # cursor must never cross into this mode.
     if cursor is not None or before is not None:
-        page["status"] = "reset_required"
-    return page
+        return {**page, "status": "reset_required"}
+    if evidence is None:
+        return page
+    selected = _read_conversation_page(provider, auth_home, limit=limit, tail=tail,
+                                       _transcript=evidence[1], _file_identity=evidence[2])
+    checked, current = resolve_process_conversation(provider, auth_home, process_identity=resolution["process_identity"])
+    if current != evidence or checked != resolution:
+        return {**page, **checked, "resolution_status": "unknown", "resolution_method": None,
+                "conversation_id": None, "reason": checked["reason"] or "evidence_changed"}
+    if selected["status"] != "ok":
+        return {**page, "resolution_status": "unknown", "resolution_method": None,
+                "conversation_id": None, "reason": selected["reason"]}
+    return {**selected, **resolution, "reason": None, "next_cursor": None, "before_cursor": None,
+            "has_more": False}
 
 
 def _read_conversation_page(provider, auth_home=None, *, conversation_id=None, started_at=None,
-                      terminal_transcript=None, cursor=None, limit=100, fallback_to_recency=False, tail=None, before=None, cwd=None):
+                      terminal_transcript=None, cursor=None, limit=100, fallback_to_recency=False, tail=None, before=None, cwd=None,
+                      _transcript=None, _file_identity=None):
     """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
@@ -440,7 +453,7 @@ def _read_conversation_page(provider, auth_home=None, *, conversation_id=None, s
             datetime.fromisoformat(started_at.replace("Z", "+00:00"))
         except (ValueError, AttributeError, TypeError):
             raise CdxError("Conversation --since must be an ISO timestamp.") from None
-    scope = {"cwd": os.path.realpath(os.path.expanduser(cwd or os.getcwd())), "since": started_at}
+    scope = None if _transcript is not None else {"cwd": os.path.realpath(os.path.expanduser(cwd or os.getcwd())), "since": started_at}
     page = {"status": "ok", "reason": None, "provider": provider, "entries": [], "next_cursor": None, "has_more": False,
             "resolution_method": None, "resolution_scope": None}
     if tail is not None or before is not None:
@@ -448,7 +461,9 @@ def _read_conversation_page(provider, auth_home=None, *, conversation_id=None, s
     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:
+    if _transcript is not None:
+        path = _transcript
+    elif conversation_id:
         path = conversation_transcript(provider, auth_home, conversation_id)
         if path:
             page["resolution_method"] = "conversation_id"
@@ -464,6 +479,8 @@ def _read_conversation_page(provider, auth_home=None, *, conversation_id=None, s
     try:
         with open(path, "rb") as handle:
             stat = os.fstat(handle.fileno())
+            if _file_identity is not None and (stat.st_dev, stat.st_ino) != _file_identity:
+                return {**page, "status": "unavailable", "reason": "evidence_changed"}
             identity = hashlib.sha256(f"{provider}:{os.path.realpath(path)}:{stat.st_dev}:{stat.st_ino}".encode()).hexdigest()
             if tail is not None or before is not None:
                 return _read_tail(handle, stat, identity, provider, page, tail if tail is not None else limit, before)

package/src/process_conversation.py

@@ -1,12 +1,14 @@
-"""Bounded Linux process identity, without guessing a selected conversation.
+"""Bounded Linux process identity and profile-scoped native rollout evidence.
 
 No argv, environment, credential stores, transcript searches or parent/child
 heuristics participate in identity resolution.
 """
 
 import hashlib
+import json
 import os
 import re
+import stat
 import sys
 from pathlib import Path
 
@@ -46,8 +48,66 @@ def _process(pid):
     return f"linux:{pid}:{digest}"
 
 
+def _rollout(pid, auth_home):
+    """Identify a sole writable rollout; multiple native writers are ambiguous."""
+    home = Path(auth_home).resolve()
+    sessions = (home / "sessions").resolve()
+    if not sessions.is_relative_to(home):
+        raise _Unknown("profile_boundary_mismatch")
+    candidates = set()
+    root = PROC_ROOT / str(pid)
+    with os.scandir(root / "fd") as descriptors:
+        for count, descriptor in enumerate(descriptors):
+            if count >= 512:
+                raise _Unknown("evidence_limit")
+            try:
+                target = os.readlink(descriptor.path)
+            except FileNotFoundError:
+                continue  # Unrelated descriptors can close during enumeration.
+            name = Path(target).name
+            if not name.startswith("rollout-") or ".jsonl" not in name:
+                continue
+            flags = next(line.split()[1] for line in _bounded(root / "fdinfo" / descriptor.name).splitlines()
+                         if line.startswith("flags:"))
+            if int(flags, 8) & os.O_ACCMODE not in (os.O_WRONLY, os.O_RDWR):
+                continue
+            path = Path(target).resolve()
+            if not path.is_relative_to(sessions):
+                raise _Unknown("profile_boundary_mismatch")
+            match = re.fullmatch(r"rollout-.*(" + _UUID + r")\.jsonl", name)
+            if not match:
+                raise _Unknown("invalid_native_rollout")
+            file_stat = os.stat(descriptor.path)
+            path_stat = path.stat()
+            file_identity = (file_stat.st_dev, file_stat.st_ino)
+            if not stat.S_ISREG(file_stat.st_mode) or file_identity != (path_stat.st_dev, path_stat.st_ino):
+                raise _Unknown("evidence_changed")
+            # Read only the metadata header of the exact open file, never a
+            # transcript found by scanning the profile or matching a workspace.
+            with open(descriptor.path, "rb") as handle:
+                opened = os.fstat(handle.fileno())
+                if (opened.st_dev, opened.st_ino) != file_identity:
+                    raise _Unknown("evidence_changed")
+                header = handle.readline(65537)
+            if len(header) > 65536:
+                raise _Unknown("evidence_limit")
+            if not header.endswith(b"\n"):
+                raise _Unknown("invalid_native_rollout")
+            metadata = json.loads(header)
+            payload = metadata.get("payload")
+            if (metadata.get("type") != "session_meta" or not isinstance(payload, dict)
+                    or payload.get("id") != match[1] or payload.get("source") != "cli"):
+                raise _Unknown("invalid_native_rollout")
+            candidates.add((match[1], path, file_identity))
+    if len(candidates) > 1:
+        raise _Unknown("ambiguous_native_rollouts")
+    if not candidates:
+        raise _Unknown("native_conversation_identity_unavailable")
+    return candidates.pop()
+
+
 def resolve_process_conversation(provider, auth_home, *, pid=None, process_identity=None):
-    """Return explicit unknown when the native selected-thread link is absent.
+    """Return public resolution fields and private exact-file evidence, if present.
 
     A bare PID means the process alive *now*. Persist process_identity to reject
     reuse on subsequent calls. The identity is an opaque guard, not a secret or
@@ -56,26 +116,25 @@ def resolve_process_conversation(provider, auth_home, *, pid=None, process_ident
     result = {"resolution_status": "unknown", "resolution_method": None,
               "conversation_id": None, "process_identity": None, "reason": None}
     if provider != "codex" or sys.platform != "linux":
-        return {**result, "reason": "unsupported_process_resolution"}
+        return {**result, "reason": "unsupported_process_resolution"}, None
     if process_identity is not None:
         match = _IDENTITY.fullmatch(process_identity) if isinstance(process_identity, str) and len(process_identity) <= 100 else None
         if not match or pid is not None:
-            return {**result, "reason": "invalid_process_identity"}
+            return {**result, "reason": "invalid_process_identity"}, None
         pid = int(match[1])
     if type(pid) is not int or not 0 < pid < 2**31 or not auth_home:
-        return {**result, "reason": "invalid_process_identity"}
+        return {**result, "reason": "invalid_process_identity"}, None
     try:
         identity = _process(pid)
         if process_identity is not None and identity != process_identity:
             raise _Unknown("process_identity_changed")
         result["process_identity"] = identity
-        if _process(pid) != identity:
+        evidence = _rollout(pid, auth_home)
+        if _process(pid) != identity or _rollout(pid, auth_home) != evidence:
             raise _Unknown("evidence_changed")
-        # Even a sole writable rollout may belong to a retained thread while
-        # another thread is selected but has not created its rollout. Neither
-        # that descriptor nor resume argv is a native selected-thread event.
-        return {**result, "reason": "native_conversation_identity_unavailable"}
+        return {**result, "resolution_status": "resolved", "resolution_method": "process_open_rollout",
+                "conversation_id": evidence[0]}, evidence
     except _Unknown as exc:
-        return {**result, "reason": str(exc)}
-    except (OSError, ValueError, KeyError, IndexError, TypeError, StopIteration, UnicodeError, RecursionError):
-        return {**result, "reason": "native_evidence_unavailable"}
+        return {**result, "reason": str(exc)}, None
+    except (OSError, ValueError, KeyError, IndexError, TypeError, StopIteration, UnicodeError, RecursionError, AttributeError):
+        return {**result, "reason": "native_evidence_unavailable"}, None