@qthinker/opencode-deepseek-search 0.3.0 → 0.4.0

package/src/index.ts

@@ -16,16 +16,19 @@ import { Plugin } from "@opencode/plugin"
 import type { Result as ToolResult, ToolContext } from "@opencode/plugin/promise/tool"
 import type { RpcRegistration } from "@opencode/plugin/promise/rpc"
 import {
+  deepseekBalance,
   deepseekFetch,
   deepseekSearch,
   formatSearchResults,
+  MAX_ORI_CHARS,
   missingKeyMessage,
   validateQuery,
   validateUrl,
+  type SearchExtras,
   type SearchResult,
 } from "./deepseek.ts"
 import { resolveLanguage, t } from "./i18n/index.ts"
-import { DeepSeekRpc, type ModeSwitchResult, type SearchStatus } from "./rpc.ts"
+import { DeepSeekRpc, type BalanceRead, type ModeSwitchResult, type SearchStatus } from "./rpc.ts"
 import {
   USAGE_KEY,
   applyTally,
@@ -55,7 +58,12 @@ type ModeAction = "status" | Mode | "config"
 
 const SEARCH_TOOL_DESCRIPTION =
   "Search the web using DeepSeek Search. Use this for current information beyond knowledge cutoff." +
-  `\n\nThe current year is ${new Date().getFullYear()}. Use this year when searching for recent information or current events.`
+  `\n\nThe current year is ${new Date().getFullYear()}. Use this year when searching for recent information or current events.` +
+  "\n\nThe query supports search operators (they count toward the 128-character limit): " +
+  "site:github.com limits results to a site (combine with OR, e.g. site:github.com OR site:npmjs.com); " +
+  '-site:example.com excludes a site; bare word or -"quoted phrase" excludes matches; ' +
+  '"exact phrase" matches exactly; lang:zh,en limits languages; ' +
+  "after:2025-01-01 and before:2026 limit by publish date. Combine several operators in one query."
 
 // Pure parser: the caller decides how to surface an invalid value (tool error
 // vs. RPC result), so the message can be localized at that call site.
@@ -127,6 +135,7 @@ export default Plugin.define({
     const count = int(opt.count, 5, 1, 50)
     const fetchMaxChars = int(opt.fetchMaxChars, 30_000, 500, 200_000)
     const pricePerThousand = int(opt.pricePerThousand, 5, 0, 10_000)
+    const localization = str(opt.localization)
 
     // ctx.storage offers no compare-and-swap, so every read-modify-write goes
     // through this single in-process chain. Stats must never break a search, so
@@ -157,11 +166,40 @@ export default Plugin.define({
       }).catch(() => {})
     }
 
-    const runSearch = async (query: string, signal: AbortSignal): Promise<SearchResult[]> => {
+    // Best-effort capture of each session's most recent user prompt, sent as the
+    // DeepSeek `ori_question` intent hint. Clamped here at capture time so long
+    // pasted prompts cannot inflate the cache; empty prompts never overwrite a
+    // stored value. The map is capped, and JS Map re-assignment keeps insertion
+    // order, so eviction drops the oldest session.
+    const ORI_SESSION_CAP = 64
+    const oriBySession = new Map<string, string>()
+    let promptHook: { dispose: () => Promise<void> } | undefined
+    try {
+      promptHook = await ctx.session.hook("prompt", (p) => {
+        const text = p.prompt?.text?.trim()
+        if (!text) return
+        if (oriBySession.size >= ORI_SESSION_CAP && !oriBySession.has(p.sessionID)) {
+          const oldest = oriBySession.keys().next().value
+          if (oldest !== undefined) oriBySession.delete(oldest)
+        }
+        oriBySession.set(p.sessionID, text.slice(0, MAX_ORI_CHARS))
+      })
+    } catch (e) {
+      console.error(
+        `[deepseek-search] prompt hook unavailable; ori_question will be omitted ` +
+          `(${e instanceof Error ? e.message : String(e)})`,
+      )
+    }
+
+    const runSearch = async (
+      query: string,
+      signal: AbortSignal,
+      extras?: SearchExtras,
+    ): Promise<SearchResult[]> => {
       const problem = validateQuery(query, language)
       if (problem) throw new Error(problem)
       try {
-        const results = await deepseekSearch(query, apiKey, count, language, signal)
+        const results = await deepseekSearch(query, apiKey, count, language, signal, extras)
         tally(results.length > 0 ? "search" : "empty")
         return results
       } catch (e) {
@@ -175,7 +213,11 @@ export default Plugin.define({
       editor.add({
         id: PROVIDER_ID,
         name: "DeepSeek Search",
-        execute: async (input, context) => runSearch(input?.query ?? "", context.signal),
+        execute: async (input, context) => {
+          // This provider-fallback context carries no sessionID, so `ori_question`
+          // is omitted here by design (see plan D2).
+          return runSearch(input?.query ?? "", context.signal, { localization })
+        },
       })
       if (mode === "deepseek") editor.default.set(PROVIDER_ID)
     })
@@ -204,9 +246,16 @@ export default Plugin.define({
       })
       // Mirror the built-in tool's progress update so long searches are not silent.
       await context.progress({ provider: PROVIDER_ID })
-      const results = await runSearch(query, context.signal)
+      const oriQuestion = oriBySession.get(context.sessionID)
+      const results = await runSearch(query, context.signal, { oriQuestion, localization })
       return {
-        output: { provider: PROVIDER_ID, results },
+        output: {
+          provider: PROVIDER_ID,
+          // Project back to the built-in tool's declared result shape: internal
+          // quality fields (authority/rerankScore) stay out of the tool output.
+          results: results.map((r) => ({ url: r.url, title: r.title, content: r.content, time: r.time })),
+        },
+        // Rendered from the full objects: the [authoritative] marker needs authority.
         content: formatSearchResults(results),
         metadata: { provider: PROVIDER_ID },
       }
@@ -375,13 +424,52 @@ export default Plugin.define({
       })
     })
 
+    // ---------- account balance cache ----------
+    // The sidebars poll `status`, so the balance is cached for a minute: at most
+    // one upstream probe per TTL, shared by every caller. Failures keep the last
+    // good snapshot and back off instead of retrying on every poll.
+    const BALANCE_TTL_MS = 60_000
+    let balanceCache: { value: BalanceRead; at: number } | undefined
+    let balanceInFlight: Promise<void> | undefined
+    let lastBalanceAttemptAt = 0
+    // Never rejects: the balance is decoration on `status`, not a feature that
+    // may break it, so every failure is swallowed here.
+    const refreshBalance = (force: boolean): Promise<void> => {
+      if (!apiKey) return Promise.resolve()
+      if (balanceInFlight) return balanceInFlight
+      const startedAt = Date.now()
+      if (!force) {
+        if (balanceCache && startedAt - balanceCache.at < BALANCE_TTL_MS) return Promise.resolve()
+        if (startedAt - lastBalanceAttemptAt < BALANCE_TTL_MS) return Promise.resolve()
+      }
+      lastBalanceAttemptAt = startedAt
+      const run = (async (): Promise<void> => {
+        try {
+          const value = await deepseekBalance(apiKey, language)
+          balanceCache = { value, at: Date.now() }
+          notifyChanged()
+        } catch {
+          /* keep the previous snapshot */
+        } finally {
+          balanceInFlight = undefined
+        }
+      })()
+      balanceInFlight = run
+      return run
+    }
+
     // ---------- RPC contract (TUI / desktop sidebars) ----------
     // Both sidebars read `status` and call `setMode`; nothing else crosses the
     // process boundary, so the plugin's state stays the single source of truth.
     rpcRegistration = await ctx.rpc.register(DeepSeekRpc, {
       // Reads through `withLedger` so it observes the same serialized chain.
-      status: async (): Promise<SearchStatus> =>
-        withLedger((ledger): SearchStatus => {
+      status: async (input: unknown): Promise<SearchStatus> => {
+        // A manual refresh (the sidebar's refresh button) may ask for a fresh
+        // probe; timer paths send `{}` so old servers still accept the input.
+        const force = (input as { force?: unknown } | undefined)?.force === true
+        // Kicked, not awaited: `status` must stay fast even when the probe hangs.
+        void refreshBalance(force)
+        return withLedger((ledger): SearchStatus => {
           const todayKey = dayKey()
           return {
             mode,
@@ -398,8 +486,12 @@ export default Plugin.define({
               month: sumDays(ledger, (k) => k.startsWith(todayKey.slice(0, 7))),
               total: sumDays(ledger, () => true),
             },
+            // Absent until the first successful probe; `fetchedAt` is stamped by
+            // the cache, so clients can render staleness.
+            balance: balanceCache ? { ...balanceCache.value, fetchedAt: balanceCache.at } : undefined,
           }
-        }),
+        })
+      },
       // The input is plain JSON Schema, hence `unknown`: report, never throw.
       setMode: async (input: unknown): Promise<ModeSwitchResult> => {
         const parsed = readModeAction(input)
@@ -418,7 +510,8 @@ export default Plugin.define({
     console.error(
       `[deepseek-search] loaded: mode=${mode} source=${overrideMode ? "override" : "config"} ` +
         `apiKey=${apiKey ? "present" : "MISSING"} count=${count} ` +
-        `searchTool=${searchToolPatched ? "deepseek" : "untouched"}`,
+        `searchTool=${searchToolPatched ? "deepseek" : "untouched"}` +
+        ` localization=${localization ? "set" : "unset"}`,
     )
     if (!apiKey) console.error(`[deepseek-search] ${missingKeyMessage("en")}`)
     if (overrideMode && overrideMode !== configMode)
@@ -431,5 +524,9 @@ export default Plugin.define({
         `[deepseek-search] warning: built-in ${SEARCH_TOOL} tool not found; search still uses the built-in backend. ` +
           `Set "websearch": { "provider": "${PROVIDER_ID}" } in opencode.jsonc to force the route.`,
       )
+
+    return async () => {
+      await promptHook?.dispose()
+    }
   },
 })

package/src/rpc.ts

@@ -38,11 +38,36 @@ const USAGE_COUNTS_SCHEMA = {
   additionalProperties: false,
 } as const
 
+// Account balance snapshot in `status.balance`. `currency` deliberately has no
+// enum: a value the server could not normalize must not fail the whole payload
+// at output-schema validation time.
+const BALANCE_SCHEMA = {
+  type: "object",
+  properties: {
+    isAvailable: { type: "boolean" },
+    currency: { type: "string" },
+    totalBalance: { type: "string" },
+    grantedBalance: { type: "string" },
+    toppedUpBalance: { type: "string" },
+    fetchedAt: { type: "number" },
+  },
+  required: ["isAvailable", "currency", "totalBalance", "grantedBalance", "toppedUpBalance", "fetchedAt"],
+  additionalProperties: false,
+} as const
+
 export const DeepSeekRpc = {
   id: DEEPSEEK_RPC_ID,
   methods: {
     status: {
-      input: { type: "object", properties: {}, additionalProperties: false },
+      input: {
+        type: "object",
+        properties: {
+          // Only a manual refresh sends `{ force: true }`; timer paths MUST send
+          // `{}`, because older servers reject unknown input properties.
+          force: { type: "boolean" },
+        },
+        additionalProperties: false,
+      },
       output: {
         type: "object",
         properties: {
@@ -67,6 +92,9 @@ export const DeepSeekRpc = {
             required: ["today", "month", "total"],
             additionalProperties: false,
           },
+          // Optional like `counts`: absent while the first probe is in flight, on
+          // servers without the endpoint, or when the API key is missing.
+          balance: BALANCE_SCHEMA,
         },
         required: ["mode", "source", "patched", "hasKey", "pricePerThousand", "today", "month", "total"],
         additionalProperties: false,
@@ -107,6 +135,24 @@ export interface UsageCounts {
   costMicro: number
 }
 
+/**
+ * DeepSeek account balance as reported by `GET /user/balance`.
+ *
+ * `fetchedAt` is epoch milliseconds attached by the server when it caches the
+ * snapshot, so sidebars can show staleness without trusting client clocks.
+ */
+export interface BalanceStatus {
+  isAvailable: boolean
+  currency: string
+  totalBalance: string
+  grantedBalance: string
+  toppedUpBalance: string
+  fetchedAt: number
+}
+
+/** The wire shape of a balance probe, before the cache stamps `fetchedAt`. */
+export type BalanceRead = Omit<BalanceStatus, "fetchedAt">
+
 export interface SearchStatus {
   mode: "deepseek" | "native"
   source: "override" | "config"
@@ -124,6 +170,8 @@ export interface SearchStatus {
   language: Language
   /** Structured counters, so each surface can format for its own width. Optional for older servers. */
   counts?: { today: UsageCounts; month: UsageCounts; total: UsageCounts }
+  /** Last cached balance probe. Absent until the first successful fetch. */
+  balance?: BalanceStatus
 }
 
 export interface ModeSwitchResult {
@@ -151,10 +199,23 @@ function readUsageCounts(value: unknown): UsageCounts | undefined {
   return { search, fetch, empty, failed, costMicro } as UsageCounts
 }
 
+/** Strict read of a cached balance snapshot: all six fields, currency normalized. */
+function readBalance(value: unknown): BalanceStatus | undefined {
+  if (!isRecord(value)) return undefined
+  const { isAvailable, currency, totalBalance, grantedBalance, toppedUpBalance, fetchedAt } = value
+  if (typeof isAvailable !== "boolean") return undefined
+  if (currency !== "CNY" && currency !== "USD") return undefined
+  for (const text of [totalBalance, grantedBalance, toppedUpBalance]) {
+    if (typeof text !== "string" || text.length === 0) return undefined
+  }
+  if (typeof fetchedAt !== "number" || !Number.isFinite(fetchedAt) || fetchedAt < 0) return undefined
+  return { isAvailable, currency, totalBalance, grantedBalance, toppedUpBalance, fetchedAt } as BalanceStatus
+}
+
 /** Defensive read of an RPC `status` result. Never throws. */
 export function readStatus(raw: unknown): SearchStatus | undefined {
   if (!isRecord(raw)) return undefined
-  const { mode, source, patched, hasKey, pricePerThousand, today, month, total, language, counts } = raw
+  const { mode, source, patched, hasKey, pricePerThousand, today, month, total, language, counts, balance } = raw
   if (!isMode(mode)) return undefined
   if (source !== "override" && source !== "config") return undefined
   if (typeof patched !== "boolean" || typeof hasKey !== "boolean") return undefined
@@ -180,6 +241,10 @@ export function readStatus(raw: unknown): SearchStatus | undefined {
     const totalCounts = readUsageCounts(counts.total)
     if (todayCounts && monthCounts && totalCounts) status.counts = { today: todayCounts, month: monthCounts, total: totalCounts }
   }
+  // A missing balance stays absent (no probe yet, no key, older server); a
+  // malformed one is dropped without failing the rest of the payload.
+  const balanceStatus = readBalance(balance)
+  if (balanceStatus) status.balance = balanceStatus
   return status
 }
 

package/src/status-view.ts

@@ -1,7 +1,7 @@
 // Pure view model for the sidebar card. No renderer, no runtime dependency:
 // the card and the tests both derive their text from here.
 import { format, pack, t } from "./i18n/index.ts"
-import type { SearchStatus, UsageCounts, Language } from "./rpc.ts"
+import type { BalanceStatus, SearchStatus, UsageCounts, Language } from "./rpc.ts"
 
 export interface SidebarInput {
   readonly status: SearchStatus | undefined
@@ -41,7 +41,12 @@ export interface SidebarRows {
   readonly hint: string | undefined
   /** Whether a click on `action` really performs it (some states have no action). */
   readonly clickable: boolean
-  /** Body rows: the three usage rows, or the short error reason. */
+  /**
+   * Body rows: the three usage rows (or the single collapsed usage row when
+   * not even the shortest fits), or the short error reason, then the optional
+   * balance row last. A row starting with `!` is an unavailable balance; the
+   * marker is a color directive for the renderer and never part of the copy.
+   */
   readonly lines: readonly string[]
   /** Drives the state color in card.ts. */
   readonly tone: "on" | "off" | "warn" | "error" | "idle"
@@ -150,10 +155,12 @@ function usageLayout(counts: Counts): UsageLayout {
 
 /**
  * One usage row, e.g. `今日  Search 0  Fetch 3  ¥0.015` when the surface is
- * wide, otherwise shorter forms down to `今日`. The ladder is per language:
- * each locale owns the shapes that read well at its widths, so no language is
- * squeezed into another one's budget. Counts are right-aligned in their shared
- * width and every row picks the same form, so the three rows read as a table.
+ * wide, otherwise shorter forms down to the amount or the search count alone.
+ * The ladder is per language: each locale owns the shapes that read well at its
+ * widths, so no language is squeezed into another one's budget. Counts are
+ * right-aligned in their shared width and every row picks the same form, so the
+ * three rows read as a table. `undefined` means not even the shortest rung fits;
+ * the caller then collapses the three rows instead of emitting blanks.
  */
 function compactUsageRow(
   period: Period,
@@ -161,42 +168,54 @@ function compactUsageRow(
   layout: UsageLayout,
   maxColumns: number,
   language: Language,
-): string {
+): string | undefined {
   const label = t(language, LABEL_KEY[period])
   const search = String(counts.search).padStart(layout.search, " ")
   const fetch = String(counts.fetch).padStart(layout.fetch, " ")
   const cost = money(counts.costMicro).padStart(layout.cost, " ")
   const params = { label, search, fetch, cost }
+  const forms = pack(language).usageForms
   // Each candidate is a complete row, so nothing is ever left dangling and no
   // number is ever cut from its unit.
-  for (const form of pack(language).usageForms) {
+  for (const form of forms.slice(0, -1)) {
     const row = format(form, params)
     if (textColumns(row) <= maxColumns) return row
   }
-  return textColumns(label) <= maxColumns ? label : clip(label, maxColumns)
+  // The amount alone outranks the ladder's last rung, a lone search count: money
+  // is what this card is for, and a single counter is not. The row is composed
+  // here because it carries no count, so it is not a locale ladder entry — the
+  // label still comes from the locale table.
+  const amountRow = `${label} ${cost}`
+  if (textColumns(amountRow) <= maxColumns) return amountRow
+  const narrowest = forms[forms.length - 1]
+  if (narrowest !== undefined) {
+    const row = format(narrowest, params)
+    if (textColumns(row) <= maxColumns) return row
+  }
+  return undefined
 }
 
 /**
- * An older server only sends pre-formatted strings, and those are always the
- * Chinese ones this plugin used to send: the filter below is deliberately
- * Chinese-only and stays correct while the UI language changes. Keep the full
- * string when it fits, otherwise drop its trailing segments whole: the amount
- * and the diagnostic counters go first, then the fetch count.
+ * Below the shortest rung no usage row can carry a number, so the three rows
+ * become one that still does: the total cost first (the number this card is
+ * opened for), then the total search count, then the bare amount, which fits
+ * the card floor on its own. A label with no number behind it is a row of noise
+ * and is never emitted.
  */
-function legacyUsageRow(period: Period, text: string, maxColumns: number, language: Language): string {
-  const label = t(language, LABEL_KEY[period])
-  const full = `${label} ${text}`
-  if (textColumns(full) <= maxColumns) return full
-  const stats = text.split(" · ").filter((part) => !part.startsWith("¥") && !part.startsWith("空/失"))
+function collapseUsageRow(counts: UsageCounts, layout: UsageLayout, maxColumns: number, language: Language): string {
+  const label = t(language, LABEL_KEY.total)
+  const cost = money(counts.costMicro)
   const candidates = [
-    `${label} ${stats.join("  ")}`.trimEnd(),
-    `${label} ${stats[0] ?? ""}`.trimEnd(),
-    label,
+    `${label} ${cost.padStart(layout.cost, " ")}`,
+    `${label} ${String(counts.search).padStart(layout.search, " ")}S`,
+    cost,
   ]
   for (const row of candidates) {
     if (textColumns(row) <= maxColumns) return row
   }
-  return clip(label, maxColumns)
+  // Nothing unclipped fits: only a clipped amount is left, and it still shows a
+  // digit as far as the columns allow.
+  return clip(cost, maxColumns)
 }
 
 function usageLines(status: SearchStatus, maxColumns: number, language: Language): readonly string[] {
@@ -212,11 +231,67 @@ function usageLines(status: SearchStatus, maxColumns: number, language: Language
   const counts = status.counts
   if (counts) {
     const layout = usageLayout(counts)
-    return PERIODS.map((period) => compactUsageRow(period, counts[period], layout, maxColumns, language))
+    const rows: string[] = []
+    for (const period of PERIODS) {
+      const row = compactUsageRow(period, counts[period], layout, maxColumns, language)
+      // All three rows share their padded widths, so they either all fit or none
+      // does; the first miss is enough to collapse rather than half a table.
+      if (row === undefined) return [collapseUsageRow(counts.total, layout, maxColumns, language)]
+      rows.push(row)
+    }
+    return rows
   }
   return PERIODS.map((period) => legacyUsageRow(period, status[period], maxColumns, language))
 }
 
+// The server normalizes `currency` to one of these codes, so the symbol is a
+// lookup rather than a formatting library. An unknown code contributes nothing
+// instead of a wrong symbol. The desktop panel reuses it for its account block.
+export const CURRENCY_SYMBOL: Readonly<Record<string, string>> = { CNY: "¥", USD: "$" }
+
+/**
+ * The account-balance row, or `undefined` when it does not fit. The amount is
+ * the server's string verbatim (`110.00`), never re-rounded: DeepSeek's account
+ * balance is authoritative and this row only mirrors it.
+ *
+ * `!` marks an unavailable balance and costs one column; it is the only marker,
+ * so the renderer can turn it into a color and every other consumer keeps a
+ * plain string. The row is never compressed into another one: below its width it
+ * is dropped, because half an amount is worse than no amount.
+ */
+function balanceRow(balance: BalanceStatus, maxColumns: number, language: Language): string | undefined {
+  const marker = balance.isAvailable ? "" : "!"
+  const amount = `${CURRENCY_SYMBOL[balance.currency] ?? ""}${balance.totalBalance}`
+  for (const form of pack(language).balanceForms) {
+    const row = `${marker}${format(form, { amount })}`
+    if (textColumns(row) <= maxColumns) return row
+  }
+  return undefined
+}
+
+/**
+ * An older server only sends pre-formatted strings, and those are always the
+ * Chinese ones this plugin used to send: the filter below is deliberately
+ * Chinese-only and stays correct while the UI language changes. Keep the full
+ * string when it fits, otherwise drop its trailing segments whole: the amount
+ * and the diagnostic counters go first, then the fetch count.
+ */
+function legacyUsageRow(period: Period, text: string, maxColumns: number, language: Language): string {
+  const label = t(language, LABEL_KEY[period])
+  const full = `${label} ${text}`
+  if (textColumns(full) <= maxColumns) return full
+  const stats = text.split(" · ").filter((part) => !part.startsWith("¥") && !part.startsWith("空/失"))
+  const candidates = [
+    `${label} ${stats.join("  ")}`.trimEnd(),
+    `${label} ${stats[0] ?? ""}`.trimEnd(),
+    label,
+  ]
+  for (const row of candidates) {
+    if (textColumns(row) <= maxColumns) return row
+  }
+  return clip(label, maxColumns)
+}
+
 /**
  * The clickable label, always bracketed: a bare two-character verb is an easy
  * target to miss. At pathological widths the verb is clipped but the brackets
@@ -243,12 +318,17 @@ interface TitleFit {
  * and the title keeps the full width, and only then do the product name and the
  * wordy state shrink. Within one wording the glyph is the first thing to go,
  * because it costs two columns and the state word is right beside it.
+ *
+ * `allowActionBelow` is false on a card whose body is already full: giving the
+ * action its own row would push the card past its height budget, so the title
+ * shrinks instead — the action row always wins, because it is the only control.
  */
 function fitTitle(
   state: string,
   shortState: string,
   maxColumns: number,
   actionColumns: number | undefined,
+  allowActionBelow = true,
 ): TitleFit {
   const budget = (glyph: boolean, actionBelow: boolean): number => {
     if (maxColumns === Number.POSITIVE_INFINITY) return Number.POSITIVE_INFINITY
@@ -265,7 +345,7 @@ function fitTitle(
   ]
   // Inline first, then the action below it; a wording is never traded for a
   // shorter one that happens to fit inline, because the wording is the point.
-  const placements = actionColumns === undefined ? [false] : [false, true]
+  const placements = actionColumns === undefined || !allowActionBelow ? [false] : [false, true]
   for (const candidate of candidates) {
     for (const actionBelow of placements) {
       for (const glyph of [true, false]) {
@@ -276,8 +356,9 @@ function fitTitle(
     }
   }
   // Nothing fits whole at a pathological width: clip the state and give the
-  // action its own row so the hit area never disappears.
-  const actionBelow = actionColumns !== undefined
+  // action its own row so the hit area never disappears — unless the body has
+  // already spent that row, in which case the clipped title shares the width.
+  const actionBelow = allowActionBelow && actionColumns !== undefined
   return { title: clip(shortState, budget(false, actionBelow)), glyph: false, actionBelow }
 }
 
@@ -296,15 +377,36 @@ interface ActionRows extends TitleFit {
 }
 
 /** Fit the action first: the title can only use the columns it leaves over. */
-function actionRows(state: string, shortState: string, verb: string, maxColumns: number): ActionRows {
+function actionRows(
+  state: string,
+  shortState: string,
+  verb: string,
+  maxColumns: number,
+  allowActionBelow = true,
+): ActionRows {
   const action = fitAction(verb, maxColumns)
-  return { ...fitTitle(state, shortState, maxColumns, textColumns(action)), action }
+  return { ...fitTitle(state, shortState, maxColumns, textColumns(action), allowActionBelow), action }
 }
 
 export function sidebarRows(input: SidebarInput): SidebarRows {
   const { status, error, language } = input
   const maxColumns = input.maxColumns ?? DEFAULT_COLUMNS
-  const lines = status === undefined ? [] : usageLines(status, maxColumns, language)
+  const usage = status === undefined ? [] : usageLines(status, maxColumns, language)
+  // Only the two states that really point at the account show it: an enabled
+  // takeover or an explicit native mode. A state where nothing is taken over, a
+  // missing key, or a failed read leaves the body to usage and the error reason.
+  const balance =
+    status !== undefined &&
+    ((status.patched && status.hasKey) || status.mode === "native") &&
+    status.balance !== undefined
+      ? balanceRow(status.balance, maxColumns, language)
+      : undefined
+  // The balance row closes the body: the three usage rows read as the receipt
+  // (what this machine spent) and the account truth lands under them (what is
+  // left to spend). It still costs one body row, so the header must keep the
+  // action inline to stay within five rows.
+  const lines = balance === undefined ? usage : [...usage, balance]
+  const allowActionBelow = balance === undefined
 
   // No status yet: the body has no numbers to show, only the reason (or that
   // the first read is still in flight).
@@ -329,7 +431,13 @@ export function sidebarRows(input: SidebarInput): SidebarRows {
 
   if (status.patched && status.hasKey) {
     return {
-      ...actionRows(t(language, "state.enabled"), t(language, "state.enabledShort"), t(language, "action.disable"), maxColumns),
+      ...actionRows(
+        t(language, "state.enabled"),
+        t(language, "state.enabledShort"),
+        t(language, "action.disable"),
+        maxColumns,
+        allowActionBelow,
+      ),
       hint: undefined,
       clickable: true,
       lines,
@@ -345,6 +453,7 @@ export function sidebarRows(input: SidebarInput): SidebarRows {
         t(language, "state.unpatchedShort"),
         t(language, "action.release"),
         maxColumns,
+        allowActionBelow,
       ),
       hint: undefined,
       clickable: true,
@@ -354,7 +463,13 @@ export function sidebarRows(input: SidebarInput): SidebarRows {
   }
   if (status.mode === "native") {
     return {
-      ...actionRows(t(language, "state.disabled"), t(language, "state.disabledShort"), t(language, "action.enable"), maxColumns),
+      ...actionRows(
+        t(language, "state.disabled"),
+        t(language, "state.disabledShort"),
+        t(language, "action.enable"),
+        maxColumns,
+        allowActionBelow,
+      ),
       hint: undefined,
       clickable: true,
       lines,