@code-yeongyu/senpi 2026.11.3-1 → 2026.11.3-2

package/dist/core/execution/executor-freeze.d.ts

@@ -0,0 +1,17 @@
+import type { AgentToolResult } from "@earendil-works/pi-agent-core";
+import type { FrozenCall, StoreValue } from "@earendil-works/pi-agent-core/conformance";
+import type { PrepareReply } from "./executor-types.ts";
+/** Tool arguments and results are JSON on every model and wire path; a round trip drops what JSON cannot carry. */
+export declare function toStoreValue(value: unknown): StoreValue;
+export declare function digestOf(value: StoreValue): string;
+/** The call after the whole `tool_call` chain, detached from every object a handler or caller still holds. */
+export declare function freezeCall(name: string, args: unknown): FrozenCall;
+/** The durable record of a settled body: what the issuer commits before ACK. Details stay in the in-process reply. */
+export declare function resultValue(result: AgentToolResult<unknown>, isError: boolean, requestedName?: string): StoreValue;
+export type StoppedReply = Extract<PrepareReply, {
+    readonly kind: "blocked" | "batch_abort";
+}>;
+/** A preparation that ended without a frozen call, as the ledger's durable `blocked` outcome value. */
+export declare function stoppedValue(reply: StoppedReply): StoreValue;
+export declare function stoppedReply(value: StoreValue): StoppedReply | undefined;
+//# sourceMappingURL=executor-freeze.d.ts.map

package/dist/core/execution/executor-freeze.js

@@ -0,0 +1,53 @@
+import { createHash } from "node:crypto";
+import { errorResult } from "./executor-body.js";
+function canonical(value) {
+    if (value === null || typeof value !== "object")
+        return JSON.stringify(value);
+    if (Array.isArray(value))
+        return `[${value.map(canonical).join(",")}]`;
+    const entries = Object.entries(value).sort(([left], [right]) => (left < right ? -1 : left > right ? 1 : 0));
+    return `{${entries.map(([key, entry]) => `${JSON.stringify(key)}:${canonical(entry)}`).join(",")}}`;
+}
+/** Tool arguments and results are JSON on every model and wire path; a round trip drops what JSON cannot carry. */
+export function toStoreValue(value) {
+    const json = JSON.stringify(value);
+    return json === undefined ? null : JSON.parse(json);
+}
+export function digestOf(value) {
+    return createHash("sha256").update(canonical(value)).digest("hex");
+}
+/** The call after the whole `tool_call` chain, detached from every object a handler or caller still holds. */
+export function freezeCall(name, args) {
+    const frozenArgs = toStoreValue(args);
+    return { name, args: frozenArgs, digest: digestOf({ name, args: frozenArgs }) };
+}
+/** The durable record of a settled body: what the issuer commits before ACK. Details stay in the in-process reply. */
+export function resultValue(result, isError, requestedName) {
+    return toStoreValue({ content: result.content ?? [], isError, requestedName });
+}
+/** A preparation that ended without a frozen call, as the ledger's durable `blocked` outcome value. */
+export function stoppedValue(reply) {
+    const text = (reply.result.content ?? []).map((part) => (part.type === "text" ? part.text : "")).join("");
+    const requestedName = reply.kind === "blocked" ? reply.requestedName : undefined;
+    return toStoreValue({ kind: reply.kind, text, terminate: reply.result.terminate === true, requestedName });
+}
+/** The reply a re-sent prepare gets back from a durable `blocked` outcome; undefined for a value this module never wrote. */
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+export function stoppedReply(value) {
+    if (!isRecord(value))
+        return undefined;
+    const { kind, text, terminate, requestedName } = value;
+    if (typeof text !== "string" || typeof terminate !== "boolean")
+        return undefined;
+    const result = errorResult(text);
+    if (terminate)
+        result.terminate = true;
+    if (kind === "batch_abort")
+        return { kind, result };
+    if (kind !== "blocked")
+        return undefined;
+    return typeof requestedName === "string" ? { kind, result, requestedName } : { kind, result };
+}
+//# sourceMappingURL=executor-freeze.js.map

