@maxiaochao/pi-toolkit 0.11.9 → 0.11.10

package/CHANGELOG.md

@@ -1,3 +1,9 @@
+## 2026-10-14 - v0.11.10
+
+- openai-account-pool v0.1.2: document that toolkit 0.11.9 was the last version to embed this package
+- Stop enabling `openai-account-pool` in `pi install npm:@maxiaochao/pi-toolkit`: the toolkit tarball and default loadout no longer contain it, and its source stays an independently installable child package.
+- Document which five child packages a toolkit install enables by default and which child stays a separate install. The toolkit README no longer describes Todo.
+
 ## 2026-10-14 - v0.11.9
 
 - bundle openai-account-pool v0.1.1: publish the initial OpenAI Codex account pool and fix coordinated initial-release detection

package/README.md

@@ -10,51 +10,38 @@ Install the complete toolkit:
 pi install npm:@maxiaochao/pi-toolkit
 ```
 
-Update it:
+That one install enables five child packages by default, because their source is embedded in the toolkit tarball: `pi-cache-export`, `pi-codex-edit`, `pi-herdr-subagents`, `pi-scheduler`, and `pi-worktree`.
+
+`pi-openai-account-pool` is not enabled and stays a separate install:
 
 ```bash
-pi update npm:@maxiaochao/pi-toolkit
+pi install npm:@maxiaochao/pi-openai-account-pool
 ```
 
-The root package embeds its enabled child-package source snapshots. Todo is intentionally excluded from the default toolkit and remains available as an opt-in standalone package.
-
-Existing toolkit users can pick up the change with:
+Update it:
 
 ```bash
 pi update npm:@maxiaochao/pi-toolkit
 ```
 
-Restart Pi after updating. The `todo` tool and widget will no longer load. `pi update --extensions` has the same effect when updating all installed packages. Explicitly versioned sources remain pinned and must be changed or reinstalled without the old version suffix.
+Restart Pi after updating. `pi update --extensions` has the same effect when updating all installed packages. Explicitly versioned sources remain pinned and must be changed or reinstalled without the old version suffix.
 
 ## Child packages
 
-| Package | Capability | Install | Update | Why |
-|---|---|---|---|---|
-| [pi-todo](packages/todo/README.md) | Optional branch-local execution plan UI; not bundled with pi-toolkit | `pi install npm:@maxiaochao/pi-todo` | `pi update npm:@maxiaochao/pi-todo` | I don't recommend this for now, as both OpenAI and Claude Code official have stated that strong models are currently cumbersome in Todo |
-| [pi-cache-export](packages/cache-export/README.md) | Tau-aligned interactive cache dashboard for Pi sessions | `pi install npm:@maxiaochao/pi-cache-export` | `pi update npm:@maxiaochao/pi-cache-export` | Because I watched the cache video on @alejandro.ao YouTube, which has a Tau style page for viewing cache |
-| [pi-codex-edit](packages/codex-edit/README.md) | Codex-harness `apply_patch` routing for selected GPT models | `pi install npm:@maxiaochao/pi-codex-edit` | `pi update npm:@maxiaochao/pi-codex-edit` | The core lies in the fact that the Codex model is naturally good at apply_patch, and the model is trained on this during training. However, hash-based in-context patch schemes have high token costs and complexity |
-| [pi-herdr-subagents](packages/herdr-subagents/README.md) | Visible Herdr Pi Agents coordinated by a small task state machine | `pi install npm:@maxiaochao/pi-herdr-subagents` | `pi update npm:@maxiaochao/pi-herdr-subagents` | I wanted simple serial or bounded-parallel dispatch while each task stays a real interactive Pi session in its own Herdr pane, and the main conversation only receives short summaries instead of every child's full transcript |
-| [pi-openai-account-pool](packages/openai-account-pool/README.md) | Several ChatGPT Plus/Pro logins behind `openai-codex`, switching accounts on a proven quota limit | `pi install npm:@maxiaochao/pi-openai-account-pool` | `pi update npm:@maxiaochao/pi-openai-account-pool` | One `/login openai-codex` credential overwrites the previous one, so hitting the subscription limit meant logging in again by hand mid-task; this keeps the accounts I authorized side by side and continues the same request on the next usable one |
-| [pi-scheduler](packages/scheduler/README.md) | Session-scoped interval prompts with Agent and `/schedule` controls | `pi install npm:@maxiaochao/pi-scheduler` | `pi update npm:@maxiaochao/pi-scheduler` | I don't recommend this, it's just that it sends messages to the main session at loop intervals |
-| [pi-worktree](packages/worktree/README.md) | Worktree CLI, current-session switching Extension, and agent skill | `pi install npm:@maxiaochao/pi-worktree` | `pi update npm:@maxiaochao/pi-worktree` | In addition to the basic worktree CLI + skill, what can be achieved is to directly switch to the worktree path in the main conversation to continue the task conversation after communicating the requirements in the main conversation |
+| Package | Capability | Installed by `pi-toolkit` | Install | Update | Why |
+|---|---|---|---|---|---|
+| [pi-cache-export](packages/cache-export/README.md) | Tau-aligned interactive cache dashboard for Pi sessions | Yes | `pi install npm:@maxiaochao/pi-cache-export` | `pi update npm:@maxiaochao/pi-cache-export` | Because I watched the cache video on @alejandro.ao YouTube, which has a Tau style page for viewing cache |
+| [pi-codex-edit](packages/codex-edit/README.md) | Codex-harness `apply_patch` routing for selected GPT models | Yes | `pi install npm:@maxiaochao/pi-codex-edit` | `pi update npm:@maxiaochao/pi-codex-edit` | The core lies in the fact that the Codex model is naturally good at apply_patch, and the model is trained on this during training. However, hash-based in-context patch schemes have high token costs and complexity |
+| [pi-herdr-subagents](packages/herdr-subagents/README.md) | Visible Herdr Pi Agents coordinated by a small task state machine | Yes | `pi install npm:@maxiaochao/pi-herdr-subagents` | `pi update npm:@maxiaochao/pi-herdr-subagents` | I wanted simple serial or bounded-parallel dispatch while each task stays a real interactive Pi session in its own Herdr pane, and the main conversation only receives short summaries instead of every child's full transcript |
+| [pi-openai-account-pool](packages/openai-account-pool/README.md) | Several ChatGPT Plus/Pro logins behind `openai-codex`, switching accounts on a proven quota limit | No | `pi install npm:@maxiaochao/pi-openai-account-pool` | `pi update npm:@maxiaochao/pi-openai-account-pool` | One `/login openai-codex` credential overwrites the previous one, so hitting the subscription limit meant logging in again by hand mid-task; this keeps the accounts I authorized side by side and continues the same request on the next usable one |
+| [pi-scheduler](packages/scheduler/README.md) | Session-scoped interval prompts with Agent and `/schedule` controls | Yes | `pi install npm:@maxiaochao/pi-scheduler` | `pi update npm:@maxiaochao/pi-scheduler` | I don't recommend this, it's just that it sends messages to the main session at loop intervals |
+| [pi-worktree](packages/worktree/README.md) | Worktree CLI, current-session switching Extension, and agent skill | Yes | `pi install npm:@maxiaochao/pi-worktree` | `pi update npm:@maxiaochao/pi-worktree` | In addition to the basic worktree CLI + skill, what can be achieved is to directly switch to the worktree path in the main conversation to continue the task conversation after communicating the requirements in the main conversation |
 
 Each child README owns its feature description, motivation or upstream alignment, examples, screenshots/demos, configuration, and test documentation.
 
 Herdr Subagents personas can opt into local extension files or npm/git Pi packages through `extensions`. This uses native Pi package semantics: package-provided skills, prompt templates, and themes may also load, and `--no-skills` does not exclude explicitly selected package skills. See the [extension-source contract](packages/herdr-subagents/README.md#explicit-extension-sources-and-pi-packages) for precedence, isolation, and examples.
 
-Multiple standalone children may be installed together. `pi-todo` may also be installed alongside the complete toolkit because Todo is no longer bundled. Do not install another bundled child alongside the complete toolkit because that exposes the same resource twice.
-
-To keep Todo after updating the toolkit:
-
-```bash
-pi install npm:@maxiaochao/pi-todo
-```
-
-If Todo was already installed separately and should be removed completely:
-
-```bash
-pi remove npm:@maxiaochao/pi-todo
-```
+Multiple standalone children may be installed together. `pi-openai-account-pool` may also be installed alongside the complete toolkit because the toolkit does not embed it. Every other child in the table above is embedded, so a second install exposes the same resource twice.
 
 Use `--local` with install or remove when the package declaration belongs to a project's `.pi/settings.json` rather than personal settings.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maxiaochao/pi-toolkit",
-  "version": "0.11.9",
+  "version": "0.11.10",
   "description": "Personal pi coding agent toolkit: scheduler, /btw, /cache_export, apply_patch, browser automation, and bundled theme/skills.",
   "type": "module",
   "workspaces": [
@@ -16,7 +16,6 @@
     "packages/cache-export",
     "packages/codex-edit",
     "packages/herdr-subagents",
-    "packages/openai-account-pool",
     "packages/scheduler",
     "packages/worktree",
     "themes",
@@ -36,7 +35,6 @@
       "./extensions/btw/index.ts",
       "./packages/codex-edit/extensions/codex-edit.ts",
       "./packages/herdr-subagents/extensions/herdr-subagents.ts",
-      "./packages/openai-account-pool/extensions/openai-account-pool.ts",
       "./packages/scheduler/extensions/scheduler.ts",
       "./packages/worktree/extensions/worktree.ts"
     ],
@@ -62,7 +60,7 @@
   },
   "scripts": {
     "test": "node tests/package-layout.mjs && npm --prefix packages/todo test && npm --prefix packages/cache-export test && npm --prefix packages/codex-edit test && npm --prefix packages/herdr-subagents test && npm --prefix packages/openai-account-pool test && npm --prefix packages/scheduler test && npm --prefix packages/worktree test && node --experimental-strip-types extensions/btw/tests/history.mjs",
-    "load-test": "pi -ne -e ./packages/cache-export/extensions/cache-export.ts && pi -ne -e ./extensions/btw/index.ts && pi -ne -e ./packages/codex-edit/extensions/codex-edit.ts && pi -ne -e ./packages/herdr-subagents/extensions/herdr-subagents.ts && pi -ne -e ./packages/openai-account-pool/extensions/openai-account-pool.ts && pi -ne -e ./packages/scheduler/extensions/scheduler.ts && pi -ne -e ./packages/worktree/extensions/worktree.ts",
+    "load-test": "pi -ne -e ./packages/cache-export/extensions/cache-export.ts && pi -ne -e ./extensions/btw/index.ts && pi -ne -e ./packages/codex-edit/extensions/codex-edit.ts && pi -ne -e ./packages/herdr-subagents/extensions/herdr-subagents.ts && pi -ne -e ./packages/scheduler/extensions/scheduler.ts && pi -ne -e ./packages/worktree/extensions/worktree.ts",
     "eval:agents": "node evaluations/agents-md/run.mjs",
     "eval:agents:test": "node evaluations/agents-md/tests/run-tests.mjs",
     "postinstall": "node scripts/install-agents.mjs"

package/packages/openai-account-pool/CHANGELOG.md

@@ -1,15 +0,0 @@
-## 2026-10-14 - v0.1.1
-
-- publish the initial OpenAI Codex account pool and fix coordinated initial-release detection
-
-## 2026-10-14 - v0.1.0
-
-- add OpenAI Codex account pooling with safe quota failover and live usage status
-- add multi-account failover for the openai-codex provider
-- Add `/codex_pool` with a continue/end loop that adds any number of ChatGPT accounts through the native OAuth flow and keeps an existing single login.
-- Switch accounts on proven subscription limits or proven authorization failures only, before any output reaches the conversation.
-- Share cooldown and probe state between pi processes in the same agent directory, and keep auth.json authoritative for credentials.
-- Show live per-account Codex usage and the last successful account, recover locally cooled accounts with one bounded usage sweep, and report the earliest server-stated recovery time.
-- Keep usage recovery race-safe across processes with freshness-guarded state updates, probe leases, bounded private-endpoint reads, model-scoped estimates, and non-secret failure codes.
-- Show `/codex_pool status` in a temporary colored panel above the editor that appears immediately, displays cached state, refreshes live quota in the background, and removes itself after 15 seconds; keep non-TUI text output and place `●当前` at the end of the account line.
-- Stop returning an identical argument completion after a subcommand is fully typed, so one Enter submits `/codex_pool status` instead of merely accepting `status`.

package/packages/openai-account-pool/README.md

@@ -1,67 +0,0 @@
-# Pi OpenAI Account Pool
-
-Pool several ChatGPT Plus/Pro logins behind pi's built-in `openai-codex` provider. When the account in use proves it is out of subscription quota, the same request continues on another account — same conversation, same model, same thinking level, no replayed tools.
-
-![账号池向导、状态与真实切换](docs/screenshot.png)
-
-![/codex_pool 添加账号并在额度耗尽时自动切换](docs/demo.gif)
-
-## Why
-
-`/login openai-codex` stores one credential per provider: logging in a second account overwrites the first. Hitting the subscription limit therefore means logging in again by hand, in the middle of the work. This package keeps every authorized account side by side and picks the next usable one for you.
-
-It does not create accounts, share them between people, or work around a limit on one account. It only uses logins you authorized yourself, one at a time.
-
-## Install
-
-```bash
-pi install npm:@maxiaochao/pi-openai-account-pool
-```
-
-Update it with `pi update npm:@maxiaochao/pi-openai-account-pool`. Installing alone changes nothing: the pool turns on the first time you add an account.
-
-## User command
-
-```text
-/codex_pool                 添加账号：反复确认「继续 / 删除 / 结束」，继续一次就登录一个账号
-/codex_pool status          输入框上方立即显示彩色临时面板并在后台查询官网 5 小时/周额度；最近成功使用的账号在行末标 ●当前
-/codex_pool use             下拉选择默认从哪个账号开始（`use auto` 恢复自动）
-/codex_pool remove          下拉选择要删除的账号（也可写 `remove 2` 或 `remove 邮箱`）
-/codex_pool off             恢复原生单账号登录
-```
-
-`/codex_pool` 先显示确认界面，不会无提示打开浏览器。选择继续就走一次原生 Codex 登录；成功后立即原子保存，并回到同一个界面，可以一直加下去。结束只结束添加，账号池和自动切换保留；Esc 取消的是当前这次授权。
-
-账号按登录邮箱显示（如 `#2 (you@example.com)`），邮箱取自令牌自带的身份声明；没有该声明时回落到脱敏标识。去重按 ChatGPT 账号 id：重新登录同一个账号只更新它的凭据和标签，编号和总数不变，这也是授权失效后重新授权的做法。
-
-第一次成功添加会把原有的 `openai-codex` 登录一起并入池，不会丢失。
-
-## When it switches
-
-| 结构化证据 | 行为 |
-|---|---|
-| `usage_limit_reached` | 记录额度冷却，换到下一个可用账号 |
-| 明确失效的授权（`invalid_grant`、刷新后仍 401） | 标记需重新授权，换到下一个可用账号 |
-| 普通 429、`rate_limit_exceeded`、5xx、网络错误 | 原账号原有重试，不换账号 |
-| `usage_not_included`、403、400、未知错误 | 停止，不猜测额度耗尽 |
-
-切换只在请求还没有向外输出文字、思考或工具调用时发生，所以不会出现重复回答。已经输出后才遇到额度耗尽的请求会正常结束，冷却仍被记录，下一次请求自动跳过那个账号。
-
-## Semantics and limits
-
-- 凭据的权威来源仍是 `~/.pi/agent/auth.json`：每个账号一条独立条目，主 `openai-codex` 条目只存非秘密引用，不能当令牌使用。
-- 冷却与探测状态放在 `~/.pi/agent/openai-account-pool/state.json`，同机多个 pi 进程共享：一个进程撞到的额度上限，另一个进程下一次请求就会跳过。
-- 默认 sticky：一直用当前可用的账号，不轮询分摊。`/codex_pool use` 指定下次优先尝试哪个账号，跨进程生效，但 status 不给这个设置加徽标；只有最近成功承接模型请求的账号显示 `●当前`。它额度用完或需要重新授权时仍会自动切走。
-- 令牌过期是自动处理的：每次请求前在 `auth.json` 锁下用 refresh token 刷新，多进程只会兑换一次。只有 refresh token 本身被证明失效时才标为需重新授权，此时跑 `/codex_pool` 重新登录该账号即可。
-- 每个逻辑请求里每个账号最多作为一次切换候选；全部不可用时立即返回每个账号的脱敏状态，不会后台等待几小时。
-- 服务器给出恢复时间就显示恢复时间；没有给出就显示「未知」，只做短时本地探测退避。
-- 只对原生 Codex endpoint 使用池凭据。显式传入的 API key 和自定义 endpoint 不会被替换。
-- `print`/JSON 模式没有交互界面，不能添加账号；已有账号池的模型请求照常工作。
-
-## Remove
-
-```bash
-pi remove npm:@maxiaochao/pi-openai-account-pool
-```
-
-先运行 `/codex_pool off` 恢复单账号登录，再卸载，否则 `openai-codex` 会留下一条无法使用的池引用。不要同时安装独立包和已经内置本包的 toolkit 版本，否则命令会注册两次。

