@dotobokuri/fleet-console 1.59.0 → 1.61.0

package/dist/fleet-plugins/file-explorer/routes.mjs

@@ -567,6 +567,7 @@ function createWatcherRegistry(watcherFactory = (p, opts, cb) => fs2.watch(p, op
     try {
       startWatcher(theaterId, entry, relativePath, target.path, target.identity);
       entry.pendingDirectories.delete(relativePath);
+      scheduleChange(entry, relativePath);
     } catch {
       for (const notify of entry.stateSubscribers) notify("degraded");
     }
@@ -614,6 +615,8 @@ var FolderBrowserError = class extends Error {
   }
 };
 var DIRECTORY_ENTRY_CAP = 500;
+var CLASSIFY_CONCURRENCY = 16;
+var VCS_INTERNAL_NAMES = /* @__PURE__ */ new Set([".git", ".svn", ".hg"]);
 async function listTheaterContents(theaterPath, relativePath, deps = {}) {
   const opendir = deps.opendir ?? fs2.promises.opendir;
   const stat = deps.stat ?? fs2.promises.stat;
@@ -636,10 +639,12 @@ async function listTheaterContents(theaterPath, relativePath, deps = {}) {
   if (realTargetAbs !== realRoot && !realTargetAbs.startsWith(realNormalizedRoot)) {
     throw new FolderBrowserError("forbidden");
   }
+  if (vcsSegmentOf(realRoot, realTargetAbs)) throw new FolderBrowserError("forbidden");
   const targetStat = await statDirectory(realTargetAbs, stat);
   if (!targetStat.isDirectory()) throw new FolderBrowserError("invalid_path");
   const entries = [];
-  const truncated = await collectContentsEntries(realTargetAbs, realRoot, opendir, stat, entries);
+  const hiddenVcs = [];
+  const truncated = await collectContentsEntries(realTargetAbs, realRoot, opendir, stat, entries, hiddenVcs);
   entries.sort((a, b) => {
     if (a.kind !== b.kind) return a.kind === "dir" ? -1 : 1;
     return a.name.localeCompare(b.name);
@@ -650,7 +655,8 @@ async function listTheaterContents(theaterPath, relativePath, deps = {}) {
     relativePath: rel,
     parentRelativePath: parentRel === "" ? null : parentRel ?? null,
     entries,
-    ...truncated ? { truncated: true } : {}
+    ...truncated ? { truncated: true, cap: DIRECTORY_ENTRY_CAP } : {},
+    ...hiddenVcs.length > 0 ? { hiddenVcsInternals: [...new Set(hiddenVcs)].sort() } : {}
   };
 }
 async function statDirectory(targetPath, stat) {
@@ -660,17 +666,100 @@ async function statDirectory(targetPath, stat) {
     throw mapFolderBrowserFsError(error);
   }
 }
-async function collectContentsEntries(targetPath, theaterPath, opendir, stat, entries) {
+async function collectContentsEntries(targetPath, theaterPath, opendir, stat, entries, hiddenVcs) {
   const directory = await openDirectory(targetPath, opendir);
   try {
+    const pending = [];
+    let truncated = false;
+    const accept = (entry) => {
+      if (entry === null) return false;
+      if ("vcsInternal" in entry) {
+        hiddenVcs.push(entry.vcsInternal);
+        return false;
+      }
+      if (entries.length >= DIRECTORY_ENTRY_CAP) return true;
+      entries.push(entry);
+      return false;
+    };
+    const flushPending = async () => {
+      while (pending.length > 0) {
+        if (entries.length >= DIRECTORY_ENTRY_CAP) {
+          pending.length = 0;
+          return true;
+        }
+        const remaining = DIRECTORY_ENTRY_CAP - entries.length;
+        const batch = pending.splice(0, Math.min(CLASSIFY_CONCURRENCY, remaining));
+        const classified = await Promise.all(
+          batch.map((item) => toContentsEntry(targetPath, theaterPath, item, stat))
+        );
+        let overflowed = false;
+        for (const entry of classified) {
+          if (overflowed) {
+            if (entry && "vcsInternal" in entry) hiddenVcs.push(entry.vcsInternal);
+            continue;
+          }
+          if (accept(entry)) overflowed = true;
+        }
+        if (overflowed) {
+          pending.length = 0;
+          return true;
+        }
+      }
+      return false;
+    };
+    const finishCheapTail = async (first) => {
+      pending.length = 0;
+      let current = first;
+      let omitted = false;
+      while (current !== null) {
+        if (VCS_INTERNAL_NAMES.has(current.name)) hiddenVcs.push(current.name);
+        else {
+          omitted = true;
+          break;
+        }
+        current = await directory.read();
+      }
+      return omitted;
+    };
     let dirent = await directory.read();
     while (dirent !== null) {
-      if (entries.length >= DIRECTORY_ENTRY_CAP) return true;
-      const entry = await toContentsEntry(targetPath, theaterPath, dirent, stat);
-      if (entry !== null) entries.push(entry);
+      if (VCS_INTERNAL_NAMES.has(dirent.name)) {
+        hiddenVcs.push(dirent.name);
+        dirent = await directory.read();
+        continue;
+      }
+      if (entries.length >= DIRECTORY_ENTRY_CAP) {
+        truncated = await finishCheapTail(dirent);
+        dirent = null;
+        break;
+      }
+      if (dirent.isDirectory() || dirent.isFile()) {
+        if (pending.length > 0 && await flushPending()) {
+          truncated = true;
+          await finishCheapTail(dirent);
+          dirent = null;
+          break;
+        }
+        const rel = path5.relative(theaterPath, path5.join(targetPath, dirent.name));
+        if (accept({ name: dirent.name, relativePath: rel, kind: dirent.isDirectory() ? "dir" : "file" })) {
+          truncated = true;
+          await finishCheapTail(await directory.read());
+          dirent = null;
+          break;
+        }
+      } else {
+        pending.push(dirent);
+        if (pending.length >= CLASSIFY_CONCURRENCY && await flushPending()) {
+          truncated = true;
+          await finishCheapTail(await directory.read());
+          dirent = null;
+          break;
+        }
+      }
       dirent = await directory.read();
     }
-    return false;
+    if (!truncated && await flushPending()) truncated = true;
+    return truncated;
   } catch (error) {
     throw mapFolderBrowserFsError(error);
   } finally {
@@ -684,6 +773,14 @@ async function openDirectory(targetPath, opendir) {
     throw mapFolderBrowserFsError(error);
   }
 }
+function vcsSegmentOf(realRoot, realPath) {
+  const rel = path5.relative(realRoot, realPath);
+  if (!rel) return null;
+  for (const segment of rel.split(path5.sep)) {
+    if (VCS_INTERNAL_NAMES.has(segment)) return segment;
+  }
+  return null;
+}
 async function toContentsEntry(targetPath, theaterPath, dirent, stat) {
   const entryPath = path5.join(targetPath, dirent.name);
   const rel = path5.relative(theaterPath, entryPath);
@@ -694,6 +791,8 @@ async function toContentsEntry(targetPath, theaterPath, dirent, stat) {
       const realEntryPath = await fs2.promises.realpath(entryPath);
       const realNormalizedRoot = theaterPath.endsWith(path5.sep) ? theaterPath : theaterPath + path5.sep;
       if (realEntryPath !== theaterPath && !realEntryPath.startsWith(realNormalizedRoot)) return null;
+      const vcsSegment = vcsSegmentOf(theaterPath, realEntryPath);
+      if (vcsSegment) return { vcsInternal: vcsSegment };
       const s = await stat(realEntryPath);
       if (s.isDirectory()) return { name: dirent.name, relativePath: rel, kind: "dir" };
       if (s.isFile()) return { name: dirent.name, relativePath: rel, kind: "file" };
@@ -756,7 +855,7 @@ async function readTheaterGitStatus(theaterPath, deps = {}) {
       ok: true,
       gitAvailable: true,
       statuses: statuses.slice(0, GIT_STATUS_CAP),
-      ...truncated ? { truncated: true } : {}
+      ...truncated ? { truncated: true, cap: GIT_STATUS_CAP } : {}
     };
   } catch {
     return { ok: true, gitAvailable: false, statuses: [] };
@@ -859,7 +958,12 @@ async function searchTheaterFiles(theaterPath, query, limit) {
   const matches = [];
   let directoryCount = 0;
   let entryCount = 0;
-  while (pending.length > 0 && directoryCount < SEARCH_DIRECTORY_CAP && entryCount < SEARCH_ENTRY_CAP) {
+  let walkCapped = false;
+  while (pending.length > 0) {
+    if (directoryCount >= SEARCH_DIRECTORY_CAP || entryCount >= SEARCH_ENTRY_CAP) {
+      walkCapped = true;
+      break;
+    }
     const directory = pending.shift();
     if (!directory || visited.has(directory.absolutePath)) continue;
     visited.add(directory.absolutePath);
@@ -872,8 +976,12 @@ async function searchTheaterFiles(theaterPath, query, limit) {
     }
     entries.sort((left, right) => left.name.localeCompare(right.name));
     for (const entry of entries) {
-      if (entryCount >= SEARCH_ENTRY_CAP) break;
+      if (entryCount >= SEARCH_ENTRY_CAP) {
+        walkCapped = true;
+        break;
+      }
       entryCount += 1;
+      if (VCS_INTERNAL_NAMES.has(entry.name)) continue;
       const relativePath = directory.relativePath ? `${directory.relativePath}/${entry.name}` : entry.name;
       const absolutePath = path5.join(directory.absolutePath, entry.name);
       let kind = entry.isDirectory() ? "dir" : entry.isFile() ? "file" : null;
@@ -882,6 +990,7 @@ async function searchTheaterFiles(theaterPath, query, limit) {
         try {
           realPath = await fsp.realpath(absolutePath);
           if (!isContained(realRoot, realPath)) continue;
+          if (vcsSegmentOf(realRoot, realPath)) continue;
           const stat = await fsp.stat(realPath);
           kind = stat.isDirectory() ? "dir" : stat.isFile() ? "file" : null;
         } catch {
@@ -896,8 +1005,14 @@ async function searchTheaterFiles(theaterPath, query, limit) {
       const low = relativePath.toLocaleLowerCase();
       if (tokens.every((token) => low.includes(token))) matches.push({ relativePath });
     }
+    if (walkCapped) break;
   }
-  return matches.sort((left, right) => compareFileSearchItem(left, right, query)).slice(0, limit);
+  const sorted = matches.sort((left, right) => compareFileSearchItem(left, right, query));
+  return {
+    files: sorted.slice(0, limit),
+    totalMatches: sorted.length,
+    ...walkCapped ? { walkCapped: true } : {}
+  };
 }
 async function handleFilesSearch(req, res, ctx) {
   if (req.method !== "POST") {
@@ -919,8 +1034,11 @@ async function handleFilesSearch(req, res, ctx) {
     return;
   }
   try {
+    const outcome = await searchTheaterFiles(theaterPath, body.query, body.limit);
     ctx.host.http.writeJson(res, 200, {
-      files: await searchTheaterFiles(theaterPath, body.query, body.limit)
+      files: outcome.files,
+      totalMatches: outcome.totalMatches,
+      ...outcome.walkCapped ? { walkCapped: true } : {}
     });
   } catch {
     ctx.host.http.writeJson(res, 500, { error: "search_failed" });
@@ -978,7 +1096,8 @@ async function handleFilesList(req, res, ctx) {
   }
   try {
     const result = await listTheaterContents(theaterPath, relPath);
-    await watcherRegistry.trackDirectory(rawTheaterId, theaterPath, relPath);
+    void watcherRegistry.trackDirectory(rawTheaterId, theaterPath, relPath).catch(() => {
+    });
     ctx.host.http.writeJson(res, 200, result);
   } catch (error) {
     if (error instanceof FolderBrowserError) {

package/dist/fleet-plugins/ledger/routes.mjs

@@ -338,7 +338,7 @@ async function handleSummary(req, res, ctx, service) {
 
 // ../fleet-plugins/ledger/server/parser.ts
 var CLIENT_RE = /^[a-z0-9][a-z0-9-]{0,31}$/;
-var MODEL_RE = /^[A-Za-z0-9][A-Za-z0-9._/-]{0,63}$/;
+var MODEL_RE = /^[A-Za-z0-9][A-Za-z0-9._/-]{0,63}(?:\[1[mM]\])?$/;
 var UUID_FRAGMENT_RE = /(?:^|[^0-9a-f])[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}(?:$|[^0-9a-f])/i;
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -398,8 +398,112 @@ function parseTokscaleOutput(stdout) {
   if (parsed.length > 0 && sessions.length === 0) return { status: "unreadable", sessions: [], skippedSessions };
   return { status: skippedSessions > 0 ? "degraded" : "ok", sessions, skippedSessions };
 }
+function parseModelEntry(value) {
+  if (!isRecord(value)) return null;
+  const models = sanitizeModels(typeof value.model === "string" ? [value.model] : []);
+  if (models.length !== 1 || !isNonNegativeSafeInteger(value.input) || !isNonNegativeSafeInteger(value.output) || !isNonNegativeSafeInteger(value.cacheRead) || !isNonNegativeFinite(value.cost) || !isNonNegativeSafeInteger(value.messageCount)) return null;
+  return {
+    modelId: models[0],
+    input: value.input,
+    output: value.output,
+    cacheRead: value.cacheRead,
+    costUsd: value.cost,
+    messages: value.messageCount
+  };
+}
+function parseTokscaleModelsOutput(stdout) {
+  let parsed;
+  try {
+    parsed = JSON.parse(stdout);
+  } catch {
+    return { status: "unreadable", entries: [], skippedEntries: 0 };
+  }
+  if (!isRecord(parsed) || !Array.isArray(parsed.entries)) {
+    return { status: "unreadable", entries: [], skippedEntries: 0 };
+  }
+  const entries = parsed.entries.map(parseModelEntry).filter((entry) => entry !== null);
+  const skippedEntries = parsed.entries.length - entries.length;
+  if (parsed.entries.length > 0 && entries.length === 0) {
+    return { status: "unreadable", entries: [], skippedEntries };
+  }
+  return { status: skippedEntries > 0 ? "degraded" : "ok", entries, skippedEntries };
+}
+
+// ../fleet-plugins/ledger/server/identity.ts
+var LEDGER_LAUNCH_PROVIDERS = ["claude", "codex", "cursor", "kimi", "opencode", "xai"];
+var GATEWAY_MODEL_PREFIX = "claude-gateway--";
+var NATIVE_SUPPLIER = "native";
+var PROVIDER_SET = new Set(LEDGER_LAUNCH_PROVIDERS);
+function isLaunchProvider(value) {
+  return typeof value === "string" && PROVIDER_SET.has(value);
+}
+function readLaunchProvider(payload) {
+  return isLaunchProvider(payload.launchProvider) ? payload.launchProvider : null;
+}
+function parseModelIdentity(modelId) {
+  let rest = modelId;
+  let supplier = NATIVE_SUPPLIER;
+  if (rest.startsWith(GATEWAY_MODEL_PREFIX)) {
+    rest = rest.slice(GATEWAY_MODEL_PREFIX.length);
+    const separator = rest.indexOf("--");
+    if (separator > 0) {
+      const candidate = rest.slice(0, separator);
+      if (PROVIDER_SET.has(candidate)) {
+        supplier = candidate;
+        rest = rest.slice(separator + 2);
+      }
+    }
+  } else {
+    const inferred = inferUnprefixedSupplier(rest);
+    supplier = inferred.supplier;
+    rest = inferred.bare;
+  }
+  return {
+    modelId,
+    supplier,
+    bare: rest,
+    label: humanizeBareModel(rest)
+  };
+}
+function inferUnprefixedSupplier(modelId) {
+  const slash = modelId.indexOf("/");
+  if (slash > 0) {
+    const candidate = modelId.slice(0, slash).toLowerCase();
+    if (PROVIDER_SET.has(candidate)) {
+      return { supplier: candidate, bare: modelId.slice(slash + 1) };
+    }
+  }
+  const lower = modelId.toLowerCase();
+  if (lower.startsWith("claude")) return { supplier: "claude", bare: modelId };
+  if (lower.startsWith("gpt-")) return { supplier: "codex", bare: modelId };
+  if (lower.startsWith("grok")) return { supplier: "xai", bare: modelId };
+  if (lower.startsWith("kimi")) return { supplier: "kimi", bare: modelId };
+  return { supplier: NATIVE_SUPPLIER, bare: modelId };
+}
+function normalizeModelKey(modelId) {
+  return parseModelIdentity(modelId).bare.toLowerCase().replace(/\bgpt-(\d)-(\d)\b/g, "gpt-$1.$2");
+}
+function humanizeBareModel(bare) {
+  const bracketMillion = /\[1m\]$/i.test(bare);
+  const tokens = bare.replace(/\[1m\]$/i, "").split(/[-_]/).filter(Boolean);
+  const trailingMillion = tokens.at(-1)?.toLowerCase() === "1m";
+  const nameTokens = trailingMillion ? tokens.slice(0, -1) : tokens;
+  const words = nameTokens.map((token) => {
+    if (/^\d/.test(token)) return token;
+    const lower = token.toLowerCase();
+    if (lower === "gpt") return "GPT";
+    return `${token.charAt(0).toUpperCase()}${token.slice(1)}`;
+  });
+  const joined = words.join(" ").replace(/\bGPT (\d) (\d)\b/g, "GPT $1.$2");
+  return bracketMillion || trailingMillion ? `${joined} (1M)` : joined;
+}
 
 // ../fleet-plugins/ledger/server/summary.ts
+var EMPTY_MODEL_BREAKDOWN = {
+  entries: [],
+  status: "ok",
+  skippedEntries: 0
+};
 var AggregateOverflowError = class extends Error {
 };
 var MAX_DAILY_DAYS = 366;
@@ -475,7 +579,8 @@ function readClaim(operation) {
     sessionId: candidate.sessionId,
     provider: candidate.provider,
     cliId: stringField(operation.payload, "cliId"),
-    cliLabel: stringField(operation.payload, "cliLabel")
+    cliLabel: stringField(operation.payload, "cliLabel"),
+    launchProvider: readLaunchProvider(operation.payload)
   };
 }
 function nativeSessionId(session) {
@@ -489,9 +594,17 @@ function nativeSessionId(session) {
   const match = session.sessionId.match(new RegExp(`^rollout-${timestamp}-(${uuid})$`, "i"));
   return match?.[1]?.toLowerCase() ?? null;
 }
-function buildSummary(sessions, operations, scope, status = "ok", generatedAtMs = Date.now(), skippedSessions = 0) {
+function emptyModelFields(status = "ok", skippedEntries = 0) {
+  return {
+    suppliers: [],
+    modelRows: [],
+    modelTotals: { costUsd: 0, input: 0, output: 0, cacheRead: 0, messages: 0, models: 0 },
+    modelSource: { status, skippedEntries }
+  };
+}
+function buildSummary(sessions, operations, scope, status = "ok", generatedAtMs = Date.now(), skippedSessions = 0, modelBreakdown = EMPTY_MODEL_BREAKDOWN) {
   try {
-    return buildSummaryUnchecked(sessions, operations, scope, status, generatedAtMs, skippedSessions);
+    return buildSummaryUnchecked(sessions, operations, scope, status, generatedAtMs, skippedSessions, modelBreakdown);
   } catch (error) {
     if (!(error instanceof AggregateOverflowError)) throw error;
     return {
@@ -505,6 +618,7 @@ function buildSummary(sessions, operations, scope, status = "ok", generatedAtMs
       otherTheaterTotals: { costUsd: 0, input: 0, output: 0, cacheRead: 0, messages: 0 },
       deviceTotals: { costUsd: 0, input: 0, output: 0, cacheRead: 0, messages: 0, sessions: 0 },
       clients: [],
+      ...emptyModelFields("unreadable", modelBreakdown.skippedEntries + modelBreakdown.entries.length),
       daily: [],
       dailyAttributed: [],
       source: {
@@ -514,7 +628,7 @@ function buildSummary(sessions, operations, scope, status = "ok", generatedAtMs
     };
   }
 }
-function buildSummaryUnchecked(sessions, operations, scope, status, generatedAtMs, skippedSessions) {
+function buildSummaryUnchecked(sessions, operations, scope, status, generatedAtMs, skippedSessions, modelBreakdown) {
   const operationClaims = operations.map(readClaim).filter((claim) => claim !== null).sort((a, b) => b.operation.ts.updatedAt - a.operation.ts.updatedAt || (a.operation.id < b.operation.id ? -1 : a.operation.id > b.operation.id ? 1 : 0));
   const claims = /* @__PURE__ */ new Map();
   for (const claim of operationClaims) {
@@ -547,6 +661,7 @@ function buildSummaryUnchecked(sessions, operations, scope, status, generatedAtM
       title: claim.operation.title,
       cliId: claim.cliId,
       cliLabel: claim.cliLabel,
+      launchProvider: claim.launchProvider,
       client: claimed[0]?.client ?? claim.provider,
       messages: totals.messages,
       usage: usageOf(totals),
@@ -560,6 +675,7 @@ function buildSummaryUnchecked(sessions, operations, scope, status, generatedAtM
     title: claim.operation.title,
     cliId: claim.cliId,
     cliLabel: claim.cliLabel,
+    launchProvider: claim.launchProvider,
     lastActivityAtMs: claim.operation.ts.updatedAt
   }));
   const unmatched = unmatchedAll.slice(0, MAX_UNMATCHED);
@@ -608,11 +724,77 @@ function buildSummaryUnchecked(sessions, operations, scope, status, generatedAtM
     otherTheaterTotals: { ...usageOf(otherTheaterValues), costUsd: otherTheaterValues.costUsd, messages: otherTheaterValues.messages },
     deviceTotals: { ...usageOf(deviceValues), costUsd: deviceValues.costUsd, messages: deviceValues.messages, sessions: deviceSessions },
     clients,
+    ...buildModelFields(modelBreakdown),
     daily,
     dailyAttributed,
     source: { status, skippedSessions }
   };
 }
+var MAX_MODEL_ROWS = 80;
+function buildModelFields(modelBreakdown) {
+  if (modelBreakdown.status === "unavailable" || modelBreakdown.status === "unreadable" || modelBreakdown.status === "bootstrapping") {
+    return emptyModelFields(modelBreakdown.status, modelBreakdown.skippedEntries);
+  }
+  try {
+    return buildModelFieldsUnchecked(modelBreakdown);
+  } catch (error) {
+    if (!(error instanceof AggregateOverflowError)) throw error;
+    return emptyModelFields("unreadable", modelBreakdown.skippedEntries + modelBreakdown.entries.length);
+  }
+}
+function buildModelFieldsUnchecked(modelBreakdown) {
+  const modelMap = /* @__PURE__ */ new Map();
+  const supplierMap = /* @__PURE__ */ new Map();
+  const grand = emptyAccumulator();
+  for (const entry of modelBreakdown.entries) {
+    const identity = parseModelIdentity(entry.modelId);
+    const key = `${identity.supplier}:${normalizeModelKey(entry.modelId)}`;
+    const model = modelMap.get(key) ?? { identity, totals: emptyAccumulator() };
+    addModelEntry(model.totals, entry);
+    modelMap.set(key, model);
+    const supplier = supplierMap.get(identity.supplier) ?? { models: /* @__PURE__ */ new Set(), totals: emptyAccumulator() };
+    supplier.models.add(key);
+    addModelEntry(supplier.totals, entry);
+    supplierMap.set(identity.supplier, supplier);
+    addModelEntry(grand, entry);
+  }
+  const modelRows = [...modelMap.values()].map(({ identity, totals }) => ({
+    modelId: identity.modelId,
+    label: identity.label,
+    supplier: identity.supplier,
+    usage: usageOf(totals),
+    costUsd: totals.costUsd,
+    messages: totals.messages
+  })).sort((a, b) => b.costUsd - a.costUsd || b.messages - a.messages || (a.label < b.label ? -1 : 1)).slice(0, MAX_MODEL_ROWS);
+  const suppliers = [...supplierMap.entries()].map(([supplier, value]) => ({
+    supplier,
+    models: value.models.size,
+    usage: usageOf(value.totals),
+    costUsd: value.totals.costUsd,
+    messages: value.totals.messages
+  })).sort((a, b) => b.costUsd - a.costUsd || (a.supplier < b.supplier ? -1 : 1));
+  return {
+    suppliers,
+    modelRows,
+    modelTotals: {
+      ...usageOf(grand),
+      costUsd: grand.costUsd,
+      messages: grand.messages,
+      models: modelMap.size
+    },
+    modelSource: {
+      status: modelBreakdown.status,
+      skippedEntries: modelBreakdown.skippedEntries
+    }
+  };
+}
+function addModelEntry(target, entry) {
+  target.input = addFinite(target.input, entry.input);
+  target.output = addFinite(target.output, entry.output);
+  target.cacheRead = addFinite(target.cacheRead, entry.cacheRead);
+  target.costUsd = addFinite(target.costUsd, entry.costUsd);
+  target.messages = addFinite(target.messages, entry.messages);
+}
 
 // ../fleet-plugins/ledger/server/service.ts
 var CACHE_TTL_MS = 15e3;
@@ -626,14 +808,17 @@ function createLedgerService(deps) {
   function cacheKey(request) {
     return request.window;
   }
-  function summaryFromReport(request, report) {
-    return buildSummary(report.sessions, request.operations, {
+  function summaryFromWindow(request, window) {
+    return buildSummary(window.report.sessions, request.operations, {
       theaterId: request.theaterId,
       window: request.window
-    }, report.status, report.generatedAtMs, report.skippedSessions);
+    }, window.report.status, window.report.generatedAtMs, window.report.skippedSessions, window.models);
   }
   function statusDto(request, status) {
-    return summaryFromReport(request, { sessions: [], status, skippedSessions: 0, generatedAtMs: now() });
+    return summaryFromWindow(request, {
+      report: { sessions: [], status, skippedSessions: 0, generatedAtMs: now() },
+      models: { ...EMPTY_MODEL_BREAKDOWN, status }
+    });
   }
   async function executeReport(window) {
     const args = ["report", "--json", "--no-summarize", `--${window}`];
@@ -654,18 +839,40 @@ function createLedgerService(deps) {
       return { sessions: [], status: "unavailable", skippedSessions: 0, generatedAtMs: now() };
     }
   }
+  async function executeModels(window) {
+    const args = ["models", "--json", "--no-spinner", "--group-by", "model", `--${window}`];
+    try {
+      const result = await deps.executor(args, {
+        cwd: os.homedir(),
+        timeout: TOKSCALE_TIMEOUT_MS
+      });
+      if (result.exitCode !== 0) return { entries: [], status: "unavailable", skippedEntries: 0 };
+      const parsed = parseTokscaleModelsOutput(result.stdout);
+      return {
+        entries: parsed.entries,
+        status: parsed.status,
+        skippedEntries: parsed.skippedEntries
+      };
+    } catch {
+      return { entries: [], status: "unavailable", skippedEntries: 0 };
+    }
+  }
+  async function executeWindow(window) {
+    const [report, models] = await Promise.all([executeReport(window), executeModels(window)]);
+    return { report, models };
+  }
   function getOrStartReport(key, window) {
     const existing = reportInFlight.get(key);
     if (existing) return existing;
-    const task = executeReport(window).finally(() => {
+    const task = executeWindow(window).finally(() => {
       reportInFlight.delete(key);
     });
     reportInFlight.set(key, task);
     return task;
   }
   function startBootstrapAndReport(key, request) {
-    const task = bootstrap(deps.cliHome).then(() => getOrStartReport(key, request.window)).then((report) => {
-      cache.set(key, { report, expiresAt: now() + CACHE_TTL_MS });
+    const task = bootstrap(deps.cliHome).then(() => getOrStartReport(key, request.window)).then((window) => {
+      cache.set(key, { window, expiresAt: now() + CACHE_TTL_MS });
     }).catch(() => {
     }).finally(() => {
       bootstrapPending.delete(key);
@@ -677,7 +884,7 @@ function createLedgerService(deps) {
       const key = cacheKey(request);
       if (request.refresh) cache.delete(key);
       const cached = cache.get(key);
-      if (cached && cached.expiresAt > now()) return summaryFromReport(request, cached.report);
+      if (cached && cached.expiresAt > now()) return summaryFromWindow(request, cached.window);
       cache.delete(key);
       if (bootstrapPending.has(key)) return statusDto(request, "bootstrapping");
       if (!await isInstalled(deps.cliHome)) {
@@ -685,9 +892,9 @@ function createLedgerService(deps) {
         startBootstrapAndReport(key, request);
         return statusDto(request, "bootstrapping");
       }
-      const report = await getOrStartReport(key, request.window);
-      cache.set(key, { report, expiresAt: now() + CACHE_TTL_MS });
-      return summaryFromReport(request, report);
+      const window = await getOrStartReport(key, request.window);
+      cache.set(key, { window, expiresAt: now() + CACHE_TTL_MS });
+      return summaryFromWindow(request, window);
     }
   };
 }