@opencode-cockpit/status 0.3.0

package/dist/tui/index.js

@@ -0,0 +1,110 @@
+import { memo as _$memo } from "@opentui/solid";
+import { createComponent as _$createComponent } from "@opentui/solid";
+/** @jsxImportSource @opentui/solid */
+
+import { claimFeature, duplicateFeatureMessage } from "@opencode-cockpit/client/feature";
+import { createMemo } from "solid-js";
+import pkg from "../../package.json" with { type: "json" };
+import { asSegmentConfig, loadStatusConfig, resolveLines } from "../core/config.js";
+import { loadCustomSegments } from "../core/custom.js";
+import { fit, fitColumn } from "../core/render.js";
+import { buildSegments } from "../core/segments.js";
+import { StatusLine } from "./components/statusline.js";
+import { buildContext } from "./state/snapshot.js";
+import { createStatusStore } from "./state/store.js";
+const STATUS_PACKAGE = "@opencode-cockpit/status";
+
+/** Status' TUI half as a factory, so bundles such as `opencode-cockpit` can include it. */
+export function createStatusTui({
+  source = STATUS_PACKAGE
+} = {}) {
+  return async (api, rawOptions) => {
+    // The renderer is shared by every TUI plugin in this OpenCode window.
+    const claim = claimFeature(api.renderer, "status", source);
+    if (!claim.active) {
+      api.ui.toast({
+        variant: "warning",
+        title: "opencode-cockpit",
+        message: duplicateFeatureMessage("Statusline", claim.owner, source),
+        duration: 10_000
+      });
+      return;
+    }
+    api.lifecycle.onDispose(() => claim.release());
+    const directory = api.state.path.directory;
+    const config = loadStatusConfig(directory, rawOptions);
+    if (config.enabled === false) return;
+
+    // Your own segments, loaded before the first draw so they are never missing from frame one.
+    let custom = new Map();
+    if (config.modules?.length) {
+      const loaded = await loadCustomSegments(config.modules, directory);
+      custom = loaded.segments;
+      // A module that will not load is worth saying out loud: its segments silently vanish.
+      for (const error of loaded.errors) {
+        api.ui.toast({
+          variant: "error",
+          title: "Statusline",
+          message: error,
+          duration: 10_000
+        });
+      }
+    }
+    const lines = resolveLines(config);
+    const store = createStatusStore(api, config, {
+      version: pkg.version,
+      build: buildContext
+    });
+    api.lifecycle.onDispose(() => store.dispose());
+
+    /** A line, fitted to the room its surface actually has. */
+    const line = (spec, width) => {
+      const segments = createMemo(() => {
+        const built = buildSegments(store.context(), spec.segments.map(asSegmentConfig), {
+          custom,
+          icons: spec.icons
+        });
+        return spec.stack === "vertical" ? fitColumn(built, width(), spec.maxRows).segments : fit(built, width(), spec.separator).segments;
+      });
+      return _$createComponent(StatusLine, {
+        api: api,
+        segments: segments,
+        get separator() {
+          return spec.separator;
+        },
+        get stack() {
+          return spec.stack;
+        },
+        get paddingLeft() {
+          return spec.paddingLeft;
+        },
+        get paddingRight() {
+          return spec.paddingRight;
+        },
+        get paddingTop() {
+          return spec.paddingTop;
+        },
+        get paddingBottom() {
+          return spec.paddingBottom;
+        }
+      });
+    };
+    const on = surface => lines.filter(spec => spec.surface === surface);
+    const bottom = on("bottom");
+    const sidebar = on("sidebar");
+    api.slots.register({
+      // After the shell dock (150), so the line sits at the very bottom of the window.
+      order: 200,
+      slots: {
+        app_bottom: () => _$memo(() => bottom.map(spec => line(spec, () => api.renderer.width - spec.paddingLeft - spec.paddingRight))),
+        // sidebar_content, not sidebar_footer: the host does not draw plugin content in the footer.
+        sidebar_content: () => _$memo(() => sidebar.map(spec => line(spec, () => Math.max(10, Math.floor(api.renderer.width / 4)))))
+      }
+    });
+  };
+}
+const plugin = {
+  id: STATUS_PACKAGE,
+  tui: createStatusTui()
+};
+export default plugin;

package/dist/tui/state/snapshot.js