package/dist/core/execution/executor-pipeline.d.ts

@@ -0,0 +1,9 @@
+import { type Agent } from "@earendil-works/pi-agent-core";
+import type { PreparationPipeline } from "./executor-types.ts";
+/**
+ * The preparation steps an agent's loop runs today, read from the agent at call time: its resolver (lazy activation),
+ * its `beforeToolCall` / `afterToolCall` (the session's `tool_call` and `tool_result` chains) and its removed-tool
+ * hints. Building this pipeline installs nothing on the agent.
+ */
+export declare function agentPreparationPipeline(agent: Agent): PreparationPipeline;
+//# sourceMappingURL=executor-pipeline.d.ts.map

package/dist/core/execution/executor-pipeline.js

@@ -0,0 +1,25 @@
+import { resolveToolNameAlias } from "@earendil-works/pi-agent-core";
+/**
+ * The preparation steps an agent's loop runs today, read from the agent at call time: its resolver (lazy activation),
+ * its `beforeToolCall` / `afterToolCall` (the session's `tool_call` and `tool_result` chains) and its removed-tool
+ * hints. Building this pipeline installs nothing on the agent.
+ */
+export function agentPreparationPipeline(agent) {
+    return {
+        resolve: async (call, context) => {
+            const tools = context.tools ?? [];
+            const exact = tools.find((tool) => tool.name === call.name);
+            if (exact)
+                return exact;
+            const resolved = await agent.resolveUnknownToolCall?.(call.name, context);
+            if (resolved)
+                return resolved;
+            const aliased = resolveToolNameAlias(call.name, tools.map((tool) => tool.name));
+            return tools.find((tool) => tool.name === aliased);
+        },
+        beforeToolCall: async (context, signal) => agent.beforeToolCall?.(context, signal),
+        afterToolCall: async (context, signal) => agent.afterToolCall?.(context, signal),
+        removedToolHint: (name) => agent.removedToolHints?.[name],
+    };
+}
+//# sourceMappingURL=executor-pipeline.js.map

package/dist/core/execution/executor-types.d.ts

