@code-yeongyu/senpi 2026.10.16-3 → 2026.10.16-4

package/dist/core/context-files.js

@@ -0,0 +1,175 @@
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { basename, dirname, join, sep } from "node:path";
+import chalk from "chalk";
+import { canonicalizePath, resolvePath } from "../utils/paths.js";
+import { stripBom } from "../utils/text.js";
+import { findGitPaths } from "./footer-data-provider.js";
+export const DEFAULT_CONTEXT_FILE_MAX_BYTES = 64 * 1024;
+export const DEFAULT_CONTEXT_FILES_MAX_TOTAL_BYTES = 128 * 1024;
+const MIN_USEFUL_BYTES = 1024;
+function loadContextFileFromDir(dir) {
+    const candidates = ["AGENTS.override.md", "AGENTS.md", "AGENTS.MD", "CLAUDE.md", "CLAUDE.MD"];
+    for (const filename of candidates) {
+        const filePath = join(dir, filename);
+        if (existsSync(filePath)) {
+            try {
+                if (!statSync(filePath).isFile()) {
+                    continue;
+                }
+                return {
+                    path: filePath,
+                    content: stripBom(readFileSync(filePath, "utf-8")),
+                };
+            }
+            catch (error) {
+                console.error(chalk.yellow(`Warning: Could not read ${filePath}: ${error}`));
+            }
+        }
+    }
+    return null;
+}
+/**
+ * The main repo's context file that a nested linked worktree's own copy shadows: both
+ * occupy the same logical repository scope, so loading both applies that context twice. Returns
+ * undefined when nothing is shadowed, leaving normal ancestor inheritance alone.
+ *
+ * Returned canonicalized (realpath), because `git worktree add` writes the `.git`
+ * file's `gitdir:` target in realpath form while cwd may still be symlinked
+ * (macOS `/tmp` -> `/private/tmp`).
+ */
+function findShadowedContextFile(cwd) {
+    const gitPaths = findGitPaths(cwd);
+    if (!gitPaths)
+        return undefined;
+    const commonGitDir = canonicalizePath(gitPaths.commonGitDir);
+    const worktreeRoot = canonicalizePath(gitPaths.repoDir);
+    const mainRepoRoot = dirname(commonGitDir);
+    // False for an ordinary repo, where the two are the same dir, and for a sibling
+    // worktree (`git worktree add ../feat`), whose main repo is not an ancestor.
+    if (!worktreeRoot.startsWith(`${mainRepoRoot}${sep}`))
+        return undefined;
+    // dirname of the common git dir is the main worktree root only when that dir is
+    // itself checked out from the same repo. In a bare layout (`proj/.bare` +
+    // `proj/main`) it is just the directory holding `.bare`, which tracks nothing; a
+    // submodule's gitdir has no `commondir`, so it lands under `.git/modules`.
+    if (canonicalizePath(join(mainRepoRoot, ".git")) !== commonGitDir)
+        return undefined;
+    const worktreeContextFile = loadContextFileFromDir(worktreeRoot);
+    return worktreeContextFile ? join(mainRepoRoot, basename(worktreeContextFile.path)) : undefined;
+}
+function kib(bytes) {
+    const value = bytes / 1024;
+    return Number.isInteger(value) ? `${value} KiB` : `${value.toFixed(1)} KiB`;
+}
+function utf8Prefix(content, maxBytes) {
+    if (maxBytes <= 0)
+        return "";
+    const bytes = Buffer.from(content, "utf8");
+    let end = Math.min(maxBytes, bytes.length);
+    while (end > 0 && end < bytes.length && ((bytes[end] ?? 0) & 0xc0) === 0x80)
+        end--;
+    const newline = bytes.lastIndexOf(10, end - 1);
+    if (newline >= maxBytes * 0.75)
+        end = newline + 1;
+    return bytes.subarray(0, end).toString("utf8");
+}
+function positiveLimit(value, fallback) {
+    return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.floor(value) : fallback;
+}
+/**
+ * Bound what the context files add to every request. Files are given budget nearest-first
+ * (the cwd's file before its ancestors, the global file last), so the most specific
+ * instructions survive; every cut or skipped file is named in a warning.
+ */
+function applyContextFileLimits(files, limits) {
+    const perFile = positiveLimit(limits.maxBytesPerFile, DEFAULT_CONTEXT_FILE_MAX_BYTES);
+    const total = positiveLimit(limits.maxTotalBytes, DEFAULT_CONTEXT_FILES_MAX_TOTAL_BYTES);
+    const limitText = `limit ${kib(perFile)} per file, ${kib(total)} total; raise contextFiles.maxBytesPerFile / contextFiles.maxTotalBytes in settings to load more`;
+    const kept = [];
+    const diagnostics = [];
+    let remaining = total;
+    for (const file of [...files].reverse()) {
+        const size = Buffer.byteLength(file.content, "utf8");
+        const allowed = Math.min(perFile, remaining);
+        if (size <= allowed) {
+            kept.unshift(file);
+            remaining -= size;
+            continue;
+        }
+        if (allowed < MIN_USEFUL_BYTES) {
+            const reason = perFile < MIN_USEFUL_BYTES ? "the per-file limit is too small" : "nearer context files used the budget";
+            diagnostics.push({
+                type: "warning",
+                category: "size-limit",
+                path: file.path,
+                message: `Context file (${kib(size)}) was not loaded: ${reason} (${limitText}).`,
+            });
+            continue;
+        }
+        const note = `\n\n[This file was truncated from ${kib(size)}.]`;
+        const contentBudget = allowed - Buffer.byteLength(note);
+        let prefix = utf8Prefix(file.content, contentBudget);
+        let content;
+        while (true) {
+            let openFence;
+            for (const match of prefix.matchAll(/^[ \t]*(`{3,}|~{3,})([^\n]*)$/gm)) {
+                const marker = match[1];
+                if (!marker)
+                    continue;
+                if (openFence === undefined)
+                    openFence = marker;
+                else if (marker[0] === openFence[0] && marker.length >= openFence.length && match[2]?.trim() === "") {
+                    openFence = undefined;
+                }
+            }
+            const closingFence = openFence ? `${prefix.endsWith("\n") ? "" : "\n"}${openFence}\n` : "";
+            content = `${prefix}${closingFence}${note}`;
+            if (Buffer.byteLength(content) <= allowed)
+                break;
+            // A longer closing marker can expose another opener when the prefix shrinks.
+            prefix = utf8Prefix(prefix, Math.max(0, contentBudget - Buffer.byteLength(closingFence)));
+        }
+        const loaded = Buffer.byteLength(prefix, "utf8");
+        diagnostics.push({
+            type: "warning",
+            category: "size-limit",
+            path: file.path,
+            message: `Context file is ${kib(size)}; only the first ${kib(loaded)} was loaded (${limitText}).`,
+        });
+        kept.unshift({
+            path: file.path,
+            content,
+        });
+        remaining -= Buffer.byteLength(content);
+    }
+    return Object.assign(kept, { diagnostics });
+}
+export function loadProjectContextFiles(options) {
+    const resolvedCwd = resolvePath(options.cwd);
+    const resolvedAgentDir = resolvePath(options.agentDir);
+    const contextFiles = [];
+    const seenPaths = new Set();
+    const globalContext = loadContextFileFromDir(resolvedAgentDir);
+    if (globalContext) {
+        contextFiles.push(globalContext);
+        seenPaths.add(globalContext.path);
+    }
+    const ancestorContextFiles = [];
+    const shadowedContextFile = findShadowedContextFile(resolvedCwd);
+    let currentDir = resolvedCwd;
+    while (true) {
+        const contextFile = loadContextFileFromDir(currentDir);
+        const isShadowed = shadowedContextFile !== undefined && canonicalizePath(contextFile?.path ?? "") === shadowedContextFile;
+        if (contextFile && !isShadowed && !seenPaths.has(contextFile.path)) {
+            ancestorContextFiles.unshift(contextFile);
+            seenPaths.add(contextFile.path);
+        }
+        const parentDir = dirname(currentDir);
+        if (parentDir === currentDir)
+            break;
+        currentDir = parentDir;
+    }
+    contextFiles.push(...ancestorContextFiles);
+    return applyContextFileLimits(contextFiles, options);
+}
+//# sourceMappingURL=context-files.js.map

package/dist/core/diagnostics.d.ts

@@ -8,6 +8,7 @@ export interface ResourceCollision {
 }
 export interface ResourceDiagnostic {
     type: "warning" | "error" | "collision";
+    category?: "size-limit";
     message: string;
     path?: string;
     collision?: ResourceCollision;

package/dist/core/extensions/builtin/anthropic-subscription/account-command.js

@@ -3,7 +3,7 @@ import { describeModelBlocks } from "../../../credential-pool/model-scope.js";
 import { accountDisplayNameCommand, promptAccountDisplayName } from "../account-display-name.js";
 import { createExtensionLoginInteraction, LOGIN_CANCELLED_MESSAGE } from "../oauth-login-interaction.js";
 import { emitProviderAccountsChanged } from "./account-events.js";
-import { ANTHROPIC_SUBSCRIPTION_PROVIDER_ID, pinProviderAccount, removeProviderAccount } from "./account-management.js";
+import { ANTHROPIC_SUBSCRIPTION_PROVIDER_ID, pinProviderAccount, removeProviderAccount, unblockProviderAccount, } from "./account-management.js";
 import { emptyCredential, listAccounts } from "./accounts.js";
 import { selectAccount } from "./affinity.js";
 import { loadAnthropicSubscriptionProviderSettingsFromDisk, } from "./settings.js";
@@ -65,7 +65,7 @@ export function registerClaudeAccountCommand(pi, deps = {}) {
     });
     pi.registerCommand("claude-account", {
         description: "List and manage Anthropic Subscription accounts.",
-        argumentHint: "[add | remove <id> | pin <id> | unpin | rename <id> <display name...> | clear-name <id>]",
+        argumentHint: "[add | remove <id> | pin <id> | unpin | unblock <id> | rename <id> <display name...> | clear-name <id>]",
         requiresArguments: false,
         handler: async (rawArgs, ctx) => {
             if (await accountDisplayNameCommand(ctx, ANTHROPIC_SUBSCRIPTION_PROVIDER_ID, rawArgs))
@@ -92,7 +92,11 @@ export function registerClaudeAccountCommand(pi, deps = {}) {
                 await unpinAccount(ctx);
                 return;
             }
-            ctx.ui.notify("Usage: /claude-account [add | remove <id> | pin <id> | unpin | rename <id> <display name...> | clear-name <id>]", "error");
+            if (action === "unblock") {
+                await unblockNamedAccount(ctx, args[1], environment);
+                return;
+            }
+            ctx.ui.notify("Usage: /claude-account [add | remove <id> | pin <id> | unpin | unblock <id> | rename <id> <display name...> | clear-name <id>]", "error");
         },
     });
 }
@@ -194,6 +198,25 @@ async function pinNamedAccount(ctx, name, environment) {
         ctx.ui.notify(error instanceof Error ? error.message : String(error), "error");
     }
 }
+async function unblockNamedAccount(ctx, name, environment) {
+    if (!name) {
+        ctx.ui.notify("Usage: /claude-account unblock <name>", "error");
+        return;
+    }
+    if (!readAccounts(ctx, environment).accounts.some((account) => account.name === name)) {
+        return accountError(ctx, name);
+    }
+    try {
+        const env = new Proxy({}, { get: (_target, key) => environment(String(key)) });
+        const lifted = await unblockProviderAccount(ctx.modelRegistry.authStorage, ANTHROPIC_SUBSCRIPTION_PROVIDER_ID, name, env);
+        ctx.ui.notify(lifted
+            ? `Unblocked Anthropic Subscription account: ${name}. The next turn may use it.`
+            : `Anthropic Subscription account '${name}' has no usage block to lift.`, "info");
+    }
+    catch (error) {
+        ctx.ui.notify(error instanceof Error ? error.message : String(error), "error");
+    }
+}
 async function unpinAccount(ctx) {
     const credential = asCredential(ctx.modelRegistry.authStorage.get(ANTHROPIC_SUBSCRIPTION_PROVIDER_ID));
     if (!credential?.pinned) {

package/dist/core/extensions/builtin/anthropic-subscription/account-management.d.ts

@@ -11,4 +11,9 @@ export type ProviderAccountSummary = {
 export declare function getProviderAccounts(storage: AuthStorage, provider: string, env?: NodeJS.ProcessEnv): ProviderAccountSummary[];
 export declare function pinProviderAccount(storage: AuthStorage, provider: string, name: string | null, env?: NodeJS.ProcessEnv): Promise<void>;
 export declare function removeProviderAccount(storage: AuthStorage, provider: string, name: string): Promise<void>;
+/**
+ * Lifts a usage or rate-limit block the user knows is wrong (extra usage bought, a misread reset).
+ * Auth blocks stay: only a login or the re-probe can lift those. Returns whether a block was lifted.
+ */
+export declare function unblockProviderAccount(storage: AuthStorage, provider: string, name: string, env?: NodeJS.ProcessEnv): Promise<boolean>;
 //# sourceMappingURL=account-management.d.ts.map

package/dist/core/extensions/builtin/anthropic-subscription/account-management.js

@@ -1,6 +1,7 @@
 import { accountDisplayName } from "@earendil-works/pi-ai/auth/pool/slots";
 import { emitProviderAccountsChanged } from "./account-events.js";
 import { emptyCredential, listAccounts, pinAccount, removeAccount, } from "./accounts.js";
+import { forgetSessionBlocksFor } from "./failover.js";
 export const ANTHROPIC_SUBSCRIPTION_PROVIDER_ID = "anthropic-subscription";
 export function getProviderAccounts(storage, provider, env = process.env) {
     assertManagedProvider(provider);
@@ -50,6 +51,45 @@ export async function removeProviderAccount(storage, provider, name) {
     });
     emitProviderAccountsChanged(provider);
 }
+/**
+ * Lifts a usage or rate-limit block the user knows is wrong (extra usage bought, a misread reset).
+ * Auth blocks stay: only a login or the re-probe can lift those. Returns whether a block was lifted.
+ */
+export async function unblockProviderAccount(storage, provider, name, env = process.env) {
+    assertManagedProvider(provider);
+    let lifted = false;
+    await storage.modify(provider, async (current) => {
+        const credential = credentialFrom(current);
+        const account = listAccounts(credential, (key) => env[key]).find((candidate) => candidate.name === name);
+        if (!account)
+            throw new Error(`Provider account not found: ${name}`);
+        if (account.blockedUntil === undefined || account.blockReason === "auth_error")
+            return current;
+        lifted = true;
+        const state = credential.slotState?.[name];
+        return {
+            ...credential,
+            ...(state === undefined
+                ? {}
+                : {
+                    slotState: {
+                        ...credential.slotState,
+                        [name]: state.modelBlocks ? { modelBlocks: state.modelBlocks } : {},
+                    },
+                }),
+            accounts: (credential.accounts ?? []).map((candidate) => {
+                if (candidate.name !== name)
+                    return candidate;
+                const { blockedUntil: _blockedUntil, blockReason: _blockReason, blockedAt: _blockedAt, ...rest } = candidate;
+                return rest;
+            }),
+        };
+    });
+    const sessionScoped = forgetSessionBlocksFor(name);
+    if (lifted || sessionScoped)
+        emitProviderAccountsChanged(provider);
+    return lifted || sessionScoped;
+}
 function assertManagedProvider(provider) {
     if (provider !== ANTHROPIC_SUBSCRIPTION_PROVIDER_ID) {
         throw new Error(`Provider account management is unavailable for: ${provider}`);

package/dist/core/extensions/builtin/anthropic-subscription/accounts.d.ts

@@ -10,6 +10,8 @@ export type AccountSlot = {
     source: "login" | "import" | "env";
     blockedUntil?: number;
     blockReason?: string;
+    /** When the current block was stored, so a turn that started earlier never clears it (senpi#3462). */
+    blockedAt?: number;
     /** Rate limits that bind one model family on this account, not the account (senpi#2555). */
     modelBlocks?: ModelBlocks;
     /**
@@ -23,6 +25,7 @@ export type AccountSlot = {
 export type SlotState = Record<string, {
     blockedUntil?: number;
     blockReason?: string;
+    blockedAt?: number;
     modelBlocks?: ModelBlocks;
 }>;
 export type AnthropicSubscriptionCredential = OAuthCredential & {

package/dist/core/extensions/builtin/anthropic-subscription/accounts.js

@@ -57,7 +57,7 @@ export function upsertAccount(credential, slot) {
     const existing = storedSlots(credential).find((candidate) => candidate.name === slot.name);
     if (!existing)
         return { ...credential, accounts: [...storedSlots(credential), slot] };
-    const { blockedUntil: _blockedUntil, blockReason: _blockReason, modelBlocks: _modelBlocks, authRecoveryGrant: _authRecoveryGrant, ...identity } = existing;
+    const { blockedUntil: _blockedUntil, blockReason: _blockReason, blockedAt: _blockedAt, modelBlocks: _modelBlocks, authRecoveryGrant: _authRecoveryGrant, ...identity } = existing;
     const refreshed = {
         ...identity,
         access: slot.access,

package/dist/core/extensions/builtin/anthropic-subscription/affinity.js

@@ -47,7 +47,7 @@ export function clearExpiredBlocks(accounts, now = Date.now()) {
     return accounts.map((account) => {
         let available = account;
         if (account.blockReason !== undefined && (account.blockedUntil === undefined || account.blockedUntil <= now)) {
-            const { blockedUntil: _blockedUntil, blockReason: _blockReason, ...rest } = account;
+            const { blockedUntil: _blockedUntil, blockReason: _blockReason, blockedAt: _blockedAt, ...rest } = account;
             available = rest;
         }
         if (available.modelBlocks === undefined)

package/dist/core/extensions/builtin/anthropic-subscription/auth-lane.js

@@ -228,6 +228,7 @@ export async function* queryWithAuthLane(input) {
             });
         },
         classify: classifySdkError,
+        ...(input.sessionId === undefined ? {} : { sessionKey: input.sessionId }),
         onLongContextRefused: () => markLongContextRefused(),
         store: pool.store,
         providerId: ANTHROPIC_SUBSCRIPTION_PROVIDER_ID,

package/dist/core/extensions/builtin/anthropic-subscription/failover.d.ts

@@ -3,7 +3,7 @@ import type { AccountSlot } from "./accounts.ts";
 import type { SdkErrorClassification } from "./errors.ts";
 export declare const MAX_RATE_LIMIT_BLOCK_MS: number;
 export declare const DEFAULT_RATE_LIMIT_BLOCK_MS = 60000;
-/** Same-account retries per turn for a transient failure (overload, network, server error) before rotating. */
+/** Same-account retries per turn for a transient failure (overload, network, server error); it never rotates. */
 export declare const TRANSIENT_RETRIES_PER_TURN = 2;
 export declare const TRANSIENT_RETRY_DELAY_MS = 1000;
 export declare const TURN_RETRY_SUPPRESSION_PREFIX = "senpi:no-turn-retry:";
@@ -33,7 +33,11 @@ export type FailoverOptions<TEvent> = {
     signal?: AbortSignal;
     /** Records a refused 1M window so the retry, built by `runAttempt`, requests the standard one. */
     onLongContextRefused?: () => void;
+    /** The session this turn belongs to: blocks that bind only this session are remembered under it. */
+    sessionKey?: string;
 };
+/** `/claude-account unblock` lifts the account's session-scoped blocks in every session too. Returns whether one was lifted. */
+export declare function forgetSessionBlocksFor(name: string): boolean;
 export declare class ClassifiedSdkError extends Error {
     readonly classification: SdkErrorClassification;
     readonly original: unknown;
@@ -41,10 +45,11 @@ export declare class ClassifiedSdkError extends Error {
     constructor(classification: SdkErrorClassification, original: unknown, suppressTurnRetry: boolean);
 }
 /**
- * Runs one attempt per account, plus at most TRANSIENT_RETRIES_PER_TURN same-account retries
- * for a transient failure (and one retry on newer stored credentials). A retry is transparent only before a
- * text, thinking, or tool-call event reaches the caller; post-delta failures
- * are marked so AgentSession never replays the partial turn.
+ * Runs one attempt per account for account-level failures (a limit, billing, auth), plus at most
+ * TRANSIENT_RETRIES_PER_TURN same-account retries for a transient failure, after which the turn fails on
+ * that account instead of rotating (and one retry on newer stored credentials). A retry is transparent only
+ * before a text, thinking, or tool-call event reaches the caller; post-delta failures are marked so
+ * AgentSession never replays the partial turn.
  */
 export declare function runFailover<TEvent>(options: FailoverOptions<TEvent>): AsyncGenerator<TEvent>;
 //# sourceMappingURL=failover.d.ts.map

package/dist/core/extensions/builtin/anthropic-subscription/failover.js

@@ -1,13 +1,95 @@
 import { AUTH_BLOCK_REPROBE_MS } from "../../../credential-pool/auth-reprobe.js";
-import { activeModelBlockUntil, mergeModelBlocks, modelBlockKey, withModelBlock, } from "../../../credential-pool/model-scope.js";
+import { activeModelBlockUntil, mergeModelBlocks, modelBlockKey, pruneModelBlocks, withModelBlock, } from "../../../credential-pool/model-scope.js";
 import { usageLimitResetMs } from "../../../credential-pool/reset-time.js";
 import { clearExpiredBlocks } from "./affinity.js";
+import { isConfirmedAccountUsageLimit, usageLimitBlockMs } from "./usage-limit-block.js";
 export const MAX_RATE_LIMIT_BLOCK_MS = 48 * 60 * 60 * 1_000;
 export const DEFAULT_RATE_LIMIT_BLOCK_MS = 60_000;
-/** Same-account retries per turn for a transient failure (overload, network, server error) before rotating. */
+/** Same-account retries per turn for a transient failure (overload, network, server error); it never rotates. */
 export const TRANSIENT_RETRIES_PER_TURN = 2;
 export const TRANSIENT_RETRY_DELAY_MS = 1_000;
 export const TURN_RETRY_SUPPRESSION_PREFIX = "senpi:no-turn-retry:";
+/**
+ * Blocks that bind only the session that hit them, in memory for the process: a plain rate limit and a
+ * one-model limit. Another session on the same account keeps using it and finds out on its own request.
+ */
+const sessionBlocks = new Map();
+/**
+ * Only a verdict that the account itself cannot serve anyone is shared through the credential store: a
+ * confirmed account-level usage limit, a billing or organization refusal, or a rejected token. Moving
+ * every session off the account is right then, since leaving them would retry a dead account. A plain
+ * rate limit, an overload or a one-model limit is not that verdict, so it never moves other sessions
+ * (senpi#3466).
+ */
+function isSharedVerdict(classification, error) {
+    if (classification.kind === "auth_error" ||
+        classification.kind === "billing" ||
+        classification.kind === "org_not_allowed")
+        return true;
+    return (classification.kind === "rate_limit" &&
+        classification.modelFamily === undefined &&
+        isConfirmedAccountUsageLimit(errorText(error)));
+}
+function rememberSessionBlock(sessionKey, account) {
+    if (sessionKey === undefined)
+        return;
+    const blocks = sessionBlocks.get(sessionKey) ?? new Map();
+    blocks.set(account.name, {
+        blockedUntil: account.blockedUntil,
+        blockReason: account.blockReason,
+        blockedAt: account.blockedAt,
+        modelBlocks: account.modelBlocks,
+    });
+    sessionBlocks.set(sessionKey, blocks);
+}
+/** Drops elapsed session blocks for every session, so sessions that ended leave nothing behind. */
+function pruneSessionBlocks(now) {
+    for (const [sessionKey, blocks] of sessionBlocks) {
+        for (const [name, block] of blocks) {
+            if ((block.blockedUntil ?? 0) <= now && pruneModelBlocks(block.modelBlocks, now) === undefined)
+                blocks.delete(name);
+        }
+        if (blocks.size === 0)
+            sessionBlocks.delete(sessionKey);
+    }
+}
+function withSessionBlocks(accounts, sessionKey, now) {
+    pruneSessionBlocks(now);
+    const blocks = sessionKey === undefined ? undefined : sessionBlocks.get(sessionKey);
+    if (blocks === undefined)
+        return [...accounts];
+    return accounts.map((account) => {
+        const own = blocks.get(account.name);
+        if (own === undefined)
+            return account;
+        const later = (own.blockedUntil ?? 0) > (account.blockedUntil ?? 0);
+        return {
+            ...account,
+            ...(later ? { blockedUntil: own.blockedUntil, blockReason: own.blockReason, blockedAt: own.blockedAt } : {}),
+            modelBlocks: mergeModelBlocks(account.modelBlocks, own.modelBlocks, 0),
+        };
+    });
+}
+function forgetSessionBlock(sessionKey, name) {
+    if (sessionKey === undefined)
+        return;
+    const blocks = sessionBlocks.get(sessionKey);
+    if (!blocks?.delete(name))
+        return;
+    if (blocks.size === 0)
+        sessionBlocks.delete(sessionKey);
+}
+/** `/claude-account unblock` lifts the account's session-scoped blocks in every session too. Returns whether one was lifted. */
+export function forgetSessionBlocksFor(name) {
+    let lifted = false;
+    for (const [sessionKey, blocks] of [...sessionBlocks]) {
+        if (!blocks.has(name))
+            continue;
+        lifted = true;
+        forgetSessionBlock(sessionKey, name);
+    }
+    return lifted;
+}
 export class ClassifiedSdkError extends Error {
     constructor(classification, original, suppressTurnRetry) {
         const detail = original instanceof Error ? original.message : String(original);
@@ -53,7 +135,7 @@ function retryAfterMs(error) {
 }
 function blockedAccount(account, classification, now, attempt, baseBlockMs, error, model) {
     if (classification.kind === "auth_error") {
-        return { ...account, blockedUntil: now + AUTH_BLOCK_REPROBE_MS, blockReason: "auth_error" };
+        return { ...account, blockedUntil: now + AUTH_BLOCK_REPROBE_MS, blockReason: "auth_error", blockedAt: now };
     }
     const fallback = Math.min(MAX_RATE_LIMIT_BLOCK_MS, baseBlockMs * 2 ** attempt);
     if (classification.modelFamily !== undefined && model !== undefined) {
@@ -64,8 +146,45 @@ function blockedAccount(account, classification, now, attempt, baseBlockMs, erro
         const key = modelBlockKey(classification.modelFamily, model);
         return { ...account, modelBlocks: withModelBlock(account.modelBlocks, key, now + duration, now) };
     }
-    const duration = Math.min(MAX_RATE_LIMIT_BLOCK_MS, retryAfterMs(error) ?? fallback);
-    return { ...account, blockedUntil: now + duration, blockReason: classification.kind };
+    // A spent account is out until its limit resets, capped at the limit's own window; a fixed
+    // short block sent a pinned account back to the same limit every minute (senpi#3462).
+    const hinted = retryAfterMs(error) ?? usageLimitBlockMs(errorText(error), account.name, now);
+    const duration = Math.min(MAX_RATE_LIMIT_BLOCK_MS, hinted ?? fallback);
+    return { ...account, blockedUntil: now + duration, blockReason: classification.kind, blockedAt: now };
+}
+/**
+ * An account that just served a turn is not spent: a limit block stored before the turn started (a
+ * misread reset, a stale failure) is cleared so it cannot hold a working account out. A block stored
+ * after the turn started is newer evidence than this success and stays. Auth blocks keep their re-probe.
+ */
+async function clearBlockAfterSuccess(store, providerId, name, startedAt) {
+    const clearable = (slot) => slot?.blockedUntil !== undefined && slot.blockReason !== "auth_error" && (slot.blockedAt ?? 0) <= startedAt;
+    const stored = await store.read(providerId);
+    if (stored?.type !== "oauth")
+        return;
+    const read = stored;
+    const slot = read.accounts?.find((account) => account.name === name) ?? read.slotState?.[name];
+    if (!clearable(slot))
+        return;
+    await store.modify(providerId, async (current) => {
+        if (current?.type !== "oauth")
+            return current;
+        const credential = current;
+        const state = credential.slotState?.[name];
+        const slotState = state === undefined || !clearable(state)
+            ? credential.slotState
+            : { ...credential.slotState, [name]: { ...(state.modelBlocks ? { modelBlocks: state.modelBlocks } : {}) } };
+        return {
+            ...credential,
+            ...(slotState === undefined ? {} : { slotState }),
+            accounts: (credential.accounts ?? []).map((account) => {
+                if (account.name !== name || !clearable(account))
+                    return account;
+                const { blockedUntil: _blockedUntil, blockReason: _blockReason, blockedAt: _blockedAt, ...rest } = account;
+                return rest;
+            }),
+        };
+    });
 }
 function isTransient(classification) {
     return classification.kind === "overloaded" || classification.kind === "other";
@@ -111,6 +230,7 @@ async function persistBlock(store, providerId, account, now) {
                     [account.name]: {
                         blockedUntil: account.blockedUntil,
                         blockReason: account.blockReason,
+                        ...(account.blockedAt === undefined ? {} : { blockedAt: account.blockedAt }),
                         // Union with what a concurrent request stored meanwhile, later expiry winning.
                         modelBlocks: mergeModelBlocks(credential.slotState?.[account.name]?.modelBlocks, account.modelBlocks, now),
                     },
@@ -129,6 +249,7 @@ async function persistBlock(store, providerId, account, now) {
                 ...existing,
                 blockedUntil: account.blockedUntil,
                 blockReason: account.blockReason,
+                ...(account.blockedAt === undefined ? {} : { blockedAt: account.blockedAt }),
                 modelBlocks: mergeModelBlocks(existing.modelBlocks, account.modelBlocks, now),
             }
             : existing);
@@ -142,15 +263,16 @@ function usable(account, now, model) {
         activeModelBlockUntil(account.modelBlocks, model, now) === undefined);
 }
 /**
- * Runs one attempt per account, plus at most TRANSIENT_RETRIES_PER_TURN same-account retries
- * for a transient failure (and one retry on newer stored credentials). A retry is transparent only before a
- * text, thinking, or tool-call event reaches the caller; post-delta failures
- * are marked so AgentSession never replays the partial turn.
+ * Runs one attempt per account for account-level failures (a limit, billing, auth), plus at most
+ * TRANSIENT_RETRIES_PER_TURN same-account retries for a transient failure, after which the turn fails on
+ * that account instead of rotating (and one retry on newer stored credentials). A retry is transparent only
+ * before a text, thinking, or tool-call event reaches the caller; post-delta failures are marked so
+ * AgentSession never replays the partial turn.
  */
 export async function* runFailover(options) {
     const now = options.now ?? Date.now;
     const baseBlockMs = options.baseBlockMs ?? DEFAULT_RATE_LIMIT_BLOCK_MS;
-    let accounts = clearExpiredBlocks(options.accounts, now());
+    let accounts = clearExpiredBlocks(withSessionBlocks(options.accounts, options.sessionKey, now()), now());
     let lastError;
     const retriedOnStoredMaterial = new Set();
     let transientRetriesUsed = 0;
@@ -163,6 +285,8 @@ export async function* runFailover(options) {
         retryAccountName = undefined;
         const account = { ...(retrySlot ?? options.selectFn(accounts)) };
         let visibleDeltaEmitted = false;
+        let completed = false;
+        const startedAt = now();
         try {
             const attemptStream = await options.runAttempt(account);
             for await (const event of attemptStream) {
@@ -172,7 +296,7 @@ export async function* runFailover(options) {
                 visibleDeltaEmitted ||= (options.isVisibleDelta ?? defaultIsVisibleDelta)(event);
                 yield event;
             }
-            return;
+            completed = true;
         }
         catch (error) {
             const classification = options.classify(error);
@@ -191,11 +315,14 @@ export async function* runFailover(options) {
                 attempt--;
                 continue;
             }
-            // A transient failure says nothing about the account, and on the config-dir lane moving
-            // to another account re-sends the whole conversation (senpi#2891): retry it in place first.
-            // The budget is per turn, not per account: an outage that fails every account must not
-            // multiply into retries on each of them.
-            if (!visibleDeltaEmitted && isTransient(classification) && transientRetriesUsed < TRANSIENT_RETRIES_PER_TURN) {
+            // A transient failure says nothing about the account: it is retried in place a bounded
+            // number of times, then the turn fails on this account and the session's own retry and
+            // model fallback take over. It never blocks or rotates the account: moving to another
+            // account writes the whole conversation to a cold prompt cache, and a persisted block would
+            // move every other session off a healthy account too (senpi#2891, senpi#3466).
+            if (isTransient(classification)) {
+                if (visibleDeltaEmitted || transientRetriesUsed >= TRANSIENT_RETRIES_PER_TURN)
+                    throw classified;
                 const delayMs = TRANSIENT_RETRY_DELAY_MS * 2 ** transientRetriesUsed;
                 transientRetriesUsed += 1;
                 try {
@@ -209,7 +336,12 @@ export async function* runFailover(options) {
                 continue;
             }
             const blocked = blockedAccount(account, classification, now(), attempt, baseBlockMs, error, options.model);
-            const superseded = await persistBlock(options.store, options.providerId, blocked, now());
+            // With no session to hold it, a block is shared as before: dropping it would re-send every
+            // sessionless request to the spent account until its window resets.
+            const shared = isSharedVerdict(classification, error) || options.sessionKey === undefined;
+            if (!shared)
+                rememberSessionBlock(options.sessionKey, blocked);
+            const superseded = shared ? await persistBlock(options.store, options.providerId, blocked, now()) : undefined;
             if (superseded &&
                 !visibleDeltaEmitted &&
                 usable(superseded, now(), options.model) &&
@@ -239,6 +371,15 @@ export async function* runFailover(options) {
             if (visibleDeltaEmitted)
                 throw classified;
         }
+        if (completed) {
+            forgetSessionBlock(options.sessionKey, account.name);
+            // Outside the attempt's try: clearing is best-effort hygiene after a finished turn, so a store
+            // failure is logged and the block stays for the next success; it never fails or replays the turn.
+            await clearBlockAfterSuccess(options.store, options.providerId, account.name, startedAt).catch((error) => {
+                process.stderr.write(`senpi anthropic-subscription: could not clear a stored block on ${account.name}: ${error instanceof Error ? error.message : String(error)}\n`);
+            });
+            return;
+        }
     }
     throw lastError ?? new Error("Anthropic Subscription failover exhausted without an attempt");
 }