@@ -0,0 +1,144 @@
+import { homedir } from "node:os";
+/**
+ * Turns OpenCode's live state into the plain snapshot the segments read. Everything that touches
+ * the plugin api lives here, so every built-in stays a pure function of its input.
+ */
+
+/** Everything a usage reading accounts for; zero means the message has not reported yet. */
+function counted(tokens) {
+  return tokens.input + tokens.output + tokens.reasoning + tokens.cache.read + tokens.cache.write;
+}
+
+/** The session the interface is showing, when it is showing one. */
+export function currentSession(api) {
+  const route = api.route.current;
+  return route.name === "session" ? route.params.sessionID : undefined;
+}
+export function sessionSnapshot(api, id, now) {
+  const messages = api.state.session.messages(id);
+  const status = api.state.session.status(id);
+  const session = api.state.session.get(id);
+  let summed = 0;
+  let tokens;
+  let modelID;
+  let providerID;
+  for (const message of messages) {
+    if (message.role !== "assistant") continue;
+    summed += message.cost ?? 0;
+    /**
+     * The newest assistant message is what currently occupies the window -- but only once it has
+     * reported its usage. A message that is still streaming carries zeroes, and taking those would
+     * blank every token-based segment for the length of the turn, which reads as the line breaking
+     * exactly when you are watching it.
+     */
+    if (message.tokens && counted(message.tokens) > 0) tokens = message.tokens;
+    modelID = message.modelID;
+    providerID = message.providerID;
+  }
+
+  /**
+   * OpenCode keeps a running total on the session record, and its own sidebar reads that. Summing
+   * the messages we can see under-reports it twice over: a turn still streaming has not booked its
+   * cost yet, and revert or compaction takes spent history out of the list entirely. Observed live
+   * against a proxy as $0.30 here against $0.56 in the sidebar.
+   *
+   * The field is not in the published `Session` type, so it is read defensively and the sum stands
+   * in when it is absent.
+   */
+  const accumulated = session?.cost;
+  const cost = typeof accumulated === "number" && Number.isFinite(accumulated) ? accumulated : summed;
+  const model = modelID && providerID ? describeModel(api, providerID, modelID) : undefined;
+  let additions = 0;
+  let deletions = 0;
+  const files = api.state.session.diff(id);
+  for (const file of files) {
+    additions += file.additions;
+    deletions += file.deletions;
+  }
+  const todos = api.state.session.todo(id);
+  const completed = todos.filter(todo => todo.status === "completed").length;
+  return {
+    id,
+    title: session?.title,
+    status: status?.type === "busy" ? "busy" : status?.type === "retry" ? "retry" : "idle",
+    ...(status?.type === "retry" ? {
+      retry: {
+        attempt: status.attempt,
+        message: status.message,
+        next: status.next
+      }
+    } : {}),
+    ...(model ? {
+      model
+    } : {}),
+    ...(tokens ? {
+      tokens
+    } : {}),
+    cost,
+    priced: model?.priced ?? false,
+    messages: messages.length,
+    ...(session?.time.created ? {
+      startedAt: session.time.created
+    } : {
+      startedAt: now
+    }),
+    diff: {
+      files: files.length,
+      additions,
+      deletions
+    },
+    todo: {
+      total: todos.length,
+      completed
+    }
+  };
+}
+
+/**
+ * A model's context window and whether anyone declared prices for it. Both come from the provider
+ * catalogue or from the user's own `provider.<id>.models` config — which is the only place they
+ * come from behind a proxy such as LiteLLM, where the catalogue knows nothing.
+ */
+function describeModel(api, providerID, modelID) {
+  const provider = api.state.provider.find(p => p.id === providerID);
+  const model = provider?.models[modelID];
+  const limit = model?.limit?.context;
+  const cost = model?.cost;
+  return {
+    providerID,
+    modelID,
+    ...(limit && limit > 0 ? {
+      contextLimit: limit
+    } : {}),
+    priced: Boolean(cost && (cost.input > 0 || cost.output > 0))
+  };
+}
+export function buildContext(api, options) {
+  const sessionID = currentSession(api);
+  return {
+    now: options.now,
+    directory: api.state.path.directory,
+    worktree: api.state.path.worktree,
+    home: process.env.HOME ?? homedir(),
+    ...(api.state.vcs?.branch ? {
+      branch: api.state.vcs.branch
+    } : {}),
+    ...(api.state.vcs?.default_branch ? {
+      defaultBranch: api.state.vcs.default_branch
+    } : {}),
+    version: options.version,
+    ...(sessionID ? {
+      session: sessionSnapshot(api, sessionID, options.now)
+    } : {}),
+    lsp: api.state.lsp().map(item => ({
+      name: item.id,
+      status: String(item.status)
+    })),
+    mcp: api.state.mcp().map(item => ({
+      name: item.name,
+      status: String(item.status)
+    })),
+    commands: options.commands,
+    width: options.width
+  };
+}