@@ -0,0 +1,82 @@
+import type { AfterToolCallContext, AfterToolCallResult, AgentContext, AgentTool, AgentToolCall, AgentToolResult, AgentToolUpdateCallback, BeforeToolCallContext, BeforeToolCallResult } from "@earendil-works/pi-agent-core";
+import type { ExecutionEntry, ExecutionKey, ExecutionLedger, FrozenCall } from "@earendil-works/pi-agent-core/conformance";
+import type { AssistantMessage } from "@earendil-works/pi-ai";
+/** Today's per-call steps, as the executor runs them; the executor owns their order and the ledger around them. */
+export interface PreparationPipeline {
+    /** Exact name, then the host resolver (which may activate a lazy tool), then the alias rule. */
+    resolve(call: AgentToolCall, context: AgentContext): Promise<AgentTool | undefined>;
+    /** The ordered `tool_call` chain; PreToolUse is one handler in it. */
+    beforeToolCall(context: BeforeToolCallContext, signal?: AbortSignal): Promise<BeforeToolCallResult | undefined>;
+    afterToolCall(context: AfterToolCallContext, signal?: AbortSignal): Promise<AfterToolCallResult | undefined>;
+    removedToolHint(name: string): string | undefined;
+}
+export interface PreparedExecutorOptions {
+    readonly ledger: ExecutionLedger;
+    /** The executor's authenticated identity: the actor of every executor-side ledger event. */
+    readonly executor: string;
+    readonly pipeline: PreparationPipeline;
+    readonly clock?: () => number;
+}
+export interface PrepareRequest {
+    readonly issuer: string;
+    readonly generation: number;
+    readonly workspace: string;
+    readonly scope: string;
+    /** The model's raw call; its id is the execution's command id. */
+    readonly call: AgentToolCall;
+    readonly assistantMessage: AssistantMessage;
+    readonly context: AgentContext;
+    /** Issuer-minted with the call, so a re-sent prepare matches its admission exactly. */
+    readonly admittedAt: number;
+    readonly leaseUntil: number;
+    readonly reconcilable?: boolean;
+    readonly signal?: AbortSignal;
+}
+/** `requestedName` is set when the model's name resolved to another tool; the caller adds today's notice. */
+export type PrepareReply = {
+    readonly kind: "prepared";
+    readonly call: FrozenCall;
+    readonly requestedName?: string;
+} | {
+    readonly kind: "blocked";
+    readonly result: AgentToolResult<unknown>;
+    readonly requestedName?: string;
+} | {
+    readonly kind: "batch_abort";
+    readonly result: AgentToolResult<unknown>;
+} | {
+    readonly kind: "refused";
+    readonly reason: string;
+};
+export interface ReleaseRequest {
+    readonly key: ExecutionKey;
+    readonly generation: number;
+    /** Verified identity of the releasing issuer, supplied by the endpoint. */
+    readonly actor: {
+        readonly id: string;
+    };
+    readonly signal?: AbortSignal;
+    readonly onUpdate?: AgentToolUpdateCallback<unknown>;
+}
+export type ReleaseReply = {
+    readonly kind: "settled";
+    readonly toolCall: AgentToolCall;
+    readonly result: AgentToolResult<unknown>;
+    readonly isError: boolean;
+    /** Set when the model's name resolved to another tool; the caller adds today's correction notice. */
+    readonly requestedName?: string;
+} | {
+    readonly kind: "aborted";
+    readonly result: AgentToolResult<unknown>;
+} | {
+    readonly kind: "replayed";
+    readonly entry: ExecutionEntry;
+} | {
+    readonly kind: "refused";
+    readonly reason: string;
+};
+export interface PreparedExecutor {
+    prepare(request: PrepareRequest): Promise<PrepareReply>;
+    release(request: ReleaseRequest): Promise<ReleaseReply>;
+}
+//# sourceMappingURL=executor-types.d.ts.map

package/dist/core/execution/executor-types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=executor-types.js.map

package/dist/core/execution/executor.d.ts

@@ -0,0 +1,8 @@
+import type { PreparedExecutor, PreparedExecutorOptions } from "./executor-types.ts";
+/**
+ * The prepared executor (design 5.6.1): PREPARE persists effect_possible, runs today's resolution, shim, validation
+ * and `tool_call` chain once, and freezes the result; RELEASE dispatches the frozen call at most once and runs the
+ * after-hook once. Nothing here is installed on a session; a caller builds one and drives it.
+ */
+export declare function createPreparedExecutor(options: PreparedExecutorOptions): PreparedExecutor;
+//# sourceMappingURL=executor.d.ts.map

package/dist/core/execution/executor.js

