parawatch 0.2.1 → 0.3.2

package/dist/core/ops.js

@@ -1,10 +1,19 @@
 import fs from "node:fs";
 import path from "node:path";
 import { UserError } from "./errors.js";
-import { appendEvent, eventsPath, homeDir, readCursor, readEvents, writeCursor } from "./store.js";
-import { fold, nextId } from "./state.js";
+import { advance, appendEvent, deviceName, eventsDir, homeDir, isAfter, readCursor, readEvents, sharedDir, writeCursor } from "./store.js";
+import { findId, fold, nextId } from "./state.js";
+import { pathMap } from "./sync.js";
 import { CARD_KINDS, HUMAN, PR_CHANGES } from "./types.js";
 export { UserError };
+/** Current state, with other machines' paths made local. */
+export function readState(events = readEvents()) {
+    return fold(events, pathMap());
+}
+/** The machine name ids carry, when the log is shared. */
+function idDevice() {
+    return sharedDir() ? deviceName() : undefined;
+}
 function cleanList(xs) {
     const out = (xs ?? []).map((x) => x.trim()).filter(Boolean);
     return out.length ? out : undefined;
@@ -22,7 +31,7 @@ export function addProject(name, paths) {
     }));
 }
 export function removeProject(name) {
-    const s = fold(readEvents());
+    const s = readState();
     if (!s.projects.has(name))
         throw new UserError(`no project named "${name}"`);
     appendEvent(() => ({ type: "project.remove", name }));
@@ -80,7 +89,7 @@ export function openCard(input) {
     const since = input.since?.trim() ? parseWhen(input.since) : undefined;
     let id = "";
     appendEvent((events) => {
-        id = nextId(events, "c");
+        id = nextId(events, "c", idDevice());
         const session = input.session?.trim() || undefined;
         const from = input.from?.trim() || sessionTitle(fold(events).claims, session);
         return {
@@ -105,19 +114,31 @@ export function openCard(input) {
             },
         };
     });
-    const card = fold(readEvents()).cards.get(id);
+    const card = readState().cards.get(id);
     if (!card)
         throw new Error("card vanished right after it was written");
     return card;
 }
+/** A card by id; a shared id may leave out its machine (`c3` for `pc-c3`). */
+export function findCard(state, id) {
+    const k = findId(state.cards, id);
+    return k ? state.cards.get(k) : undefined;
+}
 function requireCard(id) {
-    const card = fold(readEvents()).cards.get(id);
+    const card = findCard(readState(), id);
     if (!card)
         throw new UserError(`no card "${id}"`);
     return card;
 }
+function requireRun(id) {
+    const k = findId(readState().runs, id);
+    if (!k)
+        throw new UserError(`no declared run "${id}"`);
+    return k;
+}
 export function answerCard(id, a) {
     const card = requireCard(id);
+    id = card.id;
     if (card.status === "closed")
         throw new UserError(`card ${id} is already closed`);
     if (a.choice === undefined && !a.comment?.trim() && !cleanList(a.attach)) {
@@ -129,23 +150,26 @@ export function answerCard(id, a) {
             throw new UserError(n ? `--choice must be between 1 and ${n}` : `card ${id} has no options`);
         }
     }
-    appendEvent(() => ({
+    const shared = !!sharedDir();
+    appendEvent((events) => ({
         type: "card.answer",
         card: id,
         by: a.by || HUMAN,
         choice: a.choice,
         comment: a.comment?.trim() || undefined,
         attach: absPaths(a.attach),
+        // what this machine knew when answering, so a crossing answer from another machine shows
+        seen: shared ? events.filter((e) => e.type === "card.answer" && e.card === id).length : undefined,
     }));
 }
 export function commentCard(id, text, by) {
-    requireCard(id);
+    id = requireCard(id).id;
     if (!text.trim())
         throw new UserError("a comment needs text");
     appendEvent(() => ({ type: "card.comment", card: id, by, text: text.trim() }));
 }
 export function editCard(id, set) {
-    requireCard(id);
+    id = requireCard(id).id;
     const clean = {};
     if (set.kind !== undefined)
         clean.kind = checkKind(set.kind);
@@ -175,7 +199,7 @@ export function closeCard(id, note) {
     const card = requireCard(id);
     if (card.status === "closed")
         return;
-    appendEvent(() => ({ type: "card.close", card: id, note: note?.trim() || undefined }));
+    appendEvent(() => ({ type: "card.close", card: card.id, note: note?.trim() || undefined }));
 }
 export function startRun(r) {
     if (r.heartbeat !== undefined && (!Number.isFinite(r.heartbeat) || r.heartbeat <= 0))
@@ -183,25 +207,22 @@ export function startRun(r) {
     const log = r.log?.trim() ? path.resolve(r.log) : undefined;
     let id = "";
     appendEvent((events) => {
-        id = nextId(events, "r");
+        id = nextId(events, "r", idDevice());
         return { type: "run.start", run: { id, project: r.project, task: r.task, title: r.title, parent: r.parent, heartbeat: r.heartbeat, log } };
     });
     return id;
 }
 export function noteRun(id, text) {
-    if (!fold(readEvents()).runs.has(id))
-        throw new UserError(`no declared run "${id}"`);
-    appendEvent(() => ({ type: "run.note", run: id, text }));
+    const run = requireRun(id);
+    appendEvent(() => ({ type: "run.note", run, text }));
 }
 export function beatRun(id) {
-    if (!fold(readEvents()).runs.has(id))
-        throw new UserError(`no declared run "${id}"`);
-    appendEvent(() => ({ type: "run.beat", run: id }));
+    const run = requireRun(id);
+    appendEvent(() => ({ type: "run.beat", run }));
 }
 export function endRun(id, status, note) {
-    if (!fold(readEvents()).runs.has(id))
-        throw new UserError(`no declared run "${id}"`);
-    appendEvent(() => ({ type: "run.end", run: id, status, note }));
+    const run = requireRun(id);
+    appendEvent(() => ({ type: "run.end", run, status, note }));
 }
 /**
  * Say which project and task a session works on. A claim without a project keeps the session's
@@ -210,7 +231,7 @@ export function endRun(id, status, note) {
 export function claimSession(input) {
     if (input.session.length < 6)
         throw new UserError("give at least 6 characters of the session id");
-    const before = fold(readEvents()).claims.find((c) => c.session === input.session);
+    const before = readState().claims.find((c) => c.session === input.session);
     const project = input.project?.trim() || before?.project;
     if (!project)
         throw new UserError("this session has not claimed a project yet: give --project");
@@ -233,7 +254,7 @@ export function claimSession(input) {
 }
 // ---------------------------------------------------------------- pull requests
 export function linkPr(link) {
-    const claims = fold(readEvents()).claims;
+    const claims = readState().claims;
     const claim = link.session ? claims.find((c) => link.session.startsWith(c.session)) : undefined;
     const project = link.project?.trim() || claim?.project;
     appendEvent(() => ({
@@ -242,7 +263,7 @@ export function linkPr(link) {
     }));
 }
 export function unlinkPr(key) {
-    if (!fold(readEvents()).prLinks.has(key))
+    if (!readState().prLinks.has(key))
         throw new UserError(`no linked pull request ${key}`);
     appendEvent(() => ({ type: "pr.unlink", pr: key }));
 }
@@ -252,37 +273,67 @@ export function prEvent(pr, change, opts = {}) {
         throw new UserError(`change must be one of ${PR_CHANGES.join(", ")}`);
     appendEvent(() => ({ type: "pr.change", pr, change: change, by: opts.by, text: opts.text?.trim() || undefined, title: opts.title, source: "external" }));
 }
+/** Whether two session ids name the same session. A claim or a link may hold a short prefix. */
+export function sameSession(a, b) {
+    return !!a && !!b && (a.startsWith(b) || b.startsWith(a));
+}
+/** 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;
+    return !f.project || project === f.project;
+}
+/** Two machines that both read GitHub report the same change; the later report is an echo. */
+const ECHO_MS = 30 * 60_000;
 /**
- * Human answers and comments newer than `afterSeq`, on cards that are not closed, and news on pull
- * requests linked to the project.
+ * Human answers and comments after `after` (a position, or a seq on a single machine), on cards
+ * that are not closed, and news on pull requests linked to the project. An answer given on
+ * another machine before it saw an earlier answer is kept on the card but not delivered.
  */
-export function inboxFrom(events, afterSeq, filter) {
-    const state = fold(events);
+export function inboxFrom(events, after, filter, state = readState(events)) {
+    const pos = typeof after === "number" ? { [deviceName()]: after } : after;
     const out = [];
+    const reported = new Map();
+    const answerNo = new Map();
     for (const ev of events) {
-        if (ev.seq <= afterSeq)
-            continue;
         if (ev.type === "pr.change") {
+            const k = `${ev.pr.key}|${ev.change}|${ev.text ?? ""}`;
+            const prev = reported.get(k);
+            const at = Date.parse(ev.ts);
+            reported.set(k, { dev: ev.dev, at });
+            if (prev && prev.dev !== ev.dev && at - prev.at < ECHO_MS)
+                continue;
+            if (!isAfter(ev, pos))
+                continue;
             const link = state.prLinks.get(ev.pr.key);
-            if (!link || filter.card || (filter.project && link.project !== filter.project))
+            if (!link || filter.card || !inScope(link.session, link.project, filter))
                 continue;
-            out.push({ seq: ev.seq, 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 } });
+            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;
         }
         if (ev.type !== "card.answer" && ev.type !== "card.comment")
             continue;
-        if (ev.by !== HUMAN)
+        let late = false;
+        if (ev.type === "card.answer") {
+            const n = answerNo.get(ev.card) ?? 0;
+            answerNo.set(ev.card, n + 1);
+            late = typeof ev.seen === "number" && ev.seen < n;
+        }
+        if (!isAfter(ev, pos))
+            continue;
+        if (ev.by !== HUMAN || late)
             continue;
         const card = state.cards.get(ev.card);
         if (!card || card.status === "closed")
             continue;
-        if (filter.project && card.project !== filter.project)
+        if (!inScope(card.session, card.project, filter))
             continue;
         if (filter.card && card.id !== filter.card)
             continue;
         if (ev.type === "card.answer") {
             out.push({
                 seq: ev.seq,
+                dev: ev.dev,
                 at: ev.ts,
                 kind: "answer",
                 card,
@@ -294,26 +345,50 @@ export function inboxFrom(events, afterSeq, filter) {
             });
         }
         else {
-            out.push({ seq: ev.seq, at: ev.ts, kind: "comment", card, by: ev.by, comment: ev.text });
+            out.push({ seq: ev.seq, dev: ev.dev, at: ev.ts, kind: "comment", card, by: ev.by, comment: ev.text });
         }
     }
     return out;
 }
 // ---------------------------------------------------------------- listeners
+/** Waits are visible to every machine when the log is shared. */
 function listenersDir() {
-    return path.join(homeDir(), "listeners");
+    return path.join(sharedDir() ?? homeDir(), "listeners");
 }
+/** How often a wait says it is still there, and when one on another machine counts as gone. */
+const LISTENER_BEAT_MS = 60_000;
+const LISTENER_GONE_MS = 3 * LISTENER_BEAT_MS;
 /** Mark this process as waiting, so cards can say whether an answer reaches an agent at once. */
 export function startListening(l) {
-    const file = path.join(listenersDir(), `${process.pid}.json`);
+    const shared = !!sharedDir();
+    const file = path.join(listenersDir(), shared ? `${deviceName()}-${process.pid}.json` : `${process.pid}.json`);
     fs.mkdirSync(listenersDir(), { recursive: true });
-    const me = { ...l, pid: process.pid, since: new Date().toISOString() };
-    fs.writeFileSync(file, JSON.stringify(me) + "\n");
+    const me = { ...l, pid: process.pid, since: new Date().toISOString(), ...(shared ? { device: deviceName(), beat: new Date().toISOString() } : {}) };
+    const write = () => {
+        try {
+            const tmp = `${file}.tmp`;
+            fs.writeFileSync(tmp, JSON.stringify(me) + "\n");
+            fs.renameSync(tmp, file);
+        }
+        catch {
+            // the folder may be busy syncing; the next beat writes it again
+        }
+    };
+    write();
+    const timer = shared
+        ? setInterval(() => {
+            me.beat = new Date().toISOString();
+            write();
+        }, LISTENER_BEAT_MS)
+        : undefined;
+    timer?.unref();
     let done = false;
     const stop = () => {
         if (done)
             return;
         done = true;
+        if (timer)
+            clearInterval(timer);
         fs.rmSync(file, { force: true });
     };
     process.once("exit", stop);
@@ -334,8 +409,11 @@ function alive(pid) {
         return err.code === "EPERM";
     }
 }
-/** Waits running now. Files left by a process that died are removed. */
-export function listeners() {
+/**
+ * Waits running now, on this machine and (when shared) the others. Files left by a process that
+ * died here are removed; a wait on another machine counts while its beat is fresh.
+ */
+export function listeners(now = Date.now()) {
     let names;
     try {
         names = fs.readdirSync(listenersDir()).filter((f) => f.endsWith(".json"));
@@ -343,12 +421,17 @@ export function listeners() {
     catch {
         return [];
     }
+    const me = deviceName();
     const out = [];
     for (const n of names) {
         const file = path.join(listenersDir(), n);
         try {
             const l = JSON.parse(fs.readFileSync(file, "utf8"));
-            if (alive(l.pid))
+            if (l.device && l.device !== me) {
+                if (l.beat && now - Date.parse(l.beat) < LISTENER_GONE_MS)
+                    out.push(l);
+            }
+            else if (alive(l.pid))
                 out.push(l);
             else
                 fs.rmSync(file, { force: true });
@@ -361,17 +444,56 @@ export function listeners() {
 }
 /** The waits an answer to this card would wake right now. */
 export function listenersFor(card, ls) {
-    return ls.filter((l) => (l.card ? l.card === card.id : !l.project || l.project === card.project));
+    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
+            : !l.project || l.project === card.project);
 }
 export function consumerName(opts) {
     return opts.as || opts.project || (opts.card ? `card-${opts.card}` : "default");
 }
-export function readInbox(consumer, filter, advance) {
+/** The cursor a session reads with when it waits for its own news. */
+export function sessionConsumer(session) {
+    return `session-${session.replace(/[^A-Za-z0-9._-]/g, "_")}`;
+}
+/** Per device, the further of two positions. */
+export function furthest(a, b) {
+    const out = { ...a };
+    for (const [d, seq] of Object.entries(b))
+        if (seq > (out[d] ?? 0))
+            out[d] = seq;
+    return out;
+}
+/**
+ * What a wait or an inbox reads. `--card` and `--project` read what they name, with a cursor of
+ * that name. Called from an agent session without either, it reads that session's own cards and
+ * pull requests, plus unowned ones in the project the session claimed, with a cursor of its own:
+ * sessions in one project neither wake for each other's news nor take it from each other.
+ * Outside a session, it reads everything.
+ */
+export function inboxScope(opts, session) {
+    if (opts.card || opts.project || !session)
+        return { consumer: consumerName(opts), filter: { project: opts.project, card: opts.card } };
+    const claim = readState().claims.find((c) => sameSession(session, c.session));
+    const consumer = opts.as || sessionConsumer(session);
+    // A session that used to wait on its project starts where that wait stopped, so moving to its
+    // own cursor does not bring back news it has already handled.
+    if (claim && !Object.keys(readCursor(consumer)).length) {
+        const from = readCursor(claim.project);
+        if (Object.keys(from).length)
+            writeCursor(consumer, from);
+    }
+    return { consumer, filter: { session, project: claim?.project } };
+}
+export function readInbox(consumer, filter, move) {
     const events = readEvents();
-    const items = inboxFrom(events, readCursor(consumer), filter);
-    const last = items[items.length - 1];
-    if (advance && last)
-        writeCursor(consumer, last.seq);
+    const pos = readCursor(consumer);
+    const items = inboxFrom(events, pos, filter);
+    if (move && items.length)
+        writeCursor(consumer, advance(pos, items));
     return items;
 }
 /**
@@ -383,7 +505,7 @@ export async function waitInbox(consumer, filter, timeoutMs, pollMs = 1000) {
     let watcher;
     let wake;
     try {
-        const dir = path.dirname(eventsPath());
+        const dir = eventsDir();
         fs.mkdirSync(dir, { recursive: true });
         watcher = fs.watch(dir, () => wake?.());
     }

package/dist/core/runs.js

@@ -3,6 +3,7 @@ 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 { deviceName, sharedDir } from "./store.js";
 /** All checkouts of a project path: the path itself plus its git worktrees. */
 function rootsOf(p, cache) {
     const hit = cache.get(p);
@@ -96,27 +97,30 @@ function claimFor(id, state) {
  * 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.
  */
+function applyClaim(r, claim) {
+    r.project = claim.project;
+    r.projectSource = "claim";
+    r.task = claim.task ?? r.task;
+    r.role = claim.role ?? r.role;
+    if (claim.title)
+        r.title = claim.title;
+    if (claim.kind === "scheduled")
+        r.scheduled = true;
+    // 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")
+            r.state = "done";
+        r.asks = undefined;
+    }
+}
 export function attribute(runs, state) {
     const ms = matchers([...state.projects.values()]);
     const byId = new Map(runs.map((r) => [r.id, r]));
     for (const r of runs) {
         const claim = claimFor(r.id, state);
         if (claim) {
-            r.project = claim.project;
-            r.projectSource = "claim";
-            r.task = claim.task ?? r.task;
-            r.role = claim.role ?? r.role;
-            if (claim.title)
-                r.title = claim.title;
-            if (claim.kind === "scheduled")
-                r.scheduled = true;
-            // 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")
-                    r.state = "done";
-                r.asks = undefined;
-            }
+            applyClaim(r, claim);
             continue;
         }
         const here = projectForCwd(r.cwd, ms);
@@ -247,6 +251,92 @@ export function declaredRuns(state, now = Date.now()) {
         };
     });
 }
+// ---------------------------------------------------------------- other machines
+/** How often a machine rewrites its runs for the others, and when its summary counts as gone. */
+const SHARE_EVERY_MS = 30_000;
+export const SHARED_RUNS_GONE_MS = 15 * 60_000;
+const SHARED_RUNS_FILE = /^([a-z0-9][a-z0-9-]{0,31})\.json$/;
+function sharedRunsDir() {
+    const s = sharedDir();
+    return s ? path.join(s, "runs") : undefined;
+}
+/**
+ * Write the runs read from this machine's agent logs where the other machines read them, at most
+ * every half minute. The logs themselves stay here; only the summary travels.
+ */
+export function shareRuns(runs, now = Date.now()) {
+    if (!shareRunsDue(now))
+        return;
+    const dir = sharedRunsDir();
+    const me = deviceName();
+    const file = path.join(dir, `${me}.json`);
+    // the folders it edited are paths on this machine, and only guide attribution here
+    const slim = runs.map(({ touched: _t, ...r }) => ({ ...r, prompt: r.prompt?.slice(0, 300) }));
+    const body = { v: 1, device: me, at: new Date(now).toISOString(), runs: slim };
+    try {
+        fs.mkdirSync(dir, { recursive: true });
+        const tmp = path.join(dir, `.${me}.${process.pid}.tmp`);
+        fs.writeFileSync(tmp, JSON.stringify(body) + "\n");
+        fs.renameSync(tmp, file);
+    }
+    catch {
+        // the folder may be busy syncing; the next reading writes it again
+    }
+}
+/** Whether this machine's summary for the others is due (a shared folder, and none written lately). */
+export function shareRunsDue(now = Date.now()) {
+    const dir = sharedRunsDir();
+    if (!dir)
+        return false;
+    try {
+        return now - fs.statSync(path.join(dir, `${deviceName()}.json`)).mtimeMs >= SHARE_EVERY_MS;
+    }
+    catch {
+        return true;
+    }
+}
+/**
+ * Runs other machines shared, as they last wrote them, marked with the machine. A machine that
+ * has not written for a while is left out: its agents may be long gone. Claims made since are
+ * applied here, and the activity chart slides by the summary's age.
+ */
+export function otherRuns(state, now = Date.now()) {
+    const dir = sharedRunsDir();
+    if (!dir)
+        return [];
+    const me = deviceName();
+    let names = [];
+    try {
+        names = fs.readdirSync(dir);
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const n of names.sort()) {
+        const m = SHARED_RUNS_FILE.exec(n);
+        if (!m || m[1] === me)
+            continue;
+        try {
+            const s = JSON.parse(fs.readFileSync(path.join(dir, n), "utf8"));
+            const at = Date.parse(s.at);
+            if (!Number.isFinite(at) || now - at > SHARED_RUNS_GONE_MS || !Array.isArray(s.runs))
+                continue;
+            const shift = Math.max(0, Math.floor((now - at) / 60_000));
+            for (const r of s.runs) {
+                const run = { ...r, device: m[1], activity: r.activity?.map((x) => x + shift).filter((x) => x < ACTIVITY_MINUTES) };
+                const claim = claimFor(run.id, state);
+                if (claim)
+                    applyClaim(run, claim);
+                out.push(run);
+            }
+        }
+        catch {
+            // half synced; read it next time
+        }
+    }
+    return out;
+}
 const ENDED = new Set(["done", "idle", "failed"]);
 const RECENT_END_MS = 30 * 60_000;
 const OLD_STALL_MS = 3 * 3_600_000;
@@ -255,6 +345,10 @@ export function collectRuns(state, q, now = Date.now()) {
     // 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);
+    // a narrower reading (one runtime) would hide the rest from the other machines
+    if (!q.runtimes)
+        shareRuns(runs, now);
+    runs.push(...otherRuns(state, now).filter(recent));
     runs.push(...declaredRuns(state, now).filter(recent));
     attachPrs(runs, state);
     if (q.project)

package/dist/core/snapshot.js

@@ -1,8 +1,7 @@
 import { prViews, keyOf, parsePrRef, readCache, githubConfig } from "./github.js";
-import { linkPr, listeners } from "./ops.js";
+import { linkPr, listeners, readState } from "./ops.js";
 import { collectRuns } from "./runs.js";
-import { fold } from "./state.js";
-import { readEvents } from "./store.js";
+import { deviceName, eventFiles, sharedDir } from "./store.js";
 import { SCHEMA_VERSION } from "./types.js";
 /**
  * `closed`: also carry the most recently closed cards, newest first, so a panel can show them
@@ -11,10 +10,10 @@ import { SCHEMA_VERSION } from "./types.js";
  * GitHub is read from the last reading only; `syncGithub` refreshes it.
  */
 export function snapshot(opts = {}) {
-    let state = fold(readEvents());
+    let state = readState();
     const runs = collectRuns(state, { sinceHours: opts.sinceHours ?? 6, project: opts.project, keepRepeats: opts.keepRepeats });
     if (linkCreatedPrs(runs, state))
-        state = fold(readEvents());
+        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)];
     quietAnsweredAsks(runs, all);
@@ -32,6 +31,7 @@ export function snapshot(opts = {}) {
         prs,
         github: { enabled, fetchedAt: cache.fetchedAt, error: cache.error },
         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. */

package/dist/core/state.js

@@ -1,23 +1,38 @@
-/** Rebuild current state from the event log. */
-export function fold(events) {
+function mapAll(xs, map, from) {
+    return xs && map ? xs.map((x) => map(x, from)) : xs;
+}
+/** Rebuild current state from the event log. `map` makes other machines' paths local. */
+export function fold(events, map) {
     const s = { projects: new Map(), cards: new Map(), runs: new Map(), claims: [], prLinks: new Map(), lastSeq: 0 };
     for (const ev of events) {
         s.lastSeq = Math.max(s.lastSeq, ev.seq);
         switch (ev.type) {
             case "project.add":
-                s.projects.set(ev.project.name, ev.project);
+                s.projects.set(ev.project.name, { ...ev.project, paths: mapAll(ev.project.paths, map, ev.dev) ?? [] });
                 break;
             case "project.remove":
                 s.projects.delete(ev.name);
                 break;
-            case "card.open":
-                s.cards.set(ev.card.id, { ...ev.card, openedAt: ev.ts, status: "open", answers: [], comments: [] });
+            case "card.open": {
+                const card = { ...ev.card, openedAt: ev.ts, status: "open", answers: [], comments: [] };
+                if (ev.v >= 2 && ev.dev)
+                    card.dev = ev.dev;
+                card.attach = mapAll(card.attach, map, ev.dev);
+                card.open = mapAll(card.open, map, ev.dev);
+                s.cards.set(ev.card.id, card);
                 break;
+            }
             case "card.answer": {
                 const c = s.cards.get(ev.card);
                 if (!c)
                     break;
-                c.answers.push({ seq: ev.seq, at: ev.ts, by: ev.by, choice: ev.choice, comment: ev.comment, attach: ev.attach });
+                const a = { seq: ev.seq, at: ev.ts, by: ev.by, choice: ev.choice, comment: ev.comment, attach: mapAll(ev.attach, map, ev.dev) };
+                if (ev.v >= 2 && ev.dev)
+                    a.dev = ev.dev;
+                // written on another machine before that machine saw an earlier answer: the earlier one stands
+                if (typeof ev.seen === "number" && ev.seen < c.answers.length)
+                    a.late = true;
+                c.answers.push(a);
                 if (c.status === "open")
                     c.status = "answered";
                 break;
@@ -93,15 +108,31 @@ export function fold(events) {
     }
     return s;
 }
-/** Next id with a prefix, counting the events that created that kind of thing. */
-export function nextId(events, prefix) {
+/**
+ * Next id with a prefix, counting the events that created that kind of thing. In a shared folder
+ * (`device` given) only that machine's own log counts and the id carries the machine's name, so
+ * two machines never pick the same id: `pc-c3`.
+ */
+export function nextId(events, prefix, device) {
     let n = 0;
     for (const ev of events) {
+        if (device && ev.dev !== device)
+            continue;
         if (prefix === "c" && ev.type === "card.open")
             n++;
         if (prefix === "r" && ev.type === "run.start")
             n++;
     }
-    return `${prefix}${n + 1}`;
+    return device ? `${device}-${prefix}${n + 1}` : `${prefix}${n + 1}`;
+}
+/**
+ * Find a card or run by id. A shared id may be given without its machine (`c3` for `pc-c3`) as
+ * long as only one machine has it; an exact id always wins.
+ */
+export function findId(map, id) {
+    if (map.has(id))
+        return id;
+    const hits = [...map.keys()].filter((k) => k.endsWith(`-${id}`));
+    return hits.length === 1 ? hits[0] : undefined;
 }
 //# sourceMappingURL=state.js.map