package/packages/openai-account-pool/TESTING.md

@@ -1,28 +0,0 @@
-# Testing Pi OpenAI Account Pool
-
-Run from the repository root:
-
-```bash
-npm --prefix packages/openai-account-pool test
-npm --prefix packages/openai-account-pool run load-test
-npm pack ./packages/openai-account-pool --dry-run
-```
-
-Every test runs against an isolated temporary agent directory with fixture credentials. No real token, refresh token or authorization callback URL appears in this repository, in the tests, or in the generated media.
-
-- `tests/store-ownership.mjs` covers the credential store: unrelated provider entries survive, the lock is mutually exclusive with pi's own writes in both directions, cancelled lock waits, stale lock reclaim, a compromised lock refusing to write, single token rotation under concurrency, ownership across plain login/logout/re-enable, monotonic generations, corrupt JSON and symlink refusal, and enrollment lease recovery.
-- `tests/selection.mjs` covers classification and selection: only structured `usage_limit_reached` counts as a subscription limit, a plain 429 with the same friendly wording does not, reset times are validated, and shared state ignores stale generations and late successes.
-- `tests/command-completions.mjs` covers slash-command argument completion, including the real TUI regression where returning an identical completion for a fully typed `status` consumed the first Enter instead of submitting the command.
-- `tests/enrollment.mjs` covers the `/codex_pool` loop: repeated continue adds more than two accounts, an existing plain login is migrated instead of replaced, ending immediately changes nothing, failures are redacted, cancelling keeps what was already saved, two processes cannot enroll at once, and status/off/remove speak in masked labels.
-- `tests/usage.mjs` covers live `wham/usage` normalization and headers, OAuth refresh, sequential account queries, bounded response size and time, non-secret failures, stale-observation races, cross-process probe leases, model-scoped recovery estimates, stored exhaustion after a failed live lookup, and the immediately rendered colored status widget with loading state and line-final `●当前`. Every HTTP path uses an injected fixture transport.
-- `tests/failover-stream.mjs` runs through real pi-ai stream plumbing: one external start, no replay after output, a repaired 401, websocket-style evidence, cancellation, one live-usage sweep when all accounts are locally unavailable, recovered-account selection, and exhausted-pool earliest-ready messages.
-- `tests/multiprocess.mjs` spawns real child processes: two pi processes racing an expired rotating refresh token exchange it exactly once and converge on the same credential, concurrent writes from five processes lose no entry, and a valid credential is never refreshed.
-- `tests/integration-login-ownership.mjs` uses the real `Models` implementation to show that a second plain login still overwrites the first, and that the pool keeps every account.
-
-For a manual check, run pi with `-e ./packages/openai-account-pool/extensions/openai-account-pool.ts`, run `/codex_pool`, authorize two different ChatGPT accounts, and confirm that the same model keeps answering after the first account reports its limit. Do not exhaust a paid quota on purpose; record what was and was not executed.
-
-Regenerate package media with:
-
-```bash
-node scripts/capture-package-media.mjs openai-account-pool
-```

