dsh-tacit 0.3.0 → 0.5.0

package/lib/store.js

@@ -8,7 +8,7 @@
  *   profile.json                 persistent user mistake profile
  *   reports/<sessionId>/<turn>.json  analysis reports
  *   usage/<YYYY-MM-DD>.json      per-day usage ledger (runs of metered model calls)
- *   usage/summary.json           rolling lifetime/byType/byModel/day totals
+ *   usage/summary.json           rolling lifetime/byType/byModel/byProvider/byTrigger/day totals
  *
  * Safety rules (hard constraints):
  *  - writes are atomic (temp file + rename) and never truncate an existing
@@ -31,6 +31,14 @@ import { usageDayFileSchema, usageSummarySchema } from './schema.js'
 const USAGE_DAY_FILE_RE = /^\d{4}-\d{2}-\d{2}\.json$/
 const USAGE_DAY_RE = /^\d{4}-\d{2}-\d{2}$/
 
+/**
+ * How much summed on-disk day-file weight `readUsageDay` may keep parsed in
+ * memory. Chosen so a realistic retention window is never evicted while a
+ * pathological one (a year of capped 500-run days) degrades to re-reading
+ * instead of pinning hundreds of megabytes for the life of the process.
+ */
+const USAGE_DAY_MEMO_BUDGET_BYTES = 16 * 1024 * 1024
+
 /** Local calendar day key, `YYYY-MM-DD` (auto-analysis daily budget and the usage ledger share this). */
 export function dayKey(now = Date.now()) {
   const date = new Date(now)
@@ -43,7 +51,7 @@ export function dayKey(now = Date.now()) {
  * Subtracting a fixed `days * 86_400_000` instead would land a day early across
  * a spring-forward (a 23 h day), silently keeping one day more than asked for.
  */
-function dayKeyBefore(today, days) {
+export function dayKeyBefore(today, days) {
   const match = USAGE_DAY_RE.exec(String(today))
   const at = match !== null
     ? new Date(Number(match[0].slice(0, 4)), Number(match[0].slice(5, 7)) - 1, Number(match[0].slice(8, 10)))
@@ -54,7 +62,7 @@ function dayKeyBefore(today, days) {
 }
 
 function emptyUsageSummaryRaw() {
-  return { version: 1, trackingSince: Date.now(), lifetime: {}, byType: {}, byModel: {}, days: {} }
+  return { version: 1, trackingSince: Date.now(), lifetime: {}, byType: {}, byModel: {}, byProvider: {}, byTrigger: {}, days: {} }
 }
 
 export function emptyProfile() {
@@ -75,6 +83,9 @@ export class CoachStore {
     this.root = root
     /** Absolute paths already warned about (corrupt usage JSON) — warn once per file, not once per read. */
     this.warnedUsageFiles = new Set()
+    /** Parsed day files by absolute path, keyed on the `mtimeMs`/`size` they were read at. */
+    this.usageDayMemo = new Map()
+    this.usageDayMemoBytes = 0
   }
 
   ensureDir(dir) {
@@ -299,14 +310,55 @@ export class CoachStore {
     return path.join(this.usageDir(), `${day}.json`)
   }
 
+  /**
+   * A parsed day file. Old day files never change, and `report()` re-reads the
+   * whole window on every poll of the cost panel, so an unchanged file is
+   * served from memory. The returned object is shared, not cloned: no caller
+   * mutates it (`upsertDay` copies `runs` before editing).
+   */
   readUsageDay(day) {
-    return this.readUsageJson(this.usageDayFile(day), usageDayFileSchema, { version: 1, day, runs: [] })
+    const file = this.usageDayFile(day)
+    let stat = null
+    try {
+      stat = fs.statSync(file)
+    } catch {
+      stat = null
+    }
+    if (stat === null) {
+      this.forgetUsageDay(file)
+      return this.readUsageJson(file, usageDayFileSchema, { version: 1, day, runs: [] })
+    }
+    const memo = this.usageDayMemo.get(file)
+    if (memo !== undefined && memo.mtimeMs === stat.mtimeMs && memo.size === stat.size) return memo.value
+    const value = this.readUsageJson(file, usageDayFileSchema, { version: 1, day, runs: [] })
+    this.forgetUsageDay(file)
+    this.usageDayMemo.set(file, { mtimeMs: stat.mtimeMs, size: stat.size, value })
+    this.usageDayMemoBytes += stat.size
+    while (this.usageDayMemoBytes > USAGE_DAY_MEMO_BUDGET_BYTES) {
+      const oldest = this.usageDayMemo.keys().next()
+      if (oldest.done) break
+      this.forgetUsageDay(oldest.value)
+    }
+    return value
+  }
+
+  /**
+   * Drop one memoized day file. Every in-process write and unlink calls this:
+   * a same-millisecond same-size rewrite would otherwise pass the stat check
+   * and let `upsertDay`'s read-modify-write silently drop runs.
+   */
+  forgetUsageDay(file) {
+    const memo = this.usageDayMemo.get(file)
+    if (memo === undefined) return
+    this.usageDayMemo.delete(file)
+    this.usageDayMemoBytes -= memo.size
   }
 
   /** Atomic write; caps `runs` to the newest 500 by `startedAt` before writing. */
   writeUsageDay(day, file) {
     const runs = Array.isArray(file?.runs) ? [...file.runs] : []
     runs.sort((a, b) => (Number(a?.startedAt) || 0) - (Number(b?.startedAt) || 0))
+    this.forgetUsageDay(this.usageDayFile(day))
     this.writeJsonAtomic(this.usageDayFile(day), { version: 1, day, runs: runs.slice(-500) })
   }
 
@@ -329,8 +381,15 @@ export class CoachStore {
       .sort()
   }
 
+  /**
+   * `{summary, created}`. `created` is true when there was no usable file and
+   * the default was synthesized, which a caller cannot infer from the value:
+   * a summary with nothing recorded yet is indistinguishable from a fresh one.
+   */
   readUsageSummary() {
-    return this.readUsageJson(this.usageSummaryFile(), usageSummarySchema, usageSummarySchema.parse(emptyUsageSummaryRaw()))
+    const fallback = usageSummarySchema.parse(emptyUsageSummaryRaw())
+    const summary = this.readUsageJson(this.usageSummaryFile(), usageSummarySchema, fallback)
+    return { summary, created: summary === fallback }
   }
 
   writeUsageSummary(summary) {
@@ -350,6 +409,7 @@ export class CoachStore {
     for (const day of this.listUsageDays()) {
       if (day >= cutoff) continue
       try {
+        this.forgetUsageDay(this.usageDayFile(day))
         fs.unlinkSync(this.usageDayFile(day))
         removed += 1
       } catch {
@@ -368,6 +428,7 @@ export class CoachStore {
     let removed = 0
     for (const day of this.listUsageDays()) {
       try {
+        this.forgetUsageDay(this.usageDayFile(day))
         fs.unlinkSync(this.usageDayFile(day))
         removed += 1
       } catch {

package/lib/usage.js

@@ -23,18 +23,20 @@
  * flushed to `usage/summary.json`) so reports never re-scan every day file.
  */
 
-import { dayKey } from './store.js'
-import { USAGE_OPS, USAGE_RUN_TYPES } from './schema.js'
+import { dayKey, dayKeyBefore } from './store.js'
+import { USAGE_ATTEMPT_STATUSES, USAGE_OPS, USAGE_RUN_STATUSES, USAGE_RUN_TYPES } from './schema.js'
 
-const ATTEMPT_STATUSES = ['ok', 'failed', 'unmetered']
-const RUN_STATUSES = ['running', 'success', 'partial', 'failed']
 const TOKEN_KEYS = ['inputTokens', 'outputTokens', 'cacheReadTokens', 'cacheWriteTokens', 'reasoningTokens']
+/** The retry ops a repair pays for, each its own billed attempt. */
+const REPAIR_OPS = ['analysis-repair', 'improve-repair']
 /** Finished runs kept addressable for `runSummary()` after they leave `live`. */
 const MAX_REMEMBERED_RUNS = 50
 const MS_PER_DAY = 24 * 60 * 60 * 1000
 /** Report defaults for the wire-optional filter fields. */
 const DEFAULT_RANGE = '30d'
 const DEFAULT_PAGE_SIZE = 20
+/** Summary day buckets kept. Far past the ~30 days any range reads, so nothing dropped is ever missed. */
+const MAX_SUMMARY_DAYS = 400
 /** Days each `range` looks back over (`month`/`all` are computed instead). */
 const RANGE_DAYS = { today: 1, '7d': 7, '30d': 30 }
 /** Spend at or above this share of the limit is a warning (below the limit itself). */
@@ -42,6 +44,15 @@ const WARN_AT = 0.8
 /** The one honest claim the cost cards may make: real usage, list-price arithmetic. */
 const PRICING_LABEL = 'Measured usage · list-price cost'
 
+/**
+ * Two random base36 characters. The clock and the per-tracker sequence alone
+ * repeat across trackers in one process, and `upsertDay` keys on the run id,
+ * so a repeat silently replaces the earlier run in its day file.
+ */
+function idSalt() {
+  return Math.floor(Math.random() * 36 * 36).toString(36).padStart(2, '0')
+}
+
 /** A non-negative finite number, or 0. */
 function count(value) {
   return typeof value === 'number' && Number.isFinite(value) && value >= 0 ? value : 0
@@ -51,12 +62,30 @@ function isPlainObject(value) {
   return value !== null && typeof value === 'object' && !Array.isArray(value)
 }
 
+function isFiniteNumber(value) {
+  return typeof value === 'number' && Number.isFinite(value)
+}
+
+/**
+ * A `usageAttemptSchema.priced` object, or `null` for anything else. The
+ * schema is strict, so one malformed pricing result written into a day file
+ * would make that whole day unreadable on the way back in.
+ */
+function narrowPriced(priced) {
+  if (!isPlainObject(priced) || !isPlainObject(priced.rates)) return null
+  const { source, tier, asOf, usd, rates } = priced
+  if (source !== 'bundled' && source !== 'costMeter') return null
+  if (typeof tier !== 'string' || typeof asOf !== 'string' || !isFiniteNumber(usd)) return null
+  if (!isFiniteNumber(rates.cacheHit) || !isFiniteNumber(rates.cacheMiss) || !isFiniteNumber(rates.output)) return null
+  return { source, tier, rates: { cacheHit: rates.cacheHit, cacheMiss: rates.cacheMiss, output: rates.output }, asOf, usd }
+}
+
 function emptyTokens() {
   return { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0, reasoningTokens: 0 }
 }
 
 function emptyTotals() {
-  return { attempts: 0, billedCalls: 0, unmeteredCalls: 0, unpricedCalls: 0, tokens: emptyTokens(), usdKnown: 0 }
+  return { attempts: 0, billedCalls: 0, failedCalls: 0, unmeteredCalls: 0, unpricedCalls: 0, tokens: emptyTokens(), usdKnown: 0, failedUsd: 0 }
 }
 
 function emptyDayTotals() {
@@ -86,9 +115,11 @@ function narrowUsage(usage) {
 function addTotals(target, delta) {
   target.attempts += delta.attempts
   target.billedCalls += delta.billedCalls
+  target.failedCalls += delta.failedCalls
   target.unmeteredCalls += delta.unmeteredCalls
   target.unpricedCalls += delta.unpricedCalls
   target.usdKnown += delta.usdKnown
+  target.failedUsd += delta.failedUsd
   for (const key of TOKEN_KEYS) target.tokens[key] += delta.tokens[key]
 }
 
@@ -150,7 +181,7 @@ function safeTotals(value) {
   const source = isPlainObject(value) ? value : {}
   const out = { ...emptyTotals(), ...source }
   out.tokens = { ...emptyTokens(), ...(isPlainObject(source.tokens) ? source.tokens : {}) }
-  for (const key of ['attempts', 'billedCalls', 'unmeteredCalls', 'unpricedCalls', 'usdKnown']) out[key] = count(out[key])
+  for (const key of ['attempts', 'billedCalls', 'failedCalls', 'unmeteredCalls', 'unpricedCalls', 'usdKnown', 'failedUsd']) out[key] = count(out[key])
   for (const key of TOKEN_KEYS) out.tokens[key] = count(out.tokens[key])
   return out
 }
@@ -158,14 +189,16 @@ function safeTotals(value) {
 /** The totals delta one stored attempt contributed — the same arithmetic `recordAttempt` applied live. */
 function attemptDelta(attempt) {
   const usage = narrowUsage(attempt.usage)
-  const priced = isPlainObject(attempt.priced) ? attempt.priced : null
+  const priced = narrowPriced(attempt.priced)
   return {
     attempts: 1,
     billedCalls: usage !== null ? 1 : 0,
+    failedCalls: usage !== null && attempt.status === 'failed' ? 1 : 0,
     unmeteredCalls: usage === null ? 1 : 0,
     unpricedCalls: usage !== null && priced === null ? 1 : 0,
     tokens: usage ?? emptyTokens(),
     usdKnown: count(priced?.usd),
+    failedUsd: attempt.status === 'failed' ? count(priced?.usd) : 0,
   }
 }
 
@@ -202,22 +235,17 @@ export function createUsageTracker({ store, config, pricing, now = Date.now, flu
   let seq = 0
   /** '' until the first prune; then the day key it last ran on. */
   let lastPruneDay = ''
+  /** Unknown run types already warned about — warn once per type, not once per run. */
+  const warnedRunTypes = new Set()
 
+  const loaded = store.readUsageSummary()
   // Reassigned by `clear()`, which reloads the (fresh) summary the store wrote.
-  let summary = store.readUsageSummary()
-  if (isFreshSummary(summary)) {
+  let summary = loaded.summary
+  if (loaded.created) {
     summary.trackingSince = now()
     store.writeUsageSummary(summary)
   }
 
-  /** A summary with nothing recorded yet was just created by the store — persist it so `trackingSince` sticks. */
-  function isFreshSummary(value) {
-    return count(value?.lifetime?.attempts) === 0
-      && Object.keys(value?.days ?? {}).length === 0
-      && Object.keys(value?.byType ?? {}).length === 0
-      && Object.keys(value?.byModel ?? {}).length === 0
-  }
-
   /** The day file a run belongs to (its start, so a run never splits across two files). */
   function runDay(run) {
     return dayKey(run.startedAt)
@@ -245,22 +273,39 @@ export function createUsageTracker({ store, config, pricing, now = Date.now, flu
     store.writeUsageDay(day, { version: 1, day, runs: list })
   }
 
-  /** Expire old day files at most once per calendar day. */
+  /** Expire old day files and summary day buckets, at most once per calendar day. */
   function pruneIfNewDay() {
     const today = dayKey(now())
     if (today === lastPruneDay) return
     lastPruneDay = today
-    const keepDays = count(config?.().costHistoryDays)
-    store.pruneUsageDays(keepDays > 0 ? keepDays : 30, today)
+    store.pruneUsageDays(retentionDays(), today)
+    pruneSummaryDays()
+  }
+
+  /** One bucket per calendar day would accumulate forever; nothing reads past `MAX_SUMMARY_DAYS`. */
+  function pruneSummaryDays() {
+    const oldest = dayKeysEnding(now(), MAX_SUMMARY_DAYS)[0]
+    let removed = 0
+    for (const day of Object.keys(summary.days ?? {})) {
+      if (day >= oldest) continue
+      delete summary.days[day]
+      removed += 1
+    }
+    if (removed === 0) return
+    summaryDirty = true
+    scheduleFlush()
   }
 
   function beginRun({ type, trigger = '', sessionId = '', turn = null, workspace = '', model = '', provider = '' } = {}) {
     const startedAt = now()
-    const runId = `u${startedAt.toString(36)}-${(seq++).toString(36)}`
+    const runId = `u${startedAt.toString(36)}${idSalt()}-${(seq++).toString(36)}`
     if (!USAGE_RUN_TYPES.includes(type)) {
       // Never track a run the day-file schema would reject: one bad row makes
       // the whole day unreadable. The id stays valid; every sink ignores it.
-      console.warn(`[tacit] usage: unknown run type ${JSON.stringify(type)}, not tracked`)
+      if (!warnedRunTypes.has(type)) {
+        warnedRunTypes.add(type)
+        console.warn(`[tacit] usage: unknown run type ${JSON.stringify(type)}, not tracked`)
+      }
       return runId
     }
     live.set(runId, {
@@ -303,27 +348,31 @@ export function createUsageTracker({ store, config, pricing, now = Date.now, flu
       provider,
       reasoningEffort: typeof record.reasoningEffort === 'string' ? record.reasoningEffort : null,
       finish: typeof record.finish === 'string' ? record.finish : '',
-      status: ATTEMPT_STATUSES.includes(record.status) ? record.status : (usage === null ? 'unmetered' : 'ok'),
+      status: USAGE_ATTEMPT_STATUSES.includes(record.status) ? record.status : (usage === null ? 'unmetered' : 'ok'),
       code: typeof record.code === 'string' ? record.code : '',
       sessionId: String(sessionId ?? ''),
       turn: typeof turn === 'number' && Number.isFinite(turn) ? turn : null,
       usage,
-      priced: isPlainObject(priced) ? priced : null,
+      priced: narrowPriced(priced),
     }
     run.attempts.push(attempt)
 
     const delta = {
       attempts: 1,
       billedCalls: usage !== null ? 1 : 0,
+      failedCalls: usage !== null && attempt.status === 'failed' ? 1 : 0,
       unmeteredCalls: usage === null ? 1 : 0,
       unpricedCalls: usage !== null && attempt.priced === null ? 1 : 0,
       tokens: usage ?? emptyTokens(),
       usdKnown: count(attempt.priced?.usd),
+      failedUsd: attempt.status === 'failed' ? count(attempt.priced?.usd) : 0,
     }
     addTotals(run.totals, delta)
     addTotals(bucketOf(summary, 'lifetime', emptyTotals), delta)
     addTotals(bucketOf(summary.byType, run.type, emptyTotals), delta)
     if (model.length > 0) addTotals(bucketOf(summary.byModel, model, emptyTotals), delta)
+    if (provider.length > 0) addTotals(bucketOf(summary.byProvider, provider, emptyTotals), delta)
+    if (run.trigger.length > 0) addTotals(bucketOf(summary.byTrigger, run.trigger, emptyTotals), delta)
     const day = bucketOf(summary.days, dayKey(startedAt), emptyDayTotals)
     if (!isPlainObject(day.byType)) day.byType = {}
     addTotals(day, delta)
@@ -344,7 +393,7 @@ export function createUsageTracker({ store, config, pricing, now = Date.now, flu
     const run = live.get(runId)
     if (run === undefined) return null
     run.endedAt = now()
-    run.status = RUN_STATUSES.includes(status) ? status : deriveStatus(run.attempts)
+    run.status = USAGE_RUN_STATUSES.includes(status) ? status : deriveStatus(run.attempts)
     run.results = narrowResults(results)
     upsertDay(runDay(run), [run])
     live.delete(runId)
@@ -369,10 +418,12 @@ export function createUsageTracker({ store, config, pricing, now = Date.now, flu
       status: run.status,
       attempts: run.totals.attempts,
       billedCalls: run.totals.billedCalls,
+      failedCalls: run.totals.failedCalls,
       unmeteredCalls: run.totals.unmeteredCalls,
       unpricedCalls: run.totals.unpricedCalls,
       tokens: { ...run.totals.tokens },
       usdKnown: run.totals.usdKnown,
+      failedUsd: run.totals.failedUsd,
     }
   }
 
@@ -457,7 +508,7 @@ export function createUsageTracker({ store, config, pricing, now = Date.now, flu
   }
 
   /**
-   * One period card: the summary's own totals plus the two derived figures
+   * One period card: the summary's own totals plus the derived figures
    * the panel shows. `avgAnalysisUsd` is a median (a single bootstrap batch
    * must not drag the typical cost of one analysis upwards) over the priced
    * `analysis` attempts of the day files that were loaded — so it is only as
@@ -465,12 +516,26 @@ export function createUsageTracker({ store, config, pricing, now = Date.now, flu
    */
   function periodOf(totals, attempts) {
     const usds = []
+    let repairUsd = 0
+    let repairUsdNotFailed = 0
     for (const attempt of attempts) {
-      if (attempt.op !== 'analysis') continue
       if (!isPlainObject(attempt.priced)) continue
-      usds.push(count(attempt.priced.usd))
+      const usd = count(attempt.priced.usd)
+      if (attempt.op === 'analysis') usds.push(usd)
+      if (!REPAIR_OPS.includes(attempt.op)) continue
+      repairUsd += usd
+      if (attempt.status !== 'failed') repairUsdNotFailed += usd
+    }
+    // `failedOrRepairUsd` is the union of "failed" and "repair", counted once.
+    // `repairUsd` and `totals.failedUsd` both count a failed repair, so those
+    // two halves can sum to more than the union.
+    return {
+      ...totals,
+      avgAnalysisUsd: median(usds),
+      cachedInputRate: cachedInputRateOf(totals.tokens),
+      repairUsd,
+      failedOrRepairUsd: totals.failedUsd + repairUsdNotFailed,
     }
-    return { ...totals, avgAnalysisUsd: median(usds), cachedInputRate: cachedInputRateOf(totals.tokens) }
   }
 
   /**
@@ -523,6 +588,18 @@ export function createUsageTracker({ store, config, pricing, now = Date.now, flu
     }
   }
 
+  /**
+   * A run belongs to a range if any day it billed on falls inside it. The row
+   * lives in its start day's file, but a run that crosses midnight bills into
+   * the next day's totals, so matching on the start day alone would make the
+   * `today` tile and the `today` run list disagree by one run.
+   */
+  function inRange(run, days) {
+    if (days.has(dayKey(count(run.startedAt)))) return true
+    if (!Array.isArray(run.attempts)) return false
+    return run.attempts.some((attempt) => isPlainObject(attempt) && days.has(dayKey(count(attempt.startedAt))))
+  }
+
   /** Every filter is an exact match; an absent filter matches everything. */
   function matchesFilters(run, filters) {
     if (filters.type !== undefined && run.type !== filters.type) return false
@@ -559,8 +636,11 @@ export function createUsageTracker({ store, config, pricing, now = Date.now, flu
     // The run list follows `range`; every fixed-window figure below reads the
     // union, so a narrow range can never shrink a 30-day breakdown or median.
     const listKeys = rangeKeys(range, keepDays, available)
+    // A run row lives in its start day's file, so the run that crossed midnight
+    // into the range is only reachable by opening the day before it too.
+    const scanKeys = listKeys.length === 0 ? [] : [...new Set([dayKeyBefore(listKeys[0], 1), ...listKeys])]
     const detailKeys = [...new Set([
-      ...listKeys,
+      ...scanKeys,
       ...rangeKeys('30d', keepDays, available),
       ...rangeKeys('month', keepDays, available),
     ])].sort()
@@ -590,10 +670,12 @@ export function createUsageTracker({ store, config, pricing, now = Date.now, flu
     const monthPrefix = dayKey(now()).slice(0, 7)
     const monthKeys = Object.keys(summary.days ?? {}).filter((day) => day.startsWith(monthPrefix)).sort()
 
-    // byType comes straight from the summary's own per-day buckets; byModel is
-    // folded from the loaded attempts because the day buckets carry no model
-    // split. Both cover the same last-30-days window, whatever `range` asked
-    // for — the detail window above always includes those 30 days.
+    // byType comes straight from the summary's own per-day buckets; byModel,
+    // byProvider and byTrigger are folded from the loaded runs because the day
+    // buckets carry none of those three splits. Model and provider come off the
+    // attempt, the trigger off the run around it. All four cover the same
+    // last-30-days window, whatever `range` asked for — the detail window above
+    // always includes those 30 days.
     const byType = {}
     for (const day of last30Keys) {
       const buckets = summary.days?.[day]?.byType
@@ -601,10 +683,23 @@ export function createUsageTracker({ store, config, pricing, now = Date.now, flu
       for (const [type, totals] of Object.entries(buckets)) addTotals(bucketOf(byType, type, emptyTotals), safeTotals(totals))
     }
     const byModel = {}
-    for (const attempt of attemptsIn(last30Keys)) {
-      const model = typeof attempt.model === 'string' ? attempt.model : ''
-      if (model.length === 0) continue
-      addTotals(bucketOf(byModel, model, emptyTotals), attemptDelta(attempt))
+    const byProvider = {}
+    const byTrigger = {}
+    const last30Days = new Set(last30Keys)
+    for (const dayRuns of loaded.values()) {
+      for (const run of dayRuns) {
+        if (!Array.isArray(run.attempts)) continue
+        const trigger = typeof run.trigger === 'string' ? run.trigger : ''
+        for (const attempt of run.attempts) {
+          if (!isPlainObject(attempt) || !last30Days.has(dayKey(count(attempt.startedAt)))) continue
+          const delta = attemptDelta(attempt)
+          const model = typeof attempt.model === 'string' ? attempt.model : ''
+          const provider = typeof attempt.provider === 'string' ? attempt.provider : ''
+          if (model.length > 0) addTotals(bucketOf(byModel, model, emptyTotals), delta)
+          if (provider.length > 0) addTotals(bucketOf(byProvider, provider, emptyTotals), delta)
+          if (trigger.length > 0) addTotals(bucketOf(byTrigger, trigger, emptyTotals), delta)
+        }
+      }
     }
 
     const today = periodOf(totalsOver(todayKeys), attemptsIn(todayKeys))
@@ -612,10 +707,11 @@ export function createUsageTracker({ store, config, pricing, now = Date.now, flu
     const dailyLimit = count(effective?.costWarnDailyUsd)
     const monthlyLimit = count(effective?.costWarnMonthlyUsd)
 
+    const listDays = new Set(listKeys)
     const listRuns = []
-    for (const day of listKeys) listRuns.push(...(loaded.get(day) ?? []))
+    for (const day of scanKeys) listRuns.push(...(loaded.get(day) ?? []))
     const matched = listRuns
-      .filter((run) => matchesFilters(run, filters))
+      .filter((run) => inRange(run, listDays) && matchesFilters(run, filters))
       .sort((a, b) => count(b.startedAt) - count(a.startedAt))
     const from = (page - 1) * pageSize
 
@@ -630,6 +726,8 @@ export function createUsageTracker({ store, config, pricing, now = Date.now, flu
       lifetime: periodOf(safeTotals(summary.lifetime), attempts),
       byType,
       byModel,
+      byProvider,
+      byTrigger,
       series7: seriesOf(7),
       series30: seriesOf(30),
       warnings: {
@@ -683,7 +781,7 @@ export function createUsageTracker({ store, config, pricing, now = Date.now, flu
     summaryDirty = false
     lastPruneDay = ''
     const { removed } = store.clearUsage()
-    summary = store.readUsageSummary()
+    summary = store.readUsageSummary().summary
     // The store stamps the new window with its own `Date.now()`; the tracker's
     // injected clock is the one every other timestamp here comes from.
     summary.trackingSince = now()

package/lib/workspace.js

@@ -0,0 +1,62 @@
+import fs from 'node:fs'
+import path from 'node:path'
+
+/**
+ * The identity of a workspace: the absolute directory with `..` resolved, a
+ * trailing separator stripped and symlinks followed when it exists on disk.
+ * Case is left alone. '' when there is no directory.
+ */
+export function normalizeWorkspace(raw) {
+  if (typeof raw !== 'string' || raw.length === 0) return ''
+  const resolved = path.resolve(raw)
+  try {
+    return fs.realpathSync(resolved)
+  } catch {
+    return resolved
+  }
+}
+
+/** Whether `cwd` is `scope` itself or a directory inside it — by path segment, never by string prefix. */
+export function workspaceContains(scope, cwd) {
+  if (typeof scope !== 'string' || scope.length === 0 || typeof cwd !== 'string') return false
+  if (cwd === scope) return true
+  const base = /[\\/]$/.test(scope) ? scope.slice(0, -1) : scope
+  return cwd.startsWith(base + '/') || cwd.startsWith(base + '\\')
+}
+
+/** The last path segment of a workspace directory — what a person calls the project. */
+export function workspaceLabel(cwd) {
+  if (typeof cwd !== 'string' || cwd.length === 0) return ''
+  const parts = cwd.split(/[\\/]+/).filter((part) => part.length > 0)
+  return parts.length > 0 ? parts[parts.length - 1] : ''
+}
+
+/**
+ * A distinct label per workspace, in insertion order: the basename, extended by
+ * one more parent segment at a time (`a/web`, `b/web`) while two of them would
+ * read the same, up to the full path.
+ */
+export function workspaceLabels(cwds) {
+  const distinct = [...new Set((Array.isArray(cwds) ? cwds : []).filter((cwd) => typeof cwd === 'string' && cwd.length > 0))]
+  const segments = new Map(distinct.map((cwd) => [cwd, cwd.split(/[\\/]+/).filter((part) => part.length > 0)]))
+  const depth = new Map(distinct.map((cwd) => [cwd, 1]))
+  const labelOf = (cwd) => segments.get(cwd).slice(-depth.get(cwd)).join('/')
+  for (;;) {
+    const groups = new Map()
+    for (const cwd of distinct) {
+      const label = labelOf(cwd)
+      if (groups.has(label)) groups.get(label).push(cwd)
+      else groups.set(label, [cwd])
+    }
+    let grew = false
+    for (const group of groups.values()) {
+      if (group.length < 2) continue
+      for (const cwd of group) {
+        if (depth.get(cwd) >= segments.get(cwd).length) continue
+        depth.set(cwd, depth.get(cwd) + 1)
+        grew = true
+      }
+    }
+    if (!grew) return new Map(distinct.map((cwd) => [cwd, labelOf(cwd)]))
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-tacit",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "Tacit learns what you leave unsaid in your prompts — from messy turns and your own corrections, with zero clicks — and tells the agent how to compensate, on every turn, via a system-prompt section you can read and edit.",
   "author": "hackernotfound",
   "license": "MIT",