dsh-tacit 0.4.0 → 0.6.0

package/lib/service.js

@@ -32,6 +32,7 @@ import {
   bootstrapArgSchema,
   usageArgSchema,
   usageRunArgSchema,
+  directiveReceiptArgSchema,
 } from './schema.js'
 import { dayKey } from './store.js'
 import { createUsageTracker, totalTokens } from './usage.js'
@@ -71,22 +72,26 @@ import {
   ANALYSIS_TOOL,
   IMPROVE_TOOL,
   DISTILL_TOOL,
+  POLICY_RE,
   clipSafe,
   isMessyTurn,
   looksLikeCorrection,
   looksLikeContinuation,
+  looksLikeJobNotification,
   classifyDirectives,
   DIRECTIVE_SYSTEM_PROMPT,
   DIRECTIVE_TOOL,
   DIRECTIVE_MAX_TOKENS,
   DIRECTIVE_TIMEOUT_MS,
   buildDirectiveUserText,
+  directiveLabels,
   buildSteeringSection,
   renderSteeringSection,
-  workspaceLabel,
   scopeOf,
   capDirectives,
   mergeDirectives,
+  isDeadDirective,
+  MAX_DIRECTIVE_EVIDENCE,
   ENRICH_SYSTEM_PROMPT,
   ENRICH_TOOL,
   ENRICH_MAX_TOKENS,
@@ -99,6 +104,7 @@ import {
   computeTrend,
   markCorrections,
 } from './analyze.js'
+import { normalizeWorkspace, workspaceContains, workspaceLabel, workspaceLabels } from './workspace.js'
 
 /** In-memory rewrite ledger bounds (never persisted). */
 const MAX_REWRITE_RECORDS = 50
@@ -162,12 +168,13 @@ function turnsOf(service, sessionId) {
   }
 }
 
-/** The absolute workspace directory a session was created in, else undefined. */
+/** The normalised workspace directory a session was created in, else undefined. */
 function cwdOf(session) {
   const cwd = session !== null && typeof session === 'object' && session.header !== null && typeof session.header === 'object'
     ? session.header.cwd
     : undefined
-  return typeof cwd === 'string' && cwd.length > 0 ? cwd : undefined
+  const workspace = normalizeWorkspace(cwd)
+  return workspace.length > 0 ? workspace : undefined
 }
 
 /** A human label for a session: the workspace directory's basename, else ''. */
