@hieplp/pi-account-switcher 0.2.4 → 0.3.0

package/src/commands/accounts/subagent.ts

@@ -0,0 +1,50 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { AccountSwitcher } from "@/runtime";
+import type { AccountSwitcherContext } from "@/types";
+import { errorUtil } from "@/utils";
+import { AccountCommand } from "./shared";
+
+export const useSubagentAccountCommand = (pi: ExtensionAPI, runtime: AccountSwitcher) => {
+  new SubagentAccountCommand(pi, runtime).register();
+};
+
+class SubagentAccountCommand extends AccountCommand {
+  constructor(pi: ExtensionAPI, runtime: AccountSwitcher) {
+    super(pi, runtime, {
+      name: "accounts:subagent",
+      description: "Set the account to use for the next spawned subagent (one-shot or persistent)",
+    });
+  }
+
+  async handler(ctx: AccountSwitcherContext, args?: string): Promise<void> {
+    try {
+      await this.runtime.load();
+      const accounts = this.runtime.getAccounts();
+
+      if (accounts.length === 0) {
+        ctx.ui.notify("No accounts configured.", "info");
+        return;
+      }
+
+      // Interactive: pick an account
+      const account = await this.pickGroupedAccount(ctx, accounts, "Account for subagent");
+      if (!account) return;
+
+      // Ask about oneshot (default: yes)
+      const oneshot = await ctx.ui.confirm(
+        "Apply to next subagent only?",
+        "Yes = one-shot (next subagent only). No = persistent (all subagents until changed).",
+      );
+
+      const varName = oneshot !== false ? "PI_ACCOUNT_SWITCHER_NEXT_ID" : "PI_ACCOUNT_SWITCHER_ACTIVE_ID";
+      process.env[varName] = account.id;
+
+      ctx.ui.notify(
+        `Subagent account set to: ${account.label} (${oneshot !== false ? "next subagent only" : "persistent"}).`,
+        "info",
+      );
+    } catch (e) {
+      ctx.ui.notify(`Failed to set subagent account: ${errorUtil.format(e)}`, "error");
+    }
+  }
+}

package/src/commands/accounts/switch.ts

@@ -2,7 +2,7 @@ import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import type { AccountSwitcher } from "@/runtime";
 import type { AccountSwitcherContext } from "@/types";
 import { COMMANDS } from "@/constants";
