oh-my-opencode 4.13.0 → 4.14.0

package/packages/omo-codex/plugin/skills/coding-agent-sessions/references/all-platforms.md

@@ -0,0 +1,71 @@
+# Cross-Platform Session Search
+
+## Default locations
+
+Search these first, then add user-supplied roots with `--root`:
+
+Registered platform keys: `codex`, `claude`, `senpi`, `opencode`, `openclaw`, `droid`, `amp`, `gemini`, `kimi`, `qwen`, `codebuff`, `roo-code`, `kilo-code`, `cline`, `kodu`, `cursor-cli`, `aider`, `kilo-cli`, `hermes`, `goose`, `crush`, `zed`, `kiro`.
+
+| Platform | Unix/macOS | Windows |
+|---|---|---|
+| Codex | `$CODEX_HOME`, `~/.codex` | `%CODEX_HOME%`, `%USERPROFILE%\.codex` |
+| Claude | `~/.claude` | `%USERPROFILE%\.claude`, `%APPDATA%\Claude` |
+| Senpi / pi | `~/.senpi/agent`, `~/.pi/agent` | `%USERPROFILE%\.senpi\agent`, `%USERPROFILE%\.pi\agent` |
+| OpenCode | `$OPENCODE_HOME`, `~/.opencode`, `~/.local/share/opencode` | `%OPENCODE_HOME%`, `%APPDATA%\opencode`, `%USERPROFILE%\.opencode` |
+| OpenClaw | `~/.openclaw/agents/*/sessions`, `~/.openclaw/session-backups` | pass `--root` |
+| Factory Droid | `~/.factory/sessions/*/*.jsonl` | pass `--root` |
+| Amp | `~/.local/share/amp/threads/T-*.json` | pass `--root` |
+| Gemini / Kimi / Qwen | `~/.gemini/tmp/*/chats`, `~/.kimi/sessions/*/*/wire.jsonl`, `~/.qwen/projects/*/chats` | pass `--root` |
+| Codebuff | `~/.config/manicode*/projects/*/chats/*/chat-messages.json` | pass `--root` |
+| Roo Code (`roo-code`) / Kilo Code (`kilo-code`) / Cline | VS Code `globalStorage/<extension>/tasks/*` | VS Code `globalStorage\<extension>\tasks\*` |
+| Kodu | VS Code `globalStorage/kodu-ai.claude-dev-experimental/db/Azad.db` | VS Code `globalStorage\kodu-ai.claude-dev-experimental\db\Azad.db` |
+| Cursor CLI | `~/.cursor/chats/*/*/store.db`, `~/.cursor/prompt_history.json` | `%USERPROFILE%\.cursor\chats` |
+| Aider | bounded project roots containing `.aider.chat.history.md`; use `--root` for other repos | pass `--root` |
+| Kilo CLI (`kilo-cli`) / Hermes / Goose / Crush / Zed | Known SQLite roots are probed cheaply; unsupported schemas return empty | pass `--root` |
+| Kiro | `~/.kiro/sessions/cli/*.json` plus paired `*.jsonl` prompt events | pass `--root` |
+
+## Excluded usage-only sources
+
+Do not add these as default transcript platforms without a separate prompt-reconstruction source:
+
+| Source | Why excluded |
+|---|---|
+| Copilot OTEL | Token/telemetry rows, not prompts |
+| Mux | `session-usage.json` usage buckets only |
+| Antigravity | tokscale cache/RPC data, not raw chat transcripts |
+| Synthetic | Provider retagging over another platform, not an independent session store |
+| Cursor IDE usage CSV | Usage accounting; use `cursor-cli` for local CLI chat stores |
+
+## Workflow
+
+1. Run `scripts/find-agent-sessions.py search <query>` across all platforms, or repeat `--query` for several searches in one scan. Add `--include-subagents` when the work may have run inside a delegated agent — child transcripts are excluded from `list`/`search` by default.
+2. If results are noisy, add `--cwd`, `--model`, `--from`, or repeated `--platform` filters.
+3. Run `get <session-id>` on likely hits. The result includes a `subagents` array: every child session (Claude Task/workflow agents, Codex thread spawns, OpenCode child sessions) with its own id, `agent` label, and raw path — follow up with `get <child-id>` for a child's events.
+4. Open raw `path` files for exact quotes, tool calls, and evidence.
+
+## Subagent linkage cheat sheet
+
+| Platform | Child identity | Parent linkage | Agent label |
+|---|---|---|---|
+| Claude | `projects/<proj>/<sid>/subagents/**/agent-<agentId>.jsonl` | directory `<sid>` | `agent-*.meta.json` `agentType` |
+| Codex | thread row + own rollout JSONL | `thread_spawn_edges` / `source.subagent.thread_spawn.parent_thread_id` | `agent_nickname (agent_role)` |
+| OpenCode | `session` table row / `storage/session/**.json` | `parent_id` column / `parentID` field | `agent` column |
+
+## Parallelism
+
+The finder scans selected platforms concurrently, parses transcript files concurrently, joins OpenCode message/part files concurrently, and evaluates repeated `--query` values concurrently. Increase `--workers` for large local stores:
+
+```bash
+python3 scripts/find-agent-sessions.py search --query "commit" --query "deploy" --workers 64
+python3 scripts/find-agent-sessions.py search --query "commit" --platform senpi --platform opencode --workers 64
+```
+
+Omit `--platform` for the full multi-platform search. Add repeated platform flags such as `--platform openclaw --platform droid` only when the user already knows the likely stores. Comma-separated platform values are intentionally unsupported.
+
+The default scan is intentionally probe-first: optional platforms check for exact store roots before globbing or opening files. This avoids expensive home-wide searches while still making newly installed local agents visible without changing the command.
+
+OpenCode is optimized differently from raw JSONL stores: it calls `opencode db path`, reads the SQLite session table directly, falls back to `opencode session list --format json`, and only scans `messages/` / `parts/` when the DB/CLI is unavailable or explicit `--root` values force a file-store lookup.
+
+## Evidence rule
+
+Never answer "what happened in a session" from the normalized preview alone. Use the preview to locate candidates, then inspect the raw transcript or `get` output.