@@ -179,17 +186,30 @@ function sessionLabelOf(service, sessionId) {
 /** Every distinct workspace among the live sessions, labelled for the UI. */
 function listWorkspaces(service) {
   const sessions = typeof service.sessions?.list === 'function' ? service.sessions.list() : []
-  const seen = new Map()
-  for (const session of Array.isArray(sessions) ? sessions : []) {
-    const cwd = cwdOf(session)
-    if (cwd !== undefined && !seen.has(cwd)) seen.set(cwd, { cwd, label: workspaceLabel(cwd) })
-  }
-  return [...seen.values()].sort((a, b) => a.label.localeCompare(b.label))
+  const cwds = (Array.isArray(sessions) ? sessions : []).map(cwdOf).filter((cwd) => cwd !== undefined)
+  return [...workspaceLabels(cwds)]
+    .map(([cwd, label]) => ({ cwd, label }))
+    .sort((a, b) => a.label.localeCompare(b.label))
+}
+
+/** The `workspaceSeenAt` map narrowed to the workspaces a directive still points at. */
+function pruneSeenAt(seenAt, directives) {
+  const scopes = new Set(directives.map(scopeOf))
+  return Object.fromEntries(Object.entries(seenAt).filter(([scope]) => scopes.has(scope)))
 }
 
-/** Short, secret-free context digest of a session's last two finished turns. */
+/**
+ * Bounded context of the last two turns the user actually wrote, read from the
+ * digest. Background-job notifications and bare continuations are finished
+ * turns too, and one of them landing after the last real exchange would
+ * otherwise hide the facts the rewrite needs.
+ */
 function recentContextOf(turns) {
-  const finished = (Array.isArray(turns) ? turns : []).filter((turn) => turn?.finished === true).slice(-2)
+  const written = (turn) => {
+    const prompt = typeof turn.prompt === 'string' ? turn.prompt.trim() : ''
+    return prompt.length > 0 && !looksLikeJobNotification(prompt) && !looksLikeContinuation(prompt)
+  }
+  const finished = (Array.isArray(turns) ? turns : []).filter((turn) => turn?.finished === true && written(turn)).slice(-2)
   if (finished.length === 0) return ''
   return finished.map((turn) => {
     const prompt = typeof turn.prompt === 'string' ? turn.prompt.slice(0, 600) : ''
@@ -300,9 +320,15 @@ export function createCoachService(ctx, store, effectiveConfig) {
 
   const safeProfile = () => {
     const parsed = profileSchema.safeParse(store.profile())
-    return parsed.success
-      ? parsed.data
-      : { analyzedCount: 0, patterns: [], updatedAt: 0, styleRules: [], feedbackLog: [], pendingDistill: 0, directives: [], analysesSinceDirectives: 0 }
+    if (!parsed.success) {
+      return { analyzedCount: 0, patterns: [], updatedAt: 0, styleRules: [], feedbackLog: [], pendingDistill: 0, directives: [], analysesSinceDirectives: 0, workspaceSeenAt: {} }
+    }
+    for (const entry of parsed.data.directives) {
+      const workspace = normalizeWorkspace(entry.workspace)
+      if (workspace.length > 0) entry.workspace = workspace
+      else delete entry.workspace
+    }
+    return parsed.data
   }
   let directiveSeq = 0
   const nextDirectiveId = () => {
@@ -311,7 +337,9 @@ export function createCoachService(ctx, store, effectiveConfig) {
   }
   let directivesInFlight = false
   /** Steering `{ text, ids }` frozen per live session object (keeps the model's prefix cache stable within a session). */
-  const steeringFrozen = new WeakMap()
+  let steeringFrozen = new WeakMap()
+  /** Forget every open session's frozen steering: the next assembly re-freezes from the profile as it is now. */
+  const invalidateSteering = () => { steeringFrozen = new WeakMap() }
 
   const nextRewriteId = () => {
     rewriteSeq += 1
@@ -341,13 +369,24 @@ export function createCoachService(ctx, store, effectiveConfig) {
     return profile
   }
 
+  /** The normalised workspace of every session loaded right now. */
+  const liveCwds = () => listWorkspaces(serviceOf(ctx)).map((entry) => entry.cwd)
+
   /** Bound every v2 field, validate, persist; returns the stored profile. */
   const capAndSaveProfile = (profile) => {
     const config = effectiveConfig()
     profile.patterns = profile.patterns.slice(0, config.maxPatterns)
     profile.styleRules = profile.styleRules.slice(-MAX_STYLE_RULES)
     profile.feedbackLog = profile.feedbackLog.slice(-MAX_FEEDBACK_LOG)
-    profile.directives = capDirectives(profile.directives)
+    const cwds = liveCwds()
+    const seenAt = profile.workspaceSeenAt ?? {}
+    for (const entry of profile.directives) {
+      const scope = scopeOf(entry)
+      if (scope !== '' && cwds.some((cwd) => workspaceContains(scope, cwd))) seenAt[scope] = Date.now()
+    }
+    profile.workspaceSeenAt = pruneSeenAt(seenAt, profile.directives)
+    profile.directives = capDirectives(profile.directives, { seenAt: profile.workspaceSeenAt })
+    profile.workspaceSeenAt = pruneSeenAt(profile.workspaceSeenAt, profile.directives)
     profile.updatedAt = Date.now()
     const validated = profileSchema.parse(profile)
     store.saveProfile(validated)
@@ -471,15 +510,17 @@ export function createCoachService(ctx, store, effectiveConfig) {
       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)
+        ? 'corrections rose ' + pct(trial.baselineCorrectionRate) + ' → ' + pct(correctionRate)
         : messyRate > trial.baselineMessyRate + 2 * config.directiveWorseBy
-          ? 'messy turns ' + pct(trial.baselineMessyRate) + ' → ' + pct(messyRate)
+          ? 'messy turns rose ' + pct(trial.baselineMessyRate) + ' → ' + pct(messyRate)
           : null
       verdicts += 1
+      entry.evaluatedAt = Date.now()
+      entry.updatedAt = entry.evaluatedAt
       if (worse !== null) {
         entry.status = 'retired'
         entry.enabled = false
-        entry.retiredReason = worse + ' while active'
+        entry.retiredReason = worse + ' during its trial'
         console.info('[tacit] retired directive (' + entry.retiredReason + '): ' + entry.text)
       } else {
         entry.status = 'active'
@@ -527,7 +568,7 @@ export function createCoachService(ctx, store, effectiveConfig) {
     return earlier.length > 0 ? earlier[earlier.length - 1] : null
   }
 
-  const runAnalysis = (sessionId, turn, { trigger = 'manual', followUp = '', digest = null, previousDigest = null, runId = '' } = {}) => {
+  const runAnalysis = (sessionId, turn, { trigger = 'manual', followUp = '', digest = null, previousDigest = null, runId = '', force = false } = {}) => {
     const profile = safeProfile()
     const key = `${sessionId}:${turn}`
     /** The run this analysis is billed to: the caller's batch run, or one of its own. Stays '' on a soft refusal. */
@@ -547,6 +588,10 @@ export function createCoachService(ctx, store, effectiveConfig) {
       if (trigger === 'manual' && looksLikeContinuation(record.prompt)) {
         return { ok: false, report: null, profile, code: 'continuation', detail: '' }
       }
+      // A report already exists: a second paid look at the same turn only on request.
+      if (trigger === 'manual' && !force && store.report(sessionId, turn) !== null) {
+        return { ok: false, report: null, profile, code: 'already-analyzed', detail: '' }
+      }
       const previous = previousDigest !== null && typeof previousDigest === 'object' ? previousDigest : previousFinishedOf(turns, turn)
       const userText = buildAnalysisUserText(record, { followUp, previous })
       if (userText === null) return { ok: false, report: null, profile, code: 'not-retained', detail: '' }
@@ -686,6 +731,9 @@ export function createCoachService(ctx, store, effectiveConfig) {
     if (session === null || session === undefined || typeof session !== 'object') return steeringNow().text
     let frozen = steeringFrozen.get(session)
     if (frozen === undefined) {
+      // A workspace seen for the first time may revive a paused trial.
+      const profile = safeProfile()
+      if (startNextTrial(profile)) capAndSaveProfile(profile)
       frozen = steeringNow(cwdOf(session))
       steeringFrozen.set(session, frozen)
       if (typeof session.id === 'string' && session.id.length > 0) {
@@ -706,19 +754,39 @@ export function createCoachService(ctx, store, effectiveConfig) {
   }
 
   /**
-   * 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.
+   * One trial per scope at a time, and only in a workspace some session is
+   * loaded in: a candidate whose workspace is gone goes back to the queue and
+   * frees the slot, then the oldest enabled queued directive of every free
+   * seen scope starts its trial now, with baselines measured at this moment.
+   * Idempotent; returns whether any status changed.
    */
   const startNextTrial = (profile) => {
+    const cwds = liveCwds()
+    const seen = new Set([''])
+    for (const entry of profile.directives) {
+      const scope = scopeOf(entry)
+      if (scope !== '' && cwds.some((cwd) => workspaceContains(scope, cwd))) seen.add(scope)
+    }
+    let changed = false
+    for (const entry of profile.directives) {
+      if (entry.status !== 'candidate' || seen.has(scopeOf(entry))) continue
+      entry.status = 'queued'
+      delete entry.trial
+      changed = true
+      console.info('[tacit] trial paused, workspace not loaded: ' + entry.text)
+    }
+    const review = effectiveConfig().reviewCandidates === true
     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
+      if (entry.status !== 'queued' || entry.enabled === false || busy.has(scopeOf(entry)) || !seen.has(scopeOf(entry))) continue
+      if (review && entry.source !== 'user' && !(entry.approvedAt > 0)) continue
       busy.add(scopeOf(entry))
       entry.status = 'candidate'
       entry.trial = { turns: 0, messy: 0, corrected: 0, ...baselinesFor(scopeOf(entry)), startedAt: Date.now() }
+      changed = true
       console.info('[tacit] directive on trial: ' + entry.text)
     }
+    return changed
   }
 
   /** ONE small call every `directiveEvery` new analyses (or forced). Soft-fails; never throws. */
@@ -733,19 +801,19 @@ export function createCoachService(ctx, store, effectiveConfig) {
       ? usage.beginRun({ type: 'directive-distillation', trigger: 'auto', sessionId, model: config.model, provider })
       : runId
     try {
-      const recent = store.listAllReports(20).map((entry) => store.report(entry.sessionId, entry.turn)).filter((report) => report !== null)
+      const recent = store.listAllReports(20)
+        .map((entry) => ({ ...store.report(entry.sessionId, entry.turn), sessionId: entry.sessionId, turn: entry.turn }))
+        .filter((report) => report.ok !== undefined || typeof report.problems === 'object')
+      // Newest first, before the prompt builder reverses the list for the model.
+      const evidence = recent.slice(0, MAX_DIRECTIVE_EVIDENCE).map((report) => ({ sessionId: report.sessionId, turn: report.turn, trigger: typeof report.trigger === 'string' ? report.trigger : 'manual' }))
       // The model sees workspace names only; map them back to the directories they stand for.
-      const workspaces = new Map()
-      for (const report of recent) {
-        if (typeof report.cwd !== 'string' || report.cwd.length === 0) continue
-        const label = workspaceLabel(report.cwd)
-        if (label.length > 0 && !workspaces.has(label)) workspaces.set(label, report.cwd)
-      }
+      const labels = directiveLabels(profile, recent)
+      const workspaces = new Map([...labels].map(([cwd, label]) => [label, cwd]))
       const text = await callCoachModel(ctx, metered(usageRunId, { op: 'directive-distillation', sessionId }, {
         provider,
         model: config.model,
         system: DIRECTIVE_SYSTEM_PROMPT,
-        userText: buildDirectiveUserText(profile, recent.reverse()),
+        userText: buildDirectiveUserText(profile, recent.reverse(), { labels }),
         maxTokens: DIRECTIVE_MAX_TOKENS,
         timeoutMs: DIRECTIVE_TIMEOUT_MS,
         tool: DIRECTIVE_TOOL,
@@ -757,12 +825,31 @@ 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) => ({
-        text: item.text,
-        ...(item.id === undefined ? {} : { id: item.id }),
-        ...(item.workspace !== undefined && workspaces.has(item.workspace) ? { workspace: workspaces.get(item.workspace) } : {}),
-      }))
+      const items = []
+      for (const item of kept) {
+        if (item.workspace !== undefined && !workspaces.has(item.workspace)) {
+          console.info('[tacit] dropped directive (its workspace "' + item.workspace + '" is not one the evidence came from):', item.text)
+          continue
+        }
+        items.push({
+          text: item.text,
+          ...(item.id === undefined ? {} : { id: item.id }),
+          ...(item.workspace === undefined ? {} : { workspace: workspaces.get(item.workspace) }),
+        })
+      }
+      if (items.length === 0) return
+      const before = new Map(safeProfile().directives.map((entry) => [entry.id, entry.text]))
       profile = mergeDirectives(safeProfile(), items, { nextId: nextDirectiveId })
+      const now = Date.now()
+      for (const entry of profile.directives) {
+        if (entry.source === 'user' || isDeadDirective(entry)) continue
+        const previous = before.get(entry.id)
+        if (previous === entry.text) continue
+        if (previous !== undefined) entry.version = (entry.version ?? 1) + 1
+        entry.updatedAt = now
+        entry.evidence = evidence
+        entry.distillationRunId = usageRunId
+      }
       startNextTrial(profile)
       profile.analysesSinceDirectives = 0
       capAndSaveProfile(profile)
@@ -1019,7 +1106,7 @@ export function createCoachService(ctx, store, effectiveConfig) {
    * an auto trigger or another batch — reports `busy` and costs nothing. A
    * bootstrap running elsewhere does NOT block the batch.
    */
-  const analyzeBatch = async ({ sessionId, turns }) => {
+  const analyzeBatch = async ({ sessionId, turns, force = false }) => {
     const { session } = turnsOf(serviceOf(ctx), sessionId)
     if (session === undefined) return { ok: false, results: [], profile: safeProfile(), run: null, code: 'no-session', detail: '' }
     const wanted = [...new Set(turns)].sort((a, b) => a - b)
@@ -1043,7 +1130,7 @@ export function createCoachService(ctx, store, effectiveConfig) {
           const at = next
           next += 1
           const turn = wanted[at]
-          const result = await runAnalysis(sessionId, turn, { trigger: 'manual', runId })
+          const result = await runAnalysis(sessionId, turn, { trigger: 'manual', runId, force })
           const ok = result !== null && typeof result === 'object' && result.ok === true
           if (ok) analyzed += 1
           results[at] = { turn, ok, code: result?.code ?? 'call-failed', report: ok ? result.report : null }
@@ -1056,8 +1143,8 @@ export function createCoachService(ctx, store, effectiveConfig) {
       // made and nothing failed, so this is a real request that succeeded —
       // not the zero-attempt `failed` run the default derivation would write.
       const entries = results.filter((entry) => entry !== null && entry !== undefined)
-      const allBusy = analyzed === 0 && entries.length === wanted.length && entries.every((entry) => entry.code === 'busy')
-      closeRun(runId, { requested: wanted.length, analyzed, skipped: wanted.length - analyzed }, allBusy ? 'success' : undefined)
+      const allSkipped = analyzed === 0 && entries.length === wanted.length && entries.every((entry) => entry.code === 'busy' || entry.code === 'already-analyzed')
+      closeRun(runId, { requested: wanted.length, analyzed, skipped: wanted.length - analyzed }, allSkipped ? 'success' : undefined)
     }
     return { ok: true, results, profile: safeProfile(), run: usage.runSummary(runId), code: '', detail: '' }
   }
@@ -1189,7 +1276,7 @@ export function createCoachService(ctx, store, effectiveConfig) {
       if (!parsed.success) {
         return { ok: false, report: null, profile: safeProfile(), code: 'bad-request', detail: '', run: null }
       }
-      return runAnalysis(parsed.data.sessionId, parsed.data.turn, { trigger: 'manual' })
+      return runAnalysis(parsed.data.sessionId, parsed.data.turn, { trigger: 'manual', force: parsed.data.force === true })
     },
 
     /** Analyze a hand-picked set of turns of one session under a single run. */
@@ -1365,18 +1452,51 @@ export function createCoachService(ctx, store, effectiveConfig) {
         const found = profile.directives.find((entry) => entry.id === input.id)
         if (found === undefined) return { ok: false, profile, steering: steeringStatus(), code: 'bad-request', detail: 'id' }
         found.enabled = input.enabled
+        found.updatedAt = Date.now()
         // Re-enabling a retired directive is an explicit override.
         if (input.enabled && found.status === 'retired') {
           found.status = 'active'
           delete found.retiredReason
         }
+        // A candidate is always enabled: switched off, it leaves the trial slot and queues again.
+        if (!input.enabled && found.status === 'candidate') {
+          found.status = 'queued'
+          delete found.trial
+        }
+        if (!input.enabled) invalidateSteering()
+      } else if (input.action === 'start-trial') {
+        const found = profile.directives.find((entry) => entry.id === input.id)
+        if (found === undefined || found.status !== 'queued') return { ok: false, profile, steering: steeringStatus(), code: 'bad-request', detail: 'id' }
+        found.approvedAt = Date.now()
+        found.updatedAt = found.approvedAt
       } else if (input.action === 'add') {
         const text = clipSafe(input.text.trim(), 220)
         if (text.length === 0) return { ok: false, profile, steering: steeringStatus(), code: 'bad-request', detail: 'text' }
-        const workspace = typeof input.workspace === 'string' && input.workspace.trim().length > 0 ? input.workspace.trim() : undefined
-        profile.directives.push({ id: nextDirectiveId(), text, enabled: true, source: 'user', createdAt: Date.now(), ...(workspace === undefined ? {} : { workspace }) })
+        if (POLICY_RE.test(text)) return { ok: false, profile, steering: steeringStatus(), code: 'directive-policy', detail: '' }
+        const workspace = normalizeWorkspace(typeof input.workspace === 'string' ? input.workspace.trim() : '')
+        profile.directives.push({ id: nextDirectiveId(), text, enabled: true, source: 'user', createdAt: Date.now(), ...(workspace === '' ? {} : { workspace }) })
+      } else if (input.action === 'rescope') {
+        const found = profile.directives.find((entry) => entry.id === input.id)
+        if (found === undefined) return { ok: false, profile, steering: steeringStatus(), code: 'bad-request', detail: 'id' }
+        const workspace = normalizeWorkspace(input.workspace.trim())
+        if (workspace === '') delete found.workspace
+        else found.workspace = workspace
+        // A trial measured in one workspace says nothing about another.
+        if (found.status === 'candidate') {
+          found.status = 'queued'
+          delete found.trial
+        }
       } else {
-        profile.directives = profile.directives.filter((entry) => entry.id !== input.id)
+        // A tombstone, not a delete: the distiller is told about it so it never
+        // proposes the same directive (or a rewording) back.
+        const found = profile.directives.find((entry) => entry.id === input.id)
+        if (found !== undefined) {
+          found.status = 'removed'
+          found.enabled = false
+          found.updatedAt = Date.now()
+          delete found.trial
+          invalidateSteering()
+        }
       }
       startNextTrial(profile)
       const saved = capAndSaveProfile(profile)
@@ -1440,15 +1560,54 @@ export function createCoachService(ctx, store, effectiveConfig) {
     async usageReport(args) {
       const parsed = usageArgSchema.safeParse(args !== null && typeof args === 'object' ? args : {})
       if (!parsed.success) return { ok: false, code: 'bad-request', detail: '' }
-      return usage.report({
-        config: effectiveConfig(),
-        pricingStatus: pricing.status(),
-        pricingRates: pricing.rates(),
-        filters: parsed.data,
-      })
+      return {
+        ...usage.report({
+          config: effectiveConfig(),
+          pricingStatus: pricing.status(),
+          pricingRates: pricing.rates(),
+          filters: parsed.data,
+        }),
+        auto: autoStatus(),
+      }
     },
 
     /** One run with its attempt rows (a live run included); expired ids are a soft `unknown-run`. */
+    /** One directive's provenance and cost: ids, counts and money, never prompt text. */
+    async directiveReceipt(args) {
+      const parsed = directiveReceiptArgSchema.safeParse(args)
+      if (!parsed.success) return { ok: false, receipt: null, code: 'bad-request', detail: '' }
+      const entry = safeProfile().directives.find((candidate) => candidate.id === parsed.data.id)
+      if (entry === undefined) return { ok: false, receipt: null, code: 'unknown-directive', detail: '' }
+      const triggers = {}
+      const conversations = new Set()
+      for (const item of entry.evidence) {
+        triggers[item.trigger] = (triggers[item.trigger] ?? 0) + 1
+        conversations.add(item.sessionId)
+      }
+      const run = entry.distillationRunId === '' ? null : usage.run(entry.distillationRunId)
+      const attempts = run !== null && Array.isArray(run.attempts) ? run.attempts.filter((attempt) => attempt.op === 'directive-distillation') : []
+      const priced = attempts.filter((attempt) => attempt.priced !== null && typeof attempt.priced === 'object' && typeof attempt.priced.usd === 'number')
+      const receipt = {
+        id: entry.id,
+        text: entry.text,
+        scope: scopeOf(entry),
+        status: entry.status,
+        source: entry.source,
+        enabled: entry.enabled !== false,
+        createdAt: entry.createdAt,
+        updatedAt: entry.updatedAt,
+        evaluatedAt: entry.evaluatedAt,
+        approvedAt: entry.approvedAt,
+        version: entry.version,
+        trial: entry.trial ?? null,
+        retiredReason: entry.retiredReason ?? '',
+        triggers,
+        evidence: { turns: entry.evidence.length, conversations: conversations.size, items: entry.evidence },
+        cost: { runId: entry.distillationRunId, calls: attempts.length, usd: priced.length === 0 ? null : priced.reduce((sum, attempt) => sum + attempt.priced.usd, 0) },
+      }
+      return { ok: true, receipt, code: '', detail: '' }
+    },
+
     async usageRun(args) {
       const parsed = usageRunArgSchema.safeParse(args)
       if (!parsed.success) return { ok: false, run: null, code: 'bad-request', detail: '' }

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
@@ -62,7 +62,7 @@ export 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() {

package/lib/usage.js

@@ -27,6 +27,8 @@ import { dayKey, dayKeyBefore } from './store.js'
 import { USAGE_ATTEMPT_STATUSES, USAGE_OPS, USAGE_RUN_STATUSES, USAGE_RUN_TYPES } from './schema.js'
 
 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
@@ -83,7 +85,7 @@ function emptyTokens() {
 }
 
 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() {
@@ -113,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]
 }
 
@@ -177,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
 }
@@ -189,10 +193,12 @@ function attemptDelta(attempt) {
   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,
   }
 }
 
@@ -354,15 +360,19 @@ export function createUsageTracker({ store, config, pricing, now = Date.now, flu
     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)
@@ -408,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,
     }
   }
 
@@ -496,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
@@ -504,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) }
   }
 
   /**
@@ -644,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
@@ -655,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))
@@ -685,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: {