@thehammer/danx-session-telemetry 0.1.13 → 0.1.14

package/README.md

@@ -41,7 +41,7 @@ own header comments for the per-file reasoning.
 |---|---|---|
 | **danxbot worker** (root repo, `tsx src/index.ts`) | npm **workspace** link (`"workspaces": ["packages/*"]` in root `package.json`, `"@thehammer/danx-session-telemetry"` in root `dependencies`) | The worker and this package always ship from the SAME repo commit — a workspace link means the worker runs whatever source the current commit carries, with zero drift risk and no dependency on registry propagation timing. The Docker image builds `dist/` for it in a dedicated builder stage (mirroring `dashboard-builder`/`frontend-builder` in `Dockerfile`) since the final image's `npm ci --omit=dev` never installs this package's own `devDependencies` (`typescript`). |
 | **`danx-dashboard-mcp` desktop bridge** (separate npm-published package, DX-2954) | Ordinary npm dependency, **pinned to the exact published version** the worker's commit ships | The bridge is a genuinely separate installable artifact (`npx -y @thehammer/danx-dashboard-mcp`), so it cannot workspace-link into danxbot's own checkout — it needs the real published bytes. Pinning exact (not `^`/`~`) is what makes "worker and MCP run identical collector code for any given release" true: MCP's own version bump is the only thing that ever changes what collector code it runs. |
