@code-yeongyu/senpi 2026.11.10 → 2026.11.11

package/dist/core/retry-fallback/log.d.ts

@@ -6,5 +6,11 @@ export interface FallbackLogger {
 export interface FallbackLoggerOptions {
     maxBytes?: number;
 }
-export declare function createFallbackLogger(agentDir: string, options?: FallbackLoggerOptions): FallbackLogger;
+export interface SettledFallbackLogger extends FallbackLogger {
+    /** Resolves once the one-time removal of earlier log generations has finished and every line logged before it was written. */
+    settled(): Promise<void>;
+}
+/** Resolves once every fallback logger created so far has finished its first-start removal and flushed its queue. */
+export declare function settledFallbackLoggers(): Promise<void>;
+export declare function createFallbackLogger(agentDir: string, options?: FallbackLoggerOptions): SettledFallbackLogger;
 //# sourceMappingURL=log.d.ts.map

package/dist/core/retry-fallback/log.js

@@ -1,19 +1,81 @@
 import { closeSync, fchmodSync, mkdirSync, openSync, writeSync } from "node:fs";
+import { access, mkdir, rm, writeFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { rotateLogIfNeeded } from "../log-file-rotation.js";
-import { redactSecrets } from "../sensitive-output.js";
+import { redactSecrets, redactSensitiveTokenValues } from "../sensitive-output.js";
 const DEFAULT_MAX_BYTES = 5 * 1024 * 1024;
 const MAX_STRING_LENGTH = 200;
+const MAX_QUEUED_LINES = 256;
 const BLOCKED_KEY = /^(?:__proto__|constructor|prototype|headers?|env(?:ironment)?|authorization|credential(?:s)?|password|secret|token|api_?key|client_?secret)$/i;
 const ALLOWED_DATA_KEY = /^(?:selector|candidate|currentSelector|originalSelector|from|to|model|provider|chainKey|reason|skipReason|classification|thinkingLevel|durationMs|retryAfterMs|error|errorMessage|warning|trigger)$/;
 const SENSITIVE_TEXT = /((?:authorization\s*[:=]\s*(?:bearer|basic)\s+)|(?:bearer\s+)|(?:[?&](?:api[_-]?key|token|secret|password|auth(?:orization)?)=))[^\s&,"'}\]]+/gi;
+const unsettledLoggers = new Set();
+/** Resolves once every fallback logger created so far has finished its first-start removal and flushed its queue. */
+export async function settledFallbackLoggers() {
+    await Promise.all([...unsettledLoggers]);
+}
+function errorCode(failure) {
+    if (typeof failure === "object" && failure !== null && "code" in failure && typeof failure.code === "string") {
+        return failure.code;
+    }
+    return "unknown";
+}
 export function createFallbackLogger(agentDir, options = {}) {
     const filePath = join(agentDir, "logs", "fallback.log");
     const maxBytes = validMaxBytes(options.maxBytes);
     let reportedWriteFailure = false;
+    // Lines logged while the earlier generations are still being removed wait here, so the removal can never delete them.
+    // They are redacted before they enter the queue and the queue is bounded: the newest lines win, the drops are counted.
+    let queued = [];
+    let dropped = 0;
+    function write(line) {
+        try {
+            writeLine(filePath, line, maxBytes);
+        }
+        catch (error) {
+            if (!reportedWriteFailure) {
+                reportedWriteFailure = true;
+                console.error("Unable to write retry fallback debug log", error);
+            }
+        }
+    }
+    const settled = retireUnsharedRegistryGenerations(filePath)
+        .then(() => undefined)
+        .catch((error) => {
+        reportedWriteFailure = true;
+        console.error("Unable to remove earlier retry fallback debug log generations", error);
+        return error;
+    })
+        .then((failure) => {
+        const lines = queued ?? [];
+        queued = undefined;
+        for (const line of lines)
+            write(line);
+        if (dropped > 0) {
+            write(formatLine("warn", "queued_lines_dropped", {
+                reason: `${dropped} lines dropped while earlier log generations were removed`,
+            }));
+        }
+        if (failure !== undefined) {
+            // The code only: the error text names the agent dir's absolute path.
+            write(formatLine("warn", "retire_generations_failed", {
+                errorMessage: `removal failed: ${errorCode(failure)}`,
+            }));
+        }
+    });
+    unsettledLoggers.add(settled);
+    void settled.then(() => unsettledLoggers.delete(settled));
     function log(level, event, data) {
         try {
             const line = formatLine(level, event, data);
+            if (queued !== undefined) {
+                queued.push(redactSensitiveTokenValues(line, "[redacted]"));
+                if (queued.length > MAX_QUEUED_LINES) {
+                    queued.shift();
+                    dropped += 1;
+                }
+                return;
+            }
             writeLine(filePath, line, maxBytes);
         }
         catch (error) {
@@ -27,8 +89,23 @@ export function createFallbackLogger(agentDir, options = {}) {
         debug: (event, data) => log("debug", event, data),
         info: (event, data) => log("info", event, data),
         warn: (event, data) => log("warn", event, data),
+        settled: () => settled,
     };
 }
+/**
+ * Generations written before every engine copy in a process shared one resolved-value registry (omo#12965) are
+ * removed once per agent dir, the first time an engine with the shared registry starts on it; the marker makes every
+ * later start leave the logs alone.
+ */
+async function retireUnsharedRegistryGenerations(filePath) {
+    const marker = join(dirname(filePath), ".fallback-log-v2");
+    if (await access(marker).then(() => true, () => false))
+        return;
+    await rm(`${filePath}.1`, { force: true });
+    await rm(filePath, { force: true });
+    await mkdir(dirname(filePath), { recursive: true, mode: 0o700 });
+    await writeFile(marker, "", { mode: 0o600 });
+}
 function validMaxBytes(value) {
     return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.floor(value) : DEFAULT_MAX_BYTES;
 }
@@ -51,7 +128,7 @@ function formatLine(level, event, data) {
 }
 function writeLine(filePath, line, maxBytes) {
     mkdirSync(dirname(filePath), { recursive: true, mode: 0o700 });
-    const text = `${line}\n`;
+    const text = `${redactSensitiveTokenValues(line, "[redacted]")}\n`;
     rotateLogIfNeeded(filePath, Buffer.byteLength(text), maxBytes);
     const descriptor = openSync(filePath, "a", 0o600);
     try {
@@ -66,13 +143,13 @@ function serializeValue(value, seen) {
     if (typeof value === "string")
         return safeText(value);
     if (typeof value === "bigint")
-        return value.toString();
+        return safeText(value.toString());
     if (typeof value === "number" || typeof value === "boolean" || value === null)
         return value;
     if (typeof value === "undefined")
         return undefined;
     if (typeof value === "function" || typeof value === "symbol")
-        return String(value);
+        return safeText(String(value));
     if (seen.has(value))
         return "[Circular]";
     seen.add(value);
@@ -83,7 +160,7 @@ function serializeValue(value, seen) {
         if (!BLOCKED_KEY.test(key)) {
             const safeValue = serializeValue(item, seen);
             if (safeValue !== undefined)
-                result[key] = safeValue;
+                result[safeText(key)] = safeValue;
         }
     }
     return result;

package/dist/core/retry-fallback/model-config-error.js

@@ -1,3 +1,4 @@
+import { redactSecrets } from "../sensitive-output.js";
 const EXCERPT_LIMIT = 500;
 /**
  * A model configuration error is never retried or fallen back: another model would answer a request the caller did
@@ -16,7 +17,7 @@ export function createModelConfigErrorReporter(logger, emit) {
             if (reported.has(key))
                 return;
             reported.add(key);
-            const errorMessage = message.errorMessage ?? "";
+            const errorMessage = redactSecrets(message.errorMessage ?? "");
             logger.warn("model_config_error", { model, provider: message.provider, errorMessage });
             emit({
                 type: "model_config_error",

package/dist/core/retry-fallback/settings.d.ts

@@ -33,11 +33,14 @@ export interface ResolvedRetryFallbackSettings {
  * follows Fable 5 whichever provider serves it - the builtin Anthropic provider, the
  * Anthropic Subscription extension, a gateway, or Bedrock.
  *
- * The ladder never leaves the Anthropic Opus family. The previous shipped default was
- * removed because it led with cross-family rungs (`k3`, `kimi-k3`), which moved a Claude
- * session onto another vendor mid-turn and could rank a guaranteed-refusal OAuth lane
- * first; a same-family step-down carries neither problem. There is still deliberately no
- * wildcard lane.
+ * The ladder never leaves Anthropic. The previous shipped default was removed because it
+ * led with cross-family rungs (`k3`, `kimi-k3`), which moved a Claude session onto another
+ * vendor mid-turn and could rank a guaranteed-refusal OAuth lane first; an Anthropic-only
+ * ladder carries neither problem. There is still deliberately no wildcard lane.
+ *
+ * Opus 5.5 steps to Fable 5.2 before Opus 5: Anthropic meters Opus on its own quota window,
+ * so a rate limit on Opus 5.5 also holds every other Opus rung on that account or gateway
+ * pool (senpi#6385).
  *
  * Rungs stay on current-generation Opus: a Claude session must never step down to
  * `claude-opus-4-8` or `claude-opus-4-6` (senpi#3727).

package/dist/core/retry-fallback/settings.js

@@ -4,11 +4,14 @@
  * follows Fable 5 whichever provider serves it - the builtin Anthropic provider, the
  * Anthropic Subscription extension, a gateway, or Bedrock.
  *
- * The ladder never leaves the Anthropic Opus family. The previous shipped default was
- * removed because it led with cross-family rungs (`k3`, `kimi-k3`), which moved a Claude
- * session onto another vendor mid-turn and could rank a guaranteed-refusal OAuth lane
- * first; a same-family step-down carries neither problem. There is still deliberately no
- * wildcard lane.
+ * The ladder never leaves Anthropic. The previous shipped default was removed because it
+ * led with cross-family rungs (`k3`, `kimi-k3`), which moved a Claude session onto another
+ * vendor mid-turn and could rank a guaranteed-refusal OAuth lane first; an Anthropic-only
+ * ladder carries neither problem. There is still deliberately no wildcard lane.
+ *
+ * Opus 5.5 steps to Fable 5.2 before Opus 5: Anthropic meters Opus on its own quota window,
+ * so a rate limit on Opus 5.5 also holds every other Opus rung on that account or gateway
+ * pool (senpi#6385).
  *
  * Rungs stay on current-generation Opus: a Claude session must never step down to
  * `claude-opus-4-8` or `claude-opus-4-6` (senpi#3727).
@@ -18,7 +21,7 @@ export const DEFAULT_FALLBACK_CHAINS = {
     "claude-fable-5-2": ["claude-opus-5-5", "claude-opus-5"],
     "claude-fable-5-1": ["claude-opus-5-5", "claude-opus-5"],
     "claude-fable-5": ["claude-opus-5-5", "claude-opus-5"],
-    "claude-opus-5-5": ["claude-opus-5"],
+    "claude-opus-5-5": ["claude-fable-5-2", "claude-opus-5"],
 };
 function cloneDefaultFallbackChains() {
     const chains = {};

package/dist/core/session-manager.d.ts

@@ -440,6 +440,8 @@ export declare class SessionManager {
     private _transcriptEntryBytes;
     private _serializedFileEntries;
     isPersisted(): boolean;
+    /** Give an unclaimed in-memory session its first file without rebuilding or changing its identity. */
+    enablePersistence(): Promise<void>;
     getCwd(): string;
     getSessionDir(): string;
     usesDefaultSessionDir(): boolean;

package/dist/core/session-manager.js

@@ -1,7 +1,7 @@
 import { getCurrentSystemMessage, normalizeProviderId } from "@earendil-works/pi-ai";
 import { randomBytes, randomUUID } from "crypto";
 import { appendFileSync, closeSync, existsSync, mkdirSync, openSync, readdirSync, readSync, rmSync, statSync, writeFileSync, } from "fs";
-import { appendFile, open, readdir, rm } from "fs/promises";
+import { appendFile, mkdir, open, readdir, rm } from "fs/promises";
 import { basename, join, resolve } from "path";
 import { StringDecoder } from "string_decoder";
 import { APP_NAME, getAgentDir as getDefaultAgentDir, getSessionsDir } from "../config.js";
@@ -1230,6 +1230,20 @@ export class SessionManager {
     isPersisted() {
         return this.persist;
     }
+    /** Give an unclaimed in-memory session its first file without rebuilding or changing its identity. */
+    async enablePersistence() {
+        if (this.persist)
+            return;
+        const dir = getDefaultSessionDirPath(this.cwd);
+        await mkdir(dir, { recursive: true });
+        const header = this.fileEntries[0];
+        const path = join(dir, `${header.timestamp.replace(/[:.]/g, "-")}_${this.sessionId}.jsonl`);
+        reserveSessionWrite(path);
+        this.sessionDir = dir;
+        this.sessionFile = path;
+        this.persist = true;
+        registerSessionWriter(this);
+    }
     getCwd() {
         return this.cwd;
     }

package/dist/core/settings-manager.d.ts

@@ -302,6 +302,12 @@ export declare class SettingsManager {
     getSettings(): Settings;
     getGlobalSettings(): Settings;
     getProjectSettings(): Settings;
+    /**
+     * `contextFiles.globalPath` from the user's own layers only: session overrides, then global
+     * settings. A project's `.senpi/settings.json` never redirects the user's global context file
+     * (senpi#5567), so the project layer is deliberately skipped.
+     */
+    getGlobalContextFilePath(): string | undefined;
     /** The project settings file at `path` as stored: parsed and migrated like a load, but never gated by trust. */
     readProjectSettingsFile(path: string): ProjectSettingsFile;
     /**

package/dist/core/settings-manager.js

@@ -697,6 +697,14 @@ export class SettingsManager {
     getProjectSettings() {
         return structuredClone(this.projectSettings);
     }
+    /**
+     * `contextFiles.globalPath` from the user's own layers only: session overrides, then global
+     * settings. A project's `.senpi/settings.json` never redirects the user's global context file
+     * (senpi#5567), so the project layer is deliberately skipped.
+     */
+    getGlobalContextFilePath() {
+        return this.runtimeOverrides.contextFiles?.globalPath ?? this.globalSettings.contextFiles?.globalPath;
+    }
     /** The project settings file at `path` as stored: parsed and migrated like a load, but never gated by trust. */
     readProjectSettingsFile(path) {
         let content;

package/dist/core/turn-origin.d.ts

@@ -1,15 +1,15 @@
-import type { SessionManager } from "./session-manager.ts";
 /**
- * Who started a turn, for the delegated-default permission rule (remote approval-mode work):
- * - `local`: a local connection's or the TUI's own input;
- * - `delegated`: input that arrived on a delegated (remote device) connection;
+ * Who started a turn, for the remote approval-mode rule (senpi#6342: a turn follows the permission setting of the machine
+ * it runs on, and no origin outlives the turn it started):
+ * - `local`: this machine's own input, or input from a device the forwarder stated is the same account;
+ * - `delegated`: input from a device the forwarder did not state is the same account, or the one run such a device's
+ *   record started;
  * - `engine`: a turn no client record started (an extension's message, a goal or loop turn, restored input).
  * A steer joins the running turn (`join`) and never changes its origin.
  */
 export type TurnOrigin = "local" | "delegated" | "engine";
 export type InputTurnMark = TurnOrigin | "join";
 export type ConnectionOrigin = "local" | "delegated";
-type OriginSessionManager = Pick<SessionManager, "getEntries" | "appendCustomEntry">;
 /** The mark an input gets where it is created: explicit for client records, `local` for the TUI, else `engine`. */
 export declare function inputTurnMark(input: {
     readonly mode?: "steer" | "followUp";
@@ -21,11 +21,19 @@ export declare function markInputTurnOrigin(message: object, mark: InputTurnMark
 export declare function copyInputTurnMark(from: object, to: object): void;
 /** Whether a message carries an origin mark: a user message always opens a turn's origin, any other only when marked. */
 export declare function hasInputTurnMark(message: object): boolean;
-/** A run starts as engine work; the user message that opens a turn sets its origin, a steer keeps it. */
+/** Runs `handle`, and every async task it starts, as the record `origin` describes. */
+export declare function runInRecordScope<T>(origin: ConnectionOrigin, handle: () => Promise<T>): Promise<T>;
+/** Whether the work being created belongs to an open cross-account record's own handling. */
+export declare function recordIsDelegated(): boolean;
+/**
+ * A run starts as engine work, or as delegated work when a cross-account record's own handling starts it; a retry keeps
+ * the turn it continues. The user message that opens a turn sets its origin, a steer keeps it.
+ */
 export declare function noteRunStart(sessionManager: object): void;
+/** A retry or recovery run repeats the turn it continues, so it keeps that turn's origin until the continuation ends. */
+export declare function noteTurnContinuation(sessionManager: object): void;
+export declare function endTurnContinuation(sessionManager: object): void;
 export declare function noteUserMessageStart(sessionManager: object, message: object): void;
-export declare function recordDelegatedOrigin(sessionManager: OriginSessionManager): void;
-/** Whether the deciding turn counts as delegated-origin: a remote device started it, or nobody did on a remote-driven session. */
-export declare function decidingTurnIsDelegated(sessionManager: Pick<SessionManager, "getEntries">): boolean;
-export {};
+/** Whether the deciding turn counts as delegated-origin: a cross-account device started this turn or this run. */
+export declare function decidingTurnIsDelegated(sessionManager: object): boolean;
 //# sourceMappingURL=turn-origin.d.ts.map

package/dist/core/turn-origin.js

@@ -1,13 +1,16 @@
-const DELEGATED_ORIGIN_ENTRY = "delegated_origin";
+import { AsyncLocalStorage } from "node:async_hooks";
 const inputMarks = new WeakMap();
 const currentOrigins = new WeakMap();
-const delegatedSessions = new WeakSet();
+const recordScopes = new AsyncLocalStorage();
+const continuingTurns = new WeakSet();
 /** The mark an input gets where it is created: explicit for client records, `local` for the TUI, else `engine`. */
 export function inputTurnMark(input) {
     if (input.mode === "steer")
         return "join";
     if (input.connectionOrigin !== undefined)
         return input.connectionOrigin;
+    if (recordIsDelegated())
+        return "delegated";
     return input.source === undefined || input.source === "interactive" ? "local" : "engine";
 }
 export function markInputTurnOrigin(message, mark) {
@@ -23,9 +26,34 @@ export function copyInputTurnMark(from, to) {
 export function hasInputTurnMark(message) {
     return inputMarks.has(message);
 }
-/** A run starts as engine work; the user message that opens a turn sets its origin, a steer keeps it. */
+/** Runs `handle`, and every async task it starts, as the record `origin` describes. */
+export function runInRecordScope(origin, handle) {
+    return recordScopes.run({ origin, open: true }, handle);
+}
+/** Whether the work being created belongs to an open cross-account record's own handling. */
+export function recordIsDelegated() {
+    const scope = recordScopes.getStore();
+    return scope?.open === true && scope.origin === "delegated";
+}
+/**
+ * A run starts as engine work, or as delegated work when a cross-account record's own handling starts it; a retry keeps
+ * the turn it continues. The user message that opens a turn sets its origin, a steer keeps it.
+ */
 export function noteRunStart(sessionManager) {
-    currentOrigins.set(sessionManager, "engine");
+    if (continuingTurns.has(sessionManager))
+        return;
+    const delegated = recordIsDelegated();
+    const scope = recordScopes.getStore();
+    if (scope !== undefined)
+        scope.open = false;
+    currentOrigins.set(sessionManager, delegated ? "delegated" : "engine");
+}
+/** A retry or recovery run repeats the turn it continues, so it keeps that turn's origin until the continuation ends. */
+export function noteTurnContinuation(sessionManager) {
+    continuingTurns.add(sessionManager);
+}
+export function endTurnContinuation(sessionManager) {
+    continuingTurns.delete(sessionManager);
 }
 export function noteUserMessageStart(sessionManager, message) {
     const mark = inputMarks.get(message);
@@ -33,32 +61,8 @@ export function noteUserMessageStart(sessionManager, message) {
         return;
     currentOrigins.set(sessionManager, mark ?? "engine");
 }
-export function recordDelegatedOrigin(sessionManager) {
-    if (delegatedOriginOf(sessionManager))
-        return;
-    delegatedSessions.add(sessionManager);
-    sessionManager.appendCustomEntry(DELEGATED_ORIGIN_ENTRY, { delegatedOrigin: true }, { startupBookkeeping: true });
-}
-// How many entries a session's scan has already found free of the marker: each gated decision reads only new entries.
-const scannedEntries = new WeakMap();
-function delegatedOriginOf(sessionManager) {
-    if (delegatedSessions.has(sessionManager))
-        return true;
-    const entries = sessionManager.getEntries();
-    const persisted = entries
-        .slice(scannedEntries.get(sessionManager) ?? 0)
-        .some((entry) => entry.type === "custom" && entry.customType === DELEGATED_ORIGIN_ENTRY);
-    if (persisted)
-        delegatedSessions.add(sessionManager);
-    else
-        scannedEntries.set(sessionManager, entries.length);
-    return persisted;
-}
-/** Whether the deciding turn counts as delegated-origin: a remote device started it, or nobody did on a remote-driven session. */
+/** Whether the deciding turn counts as delegated-origin: a cross-account device started this turn or this run. */
 export function decidingTurnIsDelegated(sessionManager) {
-    const origin = currentOrigins.get(sessionManager) ?? "engine";
-    if (origin === "delegated")
-        return true;
-    return origin === "engine" && delegatedOriginOf(sessionManager);
+    return currentOrigins.get(sessionManager) === "delegated";
 }
 //# sourceMappingURL=turn-origin.js.map

package/dist/core/ultrafast-lanes.d.ts

@@ -4,5 +4,6 @@ export declare function serviceTierForProvider(provider: string | undefined, ser
 export declare function ultrafastSelectionWarning(model: {
     readonly provider: string;
     readonly id: string;
+    readonly upstreamModelId?: string;
 }, serviceTier: ServiceTier | undefined): string | undefined;
 //# sourceMappingURL=ultrafast-lanes.d.ts.map

package/dist/core/ultrafast-lanes.js

@@ -1,3 +1,4 @@
+import { ULTRAFAST_DOCUMENTED_MODEL_IDS } from "@earendil-works/pi-ai";
 /**
  * Providers that receive `service_tier: "ultrafast"`: OpenAI's own API and the ChatGPT
  * subscription backend. Gateways and other providers serving an OpenAI model on the Responses
@@ -5,7 +6,6 @@
  * sends Ultrafast only to first-party OpenAI and Codex models).
  */
 const ULTRAFAST_PROVIDERS = new Set(["openai", "chatgpt-subscription"]);
-const ULTRAFAST_DOCUMENTED_MODEL_IDS = new Set(["gpt-6-astra", "gpt-6.1-sol"]);
 export function serviceTierForProvider(provider, serviceTier) {
     if (serviceTier !== "ultrafast")
         return serviceTier;
@@ -18,7 +18,9 @@ export function ultrafastSelectionWarning(model, serviceTier) {
     if (!ULTRAFAST_PROVIDERS.has(model.provider)) {
         return `Ultrafast is only sent to OpenAI and ChatGPT Subscription; ${model.provider}/${model.id} runs at its default tier`;
     }
-    if (ULTRAFAST_DOCUMENTED_MODEL_IDS.has(model.id))
+    // A tier-pinned row (for example `gpt-6.1-sol-ultrafast`) is documented by its upstream model,
+    // as the pricing code already checks (senpi#2978).
+    if (ULTRAFAST_DOCUMENTED_MODEL_IDS.has(model.upstreamModelId ?? model.id))
         return undefined;
     return `Ultrafast is documented for GPT-6 Astra and GPT-6.1 Sol; ${model.provider}/${model.id} may reject or ignore it`;
 }

package/dist/modes/interactive/components/footer.d.ts

@@ -10,11 +10,26 @@ export declare function formatTokens(count: number): string;
 /**
  * Mirrors the provider-shown-only-when->1 rule for accounts: the active account
  * name appears only when the provider actually pools more than one slot. The
- * pick shown is the pin when present, else the first account of the user order
- * (senpi#3591), else the session's HRW winner - the same ranking the rotation
- * engine uses, so the footer names the slot that will serve.
+ * pick shown is the effective pin (CLI > settings > stored, senpi#5983) when
+ * present, else the first account of the user order (senpi#3591), else the
+ * session's HRW winner - the same ranking the rotation engine uses, so the
+ * footer names the slot that will serve. The effective pin only reaches the
+ * footer for the Anthropic subscription provider (senpi#6222 review); other
+ * pooled providers keep their stored pin even when a slot shares the pin's
+ * name. A blocked pin (blockedUntil in the
+ * future) is skipped for the first usable slot in that ranking, and the
+ * suffix marks the blocked pin (`@B (A blocked until 14:00)`); when every
+ * slot is blocked it names the top-ranked slot and marks it blocked instead
+ * of silently naming a slot that cannot serve. Block state rides on the
+ * stored slots (SlotBlockState); slots without it are treated as usable.
  */
-export declare function accountFooterSuffix(credential: Credential | undefined, sessionId: string): string;
+export type AccountFooterOptions = {
+    /** Effective pin from CLI/settings, outranking the stored pin (senpi#5983). */
+    pinnedAccount?: string;
+    /** Override for "now" (tests); defaults to `Date.now()`. */
+    now?: number;
+};
+export declare function accountFooterSuffix(credential: Credential | undefined, sessionId: string, options?: AccountFooterOptions): string;
 export declare function formatCwdForFooter(cwd: string, home: string | undefined): string;
 /**
  * Footer component that shows pwd, token stats, and context usage.
@@ -25,7 +40,10 @@ export declare class FooterComponent implements Component {
     private footerData;
     private autoCompactEnabled;
     private compactionDelegated;
-    constructor(session: AgentSession, footerData: ReadonlyFooterDataProvider);
+    private resolveAccountPin;
+    constructor(session: AgentSession, footerData: ReadonlyFooterDataProvider, options?: {
+        resolveAccountPin?: (sessionId: string) => string | undefined;
+    });
     setSession(session: AgentSession): void;
     setAutoCompactEnabled(enabled: boolean): void;
     /**

package/dist/modes/interactive/components/footer.js

@@ -4,6 +4,7 @@ import { slotsOfOwnKind } from "@earendil-works/pi-ai/auth/pool/kinds";
 import { applyAccountOrder, rendezvousOrder } from "@earendil-works/pi-ai/auth/pool/select";
 import { accountLabel } from "@earendil-works/pi-ai/auth/pool/slots";
 import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import { ANTHROPIC_SUBSCRIPTION_PROVIDER_ID } from "../../../core/extensions/builtin/anthropic-subscription/provider-id.js";
 import { theme } from "../theme/theme.js";
 import { planFooterLayout } from "./footer-layout.js";
 import { buildRightLabel, colorRightSide } from "./footer-right-label.js";
@@ -39,25 +40,43 @@ export function formatTokens(count) {
         return `${trim1(n / 1_000_000_000)}B`;
     return `${Math.round(n / 1_000_000_000)}B`;
 }
-/**
- * Mirrors the provider-shown-only-when->1 rule for accounts: the active account
- * name appears only when the provider actually pools more than one slot. The
- * pick shown is the pin when present, else the first account of the user order
- * (senpi#3591), else the session's HRW winner - the same ranking the rotation
- * engine uses, so the footer names the slot that will serve.
- */
-export function accountFooterSuffix(credential, sessionId) {
+function formatBlockedUntil(until) {
+    const date = new Date(until);
+    return `${String(date.getHours()).padStart(2, "0")}:${String(date.getMinutes()).padStart(2, "0")}`;
+}
+export function accountFooterSuffix(credential, sessionId, options = {}) {
     const pooled = credential;
     // Only slots the credential can serve with; a mixed pool's other-kind slot never does (senpi#3486).
     const slots = credential ? slotsOfOwnKind(credential) : [];
     if (slots.length < 2)
         return "";
-    const pinned = Object.entries(credential ?? {}).find(([key]) => key === "pinned")?.[1];
-    const pinnedSlot = slots.find((slot) => slot.name === pinned);
-    if (pinnedSlot)
-        return `@${footerAccountLabel(pinnedSlot)}`;
-    const winner = applyAccountOrder(pooled?.order, rendezvousOrder(sessionId, slots, (input) => createHash("sha256").update(input).digest().readBigUInt64BE(0)))[0];
-    return winner === undefined ? "" : `@${footerAccountLabel(winner)}`;
+    const now = options.now ?? Date.now();
+    // Block state rides on the stored slots at runtime (SlotBlockState) but
+    // is not part of the CredentialSlot type, so read it through unknown.
+    const blockedUntilOf = (slot) => slot.blockedUntil;
+    const isBlocked = (slot) => {
+        const until = blockedUntilOf(slot);
+        return until !== undefined && until > now;
+    };
+    const ranked = applyAccountOrder(pooled?.order, rendezvousOrder(sessionId, slots, (input) => createHash("sha256").update(input).digest().readBigUInt64BE(0)));
+    const storedPinned = Object.entries(credential ?? {}).find(([key]) => key === "pinned")?.[1];
+    const pinnedName = options.pinnedAccount ?? storedPinned;
+    const pinnedSlot = pinnedName === undefined ? undefined : slots.find((slot) => slot.name === pinnedName);
+    if (pinnedSlot) {
+        if (!isBlocked(pinnedSlot))
+            return `@${footerAccountLabel(pinnedSlot)}`;
+        const until = blockedUntilOf(pinnedSlot);
+        const serving = ranked.find((slot) => slot !== pinnedSlot && !isBlocked(slot));
+        if (serving)
+            return `@${footerAccountLabel(serving)} (${footerAccountLabel(pinnedSlot)} blocked until ${formatBlockedUntil(until)})`;
+        return `@${footerAccountLabel(pinnedSlot)} (blocked until ${formatBlockedUntil(until)})`;
+    }
+    const winner = ranked.find((slot) => !isBlocked(slot)) ?? ranked[0];
+    if (winner === undefined)
+        return "";
+    if (isBlocked(winner))
+        return `@${footerAccountLabel(winner)} (blocked until ${formatBlockedUntil(blockedUntilOf(winner))})`;
+    return `@${footerAccountLabel(winner)}`;
 }
 /**
  * Widest account label the provider segment carries. A label wider than this
@@ -90,11 +109,12 @@ export function formatCwdForFooter(cwd, home) {
  * Computes token/context stats from session, gets git branch and extension statuses from provider.
  */
 export class FooterComponent {
-    constructor(session, footerData) {
+    constructor(session, footerData, options = {}) {
         this.autoCompactEnabled = true;
         this.compactionDelegated = false;
         this.session = session;
         this.footerData = footerData;
+        this.resolveAccountPin = options.resolveAccountPin;
     }
     setSession(session) {
         this.session = session;
@@ -201,7 +221,16 @@ export class FooterComponent {
         let accountSuffix = "";
         if (state.model) {
             try {
-                accountSuffix = accountFooterSuffix(this.session.modelRegistry.authStorage.get(state.model.provider), this.session.sessionManager.getSessionId());
+                const sessionId = this.session.sessionManager.getSessionId();
+                // The resolver carries the Anthropic CLI/settings pin; resolve
+                // it only when the current model uses the Anthropic
+                // subscription provider. A same-named slot of another pooled
+                // provider (e.g. openai-codex "default") keeps its own stored
+                // pin instead (senpi#6222 review).
+                const pinnedAccount = state.model.provider === ANTHROPIC_SUBSCRIPTION_PROVIDER_ID
+                    ? this.resolveAccountPin?.(sessionId)
+                    : undefined;
+                accountSuffix = accountFooterSuffix(this.session.modelRegistry.authStorage.get(state.model.provider), sessionId, pinnedAccount === undefined ? undefined : { pinnedAccount });
             }
             catch {
                 // The footer must render even when credential storage is unreadable.

package/dist/modes/interactive/interactive-mode.js

@@ -25,6 +25,8 @@ import { collectEntriesForBranchSummary } from "../../core/compaction/branch-sum
 import { findExtensionStackMatches } from "../../core/crash-log.js";
 import { AssistantEditError, assistantTextEquals } from "../../core/edited-assistant-message.js";
 import { subscribeProviderAccountEvents } from "../../core/extensions/builtin/anthropic-subscription/account-events.js";
+import { getSessionClaudeAccountPin, resolveClaudeAccountPin, } from "../../core/extensions/builtin/anthropic-subscription/account-command.js";
+import { loadAnthropicSubscriptionProviderSettingsFromDisk } from "../../core/extensions/builtin/anthropic-subscription/settings.js";
 import { formatAccountFailoverNotice } from "./account-failover-notice.js";
 import { askUserAnswerDisplayText, formatUserMessage, showsPartialAnswers, } from "../../core/extensions/builtin/ask-user/format.js";
 import { askUserRenderers } from "../../core/extensions/builtin/ask-user/render.js";
@@ -817,7 +819,13 @@ export class InteractiveMode {
         this.footerDataProvider = new FooterDataProvider(this.sessionManager.getCwd());
         this.footer = this.chrome
             ? this.chrome.createFooter(this.session, this.footerDataProvider)
-            : new FooterComponent(this.session, this.footerDataProvider);
+            : new FooterComponent(this.session, this.footerDataProvider, {
+                // CLI > settings > stored pin, resolved per render so a
+                // mid-session /claude-account pin or settings change is
+                // picked up (senpi#5983); the stored pin stays the
+                // fallback inside accountFooterSuffix.
+                resolveAccountPin: (sessionId) => resolveClaudeAccountPin(getSessionClaudeAccountPin(sessionId), loadAnthropicSubscriptionProviderSettingsFromDisk(this.sessionManager.getCwd()).pinnedAccount, undefined),
+            });
         this.footer.setAutoCompactEnabled(this.session.autoCompactionEnabled);
         this.footerContainer = new Container();
         this.footerContainer.addChild(this.footer);

package/dist/modes/interactive/session-control-rpc-commands.d.ts

@@ -1,7 +1,7 @@
 import type { AgentSession } from "../../core/agent-session.ts";
 import { type ControlAttachments } from "./session-control-attach.ts";
 import { type ControlCommand, type ControlConnection } from "./session-control-server.ts";
-export declare const TUI_RPC_COMMANDS: readonly ["open_session", "get_snapshot", "subscribe_sessions", "unsubscribe_sessions", "steer", "follow_up", "prompt", "admit_external_message", "get_effect_status", "set_client_info", "attach_session", "release_attachment", "abort", "mcp_presenter_context", "mcp_form_presented", "mcp_form_response", "mcp_form_sync", "mcp_presenter_secret_answer"];
+export declare const TUI_RPC_COMMANDS: readonly ["open_session", "park_session", "claim_session", "get_snapshot", "subscribe_sessions", "unsubscribe_sessions", "steer", "follow_up", "prompt", "admit_external_message", "get_effect_status", "set_client_info", "attach_session", "release_attachment", "abort", "mcp_presenter_context", "mcp_form_presented", "mcp_form_response", "mcp_form_sync", "mcp_presenter_secret_answer"];
 export interface RpcCommandContext {
     /** This endpoint's instance id: the `expectedHostInstance` an `attach_session` may name. */
     readonly instanceId: string;