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

package/dist/core/auth-storage.js

@@ -4,6 +4,7 @@
  */
 import { findEnvKeys, getEnvApiKey, readByProviderId } from "@earendil-works/pi-ai";
 import { slotKind, unusedSlotKinds } from "@earendil-works/pi-ai/auth/pool/kinds";
+import { stampLogin } from "@earendil-works/pi-ai/auth/pool/login-id";
 import { appendLoginSlot, listSlots, projectSlot, removeSlot, repairManagedSentinelSlots, upsertSlot, } from "@earendil-works/pi-ai/auth/pool/slots";
 import { builtinProviders } from "@earendil-works/pi-ai/providers/all";
 import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from "fs";
@@ -16,6 +17,7 @@ import { stripBom } from "../utils/text.js";
 import { signOutLegacyClaudeLogins } from "./anthropic-legacy-sign-out.js";
 import { resolveReadOnlyCredential, resolveStoredCredential, resolveStoredSlot, validateReadOnlyAuthData, } from "./auth-credential-values.js";
 import { migrateLegacyProviderKeys } from "./auth-provider-key-migration.js";
+import { describeAuthStoreLoadFailure, failureAfterRead, parseAuthDocument, } from "./auth-store-load-error.js";
 import { ANTHROPIC_SUBSCRIPTION_PROVIDER_ID } from "./extensions/builtin/anthropic-subscription/provider-id.js";
 import { signInAgainMessage, signInRequiredNames } from "./extensions/builtin/anthropic-subscription/sign-in-again.js";
 import { lockWithLossHandling } from "./file-lock.js";
