parawatch 0.3.10 → 0.3.11

package/dist/adapters/claudeCode.js

@@ -508,4 +508,52 @@ function metaIsCurrent(file) {
         return false;
     }
 }
+/**
+ * Which run of a Claude Code session is running a command right now: the session itself, or one of
+ * its subagents. A subagent's commands get the session's own `CLAUDE_CODE_SESSION_ID`, so only the
+ * logs tell them apart: the run whose log ends on a pending Bash call matching `command`, the
+ * newest one if several do. Returns the subagent's id, or undefined for the session itself (or
+ * when the logs do not say).
+ */
+export function callingSubagent(session, command, now = Date.now()) {
+    const root = claudeProjectsDir();
+    let dirs;
+    try {
+        dirs = fs.readdirSync(root);
+    }
+    catch {
+        return undefined;
+    }
+    const pendingAt = (file) => {
+        try {
+            if (now - fs.statSync(file).mtimeMs > 120_000)
+                return undefined;
+            const recs = readTailLines(file, 64 * 1024).filter(isObj);
+            const last = recs[recs.length - 1];
+            if (!last || last.type !== "assistant")
+                return undefined;
+            const call = blocks(last).find((b) => b.type === "tool_use" && b.name === "Bash" && command.test(str(b.input?.command) ?? ""));
+            return call ? (str(last.timestamp) ?? new Date(fs.statSync(file).mtimeMs).toISOString()) : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    };
+    for (const d of dirs) {
+        const own = path.join(root, d, `${session}.jsonl`);
+        if (!fs.existsSync(own))
+            continue;
+        let best;
+        const mine = pendingAt(own);
+        if (mine)
+            best = { at: mine };
+        for (const f of listJsonl(path.join(root, d, session, "subagents"))) {
+            const at = pendingAt(f);
+            if (at && (!best || at > best.at))
+                best = { id: path.basename(f, ".jsonl").replace(/^agent-/, ""), at };
+        }
+        return best?.id;
+    }
+    return undefined;
+}
 //# sourceMappingURL=claudeCode.js.map

package/dist/bin/cli.js

@@ -5,6 +5,7 @@ import { Command } from "commander";
 import { UserError, addProject, answerCard, beatRun, claimSession, closeCard, dismissCard, commentCard, inboxScope, editCard, endRun, hideRun, unhideRun, linkPr, listeners, listenersFor, noteRun, openCard, prEvent, findCard, readInbox, readState, removeProject, startListening, startRun, unlinkPr, waitInbox, } from "../core/ops.js";
 import { githubConfig, readCache, resolvePrRef, syncGithub, prViews } from "../core/github.js";
 import { recordPrompt } from "../core/prompts.js";
+import { callingSubagent } from "../adapters/claudeCode.js";
 import { digest, digestText, localDate } from "../core/digest.js";
 import { everywhere, readEvents } from "../core/store.js";
 import { followEvents } from "../core/follow.js";
@@ -331,9 +332,12 @@ program
     .option("--kind <kind>", "'scheduled' for a session a schedule starts again and again")
     .option("--done <summary>", "the work is finished; one line on how it ended")
     .action((session, o) => {
-    const id = session ?? currentSession();
+    let id = session ?? currentSession();
     if (!id)
         throw new UserError("no session id given and none found in the environment (CLAUDE_CODE_SESSION_ID, CODEX_THREAD_ID)");
+    // a subagent runs with its session's id; its claim is its own, not a new name for the session
+    if (!session && process.env.CLAUDE_CODE_SESSION_ID === id)
+        id = callingSubagent(id, /\bparawatch\b.*\bclaim\b/) ?? id;
     if (o.kind !== undefined && o.kind !== "scheduled")
         throw new UserError("--kind can only be 'scheduled'");
     const c = claimSession({ session: id, project: o.project, task: o.task, role: o.role, title: o.title, kind: o.kind, done: o.done });

package/dist/core/ops.js

@@ -610,13 +610,26 @@ export async function waitInbox(consumer, filter, timeoutMs, pollMs = 1000) {
         const dir = eventsDir();
         fs.mkdirSync(dir, { recursive: true });
         watcher = fs.watch(dir, () => wake?.());
+        // on Windows a watched folder a sync tool writes into can report EPERM; polling goes on
+        watcher.on("error", () => {
+            watcher?.close();
+            watcher = undefined;
+        });
     }
     catch {
         watcher = undefined; // polling alone still works
     }
     try {
         for (;;) {
-            const items = readInbox(consumer, filter, true);
+            let items = [];
+            try {
+                items = readInbox(consumer, filter, true);
+            }
+            catch (err) {
+                // a file busy for a moment is read again on the next poll; a wait must not end without an answer
+                if (!["EPERM", "EBUSY", "EACCES"].includes(err.code ?? ""))
+                    throw err;
+            }
             if (items.length)
                 return items;
             const left = deadline - Date.now();

package/dist/core/snapshot.js

@@ -1,3 +1,5 @@
+import fs from "node:fs";
+import path from "node:path";
 import { prViews, keyOf, parsePrRef, readCache, githubConfig, githubFailing } from "./github.js";
 import { endedSessions, linkPr, listeners, readState } from "./ops.js";
 import { collectRuns } from "./runs.js";
@@ -16,7 +18,12 @@ export function snapshot(opts = {}) {
         state = readState();
     const all = [...state.cards.values()].filter((c) => !opts.project || c.project === opts.project);
     const ended = endedSessions(state);
-    const cards = [...all.filter((c) => c.status !== "closed"), ...recentlyClosed(all, opts.closed ?? 0)].map((c) => c.status !== "closed" && c.session && ended(c.session) ? { ...c, ownerEnded: true } : c);
+    const cards = [...all.filter((c) => c.status !== "closed"), ...recentlyClosed(all, opts.closed ?? 0)]
+        .map((c) => (c.status !== "closed" && c.session && ended(c.session) ? { ...c, ownerEnded: true } : c))
+        .map((c) => {
+        const missing = notHere([...(c.attach ?? []), ...(c.open ?? [])]);
+        return missing.length ? { ...c, missing } : c;
+    });
     quietAnsweredAsks(runs, all);
     const cache = readCache();
     const enabled = githubConfig().enabled && (cache.hosts === undefined ? false : cache.hosts.length > 0);
@@ -63,6 +70,10 @@ function linkCreatedPrs(runs, state) {
     }
     return added;
 }
+/** Files named by absolute path (on either system) that this machine does not have. */
+function notHere(targets) {
+    return targets.filter((t) => (path.isAbsolute(t) || /^[A-Za-z]:[\\/]/.test(t)) && !/^[a-z][a-z0-9+.-]*:\/\//i.test(t) && !fs.existsSync(t));
+}
 /** A question asked in chat is no longer pending once the session put it on a card. */
 function quietAnsweredAsks(runs, cards) {
     for (const r of runs) {

package/dist/core/store.js

@@ -150,17 +150,33 @@ export function withLock(fn) {
     }
 }
 // ------------------------------------------------------------------ reading
+/** What each log held at its last good reading, for a moment when it cannot be opened. */
+const lastRead = new Map();
+/** Errors a sync tool causes for a moment while it replaces a file (Windows mostly). */
+const BUSY = new Set(["EPERM", "EBUSY", "EACCES"]);
 function readFileEvents(f) {
     let text;
-    try {
-        text = fs.readFileSync(f.file, "utf8");
-    }
-    catch (err) {
-        if (err.code === "ENOENT")
-            return [];
-        throw err;
+    for (let attempt = 0; text === undefined; attempt++) {
+        try {
+            text = fs.readFileSync(f.file, "utf8");
+        }
+        catch (err) {
+            const code = err.code ?? "";
+            if (code === "ENOENT")
+                return [];
+            if (!BUSY.has(code))
+                throw err;
+            // Syncthing and cloud drives write a new copy and rename it over the old one; on Windows the
+            // file cannot be opened during the swap. Try again shortly, then go on with the last reading.
+            if (attempt < 5)
+                sleepSync(50);
+            else
+                return lastRead.get(f.file) ?? [];
+        }
     }
-    return parseEventLines(text, f.device);
+    const events = parseEventLines(text, f.device);
+    lastRead.set(f.file, events);
+    return events;
 }
 /**
  * Every event, from every machine, in time order. Each machine's own order is kept as written;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "parawatch",
-  "version": "0.3.10",
+  "version": "0.3.11",
   "description": "A control tower for people running many AI coding agents in parallel: see what is running, what needs you, and wake the right agent when you answer.",
   "keywords": [
     "ai-agents",