package/packages/omo-codex/plugin/skills/coding-agent-sessions/references/claude.md

@@ -0,0 +1,32 @@
+# Claude Session Stores
+
+Observed Claude formats:
+
+- `~/.claude/projects/<encoded-cwd>/*.jsonl`: Claude Code project sessions (main sessions; filename = session ID).
+- `~/.claude/transcripts/ses_*.jsonl`: compact transcript exports with simple `type`, `timestamp`, `content`, and tool fields.
+- `~/.claude/pre-compact-session-histories/*.jsonl`: pre-compaction histories with `sessionId`, `cwd`, `message`, `uuid`, `parentUuid`, and tool result metadata.
+
+For project files, `sessionId`, `cwd`, `version`, `gitBranch`, and `message.model` are usually embedded in each line. For transcript exports, the filename may be the only stable session ID.
+
+When reconstructing a Claude session, preserve the event order from the JSONL file and distinguish assistant text, thinking, tool use, tool result, and progress events.
+
+## Subagent transcripts (per-session directory)
+
+Each main session may own a sibling directory named after the session ID:
+
+```
+projects/<encoded-cwd>/<session-id>/
+├── subagents/
+│   ├── agent-<agentId>.jsonl        # Task-tool subagent transcript
+│   ├── agent-<agentId>.meta.json    # {"agentType", "description", "toolUseId"}
+│   └── workflows/wf_<id>/
+│       ├── agent-<agentId>.jsonl    # Workflow-spawned agent transcripts
+│       ├── agent-<agentId>.meta.json
+│       └── journal.jsonl            # workflow orchestration journal — NOT a session
+├── workflows/wf_<id>.json           # workflow run metadata
+└── tool-results/*.txt               # persisted oversized tool outputs
+```
+
+Subagent JSONL lines look like main-session lines but carry `isSidechain: true`, `agentId`, `promptId`, and `sessionId` pointing at the PARENT session — never treat a subagent file's `sessionId` as its own identity; use the `agentId` (also in the filename) and take the parent from the directory path. The first line's user message is the delegated task prompt; `agent-*.meta.json` gives the human-readable `description` and `agentType`.
+
+The finder models these as `platform: claude` sessions with `id = <agentId>`, `parent_id = <session-id>`, `agent = agentType`. `get <main-session-id>` lists them under `subagents`; `get <agentId>` returns the child transcript events. Older Claude Code versions inlined sidechains in the main JSONL (`isSidechain: true` lines) instead of separate files.