package/dist/tui/state/store.js

@@ -0,0 +1,51 @@
+import { createMemo, createRoot, createSignal } from "solid-js";
+import { createRunner, execShell } from "../../core/command.js";
+
+/**
+ * Keeps one snapshot of OpenCode's state for every line to read. One memo rather than one per
+ * segment: the whole snapshot is a handful of reads of state already in memory, and recomputing it
+ * once a second costs less than the bookkeeping to avoid it.
+ */
+
+export function createStatusStore(api, config, options) {
+  return createRoot(dispose => {
+    const clock = options.now ?? (() => Date.now());
+    const [now, setNow] = createSignal(clock());
+    const tick = setInterval(() => setNow(clock()), options.tickMs ?? 1000);
+
+    // A finished command run is a repaint: `equals: false` so an identical count still notifies.
+    const [commandTick, bump] = createSignal(0, {
+      equals: false
+    });
+    const runners = new Map();
+    for (const [name, command] of Object.entries(config.commands ?? {})) {
+      runners.set(name, createRunner(command, {
+        exec: options.exec ?? execShell,
+        now: clock,
+        onValue: () => bump(n => n + 1)
+      }));
+    }
+    const context = createMemo(() => {
+      commandTick();
+      const commands = {};
+      for (const [name, runner] of runners) commands[name] = runner.value();
+      const ctx = options.build(api, {
+        now: now(),
+        width: api.renderer.width,
+        version: options.version,
+        commands
+      });
+      // Asking here keeps the schedule tied to what is actually drawn: a hidden line costs nothing.
+      for (const runner of runners.values()) runner.maybeRun(ctx);
+      return ctx;
+    });
+    return {
+      context,
+      dispose() {
+        clearInterval(tick);
+        for (const runner of runners.values()) runner.dispose();
+        dispose();
+      }
+    };
+  });
+}

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@opencode-cockpit/status",
+  "version": "0.3.0",
+  "description": "A statusline for OpenCode you can actually configure: declarative segments, a typed module, or your existing Claude Code statusline command",
+  "type": "module",
+  "license": "MIT",
+  "author": "Codestz",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Codestz/opencode-cockpit.git",
+    "directory": "packages/status"
+  },
+  "homepage": "https://github.com/Codestz/opencode-cockpit#readme",
+  "bugs": {
+    "url": "https://github.com/Codestz/opencode-cockpit/issues"
+  },
+  "keywords": [
+    "opencode",
+    "opencode-plugin",
+    "statusline",
+    "status-line",
+    "tui",
+    "terminal",
+    "prompt"
+  ],
+  "exports": {
+    "./tui": {
+      "types": "./types/tui/index.d.ts",
+      "default": "./dist/tui/index.js"
+    },
+    "./config": {
+      "types": "./types/core/config.d.ts",
+      "default": "./dist/core/config.js"
+    },
+    "./segment": {
+      "types": "./types/core/authoring.d.ts",
+      "default": "./dist/core/authoring.js"
+    }
+  },
+  "engines": {
+    "opencode": ">=1.18.0",
+    "bun": ">=1.3.5"
+  },
+  "files": [
+    "dist",
+    "types",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@opencode-cockpit/client": "0.3.0",
+    "@opencode-ai/plugin": "1.18.31"
+  },
+  "devDependencies": {
+    "@opentui/core": "0.4.5",
+    "@opentui/keymap": "0.4.5",
+    "@opentui/solid": "0.4.5",
+    "solid-js": "1.9.12"
+  }
+}

package/types/core/ansi.d.ts

@@ -0,0 +1,8 @@
+import type { Run } from "./segments.ts";
+/**
+ * Parses one line of a script's output into runs. Text with no escapes comes back as a single
+ * muted run, which is what a plain script should look like.
+ */
+export declare function parseAnsi(line: string): Run[];
+/** Every line of a script's output, parsed. Claude Code statuslines may print several rows. */
+export declare function parseAnsiLines(stdout: string): Run[][];

package/types/core/authoring.d.ts

