agent-dag 1.13.0 → 1.15.0

package/dist/web/index.html

@@ -5,8 +5,8 @@
     <meta name="viewport" content="width=device-width, initial-scale=1" />
     <title>agent-dag</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-Cd7zyxkL.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-Ch4BS-lV.css">
+    <script type="module" crossorigin src="/assets/index-DZeh3MHD.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-Bwj0xSAo.css">
   </head>
   <body>
     <div id="root"></div>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-dag",
-  "version": "1.13.0",
+  "version": "1.15.0",
   "description": "Live DAG of Claude Code agents — watch parallel subagents fork, call tools, and return on one calm canvas.",
   "type": "module",
   "bin": {

package/src/server/index.mjs

@@ -73,32 +73,52 @@ async function maybeRotatePersistFile() {
 // payloads for that session before broadcasting, (b) emit a synthetic
 // `ModelObserved` event so the client backfills agents created before
 // the model was resolved.
-const modelBySession = new Map();         // sessionId -> "claude-…"
+const modelBySession = new Map();         // sessionId -> { rootModel, subsSig }
 const pendingTranscriptReads = new Set(); // sessionId currently being read
+const modelLastReadAt = new Map();        // sessionId -> ms timestamp (re-read throttle)
+const MODEL_READ_THROTTLE_MS = 2500;
 
 async function readModelFromTranscript(path) {
+  // Returns { rootModel, subagentModels } — root is the most recent
+  // non-sidechain assistant model, subagents are attributed by the Task
+  // tool_use id that owns them. CC transcripts mark subagent messages
+  // with `isSidechain:true` and (for current schemas) a `parentToolUseID`
+  // or `parent_tool_use_id` referencing the Task invocation.
   try {
     const s = await stat(path);
     if (s.size === 0) return null;
-    // Read up to last 128 KB — plenty for the most-recent model
-    // declaration. Reading from the tail handles sessions that switched
-    // model mid-conversation (we want the current one).
-    const TAIL = 128 * 1024;
-    const start = Math.max(0, s.size - TAIL);
     const fh = await open(path, "r");
+    let text;
     try {
-      const len = s.size - start;
-      const buf = Buffer.alloc(len);
-      await fh.read(buf, 0, len, start);
-      const text = buf.toString("utf8");
-      // Scan all matches and return the LAST one — most recent model used.
-      const re = /"model"\s*:\s*"(claude[-_][^"]+)"/gi;
-      let last = null;
-      for (const m of text.matchAll(re)) last = m[1];
-      return last;
+      const buf = Buffer.alloc(s.size);
+      await fh.read(buf, 0, s.size, 0);
+      text = buf.toString("utf8");
     } finally {
       await fh.close();
     }
+    let rootModel = null;
+    const subagentModels = {};
+    for (const line of text.split("\n")) {
+      if (!line) continue;
+      let obj;
+      try { obj = JSON.parse(line); } catch { continue; }
+      const msg = obj && obj.message;
+      // Assistant model entries live on either obj.model or obj.message.model
+      // depending on CC schema version. Accept either.
+      const model = (msg && typeof msg.model === "string" && /^claude[-_]/i.test(msg.model)) ? msg.model
+                  : (typeof obj.model === "string" && /^claude[-_]/i.test(obj.model))         ? obj.model
+                  : null;
+      if (!model) continue;
+      const isSide = obj.isSidechain === true || obj.is_sidechain === true;
+      const ptid = obj.parentToolUseID || obj.parent_tool_use_id || obj.parentToolUseId || null;
+      if (isSide && ptid) {
+        subagentModels[ptid] = model;
+      } else if (!isSide) {
+        rootModel = model;
+      }
+    }
+    if (!rootModel && Object.keys(subagentModels).length === 0) return null;
+    return { rootModel, subagentModels };
   } catch {
     return null;
   }
@@ -109,16 +129,29 @@ function maybeResolveModel(payload) {
   const sid = payload.session_id;
   const tp = payload.transcript_path;
   if (!sid || !tp) return;
-  if (modelBySession.has(sid)) return;
+  // Re-read on every event for this session — the cache was preventing us
+  // from picking up subagent models that arrive after the root is known.
+  // Throttle so we don't thrash the filesystem.
   if (pendingTranscriptReads.has(sid)) return;
+  const now = Date.now();
+  const last = modelLastReadAt.get(sid) ?? 0;
+  if (now - last < MODEL_READ_THROTTLE_MS) return;
+  modelLastReadAt.set(sid, now);
   pendingTranscriptReads.add(sid);
   readModelFromTranscript(tp)
-    .then(model => {
-      if (!model) return;
-      modelBySession.set(sid, model);
-      // Synthetic enrichment event — reducer applies to every agent in
-      // this session, including ones created before we resolved.
-      pushEvent({ hook_event_name: "ModelObserved", session_id: sid, model }, "internal");
+    .then(result => {
+      if (!result) return;
+      const { rootModel, subagentModels } = result;
+      const prev = modelBySession.get(sid);
+      const subsSig = JSON.stringify(subagentModels);
+      if (prev && prev.rootModel === rootModel && prev.subsSig === subsSig) return;
+      modelBySession.set(sid, { rootModel, subsSig });
+      pushEvent({
+        hook_event_name: "ModelObserved",
+        session_id: sid,
+        model: rootModel,
+        subagentModels,
+      }, "internal");
     })
     .catch(() => {})
     .finally(() => pendingTranscriptReads.delete(sid));
@@ -198,6 +231,145 @@ function maybeResolveUsage(payload) {
     .finally(() => pendingUsageReads.delete(sid));
 }
 
+// ─── Context enrichment ──────────────────────────────────────────────────
+// Approximation of `/context` since CC doesn't expose its breakdown via
+// hooks. We scan the transcript JSONL for message counts (user / assistant
+// / tool_use / tool_result / system-reminders) and walk up from cwd for
+// any CLAUDE.md files in scope. Token totals come from UsageObserved; this
+// scan is purely structural ("what does the context contain").
+const lastContextReadAt = new Map();
+const pendingContextReads = new Set();
+const CONTEXT_READ_THROTTLE_MS = 4000;
+
+async function readContextFromTranscript(path) {
+  try {
+    const s = await stat(path);
+    if (s.size === 0) return null;
+    const fh = await open(path, "r");
+    let buf;
+    try { buf = Buffer.alloc(s.size); await fh.read(buf, 0, s.size, 0); }
+    finally { await fh.close(); }
+    const text = buf.toString("utf8");
+    const breakdown = {
+      msgsUser: 0,
+      msgsAssistant: 0,
+      toolUses: 0,
+      toolResults: 0,
+      systemReminders: 0,
+      currentContextTokens: 0,
+    };
+    breakdown.msgsUser       = (text.match(/"type"\s*:\s*"user"/g) ?? []).length;
+    breakdown.msgsAssistant  = (text.match(/"type"\s*:\s*"assistant"/g) ?? []).length;
+    breakdown.toolUses       = (text.match(/"type"\s*:\s*"tool_use"/g) ?? []).length;
+    breakdown.toolResults    = (text.match(/"type"\s*:\s*"tool_result"/g) ?? []).length;
+    breakdown.systemReminders = (text.match(/<system-reminder>/g) ?? []).length;
+    // Current context size = input + cache_read + cache_create on the LAST
+    // usage block. Each assistant message's usage describes the context
+    // window for THAT call; summing across calls double-counts cached
+    // prefixes and explodes past the real ceiling. Take the most recent.
+    const re = /"usage"\s*:\s*\{([^}]+)\}/g;
+    const grab = (blob, key) => {
+      const km = blob.match(new RegExp(`"${key}"\\s*:\\s*(\\d+)`));
+      return km ? Number(km[1]) : 0;
+    };
+    let lastBlob = null;
+    for (const m of text.matchAll(re)) lastBlob = m[1];
+    if (lastBlob) {
+      breakdown.currentContextTokens =
+        grab(lastBlob, "input_tokens") +
+        grab(lastBlob, "cache_read_input_tokens") +
+        grab(lastBlob, "cache_creation_input_tokens");
+    }
+    return breakdown;
+  } catch { return null; }
+}
+
+/** Encode an absolute path the way CC stores it under
+ *  ~/.claude/projects/<slug>/. Drive letters, colons, and path separators
+ *  are flattened to "-" so the slug survives as a single directory name. */
+function ccProjectSlug(cwd) {
+  if (!cwd) return "";
+  // Replace path separators and the Windows drive colon. Match CC's own
+  // encoding: every \\ /  :  →  -  (no collapsing of adjacent dashes).
+  return resolve(cwd).replace(/[\\/:]/g, "-");
+}
+
+async function scanClaudeMdFiles(cwd) {
+  if (!cwd || typeof cwd !== "string") return [];
+  const found = [];
+  const seen = new Set();
+  const home = homedir();
+  const push = async (p) => {
+    if (seen.has(p)) return;
+    seen.add(p);
+    try {
+      const s = await stat(p);
+      if (s.isFile() && s.size > 0) found.push({ path: p, bytes: s.size });
+    } catch {}
+  };
+  // Walk up from cwd to filesystem root. At each dir, check for the
+  // canonical CC memory filenames plus CLAUDE.local.md (user-private).
+  let dir = resolve(cwd);
+  for (let depth = 0; depth < 16; depth++) {
+    for (const rel of [
+      "CLAUDE.md",
+      "CLAUDE.local.md",
+      join(".claude", "CLAUDE.md"),
+      join(".claude", "CLAUDE.local.md"),
+    ]) {
+      await push(join(dir, rel));
+    }
+    const parent = pdirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  // User-global memory.
+  await push(join(home, ".claude", "CLAUDE.md"));
+  await push(join(home, ".claude", "CLAUDE.local.md"));
+  // Per-project auto-memory: ~/.claude/projects/<slug>/memory/*.md
+  // (plus MEMORY.md index). CC injects these into context for sessions
+  // whose cwd matches the slug.
+  const slug = ccProjectSlug(cwd);
+  if (slug) {
+    const memDir = join(home, ".claude", "projects", slug, "memory");
+    try {
+      const entries = await readdir(memDir);
+      for (const f of entries) {
+        if (f.toLowerCase().endsWith(".md")) await push(join(memDir, f));
+      }
+    } catch {}
+  }
+  return found;
+}
+
+function maybeResolveContext(payload) {
+  if (!payload || typeof payload !== "object") return;
+  const sid = payload.session_id;
+  const tp = payload.transcript_path;
+  const cwd = payload.cwd;
+  if (!sid || !tp) return;
+  if (pendingContextReads.has(sid)) return;
+  const now = Date.now();
+  const last = lastContextReadAt.get(sid) ?? 0;
+  if (now - last < CONTEXT_READ_THROTTLE_MS) return;
+  lastContextReadAt.set(sid, now);
+  pendingContextReads.add(sid);
+  Promise.all([readContextFromTranscript(tp), scanClaudeMdFiles(cwd)])
+    .then(([breakdown, claudeMdFiles]) => {
+      if (!breakdown && (!claudeMdFiles || claudeMdFiles.length === 0)) return;
+      pushEvent({
+        hook_event_name: "ContextObserved",
+        session_id: sid,
+        context: {
+          ...(breakdown ?? {}),
+          claudeMdFiles: claudeMdFiles ?? [],
+        },
+      }, "internal");
+    })
+    .catch(() => {})
+    .finally(() => pendingContextReads.delete(sid));
+}
+
 function pushEvent(raw, source, opts = {}) {
   // Synchronous enrichment: if we already know this session's model, stamp
   // it on the payload so the client's recursive scanner picks it up.
@@ -235,6 +407,7 @@ function pushEvent(raw, source, opts = {}) {
   if (source === "hook" && !opts.replay) {
     maybeResolveModel(raw);
     maybeResolveUsage(raw);
+    maybeResolveContext(raw);
   }
 
   return evt;