parawatch 0.0.0-stage → 0.2.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,262 @@
-# 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.
+- **What waits on someone else?** Pull requests waiting on a review, CI or a merge queue, each next to the session that owns it, with how long it has waited.
+- **Did my answer reach the agent?** When you answer a card, or a review lands on its pull request, the agent waiting on it wakes up. You do not go back to the chat to say "I decided" or "a review came in".
+
+parawatch is a CLI first. Agents use the CLI, and so can you. There is no server. Agent logs and cards never leave your machine; the only thing read from outside is your pull requests, through the GitHub CLI you have already signed in, and only when you have it. 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  4
+  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
+  c7   decide   app/PR 21  Merge PR 21 and post the 1.4 release note?      9m
+
+ASKED IN CHAT, NO CARD  1  (read from the log)
+  Pricing page    6m  Publish it now, or wait for the new photos?  (site)
+
+WAITING ON OTHERS  3 · 1 stuck
+  marble-box#139  stuck in merge queue    9h  Game Director           Shake round 2 and the top-box ending
+  ear-trainer#22  review (mina)           5h                          Settings screen
+  ear-trainer#21  merge                  20m  Interval lesson screen  Interval lessons and the count-in
+
+AGENTS  4 working
+app
+  ✓ Interval lesson screen (1 PR)    1m  done · PR 21 is green and reviewed; waiting on the merge
+  ○ App Director                    24m  PR 18 passed. Waiting for the simulator runtime.
+game
+  ● Game Director (1 PR)             0s  Bash: Wait for answers
+  ├ ● 139 shake round 2              0s  Bash: Run tests
+  ├ ● Generate the level icons       2m  exec: python3 make_icons.py
+  └ ! Overnight physics benchmark   24m  stalled · no sign of life for 24m · scene 5 of 8
+site
+  ○ Pricing page                     6m  asks: Publish it now, or wait for the new photos?
+```
+
+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 optionally one or more paths. Git worktrees of a path belong to the project too. |
+| **Claim** | An agent session saying what it works on: a project, a task (a ticket key, a pull request, a short name), a title. It is the main way runs are grouped; guesses from the log are the fallback. A claim can also say the work is done. |
+| **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`, with a heartbeat if they can hang silently. |
+| **Pull request** | Read through `gh`. Linked to the session that owns it, so its news wakes that session. |
+| **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
+parawatch runs --every           # each run of a scheduled task, not one row per task
+parawatch pr list                # open pull requests: what each waits on, since when, whose it is
+parawatch goto api#88            # open the session that owns a pull request
+parawatch digest                 # what each session did today (--date, --json)
+```
+
+Agents say what they work on themselves (`parawatch claim`, below), so nothing has to be registered. Registering a project's paths groups the sessions that start inside it even when they do not claim:
+
+```
+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 a session for it
+```
+
+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 claim -p api -t ABC-1234 --title "Fix the login redirect"   # as soon as the work is clear
+parawatch pr link https://github.com/acme/api/pull/88                 # when it opens a pull request
+parawatch ask -p game "Which ending?" -o "Side tank" -o "Top box" -r 2 -b "two or three lines"
+parawatch ask -p api "Merge PR 88?" --action "gh pr merge 88 --squash" --preview note.md   # an approval
+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 run start -p game "overnight bench" --heartbeat 600 --log bench.log   # a job with no agent log
+parawatch claim --done "Merged #88; login works on staging"                    # when the work is finished
+```
+
+An agent claims the project the work is for, not the folder it runs in, and claims again when it moves to other work. A claim of `--kind scheduled` folds the runs of a schedule into one row. `--done` marks the session finished until someone writes to it again, and its line goes into the digest.
+
+An approval (`ask --action`) shows the exact command and the text it sends, with Do it and Don't, so the human can say yes without opening the session.
+
+`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 news on the project's linked pull requests, 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. While a `wait` runs, cards say an agent is waiting; when none does, an answered card says the answer is kept until the agent next checks.
+
+### 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.
+
+## Pull requests
+
+When the [GitHub CLI](https://cli.github.com) is installed and signed in, parawatch reads your open pull requests and the ones asking for your review, on every host `gh` knows (GitHub Enterprise included). It never holds a token of its own. Without `gh`, all of this stays off.
+
+- **Whose it is.** A session links a pull request with `parawatch pr link <url>`. One it opened with `gh pr create` is linked from its log on its own.
+- **What it waits on.** Review (and from whom), CI, a failed check, requested changes, a conflict, the merge queue, auto-merge, or the merge itself, and since when. Past a limit per state it shows as stuck.
+- **News wakes the owner.** New reviews, approvals, requested changes, comments, CI results, conflicts, leaving the merge queue without merging, and the merge arrive at the owning project's `wait` like an answer. The desktop app notifies what keeps a pull request from landing, and the landing.
+- **Other sources.** A merge bot or a ticket system can record news the same way: `parawatch pr event <url> queue_removed -m "batch 412 failed"`.
+
+GitHub is read when its last reading is older than the interval: by `status`, by a running `wait`, and by the desktop app. `parawatch pr sync` reads it now. Pull requests nobody touched for 60 days are left out unless a session owns them.
+
+`config.json` in the store folder changes the defaults (every key is optional):
+
+```json
+{
+  "github": {
+    "enabled": true,
+    "intervalMinutes": 5,
+    "maxAgeDays": 60,
+    "stallHours": { "review": 24, "CI": 2, "merge queue": 6, "conflict": 4 }
+  }
+}
+```
+
+`PARAWATCH_GITHUB=0` turns it off for one command.
+
+## 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 (a finished subagent, or a session that claimed `--done`), `!` stalled (quiet longer than its tool's timeout allows, or a declared job past its heartbeat), `✗` failed.
+
+A run belongs to a project by, in order: a claim; its working directory, unless it only edits files of another project; its parent's project; the project whose files it edits most; a project path named in its first prompt. Runs that match nothing show under `other`. `--wide` marks the guesses (`~edits`, `~prompt`).
+
+When a session's turn ends with a question for the human and no card, parawatch lists it under ASKED IN CHAT. It reads the Claude desktop app's end-of-turn summary when there is one, else a question at the end of the last message. It is a guess, so agents are told to put questions on cards.
+
+### 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, pull requests, running waits
+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. Next to it: cursors in `cursors/`, running waits in `listeners/`, the last GitHub reading in `github.json`, and the optional `config.json`. 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. It shows other people only as the reviewers your pull requests wait on.
+- Replacing your issue tracker. Cards are short-lived questions, not the backlog.
+
+## License
+
+MIT

package/dist/adapters/claudeCode.js

@@ -0,0 +1,331 @@
+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;
+}
+const EDIT_TOOLS = new Set(["Edit", "Write", "MultiEdit", "NotebookEdit"]);
+const DIR_IN_COMMAND = /(?:^|[;&|]\s*|\s)(?:cd|git\s+-C)\s+("[^"]+"|'[^']+'|[^\s;&|]+)/g;
+const PR_URL = /https?:\/\/[^\s"'<>()]+\/pull\/\d+/g;
+/** The desktop app's end-of-turn tool: a recap, maybe a question for the human. */
+const WRAP_UP = /(^|__)wrap_up$/;
+function resultText(b) {
+    const c = b.content;
+    if (typeof c === "string")
+        return c;
+    if (Array.isArray(c))
+        return c.map((x) => (isObj(x) && typeof x.text === "string" ? x.text : "")).join("\n");
+    return "";
+}
+function unquote(s) {
+    return s.replace(/^["']|["']$/g, "");
+}
+/**
+ * What a log shows about where the work happens and what it produced: folders of edited files and
+ * of `cd`/`git -C` targets (absolute paths only), and pull requests opened with `gh pr create`.
+ */
+export function scanWork(recs) {
+    const touched = [];
+    const add = (dir) => {
+        if (!path.isAbsolute(dir))
+            return;
+        const i = touched.indexOf(dir);
+        if (i >= 0)
+            touched.splice(i, 1);
+        touched.push(dir);
+    };
+    const prCalls = new Set();
+    const prs = [];
+    for (const r of recs) {
+        if (!isObj(r) || !isConversation(r))
+            continue;
+        for (const b of blocks(r)) {
+            if (b.type === "tool_use") {
+                const inp = b.input ?? {};
+                if (EDIT_TOOLS.has(String(b.name))) {
+                    const f = str(inp.file_path) || str(inp.notebook_path);
+                    if (f)
+                        add(path.dirname(f));
+                }
+                else if (b.name === "Bash") {
+                    const cmd = str(inp.command) ?? "";
+                    for (const m of cmd.matchAll(DIR_IN_COMMAND))
+                        add(unquote(m[1]));
+                    if (/\bgh\s+pr\s+create\b/.test(cmd) && b.id)
+                        prCalls.add(b.id);
+                }
+            }
+            else if (b.type === "tool_result" && b.tool_use_id && prCalls.has(b.tool_use_id)) {
+                for (const m of resultText(b).matchAll(PR_URL))
+                    if (!prs.includes(m[0]))
+                        prs.push(m[0]);
+            }
+        }
+    }
+    return { touched: touched.slice(-50), createdPrs: prs };
+}
+/** The last line of an agent's closing message, when it is a question. */
+function trailingQuestion(text) {
+    const lines = text.split("\n").map((l) => l.trim()).filter(Boolean);
+    const last = lines[lines.length - 1];
+    return last && /[?？]\**$/.test(last) ? last : undefined;
+}
+/** Work out what a Claude Code transcript is doing from its last records. */
+export function readClaudeTail(recs, kind) {
+    const out = { state: "unknown" };
+    let lastConv;
+    let wrapUp;
+    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 (promptText(r)) {
+            out.lastPromptAt = ts ?? out.lastPromptAt;
+            wrapUp = undefined; // a new turn began
+        }
+        if (r.type === "assistant") {
+            const w = blocks(r).find((b) => b.type === "tool_use" && WRAP_UP.test(String(b.name)));
+            if (w)
+                wrapUp = { ...(w.input ?? {}), at: ts };
+        }
+    }
+    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 full = bs.filter((b) => b.type === "text").map((b) => b.text ?? "").join("\n");
+            out.action = oneLine(full, 100);
+            if (kind === "session") {
+                const recap = wrapUp && str(wrapUp.recap);
+                if (recap)
+                    out.recap = oneLine(recap, 300);
+                const ask = wrapUp && str(wrapUp.ask);
+                const blocked = wrapUp?.blocked === true;
+                if (ask || blocked)
+                    out.asks = { text: oneLine(ask || recap || full, 200), via: "wrap_up", blocked: blocked || undefined, at: str(wrapUp.at) };
+                else if (!wrapUp) {
+                    const q = trailingQuestion(full);
+                    if (q)
+                        out.asks = { text: oneLine(q.replace(/\*\*/g, ""), 200), via: "text", at: out.lastActivity };
+                }
+            }
+        }
+        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;
+}
+/** A log small enough that its tail already holds the whole file. */
+function sameFile(file) {
+    return fs.statSync(file).size <= TAIL_BYTES;
+}
+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 tailRecs = readTailLines(file, TAIL_BYTES);
+        const tail = readClaudeTail(tailRecs, "session");
+        const work = scanWork(sameFile(file) ? tailRecs : [...readHeadLines(file, HEAD_BYTES), ...tailRecs]);
+        const run = {
+            ...base,
+            lastPromptAt: tail.lastPromptAt,
+            asks: tail.asks,
+            recap: tail.recap,
+            touched: work.touched.length ? work.touched : undefined,
+            createdPrs: work.createdPrs.length ? work.createdPrs : undefined,
+            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 tailRecs = readTailLines(file, TAIL_BYTES);
+        const tail = readClaudeTail(tailRecs, "subagent");
+        const work = scanWork(sameFile(file) ? tailRecs : [...readHeadLines(file, HEAD_BYTES), ...tailRecs]);
+        const run = {
+            ...base,
+            touched: work.touched.length ? work.touched : undefined,
+            createdPrs: work.createdPrs.length ? work.createdPrs : undefined,
+            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