cdx-manager 0.25.9 → 0.26.0

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.0-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.
@@ -218,3 +239,51 @@ 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; a profile without a recorded ID
+uses the existing latest-transcript resolver. This fallback is best effort.
+
+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.0

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/checksums/release-archives.json

@@ -782,6 +782,17 @@
         "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"
+      }
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cdx-manager",
-  "version": "0.25.9",
+  "version": "0.26.0",
   "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.0"
 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,
+    )
+    _write_json(ctx, _json_success("conversation", "Conversation page loaded.", session=session["name"], **page))
+    return 0

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,181 @@
+"""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):
+    """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.
+    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}
+    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)
+    else:
+        path, _match = 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:

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,