parawatch 0.3.16 → 0.3.18

package/README.md

@@ -46,7 +46,7 @@ parawatch sync setup ~/agent-sync/parawatch --device pc  --adapter syncthing
 
 Cards, answers and the list of running sessions then show on every machine, each marked with where it came from. Agent logs stay on the machine that wrote them. The details are in [More than one machine](docs/sync.md).
 
-Or run a [relay](docs/relay.md) of your own, a small server that carries the folder sealed end to end, so the server cannot read your cards or sessions: `parawatch relay setup <url> <folder>` on the first machine, `parawatch relay join <code> <folder>` on the others.
+Or run a [relay](docs/relay.md) of your own, a small server that carries the folder sealed end to end, so the server cannot read your cards or sessions: `parawatch relay setup <url> <folder>` on the first machine, `parawatch relay join <code> <folder>` on the others. With a relay, a phone can answer cards too: [On a phone](docs/phone.md).
 
 ## How an answer gets back
 

package/dist/adapters/claudeCode.js

@@ -239,7 +239,17 @@ export function readClaudeTail(recs, kind) {
             // the human wrote (a pasted block, a command's output): whatever the last wrap-up asked is answered
             wrapUp = undefined;
         }
+        if (str(r.permissionMode))
+            out.permissionMode = str(r.permissionMode);
         if (r.type === "assistant") {
+            const msg = isObj(r.message) ? r.message : {};
+            const model = str(msg.model);
+            // a message Claude Code makes up itself (an interrupt, an error) names no real model
+            if (model && !model.startsWith("<")) {
+                out.model = model;
+                out.effort = str(r.effort);
+                out.fast = isObj(msg.usage) && msg.usage.speed === "fast" ? true : undefined;
+            }
             const w = blocks(r).find((b) => b.type === "tool_use" && WRAP_UP.test(String(b.name)));
             if (w)
                 wrapUp = { ...(w.input ?? {}), at: ts };
@@ -427,6 +437,12 @@ export const claudeCode = {
         return runs;
     },
 };
+const PERMISSION_MODES = { acceptEdits: "accepts edits", plan: "plan mode", bypassPermissions: "bypasses permissions", dontAsk: "never asks", auto: "auto mode" };
+/** The model, effort and options a Claude Code run's last answer ran with. */
+function claudeSettings(t) {
+    const options = [t.fast ? "fast" : undefined, t.permissionMode ? PERMISSION_MODES[t.permissionMode] : undefined].filter((x) => !!x);
+    return { model: t.model, effort: t.effort, options: options.length ? options : undefined };
+}
 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 };
@@ -451,6 +467,7 @@ function readSession(file, now) {
             prompt: head.prompt ? oneLine(head.prompt, 400) : undefined,
             activity: logActivity(file, now),
             pendingTool: tail.pendingTool,
+            ...claudeSettings(tail),
         };
         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
@@ -477,7 +494,8 @@ function readSubagent(file, now) {
             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),
+            ...claudeSettings(tail),
+            model: tail.model ?? str(meta.model),
             cwd: tail.cwd || head.cwd,
             startedAt: head.startedAt,
             lastActivity: tail.lastActivity,

package/dist/adapters/codex.js

@@ -2,7 +2,7 @@ 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";
+import { isObj, lastLineWith, 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
@@ -69,6 +69,35 @@ export function promptFromRaw(raw) {
     }
     return undefined;
 }
