pi-opencode-go-provider 1.0.25 → 1.1.1

package/README.md

@@ -21,7 +21,7 @@ _Go-optimized endpoints for lower latency — 14+ models for [pi](https://github
 - **Cost Tracking** with per-model pricing for budget management
 - **Reasoning Models** with thinking level maps for proper effort control
 - **Prompt-cache session affinity** — sends `x-opencode-session` and `x-opencode-client` so OpenCode Go can pin a session to the same cache node
-- **Usage widget** — shows how much of the OpenCode Go 5h / 7d / 30d budgets you have spent, below the editor (footer status line outside the TUI)
+- **Usage widget** — shows how much of the OpenCode Go 5h / 7d / 30d budgets you have spent, below the editor (footer status line outside the TUI). Each account carries its own budgets, so when [pi-multiprovider](https://github.com/monotykamary/pi-multiprovider) 0.8.0+ pools several `opencode-go` accounts the widget bills the session's active one and repaints on every switch or resume.
 
 ## Installation
 
@@ -139,6 +139,7 @@ so that trailing segment appears only if a response ever carries a
 /opencode-go-usage off        # hide the widget (persisted)
 /opencode-go-usage on         # show it again
 /opencode-go-usage debug      # config, last fetch/error, endpoint
+/opencode-go-usage glyphs auto|unicode|ascii   # footer glyph set (persisted)
 ```
 
 Polling runs every 60 seconds, plus after every turn and whenever the selected
@@ -151,7 +152,8 @@ model changes. Settings are read from `~/.pi/agent/opencode-go-provider.json`:
     "refreshIntervalMs": 60000,
     "showOnlyOnProvider": true,
     "showResetTimes": true,
-    "placement": "belowEditor"
+    "placement": "belowEditor",
+    "glyphs": "auto"
   }
 }
 ```
@@ -159,6 +161,19 @@ model changes. Settings are read from `~/.pi/agent/opencode-go-provider.json`:
 `placement` accepts `belowEditor` (default) or `aboveEditor`. Every key is
 optional; `/opencode-go-usage on|off` writes only `enabled`.
 
+`glyphs` accepts `auto` (default), `unicode`, or `ascii`. Older mintty/Cygwin builds measure ambiguous-width codepoints (the `·` separators, the `↺` reset marker) with their own cell-width tables, which can shift the row and desync pi’s renderer. `auto` switches the widget to ASCII equivalents on those terminals and the widget never paints the terminal’s last column; an explicit `unicode` is clamped to ASCII for widget content there (the status line is not row-budgeted and keeps the choice).
+
+### Pooled accounts
+
+When [pi-multiprovider](https://github.com/monotykamary/pi-multiprovider)
+0.8.0+ pools several `opencode-go` accounts, usage reads bill the session's
+active account instead of Pi's default credential: every account has its own
+5h / 7d / 30d budgets. The widget also repaints when the account changes,
+including when a resumed session restores the account last chosen with
+`/switch-account`, rather than showing the previous account until the next
+poll. Without pi-multiprovider nothing changes: the widget bills the key from
+the resolution order above.
+
 ## Authentication
 
 The opencode-go API key can be configured in multiple ways. Credentials are resolved in this order:

package/config.ts

@@ -9,6 +9,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import { getAgentDir } from "@earendil-works/pi-coding-agent";
+import { GLYPH_MODES, type GlyphMode } from "./glyphs.ts";
 
 export const PROVIDER_ID = "opencode-go";
 export const CONFIG_BASENAME = "opencode-go-provider.json";
@@ -26,6 +27,8 @@ export interface UsageConfig {
   showOnlyOnProvider: boolean;
   /** Include reset countdowns in the widget line. */
   showResetTimes: boolean;
+  /** Footer glyph set. "auto" degrades to ASCII on legacy terminals (mintty/Cygwin). */
+  glyphs: GlyphMode;
   placement: UsagePlacement;
 }
 
@@ -35,6 +38,7 @@ export const DEFAULT_USAGE_CONFIG: UsageConfig = {
   showOnlyOnProvider: true,
   showResetTimes: true,
   placement: "belowEditor",
+  glyphs: "auto",
 };
 
 export const MIN_USAGE_REFRESH_MS = 15_000;
@@ -90,6 +94,9 @@ export function readUsageConfig(env: NodeJS.ProcessEnv = process.env): UsageConf
   if (typeof file.refreshIntervalMs === "number") {
     config.refreshIntervalMs = clampRefreshInterval(file.refreshIntervalMs);
   }
+  if (GLYPH_MODES.includes(file.glyphs as GlyphMode)) {
+    config.glyphs = file.glyphs as GlyphMode;
+  }
   if (USAGE_PLACEMENTS.includes(file.placement as UsagePlacement)) {
     config.placement = file.placement as UsagePlacement;
   }

package/glyphs.ts

@@ -0,0 +1,57 @@
+/**
+ * Footer glyph policy for the usage widget.
+ *
+ * Older mintty/Cygwin builds measure emoji and ambiguous-width codepoints with
+ * their own cell-width tables, which can disagree with pi's. The widget line is
+ * truncated to (now) width - 1 and never padded to the edge, but a glyph the
+ * terminal measures wider than expected still shifts everything after it and
+ * can desync pi's differential renderer. "auto" swaps the footer glyphs for
+ * ASCII on detected legacy terminals; "unicode"/"ascii" force a set.
+ */
+
+export type GlyphMode = "auto" | "unicode" | "ascii";
+
+export interface GlyphSet {
+  /** Separator between usage atoms. */
+  sep: string;
+  /** Reset-countdown prefix. */
+  reset: string;
+  /** Progress-bar fill / remainder (command output). */
+  barFilled: string;
+  barHollow: string;
+  /** Truncation marker. */
+  ellipsis: string;
+}
+
+export const UNICODE_GLYPHS: GlyphSet = { sep: "\u00b7", reset: "\u21ba", barFilled: "\u2588", barHollow: "\u2591", ellipsis: "\u2026" };
+export const ASCII_GLYPHS: GlyphSet = { sep: "-", reset: "~", barFilled: "#", barHollow: "-", ellipsis: "..." };
+
+export const GLYPH_MODES: GlyphMode[] = ["auto", "unicode", "ascii"];
+
+/** True for terminals whose cell-width tables are known to disagree with the
+ * width math in format.ts (older mintty/Cygwin builds). */
+export function detectLegacyTerminal(env: NodeJS.ProcessEnv = process.env): boolean {
+  const termProgram = env.TERM_PROGRAM ?? "";
+  const term = env.TERM ?? "";
+  return (
+    termProgram === "mintty" ||
+    termProgram === "cygwin" ||
+    termProgram === "msys" ||
+    term.startsWith("cygwin") ||
+    term.startsWith("msys")
+  );
+}
+
+export function resolveGlyphSet(mode: GlyphMode, env: NodeJS.ProcessEnv = process.env): GlyphSet {
+  if (mode === "unicode") return UNICODE_GLYPHS;
+  if (mode === "ascii") return ASCII_GLYPHS;
+  return detectLegacyTerminal(env) ? ASCII_GLYPHS : UNICODE_GLYPHS;
+}
+
+/** Widget-safe variant. The widget renders inside the editor's row budget, so
+ * an over-wide glyph there can desync pi's renderer; status fallback text is
+ * not row-budgeted and keeps an explicit choice. */
+export function resolveWidgetGlyphSet(mode: GlyphMode, env: NodeJS.ProcessEnv = process.env): GlyphSet {
+  if (mode === "unicode" && detectLegacyTerminal(env)) return ASCII_GLYPHS;
+  return resolveGlyphSet(mode, env);
+}

package/index.ts

@@ -29,10 +29,17 @@ import {
   type ModelRegistry,
   type ThemeColor,
 } from "@earendil-works/pi-coding-agent";
-import { USAGE_WIDGET_KEY, readUsageConfig, writeUsageConfig } from "./config.ts";
+import { USAGE_WIDGET_KEY, readUsageConfig, writeUsageConfig, type UsageConfig } from "./config.ts";
 import { sanitizeStatusText, truncateToWidth } from "./format.ts";
+import { resolveGlyphSet, resolveWidgetGlyphSet, type GlyphSet } from "./glyphs.ts";
 import { usageSegments, type UsageSegment, type UsageSeverity } from "./usage.ts";
 import { UsageController } from "./usage-controller.ts";
+import {
+  isMultiproviderService,
+  MULTIPROVIDER_SERVICE_EVENT,
+  setActiveMultiproviderService,
+  type MultiproviderService,
+} from "./multiprovider.ts";
 import modelsData from "./models.json" with { type: "json" };
 import customModelsData from "./custom-models.json" with { type: "json" };
 import patchData from "./patch.json" with { type: "json" };
@@ -420,7 +427,36 @@ export default function (pi: ExtensionAPI) {
 
   let usageConfig = readUsageConfig();
   let usageWidgetInstalled = false;
+  let usageClampNotified = false;
   const usageController = new UsageController(() => usageConfig, updateUsageWidget);
+  let usageContext: ExtensionContext | undefined;
+
+  // Follow pi-multiprovider's active pooled account. Usage is per-account, so a
+  // switch — and a resume, which replays the account the session last switched
+  // to — must repaint the widget instead of waiting for the next poll. Without
+  // pi-multiprovider nothing here activates and resolution stays unchanged.
+  let multiproviderService: MultiproviderService | undefined;
+  let unsubscribeMultiprovider: (() => void) | undefined;
+  const refreshUsageForActiveAccount = (ctx: ExtensionContext | undefined): void => {
+    if (ctx === undefined) return;
+    void usageController.refresh(ctx, { force: true });
+  };
+  if (typeof pi.events?.on === "function") {
+    pi.events.on(MULTIPROVIDER_SERVICE_EVENT, (value: unknown) => {
+      if (!isMultiproviderService(value)) return;
+      if (value !== multiproviderService) {
+        unsubscribeMultiprovider?.();
+        multiproviderService = value;
+        setActiveMultiproviderService(value);
+        unsubscribeMultiprovider = value.onActiveAccountChanged(PROVIDER_ID, (event) => {
+          refreshUsageForActiveAccount(usageContext ?? event.ctx);
+        });
+      }
+      // The event re-fires at every session start with the same stable object,
+      // so this also catches a service that appeared mid-session.
+      refreshUsageForActiveAccount(usageContext);
+    });
+  }
 
   const USAGE_SEVERITY_COLORS: Record<UsageSeverity, ThemeColor> = {
     ok: "success",
@@ -429,17 +465,25 @@ export default function (pi: ExtensionAPI) {
     muted: "dim",
   };
 
-  function usageSegmentsFor(ctx: ExtensionContext): UsageSegment[] | undefined {
+  function usageSegmentsFor(ctx: ExtensionContext, glyphs: GlyphSet): UsageSegment[] | undefined {
     const snapshot = usageController.snapshot;
     if (!snapshot || !usageConfig.enabled || !usageController.isEligible(ctx)) return undefined;
-    const segments = usageSegments(snapshot, { showResetTimes: usageConfig.showResetTimes });
-    if (usageController.isStale()) segments.push({ text: " · stale", severity: "warning" });
+    const segments = usageSegments(snapshot, { showResetTimes: usageConfig.showResetTimes, glyphs });
+    if (usageController.isStale()) segments.push({ text: ` ${glyphs.sep} stale`, severity: "warning" });
     return segments;
   }
 
   function updateUsageWidget(ctx: ExtensionContext): void {
     try {
-      const segments = usageSegmentsFor(ctx);
+      // Legacy terminals measure the footer glyphs with their own tables; widget
+      // content clamps to ASCII there, the status fallback keeps the choice.
+      const glyphs = resolveGlyphSet(usageConfig.glyphs);
+      const widgetGlyphs = resolveWidgetGlyphSet(usageConfig.glyphs);
+      if (widgetGlyphs !== glyphs && !usageClampNotified) {
+        usageClampNotified = true;
+        ctx.ui.notify("OpenCode Go: widget glyphs stay ASCII on this terminal — unicode glyphs overflow legacy mintty/Cygwin cell widths. The status line is unaffected.", "info");
+      }
+      const segments = usageSegmentsFor(ctx, widgetGlyphs);
       if (!segments) {
         if (usageWidgetInstalled) {
           ctx.ui.setWidget(USAGE_WIDGET_KEY, undefined);
@@ -460,14 +504,18 @@ export default function (pi: ExtensionAPI) {
               const line = segments
                 .map((segment) => theme.fg(USAGE_SEVERITY_COLORS[segment.severity], segment.text))
                 .join("");
-              return [truncateToWidth(line, width, theme.fg("dim", "\u2026"))];
+              // Budget width - 1: never paint the terminal’s last column (a
+              // pending wrap there desyncs pi’s renderer on legacy terminals).
+              const w = Math.max(1, width - 1);
+              return [truncateToWidth(line, w, theme.fg("dim", widgetGlyphs.ellipsis))];
             },
           }),
           { placement: usageConfig.placement },
         );
       } else {
         ctx.ui.setWidget(USAGE_WIDGET_KEY, undefined);
-        ctx.ui.setStatus(USAGE_WIDGET_KEY, sanitizeStatusText(segments.map((s) => s.text).join("")));
+        const barSegments = usageSegmentsFor(ctx, glyphs) ?? segments;
+        ctx.ui.setStatus(USAGE_WIDGET_KEY, sanitizeStatusText(barSegments.map((s) => s.text).join("")));
       }
       usageWidgetInstalled = true;
     } catch {
@@ -479,6 +527,15 @@ export default function (pi: ExtensionAPI) {
     description: "Show, refresh, or toggle the OpenCode Go 5h / 7d / 30d usage widget",
     handler: async (args, ctx) => {
       const action = args.trim().toLowerCase();
+      if (action === "glyphs auto" || action === "glyphs unicode" || action === "glyphs ascii") {
+        const glyphs = action.slice("glyphs ".length) as UsageConfig["glyphs"];
+        usageConfig = { ...usageConfig, glyphs };
+        const persisted = writeUsageConfig({ glyphs });
+        updateUsageWidget(ctx);
+        const suffix = persisted ? "" : " for this session (could not write the config file)";
+        ctx.ui.notify(`OpenCode Go footer glyphs: ${glyphs}${suffix}.`, "info");
+        return;
+      }
       if (action === "on" || action === "off") {
         const enabled = action === "on";
         usageConfig = { ...usageConfig, enabled };
@@ -510,6 +567,7 @@ export default function (pi: ExtensionAPI) {
   });
 
   pi.on("session_start", async (_event, ctx) => {
+    usageContext = ctx;
     usageController.start(ctx);
     revalidateAbort?.abort();
     revalidateAbort = new AbortController();
@@ -551,6 +609,11 @@ export default function (pi: ExtensionAPI) {
 
   pi.on("session_shutdown", () => {
     revalidateAbort?.abort();
+    usageContext = undefined;
+    unsubscribeMultiprovider?.();
+    unsubscribeMultiprovider = undefined;
+    multiproviderService = undefined;
+    setActiveMultiproviderService(undefined);
     usageController.shutdown();
   });
 }

package/multiprovider.ts

@@ -0,0 +1,74 @@
+/**
+ * Soft bridge to pi-multiprovider.
+ *
+ * When pi-multiprovider pools several opencode-go accounts it announces a
+ * service on Pi's event bus and notifies followers whenever the session's
+ * active account changes — including a resume, which replays the account the
+ * session last switched to. Usage is account-scoped: each account has its own
+ * 5h / 7d / 30d budget, so the widget has to bill the active pooled account
+ * instead of whichever credential Pi resolves on its own. Without that
+ * extension everything here stays inert and resolution is unchanged.
+ */
+
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+
+export const MULTIPROVIDER_SERVICE_EVENT = "pi-multiprovider:service";
+
+export type MultiproviderActiveAccount = {
+  id: string;
+  label: string;
+  authKind: string;
+};
+
+export type MultiproviderAccountAuth = {
+  accessToken: string;
+  label: string;
+  source?: string;
+};
+
+export type MultiproviderAccountChangedEvent = {
+  providerId: string;
+  account: MultiproviderActiveAccount | undefined;
+  ctx: ExtensionContext;
+};
+
+export type MultiproviderServiceContext = Pick<
+  ExtensionContext,
+  "modelRegistry" | "model" | "sessionManager"
+>;
+
+export type MultiproviderService = {
+  getActiveAccount(
+    providerId: string,
+    ctx: MultiproviderServiceContext,
+  ): Promise<MultiproviderActiveAccount | undefined>;
+  resolveActiveAccountAuth(
+    providerId: string,
+    ctx: MultiproviderServiceContext,
+    signal?: AbortSignal,
+  ): Promise<MultiproviderAccountAuth | undefined>;
+  onActiveAccountChanged(
+    providerId: string,
+    callback: (event: MultiproviderAccountChangedEvent) => void,
+  ): () => void;
+};
+
+export function isMultiproviderService(value: unknown): value is MultiproviderService {
+  if (typeof value !== "object" || value === null) return false;
+  const candidate = value as Partial<MultiproviderService>;
+  return (
+    typeof candidate.getActiveAccount === "function" &&
+    typeof candidate.resolveActiveAccountAuth === "function" &&
+    typeof candidate.onActiveAccountChanged === "function"
+  );
+}
+
+let activeService: MultiproviderService | undefined;
+
+export function setActiveMultiproviderService(service: MultiproviderService | undefined): void {
+  activeService = service;
+}
+
+export function getActiveMultiproviderService(): MultiproviderService | undefined {
+  return activeService;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-opencode-go-provider",
-  "version": "1.0.25",
+  "version": "1.1.1",
   "description": "Opencode Go provider extension for pi - Fast, efficient GLM, Kimi, and MiniMax models through the opencode.ai API",
   "type": "module",
   "main": "index.ts",

package/tests/glyphs.test.ts

@@ -0,0 +1,76 @@
+/**
+ * Glyph policy: legacy terminals (mintty/Cygwin) get an ASCII footer so an
+ * over-wide glyph cannot shift the widget line and desync pi's renderer.
+ */
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { DEFAULT_USAGE_CONFIG } from "../config.ts";
+import { ASCII_GLYPHS, UNICODE_GLYPHS, detectLegacyTerminal, resolveGlyphSet, resolveWidgetGlyphSet } from "../glyphs.ts";
+import { formatBar, parseUsageSnapshot, usageSegments } from "../usage.ts";
+import { truncateToWidth } from "../format.ts";
+
+const mintty = { TERM_PROGRAM: "mintty", TERM: "xterm" } as NodeJS.ProcessEnv;
+const cygwin = { TERM: "cygwin" } as NodeJS.ProcessEnv;
+const wt = { TERM_PROGRAM: "Windows_Terminal", TERM: "xterm-256color" } as NodeJS.ProcessEnv;
+const isAscii = (value: string) => [...value].every((char) => char.charCodeAt(0) < 128);
+
+test("detects legacy terminals", () => {
+  assert.equal(detectLegacyTerminal(mintty), true);
+  assert.equal(detectLegacyTerminal(cygwin), true);
+  assert.equal(detectLegacyTerminal(wt), false);
+  assert.equal(detectLegacyTerminal({} as NodeJS.ProcessEnv), false);
+});
+
+test("auto degrades on legacy terminals; explicit modes win for the status line", () => {
+  assert.equal(resolveGlyphSet("auto", mintty), ASCII_GLYPHS);
+  assert.equal(resolveGlyphSet("auto", wt), UNICODE_GLYPHS);
+  assert.equal(resolveGlyphSet("unicode", mintty), UNICODE_GLYPHS);
+  assert.equal(resolveGlyphSet("ascii", wt), ASCII_GLYPHS);
+});
+
+test("widget content clamps an explicit unicode choice on legacy terminals", () => {
+  assert.equal(resolveWidgetGlyphSet("unicode", mintty), ASCII_GLYPHS);
+  assert.equal(resolveWidgetGlyphSet("unicode", wt), UNICODE_GLYPHS);
+  assert.equal(resolveWidgetGlyphSet("auto", mintty), ASCII_GLYPHS);
+  assert.equal(resolveWidgetGlyphSet("ascii", wt), ASCII_GLYPHS);
+});
+
+test("the default config is auto", () => {
+  assert.equal(DEFAULT_USAGE_CONFIG.glyphs, "auto");
+});
+
+test("the ASCII set is pure ASCII and renders an ASCII usage line", () => {
+  assert.equal(isAscii(Object.values(ASCII_GLYPHS).join("")), true);
+  assert.equal(isAscii(Object.values(UNICODE_GLYPHS).join("")), false);
+
+  // Built through the real parser so the fixture cannot drift from the wire shape.
+  const now = Date.now();
+  const snapshot = parseUsageSnapshot(
+    {
+      usage: {
+        rolling: { status: "ok", percent: 37, resetsAt: new Date(now + 3_600_000).toISOString() },
+        weekly: { status: "ok", percent: 59, resetsAt: new Date(now + 86_400_000).toISOString() },
+      },
+    },
+    now,
+  );
+  assert.ok(snapshot);
+  const asciiLine = usageSegments(snapshot, { showResetTimes: true, glyphs: ASCII_GLYPHS }, now)
+    .map((segment) => segment.text)
+    .join("");
+  const unicodeLine = usageSegments(snapshot, { showResetTimes: true }, now)
+    .map((segment) => segment.text)
+    .join("");
+  assert.equal(isAscii(asciiLine), true);
+  assert.equal(asciiLine.includes("5h: 63% - 7d: 41%"), true);
+  assert.equal(unicodeLine.includes("\u00b7"), true);
+  assert.equal(unicodeLine.includes("\u21ba"), true);
+});
+
+test("bars and truncation take the ASCII glyphs too", () => {
+  assert.equal(formatBar(50, 4, ASCII_GLYPHS), "##--");
+  assert.equal(formatBar(50, 4), "\u2588\u2588\u2591\u2591");
+  const cut = truncateToWidth("abcdefghij", 5, ASCII_GLYPHS.ellipsis);
+  assert.equal(cut, "ab...");
+  assert.equal(isAscii(cut), true);
+});

package/tests/multiprovider.test.ts

@@ -0,0 +1,132 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { DEFAULT_USAGE_CONFIG, PROVIDER_ID } from "../config.ts";
+import {
+  isMultiproviderService,
+  setActiveMultiproviderService,
+  type MultiproviderAccountAuth,
+  type MultiproviderService,
+} from "../multiprovider.ts";
+import { UsageController } from "../usage-controller.ts";
+
+function fakeService(
+  resolve: () => Promise<MultiproviderAccountAuth | undefined>,
+): { value: MultiproviderService; resolveActiveAccountAuth: () => Promise<MultiproviderAccountAuth | undefined> } {
+  const resolveActiveAccountAuth = async () => resolve();
+  const value: MultiproviderService = {
+    getActiveAccount: async () => undefined,
+    resolveActiveAccountAuth,
+    onActiveAccountChanged: () => () => {},
+  };
+  return { value, resolveActiveAccountAuth };
+}
+
+function sessionContext(registryKey: string | undefined): ExtensionContext {
+  return {
+    model: { provider: PROVIDER_ID, id: "kimi-k3" },
+    hasUI: true,
+    signal: undefined,
+    ui: { notify: () => {} },
+    modelRegistry: { getApiKeyForProvider: async () => registryKey },
+    sessionManager: { getSessionId: () => "session-1" },
+  } as unknown as ExtensionContext;
+}
+
+function makeController(): UsageController {
+  return new UsageController(() => DEFAULT_USAGE_CONFIG, () => {});
+}
+
+/** Records the bearer token each usage request billed. */
+function stubUsageFetch(): { headers: string[]; restore: () => void } {
+  const original = globalThis.fetch;
+  const headers: string[] = [];
+  globalThis.fetch = (async (_input: unknown, init?: RequestInit) => {
+    const requestHeaders = (init?.headers ?? {}) as Record<string, string>;
+    headers.push(String(requestHeaders.authorization ?? ""));
+    return new Response(
+      JSON.stringify({
+        usage: {
+          rolling: { status: "ok", percent: 10, resetsAt: null },
+          weekly: { status: "ok", percent: 20, resetsAt: null },
+          monthly: { status: "ok", percent: 30, resetsAt: null },
+        },
+      }),
+    );
+  }) as typeof fetch;
+  return {
+    headers,
+    restore() {
+      globalThis.fetch = original;
+    },
+  };
+}
+
+test("detects the pi-multiprovider service payload", () => {
+  assert.equal(isMultiproviderService(fakeService(async () => undefined).value), true);
+  assert.equal(isMultiproviderService(undefined), false);
+  assert.equal(isMultiproviderService({ getActiveAccount: () => {} }), false);
+  assert.equal(
+    isMultiproviderService({
+      getActiveAccount: () => {},
+      resolveActiveAccountAuth: () => {},
+      onActiveAccountChanged: null,
+    }),
+    false,
+  );
+});
+
+test("bills the session's pooled account when pi-multiprovider pins one", async () => {
+  const fetchStub = stubUsageFetch();
+  const service = fakeService(async () => ({ accessToken: "pooled-key", label: "Work" }));
+  setActiveMultiproviderService(service.value);
+  try {
+    const controller = makeController();
+    await controller.refresh(sessionContext("registry-key"), { force: true });
+    assert.deepEqual(fetchStub.headers, ["Bearer pooled-key"]);
+    assert.ok(controller.snapshot);
+  } finally {
+    setActiveMultiproviderService(undefined);
+    fetchStub.restore();
+  }
+});
+
+test("falls back to the registry key when the session has no pooled account", async () => {
+  const fetchStub = stubUsageFetch();
+  const service = fakeService(async () => undefined);
+  setActiveMultiproviderService(service.value);
+  try {
+    const controller = makeController();
+    await controller.refresh(sessionContext("registry-key"), { force: true });
+    assert.deepEqual(fetchStub.headers, ["Bearer registry-key"]);
+  } finally {
+    setActiveMultiproviderService(undefined);
+    fetchStub.restore();
+  }
+});
+
+test("falls back to the registry key when the bridge rejects", async () => {
+  const fetchStub = stubUsageFetch();
+  const service = fakeService(() => Promise.reject(new Error("store locked")));
+  setActiveMultiproviderService(service.value);
+  try {
+    const controller = makeController();
+    await controller.refresh(sessionContext("registry-key"), { force: true });
+    assert.deepEqual(fetchStub.headers, ["Bearer registry-key"]);
+  } finally {
+    setActiveMultiproviderService(undefined);
+    fetchStub.restore();
+  }
+});
+
+test("keeps its own resolution when pi-multiprovider is absent", async () => {
+  const fetchStub = stubUsageFetch();
+  setActiveMultiproviderService(undefined);
+  try {
+    const controller = makeController();
+    await controller.refresh(sessionContext("registry-key"), { force: true });
+    assert.deepEqual(fetchStub.headers, ["Bearer registry-key"]);
+  } finally {
+    fetchStub.restore();
+  }
+});

package/usage-controller.ts

@@ -8,6 +8,7 @@
 
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { PROVIDER_ID, configPath, type UsageConfig } from "./config.ts";
+import { getActiveMultiproviderService } from "./multiprovider.ts";
 import {
   USAGE_LIMITS_NOTE,
   USAGE_URL,
@@ -156,7 +157,27 @@ export class UsageController {
     }
   }
 
+  /**
+   * The session's active pooled account, when pi-multiprovider pools
+   * opencode-go. Every account carries its own budget, so a switched or
+   * restored account must bill itself instead of Pi's default credential.
+   */
+  private async resolvePooledApiKey(ctx: ExtensionContext): Promise<string | undefined> {
+    const service = getActiveMultiproviderService();
+    if (service === undefined) return undefined;
+    try {
+      const resolved = await service.resolveActiveAccountAuth(PROVIDER_ID, ctx);
+      const token = resolved?.accessToken.trim();
+      return token ? token : undefined;
+    } catch {
+      // A failing bridge must never block the default resolution below.
+      return undefined;
+    }
+  }
+
   private async resolveApiKey(ctx: ExtensionContext): Promise<string | undefined> {
+    const pooled = await this.resolvePooledApiKey(ctx);
+    if (pooled !== undefined) return pooled;
     let key: string | undefined;
     try {
       key = await ctx.modelRegistry.getApiKeyForProvider(PROVIDER_ID);

package/usage.ts

@@ -24,6 +24,8 @@
  *   30d ↺ 20d0h
  */
 
+import { UNICODE_GLYPHS, type GlyphSet } from "./glyphs.ts";
+
 export const USAGE_URL = "https://opencode.ai/zen/go/v1/usage";
 
 /** Published Go budget per window; informational only, not sent by the API. */
@@ -66,6 +68,8 @@ export interface UsageSegment {
 export interface UsageFormatOptions {
   showResetTimes: boolean;
   showBankedResets?: boolean;
+  /** Glyph set for separators and reset markers; defaults to unicode. */
+  glyphs?: GlyphSet;
 }
 
 export const USAGE_WINDOW_LABELS: Record<UsageWindowKey, string> = {
@@ -256,9 +260,10 @@ function formatCompactReset(
   label: string | undefined,
   resetAt: number | null,
   now: number,
+  glyphs: GlyphSet = UNICODE_GLYPHS,
 ): string | null {
   if (resetAt === null) return null;
-  return `${label ? `${label} ` : ""}↺ ${formatCountdown(resetAt - now)}`;
+  return `${label ? `${label} ` : ""}${glyphs.reset} ${formatCountdown(resetAt - now)}`;
 }
 
 /** "3 banked resets", or null when the count is absent or zero. */
@@ -285,11 +290,12 @@ export function usageSegments(
   options: UsageFormatOptions,
   now = Date.now(),
 ): UsageSegment[] {
+  const glyphs = options.glyphs ?? UNICODE_GLYPHS;
   const windows = snapshot.windows;
   const labelled = windows.length > 1;
   const segments: UsageSegment[] = [{ text: "Usage: ", severity: "muted" }];
   windows.forEach((window, index) => {
-    if (index > 0) segments.push({ text: " · ", severity: "muted" });
+    if (index > 0) segments.push({ text: ` ${glyphs.sep} `, severity: "muted" });
     segments.push({ text: `${window.label}: `, severity: "muted" });
     segments.push({
       text: formatPercent(window.remainingPercent),
@@ -298,13 +304,13 @@ export function usageSegments(
   });
   if (options.showResetTimes) {
     for (const window of windows) {
-      const reset = formatCompactReset(labelled ? window.label : undefined, window.resetsAt, now);
-      if (reset) segments.push({ text: ` · ${reset}`, severity: "muted" });
+      const reset = formatCompactReset(labelled ? window.label : undefined, window.resetsAt, now, glyphs);
+      if (reset) segments.push({ text: ` ${glyphs.sep} ${reset}`, severity: "muted" });
     }
   }
   if (options.showBankedResets !== false) {
     const banked = formatBankedResetsSuffix(snapshot.bankedResets);
-    if (banked) segments.push({ text: ` · ${banked}`, severity: "muted" });
+    if (banked) segments.push({ text: ` ${glyphs.sep} ${banked}`, severity: "muted" });
   }
   return segments;
 }
@@ -320,13 +326,13 @@ export function formatUsageLine(
 }
 
 /** Progress bar: 20 cells, filled by the remaining percentage. */
-export function formatBar(percent: number, width = 20): string {
+export function formatBar(percent: number, width = 20, glyphs: GlyphSet = UNICODE_GLYPHS): string {
   const filled = Math.round((clampPercent(percent) / 100) * width);
-  return `${"█".repeat(filled)}${"░".repeat(width - filled)}`;
+  return `${glyphs.barFilled.repeat(filled)}${glyphs.barHollow.repeat(width - filled)}`;
 }
 
 /** Multi-line breakdown with bars, used by the command output. */
-export function formatUsageDetail(snapshot: UsageSnapshot, now = Date.now()): string[] {
+export function formatUsageDetail(snapshot: UsageSnapshot, now = Date.now(), glyphs: GlyphSet = UNICODE_GLYPHS): string[] {
   return snapshot.windows.map((window) => {
     const clock = window.resetsAt === null
       ? null
@@ -334,8 +340,8 @@ export function formatUsageDetail(snapshot: UsageSnapshot, now = Date.now()): st
     const reset =
       window.resetsAt === null || clock === null
         ? ""
-        : `  ↺ ${formatCountdown(window.resetsAt - now)} - ${clock}`;
+        : `  ${glyphs.reset} ${formatCountdown(window.resetsAt - now)} - ${clock}`;
     const limited = window.status === "rate-limited" ? "  RATE LIMITED" : "";
-    return `${window.label.padEnd(3)} ${formatBar(window.remainingPercent)} ${formatPercent(window.remainingPercent).padStart(4)} left${reset}${limited}`;
+    return `${window.label.padEnd(3)} ${formatBar(window.remainingPercent, 20, glyphs)} ${formatPercent(window.remainingPercent).padStart(4)} left${reset}${limited}`;
   });
 }