agent-dag 1.33.78 → 1.33.79

package/dist/web/index.html

@@ -5,7 +5,7 @@
     <meta name="viewport" content="width=device-width, initial-scale=1" />
     <title>agents-deck</title>
     <link rel="icon" href="data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 100 100'%3E%3Ctext y='84' font-size='84'%3E%E2%97%89%3C/text%3E%3C/svg%3E" />
-    <script type="module" crossorigin src="/assets/index-Ffz1bNVI.js"></script>
+    <script type="module" crossorigin src="/assets/index-BCX5R6_z.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-CF2yG9oG.css">
   </head>
   <body>

package/hook/hook.js

@@ -91,6 +91,51 @@ function isAlive(pid) {
   catch (e) { return e && e.code === "EPERM"; }
 }
 
+/**
+ * Of the decks about to be posted this event, which ones should also write it
+ * to disk? Returns the subset that should; every other target is asked to
+ * display the event and keep no record of it.
+ *
+ * The fan-out itself is deliberate — several decks can match one session and
+ * they should all draw it. Persisting is not: they all default to the same
+ * <claude config dir>/agent-dag/events.jsonl, so each of them appending its own
+ * copy wrote every event once per running deck. The file then grew N times as
+ * fast, rotated N times as often, and every replay of it ingested each tool
+ * call N times, which is what put duplicate tools and duplicate bubbles on the
+ * canvas after a restart.
+ *
+ * Decks are therefore grouped by the log file each one names in its discovery
+ * record, and one deck per group is elected. Grouping by the file rather than
+ * counting decks is what keeps the overrides honest: a deck run with
+ * `--history` sits alone in its own group and always writes, a deck run with
+ * `--no-persist` reports no file and can never be elected to write for one that
+ * does, and a deck too old to report either keeps the behaviour it had before
+ * this rule existed. Within a group the lowest port wins — a fixed rule, so the
+ * same deck holds the file for as long as it is up and the next one inherits it
+ * as soon as that deck is gone.
+ *
+ * The platform is a parameter, like cwdInWorkspace's, so the case-folding half
+ * is testable from any machine.
+ */
+function electWriters(decks, platform = process.platform) {
+  const byLog = new Map();
+  for (const d of decks) {
+    const log = typeof d.persist === "string" ? d.persist : "";
+    // Two namespaces, so a deck with no log to share — and a deck too old to
+    // report one — is alone in its group and cannot collide with a real path.
+    const key = log
+      ? `log:${foldsCase(platform) ? log.toLowerCase() : log}`
+      : `deck:${d.pid}:${d.port}`;
+    const held = byLog.get(key);
+    // Ports are unique among live decks; pid only breaks a tie a stale
+    // discovery file could invent, so the answer stays deterministic.
+    if (!held || d.port < held.port || (d.port === held.port && d.pid < held.pid)) {
+      byLog.set(key, d);
+    }
+  }
+  return new Set(byLog.values());
+}
+
 /**
  * The answer a deck must give to be handed a session payload.
  *
@@ -168,12 +213,15 @@ const POST_TIMEOUT_MS = 1000;
  * this target is finished.
  *
  * A deck that advertised no token is posted to directly: see requiresProof.
+ *
+ * `persists` is this deck's answer from electWriters: true for the one deck
+ * that logs the event, false for every other one it is also drawn on.
  */
-function deliver(d, body, done) {
+function deliver(d, body, persists, done) {
   let settled = false;
   const finish = () => { if (settled) return; settled = true; done(); };
 
-  if (!requiresProof(d)) return post(d, body, finish);
+  if (!requiresProof(d)) return post(d, body, persists, finish);
 
   const nonce = crypto.randomBytes(16).toString("hex");
   const want = challengeProof(d.token, nonce);
@@ -201,7 +249,7 @@ function deliver(d, body, done) {
       let proof;
       try { proof = JSON.parse(answer).proof; } catch { return finish(); }
       if (!sameProof(proof, want)) return finish();
-      post(d, body, finish);
+      post(d, body, persists, finish);
     });
   });
   req.on("error", finish);
@@ -209,11 +257,13 @@ function deliver(d, body, done) {
   req.end();
 }
 
