opencode-tweaks 0.4.1 → 0.5.0

package/README.md

@@ -95,10 +95,11 @@ Resetting a setting drops the local value, so the option or default applies agai
 
 ## Tweaks
 
-| Tweak    | What it does                                                      | Default |
-| -------- | ----------------------------------------------------------------- | ------- |
-| `quota`  | Provider quota, reset times, and a daily spending budget.         | On      |
-| `tokens` | Token and cost usage per turn, plus session totals at the bottom. | On      |
+| Tweak    | What it does                                              | Default |
+| -------- | --------------------------------------------------------- | ------- |
+| `quota`  | Provider quota, reset times, and a daily spending budget. | On      |
+| `tokens` | Token usage per turn, plus session totals at the bottom.  | On      |
+| `cost`   | Cost per turn, plus session totals at the bottom.         | On      |
 
 ### Quota
 
@@ -134,7 +135,7 @@ the row. The budget resets at local midnight, and a changed provider reset or wo
 
 ### Tokens
 
-Tokens shows two token counts and, optionally, their cost. Each has its own toggle.
+Tokens shows two token counts, each with its own toggle.
 
 `Turn tokens` adds what the latest finished turn spent to its `tok/s` line: `12.3K tok · 62.2 tok/s`. OpenCode draws
 that line itself and publishes no slot inside it, so the tweak splices the value into the line's text node and repairs
@@ -148,23 +149,32 @@ receives its figures and the older lines keep theirs.
 `First token time` controls the host's own `1.7s ttft` figure at the end of that line: it is off by default, so the
 span is removed and `tok/s` stays alone. Turning it on restores the host's figure.
 
-`Turn cost` adds that turn's cost after the throughput figure: `62.2 tok/s · $0.0042`.
-
 `Session tokens` adds the session's total usage to the bottom status line, before the host's context figure:
-`1 shell · 790.6K tok total · $0.91 · 115K (29%)`. It reads the counters the session itself keeps, so
-the number stays exact even when the transcript has only loaded its latest messages. The figures follow the shell
-indicator when one is running and otherwise open the context text, so the order stays shell, total, session cost,
-context. OpenCode draws those texts itself and publishes no slot inside them, so the figures are spliced in and
-repaired while the line changes; when the splice is not available the figures stay out of the line rather than
-moving elsewhere.
-
-`Token count` picks what the two numbers add up. `Generated only` is the default: it keeps just what the model wrote.
+`1 shell · 790.6K tok total · 115K (29%)`. When the cost tweak is on, its figure sits between the total and the
+context. It reads the counters the session itself keeps, so the number stays exact even when the transcript has only
+loaded its latest messages. The figures follow the shell indicator when one is running and otherwise open the context
+text, so the order stays shell, total, session cost, context. OpenCode draws those texts itself and publishes no slot
+inside them, so the figures are spliced in and repaired while the line changes; when the splice is not available the
+figures stay out of the line rather than moving elsewhere.
+
+`Token count` picks what the numbers add up. `Generated only` is the default: it keeps just what the model wrote.
 `New tokens` adds prompt, completion, reasoning, and cache writes, without cache reads, because a turn re-reads the
 whole context at every step and those reads would dwarf everything else. `Everything` matches the counters `/stats`
-reports, cache reads included. `Include subagents` is on by default, so the session totals cover the whole session tree
-instead of only the session on screen; the per-turn count always stays on the session on screen, because a prompt
+reports, cache reads included. `Include subagents` is on by default, so both session totals cover the whole session tree
+instead of only the session on screen; the per-turn figures always stay on the session on screen, because a prompt
 belongs to it. `Token format` switches between compact counts such as `12.4K` and every digit such as `12,431`.
 
+### Cost
+
+Cost shows what a turn and the session spent, each with its own toggle. It reads the same counters as Tokens, and
+either tweak can be off without hiding the other.
+
+`Turn cost` adds that turn's cost after the throughput figure: `62.2 tok/s · $0.0042`.
+
+`Session cost` adds the session's total cost to the bottom status line, before the host's context figure:
+`1 shell · 790.6K tok total · $0.91 · 115K (29%)`. It follows the same session tree as the token total, including
+`Include subagents`.
+
 Costs come from what the provider reports, so a free plan shows `$0.00`. `Cost decimals` controls the decimals:
 `Auto` keeps two decimals and grows until the first significant digit shows (`$0.004`), while a fixed choice always
 keeps that many (`$0.0042`).
@@ -175,6 +185,8 @@ provider that reports a price always wins, and a session that changed model is e
 treat the figure as an estimate. This is what makes the OpenCode Go monthly credit readable: the plan reports `$0.00`
 per turn, and the estimate follows the API rates instead. Costs use the raw counters whatever `Token count` says.
 
+The cost settings used to live in the Tokens entry. A choice saved there before the split keeps applying.
+
 ## Development
 
 ```sh
@@ -194,8 +206,13 @@ src/
   quota/
     service.ts      credential lookup and quota fetch
     parse.ts        provider response parsing
+    pace.ts         daily budget pacing
     format.ts       percents, reset times, and bars
-  tui.tsx           terminal entry: command and sidebar slot
+  usage/
+    messages.ts     message shape and turn selection
+    tokens.ts       token sums and formatting
+    cost.ts         list prices, estimates, and cost formatting
+  tui.tsx           terminal entry: commands and slots
   tweaks/
     types.ts        settings schema and validation
     registry.ts     list of tweaks
@@ -205,10 +222,10 @@ src/
     menu-model.ts   filtering and selection helpers
     quota.ts        quota tweak definition
     quota-panel.tsx sidebar quota panel
-    tokens.ts       tokens tweak definition
-    token-slots.tsx inline splice driver and status line
-    token-inject.ts splice into the host's tok/s line
-    tokens-model.ts token sum and formatting
+    tokens.ts       token tweak definition
+    cost.ts         cost tweak definition
+    usage-slots.tsx inline and status line figures
+    usage-inject.ts splice into the host's lines
 ```
 
 ## Contributing

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "opencode-tweaks",
-  "version": "0.4.1",
+  "version": "0.5.0",
   "description": "Opt-in settings and small interface improvements for OpenCode.",
   "type": "module",
   "license": "MIT",