@@ -0,0 +1,17 @@
+/**
+ * The public surface a statusline module writes against, published as
+ * `@opencode-cockpit/status/segment`.
+ *
+ *   import type { StatusContext, CustomModule } from "@opencode-cockpit/status/segment"
+ *
+ * Everything here is a type or a pure helper: a module never touches OpenCode's plugin api, only
+ * the snapshot it is handed. That is what makes a custom segment as testable as a built-in.
+ */
+export type { ClaudeCodeStatusInput } from "./claude-code.ts";
+export type { SegmentConfig } from "./config.ts";
+export type { ServiceSnapshot, SessionSnapshot, StatusContext, TokenCounts, } from "./context.ts";
+export { contextRatio, contextUsed, todoRemaining, unhealthy } from "./context.ts";
+export type { CustomModule, CustomRender } from "./custom.ts";
+export { bar, basename, compact, duration, gradient, money, percent, preciseDuration, shortModel, shortPath, truncate, truncateStart, } from "./format.ts";
+export type { Piece, Run, Segment, SegmentDef, Tone } from "./segments.ts";
+export { cutSegment, runsOf, segmentText, segmentWidth } from "./segments.ts";

package/types/core/builtins/index.d.ts

@@ -0,0 +1,6 @@
+import type { SegmentDef } from "../types.ts";
+/**
+ * Every built-in, grouped by what it talks about rather than listed in one file: adding a segment
+ * should mean opening the twenty lines it belongs with, not four hundred.
+ */
+export declare const BUILTINS: SegmentDef[];

package/types/core/builtins/model.d.ts

@@ -0,0 +1,3 @@
+/** The model in play, how full its context window is, and what the session is spending. */
+import type { SegmentDef } from "../types.ts";
+export declare const SEGMENTS: SegmentDef[];

package/types/core/builtins/place.d.ts

@@ -0,0 +1,3 @@
+/** Where you are: the folder, the branch, and what has changed in it. */
+import type { SegmentDef } from "../types.ts";
+export declare const SEGMENTS: SegmentDef[];

package/types/core/builtins/session.d.ts

@@ -0,0 +1,3 @@
+/** How the session is going: work outstanding, work in progress, time spent. */
+import type { SegmentDef } from "../types.ts";
+export declare const SEGMENTS: SegmentDef[];

package/types/core/builtins/settings.d.ts

@@ -0,0 +1,13 @@
+/** Reading a segment's own settings out of its config entry, safely. */
+import type { SegmentConfig } from "../config.ts";
+import type { Piece, Tone } from "../types.ts";
+export declare function num(config: SegmentConfig, key: string, fallback: number): number;
+export declare function str(config: SegmentConfig, key: string): string | undefined;
+/**
+ * A segment's own shape, when the config asked for one.
+ *
+ * Returns `undefined` when no `format` was written, so the segment draws its default — which is
+ * usually several runs in several colours. A format is one run in one tone: full control of the
+ * words, at the cost of the colouring, which is the honest trade and worth saying out loud.
+ */
+export declare function formatted(config: SegmentConfig, values: Record<string, string | number>, tone?: Tone): Piece | undefined;

package/types/core/builtins/system.d.ts

@@ -0,0 +1,3 @@
+/** Everything outside the conversation: service health, versions, and your own commands. */
+import type { SegmentDef } from "../types.ts";
+export declare const SEGMENTS: SegmentDef[];

package/types/core/claude-code.d.ts

@@ -0,0 +1,61 @@
+import { type StatusContext } from "./context.ts";
+/**
+ * The escape hatch: a shell command whose stdout becomes a segment.
+ *
+ * It is fed the same JSON on stdin that Claude Code's statusLine hook sends, so a statusline
+ * script someone already wrote works here unchanged. That matters more than elegance — nobody
+ * rewrites a working statusline to try a new editor.
+ *
+ * Unlike Claude Code's, this is not on the draw path: the command runs on its own interval and the
+ * line renders whatever it last returned, so a slow script makes the value stale rather than making
+ * the interface stutter.
+ */
+/**
+ * Claude Code's statusLine stdin payload, as close as our data allows.
+ *
+ * The fields real statuslines actually read are the context-window ones — a script that draws a
+ * capacity bar wants `context_window.used_percentage`, not a token total it has to divide itself.
+ * `rate_limits` is deliberately absent: it describes an Anthropic plan's quota, which has no
+ * meaning behind a proxy or another provider, and inventing a number there would be worse than
+ * the field being missing.
+ */
+export interface ClaudeCodeStatusInput {
+    hook_event_name: "Status";
+    session_id: string;
+    session_name?: string;
+    cwd: string;
+    model: {
+        id: string;
+        display_name: string;
+    };
+    workspace: {
+        current_dir: string;
+        project_dir: string;
+        git_worktree?: string;
+    };
+    version: string;
+    output_style: {
+        name: string;
+    };
+    cost: {
+        total_cost_usd: number;
+        total_duration_ms: number;
+        total_lines_added: number;
+        total_lines_removed: number;
+    };
+    context_window?: {
+        used_percentage: number;
+        remaining_percentage: number;
+        context_window_size: number;
+        total_input_tokens: number;
+        total_output_tokens: number;
+    };
+    current_usage?: {
+        input_tokens: number;
+        output_tokens: number;
+        cache_creation_tokens: number;
+        cache_read_tokens: number;
+    };
+    exceeds_200k_tokens: boolean;
+}
+export declare function claudeCodeInput(ctx: StatusContext): ClaudeCodeStatusInput;

