opencode-anthropic-fix 0.0.21 → 0.0.23

package/README.md

@@ -43,11 +43,11 @@ The [original plugin](https://github.com/anomalyco/opencode-anthropic-auth) prov
 - **Standalone CLI** — manage accounts without opening OpenCode
 - **Configurable strategies** — sticky, round-robin, or hybrid account selection
 - **Claude Code signature emulation** — full HTTP header, system prompt, beta flag, and metadata mimicry derived from Claude Code's open source code
-- **Adaptive thinking for Opus 4.6** — automatically uses `adaptive-thinking-2026-01-28` and maps `budgetTokens` to effort levels (`low`/`medium`/`high`)
+- **Effort-based thinking for Opus 4.6** — maps `budgetTokens` to effort levels (`low`/`medium`/`high`) and includes `effort-2025-11-24`
 - **1M context limit override** — patches `model.limit.context` so OpenCode compacts at the right threshold while `models.dev` catches up
 - **Runtime config + custom betas** — `/anthropic set`, `/anthropic config`, and `/anthropic betas` slash commands for live feature toggling without restarting OpenCode
-- **Files API integration** — upload, list, download, and manage files via `/anthropic files` with auto-included `files-api-2025-04-14` beta
-- **Code execution support** — auto-includes `code-execution-2025-08-25` beta for sandbox code execution (non-Haiku models)
+- **Files API integration** — upload, list, download, and manage files via `/anthropic files` with endpoint/content-scoped `files-api-2025-04-14` beta injection
+- **Code execution support** — available via explicit custom beta opt-in (`code-execution-2025-08-25`), not auto-enabled
 
 ## Installation
 
@@ -271,6 +271,8 @@ Add or remove beta flags that get included in every `anthropic-beta` header. Per
 /anthropic betas                   # show active betas (auto + custom) with presets
 /anthropic betas add <beta-name>   # add a custom beta
 /anthropic betas remove <beta-name> # remove a custom beta
+/anthropic betas add 1m            # shortcut => context-1m-2025-08-07
+/anthropic betas add fast          # shortcut => fast-mode-2026-02-01
 ```
 
 **Available preset betas** (shown by `/anthropic betas`):
@@ -284,6 +286,8 @@ Add or remove beta flags that get included in every `anthropic-beta` header. Per
 | `compact-2026-01-12`              | Conversation compaction endpoint                  |
 | `mcp-servers-2025-12-04`          | MCP servers in API request payload                |
 | `web-search-2025-03-05`           | Web search (Vertex/Foundry only)                  |
+| `context-1m-2025-08-07`           | 1M context beta (provider/model dependent)        |
+| `fast-mode-2026-02-01`            | Faster Opus mode (experimental)                   |
 
 Example workflow:
 
@@ -295,10 +299,10 @@ Example workflow:
 
 ### Files API management
 
-Upload, list, download, and delete files via the Anthropic Files API. The `files-api-2025-04-14` beta is auto-included in every request.
+Upload, list, download, and delete files via the Anthropic Files API. The `files-api-2025-04-14` beta is injected only when needed (`/v1/files` requests or Messages payloads with `file_id`).
 
 ```text
-/anthropic files                       # list uploaded files
+/anthropic files                       # list files across ALL accounts
 /anthropic files upload ./report.pdf   # upload a file
 /anthropic files get file_abc123       # get file metadata
 /anthropic files download file_abc123  # download to current directory
@@ -308,6 +312,16 @@ Upload, list, download, and delete files via the Anthropic Files API. The `files
 
 Supported formats: PDF, DOCX, TXT, CSV, Excel, Markdown, images (max 350 MB per file). Uploaded files can be referenced by `file_id` in Messages API requests.
 
+**Multi-account behavior:** Files on Anthropic are per-account. With multiple accounts:
+
+- `/anthropic files list` (no `--account`) queries **all** enabled accounts, labeling each file with its owner email
+- Use `--account <email|index>` to target a specific account for any action:
+  ```text
+  /anthropic files list --account alice@example.com
+  /anthropic files upload ./data.csv --account 2
+  ```
+- **Auto-pinning:** When you upload or list files, the plugin remembers which account owns each `file_id`. If a subsequent Messages API request references that `file_id`, the plugin automatically routes it to the correct account — even with round-robin or hybrid strategies.
+
 ### OAuth flows from slash command
 
 Login and reauth are two-step flows in slash mode:
@@ -333,11 +347,11 @@ Pending slash OAuth flows expire after 10 minutes. If completion fails with an e
 
 Control how the plugin picks which account to use for each request.
 
-| Strategy                    | Behavior                                                                                  | Best For                                              |
-| --------------------------- | ----------------------------------------------------------------------------------------- | ----------------------------------------------------- |
-| **`round-robin`** (default) | Rotate through accounts on every request                                                  | Spreading load evenly across accounts                 |
-| **`sticky`**                | Stay on one account until it fails or is rate-limited                                     | Single account, or when you want predictable behavior |
-| **`hybrid`**                | Score-based selection with stickiness bias. Considers health, token budget, and freshness | Multiple accounts with varying rate limits            |
+| Strategy               | Behavior                                                                                  | Best For                                                                            |
+| ---------------------- | ----------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------- |
+| **`sticky`** (default) | Stay on one account until it fails or is rate-limited                                     | Single account, predictable behavior, full feature compatibility                    |
+| **`round-robin`**      | Rotate through accounts on every request                                                  | Spreading load evenly across accounts (see [limitations](#round-robin-limitations)) |
+| **`hybrid`**           | Score-based selection with stickiness bias. Considers health, token budget, and freshness | Multiple accounts with varying rate limits                                          |
 
 ### Change Strategy
 
@@ -352,14 +366,37 @@ export OPENCODE_ANTHROPIC_STRATEGY=hybrid
 # Edit ~/.config/opencode/anthropic-auth.json
 ```
 
+### Round-Robin Limitations
+
+Some Anthropic API features maintain server-side per-account state that breaks when requests alternate between accounts:
+
+| Feature                                                | Impact                                                                                                           | Plugin Mitigation                                                                                        |
+| ------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------- |
+| **Files API** (`files-api-2025-04-14`)                 | `file_id` is per-account; referencing Account A's file from Account B = `file_not_found`                         | **Auto-pinning**: the plugin tracks which account owns each `file_id` and routes the request accordingly |
+| **Prompt Caching** (`prompt-caching-scope-2026-01-05`) | Cache is per-workspace; alternating accounts means zero cache hits, doubling token costs                         | **Auto-skipped** in round-robin: the `prompt-caching-scope` beta is excluded from the header             |
+| **Code Execution** (`code-execution-2025-08-25`)       | Sandbox state is ephemeral per-request; multi-step workflows lose files/state when routed to a different account | **Manual opt-in only**: add the beta explicitly, and prefer sticky/pinned sessions for multi-step flows  |
+| **Message Batches** (`message-batches-2024-09-24`)     | `batch_id` is per-account; polling from wrong account = 404                                                      | No automatic mitigation (not auto-included)                                                              |
+
+**Recommendation for round-robin users:** If you need prompt caching or code execution, pin each OpenCode session to a single account:
+
+```bash
+# Terminal 1 — uses account 1
+OPENCODE_ANTHROPIC_INITIAL_ACCOUNT=1 opencode
+
+# Terminal 2 — uses account 2
+OPENCODE_ANTHROPIC_INITIAL_ACCOUNT=2 opencode
+```
+
+This automatically overrides the strategy to `sticky` for that session, re-enabling strategy-sensitive auto betas (for example `prompt-caching-scope-2026-01-05`). Other sessions are unaffected.
+
 ## Configuration
 
 Configuration is stored at `~/.config/opencode/anthropic-auth.json`. All settings are optional &mdash; defaults work well for most users.
 
 ```jsonc
 {
-  // Account selection strategy: "round-robin" | "sticky" | "hybrid"
-  "account_selection_strategy": "round-robin",
+  // Account selection strategy: "sticky" | "round-robin" | "hybrid"
+  "account_selection_strategy": "sticky",
 
   // Seconds before consecutive failure count resets (60-7200)
   "failure_ttl_seconds": 3600,
@@ -427,16 +464,18 @@ Configuration is stored at `~/.config/opencode/anthropic-auth.json`. All setting
 
 ### Environment Variables
 
-| Variable                                           | Description                                                                                                 |
-| -------------------------------------------------- | ----------------------------------------------------------------------------------------------------------- |
-| `OPENCODE_ANTHROPIC_STRATEGY`                      | Override the account selection strategy at runtime.                                                         |
-| `OPENCODE_ANTHROPIC_DEBUG`                         | Set to `1` to enable debug logging.                                                                         |
-| `OPENCODE_ANTHROPIC_QUIET`                         | Set to `1` to suppress non-error toasts (account status, switching).                                        |
-| `OPENCODE_ANTHROPIC_EMULATE_CLAUDE_CODE_SIGNATURE` | Set to `0` to disable Claude signature emulation (legacy mode).                                             |
-| `OPENCODE_ANTHROPIC_FETCH_CLAUDE_CODE_VERSION`     | Set to `0` to skip npm version lookup at startup.                                                           |
-| `OPENCODE_ANTHROPIC_PROMPT_COMPACTION`             | Set to `off` to disable default minimal system prompt compaction.                                           |
-| `OPENCODE_ANTHROPIC_DEBUG_SYSTEM_PROMPT`           | Set to `1` to log the final transformed `system` prompt to stderr (title-generator requests are skipped).   |
-| `OPENCODE_ANTHROPIC_OVERRIDE_MODEL_LIMITS`         | Set to `0` to disable context limit overrides for 1M-window models (e.g. when models.dev has been updated). |
+| Variable                                           | Description                                                                                                                                               |
+| -------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `OPENCODE_ANTHROPIC_STRATEGY`                      | Override the account selection strategy at runtime.                                                                                                       |
+| `OPENCODE_ANTHROPIC_DEBUG`                         | Set to `1` to enable debug logging.                                                                                                                       |
+| `OPENCODE_ANTHROPIC_QUIET`                         | Set to `1` to suppress non-error toasts (account status, switching).                                                                                      |
+| `OPENCODE_ANTHROPIC_EMULATE_CLAUDE_CODE_SIGNATURE` | Set to `0` to disable Claude signature emulation (legacy mode).                                                                                           |
+| `OPENCODE_ANTHROPIC_FETCH_CLAUDE_CODE_VERSION`     | Set to `0` to skip npm version lookup at startup.                                                                                                         |
+| `OPENCODE_ANTHROPIC_PROMPT_COMPACTION`             | Set to `off` to disable default minimal system prompt compaction.                                                                                         |
+| `OPENCODE_ANTHROPIC_DEBUG_SYSTEM_PROMPT`           | Set to `1` to log the final transformed `system` prompt to stderr (title-generator requests are skipped).                                                 |
+| `OPENCODE_ANTHROPIC_OVERRIDE_MODEL_LIMITS`         | Set to `0` to disable context limit overrides for 1M-window models (e.g. when models.dev has been updated).                                               |
+| `OPENCODE_ANTHROPIC_INITIAL_ACCOUNT`               | Pin this session to a specific account (1-based index or email). Overrides strategy to `sticky`. See [Round-Robin Limitations](#round-robin-limitations). |
+| `CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS`           | Set to `1` to suppress experimental auto-betas (mirrors Claude Code gateway safety switch).                                                               |
 
 ### OAuth-only behavior
 
@@ -462,7 +501,7 @@ The plugin also:
 - Emulates Claude-style request headers and beta flags by default
 - Sanitizes "OpenCode" references to "Claude Code" in system prompts (required by Anthropic's API)
 - In `prompt_compaction="minimal"`, deduplicates repeated/contained system blocks and uses a compact dedicated prompt for internal title-generation requests
-- Adds `?beta=true` to `/v1/messages` requests
+- Adds `?beta=true` to `/v1/messages` and `/v1/messages/count_tokens` requests
 
 When signature emulation is disabled (`signature_emulation.enabled=false`), the plugin falls back to legacy behavior including the Claude Code system prompt prefix.
 

package/index.mjs

@@ -106,6 +106,8 @@ async function promptManageAccounts(accountManager) {
 const FALLBACK_CLAUDE_CLI_VERSION = "2.1.76";
 const CLAUDE_CODE_NPM_LATEST_URL = "https://registry.npmjs.org/@anthropic-ai/claude-code/latest";
 const CLAUDE_CODE_BETA_FLAG = "claude-code-20250219";
+const EFFORT_BETA_FLAG = "effort-2025-11-24";
+const TOKEN_COUNTING_BETA_FLAG = "token-counting-2024-11-01";
 const BILLING_HASH_SALT = "59cf53e54c78";
 const BILLING_HASH_POSITIONS = [4, 7, 20];
 const CLAUDE_CODE_IDENTITY_STRING = "You are Claude Code, Anthropic's official CLI for Claude.";
@@ -122,6 +124,32 @@ const BEDROCK_UNSUPPORTED_BETAS = new Set([
   "code-execution-2025-08-25",
   "files-api-2025-04-14",
 ]);
+const EXPERIMENTAL_BETA_FLAGS = new Set([
+  "adaptive-thinking-2026-01-28",
+  "advanced-tool-use-2025-11-20",
+  "afk-mode-2026-01-31",
+  "code-execution-2025-08-25",
+  "context-1m-2025-08-07",
+  "context-management-2025-06-27",
+  "fast-mode-2026-02-01",
+  "files-api-2025-04-14",
+  "fine-grained-tool-streaming-2025-05-14",
+  "interleaved-thinking-2025-05-14",
+  "prompt-caching-scope-2026-01-05",
+  "redact-thinking-2026-02-12",
+  "structured-outputs-2025-12-15",
+  "tool-examples-2025-10-29",
+  "tool-search-tool-2025-10-19",
+  "web-search-2025-03-05",
+]);
+const BETA_SHORTCUTS = new Map([
+  ["1m", "context-1m-2025-08-07"],
+  ["1m-context", "context-1m-2025-08-07"],
+  ["context-1m", "context-1m-2025-08-07"],
+  ["fast", "fast-mode-2026-02-01"],
+  ["fast-mode", "fast-mode-2026-02-01"],
+  ["opus-fast", "fast-mode-2026-02-01"],
+]);
 const STAINLESS_HELPER_KEYS = [
   "x_stainless_helper",
   "x-stainless-helper",
@@ -162,6 +190,17 @@ function isFalsyEnv(value) {
   return normalized === "0" || normalized === "false" || normalized === "no";
 }
 
+/**
+ * @param {string | undefined} value
+ * @returns {string}
+ */
+function resolveBetaShortcut(value) {
+  if (!value) return "";
+  const trimmed = value.trim();
+  const mapped = BETA_SHORTCUTS.get(trimmed.toLowerCase());
+  return mapped || trimmed;
+}
+
 /**
  * @returns {boolean}
  */
@@ -341,11 +380,11 @@ function detectProvider(requestUrl) {
 
 /**
  * @param {string | undefined} body
- * @returns {{model: string, tools: any[], messages: any[]}}
+ * @returns {{model: string, tools: any[], messages: any[], hasFileReferences: boolean}}
  */
 function parseRequestBodyMetadata(body) {
   if (!body || typeof body !== "string") {
-    return { model: "", tools: [], messages: [] };
+    return { model: "", tools: [], messages: [], hasFileReferences: false };
   }
 
   try {
@@ -353,9 +392,10 @@ function parseRequestBodyMetadata(body) {
     const model = typeof parsed?.model === "string" ? parsed.model : "";
     const tools = Array.isArray(parsed?.tools) ? parsed.tools : [];
     const messages = Array.isArray(parsed?.messages) ? parsed.messages : [];
-    return { model, tools, messages };
+    const hasFileReferences = extractFileIds(parsed).length > 0;
+    return { model, tools, messages, hasFileReferences };
   } catch {
-    return { model: "", tools: [], messages: [] };
+    return { model: "", tools: [], messages: [], hasFileReferences: false };
   }
 }
 
@@ -662,85 +702,118 @@ function buildSystemPromptBlocks(system, signature, messages) {
  * @param {string} model
  * @param {"anthropic" | "bedrock" | "vertex" | "foundry"} provider
  * @param {string[]} [customBetas]
+ * @param {import('./lib/config.mjs').AccountSelectionStrategy} [strategy]
+ * @param {string} [requestPath]
+ * @param {boolean} [hasFileReferences]
  * @returns {string}
  */
-function buildAnthropicBetaHeader(incomingBeta, signatureEnabled, model, provider, customBetas) {
+function buildAnthropicBetaHeader(
+  incomingBeta,
+  signatureEnabled,
+  model,
+  provider,
+  customBetas,
+  strategy,
+  requestPath,
+  hasFileReferences,
+) {
   const incomingBetasList = incomingBeta
     .split(",")
     .map((b) => b.trim())
     .filter(Boolean);
 
   const betas = ["oauth-2025-04-20"];
+  const disableExperimentalBetas = isTruthyEnv(process.env.CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS);
+  const isMessagesCountTokensPath = requestPath === "/v1/messages/count_tokens";
+  const isFilesEndpoint = requestPath?.startsWith("/v1/files") ?? false;
 
   if (!signatureEnabled) {
     betas.push("interleaved-thinking-2025-05-14");
-    return [...new Set([...betas, ...incomingBetasList])].join(",");
+    if (isMessagesCountTokensPath) {
+      betas.push(TOKEN_COUNTING_BETA_FLAG);
+    }
+    let mergedBetas = [...new Set([...betas, ...incomingBetasList])];
+    if (disableExperimentalBetas) {
+      mergedBetas = mergedBetas.filter((beta) => !EXPERIMENTAL_BETA_FLAGS.has(beta));
+    }
+    return mergedBetas.join(",");
   }
 
   const nonInteractive = isNonInteractiveMode();
   const haiku = isHaikuModel(model);
+  const isRoundRobin = strategy === "round-robin";
 
   if (!haiku) {
     betas.push(CLAUDE_CODE_BETA_FLAG);
-    betas.push("code-execution-2025-08-25");
   }
 
-  // Files API is model-independent; enables /v1/files endpoint and file_id references.
-  betas.push("files-api-2025-04-14");
+  // Files API beta is endpoint/content-scoped instead of globally applied.
+  if ((isFilesEndpoint || hasFileReferences) && !disableExperimentalBetas) {
+    betas.push("files-api-2025-04-14");
+  }
 
   if (isOpus46Model(model)) {
-    // Opus 4.6 uses adaptive thinking — model decides how much to think based on task complexity.
-    // The effort parameter guides it; budgetTokens/interleaved-thinking are for older models.
-    if (!isTruthyEnv(process.env.DISABLE_INTERLEAVED_THINKING)) {
-      betas.push("adaptive-thinking-2026-01-28");
-    }
-  } else if (!isTruthyEnv(process.env.DISABLE_INTERLEAVED_THINKING) && supportsThinking(model)) {
+    // Opus 4.6 uses effort-based thinking controls.
+    betas.push(EFFORT_BETA_FLAG);
+  } else if (
+    !disableExperimentalBetas &&
+    !isTruthyEnv(process.env.DISABLE_INTERLEAVED_THINKING) &&
+    supportsThinking(model)
+  ) {
     betas.push("interleaved-thinking-2025-05-14");
   }
 
   // context-1m-2025-08-07 is only supported for API key users; OAuth provider does not support it.
   // For OAuth (this plugin's only auth mode), compaction is gated by model.limit.input instead.
-  if (hasOneMillionContext(model) && provider !== "anthropic") {
+  if (!disableExperimentalBetas && hasOneMillionContext(model) && provider !== "anthropic") {
     betas.push("context-1m-2025-08-07");
   }
 
   if (
+    !disableExperimentalBetas &&
     nonInteractive &&
     (isTruthyEnv(process.env.USE_API_CONTEXT_MANAGEMENT) || isTruthyEnv(process.env.TENGU_MARBLE_ANVIL))
   ) {
     betas.push("context-management-2025-06-27");
   }
 
-  if (supportsStructuredOutputs(model) && isTruthyEnv(process.env.TENGU_TOOL_PEAR)) {
+  if (!disableExperimentalBetas && supportsStructuredOutputs(model) && isTruthyEnv(process.env.TENGU_TOOL_PEAR)) {
     betas.push("structured-outputs-2025-12-15");
   }
 
-  if (nonInteractive && isTruthyEnv(process.env.TENGU_SCARF_COFFEE)) {
+  if (!disableExperimentalBetas && nonInteractive && isTruthyEnv(process.env.TENGU_SCARF_COFFEE)) {
     betas.push("tool-examples-2025-10-29");
   }
 
-  if ((provider === "vertex" || provider === "foundry") && supportsWebSearch(model)) {
+  if (!disableExperimentalBetas && (provider === "vertex" || provider === "foundry") && supportsWebSearch(model)) {
     betas.push("web-search-2025-03-05");
   }
 
-  if (nonInteractive) {
+  // Prompt caching is per-workspace (since Feb 2026); round-robin across accounts
+  // means zero cache hits and doubled token costs. Skip in round-robin.
+  if (!disableExperimentalBetas && nonInteractive && !isRoundRobin) {
     betas.push("prompt-caching-scope-2026-01-05");
   }
 
-  if (process.env.ANTHROPIC_BETAS && !haiku) {
+  if (isMessagesCountTokensPath) {
+    betas.push(TOKEN_COUNTING_BETA_FLAG);
+  }
+
+  if (process.env.ANTHROPIC_BETAS) {
     const envBetas = process.env.ANTHROPIC_BETAS.split(",")
       .map((b) => b.trim())
       .filter(Boolean);
     betas.push(...envBetas);
   }
 
-  betas.push("fine-grained-tool-streaming-2025-05-14");
-
   if (Array.isArray(customBetas)) {
     betas.push(...customBetas.filter(Boolean));
   }
 
-  const mergedBetas = [...new Set([...betas, ...incomingBetasList])];
+  let mergedBetas = [...new Set([...betas, ...incomingBetasList])];
+  if (disableExperimentalBetas) {
+    mergedBetas = mergedBetas.filter((beta) => !EXPERIMENTAL_BETA_FLAGS.has(beta));
+  }
   if (provider === "bedrock") {
     return mergedBetas.filter((beta) => !BEDROCK_UNSUPPORTED_BETAS.has(beta)).join(",");
   }
@@ -750,7 +823,7 @@ function buildAnthropicBetaHeader(incomingBeta, signatureEnabled, model, provide
 /** @typedef {'low' | 'medium' | 'high'} ThinkingEffort */
 
 /**
- * Map budgetTokens to an adaptive thinking effort level.
+ * Map budgetTokens to an effort level.
  * Used when an Opus 4.6 request arrives with the legacy budgetTokens shape.
  * @param {number} budgetTokens
  * @returns {ThinkingEffort}
@@ -772,11 +845,11 @@ function isValidEffort(value) {
 
 /**
  * Normalise the `thinking` block in the request body for the target model:
- * - Opus 4.6 (adaptive thinking): produces `{ type: "enabled", effort: <effort> }`
+ * - Opus 4.6 (effort-based thinking): produces `{ type: "enabled", effort: <effort> }`
  * - Older models: passes the existing thinking block through unchanged.
  *
  * Handles three incoming shapes:
- *   1. Already adaptive: `{ type: "enabled", effort: "..." }` → kept as-is for Opus 4.6
+ *   1. Already effort-based: `{ type: "enabled", effort: "..." }` → kept as-is for Opus 4.6
  *   2. Legacy manual: `{ type: "enabled", budget_tokens: N }` → mapped to effort for Opus 4.6
  *   3. Absent / disabled: no transform
  *
@@ -864,7 +937,7 @@ async function fetchLatestClaudeCodeVersion(timeoutMs = 1200) {
  * @param {string} accessToken
  * @param {string | undefined} requestBody
  * @param {URL | null} requestUrl
- * @param {{enabled: boolean, claudeCliVersion: string}} signature
+ * @param {{enabled: boolean, claudeCliVersion: string, strategy?: import('./lib/config.mjs').AccountSelectionStrategy, customBetas?: string[]}} signature
  * @returns {Headers}
  */
 function buildRequestHeaders(input, requestInit, accessToken, requestBody, requestUrl, signature) {
@@ -896,9 +969,18 @@ function buildRequestHeaders(input, requestInit, accessToken, requestBody, reque
 
   // Preserve all incoming beta headers while ensuring OAuth requirements
   const incomingBeta = requestHeaders.get("anthropic-beta") || "";
-  const { model, tools, messages } = parseRequestBodyMetadata(requestBody);
+  const { model, tools, messages, hasFileReferences } = parseRequestBodyMetadata(requestBody);
   const provider = detectProvider(requestUrl);
-  const mergedBetas = buildAnthropicBetaHeader(incomingBeta, signature.enabled, model, provider, signature.customBetas);
+  const mergedBetas = buildAnthropicBetaHeader(
+    incomingBeta,
+    signature.enabled,
+    model,
+    provider,
+    signature.customBetas,
+    signature.strategy,
+    requestUrl?.pathname,
+    hasFileReferences,
+  );
 
   const authTokenOverride = process.env.ANTHROPIC_AUTH_TOKEN?.trim();
   const bearerToken = authTokenOverride || accessToken;
@@ -1024,7 +1106,7 @@ function transformRequestBody(body, signature, runtime) {
 }
 
 /**
- * Transform the request URL: add ?beta=true to /v1/messages.
+ * Transform the request URL: add ?beta=true to /v1/messages and /v1/messages/count_tokens.
  * Preserves behaviors F1-F3.
  *
  * @param {any} input
@@ -1043,7 +1125,11 @@ function transformRequestUrl(input) {
     requestUrl = null;
   }
 
-  if (requestUrl && requestUrl.pathname === "/v1/messages" && !requestUrl.searchParams.has("beta")) {
+  if (
+    requestUrl &&
+    (requestUrl.pathname === "/v1/messages" || requestUrl.pathname === "/v1/messages/count_tokens") &&
+    !requestUrl.searchParams.has("beta")
+  ) {
     requestUrl.searchParams.set("beta", "true");
     requestInput = input instanceof Request ? new Request(requestUrl.toString(), input) : requestUrl;
   }
@@ -1566,6 +1652,30 @@ function parseCommandArgs(raw) {
   return parts;
 }
 
+/**
+ * Extract all file_id values from a parsed Messages API request body.
+ * Walks messages and system arrays looking for file content blocks.
+ * @param {any} body - Parsed JSON body
+ * @returns {string[]}
+ */
+function extractFileIds(body) {
+  const ids = [];
+  if (!body || typeof body !== "object") return ids;
+  function walk(obj) {
+    if (Array.isArray(obj)) {
+      for (const item of obj) walk(item);
+    } else if (obj && typeof obj === "object") {
+      if (obj.source?.file_id) ids.push(obj.source.file_id);
+      for (const val of Object.values(obj)) {
+        if (val && typeof val === "object") walk(val);
+      }
+    }
+  }
+  walk(body.messages);
+  walk(body.system);
+  return ids;
+}
+
 /**
  * @type {import('@opencode-ai/plugin').Plugin}
  */
@@ -1596,12 +1706,27 @@ export async function AnthropicAuthPlugin({ client }) {
   const IDLE_REFRESH_WINDOW_MS = config.idle_refresh.window_minutes * 60 * 1000;
   const IDLE_REFRESH_MIN_INTERVAL_MS = config.idle_refresh.min_interval_minutes * 60 * 1000;
 
+  /**
+   * Whether OPENCODE_ANTHROPIC_INITIAL_ACCOUNT env var pinned this session to a
+   * specific account. When true, syncActiveIndexFromDisk is skipped and strategy
+   * is forced to sticky.
+   */
+  let initialAccountPinned = false;
+
   /**
    * Pending slash-command OAuth flows keyed by session ID.
    * @type {Map<string, { mode: "login" | "reauth", verifier: string, targetIndex?: number, createdAt: number }>}
    */
   const pendingSlashOAuth = new Map();
 
+  /**
+   * In-memory mapping of file_id → account index for file-ID account pinning.
+   * Populated by /anthropic files commands, consumed by the fetch interceptor
+   * to route Messages API requests referencing file_ids to the correct account.
+   * @type {Map<string, number>}
+   */
+  const fileAccountMap = new Map();
+
   /**
    * Send an informational message into the current session.
    * @param {string} sessionID
@@ -1978,26 +2103,30 @@ export async function AnthropicAuthPlugin({ client }) {
 
       if (!action || action === "list") {
         const fresh = loadConfigFresh();
+        const strategy = fresh.account_selection_strategy || config.account_selection_strategy;
         const lines = [
           "▣ Anthropic Betas",
           "",
           "Preset betas (auto-computed per model/provider):",
           "  oauth-2025-04-20, claude-code-20250219,",
-          "  interleaved-thinking-2025-05-14 OR adaptive-thinking-2026-01-28,",
-          "  fine-grained-tool-streaming-2025-05-14,",
-          "  code-execution-2025-08-25 (non-Haiku),",
-          "  files-api-2025-04-14",
+          "  interleaved-thinking-2025-05-14 (non-Opus 4.6) OR effort-2025-11-24 (Opus 4.6),",
+          "  files-api-2025-04-14 (only /v1/files and requests with file_id),",
+          "  token-counting-2024-11-01 (only /v1/messages/count_tokens),",
+          `  prompt-caching-scope-2026-01-05 (non-interactive${strategy === "round-robin" ? ", skipped in round-robin" : ""})`,
           "",
+          `Experimental betas: ${isTruthyEnv(process.env.CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS) ? "disabled (CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS=1)" : "enabled"}`,
+          `Strategy: ${strategy}${initialAccountPinned ? " (pinned via OPENCODE_ANTHROPIC_INITIAL_ACCOUNT)" : ""}`,
           `Custom betas: ${fresh.custom_betas.length ? fresh.custom_betas.join(", ") : "(none)"}`,
           "",
           "Toggleable presets:",
           "  /anthropic betas add structured-outputs-2025-12-15",
           "  /anthropic betas add context-management-2025-06-27",
-          "  /anthropic betas add prompt-caching-scope-2026-01-05",
           "  /anthropic betas add tool-examples-2025-10-29",
           "  /anthropic betas add web-search-2025-03-05",
           "  /anthropic betas add compact-2026-01-12",
           "  /anthropic betas add mcp-servers-2025-12-04",
+          "  /anthropic betas add 1m   (shortcut for context-1m-2025-08-07)",
+          "  /anthropic betas add fast (shortcut for fast-mode-2026-02-01)",
           "",
           "Remove: /anthropic betas remove <beta>",
         ];
@@ -2006,11 +2135,12 @@ export async function AnthropicAuthPlugin({ client }) {
       }
 
       if (action === "add") {
-        const beta = args[2]?.trim();
-        if (!beta) {
+        const betaInput = args[2]?.trim();
+        if (!betaInput) {
           await sendCommandMessage(input.sessionID, "▣ Anthropic Betas\n\nUsage: /anthropic betas add <beta-name>");
           return;
         }
+        const beta = resolveBetaShortcut(betaInput);
         const fresh = loadConfigFresh();
         const current = fresh.custom_betas || [];
         if (current.includes(beta)) {
@@ -2019,16 +2149,21 @@ export async function AnthropicAuthPlugin({ client }) {
         }
         saveConfig({ custom_betas: [...current, beta] });
         Object.assign(config, loadConfigFresh());
-        await sendCommandMessage(input.sessionID, `▣ Anthropic Betas\n\nAdded: ${beta}`);
+        const fromShortcut = beta !== betaInput;
+        await sendCommandMessage(
+          input.sessionID,
+          `▣ Anthropic Betas\n\nAdded: ${beta}${fromShortcut ? ` (from shortcut: ${betaInput})` : ""}`,
+        );
         return;
       }
 
       if (action === "remove" || action === "rm") {
-        const beta = args[2]?.trim();
-        if (!beta) {
+        const betaInput = args[2]?.trim();
+        if (!betaInput) {
           await sendCommandMessage(input.sessionID, "▣ Anthropic Betas\n\nUsage: /anthropic betas remove <beta-name>");
           return;
         }
+        const beta = resolveBetaShortcut(betaInput);
         const fresh = loadConfigFresh();
         const current = fresh.custom_betas || [];
         if (!current.includes(beta)) {
@@ -2046,12 +2181,23 @@ export async function AnthropicAuthPlugin({ client }) {
     }
 
     // /anthropic files [list|upload|get|delete|download] — Files API management
+    // Supports --account <email|index> to target a specific account.
+    // Without --account, list aggregates from ALL accounts; other actions use the current account.
     if (primary === "files") {
-      const action = (args[1] || "").toLowerCase();
+      // Parse --account flag from args
+      let targetAccountId = null;
+      const filteredArgs = [];
+      for (let i = 0; i < args.length; i++) {
+        if (args[i] === "--account" && i + 1 < args.length) {
+          targetAccountId = args[i + 1];
+          i++;
+        } else {
+          filteredArgs.push(args[i]);
+        }
+      }
+      const action = (filteredArgs[1] || "").toLowerCase();
 
-      // Get current account and ensure valid token
-      const account = accountManager?.getCurrentAccount();
-      if (!account) {
+      if (!accountManager || accountManager.getAccountCount() === 0) {
         await sendCommandMessage(
           input.sessionID,
           "▣ Anthropic Files (error)\n\nNo accounts configured. Use /anthropic login first.",
@@ -2059,54 +2205,152 @@ export async function AnthropicAuthPlugin({ client }) {
         return;
       }
 
-      let token = account.access;
-      if (!token || !account.expires || account.expires < Date.now()) {
-        try {
-          token = await refreshAccountTokenSingleFlight(account);
-        } catch (err) {
-          await sendCommandMessage(
-            input.sessionID,
-            `▣ Anthropic Files (error)\n\nToken refresh failed: ${err.message}`,
-          );
-          return;
+      /**
+       * Resolve a single account by email or 1-based index.
+       * If identifier is null, falls back to the current account.
+       * @param {string | null} identifier
+       * @returns {{ account: import('./lib/accounts.mjs').ManagedAccount, label: string } | null}
+       */
+      function resolveTargetAccount(identifier) {
+        const accounts = accountManager.getEnabledAccounts();
+        if (identifier) {
+          // Try by email
+          const byEmail = accounts.find((a) => a.email === identifier);
+          if (byEmail) return { account: byEmail, label: byEmail.email || `Account ${byEmail.index + 1}` };
+          // Try by 1-based index
+          const idx = parseInt(identifier, 10);
+          if (!isNaN(idx) && idx >= 1) {
+            const byIdx = accounts.find((a) => a.index === idx - 1);
+            if (byIdx) return { account: byIdx, label: byIdx.email || `Account ${byIdx.index + 1}` };
+          }
+          return null;
+        }
+        // Default to current
+        const current = accountManager.getCurrentAccount();
+        if (!current) return null;
+        return { account: current, label: current.email || `Account ${current.index + 1}` };
+      }
+
+      /**
+       * Get authenticated headers for a specific account, refreshing token if needed.
+       * @param {import('./lib/accounts.mjs').ManagedAccount} acct
+       */
+      async function getFilesAuth(acct) {
+        let tok = acct.access;
+        if (!tok || !acct.expires || acct.expires < Date.now()) {
+          tok = await refreshAccountTokenSingleFlight(acct);
         }
+        return {
+          authorization: `Bearer ${tok}`,
+          "anthropic-beta": "oauth-2025-04-20,files-api-2025-04-14",
+        };
       }
 
       const apiBase = "https://api.anthropic.com";
-      const authHeaders = {
-        authorization: `Bearer ${token}`,
-        "anthropic-beta": "files-api-2025-04-14",
-      };
 
       try {
-        // /anthropic files list — list all uploaded files
+        // /anthropic files list — list uploaded files
         if (!action || action === "list") {
-          const res = await fetch(`${apiBase}/v1/files`, { headers: authHeaders });
-          if (!res.ok) {
-            const errBody = await res.text();
-            await sendCommandMessage(input.sessionID, `▣ Anthropic Files (error)\n\nHTTP ${res.status}: ${errBody}`);
+          if (targetAccountId) {
+            // List for a specific account
+            const resolved = resolveTargetAccount(targetAccountId);
+            if (!resolved) {
+              await sendCommandMessage(
+                input.sessionID,
+                `▣ Anthropic Files (error)\n\nAccount not found: ${targetAccountId}`,
+              );
+              return;
+            }
+            const { account, label } = resolved;
+            const headers = await getFilesAuth(account);
+            const res = await fetch(`${apiBase}/v1/files`, { headers });
+            if (!res.ok) {
+              const errBody = await res.text();
+              await sendCommandMessage(
+                input.sessionID,
+                `▣ Anthropic Files (error) [${label}]\n\nHTTP ${res.status}: ${errBody}`,
+              );
+              return;
+            }
+            const data = await res.json();
+            const files = data.data || [];
+            for (const f of files) fileAccountMap.set(f.id, account.index);
+            if (files.length === 0) {
+              await sendCommandMessage(input.sessionID, `▣ Anthropic Files [${label}]\n\nNo files uploaded.`);
+              return;
+            }
+            const lines = [`▣ Anthropic Files [${label}]`, "", `${files.length} file(s):`, ""];
+            for (const f of files) {
+              const sizeKB = (f.size / 1024).toFixed(1);
+              lines.push(`  ${f.id}  ${f.filename}  (${sizeKB} KB, ${f.purpose})`);
+            }
+            await sendCommandMessage(input.sessionID, lines.join("\n"));
             return;
           }
-          const data = await res.json();
-          const files = data.data || [];
-          if (files.length === 0) {
-            await sendCommandMessage(input.sessionID, "▣ Anthropic Files\n\nNo files uploaded.");
-            return;
+
+          // List files from ALL enabled accounts
+          const accounts = accountManager.getEnabledAccounts();
+          const allLines = ["▣ Anthropic Files (all accounts)", ""];
+          let totalFiles = 0;
+          for (const acct of accounts) {
+            const label = acct.email || `Account ${acct.index + 1}`;
+            try {
+              const headers = await getFilesAuth(acct);
+              const res = await fetch(`${apiBase}/v1/files`, { headers });
+              if (!res.ok) {
+                allLines.push(`[${label}] Error: HTTP ${res.status}`);
+                allLines.push("");
+                continue;
+              }
+              const data = await res.json();
+              const files = data.data || [];
+              for (const f of files) fileAccountMap.set(f.id, acct.index);
+              totalFiles += files.length;
+              if (files.length === 0) {
+                allLines.push(`[${label}] No files`);
+              } else {
+                allLines.push(`[${label}] ${files.length} file(s):`);
+                for (const f of files) {
+                  const sizeKB = (f.size / 1024).toFixed(1);
+                  allLines.push(`  ${f.id}  ${f.filename}  (${sizeKB} KB, ${f.purpose})`);
+                }
+              }
+              allLines.push("");
+            } catch (err) {
+              allLines.push(`[${label}] Error: ${err.message}`);
+              allLines.push("");
+            }
           }
-          const lines = ["▣ Anthropic Files", "", `${files.length} file(s):`, ""];
-          for (const f of files) {
-            const sizeKB = (f.size / 1024).toFixed(1);
-            lines.push(`  ${f.id}  ${f.filename}  (${sizeKB} KB, ${f.purpose})`);
+          if (totalFiles === 0 && accounts.length > 0) {
+            allLines.push(`Total: No files across ${accounts.length} account(s).`);
+          } else {
+            allLines.push(`Total: ${totalFiles} file(s) across ${accounts.length} account(s).`);
           }
-          await sendCommandMessage(input.sessionID, lines.join("\n"));
+          if (accounts.length > 1) {
+            allLines.push("", "Tip: Use --account <email> to target a specific account.");
+          }
+          await sendCommandMessage(input.sessionID, allLines.join("\n"));
           return;
         }
 
+        // For all non-list actions, resolve to a single account
+        const resolved = resolveTargetAccount(targetAccountId);
+        if (!resolved) {
+          const errMsg = targetAccountId ? `Account not found: ${targetAccountId}` : "No accounts available.";
+          await sendCommandMessage(input.sessionID, `▣ Anthropic Files (error)\n\n${errMsg}`);
+          return;
+        }
+        const { account, label } = resolved;
+        const authHeaders = await getFilesAuth(account);
+
         // /anthropic files upload <path> — upload a file
         if (action === "upload") {
-          const filePath = args.slice(2).join(" ").trim();
+          const filePath = filteredArgs.slice(2).join(" ").trim();
           if (!filePath) {
-            await sendCommandMessage(input.sessionID, "▣ Anthropic Files\n\nUsage: /anthropic files upload <path>");
+            await sendCommandMessage(
+              input.sessionID,
+              "▣ Anthropic Files\n\nUsage: /anthropic files upload <path> [--account <email>]",
+            );
             return;
           }
           const resolvedPath = resolve(filePath);
@@ -2124,8 +2368,8 @@ export async function AnthropicAuthPlugin({ client }) {
           const res = await fetch(`${apiBase}/v1/files`, {
             method: "POST",
             headers: {
-              authorization: `Bearer ${token}`,
-              "anthropic-beta": "files-api-2025-04-14",
+              authorization: authHeaders.authorization,
+              "anthropic-beta": "oauth-2025-04-20,files-api-2025-04-14",
             },
             body: form,
           });
@@ -2133,35 +2377,44 @@ export async function AnthropicAuthPlugin({ client }) {
             const errBody = await res.text();
             await sendCommandMessage(
               input.sessionID,
-              `▣ Anthropic Files (error)\n\nUpload failed (HTTP ${res.status}): ${errBody}`,
+              `▣ Anthropic Files (error) [${label}]\n\nUpload failed (HTTP ${res.status}): ${errBody}`,
             );
             return;
           }
           const file = await res.json();
           const sizeKB = ((file.size || 0) / 1024).toFixed(1);
+          // Cache file_id → account mapping for auto-pinning
+          fileAccountMap.set(file.id, account.index);
           await sendCommandMessage(
             input.sessionID,
-            `▣ Anthropic Files\n\nUploaded: ${file.id}\n  Filename: ${file.filename}\n  Size: ${sizeKB} KB`,
+            `▣ Anthropic Files [${label}]\n\nUploaded: ${file.id}\n  Filename: ${file.filename}\n  Size: ${sizeKB} KB`,
           );
           return;
         }
 
         // /anthropic files get <file_id> — get file metadata
         if (action === "get" || action === "info") {
-          const fileId = args[2]?.trim();
+          const fileId = filteredArgs[2]?.trim();
           if (!fileId) {
-            await sendCommandMessage(input.sessionID, "▣ Anthropic Files\n\nUsage: /anthropic files get <file_id>");
+            await sendCommandMessage(
+              input.sessionID,
+              "▣ Anthropic Files\n\nUsage: /anthropic files get <file_id> [--account <email>]",
+            );
             return;
           }
           const res = await fetch(`${apiBase}/v1/files/${encodeURIComponent(fileId)}`, { headers: authHeaders });
           if (!res.ok) {
             const errBody = await res.text();
-            await sendCommandMessage(input.sessionID, `▣ Anthropic Files (error)\n\nHTTP ${res.status}: ${errBody}`);
+            await sendCommandMessage(
+              input.sessionID,
+              `▣ Anthropic Files (error) [${label}]\n\nHTTP ${res.status}: ${errBody}`,
+            );
             return;
           }
           const file = await res.json();
+          fileAccountMap.set(file.id, account.index);
           const lines = [
-            "▣ Anthropic Files",
+            `▣ Anthropic Files [${label}]`,
             "",
             `  ID:       ${file.id}`,
             `  Filename: ${file.filename}`,
@@ -2176,9 +2429,12 @@ export async function AnthropicAuthPlugin({ client }) {
 
         // /anthropic files delete <file_id> — delete a file
         if (action === "delete" || action === "rm") {
-          const fileId = args[2]?.trim();
+          const fileId = filteredArgs[2]?.trim();
           if (!fileId) {
-            await sendCommandMessage(input.sessionID, "▣ Anthropic Files\n\nUsage: /anthropic files delete <file_id>");
+            await sendCommandMessage(
+              input.sessionID,
+              "▣ Anthropic Files\n\nUsage: /anthropic files delete <file_id> [--account <email>]",
+            );
             return;
           }
           const res = await fetch(`${apiBase}/v1/files/${encodeURIComponent(fileId)}`, {
@@ -2187,24 +2443,28 @@ export async function AnthropicAuthPlugin({ client }) {
           });
           if (!res.ok) {
             const errBody = await res.text();
-            await sendCommandMessage(input.sessionID, `▣ Anthropic Files (error)\n\nHTTP ${res.status}: ${errBody}`);
+            await sendCommandMessage(
+              input.sessionID,
+              `▣ Anthropic Files (error) [${label}]\n\nHTTP ${res.status}: ${errBody}`,
+            );
             return;
           }
-          await sendCommandMessage(input.sessionID, `▣ Anthropic Files\n\nDeleted: ${fileId}`);
+          fileAccountMap.delete(fileId);
+          await sendCommandMessage(input.sessionID, `▣ Anthropic Files [${label}]\n\nDeleted: ${fileId}`);
           return;
         }
 
         // /anthropic files download <file_id> [output_path] — download file content
         if (action === "download" || action === "dl") {
-          const fileId = args[2]?.trim();
+          const fileId = filteredArgs[2]?.trim();
           if (!fileId) {
             await sendCommandMessage(
               input.sessionID,
-              "▣ Anthropic Files\n\nUsage: /anthropic files download <file_id> [output_path]",
+              "▣ Anthropic Files\n\nUsage: /anthropic files download <file_id> [output_path] [--account <email>]",
             );
             return;
           }
-          const outputPath = args.slice(3).join(" ").trim();
+          const outputPath = filteredArgs.slice(3).join(" ").trim();
 
           // Get file metadata first for the filename
           const metaRes = await fetch(`${apiBase}/v1/files/${encodeURIComponent(fileId)}`, {
@@ -2214,7 +2474,7 @@ export async function AnthropicAuthPlugin({ client }) {
             const errBody = await metaRes.text();
             await sendCommandMessage(
               input.sessionID,
-              `▣ Anthropic Files (error)\n\nHTTP ${metaRes.status}: ${errBody}`,
+              `▣ Anthropic Files (error) [${label}]\n\nHTTP ${metaRes.status}: ${errBody}`,
             );
             return;
           }
@@ -2229,7 +2489,7 @@ export async function AnthropicAuthPlugin({ client }) {
             const errBody = await res.text();
             await sendCommandMessage(
               input.sessionID,
-              `▣ Anthropic Files (error)\n\nDownload failed (HTTP ${res.status}): ${errBody}`,
+              `▣ Anthropic Files (error) [${label}]\n\nDownload failed (HTTP ${res.status}): ${errBody}`,
             );
             return;
           }
@@ -2238,7 +2498,7 @@ export async function AnthropicAuthPlugin({ client }) {
           const sizeKB = (buffer.length / 1024).toFixed(1);
           await sendCommandMessage(
             input.sessionID,
-            `▣ Anthropic Files\n\nDownloaded: ${meta.filename}\n  Saved to: ${savePath}\n  Size: ${sizeKB} KB`,
+            `▣ Anthropic Files [${label}]\n\nDownloaded: ${meta.filename}\n  Saved to: ${savePath}\n  Size: ${sizeKB} KB`,
           );
           return;
         }
@@ -2247,17 +2507,23 @@ export async function AnthropicAuthPlugin({ client }) {
         const helpLines = [
           "▣ Anthropic Files",
           "",
-          "Usage: /anthropic files <action>",
+          "Usage: /anthropic files <action> [--account <email|index>]",
           "",
           "Actions:",
-          "  list                          List uploaded files",
+          "  list                          List uploaded files (all accounts if no --account)",
           "  upload <path>                 Upload a file (max 350MB)",
           "  get <file_id>                 Get file metadata",
           "  delete <file_id>              Delete a file",
           "  download <file_id> [path]     Download file content",
           "",
+          "Options:",
+          "  --account <email|index>       Target a specific account (1-based index)",
+          "",
           "Supported formats: PDF, DOCX, TXT, CSV, Excel, Markdown, images",
           "Files can be referenced by file_id in Messages API requests.",
+          "",
+          "When using round-robin, file_ids are automatically pinned to the",
+          "account that owns them for Messages API requests.",
         ];
         await sendCommandMessage(input.sessionID, helpLines.join("\n"));
         return;
@@ -2584,6 +2850,39 @@ export async function AnthropicAuthPlugin({ client }) {
             await accountManager.saveToDisk();
           }
 
+          // OPENCODE_ANTHROPIC_INITIAL_ACCOUNT: pin this session to a specific account.
+          // Accepts 1-based index or email. Overrides strategy to sticky and disables
+          // syncActiveIndexFromDisk so other sessions can't override this one.
+          // Use case: terminal 1 with INITIAL_ACCOUNT=1, terminal 2 with =2.
+          const initialAccountEnv = process.env.OPENCODE_ANTHROPIC_INITIAL_ACCOUNT?.trim();
+          if (initialAccountEnv && accountManager.getAccountCount() > 1) {
+            const accounts = accountManager.getEnabledAccounts();
+            let target = null;
+
+            // Try as 1-based index
+            const asIndex = parseInt(initialAccountEnv, 10);
+            if (!isNaN(asIndex) && asIndex >= 1 && asIndex <= accounts.length) {
+              target = accounts[asIndex - 1];
+            }
+
+            // Try as email
+            if (!target) {
+              target = accounts.find((a) => a.email && a.email.toLowerCase() === initialAccountEnv.toLowerCase());
+            }
+
+            if (target && accountManager.forceCurrentIndex(target.index)) {
+              config.account_selection_strategy = "sticky";
+              initialAccountPinned = true;
+              debugLog("OPENCODE_ANTHROPIC_INITIAL_ACCOUNT: pinned to account", {
+                index: target.index + 1,
+                email: target.email,
+                strategy: "sticky (overridden)",
+              });
+            } else {
+              debugLog("OPENCODE_ANTHROPIC_INITIAL_ACCOUNT: could not resolve account", initialAccountEnv);
+            }
+          }
+
           return {
             apiKey: "",
             /**
@@ -2612,7 +2911,9 @@ export async function AnthropicAuthPlugin({ client }) {
               const transientRefreshSkips = new Set();
 
               // Sync with CLI changes at request start.
-              if (accountManager) {
+              // Skip when OPENCODE_ANTHROPIC_INITIAL_ACCOUNT pinned this session —
+              // other sessions' CLI changes must not override the pinned account.
+              if (accountManager && !initialAccountPinned) {
                 await accountManager.syncActiveIndexFromDisk();
               }
 
@@ -2620,9 +2921,42 @@ export async function AnthropicAuthPlugin({ client }) {
               // switch to the next account. If it's service-wide, return immediately.
               const maxAttempts = accountManager.getTotalAccountCount();
 
+              // File-ID account pinning: if the request body references file_ids
+              // that we've mapped to a specific account (via /anthropic files),
+              // pin the first attempt to that account so files are accessible.
+              // Without this, round-robin could route to an account that doesn't
+              // have the referenced files, causing file_not_found errors.
+              let pinnedAccount = null;
+              if (typeof requestInit.body === "string" && fileAccountMap.size > 0) {
+                try {
+                  const bodyObj = JSON.parse(requestInit.body);
+                  const fileIds = extractFileIds(bodyObj);
+                  for (const fid of fileIds) {
+                    const pinnedIndex = fileAccountMap.get(fid);
+                    if (pinnedIndex !== undefined) {
+                      const candidates = accountManager.getEnabledAccounts();
+                      pinnedAccount = candidates.find((a) => a.index === pinnedIndex) ?? null;
+                      if (pinnedAccount) {
+                        debugLog("file-id pinning: routing to account", {
+                          fileId: fid,
+                          accountIndex: pinnedIndex,
+                          email: pinnedAccount.email,
+                        });
+                        break;
+                      }
+                    }
+                  }
+                } catch {
+                  // Non-JSON body or parse error — skip pinning
+                }
+              }
+
               for (let attempt = 0; attempt < maxAttempts; attempt++) {
-                // Select account
-                const account = accountManager.getCurrentAccount(transientRefreshSkips);
+                // Select account — use pinned account on first attempt if available
+                const account =
+                  attempt === 0 && pinnedAccount && !transientRefreshSkips.has(pinnedAccount.index)
+                    ? pinnedAccount
+                    : accountManager.getCurrentAccount(transientRefreshSkips);
 
                 // Toast account usage on first use and whenever the account changes
                 if (showUsageToast && account && accountManager) {
@@ -2756,6 +3090,7 @@ export async function AnthropicAuthPlugin({ client }) {
                   enabled: signatureEmulationEnabled,
                   claudeCliVersion,
                   customBetas: config.custom_betas,
+                  strategy: config.account_selection_strategy,
                 });
                 // Execute the request
                 let response;

package/lib/accounts.mjs

@@ -193,6 +193,20 @@ export class AccountManager {
     return this.#currentIndex;
   }
 
+  /**
+   * Force the active account to a specific index.
+   * Used by OPENCODE_ANTHROPIC_INITIAL_ACCOUNT to pin a session to one account.
+   * @param {number} index
+   * @returns {boolean} Whether the index was valid and set
+   */
+  forceCurrentIndex(index) {
+    const account = this.#accounts[index];
+    if (!account || !account.enabled) return false;
+    this.#currentIndex = index;
+    this.#cursor = index;
+    return true;
+  }
+
   /**
    * Get enabled account references for internal plugin operations.
    * Returned objects are mutable managed accounts.

package/lib/config.mjs

@@ -61,7 +61,7 @@ import { homedir } from "node:os";
 
 /** @type {AnthropicAuthConfig} */
 export const DEFAULT_CONFIG = {
-  account_selection_strategy: "round-robin",
+  account_selection_strategy: "sticky",
   failure_ttl_seconds: 3600,
   debug: false,
   signature_emulation: {

package/lib/config.test.mjs

@@ -10,7 +10,7 @@ vi.mock("node:fs", () => ({
 
 describe("DEFAULT_CONFIG", () => {
   it("has expected default strategy", () => {
-    expect(DEFAULT_CONFIG.account_selection_strategy).toBe("round-robin");
+    expect(DEFAULT_CONFIG.account_selection_strategy).toBe("sticky");
   });
 
   it("has expected health score defaults", () => {
@@ -114,7 +114,7 @@ describe("loadConfig", () => {
     existsSync.mockReturnValue(true);
     readFileSync.mockReturnValue(JSON.stringify({ account_selection_strategy: "invalid" }));
     const config = loadConfig();
-    expect(config.account_selection_strategy).toBe("round-robin");
+    expect(config.account_selection_strategy).toBe("sticky");
   });
 
   it("accepts boolean debug", () => {
@@ -199,7 +199,7 @@ describe("loadConfig", () => {
     existsSync.mockReturnValue(false);
     process.env.OPENCODE_ANTHROPIC_STRATEGY = "invalid";
     const config = loadConfig();
-    expect(config.account_selection_strategy).toBe("round-robin");
+    expect(config.account_selection_strategy).toBe("sticky");
   });
 
   it("enables debug from OPENCODE_ANTHROPIC_DEBUG=1", () => {

package/lib/oauth.mjs

@@ -5,6 +5,12 @@ import { CLIENT_ID } from "./config.mjs";
 // OAuth helpers — shared between plugin (index.mjs) and CLI (cli.mjs)
 // ---------------------------------------------------------------------------
 
+const OAUTH_CONSOLE_HOST = "platform.claude.com";
+const OAUTH_MAX_HOST = "claude.ai";
+const OAUTH_REDIRECT_URI = `https://${OAUTH_CONSOLE_HOST}/oauth/code/callback`;
+const OAUTH_TOKEN_URL = `https://${OAUTH_CONSOLE_HOST}/v1/oauth/token`;
+const OAUTH_REVOKE_URL = `https://${OAUTH_CONSOLE_HOST}/v1/oauth/revoke`;
+
 function base64url(input) {
   return Buffer.from(input).toString("base64url");
 }
@@ -23,11 +29,11 @@ function generatePKCE() {
 export async function authorize(mode) {
   const pkce = generatePKCE();
 
-  const url = new URL(`https://${mode === "console" ? "console.anthropic.com" : "claude.ai"}/oauth/authorize`);
+  const url = new URL(`https://${mode === "console" ? OAUTH_CONSOLE_HOST : OAUTH_MAX_HOST}/oauth/authorize`);
   url.searchParams.set("code", "true");
   url.searchParams.set("client_id", CLIENT_ID);
   url.searchParams.set("response_type", "code");
-  url.searchParams.set("redirect_uri", "https://console.anthropic.com/oauth/code/callback");
+  url.searchParams.set("redirect_uri", OAUTH_REDIRECT_URI);
   url.searchParams.set("scope", "org:create_api_key user:profile user:inference");
   url.searchParams.set("code_challenge", pkce.challenge);
   url.searchParams.set("code_challenge_method", "S256");
@@ -46,7 +52,7 @@ export async function authorize(mode) {
  */
 export async function exchange(code, verifier) {
   const splits = code.split("#");
-  const result = await fetch("https://console.anthropic.com/v1/oauth/token", {
+  const result = await fetch(OAUTH_TOKEN_URL, {
     method: "POST",
     headers: {
       "Content-Type": "application/json",
@@ -56,7 +62,7 @@ export async function exchange(code, verifier) {
       state: splits[1],
       grant_type: "authorization_code",
       client_id: CLIENT_ID,
-      redirect_uri: "https://console.anthropic.com/oauth/code/callback",
+      redirect_uri: OAUTH_REDIRECT_URI,
       code_verifier: verifier,
     }),
   });
@@ -86,7 +92,7 @@ export async function exchange(code, verifier) {
  */
 export async function revoke(refreshToken) {
   try {
-    const resp = await fetch("https://console.anthropic.com/v1/oauth/revoke", {
+    const resp = await fetch(OAUTH_REVOKE_URL, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify({
@@ -110,7 +116,7 @@ export async function revoke(refreshToken) {
  * @throws {Error} On HTTP errors or network failures
  */
 export async function refreshToken(refreshTokenValue, options = {}) {
-  const resp = await fetch("https://console.anthropic.com/v1/oauth/token", {
+  const resp = await fetch(OAUTH_TOKEN_URL, {
     method: "POST",
     headers: { "Content-Type": "application/json" },
     body: JSON.stringify({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-anthropic-fix",
-  "version": "0.0.21",
+  "version": "0.0.23",
   "main": "./index.mjs",
   "files": [
     "index.mjs",