parawatch 0.3.2 → 0.3.3

package/README.md

@@ -290,6 +290,7 @@ parawatch sync            # this machine, the others, how the sync tool is doing
 - **Ids carry the machine once a log is shared:** `pc-c3`, `mac-r2`. Commands take the short form (`parawatch close c3`) while only one machine has that number. Cards from before the move keep their ids.
 - **When two machines answer one card before either has seen the other's answer, the earlier answer stands.** The other one stays on the card, marked as not used, and does not wake the agent. An answer given after seeing the first one counts as usual.
 - **Paths follow the machine.** Attachments, things to open and project folders written on another machine are read as the same place here, under its home folder or the shared folder. Name other folders that sit in different places on each machine (a cloud drive, say): `parawatch sync root gdrive "G:\My Drive"` on one machine and `parawatch sync root gdrive ~/Library/CloudStorage/…/My\ Drive` on the other. Pasted pictures are saved in the shared folder, so every machine can open them.
+- **A path that is absolute on either system is kept as written**, so an agent on the PC can ask you to open `/Users/Shared/Try/Game.app` on the Mac. Git Bash on Windows rewrites arguments that start with `/` before parawatch sees them; run such commands there with `MSYS_NO_PATHCONV=1`.
 - **Waits are seen everywhere.** A card on your laptop says whether an agent on the PC is waiting for it.
 - **Runs are seen everywhere.** Each machine writes a summary of the sessions its agent logs show (state, title, project, last activity, what each does) to `runs/<device>.json` about every half minute while `status`, a `wait` or the app runs. The other machines show those runs marked with the machine. The logs stay where they are. A machine whose summary is older than 15 minutes drops out of the list.
 - **Every machine reads GitHub for itself.** The same news is delivered once.

package/dist/bin/cli.js

