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

package/dist/core/agent-session.js

@@ -306,6 +306,16 @@ export function providerRetryWatchdogAbortMessage(retryTimeoutMs, streamStartTim
             ? " (Its stream-start guard is off; to bound or extend this wait, set retry.provider.streamStartTimeoutMs, 0 disables.)"
             : ` (Stream-start guard: ${Math.round(streamStartTimeoutMs / 1000)}s; to allow longer, raise retry.provider.streamStartTimeoutMs, 0 disables.)`));
 }
+function isHumanInput(options) {
+    return inputOriginOf(options?.source) === "person";
+}
+function promptKind(options) {
+    if (options?.streamingBehavior === "steer")
+        return "steer";
+    if (options?.streamingBehavior === "followUp")
+        return "follow_up";
+    return "prompt";
+}
 export class AgentSession {
     /**
      * Resolve the effective retry profile for the current model's provider.
@@ -331,7 +341,6 @@ export class AgentSession {
         this._messageEndPersistence = new WeakMap();
         this._isAgentRunActive = false;
         this._promptsInFlight = 0;
-        this._personAnswerPending = false;
         /** senpi#3650: the core may continue a run after agent_end; the settle must not wait on that continuation. */
         this._runContinuations = new AgentRunContinuations();
         /** senpi#3650: the turn that owns extension handler waits started now; the turn deadline releases only its own. */
@@ -347,6 +356,7 @@ export class AgentSession {
         this._admissionIdleWaiters = [];
         this._engineTurnStarts = [];
         this._engineTurnRelease = new EngineTurnRelease();
+        this._humanInputListeners = new Set();
         this._engineTurnPauseRecorded = false;
         // The pause warning is shown once per pause: a stream of refused events would otherwise add one line each (senpi#2537).
         this._engineTurnPauseNotified = false;
@@ -365,6 +375,11 @@ export class AgentSession {
         this._queueClearRecorded = Promise.resolve();
         /** The exact message object queued for each `queuedId`, so removal and edits hit the native queue by identity. */
         this._queuedMessages = new Map();
+        /**
+         * Input source of each user message this session admitted, written onto its session entry when the
+         * message is persisted. Kept off the message itself so it can never reach a provider request.
+         */
+        this._userInputSources = new WeakMap();
         /** Recently delivered `queuedId`s (bounded), so a late dequeue answers `already_delivered`, not `not_found`. */
         this._deliveredQueuedIds = new Set();
         this._supersededCompactionLogAttemptIds = new Set();
@@ -1966,8 +1981,9 @@ export class AgentSession {
                     "Agent is already processing a prompt. Use steer() or followUp() to queue messages, or wait for completion.") {
                 const queuedMessages = Array.isArray(messages) ? messages : [messages];
                 const userMessage = queuedMessages.find((message) => message.role === "user");
+                const source = userMessage === undefined ? undefined : this._userInputSources.get(userMessage);
                 // The caller was already told this input started; it now waits in the queue, so persist
-                // it as queued input before it is enqueued, exactly like the regular queue path.
+                // it as queued input before it is enqueued, exactly like the regular queue path (source included).
                 const prepared = userMessage?.role === "user"
                     ? {
                         ...readClientMessageIdentity(userMessage),
@@ -1977,6 +1993,7 @@ export class AgentSession {
                             : userMessage.content.filter((part) => part.type === "image"),
                         mode: "steer",
                         enqueueOrder: this.reserveQueuedInputOrder(),
+                        ...(source === undefined ? {} : { source }),
                     }
                     : undefined;
                 if (prepared)
@@ -2339,7 +2356,9 @@ export class AgentSession {
                     event.message.role === "assistant" ||
                     event.message.role === "toolResult") {
                     // Regular LLM message - persist as SessionMessageEntry
-                    entryId = this.sessionManager.appendOwnedMessage(event.message);
+                    entryId = this.sessionManager.appendOwnedMessage(event.message, {
+                        inputSource: this._userInputSources.get(event.message),
+                    });
                     this._emitEntryAppended(entryId);
                     this._incrementMessageRevision();
                     this.externalAdmission.observePersisted(event.message);
@@ -3767,6 +3786,8 @@ export class AgentSession {
      * @throws Error if no model selected or no API key available (when not streaming)
      */
     async prompt(text, options) {
+        if (isHumanInput(options) && options?.humanInputReported !== true)
+            this._humanInputAdmitted(promptKind(options));
         // Held synchronously, before any await: an external delivery never overtakes this input.
         const hold = this.externalAdmission.beginInput({
             command: this._isExtensionCommandText(text, options),
@@ -4229,12 +4250,14 @@ export class AgentSession {
             if (currentImages) {
                 userContent.push(...currentImages);
             }
-            messages.push({
+            const userMessage = {
                 role: "user",
                 content: userContent,
                 timestamp: Date.now(),
                 ...clientMessageIdentity(options),
-            });
+            };
+            this._userInputSources.set(userMessage, options?.source ?? "interactive");
+            messages.push(userMessage);
             // Consume next-turn messages transactionally: a final admission rejection
             // restores them in their original order rather than dropping or duplicating
             // one-shot extension state.
@@ -4469,7 +4492,7 @@ export class AgentSession {
     async _queueUserInput(text, images, behavior, options) {
         const origin = inputOriginOf(options?.source);
         if (origin === "person" && this._engineTurnHold.held) {
-            await this.prompt(text, { ...options, images, streamingBehavior: behavior });
+            await this.prompt(text, { ...options, images, streamingBehavior: behavior, humanInputReported: true });
             return "queued";
         }
         if (origin === "person")
@@ -4516,6 +4539,8 @@ export class AgentSession {
      * @throws Error if text is an extension command
      */
     async steer(text, images, options) {
+        if (isHumanInput(options))
+            this._humanInputAdmitted("steer");
         return this._queueUserInput(text, images, "steer", options);
     }
     /**
@@ -4528,6 +4553,8 @@ export class AgentSession {
      * @throws Error if text is an extension command
      */
     async followUp(text, images, options) {
+        if (isHumanInput(options))
+            this._humanInputAdmitted("follow_up");
         return this._queueUserInput(text, images, "followUp", options);
     }
     _startSessionTitleGeneration(firstPrompt) {
@@ -4614,11 +4641,12 @@ export class AgentSession {
     /** Identified input is admitted into durable custody and enqueued in one gated step; other input as before. */
     async _enqueueQueuedInput(input) {
         const clientMessageId = input.clientMessageId;
+        const sourced = { ...input, source: input.source ?? "interactive" };
         if (clientMessageId === undefined) {
-            this._enqueuePreparedInput(input);
+            this._enqueuePreparedInput(sourced);
             return;
         }
-        await this._pendingInputs.admit({ clientMessageId, text: input.text, ...(input.images ? { images: input.images } : {}), mode: input.mode }, (queuedId) => this._enqueuePreparedInput({ ...input, queuedId }));
+        await this._pendingInputs.admit({ clientMessageId, text: input.text, ...(input.images ? { images: input.images } : {}), mode: input.mode }, (queuedId) => this._enqueuePreparedInput({ ...sourced, queuedId }));
     }
     /** Restore accepted input without re-running input transforms or changing its enqueue order. */
     async restoreQueuedInput(input) {
@@ -4638,6 +4666,7 @@ export class AgentSession {
             images: input.images,
             mode: input.mode,
             enqueueOrder,
+            ...(input.source === undefined ? {} : { source: input.source }),
         };
         input.onQueuedInput?.(prepared);
         const queue = input.mode === "steer" ? this._steeringMessages : this._followUpMessages;
@@ -4657,6 +4686,11 @@ export class AgentSession {
             timestamp: Date.now(),
             ...clientMessageIdentity(input),
         };
+        // New input always arrives with a source: `_enqueueQueuedInput` applies the same "interactive" default
+        // `prompt()` does. Only restored input can lack one (a record written before sources were kept), and it
+        // stays unstamped: unknown origin, never defaulted to a trusted source.
+        if (input.source !== undefined)
+            this._userInputSources.set(message, input.source);
         this._queuedMessages.set(queuedId, message);
         if (this._promptStartPending && this._skipNextPostCompactionAssistantCheck) {
             const deferred = input.mode === "steer"
@@ -4843,8 +4877,33 @@ export class AgentSession {
             finishSessionWork?.();
         }
     }
+    /**
+     * Subscribe to human input as it enters the session: called synchronously for every input whose origin is a
+     * person (TUI input, RPC prompt/steer/follow_up, human question answers, `resumeSession`). Origin comes from
+     * the entry point, never from the connection's `interactive_user` role, which only decides authority. Never
+     * called for automatic deliveries (extension messages, wakes, continuations). A throwing listener does not block
+     * the input. Timing: a call means a person sent it, not that it took effect: `prompt` reports before checks that
+     * can still throw, `resumeSession` reports even when nothing is paused, and TUI messages queued during
+     * compaction report when they are delivered.
+     */
+    onHumanInputAdmitted(listener) {
+        this._humanInputListeners.add(listener);
+        return () => this._humanInputListeners.delete(listener);
+    }
+    _humanInputAdmitted(kind) {
+        const event = { kind, at: Date.now() };
+        for (const listener of this._humanInputListeners) {
+            try {
+                listener(event);
+            }
+            catch (error) {
+                this._sessionLogger.warn("human_input_listener_failed", { error: String(error) });
+            }
+        }
+    }
     /** Explicit user Resume; attachment alone must never call this. */
     resumeSession() {
+        this._humanInputAdmitted("resume");
         return this._engineTurnRelease.resume(this._engineTurnHold, async (message, admit) => {
             const generation = this._userAbortGeneration;
             await this.waitForIdle();
@@ -5087,10 +5146,10 @@ export class AgentSession {
             // before prompt() accepted the message must not silently drop it.
             if (disposition === undefined) {
                 if (options?.deliverAs === "steer") {
-                    await this._queueSteer(text, images, { textBlocks });
+                    await this._queueSteer(text, images, { textBlocks, source: "extension" });
                 }
                 else {
-                    await this._queueFollowUp(text, images, { textBlocks });
+                    await this._queueFollowUp(text, images, { textBlocks, source: "extension" });
                 }
             }
             throw error;
@@ -5546,6 +5605,7 @@ export class AgentSession {
                 modelSelectSource: "set",
                 invalidateCompaction: true,
                 allowDeferral: false,
+                admittedLiveContextTokens: projection.liveContextTokens,
                 origin: heldSwitchOrigin(pending.origin),
             });
         }
@@ -5816,9 +5876,8 @@ export class AgentSession {
                 this._admitSwitchCompactionRequired(model, deferral, opts.persistDefault, opts.origin);
                 return undefined;
             }
-            const admittedLiveContextTokens = opts.repairWithSlice
-                ? this._reduceForSwitchTarget(model, liveContextTokens)
-                : liveContextTokens;
+            const admittedLiveContextTokens = opts.admittedLiveContextTokens ??
+                (opts.repairWithSlice ? this._reduceForSwitchTarget(model, liveContextTokens) : liveContextTokens);
             this._assertModelUsableForSwitch(model, admittedLiveContextTokens);
             if (opts.appendSessionEntry) {
                 this.sessionManager.appendModelChange(model.provider, model.id, opts.entryReason, previousModel?.provider, previousModel?.id, { origin: opts.origin, duringTurn });
@@ -7994,7 +8053,7 @@ export class AgentSession {
                     return;
                 send();
             },
-            sendUserMessage: (content, options) => {
+            sendUserMessage: (content, options, inputOrigin = "extension") => {
                 const reportError = (err) => {
                     if (err instanceof ModelNotReadyError) {
                         this._noticeProviderRequired(err.message);
@@ -8006,9 +8065,6 @@ export class AgentSession {
                         error: err instanceof Error ? err.message : String(err),
                     });
                 };
-                // A person's answer is classified when it is delivered, not by the phase it later runs in.
-                const inputOrigin = this._personAnswerPending ? "person" : "extension";
-                this._personAnswerPending = false;
                 // sendUserMessage always triggers a turn; register a settlement-deferred
                 // turn claim so agent_idle is not emitted before its deferred agent_start.
                 if (this._agentSettledDelivery.deferTriggerTurn((claim) => {
@@ -8078,12 +8134,11 @@ export class AgentSession {
             engineTurnsHeld: () => this._engineTurnHold.holdsSource("goal"),
             noteHeldWake: (source) => this._engineTurnHold.note(source),
             questionInput: () => {
+                this._humanInputAdmitted("answer");
                 this._engineTurnInput.begin();
                 this._engineResumeWindow = false;
-                this._personAnswerPending = true;
                 // The answer's follow-on (if any) enters prompt() synchronously after this; settle once it has.
                 queueMicrotask(() => {
-                    this._personAnswerPending = false;
                     this._settleInputRelease()?.catch((error) => {
                         this._sessionLogger.warn("input_release_settle_failed", {
                             error: error instanceof Error ? error.message : String(error),

package/dist/core/auth-storage.d.ts

@@ -3,8 +3,21 @@
  * Provider auth orchestration belongs to ModelRuntime and pi-ai Models.
  */
 import type { ApiKeyCredential, AuthOperationOptions, Credential, CredentialInfo, CredentialStore, OAuthAuth, OAuthCredential, OAuthLoginCallbacks } from "@earendil-works/pi-ai";
+import { type CredentialKind } from "@earendil-works/pi-ai/auth/pool/kinds";
 import { type CredentialSlot } from "@earendil-works/pi-ai/auth/pool/slots";
 type AuthStorageData = Record<string, Credential>;
+/** A credential problem the user should see once per change: `id` changes when the problem does. */
+export type AuthNotice = {
+    readonly id: string;
+    readonly provider: string;
+    readonly message: string;
+};
+export type CredentialReplacement = {
+    readonly replaced: CredentialKind;
+    readonly backupPath?: string;
+};
+/** What a login that replaced a credential of the other kind tells the user (senpi#3448, #3486). */
+export declare function describeCredentialReplacement(provider: string, replacement: CredentialReplacement): string;
 export type AuthCredential = Credential;
 export type { ApiKeyCredential, OAuthCredential };
 export type AuthStatus = {
@@ -75,6 +88,10 @@ export declare class AuthStorage implements CredentialStore {
     private readonly extensionOAuthProviders;
     private errors;
     private readonly reportedMigrationSkips;
+    private notices;
+    private readonly seenInMemory;
+    private readonly takenNotices;
+    private readonly replacements;
     private storage;
     private authPath;
     private readState;
@@ -127,7 +144,33 @@ export declare class AuthStorage implements CredentialStore {
     removeRuntimeApiKey(provider: string): void;
     get(provider: string): Credential | undefined;
     getProviderEnv(provider: string): Record<string, string> | undefined;
-    set(provider: string, credential: Credential): void;
+    /**
+     * Stores a login. A login of the other kind replaces the provider's credential (senpi#3448); the
+     * previous bytes are backed up first, and the replacement is returned and kept for
+     * `takeReplacement`, so no credential disappears without the user being told where it went.
+     */
+    set(provider: string, credential: Credential): CredentialReplacement | undefined;
+    /** The last replacement a login made for this provider, once; the caller shows it to the user. */
+    takeReplacement(provider: string): CredentialReplacement | undefined;
+    /** Credential notices not yet marked seen; a changed problem gets a new id and shows again. */
+    pendingNotices(): ReadonlyArray<AuthNotice>;
+    /**
+     * Hands out each pending notice once per process, so a run that reports auth problems at several
+     * points shows it once (senpi#3486). With `persistSeen`, the notices are also recorded as seen, so
+     * the next launch stays quiet until the problem changes; a run nobody reads (RPC) leaves them pending.
+     */
+    takePendingNotices(options: {
+        persistSeen: boolean;
+    }): ReadonlyArray<AuthNotice>;
+    /**
+     * Records notices as shown, so the next launch stays quiet until the problem changes. Ids of
+     * problems that no longer exist are dropped. A failed write never aborts startup: it is reported,
+     * and the notice may be shown once more.
+     */
+    markNoticesSeen(ids: readonly string[]): void;
+    private seenNoticesPath;
+    private seenNoticeIds;
+    private noteReplacement;
     remove(provider: string): void;
     listSlots(provider: string): CredentialSlot[];
     setSlot(provider: string, slot: CredentialSlot): void;

package/dist/core/auth-storage.js

@@ -3,6 +3,7 @@
  * Provider auth orchestration belongs to ModelRuntime and pi-ai Models.
  */
 import { findEnvKeys, getEnvApiKey, readByProviderId } from "@earendil-works/pi-ai";
+import { slotKind, unusedSlotKinds } from "@earendil-works/pi-ai/auth/pool/kinds";
 import { appendLoginSlot, listSlots, 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";
@@ -37,6 +38,36 @@ function repairPoisonedPoolSlots(data) {
     }
     return repaired ? { data: repaired, repaired: true } : { data, repaired: false };
 }
+const KIND_LABEL = { oauth: "OAuth login", api_key: "API key" };
+/**
+ * One notice per provider whose stored credential holds slots its type cannot use (senpi#3448).
+ * Nothing is changed: which credential pays stays the user's choice, so the notice names the
+ * unused login, where it still is, and the action that switches to it.
+ */
+function unusedLoginNotices(data) {
+    const notices = [];
+    for (const [provider, credential] of Object.entries(data)) {
+        if (typeof credential !== "object" || credential === null)
+            continue;
+        for (const kind of unusedSlotKinds(credential)) {
+            const slots = listSlots(credential).filter((slot) => slotKind(slot) === kind);
+            const inUse = KIND_LABEL[credential.type];
+            const names = slots.map((slot) => slot.name);
+            notices.push({
+                // Slot names, never key material: a new unused login gets a new id and is shown again.
+                id: `${provider}:${kind}:${names.join(",")}`,
+                provider,
+                message: `${provider}: an ${KIND_LABEL[kind]} saved earlier is stored next to your ${inUse} but is never used; the ${inUse} stays in use. It is still in auth.json (${slots.map((slot) => slot.name).join(", ")}); to switch to it, save it again with /login (the ${inUse} is backed up first).`,
+            });
+        }
+    }
+    return notices;
+}
+/** What a login that replaced a credential of the other kind tells the user (senpi#3448, #3486). */
+export function describeCredentialReplacement(provider, replacement) {
+    const where = replacement.backupPath ? ` It is saved in ${replacement.backupPath}` : " It was not backed up";
+    return `Your ${KIND_LABEL[replacement.replaced]} for ${provider} was replaced by this login.${where}; to switch back, log in with it again.`;
+}
 // Every write stages a fresh 0o600 file and renames it over the store, so the
 // credential file is never briefly world-readable and never half-written; the
 // restrictive mode also wins over any wider mode an earlier direct write left.
@@ -317,6 +348,10 @@ export class AuthStorage {
         this.extensionOAuthProviders = new Map();
         this.errors = [];
         this.reportedMigrationSkips = new Set();
+        this.notices = [];
+        this.seenInMemory = new Set();
+        this.takenNotices = new Set();
+        this.replacements = new Map();
         this.busyReads = 0;
         this.dataLoaded = false;
         this.dataFromBusyRead = false;
@@ -381,6 +416,7 @@ export class AuthStorage {
             this.reportedMigrationSkips.add(moved.skipped);
             this.recordError(new Error(`The Anthropic Claude subscription login in auth.json was not moved to Anthropic Subscription because ${moved.skipped}. It was left unchanged; sign in again with /login and choose "Anthropic Subscription (Claude Pro/Max)".`));
         }
+        this.notices = unusedLoginNotices(moved.data);
         return {
             data: moved.data,
             repaired: repaired.repaired,
@@ -398,13 +434,14 @@ export class AuthStorage {
      */
     backupAuthFile(content) {
         if (!this.authPath || content === undefined)
-            return;
+            return undefined;
         const stamp = new Date().toISOString().replace(/[:.]/g, "-");
         let backupPath = `${this.authPath}.backup-${stamp}`;
         for (let attempt = 1; existsSync(backupPath); attempt++) {
             backupPath = `${this.authPath}.backup-${stamp}-${attempt}`;
         }
         writeFileSync(backupPath, content, AUTH_FILE_WRITE_OPTIONS);
+        return backupPath;
     }
     updateReadState(data, revision) {
         this.data = data;
@@ -484,15 +521,94 @@ export class AuthStorage {
         const credential = readByProviderId(this.data, provider);
         return credential?.type === "api_key" && credential.env ? { ...credential.env } : undefined;
     }
+    /**
+     * Stores a login. A login of the other kind replaces the provider's credential (senpi#3448); the
+     * previous bytes are backed up first, and the replacement is returned and kept for
+     * `takeReplacement`, so no credential disappears without the user being told where it went.
+     */
     set(provider, credential) {
-        this.storage.withLock((content) => {
+        return this.storage.withLock((content) => {
             const currentData = this.parseStorageData(content);
+            const replacement = this.noteReplacement(provider, currentData[provider], credential, content);
             const next = appendLoginSlot(currentData[provider], credential);
             const nextData = { ...currentData, [provider]: next };
             this.data = nextData;
-            return { result: undefined, next: JSON.stringify(nextData, null, 2) };
+            return { result: replacement, next: JSON.stringify(nextData, null, 2) };
         });
     }
+    /** The last replacement a login made for this provider, once; the caller shows it to the user. */
+    takeReplacement(provider) {
+        const replacement = this.replacements.get(provider);
+        this.replacements.delete(provider);
+        return replacement;
+    }
+    /** Credential notices not yet marked seen; a changed problem gets a new id and shows again. */
+    pendingNotices() {
+        const seen = this.seenNoticeIds();
+        return this.notices.filter((notice) => !seen.has(notice.id));
+    }
+    /**
+     * Hands out each pending notice once per process, so a run that reports auth problems at several
+     * points shows it once (senpi#3486). With `persistSeen`, the notices are also recorded as seen, so
+     * the next launch stays quiet until the problem changes; a run nobody reads (RPC) leaves them pending.
+     */
+    takePendingNotices(options) {
+        const taken = this.pendingNotices().filter((notice) => !this.takenNotices.has(notice.id));
+        for (const notice of taken)
+            this.takenNotices.add(notice.id);
+        if (options.persistSeen)
+            this.markNoticesSeen(taken.map((notice) => notice.id));
+        return taken;
+    }
+    /**
+     * Records notices as shown, so the next launch stays quiet until the problem changes. Ids of
+     * problems that no longer exist are dropped. A failed write never aborts startup: it is reported,
+     * and the notice may be shown once more.
+     */
+    markNoticesSeen(ids) {
+        if (ids.length === 0)
+            return;
+        const path = this.seenNoticesPath();
+        if (!path) {
+            for (const id of ids)
+                this.seenInMemory.add(id);
+            return;
+        }
+        const current = new Set(this.notices.map((notice) => notice.id));
+        const seen = [...new Set([...this.seenNoticeIds(), ...ids])].filter((id) => current.has(id));
+        try {
+            writeFileSync(path, JSON.stringify(seen, null, 2), AUTH_FILE_WRITE_OPTIONS);
+        }
+        catch (error) {
+            const reason = error instanceof Error ? error.message : String(error);
+            this.recordError(new Error(`Could not record which credential notices were shown (${path}): ${reason}. They may be shown again on the next start; check that the file is writable.`));
+        }
+    }
+    seenNoticesPath() {
+        return this.authPath ? join(dirname(this.authPath), "auth-notices-seen.json") : undefined;
+    }
+    seenNoticeIds() {
+        const path = this.seenNoticesPath();
+        if (!path)
+            return new Set(this.seenInMemory);
+        try {
+            const parsed = JSON.parse(readFileSync(path, "utf-8"));
+            return new Set(Array.isArray(parsed) ? parsed.filter((id) => typeof id === "string") : []);
+        }
+        catch {
+            return new Set();
+        }
+    }
+    noteReplacement(provider, previous, next, content) {
+        if (previous === undefined || previous.type === next.type)
+            return undefined;
+        const backupPath = this.backupAuthFile(content);
+        const replacement = backupPath
+            ? { replaced: previous.type, backupPath }
+            : { replaced: previous.type };
+        this.replacements.set(provider, replacement);
+        return replacement;
+    }
     remove(provider) {
         this.storage.withLock((content) => {
             const nextData = { ...this.parseStorageData(content) };
@@ -640,6 +756,7 @@ export class AuthStorage {
                 revision = this.authPath ? getFileContentRevision(this.authPath) : undefined;
                 return { result: currentData[provider] };
             }
+            this.noteReplacement(provider, currentData[provider], next, content);
             const merged = { ...currentData, [provider]: next };
             latestData = merged;
             return { result: next, next: JSON.stringify(merged, null, 2) };

package/dist/core/client-message-identity.d.ts

@@ -1,5 +1,6 @@
 import type { ImageContent } from "@earendil-works/pi-ai";
 import { z } from "zod";
+import type { InputSource } from "./extensions/types.ts";
 export declare const clientMessageIdentitySchema: z.ZodObject<{
     clientMessageId: z.ZodOptional<z.ZodString>;
     clientTurnId: z.ZodOptional<z.ZodString>;
@@ -10,6 +11,8 @@ export type PreparedClientInput = ClientMessageIdentity & {
     readonly images?: ImageContent[];
     readonly mode: "steer" | "followUp";
     readonly enqueueOrder: number;
+    /** The input's `input` event source, kept so restored input is re-stamped with it. Absent: unknown origin. */
+    readonly source?: InputSource;
 };
 /** Copy only correlation metadata, never the rest of a prompt's options. */
 export declare function clientMessageIdentity(value?: ClientMessageIdentity): ClientMessageIdentity;

package/dist/core/credential-accounts.d.ts

@@ -14,6 +14,8 @@ export type CredentialAccountSummary = {
         readonly model: string;
         readonly until: number;
     }[];
+    /** A slot of the other kind than the stored credential: kept, never used, cannot be pinned (senpi#3486). */
+    readonly unused?: true;
 };
 export declare function assertValidAccountName(name: string): void;
 export declare function credentialPoolRepository(storage: AuthStorage): CredentialSlotRepository;

package/dist/core/credential-accounts.js

@@ -1,5 +1,6 @@
 import { dirname, join } from "node:path";
 import { normalizeProviderId } from "@earendil-works/pi-ai";
+import { slotsOfOwnKind } from "@earendil-works/pi-ai/auth/pool/kinds";
 import { applyAccountOrder, withoutOrderedAccount } from "@earendil-works/pi-ai/auth/pool/select";
 import { accountDisplayName, listSlots, pinSlot, removeSlot, renameSlotDisplayName, } from "@earendil-works/pi-ai/auth/pool/slots";
 import { discoverEnvSlots } from "./credential-pool/env-slots.js";
@@ -94,6 +95,7 @@ async function summarizeInStoredOrder(provider, credential, env, repository) {
                 ? listSlots(credential)
                 : []
             : listSlots(credential);
+        const usable = new Set(slotsOfOwnKind(credential).map((slot) => slot.name));
         for (const slot of storedAccounts) {
             const displayName = accountDisplayName(slot.displayName);
             const persisted = state[slot.name];
@@ -111,6 +113,7 @@ async function summarizeInStoredOrder(provider, credential, env, repository) {
                 blocked: slotBlocked(slot, applicable, now),
                 pinned: pinned === slot.name,
                 ...blockedModels(now, applicable?.modelBlocks, storedModelBlocks(slot)),
+                ...(usable.has(slot.name) ? {} : { unused: true }),
             });
         }
         if (normalizeProviderId(provider) !== "anthropic-subscription")
@@ -155,9 +158,13 @@ export async function pinCredentialAccount(storage, provider, name, env = proces
     if (name !== null) {
         assertValidAccountName(name);
         const accounts = await getCredentialAccounts(storage, provider, env, repo);
-        if (!accounts.some((account) => account.name === name)) {
+        const account = accounts.find((candidate) => candidate.name === name);
+        if (!account) {
             throw new Error(`Provider account not found: ${name}`);
         }
+        if (account.unused) {
+            throw new Error(`Account ${name} holds a login of the other kind and is never used, so it cannot be pinned. To switch ${provider} to it, save it again with /login.`);
+        }
     }
     await storage.modify(provider, async (current) => {
         if (current === undefined) {

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

@@ -1,4 +1,4 @@
-import { listSlots as listCredentialSlots } from "@earendil-works/pi-ai/auth/pool/slots";
+import { slotsOfOwnKind } from "@earendil-works/pi-ai/auth/pool/kinds";
 import { resolveConfigValue } from "../resolve-config-value.js";
 import { discoverEnvSlots } from "./env-slots.js";
 import { STORE_BUSY, writeHealthUnlessStoreBusy } from "./health-write.js";
@@ -74,7 +74,8 @@ export async function listRotationSlots(sources, options = {}) {
     if (credential) {
         const state = await repository.listSlots(providerId, "stored");
         const slots = [];
-        for (const slot of listCredentialSlots(credential)) {
+        // A slot of the other kind cannot project, so a session must never be handed it (senpi#3486).
+        for (const slot of slotsOfOwnKind(credential)) {
             const persisted = state[slot.name];
             const storedRevision = await repository.storedCredentialRevision(providerId, slot.name, {
                 key: slot.key,

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

@@ -9,7 +9,12 @@ function usage(ctx) {
     ctx.ui.notify("Usage: /account <provider> [list | pin <id> | unpin | reset <id> | remove <id> | rename <id> <display name...> | clear-name <id>]", "error");
 }
 function statusOf(account) {
-    const states = [accountLabel(account), account.source, account.blocked ? "blocked" : "available"];
+    const availability = account.unused
+        ? "unused (other login kind; switch with /login)"
+        : account.blocked
+            ? "blocked"
+            : "available";
+    const states = [accountLabel(account), account.source, availability];
     for (const { model, until } of account.blockedModels ?? []) {
         states.push(`blocked for ${model} until ${new Date(until).toISOString()}`);
     }

package/dist/core/extensions/builtin/compaction/openai-remote.d.ts

@@ -11,6 +11,7 @@ export { getOpenAiRemoteCompactionDetails, OPENAI_REMOTE_COMPACTION_SCHEMA } fro
 export declare const SENPI_COMPACTION_EVENT = "senpi:compaction";
 export type OpenAiRemoteCompactionRequest = {
     body: OpenAiCompactBody;
+    sessionId?: string;
     inputItemCount: number;
     tokensBefore: number;
 };
@@ -99,7 +100,7 @@ export declare function createOpenAiRemoteCompactionRequest(options: {
     branchEntries: SessionEntry[];
     messages?: AgentMessage[];
     tokensBefore: number;
-    promptCacheKey?: string;
+    sessionId?: string;
     serviceTier?: ServiceTier;
 }): OpenAiRemoteCompactionRequest | undefined;
 export declare function buildOpenAiRemoteCompactionResult(options: {