@jameslovespancakes/pi-plus 1.0.10 → 1.0.12

package/README.md

@@ -5,7 +5,7 @@
 **Everything [pi](https://pi.dev/) is missing, in one install.**
 
 [![npm](https://img.shields.io/npm/v/@jameslovespancakes/pi-plus?color=%234D9ABF&label=npm)](https://www.npmjs.com/package/@jameslovespancakes/pi-plus)
-[![build](https://github.com/jameslovespancakes/pi-plus/actions/workflows/release.yml/badge.svg?branch=main)](https://github.com/jameslovespancakes/pi-plus/actions/workflows/release.yml)
+[![CI](https://github.com/jameslovespancakes/pi-plus/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/jameslovespancakes/pi-plus/actions/workflows/ci.yml)
 [![license](https://img.shields.io/badge/license-MIT-F1BE58)](LICENSE)
 [![pi-package](https://img.shields.io/badge/pi--package-F09082)](https://pi.dev/packages)
 
@@ -29,7 +29,7 @@ on any row starts that setup.
 ```
 ──────────────────────────────────────────────────────────
  pi-plus
-› ● Subscriptions   2 accounts · optimal
+› ● Subscriptions   2 accounts · quota-aware
   ● Model Information  catalogue cached
   ● Providers       2 allowed · 4 need approval
   ● Agent Board     not configured
@@ -48,13 +48,14 @@ Nothing else is required, every feature configures itself from within pi.
 
 ### Pool every subscription
 
-Add all the Claude accounts you own. pi-plus balances sessions across them by
-**remaining quota and time-to-reset**, keeps caches sticky, and migrates only on
-confirmed exhaustion.
+Add multiple Claude, ChatGPT/Codex, Kimi Code, or xAI/Grok accounts. pi-plus
+keeps credentials separate, refreshes them safely, and supports sequential or
+quota-aware routing.
 
 ```
-/account anthropic add work
-/routing optimal
+/accounts add anthropic work
+/accounts add kimi-coding personal
+/routing quota-aware
 ```
 
 Your live quota, always in the footer:
@@ -70,9 +71,9 @@ Your live quota, always in the footer:
 With more than two accounts only the two most recently used are listed, so the
 footer stays a fixed height however many you pool.
 
-Account and routing commands are provider-agnostic: they dispatch through an
-adapter registry, so a second provider is one adapter, not a new command
-surface. Anthropic ships today.
+Account and routing commands are provider-agnostic. Sequential routing uses
+account order; quota-aware routing uses reported capacity and fairly probes
+accounts whose provider does not publish quota headers.
 
 ### Pick models on evidence
 
@@ -153,6 +154,23 @@ across every running pi agent. `/board` opens the messaging view:
 any Mac or Linux host over SSH, where launchd or systemd brings it back after a
 reboot.
 
+### Orchestrate repeatable workflows
+
+The built-in workflow engine runs named or inline multi-agent workflows with
+optional concurrency limits, replay, background runs, worktree isolation, progress,
+and usage accounting. `code-review`, `diagnose`, `perf-review`,
+`refactor-scout`, and `research` ship in this package—no external workflow
+package is installed.
+
+```
+/workflow code-review HEAD~3
+/workflow research "Compare the current provider implementations"
+```
+
+The `workflow` tool exposes the same engine to the model. Runs have no agent,
+timeout, submission, or token-budget limit by default; set limits explicitly
+with workflow options when a task needs them.
+
 ---
 
 ## Commands
@@ -161,10 +179,10 @@ reboot.
 | --- | --- |
 | `/pi-plus` | status modal for every feature |
 | `/pi-plus help` | model explains the pack and what is missing |
-| `/account` | account hub: toggle, add, reauth, switch routing |
-| `/account <provider> add [label]` | add a subscription |
-| `/account <provider> reauth [label]` | reauthorize one |
-| `/routing standard \| optimal` | main-first, or balance by quota |
+| `/accounts` | account hub: toggle, add, reauth, switch routing |
+| `/accounts add <provider> [label]` | add a subscription |
+| `/accounts reauth <provider> [label]` | reauthorize one |
+| `/routing sequential \| quota-aware` | account order, or remaining capacity |
 | `/usage [on\|off\|text]` | quota bars |
 | `/models [sort]` | ranked catalog |
 | `/model-info <id>` | every benchmark for one model |
@@ -176,9 +194,11 @@ reboot.
 | `/remote add \| rename \| remove` | jump to one step |
 | `/board` | live agent board UI |
 | `/board setup \| restart \| clear \| status` | manage the board server |
+| `/workflow` | open the running workflow agent board |
+| `/workflow <name> [args]` | run a bundled workflow |
 
-**Tools available to the agent:** `list_models`, `agent_board`, `remote_status`,
-`remote_test`.
+**Tools available to the agent:** `workflow`, `list_models`, `agent_board`,
+`remote_status`, `remote_test`.
 
 ---
 
@@ -213,13 +233,13 @@ src/
               usage-service, the single quota poller
   ui/         dumb render primitives: format · usage-bars
   domains/    one pi extension entry each
-              setup · subscriptions · models · agents · remote
-  vendor/     anthropic.ts, the only file importing @cortexkit/*
-server/       the agent board server, one file and one dependency (ws)
+              setup · subscriptions · models · workflows · agents · remote
+server/       agent board server
+config/       example settings and bundled skills
 ```
 
 ```sh
-npm install && npm run verify   # typecheck + 106 tests
+npm install && npm run verify   # lint + type check + tests
 ```
 
 ---
@@ -232,6 +252,10 @@ pi-plus is a thin layer over other people's work.
 | --- | --- | --- |
 | [`pi`](https://pi.dev/) | the host agent and the entire extension API | MIT |
 | [`xxhash-wasm`](https://github.com/jungomi/xxhash-wasm) | vendored into `src/core/anthropic/vendor/` for the billing checksum | MIT |
+| [`pi-workflow-engine`](https://github.com/timbrinded/pi-workflow-engine) | embedded workflow runtime and built-in workflows | MIT |
+
+The workflow engine keeps its upstream license in
+[`src/domains/workflows/LICENSE.md`](src/domains/workflows/LICENSE.md).
 
 The Anthropic provider, OAuth, quota and routing were originally adopted from
 [`@cortexkit/pi-anthropic-auth`](https://github.com/cortexkit/anthropic-auth)

package/config/skills/workflow-code-review-actions/SKILL.md

@@ -0,0 +1,44 @@
+---
+name: workflow-code-review-actions
+description: "Act on selected workflow code-review findings: make minimal fixes or post GitHub PR inline comments using gh, GitHub MCP/tools, or project-specific tools."
+---
+
+Use this skill when the parent agent receives selected findings from the workflow code review.
+
+## Inputs
+
+The prompt will include compact JSON with:
+
+- `context`: workflow name, target, diff command, changed files, and optional summary.
+- `issues`: selected findings with `id`, `summary`, `category`, `severity`, `confidence`, `location`, `impact`, `evidence`, and `recommendation`.
+
+## Fix mode
+
+When mode is `fix selected code-review findings`:
+
+1. Inspect the selected issue JSON before editing.
+2. Make minimal edits that address only the selected findings.
+3. Preserve unrelated user changes and avoid broad refactors.
+4. Run focused validation if available for the touched files or behavior.
+5. Summarize changed files and validation results.
+6. Do not post GitHub PR comments in fix mode.
+
+## Comment mode
+
+When mode is `post inline GitHub PR comments`:
+
+1. Do not edit files or make code changes.
+2. Prefer installed GitHub MCP/tools if visible in the active tool list.
+3. If no GitHub MCP/tools are available, use `gh`:
+   - Resolve the PR with `gh pr view --json number,headRefOid,url,headRepositoryOwner,headRepository`.
+   - Resolve the repository with `gh repo view --json nameWithOwner` when owner/name is missing.
+   - Post each inline comment with `gh api repos/{owner}/{repo}/pulls/{number}/comments` and include `commit_id`, `path`, `line`, and `side=RIGHT`.
+4. Keep each comment concise: summary, severity/confidence/category, impact, evidence, and recommendation.
+5. Report posted, skipped, and failed counts.
+
+## Safety rules
+
+- Do not post duplicate comments.
+- Do not comment line-less findings inline.
+- Ask the user if the upstream PR cannot be identified.
+- Keep actions scoped to the selected issue IDs only.

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@jameslovespancakes/pi-plus",
-  "version": "1.0.10",
+  "version": "1.0.12",
   "type": "module",
-  "description": "Consolidated pi extensions: Claude subscription accounts and quota HUD, benchmark-driven model catalog and billing policy, live agent board, and capacity-gated remote test workers.",
+  "description": "pi and more",
   "license": "MIT",
   "author": "james",
   "keywords": [
@@ -12,7 +12,9 @@
     "anthropic",
     "claude",
     "quota",
-    "models"
+    "models",
+    "workflows",
+    "multi-agent"
   ],
   "repository": {
     "type": "git",
@@ -35,6 +37,7 @@
       "./src/domains/setup/index.ts",
       "./src/domains/subscriptions/index.ts",
       "./src/domains/models/index.ts",
+      "./src/domains/workflows/index.ts",
       "./src/domains/agents/index.ts",
       "./src/domains/remote/index.ts"
     ],

package/src/core/accounts/oauth-pool.ts

@@ -0,0 +1,102 @@
+import type { OAuthCredential } from "@earendil-works/pi-ai";
+import { agentPath, readJson, writeJson } from "../store.ts";
+import { normalizeRoutingMode, type AccountQuotaState, type AccountRoutingMode } from "./routing.ts";
+
+export type OAuthPoolMode = AccountRoutingMode;
+
+export interface PooledOAuthAccount extends OAuthCredential {
+  id: string;
+  label: string;
+  enabled?: boolean;
+  identity?: string;
+  addedAt: number;
+  lastUsed?: number;
+  quota?: AccountQuotaState;
+}
+
+export interface ProviderOAuthPool {
+  accounts: PooledOAuthAccount[];
+  mode: OAuthPoolMode;
+}
+
+interface OAuthPoolFile {
+  version: 1;
+  providers: Record<string, ProviderOAuthPool>;
+}
+
+const EMPTY_FILE: OAuthPoolFile = { version: 1, providers: {} };
+const DEFAULT_PATH = "pi-plus-oauth-accounts.json";
+const fileCache = new Map<string, OAuthPoolFile>();
+
+export function oauthPoolPath(): string {
+  return process.env.PI_PLUS_OAUTH_ACCOUNTS_FILE ?? agentPath(DEFAULT_PATH);
+}
+
+function loadFile(path = oauthPoolPath()): OAuthPoolFile {
+  const cached = fileCache.get(path);
+  if (cached) return cached;
+
+  const raw = readJson<Partial<OAuthPoolFile>>(path, EMPTY_FILE);
+  const file: OAuthPoolFile = {
+    version: 1,
+    providers: raw.providers && typeof raw.providers === "object" ? raw.providers : {},
+  };
+  fileCache.set(path, file);
+  return file;
+}
+
+function saveFile(file: OAuthPoolFile, path = oauthPoolPath()): void {
+  fileCache.set(path, file);
+  if (!writeJson(path, file, true, 0o600)) throw new Error(`Could not write OAuth accounts to ${path}`);
+}
+
+export function loadOAuthPool(providerId: string, path = oauthPoolPath()): ProviderOAuthPool {
+  const pool = loadFile(path).providers[providerId];
+  return {
+    accounts: Array.isArray(pool?.accounts) ? pool.accounts : [],
+    mode: normalizeRoutingMode(pool?.mode as string | undefined),
+  };
+}
+
+export function saveOAuthPool(providerId: string, pool: ProviderOAuthPool, path = oauthPoolPath()): void {
+  const file = loadFile(path);
+  file.providers[providerId] = pool;
+  saveFile(file, path);
+}
+
+export function saveOAuthAccount(providerId: string, account: PooledOAuthAccount, path = oauthPoolPath()): void {
+  const pool = loadOAuthPool(providerId, path);
+  const index = pool.accounts.findIndex((candidate) => candidate.id === account.id);
+  if (index === -1) pool.accounts.push(account);
+  else pool.accounts[index] = { ...pool.accounts[index], ...account };
+  saveOAuthPool(providerId, pool, path);
+}
+
+export function removeOAuthAccount(providerId: string, accountId: string, path = oauthPoolPath()): boolean {
+  const pool = loadOAuthPool(providerId, path);
+  const accounts = pool.accounts.filter((account) => account.id !== accountId);
+  if (accounts.length === pool.accounts.length) return false;
+  saveOAuthPool(providerId, { ...pool, accounts }, path);
+  return true;
+}
+
+export function setOAuthPoolMode(providerId: string, mode: OAuthPoolMode, path = oauthPoolPath()): void {
+  saveOAuthPool(providerId, { ...loadOAuthPool(providerId, path), mode }, path);
+}
+
+export function oauthIdentity(access: string): string | undefined {
+  try {
+    const payload = JSON.parse(Buffer.from(access.split(".")[1] ?? "", "base64url").toString()) as Record<string, unknown>;
+    for (const key of ["sub", "email", "account_id", "user_id", "uid"]) {
+      const value = payload[key];
+      if (typeof value === "string" && value) return `${key}:${value}`;
+    }
+  } catch {
+    // Opaque access tokens have no local identity.
+  }
+  return undefined;
+}
+
+export function resetOAuthPoolCache(): void {
+  fileCache.clear();
+}

package/src/core/accounts/registry.ts

@@ -1,13 +1,4 @@
-/**
- * Provider-agnostic subscription accounts.
- *
- * Today only Anthropic implements this, through
- * `domains/subscriptions/providers/anthropic.ts`. The point of the indirection
- * is that `/account` and `/routing` contain no provider-specific logic, so a
- * second provider is a new adapter rather than a new command surface.
- *
- * Structural types only; nothing here imports pi.
- */
+/** Provider-agnostic subscription account adapters. */
 
 export interface ManagedAccount {
   id: string;
@@ -20,15 +11,12 @@ export interface ManagedAccount {
   primary?: boolean;
 }
 
-/**
- * `standard` uses the main account first and falls back only when it is
- * exhausted. `optimal` balances across accounts by remaining quota and time to
- * reset, keeping session caches sticky.
- */
-export type RoutingMode = "standard" | "optimal";
+/** Fixed account order or provider quota-aware selection. */
+export type RoutingMode = "sequential" | "quota-aware";
 
 export interface AccountUi {
   input(title: string, placeholder?: string): Promise<string | undefined>;
+  select(title: string, options: string[]): Promise<string | undefined>;
   confirm(title: string, message: string): Promise<boolean>;
   notify(message: string, type?: "info" | "warning" | "error"): void;
 }
@@ -36,7 +24,8 @@ export interface AccountUi {
 export interface AccountContext {
   ui: AccountUi;
   hasUI: boolean;
-  /** Opens a URL in the user's browser, for OAuth flows. */
+  signal?: AbortSignal;
+  /** Opens an OAuth URL. */
   openBrowser(url: string): Promise<void>;
 }
 
@@ -56,15 +45,9 @@ export interface AccountProvider {
   add(ctx: AccountContext, label: string): Promise<string | undefined>;
   /** Returns the label of the account that was reauthorized. */
   reauth(ctx: AccountContext, accountId: string): Promise<string | undefined>;
-  /**
-   * Enables or disables one account without removing its credentials.
-   * Optional: a provider that cannot suspend accounts simply omits it.
-   */
+  /** Enables or disables an account without removing credentials. */
   setEnabled?(accountId: string, enabled: boolean): Promise<void>;
-  /**
-   * Changes an account's display label. Credentials are untouched, so this is
-   * purely cosmetic and never needs a re-authorization.
-   */
+  /** Changes only the display label. */
   rename?(accountId: string, label: string): Promise<void>;
   routing?: RoutingSupport;
 }

package/src/core/accounts/routing.ts

@@ -0,0 +1,122 @@
+export interface AccountQuotaState {
+  remainingPercent?: number;
+  resetAt?: number;
+  checkedAt: number;
+  blockedUntil?: number;
+}
+
+export interface AccountRoutingCandidate<T> {
+  readonly id: string;
+  readonly order: number;
+  readonly lastUsed: number;
+  readonly quota?: AccountQuotaState;
+  readonly value: T;
+}
+
+export type AccountRoutingMode = "sequential" | "quota-aware";
+
+/** Maps stored legacy names onto the two routing modes. */
+export function normalizeRoutingMode(value: string | undefined): AccountRoutingMode {
+  return value === "quota-aware" || value === "optimal" || value === "sticky-balanced"
+    ? "quota-aware"
+    : "sequential";
+}
+
+/** Sequential keeps account order; quota-aware prefers unmeasured then highest remaining capacity. */
+export function selectRoutingCandidate<T>(
+  candidates: readonly AccountRoutingCandidate<T>[],
+  mode: AccountRoutingMode,
+  now = Date.now(),
+): AccountRoutingCandidate<T> | undefined {
+  if (candidates.length === 0) return undefined;
+  const viable = candidates.filter((candidate) => isCandidateViable(candidate.quota, now));
+  if (viable.length === 0) return undefined;
+
+  if (mode === "sequential") {
+    return [...viable].sort((left, right) => left.order - right.order)[0];
+  }
+
+  const unmeasured = viable.filter((candidate) => candidate.quota?.remainingPercent === undefined);
+  if (unmeasured.length > 0) return leastRecentlyUsed(unmeasured);
+
+  return [...viable].sort((left, right) =>
+    (right.quota?.remainingPercent ?? 0) - (left.quota?.remainingPercent ?? 0)
+    || left.lastUsed - right.lastUsed
+    || left.order - right.order
+    || left.id.localeCompare(right.id))[0];
+}
+
+export function quotaStateFromHeaders(
+  status: number,
+  headers: Record<string, string>,
+  previous?: AccountQuotaState,
+  now = Date.now(),
+): AccountQuotaState | undefined {
+  const normalized = new Map(Object.entries(headers).map(([key, value]) => [key.toLowerCase(), value]));
+  const remaining = firstNumber(normalized, [
+    "x-ratelimit-remaining-requests",
+    "ratelimit-remaining-requests",
+    "x-ratelimit-remaining",
+    "ratelimit-remaining",
+  ]);
+  const limit = firstNumber(normalized, [
+    "x-ratelimit-limit-requests",
+    "ratelimit-limit-requests",
+    "x-ratelimit-limit",
+    "ratelimit-limit",
+  ]);
+  const resetAt = parseResetAt(normalized, now);
+
+  if (status === 429) {
+    return {
+      remainingPercent: 0,
+      resetAt,
+      checkedAt: now,
+      blockedUntil: resetAt ?? now + 60_000,
+    };
+  }
+  if (remaining === undefined) return previous;
+
+  const remainingPercent = limit && limit > 0
+    ? Math.max(0, Math.min(100, remaining / limit * 100))
+    : Math.max(0, Math.min(100, remaining));
+  return { remainingPercent, resetAt, checkedAt: now };
+}
+
+function isCandidateViable(quota: AccountQuotaState | undefined, now: number): boolean {
+  if (!quota) return true;
+  if (quota.blockedUntil !== undefined && quota.blockedUntil > now) return false;
+  if (quota.remainingPercent !== 0) return true;
+  return quota.resetAt !== undefined && quota.resetAt <= now;
+}
+
+function leastRecentlyUsed<T>(candidates: readonly AccountRoutingCandidate<T>[]): AccountRoutingCandidate<T> {
+  return [...candidates].sort((left, right) =>
+    left.lastUsed - right.lastUsed
+    || left.order - right.order
+    || left.id.localeCompare(right.id))[0];
+}
+
+function firstNumber(headers: ReadonlyMap<string, string>, names: readonly string[]): number | undefined {
+  for (const name of names) {
+    const value = Number(headers.get(name));
+    if (Number.isFinite(value)) return value;
+  }
+  return undefined;
+}
+
+function parseResetAt(headers: ReadonlyMap<string, string>, now: number): number | undefined {
+  const retryAfter = Number(headers.get("retry-after"));
+  if (Number.isFinite(retryAfter) && retryAfter >= 0) return now + retryAfter * 1_000;
+
+  const raw = firstNumber(headers, [
+    "x-ratelimit-reset-requests",
+    "ratelimit-reset-requests",
+    "x-ratelimit-reset",
+    "ratelimit-reset",
+  ]);
+  if (raw === undefined) return undefined;
+  if (raw > 1_000_000_000_000) return raw;
+  if (raw > 1_000_000_000) return raw * 1_000;
+  return now + raw * 1_000;
+}

package/src/core/anthropic/client-identity.ts

@@ -2,43 +2,15 @@ import { createHash, randomUUID } from "node:crypto";
 import { xxhash64 } from "./xxhash64.ts";
 
 /**
- * Claude Code client identity headers.
- *
- * ---------------------------------------------------------------------------
- * READ THIS BEFORE CHANGING ANYTHING HERE
- *
- * These headers make a request indistinguishable from Anthropic's official
- * Claude Code CLI. Without them Anthropic classifies the caller as a
- * third-party app and answers:
- *
- *   "Third-party apps now draw from your extra usage, not your plan limits."
- *
- * So the purpose of this file is to bill against plan limits rather than extra
- * usage. That is plausibly contrary to Anthropic's intent as stated in that
- * message, and the exposure falls on the account owner.
- *
- * It is isolated in one file, and referenced from exactly one place, so it can
- * be deleted or replaced without touching the rest of the provider. Removing it
- * does not break anything: requests keep working and bill to extra usage.
- *
- * Ported from @cortexkit/anthropic-auth-core during extraction.
- * ---------------------------------------------------------------------------
+ * Emulates Claude Code so OAuth requests use plan limits instead of extra usage.
+ * This may conflict with Anthropic's stated intent; remove this identity from
+ * the provider to opt out. Adapted from @cortexkit/anthropic-auth-core.
  */
 
 /** Pinned to the Claude Code release being imitated. */
 export const CLAUDE_CODE_VERSION = "2.1.258";
 
-/**
- * Anti-tamper checksum, replicated from the official client.
- *
- * The real CLI signs the serialised request body with xxHash64 under a fixed
- * seed and writes the low 20 bits into a `cch=` placeholder. Anthropic added
- * this so a client cannot simply assert it is Claude Code in a header: it has
- * to prove it by producing a value derived from the request itself.
- *
- * The salt and sample positions are constants in the official bundle, not
- * derivable from anything, and they will change when the CLI is updated.
- */
+/** Claude Code checksum constants. They can change between CLI releases. */
 const CCH_SEED = 0x4d659218e32a3268n;
 const CCH_SALT = "59cf53e54c78";
 const CCH_POSITIONS = [4, 7, 20];
@@ -147,15 +119,7 @@ function hasFullAgentShape(body: any): boolean {
     && !!body?.thinking && typeof body.thinking === "object";
 }
 
-/**
- * Paragraphs containing this anchor cannot sit in the top-level `system` array.
- *
- * Two lines of pi's documentation paragraph are each independently sufficient to
- * make Anthropic answer 400 "Third-party apps now draw from your extra usage".
- * The same text is accepted inside `messages`, so it is moved there. Confirmed
- * by bisection: the identical payload returns 200 with the paragraph removed and
- * 400 with it present, and entry count and payload size are not the factors.
- */
+/** Documentation paragraphs must move from `system` into `messages`. */
 const DOCS_ANCHOR = "Pi documentation";
 
 /** Lone surrogates are invalid UTF-8 and are rejected outright. */
@@ -163,14 +127,7 @@ function sanitizePrompt(text: string): string {
   return text.replace(/[\uD800-\uDFFF]/gu, "\uFFFD");
 }
 
-/**
- * Splits pi's system prompt into what may stay in `system` and what must move
- * into the first user message.
- *
- * An unrecognised prompt shape (no docs paragraph found) is moved whole, the
- * same conservative fallback the vendor uses: better to shift the entire prompt
- * into messages than to guess and trigger the 400.
- */
+/** Splits the system prompt, moving unknown shapes conservatively. */
 export function splitSystemPrompt(prompt: string): { systemText?: string; messageText: string } {
   const paragraphs = sanitizePrompt(prompt).split(/\n\n+/);
   const docs = paragraphs.filter((p) => p.includes(DOCS_ANCHOR));
@@ -183,15 +140,7 @@ export function splitSystemPrompt(prompt: string): { systemText?: string; messag
   };
 }
 
-/**
- * Inserts text as its own cache-controlled block ahead of the first user
- * message.
- *
- * A separate block rather than merged text, so the cache prefix ends before the
- * user's own words and a new conversation with a different first message still
- * reads this from cache. `cache_control` is explicit because the message-level
- * breakpoint elsewhere only covers the last user message.
- */
+/** Prepends a cache-controlled block to the first user message. */
 export function prependPromptBlock(messages: any[], text: string): void {
   const firstUser = (messages ?? []).find((m) => m?.role === "user");
   if (!firstUser || !text) return;
@@ -213,16 +162,12 @@ export function selectBetas(body: unknown, extra: string[] = []): string {
   return [...new Set(selected)].join(",");
 }
 
-/**
- * Headers presenting this client as Claude Code.
- * Merged over whatever pi already set.
- */
+/** Headers presenting this client as Claude Code. */
 export function clientIdentityHeaders(body?: unknown, existingBetas?: string): Record<string, string> {
   const incoming = (existingBetas ?? "").split(",").map((b) => b.trim()).filter(Boolean);
   return {
     "user-agent": USER_AGENT,
-    // Required: pi's Anthropic client reads this header to decide which betas
-    // to send, then puts them in the body's `betas` field.
+    // Pi copies this header into the request body's betas field.
     "anthropic-beta": selectBetas(body, incoming),
     "anthropic-version": "2023-06-01",
     "anthropic-dangerous-direct-browser-access": "true",