@@ -0,0 +1,216 @@
+import { prepareAgentToolCall } from "@earendil-works/pi-agent-core";
+import { errorResult, finalizeBody, messageOf, runBody } from "./executor-body.js";
+import { digestOf, freezeCall, resultValue, stoppedReply, stoppedValue, toStoreValue, } from "./executor-freeze.js";
+const keyId = ({ issuer, commandId }) => JSON.stringify([issuer, commandId]);
+function refusal(reply) {
+    return { kind: "refused", reason: reply.status === "refused" ? reply.reason : reply.status };
+}
+// Today's message for a call the response cut off (agent-loop `createIncompleteToolCallErrorMessage`).
+function incompleteMessage(name, errorMessage) {
+    if (errorMessage !== undefined) {
+        return `${errorMessage}${errorMessage.endsWith(".") ? "" : "."} Re-issue the tool call with complete arguments.`;
+    }
+    return `Tool call "${name}" was not executed: the response ended before the tool call was complete because it hit the output token limit. Re-issue the tool call with complete arguments.`;
+}
+/** A durable row that already passed admission: answer from it and never run preparation again. */
+function fromRow(entry) {
+    const progress = entry.progress;
+    if ("call" in progress)
+        return { kind: "prepared", call: progress.call };
+    if (progress.state !== "settled")
+        return { kind: "refused", reason: progress.state };
+    const outcome = progress.outcome;
+    if (outcome.reason !== "blocked")
+        return { kind: "refused", reason: "terminal" };
+    return stoppedReply(outcome.value) ?? { kind: "refused", reason: "corrupt_blocked_outcome" };
+}
+/**
+ * The prepared executor (design 5.6.1): PREPARE persists effect_possible, runs today's resolution, shim, validation
+ * and `tool_call` chain once, and freezes the result; RELEASE dispatches the frozen call at most once and runs the
+ * after-hook once. Nothing here is installed on a session; a caller builds one and drives it.
+ */
+export function createPreparedExecutor(options) {
+    const { ledger, executor, pipeline } = options;
+    const clock = options.clock ?? Date.now;
+    const preparations = new Map();
+    const bodies = new Map();
+    const releases = new Map();
+    const step = (key, generation, event) => ledger.apply({ key, generation, actor: { id: executor }, now: clock(), event });
+    // A preparation that ends without a frozen call is terminal and durable, so a re-sent prepare (also from a new
+    // executor process after restart) gets this reply back instead of a restart-recovered `hand_restarted`.
+    async function stop(key, generation, reply) {
+        const recorded = await step(key, generation, { kind: "block", value: stoppedValue(reply) });
+        if (recorded.status === "applied")
+            return reply;
+        return recorded.status === "replayed" ? fromRow(recorded.entry) : refusal(recorded);
+    }
+    async function prepareOnce(request, requestDigest) {
+        const { call, generation, signal } = request;
+        const key = { issuer: request.issuer, commandId: call.id };
+        const admitted = await ledger.admit({
+            ...key,
+            executor,
+            workspace: request.workspace,
+            scope: request.scope,
+            generation,
+            requestDigest,
+            admittedAt: request.admittedAt,
+            leaseUntil: request.leaseUntil,
+            reconcilable: request.reconcilable ?? false,
+        });
+        if (admitted.status === "replayed")
+            return fromRow(admitted.entry);
+        if (admitted.status !== "applied")
+            return refusal(admitted);
+        const preparing = await step(key, generation, { kind: "prepare" });
+        if (preparing.status !== "applied")
+            return refusal(preparing);
+        if (call.incomplete === true) {
+            return stop(key, generation, {
+                kind: "blocked",
+                result: errorResult(incompleteMessage(call.name, call.errorMessage)),
+            });
+        }
+        const effect = await step(key, generation, { kind: "effect" });
+        if (effect.status !== "applied")
+            return refusal(effect);
+        let tool;
+        try {
+            tool = await pipeline.resolve(call, request.context);
+        }
+        catch (error) {
+            return stop(key, generation, { kind: "blocked", result: errorResult(messageOf(error)) });
+        }
+        if (!tool) {
+            const hint = pipeline.removedToolHint(call.name);
+            const text = hint === undefined ? `Tool ${call.name} not found` : `Tool ${call.name} not found. ${hint}`;
+            return stop(key, generation, { kind: "blocked", result: errorResult(text) });
+        }
+        const requestedName = tool.name === call.name ? undefined : call.name;
+        const named = requestedName === undefined ? {} : { requestedName };
+        try {
+            const prepared = prepareAgentToolCall(tool, requestedName === undefined ? call : { ...call, name: tool.name });
+            const before = await pipeline.beforeToolCall({
+                assistantMessage: request.assistantMessage,
+                toolCall: prepared.toolCall,
+                args: prepared.args,
+                context: request.context,
+            }, signal);
+            if (signal?.aborted)
+                return stop(key, generation, { kind: "batch_abort", result: errorResult("Operation aborted") });
+            if (before?.block) {
+                const result = errorResult(before.reason || "Tool execution was blocked");
+                if (before.terminate === true)
+                    result.terminate = true;
+                return stop(key, generation, { kind: "blocked", result, ...named });
+            }
+            const frozen = freezeCall(tool.name, prepared.args);
+            const freeze = await step(key, generation, { kind: "freeze", call: frozen, awaitingConsent: false });
+            if (freeze.status !== "applied")
+                return refusal(freeze);
+            bodies.set(keyId(key), {
+                ...named,
+                tool,
+                toolCall: prepared.toolCall,
+                args: frozen.args,
+                assistantMessage: request.assistantMessage,
+                context: request.context,
+            });
+            return { kind: "prepared", call: frozen, ...named };
+        }
+        catch (error) {
+            return stop(key, generation, { kind: "blocked", result: errorResult(messageOf(error)), ...named });
+        }
+    }
+    async function terminalRow(key) {
+        const entry = await ledger.read(key);
+        if (entry === undefined)
+            return { kind: "refused", reason: "not_found" };
+        const progress = entry.progress;
+        // A blocked call never had a body: release on it is refused, not replayed.
+        if (progress.state === "settled" && progress.outcome.reason === "blocked")
+            return { kind: "refused", reason: "blocked" };
+        return { kind: "replayed", entry };
+    }
+    async function runReleased(request, body) {
+        const { key, generation, signal } = request;
+        const dispatched = await step(key, generation, { kind: "dispatch" });
+        if (dispatched.status === "replayed")
+            return { kind: "replayed", entry: dispatched.entry };
+        if (dispatched.status !== "applied" || dispatched.entry.progress.state !== "dispatched") {
+            return refusal(dispatched);
+        }
+        const executed = await runBody(body, signal, request.onUpdate ?? (() => { }));
+        const { result, isError } = await finalizeBody(body, executed, pipeline, signal);
+        const value = resultValue(result, isError, body.requestedName);
+        const recorded = await step(key, generation, { kind: "result", value });
+        for (const memo of [bodies, preparations, releases])
+            memo.delete(keyId(key));
+        // A cancel or lease expiry that settled first stays terminal; the late body result is audit only.
+        if (recorded.status === "replayed")
+            return { kind: "replayed", entry: recorded.entry };
+        if (recorded.status !== "applied")
+            return refusal(recorded);
+        const named = body.requestedName === undefined ? {} : { requestedName: body.requestedName };
+        return { kind: "settled", toolCall: body.toolCall, result, isError, ...named };
+    }
+    // Every release reaches the ledger with its own actor and generation before any memo is read or written, so a
+    // wrong actor or an old generation is refused there and can never answer, or block, the issuer's own release.
+    async function release(request) {
+        const { key, generation } = request;
+        const released = await ledger.apply({
+            key,
+            generation,
+            actor: request.actor,
+            now: clock(),
+            event: { kind: "release" },
+        });
+        if (released.status === "refused")
+            return released.reason === "terminal" ? terminalRow(key) : refusal(released);
+        if (released.status === "result_expired")
+            return refusal(released);
+        const id = keyId(key);
+        const pending = releases.get(id);
+        if (pending !== undefined)
+            return pending;
+        const body = bodies.get(id);
+        if (body === undefined)
+            return { kind: "refused", reason: "not_prepared" };
+        // Today's loop never starts a body once the run is aborted; the call stays released for the issuer's abort.
+        if (request.signal?.aborted)
+            return { kind: "aborted", result: errorResult("Operation aborted") };
+        const reply = runReleased(request, body);
+        releases.set(id, reply);
+        void reply.catch(() => releases.get(id) === reply && releases.delete(id));
+        return reply;
+    }
+    return {
+        prepare: (request) => {
+            const { name, arguments: args, incomplete, errorMessage } = request.call;
+            const requestDigest = digestOf(toStoreValue({ name, args, incomplete, errorMessage }));
+            const admission = JSON.stringify([
+                request.generation,
+                request.workspace,
+                request.scope,
+                requestDigest,
+                request.admittedAt,
+                request.leaseUntil,
+                request.reconcilable ?? false,
+            ]);
+            const id = keyId({ issuer: request.issuer, commandId: request.call.id });
+            const pending = preparations.get(id);
+            if (pending !== undefined && pending.admission === admission)
+                return pending.reply;
+            if (pending !== undefined)
+                return Promise.resolve({ kind: "refused", reason: "identity_conflict" });
+            const reply = prepareOnce(request, requestDigest);
+            preparations.set(id, { admission, reply });
+            // Only a prepared call keeps its memo (release needs it); every other reply is durable or retryable.
+            const forget = () => preparations.get(id)?.reply === reply && preparations.delete(id);
+            void reply.then((settled) => settled.kind === "prepared" || forget(), forget);
+            return reply;
+        },
+        release,
+    };
+}
+//# sourceMappingURL=executor.js.map

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

