@jameslovespancakes/pi-plus 1.0.12 → 1.0.14

package/src/core/config.ts

@@ -15,7 +15,6 @@ export interface PolicySection {
 }
 
 export interface RemoteSection {
-  injectStatus?: boolean;
   defaults?: Record<string, unknown>;
   workers: Record<string, unknown>[];
 }
@@ -33,7 +32,7 @@ const DEFAULTS: PiPlusConfig = {
     requireApproval: ["openrouter/*", "google/*", "openai/*"],
     deny: [],
   },
-  remote: { injectStatus: true, workers: [] },
+  remote: { workers: [] },
 };
 
 /** Legacy file -> section, applied only when that section is still absent. */
@@ -82,7 +81,7 @@ const MIGRATIONS: { file: string; apply: (raw: any, into: PiPlusConfig) => boole
     file: "remote.json",
     apply: (raw, into) => {
       if (into.remote.workers.length > 0 || !Array.isArray(raw?.workers)) return false;
-      into.remote = { injectStatus: raw.injectStatus !== false, defaults: raw.defaults, workers: raw.workers };
+      into.remote = { defaults: raw.defaults, workers: raw.workers };
       return true;
     },
   },
@@ -90,7 +89,7 @@ const MIGRATIONS: { file: string; apply: (raw: any, into: PiPlusConfig) => boole
     file: "remote-workers.json",
     apply: (raw, into) => {
       if (into.remote.workers.length > 0 || !Array.isArray(raw?.workers)) return false;
-      into.remote = { injectStatus: raw.injectStatus !== false, defaults: raw.defaults, workers: raw.workers };
+      into.remote = { defaults: raw.defaults, workers: raw.workers };
       return true;
     },
   },
@@ -113,7 +112,6 @@ function normalize(raw: Partial<PiPlusConfig> | undefined): PiPlusConfig {
       deny: Array.isArray(raw?.policy?.deny) ? raw.policy.deny : [],
     },
     remote: {
-      injectStatus: raw?.remote?.injectStatus !== false,
       defaults: raw?.remote?.defaults,
       workers: Array.isArray(raw?.remote?.workers) ? raw.remote.workers : [],
     },
@@ -125,16 +123,16 @@ export function readConfig(): PiPlusConfig {
 
   const path = configPath();
   const exists = existsSync(path);
-  const config = normalize(exists ? readJson<Partial<PiPlusConfig>>(path, {}) : undefined);
+  const raw = exists ? readJson<Partial<PiPlusConfig>>(path, {}) : undefined;
+  const config = normalize(raw);
 
-  // Only consider legacy sources when the unified file is absent or partial.
   let migrated = false;
   for (const migration of MIGRATIONS) {
     const legacyPath = agentPath(migration.file);
     if (!existsSync(legacyPath)) continue;
-    const raw = readJson<any>(legacyPath, undefined);
-    if (raw === undefined) continue;
-    if (migration.apply(raw, config)) migrated = true;
+    const legacy = readJson<any>(legacyPath, undefined);
+    if (legacy === undefined) continue;
+    if (migration.apply(legacy, config)) migrated = true;
   }
 
   if (!exists || migrated) writeJson(path, config, true);

package/src/domains/agents/format.ts

@@ -0,0 +1,39 @@
+const DELIVERY_TEXT_MAX = 2_000;
+
+export interface DeliveryMessage {
+  senderId: string;
+  senderAlias?: string;
+  text: string;
+  priority: "normal" | "urgent";
+}
+
+export interface DeliveryThread {
+  id: string;
+  title?: string;
+}
+
+export interface BoardDelivery {
+  message: DeliveryMessage;
+  thread: DeliveryThread;
+}
+
+function cleanLine(value: unknown, max: number): string {
+  const text = String(value ?? "").replace(/[\u0000-\u001f\u007f]/g, " ").replace(/\s+/g, " ").trim();
+  return text.length <= max ? text : `${text.slice(0, max - 1)}…`;
+}
+
+function compactDeliveryText(text: string): string {
+  const clean = text.replace(/\r\n?/g, "\n").replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/g, " ").trim();
+  if (clean.length <= DELIVERY_TEXT_MAX) return clean;
+  return `${clean.slice(0, DELIVERY_TEXT_MAX - 1)}…\n[truncated; use agent_board read]`;
+}
+
+export function formatBoardDeliveries(deliveries: readonly BoardDelivery[]): string {
+  const lines = [`[board${deliveries.some(({ message }) => message.priority === "urgent") ? " urgent" : ""} x${deliveries.length}]`];
+  for (const { message, thread } of deliveries) {
+    const sender = message.senderAlias || message.senderId.slice(0, 8);
+    lines.push(`${message.priority === "urgent" ? "! " : ""}from=${sender} thread=${thread.id}${thread.title ? ` (${cleanLine(thread.title, 60)})` : ""}`);
+    lines.push(compactDeliveryText(message.text));
+  }
+  return lines.join("\n");
+}

