cdx-manager 0.25.9 → 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.25.9-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.
 
@@ -42,6 +42,27 @@ cdx work
 
 CDX checks authentication before interactive launches. Handoff keeps the source transcript in place and asks the receiving agent to verify the conversation and workspace before acting. No account switch or prompt submission happens just because you run `cdx next`.
 
+## Automatic mission concurrency per profile
+
+```bash
+cdx set work --max-parallel 2
+cdx show work
+cdx unset work --max-parallel
+```
+
+`--max-parallel` accepts an integer from 0 to 5 and stores `launch.max_parallel`
+next to `priority` and `policy`. Zero excludes the profile from automatic
+missions. An absent value adds no profile-specific ceiling: the scheduling
+client applies its own rule. Existing configurations need no migration.
+`cdx unset work --all` also removes the limit.
+
+The scheduling client is responsible for enforcing this metadata. It is
+separate from the existing per-command `cdx run --max-parallel` limit.
+`cdx --json` (also `cdx ls --json`) includes the optional field in each
+session's `launch` object; `cdx status --json` exposes `max_parallel` on each
+row (`null` when absent). `cdx show` is an alias for `cdx config` and displays
+`Max parallel` as `default` when unset.
+
 ## Cache efficiency and fix rounds
 
 `cdx history --json` records uncached input, cache reads, cache writes, output tokens, and `usage.cache_hit_ratio` beside the existing token totals. The ratio is cache reads divided by all input tokens, excluding output. Missing provider splits stay `null`, and text views show `cache n/d` instead of claiming a zero hit rate.
@@ -57,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
@@ -218,3 +243,56 @@ The empty-refresh-token behavior was measured with Codex CLI 0.166.0. Real-host
 acceptance should verify that the installed matching CLI does not attempt a
 refresh with the temporary home, that the controller token chain stays unchanged
 for a fresh credential, and that cleanup works after disconnect and SIGTERM.
+
+### Read an interactive conversation
+
+`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 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`
+(`user`, `assistant`, or `tool`), `text`, `tool_name`, `tool_summary`, `at`, and
+`id`. Missing values are `null`; tool text is empty. Entries follow file and
+content-block order, with stable IDs for the same file position. Timestamps are
+provider timestamps when valid. Tool calls/results have a name and a short
+summary; arguments, results, attachments, and reasoning blocks are omitted.
+Result names are recovered from up to 100 recent calls, otherwise `tool`.
+Common credential patterns and secret assignments in text are redacted without
+opening credential stores. Review conversation text before sharing: arbitrary
+unlabelled sensitive prose cannot be identified automatically.
+
+Pass `next_cursor` unchanged as `--cursor` to fetch the next page or poll for new
+entries. `--limit` bounds entries (default 100, range 1–1000). Reading seeks to
+the saved byte position rather than replaying history, and scans at most 8 MiB
+per call. A page may be empty while still returning a usable cursor. Poll on a
+timer: `has_more` means unread bytes, which can include an incomplete final line
+that will only become readable after the provider appends its newline.
+
+Codex response items and Claude-compatible JSONL transcripts (Claude and
+Antigravity) are supported through the existing transcript resolver. Missing or
+unreadable files return `status: "unavailable"` with a reason. Ollama's terminal
+capture does not reliably identify message roles and returns
+`status: "unsupported"`, including when no capture exists. A transcript record
+larger than 1 MiB returns `unavailable`. A replaced/truncated file or invalid
+cursor returns `reset_required`; discard the cursor and reload the conversation.
+Cursors are opaque, versioned, and bound to a provider and file. Treat transcripts
+as append-only; reset the client if a provider rewrites earlier history.
+
+Python callers can use the same page contract:
+
+```python
+from cdx_manager.conversation import read_conversation
+
+page = read_conversation("claude", "/path/to/profile/home", conversation_id="session-id", limit=100)
+next_page = read_conversation(
+    "claude", "/path/to/profile/home", conversation_id="session-id",
+    cursor=page["next_cursor"], limit=100,
+)
+```

package/VERSION

@@ -1 +1 @@
-0.25.9
+0.26.1

package/changelogs/CHANGELOGS_0_26_0.md