@@ -0,0 +1,15 @@
+export type AccountBlockRecord = {
+    readonly account: string;
+    readonly reason: string;
+    readonly until: number | undefined;
+    /** Whether the block was written to the credential store for every session, or held for this session only. */
+    readonly shared: boolean;
+    readonly detail: string;
+};
+/**
+ * Writes one `account_blocked` line to session.log for every block that is saved, so a pool that later
+ * refuses a request locally has a recorded cause (senpi#4671). The account is named by its seat digest,
+ * never its name (Desktop#4753); an unknown end time is left out rather than guessed.
+ */
+export declare function logAccountBlocked(record: AccountBlockRecord): void;
+//# sourceMappingURL=account-block-log.d.ts.map

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

@@ -0,0 +1,18 @@
+import { seatDigest } from "./seat-digest.js";
+import { logContinuityEvent } from "./session-observability.js";
+const MAX_DETAIL_CHARS = 200;
+/**
+ * Writes one `account_blocked` line to session.log for every block that is saved, so a pool that later
+ * refuses a request locally has a recorded cause (senpi#4671). The account is named by its seat digest,
+ * never its name (Desktop#4753); an unknown end time is left out rather than guessed.
+ */
+export function logAccountBlocked(record) {
+    logContinuityEvent("account_blocked", {
+        seat: seatDigest(record.account),
+        reason: record.reason,
+        ...(record.until === undefined ? {} : { until: new Date(record.until).toISOString() }),
+        shared: record.shared,
+        error: record.detail.slice(0, MAX_DETAIL_CHARS),
+    });
+}
+//# sourceMappingURL=account-block-log.js.map

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