+const SANDBOXES = { "read-only": "read-only", "workspace-write": "writes in its folders", "danger-full-access": "full access" };
+const APPROVALS = { never: "never asks", "on-request": "asks when it wants to", "on-failure": "asks on failure", untrusted: "asks before most commands" };
+/** The model, effort and options of the last turn, from Codex's `turn_context` lines. */
+export function codexSettings(lines) {
+    let tc;
+    for (const r of lines)
+        if (isObj(r) && r.type === "turn_context" && isObj(r.payload))
+            tc = r.payload;
+    if (!tc)
+        return {};
+    const sp = tc.sandbox_policy;
+    const sandbox = typeof sp === "string" ? sp : isObj(sp) ? str(sp.type) : undefined;
+    const approval = str(tc.approval_policy);
+    const options = [sandbox ? (SANDBOXES[sandbox] ?? sandbox) : undefined, approval ? (APPROVALS[approval] ?? approval) : undefined].filter((x) => !!x);
+    return { model: str(tc.model), effort: str(tc.effort) ?? str(tc.reasoning_effort) ?? (isObj(tc.collaboration_mode) && isObj(tc.collaboration_mode.settings) ? str(tc.collaboration_mode.settings.reasoning_effort) : undefined), options: options.length ? options : undefined };
+}
+/** What the last turn ran with, per log: a long log is searched once, then only where it grew. */
+const middle = new Map();
+/** The settings of a log whose last `turn_context` sits between its head and tail. */
+export function settingsInMiddle(file) {
+    const size = fs.statSync(file).size;
+    const known = middle.get(file);
+    if (known && known.size === size)
+        return known.settings;
+    const found = lastLineWith(file, '"type":"turn_context"', known && known.size < size ? Math.max(0, known.size - 64) : 0);
+    const settings = found ? codexSettings([found]) : (known?.settings ?? {});
+    middle.set(file, { size, settings });
+    return settings;
+}
 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";
@@ -98,6 +127,8 @@ export function readCodexLog(head, tail, rawHead) {
         startedAt: str(meta?.timestamp) ?? (isObj(head[0]) ? str(head[0].timestamp) : undefined),
         state: "working",
         prompt: prompt ? oneLine(prompt, 400) : undefined,
+        // the last turn's settings: a later turn may change them (`codex exec resume -m ...`)
+        ...codexSettings([...head, ...tail]),
     };
     let lastStart = -1;
     let lastDone = -1;
@@ -170,6 +201,8 @@ export const codex = {
                     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 };
+                    if (!run.model)
+                        Object.assign(run, settingsInMiddle(file));
                     run.activity = logActivity(file, opts.now);
                     applyStall(run, undefined, opts.now);
                     runs.push(run);

package/dist/adapters/jsonl.js

@@ -141,4 +141,70 @@ export function logActivity(file, now) {
     seen.set(file, entry);
     return activeMinutes(entry.times, now);
 }
