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

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");
 }

package/dist/core/extensions/builtin/anthropic-subscription/usage-limit-block.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Claude Code's own verdict that the account's subscription is spent: its anchored usage-limit prose
+ * or its structured terminal reason, under no status other than 429 (senpi#3462, senpi#3466).
+ */
+export declare function isConfirmedAccountUsageLimit(text: string): boolean;
+/**
+ * How long a spent account stays blocked: until the reset its limit names, or the reset its spent
+ * window reported, never past the window the limit belongs to. Undefined when the error is not
+ * Claude Code's account usage limit or names no reset, so the caller keeps its short default
+ * (senpi#3462).
+ */
+export declare function usageLimitBlockMs(text: string, accountName: string, now: number): number | undefined;
+//# sourceMappingURL=usage-limit-block.d.ts.map

package/dist/core/extensions/builtin/anthropic-subscription/usage-limit-block.js

@@ -0,0 +1,89 @@
+import { usageLimitResetMs } from "../../../credential-pool/reset-time.js";
+import { subscriptionLimits } from "../../../subscription-limits/limit-store.js";
+// The subscription-limit store keys accounts by this provider id (auth-attempt.ts).
+const PROVIDER = "anthropic-subscription";
+const HOUR_MS = 60 * 60 * 1_000;
+/**
+ * Claude Code's own account usage-limit errors, anchored at the start of the message: "You've hit
+ * your session limit · resets 3pm", "You've reached your 5-hour limit", "Claude AI usage limit
+ * reached". Only a window word Claude Code uses may stand before "limit", so a context or rate
+ * limit, a warning ("approaching your usage limit") or ordinary prose never takes a long block.
+ */
+const CLAUDE_USAGE_LIMIT = /^(?:You['\u2019]ve|You have) (?:hit|reached) your (?:(session|weekly|daily|monthly|\d+-hour|usage) )?limit(?=$|\s*[\u00b7\u2219.,{(]|\s+resets?\b)|^Claude AI usage limit reached\b/i;
+/**
+ * Claude Code's structured terminal reason for a spent subscription. `rapid_refill_breaker` is a short burst
+ * breaker, not a spent account, so it keeps the short, session-scoped block (senpi#3466).
+ */
+const TERMINAL_LIMIT_REASON = /\bblocking_limit\b/;
+/** A status the error names; a usage limit is a 429, so any other status is not one. */
+const NAMED_STATUS = /\b(?:HTTP|status(?: code)?)\s*(\d{3})\b/i;
+/** The longest a block may last for each window word: a reset read past it is a misread. */
+const WINDOW_MS = {
+    session: 5 * HOUR_MS,
+    daily: 24 * HOUR_MS,
+    weekly: 7 * 24 * HOUR_MS,
+    monthly: 31 * 24 * HOUR_MS,
+};
+/** A limit that names no window is capped at the shortest subscription window. */
+const UNNAMED_WINDOW_MS = 5 * HOUR_MS;
+function namedWindowMs(word) {
+    if (word === undefined)
+        return undefined;
+    const lower = word.toLowerCase();
+    const hours = /^(\d+)-hour$/.exec(lower);
+    if (hours)
+        return Number(hours[1]) * HOUR_MS;
+    return WINDOW_MS[lower];
+}
+/** The latest-resetting fully used window the SDK last reported for this account. */
+function spentWindow(accountName, now) {
+    const limits = subscriptionLimits
+        .snapshot()
+        .find((entry) => entry.provider === PROVIDER && entry.account === accountName);
+    let spent;
+    for (const window of limits?.windows ?? []) {
+        if (window.usedPercent < 100 || window.resetsAt === undefined)
+            continue;
+        const resetsAt = Date.parse(window.resetsAt);
+        if (!Number.isFinite(resetsAt) || resetsAt <= now)
+            continue;
+        if (spent === undefined || resetsAt - now > spent.resetMs) {
+            spent = {
+                resetMs: resetsAt - now,
+                windowMs: window.windowMinutes === undefined ? undefined : window.windowMinutes * 60_000,
+            };
+        }
+    }
+    return spent;
+}
+/**
+ * Claude Code's own verdict that the account's subscription is spent: its anchored usage-limit prose
+ * or its structured terminal reason, under no status other than 429 (senpi#3462, senpi#3466).
+ */
+export function isConfirmedAccountUsageLimit(text) {
+    const trimmed = text.trim();
+    if (!CLAUDE_USAGE_LIMIT.test(trimmed) && !TERMINAL_LIMIT_REASON.test(trimmed))
+        return false;
+    const status = NAMED_STATUS.exec(trimmed)?.[1];
+    return status === undefined || status === "429";
+}
+/**
+ * How long a spent account stays blocked: until the reset its limit names, or the reset its spent
+ * window reported, never past the window the limit belongs to. Undefined when the error is not
+ * Claude Code's account usage limit or names no reset, so the caller keeps its short default
+ * (senpi#3462).
+ */
+export function usageLimitBlockMs(text, accountName, now) {
+    const trimmed = text.trim();
+    if (!isConfirmedAccountUsageLimit(trimmed))
+        return undefined;
+    const shape = CLAUDE_USAGE_LIMIT.exec(trimmed);
+    const window = spentWindow(accountName, now);
+    const parsed = usageLimitResetMs(trimmed, now);
+    const resetMs = parsed !== undefined && parsed > 0 ? parsed : window?.resetMs;
+    if (resetMs === undefined)
+        return undefined;
+    const capMs = namedWindowMs(shape?.[1]) ?? window?.windowMs ?? UNNAMED_WINDOW_MS;
+    return Math.min(resetMs, capMs);
+}
+//# sourceMappingURL=usage-limit-block.js.map

package/dist/core/extensions/builtin/goal/index.js

@@ -1,5 +1,7 @@
 import { MANUAL_CONTINUE_CUSTOM_TYPE } from "../../../manual-continue.js";
 import { GOAL_CONTINUATION_MESSAGE_TYPE } from "../../../messages.js";
+import { buildDeadlineStopNotice, deadlineStopPendingSinceLastTurn, TURN_DEADLINE_ENTRY_TYPE, } from "../../../turn-deadline.js";
+import { noticeEntryRenderer } from "../../notice/index.js";
 import { continueGoalAfterAgentEnd } from "./agent-end-continuation.js";
 import { GOAL_CACHE_WARMUP_ENTRY_TYPE } from "./cache-warm.js";
 import { isSameGoalCacheWarmCard, renderGoalCacheWarmupEntry } from "./cache-warm-renderer.js";
@@ -58,6 +60,12 @@ export default function goalExtension(pi) {
     pi.registerEntryRenderer(GOAL_CACHE_WARMUP_ENTRY_TYPE, renderGoalCacheWarmupEntry, {
         replaces: isSameGoalCacheWarmCard,
     });
+    pi.registerEntryRenderer(TURN_DEADLINE_ENTRY_TYPE, noticeEntryRenderer((entry) => {
+        const data = entry.data;
+        if (data === undefined)
+            return undefined;
+        return { title: "turn stopped on a deadline", why: buildDeadlineStopNotice(data) };
+    }));
     registerGoalTools(pi, {
         goalStoreRef: (ctx) => buildGoalStoreRef(ctx.sessionManager, ctx.cwd),
         accountCurrentAgentTurn,
@@ -246,14 +254,16 @@ export default function goalExtension(pi) {
             goal = continuationGoal;
             syncContinuationGoal(ctx, goal);
         }
-        todoOwedBackstop.afterAgentEnd({
-            ctx,
-            event,
-            goal,
-            continuationPending,
-            hasActiveWakeSources: monitorContinuation.hasActiveWakeSources(),
-            wakeSourceNames: monitorContinuation.liveWakeSources(),
-        });
+        if (deadlineStopPendingSinceLastTurn(ctx.sessionManager.getBranch()) === undefined) {
+            todoOwedBackstop.afterAgentEnd({
+                ctx,
+                event,
+                goal,
+                continuationPending,
+                hasActiveWakeSources: monitorContinuation.hasActiveWakeSources(),
+                wakeSourceNames: monitorContinuation.liveWakeSources(),
+            });
+        }
     });
     pi.on("agent_settled", async (_event, ctx) => {
         const goal = await monitorContinuation.afterAgentSettled();

package/dist/core/extensions/builtin/goal/monitor-continuation.js

@@ -1,3 +1,4 @@
+import { deadlineStopPendingSinceLastTurn } from "../../../turn-deadline.js";
 import { createGoalCacheWarmScheduleData, estimateCacheWarmMetrics, GOAL_CACHE_WARMUP_ENTRY_TYPE, GOAL_MONITOR_CONTINUATION_FALLBACK_DELAY_MS, resolveGoalBackstopMaxSecondsForCache, resolveGoalMonitorContinuationDelayMs, resolveGoalPromptCacheLifetime, } from "./cache-warm.js";
 import { subscribeGoalChannelState } from "./channel-state-subscriptions.js";
 import { publishGoalContinuationEvent } from "./rpc-wait-surface.js";
@@ -146,6 +147,10 @@ export class MonitorAwareGoalContinuation {
         }
         if (options.willRetry)
             return options.goal;
+        // A deadline stop is never auto-continued; the hold releases on admitted user input.
+        if (deadlineStopPendingSinceLastTurn(options.ctx.sessionManager.getBranch()) !== undefined) {
+            return options.goal;
+        }
         if (this.#activeWakeSourceCount() > 0)
             this.#schedule(options.goal, "monitor");
         else if (lastAssistantMessage(options.messages)?.stopReason === "error") {
@@ -429,6 +434,8 @@ export class MonitorAwareGoalContinuation {
         const goal = this.#goal;
         if (ctx === undefined || goal?.status !== "active" || !ctx.isIdle() || ctx.hasPendingMessages())
             return;
+        if (deadlineStopPendingSinceLastTurn(ctx.sessionManager.getBranch()) !== undefined)
+            return;
         if (kind === "monitor" && this.#activeWakeSourceCount() === 0 && !drainFire)
             return;
         const admission = await this.#admitAndQueue(ctx, goal, kind === "monitor" ? "monitorDelayed" : kind === "providerRetry" ? "providerRecovery" : "userGrace", this.#lastAgentEndMessages);

package/dist/core/extensions/builtin/goal/reload-reengagement.js

@@ -1,3 +1,4 @@
+import { deadlineStopPendingSinceLastTurn } from "../../../turn-deadline.js";
 import { GOAL_CONTINUATION_CAP } from "./continuation.js";
 /**
  * Re-engages a goal after a config reload retired the previous extension
@@ -21,6 +22,10 @@ export async function reengageGoalAfterReload(options) {
     const { ctx, goal, monitor } = options;
     if (goal.status !== "active")
         return "skipped-inactive";
+    // A deadline stop stays held across reload: re-engagement resumes only on admitted input.
+    if (deadlineStopPendingSinceLastTurn(ctx.sessionManager.getBranch()) !== undefined) {
+        return "skipped-inactive";
+    }
     if (monitor.hasActiveWakeSources()) {
         monitor.rearmMonitorBackstop(goal);
         return "backstop-rearmed";

package/dist/core/extensions/builtin/index.js

@@ -47,6 +47,7 @@ import toolPairGuardExtension from "./tool-pair-guard/index.js";
 import toolSearchExtension from "./tool-search/index.js";
 import tpsExtension from "./tps.js";
 import ttsrExtension from "./ttsr/index.js";
+import vertexModelGardenExtension from "./vertex-model-garden/index.js";
 import videoInExtension from "./video-in/index.js";
 import webfetchExtension from "./webfetch/index.js";
 import websearchExtension from "./websearch/index.js";
@@ -117,6 +118,8 @@ export const builtinExtensions = [
     { id: "claude-sdk-oauth", factory: anthropicSubscriptionExtension },
     // Registers unconditionally and reports executable/auth state through its oauth check, so it stays beside the other provider lane.
     { id: "cursor-cli-oauth", factory: cursorCliOauthExtension },
+    // Provider-only lane beside the other provider registrations; no hooks, so order is not load-bearing.
+    { id: "vertex-model-garden", factory: vertexModelGardenExtension },
     // Config reload follows settings-dependent builtins so reloads rebuild their resolved settings before catalog feeders observe them.
     { id: "config-reload", factory: configReloadExtension },
     // Shared catalog wiring loads before MCP, which feeds its tools into the shared catalog as the final builtin.

package/dist/core/extensions/builtin/permission-system/always-scope.d.ts

@@ -0,0 +1,34 @@
+/**
+ * The wider "Allow always" a prompt may offer for a tool WITHOUT its own permission parser, where
+ * plain "Allow always" remembers only the exact argument (one URL, one input) and so asks again for
+ * the next one (senpi#3403):
+ * - a URL argument: that URL's DOMAIN (scheme + canonical host + non-default port), stored as one
+ *   literal and matched by equality, never the whole tool: a tool-wide allow for a browser or
+ *   fetch tool would mean "go anywhere", close to Full access for the web;
+ * - a free `input`/`pattern` argument: the tool itself, for this project;
+ * - a command or a path: nothing wider (that would grant a shell or file access wholesale).
+ * Built-in tools (bash, eval, edit, write, read, ...) have parsers and never reach this.
+ */
+export interface WiderAlwaysScope {
+    /** The option label, stating the scope in plain words. */
+    readonly label: string;
+    /** The patterns an answer with this option approves for the permission. */
+    readonly patterns: string[];
+}
+/**
+ * The one normalizer both sides of a domain grant go through (senpi#3403). A parser-less tool (an
+ * MCP server, a custom tool) parses the URL itself, and the permission layer cannot make it reuse
+ * this parse. So a domain origin is given only for raw text every parser reads as the same host:
+ * the strict shape above, no ambiguous character anywhere, and the same host and port as the WHATWG
+ * parser finds (#3416 review: `https://example.invalid\\@evil.test/` is example.invalid to WHATWG and
+ * evil.test to curl and Python). Anything else gets no alias and no domain option, so it asks.
+ */
+export declare function canonicalUrlOrigin(raw: string): string | undefined;
+/**
+ * The match target a domain grant is written for: a literal that never contains a wildcard
+ * character, so the grant matches by equality. The `origin=` prefix keeps it from colliding with a
+ * user's own URL rules.
+ */
+export declare function urlOriginAlias(raw: string): string | undefined;
+export declare function widerAlwaysScope(toolName: string, argKey: string, arg: string): WiderAlwaysScope | undefined;
+//# sourceMappingURL=always-scope.d.ts.map