@@ -31,6 +31,12 @@ export type UnavailableAccount = {
 };
 /** The origin of an account pin, highest precedence first (`resolveClaudeAccountPin`). */
 export type PinSource = "cli" | "settings" | "stored";
+/** One pool member's state when the pool refused a request: why it is out, and until when. */
+export type BlockedAccountState = {
+    readonly name: string;
+    readonly reason: string;
+    readonly until: number | undefined;
+};
 export declare class AllAccountsBlockedError extends Error {
     readonly soonestUnblockAt: number | undefined;
     /**
@@ -49,7 +55,9 @@ export declare class AllAccountsBlockedError extends Error {
     readonly limitedModel: string | undefined;
     /** Set only when account fallback is off, so the guidance names that account instead of the whole pool. */
     readonly unavailableAccount: UnavailableAccount | undefined;
-    constructor(soonestUnblockAt: number | undefined, blockReason?: "auth_error", limitedModel?: string, unavailableAccount?: UnavailableAccount);
+    /** Every candidate's state, so the error names which account needs /login and which waits on a reset (senpi#4671). */
+    readonly accounts: readonly BlockedAccountState[];
+    constructor(soonestUnblockAt: number | undefined, blockReason?: "auth_error", limitedModel?: string, unavailableAccount?: UnavailableAccount, accounts?: readonly BlockedAccountState[]);
 }
 export declare function getAffinityKey(options: Pick<AffinityOptions, "affinityKey" | "sessionId">): string;
 /**

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

@@ -2,14 +2,21 @@ import { createHash } from "node:crypto";
 import { applyAccountOrder } from "@earendil-works/pi-ai/auth/pool/select";
 import { activeModelBlockUntil, pruneModelBlocks } from "../../../credential-pool/model-scope.js";
 export const DEFAULT_AFFINITY_KEY = "claude-sdk-oauth-default";
+function describeAccountState(state) {
+    const until = state.until === undefined ? "re-login" : new Date(state.until).toISOString();
+    const login = state.reason === "auth_error" ? ` (run /login anthropic-subscription for ${state.name})` : "";
+    return `${state.name}: ${state.reason} until ${until}${login}`;
+}
 export class AllAccountsBlockedError extends Error {
-    constructor(soonestUnblockAt, blockReason, limitedModel, unavailableAccount) {
+    constructor(soonestUnblockAt, blockReason, limitedModel, unavailableAccount, accounts = []) {
         const until = soonestUnblockAt === undefined ? undefined : new Date(soonestUnblockAt).toISOString();
-        super(limitedModel !== undefined && until !== undefined
+        const summary = limitedModel !== undefined && until !== undefined
             ? `All Anthropic Subscription accounts have hit the usage limit for model ${limitedModel} until ${until}.`
             : until === undefined
                 ? "All Anthropic Subscription accounts are blocked until re-login."
-                : `All Anthropic Subscription accounts are blocked until ${until}.`);
+                : `All Anthropic Subscription accounts are blocked until ${until}.`;
+        super(accounts.length === 0 ? summary : `${summary} Accounts: ${accounts.map(describeAccountState).join("; ")}.`);
+        this.accounts = accounts;
         this.limitedModel = limitedModel;
         this.name = "AllAccountsBlockedError";
         this.soonestUnblockAt = soonestUnblockAt;
@@ -119,6 +126,10 @@ export function selectAccount(accounts, options = {}) {
         return afterClear;
     throw new AllAccountsBlockedError(soonestUnblockAt(candidates, now, options.model), candidates.length > 0 && candidates.every((account) => account.blockReason === "auth_error")
         ? "auth_error"
-        : undefined, limitedModel(candidates, now, options.model), unavailableAccount);
+        : undefined, limitedModel(candidates, now, options.model), unavailableAccount, candidates.map((account) => ({
+        name: account.name,
+        reason: account.blockReason ?? (isAccountBlocked(account, now) ? "blocked" : "model_limit"),
+        until: unblockAt(account, now, options.model),
+    })));
 }
 //# sourceMappingURL=affinity.js.map

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

@@ -1,5 +1,6 @@
 import type { CredentialStore } from "@earendil-works/pi-ai";
 import type { AccountSlot } from "./accounts.ts";
+import { AllAccountsBlockedError } from "./affinity.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;
@@ -49,7 +50,12 @@ export declare class ClassifiedSdkError extends Error {
     readonly classification: SdkErrorClassification;
     readonly original: unknown;
     readonly suppressTurnRetry: boolean;
-    constructor(classification: SdkErrorClassification, original: unknown, suppressTurnRetry: boolean);
+    /**
+     * The pool's state when this failure left no other account to try (senpi#4671). The failure stays the
+     * error; the pool refusal is context, so a refresh failure or a 401 is never hidden behind "all blocked".
+     */
+    readonly poolState: AllAccountsBlockedError | undefined;
+    constructor(classification: SdkErrorClassification, original: unknown, suppressTurnRetry: boolean, poolState?: AllAccountsBlockedError);
 }
 /**
  * Runs one attempt per account for account-level failures (a limit, billing, auth), plus at most

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

@@ -1,6 +1,7 @@
 import { AUTH_BLOCK_REPROBE_MS } from "../../../credential-pool/auth-reprobe.js";
 import { activeModelBlockUntil, mergeModelBlocks, modelBlockKey, pruneModelBlocks, withModelBlock, } from "../../../credential-pool/model-scope.js";
 import { usageLimitResetMs } from "../../../credential-pool/reset-time.js";
+import { logAccountBlocked } from "./account-block-log.js";
 import { AllAccountsBlockedError, clearExpiredBlocks } from "./affinity.js";
 import { isConfirmedAccountUsageLimit, usageLimitBlockMs } from "./usage-limit-block.js";
 export const MAX_RATE_LIMIT_BLOCK_MS = 48 * 60 * 60 * 1_000;
@@ -91,13 +92,14 @@ export function forgetSessionBlocksFor(name) {
     return lifted;
 }
 export class ClassifiedSdkError extends Error {
-    constructor(classification, original, suppressTurnRetry) {
+    constructor(classification, original, suppressTurnRetry, poolState) {
         const detail = original instanceof Error ? original.message : String(original);
-        super(`${suppressTurnRetry ? TURN_RETRY_SUPPRESSION_PREFIX : ""}${detail}`);
+        super(`${suppressTurnRetry ? TURN_RETRY_SUPPRESSION_PREFIX : ""}${detail}`, poolState === undefined ? undefined : { cause: poolState });
         this.name = "ClassifiedSdkError";
         this.classification = classification;
         this.original = original;
         this.suppressTurnRetry = suppressTurnRetry;
+        this.poolState = poolState;
     }
 }
 function record(value) {
@@ -356,6 +358,13 @@ export async function* runFailover(options) {
                 attempt--;
                 continue;
             }
+            logAccountBlocked({
+                account: blocked.name,
+                reason: blocked.blockReason ?? "model_limit",
+                until: blocked.blockedUntil ?? activeModelBlockUntil(blocked.modelBlocks, options.model, now()),
+                shared,
+                detail: errorText(error),
+            });
             accounts = replaceAccount(accounts, blocked);
             const event = {
                 account: blocked,
@@ -363,14 +372,22 @@ export async function* runFailover(options) {
                 attempt: attempt + 1,
                 visibleDeltaEmitted,
             };
+            let poolState;
             try {
                 if (!visibleDeltaEmitted && attempt + 1 < attemptLimit) {
                     event.nextAccount = options.selectFn(accounts);
                 }
             }
+            catch (selectError) {
+                if (!(selectError instanceof AllAccountsBlockedError))
+                    throw selectError;
+                poolState = selectError;
+            }
             finally {
                 await options.onFailover?.(event);
             }
+            if (poolState !== undefined)
+                throw new ClassifiedSdkError(classification, error, visibleDeltaEmitted, poolState);
             if (visibleDeltaEmitted)
                 throw classified;
         }

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

@@ -1,8 +1,14 @@
-import type { PinSource, UnavailableAccount } from "./affinity.ts";
+import type { BlockedAccountState, PinSource, UnavailableAccount } from "./affinity.ts";
 import type { SdkErrorKind } from "./errors.ts";
 import type { ClaudeCodeRun } from "./executable.ts";
 export declare function noAccountGuidance(hasAnthropicCredential: boolean): string;
-export declare function allAccountsBlockedGuidance(soonestUnblockAt: number | undefined, blockReason?: "auth_error"): string;
+/**
+ * The pool context of a failure that left no other account (senpi#4671): the failure stays the error, and this
+ * names the soonest retry (which goal mode reads) and every account's state. No refusal note: the pool did not
+ * refuse the request, the account failed it.
+ */
+export declare function exhaustedPoolGuidance(soonestUnblockAt: number | undefined, accounts: readonly BlockedAccountState[]): string;
+export declare function allAccountsBlockedGuidance(soonestUnblockAt: number | undefined, blockReason?: "auth_error", accounts?: readonly BlockedAccountState[]): string;
 /**
  * How to move off a pinned account. `/claude-account pin` only writes the stored pin, which a CLI or a
  * settings pin outranks (`resolveClaudeAccountPin`), so for those it would change nothing (senpi#3672).