parawatch 0.3.12 → 0.3.14

package/dist/core/ops.js

@@ -423,10 +423,12 @@ export function leadOf(state, ended) {
         if (!project)
             return undefined;
         if (!memo.has(project)) {
+            // the newest claim leads; claims keep log order, so a tie in time goes to the later one
             const leads = state.claims
-                .filter((c) => c.role === "lead" && c.project === project && !c.done && !ended(c.session))
-                .sort((a, b) => (b.at ?? "").localeCompare(a.at ?? ""));
-            memo.set(project, leads[0]?.session);
+                .map((c, i) => ({ c, i }))
+                .filter(({ c }) => c.role === "lead" && c.project === project && !c.done && !ended(c.session))
+                .sort((a, b) => (b.c.at ?? "").localeCompare(a.c.at ?? "") || b.i - a.i);
+            memo.set(project, leads[0]?.c.session);
         }
         return memo.get(project);
     };
@@ -719,7 +721,7 @@ export function inboxScope(opts, session) {
         // A lead waiting on its project from a session: what other live sessions own is theirs. It
         // takes over the project cursor once, so it does not hear again what that wait delivered.
         const mine = readCursor(consumer);
-        const merged = furthest(mine, readCursor(opts.project));
+        const merged = furthest(Object.keys(mine).length ? mine : bornAt(session), readCursor(opts.project));
         if (JSON.stringify(merged) !== JSON.stringify(mine))
             writeCursor(consumer, merged);
         return { consumer, filter: { session, project: opts.project } };
@@ -728,12 +730,36 @@ export function inboxScope(opts, 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);
+        const from = furthest(bornAt(session), readCursor(claim.project));
         if (Object.keys(from).length)
             writeCursor(consumer, from);
     }
     return { consumer, filter: { session, project: claim?.project } };
 }
+/**
+ * Where a session's first wait starts: just before the session first shows in the log (a claim,
+ * a card it opened, a pull request linked to it, something handed to it). Nothing before that was
+ * its to act on, and a lead starting at the top of the log would hear every old pull request and
+ * answer of the project again. A session the log has not seen starts at the top; it has nothing
+ * of its own and no project yet.
+ */
+export function bornAt(session, events = readEvents()) {
+    const i = events.findIndex((ev) => {
+        switch (ev.type) {
+            case "run.claim":
+                return sameSession(ev.claim.session, session);
+            case "card.open":
+                return sameSession(ev.card.session, session);
+            case "pr.link":
+                return sameSession(ev.link.session, session);
+            case "card.hand":
+                return sameSession(ev.session, session);
+            default:
+                return false;
+        }
+    });
+    return i < 0 ? {} : advance({}, events.slice(0, i));
+}
 export function readInbox(consumer, filter, move) {
     const events = readEvents();
     const pos = readCursor(consumer);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "parawatch",
-  "version": "0.3.12",
+  "version": "0.3.14",
   "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",
@@ -48,6 +48,7 @@
   },
   "devDependencies": {
     "@types/node": "^22.10.1",
+    "happy-dom": "^21.0.4",
     "tsx": "^4.19.2",
     "typescript": "^5.7.2",
     "vitest": "^2.1.8"