@opencode-cockpit/status 0.3.0 → 0.3.1

package/examples/gallery.ts

@@ -0,0 +1,209 @@
+/**
+ * Every technique the renderer can draw, in one column, labelled.
+ *
+ * Not a statusline — a catalogue. A segment can only return styled runs of text, so "what can I
+ * draw?" has a finite answer, and nobody can design against a list of segment names. Preview it
+ * and copy the row you want:
+ *
+ *   bunx @opencode-cockpit/status preview --module <this file> --state working
+ *
+ * The bounds, so they are written down somewhere: a run carries a foreground colour (a theme tone
+ * or a hex), a background, bold and dim. A segment draws one row, or an array of rows. There are
+ * no borders, no images and no HTML — this is a terminal, and the freedom is in colour, in block
+ * glyphs, and in alignment.
+ */
+
+import type { CustomModule, Piece, Run, StatusContext, Tone } from "@opencode-cockpit/status/segment"
+import { contextRatio, gradient } from "@opencode-cockpit/status/segment"
+
+const W = 16
+const ratio = (ctx: StatusContext) => contextRatio(ctx.session) ?? 0.42
+
+/** A label column, so a catalogue of rows reads as a table. */
+function labelled(label: string, runs: Run[]): { runs: Run[] } {
+  return { runs: [{ text: label.padEnd(11), tone: "muted", dim: true }, ...runs] }
+}
+
+/** Eighths, for a bar that resolves more than one cell at a time. */
+const EIGHTHS = ["", "▏", "▎", "▍", "▌", "▋", "▊", "▉"]
+
+export default {
+  segments: {
+    /** Solid fill against a solid dark track. The safest bar: no gaps, no dashes. */
+    barSolid(ctx: StatusContext) {
+      const filled = Math.round(ratio(ctx) * W)
+      return labelled("solid", [
+        { text: "▕", tone: "border" },
+        ...Array.from({ length: W }, (_, c) =>
+          c < filled ? { text: "█", tone: "accent" as const } : { text: "█", tone: "border" as const },
+        ),
+        { text: "▏", tone: "border" },
+      ])
+    },
+
+    /** The same bar, each filled cell coloured by the level it stands for. */
+    barGradient(ctx: StatusContext) {
+      const filled = Math.round(ratio(ctx) * W)
+      return labelled("gradient", [
+        { text: "▕", tone: "border" },
+        ...Array.from({ length: W }, (_, c) =>
+          c < filled ? { text: "█", color: gradient((c + 1) / W) } : { text: "█", tone: "border" as const },
+        ),
+        { text: "▏", tone: "border" },
+      ])
+    },
+
+    /** Eighths resolve a fraction of a cell — worth it when the bar is short. */
+    barFine(ctx: StatusContext) {
+      const exact = ratio(ctx) * W
+      const full = Math.floor(exact)
+      const part = EIGHTHS[Math.floor((exact - full) * 8)] ?? ""
+      return labelled("fine", [
+        { text: "█".repeat(full), tone: "accent" },
+        ...(part ? [{ text: part, tone: "accent" as const }] : []),
+        { text: "█".repeat(Math.max(0, W - full - (part ? 1 : 0))), tone: "border" },
+      ])
+    },
+
+    /** One bar coloured by what fills it, for a quantity made of parts. */
+    barSplit(ctx: StatusContext) {
+      const tokens = ctx.session?.tokens
+      if (!tokens) return undefined
+      const total = tokens.input + tokens.output + tokens.cache.read + tokens.cache.write
+      const cells = (n: number) => Math.round((n / total) * W * ratio(ctx))
+      return labelled("split", [
+        { text: "█".repeat(cells(tokens.cache.read)), tone: "success" },
+        { text: "█".repeat(cells(tokens.input)), tone: "info" },
+        { text: "█".repeat(cells(tokens.output)), tone: "accent" },
+        { text: "█".repeat(Math.max(0, W - Math.round(ratio(ctx) * W))), tone: "border" },
+      ])
+    },
+
+    /** Discrete steps, when the number is a count rather than a proportion. */
+    barSteps(ctx: StatusContext) {
+      const filled = Math.round(ratio(ctx) * 10)
+      return labelled("steps", [
+        {
+          text: Array.from({ length: 10 }, (_, c) => (c < filled ? "▮" : "▯")).join(""),
+          tone: "accent",
+        },
+      ])
+    },
+
+    /** A bar drawn in background colour: taller-looking, and it keeps text on top of it. */
+    barFilled(ctx: StatusContext) {
+      const filled = Math.round(ratio(ctx) * W)
+      return labelled("background", [
+        { text: " ".repeat(filled), bgTone: "accent" },
+        { text: " ".repeat(W - filled), bgTone: "panel" },
+        { text: ` ${Math.round(ratio(ctx) * 100)}%`, tone: "muted" },
+      ])
+    },
+
+    /**
+     * Background *and* level colour: the chunkiest bar available, because nothing is drawn at
+     * all — every cell is a painted space, so there is no glyph shape to read around.
+     */
+    barPaint(ctx: StatusContext) {
+      const filled = Math.round(ratio(ctx) * W)
+      return labelled("paint", [
+        ...Array.from({ length: W }, (_, c) =>
+          c < filled ? { text: " ", bg: gradient((c + 1) / W) } : { text: " ", bgTone: "border" as const },
+        ),
+        { text: ` ${Math.round(ratio(ctx) * 100)}%`, color: gradient(ratio(ctx)) },
+      ])
+    },
+
+    /**
+     * Braille packs two columns per cell, so a bar is twice the resolution in the same width.
+     * It is also the smallest thing here — good beside text, poor as a headline.
+     */
+    barBraille(ctx: StatusContext) {
+      const dots = Math.round(ratio(ctx) * W * 2)
+      const cells = Array.from({ length: W }, (_, c) => {
+        const left = dots > c * 2
+        const right = dots > c * 2 + 1
+        return left && right ? "⣿" : left ? "⡇" : "⠀"
+      })
+      return labelled("braille", [{ text: cells.join(""), tone: "accent" }])
+    },
+
+    /** A sparkline: only worth it for history, and only where movement is acceptable. */
+    spark() {
+      const points = [0.1, 0.18, 0.3, 0.28, 0.46, 0.52, 0.5, 0.71]
+      return labelled("sparkline", [
+        {
+          text: points.map((p) => "▁▂▃▄▅▆▇█"[Math.min(7, Math.floor(p * 8))]).join(""),
+          tone: "info",
+        },
+      ])
+    },
+
+    /** Markers: a rule reads at one column wide, a chip needs the width of its text. */
+    markers() {
+      return labelled("markers", [
+        { text: "▌", tone: "success" },
+        { text: "rule  ", tone: "muted" },
+        { text: "▪ ", tone: "warning" },
+        { text: "dot  ", tone: "muted" },
+        { text: " chip ", tone: "background", bgTone: "info", bold: true },
+      ])
+    },
+
+    /** Separating things: a hairline, an inline pipe, and plain space. */
+    dividers() {
+      return labelled("dividers", [
+        { text: "──────", tone: "border", dim: true },
+        { text: "  │  ", tone: "border" },
+        { text: "· · ·", tone: "border", dim: true },
+      ])
+    },
+
+    /**
+     * Emphasis, and a warning: a terminal with no bold face draws bold exactly like plain, so
+     * emphasis is a bonus and never the thing that carries the meaning. Colour always renders.
+     */
+    emphasis() {
+      return labelled("emphasis", [
+        { text: "bold ", tone: "text", bold: true },
+        { text: "plain ", tone: "text" },
+        { text: "dim ", tone: "muted", dim: true },
+        { text: "ital", tone: "text", italic: true },
+      ])
+    },
+
+    /** Underline, and the reliable way to make a run shout: give it a background. */
+    emphasis2() {
+      return labelled("", [
+        { text: "underline ", tone: "text", underline: true },
+        { text: " on a background ", tone: "background", bgTone: "accent" },
+      ])
+    },
+
+    /** Every tone, so a design can be picked from what the theme actually provides. */
+    /**
+     * Every tone the theme provides, over two rows — one row is cut short in a sidebar column,
+     * which is exactly the kind of thing you only find by looking at it.
+     */
+    tones(): Piece[] {
+      const show = (names: readonly Tone[]) => names.map((tone) => ({ text: `${tone} `, tone }))
+      return [
+        labelled("tones", show(["text", "muted", "accent", "success"])),
+        labelled("", show(["warning", "error", "info", "border"])),
+      ]
+    },
+
+    /**
+     * Several rows from one segment — a gauge, a table, a row per item. Returning an array is how
+     * any repeated element is drawn; it is not one row containing newlines.
+     */
+    rows(ctx: StatusContext): Piece[] {
+      const pct = Math.round(ratio(ctx) * 100)
+      return [
+        labelled("rows", [{ text: "one segment,", tone: "muted" }]),
+        labelled("", [{ text: `three rows — ${pct}%`, tone: "muted" }]),
+        labelled("", [{ text: "returned as an array", tone: "muted" }]),
+      ]
+    },
+  },
+} satisfies CustomModule