@@ -392,7 +394,7 @@ export class AuthStorage {
         // Mutation paths keep the stored keys as-is: the key migration (and its
         // pre-write backup) belongs to the load seam, so a write can never drop a
         // legacy entry without the backup that preserves it.
-        return repairPoisonedPoolSlots(JSON.parse(stripBom(content))).data;
+        return repairPoisonedPoolSlots(parseAuthDocument(content)).data;
     }
     /**
      * Reports whether the parse healed poisoned pool slots or moved legacy
@@ -406,7 +408,7 @@ export class AuthStorage {
         if (!content) {
             return { data: {}, repaired: false, migrated: false };
         }
-        const repaired = repairPoisonedPoolSlots(JSON.parse(stripBom(content)));
+        const repaired = repairPoisonedPoolSlots(parseAuthDocument(content));
         const migrated = migrateLegacyProviderKeys(repaired.data);
         const moved = signOutLegacyClaudeLogins(migrated.data);
         if (moved.skipped && !this.reportedMigrationSkips.has(moved.skipped)) {
@@ -444,19 +446,37 @@ export class AuthStorage {
         this.data = data;
         this.dataLoaded = true;
         this.dataFromBusyRead = false;
+        this.loadError = undefined;
         this.readState.data = data;
         this.readState.loaded = true;
         this.readState.revision = revision;
     }
+    /** The shared read state holds the store's current contents: this instance answers from it again. */
+    adoptReadState(data) {
+        this.data = data;
+        this.dataLoaded = true;
+        this.dataFromBusyRead = false;
+        this.loadError = undefined;
+        return data;
+    }
+    /** A sync write that parsed and saved the locked store proves it loads again. */
+    writeLocked(fn) {
+        const result = this.storage.withLock(fn);
+        this.loadError = undefined;
+        return result;
+    }
     /**
      * Reload credentials from storage.
      */
     reload() {
         let data = {};
         let revision;
+        const load = { parsed: false, writeBack: false };
         try {
             this.storage.withLock((current) => {
                 const parsed = this.parseStorageContent(current);
+                load.parsed = true;
+                load.writeBack = parsed.repaired || parsed.migrated;
                 data = parsed.data;
                 // A written repair or migration invalidates the revision read before
                 // it; leaving it unset makes the next reader re-read instead of
@@ -472,9 +492,17 @@ export class AuthStorage {
             this.updateReadState(data, revision);
             return "loaded";
         }
-        catch (error) {
-            // Preserve the last valid in-memory snapshot.
-            this.recordError(error instanceof Error ? error : new Error(String(error)));
+        catch (rawError) {
+            const error = failureAfterRead(rawError, load);
+            const recorded = this.noteLoadFailure(error);
+            // auth.json parsed and only a later step failed (a write-back or a lost lock): its parsed
+            // credentials stand, as on the async path. A failure before the parse keeps the last snapshot.
+            if (load.parsed) {
+                this.updateReadState(data, revision);
+                this.loadError = describeAuthStoreLoadFailure(error);
+            }
+            if (!recorded)
+                return "failed";
             if (!(error instanceof CredentialStoreBusyError))
                 return "failed";
             if (!this.dataLoaded) {
@@ -492,6 +520,30 @@ export class AuthStorage {
     isCredentialStoreBusy() {
         return this.dataFromBusyRead;
     }
+    /**
+     * Why the store could not be loaded on its last read, or undefined once any read or write of this
+     * instance finds it good again (senpi#4413). While set, the in-memory credentials are not the store's
+     * contents; a store that cannot be read or parsed also refuses every write.
+     */
+    getLoadError() {
+        return this.loadError;
+    }
+    /**
+     * Records a failed read; returns false when it repeats the load error already reported, so a store
+     * that stays broken is not re-recorded on every status read that retries it.
+     */
+    noteLoadFailure(error) {
+        const loadError = describeAuthStoreLoadFailure(error);
+        const repeated = loadError !== undefined &&
+            this.loadError?.kind === loadError.kind &&
+            this.loadError.reason === loadError.reason;
+        if (loadError)
+            this.loadError = loadError;
+        if (repeated)
+            return false;
+        this.recordError(error);
+        return true;
+    }
     /**
      * Monotonic count of reads (sync or async) that found the store locked before it ever
      * loaded and answered with the empty placeholder. A change across an operation means
@@ -524,12 +576,12 @@ export class AuthStorage {
      * `takeReplacement`, so no credential disappears without the user being told where it went.
      */
     set(provider, credential) {
-        return this.storage.withLock((content) => {
+        return this.writeLocked((content) => {
             const currentData = this.parseStorageData(content);
             const replacement = this.noteReplacement(provider, currentData[provider], credential, content);
-            const next = appendLoginSlot(currentData[provider], credential, undefined, {
+            const next = stampLogin(appendLoginSlot(currentData[provider], credential, undefined, {
                 accountIdentity: this.oauthAuth(provider)?.accountIdentity,
-            });
+            }));
             const nextData = { ...currentData, [provider]: next };
             this.data = nextData;
             return { result: replacement, next: JSON.stringify(nextData, null, 2) };
@@ -609,7 +661,7 @@ export class AuthStorage {
         return replacement;
     }
     remove(provider) {
-        this.storage.withLock((content) => {
+        this.writeLocked((content) => {
             const nextData = { ...this.parseStorageData(content) };
             delete nextData[provider];
             this.data = nextData;
@@ -619,17 +671,21 @@ export class AuthStorage {
     listSlots(provider) {
         return listSlots(readByProviderId(this.data, provider));
     }
+    /** Adding a new slot is a sign-in and stamps a fresh `loginId`; updating an existing slot keeps it (senpi#4099). */
     setSlot(provider, slot) {
-        this.storage.withLock((content) => {
+        this.writeLocked((content) => {
             const currentData = this.parseStorageData(content);
-            const next = upsertSlot(currentData[provider], slot);
+            const current = currentData[provider];
+            const upserted = upsertSlot(current, slot);
+            const adds = !listSlots(current).some((existing) => existing.name === slot.name);
+            const next = adds ? stampLogin(upserted) : upserted;
             const nextData = { ...currentData, [provider]: next };
             this.data = nextData;
             return { result: undefined, next: JSON.stringify(nextData, null, 2) };
         });
     }
     removeSlot(provider, name) {
-        this.storage.withLock((content) => {
+        this.writeLocked((content) => {
             const currentData = this.parseStorageData(content);
             const next = removeSlot(currentData[provider], name);
             const nextData = { ...currentData };
@@ -666,16 +722,34 @@ export class AuthStorage {
         return errors;
     }
     async reloadFromStorageAsync(options) {
-        return this.storage.withLockAsync(async (content) => {
-            const parsed = this.parseStorageContent(content);
-            const revision = parsed.repaired || parsed.migrated || !this.authPath ? undefined : getFileContentRevision(this.authPath);
-            this.updateReadState(parsed.data, revision);
-            if (parsed.migrated)
-                this.backupAuthFile(content);
-            return parsed.repaired || parsed.migrated
-                ? { result: parsed.data, next: JSON.stringify(parsed.data, null, 2) }
-                : { result: parsed.data };
-        }, options);
+        try {
+            return await this.reloadLockedAsync(options);
+        }
+        catch (error) {
+            if (!options?.signal?.aborted)
+                this.loadError = describeAuthStoreLoadFailure(error) ?? this.loadError;
+            throw error;
+        }
+    }
+    async reloadLockedAsync(options) {
+        const load = { parsed: false, writeBack: false };
+        try {
+            return await this.storage.withLockAsync(async (content) => {
+                const parsed = this.parseStorageContent(content);
+                load.parsed = true;
+                load.writeBack = parsed.repaired || parsed.migrated;
+                const revision = parsed.repaired || parsed.migrated || !this.authPath ? undefined : getFileContentRevision(this.authPath);
+                this.updateReadState(parsed.data, revision);
+                if (parsed.migrated)
+                    this.backupAuthFile(content);
+                return parsed.repaired || parsed.migrated
+                    ? { result: parsed.data, next: JSON.stringify(parsed.data, null, 2) }
+                    : { result: parsed.data };
+            }, options);
+        }
+        catch (error) {
+            throw failureAfterRead(error, load);
+        }
     }
     async readLatestData(options) {
         options?.signal?.throwIfAborted();
@@ -692,7 +766,7 @@ export class AuthStorage {
         }
         const revision = getFileContentRevision(this.authPath);
         if (revision !== undefined && revision === this.readState.revision)
-            return this.readState.data;
+            return this.adoptReadState(this.readState.data);
         if (!this.readState.reload) {
             const controller = new AbortController();
             const reload = {
@@ -715,10 +789,11 @@ export class AuthStorage {
         reload.readers++;
         try {
             try {
-                return await raceWithAbortSignal(reload.promise, options?.signal);
+                return this.adoptReadState(await raceWithAbortSignal(reload.promise, options?.signal));
             }
             catch (error) {
                 options?.signal?.throwIfAborted();
+                this.loadError = describeAuthStoreLoadFailure(error) ?? this.loadError;
                 this.noteBusyFallback(error);
                 return this.readState.data;
             }

package/dist/core/auth-store-load-error.d.ts

@@ -0,0 +1,29 @@
+export type AuthStoreLoadErrorKind = "malformed_json" | "invalid_format" | "unreadable" | "write_back_failed";
+/**
+ * Why an existing auth.json could not be loaded (senpi#4413). `reason` is safe to show and send to
+ * clients: it never carries the file's path or contents.
+ */
+export interface AuthStoreLoadError {
+    readonly kind: AuthStoreLoadErrorKind;
+    readonly reason: string;
+}
+export declare class AuthStoreUnreadableError extends Error {
+    readonly loadError: AuthStoreLoadError;
+    constructor(loadError: AuthStoreLoadError);
+}
+/** The top-level object of an auth.json document; anything else is refused rather than read as empty. */
+export declare function parseAuthDocument(content: string): Record<string, unknown>;
+/**
+ * The load error a failed store read stands for, or undefined when the failure says nothing about
+ * the file: a lock held by another writer, a read the caller aborted, or a lock lost after a clean read.
+ */
+export declare function describeAuthStoreLoadFailure(error: unknown): AuthStoreLoadError | undefined;
+/**
+ * The error a store load surfaces: once auth.json parsed, a later failure (a write-back or a lost lock)
+ * becomes an AuthStoreAfterReadError so it is never reported as an unreadable file. Aborts pass through.
+ */
+export declare function failureAfterRead(error: unknown, load: {
+    parsed: boolean;
+    writeBack: boolean;
+}): unknown;
+//# sourceMappingURL=auth-store-load-error.d.ts.map

package/dist/core/auth-store-load-error.js

@@ -0,0 +1,74 @@
+import { stripBom } from "../utils/text.js";
+import { CredentialStoreBusyError } from "./lockfile-policy.js";
+export class AuthStoreUnreadableError extends Error {
+    constructor(loadError) {
+        super(`Your sign-in store (auth.json) could not be read: ${loadError.reason}. Nothing was changed; repair or move auth.json in the agent directory, then sign in again.`);
+        this.name = "AuthStoreUnreadableError";
+        this.loadError = loadError;
+    }
+}
+/**
+ * A store load that failed after auth.json was read and parsed: saving its repaired or migrated copy
+ * failed (`wroteBack`), or the lock was lost once the read was done. Neither means the file is unreadable.
+ */
+class AuthStoreAfterReadError extends Error {
+    constructor(cause, wroteBack) {
+        const detail = cause instanceof Error ? cause.message : String(cause);
+        super(wroteBack
+            ? `auth.json was read, but saving its repaired or migrated copy failed: ${detail}`
+            : `auth.json was read, but its lock was lost before the read finished: ${detail}`, { cause });
+        this.name = "AuthStoreAfterReadError";
+        this.wroteBack = wroteBack;
+    }
+}
+/** The top-level object of an auth.json document; anything else is refused rather than read as empty. */
+export function parseAuthDocument(content) {
+    let parsed;
+    try {
+        parsed = JSON.parse(stripBom(content));
+    }
+    catch {
+        throw new AuthStoreUnreadableError({ kind: "malformed_json", reason: "it is not valid JSON" });
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+        throw new AuthStoreUnreadableError({ kind: "invalid_format", reason: "it does not hold a JSON object" });
+    }
+    return parsed;
+}
+/**
+ * The load error a failed store read stands for, or undefined when the failure says nothing about
+ * the file: a lock held by another writer, a read the caller aborted, or a lock lost after a clean read.
+ */
+export function describeAuthStoreLoadFailure(error) {
+    if (error instanceof AuthStoreUnreadableError)
+        return error.loadError;
+    if (error instanceof CredentialStoreBusyError)
+        return undefined;
+    if (error instanceof Error && error.name === "AbortError")
+        return undefined;
+    if (error instanceof AuthStoreAfterReadError) {
+        if (!error.wroteBack)
+            return undefined;
+        const code = errnoCode(error.cause);
+        const reason = "it was read, but its repaired or migrated copy could not be saved";
+        return { kind: "write_back_failed", reason: code ? `${reason} (${code})` : reason };
+    }
+    const code = errnoCode(error);
+    return {
+        kind: "unreadable",
+        reason: code ? `the file could not be read (${code})` : "the file could not be read",
+    };
+}
+/**
+ * The error a store load surfaces: once auth.json parsed, a later failure (a write-back or a lost lock)
+ * becomes an AuthStoreAfterReadError so it is never reported as an unreadable file. Aborts pass through.
+ */
+export function failureAfterRead(error, load) {
+    if (!load.parsed || (error instanceof Error && error.name === "AbortError"))
+        return error;
+    return new AuthStoreAfterReadError(error, load.writeBack);
+}
+function errnoCode(error) {
+    return error instanceof Error && "code" in error && typeof error.code === "string" ? error.code : undefined;
+}
+//# sourceMappingURL=auth-store-load-error.js.map

package/dist/core/brand.d.ts

@@ -46,6 +46,8 @@ export interface BrandProfile {
     readonly userAgent: string;
     /** Product token used as the provider-side originator, when the distribution overrides it. */
     readonly originator?: string;
+    /** Product logo for the sign-in result pages, as a base64 image data URI. */
+    readonly logo?: string;
     /** Update channel of the branded product; absent means the product manages updates itself. */
     readonly update?: BrandUpdateChannel;
     readonly changelog?: BrandChangelog;

package/dist/core/brand.js

@@ -91,6 +91,7 @@ export function parseBrandProfile(raw) {
         envPrefix: (readString(source, "envPrefix") || name).toUpperCase(),
         userAgent: readString(source, "userAgent") || name,
         originator: readString(source, "originator"),
+        logo: readString(source, "logo"),
         update: readUpdateChannel(source),
         ...(changelog ? { changelog } : {}),
     };

package/dist/core/credential-pool/failover.d.ts

@@ -82,6 +82,14 @@ export declare class CredentialFailoverError extends Error {
     });
 }
 export declare function isAvailable(slot: Pick<RunSlot, "blockReason" | "blockedUntil">, now: number): boolean;
+/**
+ * The slots a request's next attempt may pick from: the untried, unblocked ones, else the cooling
+ * probe. Empty means the request is refused. Shared by the stream and by auxiliary callers that
+ * resolve the session's account outside it (senpi#3924), so both treat an all-blocked pool alike.
+ */
+export declare function attemptCandidates<TSlot extends RunSlot>(slots: readonly TSlot[], attempted: ReadonlySet<string>, now: number): TSlot[];
+/** The refusal a request gets when {@link attemptCandidates} is empty before any attempt ran. */
+export declare function noSlotsError(slots: readonly RunSlot[], now: number): CredentialFailoverError;
 /**
  * Generic in-lane credential failover. Runs at most one failover attempt per
  * slot per request, retries provider-scoped faults on the SAME slot up to the

package/dist/core/credential-pool/failover.js

@@ -46,6 +46,20 @@ function coolingProbe(slots, attempted) {
     const soonest = cooling.reduce((best, slot) => (best === undefined || (slot.blockedUntil ?? 0) < (best.blockedUntil ?? 0) ? slot : best), undefined);
     return soonest === undefined ? [] : [soonest];
 }
+/**
+ * The slots a request's next attempt may pick from: the untried, unblocked ones, else the cooling
+ * probe. Empty means the request is refused. Shared by the stream and by auxiliary callers that
+ * resolve the session's account outside it (senpi#3924), so both treat an all-blocked pool alike.
+ */
+export function attemptCandidates(slots, attempted, now) {
+    const available = slots.filter((slot) => !attempted.has(slot.name) && isAvailable(slot, now));
+    return available.length > 0 ? available : coolingProbe(slots, attempted);
+}
+/** The refusal a request gets when {@link attemptCandidates} is empty before any attempt ran. */
+export function noSlotsError(slots, now) {
+    const retryAt = soonestRetryAt(slots, now);
+    return new CredentialFailoverError({ kind: "fail_request" }, new Error(noSlotsMessage(slots, now)), retryAt === undefined ? {} : { retryAt });
+}
 /**
  * A slot's due-back time as the reader's local clock shows it, followed by the ISO instant that the goal
  * provider-retry scan (`providerRetryAt`) and turn-end liveness read from this text (senpi#4329).
@@ -134,17 +148,16 @@ export async function* runCredentialFailover(options) {
     try {
         while (true) {
             const slots = await options.listSlots();
-            const available = slots.filter((slot) => !attempted.has(slot.name) && isAvailable(slot, now()));
-            const candidates = available.length > 0 ? available : coolingProbe(slots, attempted);
+            const candidates = attemptCandidates(slots, attempted, now());
             if (candidates.length === 0) {
                 if (lastTerminalEvent !== undefined) {
                     yield lastTerminalEvent;
                     return;
                 }
+                if (lastError === undefined || lastOriginal === undefined)
+                    throw noSlotsError(slots, now());
                 const retryAt = soonestRetryAt(slots, now());
-                throw lastError !== undefined && lastOriginal !== undefined
-                    ? new CredentialFailoverError(lastError.action, lastOriginal, retryAt === undefined ? {} : { retryAt })
-                    : new CredentialFailoverError({ kind: "fail_request" }, new Error(noSlotsMessage(slots, now())), retryAt === undefined ? {} : { retryAt });
+                throw new CredentialFailoverError(lastError.action, lastOriginal, retryAt === undefined ? {} : { retryAt });
             }
             const slot = options.select(candidates);
             unsettled = slot;

package/dist/core/credential-pool/rotation-stream.d.ts

@@ -1,5 +1,5 @@
 import type { AssistantMessageEvent } from "@earendil-works/pi-ai";
-import { type SlotHasher } from "@earendil-works/pi-ai/auth/pool/select";
+import type { SlotHasher } from "@earendil-works/pi-ai/auth/pool/select";
 import { type RotationSlot, type RotationSources } from "./rotation-slots.ts";
 export { listRotationSlots, type RotationLane, type RotationSlot, type RotationSources } from "./rotation-slots.ts";
 /** The exact hash the claude-sdk-oauth affinity oracle uses, so pools never remap. */

package/dist/core/credential-pool/rotation-stream.js

@@ -1,5 +1,4 @@
 import { createHash, randomUUID } from "node:crypto";
-import { applyAccountOrder, rendezvousOrder } from "@earendil-works/pi-ai/auth/pool/select";
 import { emitProviderAccountFailover, emitProviderAccountsChanged, } from "../extensions/builtin/anthropic-subscription/account-events.js";
 import { AUTH_BLOCK_REPROBE_MS } from "./auth-reprobe.js";
 import { classifyCredentialFailure } from "./classify.js";
@@ -8,6 +7,7 @@ import { STORE_BUSY, writeHealthUnlessStoreBusy } from "./health-write.js";
 import { modelBlockKey, pruneModelBlocks, withModelBlock } from "./model-scope.js";
 import { isCommittedRotationOutput, isRotationStreamStart, rotationErrorFromEvent } from "./rotation-events.js";
 import { listRotationSlots, releaseProbeLease } from "./rotation-slots.js";
+import { pickRotationSlot } from "./session-slot.js";
 export { listRotationSlots } from "./rotation-slots.js";
 /** The exact hash the claude-sdk-oauth affinity oracle uses, so pools never remap. */
 export const sha256SlotHasher = (input) => createHash("sha256").update(input).digest().readBigUInt64BE(0);
@@ -79,12 +79,7 @@ export function streamWithCredentialRotation(options) {
     return runCredentialFailover({
         listSlots: () => listRotationSlots(sources, options.modelId === undefined ? {} : { modelId: options.modelId }),
         select: (candidates) => {
-            const pinned = candidates.find((candidate) => candidate.pinned === true);
-            if (pinned)
-                return pinned;
-            const ranked = useAffinity ? rendezvousOrder(affinityKey, candidates, hasher) : candidates;
-            const ordered = applyAccountOrder(pooled?.order, ranked);
-            const winner = ordered[0];
+            const winner = pickRotationSlot(candidates, { affinityKey, useAffinity, hasher, order: pooled?.order });
             if (!winner)
                 throw new Error("credential rotation selected from an empty candidate set");
             return winner;

package/dist/core/credential-pool/session-slot.d.ts

@@ -0,0 +1,20 @@
+import { type SlotHasher } from "@earendil-works/pi-ai/auth/pool/select";
+import type { RotationSlot } from "./rotation-slots.ts";
+export type SlotPickPolicy = {
+    affinityKey: string;
+    useAffinity: boolean;
+    hasher: SlotHasher;
+    /** The pool's user account order, applied after the pin (senpi#3591). */
+    order?: readonly string[];
+};
+/** The pin when present, else the first account of the affinity order with the user's order applied. */
+export declare function pickRotationSlot<TSlot extends RotationSlot>(candidates: readonly TSlot[], policy: SlotPickPolicy): TSlot | undefined;
+/**
+ * The account a session's next streamed request starts on, for callers that send a resolved key
+ * outside the rotation stream (compaction, /btw, look-at, cache keepalive). It is the stream's own
+ * first pick: the same candidates (unblocked accounts, else the rate-limited one due back first) and
+ * the same order. When the stream would refuse, this throws the stream's refusal, so an auxiliary
+ * request never authenticates as an account the stream would not use.
+ */
+export declare function selectSessionSlot<TSlot extends RotationSlot>(slots: readonly TSlot[], policy: SlotPickPolicy, now: number): TSlot | undefined;
+//# sourceMappingURL=session-slot.d.ts.map

package/dist/core/credential-pool/session-slot.js

@@ -0,0 +1,26 @@
+import { applyAccountOrder, rendezvousOrder } from "@earendil-works/pi-ai/auth/pool/select";
+import { attemptCandidates, noSlotsError } from "./failover.js";
+/** The pin when present, else the first account of the affinity order with the user's order applied. */
+export function pickRotationSlot(candidates, policy) {
+    const pinned = candidates.find((candidate) => candidate.pinned === true);
+    if (pinned)
+        return pinned;
+    const ranked = policy.useAffinity ? rendezvousOrder(policy.affinityKey, candidates, policy.hasher) : candidates;
+    return applyAccountOrder(policy.order, ranked)[0];
+}
+/**
+ * The account a session's next streamed request starts on, for callers that send a resolved key
+ * outside the rotation stream (compaction, /btw, look-at, cache keepalive). It is the stream's own
+ * first pick: the same candidates (unblocked accounts, else the rate-limited one due back first) and
+ * the same order. When the stream would refuse, this throws the stream's refusal, so an auxiliary
+ * request never authenticates as an account the stream would not use.
+ */
+export function selectSessionSlot(slots, policy, now) {
+    if (slots.length === 0)
+        return undefined;
+    const candidates = attemptCandidates(slots, new Set(), now);
+    if (candidates.length === 0)
+        throw noSlotsError(slots, now);
+    return pickRotationSlot(candidates, policy);
+}
+//# sourceMappingURL=session-slot.js.map

package/dist/core/credential-recovery-revision.d.ts

@@ -0,0 +1,10 @@
+import type { AuthStorage } from "./auth-storage.ts";
+/**
+ * The retry-fallback recovery revision of `provider` (senpi#4099): the `loginId` the last sign-in
+ * stored, or "" when none did. A token refresh keeps the id or drops it to "" and never mints one, so
+ * only a sign-in moves it to a new non-empty value. The
+ * metadata read reloads another process's write without resolving key references. An unreadable
+ * store answers `undefined`, which never releases anything.
+ */
+export declare function credentialRecoveryRevision(storage: AuthStorage | undefined, provider: string): Promise<string | undefined>;
+//# sourceMappingURL=credential-recovery-revision.d.ts.map

package/dist/core/credential-recovery-revision.js

@@ -0,0 +1,19 @@
+/**
+ * The retry-fallback recovery revision of `provider` (senpi#4099): the `loginId` the last sign-in
+ * stored, or "" when none did. A token refresh keeps the id or drops it to "" and never mints one, so
+ * only a sign-in moves it to a new non-empty value. The
+ * metadata read reloads another process's write without resolving key references. An unreadable
+ * store answers `undefined`, which never releases anything.
+ */
+export async function credentialRecoveryRevision(storage, provider) {
+    if (!storage)
+        return undefined;
+    try {
+        await storage.list();
+        return storage.get(provider)?.loginId ?? "";
+    }
+    catch {
+        return undefined;
+    }
+}
+//# sourceMappingURL=credential-recovery-revision.js.map

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

@@ -0,0 +1,22 @@
+import type { AgentContext, AgentTool, AgentToolCall, AgentToolResult, AgentToolUpdateCallback } from "@earendil-works/pi-agent-core";
+import type { AssistantMessage } from "@earendil-works/pi-ai";
+import type { PreparationPipeline } from "./executor-types.ts";
+/** What release needs from preparation; it lives in memory with the executor that prepared the call. */
+export interface PreparedBody {
+    readonly tool: AgentTool;
+    readonly toolCall: AgentToolCall;
+    readonly args: unknown;
+    readonly assistantMessage: AssistantMessage;
+    readonly context: AgentContext;
+    /** The model's own name when it resolved to another tool; today's result carries a correction notice for it. */
+    readonly requestedName?: string;
+}
+export interface BodyOutcome {
+    readonly result: AgentToolResult<unknown>;
+    readonly isError: boolean;
+}
+export declare function errorResult(message: string): AgentToolResult<unknown>;
+export declare function messageOf(error: unknown): string;
+export declare function runBody(body: PreparedBody, signal: AbortSignal | undefined, onUpdate: AgentToolUpdateCallback<unknown>): Promise<BodyOutcome>;
+export declare function finalizeBody(body: PreparedBody, executed: BodyOutcome, pipeline: PreparationPipeline, signal: AbortSignal | undefined): Promise<BodyOutcome>;
+//# sourceMappingURL=executor-body.d.ts.map

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

@@ -0,0 +1,73 @@
+export function errorResult(message) {
+    return { content: [{ type: "text", text: message }], details: {} };
+}
+export function messageOf(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+const ABORTED = Symbol("aborted");
+// Today's body semantics (agent-loop `executePreparedToolCall`): an abort releases the wait even when the tool never
+// settles, and updates stop at settlement.
+export async function runBody(body, signal, onUpdate) {
+    const updates = [];
+    let accepting = true;
+    try {
+        const execution = body.tool.execute(body.toolCall.id, body.args, signal, (partial) => {
+            if (accepting)
+                updates.push(Promise.resolve(onUpdate(partial)));
+        });
+        const aborted = signal === undefined
+            ? undefined
+            : new Promise((resolve) => {
+                if (signal.aborted)
+                    resolve(ABORTED);
+                else
+                    signal.addEventListener("abort", () => resolve(ABORTED), { once: true });
+            });
+        const settled = aborted ? await Promise.race([execution, aborted]) : await execution;
+        accepting = false;
+        await Promise.all(updates);
+        if (settled === ABORTED) {
+            void Promise.resolve(execution).catch(() => undefined);
+            return { result: errorResult("Tool execution aborted"), isError: true };
+        }
+        return { result: settled, isError: settled.isError === true };
+    }
+    catch (error) {
+        accepting = false;
+        await Promise.all(updates);
+        return { result: errorResult(messageOf(error)), isError: true };
+    }
+}
+// Today's after-hook merge (agent-loop `finalizeExecutedToolCall`), field by field.
+export async function finalizeBody(body, executed, pipeline, signal) {
+    const { result, isError } = executed;
+    try {
+        const after = await pipeline.afterToolCall({
+            assistantMessage: body.assistantMessage,
+            toolCall: body.toolCall,
+            args: body.args,
+            result,
+            isError,
+            context: body.context,
+        }, signal);
+        if (!after)
+            return executed;
+        const structuredContent = after.structuredContent ?? (after.content ? undefined : result.structuredContent);
+        const merged = {
+            ...result,
+            content: after.content ?? result.content,
+            details: after.details ?? result.details,
+            usage: after.usage ?? result.usage,
+            terminate: after.terminate ?? result.terminate,
+        };
+        if (structuredContent === undefined)
+            delete merged.structuredContent;
+        else
+            merged.structuredContent = structuredContent;
+        return { result: merged, isError: after.isError ?? isError };
+    }
+    catch (error) {
+        return { result: errorResult(messageOf(error)), isError: true };
+    }
+}
+//# sourceMappingURL=executor-body.js.map