package/src/domains/agents/index.ts

@@ -11,11 +11,13 @@ import { Type } from "typebox";
 import WebSocket from "ws";
 import { env } from "../../core/env.ts";
 import { handleBoardAdmin, registerBoardLifecycle } from "./board-setup.ts";
+import { formatBoardDeliveries, type BoardDelivery } from "./format.ts";
 
 const HEARTBEAT_MS = 8_000;
 const REQUEST_TIMEOUT_MS = 2_000;
-const SNAPSHOT_CACHE_MS = 1_500;
 const MESSAGE_MAX = 8_000;
+const DELIVERY_DEBOUNCE_MS = 250;
+const DELIVERY_BATCH_MAX = 8;
 
 type State = "idle" | "thinking" | "tool";
 type Priority = "normal" | "urgent";
@@ -301,7 +303,8 @@ export default function (pi: ExtensionAPI) {
   let ctx: ExtensionContext | undefined;
   let self: AgentInfo | undefined;
   let gitInfo: GitInfo = {};
-  let snapshot: { at: number; agents: AgentInfo[] } = { at: 0, agents: [] };
+  let pendingDeliveries: BoardDelivery[] = [];
+  let deliveryTimer: ReturnType<typeof setTimeout> | undefined;
 
   const updateStatus = () => {
     if (!ctx?.hasUI) return;
@@ -315,43 +318,39 @@ export default function (pi: ExtensionAPI) {
     self = { ...self, ...gitInfo };
     client.presence(gitInfo);
   };
-  const formatCoordination = (): string[] => {
-    const { coordinator, reports, repoThread } = client.coordination;
-    const lines: string[] = [];
-    if (coordinator) lines.push(`You report to coordinator '${coordinator}'. Use agent_board action 'report' to send them progress, blockers, and completed work.`);
-    if (reports?.length) lines.push(`You are the coordinator for: ${reports.join(", ")}. Their reports arrive as agent-board messages; keep their work aligned.`);
-    if (repoThread) lines.push(`Shared repo room: thread '${repoThread}' automatically contains every agent working in this repository. Post repo-wide notices there with agent_board send.`);
-    return lines;
+  const flushDeliveries = () => {
+    if (deliveryTimer) clearTimeout(deliveryTimer);
+    deliveryTimer = undefined;
+    const deliveries = pendingDeliveries;
+    pendingDeliveries = [];
+    if (!ctx || !deliveries.length) return;
+    const urgent = deliveries.some(({ message }) => message.priority === "urgent");
+    if (urgent && !ctx.isIdle()) ctx.abort();
+    const details = deliveries.length === 1 ? deliveries[0] : { deliveries };
+    pi.sendMessage(
+      { customType: "agent-board", content: formatBoardDeliveries(deliveries), display: true, details },
+      { deliverAs: "steer", triggerTurn: true },
+    );
   };
-  const formatSnapshot = (agents: AgentInfo[]): string => {
-    const coordinationLines = formatCoordination();
-    if (!agents.length) return ["[Live agent board]\nNo other Pi agents are currently running.", ...coordinationLines].join("\n");
-    const lines = agents.slice(0, 20).map((agent) => {
-      const commit = agent.commit ? agent.commit.slice(0, 12) : "no-commit";
-      const sameLine = agent.repo && gitInfo.repo === agent.repo && agent.branch === gitInfo.branch;
-      const divergent = sameLine && agent.commit && gitInfo.commit && agent.commit !== gitInfo.commit ? " ⚠ different commit" : "";
-      const activity = agent.state === "tool" && agent.lastTool ? agent.lastTool : agent.state;
-      const role = agent.reports?.length ? " [coordinator]" : agent.coordinator ? ` [reports to ${agent.coordinator}]` : "";
-      return `- ${agent.alias || agent.sessionId.slice(0, 8)}@${agent.host}${role}: ${activity}; ${agent.branch || "-"}@${commit}${divergent}${agent.lastPrompt ? `; ${agent.lastPrompt}` : ""}`;
-    });
-    return [
-      `[Live agent board, consult before working]`,
-      `Your commit: ${gitInfo.branch || "-"}@${gitInfo.commit?.slice(0, 12) || "no-commit"}`,
-      `Running collaborators:`,
-      lines.join("\n"),
-      ...coordinationLines,
-      `Avoid duplicate or outdated work. Use agent_board to coordinate when useful.`,
-    ].join("\n");
+  const queueDelivery = (delivery: BoardDelivery) => {
+    pendingDeliveries.push(delivery);
+    if (delivery.message.priority === "urgent" || pendingDeliveries.length >= DELIVERY_BATCH_MAX) {
+      flushDeliveries();
+      return;
+    }
+    if (deliveryTimer) return;
+    deliveryTimer = setTimeout(flushDeliveries, DELIVERY_DEBOUNCE_MS);
+    deliveryTimer.unref?.();
   };
 
   client.on((event) => {
-    if (event.t === "connection" || event.t === "coordination") { updateStatus(); return; }
+    if (event.t === "connection") {
+      updateStatus();
+      return;
+    }
+    if (event.t === "coordination") { updateStatus(); return; }
     if (event.t !== "message" || event.adminView || !ctx) return;
-    const message = event.message as BoardMessage;
-    const thread = event.thread as ThreadInfo;
-    const content = `[Live agent-board message${message.priority === "urgent" ? " URGENT" : ""}]\nFrom: ${message.senderAlias || message.senderId}\nThread: ${thread.title || thread.id}\nCommit context: you are on ${gitInfo.branch || "-"}@${gitInfo.commit?.slice(0, 12) || "no-commit"}\n\n${message.text}\n\nEvaluate this at the next decision point. If relevant, adjust your work and reply through agent_board with thread '${thread.id}'. If irrelevant, continue the current task.`;
-    if (message.priority === "urgent" && !ctx.isIdle()) ctx.abort();
-    pi.sendMessage({ customType: "agent-board", content, display: true, details: { message, thread } }, { deliverAs: "steer", triggerTurn: true });
+    queueDelivery({ message: event.message as BoardMessage, thread: event.thread as ThreadInfo });
   });
 
   pi.on("session_start", async (_event, eventCtx) => {
@@ -365,7 +364,7 @@ export default function (pi: ExtensionAPI) {
   });
   pi.on("session_info_changed", async (event) => { if (self) { self.alias = event.name; client.presence({ alias: event.name }); } });
   pi.on("model_select", async (event) => client.presence({ model: `${event.model.provider}/${event.model.id}` }));
-  pi.on("before_agent_start", async (event) => {
+  pi.on("before_agent_start", (event) => {
     client.presence({ state: "thinking", lastPrompt: cleanLine(event.prompt) });
     client.activity("prompt", event.prompt);
   });
@@ -375,20 +374,10 @@ export default function (pi: ExtensionAPI) {
   });
   pi.on("tool_execution_end", async () => client.presence({ state: "thinking" }));
   pi.on("agent_settled", async () => { client.presence({ state: "idle", lastTool: undefined }); refreshGit(); });
-  pi.on("session_shutdown", async (_event, eventCtx) => { client.stop(); eventCtx.ui.setStatus("agent-board", undefined); ctx = undefined; self = undefined; });
-
-  // A transient, late context message avoids growing the session and keeps the static prompt cache stable.
-  pi.on("context", async (event) => {
-    if (!client.connected) return;
-    try {
-      if (Date.now() - snapshot.at > SNAPSHOT_CACHE_MS) snapshot = { at: Date.now(), agents: await client.request("agents", {}, 500) };
-      return {
-        messages: [...event.messages, {
-          role: "custom" as const, customType: "agent-board-snapshot", content: formatSnapshot(snapshot.agents),
-          display: false, details: {}, timestamp: Date.now(),
-        }],
-      };
-    } catch { return; }
+  pi.on("session_shutdown", async (_event, eventCtx) => {
+    if (deliveryTimer) clearTimeout(deliveryTimer);
+    deliveryTimer = undefined; pendingDeliveries = [];
+    client.stop(); eventCtx.ui.setStatus("agent-board", undefined); ctx = undefined; self = undefined;
   });
 
   pi.registerMessageRenderer("agent-board", (message, _options, theme) => new Text(theme.fg("accent", message.content as string), 1, 0));
@@ -419,7 +408,7 @@ export default function (pi: ExtensionAPI) {
     description: "Consult and message all currently running local and remote Pi agents. Every agent record includes host, state, Git branch, and commit hash. Messages are live: idle agents wake immediately and busy agents see them at the next safe turn boundary. Stopped agents are never listed and messages are not queued for them. Agents working in the same repository share an auto-created repo room, and coordinators can be assigned so subordinate agents report their progress upward.",
     promptSnippet: "Consult live collaborators, report to your coordinator, and exchange direct, repo-room, or group messages",
     promptGuidelines: [
-      "Consult the transient Live agent board context before starting work; avoid duplicating work and compare Git commit hashes before relying on another agent's changes.",
+      "Consult the latest compact Live agent board snapshot before starting work; avoid duplicating work and compare Git commit hashes before relying on another agent's changes.",
       "Use agent_board to inform collaborators when their commit or assumptions appear outdated, and reply only when coordination is useful.",
       "If the board snapshot names a coordinator for you, use agent_board action 'report' to send them meaningful progress, blockers, and completed work instead of staying silent.",
       "Use agent_board action 'set_coordinator' when the user puts one agent in charge of others, and 'coordinators' to inspect the current reporting structure.",

package/src/domains/remote/config-path.ts

@@ -20,7 +20,6 @@ export interface RemoteWorkerRecord {
 }
 
 export interface RemoteSettings {
-  injectStatus: boolean;
   defaults: Record<string, unknown>;
   workers: RemoteWorkerRecord[];
 }
@@ -28,7 +27,6 @@ export interface RemoteSettings {
 export function readRemote(): RemoteSettings {
   const section = readConfig().remote;
   return {
-    injectStatus: section.injectStatus !== false,
     defaults: (section.defaults as Record<string, unknown>) ?? {},
     workers: (section.workers as RemoteWorkerRecord[]) ?? [],
   };

package/src/domains/remote/index.ts

@@ -31,7 +31,6 @@ interface Limits {
 	gpuMemoryBlockPercent: number;
 	memoryBlockPercent: number;
 	minimumFreeDiskGB: number;
-	statusCacheSeconds: number;
 	retentionHours: number;
 }
 
@@ -58,7 +57,6 @@ interface Worker extends Omit<WorkerInput, keyof Limits | "enabled">, Limits {
 }
 
 interface Config {
-	injectStatus: boolean;
 	workers: Worker[];
 }
 
@@ -100,7 +98,6 @@ const DEFAULT_LIMITS: Limits = {
 	gpuMemoryBlockPercent: 90,
 	memoryBlockPercent: 90,
 	minimumFreeDiskGB: 10,
-	statusCacheSeconds: 30,
 	retentionHours: 24,
 };
 
@@ -117,8 +114,6 @@ const HARD_WALK_EXCLUDES = new Set([
 	"remote_tests",
 ]);
 
-let statusCache: { expiresAt: number; key: string; statuses: WorkerStatus[] } | undefined;
-
 function finiteNumber(value: unknown, fallback: number, min: number, max: number): number {
 	return typeof value === "number" && Number.isFinite(value) ? Math.min(max, Math.max(min, value)) : fallback;
 }
@@ -139,7 +134,6 @@ async function loadConfig(): Promise<Config> {
 		),
 		memoryBlockPercent: finiteNumber(defaults.memoryBlockPercent, DEFAULT_LIMITS.memoryBlockPercent, 1, 100),
 		minimumFreeDiskGB: finiteNumber(defaults.minimumFreeDiskGB, DEFAULT_LIMITS.minimumFreeDiskGB, 0, 100000),
-		statusCacheSeconds: finiteNumber(defaults.statusCacheSeconds, DEFAULT_LIMITS.statusCacheSeconds, 1, 600),
 		retentionHours: finiteNumber(defaults.retentionHours, DEFAULT_LIMITS.retentionHours, 1, 24 * 365),
 	};
 	const names = new Set<string>();
@@ -172,11 +166,10 @@ async function loadConfig(): Promise<Config> {
 			),
 			memoryBlockPercent: finiteNumber(raw.memoryBlockPercent, defaultLimits.memoryBlockPercent, 1, 100),
 			minimumFreeDiskGB: finiteNumber(raw.minimumFreeDiskGB, defaultLimits.minimumFreeDiskGB, 0, 100000),
-			statusCacheSeconds: finiteNumber(raw.statusCacheSeconds, defaultLimits.statusCacheSeconds, 1, 600),
 			retentionHours: finiteNumber(raw.retentionHours, defaultLimits.retentionHours, 1, 24 * 365),
 		};
 	});
-	return { injectStatus: parsed.injectStatus !== false, workers };
+	return { workers };
 }
 
 /** `-i`/`-p` only when the worker was added without an ~/.ssh/config entry. */
@@ -331,27 +324,15 @@ async function probeWorker(worker: Worker): Promise<WorkerStatus> {
 	}
 }
 
-async function probeWorkers(config: Config, force = false): Promise<WorkerStatus[]> {
+async function probeWorkers(config: Config): Promise<WorkerStatus[]> {
 	const active = config.workers.filter((worker) => worker.enabled);
-	if (active.length === 0) return [];
-	const key = JSON.stringify(active.map((worker) => [worker.name, worker.ssh, worker.root]));
-	const ttlSeconds = Math.min(...active.map((worker) => worker.statusCacheSeconds));
-	if (!force && statusCache && statusCache.key === key && statusCache.expiresAt > Date.now()) return statusCache.statuses;
-	const statuses = await Promise.all(active.map(probeWorker));
-	statusCache = { key, statuses, expiresAt: Date.now() + ttlSeconds * 1000 };
-	return statuses;
+	return Promise.all(active.map(probeWorker));
 }
 
 function metric(value: number | undefined): string {
 	return value === undefined ? "?" : `${Math.round(value)}%`;
 }
 
-function compactStatus(status: WorkerStatus): string {
-	const gpu = status.gpuPercent === undefined ? "GPU ?" : `GPU ${metric(status.gpuPercent)}`;
-	const reason = status.reasons.length ? ` (${status.reasons.join(", ")})` : "";
-	return `${status.name} ${status.state.toUpperCase()} CPU ${metric(status.cpuPercent)} MEM ${metric(status.memoryPercent)} ${gpu} active-jobs ${status.jobs ?? "?"}${reason}`;
-}
-
 function detailedStatuses(statuses: WorkerStatus[]): string {
 	return statuses
 		.map((status) => {
@@ -696,7 +677,6 @@ export default function remoteJobsExtension(pi: ExtensionAPI) {
 			const selected = params.host ? enabled.filter((worker) => worker.name === params.host) : enabled;
 			if (params.host && selected.length === 0) throw new Error(`Unknown remote worker: ${params.host}`);
 			const statuses = await Promise.all(selected.map(probeWorker));
-			statusCache = undefined;
 			return {
 				content: [{ type: "text", text: detailedStatuses(statuses) }],
 				details: { statuses },
@@ -745,7 +725,7 @@ export default function remoteJobsExtension(pi: ExtensionAPI) {
 			if (requestedHost !== "auto" && !enabledWorkers.some((worker) => worker.name === requestedHost)) {
 				throw new Error(`Unknown remote worker: ${requestedHost}. Available: ${enabledWorkers.map((w) => w.name).join(", ")}`);
 			}
-			let statuses = await probeWorkers(config, true);
+			const statuses = await probeWorkers(config);
 			let worker = pickWorker(config, statuses, requestedHost, params.requiresGpu ?? false);
 			if (!worker) return blockedResult(undefined, undefined, detailedStatuses(statuses));
 			let workerStatus = statuses.find((status) => status.name === worker!.name);
@@ -818,7 +798,6 @@ export default function remoteJobsExtension(pi: ExtensionAPI) {
 					text += `\n\n[Output truncated; full log: ${remoteJob}/test.log]`;
 				}
 				void runSsh(worker, "bash -s", { input: cleanupScript(worker, snapshot.repoName), timeoutSeconds: 15 }).catch(() => {});
-				statusCache = undefined;
 				return {
 					content: [{ type: "text", text }],
 					details: {
@@ -847,20 +826,4 @@ export default function remoteJobsExtension(pi: ExtensionAPI) {
 		},
 	});
 
-	pi.on("before_agent_start", async (event) => {
-		try {
-			const config = await loadConfig();
-			if (!config.injectStatus) return;
-			const statuses = await probeWorkers(config);
-			if (statuses.length === 0) return;
-			const line = statuses.map(compactStatus).join("; ");
-			return {
-				systemPrompt:
-					event.systemPrompt +
-					`\n\nRemote worker capacity (recent sample): ${line}. remote_test always performs a fresh hard admission check. Never retry a BLOCKED worker immediately; choose another READY worker or run locally.`,
-			};
-		} catch {
-			return;
-		}
-	});
 }

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

@@ -26,15 +26,50 @@ export interface AccountRow {
   providerLabel: string;
   label: string;
   state: AccountState;
+  primary?: boolean;
   detail?: string;
 }
 
+export type PrimaryAccountResolver = (
+  provider: AccountProvider,
+) => ManagedAccount | undefined | Promise<ManagedAccount | undefined>;
+
+/** Adds pi's own credential to a provider's sidecar-managed accounts. */
+export async function providerAccounts(
+  provider: AccountProvider,
+  resolvePrimary?: PrimaryAccountResolver,
+): Promise<ManagedAccount[]> {
+  // Resolve serially so providers that discover identity through a profile
+  // endpoint do not burst the same endpoint for primary and sidecar accounts.
+  const primary = resolvePrimary
+    ? await Promise.resolve().then(() => resolvePrimary(provider)).catch(() => undefined)
+    : undefined;
+  const accounts = await provider.list();
+  const combined = !primary || accounts.some((account) => account.primary || account.id === primary.id)
+    ? accounts
+    : [primary, ...accounts];
+
+  const ids = new Set<string>();
+  const identities = new Set<string>();
+  return combined.filter((account) => {
+    if (ids.has(account.id)) return false;
+    ids.add(account.id);
+    if (!account.identity) return true;
+    if (identities.has(account.identity)) return false;
+    identities.add(account.identity);
+    return true;
+  });
+}
+
 /** Flattens provider accounts while loading providers in parallel. */
-export async function accountRows(providers: AccountProvider[]): Promise<AccountRow[]> {
+export async function accountRows(
+  providers: AccountProvider[],
+  resolvePrimary?: PrimaryAccountResolver,
+): Promise<AccountRow[]> {
   const groups = await Promise.all(providers.map(async (provider) => {
     let accounts: ManagedAccount[];
     try {
-      accounts = await provider.list();
+      accounts = await providerAccounts(provider, resolvePrimary);
     } catch {
       return [];
     }
@@ -44,7 +79,8 @@ export async function accountRows(providers: AccountProvider[]): Promise<Account
       providerLabel: provider.label,
       label: account.label,
       state: account.enabled ? "enabled" as const : "disabled" as const,
-      detail: account.primary ? "primary" : undefined,
+      primary: account.primary,
+      detail: account.primary ? "primary · managed by pi auth" : undefined,
     }));
   }));
   return groups.flat();
@@ -96,7 +132,7 @@ export async function openAccountsPicker(ctx: any, deps: AccountPickerDeps): Pro
     const items: any[] = rows.map((row) => ({
       id: row.id,
       label: labelFor(theme, row),
-      values: [...toggleValues],
+      values: row.primary ? [colourAccountState(theme, row.state)] : [...toggleValues],
       currentValue: colourAccountState(theme, row.state),
       description: row.detail,
     }));
@@ -128,6 +164,10 @@ export async function openAccountsPicker(ctx: any, deps: AccountPickerDeps): Pro
       const row = rows.find((r) => r.id === id);
       const item = items.find((i) => i.id === id);
       if (!row || !item) return;
+      if (row.primary) {
+        ctx.ui.notify("Primary accounts are managed by pi auth.", "info");
+        return;
+      }
       try {
         const next = deps.toggle(row.providerId, row.id.slice(row.providerId.length + 1));
         row.state = next;

package/src/domains/subscriptions/accounts.ts

@@ -1,5 +1,10 @@
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { accountRows, openAccountsPicker, type AccountState } from "./accounts-picker.ts";
+import { readStoredCredential, type ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import {
+  accountRows,
+  openAccountsPicker,
+  providerAccounts,
+  type AccountState,
+} from "./accounts-picker.ts";
 import {
   accountProvider,
   accountProviders,
@@ -46,11 +51,29 @@ function bridge(pi: ExtensionAPI, ctx: any): AccountContext {
   };
 }
 
+async function primaryAccount(provider: AccountProvider): Promise<ManagedAccount | undefined> {
+  try {
+    const credential = readStoredCredential(provider.id);
+    if (!credential) return undefined;
+    return {
+      id: "main",
+      label: "Primary",
+      enabled: true,
+      expiresAt: credential.type === "oauth" ? credential.expires : undefined,
+      primary: true,
+      identity: credential.type === "oauth" ? await provider.identify?.(credential.access) : undefined,
+    };
+  } catch {
+    // A malformed/unreadable auth file must not hide the sidecar accounts.
+    return undefined;
+  }
+}
+
 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}`;
+  return `${account.label.padEnd(20)} ${state}${account.primary ? " · primary" : ""}`;
 }
 
 async function listAll(ctx: any): Promise<void> {
@@ -63,7 +86,7 @@ async function listAll(ctx: any): Promise<void> {
   const blocks = await Promise.all(providers.map(async (provider): Promise<string[]> => {
     try {
       const [accounts, mode] = await Promise.all([
-        provider.list(),
+        providerAccounts(provider, primaryAccount),
         provider.routing?.get(),
       ]);
       const routing = mode ? ` · routing: ${mode}` : "";
@@ -81,7 +104,7 @@ async function listAll(ctx: any): Promise<void> {
 }
 
 async function pickAccount(ctx: any, provider: AccountProvider): Promise<string | undefined> {
-  const accounts = await provider.list();
+  const accounts = (await provider.list()).filter((account) => !account.primary);
   if (accounts.length === 0) {
     ctx.ui.notify(`No ${provider.label} accounts yet. Add one with /accounts add ${provider.id}.`, "info");
     return undefined;
@@ -110,7 +133,7 @@ export function registerAccountCommands(pi: ExtensionAPI): void {
   const pendingState = new Map<string, AccountState>();
 
   const rows = async () => {
-    const list = await accountRows(accountProviders());
+    const list = await accountRows(accountProviders(), primaryAccount);
     pendingState.clear();
     for (const row of list) pendingState.set(row.id, row.state);
     return list;
@@ -158,8 +181,8 @@ export function registerAccountCommands(pi: ExtensionAPI): void {
       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);
+    const list = await accountRows(accountProviders(), primaryAccount);
+    const renameable = list.filter((row) => !row.primary && accountProvider(row.providerId)?.rename);
     if (renameable.length === 0) {
       ctx.ui.notify("No accounts can be renamed.", "info");
       return;

package/src/domains/subscriptions/index.ts

@@ -1,7 +1,7 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { registerAccountProvider } from "../../core/accounts/registry.ts";
 import { anthropicAccounts } from "./providers/anthropic.ts";
-import { codexAccounts, registerCodexProvider } from "./providers/codex.ts";
+import { codexAccounts, CODEX_SPEC } from "./providers/codex.ts";
 import { kimiAccounts, KIMI_SPEC, xaiAccounts, XAI_SPEC } from "./providers/hosted.ts";
 import { registerPooledOAuthProvider } from "./providers/oauth-pool.ts";
 import { registerAnthropicProvider } from "./provider.ts";
@@ -16,7 +16,7 @@ export default function subscriptions(pi: ExtensionAPI) {
   }
 
   registerAnthropicProvider(pi);
-  registerCodexProvider(pi);
+  registerPooledOAuthProvider(pi, CODEX_SPEC);
   registerPooledOAuthProvider(pi, KIMI_SPEC);
   registerPooledOAuthProvider(pi, XAI_SPEC);
 

package/src/domains/subscriptions/provider.ts

@@ -3,8 +3,16 @@ import { authorize, exchange, refreshToken } from "../../core/anthropic/oauth.ts
 import {
   billingHeader, clientIdentityHeaders, firstUserText, prependPromptBlock, signRequestBody, splitSystemPrompt,
 } from "../../core/anthropic/client-identity.ts";
+import {
+  anthropicAccountIdentity,
+  cachedAnthropicAccountIdentity,
+} from "../../core/anthropic/identity.ts";
 import { ANTHROPIC_MODELS } from "../../core/anthropic/models.ts";
-import { applyQuotaHeaders, refreshAllQuota } from "../../core/anthropic/quota.ts";
+import {
+  ACCESS_REFRESH_INTERVAL_MS,
+  applyQuotaHeaders,
+  refreshAllQuota,
+} from "../../core/anthropic/quota.ts";
 import {
   MAIN_ACCOUNT_ID, familyForModel, selectAccount, type Candidate,
 } from "../../core/anthropic/routing.ts";
@@ -41,6 +49,17 @@ export function routeAccessToken(primary: string, modelId?: string, _sessionId?:
 
   const mode = getRoutingMode(storage);
   const family = familyForModel(modelId);
+  const primaryIdentity = cachedAnthropicAccountIdentity(primary);
+  if (!primaryIdentity) void anthropicAccountIdentity(primary).catch(() => {});
+  const identities = new Set(primaryIdentity ? [primaryIdentity] : []);
+  const sidecars = storage.accounts.filter((account) => {
+    if (account.enabled === false || account.type !== "oauth" || !account.access
+      || typeof account.expires !== "number" || account.expires <= Date.now()) return false;
+    if (!account.identity) return true;
+    if (identities.has(account.identity)) return false;
+    identities.add(account.identity);
+    return true;
+  });
 
   const candidates: Candidate[] = [
     {
@@ -50,9 +69,10 @@ export function routeAccessToken(primary: string, modelId?: string, _sessionId?:
       order: 0,
       lastUsed: accountLastUsed.get(MAIN_ACCOUNT_ID) ?? Number(storage.main?.lastUsed ?? 0),
     },
-    ...storage.accounts
-      .filter((a) => a.enabled !== false && a.type === "oauth" && a.access)
-      .map((a, index) => ({
+    // Never route an expired/unknown-lifetime sidecar while its asynchronous
+    // refresher catches up; falling back to pi's primary is safer than a 401.
+    // Stable identities also keep duplicate logins from inflating the pool.
+    ...sidecars.map((a, index) => ({
         id: a.id,
         access: a.access,
         quota: a.quota,
@@ -150,12 +170,33 @@ export function registerAnthropicProvider(pi: ExtensionAPI): void {
     }
   });
 
-  /** Refreshes stale idle-account quota when a message starts. */
+  /**
+   * Keep rotating sidecar credentials even while their quota snapshot is fresh.
+   * CortexKit refreshes fallbacks on an independent background cadence for the
+   * same reason: quota freshness is not credential freshness.
+   */
+  let refreshTimer: ReturnType<typeof setInterval> | undefined;
+  const startRefreshLoop = () => {
+    if (refreshTimer) return;
+    refreshTimer = setInterval(
+      () => void refreshAllQuota().catch(() => {}),
+      ACCESS_REFRESH_INTERVAL_MS + Math.floor(Math.random() * 30_000),
+    );
+    refreshTimer.unref?.();
+  };
+
   pi.on("input", async () => {
+    startRefreshLoop();
     void refreshAllQuota().catch(() => {});
   });
 
   pi.on("session_start", async () => {
+    startRefreshLoop();
     void refreshAllQuota().catch(() => {});
   });
+
+  pi.on("session_shutdown", async () => {
+    if (refreshTimer) clearInterval(refreshTimer);
+    refreshTimer = undefined;
+  });
 }