@@ -425,8 +425,9 @@ program
     }
     if (answered.length) {
         const notes = {};
+        // the snapshot already marked the cards whose session has ended
         for (const c of answered)
-            if (!listenersFor(c, ls).length)
+            if (!listenersFor(c, ls, () => false).length)
                 notes[c.id] = "no agent waiting";
         out.push("", head("ANSWERED, WAITING FOR THE AGENT", answered.length));
         out.push(...cardRows(answered, v, now, "  ", notes));

package/dist/core/desktop.js

@@ -2,7 +2,8 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { parsePrRef } from "./github.js";
-import { sessionTitle, UserError } from "./ops.js";
+import { UserError } from "./errors.js";
+import { sessionTitle } from "./state.js";
 /**
  * Where the Claude desktop app keeps its Code sessions: one JSON file per session, named
  * `local_<id>.json`, holding the CLI session id the app runs (`cliSessionId`).
@@ -27,36 +28,86 @@ function* sessionFiles(dir, depth = 0) {
             yield p;
     }
 }
-/** The desktop app session running a CLI session (full id or a prefix of 6+ characters). */
-export function findDesktopSession(cliSession, dir = desktopSessionsDir()) {
-    if (cliSession.length < 6)
-        return undefined;
-    let best;
+/** Session files read before, by path; a file is read again only when it changes. */
+const readCache = new Map();
+/** Every desktop app session in the folder, read once per change of its file. */
+function desktopSessions(dir) {
+    const out = [];
     for (const file of sessionFiles(dir)) {
-        let d;
+        let mtimeMs;
         try {
-            d = JSON.parse(fs.readFileSync(file, "utf8"));
+            mtimeMs = fs.statSync(file).mtimeMs;
         }
         catch {
             continue;
         }
-        const ids = [d.cliSessionId, d.lastAssistantCliSessionId].filter((x) => typeof x === "string");
+        let hit = readCache.get(file);
+        if (!hit || hit.mtimeMs !== mtimeMs) {
+            hit = { mtimeMs, session: readSessionFile(file) };
+            readCache.set(file, hit);
+        }
+        if (hit.session)
+            out.push(hit.session);
+    }
+    return out;
+}
+function readSessionFile(file) {
+    let d;
+    try {
+        d = JSON.parse(fs.readFileSync(file, "utf8"));
+    }
+    catch {
+        return undefined;
+    }
+    const ids = [d.cliSessionId, d.lastAssistantCliSessionId].filter((x) => typeof x === "string");
+    if (!ids.length)
+        return undefined;
+    return {
+        id: typeof d.sessionId === "string" ? d.sessionId : path.basename(file, ".json"),
+        cliSessionId: ids[0],
+        ids,
+        title: typeof d.title === "string" ? d.title : undefined,
+        cwd: typeof d.cwd === "string" ? d.cwd : undefined,
+        archived: d.isArchived === true,
+        lastActivityAt: typeof d.lastActivityAt === "number" ? d.lastActivityAt : 0,
+    };
+}
+/** The desktop app session running a CLI session (full id or a prefix of 6+ characters). */
+export function findDesktopSession(cliSession, dir = desktopSessionsDir()) {
+    if (cliSession.length < 6)
+        return undefined;
+    let best;
+    for (const { ids, ...s } of desktopSessions(dir)) {
         if (!ids.some((x) => x.startsWith(cliSession)))
             continue;
-        const s = {
-            id: typeof d.sessionId === "string" ? d.sessionId : path.basename(file, ".json"),
-            cliSessionId: ids[0],
-            title: typeof d.title === "string" ? d.title : undefined,
-            cwd: typeof d.cwd === "string" ? d.cwd : undefined,
-            archived: d.isArchived === true,
-            lastActivityAt: typeof d.lastActivityAt === "number" ? d.lastActivityAt : 0,
-        };
         // prefer a live session, then the most recent one
         if (!best || (best.archived && !s.archived) || (best.archived === s.archived && s.lastActivityAt > best.lastActivityAt))
             best = s;
     }
     return best;
 }
+/**
+ * The CLI sessions the human archived in the Claude desktop app, as a test for a session id
+ * (full or a prefix of 6+ characters). Such a session never takes another turn, however its log
+ * ends. A CLI session that a live desktop session also runs is not archived.
+ */
+export function archivedSessions(dir = desktopSessionsDir()) {
+    const archived = new Set();
+    const live = new Set();
+    for (const s of desktopSessions(dir))
+        for (const id of s.ids)
+            (s.archived ? archived : live).add(id);
+    for (const id of live)
+        archived.delete(id);
+    const ids = [...archived];
+    return (session) => {
+        if (!session || session.length < 6)
+            return false;
+        if (archived.has(session))
+            return true;
+        return ids.some((id) => id.startsWith(session));
+    };
+}
 /** A link that opens the session in the Claude desktop app. */
 export function desktopSessionUrl(s) {
     return `claude://code/continue?session=${encodeURIComponent(s.id)}&source=parawatch`;

package/dist/core/format.js

@@ -321,6 +321,9 @@ export function runsTree(runs, v = PLAIN, now = Date.now(), indent = "") {
     const all = blocks.flatMap((b) => b.rows);
     const nameW = Math.min(Math.max(24, Math.floor(v.width * 0.4)), Math.max(12, ...all.map((row) => textWidth(row.prefix) + 2 + textWidth(row.run?.title ?? ""))));
     const wideW = v.wide ? 24 : 0;
+    // the machine a run is on gets a column of its own, so a long title cannot cut it off
+    const devW = Math.min(12, Math.max(0, ...all.map((row) => (row.run?.device ? textWidth(row.run.device) : 0))));
+    const devCol = devW ? devW + 2 : 0;
     const out = [];
     for (const { name, rows } of blocks) {
         if (name === OTHER)
@@ -339,15 +342,16 @@ export function runsTree(runs, v = PLAIN, now = Date.now(), indent = "") {
             const ended = ENDED.has(r.state);
             const titlePaint = r.role === "lead" ? ["bold"] : ended ? ["dim"] : [];
             const mark = paint(v, STATE_MARK[r.state], ...STATE_PAINT[r.state]);
-            const label = r.title + (r.repeats ? ` ×${r.repeats + 1}` : "") + (r.prs?.length ? ` (${r.prs.length} PR)` : "") + (r.device ? ` · on ${r.device}` : "");
+            const label = r.title + (r.repeats ? ` ×${r.repeats + 1}` : "") + (r.prs?.length ? ` (${r.prs.length} PR)` : "");
             const title = paint(v, pad(fit(label, room), room), ...titlePaint);
             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 restW = v.width - nameW - 2 - 4 - wideW - 2;
+            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) : "";
-            out.push(`${lead}${mark} ${title}  ${age}${wide}${what}`.trimEnd());
+            out.push(`${lead}${mark} ${title}  ${age}${dev}${wide}${what}`.trimEnd());
         }
     }
     return out.join("\n");

package/dist/core/integrate.js

@@ -4,6 +4,7 @@ import path from "node:path";
 import { furthest, inboxFrom, readInbox, readState, sameSession, sessionConsumer } from "./ops.js";
 import { homeDir, readCursor, readEvents } from "./store.js";
 import { inboxLine } from "./format.js";
+import { insidePath } from "./paths.js";
 export const BEGIN = "<!-- parawatch:begin -->";
 export const END = "<!-- parawatch:end -->";
 export function instructions(project) {
@@ -103,7 +104,7 @@ export function hookContext(input, project) {
         name = state.claims.find((c) => sameSession(session, c.session))?.project;
     if (!name && input.cwd) {
         for (const p of state.projects.values())
-            if (p.paths.some((x) => input.cwd === x || input.cwd.startsWith(x + "/")))
+            if (p.paths.some((x) => insidePath(input.cwd, x)))
                 name = p.name;
     }
     if (!name && !session)

package/dist/core/ops.js

@@ -2,10 +2,11 @@ import fs from "node:fs";
 import path from "node:path";
 import { UserError } from "./errors.js";
 import { advance, appendEvent, deviceName, eventsDir, homeDir, isAfter, readCursor, readEvents, sharedDir, writeCursor } from "./store.js";
-import { findId, fold, nextId } from "./state.js";
+import { archivedSessions } from "./desktop.js";
+import { findId, fold, nextId, sessionTitle } from "./state.js";
 import { pathMap } from "./sync.js";
 import { CARD_KINDS, HUMAN, PR_CHANGES } from "./types.js";
-export { UserError };
+export { UserError, sessionTitle };
 /** Current state, with other machines' paths made local. */
 export function readState(events = readEvents()) {
     return fold(events, pathMap());
@@ -18,9 +19,21 @@ function cleanList(xs) {
     const out = (xs ?? []).map((x) => x.trim()).filter(Boolean);
     return out.length ? out : undefined;
 }
+/**
+ * An attachment or a thing to open, as stored. A URL, and a path that is absolute on either
+ * system (`/Users/...`, `C:\...`, `\\server\share`), is kept as written: it may name a place on
+ * another machine, and resolving it here would root it on this one (`E:\Users\...` on Windows,
+ * `<cwd>/C:\...` on a Mac). Only a relative path is resolved.
+ */
+export function storedPath(x) {
+    if (/^[a-z]+:\/\//i.test(x))
+        return x;
+    if (path.posix.isAbsolute(x) || path.win32.isAbsolute(x))
+        return x;
+    return path.resolve(x);
+}
 function absPaths(xs) {
-    // attachments and things to open are kept as given when they look like URLs
-    return cleanList(xs)?.map((x) => (/^[a-z]+:\/\//i.test(x) ? x : path.resolve(x)));
+    return cleanList(xs)?.map(storedPath);
 }
 export function addProject(name, paths) {
     if (!/^[A-Za-z0-9._-]+$/.test(name))
@@ -57,13 +70,6 @@ export function parseWhen(s) {
         throw new UserError(`"${s}" is not a date (use YYYY-MM-DD)`);
     return d.toISOString();
 }
-/** The claimed name of a session (claims may hold an id prefix). */
-export function sessionTitle(claims, session) {
-    if (!session)
-        return undefined;
-    const c = claims.find((x) => session.startsWith(x.session) || x.session.startsWith(session));
-    return c?.title;
-}
 function checkKind(kind) {
     if (!CARD_KINDS.includes(kind))
         throw new UserError(`kind must be one of ${CARD_KINDS.join(", ")}`);
@@ -277,10 +283,32 @@ export function prEvent(pr, change, opts = {}) {
 export function sameSession(a, b) {
     return !!a && !!b && (a.startsWith(b) || b.startsWith(a));
 }
+/**
+ * Whether a session has ended: it said so with `claim --done`, or the human archived it in the
+ * Claude desktop app. Cards and pull requests it owned then belong to its project, so an answer
+ * still reaches a session waiting there. The desktop app is read only when asked about a session
+ * that has not claimed done.
+ */
+export function endedSessions(state, isArchived) {
+    let archived = isArchived;
+    return (session) => {
+        const claim = state.claims.find((c) => sameSession(c.session, session));
+        if (claim?.done)
+            return true;
+        archived ??= archivedSessions();
+        return archived(session);
+    };
+}
 /** Whether something owned by `owner` in `project` is for a reader with this filter. */
-function inScope(owner, project, f) {
-    if (f.session)
-        return owner ? sameSession(owner, f.session) : !!f.project && project === f.project;
+function inScope(owner, project, f, ended) {
+    if (f.session) {
+        if (owner && sameSession(owner, f.session))
+            return true;
+        // what a session that has ended owned is the project's now
+        if (owner && !ended(owner))
+            return false;
+        return !!f.project && project === f.project;
+    }
     return !f.project || project === f.project;
 }
 /** Two machines that both read GitHub report the same change; the later report is an echo. */
@@ -295,6 +323,7 @@ export function inboxFrom(events, after, filter, state = readState(events)) {
     const out = [];
     const reported = new Map();
     const answerNo = new Map();
+    const ended = filter.ended ?? endedSessions(state);
     for (const ev of events) {
         if (ev.type === "pr.change") {
             const k = `${ev.pr.key}|${ev.change}|${ev.text ?? ""}`;
@@ -306,7 +335,7 @@ export function inboxFrom(events, after, filter, state = readState(events)) {
             if (!isAfter(ev, pos))
                 continue;
             const link = state.prLinks.get(ev.pr.key);
-            if (!link || filter.card || !inScope(link.session, link.project, filter))
+            if (!link || filter.card || !inScope(link.session, link.project, filter, ended))
                 continue;
             out.push({ seq: ev.seq, dev: ev.dev, at: ev.ts, kind: "pr", by: ev.by ?? ev.source, pr: { ref: ev.pr, change: ev.change, title: ev.title, text: ev.text, project: link.project } });
             continue;
@@ -326,7 +355,7 @@ export function inboxFrom(events, after, filter, state = readState(events)) {
         const card = state.cards.get(ev.card);
         if (!card || card.status === "closed")
             continue;
-        if (!inScope(card.session, card.project, filter))
+        if (!inScope(card.session, card.project, filter, ended))
             continue;
         if (filter.card && card.id !== filter.card)
             continue;
@@ -442,14 +471,20 @@ export function listeners(now = Date.now()) {
     }
     return out;
 }
-/** The waits an answer to this card would wake right now. */
-export function listenersFor(card, ls) {
+/**
+ * The waits an answer to this card would wake right now. A card whose session has ended reaches
+ * the session waits in its project, as an unowned card does. A snapshot's card says so itself
+ * (`ownerEnded`); otherwise `ended` tells.
+ */
+export function listenersFor(card, ls, ended) {
+    let gone = card.ownerEnded;
+    const ownerGone = () => (gone ??= !!card.session && (ended ?? endedSessions(readState()))(card.session));
     return ls.filter((l) => l.card
         ? l.card === card.id
         : l.scope === "session"
-            ? card.session
-                ? sameSession(l.session, card.session)
-                : !!l.project && l.project === card.project
+            ? card.session && sameSession(l.session, card.session)
+                ? true
+                : (!card.session || ownerGone()) && !!l.project && l.project === card.project
             : !l.project || l.project === card.project);
 }
 export function consumerName(opts) {

package/dist/core/paths.js

@@ -0,0 +1,56 @@
+import fs from "node:fs";
+import path from "node:path";
+const WINDOWS = process.platform === "win32";
+/**
+ * The real spelling of a path, for comparing: symlinks and Windows short names (`RUNNER~1`)
+ * resolved, through the deepest part that exists. On Windows also lower case with `\` only, since
+ * the file system ignores case and logs mix `/` and `\`.
+ */
+export function canonicalPath(p) {
+    let rest = "";
+    let head = path.resolve(p);
+    let out = head;
+    for (;;) {
+        try {
+            out = path.join(fs.realpathSync.native(head), rest);
+            break;
+        }
+        catch {
+            const up = path.dirname(head);
+            if (up === head)
+                break;
+            rest = path.join(path.basename(head), rest);
+            head = up;
+        }
+    }
+    return WINDOWS ? out.replace(/\//g, "\\").toLowerCase() : out;
+}
+function within(child, parent) {
+    const rel = path.relative(parent, child);
+    return rel === "" || (!rel.startsWith("..") && !path.isAbsolute(rel));
+}
+/**
+ * Whether `child` is `parent` or inside it, as written or once both are resolved
+ * (`canonicalPath`). Pass a canonical form when it is already known, to skip the file system.
+ */
+export function insidePath(child, parent, canon) {
+    if (within(path.resolve(child), path.resolve(parent)))
+        return true;
+    return within(canon?.child ?? canonicalPath(child), canon?.parent ?? canonicalPath(parent));
+}
+/** Whether two paths name the same folder. */
+export function samePath(a, b) {
+    return path.resolve(a) === path.resolve(b) || canonicalPath(a) === canonicalPath(b);
+}
+/**
+ * Whether a text (a prompt) names this folder: as written, or with `\` and `/` swapped, and on
+ * Windows ignoring case.
+ */
+export function namesPath(text, dir) {
+    if (text.includes(dir))
+        return true;
+    const hay = WINDOWS ? text.toLowerCase() : text;
+    const d = WINDOWS ? dir.toLowerCase() : dir;
+    return hay.includes(d.replace(/\\/g, "/")) || hay.includes(d.replace(/\//g, "\\"));
+}
+//# sourceMappingURL=paths.js.map

package/dist/core/runs.js

@@ -3,6 +3,8 @@ import fs from "node:fs";
 import path from "node:path";
 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 { deviceName, sharedDir } from "./store.js";
 /** All checkouts of a project path: the path itself plus its git worktrees. */
 function rootsOf(p, cache) {
@@ -14,7 +16,7 @@ function rootsOf(p, cache) {
         const git = (args) => execFileSync("git", ["-C", p, ...args], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 5000 });
         // a folder inside a bigger repo (a notes vault, a monorepo package) must not claim the whole repo
         const top = git(["rev-parse", "--show-toplevel"]).trim();
-        if (path.resolve(top) !== path.resolve(p)) {
+        if (!samePath(top, p)) {
             cache.set(p, roots);
             return roots;
         }
@@ -33,23 +35,23 @@ function rootsOf(p, cache) {
     cache.set(p, roots);
     return roots;
 }
-function inside(child, parent) {
-    const rel = path.relative(parent, child);
-    return rel === "" || (!rel.startsWith("..") && !path.isAbsolute(rel));
-}
 function matchers(projects) {
     const cache = new Map();
-    return projects.map((p) => ({ project: p.name, roots: p.paths.flatMap((x) => rootsOf(x, cache)) }));
+    return projects.map((p) => ({
+        project: p.name,
+        roots: p.paths.flatMap((x) => rootsOf(x, cache)).map((r) => ({ path: r, canonical: canonicalPath(r) })),
+    }));
 }
 /** The project whose checkout holds this directory; the deepest root wins. */
 function projectForCwd(cwd, ms) {
     if (!cwd)
         return undefined;
+    const child = canonicalPath(cwd);
     let best;
     for (const m of ms) {
         for (const r of m.roots) {
-            if (inside(cwd, r) && (!best || r.length > best.depth))
-                best = { project: m.project, depth: r.length };
+            if (insidePath(cwd, r.path, { child, parent: r.canonical }) && (!best || r.path.length > best.depth))
+                best = { project: m.project, depth: r.path.length };
         }
     }
     return best?.project;
@@ -61,7 +63,7 @@ function projectForPrompt(prompt, ms) {
     const hits = new Set();
     for (const m of ms) {
         for (const r of m.roots)
-            if (prompt.includes(r))
+            if (namesPath(prompt, r.path))
                 hits.add(m.project);
     }
     return hits.size === 1 ? [...hits][0] : undefined;
@@ -109,7 +111,8 @@ function applyClaim(r, claim) {
     // done until someone writes to the session again
     if (claim.done && claim.at && (!r.lastPromptAt || r.lastPromptAt < claim.at)) {
         r.done = claim.done;
-        if (r.state === "idle")
+        // a session that says it is finished is not stuck, even if its log ends mid-turn
+        if (r.state === "idle" || r.state === "stalled")
             r.state = "done";
         r.asks = undefined;
     }
@@ -158,6 +161,29 @@ export function attribute(runs, state) {
     }
     return runs;
 }
+/**
+ * A Claude Code session the human archived in the Claude desktop app has ended, even when its log
+ * stops mid-turn (archived while a tool ran, say), and so have its subagents.
+ */
+export function endArchived(runs, isArchived) {
+    const ended = new Set();
+    for (const r of runs) {
+        if (r.runtime !== "claude-code" || r.kind !== "session" || r.device || !isArchived(r.id))
+            continue;
+        ended.add(r.id);
+    }
+    for (const r of runs) {
+        if (!ended.has(r.id) && !(r.parent && ended.has(r.parent)))
+            continue;
+        if (r.state === "failed")
+            continue;
+        r.state = "done";
+        if (ended.has(r.id))
+            r.done ??= "archived in the Claude app";
+        r.asks = undefined;
+    }
+    return runs;
+}
 /**
  * Fold repeated runs of a scheduled task into the newest one, with a count. Runs claimed as
  * scheduled group by project and task; unclaimed top-level sessions group by an identical first
@@ -344,7 +370,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 = attribute(scanAll({ sinceMs, now }, q.runtimes), state).filter(recent);
+    let runs = 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,5 +1,5 @@
 import { prViews, keyOf, parsePrRef, readCache, githubConfig } from "./github.js";
-import { linkPr, listeners, readState } from "./ops.js";
+import { endedSessions, linkPr, listeners, readState } from "./ops.js";
 import { collectRuns } from "./runs.js";
 import { deviceName, eventFiles, sharedDir } from "./store.js";
 import { SCHEMA_VERSION } from "./types.js";
@@ -15,7 +15,8 @@ export function snapshot(opts = {}) {
     if (linkCreatedPrs(runs, state))
         state = readState();
     const all = [...state.cards.values()].filter((c) => !opts.project || c.project === opts.project);
-    const cards = [...all.filter((c) => c.status !== "closed"), ...recentlyClosed(all, opts.closed ?? 0)];
+    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);
     quietAnsweredAsks(runs, all);
     const cache = readCache();
     const enabled = githubConfig().enabled && (cache.hosts === undefined ? false : cache.hosts.length > 0);

package/dist/core/state.js

@@ -1,3 +1,10 @@
+/** The claimed name of a session (claims may hold an id prefix). */
+export function sessionTitle(claims, session) {
+    if (!session)
+        return undefined;
+    const c = claims.find((x) => session.startsWith(x.session) || x.session.startsWith(session));
+    return c?.title;
+}
 function mapAll(xs, map, from) {
     return xs && map ? xs.map((x) => map(x, from)) : xs;
 }

package/package.json

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