package/types/core/command.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Running a shell command for a segment.
+ *
+ * Unlike Claude Code's statusline, this is not on the draw path: the command runs on its own
+ * interval and the line renders whatever it last returned, so a slow script makes the value stale
+ * rather than making the interface stutter.
+ */
+import type { CommandConfig } from "./config.ts";
+import type { StatusContext } from "./context.ts";
+/**
+ * What a command's output is worth keeping: every row, escapes and all.
+ *
+ * The colour escapes are deliberately *not* stripped — they are parsed into styled runs when the
+ * segment draws, so a script someone already tuned for Claude Code looks the same here. Claude
+ * Code statuslines may also print several rows, so the rows are kept rather than the first one.
+ */
+export declare function cleanOutput(stdout: string): string;
+/** The rows of a command's last output. */
+export declare function outputRows(value: string): string[];
+export interface CommandRunner {
+    /** The last successful output, or "" until one arrives. */
+    value(): string;
+    /** Runs if the interval has elapsed and no run is in flight. */
+    maybeRun(ctx: StatusContext): void;
+    dispose(): void;
+}
+export interface RunnerHost {
+    /** Injected so tests do not need a shell. Resolves to stdout, or rejects. */
+    exec(command: string, stdin: string, timeoutMs: number): Promise<string>;
+    now(): number;
+    onValue(): void;
+}
+export declare function createRunner(config: CommandConfig, host: RunnerHost): CommandRunner;
+/** The real shell, used outside tests. */
+export declare function execShell(command: string, stdin: string, timeoutMs: number): Promise<string>;

package/types/core/config.d.ts