package/packages/omo-codex/plugin/skills/coding-agent-sessions/references/codex.md

@@ -0,0 +1,30 @@
+# Codex Sessions
+
+Codex has two useful surfaces:
+
+- `$CODEX_HOME/state_*.sqlite` stores thread metadata.
+- `$CODEX_HOME/sessions/**/rollout-*.jsonl` and archived rollout files store event transcripts.
+
+Use the broad finder for Codex discovery:
+
+```bash
+python3 scripts/find-agent-sessions.py list --platform codex --limit 10
+python3 scripts/find-agent-sessions.py search "deploy" --platform codex
+python3 scripts/find-agent-sessions.py search --query "deploy" --query "token usage" --platform codex --workers 32
+python3 scripts/find-agent-sessions.py get <session-id> --platform codex
+```
+
+Important filters: `--from`, `--to`, `--cwd`, `--model`, `--root`, `--limit`, and `--include-subagents`.
+
+## Spawned (subagent) threads
+
+Codex subagent threads are ordinary rows in `threads` with their own rollout files. Two linkage sources:
+
+- `thread_spawn_edges(parent_thread_id, child_thread_id, status)` — authoritative parent→child table.
+- `threads.source` — `cli` / `exec` / `vscode` for user-started threads, or JSON for spawned ones:
+  - `{"subagent": "review"}`, `{"subagent": "memory_consolidation"}` — built-in side threads.
+  - `{"subagent": {"thread_spawn": {"parent_thread_id": "...", "depth": 1, "agent_nickname": "Tesla", "agent_role": "explorer"}}}` — collab/multi-agent spawns (depth can exceed 1: children spawn grandchildren).
+
+`threads` also carries `agent_nickname`, `agent_role`, `model`, `first_user_message`, `tokens_used`. Without the SQLite DB, the same linkage is in each rollout file's first line: `type: "session_meta"` whose `payload` has `id`, `cwd`, `model_provider`, `forked_from_id`, and the same `source.subagent.thread_spawn` object.
+
+The finder maps these to `parent_id` and `agent = "nickname (role)"`; `get <parent-thread-id>` lists children under `subagents`, and `get <child-thread-id>` returns the child's rollout events.

package/packages/omo-codex/plugin/skills/coding-agent-sessions/references/opencode.md

@@ -0,0 +1,43 @@
+# OpenCode Session Stores
+
+## Fast path
+
+Prefer the OpenCode CLI index before touching session files:
+
+```bash
+opencode db path
+sqlite3 "$(opencode db path)" 'select id, title, directory, time_updated from session order by time_updated desc limit 2000'
+opencode session list --format json --max-count 100
+```
+
+Use direct SQLite via `opencode db path` for ordinary `list` and title/session-ID/cwd searches. It queries OpenCode's own indexed session database and avoids expensive scans across `messages/` and `parts/`. Use `opencode session list --format json` as the next fallback when direct DB access is unavailable.
+
+Only fall back to file joins when `opencode` is not installed, the command fails, or the user passes an explicit `--root` for a nonstandard store.
+
+## Subagent (child) sessions
+
+Child sessions spawned by the task tool / subagents are ordinary rows in the `session` table:
+
+- `session.parent_id` — parent session ID (`NULL` for main sessions). Tens of thousands of child rows are normal.
+- `session.agent` — subagent name (`explore`, `plan`, `librarian`, `Sisyphus-Junior`, ...).
+- Child titles often end with the convention `"... (@<agent> subagent)"`.
+
+```bash
+sqlite3 "$(opencode db path)" "select id, agent, title from session where parent_id='<parent-id>' order by time_created"
+```
+
+In the file store, the same linkage is the `parentID` field of `storage/session/<project-hash>/ses_*.json` info files. The finder surfaces children with `parent_id` + `agent` set; `get <parent-id>` lists them under `subagents`.
+
+## File fallback
+
+Observed OpenCode layouts vary by version:
+
+- `~/.opencode/messages/ses_*/*.json`: message metadata.
+- `~/.opencode/parts/msg_*/*.json`: message parts, including text and synthetic compaction context.
+- `~/.opencode/sessions/**`: newer session indexes or compatibility storage.
+- `~/.local/share/opencode/storage/session/<project-hash>/ses_*.json`: session info files (`id`, `parentID`, `title`, `directory`, `time.created/updated`) — sibling `storage/message/` and `storage/part/` (singular) dirs hold content.
+- `~/.local/share/opencode/storage/**`: older or Linux/XDG storage, often with session/message JSON or SQLite-backed data.
+
+Message metadata usually contains `sessionID`, `role`, `time.created`, `agent`, `model.providerID`, `model.modelID`, and `path.cwd`. Text content may live in `parts/<message-id>/*.json`.
+
+When answering from OpenCode, join messages to parts by `messageID` and order by `time.created` or part time. Compaction injections are useful for continuity but should be labeled as synthetic.