-| **Dashboard server / dashboard SPA** (`src/dashboard/*`, `dashboard/*`) | Same npm dependency shape as the worker (dashboard's `src/` is root-repo code, so it resolves through the SAME root workspace link as the worker; `dashboard/` is its own separate npm package — DX-2963, the first real consumer there, adds an ordinary `dashboard/package.json` dependency, resolved by Vite/Vitest/`vue-tsc` through plain node_modules resolution, no alias needed) | No `@backend`-style alias is needed for an npm dependency the way one is needed for `dashboard/`'s reach into root `src/` — that alias exists because `dashboard/` is a SEPARATE package with no other way to reach root source; a real npm dependency resolves through ordinary node_modules lookup in every one of Vite's two configs, Vitest, `vue-tsc`, and the `dashboard-builder` Dockerfile stage (which already runs `cd dashboard && npm ci` AFTER the root repo — including `packages/`— is copied in, so the dependency is resolvable with zero Dockerfile change). `dashboard/` is FROZEN (`.claude/rules/ui-deprecation.md`) — this card adds no dependency there since nothing consumes it yet; DX-2963 adds the one line when it wires the real counter into `DispatchDetail.vue`/`DispatchList.vue`. |
+| **Dashboard server / dashboard SPA** (`src/dashboard/*`, `dashboard/*`) | Same npm dependency shape as the worker (dashboard's `src/` is root-repo code, so it resolves through the SAME root workspace link as the worker; `dashboard/` is its own separate npm package — DX-2963, the first real consumer there, adds an ordinary `dashboard/package.json` dependency, resolved by Vite/Vitest/`vue-tsc` through plain node_modules resolution, no alias needed) | No `@backend`-style alias is needed for an npm dependency the way one is needed for `dashboard/`'s reach into root `src/` — that alias exists because `dashboard/` is a SEPARATE package with no other way to reach root source; a real npm dependency resolves through ordinary node_modules lookup in every one of Vite's two configs, Vitest, `vue-tsc`, and the Dockerfile builder stages (`dashboard-deps-builder` runs `cd dashboard && npm ci` from `dashboard/`'s own manifests, so a `dashboard/package.json` dependency is resolvable with zero Dockerfile change). `dashboard/` is FROZEN (`.claude/rules/ui-deprecation.md`) — this card adds no dependency there since nothing consumes it yet; DX-2963 adds the one line when it wires the real counter into `DispatchDetail.vue`/`DispatchList.vue`. |
 
 ## Release order (DX-2962 AC3)
 

package/dist/session-log-watcher.js

@@ -219,52 +219,29 @@ export async function findSessionFileByDispatchId(dir, dispatchId) {
     try {
         const files = await readdir(dir);
         const jsonlFiles = files.filter((f) => f.endsWith(".jsonl"));
-        for (const file of jsonlFiles) {
-            const filePath = join(dir, file);
-            let fd;
-            try {
-                fd = await open(filePath, "r");
-                const fileStats = await stat(filePath);
-                if (await windowIncludesTag(fd, 0, fileStats.size, SCAN_BYTES, tag)) {
-                    return filePath;
-                }
-                // Resume: the new tag is at the tail of a large prior-session file.
-                // Skip when the file fits in one head window (already fully read).
-                if (fileStats.size > SCAN_BYTES) {
-                    const tailStart = fileStats.size - SCAN_BYTES;
-                    if (await windowIncludesTag(fd, tailStart, fileStats.size, SCAN_BYTES, tag)) {
-                        return filePath;
-                    }
-                }
-            }
-            catch (err) {
-                // DX-1201 — a single unreadable SIBLING file must NOT abort the
-                // whole scan. Dispatched agents share a busy session dir (e.g.
-                // every issue-worker dispatch of one repo writing under the same
-                // encoded `~/.claude/projects/<cwd>/` dir), so any one of the
-                // co-located multi-MB files can momentarily fail an `open`/`stat`/
-                // `read`: ENOENT (sibling rotated/deleted mid-scan), ESTALE (a
-                // worktree torn down under the agent), EACCES (perms race), EMFILE
-                // (fd pressure across N concurrent watchers). Before this guard the
-                // throw propagated out of the per-file body and rejected the entire
-                // `findSessionFileByDispatchId` call → `discoverSessionFile` →
-                // `start()` (fire-and-forget, no `.catch`) → the watcher silently
-                // never attached → null `session_uuid` + zero usage/tool-call
-                // counters on ~20% of host dispatches (intermittent because the
-                // outcome hinged on `readdir` ordering vs the failing sibling).
-                // Skip this file and keep scanning the rest — the tagged file the
-                // caller actually wants may be later in the directory.
-                const code = err.code;
-                if (code !== "ENOENT") {
-                    log.warn(`Skipping unreadable session file during dispatch-tag scan: ${filePath} (${code ?? String(err)})`);
-                }
-                continue;
-            }
-            finally {
-                await fd?.close();
-            }
-        }
-        return null;
+        // DX-3395 — scan every sibling CONCURRENTLY instead of one at a time.
+        // A dispatched agent's cwd is a busy, SHARED session dir (DX-1201's own
+        // comment below: every issue-worker dispatch of one card writes under
+        // the same encoded `~/.claude/projects/<cwd>/` dir), so this directory
+        // accumulates one multi-MB `.jsonl` per distinct session ever launched
+        // there. The previous `for...of` paid each sibling's bounded
+        // open+stat+read (<=2*SCAN_BYTES) back-to-back even though they are
+        // independent filesystem operations the OS can service in parallel —
+        // this is the ONE stage DX-3395's resume-latency investigation found
+        // that is both real, sequential, and entirely danxbot-owned (unlike the
+        // dominant cost, `claude --resume`'s own session reload, which lives
+        // outside this codebase — see the card for the measured comparison).
+        // `Promise.all` lets every sibling's I/O overlap; each check keeps its
+        // own try/catch (unchanged from the DX-1201 per-file isolation below),
+        // so one unreadable sibling still can never abort the others. At most
+        // ONE sibling can ever contain a given dispatch's unique tag, so which
+        // promise settles first is never ambiguous — the result is looked up by
+        // `files`' ORIGINAL index, so the return value stays deterministic
+        // regardless of resolution order (proven by the multi-sibling test in
+        // `session-log-watcher.test.ts`).
+        const hits = await Promise.all(jsonlFiles.map((file) => fileContainsTag(dir, file, tag, SCAN_BYTES)));
+        const index = hits.findIndex(Boolean);
+        return index === -1 ? null : join(dir, jsonlFiles[index]);
     }
     catch (err) {
         if (err.code === "ENOENT")
@@ -272,6 +249,56 @@ export async function findSessionFileByDispatchId(dir, dispatchId) {
         throw err;
     }
 }
+/**
+ * One sibling's head+tail scan for `findSessionFileByDispatchId`'s
+ * concurrent `Promise.all` — factored out so each file's try/catch/finally
+ * is self-contained and never affects any other sibling's check.
+ */
+async function fileContainsTag(dir, file, tag, scanBytes) {
+    const filePath = join(dir, file);
+    let fd;
+    try {
+        fd = await open(filePath, "r");
+        const fileStats = await stat(filePath);
+        if (await windowIncludesTag(fd, 0, fileStats.size, scanBytes, tag)) {
+            return true;
+        }
+        // Resume: the new tag is at the tail of a large prior-session file.
+        // Skip when the file fits in one head window (already fully read).
+        if (fileStats.size > scanBytes) {
+            const tailStart = fileStats.size - scanBytes;
+            if (await windowIncludesTag(fd, tailStart, fileStats.size, scanBytes, tag)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    catch (err) {
+        // DX-1201 — a single unreadable SIBLING file must NOT abort the
+        // whole scan. Dispatched agents share a busy session dir (e.g.
+        // every issue-worker dispatch of one repo writing under the same
+        // encoded `~/.claude/projects/<cwd>/` dir), so any one of the
+        // co-located multi-MB files can momentarily fail an `open`/`stat`/
+        // `read`: ENOENT (sibling rotated/deleted mid-scan), ESTALE (a
+        // worktree torn down under the agent), EACCES (perms race), EMFILE
+        // (fd pressure across N concurrent watchers). Before this guard the
+        // throw propagated out of the per-file body and rejected the entire
+        // `findSessionFileByDispatchId` call → `discoverSessionFile` →
+        // `start()` (fire-and-forget, no `.catch`) → the watcher silently
+        // never attached → null `session_uuid` + zero usage/tool-call
+        // counters on ~20% of host dispatches (intermittent because the
+        // outcome hinged on `readdir` ordering vs the failing sibling).
+        // Report this sibling as a non-match and let the others resolve.
+        const code = err.code;
+        if (code !== "ENOENT") {
+            log.warn(`Skipping unreadable session file during dispatch-tag scan: ${filePath} (${code ?? String(err)})`);
+        }
+        return false;
+    }
+    finally {
+        await fd?.close();
+    }
+}
 /**
  * Read a `<= maxBytes` window starting at `from` (clamped to the file) and
  * report whether `tag` appears in it. Factored out so the head + tail scans

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thehammer/danx-session-telemetry",
-  "version": "0.1.13",
+  "version": "0.1.14",
   "description": "Shared Claude Code transcript collector (DX-2962) — incremental JSONL tailing for the danxbot worker and the danx-dashboard-mcp desktop bridge, so both run identical collector code.",
   "license": "MIT",
   "type": "module",