-function post(d, body, finish) {
+function post(d, body, persists, finish) {
   const req = http.request({
     hostname: "127.0.0.1",
     port: d.port,
-    path: "/api/event",
+    // Only the elected deck records the event; the rest are asked to draw it
+    // and keep no copy, so one log file ends up with one copy of it.
+    path: persists ? "/api/event" : "/api/event?persist=0",
     method: "POST",
     headers: { "Content-Type": "application/json" },
     timeout: POST_TIMEOUT_MS,
@@ -289,16 +339,20 @@ function main() {
     const bestLen = matches[0].wsLen;
     const targets = matches.filter(m => m.wsLen === bestLen);
 
+    // One deck per events log records this event; the others only draw it.
+    const writers = electWriters(targets.map(m => m.d));
+
     let pending = targets.length;
     const done = () => { if (--pending <= 0) process.exit(0); };
 
-    for (const { d } of targets) deliver(d, taggedInput, done);
+    for (const { d } of targets) deliver(d, taggedInput, writers.has(d), done);
   });
 }
 
 // The host CLI always runs this file as the process entry point — the command
 // the installer writes is `"<node>" "<...>/hook.js" --provider <name>`. Under a
-// require() it exports the matching rule and starts nothing, which is what lets
-// the rule be tested without a 1.5s exit timer in the test runner.
-module.exports = { cwdInWorkspace, foldsCase, challengeProof, requiresProof };
+// require() it exports the rules it decides by — matching, election, the
+// handshake — and starts nothing, which is what lets them be tested without a
+// 1.5s exit timer in the test runner.
+module.exports = { cwdInWorkspace, foldsCase, electWriters, challengeProof, requiresProof };
 if (require.main === module) main();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-dag",
-  "version": "1.33.78",
+  "version": "1.33.79",
   "description": "Live deck of Claude Code and Codex agents — watch parallel subagents fork, call tools, and return on one calm canvas. Also available as npx ccdeck and npx agent-dag.",
   "type": "module",
   "bin": {

package/src/server/index.mjs

@@ -50,6 +50,45 @@ const sseClients = new Set();       // res handles
 
 let persistPath = null;             // absolute path to events.jsonl, or null
 
+// ─── Which deck records which session ─────────────────────────────────────
+// The hook posts an event to every deck whose workspace matches, and by
+// default all of them append to one events.jsonl — so each event landed in
+// that file once per running deck, and every later replay of it ingested each
+// tool call that many times. The hook now elects one writer per log file and
+// marks the request to the rest `?persist=0`. That flag covers the hook event
+// itself; this map carries it to the ModelObserved/UsageObserved/
+// ContextObserved events a deck derives from the same session's transcript,
+// which every deck reads for itself and would otherwise duplicate exactly the
+// same way. A session is recorded unless we have been told someone else owns
+// it, so a lone deck — and a deck the hook is too old to flag — still writes
+// everything.
+const foreignSessions = new Set();  // session ids another deck is logging
+const MAX_FOREIGN_SESSIONS = 512;   // bound: insertion order = oldest first
+
+function noteLogWriter(payload, mine) {
+  const sid = payload && typeof payload === "object" ? payload.session_id : null;
+  if (typeof sid !== "string" || sid === "") return;
+  // Delete either way: on re-add it moves the id back to the young end, so the
+  // eviction below drops sessions that stopped being posted, not busy ones.
+  foreignSessions.delete(sid);
+  if (mine) return;
+  foreignSessions.add(sid);
+  if (foreignSessions.size > MAX_FOREIGN_SESSIONS) {
+    foreignSessions.delete(foreignSessions.values().next().value);
+  }
+}
+
+/**
+ * Is this deck the one that writes this payload's session to the log? Every
+ * event goes through here on its way to disk, including the ones this deck
+ * derives from a transcript on its own — that is the point of remembering the
+ * session rather than only honouring the flag on the event that carried it.
+ */
+export function writesLogFor(payload) {
+  const sid = payload && typeof payload === "object" ? payload.session_id : null;
+  return typeof sid !== "string" || sid === "" || !foreignSessions.has(sid);
+}
+
 // ─── Persistence rotation ─────────────────────────────────────────────────
 // 24/7 dev servers used to grow events.jsonl unbounded — saw it hit GBs
 // across weeks. We rotate when the file passes ROTATE_AT_BYTES, archiving
@@ -949,7 +988,7 @@ function pushEvent(raw, source, opts = {}) {
     try { res.write(line); } catch {}
   }
 
-  if (persistPath && !opts.replay) {
+  if (persistPath && !opts.replay && opts.persist !== false && writesLogFor(raw)) {
     // Fire-and-forget append. JSONL = newline-delimited JSON.
     appendFile(persistPath, JSON.stringify(evt) + "\n", "utf8").catch(() => {});
     // Cheap throttled check (every 30s) — only rotates if file > 50MB.
@@ -1048,7 +1087,11 @@ function readBody(req, limit = 64_000) {
   });
 }
 
-function handleEventIngest(req, res) {
+// `persist` is false when the hook posted this event to another deck as well
+// and elected that one to write it to the log they share. The event is still
+// buffered and broadcast here — every matching deck draws it — it is only the
+// second copy on disk that is dropped.
+function handleEventIngest(req, res, persist = true) {
   let body = "";
   req.setEncoding("utf8");
   req.on("data", c => {
@@ -1061,7 +1104,8 @@ function handleEventIngest(req, res) {
     let parsed;
     try { parsed = JSON.parse(body); }
     catch { return send(res, 400, { error: "invalid json" }); }
-    const evt = pushEvent(parsed, "hook");
+    noteLogWriter(parsed, persist);
+    const evt = pushEvent(parsed, "hook", { persist });
     send(res, 200, { ok: true, seq: evt.seq });
   });
   req.on("error", () => send(res, 400, { error: "bad request" }));
@@ -1556,7 +1600,9 @@ export async function startServer({ port = 4317, host = "127.0.0.1", persist = n
       return send(res, 403, { error: "cross-site request blocked" });
     }
 
-    if (req.method === "POST" && url.pathname === "/api/event") return guard(handleEventIngest(req, res), res);
+    // `?persist=0` — another deck was elected to write this event to the log
+    // the two of them share. Absent, this deck writes it.
+    if (req.method === "POST" && url.pathname === "/api/event") return guard(handleEventIngest(req, res, url.searchParams.get("persist") !== "0"), res);
     if (req.method === "GET"  && url.pathname === "/api/health") return handleHealth(req, res);
     if (req.method === "GET"  && url.pathname === "/api/hook-challenge") return handleHookChallenge(req, res, url);
     if (req.method === "GET"  && url.pathname === "/events")     return handleSse(req, res);

package/src/server/installer.mjs

@@ -300,12 +300,21 @@ export function hasCodexInstalled() {
   return existsSync(CODEX_DIR);
 }
 
+/**
+ * The events log as the record spells it: an absolute path, or null when this
+ * deck writes none. Shared by the writer and by ensureDiscovery's comparison,
+ * so a file this process wrote can never read back as somebody else's.
+ */
+function persistField(persist) {
+  return typeof persist === "string" && persist !== "" ? persist : null;
+}
+
 // The token is the deck's proof of identity, so the file holding it is the
 // deck's key material: readable and writable by its owner, nobody else. Windows
 // ignores the mode (NTFS ACLs inherit from the profile directory, which is
 // already per-user), and a file left over from an earlier run under a recycled
 // pid keeps its old mode through writeFile, hence the explicit chmod.
-export async function writeDiscovery({ port, workspace, token }) {
+export async function writeDiscovery({ port, workspace, token, persist = null }) {
   await ensureDir(AGENT_DAG_DIR);
   const file = discoveryPath();
   const data = {
@@ -315,6 +324,12 @@ export async function writeDiscovery({ port, workspace, token }) {
     // Without this the hooks refuse to post: a file naming a port it cannot
     // authenticate is exactly the stale-file case they now decline to trust.
     token: token ?? "",
+    // Absolute path of the events log this deck appends to, or null under
+    // --no-persist. The hook reads it to elect a single writer per file:
+    // several decks receive the same event by design, and without this they
+    // each appended their own copy to the one log they share. See
+    // electWriters in hook/hook.js.
+    persist: persistField(persist),
     startedAt: new Date().toISOString(),
   };
   await writeFile(file, JSON.stringify(data, null, 2) + "\n", { encoding: "utf8", mode: 0o600 });
@@ -342,9 +357,13 @@ export function discoveryPath() {
  * is cheap (one small read), so the deck checks rather than assumes.
  *
  * A file this process wrote is left alone, mode included. Anything else — no
- * file, unreadable, another pid, a stale port or token — is replaced.
+ * file, unreadable, another pid, a stale port, token or events log — is
+ * replaced. Every field the hooks read is compared, the log path included:
+ * leave one out and a record missing it would pass as ours forever, which for
+ * the log path means the hook cannot tell which decks share a file and they all
+ * write their own copy of every event again.
  */
-export async function ensureDiscovery({ port, workspace, token }) {
+export async function ensureDiscovery({ port, workspace, token, persist = null }) {
   const file = discoveryPath();
   try {
     const d = JSON.parse(stripBom(await readFile(file, "utf8")));
@@ -352,11 +371,12 @@ export async function ensureDiscovery({ port, workspace, token }) {
       && d.pid === process.pid
       && d.port === port
       && (d.workspace ?? "") === (workspace ?? "")
-      && (d.token ?? "") === (token ?? "")) {
+      && (d.token ?? "") === (token ?? "")
+      && (d.persist ?? null) === persistField(persist)) {
       return { file, rewritten: false };
     }
   } catch { /* missing, unreadable or corrupt — rewritten below */ }
-  await writeDiscovery({ port, workspace, token });
+  await writeDiscovery({ port, workspace, token, persist });
   return { file, rewritten: true };
 }
 
@@ -373,7 +393,7 @@ export async function ensureDiscovery({ port, workspace, token }) {
  * `stop()` must be called before the file is removed on shutdown — otherwise
  * the next tick would put it straight back.
  */
-export function keepDiscovery({ port, workspace, token, intervalMs = 5000, onState = null } = {}) {
+export function keepDiscovery({ port, workspace, token, persist = null, intervalMs = 5000, onState = null } = {}) {
   // null until the first outcome, which therefore always differs and is always
   // reported — the caller learns where it stands before anything else happens.
   let healthy = null;
@@ -381,7 +401,7 @@ export function keepDiscovery({ port, workspace, token, intervalMs = 5000, onSta
   const check = async () => {
     let state;
     try {
-      const { rewritten } = await ensureDiscovery({ port, workspace, token });
+      const { rewritten } = await ensureDiscovery({ port, workspace, token, persist });
       state = { ok: true, rewritten, file: discoveryPath(), error: null };
     } catch (err) {
       state = { ok: false, rewritten: false, file: discoveryPath(), error: err };