package/packages/openai-account-pool/extensions/openai-account-pool.ts

@@ -1,368 +0,0 @@
-import type { AuthEvent, AuthPrompt, OAuthCredential, Provider, ProviderAuthInteraction } from "@earendil-works/pi-ai";
-import { lazyStream } from "@earendil-works/pi-ai";
-import {
-	getAgentDir,
-	LoginDialogComponent,
-	type ExtensionAPI,
-	type ExtensionCommandContext,
-	type ExtensionContext,
-} from "@earendil-works/pi-coding-agent";
-
-import { accountLabel, loadPoolSnapshot, maskAccountId, type PoolAccount } from "../src/auth.ts";
-import { readPreferredAccountId } from "../src/availability.ts";
-import { codexPoolArgumentCompletions } from "../src/command-completions.ts";
-import {
-	AccountQueryError,
-	confirmText,
-	endPool,
-	isCancellation,
-	poolStatus,
-	redactMessage,
-	removePoolAccount,
-	resolveAccount,
-	runEnrollment,
-	setDefaultAccount,
-	type EnrollmentUi,
-	type PoolStatus,
-} from "../src/enrollment.ts";
-import { EnrollmentInProgressError } from "../src/lease.ts";
-import { LoginSlot, type LoginDialog, type LoginSlotUi } from "../src/login-slot.ts";
-import { createPoolProvider } from "../src/provider.ts";
-import { CodexPoolStatusWidget, formatAccountStatusLine } from "../src/status-widget.ts";
-import { authPathFor, poolStatePathFor, type AuthEntry } from "../src/store.ts";
-
-const PROVIDER_ID = "openai-codex";
-const PROVIDER_NAME = "OpenAI (ChatGPT Plus/Pro)";
-/** Marks our wrapper so a reload cannot wrap the wrapper again. */
-const POOL_WRAPPER = Symbol.for("pi-openai-account-pool.wrapper");
-
-const CONTINUE = "继续：登录并添加一个账号";
-const REMOVE = "删除：从账号池里移除一个账号";
-const END = "结束：保留账号池和自动切换";
-const BACK = "返回：什么都不做";
-const AUTOMATIC = "自动：按编号顺序，用着哪个顺手就留在哪个";
-const DIALOG_TITLE = "添加 Codex 账号";
-const STATUS_WIDGET_KEY = "openai-account-pool-status";
-const STATUS_VISIBLE_MS = 15_000;
-
-function agentPaths() {
-	const agentDir = getAgentDir();
-	return { authPath: authPathFor(agentDir), statePath: poolStatePathFor(agentDir) };
-}
-
-/**
- * Drives the native OAuth flow through pi's own login dialog, exactly like `/login` does.
- *
- * The dialog and pi's selectors share one slot below the chat, so `LoginSlot` owns that slot and
- * decides what is mounted when.
- */
-async function loginWithDialog(ctx: ExtensionContext, oauth: NonNullable<Provider["auth"]["oauth"]>): Promise<OAuthCredential> {
-	const ui: LoginSlotUi = {
-		mount: (register) =>
-			ctx.ui.custom<void>((tui, _theme, _keybindings, done) => {
-				const dialog = new LoginDialogComponent(tui, PROVIDER_ID, () => done(undefined), PROVIDER_NAME, DIALOG_TITLE);
-				register(dialog satisfies LoginDialog, () => done(undefined));
-				return dialog;
-			}),
-		select: (message, options, signal) => ctx.ui.select(message, [...options], { signal }),
-	};
-	const slot = new LoginSlot(ui);
-	try {
-		return await oauth.login(slot.interaction);
-	} finally {
-		await slot.close();
-	}
-}
-
-async function selectThroughDialog(ctx: ExtensionContext, request: AuthPrompt & { type: "select" }): Promise<string> {
-	const labels = request.options.map((option) => option.label);
-	const chosen = await ctx.ui.select(request.message, labels);
-	const index = chosen === undefined ? -1 : labels.indexOf(chosen);
-	if (index < 0) throw new Error("Login cancelled");
-	return request.options[index].id;
-}
-
-/** Dialog-capable modes without a terminal, such as RPC, use the standard dialogs. */
-async function loginWithDialogs(ctx: ExtensionContext, oauth: NonNullable<Provider["auth"]["oauth"]>): Promise<OAuthCredential> {
-	const controller = new AbortController();
-	const prompt = async (request: AuthPrompt): Promise<string> => {
-		if (request.type === "select") return selectThroughDialog(ctx, request);
-		const answer = await ctx.ui.input(request.message, request.placeholder, { signal: request.signal });
-		if (answer === undefined) throw new Error("Login cancelled");
-		return answer;
-	};
-	const notify = (event: AuthEvent) => {
-		if (event.type === "auth_url") ctx.ui.notify(`在浏览器中打开以授权：${event.url}`);
-		else if (event.type === "device_code") ctx.ui.notify(`在 ${event.verificationUri} 输入代码 ${event.userCode}`);
-		else ctx.ui.notify(event.message);
-	};
-	return oauth.login({ signal: controller.signal, prompt, notify } satisfies ProviderAuthInteraction);
-}
-
-/** Lets the user point at one account with the arrow keys instead of typing an identifier. */
-async function pickAccount(ctx: ExtensionContext, message: string, accounts: readonly PoolAccount[], extra: string[] = []): Promise<PoolAccount | string | undefined> {
-	const labels = accounts.map((account) => accountLabel(account));
-	const chosen = await ctx.ui.select(message, [...labels, ...extra, BACK]);
-	if (chosen === undefined || chosen === BACK) return undefined;
-	const index = labels.indexOf(chosen);
-	return index >= 0 ? accounts[index] : chosen;
-}
-
-function enrollmentUi(ctx: ExtensionContext, oauth: NonNullable<Provider["auth"]["oauth"]>): EnrollmentUi {
-	return {
-		confirm: async (view) => {
-			const options = view.savedAccounts > 0 ? [CONTINUE, REMOVE, END] : [CONTINUE, END];
-			const choice = await ctx.ui.select(confirmText(view), options);
-			if (choice === CONTINUE) return "continue";
-			return choice === REMOVE ? "remove" : "end";
-		},
-		login: async () => {
-			const credential = ctx.mode === "tui" ? await loginWithDialog(ctx, oauth) : await loginWithDialogs(ctx, oauth);
-			return credential as unknown as AuthEntry;
-		},
-		pickRemoval: async (accounts) => {
-			const chosen = await pickAccount(ctx, "删除哪个账号？会删掉本地凭据，不会撤销 OpenAI 上的授权。", accounts);
-			return typeof chosen === "object" ? chosen : undefined;
-		},
-		notify: (message, kind) => ctx.ui.notify(message, kind ?? "info"),
-	};
-}
-
-async function readStatus(ctx: ExtensionContext, live: boolean, signal?: AbortSignal): Promise<PoolStatus> {
-	const { authPath, statePath } = agentPaths();
-	const oauth = ctx.modelRegistry.getProvider(PROVIDER_ID)?.auth.oauth;
-	return poolStatus({
-		authPath,
-		statePath,
-		modelId: ctx.model?.id,
-		refresh: live && oauth
-			? async (credential, signal) =>
-					oauth.refresh(credential as unknown as OAuthCredential, signal ?? new AbortController().signal) as unknown as AuthEntry
-			: undefined,
-		signal,
-	});
-}
-
-async function showStatus(ctx: ExtensionContext, showTuiStatus: (ctx: ExtensionContext) => void): Promise<void> {
-	if (ctx.mode === "tui") {
-		showTuiStatus(ctx);
-		return;
-	}
-	const status = await readStatus(ctx, true);
-	const lines = [status.summary, ...status.accounts.map(formatAccountStatusLine)];
-	ctx.ui.notify(lines.join("\n"));
-}
-
-async function handleCommand(
-	args: string,
-	ctx: ExtensionCommandContext,
-	provider: () => Provider | undefined,
-	showTuiStatus: (ctx: ExtensionContext) => void,
-): Promise<void> {
-	const [subcommand = "", ...rest] = args.trim().split(/\s+/).filter(Boolean);
-	const { authPath, statePath } = agentPaths();
-
-	try {
-		if (subcommand === "status") {
-			await showStatus(ctx, showTuiStatus);
-			return;
-		}
-
-		if (subcommand === "off") {
-			const snapshot = await loadPoolSnapshot(authPath);
-			if (!snapshot.enabled) {
-				ctx.ui.notify("账号池未启用，无需关闭。", "warning");
-				return;
-			}
-			const keep = [...snapshot.accounts].sort((left, right) => left.ordinal - right.ordinal)[0];
-			const confirmed = await ctx.ui.confirm(
-				"关闭 Codex 账号池？",
-				`将恢复为单账号登录（保留 ${maskAccountId(keep.id)}），其余 ${snapshot.accounts.length - 1} 个账号的本地凭据会保留但不再使用。`,
-			);
-			if (!confirmed) return;
-			const result = await endPool({ authPath, statePath, keepAccountId: keep.id });
-			ctx.ui.notify(`已关闭账号池，恢复为单账号登录（${maskAccountId(result.kept.id)}）。`);
-			return;
-		}
-
-		if (subcommand === "use") {
-			const snapshot = await loadPoolSnapshot(authPath);
-			if (!snapshot.enabled) throw new AccountQueryError("账号池未启用，没有可切换的账号。");
-			const query = rest.join(" ");
-			if (query === "auto") {
-				await setDefaultAccount({ authPath, statePath, accountId: undefined });
-				ctx.ui.notify("已恢复自动选号。");
-				return;
-			}
-			const accounts = [...snapshot.accounts].sort((left, right) => left.ordinal - right.ordinal);
-			const current = await readPreferredAccountId(statePath);
-			const chosen = query
-				? resolveAccount(snapshot, query)
-				: await pickAccount(ctx, `默认用哪个账号？当前：${current ? accountLabel(accounts.find((account) => account.id === current) ?? accounts[0]) : "自动"}`, accounts, [AUTOMATIC]);
-			if (chosen === undefined) return;
-			if (chosen === AUTOMATIC) {
-				await setDefaultAccount({ authPath, statePath, accountId: undefined });
-				ctx.ui.notify("已恢复自动选号。");
-				return;
-			}
-			const account = chosen as PoolAccount;
-			await setDefaultAccount({ authPath, statePath, accountId: account.id });
-			ctx.ui.notify(`以后从 ${accountLabel(account)} 开始。它额度用完或需要重新授权时，仍会自动切到其他账号。`);
-			return;
-		}
-
-		if (subcommand === "remove") {
-			const snapshot = await loadPoolSnapshot(authPath);
-			if (!snapshot.enabled) throw new AccountQueryError("账号池未启用，没有可删除的池内账号。");
-			const query = rest.join(" ");
-			const accounts = [...snapshot.accounts].sort((left, right) => left.ordinal - right.ordinal);
-			const chosen = query
-				? resolveAccount(snapshot, query)
-				: await pickAccount(ctx, "删除哪个账号？", accounts);
-			if (chosen === undefined) return;
-			const account = chosen as PoolAccount;
-			const confirmed = await ctx.ui.confirm("删除这个 Codex 账号？", `将删除 ${accountLabel(account)} 的本地凭据，不会撤销 OpenAI 上的授权。`);
-			if (!confirmed) return;
-			const result = await removePoolAccount({ authPath, statePath, accountId: account.id });
-			ctx.ui.notify(
-				result.poolDisabled
-					? `已删除最后一个账号 ${accountLabel(account)}，账号池已关闭，openai-codex 现在没有登录。`
-					: `已删除账号 ${accountLabel(account)}，还剩 ${result.remaining} 个。`,
-			);
-			return;
-		}
-
-		if (subcommand) {
-			ctx.ui.notify("用法：/codex_pool [status|use [编号|邮箱|auto]|remove [编号|邮箱]|off]", "warning");
-			return;
-		}
-
-		if (!ctx.hasUI) {
-			ctx.ui.notify("当前模式没有交互界面，无法添加账号。请在交互式 pi 中运行 /codex_pool；已有账号池的模型请求不受影响。", "error");
-			return;
-		}
-
-		const oauth = provider()?.auth.oauth;
-		if (!oauth) {
-			ctx.ui.notify("找不到 openai-codex 的 OAuth 登录方式。", "error");
-			return;
-		}
-
-		const result = await runEnrollment({ authPath, statePath, ui: enrollmentUi(ctx, oauth) });
-		if (result.cancelled) ctx.ui.notify(`已取消这次授权。当前共 ${result.accounts} 个账号。`, "warning");
-		else if (result.added + result.updated + result.removed === 0) ctx.ui.notify(`没有改动。当前共 ${result.accounts} 个账号。`);
-		else ctx.ui.notify(`账号池共 ${result.accounts} 个账号${result.accounts > 1 ? "，额度耗尽时会自动切换" : "，暂无备用账号"}。`);
-	} catch (error) {
-		if (error instanceof EnrollmentInProgressError) {
-			ctx.ui.notify("另一个 pi 正在添加 Codex 账号，请等它结束后再试。", "warning");
-			return;
-		}
-		if (error instanceof AccountQueryError) {
-			ctx.ui.notify(error.message, "warning");
-			return;
-		}
-		if (isCancellation(error)) {
-			ctx.ui.notify("已取消。", "warning");
-			return;
-		}
-		ctx.ui.notify(`/codex_pool 失败：${redactMessage(error)}`, "error");
-	}
-}
-
-export default function openaiAccountPool(pi: ExtensionAPI) {
-	let base: Provider | undefined;
-	let latest: ExtensionContext | undefined;
-	let statusPanel: { component: CodexPoolStatusWidget; tui: { requestRender(): void } } | undefined;
-	let statusController: AbortController | undefined;
-	let statusTimer: ReturnType<typeof setTimeout> | undefined;
-	let statusGeneration = 0;
-
-	const clearStatusPanel = (ctx: ExtensionContext) => {
-		statusController?.abort();
-		statusController = undefined;
-		if (statusTimer) clearTimeout(statusTimer);
-		statusTimer = undefined;
-		ctx.ui.setWidget(STATUS_WIDGET_KEY, undefined, { placement: "aboveEditor" });
-		statusPanel = undefined;
-	};
-
-	const showTuiStatus = (ctx: ExtensionContext) => {
-		clearStatusPanel(ctx);
-		const generation = ++statusGeneration;
-		const controller = new AbortController();
-		statusController = controller;
-		let status: PoolStatus | undefined;
-		let loading = true;
-		let updateFailed = false;
-		const render = () => {
-			if (generation !== statusGeneration) return;
-			statusPanel?.component.update(status, { loading, updateFailed });
-			statusPanel?.tui.requestRender();
-		};
-		ctx.ui.setWidget(STATUS_WIDGET_KEY, (tui, theme) => {
-			const component = new CodexPoolStatusWidget(theme);
-			statusPanel = { component, tui };
-			render();
-			return component;
-		}, { placement: "aboveEditor" });
-		void (async () => {
-			try {
-				status = await readStatus(ctx, false, controller.signal);
-				if (generation !== statusGeneration) return;
-				render();
-				status = await readStatus(ctx, true, controller.signal);
-				if (generation !== statusGeneration) return;
-				loading = false;
-				render();
-			} catch {
-				if (controller.signal.aborted || generation !== statusGeneration) return;
-				loading = false;
-				updateFailed = true;
-				render();
-			} finally {
-				if (!controller.signal.aborted && generation === statusGeneration) {
-					statusTimer = setTimeout(() => clearStatusPanel(ctx), STATUS_VISIBLE_MS);
-				}
-			}
-		})();
-	};
-
-	const install = (ctx: ExtensionContext) => {
-		latest = ctx;
-		const current = ctx.modelRegistry.getProvider(PROVIDER_ID);
-		if (!current || (current as Record<symbol, unknown>)[POOL_WRAPPER]) {
-			base ??= current;
-			return;
-		}
-		base = current;
-		const { authPath, statePath } = agentPaths();
-		const wrapped = createPoolProvider(current, {
-			lazyStream,
-			authPath,
-			statePath,
-			// Switch notes go to whichever context is current when the request runs.
-			notify: (message) => latest?.ui.notify(message, "warning"),
-		});
-		Object.defineProperty(wrapped, POOL_WRAPPER, { value: true, enumerable: false });
-		ctx.modelRegistry.registerProvider(wrapped);
-	};
-
-	pi.on("session_start", (_event, ctx) => {
-		install(ctx);
-	});
-
-	pi.on("session_shutdown", (_event, ctx) => {
-		statusGeneration += 1;
-		if (ctx.mode === "tui") clearStatusPanel(ctx);
-		latest = undefined;
-	});
-
-	pi.registerCommand("codex_pool", {
-		description: "添加并管理多个 ChatGPT 账号，额度耗尽时自动切换",
-		getArgumentCompletions: codexPoolArgumentCompletions,
-		handler: async (args, ctx) => {
-			install(ctx);
-			await handleCommand(args, ctx, () => base, showTuiStatus);
-		},
-	});
-}