package/examples/sidebar-budget.ts

@@ -0,0 +1,257 @@
+/**
+ * A sidebar built as a table: a context header, the window as one solid bar, the tokens broken
+ * into named rows, a budget read from a proxy, and the branch's whole diff.
+ *
+ * This is the layout a user arrived at after five rejected iterations, kept here because the
+ * reasons are worth more than the rows: every number gets a word, the labels are a fixed column
+ * so the values line up, the bar is solid rather than dashed, and the groups are separated by
+ * hairlines rather than headings — a heading cannot know whether the rows under it will draw.
+ *
+ *   {
+ *     "statusline": {
+ *       "modules": ["<this file>"],
+ *       "lines": [{
+ *         "surface": "sidebar",
+ *         "maxRows": 13,
+ *         "segments": ["title", "bar", "tokens", "in", "out", "cache", "write",
+ *                      "sep", "spend", "avail", "sep", "git"]
+ *       }]
+ *     }
+ *   }
+ *
+ * It replaces OpenCode's own Context block, so turn that off:
+ *   { "plugin_enabled": { "internal:sidebar-context": false } }
+ *
+ * The budget rows read a file a proxy writes. Without one they stay silent, which is right in a
+ * statusline and unhelpful while you are designing — `"demo": true` on either segment fills in
+ * sample figures so the layout can be looked at.
+ */
+
+import { execFile } from "node:child_process"
+import { readFileSync } from "node:fs"
+import { homedir } from "node:os"
+import { join } from "node:path"
+import type { CustomModule, Piece, Run, SegmentConfig, StatusContext } from "@opencode-cockpit/status/segment"
+import { compact, contextRatio, contextUsed, gradient } from "@opencode-cockpit/status/segment"
+
+/** The label column, padded so every value starts in the same place. */
+const LABEL = 6
+function row(label: string, value: Run[]): { runs: Run[] } {
+  return { runs: [{ text: label.padEnd(LABEL), tone: "muted", dim: true }, ...value] }
+}
+
+/** A marker in a category colour, so the label and the colour say the same thing twice. */
+function mark(tone: "success" | "info" | "text" | "warning"): Run {
+  return { text: "▪ ", tone }
+}
+
+const BAR = 16
+
+/** What each token row needs: its own figure, and its share of the window. */
+function share(ctx: StatusContext, value: number, tone: "success" | "info" | "text" | "warning") {
+  const total = contextUsed(ctx.session?.tokens)
+  if (total === 0) return undefined
+  return [
+    mark(tone),
+    { text: compact(value), tone: "muted" as const },
+    { text: ` · ${Math.round((value / total) * 100)}%`, tone: "muted" as const, dim: true },
+  ]
+}
+
+/**
+ * The spend a proxy reports. LiteLLM's IAP plugin writes this; anything that writes
+ * `{ baseline, delta, cap }` will do. Re-read at most every five seconds — the file is tiny, but
+ * a statusline redraws every second and this is not worth a syscall each time.
+ */
+interface Spend {
+  baseline?: number
+  delta?: number
+  cap?: number
+}
+let cached: { at: number; spend: Spend | undefined } | undefined
+function spendState(config: SegmentConfig): { total: number; cap: number } | undefined {
+  if (config.demo === true) return { total: 26.24, cap: 200 }
+  const now = Date.now()
+  if (!cached || now - cached.at > 5000) {
+    const file =
+      typeof config.file === "string"
+        ? config.file
+        : join(homedir(), ".cache", "opencode-litellm-iap", "spend.json")
+    try {
+      cached = { at: now, spend: JSON.parse(readFileSync(file, "utf8")) as Spend }
+    } catch {
+      cached = { at: now, spend: undefined }
+    }
+  }
+  const { baseline, delta, cap } = cached.spend ?? {}
+  if (typeof baseline !== "number" || typeof cap !== "number" || cap <= 0) return undefined
+  return { total: baseline + (typeof delta === "number" ? delta : 0), cap }
+}
+
+/** Green with room, amber as it tightens, red when it is nearly gone. */
+function budgetColour(left: number): string {
+  return left >= 0.5 ? "#39d353" : left >= 0.2 ? "#e8b923" : "#f85149"
+}
+
+/**
+ * The branch's whole diff against where it forked: every commit on the branch plus uncommitted
+ * edits — what a reviewer would read, rather than what this session happened to touch. Git runs
+ * away from the draw path and the row shows whatever the last finished reading produced.
+ */
+interface BranchDiff {
+  files: number
+  added: number
+  removed: number
+}
+let branch: BranchDiff | undefined
+let asking = false
+let askedAt = 0
+function refreshBranch(ctx: StatusContext): void {
+  if (asking || Date.now() - askedAt < 10_000) return
+  asking = true
+  const base = ctx.defaultBranch ?? "main"
+  const run = execFile as unknown as (
+    cmd: string,
+    args: string[],
+    opts: { timeout: number; cwd: string },
+    cb: (err: Error | null, out: string) => void,
+  ) => void
+  const opts = { timeout: 3000, cwd: ctx.worktree }
+  run("git", ["merge-base", base, "HEAD"], opts, (err, fork) => {
+    if (err || !fork.trim()) {
+      asking = false
+      askedAt = Date.now()
+      return
+    }
+    run("git", ["diff", "--shortstat", fork.trim()], opts, (err2, out) => {
+      asking = false
+      askedAt = Date.now()
+      if (err2) return
+      const found = /(\d+) files? changed(?:, (\d+) insertions?)?(?:, (\d+) deletions?)?/.exec(out)
+      if (!found) return
+      branch = {
+        files: Number(found[1]),
+        added: Number(found[2] ?? 0),
+        removed: Number(found[3] ?? 0),
+      }
+    })
+  })
+}
+
+export default {
+  segments: {
+    /** The column's subject, so the table below it has one. */
+    title() {
+      return { runs: [{ text: "Context", tone: "text", bold: true }] }
+    },
+
+    /**
+     * One solid bar: filled cells coloured by level, empty cells a solid dark track. Not `░`,
+     * which reads as floating gaps, and not `─`, which reads as a row of dashes.
+     *
+     * No end caps. `▕` and `▏` are eighth-blocks whose ink sits against one edge of the cell, so an
+     * opening cap indents the row by most of a column and the bar stops lining up with the labels
+     * above and below it. The dark track already shows how far the bar could go.
+     *
+     * No figure beside it either: the `tokens` row directly below already reads the percentage out,
+     * and a number printed twice in a column of ten rows is the thing the eye catches on.
+     */
+    bar(ctx: StatusContext) {
+      const ratio = contextRatio(ctx.session)
+      if (ratio === undefined) return undefined
+      const filled = Math.round(ratio * BAR)
+      const runs: Run[] = Array.from({ length: BAR }, (_, cell) =>
+        cell < filled
+          ? { text: "█", color: gradient((cell + 1) / BAR) }
+          : { text: "█", tone: "border" as const },
+      )
+      return { runs }
+    },
+
+    /** The whole window, and how full it is. */
+    tokens(ctx: StatusContext) {
+      const total = contextUsed(ctx.session?.tokens)
+      if (total === 0) return undefined
+      const ratio = contextRatio(ctx.session)
+      return row("tokens", [
+        { text: compact(total), tone: "text" },
+        ...(ratio === undefined ? [] : [{ text: ` · ${Math.round(ratio * 100)}%`, color: gradient(ratio) }]),
+      ])
+    },
+
+    /** Fresh prompt tokens: neither cached nor generated. */
+    in(ctx: StatusContext) {
+      const value = share(ctx, ctx.session?.tokens?.input ?? 0, "info")
+      return value && row("in", value)
+    },
+
+    /** What the model wrote, reasoning included. */
+    out(ctx: StatusContext) {
+      const tokens = ctx.session?.tokens
+      const value = share(ctx, (tokens?.output ?? 0) + (tokens?.reasoning ?? 0), "text")
+      return value && row("out", value)
+    },
+
+    /** Served from the prompt cache — cheap, and usually most of the window. */
+    cache(ctx: StatusContext) {
+      const value = share(ctx, ctx.session?.tokens?.cache.read ?? 0, "success")
+      return value && row("cache", value)
+    },
+
+    /** Written into the cache this session — a one-time premium each. Not the same as "out". */
+    write(ctx: StatusContext) {
+      const value = share(ctx, ctx.session?.tokens?.cache.write ?? 0, "warning")
+      return value && row("write", value)
+    },
+
+    /** A hairline, to group without a heading that might strand itself. */
+    sep() {
+      return { runs: [{ text: "─".repeat(14), tone: "border", dim: true }] }
+    },
+
+    /** Spent so far against the cap. */
+    spend(_ctx: StatusContext, config: SegmentConfig) {
+      const state = spendState(config)
+      if (!state) return undefined
+      const colour = budgetColour(Math.max(0, state.cap - state.total) / state.cap)
+      return row("spend", [
+        { text: "▪ ", color: colour },
+        { text: `$${state.total.toFixed(2)}`, color: colour, bold: true },
+      ])
+    },
+
+    /** What is left, and the share of the cap that decides the colour. */
+    avail(_ctx: StatusContext, config: SegmentConfig) {
+      const state = spendState(config)
+      if (!state) return undefined
+      const left = Math.max(0, state.cap - state.total)
+      const ratio = left / state.cap
+      const colour = budgetColour(ratio)
+      return row("avail", [
+        { text: "▪ ", color: colour },
+        { text: `$${left.toFixed(2)}`, color: colour, bold: true },
+        { text: ` · ${Math.round(ratio * 100)}%`, color: colour },
+      ])
+    },
+
+    /** The branch as a reviewer will see it, not as this session left it. */
+    git(ctx: StatusContext, config: SegmentConfig): Piece | undefined {
+      if (config.demo === true) {
+        return row("git", [
+          { text: "3f", tone: "muted" },
+          { text: " +42", tone: "success" },
+          { text: " -7", tone: "error" },
+          { text: ` vs ${ctx.defaultBranch ?? "main"}`, tone: "muted", dim: true },
+        ])
+      }
+      refreshBranch(ctx)
+      if (!branch || branch.files === 0) return undefined
+      return row("git", [
+        { text: `${branch.files}f`, tone: "muted" },
+        { text: ` +${compact(branch.added)}`, tone: "success" },
+        { text: ` -${compact(branch.removed)}`, tone: "error" },
+        { text: ` vs ${ctx.defaultBranch ?? "main"}`, tone: "muted", dim: true },
+      ])
+    },
+  },
+} satisfies CustomModule

