@jameslovespancakes/pi-plus 1.0.0

package/src/domains/subscriptions/accounts-picker.ts

@@ -0,0 +1,178 @@
+import type { Component } from "@earendil-works/pi-tui";
+import { hasTruecolor, levelColor } from "../../ui/format.ts";
+import type { AccountProvider, ManagedAccount } from "../../core/accounts/registry.ts";
+
+/**
+ * The `/accounts` list.
+ *
+ * Mirrors the provider picker: an inline SettingsList inside pi's own rule
+ * chrome, toggled in place so nothing redraws the screen. Rows are grouped by
+ * provider, because an account label alone ("Personal") does not say which
+ * subscription it belongs to.
+ */
+
+export type AccountState = "enabled" | "disabled";
+
+export const ACCOUNT_STATE_TEXT: Record<AccountState, string> = {
+  enabled: "Enabled",
+  disabled: "Disabled",
+};
+
+/** Enabled reads as a full quota bar, disabled as an empty one. */
+const STATE_LEVEL: Record<AccountState, number> = { enabled: 100, disabled: 0 };
+const STATE_THEME: Record<AccountState, string> = { enabled: "success", disabled: "muted" };
+
+export function colourAccountState(theme: any, state: AccountState, text: string = ACCOUNT_STATE_TEXT[state]): string {
+  if (hasTruecolor()) return levelColor(STATE_LEVEL[state])(text);
+  return theme.fg(STATE_THEME[state], text);
+}
+
+export interface AccountRow {
+  id: string;
+  providerId: string;
+  providerLabel: string;
+  label: string;
+  state: AccountState;
+  detail?: string;
+}
+
+/** Flattens every provider's accounts into one ordered list. */
+export async function accountRows(providers: AccountProvider[]): Promise<AccountRow[]> {
+  const rows: AccountRow[] = [];
+  for (const provider of providers) {
+    let accounts: ManagedAccount[] = [];
+    try {
+      accounts = await provider.list();
+    } catch {
+      continue; // A provider that cannot enumerate is simply not shown.
+    }
+    for (const account of accounts) {
+      rows.push({
+        id: `${provider.id}:${account.id}`,
+        providerId: provider.id,
+        providerLabel: provider.label,
+        label: account.label,
+        state: account.enabled ? "enabled" : "disabled",
+        detail: account.primary ? "primary" : undefined,
+      });
+    }
+  }
+  return rows;
+}
+
+function labelFor(theme: any, row: AccountRow): string {
+  const dot = colourAccountState(theme, row.state, "●");
+  const name = row.state === "disabled" ? theme.fg("muted", row.label) : row.label;
+  return `${dot} ${theme.fg("dim", row.providerLabel)}  ${name}`;
+}
+
+function framed(theme: any, list: any, title: string): Component {
+  const rule = (w: number) => theme.fg("accent", "─".repeat(Math.max(1, w)));
+  return {
+    invalidate: () => list.invalidate?.(),
+    handleInput: (data: string) => list.handleInput(data),
+    handleMouse: (event: any) => list.handleMouse?.(event),
+    render(width: number): string[] {
+      const inner = Math.max(1, width);
+      return [rule(inner), ` ${theme.fg("accent", theme.bold(title))}`, ...list.render(inner), rule(inner)];
+    },
+  } as Component;
+}
+
+/**
+ * What closing the picker asked for.
+ *
+ * The wizards run AFTER the picker closes rather than inside it, so they can
+ * use pi's ordinary select/input prompts instead of being reimplemented as
+ * nested TUI components.
+ */
+export type PickerAction = { kind: "add" } | { kind: "rename" } | undefined;
+
+/** Action row ids are namespaced so they cannot collide with an account id. */
+const ADD_ID = "__action_add";
+const RENAME_ID = "__action_rename";
+
+export interface AccountPickerDeps {
+  rows: () => Promise<AccountRow[]>;
+  /** Applies a toggle and returns the resulting state. Synchronous so the
+   *  label, dot and value all change in one render. */
+  toggle: (providerId: string, accountId: string) => AccountState;
+}
+
+export async function openAccountsPicker(ctx: any, deps: AccountPickerDeps): Promise<PickerAction> {
+  const rows = await deps.rows();
+
+  const { SettingsList } = await import("@earendil-works/pi-tui");
+
+  return await ctx.ui.custom((_tui: any, theme: any, _keys: any, done: (value?: unknown) => void) => {
+    const toggleValues = [
+      colourAccountState(theme, "enabled"),
+      colourAccountState(theme, "disabled"),
+    ];
+
+    const items: any[] = rows.map((row) => ({
+      id: row.id,
+      label: labelFor(theme, row),
+      values: [...toggleValues],
+      currentValue: colourAccountState(theme, row.state),
+      description: row.detail,
+    }));
+
+    // Actions live as rows rather than hidden keystrokes, so they are
+    // discoverable. A single-entry `values` makes Enter fire onChange without
+    // the row appearing to cycle through anything.
+    items.push({
+      id: ADD_ID,
+      label: theme.fg("accent", "+ Add account"),
+      values: [""],
+      currentValue: "",
+      description: "Authorize another subscription",
+    });
+    if (rows.length > 0) {
+      items.push({
+        id: RENAME_ID,
+        label: theme.fg("accent", "✎ Rename account"),
+        values: [""],
+        currentValue: "",
+        description: "Change an account's display name",
+      });
+    }
+
+    let list: any;
+
+    const onChange = (id: string) => {
+      if (id === ADD_ID) { done({ kind: "add" }); return; }
+      if (id === RENAME_ID) { done({ kind: "rename" }); return; }
+
+      const row = rows.find((r) => r.id === id);
+      const item = items.find((i) => i.id === id);
+      if (!row || !item) return;
+      try {
+        const next = deps.toggle(row.providerId, row.id.slice(row.providerId.length + 1));
+        row.state = next;
+        item.label = labelFor(theme, row);
+        list?.updateValue(id, colourAccountState(theme, next));
+        list?.invalidate?.();
+      } catch (error) {
+        list?.updateValue(id, colourAccountState(theme, row.state));
+        ctx.ui.notify(error instanceof Error ? error.message : String(error), "error");
+      }
+    };
+
+    list = new SettingsList(
+      items,
+      Math.min(items.length, 12),
+      {
+        label: (text: string, selected: boolean) => (selected ? theme.fg("accent", text) : text),
+        value: (text: string) => text,
+        description: (text: string) => theme.fg("dim", text),
+        cursor: theme.fg("accent", "›"),
+        hint: (text: string) => theme.fg("dim", text),
+      },
+      onChange,
+      () => done(undefined),
+    );
+
+    return framed(theme, list, "Accounts") as Component & { dispose?(): void };
+  });
+}

