codesesh 1.0.2 → 1.0.4

package/dist/chunk-MBZ4VV4C.js

@@ -0,0 +1,670 @@
+#!/usr/bin/env node
+import {
+  addCalendarDays,
+  buildSessionTree,
+  countCalendarDays,
+  filterSessionTreeEntriesByActivityWindow,
+  getProjectIdentityKey,
+  getSessionAgentKey,
+  getSessionReferenceKey,
+  toCalendarDayKey
+} from "./chunk-W4PZHL2C.js";
+
+// ../core/dist/chunk-OGQ63HC5.mjs
+var COST_ABSOLUTE_TOLERANCE = 1e-8;
+var COST_RELATIVE_TOLERANCE = 1e-6;
+function indexFacts(facts) {
+  const messagesBySession = /* @__PURE__ */ new Map();
+  const summariesBySession = /* @__PURE__ */ new Map();
+  if (!facts) return { messagesBySession, summariesBySession };
+  for (const summary of facts.sessions) {
+    summariesBySession.set(getSessionReferenceKey(summary.reference), summary);
+  }
+  for (const message of facts.messages) {
+    const key = getSessionReferenceKey(message.reference);
+    const messages = messagesBySession.get(key);
+    if (messages) messages.push(message);
+    else messagesBySession.set(key, [message]);
+  }
+  return { messagesBySession, summariesBySession };
+}
+function nonNegative(value) {
+  return Math.max(0, Number(value ?? 0));
+}
+function costsReconcile(left, right) {
+  const tolerance = Math.max(
+    COST_ABSOLUTE_TOLERANCE,
+    Math.max(Math.abs(left), Math.abs(right)) * COST_RELATIVE_TOLERANCE
+  );
+  return Math.abs(left - right) <= tolerance;
+}
+function hasDetailedCost(session, summary) {
+  const totalCost = Math.max(0, session.stats.total_cost);
+  return totalCost > 0 && summary != null && summary.untimedMessageCost <= COST_ABSOLUTE_TOLERANCE && costsReconcile(summary.messageCost, totalCost);
+}
+function hasDetailedMessages(session, summary) {
+  return summary != null && summary.untimedMessageCount === 0 && summary.messageCount === nonNegative(session.stats.message_count);
+}
+function detailedOutputIncludesReasoning(session, summary) {
+  if (!summary) return null;
+  const stats = session.stats;
+  const sessionInput = nonNegative(stats.total_input_tokens);
+  const sessionOutput = nonNegative(stats.total_output_tokens);
+  const sessionCacheRead = nonNegative(stats.total_cache_read_tokens);
+  const sessionCacheCreate = nonNegative(stats.total_cache_create_tokens);
+  const sessionTotal = nonNegative(stats.total_tokens ?? sessionInput + sessionOutput);
+  const outputIncludesReasoning = summary.outputTokens + summary.reasoningTokens;
+  const outputMatches = summary.outputTokens === sessionOutput;
+  const outputWithReasoningMatches = outputIncludesReasoning === sessionOutput;
+  const effectiveOutput = outputMatches ? summary.outputTokens : outputWithReasoningMatches ? outputIncludesReasoning : null;
+  if (effectiveOutput == null || summary.inputTokens !== sessionInput || summary.cacheReadTokens !== sessionCacheRead || summary.cacheCreateTokens !== sessionCacheCreate || summary.inputTokens + effectiveOutput !== sessionTotal || summary.untimedInputTokens > 0 || summary.untimedOutputTokens > 0 || summary.untimedReasoningTokens > 0 || summary.untimedCacheReadTokens > 0 || summary.untimedCacheCreateTokens > 0) {
+    return null;
+  }
+  return !outputMatches && outputWithReasoningMatches;
+}
+function isInWindow(time, from, to) {
+  return (from == null || time >= from) && time <= to;
+}
+function resolvedCostSource(session, source) {
+  return source ?? session.stats.cost_source ?? "recorded";
+}
+function fallbackModelCosts(summary, totalCost) {
+  if (!summary) return [];
+  const modelTotal = summary.modelCosts.reduce((sum, model) => sum + model.cost, 0);
+  return modelTotal > totalCost && !costsReconcile(modelTotal, totalCost) ? [] : summary.modelCosts;
+}
+function visitAttributedCosts(tree, options, visit) {
+  const factIndex = indexFacts(options.facts);
+  const factsAvailable = options.facts != null;
+  for (const entry of tree.entries) {
+    if (options.matchesEntry && !options.matchesEntry(entry.session)) continue;
+    const fallbackTime = entry.session.time_updated ?? entry.session.time_created;
+    const pending = [entry];
+    while (pending.length > 0) {
+      const node = pending.pop();
+      for (const child of node.children) pending.push(child);
+      const session = node.session;
+      const totalCost = Math.max(0, session.stats.total_cost);
+      if (totalCost <= 0) continue;
+      const key = getSessionReferenceKey(session.reference);
+      const summary = factIndex.summariesBySession.get(key);
+      if (factsAvailable && hasDetailedCost(session, summary)) {
+        for (const message of factIndex.messagesBySession.get(key) ?? []) {
+          if (!isInWindow(message.time, options.from, options.to) || message.cost <= 0) continue;
+          const source = resolvedCostSource(session, message.costSource);
+          visit({
+            entry,
+            time: message.time,
+            cost: message.cost,
+            source,
+            modelCosts: message.model ? [
+              {
+                model: message.model,
+                cost: message.cost,
+                costRecorded: source === "recorded" ? message.cost : 0
+              }
+            ] : []
+          });
+        }
+        continue;
+      }
+      if (!isInWindow(fallbackTime, options.from, options.to)) continue;
+      visit({
+        entry,
+        time: fallbackTime,
+        cost: totalCost,
+        source: resolvedCostSource(session),
+        modelCosts: factsAvailable ? fallbackModelCosts(summary, totalCost) : []
+      });
+    }
+  }
+}
+function visitAttributedUsage(tree, options, visit) {
+  const factIndex = indexFacts(options.facts);
+  const factsAvailable = options.facts != null;
+  for (const entry of tree.entries) {
+    if (options.matchesEntry && !options.matchesEntry(entry.session)) continue;
+    const fallbackTime = entry.session.time_updated ?? entry.session.time_created;
+    const pending = [entry];
+    while (pending.length > 0) {
+      const node = pending.pop();
+      for (const child of node.children) pending.push(child);
+      const session = node.session;
+      const key = getSessionReferenceKey(session.reference);
+      const summary = factIndex.summariesBySession.get(key);
+      const detailedMessages = factsAvailable && hasDetailedMessages(session, summary);
+      const outputIncludesReasoning = factsAvailable ? detailedOutputIncludesReasoning(session, summary) : null;
+      const detailedTokens = outputIncludesReasoning != null;
+      if (detailedMessages || detailedTokens) {
+        for (const message of factIndex.messagesBySession.get(key) ?? []) {
+          if (!isInWindow(message.time, options.from, options.to)) continue;
+          const outputTokens = detailedTokens ? message.outputTokens + (outputIncludesReasoning ? message.reasoningTokens : 0) : 0;
+          visit({
+            entry,
+            time: message.time,
+            messages: detailedMessages ? 1 : 0,
+            totalTokens: detailedTokens ? message.inputTokens + outputTokens : 0,
+            inputTokens: detailedTokens ? message.inputTokens : 0,
+            outputTokens,
+            cacheReadTokens: detailedTokens ? message.cacheReadTokens : 0,
+            cacheCreateTokens: detailedTokens ? message.cacheCreateTokens : 0
+          });
+        }
+      }
+      if (!isInWindow(fallbackTime, options.from, options.to)) continue;
+      if (!detailedMessages) {
+        visit({
+          entry,
+          time: fallbackTime,
+          messages: nonNegative(session.stats.message_count),
+          totalTokens: 0,
+          inputTokens: 0,
+          outputTokens: 0,
+          cacheReadTokens: 0,
+          cacheCreateTokens: 0
+        });
+      }
+      if (!detailedTokens) {
+        const inputTokens = nonNegative(session.stats.total_input_tokens);
+        const outputTokens = nonNegative(session.stats.total_output_tokens);
+        visit({
+          entry,
+          time: fallbackTime,
+          messages: 0,
+          totalTokens: nonNegative(session.stats.total_tokens ?? inputTokens + outputTokens),
+          inputTokens,
+          outputTokens,
+          cacheReadTokens: nonNegative(session.stats.total_cache_read_tokens),
+          cacheCreateTokens: nonNegative(session.stats.total_cache_create_tokens)
+        });
+      }
+    }
+  }
+}
+var DASHBOARD_RECENT_LIMIT = 10;
+var DASHBOARD_PROJECT_LIMIT = 12;
+var PROJECT_SPARKLINE_DAYS = 14;
+var MODEL_COST_LIMIT = 20;
+function getSessionAgentName(session) {
+  return getSessionAgentKey(session);
+}
+function getSessionActivityTime(session) {
+  return session.time_updated ?? session.time_created;
+}
+function matchesScope(session, scope) {
+  if (scope.agent && getSessionAgentName(session) !== scope.agent) return false;
+  if (scope.projectKind == null && scope.projectKey == null) return true;
+  const identity = session.project_identity;
+  return identity != null && identity.kind === scope.projectKind && identity.key === scope.projectKey;
+}
+function scopedEntries(tree, scope, from, to) {
+  return filterSessionTreeEntriesByActivityWindow(tree, from, to).filter(
+    (node) => matchesScope(node.session, scope)
+  );
+}
+function emptyDailyBucket(date) {
+  return {
+    date,
+    sessions: 0,
+    messages: 0,
+    cost: 0,
+    input: 0,
+    output: 0,
+    cache_read: 0,
+    cache_create: 0
+  };
+}
+function createAccumulator(byAgentNames, scope, to) {
+  const agents = /* @__PURE__ */ new Map();
+  for (const name of byAgentNames) {
+    const key = name.toLowerCase();
+    if (scope.agent && key !== scope.agent) continue;
+    agents.set(key, { name, sessions: 0, messages: 0, tokens: 0, cost: 0 });
+  }
+  const sparklineSlots = /* @__PURE__ */ new Map();
+  for (let slot = 0; slot < PROJECT_SPARKLINE_DAYS; slot += 1) {
+    const day = addCalendarDays(to, slot - (PROJECT_SPARKLINE_DAYS - 1));
+    sparklineSlots.set(toCalendarDayKey(day), slot);
+  }
+  return {
+    sessions: 0,
+    messages: 0,
+    tokens: 0,
+    cost: 0,
+    costRecorded: 0,
+    costEstimated: 0,
+    cacheReadTokens: 0,
+    hasEstimatedCost: false,
+    agents,
+    agentKeys: /* @__PURE__ */ new Set(),
+    daily: /* @__PURE__ */ new Map(),
+    models: /* @__PURE__ */ new Map(),
+    modelCosts: /* @__PURE__ */ new Map(),
+    projects: /* @__PURE__ */ new Map(),
+    projectKeys: /* @__PURE__ */ new Set(),
+    sparklineSlots,
+    recent: []
+  };
+}
+function foldModelUsage(node, into) {
+  if (node.session.model_usage) {
+    for (const [model, tokens] of Object.entries(node.session.model_usage)) {
+      into.set(model, (into.get(model) ?? 0) + tokens);
+    }
+  }
+  for (const child of node.children) foldModelUsage(child, into);
+}
+function getOrCreateProject(session, acc) {
+  const identity = session.project_identity;
+  if (!identity) return void 0;
+  const key = getProjectIdentityKey(identity);
+  let project = acc.projects.get(key);
+  if (!project) {
+    project = {
+      identityKind: identity.kind,
+      identityKey: identity.key,
+      displayName: identity.displayName,
+      sessions: 0,
+      messages: 0,
+      tokens: 0,
+      cost: 0,
+      hasEstimatedCost: false,
+      agentSessions: /* @__PURE__ */ new Map(),
+      sparkline: Array.from({ length: PROJECT_SPARKLINE_DAYS }, () => 0)
+    };
+    acc.projects.set(key, project);
+  }
+  return project;
+}
+function trackProjectActivity(node, acc, agentKey) {
+  const identity = node.session.project_identity;
+  const project = getOrCreateProject(node.session, acc);
+  if (!identity || !project) return;
+  project.sessions += 1;
+  project.agentSessions.set(agentKey, (project.agentSessions.get(agentKey) ?? 0) + 1);
+  acc.projectKeys.add(getProjectIdentityKey(identity));
+}
+function accumulateActivity(node, acc) {
+  const session = node.session;
+  const activity = getSessionActivityTime(session);
+  const agentKey = getSessionAgentName(session);
+  acc.sessions += 1;
+  acc.agentKeys.add(agentKey);
+  const metric = acc.agents.get(agentKey);
+  if (metric) {
+    metric.sessions += 1;
+  }
+  const dayKey = toCalendarDayKey(activity);
+  let bucket = acc.daily.get(dayKey);
+  if (!bucket) {
+    bucket = emptyDailyBucket(dayKey);
+    acc.daily.set(dayKey, bucket);
+  }
+  bucket.sessions += 1;
+  const usage = /* @__PURE__ */ new Map();
+  foldModelUsage(node, usage);
+  for (const [model, tokens] of usage) {
+    const entry = acc.models.get(model);
+    if (entry) {
+      entry.tokens += tokens;
+      entry.sessions += 1;
+    } else {
+      acc.models.set(model, { tokens, sessions: 1 });
+    }
+  }
+  trackProjectActivity(node, acc, agentKey);
+  let recentIndex = acc.recent.length;
+  for (let i = 0; i < acc.recent.length; i += 1) {
+    if (activity > acc.recent[i].activity) {
+      recentIndex = i;
+      break;
+    }
+  }
+  if (recentIndex < DASHBOARD_RECENT_LIMIT) {
+    acc.recent.splice(recentIndex, 0, { session, activity });
+    if (acc.recent.length > DASHBOARD_RECENT_LIMIT) acc.recent.pop();
+  }
+}
+function addUsage(acc, entry, time, usage) {
+  const { messages, totalTokens, inputTokens, outputTokens, cacheReadTokens, cacheCreateTokens } = usage;
+  if (messages <= 0 && totalTokens <= 0 && inputTokens <= 0 && outputTokens <= 0 && cacheReadTokens <= 0 && cacheCreateTokens <= 0) {
+    return;
+  }
+  acc.messages += messages;
+  acc.tokens += totalTokens;
+  acc.cacheReadTokens += cacheReadTokens;
+  const agentKey = getSessionAgentName(entry.session);
+  let metric = acc.agents.get(agentKey);
+  if (!metric) {
+    metric = { name: agentKey, sessions: 0, messages: 0, tokens: 0, cost: 0 };
+    acc.agents.set(agentKey, metric);
+  }
+  metric.messages += messages;
+  metric.tokens += totalTokens;
+  const dayKey = toCalendarDayKey(time);
+  let bucket = acc.daily.get(dayKey);
+  if (!bucket) {
+    bucket = emptyDailyBucket(dayKey);
+    acc.daily.set(dayKey, bucket);
+  }
+  bucket.messages += messages;
+  bucket.input += Math.max(0, inputTokens - cacheReadTokens - cacheCreateTokens);
+  bucket.output += outputTokens;
+  bucket.cache_read += cacheReadTokens;
+  bucket.cache_create += cacheCreateTokens;
+  const project = getOrCreateProject(entry.session, acc);
+  if (!project) return;
+  project.messages += messages;
+  project.tokens += totalTokens;
+}
+function accumulateUsage(tree, scope, acc, from, to, costFacts) {
+  visitAttributedUsage(
+    tree,
+    { from, to, facts: costFacts, matchesEntry: (session) => matchesScope(session, scope) },
+    ({ entry, time, ...usage }) => addUsage(acc, entry, time, usage)
+  );
+}
+function addModelCost(acc, model, cost, recordedCost) {
+  if (!model || cost <= 0) return;
+  const recorded = Math.max(0, Math.min(cost, recordedCost));
+  const current = acc.modelCosts.get(model);
+  if (current) {
+    current.cost += cost;
+    current.costRecorded += recorded;
+    current.costEstimated += cost - recorded;
+    return;
+  }
+  acc.modelCosts.set(model, {
+    model,
+    cost,
+    costRecorded: recorded,
+    costEstimated: cost - recorded
+  });
+}
+function addCost(acc, entry, time, cost, source) {
+  if (cost <= 0) return;
+  acc.cost += cost;
+  if (source === "recorded") acc.costRecorded += cost;
+  else {
+    acc.costEstimated += cost;
+    acc.hasEstimatedCost = true;
+  }
+  const agentKey = getSessionAgentName(entry.session);
+  let metric = acc.agents.get(agentKey);
+  if (!metric) {
+    metric = { name: agentKey, sessions: 0, messages: 0, tokens: 0, cost: 0 };
+    acc.agents.set(agentKey, metric);
+  }
+  metric.cost += cost;
+  const dayKey = toCalendarDayKey(time);
+  let bucket = acc.daily.get(dayKey);
+  if (!bucket) {
+    bucket = emptyDailyBucket(dayKey);
+    acc.daily.set(dayKey, bucket);
+  }
+  bucket.cost += cost;
+  const project = getOrCreateProject(entry.session, acc);
+  if (!project) return;
+  project.cost += cost;
+  if (source === "estimated") project.hasEstimatedCost = true;
+  const slot = acc.sparklineSlots.get(dayKey);
+  if (slot != null) project.sparkline[slot] += cost;
+}
+function accumulateCosts(tree, scope, acc, from, to, costFacts) {
+  visitAttributedCosts(
+    tree,
+    { from, to, facts: costFacts, matchesEntry: (session) => matchesScope(session, scope) },
+    ({ entry, time, cost, source, modelCosts }) => {
+      addCost(acc, entry, time, cost, source);
+      for (const model of modelCosts) {
+        addModelCost(acc, model.model, model.cost, model.costRecorded);
+      }
+    }
+  );
+}
+function toPreviousTotals(acc) {
+  return { sessions: acc.sessions, messages: acc.messages, tokens: acc.tokens, cost: acc.cost };
+}
+function toProjectStat(project) {
+  return {
+    identityKind: project.identityKind,
+    identityKey: project.identityKey,
+    displayName: project.displayName,
+    sessions: project.sessions,
+    messages: project.messages,
+    tokens: project.tokens,
+    cost: project.cost,
+    cost_source: project.cost > 0 ? project.hasEstimatedCost ? "estimated" : "recorded" : void 0,
+    agents: [...project.agentSessions.entries()].sort((a, b) => b[1] - a[1]).map(([agentKey]) => agentKey),
+    sparkline: project.sparkline
+  };
+}
+function buildDashboard(sessions, options) {
+  const { byAgentNames, scope, from, to, agentInfoMap, compare, costFacts } = options;
+  const tree = buildSessionTree(sessions);
+  const costFactsAvailable = costFacts != null;
+  const acc = createAccumulator(byAgentNames, scope, to);
+  if (from != null) {
+    const bucketDays = countCalendarDays(from, to);
+    for (let i = 0; i < bucketDays; i += 1) {
+      const key = toCalendarDayKey(addCalendarDays(from, i));
+      acc.daily.set(key, emptyDailyBucket(key));
+    }
+  }
+  for (const node of scopedEntries(tree, scope, from, to)) accumulateActivity(node, acc);
+  accumulateUsage(tree, scope, acc, from, to, costFacts);
+  accumulateCosts(tree, scope, acc, from, to, costFacts);
+  let previous;
+  if (compare) {
+    const compareAcc = createAccumulator(byAgentNames, scope, compare.to);
+    for (const node of scopedEntries(tree, scope, compare.from, compare.to)) {
+      accumulateActivity(node, compareAcc);
+    }
+    accumulateUsage(tree, scope, compareAcc, compare.from, compare.to, costFacts);
+    accumulateCosts(tree, scope, compareAcc, compare.from, compare.to, costFacts);
+    previous = toPreviousTotals(compareAcc);
+  }
+  const perAgent = [...acc.agents.values()].map((metrics) => {
+    const info = agentInfoMap?.get(metrics.name);
+    return {
+      name: metrics.name,
+      displayName: info?.displayName ?? metrics.name,
+      icon: info?.icon ?? "",
+      iconColored: info?.iconColored,
+      sessions: metrics.sessions,
+      messages: metrics.messages,
+      tokens: metrics.tokens,
+      cost: metrics.cost
+    };
+  }).filter((item) => item.sessions > 0 || item.messages > 0 || item.tokens > 0 || item.cost > 0).sort((a, b) => b.sessions - a.sessions || b.cost - a.cost);
+  const dailyActivity = [...acc.daily.values()].sort((a, b) => a.date.localeCompare(b.date));
+  const modelDistribution = [...acc.models.entries()].map(([model, { tokens, sessions: count }]) => ({ model, tokens, sessions: count })).sort((a, b) => b.tokens - a.tokens);
+  const modelCost = costFactsAvailable ? [...acc.modelCosts.values()].sort((a, b) => b.cost - a.cost).slice(0, MODEL_COST_LIMIT) : null;
+  const rankedProjects = [...acc.projects.values()].sort((a, b) => b.cost - a.cost);
+  const perProject = rankedProjects.slice(0, DASHBOARD_PROJECT_LIMIT).map(toProjectStat);
+  const projectRollup = rankedProjects.slice(DASHBOARD_PROJECT_LIMIT).reduce(
+    (rollup, project) => ({
+      projects: rollup.projects + 1,
+      sessions: rollup.sessions + project.sessions,
+      tokens: rollup.tokens + project.tokens,
+      cost: rollup.cost + project.cost
+    }),
+    { projects: 0, sessions: 0, tokens: 0, cost: 0 }
+  );
+  const recentSessions = acc.recent.map(({ session }) => ({
+    reference: session.reference,
+    session
+  }));
+  const latest = acc.recent[0];
+  return {
+    totals: {
+      sessions: acc.sessions,
+      messages: acc.messages,
+      tokens: acc.tokens,
+      cost: acc.cost,
+      costRecorded: acc.costRecorded,
+      costEstimated: acc.costEstimated,
+      cacheReadTokens: acc.cacheReadTokens,
+      cost_source: acc.cost > 0 ? acc.hasEstimatedCost ? "estimated" : "recorded" : void 0,
+      latestActivity: latest?.activity || void 0,
+      latestActivityProject: latest?.session.project_identity?.displayName,
+      latestActivityAgent: latest ? getSessionAgentName(latest.session) : void 0,
+      previous
+    },
+    scopeCounts: { projects: acc.projectKeys.size, agents: acc.agentKeys.size },
+    perAgent,
+    dailyActivity,
+    modelDistribution,
+    modelCost,
+    perProject,
+    projectRollup,
+    recentSessions
+  };
+}
+
+// ../core/dist/runtime/projects.mjs
+function summarizeProjects(projects) {
+  const summary = {
+    projects: projects.length,
+    sessions: 0,
+    tokens: 0,
+    cost: 0,
+    latestActivity: null
+  };
+  for (const project of projects) {
+    summary.sessions += project.sessionCount;
+    summary.tokens += project.tokens;
+    summary.cost += project.cost;
+    if (project.lastActivity != null) {
+      summary.latestActivity = summary.latestActivity == null ? project.lastActivity : Math.max(summary.latestActivity, project.lastActivity);
+    }
+  }
+  return summary;
+}
+function emptyMetrics() {
+  return {
+    sessions: 0,
+    messages: 0,
+    tokens: 0,
+    cost: 0,
+    hasEstimatedCost: false,
+    agentStats: /* @__PURE__ */ new Map()
+  };
+}
+function attachProjectMetricsFromTree(projects, tree, from, to, costFacts) {
+  return attachProjectMetricsToEntries(
+    projects,
+    tree,
+    filterSessionTreeEntriesByActivityWindow(tree, from, to),
+    from,
+    to,
+    costFacts
+  );
+}
+function attachProjectMetricsToEntries(projects, tree, entries, from, to, costFacts) {
+  const metrics = /* @__PURE__ */ new Map();
+  for (const node of entries) {
+    const identity = node.session.project_identity;
+    if (!identity) continue;
+    const key = getProjectIdentityKey(identity);
+    let current = metrics.get(key);
+    if (!current) {
+      current = emptyMetrics();
+      metrics.set(key, current);
+    }
+    current.sessions += 1;
+    const agentName = getSessionAgentName(node.session);
+    const agent = current.agentStats.get(agentName);
+    if (agent) {
+      agent.sessions += 1;
+    } else {
+      current.agentStats.set(agentName, {
+        name: agentName,
+        sessions: 1,
+        messages: 0,
+        tokens: 0,
+        cost: 0
+      });
+    }
+  }
+  visitAttributedUsage(
+    tree,
+    { from, to: to ?? Number.POSITIVE_INFINITY, facts: costFacts },
+    ({ entry, messages, totalTokens }) => {
+      const identity = entry.session.project_identity;
+      if (!identity) return;
+      const key = getProjectIdentityKey(identity);
+      let current = metrics.get(key);
+      if (!current) {
+        current = emptyMetrics();
+        metrics.set(key, current);
+      }
+      current.messages += messages;
+      current.tokens += totalTokens;
+      const agentName = getSessionAgentName(entry.session);
+      const agent = current.agentStats.get(agentName);
+      if (agent) {
+        agent.messages += messages;
+        agent.tokens += totalTokens;
+      } else {
+        current.agentStats.set(agentName, {
+          name: agentName,
+          sessions: 0,
+          messages,
+          tokens: totalTokens,
+          cost: 0
+        });
+      }
+    }
+  );
+  visitAttributedCosts(
+    tree,
+    { from, to: to ?? Number.POSITIVE_INFINITY, facts: costFacts },
+    ({ entry, cost, source }) => {
+      const identity = entry.session.project_identity;
+      if (!identity) return;
+      const key = getProjectIdentityKey(identity);
+      let current = metrics.get(key);
+      if (!current) {
+        current = emptyMetrics();
+        metrics.set(key, current);
+      }
+      current.cost += cost;
+      if (source === "estimated") current.hasEstimatedCost = true;
+      const agentName = getSessionAgentName(entry.session);
+      const agent = current.agentStats.get(agentName);
+      if (agent) agent.cost += cost;
+      else {
+        current.agentStats.set(agentName, {
+          name: agentName,
+          sessions: 0,
+          messages: 0,
+          tokens: 0,
+          cost
+        });
+      }
+    }
+  );
+  return projects.map((project) => {
+    const metric = metrics.get(
+      getProjectIdentityKey({ kind: project.identityKind, key: project.identityKey })
+    );
+    return {
+      ...project,
+      sessionCount: metric?.sessions ?? 0,
+      messages: metric?.messages ?? 0,
+      tokens: metric?.tokens ?? 0,
+      cost: metric?.cost ?? 0,
+      cost_source: metric && metric.cost > 0 ? metric.hasEstimatedCost ? "estimated" : "recorded" : void 0,
+      agentStats: [...metric?.agentStats.values() ?? []].sort((a, b) => b.sessions - a.sessions)
+    };
+  });
+}
+
+export {
+  getSessionActivityTime,
+  buildDashboard,
+  summarizeProjects,
+  attachProjectMetricsFromTree
+};
+//# sourceMappingURL=chunk-MBZ4VV4C.js.map