dsh-tacit 0.2.3 → 0.4.0

package/docs/README.zh.md

@@ -45,7 +45,7 @@ DeepSeek API Key（Tacit 从不读取它）。
 | **零点击学习** | 不顺的轮次和你自己的纠正会在后台被分析，并带上上一轮作为上下文；自动分析每天有上限（默认 30 次） | 每次 $0.001–0.003 |
 | **指令要靠表现留下** | 学到的指令作为一小段系统提示注入，你可以查看、编辑、开关或删除；新指令先是*候选*，如果你的不顺轮次比例变差就会退役 | 免费 |
 | **✨ 改进** | 输入框里的按钮，用 Tacit 学到的东西重写当前草稿，带前后对比预览和 👍/👎 | 每次点击 $0.001–0.002 |
-| **测量而非猜测** | 设置页显示你的真实趋势：不顺轮次比例和每轮 token 数，最早 20 轮 vs 最近 20 轮 | 免费 |
+| **测量而非猜测** | 设置页显示你的真实趋势：不顺轮次比例和每轮 token 数，最早 20 轮 vs 最近 20 轮——以及 Tacit 自己的花费：每次调用都被计量并按目录价定价，显示在设置页里 | 免费 |
 
 ## 它是怎么工作的
 
@@ -63,8 +63,8 @@ DeepSeek API Key（Tacit 从不读取它）。
 
 Tacit 从不接触你的 API Key（所有调用都经过 harness 自己的模型服务），只通过你会话
 自己的 provider 路由调用白名单里的官方模型，报告和指令都存放在
