dsh-tacit 0.3.0 → 0.4.0

package/lib/service.js

@@ -80,12 +80,13 @@ import {
   DIRECTIVE_TOOL,
   DIRECTIVE_MAX_TOKENS,
   DIRECTIVE_TIMEOUT_MS,
-  MAX_DIRECTIVES,
   buildDirectiveUserText,
   buildSteeringSection,
   renderSteeringSection,
   workspaceLabel,
-  MAX_WORKSPACE_DIRECTIVES,
+  scopeOf,
+  capDirectives,
+  mergeDirectives,
   ENRICH_SYSTEM_PROMPT,
   ENRICH_TOOL,
   ENRICH_MAX_TOKENS,
@@ -96,6 +97,7 @@ import {
   buildEnrichUserText,
   normalizeEnrichNote,
   computeTrend,
+  markCorrections,
 } from './analyze.js'
 
 /** In-memory rewrite ledger bounds (never persisted). */
@@ -185,21 +187,6 @@ function listWorkspaces(service) {
   return [...seen.values()].sort((a, b) => a.label.localeCompare(b.label))
 }
 
-/** At most MAX_DIRECTIVES global directives and MAX_WORKSPACE_DIRECTIVES per workspace, order kept. */
-function capDirectives(list) {
-  const counts = new Map()
-  const out = []
-  for (const entry of list) {
-    const scope = typeof entry.workspace === 'string' && entry.workspace.length > 0 ? entry.workspace : ''
-    const limit = scope === '' ? MAX_DIRECTIVES : MAX_WORKSPACE_DIRECTIVES
-    const n = counts.get(scope) ?? 0
-    if (n >= limit) continue
-    counts.set(scope, n + 1)
-    out.push(entry)
-  }
-  return out
-}
-
 /** Short, secret-free context digest of a session's last two finished turns. */
 function recentContextOf(turns) {
   const finished = (Array.isArray(turns) ? turns : []).filter((turn) => turn?.finished === true).slice(-2)
@@ -265,6 +252,9 @@ function coachErrorCode(error) {
   const text = raw + ' ' + message
   if (/abort|timeout/i.test(text)) return 'timeout'
   if (/auth|401|403|api[ _-]?key|key not/i.test(text)) return 'no-api-key'
+  // Ahead of the rate-limit rule: an exhausted balance says "quota" too, but
+  // it will not clear by waiting, so it must not read as "try again shortly".
+  if (/\binsufficient[ _-]?(quota|balance|credit)|\bexceeded your current quota/i.test(text)) return 'no-credit'
   // Word-bounded: a bare /rate/ matches the "rate" inside "generate", and the
   // ladder now sees the raw code and message of every provider failure. A
   // trailing \b after "quota" would not do here — `_` is a word character, so
@@ -437,26 +427,32 @@ export function createCoachService(ctx, store, effectiveConfig) {
     handleVerification(sessionId, turns)
   }
 
-  /** Finished turns already counted toward directive trials (sessionId:turn). */
+  /** Finished turns already counted toward directive trials, and turns already counted as corrected (sessionId:turn). */
   const seenFinished = new Set()
+  const seenCorrected = new Set()
 
   const pct = (rate) => String(Math.round(rate * 100)) + '%'
 
   /**
    * Directive trials ride the same free feed: every NEW finished turn counts
    * toward each candidate that was actually in that session's frozen steering
-   * text; after `directiveTrialTurns` such turns the candidate is activated,
-   * or retired when the messy rate rose past the baseline by more than
-   * `directiveWorseBy`. A session whose steering was never assembled here
-   * (started before the candidate existed, or before a restart) counts toward
-   * nobody — its turns say nothing about the candidate.
+   * text, and so does every correction of such a turn (the session's next
+   * prompt, known the moment it starts). After `directiveTrialTurns` turns the
+   * candidate is retired when its correction rate rose past the baseline by
+   * more than `directiveWorseBy` (or its messy rate by twice that), otherwise
+   * activated. A session whose steering was never assembled here (started
+   * before the candidate existed, or before a restart) counts toward nobody —
+   * its turns say nothing about the candidate.
    */
   const recordTrialTurns = (sessionId, turns) => {
-    const fresh = (Array.isArray(turns) ? turns : []).filter((turn) => turn !== null && typeof turn === 'object'
-      && turn.finished === true && typeof turn.turn === 'number' && typeof turn.endedAt === 'number' && turn.endedAt >= pluginStartedAt
-      && !seenFinished.has(sessionId + ':' + turn.turn))
-    if (fresh.length === 0) return
-    for (const turn of fresh) seenFinished.add(sessionId + ':' + turn.turn)
+    const key = (turn) => sessionId + ':' + turn.turn
+    const counted = markCorrections(turns).filter((turn) => typeof turn.turn === 'number' && turn.finished === true
+      && typeof turn.endedAt === 'number' && turn.endedAt >= pluginStartedAt)
+    const fresh = counted.filter((turn) => !seenFinished.has(key(turn)))
+    const corrected = counted.filter((turn) => turn.corrected && !seenCorrected.has(key(turn)))
+    for (const turn of fresh) seenFinished.add(key(turn))
+    for (const turn of corrected) seenCorrected.add(key(turn))
+    if (fresh.length === 0 && corrected.length === 0) return
     const steered = steeringIdsBySession.get(sessionId)
     if (steered === undefined || steered.length === 0) return
     const profile = safeProfile()
@@ -464,21 +460,33 @@ export function createCoachService(ctx, store, effectiveConfig) {
     if (candidates.length === 0) return
     const config = effectiveConfig()
     const messyCount = fresh.filter((turn) => isMessyTurn(turn, { minSteps: Number.POSITIVE_INFINITY })).length
+    let verdicts = 0
     for (const entry of candidates) {
-      entry.trial.turns += fresh.length
-      entry.trial.messy += messyCount
-      if (entry.trial.turns < config.directiveTrialTurns) continue
-      const rate = entry.trial.messy / entry.trial.turns
-      if (rate > entry.trial.baselineRate + config.directiveWorseBy) {
+      const trial = entry.trial
+      if (trial.baselineCorrectionRate < 0) trial.baselineCorrectionRate = baselinesFor(scopeOf(entry)).baselineCorrectionRate
+      trial.turns += fresh.length
+      trial.messy += messyCount
+      trial.corrected += corrected.length
+      if (trial.turns < config.directiveTrialTurns) continue
+      const correctionRate = trial.corrected / trial.turns
+      const messyRate = trial.messy / trial.turns
+      const worse = correctionRate > trial.baselineCorrectionRate + config.directiveWorseBy
+        ? 'corrections ' + pct(trial.baselineCorrectionRate) + ' → ' + pct(correctionRate)
+        : messyRate > trial.baselineMessyRate + 2 * config.directiveWorseBy
+          ? 'messy turns ' + pct(trial.baselineMessyRate) + ' → ' + pct(messyRate)
+          : null
+      verdicts += 1
+      if (worse !== null) {
         entry.status = 'retired'
         entry.enabled = false
-        entry.retiredReason = 'messy turns ' + pct(entry.trial.baselineRate) + ' → ' + pct(rate) + ' while active'
+        entry.retiredReason = worse + ' while active'
         console.info('[tacit] retired directive (' + entry.retiredReason + '): ' + entry.text)
       } else {
         entry.status = 'active'
-        console.info('[tacit] activated directive (messy turns ' + pct(entry.trial.baselineRate) + ' → ' + pct(rate) + '): ' + entry.text)
+        console.info('[tacit] activated directive (corrections ' + pct(trial.baselineCorrectionRate) + ' → ' + pct(correctionRate) + '): ' + entry.text)
       }
     }
+    if (verdicts > 0) startNextTrial(profile)
     capAndSaveProfile(profile)
   }
 
@@ -689,64 +697,28 @@ export function createCoachService(ctx, store, effectiveConfig) {
     return frozen.text
   }
 
-  /**
-   * Replace the distilled directives with the model's new complete set; user
-   * entries are untouched, and a re-emitted directive keeps the enabled flag
-   * the user gave its identical text. Capped at MAX_DIRECTIVES overall.
-   */
-  const scopeOf = (entry) => (typeof entry.workspace === 'string' && entry.workspace.length > 0 ? entry.workspace : '')
-  const directiveKey = (scope, text) => scope + '\n' + text.trim().toLowerCase()
-
-  /** Messy-turn baseline for a new candidate: the workspace's own turns when there are enough, else everything. */
-  const baselineRateFor = (cwd) => {
-    const scoped = cwd !== undefined ? allFinishedTurns({ cwd }) : []
+  /** Baselines for a new trial: the workspace's own turns when there are enough, else everything. */
+  const baselinesFor = (scope) => {
+    const scoped = scope !== '' ? allFinishedTurns({ cwd: scope }) : []
     const turns = scoped.length >= 20 ? scoped : allFinishedTurns()
-    return computeTrend(turns, { window: 20 }).recent.messyRate
+    const { messyRate, correctionRate } = computeTrend(turns, { window: 20 }).recent
+    return { baselineMessyRate: messyRate, baselineCorrectionRate: correctionRate }
   }
 
   /**
-   * Merge the model's new complete set of directives ({ text, workspace? }):
-   * user entries are untouched; the global distilled set and the distilled set
-   * of every workspace the model mentioned are replaced; distilled entries of
-   * other workspaces are kept (their evidence was not in this batch). A
-   * re-emitted directive keeps its identity, state and enabled flag.
+   * One trial per scope at a time: wherever no candidate is on trial, the
+   * oldest enabled queued directive of that scope starts its trial now, with
+   * baselines measured at this moment. Idempotent.
    */
-  const mergeDirectives = (profile, items) => {
-    const users = profile.directives.filter((entry) => entry.source === 'user')
-    const userKeys = new Set(users.map((entry) => directiveKey(scopeOf(entry), entry.text)))
-    const prior = profile.directives.filter((entry) => entry.source !== 'user')
-    const previous = new Map(prior.map((entry) => [directiveKey(scopeOf(entry), entry.text), entry]))
-    const mentioned = new Set([''])
-    for (const item of items) mentioned.add(scopeOf(item))
-    const untouched = prior.filter((entry) => !mentioned.has(scopeOf(entry)))
-    const distilled = []
-    const seen = new Set()
-    const baselines = new Map()
-    for (const item of items) {
-      const scope = scopeOf(item)
-      const key = directiveKey(scope, item.text)
-      if (seen.has(key) || userKeys.has(key)) continue
-      seen.add(key)
-      const kept = previous.get(key)
-      if (kept !== undefined) {
-        distilled.push({ ...kept, text: item.text })
-        continue
-      }
-      // A new distilled directive goes on trial against the current messy-turn rate.
-      if (!baselines.has(scope)) baselines.set(scope, baselineRateFor(scope === '' ? undefined : scope))
-      distilled.push({
-        id: nextDirectiveId(),
-        text: item.text,
-        enabled: true,
-        source: 'distilled',
-        createdAt: Date.now(),
-        status: 'candidate',
-        trial: { turns: 0, messy: 0, baselineRate: baselines.get(scope), startedAt: Date.now() },
-        ...(scope === '' ? {} : { workspace: scope }),
-      })
+  const startNextTrial = (profile) => {
+    const busy = new Set(profile.directives.filter((entry) => entry.status === 'candidate').map(scopeOf))
+    for (const entry of profile.directives) {
+      if (entry.status !== 'queued' || entry.enabled === false || busy.has(scopeOf(entry))) continue
+      busy.add(scopeOf(entry))
+      entry.status = 'candidate'
+      entry.trial = { turns: 0, messy: 0, corrected: 0, ...baselinesFor(scopeOf(entry)), startedAt: Date.now() }
+      console.info('[tacit] directive on trial: ' + entry.text)
     }
-    profile.directives = capDirectives([...users, ...distilled, ...untouched])
-    return profile
   }
 
   /** ONE small call every `directiveEvery` new analyses (or forced). Soft-fails; never throws. */
@@ -785,10 +757,13 @@ export function createCoachService(ctx, store, effectiveConfig) {
         console.warn('[tacit] directive distillation returned nothing usable; will retry after the next analysis:', clipSafe(text, 300))
         return
       }
-      const items = kept.map((item) => (item.workspace !== undefined && workspaces.has(item.workspace)
-        ? { text: item.text, workspace: workspaces.get(item.workspace) }
-        : { text: item.text }))
-      profile = mergeDirectives(safeProfile(), items)
+      const items = kept.map((item) => ({
+        text: item.text,
+        ...(item.id === undefined ? {} : { id: item.id }),
+        ...(item.workspace !== undefined && workspaces.has(item.workspace) ? { workspace: workspaces.get(item.workspace) } : {}),
+      }))
+      profile = mergeDirectives(safeProfile(), items, { nextId: nextDirectiveId })
+      startNextTrial(profile)
       profile.analysesSinceDirectives = 0
       capAndSaveProfile(profile)
       const scoped = items.filter((item) => item.workspace !== undefined).length
@@ -858,7 +833,7 @@ export function createCoachService(ctx, store, effectiveConfig) {
       if (session === null || typeof session !== 'object' || typeof session.id !== 'string') continue
       if (cwd !== undefined && cwdOf(session) !== cwd) continue
       const { turns } = turnsOf(svc, session.id)
-      for (const turn of turns) if (turn?.finished === true) out.push(turn)
+      for (const turn of markCorrections(turns)) if (turn.finished === true) out.push(turn)
     }
     return out
   }
@@ -868,6 +843,19 @@ export function createCoachService(ctx, store, effectiveConfig) {
    *  deliberately not named `tokens`, which everywhere else in the ledger is the five-bucket object. */
   const bootstrapState = { running: false, done: 0, total: 0, startedAt: 0, runId: '', billedCalls: 0, unpricedCalls: 0, usdKnown: 0, tokensTotal: 0 }
 
+  /** Back to "no bootstrap has run": every field, so a no-op never shows the previous batch's figures. */
+  const resetBootstrapState = () => {
+    bootstrapState.running = false
+    bootstrapState.done = 0
+    bootstrapState.total = 0
+    bootstrapState.startedAt = 0
+    bootstrapState.runId = ''
+    bootstrapState.billedCalls = 0
+    bootstrapState.unpricedCalls = 0
+    bootstrapState.usdKnown = 0
+    bootstrapState.tokensTotal = 0
+  }
+
   /** Mirror the bootstrap run's live counters into the state the panel polls. */
   const refreshBootstrapUsage = () => {
     const summary = bootstrapState.runId === '' ? null : usage.runSummary(bootstrapState.runId)
@@ -967,6 +955,7 @@ export function createCoachService(ctx, store, effectiveConfig) {
     // Nothing to analyze is a no-op, not a run: an empty run would be written
     // to the ledger as `failed` (no attempts) and read as a broken bootstrap.
     if (eligible.length === 0) {
+      resetBootstrapState()
       return { ok: true, analyzed: 0, skipped, directives: safeProfile().directives.length, code: '', detail: '', run: null }
     }
     const config = effectiveConfig()
@@ -980,15 +969,11 @@ export function createCoachService(ctx, store, effectiveConfig) {
       model: config.model,
       provider: scopedToSession ? providerForSession(sessionId) : COACH_PROVIDER,
     })
+    resetBootstrapState()
     bootstrapState.running = true
-    bootstrapState.done = 0
     bootstrapState.total = eligible.length
     bootstrapState.startedAt = Date.now()
     bootstrapState.runId = runId
-    bootstrapState.billedCalls = 0
-    bootstrapState.unpricedCalls = 0
-    bootstrapState.usdKnown = 0
-    bootstrapState.tokensTotal = 0
     let analyzed = 0
     try {
       // A small worker pool: each worker pulls the next eligible turn until the
@@ -1019,6 +1004,9 @@ export function createCoachService(ctx, store, effectiveConfig) {
       bootstrapState.running = false
       closeRun(runId, { requested: limit, eligible: eligible.length, analyzed, skipped, directives: safeProfile().directives.length })
       refreshBootstrapUsage()
+      // Mirror the final counters first, then drop the id: the tile keeps the
+      // finished run's figures, but nothing may still call it the live run.
+      bootstrapState.runId = ''
     }
     return { ok: true, analyzed, skipped, directives: safeProfile().directives.length, code: '', detail: '', run: usage.runSummary(runId) }
   }
@@ -1390,6 +1378,7 @@ export function createCoachService(ctx, store, effectiveConfig) {
       } else {
         profile.directives = profile.directives.filter((entry) => entry.id !== input.id)
       }
+      startNextTrial(profile)
       const saved = capAndSaveProfile(profile)
       return { ok: true, profile: saved, steering: steeringStatus(), code: '', detail: '' }
     },

package/lib/store.js

@@ -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)))
@@ -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,11 +23,9 @@
  * 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']
 /** Finished runs kept addressable for `runSummary()` after they leave `live`. */
 const MAX_REMEMBERED_RUNS = 50
@@ -35,6 +33,8 @@ 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 +42,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,6 +60,24 @@ 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 }
 }
@@ -158,7 +185,7 @@ 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,
@@ -202,22 +229,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 +267,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,12 +342,12 @@ 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)
 
@@ -344,7 +383,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)
@@ -523,6 +562,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 +610,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()
@@ -612,10 +666,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
 
@@ -683,7 +738,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-tacit",
-  "version": "0.3.0",
+  "version": "0.4.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",