package/packages/omo-codex/plugin/skills/coding-agent-sessions/references/senpi.md

@@ -0,0 +1,17 @@
+# Senpi / pi Coding-Agent Sessions
+
+Observed Senpi layout:
+
+- `~/.senpi/agent/sessions/<encoded-cwd>/<timestamp>_<uuid>.jsonl`
+- `~/.senpi/agent/settings.json`, `models.json`, and `auth.json` provide environment context.
+- `~/.pi/agent/sessions/**` can use the same family of JSONL formats.
+
+Common event types:
+
+- `session`: includes `id`, `timestamp`, and `cwd`.
+- `model_change`: includes `provider` and `modelId`.
+- `thinking_level_change`: includes effort metadata.
+- `message`: wraps provider-native messages, tool calls, usage, and costs.
+- `custom` with `customType: senpi.todo-state`: stores todo state.
+
+Prefer Senpi usage fields when present: `usage.input`, `usage.output`, `usage.cacheRead`, `usage.cacheWrite`, `usage.totalTokens`, and `usage.cost.total`.

package/packages/omo-codex/plugin/skills/coding-agent-sessions/scripts/agent_sessions/__init__.py

@@ -0,0 +1 @@
+from __future__ import annotations

package/packages/omo-codex/plugin/skills/coding-agent-sessions/scripts/agent_sessions/claude.py

@@ -0,0 +1,66 @@
+from __future__ import annotations
+
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from pathlib import Path
+
+from .jsonio import as_map, iter_jsonl, read_json, text
+from .timeparse import file_time
+from .transcript import content_text, env_path, existing, jsonl_parallel, recent
+from .types import Session
+
+
+def scan_claude(extra_roots: tuple[Path, ...], workers: int) -> list[Session]:
+    appdata = env_path("APPDATA")
+    roots = existing([Path.home() / ".claude", *(path / "Claude" for path in (appdata,) if path is not None), *extra_roots])
+    mains: list[Path] = []
+    subagents: list[Path] = []
+    for root in roots:
+        mains.extend((root / "transcripts").glob("*.jsonl"))
+        mains.extend((root / "projects").glob("*/*.jsonl"))
+        mains.extend((root / "pre-compact-session-histories").glob("*.jsonl"))
+        subagents.extend((root / "projects").glob("*/*/subagents/**/agent-*.jsonl"))
+    sessions = jsonl_parallel(recent(mains), workers, "claude", lambda path: path.stem)
+    sessions.extend(_subagent_parallel(recent(subagents), workers))
+    return sessions
+
+
+def _subagent_parallel(paths: list[Path], workers: int) -> list[Session]:
+    if not paths:
+        return []
+    sessions: list[Session] = []
+    with ThreadPoolExecutor(max_workers=min(workers, max(len(paths), 1))) as pool:
+        futures = [pool.submit(_subagent_session, path) for path in paths]
+        for future in as_completed(futures):
+            session = future.result()
+            if session is not None:
+                sessions.append(session)
+    return sessions
+
+
+def _subagent_session(path: Path) -> Session | None:
+    parts = path.parts
+    if "subagents" not in parts:
+        return None
+    parent_sid = parts[parts.index("subagents") - 1]
+    meta = as_map(read_json(path.with_name(path.stem + ".meta.json"))) or {}
+    first = next(iter_jsonl(path), None) or {}
+    message = as_map(first.get("message")) or {}
+    description = text(meta.get("description")) or ""
+    task = content_text(message.get("content"))
+    prompt = "\n".join(part for part in (description, task) if part)
+    created = text(first.get("timestamp")) or file_time(path)
+    return Session(
+        "claude",
+        path.stem.removeprefix("agent-"),
+        str(path),
+        text(first.get("cwd")),
+        created,
+        file_time(path) or created,
+        None,
+        None,
+        prompt,
+        {},
+        parent_sid,
+        text(meta.get("agentType")),
+        prompt,
+    )