package/examples/sidebar-full.ts

@@ -0,0 +1,160 @@
+/**
+ * The sidebar as the whole instrument panel, for people who would rather not read a line under
+ * the prompt at all.
+ *
+ * This one is meant to *replace* OpenCode's own Context block rather than sit beside it, so it
+ * carries the figures that block carried — tokens, percentage, spend — and then the ones it never
+ * did. Turn the host's block off and give the column to this:
+ *
+ *   // ~/.config/opencode/tui.json
+ *   { "plugin": ["opencode-cockpit"], "plugin_enabled": { "internal:sidebar-context": false } }
+ *
+ *   // ~/.config/opencode-cockpit/config.json
+ *   {
+ *     "statusline": {
+ *       "modules": ["<this file>"],
+ *       "surface": "sidebar",
+ *       "segments": [
+ *         { "type": "text", "value": "CONTEXT", "color": "border" },
+ *         "gauge", "window", "cache",
+ *         { "type": "text", "value": "SPEND", "color": "border" },
+ *         "spend",
+ *         { "type": "text", "value": "SESSION", "color": "border" },
+ *         "elapsed", "work", "tasks"
+ *       ],
+ *       "maxRows": 14
+ *     }
+ *   }
+ *
+ * Every row is self-labelled and built to read at about thirty characters, and there are
+ * deliberately no section headings: a heading cannot know whether the rows under it will draw
+ * anything, so on an unpriced model a "SPEND" title strands itself above nothing.
+ *
+ * `tasks` is here but left out of the config above, because OpenCode's own Todo list carries the
+ * task names and this is only a count. Add it if you switch that list off too
+ * (`internal:sidebar-todo`).
+ */
+
+import type { CustomModule, Run, StatusContext } from "@opencode-cockpit/status/segment"
+import {
+  compact,
+  contextRatio,
+  contextUsed,
+  gradient,
+  money,
+  preciseDuration,
+} from "@opencode-cockpit/status/segment"
+
+/** Spend samples, so a rate can be shown beside the total. */
+const samples: { at: number; cost: number }[] = []
+
+/** A row of label and value, so a column of them lines up as a table would. */
+function row(label: string, value: Run[]): { runs: Run[] } {
+  return { runs: [{ text: `${label} `, tone: "muted", dim: true }, ...value] }
+}
+
+export default {
+  segments: {
+    /** The headline figure, and the one the host's block led with. */
+    bar(ctx: StatusContext, config) {
+      const ratio = contextRatio(ctx.session)
+      if (ratio === undefined) return undefined
+      const width = typeof config.width === "number" ? config.width : 16
+      const filled = Math.round(ratio * width)
+      const runs: Run[] = []
+      for (let cell = 0; cell < width; cell++) {
+        runs.push(
+          cell < filled
+            ? { text: "█", color: gradient((cell + 1) / width) }
+            : { text: "░", tone: "border" as const },
+        )
+      }
+      runs.push({
+        text: ` ${Math.round(ratio * 100)}%`,
+        color: gradient(ratio),
+        bold: ratio >= 0.85,
+      })
+      return { runs }
+    },
+
+    /** What the percentage is a percentage of — the denominator the bar hides. */
+    window(ctx: StatusContext) {
+      const used = contextUsed(ctx.session?.tokens)
+      const limit = ctx.session?.model?.contextLimit
+      if (used === 0) return undefined
+      return limit
+        ? row("of", [
+            { text: compact(used), tone: "text" },
+            { text: ` / ${compact(limit)}`, tone: "muted" },
+          ])
+        : row("used", [{ text: `${compact(used)} tok`, tone: "text" }])
+    },
+
+    /**
+     * What was replayed from cache against what had to be sent fresh — the two figures side by
+     * side rather than a share of them. A share reads as "100%" for most of a cached session,
+     * which looks like a bug even when it is arithmetic.
+     */
+    cached(ctx: StatusContext) {
+      const tokens = ctx.session?.tokens
+      if (!tokens || contextUsed(tokens) === 0) return undefined
+      const fresh = tokens.input + tokens.output + tokens.reasoning
+      return row("cache", [
+        { text: compact(tokens.cache.read), tone: "success" },
+        { text: " · fresh ", tone: "muted", dim: true },
+        { text: compact(fresh), tone: "info" },
+      ])
+    },
+
+    /** What the session has cost, and what it is costing. Silent where nobody declared prices. */
+    spend(ctx: StatusContext) {
+      const session = ctx.session
+      if (!session?.priced) return undefined
+      const last = samples[samples.length - 1]
+      if (!last || ctx.now - last.at >= 1000) samples.push({ at: ctx.now, cost: session.cost })
+      if (samples.length > 60) samples.shift()
+
+      const first = samples[0]
+      const latest = samples[samples.length - 1]
+      const runs: Run[] = [{ text: money(session.cost), tone: "warning" }]
+      if (first && latest && latest.at > first.at) {
+        const perMinute = ((latest.cost - first.cost) / (latest.at - first.at)) * 60_000
+        if (perMinute >= 0.005) {
+          runs.push({ text: ` · $${perMinute.toFixed(2)}/min`, tone: "muted", dim: true })
+        }
+      }
+      return { runs }
+    },
+
+    /** How long this has been going, in a unit a person reads without converting. */
+    elapsed(ctx: StatusContext) {
+      const started = ctx.session?.startedAt
+      if (started === undefined) return undefined
+      return row("for", [{ text: preciseDuration(ctx.now - started), tone: "muted" }])
+    },
+
+    /** What the session has done to the tree. */
+    changes(ctx: StatusContext) {
+      const diff = ctx.session?.diff
+      if (!diff || diff.files === 0) return undefined
+      return row("diff", [
+        { text: `+${compact(diff.additions)}`, tone: "success" },
+        { text: ` -${compact(diff.deletions)}`, tone: "error" },
+        { text: ` · ${diff.files}f`, tone: "muted", dim: true },
+      ])
+    },
+
+    /**
+     * Work outstanding, for a sidebar where OpenCode's own Todo list is switched off. With that
+     * list on, this is a worse copy of it — the list carries the task names.
+     */
+    todo(ctx: StatusContext) {
+      const todo = ctx.session?.todo
+      if (!todo || todo.total === 0 || todo.completed === todo.total) return undefined
+      return row("todo", [
+        { text: `${todo.completed}/${todo.total}`, tone: "text" },
+        { text: ` · ${todo.total - todo.completed} left`, tone: "muted", dim: true },
+      ])
+    },
+  },
+} satisfies CustomModule