package/src/domains/subscriptions/accounts.ts

@@ -0,0 +1,242 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { accountRows, openAccountsPicker, type AccountState } from "./accounts-picker.ts";
+import {
+  accountProvider,
+  accountProviders,
+  type AccountContext,
+  type AccountProvider,
+  type ManagedAccount,
+} from "../../core/accounts/registry.ts";
+
+/**
+ * `/accounts` is provider-agnostic subscription account management.
+ *
+ *   /accounts          every provider's accounts, toggled enabled/disabled
+ *   /accounts add      pick a provider, name the account, authorize
+ *   /accounts reauth   reauthorize an existing account
+ *
+ * No provider-specific logic lives here; adapters are registered in
+ * core/accounts/registry.ts, so a new provider is an adapter rather than a
+ * new command.
+ */
+
+async function openBrowser(pi: ExtensionAPI, url: string): Promise<void> {
+  if (process.platform === "win32") {
+    await pi.exec("rundll32.exe", ["url.dll,FileProtocolHandler", url]);
+    return;
+  }
+  if (process.platform === "darwin") {
+    await pi.exec("open", [url]);
+    return;
+  }
+  await pi.exec("xdg-open", [url]);
+}
+
+function bridge(pi: ExtensionAPI, ctx: any): AccountContext {
+  return {
+    hasUI: ctx.hasUI,
+    ui: {
+      input: (title, placeholder) => ctx.ui.input(title, placeholder),
+      confirm: (title, message) => ctx.ui.confirm(title, message),
+      notify: (message, type) => ctx.ui.notify(message, type ?? "info"),
+    },
+    openBrowser: (url) => openBrowser(pi, url),
+  };
+}
+
+function describe(account: ManagedAccount): string {
+  const state = !account.enabled
+    ? "disabled"
+    : account.expiresAt !== undefined && account.expiresAt < Date.now() ? "expired" : "active";
+  return `${account.label.padEnd(20)} ${state}`;
+}
+
+async function listAll(ctx: any): Promise<void> {
+  const providers = accountProviders();
+  if (providers.length === 0) {
+    ctx.ui.notify("No account providers are registered.", "warning");
+    return;
+  }
+
+  const blocks: string[] = [];
+  for (const provider of providers) {
+    try {
+      const accounts = await provider.list();
+      const routing = provider.routing ? ` · routing: ${await provider.routing.get()}` : "";
+      blocks.push(
+        `${provider.label} (${provider.id})${routing}`,
+        ...(accounts.length > 0
+          ? accounts.map((account) => `  ${describe(account)}`)
+          : [`  no additional accounts, add one with /account ${provider.id} add`]),
+      );
+    } catch (error) {
+      blocks.push(`${provider.label} (${provider.id}): ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  ctx.ui.notify(blocks.join("\n"), "info");
+}
+
+
+
+async function pickAccount(ctx: any, provider: AccountProvider): Promise<string | undefined> {
+  const accounts = await provider.list();
+  if (accounts.length === 0) {
+    ctx.ui.notify(`No ${provider.label} accounts yet. Add one with /account ${provider.id} add.`, "info");
+    return undefined;
+  }
+  if (!ctx.hasUI) {
+    ctx.ui.notify(`Specify an account: /account ${provider.id} reauth <label>`, "warning");
+    return undefined;
+  }
+
+  const labels = accounts.map(describe);
+  const choice = await ctx.ui.select(`Reauthorize which ${provider.label} account?`, labels);
+  if (!choice) return undefined;
+  return accounts[labels.indexOf(choice)]?.id;
+}
+
+export function registerAccountCommands(pi: ExtensionAPI): void {
+  /** Toggles one account and returns the state it ended in. */
+  const toggle = (providerId: string, accountId: string): AccountState => {
+    const provider = accountProvider(providerId);
+    if (!provider?.setEnabled) throw new Error(`${providerId} accounts cannot be disabled.`);
+    const next = pendingState.get(`${providerId}:${accountId}`) === "enabled" ? "disabled" : "enabled";
+    pendingState.set(`${providerId}:${accountId}`, next);
+    // Adapters persist asynchronously; the picker needs the answer now, so the
+    // write is fired off and failures surface as a notification.
+    void provider.setEnabled(accountId, next === "enabled").catch(() => {});
+    return next;
+  };
+
+  /** Mirror of on-disk state, so the synchronous toggle can answer instantly. */
+  const pendingState = new Map<string, AccountState>();
+
+  const rows = async () => {
+    const list = await accountRows(accountProviders());
+    pendingState.clear();
+    for (const row of list) pendingState.set(row.id, row.state);
+    return list;
+  };
+
+  /** Adds an account: choose provider, name it, authorize. */
+  async function addAccount(ctx: any, providerId?: string): Promise<void> {
+    if (!ctx.hasUI) {
+      ctx.ui.notify("Adding an account requires interactive Pi mode.", "error");
+      return;
+    }
+
+    const providers = accountProviders();
+    if (providers.length === 0) {
+      ctx.ui.notify("No subscription providers are registered.", "error");
+      return;
+    }
+
+    let provider = providerId ? accountProvider(providerId) : undefined;
+    if (!provider) {
+      if (providers.length === 1) {
+        provider = providers[0];
+      } else {
+        const labels = providers.map((p) => `${p.label} (${p.id})`);
+        const picked = await ctx.ui.select("Add an account for which subscription?", labels);
+        if (!picked) return;
+        provider = providers[labels.indexOf(picked)];
+      }
+    }
+    if (!provider) return;
+
+    const label = await ctx.ui.input(`${provider.label} account name`, "Work, Personal, etc.");
+    if (!label?.trim()) return;
+
+    try {
+      const added = await provider.add(bridge(pi, ctx), label.trim());
+      if (added) ctx.ui.notify(`${provider.label} account “${added}” added.`, "info");
+    } catch (error) {
+      ctx.ui.notify(`Could not add account: ${error instanceof Error ? error.message : String(error)}`, "error");
+    }
+  }
+
+  /** Rename wizard: pick an account, type a new name. */
+  async function renameAccount(ctx: any): Promise<void> {
+    if (!ctx.hasUI) {
+      ctx.ui.notify("Renaming an account requires interactive Pi mode.", "error");
+      return;
+    }
+    const list = await accountRows(accountProviders());
+    const renameable = list.filter((row) => accountProvider(row.providerId)?.rename);
+    if (renameable.length === 0) {
+      ctx.ui.notify("No accounts can be renamed.", "info");
+      return;
+    }
+
+    const labels = renameable.map((row) => `${row.providerLabel}  ${row.label}`);
+    const picked = await ctx.ui.select("Rename which account?", labels);
+    if (!picked) return;
+    const row = renameable[labels.indexOf(picked)];
+    if (!row) return;
+
+    const next = await ctx.ui.input("New name", row.label);
+    if (!next?.trim() || next.trim() === row.label) return;
+
+    const provider = accountProvider(row.providerId);
+    try {
+      // Row ids are "<providerId>:<accountId>"; strip the prefix.
+      await provider!.rename!(row.id.slice(row.providerId.length + 1), next.trim());
+      ctx.ui.notify(`Renamed to “${next.trim()}”.`, "info");
+    } catch (error) {
+      ctx.ui.notify(`Could not rename: ${error instanceof Error ? error.message : String(error)}`, "error");
+    }
+  }
+
+  pi.registerCommand("accounts", {
+    description: "Subscription accounts (/accounts [add|rename|reauth])",
+    getArgumentCompletions: (prefix) => {
+      const parts = prefix.trim().split(/\s+/).filter(Boolean);
+      if (parts.length <= 1) {
+        return ["add", "rename", "reauth"]
+          .filter((option) => option.startsWith(parts[0] ?? ""))
+          .map((option) => ({ value: option, label: option }));
+      }
+      return accountProviders()
+        .map((p) => p.id)
+        .filter((id) => id.startsWith(parts[1] ?? ""))
+        .map((id) => ({ value: `${parts[0]} ${id}`, label: id }));
+    },
+    handler: async (args, ctx) => {
+      const [action, providerId] = args.trim().split(/\s+/).filter(Boolean);
+
+      if (action === "add") return addAccount(ctx, providerId);
+      if (action === "rename") return renameAccount(ctx);
+
+      if (action === "reauth") {
+        const provider = providerId ? accountProvider(providerId) : accountProviders()[0];
+        if (!provider) { ctx.ui.notify("No subscription providers are registered.", "error"); return; }
+        const target = await pickAccount(ctx, provider);
+        if (!target) return;
+        try {
+          const done = await provider.reauth(bridge(pi, ctx), target);
+          if (done) ctx.ui.notify(`${provider.label} account “${done}” reauthorized.`, "info");
+        } catch (error) {
+          ctx.ui.notify(`Could not reauthorize: ${error instanceof Error ? error.message : String(error)}`, "error");
+        }
+        return;
+      }
+
+      if (action) {
+        ctx.ui.notify(`Unknown action “${action}”. Use: /accounts [add|rename|reauth]`, "warning");
+        return;
+      }
+
+      // Bare /accounts: the picker interactively, plain text headless.
+      if (!ctx.hasUI) return listAll(ctx);
+
+      // The picker closes to run a wizard, then reopens so the result is
+      // visible immediately. Bounded so a misbehaving action cannot spin.
+      for (let step = 0; step < 24; step++) {
+        const requested = await openAccountsPicker(ctx, { rows, toggle });
+        if (!requested) return;
+        if (requested.kind === "add") await addAccount(ctx);
+        else if (requested.kind === "rename") await renameAccount(ctx);
+      }
+    },
+  });
+}

package/src/domains/subscriptions/footer.ts

@@ -0,0 +1,182 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import { refreshUsage, startPolling, stopPolling, subscribe, usageState } from "../../services/usage-service.ts";
+import { renderUsageLines, usageSummaryText } from "../../ui/usage-bars.ts";
+import { formatTokens, sanitize } from "../../ui/format.ts";
+
+/**
+ * Single-line session footer (no working-directory line) with the subscription
+ * bars rendered directly underneath it.
+ *
+ * The footer no longer owns the poll loop; it subscribes to usage-service and
+ * re-renders on change. That is what lets non-UI consumers get fresh data.
+ */
+
+const SUBSCRIPTION_PROVIDERS = new Set(["anthropic", "openai-codex", "kimi-coding"]);
+
+export function registerFooter(pi: ExtensionAPI): void {
+  let showUsage = true;
+  let requestRender: (() => void) | undefined;
+  let unsubscribe: (() => void) | undefined;
+
+  const apply = (ctx: any) => {
+    if (!ctx.hasUI) return;
+    if (!showUsage) {
+      ctx.ui.setFooter(undefined);
+      return;
+    }
+
+    ctx.ui.setFooter((tui: any, theme: any, footerData: any) => {
+      requestRender = () => tui.requestRender();
+      return {
+        invalidate() {},
+        render(rawWidth: number): string[] {
+          const width = Math.max(1, Math.floor(Number(rawWidth) || 0));
+          const lines: string[] = [];
+
+          let input = 0;
+          let output = 0;
+          let cacheRead = 0;
+          let cacheWrite = 0;
+          let cost = 0;
+          let latestHitRate: number | undefined;
+
+          for (const entry of ctx.sessionManager.getEntries()) {
+            const usage = entry.type === "message"
+              ? (entry.message.role === "assistant" || entry.message.role === "toolResult" ? entry.message.usage : undefined)
+              : (entry.type === "branch_summary" || entry.type === "compaction" ? entry.usage : undefined);
+            if (!usage) continue;
+            input += usage.input ?? 0;
+            output += usage.output ?? 0;
+            cacheRead += usage.cacheRead ?? 0;
+            cacheWrite += usage.cacheWrite ?? 0;
+            cost += usage.cost?.total ?? 0;
+            if (entry.type === "message" && entry.message.role === "assistant") {
+              const prompt = (usage.input ?? 0) + (usage.cacheRead ?? 0) + (usage.cacheWrite ?? 0);
+              latestHitRate = prompt > 0 ? ((usage.cacheRead ?? 0) / prompt) * 100 : undefined;
+            }
+          }
+
+          const parts: string[] = [];
+          if (input) parts.push(`↑${formatTokens(input)}`);
+          if (output) parts.push(`↓${formatTokens(output)}`);
+          if (cacheRead) parts.push(`R${formatTokens(cacheRead)}`);
+          if (cacheWrite) parts.push(`W${formatTokens(cacheWrite)}`);
+          if ((cacheRead || cacheWrite) && latestHitRate !== undefined) parts.push(`CH${latestHitRate.toFixed(1)}%`);
+
+          const model = ctx.model;
+          const subscription = model ? SUBSCRIPTION_PROVIDERS.has(model.provider) : false;
+          if (cost || subscription) parts.push(`$${cost.toFixed(3)}${subscription ? " (sub)" : ""}`);
+
+          const contextUsage = ctx.getContextUsage();
+          const contextWindow = contextUsage?.contextWindow ?? model?.contextWindow ?? 0;
+          const percentValue = contextUsage?.percent ?? 0;
+          const percentText = contextUsage?.percent != null ? `${percentValue.toFixed(1)}%` : "?";
+          const contextText = `${percentText}/${formatTokens(contextWindow)}`;
+          parts.push(percentValue > 90
+            ? theme.fg("error", contextText)
+            : percentValue > 70 ? theme.fg("warning", contextText) : contextText);
+
+          const branch = footerData.getGitBranch?.();
+          if (branch) parts.push(`⎇ ${branch}`);
+
+          let left = parts.join(" ");
+          if (visibleWidth(left) > width) left = truncateToWidth(left, width, "...");
+          let leftWidth = visibleWidth(left);
+
+          let right = model?.id ?? "no-model";
+          if (model?.reasoning) {
+            const level = ctx.thinkingLevel || "off";
+            right = level === "off" ? `${right} • thinking off` : `${right} • ${level}`;
+          }
+          if (footerData.getAvailableProviderCount?.() > 1 && model) {
+            const withProvider = `(${model.provider}) ${right}`;
+            if (leftWidth + 2 + visibleWidth(withProvider) <= width) right = withProvider;
+          }
+
+          // Keep the composed line within `width`: shrink right, then left.
+          let rightWidth = visibleWidth(right);
+          if (rightWidth > width) {
+            right = truncateToWidth(right, width, "...");
+            rightWidth = visibleWidth(right);
+          }
+          if (leftWidth + 2 + rightWidth > width) {
+            const leftBudget = Math.max(0, width - rightWidth - 2);
+            left = leftBudget > 0 ? truncateToWidth(left, leftBudget, "...") : "";
+            leftWidth = visibleWidth(left);
+          }
+          const padding = " ".repeat(Math.max(0, width - leftWidth - rightWidth));
+          lines.push(truncateToWidth(theme.fg("dim", left) + theme.fg("dim", padding + right), width, ""));
+
+          const statuses = footerData.getExtensionStatuses?.() as Map<string, string> | undefined;
+          if (statuses && statuses.size > 0) {
+            const statusLine = Array.from(statuses.entries())
+              .sort(([a], [b]) => a.localeCompare(b))
+              .map(([, text]) => sanitize(text))
+              .join(" ");
+            lines.push(truncateToWidth(statusLine, width, theme.fg("dim", "...")));
+          }
+
+          if (showUsage) {
+            lines.push(...renderUsageLines(
+              usageState(),
+              theme,
+              width,
+              model?.provider === "anthropic" ? model.id : undefined,
+            ));
+          }
+
+          // Final safety net: never emit a line wider than the terminal.
+          return lines.map((line) => (visibleWidth(line) > width ? truncateToWidth(line, width, "") : line));
+        },
+      };
+    });
+  };
+
+  pi.on("session_start", async (_event, ctx) => {
+    apply(ctx);
+    unsubscribe ??= subscribe(() => requestRender?.());
+    // Polling is started even without a UI so headless consumers stay current.
+    startPolling(ctx);
+  });
+
+  pi.on("model_select", async (_event, ctx) => {
+    apply(ctx);
+    requestRender?.();
+  });
+
+  pi.on("agent_settled", async (_event, ctx) => {
+    // Status polling is cosmetic: never hold up agent completion on auth/network.
+    if (ctx.hasUI && showUsage) void refreshUsage(ctx);
+  });
+
+  pi.on("session_shutdown", async () => {
+    unsubscribe?.();
+    unsubscribe = undefined;
+    stopPolling();
+  });
+
+  pi.registerCommand("usage", {
+    description: "Refresh, hide, or show the subscription bars (on | off | text)",
+    getArgumentCompletions: (prefix) =>
+      ["on", "off", "text"]
+        .filter((option) => option.startsWith(prefix))
+        .map((option) => ({ value: option, label: option })),
+    handler: async (args, ctx) => {
+      const action = args.trim().toLowerCase();
+      if (action === "off") {
+        showUsage = false;
+        apply(ctx);
+        requestRender?.();
+        ctx.ui.notify("Usage bars hidden. Use /usage on to restore them.", "info");
+        return;
+      }
+      if (action === "on") showUsage = true;
+      await refreshUsage(ctx, true);
+      apply(ctx);
+      if (action === "text" || !ctx.hasUI) ctx.ui.notify(usageSummaryText(usageState()), "info");
+      else if (usageState().errors.length > 0) ctx.ui.notify(usageState().errors.join("\n"), "warning");
+    },
+  });
+
+}

package/src/domains/subscriptions/index.ts

@@ -0,0 +1,42 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { registerAccountProvider } from "../../core/accounts/registry.ts";
+import { anthropicAccounts } from "./providers/anthropic.ts";
+import { codexAccounts } from "./providers/codex.ts";
+import { registerAnthropicProvider } from "./provider.ts";
+import { registerAccountCommands } from "./accounts.ts";
+import { registerRoutingCommands } from "./routing.ts";
+import { registerFooter } from "./footer.ts";
+
+/**
+ * Subscriptions domain: Claude OAuth accounts, routing mode, and the quota HUD.
+ *
+ * This replaces the old `claude-multi-account.ts` + `compact-footer.ts` pair.
+ * Account and routing commands are provider-agnostic: `/account <provider>` and
+ * `/routing` dispatch through core/accounts/registry.ts, so adding a second
+ * provider means writing one adapter, not new commands.
+ * Authentication and model catalogue are separate concerns here; they were only
+ * ever colocated because they shared an OAuth token.
+ *
+ * Relationship to @cortexkit/pi-anthropic-auth:
+ *   That package stays installed and keeps ownership of the Anthropic provider,
+ *   its stream implementation, and its own commands (/claude-account,
+ *   /claude-routing, /claude-quota, ...). Absorbing it fully was evaluated and
+ *   rejected, because its `dist/commands.js` exports only `registerCommands(pi)` as a
+ *   unit, so taking over individual commands would mean copying ~130 lines of
+ *   provider/model specs that drift on every vendor upgrade. This domain adds
+ *   the multi-account surface the vendor does not provide, and everything it
+ *   touches goes through src/vendor/anthropic.ts.
+ */
+export default function subscriptions(pi: ExtensionAPI) {
+  // Adapters register first so the generic commands can see them.
+  registerAccountProvider(anthropicAccounts);
+  registerAccountProvider(codexAccounts);
+
+  // Own the Anthropic provider unless explicitly told to defer to cortexkit.
+  // PI_PLUS_VENDOR_ANTHROPIC=1 restores the vendored package.
+  if (process.env.PI_PLUS_VENDOR_ANTHROPIC !== "1") registerAnthropicProvider(pi);
+
+  registerAccountCommands(pi);
+  registerRoutingCommands(pi);
+  registerFooter(pi);
+}