@@ -0,0 +1,31 @@
+# CDX Manager 0.26.0
+
+Release date: 2026-11-03
+
+This release adds optional profile concurrency settings for automatic missions
+and incremental JSON access to interactive conversations.
+
+## Automatic mission concurrency
+
+- Add an optional per-profile `launch.max_parallel` setting through `cdx set
+  <name> --max-parallel N`, accepting integers from 0 to 5. Zero excludes a
+  profile from automatic missions; an unset value leaves the scheduling client's
+  default in effect. Expose the setting in list JSON, status JSON, and profile
+  settings, and clear it with `cdx unset <name> --max-parallel`. Scheduling
+  clients enforce this setting; the existing `cdx run --max-parallel` limit
+  remains separate. (#101)
+
+## Interactive conversation reading
+
+- Add `cdx conversation <name> --json` and the reusable `read_conversation`
+  Python function to read Codex, Claude, and Antigravity transcripts
+  incrementally with bounded reads and opaque pagination cursors. Return
+  normalized messages and tool activity summaries while omitting tool bodies,
+  attachments, metadata, and reasoning, and redacting recognized credentials.
+  Report missing transcripts as unavailable and Ollama terminal captures as
+  unsupported; require a cursor reset after rotation or truncation. (#100)
+
+## Maintenance
+
+- Record tray companion checksums for v0.25.9. (`6d0a825b9649da9aead3379e6411e3959cd30a77`)
+- Record release archive checksums for v0.25.9. (`e3682ad8aed14d75c3c686a0c6027f53cfe81cd3`)

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

@@ -782,6 +782,28 @@
         "x86_64-pc-windows-msvc": "9577f9dff7d457094276376f262904dad8c9aff95ed2ca87b834c9c900fb5493",
         "x86_64-unknown-linux-musl": "db7e322037041c2a898043f0c7a691c22cab6a794aab5b2439a06ac91e92fa39"
       }
+    },
+    "v0.25.9": {
+      "github_tarball_sha256": "cd6d881144cefbd82b0929f375f471ed076e2f23be60744895aee54de5aead12",
+      "github_zip_sha256": "ccd28db3f526a081ed75cefc016f54d7eadf0adcaab401c8aed77d477cf917d3",
+      "tray_assets": {
+        "aarch64-apple-darwin": "4f90576e9e8db1ec08ed856a91a02f4049c7f7186e6dccac1908ba43c72df6fd",
+        "aarch64-unknown-linux-musl": "dcdf50751982f78805492eca059d83238f5d2190b97455b2d96d91283b764cdc",
+        "x86_64-apple-darwin": "289818bd5d692a6ba5035f10886318179bb2baa98e22a05e7abd751ea64d19ed",
+        "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.25.9",
+  "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.25.9"
+version = "0.26.1"
 description = "Terminal session manager for Codex and Claude accounts."
 readme = "README.md"
 requires-python = ">=3.9.2"

package/src/cli.py

@@ -21,6 +21,7 @@ from .cli_commands import (
     handle_config,
     handle_configs,
     handle_context,
+    handle_conversation,
     handle_copy,
     handle_disable,
     handle_disk,
@@ -167,6 +168,7 @@ _COMMAND_HANDLERS = {
     "export": handle_export,
     "handoff": handle_handoff,
     "history": handle_history,
+    "conversation": handle_conversation,
     "import": handle_import,
     "label": handle_label,
     "last": handle_last,
@@ -201,6 +203,7 @@ _COMMAND_HANDLERS = {
 }
 
 _COMMAND_ALIASES = {
+    "show": "config",
     "ren": "rename",
     "mv": "rename",
 }
@@ -237,6 +240,7 @@ def _print_help(use_color=False):
         _style("Usage:", "1", use_color),
         f"  {_style('cdx', '36', use_color)}",
         f"  {_style('cdx --json', '36', use_color)}",
+        f"  {_style('cdx ls [--json]', '36', use_color)}",
         f"  {_style('cdx status [--json] [--refresh|--cached] [--timeout SECONDS]', '36', use_color)}",
         f"  {_style('cdx status --small|-s [--refresh|--cached] [--timeout SECONDS]', '36', use_color)}",
         f"  {_style('cdx status <name> [--json] [--refresh|--cached] [--timeout SECONDS]', '36', use_color)}",
@@ -258,15 +262,17 @@ def _print_help(use_color=False):
         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 show <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(SET_USAGE[len('Usage: '):], '36', use_color)}",
-        f"  {_style('cdx unset <name>|--sessions all|a,b|--provider PROVIDER (--power|--permission|--fast|--rtk|--logics|--notify|--notify-preview|--model|--priority|--all) [--json]', '36', use_color)}",
+        f"  {_style('cdx unset <name>|--sessions all|a,b|--provider PROVIDER (--power|--permission|--fast|--rtk|--logics|--notify|--notify-preview|--model|--priority|--max-parallel|--all) [--json]', '36', use_color)}",
         f"  {_style('cdx history backfill-projects [--mapping FILE] [--dry-run|--apply] [--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] [--by session|project|model] [--json]', '36', use_color)}",
         f"  {_style('cdx last [--json]', '36', use_color)}",
         f"  {_style('cdx resume <name> [--project PATH] [--conversation <id>] [--json]', '36', use_color)}",
+        f"  {_style('cdx conversation <name> [--conversation ID] [--cursor CURSOR] [--limit N] --json', '36', use_color)}",
         f"  {_style('cdx can-resume <name> [--conversation <id>] [--json]', '36', use_color)}",
         f"  {_style('cdx rescue [<session>] [--to <target>] [--yes] [--dry-run] [--json]', '36', use_color)}",
         f"  {_style('cdx retro [--limit N] [--json]', '36', use_color)}",
@@ -580,6 +586,11 @@ def main(argv, options=None):
     # directory cannot be resolved (a service or task with a minimal environment).
     service = options.get("service") or create_session_service({"env": env})
 
+    if argv[:1] == ["ls"]:
+        if argv[1:] not in ([], ["--json"]):
+            raise CdxError("Usage: cdx ls [--json]")
+        argv = argv[1:]
+
     if argv == ["--json"]:
         rows = service["format_list_rows"]()
         notices = _get_update_notices(service, env, options)

package/src/cli_args.py

@@ -16,6 +16,7 @@ from .config import (
     PROVIDER_CODEX,
     PROVIDERS,
     REASONING_EFFORT_VALUES,
+    normalize_launch_max_parallel,
     normalize_permission,
     parse_on_off,
 )
@@ -34,8 +35,8 @@ CONTEXT_USAGE = "Usage: cdx context show|path|init|edit|clear|set|append [text..
 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> [--source-conversation ID | --source-native-transcript PATH | --source-transcript PATH] [--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] [--notify on|off] [--agent-state on|off] [--notify-preview on|off] [--scrub-env on|off] [--shared-memory on|off] [--retro on|off] [--policy use|ask-first|never] [--model MODEL] [--fallback-model MODEL[,MODEL...]] [--budget USD] [--extra-args 'ARGS'] [--priority 0..100] [--json]"
-UNSET_USAGE = "Usage: cdx unset <name>|--sessions all|a,b|--provider PROVIDER (--power|--reasoning-effort|--permission|--fast|--rtk|--logics|--notify|--agent-state|--notify-preview|--scrub-env|--shared-memory|--retro|--policy|--model|--fallback-model|--budget|--extra-args|--priority|--all) [--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] [--notify on|off] [--agent-state on|off] [--notify-preview on|off] [--scrub-env on|off] [--shared-memory on|off] [--retro on|off] [--policy use|ask-first|never] [--model MODEL] [--fallback-model MODEL[,MODEL...]] [--budget USD] [--extra-args 'ARGS'] [--priority 0..100] [--max-parallel 0..5] [--json]"
+UNSET_USAGE = "Usage: cdx unset <name>|--sessions all|a,b|--provider PROVIDER (--power|--reasoning-effort|--permission|--fast|--rtk|--logics|--notify|--agent-state|--notify-preview|--scrub-env|--shared-memory|--retro|--policy|--model|--fallback-model|--budget|--extra-args|--priority|--max-parallel|--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]"
@@ -286,6 +287,7 @@ def _parse_set_args(args):
         "--budget": {"key": "budget", "type": "str", "default": None, "transform": _parse_budget_value},
         "--extra-args": {"key": "extra_args", "type": "str", "default": None},
         "--priority": {"key": "priority", "type": "str", "default": None, "transform": _parse_priority_value},
+        "--max-parallel": {"key": "max_parallel", "type": "str", "default": None, "transform": normalize_launch_max_parallel},
         "--policy": {"key": "policy", "type": "str", "default": None},
         "--sessions": {"key": "sessions", "type": "str", "default": None, "transform": _parse_set_unset_sessions},
         "--provider": {"key": "provider", "type": "str", "default": None, "transform": lambda value: _parse_provider_filter(value, SET_USAGE)},
@@ -303,7 +305,7 @@ def _parse_set_args(args):
         raise CdxError(SET_USAGE)
     settings = {
         key: parsed[key]
-        for key in ("power", "permission", "fast", "rtk", "logics", "notify", "agent_state", "notify_preview", "scrub_env", "shared_memory", "retro", "model", "fallback_model", "budget", "extra_args", "priority", "policy")
+        for key in ("power", "permission", "fast", "rtk", "logics", "notify", "agent_state", "notify_preview", "scrub_env", "shared_memory", "retro", "model", "fallback_model", "budget", "extra_args", "priority", "policy", "max_parallel")
         if parsed[key] is not None
     }
     if not settings:
@@ -336,6 +338,7 @@ def _parse_unset_args(args):
         "--budget": {"key": "budget", "type": "bool", "default": False},
         "--extra-args": {"key": "extra_args", "type": "bool", "default": False},
         "--priority": {"key": "priority", "type": "bool", "default": False},
+        "--max-parallel": {"key": "max_parallel", "type": "bool", "default": False},
         "--policy": {"key": "policy", "type": "bool", "default": False},
         "--all": {"key": "all", "type": "bool", "default": False},
         "--sessions": {"key": "sessions", "type": "str", "default": None, "transform": _parse_set_unset_sessions},
@@ -354,7 +357,7 @@ def _parse_unset_args(args):
         raise CdxError(UNSET_USAGE)
     _UNSET_KEYS = (
         "power", "reasoning_effort", "permission", "fast", "rtk", "logics", "notify", "agent_state", "notify_preview", "scrub_env", "shared_memory", "retro",
-        "model", "fallback_model", "budget", "extra_args", "priority", "policy",
+        "model", "fallback_model", "budget", "extra_args", "priority", "policy", "max_parallel",
     )
     keys = list(_UNSET_KEYS) if parsed["all"] else [key for key in _UNSET_KEYS if parsed[key]]
     if not keys:

package/src/cli_commands.py

@@ -57,8 +57,6 @@ from .commands.backup import (  # noqa: F401
     handle_export,
     handle_import,
 )
-
-# Re-exported for cli.py and tests; see src/commands/__init__.py.
 from .commands.context_memory import (  # noqa: F401
     _list_memory_entries,
     _memory_payload,
@@ -67,6 +65,9 @@ from .commands.context_memory import (  # noqa: F401
     handle_context,
     handle_memory,
 )
+
+# Re-exported for cli.py and tests; see src/commands/__init__.py.
+from .commands.conversation import handle_conversation as handle_conversation
 from .commands.launch import (  # re-export for cli.py / tests
     _format_resume_capability as _format_resume_capability,
 )

package/src/cli_helpers.py

@@ -323,6 +323,7 @@ def _format_launch_config(session, use_color=False):
         ("extra_args", "Extra args"),
         ("priority", "Priority"),
         ("policy", "Policy"),
+        ("max_parallel", "Max parallel"),
     ]:
         rows.append([
             _dim(label, use_color),

package/src/commands/conversation.py

@@ -0,0 +1,34 @@
+"""JSON conversation pages for interactive sessions."""
+
+from ..cli_args import _parse_flag_args
+from ..cli_helpers import _json_success, _write_json
+from ..conversation import read_conversation
+from ..errors import CdxError
+from ..provider_runtime import _get_auth_home
+
+CONVERSATION_USAGE = "Usage: cdx conversation <name> [--conversation ID] [--cursor CURSOR] [--limit N] --json"
+
+
+def handle_conversation(rest, ctx):
+    parsed = _parse_flag_args(rest, {
+        "--json": {"key": "json", "type": "bool", "default": False},
+        "--conversation": {"key": "conversation", "type": "str"},
+        "--cursor": {"key": "cursor", "type": "str"},
+        "--limit": {"key": "limit", "type": "str", "default": "100"},
+    }, CONVERSATION_USAGE, positionals_key="names", max_positionals=1)
+    if not parsed["json"] or len(parsed["names"]) != 1:
+        raise CdxError(CONVERSATION_USAGE)
+    session = ctx["service"]["get_session"](parsed["names"][0])
+    if not session:
+        raise CdxError(f"Unknown session: {parsed['names'][0]}")
+    try:
+        limit = int(parsed["limit"])
+    except ValueError:
+        raise CdxError(CONVERSATION_USAGE) from None
+    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, 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/config.py

@@ -78,6 +78,21 @@ def normalize_permission(value):
     return text if text in PERMISSION_VALUES else None
 
 
+def normalize_launch_max_parallel(value):
+    """Validate the optional per-profile automatic mission limit."""
+    from .errors import CdxError
+
+    if isinstance(value, bool) or not isinstance(value, (int, str)):
+        raise CdxError("Max parallel must be an integer from 0 to 5.")
+    try:
+        limit = int(value)
+    except ValueError as error:
+        raise CdxError("Max parallel must be an integer from 0 to 5.") from error
+    if not 0 <= limit <= 5:
+        raise CdxError("Max parallel must be an integer from 0 to 5.")
+    return limit
+
+
 def get_cdx_home(env=None):
     if env is None:
         env = os.environ

package/src/conversation.py

@@ -0,0 +1,187 @@
+"""Incremental, read-only conversation pages from provider JSONL transcripts."""
+
+import base64
+import hashlib
+import json
+import os
+import re
+from datetime import datetime
+
+from .config import PROVIDERS
+from .errors import CdxError
+from .interactive_usage import conversation_transcript, resolve_transcript
+
+MAX_LINE_BYTES = 1024 * 1024
+MAX_PAGE_BYTES = 8 * 1024 * 1024
+REDACTED = "[REDACTED]"
+
+
+def _redact(text):
+    # There is no shared transcript redactor; launch argument redaction only
+    # hides prompt argv. Do not read credential stores to discover secrets.
+    text = re.sub(r"-----BEGIN [^-]*PRIVATE KEY-----.*?(?:-----END [^-]*PRIVATE KEY-----|$)", REDACTED, text, flags=re.S)
+    text = re.sub(r"(?i)\b(?:[\w.-]*(?:password|passwd|secret|api[_-]?key|token)|authorization)\b[\"']?\s*[:=]\s*(?:\"[^\"]*\"|'[^']*'|[^\s,;}]+)", REDACTED, text)
+    text = re.sub(r"(?i)\b(?:bearer|basic)\s+[a-z0-9._~+/=-]+", REDACTED, text)
+    text = re.sub(r"\b(?:sk-[a-zA-Z0-9_-]+|gh[pousr]_[a-zA-Z0-9]+|github_pat_[a-zA-Z0-9_]+|AKIA[A-Z0-9]{16}|ASIA[A-Z0-9]{16}|xox[baprs]-[a-zA-Z0-9-]+|AIza[a-zA-Z0-9_-]+)\b", REDACTED, text)
+    text = re.sub(r"\beyJ[a-zA-Z0-9_-]+\.[a-zA-Z0-9_-]+\.[a-zA-Z0-9_-]+\b", REDACTED, text)
+    text = re.sub(r"https?://(?:hooks\.slack\.com/services|(?:discord(?:app)?\.com)/api/webhooks)/[^\s\"'<>]+", REDACTED, text)
+    return re.sub(r"(https?://)[^\s/@]+:[^\s/@]+@", r"\1[REDACTED]@", text)
+
+
+def _entry(role, text="", name=None, summary=None, at=None):
+    return {"role": role, "text": _redact(text), "tool_name": _redact(name) if name else None,
+            "tool_summary": summary, "at": at, "id": None}
+
+
+def _tool_name(message, names, result=False):
+    identifier = message.get("call_id") or message.get("tool_use_id") or message.get("id")
+    key = hashlib.sha256(identifier.encode()).hexdigest() if isinstance(identifier, str) else None
+    name = message.get("name") or (names.get(key) if result else None)
+    name = _redact(name) if isinstance(name, str) else "tool"
+    if not re.fullmatch(r"[a-zA-Z_][a-zA-Z0-9_.:/-]{0,99}", name):
+        name = "tool"
+    if key and not result:
+        if len(names) >= 100:
+            names.pop(next(iter(names)))
+        names[key] = name
+    return name
+
+
+def _entries(provider, record, names):
+    if not isinstance(record, dict):
+        return []
+    stamp = record.get("timestamp")
+    try:
+        datetime.fromisoformat(stamp.replace("Z", "+00:00"))
+    except (AttributeError, TypeError, ValueError):
+        stamp = None
+    if provider == "codex":
+        # event_msg repeats response_item messages; consume only canonical items.
+        if record.get("type") != "response_item":
+            return []
+        message = record.get("payload")
+    else:
+        message = record.get("message")
+    if not isinstance(message, dict):
+        return []
+    kind = message.get("type")
+    if isinstance(kind, str) and (kind.endswith("_call") or kind.endswith("_call_output")):
+        result = kind.endswith("output")
+        tool = message
+        if not message.get("name") and kind not in ("function_call", "custom_tool_call", "function_call_output", "custom_tool_call_output"):
+            tool = {**message, "name": kind.removesuffix("_output").removesuffix("_call")}
+        name = _tool_name(tool, names, result)
+        return [_entry("tool", name=name, summary="Result recorded" if result else "Call recorded", at=stamp)]
+    role = message.get("role") or record.get("type")
+    if role not in ("user", "assistant", "tool"):
+        return []
+    if role == "tool":
+        return [_entry("tool", name=_tool_name(message, names, True), summary="Result recorded", at=stamp)]
+    content = message.get("content")
+    if isinstance(content, str):
+        return [_entry(role, content, at=stamp)]
+    if not isinstance(content, list):
+        return []
+    entries = []
+    for block in content:
+        if not isinstance(block, dict):
+            continue
+        kind = block.get("type")
+        if kind in ("text", "input_text", "output_text") and isinstance(block.get("text"), str):
+            entries.append(_entry(role, block["text"], at=stamp))
+        elif kind in ("tool_use", "tool_result"):
+            name = _tool_name(block, names, kind == "tool_result")
+            entries.append(_entry("tool", name=name, summary="Call recorded" if kind == "tool_use" else "Result recorded", at=stamp))
+    return entries
+
+
+def _anchor(handle, offset):
+    handle.seek(max(0, offset - 128))
+    return hashlib.sha256(handle.read(min(offset, 128))).hexdigest()
+
+
+def read_conversation(provider, auth_home=None, *, conversation_id=None, started_at=None,
+                      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,
+            "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, 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:
+        with open(path, "rb") as handle:
+            stat = os.fstat(handle.fileno())
+            identity = hashlib.sha256(f"{provider}:{os.path.realpath(path)}:{stat.st_dev}:{stat.st_ino}".encode()).hexdigest()
+            offset, index, names = 0, 0, {}
+            if cursor is not None:
+                try:
+                    if not isinstance(cursor, str) or len(cursor) > 65536:
+                        raise ValueError
+                    state = json.loads(base64.urlsafe_b64decode(cursor.encode("ascii")))
+                    offset, index = state["offset"], state["index"]
+                    names = state["names"]
+                    if (not isinstance(names, dict) or len(names) > 100
+                            or any(not isinstance(k, str) or not re.fullmatch(r"[0-9a-f]{64}", k)
+                                   or not isinstance(v, str) or not re.fullmatch(r"[a-zA-Z_][a-zA-Z0-9_.:/-]{0,99}", v)
+                                   or _redact(v) != v for k, v in names.items())):
+                        raise ValueError
+                    if (state["v"] != 1 or state["file"] != identity
+                            or type(offset) is not int or type(index) is not int
+                            or not 0 <= offset <= stat.st_size or not 0 <= index <= MAX_LINE_BYTES
+                            or state["anchor"] != _anchor(handle, offset)):
+                        raise ValueError
+                except (ValueError, TypeError, KeyError, AttributeError, UnicodeError):
+                    return {**page, "status": "reset_required", "reason": "invalid_or_stale_cursor"}
+            handle.seek(offset)
+            scanned = 0
+            while len(page["entries"]) < limit and scanned < MAX_PAGE_BYTES:
+                start = handle.tell()
+                line = handle.readline(MAX_LINE_BYTES + 1)
+                if len(line) > MAX_LINE_BYTES:
+                    return {**page, "status": "unavailable", "reason": "record_too_large", "entries": []}
+                if not line or not line.endswith(b"\n"):
+                    break
+                scanned += len(line)
+                try:
+                    entries = _entries(provider, json.loads(line), names)
+                except (ValueError, UnicodeError):
+                    entries = []
+                for block_index in range(index, len(entries)):
+                    entry = entries[block_index]
+                    entry["id"] = f"{identity[:16]}:{start}:{block_index}"
+                    page["entries"].append(entry)
+                    if len(page["entries"]) == limit:
+                        index = block_index + 1
+                        break
+                else:
+                    index = len(entries)
+                if index < len(entries):
+                    offset = start
+                    break
+                offset, index = handle.tell(), 0
+            page["has_more"] = offset < stat.st_size
+            state = {"v": 1, "file": identity, "offset": offset, "index": index, "anchor": _anchor(handle, offset), "names": names}
+            page["next_cursor"] = base64.urlsafe_b64encode(json.dumps(state, separators=(",", ":")).encode()).decode()
+            return page
+    except OSError:
+        return {**page, "status": "unavailable", "reason": "transcript_unreadable", "entries": []}

package/src/session_service.py

@@ -45,6 +45,7 @@ from .config import (
     PROVIDER_CODEX,
     REASONING_EFFORT_VALUES,
     get_cdx_home,
+    normalize_launch_max_parallel,
     normalize_permission,
     split_extra_args,
 )
@@ -236,6 +237,8 @@ def _normalize_launch_settings(settings, mark_fast_service_tier=True):
         if priority < MIN_LAUNCH_PRIORITY or priority > MAX_LAUNCH_PRIORITY:
             raise CdxError(f"Unsupported priority: {settings['priority']}")
         normalized["priority"] = priority
+    if "max_parallel" in settings and settings["max_parallel"] is not None:
+        normalized["max_parallel"] = normalize_launch_max_parallel(settings["max_parallel"])
     if "policy" in settings and settings["policy"] is not None:
         if settings["policy"] not in ACCOUNT_POLICIES:
             raise CdxError(f"Unsupported policy: {settings['policy']} (use|ask-first|never)")
@@ -324,7 +327,7 @@ def unset_launch_settings(store, name, keys):
         raise CdxError("At least one launch setting is required.")
     allowed = {
         "power", "reasoning_effort", "reasoningEffort", "permission", "fast", "rtk", "logics", "notify", "agent_state", "notify_preview",
-        "scrub_env", "shared_memory", "retro", "model", "fallback_model", "budget", "extra_args", "priority", "policy",
+        "scrub_env", "shared_memory", "retro", "model", "fallback_model", "budget", "extra_args", "priority", "policy", "max_parallel",
     }
     unknown = [key for key in keys if key not in allowed]
     if unknown:
@@ -686,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
@@ -935,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):

package/src/session_status.py

@@ -380,6 +380,7 @@ def _status_row_from_session(store, s):
         # ignored `--priority` entirely.
         "priority": _row_priority(s),
         "policy": (s.get("launch") or {}).get("policy") or "use",
+        "max_parallel": (s.get("launch") or {}).get("max_parallel"),
         "reasoning_effort": _row_reasoning_effort(s),
         "active": bool(runtime) if enabled else False,
         "cwd": runtime.get("cwd") if runtime else None,