package/packages/omo-codex/plugin/skills/coding-agent-sessions/scripts/agent_sessions/cli.py

@@ -0,0 +1,283 @@
+from __future__ import annotations
+
+import os
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from pathlib import Path
+
+from .jsonio import as_map, dumps, iter_jsonl
+from .scanners import DEFAULT_PLATFORMS, scan
+from .timeparse import date_bound, parse_stamp
+from .transcript import user_text
+from .types import Json, JsonMap, Options, Session
+
+
+def main() -> int:
+    command, opts, rest = _parse()
+    sessions = sorted(scan(opts.platforms, opts.roots, opts.workers), key=lambda item: item.created_at or "", reverse=True)
+    if command == "list":
+        _emit(_list_payload(_filter(sessions, opts), sessions, opts.limit, include_subagents=opts.include_subagents))
+        return 0
+    if command == "search":
+        queries = _queries(opts, rest)
+        _require(list(queries), "search requires a query")
+        _emit(_search_payload(_filter(sessions, opts), sessions, queries, opts.limit, opts.workers, include_subagents=opts.include_subagents))
+        return 0
+    if command == "get":
+        _require(rest, "read requires at least one session id")
+        _emit(_get_payload(sessions, rest))
+        return 0
+    raise SystemExit(f"unknown command: {command}")
+
+
+def _parse() -> tuple[str, Options, list[str]]:
+    import sys
+
+    args = sys.argv[1:]
+    if not args or args[0] in {"-h", "--help"}:
+        usage = (
+            "Usage: find-agent-sessions.py list|find|search|read|get [query|ids...] [--query TEXT ...] "
+            "[--platform NAME ...] [--root PATH] [--from DATE] [--to DATE] [--cwd TEXT] "
+            "[--model TEXT] [--limit N] [--workers N] [--include-subagents]"
+        )
+        print(usage)
+        raise SystemExit(0)
+    command = args.pop(0)
+    if command == "find":
+        command = "search"
+    elif command == "read":
+        command = "get"
+    roots: list[Path] = []
+    queries: list[str] = []
+    platforms: list[str] = []
+    date_from = date_to = cwd = model = None
+    limit = 20
+    workers = _default_workers()
+    include_subagents = False
+    rest: list[str] = []
+    index = 0
+    while index < len(args):
+        arg = args[index]
+        if arg == "--root":
+            roots.append(Path(args[index + 1]).expanduser())
+            index += 2
+        elif arg == "--query":
+            queries.append(args[index + 1])
+            index += 2
+        elif arg == "--platform":
+            platform = args[index + 1].strip().lower()
+            if "," in platform:
+                raise SystemExit("Use repeated --platform flags, for example: --platform senpi --platform opencode")
+            platforms.append(platform)
+            index += 2
+        elif arg == "--from":
+            date_from = args[index + 1]
+            index += 2
+        elif arg == "--to":
+            date_to = args[index + 1]
+            index += 2
+        elif arg == "--cwd":
+            cwd = args[index + 1].lower()
+            index += 2
+        elif arg == "--model":
+            model = args[index + 1].lower()
+            index += 2
+        elif arg == "--limit":
+            limit = int(args[index + 1])
+            index += 2
+        elif arg == "--workers":
+            workers = max(int(args[index + 1]), 1)
+            index += 2
+        elif arg == "--include-subagents":
+            include_subagents = True
+            index += 1
+        else:
+            rest.append(arg)
+            index += 1
+    selected_platforms = frozenset(platforms) if platforms else DEFAULT_PLATFORMS
+    return command, Options(selected_platforms, tuple(roots), tuple(queries), date_from, date_to, cwd, model, limit, workers, include_subagents), rest
+
+
+def _filter(sessions: list[Session], opts: Options) -> list[Session]:
+    start = date_bound(opts.date_from)
+    end = date_bound(opts.date_to, end=True)
+    result: list[Session] = []
+    for item in sessions:
+        stamp = parse_stamp(item.created_at)
+        if start is not None and stamp is not None and stamp < start:
+            continue
+        if end is not None and stamp is not None and stamp >= end:
+            continue
+        if opts.cwd is not None and opts.cwd not in (item.cwd or "").lower():
+            continue
+        if opts.model is not None and opts.model not in (item.model or "").lower():
+            continue
+        result.append(item)
+    return result
+
+
+def _child_counts(sessions: list[Session]) -> dict[tuple[str, str], int]:
+    counts: dict[tuple[str, str], int] = {}
+    for item in sessions:
+        if item.parent_id is not None:
+            key = (item.platform, item.parent_id)
+            counts[key] = counts.get(key, 0) + 1
+    return counts
+
+
+def _annotate(item: Session, counts: dict[tuple[str, str], int]) -> JsonMap:
+    data = item.to_json()
+    data["subagent_count"] = counts.get((item.platform, item.id), 0)
+    data["detail_hint"] = _detail_hint(item)
+    return data
+
+
+def _list_payload(filtered: list[Session], all_sessions: list[Session], limit: int, include_subagents: bool = False) -> JsonMap:
+    counts = _child_counts(all_sessions)
+    candidates = filtered if include_subagents else [item for item in filtered if item.parent_id is None]
+    results: list[Json] = [_annotate(item, counts) for item in candidates[:limit]]
+    return {"count": len(results), "results": results}
+
+
+def _search_payload(filtered: list[Session], all_sessions: list[Session], queries: tuple[str, ...], limit: int, workers: int, include_subagents: bool = False) -> JsonMap:
+    counts = _child_counts(all_sessions)
+    candidates = filtered if include_subagents else [item for item in filtered if item.parent_id is None]
+    per_query: list[Json] = []
+    merged: dict[tuple[str, str], tuple[Session, list[JsonMap]]] = {}
+    with ThreadPoolExecutor(max_workers=min(workers, max(len(queries), 1))) as pool:
+        futures = [pool.submit(_search_one, candidates, query, limit) for query in queries]
+        for future in as_completed(futures):
+            query, matches = future.result()
+            per_query.append({"query": query, "count": len(matches), "results": [_annotate_search(item, counts, reasons) for item, reasons in matches]})
+            for item, reasons in matches:
+                key = (item.platform, item.id)
+                if key not in merged:
+                    merged[key] = (item, reasons)
+    results: list[Json] = [_annotate_search(item, counts, reasons) for item, reasons in list(merged.values())[:limit]]
+    return {"count": len(results), "queries": per_query, "results": results}
+
+
+def _get_payload(sessions: list[Session], ids: list[str]) -> JsonMap:
+    counts = _child_counts(sessions)
+    results: list[Json] = []
+    for item in sessions:
+        if item.id not in ids and not any(item.id.startswith(prefix) for prefix in ids):
+            continue
+        events = _events(item)
+        first_prompt, last_prompt = _prompt_edges(item, events)
+        session = _annotate(item, counts)
+        session["first_user_message"] = first_prompt[:300]
+        session["last_user_message"] = last_prompt[:300]
+        children = sorted(
+            (child for child in sessions if child.platform == item.platform and child.parent_id == item.id),
+            key=lambda child: child.created_at or "",
+        )
+        results.append(
+            {
+                "session": session,
+                "prompts": {"first_user_message": first_prompt, "last_user_message": last_prompt},
+                "events": events,
+                "subagents": [_annotate(child, counts) for child in children],
+                "detail_hint": _detail_hint(item),
+            }
+        )
+    return {"count": len(results), "results": results}
+
+
+def _annotate_search(item: Session, counts: dict[tuple[str, str], int], reasons: list[JsonMap]) -> JsonMap:
+    data = _annotate(item, counts)
+    reason_rows: list[Json] = []
+    reason_rows.extend(reasons)
+    data["match_reasons"] = reason_rows
+    return data
+
+
+def _detail_hint(item: Session) -> str:
+    return f"python3 scripts/find-agent-sessions.py read {item.id} --platform {item.platform}"
+
+
+def _events(item: Session) -> list[Json]:
+    if item.path.endswith(".jsonl"):
+        return list(iter_jsonl(Path(item.path)))
+    events: list[Json] = []
+    if item.first_user_message:
+        events.append({"type": "message", "message": {"role": "user", "content": item.first_user_message}})
+    if item.last_user_message and item.last_user_message != item.first_user_message:
+        events.append({"type": "message", "message": {"role": "user", "content": item.last_user_message}})
+    return events
+
+
+def _prompt_edges(item: Session, events: list[Json]) -> tuple[str, str]:
+    first_prompt = item.first_user_message
+    last_prompt = item.last_user_message or item.first_user_message
+    for event in events:
+        if not isinstance(event, dict):
+            continue
+        message = as_map(event.get("message")) or as_map(event.get("payload")) or {}
+        prompt = user_text(event, message)
+        if prompt:
+            first_prompt = first_prompt or prompt
+            last_prompt = prompt
+    return first_prompt, last_prompt
+
+
+def _match_reasons(item: Session, query: str) -> list[JsonMap]:
+    needle = query.lower()
+    reasons: list[JsonMap] = []
+    for field, value in _search_fields(item):
+        if needle in value.lower():
+            reasons.append({"query": query, "platform": item.platform, "field": field, "snippet": _snippet(value, needle)})
+    return reasons
+
+
+def _search_fields(item: Session) -> tuple[tuple[str, str], ...]:
+    return (
+        ("platform", item.platform),
+        ("id", item.id),
+        ("path", item.path),
+        ("cwd", item.cwd or ""),
+        ("provider", item.provider or ""),
+        ("model", item.model or ""),
+        ("agent", item.agent or ""),
+        ("first_user_message", item.first_user_message),
+        ("last_user_message", item.last_user_message),
+    )
+
+
+def _snippet(value: str, needle: str) -> str:
+    start = max(value.lower().find(needle) - 60, 0)
+    end = min(start + 160, len(value))
+    return value[start:end]
+
+
+def _queries(opts: Options, rest: list[str]) -> tuple[str, ...]:
+    if opts.queries:
+        return opts.queries
+    joined = " ".join(rest).strip()
+    return (joined,) if joined else ()
+
+
+def _search_one(sessions: list[Session], query: str, limit: int) -> tuple[str, list[tuple[Session, list[JsonMap]]]]:
+    matches: list[tuple[Session, list[JsonMap]]] = []
+    for item in sessions:
+        reasons = _match_reasons(item, query)
+        if reasons:
+            matches.append((item, reasons))
+    return query, matches[:limit]
+
+
+def _emit(value: JsonMap) -> None:
+    print(dumps(value))
+
+
+def _require(values: list[str], message: str) -> None:
+    if not values:
+        raise SystemExit(message)
+
+
+def _default_workers() -> int:
+    cpu = os.cpu_count() or 4
+    return min(max(cpu * 4, 8), 64)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/packages/omo-codex/plugin/skills/coding-agent-sessions/scripts/agent_sessions/codex.py