@@ -23,7 +23,8 @@
     "tui",
     "settings",
     "quota",
-    "tokens"
+    "tokens",
+    "cost"
   ],
   "exports": {
     ".": "./src/index.ts",

package/src/tui.tsx

@@ -2,14 +2,14 @@ import { Plugin } from "@opencode/plugin/tui"
 import { openTweaksMenu } from "./tweaks/menu"
 import { QuotaPanel } from "./tweaks/quota-panel"
 import { createSettingsStore } from "./tweaks/settings"
-import { createTokenInjector } from "./tweaks/token-inject"
-import { TokenInline, TokenStatus } from "./tweaks/token-slots"
+import { createUsageInjector } from "./tweaks/usage-inject"
+import { UsageInline, UsageStatus } from "./tweaks/usage-slots"
 
 export default Plugin.define({
   id: "opencode-tweaks.tui",
   setup(context) {
     const store = createSettingsStore(context)
-    const tokens = createTokenInjector(context)
+    const usage = createUsageInjector(context)
     let menuOpen = false
 
     context.ui.slot({
@@ -20,14 +20,14 @@ export default Plugin.define({
     context.ui.slot({
       append: "session.composer.top",
       render: (input) => (
-        <TokenInline context={context} input={input} store={store} injector={tokens} />
+        <UsageInline context={context} input={input} store={store} injector={usage} />
       ),
     })
 
     context.ui.slot({
       after: "prompt.footer.status",
       render: (input) => (
-        <TokenStatus context={context} input={input} store={store} injector={tokens} />
+        <UsageStatus context={context} input={input} store={store} injector={usage} />
       ),
     })
 
@@ -61,6 +61,6 @@ export default Plugin.define({
       ],
     }))
 
-    return () => tokens.dispose()
+    return () => usage.dispose()
   },
 })

package/src/tweaks/cost.ts

@@ -0,0 +1,70 @@
+import { defineTweak } from "./types"
+
+/**
+ * Cost reads the same counters as token usage but stays its own tweak: a
+ * provider that reports nothing still benefits from an estimate, while a user
+ * who only wants the counts can leave the prices off. The figures share the
+ * turn's throughput line and the session status line with the token counts.
+ */
+export const costTweak = defineTweak({
+  id: "cost",
+  title: "Cost",
+  description: "Show what a turn and the whole session cost.",
+  category: "Session",
+  /** Cost used to live in the token tweak; keep those choices readable. */
+  legacy: {
+    id: "tokens",
+    settings: {
+      prompt: "promptCost",
+      total: "totalCost",
+      digits: "costDigits",
+      estimate: "estimateCost",
+    },
+  },
+  settings: [
+    {
+      id: "enabled",
+      title: "Enabled",
+      description: "Turn the cost figures on.",
+      category: "General",
+      kind: "boolean",
+      default: true,
+    },
+    {
+      id: "prompt",
+      title: "Turn cost",
+      description: "Show that turn's cost after the tok/s figure.",
+      category: "Display",
+      kind: "boolean",
+      default: true,
+    },
+    {
+      id: "total",
+      title: "Session cost",
+      description: "Show the session's total cost on the bottom status line.",
+      category: "Display",
+      kind: "boolean",
+      default: true,
+    },
+    {
+      id: "digits",
+      title: "Cost decimals",
+      description:
+        "Decimals shown for costs, or auto to keep going until the first significant digit.",
+      category: "Display",
+      kind: "select",
+      default: "auto",
+      values: ["auto", 2, 3, 4, 5, 6],
+      labels: ["Auto", "2 digits", "3 digits", "4 digits", "5 digits", "6 digits"],
+    },
+    {
+      id: "estimate",
+      title: "Estimate cost",
+      description:
+        "Guess the cost from the model's list price when the provider reports none. A session that changed model is estimated with the model it ended on.",
+      category: "Scope",
+      kind: "boolean",
+      default: true,
+    },
+  ],
+})

package/src/tweaks/registry.ts

@@ -1,9 +1,10 @@
+import { costTweak } from "./cost"
 import { quotaTweak } from "./quota"
 import { tokensTweak } from "./tokens"
 import type { Tweak } from "./types"
 
 /** Every tweak shown by `/tweaks`. Add new definitions here. */
-export const tweaks: readonly Tweak[] = [quotaTweak, tokensTweak]
+export const tweaks: readonly Tweak[] = [quotaTweak, tokensTweak, costTweak]
 
 export function findTweak(id: string): Tweak | undefined {
   return tweaks.find((tweak) => tweak.id === id)

package/src/tweaks/settings.ts

@@ -18,10 +18,28 @@ interface OptionsTree {
   readonly [key: string]: unknown
 }
 
+/** One setting from a group in `opencode.json`, if the group holds one. */
+function configValue(group: unknown, settingID: string): unknown {
+  if (!group || typeof group !== "object") return undefined
+  return (group as OptionsTree)[settingID]
+}
+
+/** Drops one stored value, and the empty group it leaves behind. */
+function forget(stored: StoredSettings, tweakID: string, settingID: string) {
+  const group = stored[tweakID]
+  if (!group) return
+
+  delete group[settingID]
+  if (Object.keys(group).length === 0) delete stored[tweakID]
+}
+
 /**
  * Reads settings in priority order: value chosen in `/tweaks`, then the plugin
  * options in `opencode.json`, then the definition default. Writes only touch
  * the local layer, so the config file stays the user's to edit.
+ *
+ * A split tweak also checks the group its settings came from, so a value chosen
+ * before the split keeps applying until the user changes or resets it.
  */
 export function createSettingsStore(context: Context): SettingsStore {
   const [stored, update] = context.storage.store<StoredSettings>("settings", { initial: {} })
@@ -33,14 +51,22 @@ export function createSettingsStore(context: Context): SettingsStore {
       return { value: userValue, source: "user" }
     }
 
-    const tweakOptions = options[tweak.id]
-    const configValue =
-      tweakOptions && typeof tweakOptions === "object"
-        ? (tweakOptions as OptionsTree)[setting.id]
-        : undefined
+    const tweakConfig = configValue(options[tweak.id], setting.id)
+    if (isSettingValue(setting, tweakConfig)) {
+      return { value: tweakConfig, source: "config" }
+    }
+
+    const legacyID = tweak.legacy?.settings[setting.id]
+    if (tweak.legacy && legacyID) {
+      const legacyUser = stored[tweak.legacy.id]?.[legacyID]
+      if (isSettingValue(setting, legacyUser)) {
+        return { value: legacyUser, source: "user" }
+      }
 
-    if (isSettingValue(setting, configValue)) {
-      return { value: configValue, source: "config" }
+      const legacyConfig = configValue(options[tweak.legacy.id], legacyID)
+      if (isSettingValue(setting, legacyConfig)) {
+        return { value: legacyConfig, source: "config" }
+      }
     }
 
     return { value: setting.default, source: "default" }
@@ -60,12 +86,11 @@ export function createSettingsStore(context: Context): SettingsStore {
   }
 
   async function reset(tweak: Tweak, setting: TweakSetting): Promise<void> {
-    await update((draft) => {
-      const group = draft[tweak.id]
-      if (!group) return
+    const legacyID = tweak.legacy?.settings[setting.id]
 
-      delete group[setting.id]
-      if (Object.keys(group).length === 0) delete draft[tweak.id]
+    await update((draft) => {
+      forget(draft, tweak.id, setting.id)
+      if (tweak.legacy && legacyID) forget(draft, tweak.legacy.id, legacyID)
     })
   }
 

package/src/tweaks/tokens.ts

@@ -8,13 +8,13 @@ import { defineTweak } from "./types"
 export const tokensTweak = defineTweak({
   id: "tokens",
   title: "Tokens",
-  description: "Show token and cost usage for a turn and for the whole session.",
+  description: "Show token usage for a turn and for the whole session.",
   category: "Session",
   settings: [
     {
       id: "enabled",
       title: "Enabled",
-      description: "Turn the token and cost counts on.",
+      description: "Turn the token counts on.",
       category: "General",
       kind: "boolean",
       default: true,
@@ -28,14 +28,6 @@ export const tokensTweak = defineTweak({
       kind: "boolean",
       default: true,
     },
-    {
-      id: "promptCost",
-      title: "Turn cost",
-      description: "Show that turn's cost after the tok/s figure.",
-      category: "Display",
-      kind: "boolean",
-      default: true,
-    },
     {
       id: "total",
       title: "Session tokens",
@@ -44,14 +36,6 @@ export const tokensTweak = defineTweak({
       kind: "boolean",
       default: true,
     },
-    {
-      id: "totalCost",
-      title: "Session cost",
-      description: "Show the session's total cost on the bottom status line.",
-      category: "Display",
-      kind: "boolean",
-      default: true,
-    },
     {
       id: "format",
       title: "Token format",
@@ -61,17 +45,6 @@ export const tokensTweak = defineTweak({
       default: "compact",
       values: ["compact", "exact"],
     },
-    {
-      id: "costDigits",
-      title: "Cost decimals",
-      description:
-        "Decimals shown for costs, or auto to keep going until the first significant digit.",
-      category: "Display",
-      kind: "select",
-      default: "auto",
-      values: ["auto", 2, 3, 4, 5, 6],
-      labels: ["Auto", "2 digits", "3 digits", "4 digits", "5 digits", "6 digits"],
-    },
     {
       id: "ttft",
       title: "First token time",
@@ -95,16 +68,7 @@ export const tokensTweak = defineTweak({
     {
       id: "subagents",
       title: "Include subagents",
-      description: "Add the tokens used by subagents to the session totals.",
-      category: "Scope",
-      kind: "boolean",
-      default: true,
-    },
-    {
-      id: "estimateCost",
-      title: "Estimate cost",
-      description:
-        "Guess the cost from the model's list price when the provider reports none. A session that changed model is estimated with the model it ended on.",
+      description: "Add the usage of subagents to the session totals. Costs follow the same scope.",
       category: "Scope",
       kind: "boolean",
       default: true,

package/src/tweaks/types.ts

@@ -30,6 +30,18 @@ export interface TweakSetting {
   readonly format?: (value: SettingValue) => string
 }
 
+/**
+ * Where a tweak's settings lived before it was split out. The store reads the
+ * old group when the new one holds no value, so a rename keeps the choice the
+ * user already made instead of silently resetting it.
+ */
+export interface TweakLegacy {
+  /** The tweak id the settings used to be stored under. */
+  readonly id: string
+  /** Current setting id to the id it used to have. */
+  readonly settings: Readonly<Record<string, string>>
+}
+
 export interface Tweak {
   readonly id: string
   readonly title: string
@@ -37,6 +49,7 @@ export interface Tweak {
   /** Group shown in the `/tweaks` list. */
   readonly category: string
   readonly settings: readonly TweakSetting[]
+  readonly legacy?: TweakLegacy
 }
 
 /** Settings changed from the menu, keyed by tweak and setting id. */
@@ -105,6 +118,12 @@ export function defineTweak(tweak: Tweak): Tweak {
     }
   }
 
+  for (const id of Object.keys(tweak.legacy?.settings ?? {})) {
+    if (!ids.has(id)) {
+      throw new Error(`Legacy setting "${tweak.id}.${id}" is not defined`)
+    }
+  }
+
   return tweak
 }
 

package/src/tweaks/{token-inject.ts → usage-inject.ts}

@@ -52,9 +52,9 @@ const THROUGHPUT = / \d[\d.]* tok\/s/
 const FOOTER_USAGE = /^(?: · )?\d[\d.,]*\s?[KMG]?\s?\(\d+%\)(?:\s·\s\$[\d.,]+){0,2}$/
 /** The line is rebuilt on every token, so a slow repair would lag behind it. */
 const REPAIR_MS = 400
-const BEFORE_ID = "opencode-tweaks.tokens.before"
-const AFTER_ID = "opencode-tweaks.tokens.after"
-const FOOTER_ID = "opencode-tweaks.tokens.footer"
+const BEFORE_ID = "opencode-tweaks.usage.before"
+const AFTER_ID = "opencode-tweaks.usage.after"
+const FOOTER_ID = "opencode-tweaks.usage.footer"
 
 /**
  * Hot reload evaluates this module again while the old repair timers keep
@@ -62,10 +62,10 @@ const FOOTER_ID = "opencode-tweaks.tokens.footer"
  * never reached its own dispose.
  */
 const timers = new Set<ReturnType<typeof setInterval>>()
-const previousTimers = (globalThis as { tokenInjectorTimers?: Set<ReturnType<typeof setInterval>> })
-  .tokenInjectorTimers
+const previousTimers = (globalThis as { usageInjectorTimers?: Set<ReturnType<typeof setInterval>> })
+  .usageInjectorTimers
 for (const timer of previousTimers ?? []) clearInterval(timer)
-;(globalThis as { tokenInjectorTimers?: Set<ReturnType<typeof setInterval>> }).tokenInjectorTimers =
+;(globalThis as { usageInjectorTimers?: Set<ReturnType<typeof setInterval>> }).usageInjectorTimers =
   timers
 
 /**
@@ -229,7 +229,7 @@ export interface InjectorLabels {
   readonly after?: string
 }
 
-export interface TokenInjector {
+export interface UsageInjector {
   /**
    * The figures for the newest footer, tagged with the turn they belong to.
    * Empty fields hide them there.
@@ -257,7 +257,7 @@ interface Placed {
   afterNode?: HostNode
 }
 
-export function createTokenInjector(context: Context): TokenInjector {
+export function createUsageInjector(context: Context): UsageInjector {
   let labels: InjectorLabels = {}
   let key: string | undefined
   let active: HostText | undefined

package/src/tweaks/{token-slots.tsx → usage-slots.tsx}

@@ -1,63 +1,64 @@
 import type { Context, SlotMap } from "@opencode/plugin/tui/context"
 import { createEffect, createMemo, createSignal, onCleanup, Show, untrack } from "solid-js"
-import type { SettingsStore } from "./settings"
-import type { TokenInjector } from "./token-inject"
-import { tokensTweak } from "./tokens"
 import {
   type CostDigits,
   estimateCost,
-  footerMessage,
   formatCost,
-  formatTokens,
   isCostDigits,
   type ModelPrice,
   messagesCost,
   priceFor,
-  replyTurnMessages,
-  sessionTokens,
-  type TokenCount,
-  type TokenMessage,
-  usageTokens,
-} from "./tokens-model"
-import type { TweakSetting } from "./types"
-
-function setting(id: string): TweakSetting {
-  const found = tokensTweak.settings.find((item) => item.id === id)
-  if (!found) throw new Error(`Tokens setting "${id}" is missing`)
+} from "../usage/cost"
+import { footerMessage, replyTurnMessages, type UsageMessage } from "../usage/messages"
+import { formatTokens, sessionTokens, type TokenCount, usageTokens } from "../usage/tokens"
+import { costTweak } from "./cost"
+import type { SettingsStore } from "./settings"
+import { tokensTweak } from "./tokens"
+import type { Tweak, TweakSetting } from "./types"
+import type { UsageInjector } from "./usage-inject"
+
+function setting(tweak: Tweak, id: string): TweakSetting {
+  const found = tweak.settings.find((item) => item.id === id)
+  if (!found) throw new Error(`${tweak.title} setting "${id}" is missing`)
   return found
 }
 
-const ENABLED = setting("enabled")
-const PROMPT = setting("prompt")
-const TOTAL = setting("total")
-const SUBAGENTS = setting("subagents")
-const COUNT = setting("count")
-const PROMPT_COST = setting("promptCost")
-const TOTAL_COST = setting("totalCost")
-const COST_DIGITS = setting("costDigits")
-const ESTIMATE = setting("estimateCost")
-const FORMAT = setting("format")
-const TTFT = setting("ttft")
+const TOKENS_ON = setting(tokensTweak, "enabled")
+const PROMPT = setting(tokensTweak, "prompt")
+const TOTAL = setting(tokensTweak, "total")
+const SUBAGENTS = setting(tokensTweak, "subagents")
+const COUNT = setting(tokensTweak, "count")
+const FORMAT = setting(tokensTweak, "format")
+const TTFT = setting(tokensTweak, "ttft")
+
+const COST_ON = setting(costTweak, "enabled")
+const PROMPT_COST = setting(costTweak, "prompt")
+const TOTAL_COST = setting(costTweak, "total")
+const COST_DIGITS = setting(costTweak, "digits")
+const ESTIMATE = setting(costTweak, "estimate")
 
 /**
- * The two counts, shared by both placements. The prompt count follows the open
- * session because a prompt belongs to it. The total optionally follows the
- * session tree, since a subagent's tokens belong to the turn its parent started.
+ * The figures, shared by both placements. The prompt figures follow the open
+ * session because a prompt belongs to it. The totals optionally follow the
+ * session tree, since a subagent's usage belongs to the turn its parent
+ * started. Tokens and cost can be switched off independently.
  */
-function useCounts(props: {
+function useUsage(props: {
   readonly context: Context
   readonly store: SettingsStore
   readonly sessionID: () => string | undefined
 }) {
-  const enabled = () => props.store.read(tokensTweak, ENABLED).value === true
+  const tokensOn = () => props.store.read(tokensTweak, TOKENS_ON).value === true
+  const costOn = () => props.store.read(costTweak, COST_ON).value === true
   const perPrompt = () => props.store.read(tokensTweak, PROMPT).value === true
   const sessionTotal = () => props.store.read(tokensTweak, TOTAL).value === true
   const subagents = () => props.store.read(tokensTweak, SUBAGENTS).value === true
-  const promptCost = () => props.store.read(tokensTweak, PROMPT_COST).value === true
-  const totalCost = () => props.store.read(tokensTweak, TOTAL_COST).value === true
-  const estimate = () => props.store.read(tokensTweak, ESTIMATE).value === true
+  const promptCost = () => props.store.read(costTweak, PROMPT_COST).value === true
+  const totalCost = () => props.store.read(costTweak, TOTAL_COST).value === true
+  const estimate = () => props.store.read(costTweak, ESTIMATE).value === true
+  const ttft = () => props.store.read(tokensTweak, TTFT).value !== false
   const costDigits = (): CostDigits => {
-    const value = props.store.read(tokensTweak, COST_DIGITS).value
+    const value = props.store.read(costTweak, COST_DIGITS).value
     return isCostDigits(value) ? value : "auto"
   }
   const count = (): TokenCount => {
@@ -157,7 +158,7 @@ function useCounts(props: {
     if (!replied()) return undefined
 
     const lookup = estimate()
-      ? (message: TokenMessage) => {
+      ? (message: UsageMessage) => {
           const tokens = message.tokens
           if (!tokens) return undefined
           return priceOf(message.model, tokens.input + tokens.cache.read)
@@ -170,54 +171,63 @@ function useCounts(props: {
   /** The formatted count, or `undefined` while there is nothing worth showing. */
   const format = (value: number) => (value > 0 ? formatTokens(value, style()) : undefined)
 
-  const promptCount = () => (enabled() && perPrompt() ? format(prompt()) : undefined)
-  const totalCount = () => (enabled() && sessionTotal() ? format(total()) : undefined)
+  const promptCount = () => (tokensOn() && perPrompt() ? format(prompt()) : undefined)
+  const totalCount = () => (tokensOn() && sessionTotal() ? format(total()) : undefined)
   const promptCostLabel = () => {
     const value = cost()
-    return enabled() && promptCost() && value !== undefined
+    return costOn() && promptCost() && value !== undefined
       ? formatCost(value, costDigits())
       : undefined
   }
   const totalCostLabel = () =>
-    enabled() && totalCost() ? formatCost(sessionCost(), costDigits()) : undefined
-
-  return { enabled, promptKey, promptCount, totalCount, promptCostLabel, totalCostLabel }
+    costOn() && totalCost() ? formatCost(sessionCost(), costDigits()) : undefined
+
+  return {
+    enabled: () => tokensOn() || costOn(),
+    // The host keeps its own ttft figure whenever the token tweak is off.
+    ttft: () => !tokensOn() || ttft(),
+    promptKey,
+    promptCount,
+    totalCount,
+    promptCostLabel,
+    totalCostLabel,
+  }
 }
 
 /**
- * Inline placement has no row of its own: it hands the prompt count to the
- * injector, which splices it into the host's tok/s line. The composer slot is
+ * Inline placement has no row of its own: it hands the prompt figures to the
+ * injector, which splices them into the host's tok/s line. The composer slot is
  * claimed anyway because it is the published place that gives the plugin a
  * reactive session context above the prompt; this component renders nothing.
  */
-export function TokenInline(props: {
+export function UsageInline(props: {
   readonly context: Context
   readonly input: SlotMap["session.composer.top"]
   readonly store: SettingsStore
-  readonly injector: TokenInjector
+  readonly injector: UsageInjector
 }) {
-  const counts = useCounts({
+  const usage = useUsage({
     context: props.context,
     store: props.store,
     sessionID: () => props.input.sessionID,
   })
 
   createEffect(() => {
-    if (!counts.enabled()) {
+    if (!usage.enabled()) {
       props.injector.clear()
       return
     }
 
-    props.injector.setTtft(props.store.read(tokensTweak, TTFT).value !== false)
+    props.injector.setTtft(usage.ttft())
 
-    const count = counts.promptCount()
-    const cost = counts.promptCostLabel()
+    const count = usage.promptCount()
+    const cost = usage.promptCostLabel()
     props.injector.setLabels(
       {
         before: count ? ` · ${count} tok` : undefined,
         after: cost ? ` · ${cost}` : undefined,
       },
-      counts.promptKey(),
+      usage.promptKey(),
     )
   })
 
@@ -225,13 +235,13 @@ export function TokenInline(props: {
 }
 
 /** The bottom status line, next to the working directory and the other details. */
-export function TokenStatus(props: {
+export function UsageStatus(props: {
   readonly context: Context
   readonly input: SlotMap["prompt.footer.status"]
   readonly store: SettingsStore
-  readonly injector: TokenInjector
+  readonly injector: UsageInjector
 }) {
-  const counts = useCounts({
+  const usage = useUsage({
     context: props.context,
     store: props.store,
     sessionID: () => props.input.sessionID,
@@ -264,9 +274,9 @@ export function TokenStatus(props: {
 
   const figures = () => {
     const parts: string[] = []
-    const tokens = counts.totalCount()
+    const tokens = usage.totalCount()
     if (tokens) parts.push(`${tokens} tok total`)
-    const cost = counts.totalCostLabel()
+    const cost = usage.totalCostLabel()
     if (cost) parts.push(cost)
     return parts.length > 0 ? parts.join(" · ") : undefined
   }
@@ -291,7 +301,7 @@ export function TokenStatus(props: {
     const present = children()
     if (present === lastPresence) return
     lastPresence = present
-    // The token counters must not re-run this effect: it would cancel the
+    // The usage counters must not re-run this effect: it would cancel the
     // follow-up passes every time a figure changes.
     untrack(repaint)
     const passes = [16, 50, 150].map((delay) => setTimeout(() => untrack(repaint), delay))

package/src/usage/cost.ts

@@ -0,0 +1,92 @@
+import type { MessageTokens, UsageMessage } from "./messages"
+
+/** A model's list price, in dollars per million tokens. */
+export interface ModelPrice {
+  readonly input: number
+  readonly output: number
+  readonly cache: { readonly read: number; readonly write: number }
+  readonly tier?: { readonly size: number }
+}
+
+/**
+ * The price that applies at a context size: the base price, raised by a tier
+ * once the request is large enough. Long-context pricing works this way.
+ */
+export function priceFor(prices: readonly ModelPrice[], context: number): ModelPrice | undefined {
+  let base: ModelPrice | undefined
+  let tiered: ModelPrice | undefined
+
+  for (const price of prices) {
+    const tier = price.tier
+    if (!tier) {
+      base ??= price
+      continue
+    }
+    if (context < tier.size) continue
+    if (!tiered?.tier || tier.size > tiered.tier.size) tiered = price
+  }
+
+  return tiered ?? base ?? prices[0]
+}
+
+/**
+ * The list-price cost of one message's counters. Reasoning is billed at the
+ * output price, as providers do.
+ */
+export function estimateCost(tokens: MessageTokens, price: ModelPrice): number {
+  const { input, output, reasoning, cache } = tokens
+  const total =
+    input * price.input +
+    (output + reasoning) * price.output +
+    cache.read * price.cache.read +
+    cache.write * price.cache.write
+
+  return total / 1_000_000
+}
+
+/** Resolves the list price of one message, if the model is known. */
+export type PriceLookup = (message: UsageMessage) => ModelPrice | undefined
+
+/**
+ * The cost of a list of messages: what the provider reported, or the list-price
+ * estimate when it reported nothing and a price is available.
+ */
+export function messagesCost(messages: readonly UsageMessage[], price?: PriceLookup): number {
+  return messages.reduce((total, message) => {
+    const reported = message.cost ?? 0
+    if (reported > 0) return total + reported
+    if (!price || !message.tokens) return total + reported
+
+    const value = price(message)
+    return total + (value ? estimateCost(message.tokens, value) : reported)
+  }, 0)
+}
+
+export type CostDigits = "auto" | 2 | 3 | 4 | 5 | 6
+
+/**
+ * Dollars with two decimals, or more under a cent so the first significant
+ * digit shows. `auto` picks the decimals; a number fixes them.
+ */
+export function formatCost(value: number, digits: CostDigits = "auto"): string {
+  const cost = Math.max(0, value)
+  const places = digits === "auto" ? autoDigits(cost) : digits
+
+  return new Intl.NumberFormat("en-US", {
+    style: "currency",
+    currency: "USD",
+    minimumFractionDigits: places,
+    maximumFractionDigits: places,
+  }).format(cost)
+}
+
+/** Whether a stored or configured value is a cost digit choice. */
+export function isCostDigits(value: unknown): value is CostDigits {
+  return value === "auto" || value === 2 || value === 3 || value === 4 || value === 5 || value === 6
+}
+
+/** Normal amounts keep two decimals; smaller ones grow until a digit shows. */
+function autoDigits(cost: number): number {
+  if (cost === 0 || cost >= 0.01) return 2
+  return Math.min(6, Math.ceil(-Math.log10(cost)))
+}

package/src/usage/messages.ts

@@ -0,0 +1,67 @@
+/** The token counters OpenCode stores on an assistant message. */
+export interface MessageTokens {
+  readonly input: number
+  readonly output: number
+  readonly reasoning: number
+  readonly cache: { readonly read: number; readonly write: number }
+}
+
+/** Only what usage sums need, so any session message list fits. */
+export interface UsageMessage {
+  readonly id?: string
+  readonly type: string
+  readonly tokens?: MessageTokens
+  readonly cost?: number
+  readonly model?: { readonly providerID: string; readonly id: string }
+  /** How the step ended; the host only draws a footer for a finished one. */
+  readonly finish?: string | null
+  readonly error?: unknown
+  readonly retry?: unknown
+}
+
+/** The index just after the last user prompt before `end`. */
+function turnStart(messages: readonly UsageMessage[], end: number): number {
+  for (let index = end - 1; index >= 0; index--) {
+    if (messages[index]?.type === "user") return index + 1
+  }
+  return 0
+}
+
+/** Where the turn that starts at `start` ends: at the next prompt, or the end. */
+function turnEnd(messages: readonly UsageMessage[], start: number): number {
+  for (let index = start; index < messages.length; index++) {
+    if (messages[index]?.type === "user") return index
+  }
+  return messages.length
+}
+
+/**
+ * The newest message the host draws a footer under. A footer belongs to the
+ * last step of a turn: one that stopped for any reason other than another tool
+ * call, or one that failed or is being retried.
+ */
+export function footerMessage(messages: readonly UsageMessage[]): UsageMessage | undefined {
+  for (let index = messages.length - 1; index >= 0; index--) {
+    const message = messages[index]
+    if (message?.type !== "assistant") continue
+    if (message.error || message.retry) return message
+    if (message.finish && message.finish !== "tool-calls" && message.finish !== "unknown") {
+      return message
+    }
+  }
+  return undefined
+}
+
+/**
+ * The messages of the turn whose footer is on screen. A prompt with no finished
+ * reply yet leaves the previous turn's line there, so that line keeps showing
+ * the previous turn's numbers instead of the running one's.
+ */
+export function replyTurnMessages(messages: readonly UsageMessage[]): readonly UsageMessage[] {
+  const footer = footerMessage(messages)
+  if (!footer) return []
+
+  const last = messages.lastIndexOf(footer)
+  const start = turnStart(messages, last + 1)
+  return messages.slice(start, turnEnd(messages, start))
+}

package/src/usage/tokens.ts

@@ -0,0 +1,56 @@
+import { type MessageTokens, replyTurnMessages, type UsageMessage } from "./messages"
+
+/**
+ * Which counters a count adds up.
+ *
+ * - `new` is what the model actually processed: prompt, completion, reasoning,
+ *   and cache writes, without cache reads. A turn re-reads the whole context at
+ *   every step, so cache reads would dwarf every other counter.
+ * - `generated` is only what the model wrote.
+ * - `all` matches the counters `/stats` reports, cache reads included.
+ */
+export type TokenCount = "new" | "generated" | "all"
+
+/** The tokens in one assistant message's counters under the chosen definition. */
+export function usageTokens(tokens: MessageTokens, mode: TokenCount): number {
+  const { input, output, reasoning, cache } = tokens
+
+  switch (mode) {
+    case "generated":
+      return output + reasoning
+
+    case "new":
+      return input + output + reasoning + cache.write
+
+    case "all":
+      return input + output + reasoning + cache.read + cache.write
+  }
+}
+
+/** The tokens one assistant message spent under the chosen definition. */
+export function messageTokens(message: UsageMessage, mode: TokenCount): number {
+  if (message.type !== "assistant" || !message.tokens) return 0
+  return usageTokens(message.tokens, mode)
+}
+
+/** Every token a session spent under the chosen definition. */
+export function sessionTokens(messages: readonly UsageMessage[], mode: TokenCount): number {
+  return messages.reduce((total, message) => total + messageTokens(message, mode), 0)
+}
+
+/** The tokens that turn spent under the chosen definition. */
+export function replyTurnTokens(messages: readonly UsageMessage[], mode: TokenCount): number {
+  return sessionTokens(replyTurnMessages(messages), mode)
+}
+
+const compact = new Intl.NumberFormat("en-US", { notation: "compact", maximumFractionDigits: 1 })
+const exact = new Intl.NumberFormat("en-US")
+
+/**
+ * `12.4K` in compact style, matching the numbers in `/stats`, or `12,431` for
+ * every digit. Both stay short enough for the prompt footer.
+ */
+export function formatTokens(value: number, style: "compact" | "exact"): string {
+  const total = Math.max(0, Math.round(value))
+  return style === "exact" ? exact.format(total) : compact.format(total)
+}

package/src/tweaks/tokens-model.ts

@@ -1,213 +0,0 @@
-/** The token counters OpenCode stores on an assistant message. */
-export interface MessageTokens {
-  readonly input: number
-  readonly output: number
-  readonly reasoning: number
-  readonly cache: { readonly read: number; readonly write: number }
-}
-
-/** Only what the sum needs, so any session message list fits. */
-export interface TokenMessage {
-  readonly id?: string
-  readonly type: string
-  readonly tokens?: MessageTokens
-  readonly cost?: number
-  readonly model?: { readonly providerID: string; readonly id: string }
-  /** How the step ended; the host only draws a footer for a finished one. */
-  readonly finish?: string | null
-  readonly error?: unknown
-  readonly retry?: unknown
-}
-
-/**
- * Which counters a count adds up.
- *
- * - `new` is what the model actually processed: prompt, completion, reasoning,
- *   and cache writes, without cache reads. A turn re-reads the whole context at
- *   every step, so cache reads would dwarf every other counter.
- * - `generated` is only what the model wrote.
- * - `all` matches the counters `/stats` reports, cache reads included.
- */
-export type TokenCount = "new" | "generated" | "all"
-
-/** The tokens in one assistant message's counters under the chosen definition. */
-export function usageTokens(tokens: MessageTokens, mode: TokenCount): number {
-  const { input, output, reasoning, cache } = tokens
-
-  switch (mode) {
-    case "generated":
-      return output + reasoning
-
-    case "new":
-      return input + output + reasoning + cache.write
-
-    case "all":
-      return input + output + reasoning + cache.read + cache.write
-  }
-}
-
-/** The tokens one assistant message spent under the chosen definition. */
-export function messageTokens(message: TokenMessage, mode: TokenCount): number {
-  if (message.type !== "assistant" || !message.tokens) return 0
-  return usageTokens(message.tokens, mode)
-}
-
-/** Every token a session spent under the chosen definition. */
-export function sessionTokens(messages: readonly TokenMessage[], mode: TokenCount): number {
-  return messages.reduce((total, message) => total + messageTokens(message, mode), 0)
-}
-
-/** The index just after the last user prompt before `end`. */
-function turnStart(messages: readonly TokenMessage[], end: number): number {
-  for (let index = end - 1; index >= 0; index--) {
-    if (messages[index]?.type === "user") return index + 1
-  }
-  return 0
-}
-
-/** Where the turn that starts at `start` ends: at the next prompt, or the end. */
-function turnEnd(messages: readonly TokenMessage[], start: number): number {
-  for (let index = start; index < messages.length; index++) {
-    if (messages[index]?.type === "user") return index
-  }
-  return messages.length
-}
-
-/**
- * The newest message the host draws a footer under. A footer belongs to the
- * last step of a turn: one that stopped for any reason other than another tool
- * call, or one that failed or is being retried.
- */
-export function footerMessage(messages: readonly TokenMessage[]): TokenMessage | undefined {
-  for (let index = messages.length - 1; index >= 0; index--) {
-    const message = messages[index]
-    if (message?.type !== "assistant") continue
-    if (message.error || message.retry) return message
-    if (message.finish && message.finish !== "tool-calls" && message.finish !== "unknown") {
-      return message
-    }
-  }
-  return undefined
-}
-
-/**
- * The messages of the turn whose footer is on screen. A prompt with no finished
- * reply yet leaves the previous turn's line there, so that line keeps showing
- * the previous turn's numbers instead of the running one's.
- */
-export function replyTurnMessages(messages: readonly TokenMessage[]): readonly TokenMessage[] {
-  const footer = footerMessage(messages)
-  if (!footer) return []
-
-  const last = messages.lastIndexOf(footer)
-  const start = turnStart(messages, last + 1)
-  return messages.slice(start, turnEnd(messages, start))
-}
-
-/** The tokens that turn spent under the chosen definition. */
-export function replyTurnTokens(messages: readonly TokenMessage[], mode: TokenCount): number {
-  return sessionTokens(replyTurnMessages(messages), mode)
-}
-
-/** A model's list price, in dollars per million tokens. */
-export interface ModelPrice {
-  readonly input: number
-  readonly output: number
-  readonly cache: { readonly read: number; readonly write: number }
-  readonly tier?: { readonly size: number }
-}
-
-/**
- * The price that applies at a context size: the base price, raised by a tier
- * once the request is large enough. Long-context pricing works this way.
- */
-export function priceFor(prices: readonly ModelPrice[], context: number): ModelPrice | undefined {
-  let base: ModelPrice | undefined
-  let tiered: ModelPrice | undefined
-
-  for (const price of prices) {
-    const tier = price.tier
-    if (!tier) {
-      base ??= price
-      continue
-    }
-    if (context < tier.size) continue
-    if (!tiered?.tier || tier.size > tiered.tier.size) tiered = price
-  }
-
-  return tiered ?? base ?? prices[0]
-}
-
-/**
- * The list-price cost of one message's counters. Reasoning is billed at the
- * output price, as providers do.
- */
-export function estimateCost(tokens: MessageTokens, price: ModelPrice): number {
-  const { input, output, reasoning, cache } = tokens
-  const total =
-    input * price.input +
-    (output + reasoning) * price.output +
-    cache.read * price.cache.read +
-    cache.write * price.cache.write
-
-  return total / 1_000_000
-}
-
-/** Resolves the list price of one message, if the model is known. */
-export type PriceLookup = (message: TokenMessage) => ModelPrice | undefined
-
-/**
- * The cost of a list of messages: what the provider reported, or the list-price
- * estimate when it reported nothing and a price is available.
- */
-export function messagesCost(messages: readonly TokenMessage[], price?: PriceLookup): number {
-  return messages.reduce((total, message) => {
-    const reported = message.cost ?? 0
-    if (reported > 0) return total + reported
-    if (!price || !message.tokens) return total + reported
-
-    const value = price(message)
-    return total + (value ? estimateCost(message.tokens, value) : reported)
-  }, 0)
-}
-
-const compact = new Intl.NumberFormat("en-US", { notation: "compact", maximumFractionDigits: 1 })
-const exact = new Intl.NumberFormat("en-US")
-
-/**
- * `12.4K` in compact style, matching the numbers in `/stats`, or `12,431` for
- * every digit. Both stay short enough for the prompt footer.
- */
-export function formatTokens(value: number, style: "compact" | "exact"): string {
-  const total = Math.max(0, Math.round(value))
-  return style === "exact" ? exact.format(total) : compact.format(total)
-}
-
-/**
- * Dollars with two decimals, or more under a cent so the first significant
- * digit shows. `auto` picks the decimals; a number fixes them.
- */
-export function formatCost(value: number, digits: CostDigits = "auto"): string {
-  const cost = Math.max(0, value)
-  const places = digits === "auto" ? autoDigits(cost) : digits
-
-  return new Intl.NumberFormat("en-US", {
-    style: "currency",
-    currency: "USD",
-    minimumFractionDigits: places,
-    maximumFractionDigits: places,
-  }).format(cost)
-}
-
-export type CostDigits = "auto" | 2 | 3 | 4 | 5 | 6
-
-/** Whether a stored or configured value is a cost digit choice. */
-export function isCostDigits(value: unknown): value is CostDigits {
-  return value === "auto" || value === 2 || value === 3 || value === 4 || value === 5 || value === 6
-}
-
-/** Normal amounts keep two decimals; smaller ones grow until a digit shows. */
-function autoDigits(cost: number): number {
-  if (cost === 0 || cost >= 0.01) return 2
-  return Math.min(6, Math.ceil(-Math.log10(cost)))
-}