-import { commandUtil, errorUtil, providerUtil } from "@/utils";
+import { errorUtil } from "@/utils";
 import { AccountCommand } from "./shared";
 
 export const useSwitchAccountCommand = (pi: ExtensionAPI, runtime: AccountSwitcher) => {
@@ -14,38 +14,30 @@ class SwitchAccountCommand extends AccountCommand {
     super(pi, runtime, COMMANDS.accounts.switch);
   }
 
-  async handler(ctx: AccountSwitcherContext): Promise<void> {
+  async handler(ctx: AccountSwitcherContext, args?: string): Promise<void> {
     try {
       await this.runtime.load();
 
-      const active = this.runtime.getActiveAccount();
-      if (!active) {
-        ctx.ui.notify(
-          `No active account. Use ${commandUtil.name(COMMANDS.accounts.list.name)} to activate one first.`,
-          "info",
-        );
+      // With args: activate by ID directly (agent-facing, any provider)
+      if (args) {
+        const account = this.runtime.getAccounts().find((a) => a.id === args.trim());
+        if (!account) {
+          ctx.ui.notify(`Account not found: "${args.trim()}". Use the list_accounts tool to see available accounts.`, "error");
+          return;
+        }
+        const applied = await this.runtime.activateAccount(account, ctx);
+        ctx.ui.notify(`Switched to ${account.label} (${applied}).`, "info");
         return;
       }
 
-      const providers = this.runtime.getProviders();
-      const normalizedActive = providerUtil.normalizeProviderWithCustom(
-        active.piAuth?.provider ?? active.provider,
-        providers,
-      );
-      const peers = this.runtime
-        .getAccounts()
-        .filter(
-          (a) =>
-            providerUtil.normalizeProviderWithCustom(a.piAuth?.provider ?? a.provider, providers) ===
-              normalizedActive && a.id !== active.id,
-        );
-
-      if (peers.length === 0) {
-        ctx.ui.notify(`No other accounts for provider "${active.provider}".`, "info");
+      // Without args: interactive picker from all accounts
+      const accounts = this.runtime.getAccounts();
+      if (accounts.length === 0) {
+        ctx.ui.notify("No accounts configured. Use accounts:add to create one.", "info");
         return;
       }
 
-      const account = await this.pickGroupedAccount(ctx, peers, `Switch account (${active.provider})`);
+      const account = await this.pickGroupedAccount(ctx, accounts, "Pick account to activate");
       if (!account) return;
 
       const applied = await this.runtime.activateAccount(account, ctx);

package/src/commands/dirs/dirs.ts

@@ -0,0 +1,176 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { AccountSwitcher } from "@/runtime";
+import type { AccountConfig, AccountSwitcherContext } from "@/types";
+import { COMMANDS } from "@/constants";
+import { BaseCommand } from "../base";
+import { buildGroupedItems } from "../accounts/shared/select";
+import { homedir } from "node:os";
+import { join, dirname } from "node:path";
+import type { Dirent } from "node:fs";
+
+export const useDirsCommand = (pi: ExtensionAPI, runtime: AccountSwitcher) => {
+  new DirsCommand(pi, runtime).register();
+};
+
+class DirsCommand extends BaseCommand {
+  constructor(pi: ExtensionAPI, runtime: AccountSwitcher) {
+    super(pi, runtime, COMMANDS.accounts.dirs);
+  }
+
+  async handler(ctx: AccountSwitcherContext): Promise<void> {
+    await this.runtime.load();
+    const accounts = this.runtime.getAccounts();
+    if (accounts.length === 0) {
+      ctx.ui.notify("No accounts configured.", "info");
+      return;
+    }
+
+    // Build entry options: auto-save if active account + CWD both exist
+    const activeAccount = this.runtime.getActiveAccount();
+    const canAutoSave = Boolean(ctx.cwd && activeAccount);
+    const entryOptions = canAutoSave
+      ? ["Auto-save current folder", "Select an account to configure"]
+      : ["Select an account to configure"];
+
+    const entry = await ctx.ui.select("Directory auto-select", entryOptions);
+    if (!entry) return;
+
+    if (entry === "Auto-save current folder") {
+      await this.autoSave(ctx, activeAccount!);
+      return;
+    }
+
+    // Manual: pick account → add/remove
+    await this.manualConfig(ctx, accounts);
+  }
+
+  private async autoSave(ctx: AccountSwitcherContext, account: AccountConfig): Promise<void> {
+    const cwd = ctx.cwd!;
+    const resolved = cwd;
+
+    // Check if already present
+    const current = this.runtime.getAccounts().find((a) => a.id === account.id) ?? account;
+    const dirs = current.dirs ?? [];
+
+    if (dirs.includes(resolved)) {
+      ctx.ui.notify(`Directory already configured for ${current.label}.`, "info");
+      return;
+    }
+
+    const updated: AccountConfig = { ...current, dirs: [...dirs, resolved] };
+    await this.runtime.editAccount(current, updated);
+    ctx.ui.notify(`Added dir: ${resolved}`, "info");
+  }
+
+  private async manualConfig(ctx: AccountSwitcherContext, accounts: AccountConfig[]): Promise<void> {
+    const account = await this.pickAccount(ctx, accounts);
+    if (!account) return;
+
+    await this.manageDirs(ctx, account);
+  }
+
+  private async pickAccount(
+    ctx: AccountSwitcherContext,
+    accounts: AccountConfig[],
+  ): Promise<AccountConfig | undefined> {
+    const items = buildGroupedItems(accounts, this.runtime.getProviders(), this.runtime.getActiveAccount()?.id);
+    const labels: string[] = [];
+    const values: Array<AccountConfig | null> = [];
+    for (const item of items) {
+      if (item.type === "header") {
+        labels.push(item.provider);
+        values.push(null);
+        continue;
+      }
+      labels.push(`  ${this.isActiveAccount(item.account) ? `${item.account.label} (active)` : item.account.label}`);
+      values.push(item.account);
+    }
+    return this.pickGrouped(ctx, "Pick account to configure dirs", labels, values);
+  }
+
+  private async manageDirs(ctx: AccountSwitcherContext, account: AccountConfig): Promise<void> {
+    const current = this.runtime.getAccounts().find((a) => a.id === account.id) ?? account;
+    const dirs = current.dirs ?? [];
+    const dirsDisplay = dirs.length > 0 ? dirs.join(", ") : "(none)";
+    ctx.ui.notify(`Account: ${current.label} | Dirs: ${dirsDisplay}`, "info");
+
+    const options = ["Add directory", "Remove directory"];
+    const action = await ctx.ui.select("Directory auto-select", options);
+    if (!action) return;
+
+    if (action === "Add directory") {
+      const picked = await this.pickDirectory(ctx, homedir());
+      if (!picked) return;
+      const resolved = picked;
+      if (dirs.includes(resolved)) {
+        ctx.ui.notify(`Directory already configured for ${current.label}.`, "info");
+        return;
+      }
+      const updated: AccountConfig = { ...current, dirs: [...dirs, resolved] };
+      await this.runtime.editAccount(current, updated);
+      ctx.ui.notify(`Added dir: ${resolved}`, "info");
+      return;
+    }
+
+    if (action === "Remove directory") {
+      if (dirs.length === 0) {
+        ctx.ui.notify("No directories configured.", "info");
+        return;
+      }
+      const selected = await ctx.ui.select("Remove directory", dirs);
+      if (!selected) return;
+
+      const updatedDirs = dirs.filter((d) => d !== selected);
+      const updated: AccountConfig = { ...current, dirs: updatedDirs.length > 0 ? updatedDirs : undefined };
+      await this.runtime.editAccount(current, updated);
+      ctx.ui.notify(`Removed dir: ${selected}`, "info");
+      return;
+    }
+  }
+
+  private async pickDirectory(ctx: AccountSwitcherContext, startPath: string): Promise<string | undefined> {
+    let currentPath = startPath;
+    while (true) {
+      const entries = this.listDirectories(currentPath);
+      const displayPath = currentPath.replace(homedir(), "~");
+
+      const options: Array<{ label: string; value: string }> = [
+        { label: "✅ Select this directory", value: "__select__" },
+        { label: "⬆  ..", value: "__up__" },
+        ...entries.map((e) => ({ label: `${e}/`, value: e })),
+      ];
+
+      const labels = options.map((o) => o.label);
+      const selected = await ctx.ui.select(`Navigate: ${displayPath}`, labels);
+      if (!selected) return undefined;
+
+      const option = options.find((o) => o.label === selected);
+      if (!option) continue;
+
+      if (option.value === "__select__") return currentPath;
+      if (option.value === "__up__") {
+        const parent = dirname(currentPath);
+        if (parent === currentPath) continue; // at root, can't go up
+        currentPath = parent;
+        continue;
+      }
+      // Navigate into subdirectory
+      currentPath = join(currentPath, option.value);
+    }
+  }
+
+  private listDirectories(dirPath: string): string[] {
+    const result: string[] = [];
+    try {
+      const entries: Dirent[] = require("fs").readdirSync(dirPath, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isDirectory() && !entry.name.startsWith(".")) {
+          result.push(entry.name);
+        }
+      }
+    } catch {
+      /* permission denied, return what we have */
+    }
+    return result.sort((a, b) => a.localeCompare(b));
+  }
+}

package/src/commands/dirs/index.ts

@@ -0,0 +1,9 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { AccountSwitcher } from "@/runtime";
+import { useDirsCommand } from "./dirs";
+
+const useDirsCommands = (pi: ExtensionAPI, runtime: AccountSwitcher) => {
+  useDirsCommand(pi, runtime);
+};
+
+export default useDirsCommands;

package/src/commands/index.ts

@@ -2,6 +2,7 @@ import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import type { AccountSwitcher } from "@/runtime";
 import useProviderCommands from "./providers";
 import useAccountCommands from "./accounts";
+import useDirsCommands from "./dirs";
 import useModelCommands from "./models";
 import useSystemCommands from "./system";
 
@@ -10,6 +11,7 @@ export { BaseCommand } from "./base";
 
 export function registerAllCommands(pi: ExtensionAPI, runtime: AccountSwitcher) {
   useAccountCommands(pi, runtime);
+  useDirsCommands(pi, runtime);
   useProviderCommands(pi, runtime);
   useModelCommands(pi, runtime);
   useSystemCommands(pi, runtime);

package/src/constants/commands.ts

@@ -6,7 +6,7 @@ export const COMMANDS = {
     },
     list: {
       name: "accounts:list",
-      description: "List configured accounts and activate the selected account",
+      description: "(agent tool: use list_accounts tool instead for structured output",
     },
     edit: {
       name: "accounts:edit",
@@ -29,6 +29,10 @@ export const COMMANDS = {
       description:
         "Verify secrets for one or all accounts without activating them (pass 'all'; add 'ping' to send a test request)",
     },
+    dirs: {
+      name: "accounts:dirs",
+      description: "Manage working directories for CWD-based auto-select",
+    },
   },
   providers: {
     add: {

package/src/constants/providers.ts

@@ -14,11 +14,41 @@ export const OAUTH_PROVIDER_IDS = [
   "anthropic",
   "openai-codex",
   "github-copilot",
-  "google-antigravity",
-  "custom",
 ] as const;
 
-export const BUILT_IN_PROVIDER_IDS = ["anthropic", "openai", "openai-codex", "google", "xai", "openrouter"] as const;
+export const BUILT_IN_PROVIDER_IDS = [
+  "amazon-bedrock",
+  "anthropic",
+  "azure-openai-responses",
+  "cerebras",
+  "cloudflare-ai-gateway",
+  "cloudflare-workers-ai",
+  "deepseek",
+  "fireworks",
+  "github-copilot",
+  "google",
+  "google-vertex",
+  "groq",
+  "huggingface",
+  "kimi-coding",
+  "minimax",
+  "minimax-cn",
+  "mistral",
+  "moonshotai",
+  "moonshotai-cn",
+  "openai",
+  "openai-codex",
+  "opencode",
+  "opencode-go",
+  "openrouter",
+  "vercel-ai-gateway",
+  "xai",
+  "xiaomi",
+  "xiaomi-token-plan-ams",
+  "xiaomi-token-plan-cn",
+  "xiaomi-token-plan-sgp",
+  "zai",
+] as const;
 
 export const PROVIDER_ALIASES: Record<string, string> = {
   claude: "anthropic",
@@ -27,10 +57,35 @@ export const PROVIDER_ALIASES: Record<string, string> = {
 };
 
 export const PROVIDER_ENV_KEYS: Record<string, string[]> = {
-  anthropic: ["ANTHROPIC_API_KEY"],
+  anthropic: ["ANTHROPIC_OAUTH_TOKEN", "ANTHROPIC_API_KEY"],
   openai: ["OPENAI_API_KEY"],
   "openai-codex": ["OPENAI_API_KEY"],
-  google: ["GOOGLE_API_KEY", "GEMINI_API_KEY"],
+  google: ["GEMINI_API_KEY"],
+  "google-vertex": ["GOOGLE_CLOUD_API_KEY"],
+  "azure-openai-responses": ["AZURE_OPENAI_API_KEY"],
+  deepseek: ["DEEPSEEK_API_KEY"],
+  groq: ["GROQ_API_KEY"],
+  cerebras: ["CEREBRAS_API_KEY"],
   xai: ["XAI_API_KEY"],
   openrouter: ["OPENROUTER_API_KEY"],
+  "vercel-ai-gateway": ["AI_GATEWAY_API_KEY"],
+  zai: ["ZAI_API_KEY"],
+  mistral: ["MISTRAL_API_KEY"],
+  minimax: ["MINIMAX_API_KEY"],
+  "minimax-cn": ["MINIMAX_CN_API_KEY"],
+  moonshotai: ["MOONSHOT_API_KEY"],
+  "moonshotai-cn": ["MOONSHOT_API_KEY"],
+  huggingface: ["HF_TOKEN"],
+  fireworks: ["FIREWORKS_API_KEY"],
+  opencode: ["OPENCODE_API_KEY"],
+  "opencode-go": ["OPENCODE_API_KEY"],
+  "kimi-coding": ["KIMI_API_KEY"],
+  "cloudflare-workers-ai": ["CLOUDFLARE_API_KEY"],
+  "cloudflare-ai-gateway": ["CLOUDFLARE_API_KEY"],
+  xiaomi: ["XIAOMI_API_KEY"],
+  "xiaomi-token-plan-cn": ["XIAOMI_TOKEN_PLAN_CN_API_KEY"],
+  "xiaomi-token-plan-ams": ["XIAOMI_TOKEN_PLAN_AMS_API_KEY"],
+  "xiaomi-token-plan-sgp": ["XIAOMI_TOKEN_PLAN_SGP_API_KEY"],
+  "github-copilot": ["COPILOT_GITHUB_TOKEN", "GH_TOKEN", "GITHUB_TOKEN"],
+  "amazon-bedrock": [],
 };

package/src/index.ts

@@ -1,7 +1,7 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import type { AccountSwitcherContext } from "@/types";
-import { useAccountSwitcher, type AccountSwitcher } from "./runtime";
-import { registerAllCommands } from "./commands";
+import { useAccountSwitcher, type AccountSwitcher } from "@/runtime";
+import { registerAllCommands } from "@/commands";
 
 async function accountSwitcher(pi: ExtensionAPI) {
   const runtime: AccountSwitcher = useAccountSwitcher(pi);
@@ -10,6 +10,12 @@ async function accountSwitcher(pi: ExtensionAPI) {
     await runtime.init(ctx as AccountSwitcherContext);
   });
 
+  // Re-assert account status on agent/turn lifecycle so it persists
+  // across TUI redraws, reloads, and powerline updates.
+  pi.on("agent_start", async (_, ctx) => {
+    runtime.refreshStatus(ctx as AccountSwitcherContext);
+  });
+
   pi.on("model_select", async (event, ctx) => {
     await runtime.onModelSelect(event.model.provider, ctx as AccountSwitcherContext);
   });

package/src/runtime/account-switcher-runtime.ts

@@ -1,11 +1,12 @@
-import AccountSwitcher from "./account-switcher";
+import type AccountSwitcher from "./account-switcher";
+import { createHash } from "node:crypto";
 import { ACCOUNTS_PATH, PROVIDERS_PATH, STATE_PATH } from "@/constants";
 import type { Api, Model } from "@earendil-works/pi-ai";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import type { AccountConfig, AccountSwitcherContext, PiAuthEntry, ProviderConfig } from "@/types";
 import type { AccountService, ModelService, PiAuthService, ProviderService } from "@/services";
 import { useAccountService, useModelService, usePiAuthService, useProviderService } from "@/services";
-import { accountUtil, modelUtil, providerUtil, uiUtil } from "@/utils";
+import { accountUtil, findLongestMatchingDir, modelUtil, providerUtil, uiUtil } from "@/utils";
 
 function resolveAuthProvider(account: AccountConfig, providers: ProviderConfig[]): string {
   if (account.piAuth?.provider) return account.piAuth.provider;
@@ -22,58 +23,117 @@ export default class AccountSwitcherRuntime implements AccountSwitcher {
   private modelService: ModelService;
   private piAuthService: PiAuthService;
   private providerService: ProviderService;
-
-  constructor(private readonly pi: Pick<ExtensionAPI, "registerProvider" | "setModel">) {
-    this.providerService = useProviderService(this.pi as ExtensionAPI, PROVIDERS_PATH);
-    this.accountService = useAccountService(ACCOUNTS_PATH, STATE_PATH);
+  private lastStatusLabel: string | undefined;
+  private sessionKey: string | undefined;
+
+  constructor(
+    private readonly pi: Pick<ExtensionAPI, "registerProvider" | "setModel">,
+    private readonly paths?: { accounts: string; providers: string; state: string },
+  ) {
+    this.providerService = useProviderService(this.pi as ExtensionAPI, paths?.providers ?? PROVIDERS_PATH);
+    this.accountService = useAccountService(paths?.accounts ?? ACCOUNTS_PATH, paths?.state ?? STATE_PATH);
     this.modelService = useModelService(this.pi);
     this.piAuthService = usePiAuthService();
   }
 
+  /** Derive a stable session key from the session manager. */
+  private getSessionKey(ctx: AccountSwitcherContext): string {
+    try {
+      const sm = (ctx as unknown as Record<string, unknown>).sessionManager as Record<string, unknown> | undefined;
+      const sessionFile = typeof sm?.getSessionFile === "function" ? (sm.getSessionFile as () => string)() : undefined;
+      if (sessionFile) return createHash("sha256").update(sessionFile).digest("hex").slice(0, 12);
+    } catch {
+      /* fall through */
+    }
+    return "default";
+  }
+
+  /** Find the account whose dirs contain the longest prefix of cwd. */
+  private findAccountForCwd(cwd: string | undefined): AccountConfig | undefined {
+    if (!cwd) return undefined;
+    const id = findLongestMatchingDir(this.accountService.getAccounts(), cwd);
+    return id ? this.accountService.getAccounts().find((a) => a.id === id) : undefined;
+  }
+
   // ===============================================================================================
   // Core
   // ===============================================================================================
 
   async init(ctx: AccountSwitcherContext): Promise<void> {
+    this.sessionKey = this.getSessionKey(ctx);
+    this.accountService.setSessionKey(this.sessionKey);
     await this.load();
 
-    const active = this.accountService.getActiveAccount();
-    uiUtil.setAccountStatus(ctx.ui, active?.label);
-
-    // Re-apply saved account credentials so env vars and OAuth auth storage are
-    // populated on session start, not only after the first explicit switch.
-    if (active) {
-      const providers = this.providerService.getProviders();
-      await this.applyProviderApiKey(active, providers);
-      await accountUtil.applyAccountEnv(active, ctx.modelRegistry, resolveAuthProvider(active, providers));
+    // Cascade:
+    // 0. PI_ACCOUNT_SWITCHER_ACTIVE_ID env var (from parent process)
+    // 1. Session key state (handled inside accountService.load())
+    // 2. CWD-based auto-select via dirs
+    // 3. defaultAccountId from config
+    let selected: AccountConfig | undefined;
+
+    // Step 0: env var from parent process (for subagent inheritance)
+    // PI_ACCOUNT_SWITCHER_NEXT_ID is a one-shot override (consumed after first read)
+    // PI_ACCOUNT_SWITCHER_ACTIVE_ID is the persistent inheritance from the parent
+    const nextId = process.env.PI_ACCOUNT_SWITCHER_NEXT_ID;
+    if (nextId) {
+      delete process.env.PI_ACCOUNT_SWITCHER_NEXT_ID;
+      selected = this.accountService.getAccounts().find((a) => a.id === nextId);
+    }
+    if (!selected) {
+      const envId = process.env.PI_ACCOUNT_SWITCHER_ACTIVE_ID;
+      if (envId) {
+        selected = this.accountService.getAccounts().find((a) => a.id === envId);
+      }
     }
 
-    // Restore the last active model. modelRegistry.find returns undefined if the
-    // model is no longer available (e.g. provider was removed), in which case we
-    // leave Pi's default model selection untouched.
-    const modelState = this.accountService.getActiveModelState();
-    if (modelState) {
-      const providers = this.providerService.getProviders();
-      const activeProvider = active ? resolveAccountProvider(active, providers) : undefined;
-      const savedProvider = providerUtil.normalizeProviderWithCustom(modelState.provider, providers);
-
-      // Only restore a saved model when it belongs to the active account's provider.
-      // Otherwise Pi can start with credentials for one provider and a model from another.
-      if (!activeProvider || savedProvider === activeProvider) {
-        const model = ctx.modelRegistry.find(modelState.provider, modelState.id);
-        if (model) await this.modelService.applyModel(model, ctx);
+    if (!selected) {
+      // Step 1: session key state (restored by accountService.load())
+      selected = this.accountService.getActiveAccount();
+    }
+    if (!selected) {
+      // Step 2: CWD-based auto-select via dirs
+      selected = this.findAccountForCwd(ctx.cwd);
+    }
+    if (!selected) {
+      // Step 3: defaultAccountId from config
+      const defaultId = await this.accountService.getDefaultAccountId();
+      if (defaultId) {
+        selected = this.accountService.getAccounts().find((a) => a.id === defaultId);
       }
     }
+    if (selected) {
+      const providers = this.providerService.getProviders();
+      await this.applyProviderApiKey(selected, providers);
+      await this.accountService.activateAccount(selected, ctx, resolveAuthProvider(selected, providers));
+    }
+
+    uiUtil.setAccountStatus(ctx.ui, selected?.label);
+  }
+
+  refreshStatus(ctx: AccountSwitcherContext): void {
+    const active = this.accountService.getActiveAccount();
+    const label = active?.label;
+    if (label === this.lastStatusLabel) return;
+    this.lastStatusLabel = label;
+    uiUtil.setAccountStatus(ctx.ui, label);
   }
 
   async load(): Promise<void> {
-    await this.accountService.load();
     await this.providerService.load();
+    await this.accountService.load();
   }
 
   async onModelSelect(provider: string, ctx: AccountSwitcherContext): Promise<void> {
-    const matchingAccount = this.findAccountsByProvider(provider)[0];
+    const providers = this.providerService.getProviders();
+    const normalizedProvider = providerUtil.normalizeProviderWithCustom(provider, providers);
     const activeAccount = this.accountService.getActiveAccount();
+
+    // If the active account already belongs to this provider, keep it.
+    if (activeAccount && resolveAccountProvider(activeAccount, providers) === normalizedProvider) {
+      return;
+    }
+
+    const matchingAccount = this.findAccountsByProvider(provider)[0];
     if (matchingAccount && matchingAccount.id !== activeAccount?.id) {
       await this.activateAccount(matchingAccount, ctx);
     }
@@ -130,6 +190,9 @@ export default class AccountSwitcherRuntime implements AccountSwitcher {
     const providerApiKey = await this.applyProviderApiKey(account, providers);
     const result = await this.accountService.activateAccount(account, ctx, resolveAuthProvider(account, providers));
 
+    // Persist the active account ID for subagent (cross-process) inheritance
+    process.env.PI_ACCOUNT_SWITCHER_ACTIVE_ID = account.id;
+
     // piAuth accounts authenticate via a separate provider (e.g. github-copilot),
     // so use that for model lookup rather than the account's own provider field.
     const accountProvider = resolveAccountProvider(account, providers);
@@ -141,6 +204,11 @@ export default class AccountSwitcherRuntime implements AccountSwitcher {
     if (accountProvider !== currentProvider) {
       const model = await modelUtil.pickModel(ctx, account, providers, accountProvider);
       if (model) await this.applyModel(model, ctx);
+    } else {
+      // Same provider — persist current model for full session tracking
+      if (ctx.model) {
+        await this.accountService.saveActiveModel(ctx.model.id, ctx.model.provider);
+      }
     }
 
     return providerApiKey ? `provider apiKey (${providerApiKey})` : result;

package/src/runtime/account-switcher.ts

@@ -4,6 +4,7 @@ import type { AccountConfig, AccountSwitcherContext, PiAuthEntry, ProviderConfig
 export default interface AccountSwitcher {
   // Core
   init(ctx: AccountSwitcherContext): Promise<void>;
+  refreshStatus(ctx: AccountSwitcherContext): void;
   load(): Promise<void>;
   onModelSelect(provider: string, ctx: AccountSwitcherContext): Promise<void>;
 
@@ -27,7 +28,7 @@ export default interface AccountSwitcher {
   // Provider
   getProviders(): ProviderConfig[];
   registerProvider(provider: ProviderConfig): void;
-  addProvider(config: ProviderConfig): Promise<void>;
+  addProvider(provider: ProviderConfig): Promise<void>;
   editProvider(original: ProviderConfig, updated: ProviderConfig): Promise<void>;
   removeProvider(provider: ProviderConfig): Promise<void>;
 }

package/src/schemas/accounts.ts

@@ -30,6 +30,7 @@ export const accountSchema = z
     env: z.record(z.string().min(1), secretSourceSchema).optional(),
     providerApiKey: secretSourceSchema.optional(),
     usesProviderApiKey: z.boolean().optional(),
+    dirs: z.array(z.string()).optional(),
     piAuth: z
       .object({
         provider: z.string().min(1),

package/src/schemas/config.ts

@@ -4,4 +4,6 @@ import { accountSchema } from "./accounts";
 export const configSchema = z.object({
   accounts: z.array(accountSchema).default([]),
   switchMode: z.literal("env").optional().default("env"),
-});
+  defaultAccountId: z.string().optional(),
+  stateCleanupDays: z.number().int().min(1).optional().default(30),
+});