parawatch 0.3.9 → 0.3.10

package/dist/adapters/claudeCode.js

@@ -50,6 +50,12 @@ function promptText(rec) {
         return undefined;
     return text;
 }
+/** A message the log marks as typed or sent by the human, whatever its text looks like. */
+function fromHuman(rec) {
+    if (rec.type !== "user" || rec.isMeta === true || !isObj(rec.origin) || rec.origin.kind !== "human")
+        return false;
+    return !blocks(rec).some((b) => b.type === "tool_result");
+}
 const JOB_STARTED = /(?:running in background with ID|moved to the background \(ID): ([\w-]+)\)?[^\n]{0,80}?\.\s*Output is being written to: (.+?)\.\s+You will be notified/s;
 const JOB_STARTED_NO_PATH = /(?:running in background with ID|moved to the background \(ID): ([\w-]+)/;
 const NOTICE = /<task-notification>([\s\S]*?)<\/task-notification>/g;
@@ -114,9 +120,10 @@ function pendingJobs(recs) {
 }
 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$/;
+/** The tool a subagent calls to hand its report back to its caller; its result is the subagent's end. */
+const HANDBACK = /(^|__)SubagentHandback$/;
 function resultText(b) {
     const c = b.content;
     if (typeof c === "string")
@@ -159,19 +166,46 @@ export function scanWork(recs) {
                     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)
+                    if (runsGhPrCreate(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]);
+                const url = createdPrUrl(resultText(b));
+                if (url && !prs.includes(url))
+                    prs.push(url);
             }
         }
     }
     return { touched: touched.slice(-50), createdPrs: prs };
 }