-`~/.dsh/storages/tacit/`，拒绝对自身路由的跨站请求，除了自己的报告之外从不删除任何
-东西。美元数字是按公开价格的估算；`dsh-cost-meter` 这样的成本插件会显示真实花费。
+`~/.dsh/storages/tacit/`，拒绝对自身路由的跨站请求，除了自己的报告和过期的用量记录
+之外从不删除任何东西。美元数字是按公开价格的估算；`dsh-cost-meter` 这样的成本插件会显示真实花费。
 完整的数据流与成本表、以及坦白的限制清单（英文）：
 [Privacy, cost & limitations](https://github.com/hackernotfound/dsh-tacit/blob/main/docs/privacy-and-cost.md)。
 

package/lib/analyze.js

@@ -90,11 +90,11 @@ export const ANALYSIS_TOOL = {
 
 export const IMPROVE_TOOL = {
   name: 'improved',
-  description: 'Submit the rewritten draft.',
+  description: 'Submit the final rewritten draft, or the draft verbatim when it is already complete.',
   parameters: {
     type: 'object',
     properties: {
-      improved: { type: 'string', description: 'the rewritten prompt' },
+      improved: { type: 'string', description: 'the final prompt (the draft verbatim if already complete)' },
       rationale: { type: 'string', description: '1-2 sentences on what changed and why' },
     },
     required: ['improved', 'rationale'],
@@ -114,6 +114,7 @@ export const DIRECTIVE_TOOL = {
         items: {
           type: 'object',
           properties: {
+            id: { type: 'string', description: 'the [id] of the current directive this one keeps or rewords; omit for a genuinely new directive' },
             text: { type: 'string', maxLength: 220, description: 'one sentence, at most 25 words' },
             workspace: { type: 'string', description: 'only when the habit shows up in exactly one workspace: that workspace name as written in the evidence' },
           },
@@ -125,6 +126,67 @@ export const DIRECTIVE_TOOL = {
   },
 }
 export const MAX_WORKSPACE_DIRECTIVES = 4
+/** Retired directives kept on the profile so the distiller is told not to re-propose them. */
+export const MAX_RETIRED = 6
+
+/** The workspace a directive is limited to; '' = every conversation. */
+export const scopeOf = (entry) => (typeof entry.workspace === 'string' && entry.workspace.length > 0 ? entry.workspace : '')
+const directiveKey = (scope, text) => scope + '\n' + text.trim().toLowerCase()
+
+/** At most MAX_DIRECTIVES global and MAX_WORKSPACE_DIRECTIVES per-workspace live directives, plus the last MAX_RETIRED retired ones; order kept. */
+export function capDirectives(list) {
+  const retired = list.filter((entry) => entry.status === 'retired')
+  const forgotten = new Set(retired.slice(0, Math.max(0, retired.length - MAX_RETIRED)))
+  const counts = new Map()
+  return list.filter((entry) => {
+    if (entry.status === 'retired') return !forgotten.has(entry)
+    const scope = scopeOf(entry)
+    const n = counts.get(scope) ?? 0
+    if (n >= (scope === '' ? MAX_DIRECTIVES : MAX_WORKSPACE_DIRECTIVES)) return false
+    counts.set(scope, n + 1)
+    return true
+  })
+}
+
+/**
+ * Merge the model's new complete set of directives ({ id?, text, workspace? })
+ * into the profile: 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), and so are retired ones (the do-not-re-propose list). An item
+ * naming an existing id, or repeating an existing text, keeps that entry's
+ * identity, state, trial and enabled flag and only updates the text; a
+ * retired entry stays exactly as it is; a new one queues for its trial slot.
+ */
+export function mergeDirectives(profile, items, { nextId }) {
+  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 byId = new Map(prior.map((entry) => [entry.id, entry]))
+  const byKey = 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 distilled = []
+  const seen = new Set()
+  const matched = new Set()
+  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 = (typeof item.id === 'string' ? byId.get(item.id) : undefined) ?? byKey.get(key)
+    if (kept !== undefined) {
+      if (kept.status === 'retired' || matched.has(kept.id)) continue
+      matched.add(kept.id)
+      distilled.push({ ...kept, text: item.text })
+      continue
+    }
+    distilled.push({ id: nextId(), text: item.text, enabled: true, source: 'distilled', createdAt: Date.now(), status: 'queued', ...(scope === '' ? {} : { workspace: scope }) })
+  }
+  const untouched = prior.filter((entry) => !matched.has(entry.id) && (entry.status === 'retired' || !mentioned.has(scopeOf(entry))))
+  profile.directives = capDirectives([...users, ...distilled, ...untouched])
+  return profile
+}
 
 /** The last path segment of a workspace directory — what a person calls the project. */
 export function workspaceLabel(cwd) {
@@ -201,23 +263,36 @@ export function normalizeEnrichNote(text) {
 
 // ── Measured trend ─────────────────────────────────────────────────────────
 
+/**
+ * One conversation's turns, each with `corrected`: whether the user's NEXT
+ * message in that conversation reads as a correction of it. The last turn has
+ * no next message and counts as not corrected.
+ */
+export function markCorrections(turns) {
+  const list = (Array.isArray(turns) ? turns : []).filter((turn) => turn !== null && typeof turn === 'object')
+  return list.map((turn, index) => ({ ...turn, corrected: index + 1 < list.length && looksLikeCorrection(list[index + 1].prompt) }))
+}
+
 function windowStats(turns) {
   const n = turns.length
-  if (n === 0) return { n: 0, messyRate: 0, tokensPerTurn: 0 }
+  if (n === 0) return { n: 0, correctionRate: 0, messyRate: 0, tokensPerTurn: 0 }
+  let corrected = 0
   let messy = 0
   let tokens = 0
   for (const turn of turns) {
+    if (turn.corrected === true) corrected += 1
     if (isMessyTurn(turn, { minSteps: Number.POSITIVE_INFINITY })) messy += 1
     const usage = turn.usage !== null && typeof turn.usage === 'object' ? turn.usage : {}
     const read = (key) => (typeof usage[key] === 'number' && Number.isFinite(usage[key]) ? usage[key] : 0)
     tokens += read('inputTokens') + read('outputTokens') + read('cacheReadTokens') + read('reasoningTokens')
   }
-  return { n, messyRate: messy / n, tokensPerTurn: Math.round(tokens / n) }
+  return { n, correctionRate: corrected / n, messyRate: messy / n, tokensPerTurn: Math.round(tokens / n) }
 }
 
 /**
  * Real before/after numbers from the fold: the first `window` finished turns
- * vs. the latest `window`, on rework signals (retries/errors/compactions/
+ * vs. the latest `window`, on how often the user corrected the agent (turns
+ * pre-marked by `markCorrections`), rework signals (retries/errors/compactions/
  * rejections — step counts are deliberately NOT a signal) and tokens/turn.
  */
 export function computeTrend(turns, { window = 20 } = {}) {
@@ -347,18 +422,52 @@ export const ANALYSIS_SYSTEM_PROMPT = [
 
 export const IMPROVE_SYSTEM_PROMPT = [
   'You are a prompt-improvement assistant inside DeepSeek Harness.',
-  'The user typed a draft prompt into the composer. Rewrite it to be more',
-  'precise, complete, and token-efficient, while PRESERVING its intent.',
-  'Do not add requirements the user did not ask for; fill in only what is',
-  'genuinely underspecified (scope, constraints, format, acceptance criteria).',
-  'Learn from the user\'s recurring mistake patterns when provided.',
+  'The user typed a draft prompt for a coding agent into the composer. You get',
+  'ONE pass: return the prompt the user would arrive at after several rounds of',
+  'editing. Leave nothing for a second pass.',
+  '',
+  'A finished prompt has every item below (skip an item only when the draft or',
+  'context makes it obviously unnecessary):',
+  '- GOAL — one sentence: the outcome and what "done" looks like.',
+  '- CONTEXT — the concrete facts the agent would otherwise have to discover:',
+  '  file paths, URLs, names, versions, decisions already made. Take them from',
+  '  the draft and from RECENT CONVERSATION CONTEXT. Never invent facts.',
+  '- SCOPE — what is in and out; what to leave untouched.',
+  '- CONSTRAINTS — what not to do, limits, style, language, budget.',
+  '- OUTPUT FORMAT — the shape of the answer: list, table, diff, code only,',
+  '  prioritized, length.',
+  '- EFFICIENCY — what the agent need not explore or verify, so it finishes',
+  '  in fewer steps and tool calls.',
+  '',
+  'Rules:',
+  '- Preserve the user\'s intent; add nothing they did not ask for or clearly',
+  '  imply.',
+  '- Only fill what is genuinely underspecified. Keep the draft\'s wording where',
+  '  it already works.',
+  '- Be as short as completeness allows: no filler, no role preambles ("You are',
+  '  an expert…"), no restating what the agent already knows.',
+  '- Follow the STYLE RULES, NEGATIVE FEEDBACK and RECURRING MISTAKE PATTERNS',
+  '  when provided; they describe this user\'s habits.',
+  '- Silently check the draft against every item first, then write the whole',
+  '  prompt once.',
+  '- FIXED POINT: if the draft already satisfies every item, return it',
+  '  VERBATIM (character for character) with the rationale "Already complete."',
+  '  Never make cosmetic edits — a prompt you improved must come back',
+  '  unchanged when improved again.',
+  '',
+  'Example',
+  'draft: what do you think we can do to market our plugin today',
+  'context: the plugin was just published at https://github.com/x/y',
+  'improved: The plugin is now public at https://github.com/x/y. How do we',
+  'market it and get it noticed? Give a prioritized list of concrete actions,',
+  'easiest first, biggest impact last, with the expected effort for each.',
   '',
   'RESPONSE FORMAT — this is mandatory and machine-parsed:',
   'Your ENTIRE response must be ONE JSON object and nothing else. No preamble,',
   'no narration, no explanations outside the JSON, no markdown fences.',
   'Start directly with "{" and end with "}".',
   '{',
-  '  "improved": "<the rewritten prompt>",',
+  '  "improved": "<the final prompt — the draft verbatim if already complete>",',
   '  "rationale": "<1-2 sentences on what you changed and why>"',
   '}',
   '',
@@ -443,7 +552,9 @@ export const DIRECTIVE_SYSTEM_PROMPT = [
   'mood, addressed to the agent. A directive that needs a second sentence is two',
   'directives or too specific. You are writing',
   'the COMPLETE new set: keep existing directives that still hold (reworded if',
-  'sharper), drop ones that were one-off, add what is missing. No preamble.',
+  'sharper, returned with their id), drop ones that were one-off, add what is',
+  'missing. Never re-propose a retired directive or a close rephrasing of one.',
+  'No preamble.',
 ].join('\n')
 
 export function buildDirectiveUserText(profile, recentReports = [], { labelOf = workspaceLabel } = {}) {
@@ -489,10 +600,19 @@ export function buildDirectiveUserText(profile, recentReports = [], { labelOf =
     lines.push('', '=== STYLE RULES THE USER CONFIRMED ===')
     for (const rule of rules) lines.push('- ' + clipSafe(rule.rule, 300))
   }
-  const existing = Array.isArray(profile?.directives) ? profile.directives.filter((entry) => typeof entry?.text === 'string' && entry.text.length > 0) : []
+  const directives = Array.isArray(profile?.directives) ? profile.directives.filter((entry) => typeof entry?.text === 'string' && entry.text.length > 0) : []
+  const directiveLine = (entry, withId) => '- ' + (withId && typeof entry.id === 'string' ? '[' + entry.id + '] ' : '') + clipDirective(entry.text)
+    + (typeof entry.workspace === 'string' && entry.workspace.length > 0 ? ' [workspace: ' + labelOf(entry.workspace) + ']' : '')
+  const existing = directives.filter((entry) => entry.status !== 'retired')
   if (existing.length > 0) {
     lines.push('', '=== CURRENT DIRECTIVES (keep the ones that still hold) ===')
-    for (const entry of existing) lines.push('- ' + clipDirective(entry.text) + (typeof entry.workspace === 'string' && entry.workspace.length > 0 ? ' [workspace: ' + labelOf(entry.workspace) + ']' : ''))
+    for (const entry of existing) lines.push(directiveLine(entry, true))
+    lines.push('When you keep or reword one of these, return it with its [id]; leave id out only for a genuinely new directive.')
+  }
+  const retired = directives.filter((entry) => entry.status === 'retired').slice(-MAX_RETIRED)
+  if (retired.length > 0) {
+    lines.push('', '=== RETIRED (made things worse while active; do not re-propose these) ===')
+    for (const entry of retired) lines.push(directiveLine(entry, false))
   }
   lines.push('', 'Write 2-4 directives for the agent about this user. A habit the user has', 'shown they can fix themselves is still worth a directive: the agent should', 'compensate for it when it is missing, not ask.')
   return lines.join('\n')
@@ -502,7 +622,8 @@ export function buildDirectiveUserText(profile, recentReports = [], { labelOf =
 const ASKS_USER_RE = /\b(ask|confirm with|check with|clarify with|verify with|get (approval|confirmation|permission) from) (the )?user\b|\bstop and ask\b|\bbefore doing anything\b|\bask (what|which|whether|if|for)\b/i
 
 /**
- * Parse a directives payload into clipped, deduped one-liners (≤4 kept);
+ * Parse a directives payload into clipped, deduped one-liners (≤4 kept), each
+ * with the id of the current directive it restates when the model gave one;
  * directives that instruct the agent to ask the user are rejected.
  */
 export function classifyDirectives(text) {
@@ -520,6 +641,7 @@ export function classifyDirectives(text) {
     const workspace = typeof item === 'object' && item !== null && typeof item.workspace === 'string' && item.workspace.trim().length > 0
       ? clipSafe(item.workspace.trim(), 200)
       : undefined
+    const id = typeof item === 'object' && item !== null && typeof item.id === 'string' && item.id.trim().length > 0 ? clipSafe(item.id.trim(), 64) : undefined
     const key = (workspace ?? '') + '\n' + value.toLowerCase()
     if (value.length === 0 || seen.has(key)) continue
     seen.add(key)
@@ -527,7 +649,7 @@ export function classifyDirectives(text) {
       rejected.push(value)
       continue
     }
-    kept.push(workspace === undefined ? { text: value } : { text: value, workspace })
+    kept.push({ text: value, ...(workspace === undefined ? {} : { workspace }), ...(id === undefined ? {} : { id }) })
     if (kept.length >= 4) break
   }
   return { kept, rejected }
@@ -540,14 +662,13 @@ export function classifyDirectives(text) {
  * nothing is enabled (an empty section contributes nothing).
  */
 export function buildSteeringSection(profile, { cwd } = {}) {
-  const here = typeof cwd === 'string' && cwd.length > 0 ? cwd : null
-  const scopeOf = (entry) => (typeof entry.workspace === 'string' && entry.workspace.length > 0 ? entry.workspace : null)
+  const here = typeof cwd === 'string' && cwd.length > 0 ? cwd : ''
   const candidates = (Array.isArray(profile?.directives) ? profile.directives : [])
-    .filter((entry) => entry !== null && typeof entry === 'object' && entry.enabled !== false && entry.status !== 'retired'
+    .filter((entry) => entry !== null && typeof entry === 'object' && entry.enabled !== false && entry.status !== 'retired' && entry.status !== 'queued'
       && typeof entry.text === 'string' && entry.text.trim().length > 0)
-    .filter((entry) => scopeOf(entry) === null || scopeOf(entry) === here)
+    .filter((entry) => scopeOf(entry) === '' || scopeOf(entry) === here)
   // This workspace's own directives first: they are the more specific ones.
-  const enabled = [...candidates.filter((entry) => scopeOf(entry) !== null), ...candidates.filter((entry) => scopeOf(entry) === null)]
+  const enabled = [...candidates.filter((entry) => scopeOf(entry) !== ''), ...candidates.filter((entry) => scopeOf(entry) === '')]
   if (enabled.length === 0) return { text: '', ids: [] }
   const header = [
     '## About this user (learned by Tacit from their past prompts)',
@@ -989,8 +1110,12 @@ export function lastDownReasons(profile, n = 3) {
  * NEVER returned as the answer (chain of thought is not a report). A
  * deployment that rejects the reasoning effort gets one retry without it.
  * Returns the answer text ('' when the model produced nothing usable).
+ *
+ * When `onUsage(record)` is given, it is called once per underlying `run()`
+ * (twice on the reasoning-effort retry) with a usage/cost record. A sink
+ * that throws never fails the model call.
  */
-export async function callCoachModel(ctx, { provider, model, system, userText, maxTokens, timeoutMs, tool, sessionId, reasoningEffort = COACH_REASONING_EFFORT }) {
+export async function callCoachModel(ctx, { provider, model, system, userText, maxTokens, timeoutMs, tool, sessionId, reasoningEffort = COACH_REASONING_EFFORT, onUsage }) {
   const llm = ctx.get !== undefined && typeof ctx.get === 'function' ? ctx.get('llm') : undefined
   if (llm === undefined || typeof llm.stream !== 'function') {
     const error = new Error('the harness LLM service is unavailable')
@@ -1003,35 +1128,81 @@ export async function callCoachModel(ctx, { provider, model, system, userText, m
     content: [{ type: 'text', text: userText }],
     source: { kind: 'plugin', plugin: 'dsh-tacit' },
   })
+  const toCount = (value) => (Number.isFinite(value) && value >= 0 ? value : 0)
   const run = async (effort) => {
+    const startedAt = Date.now()
     let text = ''
     let toolArgs = ''
     let toolDeltas = ''
-    let finish = ''
-    for await (const chunk of llm.stream({
-      provider,
-      model,
-      messages: [message],
-      system,
-      maxTokens,
-      signal: controller.signal,
-      ...(effort !== undefined ? { reasoningEffort: effort } : {}),
-      ...(tool !== undefined ? { tools: [tool] } : {}),
-      ...(typeof sessionId === 'string' && sessionId.length > 0 ? { sessionId } : {}),
-    })) {
-      if (chunk === null || typeof chunk !== 'object') continue
-      if (chunk.type === 'finish' && typeof chunk.reason === 'string') finish = chunk.reason
-      if (chunk.type === 'text-delta' && typeof chunk.text === 'string') text += chunk.text
-      else if (chunk.type === 'tool-call-delta' && typeof chunk.argumentsDelta === 'string') toolDeltas += chunk.argumentsDelta
-      else if (chunk.type === 'block-end' && chunk.block !== null && typeof chunk.block === 'object'
-        && chunk.block.type === 'tool-call' && typeof chunk.block.arguments === 'string' && toolArgs === '') {
-        toolArgs = chunk.block.arguments
+    let finishKind = ''
+    let failure = null
+    let usage = null
+    let thrown = null
+    try {
+      for await (const chunk of llm.stream({
+        provider,
+        model,
+        messages: [message],
+        system,
+        maxTokens,
+        signal: controller.signal,
+        ...(effort !== undefined ? { reasoningEffort: effort } : {}),
+        ...(tool !== undefined ? { tools: [tool] } : {}),
+        ...(typeof sessionId === 'string' && sessionId.length > 0 ? { sessionId } : {}),
+      })) {
+        if (chunk === null || typeof chunk !== 'object') continue
+        if (chunk.type === 'usage' && chunk.usage !== null && typeof chunk.usage === 'object') {
+          usage = {
+            inputTokens: toCount(chunk.usage.inputTokens),
+            outputTokens: toCount(chunk.usage.outputTokens),
+            cacheReadTokens: toCount(chunk.usage.cacheReadTokens),
+            cacheWriteTokens: toCount(chunk.usage.cacheWriteTokens),
+            reasoningTokens: toCount(chunk.usage.reasoningTokens),
+          }
+        } else if (chunk.type === 'finish') {
+          finishKind = typeof chunk.reason === 'string' ? chunk.reason : (chunk.reason?.kind ?? '')
+          failure = chunk.reason?.failure ?? null
+        } else if (chunk.type === 'text-delta' && typeof chunk.text === 'string') text += chunk.text
+        else if (chunk.type === 'tool-call-delta' && typeof chunk.argumentsDelta === 'string') toolDeltas += chunk.argumentsDelta
+        else if (chunk.type === 'block-end' && chunk.block !== null && typeof chunk.block === 'object'
+          && chunk.block.type === 'tool-call' && typeof chunk.block.arguments === 'string' && toolArgs === '') {
+          toolArgs = chunk.block.arguments
+        }
+      }
+      if (finishKind === 'error' || finishKind === 'aborted') {
+        thrown = Object.assign(new Error(failure?.message ?? finishKind), { code: failure?.code ?? finishKind.toUpperCase() })
+        throw thrown
+      }
+    } catch (error) {
+      thrown = thrown ?? error
+      throw error
+    } finally {
+      if (typeof onUsage === 'function') {
+        const code = (thrown !== null && typeof thrown === 'object' ? thrown.code : undefined) ?? failure?.code ?? ''
+        const status = thrown !== null || finishKind === 'error' || finishKind === 'aborted'
+          ? 'failed'
+          : (usage === null ? 'unmetered' : 'ok')
+        try {
+          onUsage({
+            startedAt,
+            durationMs: Date.now() - startedAt,
+            model,
+            provider,
+            reasoningEffort: effort ?? null,
+            finish: finishKind,
+            status,
+            code,
+            usage,
+          })
+        } catch {
+          // a sink bug must never fail a model call
+        }
       }
     }
     if (toolArgs.length > 0) return toolArgs
     if (toolDeltas.length > 0) return toolDeltas
-    if (text.length === 0 && finish.length > 0 && finish !== 'stop') {
-      console.warn('[tacit] model call ended without an answer (finish: ' + finish + ', maxTokens: ' + String(maxTokens) + ')')
+    if (text.length === 0 && finishKind.length > 0 && finishKind !== 'stop') {
+      console.warn('[tacit] model call ended without an answer (finish: ' + finishKind + ', maxTokens: ' + String(maxTokens) + ')')
     }
     return text
   }

package/lib/index.js

@@ -87,13 +87,15 @@ export function apply(ctx, config) {
     const directives = store.profile().directives
     const count = (status) => directives.filter((entry) => entry.status === status).length
     console.info('[tacit] loaded — directives: ' + count('active') + ' active, ' + count('candidate') + ' candidates, '
-      + count('retired') + ' retired; steering ' + (cfg.steerAgent ? 'on' : 'off') + '; auto-analysis '
+      + count('queued') + ' queued, ' + count('retired') + ' retired; steering ' + (cfg.steerAgent ? 'on' : 'off') + '; auto-analysis '
       + (cfg.autoAnalyze ? 'on (cap ' + cfg.autoDailyBudget + '/day)' : 'off'))
   } catch {
     // Logging must never keep the plugin from loading.
   }
 
   ctx.effect(() => () => {
-    // Nothing to flush: all writes are atomic and complete at call time.
+    // Reports and the profile are written atomically at call time; only the
+    // usage ledger keeps debounced state, so an unload flushes it.
+    service.usage.flush()
   }, 'tacit: dispose')
 }

package/lib/pricing-source.js

@@ -0,0 +1,133 @@
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2026 hackernotfound — https://github.com/hackernotfound/dsh-tacit
+/**
+ * dsh-tacit — the price table behind the usage tracker.
+ *
+ * Wraps the pure `lib/pricing.js` with one optional input: the sibling
+ * `dsh-cost-meter` plugin's `costMeter` service. When that service is
+ * installed and hands over a usable state, its prices win; otherwise the
+ * bundled DeepSeek list prices apply. The service is fully duck-typed and
+ * never trusted: `refresh()` never throws, never blocks longer than
+ * `timeoutMs`, and any failure (absent, throwing, hanging, junk) leaves the
+ * source on the bundled table with a human-readable `error`.
+ *
+ * A model call must never wait on this — the service refreshes it in the
+ * background and every `priceCall` reads whatever snapshot is current.
+ */
+
+import { priceCall as priceCallWith, normalizeCostMeterState, tierAt, PRICES_AS_OF, BUNDLED_PRICES } from './pricing.js'
+import { COACH_MODELS } from './schema.js'
+
+/** A `{cacheHit, cacheMiss, output}` triple as a fresh object (never a reference into a shared table). */
+function copyTriple(triple) {
+  return { cacheHit: triple.cacheHit, cacheMiss: triple.cacheMiss, output: triple.output }
+}
+
+/** A normalized snapshot is only worth using if it actually carries a price. */
+function hasPrices(snapshot) {
+  if (snapshot === null || typeof snapshot !== 'object') return false
+  const models = snapshot.models !== null && typeof snapshot.models === 'object' ? Object.keys(snapshot.models) : []
+  const providers = snapshot.providers !== null && typeof snapshot.providers === 'object' ? Object.keys(snapshot.providers) : []
+  return models.length > 0 || providers.length > 0
+}
+
+/** Whatever was thrown/rejected, as a short message. */
+function messageOf(error) {
+  if (error !== null && typeof error === 'object' && typeof error.message === 'string' && error.message.length > 0) return error.message
+  return String(error)
+}
+
+/** Reject after `ms`; the timer is unref'd so a pending refresh never holds the process open. */
+function rejectAfter(ms) {
+  let timer = null
+  const promise = new Promise((_resolve, reject) => {
+    timer = setTimeout(() => reject(new Error(`costMeter getState() timed out after ${ms}ms`)), ms)
+    if (typeof timer?.unref === 'function') timer.unref()
+  })
+  return { promise, cancel: () => { if (timer !== null) clearTimeout(timer) } }
+}
+
+/**
+ * The price source the tracker and the reports read from.
+ * `now`/`timeoutMs` are injectable so tests can drive the clock and the
+ * hang path without waiting five seconds.
+ */
+export function createPricingSource(ctx, { now = Date.now, timeoutMs = 5000 } = {}) {
+  const state = { snapshot: null, source: 'bundled', refreshedAt: 0, error: '' }
+
+  /** Drop back to the bundled table, remembering why. */
+  function fallBack(error) {
+    state.snapshot = null
+    state.source = 'bundled'
+    state.refreshedAt = 0
+    state.error = error
+  }
+
+  async function refresh() {
+    const service = ctx !== null && typeof ctx === 'object' && typeof ctx.get === 'function' ? ctx.get('costMeter') : undefined
+    if (service === undefined || service === null || typeof service.getState !== 'function') {
+      fallBack('the costMeter service is not available — using bundled list prices')
+      return
+    }
+    const timeout = rejectAfter(timeoutMs)
+    let raw
+    try {
+      raw = await Promise.race([Promise.resolve(service.getState()), timeout.promise])
+    } catch (error) {
+      fallBack(messageOf(error))
+      return
+    } finally {
+      timeout.cancel()
+    }
+    const snapshot = normalizeCostMeterState(raw)
+    if (!hasPrices(snapshot)) {
+      fallBack('the costMeter state carried no usable prices — using bundled list prices')
+      return
+    }
+    state.snapshot = snapshot
+    state.source = 'costMeter'
+    state.refreshedAt = now()
+    state.error = ''
+  }
+
+  /** {@link priceCallWith} against the current snapshot (bundled when there is none). */
+  function priceCall(args) {
+    return priceCallWith({ ...args, table: state.snapshot })
+  }
+
+  /**
+   * What the Pricing card shows about the source itself. `tierNow` is read
+   * off the same snapshot `priceCall` prices against — a cost-meter table
+   * that turns peak pricing off, shifts the windows, or dates them into the
+   * future must not leave the card quoting the bundled schedule.
+   */
+  function status() {
+    const snapshot = state.snapshot
+    const tierNow = snapshot === null
+      ? tierAt(now())
+      : tierAt(now(), { windows: snapshot.windows, effectiveAtMs: snapshot.effectiveAtMs, peakEnabled: snapshot.peakEnabled !== false })
+    return {
+      source: state.source,
+      asOf: typeof snapshot?.asOf === 'string' ? snapshot.asOf : PRICES_AS_OF,
+      refreshedAt: state.refreshedAt,
+      tierNow,
+      error: state.error,
+    }
+  }
+
+  /** `{model: {offPeak, peak}}` for both coach models — snapshot first, bundled per model otherwise. */
+  function rates() {
+    const models = state.snapshot?.models
+    const out = {}
+    for (const model of COACH_MODELS) {
+      const entry = models !== null && typeof models === 'object' ? models[model] : undefined
+      const source = entry !== null && typeof entry === 'object' && entry.offPeak !== undefined && entry.peak !== undefined
+        ? entry
+        : BUNDLED_PRICES[model]
+      out[model] = { offPeak: copyTriple(source.offPeak), peak: copyTriple(source.peak) }
+    }
+    return out
+  }
+
+  return { refresh, priceCall, status, rates }
+}