cdx-manager 0.26.2 → 0.26.4

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.2-4C8BF5) ![Python](https://img.shields.io/badge/python-3.9%2B-3776AB?logo=python&logoColor=white)
+[![License](https://img.shields.io/badge/license-MIT-4C8BF5)](LICENSE) ![Version](https://img.shields.io/badge/version-v0.26.4-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.
 
@@ -65,6 +65,15 @@ row (`null` when absent). `cdx show` is an alias for `cdx config` and displays
 
 ## Cache efficiency and fix rounds
 
+
+`cdx history --interactive --cwd /path/to/project --limit 50 --json` finds interactive launches without mission runs consuming the result window. `--cwd` compares resolved paths (including symlinks and `~`), exactly, without including child directories. Both filters apply before `--limit` and also work with profile names, period filters and `--summary`. `--interactive` excludes headless `run` entries, detached entries and labels starting with `mission:`; unlabelled legacy launches remain eligible.
+
+Interactive launches appear as `status: "running"` as soon as the provider starts, including `cdx start <name> --dir PATH` (an alias for `cdx <name> --dir PATH`) inside tmux. Completion or failure updates the same run ID. Active runtimes from older supervisors are included while their process remains alive; vanished unrecorded launches cannot be reconstructed.
+
+History entries expose `conversation_id` and `provider_transcript_match: "conversation_id"` when an exact provider transcript exists. Claude uses its launch session ID; Codex can recover a unique thread from transcript metadata matching the launch directory and time window. Ambiguous discovery remains `provider_transcript_match: "recency"`, an explicitly unverified fallback that must not be treated as a verified resume target. A known ID with no transcript does not borrow another conversation. Existing history is enriched on read without rewriting old rows.
+
+`first_user_prompt` contains the first real user text (up to 2,000 characters) from a bounded, redacted transcript read. Provider command wrappers, system reminders, tool results and bare absolute file paths are skipped. Missing, oversized or unavailable evidence leaves the prompt unknown; a supplied initial prompt is used when available.
+
 `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.
 
 `cdx stats --json` adds `cache_usage` sums and an input-weighted `cache_hit_ratio` to each session, project (`--by project`), model (`--by model`), and total. `cache_usage` preserves unknown sums as `null`; existing numeric aggregate fields keep their previous behavior. Ratios include only runs with measured input and cache reads. Coverage is explicit in `measured_runs` and `measured_input_tokens`. `run_types.cold` and `run_types.continued` expose counts, sums, and ratios for comparison. Text views show values such as `cache 72 %` next to tokens.

package/VERSION

@@ -1 +1 @@
-0.26.2
+0.26.4

package/changelogs/CHANGELOGS_0_26_3.md

@@ -0,0 +1,22 @@
+# CDX Manager 0.26.3
+
+Release date: 2026-11-04
+
+## Improvements
+
+- Make interactive session history findable and resumable (#110,
+  `5abd37830095ee3519bd130ac6d80da143b29e27`). Filter `cdx history` by resolved
+  working directory (`--cwd PATH`) and interactive launches (`--interactive`)
+  before applying the result limit. Record launches immediately and update the
+  same history row on exit so active sessions remain visible without duplicates.
+- Support `cdx start <name>` through the named launch path, including tmux.
+  Prefer exact Claude session IDs and unique project/time-scoped Codex transcript
+  metadata; mark ambiguous recency matches as unverified. Recover clean, redacted
+  first-user prompts past provider wrappers, reminders, tools and bare file paths.
+
+## Maintenance
+
+- Record tray companion checksums for v0.26.2
+  (`54f201a2886f5293658f214e5725d60426dcfb28`).
+- Record release archive checksums for v0.26.2
+  (`3bc40eaada4b401e222bf599335b8b3d4dc80326`).

package/changelogs/CHANGELOGS_0_26_4.md

@@ -0,0 +1,17 @@
+# CDX Manager 0.26.4
+
+Release date: 2026-11-05
+
+## Fixes
+
+- Show Claude messages typed while the agent is working in conversation pages
+  (#112, `7baa22a4604317b5c6fffa1eb8ddb7c8726c283d`). Render human queued
+  messages as user entries, including text accompanying pasted images and
+  oversized attachments, while keeping image bodies out of conversation output.
+
+## Maintenance
+
+- Record tray companion checksums for v0.26.3
+  (`c3e861fb6a216ec0c721cff8bb07043921891457`).
+- Record release archive checksums for v0.26.3
+  (`da760da0f3b859b017a68d2f4bdde71c38ca883f`).

package/changelogs/CHANGELOGS_UNRELEASED.md

@@ -1,5 +1,12 @@
 # Unreleased
 
+## Find and resume interactive sessions
+
+- Add exact resolved `cdx history --cwd PATH` and `--interactive` filters before the result limit, preserving the JSON envelope and period/summary support.
+- Record interactive launches immediately, update the same row on exit, expose active older runtimes and support `cdx start <name>` through the named launch path, including tmux.
+- Prefer exact Claude session IDs and unique project/time-scoped Codex transcript metadata; expose ambiguous recency as unverified. Recover clean, redacted `first_user_prompt` text past provider wrappers, reminders, tools and bare file paths.
+- Cover filter ordering, live history, completion/failure deduplication, legacy launch arguments, transcript identity ambiguity, missing evidence and prompt cleanup.
+
 ## Conversation tail pagination (planned for 0.26.2)
 
 - Add `cdx conversation --tail N` (1–1000), chronological backward pages via `before_cursor` and `--before`, and a compatible `next_cursor` for live polling. Read JSONL backwards in bounded 64 KiB blocks, preserve normalization, redaction, stable IDs and oversized-record skipping, and reject stale backward cursors.

package/checksums/release-archives.json

@@ -815,6 +815,28 @@
         "x86_64-pc-windows-msvc": "07cf6f66d58320494833107cf369b66cdf171649c8128d6463028a9aa7058494",
         "x86_64-unknown-linux-musl": "e18869d50747b1eb7924005554e11154f04a27363b8b3148f7ae0a1042d6ca7a"
       }
+    },
+    "v0.26.2": {
+      "github_tarball_sha256": "c85ae3c9158a933eb151b6f74563da6fafb8160e01091e925224678bae7bc394",
+      "github_zip_sha256": "d6b70ab53b617fb364e6704684421422cbc13cabd5ba15706fac8f543eea2721",
+      "tray_assets": {
+        "aarch64-apple-darwin": "8d1089505821ee59b9b0f49ef2fdc63b081bafe468add02b83e84d9939cd2be0",
+        "aarch64-unknown-linux-musl": "816a48a84d99e84403a11eea76214c8a56301919b13556fd1ffe7e1459092fd1",
+        "x86_64-apple-darwin": "38d028177b64f616e72a81d52a451ba174f434757e2e503ba196e653b08ae6c3",
+        "x86_64-pc-windows-msvc": "7846a4b56ec3006428b9778cbee3e0c1fabea8f279ca9183cf34abb460bb4c29",
+        "x86_64-unknown-linux-musl": "d761aa0bbda8661c842f0b18e438c047ec023d30ed733d0044d1663ddd480355"
+      }
+    },
+    "v0.26.3": {
+      "github_tarball_sha256": "19f55a4b7ccc2de8a05aeee23039749f782214460368de5ce2aa90ee051c5c7e",
+      "github_zip_sha256": "67042371673a27de37f6accd5c4cea9128d4a2a8bdd382173a56ffb3bbb34e53",
+      "tray_assets": {
+        "aarch64-apple-darwin": "520b94d699dce57b381b6efb16f6afd5bf162218437bdaedfe3c152cbf95f42d",
+        "aarch64-unknown-linux-musl": "fdd710a5eeba7fbc545518b011f81acbb72087e201c8c577c2eff629bb2130ff",
+        "x86_64-apple-darwin": "082c8ea57b34295f24ecbad701d81df37860f25f645f1c3c59382407ff94e865",
+        "x86_64-pc-windows-msvc": "7b9d9fc24dd5d4285a5cac7e746614654deaebe197ab38fa6e1c302da34e0358",
+        "x86_64-unknown-linux-musl": "51ea6902917697f5d16ef994bb01d0d0c6293b60c8f26b3735cb08925b3af616"
+      }
     }
   }
 }

package/docs/cli.md

@@ -28,7 +28,7 @@
 | `cdx power\|perm\|fast\|model <name\|all\|provider:PROVIDER\|a,b> <value\|default> [--json]` | Shortcut commands for setting or clearing one launch setting |
 | `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]` | Persist launch settings for one or more sessions |
 | `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]` | Remove persisted launch settings and fall back to provider defaults |
-| `cdx history [name] [--limit N] [--summary] [--since 7d\|today\|DATE] [--from DATE] [--to DATE] [--json]` | Show recent launch history or aggregate total launch time per assistant, optionally filtered by period |
+| `cdx history [name] [--cwd PATH] [--interactive] [--limit N] [--summary] [--since 7d\|today\|DATE] [--from DATE] [--to DATE] [--json]` | Show recent launch history or aggregate total launch time per assistant, optionally filtered by period |
 | `cdx history backfill-projects [--mapping FILE] [--dry-run \| --apply] [--json]` | Recover source repository attribution from exact recorded run evidence or an operator mapping; defaults to a read-only preview |
 | `cdx history backfill-models [--dry-run \| --apply] [--json]` | Recover missing historical usage models from evidence tied to each run; defaults to a read-only preview |
 | `cdx last [--json]` | Launch the most recent existing session from launch history |
@@ -673,3 +673,13 @@ shows the before/after versions, including major upgrades. JSON keeps the
 pre-update plan and existing result fields; tool verification adds
 `version_before`, `version_after`, and `latest_version` to successful-command
 results, plus `reason` and a nonzero `returncode` if verification fails.
+
+## Find interactive conversations
+
+`cdx history --interactive --cwd /path/to/project --limit 50 --json` finds interactive launches without mission runs consuming the result window. `--cwd` compares resolved paths (including symlinks and `~`), exactly, without including child directories. Both filters apply before `--limit` and also work with profile names, period filters and `--summary`. `--interactive` excludes headless `run` entries, detached entries and labels starting with `mission:`; unlabelled legacy launches remain eligible.
+
+Interactive launches appear as `status: "running"` as soon as the provider starts, including `cdx start <name> --dir PATH` (an alias for `cdx <name> --dir PATH`) inside tmux. Completion or failure updates the same run ID. Active runtimes from older supervisors are included while their process remains alive; vanished unrecorded launches cannot be reconstructed.
+
+History entries expose `conversation_id` and `provider_transcript_match: "conversation_id"` when an exact provider transcript exists. Claude uses its launch session ID; Codex can recover a unique thread from transcript metadata matching the launch directory and time window. Ambiguous discovery remains `provider_transcript_match: "recency"`, an explicitly unverified fallback that must not be treated as a verified resume target. A known ID with no transcript does not borrow another conversation. Existing history is enriched on read without rewriting old rows.
+
+`first_user_prompt` contains the first real user text (up to 2,000 characters) from a bounded, redacted transcript read. Provider command wrappers, system reminders, tool results and bare absolute file paths are skipped. Missing, oversized or unavailable evidence leaves the prompt unknown; a supplied initial prompt is used when available.

package/docs/sessions-and-notifications.md

@@ -172,6 +172,7 @@ Every interactive `cdx <name>` launch is recorded under `CDX_HOME`, including su
 cdx history
 cdx history work
 cdx history work --limit 5
+cdx history --interactive --cwd ~/projects/example --limit 50 --json
 cdx history work --json
 cdx history --summary
 cdx history --summary --since 7d

package/package.json

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

package/src/cli.py

@@ -267,8 +267,9 @@ def _print_help(use_color=False):
         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|--max-parallel|--all) [--json]', '36', use_color)}",
+        f"  {_style('cdx start <name> [--dir PATH] [--resume] [--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 history [name] [--cwd PATH] [--interactive] [--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)}",
@@ -651,6 +652,10 @@ def main(argv, options=None):
     if handler:
         return handler(rest, ctx)
 
+    if command == "start":
+        if not rest or rest[0].startswith("-"):
+            raise CdxError("Usage: cdx start <name> [--dir PATH] [--resume] [--json]")
+        command, *rest = rest
     from .commands.launch import _parse_launch_args, _pop_value_flag, _read_launch_prompt
     project_path, rest = _pop_value_flag(rest, "--project", "Usage: cdx <name> [--project PATH]")
     directory, launch_args, prompt, on_busy = _parse_launch_args(rest)

package/src/cli_args.py

@@ -40,7 +40,7 @@ UNSET_USAGE = "Usage: cdx unset <name>|--sessions all|a,b|--provider PROVIDER (-
 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]"
-HISTORY_USAGE = "Usage: cdx history [name] [--limit N] [--summary] [--since 7d|today|DATE] [--from DATE] [--to DATE] [--json]"
+HISTORY_USAGE = "Usage: cdx history [name] [--cwd PATH] [--interactive] [--limit N] [--summary] [--since 7d|today|DATE] [--from DATE] [--to DATE] [--json]"
 STATS_USAGE = "Usage: cdx stats [name] [--since 7d|today|DATE] [--from DATE] [--to DATE] [--by session|project|model] [--json]"
 STATS_GROUPS = ("session", "project", "model")
 LAST_USAGE = "Usage: cdx last [--json]"
@@ -916,6 +916,8 @@ def _parse_history_args(args, now=None):
     now = now or datetime.now().astimezone()
     parsed = _parse_flag_args(args, {
         "--limit": {"key": "limit", "type": "str", "default": 20, "transform": _parse_positive_int},
+        "--cwd": {"key": "cwd", "type": "str", "default": None},
+        "--interactive": {"key": "interactive", "type": "bool", "default": False},
         "--summary": {"key": "summary", "type": "bool", "default": False},
         "--since": {"key": "since", "type": "str", "default": None},
         "--from": {"key": "from", "type": "str", "default": None},
@@ -926,6 +928,8 @@ def _parse_history_args(args, now=None):
     return {
         "name": parsed["names"][0] if parsed["names"] else None,
         "limit": parsed["limit"],
+        "cwd": parsed["cwd"],
+        "interactive": parsed["interactive"],
         "summary": parsed["summary"],
         "period": period,
         "json": parsed["json"],

package/src/commands/launch.py

@@ -334,8 +334,15 @@ def handle_launch(command, ctx, initial_prompt=None, resume=False, force_json=No
     def runtime_lifecycle(event, info):
         nonlocal runtime_run_id
         if event == "started":
-            runtime = ctx["service"]["start_session_runtime"](session["name"], {**info, "cwd": cwd, **project})
+            runtime = ctx["service"]["start_session_runtime"](session["name"], {**info, "cwd": cwd, **project, "runId": runtime_run_id})
             runtime_run_id = runtime.get("runId")
+            ctx["service"]["record_launch_history"](session["name"], {
+                **info, **project, "run_id": runtime_run_id, "cwd": cwd,
+                "action": "resume" if resume else "launch", "status": "running",
+                "ended_at": None, "duration_ms": None,
+                "conversation_id": _conversation_id(session) if resume or session["provider"] == PROVIDER_CLAUDE else None,
+                "first_user_prompt": initial_prompt,
+            })
         elif event == "finished" and runtime_run_id:
             ctx["service"]["finish_session_runtime"](
                 session["name"],
@@ -367,7 +374,7 @@ def handle_launch(command, ctx, initial_prompt=None, resume=False, force_json=No
     except CdxError as error:
         run_info = getattr(error, "run_info", {}) or {}
         run_info = _attach_interactive_usage(
-            session, run_info, ctx["service"]["get_launch_history"](session["name"], limit=None),
+            session, {**run_info, "cwd": cwd}, ctx["service"]["get_launch_history"](session["name"], limit=None),
             baseline=(baseline_path, baseline),
             uncertain_reason=overlap_reason(),
         )
@@ -382,6 +389,7 @@ def handle_launch(command, ctx, initial_prompt=None, resume=False, force_json=No
         if run_info:
             ctx["service"]["record_launch_history"](session["name"], {
                 "status": "failed",
+                "action": "resume" if resume else "launch",
                 "cwd": cwd,
                 "error": str(error),
                 "exit_code": error.exit_code,
@@ -391,7 +399,7 @@ def handle_launch(command, ctx, initial_prompt=None, resume=False, force_json=No
             })
         raise
     success_run_info = _attach_interactive_usage(
-        session, run_info, ctx["service"]["get_launch_history"](session["name"], limit=None),
+        session, {**run_info, "cwd": cwd}, ctx["service"]["get_launch_history"](session["name"], limit=None),
         baseline=(baseline_path, baseline),
         uncertain_reason=overlap_reason(),
     )
@@ -452,9 +460,14 @@ def _attach_interactive_usage(session, run_info, history=None, baseline=None, un
     recorded nothing would break the chain for every run after it.
     """
     run_info = dict(run_info or {})
+    from ..history_content import enrich_history
+
+    if session.get("provider") == PROVIDER_CLAUDE:
+        run_info.setdefault("conversation_id", _conversation_id(session))
+    run_info = enrich_history({**run_info, "provider": session.get("provider")}, session)
     started_at = run_info.get("started_at")
     cumulative, provider_transcript, match, model = extract_interactive_usage(
-        session.get("provider"), _get_auth_home(session), started_at, _conversation_id(session),
+        session.get("provider"), _get_auth_home(session), started_at, run_info.get("conversation_id") or _conversation_id(session),
         # Ollama writes no provider transcript; its only record is the PTY
         # capture this run already took.
         run_info.get("transcript_path"),

package/src/commands/status.py

@@ -695,16 +695,29 @@ def handle_history(rest, ctx):
     now = datetime.fromtimestamp(now_fn()).astimezone()
     parsed = _parse_history_args(rest, now=now)
     has_period = _has_history_period(parsed["period"])
-    limit = 0 if parsed["summary"] or has_period else parsed["limit"]
+    filtered = has_period or parsed["cwd"] is not None or parsed["interactive"]
+    limit = 0 if parsed["summary"] or filtered else parsed["limit"]
     entries = ctx["service"]["get_launch_history"](parsed["name"], limit=limit)
     entries = _filter_history_period(entries, parsed["period"])
+    if parsed["cwd"] is not None:
+        cwd = os.path.realpath(os.path.expanduser(parsed["cwd"]))
+        entries = [entry for entry in entries if entry.get("cwd")
+                   and os.path.realpath(os.path.expanduser(entry["cwd"])) == cwd]
+    if parsed["interactive"]:
+        entries = [entry for entry in entries if entry.get("action") != "run"
+                   and not entry.get("detached") and not entry.get("detach")
+                   and not str(entry.get("label") or "").startswith("mission:")
+                   and "--detach" not in (entry.get("args") or [])]
+    if filtered and not parsed["summary"]:
+        entries = entries[:parsed["limit"]]
+    from ..history_content import enrich_history
+
+    entries = [enrich_history(entry, ctx["service"]["get_session"](entry.get("session_name")) or {}) for entry in entries]
     entries = [{**entry, "parent_run_id": entry.get("parent_run_id"),
                 **cost_fields(entry.get("usage") if is_vouched(entry.get("usage")) else None, entry.get("usage_model"),
                               models=entry.get("usage_models", (entry.get("usage_evidence") or {}).get("models", [])), attribution=entry.get("usage_attribution")),
                 "usage": {**entry["usage"], "cache_hit_ratio": cache_hit_ratio(entry["usage"], provider=entry.get("provider")) if is_vouched(entry["usage"]) else None}
                 if isinstance(entry.get("usage"), dict) else entry.get("usage")} for entry in entries]
-    if has_period and not parsed["summary"]:
-        entries = entries[:parsed["limit"]]
     message = (
         f"Listed launch history for {parsed['name']}"
         if parsed["name"]

package/src/conversation.py

@@ -50,7 +50,16 @@ def _tool_name(message, names, result=False):
 
 def _conversation_record(provider, kind):
     # Provider bookkeeping can carry the same text as real conversation records.
-    return kind == "response_item" if provider == "codex" else kind in ("user", "assistant")
+    # Claude Code records messages typed while the agent works as queued_command attachments.
+    return kind == "response_item" if provider == "codex" else kind in ("user", "assistant", "attachment")
+
+
+def _queued_prompt(record):
+    attachment = record.get("attachment")
+    if (not isinstance(attachment, dict) or attachment.get("type") != "queued_command"
+            or (attachment.get("origin") or {}).get("kind") != "human"):
+        return None
+    return attachment.get("prompt")
 
 
 _CLAUDE_HARNESS = re.compile(
@@ -97,6 +106,9 @@ def _entries(provider, record, names):
         stamp = None
     if provider == "codex":
         message = record.get("payload")
+    elif record.get("type") == "attachment":
+        prompt = _queued_prompt(record)
+        message = {"role": "user", "content": prompt} if isinstance(prompt, (str, list)) else None
     else:
         message = record.get("message")
     if not isinstance(message, dict):
@@ -180,6 +192,18 @@ def _oversized_entry(provider, prefix):
         value = None
     if not _conversation_record(provider, value):
         return None
+    if value == "attachment":
+        # An oversized queued message carries a pasted image; keep its leading text when readable.
+        attachment = _field_start(prefix, "attachment")
+        if attachment is None or '"queued_command"' not in prefix[attachment:attachment + 200]:
+            return None
+        text = _field_start(prefix, "text", prefix.find("{", prefix.find('"prompt"', attachment)))
+        try:
+            text, _ = json.JSONDecoder().raw_decode(prefix, text) if text is not None else ("", 0)
+        except (ValueError, RecursionError):
+            text = ""
+        blocks = _claude_user_content([{"type": "text", "text": text}]) if isinstance(text, str) else []
+        return _entry("user", blocks[0]["text"] if blocks else "")
     message = _field_start(prefix, "payload" if provider == "codex" else "message")
     if message is None or prefix[message:message + 1] != "{":
         return None

package/src/history_content.py

@@ -0,0 +1,144 @@
+"""Bounded provider evidence for resumable interactive history rows."""
+
+import json
+import os
+import re
+import shlex
+import time
+
+from .conversation import MAX_LINE_BYTES, MAX_PAGE_BYTES, _entries, _redact
+from .interactive_usage import (
+    MAX_TRANSCRIPT_CANDIDATES,
+    MAX_TRANSCRIPT_SCAN_SECONDS,
+    _timestamp,
+    conversation_transcript,
+    resolve_transcript,
+)
+
+_WRAPPERS = re.compile(
+    r"<(?P<tag>local-command-caveat|command-name|command-message|command-args|local-command-stdout|"
+    r"local-command-stderr|system-reminder|environment_context|instructions)>.*?</(?P=tag)>", re.S,
+)
+
+
+def _identity_arg(args):
+    args = list(args or [])
+    if "-c" in args:
+        index = args.index("-c") + 1
+        try:
+            args = shlex.split(args[index])
+        except (IndexError, ValueError, TypeError):
+            return None
+    for index, arg in enumerate(args):
+        if arg == "--":
+            break
+        if arg in ("--session-id", "--resume", "resume") and index + 1 < len(args):
+            identifier = args[index + 1]
+            if isinstance(identifier, str) and re.fullmatch(r"[0-9a-fA-F-]{36}", identifier):
+                return identifier
+    return None
+
+
+def clean_prompt(text):
+    text = _WRAPPERS.sub("", text).strip()
+    lines = [line for line in text.splitlines() if not re.fullmatch(
+        r"\s*(?:(?:/|~/|[A-Za-z]:[\\/]|\.\.?[/\\])\S+|[\w./\\-]+\.[A-Za-z0-9]{1,10})\s*", line)]
+    return _redact("\n".join(lines).strip())
+
+
+def first_user_prompt(provider, path):
+    if not path:
+        return None
+    try:
+        with open(path, "rb") as handle:
+            scanned = 0
+            names = {}
+            while scanned < MAX_PAGE_BYTES:
+                line = handle.readline(MAX_LINE_BYTES + 1)
+                if not line:
+                    break
+                scanned += len(line)
+                if len(line) > MAX_LINE_BYTES:
+                    return None
+                try:
+                    record = json.loads(line)
+                except (ValueError, UnicodeError, RecursionError):
+                    continue
+                texts = [clean_prompt(entry["text"]) for entry in _entries(provider, record, names)
+                         if entry["role"] == "user"]
+                text = "\n".join(text for text in texts if text)
+                if text:
+                    return text[:2000]
+    except OSError:
+        pass
+    return None
+
+
+def _new_codex_id(auth_home, entry):
+    """Only a unique rollout created in this launch's project/time can identify it."""
+    start = _timestamp(entry.get("started_at"))
+    end = _timestamp(entry.get("ended_at"))
+    cwd = entry.get("cwd")
+    if start is None or not cwd:
+        return None
+    deadline = time.monotonic() + MAX_TRANSCRIPT_SCAN_SECONDS
+    found = set()
+    count = 0
+    for directory, _, names in os.walk(os.path.join(auth_home, "sessions")):
+        if time.monotonic() >= deadline:
+            return None
+        for name in names:
+            if time.monotonic() >= deadline:
+                return None
+            if not name.endswith(".jsonl"):
+                continue
+            count += 1
+            if count > MAX_TRANSCRIPT_CANDIDATES:
+                return None
+            try:
+                with open(os.path.join(directory, name), encoding="utf-8") as handle:
+                    record = json.loads(handle.readline(64 * 1024))
+                payload = record.get("payload") or {}
+                stamp = _timestamp(record.get("timestamp") or payload.get("timestamp"))
+                identifier = payload.get("id") or payload.get("session_id")
+                if (record.get("type") == "session_meta" and stamp is not None and stamp >= start
+                        and (end is None or stamp <= end) and isinstance(payload.get("cwd"), str)
+                        and os.path.realpath(payload["cwd"]) == os.path.realpath(cwd)
+                        and isinstance(identifier, str) and conversation_transcript("codex", auth_home, identifier)):
+                    found.add(identifier)
+            except (OSError, ValueError, TypeError, AttributeError, RecursionError):
+                continue
+    return next(iter(found)) if len(found) == 1 else None
+
+
+def enrich_history(entry, session):
+    entry = dict(entry)
+    provider = entry.get("provider") or session.get("provider")
+    home = session.get("authHome")
+    if provider not in ("claude", "codex") or not home:
+        return entry
+    identifier = entry.get("conversation_id")
+    if not identifier:
+        identifier = _identity_arg(entry.get("args")) if entry.get("action") != "run" else None
+    if not identifier and provider == "codex" and entry.get("action") != "run":
+        identifier = _new_codex_id(home, entry)
+    path = conversation_transcript(provider, home, identifier) if identifier else None
+    if path:
+        entry.update(conversation_id=identifier, provider_transcript_path=path,
+                     provider_transcript_match="conversation_id")
+    elif identifier:
+        # A known identity whose transcript is absent must never target another session.
+        entry["conversation_id"] = identifier
+        path = None
+    else:
+        path = entry.get("provider_transcript_path")
+        if not path and entry.get("action") != "run":
+            path, _ = resolve_transcript(provider, home, entry.get("started_at"), cwd=entry.get("cwd"))
+        if path and entry.get("action") != "run":
+            entry.update(provider_transcript_path=path, provider_transcript_match="recency")
+    prompt = first_user_prompt(provider, path)
+    if prompt:
+        entry["first_user_prompt"] = prompt
+    elif entry.get("first_user_prompt"):
+        entry["first_user_prompt"] = clean_prompt(entry["first_user_prompt"]) or None
+    return entry

package/src/session_service.py

@@ -688,9 +688,18 @@ def record_launch_history(store, name, payload):
         "launch": session.get("launch") or {},
         **payload,
     }
-    store["append_launch_history"](entry)
+    from .history_content import enrich_history
+
     if entry.get("action") != "run":
-        _observe_codex_conversation(store, session)
+        entry = enrich_history(entry, session)
+    store["append_launch_history"](entry)
+    if entry.get("action") != "run" and entry.get("status") != "running":
+        if session["provider"] == PROVIDER_CODEX and entry.get("provider_transcript_match") == "conversation_id":
+            store["update_session"](name, lambda s: {
+                **s, "conversation": {"id": entry["conversation_id"], "provenance": "observed", "recordedAt": _local_now_iso()},
+            })
+        elif entry.get("action") not in ("launch", "resume"):
+            _observe_codex_conversation(store, session)
     return entry
 
 
@@ -726,7 +735,25 @@ def _observe_codex_conversation(store, session):
 def get_launch_history(store, name=None, limit=20):
     if name and not store["get_session"](name):
         raise CdxError(f"Unknown session: {name}")
-    return store["list_launch_history"](session_name=name, limit=limit)
+    entries = store["list_launch_history"](session_name=name, limit=0)
+    known = {entry.get("run_id") for entry in entries if entry.get("run_id")}
+    # Older supervisors only wrote history on exit. Expose their active runtime
+    # without inventing completed history or duplicating newly recorded launches.
+    sessions = [store["get_session"](name)] if name else store["list_sessions"]()
+    for session in sessions:
+        runtime = _session_runtime(store, session["name"])
+        if not runtime or not runtime.get("runId") or runtime["runId"] in known:
+            continue
+        entries.insert(0, {
+            "schema_version": 1, "session_name": session["name"], "provider": session["provider"],
+            "launch": session.get("launch") or {}, "action": "launch", "status": "running",
+            "run_id": runtime["runId"], "started_at": runtime.get("startedAt"),
+            "cwd": runtime.get("cwd"), "pid": runtime.get("pid"), "label": runtime.get("label"),
+            "project": runtime.get("project"), "project_source": runtime.get("project_source", "unknown"),
+            "transcript_path": runtime.get("transcriptPath"),
+            "conversation_id": (session.get("conversation") or {}).get("id") if session["provider"] == PROVIDER_CLAUDE else None,
+        })
+    return entries[:limit] if limit else entries
 
 
 def backfill_interactive_usage(store, name=None, dry_run=True):

package/src/session_store.py

@@ -253,6 +253,24 @@ def create_session_store(base_dir):
     def append_launch_history(entry):
         with _file_lock(lock_file):
             _ensure_dir(state_dir)
+            if entry.get("run_id") and entry.get("action") in ("launch", "resume"):
+                try:
+                    with open(launch_history_file, encoding="utf-8") as handle:
+                        lines = handle.readlines()
+                except FileNotFoundError:
+                    lines = []
+                for index, line in enumerate(lines):
+                    try:
+                        previous = json.loads(line)
+                    except ValueError:
+                        continue
+                    if (previous.get("run_id") == entry["run_id"]
+                            and previous.get("session_name") == entry.get("session_name")
+                            and previous.get("action") in ("launch", "resume")):
+                        lines[index] = json.dumps({**previous, **entry}, separators=(",", ":")) + "\n"
+                        atomic_write(launch_history_file, "".join(lines))
+                        _fsync_directory(state_dir)
+                        return
             with open(launch_history_file, "a", encoding="utf-8") as handle:
                 handle.write(json.dumps(entry, separators=(",", ":")))
                 handle.write("\n")