@@ -0,0 +1,105 @@
+from __future__ import annotations
+
+import sqlite3
+from pathlib import Path
+from typing import TypeAlias
+
+from .timeparse import unix_seconds
+from .transcript import env_path, existing, flat_parallel, jsonl_parallel, nick_role, recent, spawn_info, stem_id
+from .types import Json, Session
+
+THREADS_SQL = (
+    "SELECT id, rollout_path, cwd, created_at, updated_at, model_provider, model, first_user_message, tokens_used, "
+    "source, agent_nickname, agent_role FROM threads"
+)
+LEGACY_THREADS_SQL = (
+    "SELECT id, rollout_path, cwd, created_at, updated_at, model_provider, model, first_user_message, tokens_used FROM threads"
+)
+SPAWN_EDGES_SQL = "SELECT child_thread_id, parent_thread_id FROM thread_spawn_edges"
+
+SqliteScalar: TypeAlias = str | int | float | bytes | None
+CodexRow: TypeAlias = tuple[SqliteScalar, ...]
+
+
+def scan_codex(extra_roots: tuple[Path, ...], workers: int) -> list[Session]:
+    roots = existing([*(path for path in (env_path("CODEX_HOME"),) if path is not None), Path.home() / ".codex", *extra_roots])
+    db_paths: list[Path] = []
+    rollouts: list[Path] = []
+    for root in roots:
+        db_paths.extend(root.glob("state_*.sqlite"))
+        rollouts.extend((root / "sessions").rglob("rollout-*.jsonl"))
+        rollouts.extend((root / "archived_sessions").glob("rollout-*.jsonl"))
+    sessions = flat_parallel(db_paths, workers, _codex_db)
+    sessions.extend(jsonl_parallel(recent(rollouts), workers, "codex", lambda path: stem_id(path, "rollout-")))
+    return sessions
+
+
+def _codex_db(path: Path) -> list[Session]:
+    conn: sqlite3.Connection | None = None
+    try:
+        conn = sqlite3.connect(str(path), timeout=3)
+        edges = _spawn_edges(conn)
+        rows = _thread_rows(conn)
+    except sqlite3.Error:
+        return []
+    finally:
+        if conn is not None:
+            conn.close()
+    return [_codex_row(path, row, edges) for row in rows]
+
+
+def _thread_rows(conn: sqlite3.Connection) -> list[CodexRow]:
+    try:
+        primary_rows: list[CodexRow] = conn.execute(THREADS_SQL).fetchall()
+        return primary_rows
+    except sqlite3.Error:
+        legacy_rows: list[CodexRow] = conn.execute(LEGACY_THREADS_SQL).fetchall()
+        return legacy_rows
+
+
+def _spawn_edges(conn: sqlite3.Connection) -> dict[str, str]:
+    try:
+        rows: list[CodexRow] = conn.execute(SPAWN_EDGES_SQL).fetchall()
+    except sqlite3.Error:
+        return {}
+    edges: dict[str, str] = {}
+    for row in rows:
+        child = _row_text(_row_value(row, 0))
+        parent = _row_text(_row_value(row, 1))
+        if child is not None and parent is not None:
+            edges[child] = parent
+    return edges
+
+
+def _codex_row(path: Path, row: CodexRow, edges: dict[str, str]) -> Session:
+    thread_id = str(_row_value(row, 0))
+    source_parent, source_agent = spawn_info(_row_text(_row_value(row, 9)))
+    return Session(
+        "codex",
+        thread_id,
+        str(_row_value(row, 1) or path),
+        _row_text(_row_value(row, 2)),
+        unix_seconds(_row_number(_row_value(row, 3))),
+        unix_seconds(_row_number(_row_value(row, 4))),
+        _row_text(_row_value(row, 5)),
+        _row_text(_row_value(row, 6)),
+        _row_text(_row_value(row, 7)) or "",
+        {"total_tokens": _row_number(_row_value(row, 8))},
+        edges.get(thread_id) or source_parent,
+        nick_role(_row_text(_row_value(row, 10)), _row_text(_row_value(row, 11))) or source_agent,
+    )
+
+
+def _row_text(value: Json | int | float | None) -> str | None:
+    return value if isinstance(value, str) else None
+
+
+def _row_number(value: Json | int | float | None) -> int | float | None:
+    return value if isinstance(value, int | float) else None
+
+
+def _row_value(row: CodexRow, index: int) -> Json | int | float | None:
+    value = row[index] if index < len(row) else None
+    if value is None or isinstance(value, str | int | float | bool):
+        return value
+    return None