agent-dag 1.33.93 → 1.33.94

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-CaEUrDxR.js"></script>
+    <script type="module" crossorigin src="/assets/index-DEsEm5QP.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-dwRx-2y0.css">
   </head>
   <body>

package/hook/hook.js

@@ -116,6 +116,12 @@ function isAlive(pid) {
  *
  * The platform is a parameter, like cwdInWorkspace's, so the case-folding half
  * is testable from any machine.
+ *
+ * src/server/log-writer.mjs repeats this rule for the events no hook delivers —
+ * the ones the server builds itself from Codex's rollout files — because this
+ * script is copied out of the package and cannot import it. A test compares the
+ * two directly: they decide for the same decks, and a disagreement is a line
+ * written twice or not at all.
  */
 function electWriters(decks, platform = process.platform) {
   const byLog = new Map();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-dag",
-  "version": "1.33.93",
+  "version": "1.33.94",
   "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

@@ -4,12 +4,13 @@ import { createServer } from "node:http";
 import { readFile, stat, mkdir, appendFile, open, truncate, readdir, unlink } from "node:fs/promises";
 import { createReadStream, existsSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
-import { extname, join, resolve, dirname as pdirname, sep } from "node:path";
+import { extname, join, resolve, dirname as pdirname } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { dirname } from "node:path";
 import { createInterface } from "node:readline";
 import { createHash, randomBytes } from "node:crypto";
 import { claudeConfigDir } from "./claude-dir.mjs";
+import { codexCwdInWorkspace, writesCodexLog } from "./log-writer.mjs";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const PKG_ROOT = resolve(__dirname, "..", "..");
@@ -778,8 +779,9 @@ function maybeResolveCodex(payload) {
 //   turn_context / response_item.model → model snapshot (ModelObserved on change)
 // Events are emitted with source "codex" so pushEvent skips the Claude-only
 // transcript enrichment (which needs transcript_path / hook events) but still
-// persists + broadcasts them exactly like a hook event. This path is entirely
-// additive — the Claude hook flow is untouched.
+// broadcasts them exactly like a hook event, and persists them when this deck is
+// the one elected to log this rollout — see writesCodexLog. This path is
+// entirely additive — the Claude hook flow is untouched.
 const codexFileState = new Map();      // path -> { offset, sid, cwd, skip, seenAt }
 const codexSessionModel = new Map();   // sid -> last model string
 // How long a rollout's tail cursor is kept after it stops showing up in the
@@ -790,12 +792,32 @@ let codexScanRunning = false;
 let codexWatchTimer = null;
 let codexWorkspace = "";
 
-function codexCwdInWorkspace(cwd) {
-  if (!codexWorkspace) return true;
-  if (!cwd || typeof cwd !== "string") return false;
-  const a = resolve(cwd).toLowerCase();
-  const b = resolve(codexWorkspace).toLowerCase();
-  return a === b || a.startsWith(b + sep.toLowerCase());
+/**
+ * Every deck registered right now, as its own discovery record spells it.
+ *
+ * These are the files hook.js enumerates; this is the server reading them for
+ * itself, because the rollout watcher has no hook to do it and still has to know
+ * which other decks are tailing the same file into the same log. Dead pids are
+ * ignored rather than unlinked — sweepStaleDiscovery owns that, and a poll
+ * running every 1.5s is no place to be deleting other decks' registrations.
+ */
+async function readLiveDecks() {
+  const dir = join(claudeConfigDir(), "agent-dag");
+  let files;
+  try { files = await readdir(dir); } catch { return []; }
+  const decks = [];
+  for (const f of files) {
+    if (!f.endsWith(".json")) continue;
+    try {
+      const d = JSON.parse(await readFile(join(dir, f), "utf8"));
+      // Without both numbers there is nothing to group or tie-break on, so the
+      // record cannot take part in an election either way.
+      if (!d || typeof d.pid !== "number" || typeof d.port !== "number") continue;
+      if (!isProcessAlive(d.pid)) continue;
+      decks.push(d);
+    } catch { /* corrupt, or gone between listing and read */ }
+  }
+  return decks;
 }
 
 // List rollout files from the newest 2 day-directories. New sessions always
@@ -912,17 +934,21 @@ function parseCodexOutput(raw) {
   }
 }
 
-function emitCodexEvent(payload) {
-  pushEvent(payload, "codex");
+// `persist` is false when another deck tailing this same rollout was elected to
+// write it to the log they share. The event is still buffered and broadcast —
+// every deck watching the session draws it — it is only the second copy on disk
+// that is dropped. See writesCodexLog in log-writer.mjs.
+function emitCodexEvent(payload, persist) {
+  pushEvent(payload, "codex", { persist });
 }
 
 // Emit the SessionStart root exactly once per file, lazily — only when the
 // session actually produces an event. This keeps long-dead sessions that were
 // merely on disk at startup from cluttering the canvas with empty roots.
-function ensureCodexRoot(state) {
+function ensureCodexRoot(state, persist) {
   if (state.rootEmitted) return;
   state.rootEmitted = true;
-  emitCodexEvent({ session_id: state.sid, cwd: state.cwd, provider: "codex", hook_event_name: "SessionStart" });
+  emitCodexEvent({ session_id: state.sid, cwd: state.cwd, provider: "codex", hook_event_name: "SessionStart" }, persist);
 }
 
 async function codexScanOnce(firstRun) {
@@ -930,6 +956,11 @@ async function codexScanOnce(firstRun) {
   codexScanRunning = true;
   try {
     const now = Date.now();
+    // Read at most once per scan, and only from the first rollout that actually
+    // has new bytes: most ticks read nothing and must not pay a directory
+    // listing for the answer to a question nothing is asking.
+    let decksRead = null;
+    const liveDecks = () => (decksRead ??= readLiveDecks());
     const files = await listRecentCodexRollouts();
     for (const path of files) {
       let st;
@@ -942,7 +973,7 @@ async function codexScanOnce(firstRun) {
         // capture it. Skip files outside our workspace.
         const header = await readCodexHeader(path);
         if (!header || !header.sid) continue; // not ready yet — retry next tick
-        if (!codexCwdInWorkspace(header.cwd)) {
+        if (!codexCwdInWorkspace(header.cwd, codexWorkspace)) {
           codexFileState.set(path, { offset: st.size, sid: header.sid, cwd: header.cwd, skip: true, rootEmitted: false, seenAt: now });
           continue;
         }
@@ -966,6 +997,13 @@ async function codexScanOnce(firstRun) {
       const consume = text.slice(0, lastNl);
       state.offset += Buffer.byteLength(consume, "utf8") + 1; // +1 for the \n
 
+      // Decided per file rather than per line: which decks are up, and which of
+      // them tail this rollout, cannot change inside one batch of appended
+      // lines, and the answer must be the same for every event in it — a root
+      // written by one deck and its tool calls by another is worse than either.
+      const persist = !persistPath
+        || writesCodexLog({ decks: await liveDecks(), pid: process.pid, cwd: state.cwd });
+
       for (const line of consume.split("\n")) {
         if (!line) continue;
         let obj;
@@ -975,12 +1013,12 @@ async function codexScanOnce(firstRun) {
         // If the model changed (turn_context/response_item), surface it.
         const nowModel = codexSessionModel.get(state.sid);
         if (nowModel && nowModel !== prevModel) {
-          ensureCodexRoot(state);
-          emitCodexEvent({ session_id: state.sid, cwd: state.cwd, provider: "codex", hook_event_name: "ModelObserved", model: nowModel });
+          ensureCodexRoot(state, persist);
+          emitCodexEvent({ session_id: state.sid, cwd: state.cwd, provider: "codex", hook_event_name: "ModelObserved", model: nowModel }, persist);
         }
         if (payload) {
-          ensureCodexRoot(state);
-          emitCodexEvent(payload);
+          ensureCodexRoot(state, persist);
+          emitCodexEvent(payload, persist);
         }
       }
     }

package/src/server/installer.mjs

@@ -314,7 +314,7 @@ function persistField(persist) {
 // 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, persist = null }) {
+export async function writeDiscovery({ port, workspace, token, persist = null, codex = true }) {
   await ensureDir(AGENT_DAG_DIR);
   const file = discoveryPath();
   const data = {
@@ -330,6 +330,12 @@ export async function writeDiscovery({ port, workspace, token, persist = null })
     // each appended their own copy to the one log they share. See
     // electWriters in hook/hook.js.
     persist: persistField(persist),
+    // Is this deck tailing Codex's rollout files? Those events never pass
+    // through a hook, so the decks elect a writer for them among themselves —
+    // and a deck running --no-codex must be left out of that election rather
+    // than win it and record a rollout it is not even reading. See
+    // writesCodexLog in src/server/log-writer.mjs.
+    codex: codex !== false,
     startedAt: new Date().toISOString(),
   };
   await writeFile(file, JSON.stringify(data, null, 2) + "\n", { encoding: "utf8", mode: 0o600 });
@@ -357,13 +363,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, 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.
+ * file, unreadable, another pid, a stale port, token, events log or Codex
+ * setting — is replaced. Every field another deck decides by 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 no deck can tell which of them share a
+ * file and they all write their own copy of every event again.
  */
-export async function ensureDiscovery({ port, workspace, token, persist = null }) {
+export async function ensureDiscovery({ port, workspace, token, persist = null, codex = true }) {
   const file = discoveryPath();
   try {
     const d = JSON.parse(stripBom(await readFile(file, "utf8")));
@@ -372,11 +378,12 @@ export async function ensureDiscovery({ port, workspace, token, persist = null }
       && d.port === port
       && (d.workspace ?? "") === (workspace ?? "")
       && (d.token ?? "") === (token ?? "")
-      && (d.persist ?? null) === persistField(persist)) {
+      && (d.persist ?? null) === persistField(persist)
+      && d.codex === (codex !== false)) {
       return { file, rewritten: false };
     }
   } catch { /* missing, unreadable or corrupt — rewritten below */ }
-  await writeDiscovery({ port, workspace, token, persist });
+  await writeDiscovery({ port, workspace, token, persist, codex });
   return { file, rewritten: true };
 }
 
@@ -393,7 +400,7 @@ export async function ensureDiscovery({ port, workspace, token, persist = null }
  * `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, persist = null, intervalMs = 5000, onState = null } = {}) {
+export function keepDiscovery({ port, workspace, token, persist = null, codex = true, 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;
@@ -401,7 +408,7 @@ export function keepDiscovery({ port, workspace, token, persist = null, interval
   const check = async () => {
     let state;
     try {
-      const { rewritten } = await ensureDiscovery({ port, workspace, token, persist });
+      const { rewritten } = await ensureDiscovery({ port, workspace, token, persist, codex });
       state = { ok: true, rewritten, file: discoveryPath(), error: null };
     } catch (err) {
       state = { ok: false, rewritten: false, file: discoveryPath(), error: err };

package/src/server/log-writer.mjs

@@ -0,0 +1,135 @@
+// Which of the running decks writes an event to the log they share?
+//
+// The hook already answers that for the events it delivers: it groups the decks
+// it is about to post to by the log file each one names in its discovery record,
+// elects one per file, and marks the request to every other one `?persist=0`.
+// See electWriters in hook/hook.js.
+//
+// The Codex rollout watcher never goes through the hook — it builds its events
+// inside the server by tailing ~/.codex/sessions/**/rollout-*.jsonl — so nothing
+// suppressed the copies on that path: every deck tailing the same rollout
+// appended its own line to the one events.jsonl they all default to, so each
+// Codex tool call, prompt and session start landed there once per running deck.
+// That is the duplication the hook election was added to end, still open on the
+// path that is the only Codex capture there is on Windows, where Codex hooks
+// never fire at all.
+//
+// So the server runs the same election, over the same discovery records, with
+// the same tie-break. The rule is repeated here rather than imported from
+// hook/hook.js because that file is copied out of the package and run standalone
+// by the host CLI, with no path back to the module it came from — the same
+// reason it re-derives the Claude config dir inline. The two copies are pinned
+// equal by a test, as challengeProof's pair already is.
+import { win32, posix } from "node:path";
+
+/**
+ * Does this platform's filesystem treat two spellings that differ only in case
+ * as the same file? The platform is a parameter so both answers can be checked
+ * from either kind of machine.
+ *
+ * Windows always does, and macOS does by default (APFS and HFS+ are formatted
+ * case-insensitive unless the user deliberately chose otherwise). Linux does
+ * not, and folding case there would be a bug of its own: /srv/a/events.jsonl and
+ * /srv/A/events.jsonl are two real files, each of which needs a writer.
+ */
+export const foldsCase = (platform = process.platform) =>
+  platform === "win32" || platform === "darwin";
+
+/**
+ * Of these decks, which ones write to disk? Returns the subset that should;
+ * every other one is expected to draw the event and keep no record of it.
+ *
+ * Decks are 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.
+ *
+ * Kept byte-for-byte equivalent to electWriters in hook/hook.js: the two decide
+ * for the same decks over the same records, and a disagreement between them
+ * means one log line written twice or none at all.
+ */
+export 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());
+}
+
+/**
+ * Would a deck scoped to `workspace` capture a rollout running in `cwd`? An
+ * empty workspace is unscoped and captures every session.
+ *
+ * Case is folded on every platform here, which the hook's own cwdInWorkspace
+ * deliberately does not do. That stays as it was, because this predicate now
+ * answers two questions with one function: whether THIS deck tails a rollout,
+ * and whether another deck tails it too. Model the other deck's capture with a
+ * rule stricter than the one it actually runs and the election covers the wrong
+ * set — a deck that writes without being elected, or an elected deck that never
+ * saw the file. Being wrong in the over-matching direction on Linux costs a deck
+ * a sibling tree it was not scoped to; being wrong in either direction here
+ * costs a duplicated log line or a lost one.
+ *
+ * The platform is a parameter, following the hook's cwdInWorkspace and
+ * spawnSpec in src/server/exec.mjs, so the Windows separator is testable from a
+ * POSIX machine.
+ */
+export function codexCwdInWorkspace(cwd, workspace, platform = process.platform) {
+  if (!workspace || typeof workspace !== "string") return true;
+  if (!cwd || typeof cwd !== "string") return false;
+  const p = platform === "win32" ? win32 : posix;
+  const a = p.resolve(cwd).toLowerCase();
+  const b = p.resolve(workspace).toLowerCase();
+  if (a === b) return true;
+  // A root ("C:\", "/") already ends in the separator; appending a second one
+  // would match nothing.
+  return a.startsWith(b.endsWith(p.sep) ? b : b + p.sep);
+}
+
+/**
+ * Does this deck append a rollout's events to its log, or is another deck doing
+ * it? `decks` is every deck registered right now, `pid` identifies this one
+ * among them, and `cwd` is the workspace the rollout is running in.
+ *
+ * The group is every deck that tails this same rollout — the hook's targets are
+ * narrowed to the longest workspace match, but nothing narrows these: each deck
+ * decides for itself, so all of them whose workspace contains the cwd read the
+ * file and all of them would write it. A deck started with `--no-codex` tails
+ * nothing and is left out; electing it would mean the rollout's events reach no
+ * log at all. A deck too old to say either way is assumed to be tailing, which
+ * is what it was doing before this field existed.
+ */
+export function writesCodexLog({ decks, pid, cwd, platform = process.platform }) {
+  const live = Array.isArray(decks) ? decks : [];
+  const self = live.find(d => d && d.pid === pid) ?? null;
+  // No record of our own on disk — the window before the first heartbeat writes
+  // it, or a deck that cannot write one at all. Nobody can elect us and we
+  // cannot see who else is here, so keep what this deck did before the election
+  // existed and write. A line written twice is recoverable; a deck that quietly
+  // stops recording anything is not.
+  if (!self || typeof self.persist !== "string" || self.persist === "") return true;
+
+  const group = [self];
+  for (const d of live) {
+    if (!d || d.pid === self.pid) continue;
+    if (d.codex === false) continue;
+    if (!codexCwdInWorkspace(cwd, d.workspace ?? "", platform)) continue;
+    group.push(d);
+  }
+  return electWriters(group, platform).has(self);
+}