parawatch 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 penspanic
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,207 @@
-# Temporary Holding Version
+# parawatch
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+A control tower for people who run many AI coding agents at once, across several projects and several tasks inside each one.
+
+<picture>
+  <source media="(prefers-color-scheme: dark)" srcset="docs/app-dark.png">
+  <img src="docs/app-light.png" alt="The parawatch desktop app: a chart of the last hour of agent activity per project, then the cards that need you, one with two screenshots and three options." width="560">
+</picture>
+
+It answers three questions:
+
+- **What needs me?** Decisions to make, builds or videos to try, things only you can do.
+- **What is running?** Every agent session, its subagents and its `codex exec` jobs, grouped by project, with what each one is doing right now.
+- **Did my answer reach the agent?** When you answer a card, the agent waiting on it wakes up. You do not go back to the chat to say "I decided".
+
+parawatch is a CLI first. Agents use the CLI, and so can you. There is no server and nothing leaves your machine. On top of the CLI, this repository has a [desktop app](apps/desktop/README.md) (the panel above, a menu bar count, a Dock badge and notifications).
+
+```
+$ parawatch status
+NEEDS YOU  3
+  c1   decide   game/139  Which ending for the shake box?                12m
+  c2   try      game/139  Try build 139: does the glass read as glass?    4m
+  c3   blocked  app       Install the iPad simulator runtime              1h
+
+AGENTS  5 working
+app
+  ● Interval lesson screen        1m  Bash: Build the app
+  ○ App Director                 24m  PR 18 passed. Waiting for the simulator runtime.
+game
+  ● Game Director                 1s  Bash: Wait for answers
+  ├ ● 139 shake round 2           1s  Bash: Run tests
+  ├ ● Generate the level icons    2m  exec: python3 make_icons.py
+  └ ● Glass shader pass           9m  Bash: Capture the tank
+```
+
+One line per item, always inside the terminal width. Finished subagents fold into a count after five minutes (`parawatch runs --all` shows them). `--wide` adds the runtime and ids. Colors follow `NO_COLOR` and `FORCE_COLOR`.
+
+## Install
+
+There are three parts. Most people want all three.
+
+**The CLI**, which agents and you use:
+
+```
+npm install -g parawatch
+```
+
+**The agent skill**, so Claude Code and Codex agents learn the protocol on their own:
+
+```
+parawatch skill install
+```
+
+It links [`skills/parawatch`](skills/parawatch/SKILL.md) into `~/.claude/skills` and `~/.codex/skills`. The installed skill is a link to the copy in the package, so updating parawatch updates the skill.
+
+**The desktop app**, to see and answer cards without a terminal. On macOS, download the DMG from the [latest release](https://github.com/penspanic/parawatch/releases/latest): `arm64` for Apple silicon, `x64` for Intel. It is signed and notarized, so it opens without warnings. Elsewhere, [build it from source](apps/desktop/README.md#run-from-source).
+
+### Platforms
+
+| | macOS | Linux | Windows |
+|--|--|--|--|
+| CLI | used daily | tests pass in CI | not supported yet |
+| Desktop app | used daily | untested | untested |
+| Agent logs read | Claude Code, Codex | same | |
+
+Node 20 or newer.
+
+## Concepts
+
+| | |
+|--|--|
+| **Project** | A name and one or more paths. Git worktrees of a path belong to the project too. |
+| **Card** | Something that needs the human. Four kinds: `decide` (pick an option or write an answer), `try` (open a build, watch a video, look at a screen), `block` (only the human can do it and the agent is stuck until they do: install, sudo, sign in), `todo` (only the human can do it, but nothing waits on it now: check a bill, register a company). A card remembers the session that opened it, and `--since` keeps when the matter first came up when it is older than the card. |
+| **Run** | An agent at work. Most runs are *observed*: parawatch reads the agent's own log. Jobs that leave no log (a bake, a benchmark) can be *declared* with `parawatch run start`. |
+| **Lead** | A role, not a concept of its own. Claim a session with `--role lead` and it shows at the top of its project with its children under it. |
+
+## For the human
+
+```
+parawatch status                 # what needs you, then what is running
+parawatch cards                  # open and answered cards
+parawatch show c4                # one card with its body, options and attachments
+parawatch answer c4 -c 2         # pick option 2
+parawatch answer c4 -m "fill it to the rim"          # or just say something
+parawatch answer c5 -m "glass is too dark" --attach ~/Desktop/shot.png
+parawatch runs --since 12        # agents seen in the last 12 hours
+parawatch runs -p game --all    # include finished ones
+parawatch runs --wide            # with runtime and ids
+```
+
+Register projects once:
+
+```
+parawatch project add game ~/dev/game
+parawatch project add app ~/dev/app ~/notes/app
+parawatch claim 811a9612 -p game --role lead --title "Game Director"
+```
+
+`claim` is for sessions that do not start inside a project path (an agent run from a notes folder, a scratch directory). Children of a claimed session follow it.
+
+## For agents
+
+Add the agent protocol to a project's instruction file:
+
+```
+parawatch init -f AGENTS.md -p game     # or CLAUDE.md
+```
+
+It writes a short block between `<!-- parawatch:begin -->` and `<!-- parawatch:end -->` and replaces it in place on later runs. The protocol in short:
+
+```
+parawatch ask -p game "Which ending?" -o "Side tank" -o "Top box" -r 2 -b "two or three lines"
+parawatch try -p game "Try build 139" --open /path/Game.app --look "does the glass read?"
+parawatch block -p app "Install the iPad simulator runtime"
+parawatch todo -p game "Check the GitHub bill" --since 2026-10-01
+parawatch wait -p game           # run in the background; exits when the human answers
+parawatch comment c4 "baking the top box now"   # a note on the card; does not wake anyone
+parawatch close c4 -n "used the top box"
+```
+
+`parawatch edit <card>` changes a card after the fact: its kind, wording, task, who asked or `--since`. `parawatch goto <card>` opens the session that asked in the Claude desktop app (`--copy` also puts a line about the card on the clipboard, to paste there); sessions outside the desktop app get the `claude --resume` command instead.
+
+`wait` prints the answers and exits with code 0. With `--timeout <seconds>` it exits with code 2 when nothing came. An answer given before `wait` starts is not lost: each consumer has its own cursor, and `wait` returns everything after it.
+
+### Agent skill
+
+[`skills/parawatch/SKILL.md`](skills/parawatch/SKILL.md) teaches an agent the whole protocol: claiming its session, writing a good card, keeping one background wait armed, closing cards, declaring long jobs, and who asks the human when a lead runs workers. Install it with `parawatch skill install` (see [Install](#install)); `parawatch skill path` prints where it lives, for runtimes that load skills from elsewhere.
+
+`claim`, `run start` and every card command pick up the calling session from `$CLAUDE_CODE_SESSION_ID` (or `$CODEX_THREAD_ID`), so an agent can put itself on the board without knowing its id.
+
+### Waking a Claude Code session
+
+Claude Code re-invokes a session when one of its background commands exits. So an agent that runs `parawatch wait -p <project>` as a background command is woken by your answer, with the answer as the command's output.
+
+As a backstop, the hook adds any unhandled answers to the next turn of a session in that project:
+
+```json
+{
+  "hooks": {
+    "UserPromptSubmit": [{ "hooks": [{ "type": "command", "command": "parawatch hook claude-code" }] }],
+    "SessionStart": [{ "hooks": [{ "type": "command", "command": "parawatch hook claude-code" }] }]
+  }
+}
+```
+
+The hook only peeks. The agent's own `wait` or `inbox` moves its cursor.
+
+### Other runtimes
+
+Anything that can run a command and notice when it exits can use `wait`. `parawatch inbox` returns at once (add `--peek` to leave the cursor where it is), for runtimes that poll.
+
+## Observed agents
+
+parawatch reads agent logs. It never writes to them and never sends them anywhere.
+
+| Runtime | Where it reads | What it shows |
+|--|--|--|
+| Claude Code | `~/.claude/projects/*/<session>.jsonl` and `<session>/subagents/` (or `$CLAUDE_CONFIG_DIR`) | sessions with their title, subagents with their description and model, the tool in flight |
+| Codex | `~/.codex/sessions/` (or `$CODEX_HOME`) | `codex exec` jobs and interactive sessions with their prompt and last tool call; jobs started from a Claude Code session show under it |
+
+States: `●` working, `◐` waiting, `○` idle, `✓` done, `!` stalled (quiet longer than its tool's timeout allows), `✗` failed.
+
+Runs that match no registered project show under `other`. A run belongs to a project by, in order: a claim, its working directory, its parent's project, a project path named in its first prompt.
+
+### Adding a runtime
+
+An adapter is one file in `src/adapters/` that implements:
+
+```ts
+interface Adapter {
+  name: string;
+  scan(opts: { sinceMs: number; now: number }): Run[];
+}
+```
+
+It reads only, reads only files touched since `sinceMs`, and reads only the head and tail of large logs.
+
+## Apps, plugins and dashboards
+
+| | |
+|--|--|
+| [`apps/desktop`](apps/desktop/README.md) | The desktop app. Reads and writes the store directly, so it works without the CLI on `PATH`. |
+| [`packages/panel`](packages/panel) | The panel both of them show, as plain DOM, with a harness page for working on it. |
+
+Anything else can build on the same two commands:
+
+```
+parawatch status --json          # one snapshot: projects, cards, runs
+parawatch watch                  # every new event as one JSON line
+parawatch watch --from 120       # starting after event 120
+```
+
+## Storage
+
+Everything lives in one append-only file, `~/.local/state/parawatch/events.jsonl` (`$PARAWATCH_HOME`, or `$XDG_STATE_HOME/parawatch`). Writers take a short lock, so several agents can write at once. Cursors live next to it in `cursors/`. Delete the folder to start over.
+
+Desktop notifications for new cards use `osascript` on macOS and `notify-send` on Linux. `PARAWATCH_NOTIFY=0` turns them off. While the desktop app runs it notifies instead, and the CLI stays quiet. To-dos never notify.
+
+## Not goals
+
+- Starting or steering agents. Use whatever you already use; parawatch only watches and carries answers back.
+- A shared team tracker. It is for one person and their agents, on one machine.
+- Replacing your issue tracker. Cards are short-lived questions, not the backlog.
+
+## License
+
+MIT

package/dist/adapters/claudeCode.js

@@ -0,0 +1,226 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { isObj, logActivity, oneLine, readHeadLines, readTailLines, str } from "./jsonl.js";
+const HEAD_BYTES = 96 * 1024;
+const TAIL_BYTES = 384 * 1024;
+export function claudeProjectsDir() {
+    if (process.env.PARAWATCH_CLAUDE_DIR)
+        return process.env.PARAWATCH_CLAUDE_DIR;
+    const base = process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), ".claude");
+    return path.join(base, "projects");
+}
+function blocks(rec) {
+    const msg = rec.message;
+    if (!isObj(msg))
+        return [];
+    const c = msg.content;
+    if (typeof c === "string")
+        return [{ type: "text", text: c }];
+    return Array.isArray(c) ? c.filter(isObj) : [];
+}
+function isConversation(rec) {
+    return (rec.type === "user" || rec.type === "assistant") && rec.isMeta !== true;
+}
+function toolSummary(b) {
+    const inp = b.input ?? {};
+    const pick = str(inp.description) || str(inp.command) || str(inp.file_path) || str(inp.pattern) || str(inp.prompt) || str(inp.url);
+    const short = pick && (inp.file_path === pick ? path.basename(pick) : pick);
+    return short ? `${b.name}: ${oneLine(short, 80)}` : String(b.name ?? "tool");
+}
+/** A prompt the human (or parent agent) typed, not a tool result or system notice. */
+function promptText(rec) {
+    if (rec.type !== "user" || rec.isMeta === true)
+        return undefined;
+    const bs = blocks(rec);
+    if (bs.some((b) => b.type === "tool_result"))
+        return undefined;
+    const text = bs.filter((b) => b.type === "text").map((b) => b.text ?? "").join("\n").trim();
+    if (!text || text.startsWith("<"))
+        return undefined;
+    return text;
+}
+/** Work out what a Claude Code transcript is doing from its last records. */
+export function readClaudeTail(recs, kind) {
+    const out = { state: "unknown" };
+    let lastConv;
+    for (const r of recs) {
+        if (!isObj(r))
+            continue;
+        const ts = str(r.timestamp);
+        if (ts && (!out.lastActivity || ts > out.lastActivity))
+            out.lastActivity = ts;
+        if (str(r.cwd))
+            out.cwd = str(r.cwd);
+        if (r.type === "custom-title" && str(r.customTitle))
+            out.title = str(r.customTitle);
+        if (r.type === "agent-name" && str(r.agentName) && !out.title)
+            out.title = str(r.agentName);
+        if (isConversation(r))
+            lastConv = r;
+    }
+    if (!lastConv)
+        return out;
+    const bs = blocks(lastConv);
+    if (lastConv.type === "assistant") {
+        const tool = [...bs].reverse().find((b) => b.type === "tool_use");
+        if (tool) {
+            out.state = "working";
+            out.action = toolSummary(tool);
+            const t = tool.input?.timeout;
+            if (typeof t === "number")
+                out.pendingTimeoutMs = t;
+        }
+        else if (bs.some((b) => b.type === "text" && b.text?.trim())) {
+            out.state = kind === "subagent" ? "done" : "idle";
+            const text = bs.filter((b) => b.type === "text").map((b) => b.text ?? "").join(" ");
+            out.action = oneLine(text, 100);
+        }
+        else {
+            out.state = "working";
+            out.action = "thinking";
+        }
+    }
+    else {
+        out.state = "working";
+        const result = bs.find((b) => b.type === "tool_result");
+        out.action = result ? "thinking" : "reading a new message";
+    }
+    return out;
+}
+function firstPrompt(file) {
+    const out = {};
+    for (const r of readHeadLines(file, HEAD_BYTES)) {
+        if (!isObj(r))
+            continue;
+        if (!out.startedAt && str(r.timestamp))
+            out.startedAt = str(r.timestamp);
+        if (!out.cwd && str(r.cwd))
+            out.cwd = str(r.cwd);
+        if (!out.prompt)
+            out.prompt = promptText(r);
+        if (out.prompt && out.cwd && out.startedAt)
+            break;
+    }
+    return out;
+}
+function readMeta(file) {
+    try {
+        const data = JSON.parse(fs.readFileSync(file.replace(/\.jsonl$/, ".meta.json"), "utf8"));
+        return isObj(data) ? data : {};
+    }
+    catch {
+        return {};
+    }
+}
+const STALL_MS = 20 * 60_000;
+export function applyStall(run, pendingTimeoutMs, now) {
+    if (run.state !== "working" || !run.lastActivity)
+        return;
+    const quiet = now - Date.parse(run.lastActivity);
+    const allowed = Math.max(STALL_MS, (pendingTimeoutMs ?? 0) + 2 * 60_000);
+    if (quiet > allowed)
+        run.state = "stalled";
+}
+function listJsonl(dir) {
+    try {
+        return fs.readdirSync(dir).filter((f) => f.endsWith(".jsonl")).map((f) => path.join(dir, f));
+    }
+    catch {
+        return [];
+    }
+}
+function fresh(file, sinceMs) {
+    try {
+        return fs.statSync(file).mtimeMs >= sinceMs;
+    }
+    catch {
+        return false;
+    }
+}
+export const claudeCode = {
+    name: "claude-code",
+    scan(opts) {
+        const root = claudeProjectsDir();
+        let dirs;
+        try {
+            dirs = fs.readdirSync(root).map((d) => path.join(root, d));
+        }
+        catch {
+            return [];
+        }
+        const runs = [];
+        for (const dir of dirs) {
+            for (const file of listJsonl(dir)) {
+                if (fresh(file, opts.sinceMs))
+                    runs.push(readSession(file, opts.now));
+            }
+            let subdirs = [];
+            try {
+                subdirs = fs.readdirSync(dir).map((d) => path.join(dir, d, "subagents"));
+            }
+            catch {
+                // not a directory listing we can read
+            }
+            for (const sub of subdirs) {
+                for (const file of listJsonl(sub)) {
+                    if (fresh(file, opts.sinceMs))
+                        runs.push(readSubagent(file, opts.now));
+                }
+            }
+        }
+        return runs;
+    },
+};
+function readSession(file, now) {
+    const id = path.basename(file, ".jsonl");
+    const base = { id, runtime: "claude-code", kind: "session", title: id.slice(0, 8), state: "unknown", source: file };
+    try {
+        const head = firstPrompt(file);
+        const tail = readClaudeTail(readTailLines(file, TAIL_BYTES), "session");
+        const run = {
+            ...base,
+            title: tail.title || (head.prompt ? oneLine(head.prompt, 60) : base.title),
+            cwd: tail.cwd || head.cwd,
+            startedAt: head.startedAt,
+            lastActivity: tail.lastActivity,
+            state: tail.state,
+            action: tail.action,
+            prompt: head.prompt ? oneLine(head.prompt, 400) : undefined,
+            activity: logActivity(file, now),
+        };
+        applyStall(run, tail.pendingTimeoutMs, now);
+        return run;
+    }
+    catch (err) {
+        return { ...base, error: `could not read: ${err.message}` };
+    }
+}
+function readSubagent(file, now) {
+    const id = path.basename(file, ".jsonl").replace(/^agent-/, "");
+    const parent = path.basename(path.dirname(path.dirname(file)));
+    const base = { id, runtime: "claude-code", kind: "subagent", parent, title: id.slice(0, 8), state: "unknown", source: file };
+    try {
+        const meta = readMeta(file);
+        const head = firstPrompt(file);
+        const tail = readClaudeTail(readTailLines(file, TAIL_BYTES), "subagent");
+        const run = {
+            ...base,
+            title: str(meta.description) || (head.prompt ? oneLine(head.prompt, 60) : base.title),
+            model: str(meta.model),
+            cwd: tail.cwd || head.cwd,
+            startedAt: head.startedAt,
+            lastActivity: tail.lastActivity,
+            state: tail.state,
+            action: tail.action,
+            prompt: head.prompt ? oneLine(head.prompt, 400) : undefined,
+            activity: logActivity(file, now),
+        };
+        applyStall(run, tail.pendingTimeoutMs, now);
+        return run;
+    }
+    catch (err) {
+        return { ...base, error: `could not read: ${err.message}` };
+    }
+}
+//# sourceMappingURL=claudeCode.js.map

package/dist/adapters/codex.js

@@ -0,0 +1,185 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { applyStall } from "./claudeCode.js";
+import { isObj, logActivity, oneLine, readHeadLines, readHeadText, readTailLines, str, textValues } from "./jsonl.js";
+const HEAD_BYTES = 128 * 1024;
+const TAIL_BYTES = 256 * 1024;
+// prompts can sit behind several inline base64 images on one line; read this far only when needed
+const RAW_HEAD_BYTES = 16 * 1024 * 1024;
+export function codexSessionsDir() {
+    if (process.env.PARAWATCH_CODEX_DIR)
+        return process.env.PARAWATCH_CODEX_DIR;
+    const base = process.env.CODEX_HOME || path.join(os.homedir(), ".codex");
+    return path.join(base, "sessions");
+}
+const PARENT_IN_CWD = /\/claude-\d+\/[^/]+\/([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})(?:\/|$)/;
+/** A Claude Code session id when Codex was started from inside that session's scratch space. */
+export function parentFromCwd(cwd) {
+    return cwd ? PARENT_IN_CWD.exec(cwd)?.[1] : undefined;
+}
+function payload(r) {
+    return isObj(r) && isObj(r.payload) ? r.payload : undefined;
+}
+function messageText(p) {
+    const c = p.content;
+    if (!Array.isArray(c))
+        return "";
+    return c
+        .filter(isObj)
+        .map((b) => str(b.text) ?? "")
+        .join("\n")
+        .trim();
+}
+function promptBlock(p) {
+    const c = p.content;
+    if (!Array.isArray(c))
+        return undefined;
+    for (const b of c.filter(isObj)) {
+        const t = (str(b.text) ?? "").trim();
+        if (!t || t.startsWith("<") || t.startsWith("# AGENTS.md instructions"))
+            continue;
+        return t;
+    }
+    return undefined;
+}
+function toolSummary(p) {
+    const name = str(p.name) ?? "tool";
+    let arg = str(p.input) ?? str(p.arguments) ?? "";
+    try {
+        const parsed = JSON.parse(arg);
+        if (isObj(parsed))
+            arg = str(parsed.cmd) ?? str(parsed.command) ?? (Array.isArray(parsed.command) ? parsed.command.join(" ") : arg);
+    }
+    catch {
+        // free-form input
+    }
+    return arg ? `${name}: ${oneLine(arg, 80)}` : name;
+}
+/** The first real prompt in user messages whose lines were too long to parse (inline images). */
+export function promptFromRaw(raw) {
+    for (const line of raw.split("\n")) {
+        if (!line.includes('"role":"user"'))
+            continue;
+        for (const t of textValues(line)) {
+            const v = t.trim();
+            if (v && !v.startsWith("<") && !v.startsWith("# AGENTS.md instructions"))
+                return v;
+        }
+    }
+    return undefined;
+}
+export function readCodexLog(head, tail, rawHead) {
+    const meta = head.map(payload).find((p, i) => p && isObj(head[i]) && head[i].type === "session_meta");
+    const id = str(meta?.id) ?? str(meta?.session_id) ?? "unknown";
+    const cwd = str(meta?.cwd);
+    const exec = str(meta?.originator) === "codex_exec" || str(meta?.source) === "exec";
+    let prompt;
+    for (const r of head) {
+        const p = payload(r);
+        if (isObj(r) && r.type === "response_item" && p?.type === "message" && p.role === "user") {
+            // skip injected context: environment blocks, image tags, AGENTS.md instructions
+            const t = promptBlock(p);
+            if (t) {
+                prompt = t;
+                break;
+            }
+        }
+    }
+    if (!prompt && rawHead)
+        prompt = promptFromRaw(rawHead());
+    const run = {
+        id,
+        runtime: "codex",
+        kind: exec ? "exec" : "session",
+        title: prompt ? oneLine(prompt, 60) : id.slice(0, 8),
+        cwd,
+        parent: parentFromCwd(cwd),
+        startedAt: str(meta?.timestamp) ?? (isObj(head[0]) ? str(head[0].timestamp) : undefined),
+        state: "working",
+        prompt: prompt ? oneLine(prompt, 400) : undefined,
+    };
+    let lastStart = -1;
+    let lastDone = -1;
+    let lastError = -1;
+    tail.forEach((r, i) => {
+        if (!isObj(r))
+            return;
+        const ts = str(r.timestamp);
+        if (ts && (!run.lastActivity || ts > run.lastActivity))
+            run.lastActivity = ts;
+        const p = payload(r);
+        if (!p)
+            return;
+        if (r.type === "event_msg" && p.type === "task_started")
+            lastStart = i;
+        if (r.type === "event_msg" && p.type === "task_complete") {
+            lastDone = i;
+            const msg = str(p.last_agent_message);
+            if (msg)
+                run.action = oneLine(msg, 100);
+        }
+        if (r.type === "event_msg" && (p.type === "error" || p.type === "turn_aborted"))
+            lastError = i;
+        if (r.type === "response_item" && (p.type === "custom_tool_call" || p.type === "function_call")) {
+            if (i > lastDone)
+                run.action = toolSummary(p);
+        }
+        if (r.type === "response_item" && p.type === "message" && p.role === "assistant" && i > lastDone) {
+            const t = messageText(p);
+            if (t)
+                run.action = oneLine(t, 100);
+        }
+    });
+    if (lastError > Math.max(lastStart, lastDone))
+        run.state = "failed";
+    else if (lastDone > lastStart)
+        run.state = exec ? "done" : "idle";
+    return run;
+}
+function dayDirs(root, sinceMs, now) {
+    const out = [];
+    const day = 86_400_000;
+    for (let t = sinceMs - day; t <= now + day; t += day) {
+        const d = new Date(t);
+        const y = String(d.getFullYear());
+        const m = String(d.getMonth() + 1).padStart(2, "0");
+        const dd = String(d.getDate()).padStart(2, "0");
+        const dir = path.join(root, y, m, dd);
+        if (!out.includes(dir))
+            out.push(dir);
+    }
+    return out;
+}
+export const codex = {
+    name: "codex",
+    scan(opts) {
+        const root = codexSessionsDir();
+        const runs = [];
+        for (const dir of dayDirs(root, opts.sinceMs, opts.now)) {
+            let files;
+            try {
+                files = fs.readdirSync(dir).filter((f) => f.startsWith("rollout-") && f.endsWith(".jsonl"));
+            }
+            catch {
+                continue;
+            }
+            for (const f of files) {
+                const file = path.join(dir, f);
+                try {
+                    if (fs.statSync(file).mtimeMs < opts.sinceMs)
+                        continue;
+                    const run = { ...readCodexLog(readHeadLines(file, HEAD_BYTES), readTailLines(file, TAIL_BYTES), () => readHeadText(file, RAW_HEAD_BYTES)), source: file };
+                    run.activity = logActivity(file, opts.now);
+                    applyStall(run, undefined, opts.now);
+                    runs.push(run);
+                }
+                catch (err) {
+                    runs.push({ id: f, runtime: "codex", kind: "exec", title: f, state: "unknown", source: file, error: `could not read: ${err.message}` });
+                }
+            }
+        }
+        return runs;
+    },
+};
+//# sourceMappingURL=codex.js.map

package/dist/adapters/index.js

@@ -0,0 +1,18 @@
+import { claudeCode } from "./claudeCode.js";
+import { codex } from "./codex.js";
+export const adapters = [claudeCode, codex];
+export function scanAll(opts, only) {
+    const runs = [];
+    for (const a of adapters) {
+        if (only && !only.includes(a.name))
+            continue;
+        try {
+            runs.push(...a.scan(opts));
+        }
+        catch (err) {
+            runs.push({ id: `${a.name}-error`, runtime: a.name, kind: "session", title: `${a.name} adapter failed`, state: "unknown", error: err.message });
+        }
+    }
+    return runs;
+}
+//# sourceMappingURL=index.js.map