+/** Shell words that may come before the command itself. */
+const PREFIX_WORD = /^(?:[A-Za-z_][A-Za-z0-9_]*=\S*|env|command|time|noglob|exec|then|do|else|!)$/;
+/**
+ * Whether a shell command runs `gh pr create`, as opposed to mentioning the words: a search for
+ * them, a quoted message, a heredoc. Each command of a list or pipeline is looked at on its own.
+ */
+export function runsGhPrCreate(cmd) {
+    if (!/\bpr\s+create\b/.test(cmd))
+        return false;
+    const bare = cmd
+        .replace(/<<-?\s*(['"]?)(\w+)\1[^\n]*\n[\s\S]*?\n\s*\2\s*(?=\n|$)/g, "") // heredoc bodies
+        .replace(/'[^']*'/g, "''")
+        .replace(/"(?:[^"\\]|\\.)*"/g, '""');
+    for (const seg of bare.split(/&&|\|\||[;|\n&]|\$\(|`|[()]/)) {
+        const words = seg.trim().split(/\s+/).filter(Boolean);
+        while (words.length && PREFIX_WORD.test(words[0]))
+            words.shift();
+        if (/(^|[\\/])gh(\.exe)?$/.test(words[0] ?? "") && words[1] === "pr" && words[2] === "create")
+            return true;
+    }
+    return false;
+}
+/** The URL `gh pr create` prints when it opens a PR: a line of its own, the last one. */
+export function createdPrUrl(output) {
+    const lines = output.split(/\r?\n/).map((l) => l.trim()).filter((l) => /^https?:\/\/\S+\/pull\/\d+$/.test(l));
+    return lines[lines.length - 1];
+}
 /** 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);
@@ -201,6 +235,10 @@ export function readClaudeTail(recs, kind) {
             out.lastPromptAt = ts ?? out.lastPromptAt;
             wrapUp = undefined; // a new turn began
         }
+        else if (fromHuman(r)) {
+            // the human wrote (a pasted block, a command's output): whatever the last wrap-up asked is answered
+            wrapUp = undefined;
+        }
         if (r.type === "assistant") {
             const w = blocks(r).find((b) => b.type === "tool_use" && WRAP_UP.test(String(b.name)));
             if (w)
@@ -215,6 +253,7 @@ export function readClaudeTail(recs, kind) {
         const tool = [...bs].reverse().find((b) => b.type === "tool_use");
         if (tool) {
             out.state = "working";
+            out.pendingTool = true;
             out.action = toolSummary(tool);
             const t = tool.input?.timeout;
             if (typeof t === "number")
@@ -262,9 +301,28 @@ export function readClaudeTail(recs, kind) {
         out.state = "working";
         const result = bs.find((b) => b.type === "tool_result");
         out.action = result ? "thinking" : "reading a new message";
+        if (kind === "subagent" && result && result.is_error !== true && HANDBACK.test(toolName(recs, result.tool_use_id))) {
+            // the report went back to the caller: nothing more comes from this subagent
+            out.state = "done";
+            out.action = "handed its report back";
+        }
     }
     return out;
 }
+/** The name of the tool call a result answers, looked up in the same records. */
+function toolName(recs, id) {
+    if (!id)
+        return "";
+    for (let i = recs.length - 1; i >= 0; i--) {
+        const r = recs[i];
+        if (!isObj(r) || r.type !== "assistant")
+            continue;
+        const b = blocks(r).find((x) => x.type === "tool_use" && x.id === id);
+        if (b)
+            return String(b.name ?? "");
+    }
+    return "";
+}
 function firstPrompt(file) {
     const out = {};
     for (const r of readHeadLines(file, HEAD_BYTES)) {
@@ -392,8 +450,12 @@ function readSession(file, now) {
             action: tail.action,
             prompt: head.prompt ? oneLine(head.prompt, 400) : undefined,
             activity: logActivity(file, now),
+            pendingTool: tail.pendingTool,
         };
         applyStall(run, tail.pendingTimeoutMs, now, newestMtime(tail.pendingOutputs));
+        // in the log a permission prompt and a long command look the same; the hook can tell them apart
+        if (run.state === "stalled" && tail.pendingTool)
+            run.action = `${run.action ?? "a tool call"} · or a permission prompt is open`;
         return run;
     }
     catch (err) {
@@ -424,6 +486,12 @@ function readSubagent(file, now) {
             prompt: head.prompt ? oneLine(head.prompt, 400) : undefined,
             activity: logActivity(file, now),
         };
+        if (meta.finished === true && run.state !== "done" && run.state !== "failed" && metaIsCurrent(file)) {
+            // Claude Code marks a subagent finished in its meta file; the log tail can still look mid-turn
+            run.state = "done";
+            if (run.action === "thinking" || run.action === "reading a new message")
+                run.action = "finished";
+        }
         applyStall(run, tail.pendingTimeoutMs, now, newestMtime(tail.pendingOutputs));
         return run;
     }
@@ -431,4 +499,13 @@ function readSubagent(file, now) {
         return { ...base, error: `could not read: ${err.message}` };
     }
 }
+/** A meta file written after the log's last line; an older one may be from before a resumed turn. */
+function metaIsCurrent(file) {
+    try {
+        return fs.statSync(file.replace(/\.jsonl$/, ".meta.json")).mtimeMs >= fs.statSync(file).mtimeMs - 5_000;
+    }
+    catch {
+        return false;
+    }
+}
 //# sourceMappingURL=claudeCode.js.map

package/dist/bin/cli.js

@@ -4,6 +4,7 @@ import fs from "node:fs";
 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 { digest, digestText, localDate } from "../core/digest.js";
 import { everywhere, readEvents } from "../core/store.js";
 import { followEvents } from "../core/follow.js";
@@ -432,13 +433,16 @@ program
     const open = cards.filter((c) => c.status === "open" && c.kind !== "todo");
     const todo = cards.filter((c) => c.status === "open" && c.kind === "todo");
     const answered = cards.filter((c) => c.status === "answered");
-    const askers = runs.filter((r) => r.asks);
+    // a session held by a permission prompt needs the human as much as a card does
+    const prompts = runs.filter((r) => r.asks?.via === "permission");
+    const askers = runs.filter((r) => r.asks && r.asks.via !== "permission");
     const reviews = prs.filter((p) => p.reviewRequested && !p.mine);
     const waiting = prs.filter((p) => !(p.reviewRequested && !p.mine));
     const ls = snap.listeners ?? [];
     const out = [];
-    out.push(head("NEEDS YOU", open.length || "nothing"));
+    out.push(head("NEEDS YOU", open.length + prompts.length || "nothing"));
     out.push(...cardRows(open, v, now, "  "));
+    out.push(...askRows(prompts, v, now, "  "));
     if (askers.length) {
         out.push("", head("ASKED IN CHAT, NO CARD", askers.length, "  (read from the log)"));
         out.push(...askRows(askers, v, now, "  "));
@@ -471,7 +475,9 @@ program
         out.push(runsTree(runs, v));
     const dim = (t) => (v.color ? `\x1b[2m${t}\x1b[0m` : t);
     const notes = [];
-    if (snap.github?.error && snap.github.enabled)
+    if (snap.github?.failing && snap.github.enabled)
+        notes.push(`GitHub: not read since ${(snap.github.fetchedAt ?? "").replace("T", " ").slice(0, 16) || "ever"}; ${snap.github.failedBy ?? "a reader"} failed: ${snap.github.error}. Pull request news is not coming in; see parawatch doctor`);
+    else if (snap.github?.error && snap.github.enabled)
         notes.push(`GitHub: ${snap.github.error}`);
     const skew = versionSkew(VERSION, runningDesktop()?.version);
     if (skew)
@@ -603,6 +609,9 @@ program
     catch {
         input = {};
     }
+    // a permission prompt is only recorded; the hook never answers it
+    if (recordPrompt(input) || input.hook_event_name === "Notification" || input.hook_event_name === "PermissionRequest")
+        return;
     const text = hookContext(input, o.project);
     if (!text)
         return;

package/dist/core/doctor.js

@@ -6,7 +6,7 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { CLI_UPDATE, readClient, runningDesktop, versionSkew } from "./clients.js";
-import { ghHosts, githubConfig, readCache, runGh } from "./github.js";
+import { ghCommand, ghHosts, githubConfig, githubFailing, readCache, runGh } from "./github.js";
 import { instructionState } from "./integrate.js";
 import { listeners } from "./ops.js";
 import { fold } from "./state.js";
@@ -137,13 +137,22 @@ export async function doctor(input) {
         if (!ghVersion)
             add("github", "off", "gh not found, so pull requests are not followed (nothing else needs it)", "install gh and run gh auth login");
         else {
+            if (!input.gh && ghCommand() !== "gh")
+                ghVersion += ` (${ghCommand()})`;
             const hosts = await ghHosts(gh);
             if (!hosts.length)
                 add("github", "warn", `${ghVersion}, but not signed in`, "gh auth login");
             else {
                 const c = readCache();
-                const when = c.fetchedAt ? `last read ${c.fetchedAt.replace("T", " ").slice(0, 16)}` : "not read yet";
-                add("github", c.error ? "warn" : "ok", `${hosts.join(", ")} · ${c.prs.length} PRs · ${when}${c.error ? ` · ${c.error}` : ""}`, c.error ? "parawatch pr sync" : undefined);
+                const at = (t) => t.replace("T", " ").slice(0, 16);
+                const when = c.fetchedAt ? `last read ${at(c.fetchedAt)}` : "not read yet";
+                if (githubFailing(c)) {
+                    // this process's gh works, so the failing reader is another one (often the app, opened without Homebrew's PATH)
+                    const who = c.failedBy ?? "another reader";
+                    add("github", "warn", `${hosts.join(", ")} · ${when} · ${who} failed at ${at(c.failedAt)}: ${c.error}`, who === "the desktop app" ? 'set "github": { "cli": "<path to gh>" } in config.json if the app cannot find gh, then restart it; parawatch pr sync reads now' : "parawatch pr sync");
+                }
+                else
+                    add("github", c.error ? "warn" : "ok", `${hosts.join(", ")} · ${c.prs.length} PRs · ${when}${c.error ? ` · ${c.error}` : ""}`, c.error ? "parawatch pr sync" : undefined);
             }
         }
     }

package/dist/core/github.js

@@ -64,7 +64,7 @@ export function resolvePrRef(input, cwd = process.cwd()) {
         throw new UserError(`"${input}" is not a pull request: give a URL, owner/repo#N, or #N inside the repository`);
     let url;
     try {
-        url = execFileSync("gh", ["pr", "view", n[1], "--json", "url", "-q", ".url"], { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], timeout: 20_000 }).trim();
+        url = execFileSync(ghCommand(), ["pr", "view", n[1], "--json", "url", "-q", ".url"], { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], timeout: 20_000 }).trim();
     }
     catch (err) {
         throw new UserError(`could not look up #${n[1]} with gh here: ${String(err.stderr ?? err).trim().split("\n")[0]}`);
@@ -96,26 +96,86 @@ function writeCache(c) {
     fs.writeFileSync(tmp, JSON.stringify(c) + "\n");
     fs.renameSync(tmp, cachePath());
 }
+/** Where `gh` is usually installed, for a process whose PATH lacks it (an app opened from Finder). */
+export function ghCandidates(platform = process.platform, env = process.env) {
+    if (platform === "win32") {
+        const dirs = [env.ProgramFiles, env["ProgramFiles(x86)"], env.LOCALAPPDATA && path.join(env.LOCALAPPDATA, "Programs")].filter((d) => !!d);
+        const out = dirs.map((d) => path.join(d, "GitHub CLI", "gh.exe"));
+        if (env.USERPROFILE)
+            out.push(path.join(env.USERPROFILE, "scoop", "shims", "gh.exe"));
+        return out;
+    }
+    return ["/opt/homebrew/bin/gh", "/usr/local/bin/gh", "/opt/local/bin/gh", "/home/linuxbrew/.linuxbrew/bin/gh", "/usr/bin/gh", "/snap/bin/gh"];
+}
+function onPath(name, env = process.env) {
+    const exts = process.platform === "win32" ? (env.PATHEXT ?? ".EXE;.CMD").split(";") : [""];
+    for (const dir of (env.PATH ?? "").split(path.delimiter)) {
+        if (!dir)
+            continue;
+        for (const ext of exts)
+            if (fs.existsSync(path.join(dir, name + ext.toLowerCase())) || fs.existsSync(path.join(dir, name + ext)))
+                return true;
+    }
+    return false;
+}
+let ghFound;
+/**
+ * The `gh` to run: `github.cli` in config.json, else `gh` on this process's PATH, else the first
+ * usual install location that exists. Found once per process.
+ */
+export function ghCommand() {
+    const configured = githubCli();
+    if (configured)
+        return configured;
+    if (ghFound)
+        return ghFound;
+    ghFound = onPath("gh") ? "gh" : (ghCandidates().find((f) => fs.existsSync(f)) ?? "gh");
+    return ghFound;
+}
+function githubCli() {
+    try {
+        const raw = JSON.parse(fs.readFileSync(path.join(homeDir(), "config.json"), "utf8"));
+        return typeof raw.github?.cli === "string" && raw.github.cli ? raw.github.cli : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** A `gh` that could not be started, as opposed to one that ran and failed. */
+export class GhMissing extends Error {
+}
 export const runGh = (args) => new Promise((resolve, reject) => {
-    execFile("gh", args, { encoding: "utf8", timeout: 30_000, maxBuffer: 16 * 1024 * 1024 }, (err, stdout, stderr) => {
-        if (err)
+    const cmd = ghCommand();
+    execFile(cmd, args, { encoding: "utf8", timeout: 30_000, maxBuffer: 16 * 1024 * 1024, windowsHide: true }, (err, stdout, stderr) => {
+        if (err && err.code === "ENOENT")
+            reject(new GhMissing(`gh not found on this process's PATH or in the usual places (set github.cli in config.json)`));
+        else if (err)
             reject(new Error(String(stderr || err.message).trim().split("\n")[0]));
         else
             resolve(stdout);
     });
 });
-/** Hosts `gh` is signed in to. */
-export async function ghHosts(gh = runGh) {
+/** Hosts `gh` is signed in to, or why there are none. */
+export async function ghAuth(gh = runGh) {
     try {
         const out = JSON.parse(await gh(["auth", "status", "--json", "hosts"]));
-        return Object.entries(out.hosts ?? {})
+        const hosts = Object.entries(out.hosts ?? {})
             .filter(([, accounts]) => accounts.some((a) => a.state === "success"))
             .map(([h]) => h);
+        return hosts.length ? { hosts } : { hosts, error: "gh is not signed in" };
     }
-    catch {
-        return [];
+    catch (err) {
+        return { hosts: [], error: err instanceof GhMissing ? err.message : `gh is not installed or not signed in (${err.message})` };
     }
 }
+/** Hosts `gh` is signed in to. */
+export async function ghHosts(gh = runGh) {
+    return (await ghAuth(gh)).hosts;
+}
+/** Which kind of process this is, for saying who could not read GitHub. */
+function whoReads() {
+    return process.versions.electron ? "the desktop app" : "the command line";
+}
 const FIELDS = (withQueue) => `
   number title url state isDraft mergeable reviewDecision updatedAt
   author { login }
@@ -331,6 +391,17 @@ export function dropReported(fresh, log, since, me = deviceName()) {
     return fresh.filter((b) => b.type !== "pr.change" || !seen.has(`${b.pr.key}|${b.change}|${b.by ?? ""}`));
 }
 // ------------------------------------------------------------------ sync
+/** When this process last failed to read GitHub at all. */
+let failedHere = 0;
+/** For tests: forget this process's last failure and the gh it found. */
+export function resetGithubProcess() {
+    failedHere = 0;
+    ghFound = undefined;
+}
+/** A failed attempt newer than the last good reading: news is not coming in. */
+export function githubFailing(c) {
+    return !!c.failedAt && (!c.fetchedAt || c.failedAt > c.fetchedAt);
+}
 function fetchingPath() {
     return path.join(homeDir(), "github.fetching");
 }
@@ -366,17 +437,29 @@ export async function syncGithub(opts) {
     const age = prev.fetchedAt ? Date.now() - Date.parse(prev.fetchedAt) : Infinity;
     if (!opts.force && age < cfg.intervalMinutes * 60_000)
         return prev;
+    // this process failed lately: wait the interval before trying again, others may still read
+    if (!opts.force && Date.now() - failedHere < cfg.intervalMinutes * 60_000)
+        return prev;
     if (!takeFetch())
         return prev;
     const gh = opts.gh ?? runGh;
     const started = new Date().toISOString();
     try {
-        const hosts = await ghHosts(gh);
+        const auth = await ghAuth(gh);
+        const hosts = auth.hosts;
         if (!hosts.length) {
-            const c = { ...prev, fetchedAt: started, hosts: [], error: "gh is not installed or not signed in" };
-            writeCache(c);
-            return c;
+            failedHere = Date.now();
+            return withLock(() => {
+                const latest = readCache();
+                if (latest.fetchedAt && latest.fetchedAt > started)
+                    return latest; // someone else read it meanwhile
+                // keep the last good reading and its time: a process whose gh works reads at once
+                const c = { ...latest, hosts: latest.hosts ?? [], error: auth.error, failedAt: started, failedBy: whoReads() };
+                writeCache(c);
+                return c;
+            });
         }
+        failedHere = 0;
         // PRs linked to sessions, and ones seen before, are read by number so merges and closes show
         const extra = new Map();
         for (const l of opts.state.prLinks.values())

package/dist/core/ops.js

@@ -320,7 +320,7 @@ export function linkPr(link) {
     const project = link.project?.trim() || claim?.project;
     appendEvent(() => ({
         type: "pr.link",
-        link: { pr: link.pr, session: link.session, project, task: link.task?.trim() || claim?.task },
+        link: { pr: link.pr, session: link.session, project, task: link.task?.trim() || claim?.task, auto: link.auto || undefined },
     }));
 }
 export function unlinkPr(key) {

package/dist/core/prompts.js

@@ -0,0 +1,77 @@
+/**
+ * Permission prompts a Claude Code session is showing, recorded by the optional hook
+ * (`PermissionRequest`, or a `Notification` about a permission). In the log a prompt looks like a
+ * tool call that has not returned yet, the same as a long command; only the hook can tell them apart.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { homeDir } from "./store.js";
+function dir() {
+    return path.join(homeDir(), "prompts");
+}
+function file(session) {
+    return path.join(dir(), `${session.replace(/[^A-Za-z0-9_-]/g, "_")}.json`);
+}
+function oneLine(s, max) {
+    const t = s.replace(/\s+/g, " ").trim();
+    return t.length > max ? `${t.slice(0, max - 1)}…` : t;
+}
+/** Whether the hook input is a permission prompt; records it if so. */
+export function recordPrompt(input, now = new Date()) {
+    const ev = input.hook_event_name;
+    const isPermission = ev === "PermissionRequest" || (ev === "Notification" && (input.notification_type === "permission_prompt" || /\bpermission\b/i.test(input.message ?? "")));
+    if (!isPermission || !input.session_id)
+        return false;
+    let what;
+    if (input.tool_name) {
+        const inp = input.tool_input ?? {};
+        const pick = [inp.description, inp.command, inp.file_path, inp.url].find((x) => typeof x === "string" && !!x);
+        what = pick ? `${input.tool_name}: ${oneLine(pick, 80)}` : input.tool_name;
+    }
+    else if (input.message) {
+        // "Claude needs your permission to use Bash"
+        const m = /permission to use (.+)$/i.exec(input.message.trim());
+        what = m ? m[1].trim() : undefined;
+    }
+    try {
+        const prev = readPrompt(input.session_id);
+        // a Notification after the PermissionRequest of the same prompt keeps the richer line
+        const keep = prev && !input.tool_name && prev.what && now.getTime() - Date.parse(prev.at) < 60_000;
+        fs.mkdirSync(dir(), { recursive: true });
+        fs.writeFileSync(file(input.session_id), JSON.stringify(keep ? prev : { at: now.toISOString(), what }) + "\n");
+    }
+    catch {
+        // a hook never fails the session
+    }
+    return true;
+}
+export function readPrompt(session) {
+    try {
+        const p = JSON.parse(fs.readFileSync(file(session), "utf8"));
+        return typeof p.at === "string" ? p : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * A session whose last tool call has not returned and that showed a permission prompt after its
+ * log last moved is waiting for the human to approve: it asks, blocked. A prompt the log has
+ * moved past is over.
+ */
+export function applyPrompts(runs, read = readPrompt) {
+    for (const r of runs) {
+        if (r.runtime !== "claude-code" || r.kind !== "session" || r.device || !r.pendingTool)
+            continue;
+        if (r.state !== "working" && r.state !== "stalled")
+            continue;
+        const p = read(r.id);
+        if (!p || !r.lastActivity || Date.parse(p.at) < Date.parse(r.lastActivity) - 2_000)
+            continue;
+        r.asks = { text: `approve a tool call${p.what ? `: ${p.what}` : ""}`, via: "permission", blocked: true, at: p.at };
+        // like a session that asked in chat, it waits for the human rather than working
+        r.state = "idle";
+    }
+    return runs;
+}
+//# sourceMappingURL=prompts.js.map

package/dist/core/runs.js

@@ -5,6 +5,7 @@ import { scanAll } from "../adapters/index.js";
 import { ACTIVITY_MINUTES, activeMinutes } from "../adapters/jsonl.js";
 import { archivedSessions } from "./desktop.js";
 import { canonicalPath, insidePath, namesPath, samePath } from "./paths.js";
+import { applyPrompts } from "./prompts.js";
 import { deviceName, sharedDir } from "./store.js";
 /** All checkouts of a project path: the path itself plus its git worktrees. */
 function rootsOf(p, cache) {
@@ -391,7 +392,7 @@ export function collectRuns(state, q, now = Date.now()) {
     const sinceMs = now - q.sinceHours * 3_600_000;
     // a log file can be touched (title records, snapshots) long after its last real activity
     const recent = (r) => !r.lastActivity || Date.parse(r.lastActivity) >= sinceMs;
-    let runs = endArchived(attribute(scanAll({ sinceMs, now }, q.runtimes), state), archivedSessions()).filter(recent);
+    let runs = applyPrompts(endArchived(attribute(scanAll({ sinceMs, now }, q.runtimes), state), archivedSessions())).filter(recent);
     // a narrower reading (one runtime) would hide the rest from the other machines
     if (!q.runtimes)
         shareRuns(runs, now);

package/dist/core/snapshot.js

@@ -1,4 +1,4 @@
-import { prViews, keyOf, parsePrRef, readCache, githubConfig } from "./github.js";
+import { prViews, keyOf, parsePrRef, readCache, githubConfig, githubFailing } from "./github.js";
 import { endedSessions, linkPr, listeners, readState } from "./ops.js";
 import { collectRuns } from "./runs.js";
 import { deviceName, eventFiles, sharedDir } from "./store.js";
@@ -30,22 +30,34 @@ export function snapshot(opts = {}) {
         cards,
         runs,
         prs,
-        github: { enabled, fetchedAt: cache.fetchedAt, error: cache.error },
+        github: { enabled, fetchedAt: cache.fetchedAt, error: cache.error, failing: githubFailing(cache) || undefined, failedBy: cache.failedBy, failedAt: cache.failedAt },
         listeners: listeners(),
         devices: sharedDir() ? { me: deviceName(), others: eventFiles().map((f) => f.device).filter((d) => d !== deviceName()) } : undefined,
     };
 }
-/** A pull request a session's log shows it opened belongs to that session, unless linked already. */
+/**
+ * A pull request a session's log shows it opened belongs to that session, unless linked already.
+ * An earlier automatic link to another session gives way when that session's log no longer shows
+ * it opening the PR (it was read wrongly); a link made with `parawatch pr link` never does.
+ */
 function linkCreatedPrs(runs, state) {
     let added = false;
     for (const r of runs) {
         for (const url of r.createdPrs ?? []) {
             const key = keyOf(url);
             const pr = parsePrRef(url);
-            if (!key || !pr || state.prLinks.has(key))
+            if (!key || !pr)
                 continue;
-            linkPr({ pr, session: r.id, project: r.project, task: r.task });
-            state.prLinks.set(key, { pr, session: r.id, project: r.project, at: new Date().toISOString() });
+            const had = state.prLinks.get(key);
+            if (had) {
+                if (!had.auto || !had.session || r.id.startsWith(had.session))
+                    continue;
+                const owner = runs.find((x) => x.id.startsWith(had.session));
+                if (!owner || (owner.createdPrs ?? []).some((u) => keyOf(u) === key))
+                    continue;
+            }
+            linkPr({ pr, session: r.id, project: r.project, task: r.task, auto: true });
+            state.prLinks.set(key, { pr, session: r.id, project: r.project, auto: true, at: new Date().toISOString() });
             added = true;
         }
     }
@@ -54,7 +66,8 @@ function linkCreatedPrs(runs, state) {
 /** 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) {
-        if (!r.asks)
+        // a permission prompt holds the session whatever cards it has open
+        if (!r.asks || r.asks.via === "permission")
             continue;
         const turn = r.lastPromptAt ?? "";
         if (cards.some((c) => c.status !== "closed" && c.session && r.id.startsWith(c.session) && c.openedAt >= turn))

package/dist/core/state.js

@@ -48,8 +48,12 @@ export function fold(events, map) {
             }
             case "card.comment": {
                 const c = s.cards.get(ev.card);
-                if (c)
-                    c.comments.push({ seq: ev.seq, at: ev.ts, by: ev.by, text: ev.text });
+                if (!c)
+                    break;
+                c.comments.push({ seq: ev.seq, at: ev.ts, by: ev.by, text: ev.text });
+                // The human wrote without choosing and the agent replied: the choice is still the human's to make
+                if (ev.by !== "human" && c.status === "answered" && c.options?.length && !c.answers.some((a) => a.choice !== undefined && !a.late))
+                    c.status = "open";
                 break;
             }
             case "card.edit": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "parawatch",
-  "version": "0.3.9",
+  "version": "0.3.10",
   "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",