+/**
+ * The last line holding `marker` in the part of a file after byte `from`, parsed, searching back
+ * from the end a megabyte at a time. For a record written once a turn that can sit anywhere in a
+ * log of many megabytes, between what the head and tail readings cover.
+ */
+export function lastLineWith(file, marker, from = 0, maxLine = 4 * 1024 * 1024) {
+    const size = fs.statSync(file).size;
+    const needle = Buffer.from(marker);
+    const CHUNK = 1024 * 1024;
+    const fd = fs.openSync(file, "r");
+    try {
+        let end = size;
+        while (end > from) {
+            const start = Math.max(from, end - CHUNK);
+            // overlap by the marker's length, so one cut in two is still found
+            const len = Math.min(size, end + needle.length) - start;
+            const buf = Buffer.alloc(len);
+            const n = fs.readSync(fd, buf, 0, len, start);
+            const at = buf.subarray(0, n).lastIndexOf(needle);
+            if (at >= 0)
+                return lineAt(fd, size, start + at, maxLine);
+            end = start;
+        }
+        return undefined;
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+/** The whole line around a byte position, parsed; undefined when it is too long or not JSON. */
+function lineAt(fd, size, pos, maxLine) {
+    const STEP = 64 * 1024;
+    let lineStart = pos;
+    while (lineStart > 0 && pos - lineStart < maxLine) {
+        const from = Math.max(0, lineStart - STEP);
+        const buf = Buffer.alloc(lineStart - from);
+        fs.readSync(fd, buf, 0, buf.length, from);
+        const nl = buf.lastIndexOf(10);
+        if (nl >= 0) {
+            lineStart = from + nl + 1;
+            break;
+        }
+        lineStart = from;
+    }
+    let lineEnd = pos;
+    while (lineEnd < size && lineEnd - lineStart < maxLine) {
+        const buf = Buffer.alloc(Math.min(STEP, size - lineEnd));
+        fs.readSync(fd, buf, 0, buf.length, lineEnd);
+        const nl = buf.indexOf(10);
+        if (nl >= 0) {
+            lineEnd += nl;
+            break;
+        }
+        lineEnd += buf.length;
+    }
+    if (lineEnd - lineStart >= maxLine)
+        return undefined;
+    const buf = Buffer.alloc(lineEnd - lineStart);
+    fs.readSync(fd, buf, 0, buf.length, lineStart);
+    try {
+        return JSON.parse(buf.toString("utf8"));
+    }
+    catch {
+        return undefined;
+    }
+}
 //# sourceMappingURL=jsonl.js.map

package/dist/bin/cli.js

@@ -2,7 +2,7 @@
 import { execFileSync } from "node:child_process";
 import fs from "node:fs";
 import { Command } from "commander";
-import { UserError, addProject, answerCard, beatRun, claimSession, closeCard, dismissCard, endedSessions, handCard, handPr, leadOf, makeLead, 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 { UserError, addProject, answerCard, beatRun, claimSession, closeCard, dismissCard, endedSessions, handCard, handPr, leadOf, makeLead, commentCard, inboxScope, editCard, endRun, hideRun, unhideRun, linkPr, listeners, listenersFor, noteRun, openCard, prEvent, findCard, readInbox, readState, sameSession, 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";
@@ -374,10 +374,17 @@ program
         id = callingSubagent(id, /\bparawatch\b.*\bclaim\b/) ?? id;
     if (o.kind !== undefined && o.kind !== "scheduled")
         throw new UserError("--kind can only be 'scheduled'");
+    // a lead that says done stops leading: say so, since it may only have finished one task
+    const before = o.done?.trim() ? readState() : undefined;
+    const ledBefore = before ? leadOf(before, endedSessions(before))(o.project?.trim() || before.claims.find((x) => sameSession(x.session, id))?.project) : undefined;
     const c = claimSession({ session: id, project: o.project, task: o.task, role: o.role, title: o.title, kind: o.kind, done: o.done });
     // a new lead: earlier leads of the project step down, and it takes what no session got
     const handed = o.role === "lead" && !c.done ? makeLead(c.project, id).handed : [];
     process.stdout.write(`${id.slice(0, 8)} → ${c.project}${c.task ? ` / ${c.task}` : ""}${c.role ? ` (${c.role})` : ""}${c.done ? " · done" : ""}${handed.length ? `; handed ${handed.join(", ")}` : ""}\n`);
+    if (c.done && ledBefore && sameSession(ledBefore, id)) {
+        process.stdout.write(`This session no longer leads ${c.project}: what no session owns there now waits in parawatch until a session claims --role lead.\n` +
+            `If it goes on working, claim its next work instead of --done: parawatch claim -p ${c.project} -t <task> --role lead\n`);
+    }
 });
 // ------------------------------------------------------------------ pull requests
 const pr = program.command("pr").description("pull requests and what they wait on (reads GitHub through gh)");

package/dist/core/format.js

@@ -1,3 +1,4 @@
+import { settingsLine } from "./model.js";
 export function ago(iso, now = Date.now()) {
     if (!iso)
         return "?";
@@ -374,7 +375,7 @@ export function runsTree(runs, v = PLAIN, now = Date.now(), indent = "") {
             const age = paint(v, ago(r.lastActivity, now).padStart(4), "dim");
             const dev = devW ? "  " + paint(v, pad(fit(r.device ?? "", devW), devW), "cyan") : "";
             const src = (r.projectSource && SOURCE_NOTE[r.projectSource]) || "";
-            const wide = v.wide ? "  " + paint(v, pad(fit(`${r.kind === "subagent" ? r.model ?? "subagent" : r.runtime} ${r.id.slice(0, 8)}${src ? " " + src : ""}`, wideW - 2), wideW - 2), "dim") : "";
+            const wide = v.wide ? "  " + paint(v, pad(fit(`${r.runtime} ${r.id.slice(0, 8)}${settingsLine(r) ? " " + settingsLine(r) : ""}${src ? " " + src : ""}`, wideW - 2), wideW - 2), "dim") : "";
             const restW = v.width - nameW - 2 - 4 - devCol - wideW - 2;
             const whatPaint = r.error || r.state === "stalled" || r.state === "failed" || r.asks?.blocked ? ["red"] : r.asks ? ["yellow"] : ended ? ["dim"] : [];
             const what = restW >= 8 ? "  " + paint(v, fit(whatText(r), restW), ...whatPaint) : "";

package/dist/core/github.js

@@ -320,6 +320,11 @@ export function waitingOn(p) {
         return { what: "no reviewer", who: author };
     return { what: "merge", who: author };
 }
+/** A reading of a PR from before anything happened to it: open, CI running, its reviews and comments as now. */
+function unseen(p) {
+    // a PR already finished reports only that, not the CI it had
+    return { ...p, state: "open", ci: p.state === "open" ? "PENDING" : p.ci, mergeable: p.state === "open" ? undefined : p.mergeable, queue: p.queue };
+}
 const REVIEW_CHANGE = { APPROVED: "approved", CHANGES_REQUESTED: "changes_requested", COMMENTED: "review", DISMISSED: "review" };
 /** The events between two readings of the same PR. */
 export function changesBetween(old, now) {
@@ -348,13 +353,18 @@ export function changesBetween(old, now) {
         out.push({ change: "closed" });
     return out;
 }
-/** Next cache and the events it implies, given the previous cache and a fresh reading. */
-export function nextCache(prev, fresh, hosts, at) {
+/**
+ * Next cache and the events it implies, given the previous cache and a fresh reading. `newlyLinked`
+ * names PRs a session linked since the previous reading: one first seen with its CI already done,
+ * or already merged or closed, reports that, since no earlier reading can show it changing (a CI
+ * of a minute ends before the first reading).
+ */
+export function nextCache(prev, fresh, hosts, at, newlyLinked = new Set()) {
     const old = new Map(prev.prs.map((p) => [p.key, p]));
     const events = [];
     const since = {};
     for (const p of fresh) {
-        const was = old.get(p.key);
+        const was = old.get(p.key) ?? (newlyLinked.has(p.key) ? unseen(p) : undefined);
         if (was) {
             for (const c of changesBetween(was, p)) {
                 events.push({ type: "pr.change", pr: prRef(p.host, p.repo, p.number, p.url), change: c.change, title: p.title, by: c.by, source: "github" });
@@ -460,10 +470,14 @@ export async function syncGithub(opts) {
             });
         }
         failedHere = 0;
-        // PRs linked to sessions, and ones seen before, are read by number so merges and closes show
+        // PRs linked to sessions, and ones seen before, are read by number so merges and closes show.
+        // The newest links first, leaving out the ones already seen finished: the number read is capped.
         const extra = new Map();
-        for (const l of opts.state.prLinks.values())
-            extra.set(l.pr.key, l.pr);
+        const finished = new Set(prev.finished ?? []);
+        const links = [...opts.state.prLinks.values()].reverse().sort((a, b) => b.at.localeCompare(a.at));
+        for (const l of links)
+            if (!finished.has(l.pr.key))
+                extra.set(l.pr.key, l.pr);
         const cutoff = new Date(Date.now() - cfg.maxAgeDays * 86_400_000).toISOString();
         for (const p of prev.prs)
             if (p.state === "open" && p.updatedAt >= cutoff)
@@ -489,7 +503,11 @@ export async function syncGithub(opts) {
             const latest = readCache();
             if (latest.fetchedAt && latest.fetchedAt > started)
                 return latest; // someone else was faster
-            const { cache, events } = nextCache(latest, fresh, hosts, started);
+            // a first reading of everything reports nothing; after that, links made since the last reading are new
+            const newly = new Set(latest.fetchedAt ? links.filter((l) => l.at > latest.fetchedAt).map((l) => l.pr.key) : []);
+            const { cache, events } = nextCache(latest, fresh, hosts, started, newly);
+            const done = new Set([...(latest.finished ?? []), ...fresh.filter((p) => p.state !== "open").map((p) => p.key)]);
+            cache.finished = [...done].filter((k) => opts.state.prLinks.has(k));
             if (errors.length)
                 cache.error = errors.join("; ");
             appendLocked((log) => dropReported(events, log, latest.fetchedAt));

package/dist/core/log.js

@@ -0,0 +1,69 @@
+/** Merge per-device logs, each already in its own order, into one. */
+export function mergeLogs(lists) {
+    const at = lists.map(() => 0);
+    const out = [];
+    for (;;) {
+        let pick = -1;
+        for (let i = 0; i < lists.length; i++) {
+            const ev = lists[i][at[i]];
+            if (!ev)
+                continue;
+            if (pick < 0) {
+                pick = i;
+                continue;
+            }
+            const best = lists[pick][at[pick]];
+            if (ev.ts < best.ts || (ev.ts === best.ts && (ev.dev ?? "") < (best.dev ?? "")))
+                pick = i;
+        }
+        if (pick < 0)
+            return out;
+        out.push(lists[pick][at[pick]++]);
+    }
+}
+export function parseEventLines(text, device) {
+    const out = [];
+    for (const line of text.split("\n")) {
+        if (!line.trim())
+            continue;
+        try {
+            const ev = JSON.parse(line);
+            if (typeof ev.seq !== "number" || typeof ev.type !== "string")
+                continue;
+            if (device)
+                ev.dev = device;
+            out.push(ev);
+        }
+        catch {
+            // a torn or hand-edited line; keep going
+        }
+    }
+    return out;
+}
+/** The card an event is about, if any. */
+function cardOf(e) {
+    if (e.type === "card.open")
+        return e.card.id;
+    const c = e.card;
+    return typeof c === "string" ? c : undefined;
+}
+/**
+ * When a writer may stamp its next event: now, but never before its own last event (each log
+ * stays in order) and, for an event about a card, after everything already said about that card.
+ * Logs merge by time and then by machine name, so an answer stamped in the same millisecond as the
+ * card on another machine, or by a clock running behind, would sort before the card and be lost.
+ */
+export function stampFor(events, own, card, now) {
+    let t = now;
+    for (const e of events) {
+        const at = Date.parse(e.ts);
+        if (!Number.isFinite(at))
+            continue;
+        if (own(e) && at > t)
+            t = at;
+        if (typeof card === "string" && cardOf(e) === card && at >= t)
+            t = at + 1;
+    }
+    return t;
+}
+//# sourceMappingURL=log.js.map

package/dist/core/model.js

@@ -0,0 +1,18 @@
+const CLAUDE = /^claude-([a-z]+)-(\d+)-(\d+)(?:-\d{8})?(\[1m\])?$/;
+export function shortModel(model) {
+    const m = CLAUDE.exec(model);
+    if (m)
+        return `${m[1]} ${m[2]}.${m[3]}${m[4] ? " 1M" : ""}`;
+    return model.replace(/-\d{8}$/, "");
+}
+/** The model and effort in a few words, `opus 5.5 high`; fast mode too, as it changes the speed. */
+export function settingsLine(r) {
+    const parts = [r.model ? shortModel(r.model) : undefined, r.effort, r.options?.includes("fast") ? "fast" : undefined].filter(Boolean);
+    return parts.length ? parts.join(" ") : undefined;
+}
+/** Everything it runs with, for a tooltip or a detail line: `claude-opus-5-5 · effort high · bypasses permissions`. */
+export function settingsFull(r) {
+    const parts = [r.model, r.effort ? `effort ${r.effort}` : undefined, ...(r.options ?? [])].filter(Boolean);
+    return parts.length ? parts.join(" · ") : undefined;
+}
+//# sourceMappingURL=model.js.map

package/dist/core/store.js

@@ -2,7 +2,9 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { UserError } from "./errors.js";
+import { mergeLogs, parseEventLines, stampFor } from "./log.js";
 import { STORE_FORMAT } from "./types.js";
+export { mergeLogs, parseEventLines };
 /** Directory holding all parawatch state for this user on this machine. */
 export function homeDir() {
     const explicit = process.env.PARAWATCH_HOME;
@@ -188,48 +190,6 @@ export function readEvents() {
         return lists[0] ?? [];
     return mergeLogs(lists);
 }
-/** Merge per-device logs, each already in its own order, into one. */
-export function mergeLogs(lists) {
-    const at = lists.map(() => 0);
-    const out = [];
-    for (;;) {
-        let pick = -1;
-        for (let i = 0; i < lists.length; i++) {
-            const ev = lists[i][at[i]];
-            if (!ev)
-                continue;
-            if (pick < 0) {
-                pick = i;
-                continue;
-            }
-            const best = lists[pick][at[pick]];
-            if (ev.ts < best.ts || (ev.ts === best.ts && (ev.dev ?? "") < (best.dev ?? "")))
-                pick = i;
-        }
-        if (pick < 0)
-            return out;
-        out.push(lists[pick][at[pick]++]);
-    }
-}
-export function parseEventLines(text, device) {
-    const out = [];
-    for (const line of text.split("\n")) {
-        if (!line.trim())
-            continue;
-        try {
-            const ev = JSON.parse(line);
-            if (typeof ev.seq !== "number" || typeof ev.type !== "string")
-                continue;
-            if (device)
-                ev.dev = device;
-            out.push(ev);
-        }
-        catch {
-            // a torn or hand-edited line; keep going
-        }
-    }
-    return out;
-}
 // ------------------------------------------------------------------ writing
 /** Append one event. `build` sees the current events so it can pick ids under the lock. */
 export function appendEvent(build) {
@@ -263,9 +223,13 @@ export function appendLocked(build) {
     for (const e of own)
         if (e.seq > seq)
             seq = e.seq;
-    const ts = new Date().toISOString();
+    const mine = new Set(own);
+    let last = 0;
     const v = writeFormat();
-    const out = build(events).map((body) => ({ v, seq: ++seq, ts, ...body }));
+    const out = build(events).map((body) => {
+        last = stampFor(events, (e) => mine.has(e), body.card, Math.max(Date.now(), last));
+        return { v, seq: ++seq, ts: new Date(last).toISOString(), ...body };
+    });
     if (out.length) {
         ensureDir(path.dirname(eventsPath()));
         fs.appendFileSync(eventsPath(), out.map((e) => JSON.stringify(e) + "\n").join(""));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "parawatch",
-  "version": "0.3.16",
+  "version": "0.3.18",
   "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",
@@ -39,7 +39,7 @@
     "build": "tsc -p tsconfig.json",
     "dev": "tsx src/bin/cli.ts",
     "test": "vitest run",
-    "typecheck": "tsc -p tsconfig.json --noEmit && tsc -p tsconfig.test.json --noEmit && npm run typecheck -w @parawatch/panel -w @parawatch/desktop",
+    "typecheck": "tsc -p tsconfig.json --noEmit && tsc -p tsconfig.test.json --noEmit && npm run typecheck -w @parawatch/panel -w @parawatch/desktop -w @parawatch/web",
     "prepublishOnly": "npm run build && npm test",
     "demo": "tsx scripts/demo.ts"
   },

package/skills/parawatch/SKILL.md

@@ -130,6 +130,7 @@ The session then shows as done, not as idle, and the line goes into the human's
 - The lead owns the cards for the work it hands out. Workers (subagents, `codex exec` jobs, other sessions you start) report back to the lead instead of opening cards, unless the lead told them to ask the human directly.
 - A session the human started on their own asks the human directly. Its cards and pull requests are its own: answers and news on them go to it, not to the lead. When that work belongs in the lead's queue, the session tells the lead, not the other way round.
 - Tell workers in their brief what to return to you, so the lead can turn it into one clear card.
+- **A lead that finishes one task claims its next work, not `--done`** (`parawatch claim -p <project> -t <next> --role lead`). `--done` ends the session as lead too: from then on what no session owns in the project goes nowhere until a session claims the lead. When you do a worker's task yourself, its brief's rules for workers (such as "do not use parawatch") are not yours.
 - Before ending a session, close cards you handled, end runs you started, and claim `--done`.
 
 ## On more than one machine