@@ -0,0 +1,141 @@
+/**
+ * Statusline settings, read from the same two files every cockpit bay uses:
+ *
+ *   ~/.config/opencode-cockpit/config.json  →  <project>/.cockpit.json  →  plugin-entry options
+ *
+ * Only the `statusline` section is read here. An unreadable or invalid file is ignored rather than
+ * fatal — a typo in a config should never cost you the interface.
+ */
+export declare const CONFIG_FILE = "config.json";
+export declare const PROJECT_FILE = ".cockpit.json";
+/**
+ * Where a line is drawn.
+ *
+ * Two surfaces, deliberately. A third sat inside the prompt box, which is both the narrowest place
+ * in the window and the one OpenCode already fills with the agent, the model and the elapsed time:
+ * a line there had almost no room and almost nothing left to say.
+ */
+export type Surface = "bottom" | "sidebar";
+/**
+ * A segment is either a built-in named by string ("cwd"), or that name with settings. `when` and
+ * `priority` are what make a line survive a narrow terminal instead of wrapping into noise.
+ */
+export interface SegmentConfig {
+    type: string;
+    /** Text placed before the value, e.g. "on ". */
+    prefix?: string;
+    suffix?: string;
+    /** Higher survives when the line has to be shortened. Defaults per built-in. */
+    priority?: number;
+    /** Theme colour name (`success`, `warning`, `textMuted`…) or a literal `#rrggbb`. */
+    color?: string;
+    /** Built-in specific settings, e.g. `{ "style": "bar" }` for context. */
+    [key: string]: unknown;
+}
+export interface CommandConfig {
+    /** Shell command whose stdout becomes the segment's text. */
+    run: string;
+    /** How often it may run. Defaults to 2000ms; it never runs more than once at a time. */
+    intervalMs?: number;
+    /** Kill and ignore the output after this long. Defaults to 1000ms. */
+    timeoutMs?: number;
+    /**
+     * Feed the command Claude Code's statusline JSON on stdin, so an existing statusline script
+     * works unchanged. On by default.
+     */
+    claudeCodeCompat?: boolean;
+    priority?: number;
+}
+/**
+ * How a line lays its segments out. A wide line under the prompt reads across; a sidebar four
+ * columns wide reads down.
+ */
+export type Stack = "horizontal" | "vertical";
+export interface LineConfig {
+    surface?: Surface;
+    segments?: (string | SegmentConfig)[];
+    /** Drawn between segments. Defaults to " · " across, and nothing down. */
+    separator?: string;
+    /** Defaults to vertical in the sidebar, horizontal everywhere else. */
+    stack?: Stack;
+    /** Built-in icons. On by default; switch off for a terminal missing the glyphs. */
+    icons?: boolean;
+    /** Vertical only: rows to draw at most. Lowest priority goes first. Defaults to 8. */
+    maxRows?: number;
+    /**
+     * Columns of space either side. The defaults line each surface up with OpenCode's own
+     * furniture -- its footer indents three, its prompt keeps two clear on the right -- so the line
+     * reads as part of the interface rather than as something bolted underneath it.
+     */
+    paddingLeft?: number;
+    paddingRight?: number;
+    paddingTop?: number;
+    paddingBottom?: number;
+}
+export interface StatusConfig {
+    enabled?: boolean;
+    /** One line, for the common case. Use `lines` for more than one surface. */
+    surface?: Surface;
+    segments?: (string | SegmentConfig)[];
+    separator?: string;
+    stack?: Stack;
+    /** Built-in icons. On by default; switch off for a terminal missing the glyphs. */
+    icons?: boolean;
+    lines?: LineConfig[];
+    /** Named commands usable as segments: `{"type": "command", "name": "budget"}`. */
+    commands?: Record<string, CommandConfig>;
+    /**
+     * Your own segments: paths to modules that export them by name, usable in `segments` exactly
+     * like the built-ins. `~` and a path relative to the project both work.
+     */
+    modules?: string[];
+}
+export interface CockpitStatusConfig {
+    statusline?: StatusConfig;
+}
+export declare function globalConfigPath(env?: Record<string, string | undefined>): string;
+/** Reads and merges every source. `options` is the plugin entry's own options object. */
+export declare function loadStatusConfig(directory: string, options?: unknown, env?: Record<string, string | undefined>): StatusConfig;
+export declare function readStatusFile(path: string): StatusConfig;
+/**
+ * Section-wise merge. `segments` is replaced rather than concatenated: a project that lists its
+ * own segments means "this line", not "these as well as the global ones".
+ */
+export declare function mergeStatus(base: StatusConfig, over: StatusConfig): StatusConfig;
+/**
+ * Accepts either a whole cockpit config (`{ statusline: {...} }`) or the statusline section on its
+ * own, because plugin-entry options are written straight onto the `tui.json` entry.
+ */
+export declare function asStatusConfig(input: unknown): StatusConfig;
+/**
+ * The default line: what someone who writes nothing at all should see.
+ *
+ * It took a long walk to arrive here, and the shape is the point. A capacity bar that means
+ * something at a glance, the total beside the three quantities that make it up, what changed, how
+ * long it has been. Colour carries which is which; the separators carry the grouping.
+ *
+ * It does repeat one thing OpenCode already shows -- the token count and the percentage, which its
+ * footer carries in a corner. That is deliberate. The rule is not to avoid every fact the host
+ * mentions, it is to avoid saying it no better than the host does: a bar you can read without
+ * looking, with the breakdown beside it, is a different instrument from "78.5K (39%)" in the
+ * corner. What stays out are the facts a second copy adds nothing to -- the path, the branch, the
+ * model, the spend.
+ */
+export declare const DEFAULT_SEGMENTS: (string | SegmentConfig)[];
+export declare const DEFAULT_SEPARATOR = " \u2502 ";
+export interface ResolvedLine {
+    surface: Surface;
+    segments: (string | SegmentConfig)[];
+    separator: string;
+    stack: Stack;
+    maxRows: number;
+    icons: boolean;
+    paddingLeft: number;
+    paddingRight: number;
+    paddingTop: number;
+    paddingBottom: number;
+}
+/** Normalises whatever the config said into the lines the renderer draws. */
+export declare function resolveLines(config: StatusConfig): ResolvedLine[];
+/** A segment written as a bare string is that built-in with no settings. */
+export declare function asSegmentConfig(entry: string | SegmentConfig): SegmentConfig;