ccc-notifier 0.3.0 → 0.5.0

package/dist/{chunk-4RZ6OGTD.js → chunk-DDUK4EWQ.js}

@@ -4,7 +4,7 @@ import {
   isMuted,
   readMuteState,
   writeMuteState
-} from "./chunk-ECADO26T.js";
+} from "./chunk-5PH7PPD6.js";
 
 // src/mute.ts
 function parseDuration(arg) {

package/dist/chunk-ENGUOLTD.js

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+import {
+  paths
+} from "./chunk-5PH7PPD6.js";
+
+// src/dashboard-state.ts
+import {
+  closeSync,
+  existsSync,
+  openSync,
+  readFileSync,
+  readSync,
+  renameSync,
+  rmSync,
+  writeFileSync
+} from "fs";
+import { randomUUID } from "crypto";
+function localDate(now) {
+  const y = now.getFullYear();
+  const m = String(now.getMonth() + 1).padStart(2, "0");
+  const d = String(now.getDate()).padStart(2, "0");
+  return `${y}-${m}-${d}`;
+}
+function timeZone() {
+  return Intl.DateTimeFormat().resolvedOptions().timeZone || "unknown";
+}
+function makeFullDashboardState(now = /* @__PURE__ */ new Date()) {
+  return { localDate: localDate(now), timeZone: timeZone(), generatedAt: now.toISOString() };
+}
+function readState() {
+  const file = paths().dashboardFullStateFile;
+  if (!existsSync(file)) return null;
+  try {
+    const value = JSON.parse(readFileSync(file, "utf8"));
+    if (typeof value !== "object" || value === null || Array.isArray(value)) return null;
+    const v = value;
+    if (typeof v.localDate !== "string" || !/^\d{4}-\d{2}-\d{2}$/.test(v.localDate) || typeof v.timeZone !== "string" || v.timeZone.length === 0 || typeof v.generatedAt !== "string" || !Number.isFinite(Date.parse(v.generatedAt))) {
+      return null;
+    }
+    return v;
+  } catch {
+    return null;
+  }
+}
+function isFullDashboardDue(now = /* @__PURE__ */ new Date()) {
+  const p = paths();
+  if (!existsSync(p.fullDashboardFile)) return true;
+  try {
+    const fd = openSync(p.fullDashboardFile, "r");
+    try {
+      const head = Buffer.alloc(512);
+      const n = readSync(fd, head, 0, head.length, 0);
+      if (head.toString("utf8", 0, n).includes('name="cccn-placeholder"')) return true;
+    } finally {
+      closeSync(fd);
+    }
+  } catch {
+    return true;
+  }
+  const state = readState();
+  if (state === null) return true;
+  const expected = makeFullDashboardState(now);
+  if (state.timeZone !== expected.timeZone) return true;
+  if (state.localDate !== expected.localDate) return true;
+  if (state.localDate > expected.localDate) return true;
+  if (Date.parse(state.generatedAt) > now.getTime()) return true;
+  return false;
+}
+function writeFullDashboardStateAtomic(state) {
+  const file = paths().dashboardFullStateFile;
+  const tmp = `${file}.${process.pid}.${randomUUID()}.tmp`;
+  try {
+    writeFileSync(tmp, `${JSON.stringify(state)}
+`, "utf8");
+    renameSync(tmp, file);
+  } finally {
+    rmSync(tmp, { force: true });
+  }
+}
+function invalidateCanonicalDashboards() {
+  const p = paths();
+  for (const file of [p.recentDashboardFile, p.fullDashboardFile, p.dashboardFullStateFile]) {
+    rmSync(file, { force: true });
+  }
+}
+
+export {
+  makeFullDashboardState,
+  isFullDashboardDue,
+  writeFullDashboardStateAtomic,
+  invalidateCanonicalDashboards
+};

package/dist/chunk-HLJAJS2W.js

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+
+// src/codex/sessions.ts
+import { promises as fsp } from "fs";
+import { join, resolve } from "path";
+var CODEX_MAX_DEPTH = 4;
+async function listCodexRollouts(sessionsRoot) {
+  const rollouts = [];
+  let unreadableDirs = 0;
+  const root = resolve(sessionsRoot);
+  const rootStat = await fsp.lstat(root).catch(() => null);
+  if (rootStat === null || !rootStat.isDirectory()) {
+    return { rollouts, unreadableDirs: 1 };
+  }
+  const walk = async (dir, depth) => {
+    const entries = await fsp.readdir(dir, { withFileTypes: true }).catch(() => null);
+    if (entries === null) {
+      unreadableDirs += 1;
+      return;
+    }
+    for (const entry of entries) {
+      const full = resolve(join(dir, entry.name));
+      if (entry.isFile()) {
+        if (entry.name.startsWith("rollout-") && entry.name.endsWith(".jsonl")) rollouts.push(full);
+      } else if (entry.isDirectory() && depth < CODEX_MAX_DEPTH) {
+        await walk(full, depth + 1);
+      }
+    }
+  };
+  await walk(root, 1);
+  return { rollouts, unreadableDirs };
+}
+async function findLatestCodexRollout(sessionsRoot) {
+  const discovery = await listCodexRollouts(sessionsRoot);
+  let latest = null;
+  let latestMtime = -Infinity;
+  let unreadableFiles = 0;
+  for (const path of discovery.rollouts) {
+    const stat = await fsp.lstat(path).catch(() => null);
+    if (stat === null || !stat.isFile()) {
+      unreadableFiles += 1;
+      continue;
+    }
+    if (stat.mtimeMs > latestMtime || stat.mtimeMs === latestMtime && (latest === null || path < latest)) {
+      latest = path;
+      latestMtime = stat.mtimeMs;
+    }
+  }
+  return { latest, unreadableDirs: discovery.unreadableDirs, unreadableFiles };
+}
+
+export {
+  listCodexRollouts,
+  findLatestCodexRollout
+};

package/dist/{chunk-LHKBGA5K.js → chunk-LVMKY6JB.js}

@@ -61,7 +61,7 @@ function resolvePrice(modelId, table) {
   return bestPrice ? { ...bestPrice } : null;
 }
 function computeCost(main, sidechain, table) {
-  const byModel = {};
+  const byModel = /* @__PURE__ */ Object.create(null);
   const unknownModels = [];
   let usd = 0;
   const accumulate = (usage) => {
@@ -73,7 +73,7 @@ function computeCost(main, sidechain, table) {
       } else {
         cost = (tokens.input * p.input + tokens.output * p.output + tokens.cacheWrite5m * p.cacheWrite5m + tokens.cacheWrite1h * p.cacheWrite1h + tokens.cacheRead * p.cacheRead) / 1e6;
       }
-      byModel[model] = (byModel[model] ?? 0) + cost;
+      byModel[model] = (Object.hasOwn(byModel, model) ? byModel[model] : 0) + cost;
       usd += cost;
     }
   };
@@ -277,11 +277,10 @@ async function getUsdJpy(cfg, cacheDir) {
   return { rate: cfg.fx.fallbackRate, source: "fixed", fetchedAt: (/* @__PURE__ */ new Date()).toISOString() };
 }
 
-// src/transcript.ts
+// src/codex/transcript.ts
 import { readFile as readFile2 } from "fs/promises";
+import { basename } from "path";
 var NEWLINE = 10;
-var MAX_SEEN_KEYS = 500;
-var SYNTHETIC_MODEL = "<synthetic>";
 function isRecord(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
@@ -291,6 +290,280 @@ function numOf(v) {
 function strOrNull(v) {
   return typeof v === "string" ? v : null;
 }
+function zeroTotals() {
+  return { input: 0, cached: 0, output: 0 };
+}
+function isZeroTotals(t) {
+  return t.input === 0 && t.cached === 0 && t.output === 0;
+}
+function addTotals(target, d) {
+  target.input += d.input;
+  target.cached += d.cached;
+  target.output += d.output;
+}
+function readTotals(v) {
+  if (!isRecord(v)) return null;
+  return {
+    input: numOf(v.input_tokens),
+    cached: numOf(v.cached_input_tokens),
+    output: numOf(v.output_tokens)
+  };
+}
+function totalsToBuckets(acc) {
+  return {
+    input: Math.max(0, acc.input - acc.cached),
+    output: acc.output,
+    cacheWrite5m: 0,
+    cacheWrite1h: 0,
+    cacheRead: acc.cached
+  };
+}
+function sessionIdFromFilename(rolloutPath) {
+  const m = /^rollout-.*-([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/i.exec(
+    basename(rolloutPath)
+  );
+  return m !== null ? m[1] : "";
+}
+async function readAll(path2) {
+  try {
+    return await readFile2(path2);
+  } catch {
+    return null;
+  }
+}
+function newSegmentBuf() {
+  return {
+    acc: zeroTotals(),
+    apiCalls: 0,
+    prompt: null,
+    turnCtxCwd: null,
+    firstTs: null,
+    endTs: null,
+    hasLines: false
+  };
+}
+async function scanWindow(rolloutPath, cursor) {
+  const buffer = await readAll(rolloutPath);
+  if (buffer === null) return null;
+  const fileSize = buffer.length;
+  let startOffset;
+  let rescan;
+  if (cursor !== null && cursor.offset > 0 && cursor.offset <= fileSize && buffer[cursor.offset - 1] === NEWLINE) {
+    startOffset = cursor.offset;
+    rescan = false;
+  } else {
+    startOffset = 0;
+    rescan = cursor !== null;
+  }
+  const tsFloor = cursor?.lastTs ?? null;
+  const initTotals = cursor?.codexTotals;
+  let prev = initTotals !== void 0 ? { ...initTotals } : zeroTotals();
+  const acc = zeroTotals();
+  let apiCalls = 0;
+  let lastModel = null;
+  let windowPrompt = null;
+  let windowTurnCtxCwd = null;
+  let sessionMetaCwd = null;
+  let sessionMetaSid = null;
+  let firstTs = null;
+  let lastTs = null;
+  const segments = [];
+  let seg = newSegmentBuf();
+  const snapshotSegment = (endOffset) => ({
+    acc: seg.acc,
+    apiCalls: seg.apiCalls,
+    prompt: seg.prompt,
+    model: lastModel,
+    cwd: seg.turnCtxCwd ?? sessionMetaCwd,
+    firstTs: seg.firstTs,
+    endTs: seg.endTs,
+    endOffset,
+    prevAtEnd: { ...prev },
+    lastTsAtEnd: lastTs
+  });
+  const handleLine = (raw, endOffset) => {
+    if (raw.trim().length === 0) return;
+    let obj;
+    try {
+      obj = JSON.parse(raw);
+    } catch {
+      return;
+    }
+    if (!isRecord(obj)) return;
+    const ts = strOrNull(obj.timestamp);
+    if (rescan && tsFloor !== null && ts !== null && ts <= tsFloor) return;
+    if (ts !== null) {
+      if (firstTs === null || ts < firstTs) firstTs = ts;
+      if (lastTs === null || ts > lastTs) lastTs = ts;
+      if (seg.firstTs === null || ts < seg.firstTs) seg.firstTs = ts;
+      seg.endTs = ts;
+    }
+    seg.hasLines = true;
+    const payload = isRecord(obj.payload) ? obj.payload : null;
+    if (payload === null) return;
+    const type = obj.type;
+    if (type === "session_meta") {
+      const sid = strOrNull(payload.session_id);
+      if (sid !== null) sessionMetaSid = sid;
+      const c = strOrNull(payload.cwd);
+      if (c !== null) sessionMetaCwd = c;
+      return;
+    }
+    if (type === "turn_context") {
+      const m = strOrNull(payload.model);
+      if (m !== null) lastModel = m;
+      const c = strOrNull(payload.cwd);
+      if (c !== null) {
+        seg.turnCtxCwd = c;
+        windowTurnCtxCwd = c;
+      }
+      return;
+    }
+    if (type !== "event_msg") return;
+    const kind = payload.type;
+    if (kind === "user_message") {
+      const msg = strOrNull(payload.message);
+      if (msg !== null) {
+        seg.prompt = msg;
+        windowPrompt = msg;
+      }
+      return;
+    }
+    if (kind === "token_count") {
+      const info = isRecord(payload.info) ? payload.info : null;
+      if (info === null) return;
+      const total = readTotals(info.total_token_usage);
+      if (total === null) return;
+      let step = {
+        input: total.input - prev.input,
+        cached: total.cached - prev.cached,
+        output: total.output - prev.output
+      };
+      if (step.input < 0 || step.cached < 0 || step.output < 0) {
+        step = readTotals(info.last_token_usage) ?? zeroTotals();
+      }
+      addTotals(acc, step);
+      addTotals(seg.acc, step);
+      prev = total;
+      if (!isZeroTotals(step)) {
+        apiCalls++;
+        seg.apiCalls++;
+      }
+      return;
+    }
+    if (kind === "task_complete") {
+      segments.push(snapshotSegment(endOffset));
+      seg = newSegmentBuf();
+    }
+  };
+  let lineStart = startOffset;
+  for (let pos = startOffset; pos < fileSize; pos++) {
+    if (buffer[pos] !== NEWLINE) continue;
+    handleLine(buffer.toString("utf8", lineStart, pos), pos + 1);
+    lineStart = pos + 1;
+  }
+  const newOffset = lineStart;
+  const open = seg.hasLines ? snapshotSegment(newOffset) : null;
+  return {
+    segments,
+    open,
+    acc,
+    prev,
+    apiCalls,
+    model: lastModel,
+    prompt: windowPrompt,
+    cwd: windowTurnCtxCwd ?? sessionMetaCwd,
+    sessionId: sessionMetaSid ?? sessionIdFromFilename(rolloutPath),
+    firstTs,
+    lastTs,
+    newOffset
+  };
+}
+function windowCursor(scan) {
+  return {
+    offset: scan.newOffset,
+    lastUuid: null,
+    // rollout に uuid 行は無い
+    lastTs: scan.lastTs,
+    seenMessageKeys: [],
+    // 去重は codexTotals の差分方式が担う
+    codexTotals: { ...scan.prev }
+  };
+}
+async function aggregateCodexTurn(rolloutPath, cursor) {
+  const scan = await scanWindow(rolloutPath, cursor);
+  if (scan === null || isZeroTotals(scan.acc)) return null;
+  return {
+    sessionId: scan.sessionId,
+    main: { [scan.model ?? "unknown"]: totalsToBuckets(scan.acc) },
+    sidechain: {},
+    // Codex にサブエージェント概念は無い
+    apiCalls: scan.apiCalls,
+    prompt: scan.prompt,
+    cwd: scan.cwd,
+    gitBranch: null,
+    // rollout に無い
+    firstTs: scan.firstTs,
+    lastTs: scan.lastTs,
+    newCursor: windowCursor(scan)
+  };
+}
+async function splitIntoCodexTurnDrafts(rolloutPath, cursor) {
+  const scan = await scanWindow(rolloutPath, cursor);
+  if (scan === null || isZeroTotals(scan.acc)) return null;
+  const picked = scan.segments.filter((s) => !isZeroTotals(s.acc));
+  if (scan.open !== null && !isZeroTotals(scan.open.acc)) {
+    const last = picked[picked.length - 1];
+    if (last !== void 0) {
+      addTotals(last.acc, scan.open.acc);
+      last.apiCalls += scan.open.apiCalls;
+      if (scan.open.endTs !== null) last.endTs = scan.open.endTs;
+    } else {
+      picked.push(scan.open);
+    }
+  }
+  const lastIndex = picked.length - 1;
+  return picked.map((s, i) => ({
+    agg: {
+      sessionId: scan.sessionId,
+      // session_meta はファイル先頭にしか無いので全ドラフト共通
+      main: { [s.model ?? "unknown"]: totalsToBuckets(s.acc) },
+      sidechain: {},
+      apiCalls: s.apiCalls,
+      prompt: s.prompt,
+      cwd: s.cwd,
+      gitBranch: null,
+      firstTs: s.firstTs,
+      lastTs: s.endTs,
+      // 最後のドラフトはウィンドウ全体を消費した状態(= aggregateCodexTurn の newCursor と同一。
+      // 末尾の usage ゼロな行の読み捨てもここに含まれる)。途中のドラフトはそのセグメント末尾を
+      // 指す有効な再開点(そこから読み直せば残りが差分になる)。
+      newCursor: i === lastIndex ? windowCursor(scan) : {
+        offset: s.endOffset,
+        lastUuid: null,
+        lastTs: s.lastTsAtEnd,
+        seenMessageKeys: [],
+        codexTotals: { ...s.prevAtEnd }
+      }
+    },
+    endTs: s.endTs
+  }));
+}
+
+// src/transcript.ts
+import { readFile as readFile3 } from "fs/promises";
+var NEWLINE2 = 10;
+var MAX_SEEN_KEYS = 500;
+var SYNTHETIC_MODEL = "<synthetic>";
+function isRecord2(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function numOf2(v) {
+  return typeof v === "number" && Number.isFinite(v) ? v : 0;
+}
+function strOrNull2(v) {
+  return typeof v === "string" ? v : null;
+}
 function emptyBuckets() {
   return { input: 0, output: 0, cacheWrite5m: 0, cacheWrite1h: 0, cacheRead: 0 };
 }
@@ -304,17 +577,17 @@ function addToModel(target, model, b) {
   target[model] = cur;
 }
 function extractBucket(usage) {
-  const input = numOf(usage.input_tokens);
-  const output = numOf(usage.output_tokens);
-  const cacheRead = numOf(usage.cache_read_input_tokens);
+  const input = numOf2(usage.input_tokens);
+  const output = numOf2(usage.output_tokens);
+  const cacheRead = numOf2(usage.cache_read_input_tokens);
   let cacheWrite5m;
   let cacheWrite1h;
   const cc = usage.cache_creation;
-  if (isRecord(cc)) {
-    cacheWrite5m = numOf(cc.ephemeral_5m_input_tokens);
-    cacheWrite1h = numOf(cc.ephemeral_1h_input_tokens);
+  if (isRecord2(cc)) {
+    cacheWrite5m = numOf2(cc.ephemeral_5m_input_tokens);
+    cacheWrite1h = numOf2(cc.ephemeral_1h_input_tokens);
   } else {
-    cacheWrite5m = numOf(usage.cache_creation_input_tokens);
+    cacheWrite5m = numOf2(usage.cache_creation_input_tokens);
     cacheWrite1h = 0;
   }
   return { input, output, cacheWrite5m, cacheWrite1h, cacheRead };
@@ -325,7 +598,7 @@ function promptCandidate(content) {
     let hasToolResult = false;
     const texts = [];
     for (const block of content) {
-      if (!isRecord(block)) continue;
+      if (!isRecord2(block)) continue;
       if (block.type === "tool_result") hasToolResult = true;
       else if (block.type === "text" && typeof block.text === "string") texts.push(block.text);
     }
@@ -334,20 +607,20 @@ function promptCandidate(content) {
   }
   return null;
 }
-async function readAll(path2) {
+async function readAll2(path2) {
   try {
-    return await readFile2(path2);
+    return await readFile3(path2);
   } catch {
     return null;
   }
 }
 async function aggregateNewTurn(transcriptPath, cursor) {
-  const buffer = await readAll(transcriptPath);
+  const buffer = await readAll2(transcriptPath);
   if (buffer === null) return null;
   const fileSize = buffer.length;
   let startOffset;
   let rescan;
-  if (cursor !== null && cursor.offset > 0 && cursor.offset <= fileSize && buffer[cursor.offset - 1] === NEWLINE) {
+  if (cursor !== null && cursor.offset > 0 && cursor.offset <= fileSize && buffer[cursor.offset - 1] === NEWLINE2) {
     startOffset = cursor.offset;
     rescan = false;
   } else {
@@ -372,26 +645,26 @@ async function aggregateNewTurn(transcriptPath, cursor) {
     } catch {
       return;
     }
-    if (!isRecord(obj)) return;
-    const ts = strOrNull(obj.timestamp);
+    if (!isRecord2(obj)) return;
+    const ts = strOrNull2(obj.timestamp);
     if (rescan && tsFloor !== null && ts !== null && ts <= tsFloor) return;
     const isSide = obj.isSidechain === true;
-    const sid = strOrNull(obj.sessionId);
+    const sid = strOrNull2(obj.sessionId);
     if (sid !== null) sessionId = sid;
     if (!isSide) {
-      const c = strOrNull(obj.cwd);
+      const c = strOrNull2(obj.cwd);
       if (c !== null) cwd = c;
-      const gb = strOrNull(obj.gitBranch);
+      const gb = strOrNull2(obj.gitBranch);
       if (gb !== null) gitBranch = gb;
     }
     if (ts !== null) {
       if (firstTs === null || ts < firstTs) firstTs = ts;
       if (lastTs === null || ts > lastTs) lastTs = ts;
     }
-    const uuid = strOrNull(obj.uuid);
+    const uuid = strOrNull2(obj.uuid);
     if (uuid !== null) lastUuid = uuid;
     const type = obj.type;
-    const message = isRecord(obj.message) ? obj.message : null;
+    const message = isRecord2(obj.message) ? obj.message : null;
     if (type === "user" && !isSide && message !== null) {
       const cand = promptCandidate(message.content);
       if (cand !== null) {
@@ -401,14 +674,14 @@ async function aggregateNewTurn(transcriptPath, cursor) {
     }
     if (type === "assistant" && message !== null) {
       const usage = message.usage;
-      if (isRecord(usage)) {
+      if (isRecord2(usage)) {
         const rawModel = message.model;
         if (rawModel !== SYNTHETIC_MODEL) {
-          const id = strOrNull(message.id) ?? "";
-          const reqId = strOrNull(obj.requestId) ?? "";
+          const id = strOrNull2(message.id) ?? "";
+          const reqId = strOrNull2(obj.requestId) ?? "";
           const key = `${id}:${reqId}`;
           if (!seenKeys.has(key)) {
-            const model = strOrNull(rawModel) ?? "unknown";
+            const model = strOrNull2(rawModel) ?? "unknown";
             pending.set(key, { model, isSidechain: isSide, bucket: extractBucket(usage) });
           }
         }
@@ -417,7 +690,7 @@ async function aggregateNewTurn(transcriptPath, cursor) {
   };
   let lineStart = startOffset;
   for (let pos = startOffset; pos < fileSize; pos++) {
-    if (buffer[pos] !== NEWLINE) continue;
+    if (buffer[pos] !== NEWLINE2) continue;
     handleLine(buffer.toString("utf8", lineStart, pos));
     lineStart = pos + 1;
   }
@@ -456,6 +729,8 @@ export {
   computeCost,
   loadPriceTable,
   getUsdJpy,
+  aggregateCodexTurn,
+  splitIntoCodexTurnDrafts,
   extractBucket,
   promptCandidate,
   aggregateNewTurn

package/dist/chunk-O2AR4PXU.js

@@ -0,0 +1,82 @@
+#!/usr/bin/env node
+import {
+  aggregateNewTurn
+} from "./chunk-LVMKY6JB.js";
+import {
+  loadCursor,
+  logError,
+  sanitizeCursor
+} from "./chunk-5PH7PPD6.js";
+
+// src/subagents.ts
+import { promises as fs } from "fs";
+import { join } from "path";
+var MAX_AGENT_FILES = 200;
+function emptyBuckets() {
+  return { input: 0, output: 0, cacheWrite5m: 0, cacheWrite1h: 0, cacheRead: 0 };
+}
+function addToModel(target, model, b) {
+  const cur = target[model] ?? emptyBuckets();
+  cur.input += b.input;
+  cur.output += b.output;
+  cur.cacheWrite5m += b.cacheWrite5m;
+  cur.cacheWrite1h += b.cacheWrite1h;
+  cur.cacheRead += b.cacheRead;
+  target[model] = cur;
+}
+function mergeUsage(target, src) {
+  for (const [model, b] of Object.entries(src)) addToModel(target, model, b);
+}
+function subagentsDirOf(mainTranscriptPath) {
+  const base = mainTranscriptPath.endsWith(".jsonl") ? mainTranscriptPath.slice(0, -".jsonl".length) : mainTranscriptPath;
+  return join(base, "subagents");
+}
+async function listAgentFiles(dir, entries) {
+  const files = entries.filter((e) => e.isFile() && e.name.startsWith("agent-") && e.name.endsWith(".jsonl")).map((e) => join(dir, e.name));
+  if (files.length <= MAX_AGENT_FILES) return files;
+  const withMtime = [];
+  for (const p of files) {
+    let mtime = 0;
+    try {
+      mtime = (await fs.stat(p)).mtimeMs;
+    } catch {
+      mtime = 0;
+    }
+    withMtime.push({ path: p, mtime });
+  }
+  withMtime.sort((a, b) => b.mtime - a.mtime);
+  return withMtime.slice(0, MAX_AGENT_FILES).map((x) => x.path);
+}
+async function collectSubagentUsage(mainTranscriptPath) {
+  const dir = subagentsDirOf(mainTranscriptPath);
+  let entries;
+  try {
+    entries = await fs.readdir(dir, { withFileTypes: true });
+  } catch {
+    return null;
+  }
+  const files = await listAgentFiles(dir, entries);
+  const perModel = {};
+  let apiCalls = 0;
+  let agentFiles = 0;
+  const newCursors = [];
+  for (const filePath of files) {
+    try {
+      const cursor = sanitizeCursor(loadCursor(filePath));
+      const agg = await aggregateNewTurn(filePath, cursor);
+      if (agg === null) continue;
+      mergeUsage(perModel, agg.main);
+      mergeUsage(perModel, agg.sidechain);
+      apiCalls += agg.apiCalls;
+      agentFiles += 1;
+      newCursors.push({ path: filePath, cursor: agg.newCursor });
+    } catch (err) {
+      logError("subagents:file", err);
+    }
+  }
+  return { perModel, apiCalls, agentFiles, newCursors };
+}
+
+export {
+  collectSubagentUsage
+};