@code-yeongyu/senpi 2026.10.11 → 2026.10.12

package/dist/core/agent-session.js

@@ -73,6 +73,7 @@ import { ExecuteToolError, ExtensionRunner, wrapRegisteredTools, } from "./exten
 import { projectKernelPrelude } from "./extensions/kernel-prelude.js";
 import { emitSessionShutdownEvent } from "./extensions/runner.js";
 import { normalizeToolExposure, RUNTIME_EXTENSION_PATH } from "./extensions/types.js";
+import { createUserActivitySource, emitUserActivity } from "./extensions/user-activity.js";
 import { deliveryIdOf, ExternalAdmission } from "./external-admission.js";
 import { shouldWarnHighReasoning } from "./high-reasoning-warning.js";
 import { LazyToolActivation } from "./lazy-tool-activation.js";
@@ -98,12 +99,13 @@ import { SelectorCooldowns } from "./retry-fallback/cooldown.js";
 import { classifyRateLimitedWait, degradeWithoutFallback, nextInTurnDelayMs, probeBackSchedule, } from "./retry-fallback/hint-policy.js";
 import { createFallbackLogger } from "./retry-fallback/log.js";
 import { ProbeBackScheduler } from "./retry-fallback/probe-scheduler.js";
+import { AccountUsageLimitError, describeUsageLimitEntry, describeUsageLimitMessage, usageLimitScope, } from "./retry-fallback/usage-limit.js";
 import { validateFallbackChains } from "./retry-fallback/validate.js";
 import { isSessionBusySnapshot, WakeSourceTracker } from "./session-activity.js";
 import { createSessionControlActions } from "./session-control-actions.js";
 import { computeSessionFailureReport } from "./session-failure-report.js";
 import { createSessionLogger } from "./session-log.js";
-import { CURRENT_SESSION_VERSION, getLatestCompactionEntry, SessionManager, } from "./session-manager.js";
+import { CURRENT_SESSION_VERSION, getLatestCompactionEntry, getSessionContextEntryId, SessionManager, } from "./session-manager.js";
 import { generateSessionTitle, sessionTitleRetryPolicy, shouldSkipSessionTitle } from "./session-title-generator.js";
 import { SessionWorkBarrier } from "./session-work-barrier.js";
 import { DEFAULT_STREAM_START_TIMEOUT_MS, DEFAULT_TOOL_NAMES, } from "./settings-manager.js";
@@ -423,6 +425,7 @@ export class AgentSession {
         // (which rebuilds the base prompt with discovered skills) have run.
         this._sessionStartSettled = Promise.resolve();
         this._promptCachePrefixBuilds = new PromptCachePrefixBuilds();
+        this._userActivity = createUserActivitySource();
         this._extensionMode = "print";
         this._providerRequiredNoticed = false;
         this._probeBackLaneSeq = 0;
@@ -571,7 +574,7 @@ export class AgentSession {
         // Cooldowns, probe schedules, and circuits measure elapsed time, so they all
         // run on the monotonic clock; a wall-clock jump never parks or releases an entry.
         this._fallbackNow = config.fallbackNow ?? monotonicNow;
-        this._selectorCooldowns = new SelectorCooldowns(this._fallbackNow);
+        this._selectorCooldowns = new SelectorCooldowns(this._fallbackNow, undefined, config.fallbackWallNow ?? config.fallbackNow ?? Date.now);
         const lease = () => this._fallbackCircuitsLease;
         this._fallbackCircuits = createFallbackCircuitAccess({
             // Read on every use: the hold is taken as construction's last step.
@@ -742,19 +745,35 @@ export class AgentSession {
      * `compaction.model` override ("provider/model"), that model is used for the
      * summarization call instead of the session model — this is what lets an
      * SDK-owned lane (anthropic-subscription) compact on a cheaper/different model.
-     * Any resolution failure (unset, malformed, unknown model) falls back to the
-     * session model so compaction never silently breaks.
+     * Unset, malformed, or unknown overrides keep a usable session model.
+     * A spent account instead uses the held target or another authenticated model.
      */
     _resolveCompactionModel(sessionModel) {
         const override = this._getCompactionSettings().model;
-        if (!override)
-            return sessionModel;
-        const slash = override.indexOf("/");
-        if (slash <= 0 || slash === override.length - 1)
-            return sessionModel;
-        const provider = override.slice(0, slash);
-        const modelId = override.slice(slash + 1);
-        return this._modelRuntime.getModel(provider, modelId) ?? sessionModel;
+        const slash = override?.indexOf("/") ?? -1;
+        const configured = override && slash > 0
+            ? this._modelRuntime.getModel(override.slice(0, slash), override.slice(slash + 1))
+            : undefined;
+        const usable = (model) => !this._retryFallback.isProviderSpent(model.provider);
+        // Preserve the explicit override and original-model geometry on healthy sessions.
+        // A held downswitch uses its target only when the original account cannot serve.
+        if (usable(sessionModel))
+            return configured && usable(configured) ? configured : sessionModel;
+        const pending = this._pendingModelSwitch?.model;
+        if (pending && usable(pending))
+            return pending;
+        if (configured && usable(configured))
+            return configured;
+        const requiredContextWindow = estimateMessagesTokens(filterContextExcludedMessages(this._runtimeMessages())) +
+            this._getCompactionSettings().reserveTokens;
+        const available = this._modelRuntime
+            .getModels()
+            .find((model) => usable(model) &&
+            model.contextWindow >= requiredContextWindow &&
+            this._modelRuntime.hasConfiguredAuth(model.provider));
+        if (available)
+            return available;
+        throw new AccountUsageLimitError(sessionModel.provider, this._retryFallback.accountError(sessionModel.provider));
     }
     async _getCompactionRequestAuth(model, signal, callbacks) {
         const auth = await this._getSummarizationRequestAuth(model, signal, callbacks);
@@ -1365,6 +1384,39 @@ export class AgentSession {
     }
     _emit(event) {
         this._logSessionEvent(event);
+        if (event.type === "entry_appended") {
+            event = { ...event, entry: describeUsageLimitEntry(event.entry) };
+        }
+        if (event.type === "retry_fallback_exhausted" && usageLimitScope(event.lastError) === "account") {
+            event = {
+                ...event,
+                lastError: new AccountUsageLimitError(this.model?.provider ?? "", event.lastError).message,
+            };
+        }
+        if (event.type === "agent_end") {
+            event = {
+                ...event,
+                messages: event.messages.map((message) => message.role === "assistant" ? describeUsageLimitMessage(message) : message),
+            };
+        }
+        // Keep provider text on the engine message for classification and in session.log,
+        // but publish only the existing user-facing description to clients.
+        if ((event.type === "message_end" || event.type === "message_start" || event.type === "message_update") &&
+            event.message.role === "assistant") {
+            const message = describeUsageLimitMessage(event.message);
+            event =
+                event.type === "message_update"
+                    ? {
+                        ...event,
+                        message,
+                        assistantMessageEvent: {
+                            ...event.assistantMessageEvent,
+                            ...("error" in event.assistantMessageEvent ? { error: message } : {}),
+                            ...("partial" in event.assistantMessageEvent ? { partial: message } : {}),
+                        },
+                    }
+                    : { ...event, message };
+        }
         for (const l of [...this._eventListeners]) {
             l(event);
         }
@@ -2213,7 +2265,9 @@ export class AgentSession {
             this._clearCircuitProbeWatchdog();
             // Billing and quota exhaustion make the entry unusable for every session,
             // whether or not the chain has a candidate left.
-            if (msg.stopReason === "error" && isHealthExhaustionFailure(msg.errorMessage) && this.model) {
+            if (msg.stopReason === "error" &&
+                (isHealthExhaustionFailure(msg.errorMessage) || usageLimitScope(msg.errorMessage) === "account") &&
+                this.model) {
                 this._retryFallback.noteHealthFailure(this.model, this.thinkingLevel, { errorMessage: msg.errorMessage });
             }
             const requiredAutoCompaction = this._getRequiredAutoCompactionReason(msg);
@@ -3275,6 +3329,10 @@ export class AgentSession {
     onExtensionEvent(channel, handler) {
         return this._resourceLoader.onExtensionEvent?.(channel, handler) ?? (() => { });
     }
+    /** Host input entry point; not exposed by the extension API or its event bus. */
+    recordUserActivity(kind) {
+        this._userActivity.emit(kind);
+    }
     /** Publish on the internal event bus shared by this session's extensions. */
     emitExtensionEvent(channel, data) {
         this._resourceLoader.emitExtensionEvent?.(channel, data);
@@ -3467,6 +3525,8 @@ export class AgentSession {
             submittedByCommand: options?.source === "extension",
         });
         try {
+            if (options?.source !== "extension")
+                emitUserActivity(this, "prompt");
             await this._prompt(text, {
                 ...options,
                 promptDisposition: (disposition) => {
@@ -3573,6 +3633,15 @@ export class AgentSession {
         if (!this.isStreaming) {
             try {
                 await this._maybeRestoreFallbackPrimary();
+                const model = this.model;
+                if (model && !this._pendingModelSwitch && this._retryFallback.isProviderSpent(model.provider)) {
+                    this._retryFallback.resetTurn();
+                    const errorMessage = this._retryFallback.accountError(model.provider);
+                    // Routing around a remembered failure did not observe another provider failure.
+                    if (!(await this._retryFallback.tryFallback("transient", { errorMessage }, false))) {
+                        throw new AccountUsageLimitError(model.provider, errorMessage);
+                    }
+                }
             }
             catch (error) {
                 if (ownsPromptStart)
@@ -4054,6 +4123,8 @@ export class AgentSession {
      * `input` handlers, skill/template expansion, then the recovery-ordered enqueue.
      */
     async _queueUserInput(text, images, behavior, options) {
+        if (options?.source !== "extension")
+            emitUserActivity(this, "prompt");
         // Check for extension commands (cannot be queued)
         if (text.startsWith("/")) {
             this._throwIfExtensionCommand(text);
@@ -4880,7 +4951,9 @@ export class AgentSession {
     }
     /** Whether a recorded resume requirement still blocks: the current context does not fit the current model. */
     _resumeRequirementStillBlocks(model, settings) {
-        const currentContext = estimateContextTokens(filterContextExcludedMessages(this.sessionManager.buildSessionContext().messages)).tokens;
+        // Kept assistant usage predates an accepted checkpoint. The projection
+        // estimates its summary and suffix until a fresh provider response supersedes it.
+        const currentContext = estimateProjectedContextTokens(this.sessionManager.buildSessionProjection(), this.sessionManager.getBranch()).tokens;
         return !projectModelUsabilityBudget({
             model,
             systemPrompt: this.agent.state.systemPrompt,
@@ -6015,6 +6088,7 @@ export class AgentSession {
                     }
                     throw new Error("Nothing to compact (session too small)");
                 }
+                const compactionModel = this._resolveCompactionModel(model);
                 if (this._extensionRunner.hasHandlers("session_before_compact")) {
                     const messagesBeforeExtension = new Set(this.agent.state.messages);
                     const extensionResult = (await this._extensionRunner.emit({
@@ -6050,7 +6124,6 @@ export class AgentSession {
                     // (lifecycle record, preparation, branch) still tracks the session
                     // model. Falls back to the session model when the override is unset
                     // or cannot be resolved.
-                    const compactionModel = this._resolveCompactionModel(model);
                     const { model: requestModel, apiKey, headers, extraBody, env, thinkingLevel, } = await this._getCompactionRequestAuth(compactionModel, signal, this._summarizationRetryCallbacks({ source: "compaction", reason: request.reason }));
                     compactionResult = await this._runDefaultCompaction(preparation, requestModel, apiKey, headers, extraBody, request.customInstructions, signal, env, request.reason, thinkingLevel);
                 }
@@ -6371,13 +6444,13 @@ export class AgentSession {
             }
             this._resumeCompactionRequirement = undefined;
         }
-        const contextTokens = estimateContextTokens(filterContextExcludedMessages(this.sessionManager.buildSessionContext().messages)).tokens;
         const compacted = assistantMessage
             ? await this._checkCompaction(assistantMessage, skipAbortedCheck, inlineReason, retryAfterCompaction)
             : false;
         if (compacted || (assistantMessage && this._postCompactionUsageExemptAssistants.has(assistantMessage))) {
             return compacted;
         }
+        const contextTokens = this._estimatePrePromptContextTokens();
         // Under a virtual selection, the physical model of the latest response supplies the limits;
         // before one, the virtual model's declared limits apply. An undeclared window (<= 0) is unknown, so
         // admission never refuses a turn as "already over the threshold" (#2677). Compaction after a turn
@@ -6389,13 +6462,7 @@ export class AgentSession {
             !shouldCompact(contextTokens, limitsModel.contextWindow, settings)) {
             return false;
         }
-        const latestCompaction = getLatestCompactionEntry(this.sessionManager.getBranch());
         const assistantBeforeLatestCompaction = assistantMessage !== undefined && this._isAssistantFromBeforeLatestCompaction(assistantMessage);
-        const hasPostCompactionCustomState = latestCompaction !== null &&
-            this.agent.state.messages.some((message) => message.role === "custom" && message.timestamp >= new Date(latestCompaction.timestamp).getTime());
-        if (assistantBeforeLatestCompaction && !hasPostCompactionCustomState) {
-            return false;
-        }
         if (assistantBeforeLatestCompaction && assistantMessage) {
             const compacted = await this._runPrePromptCompaction(assistantMessage, skipAbortedCheck, inlineReason);
             if (compacted)
@@ -6406,6 +6473,32 @@ export class AgentSession {
         }
         throw new RequiredCompactionError();
     }
+    /** Share resume's branch provenance rule without projecting trusted usage on every request. */
+    _estimatePrePromptContextTokens(additions = []) {
+        const branch = this.sessionManager.getBranch();
+        const messages = [...this.sessionManager.buildSessionContext().messages, ...additions];
+        const estimate = estimateContextTokens(messages);
+        const usageMessage = estimate.lastUsageIndex === null ? undefined : messages[estimate.lastUsageIndex];
+        const usageEntryId = usageMessage ? getSessionContextEntryId(usageMessage) : undefined;
+        let needsProjection = false;
+        for (let i = branch.length - 1; i >= 0; i--) {
+            const entry = branch[i];
+            if (usageEntryId !== undefined && entry.id === usageEntryId)
+                break;
+            if (entry.type === "compaction" || entry.type === "context_edit") {
+                needsProjection = true;
+                break;
+            }
+        }
+        if (!needsProjection)
+            return estimate.tokens;
+        if (this._prePromptProjection?.branch !== branch) {
+            this._prePromptProjection = { branch, projection: this.sessionManager.buildSessionProjection() };
+        }
+        const { projection } = this._prePromptProjection;
+        return estimateProjectedContextTokens({ ...projection, messages: [...projection.messages, ...additions] }, branch)
+            .tokens;
+    }
     /**
      * Pending queued input the provider will also carry on this turn. Steering and
      * follow-up text enqueued after the admission projection was assembled - by a
@@ -6448,21 +6541,12 @@ export class AgentSession {
         const settings = this._getCompactionSettings();
         const reserveTokens = resolveEffectiveReserveTokens(model.contextWindow, settings);
         const isOversized = () => {
-            const providerMessages = filterContextExcludedMessages([
-                ...this.agent.state.messages,
+            const contextTokens = this._estimatePrePromptContextTokens([
                 ...messages,
                 // Re-read the queues on every sample: this closure is evaluated again
                 // after compaction, when more input may have arrived.
                 ...this._pendingQueuedInputMessages(),
             ]);
-            const estimate = estimateContextTokens(providerMessages);
-            const usageMessage = estimate.lastUsageIndex === null ? undefined : providerMessages[estimate.lastUsageIndex];
-            // Kept assistant usage can describe the pre-compaction request. Once a
-            // compaction boundary exists, fall back to byte-derived message estimates
-            // until a provider response refreshes that usage.
-            const contextTokens = usageMessage?.role === "assistant" && this._isAssistantFromBeforeLatestCompaction(usageMessage)
-                ? estimateMessagesTokens(providerMessages)
-                : estimate.tokens;
             return contextTokens > model.contextWindow - reserveTokens;
         };
         if (!settings.enabled || !isOversized())
@@ -6638,8 +6722,7 @@ export class AgentSession {
         let contextTokens;
         let staleUsageContentTokens;
         if (inlineReason) {
-            const messages = filterContextExcludedMessages(this.sessionManager.buildSessionContext().messages);
-            contextTokens = estimateContextTokens(messages).tokens;
+            contextTokens = this._estimatePrePromptContextTokens();
         }
         else {
             const directContextTokens = assistantMessage.usage ? calculateContextTokens(assistantMessage.usage) : 0;
@@ -6786,12 +6869,7 @@ export class AgentSession {
         const settings = this._getCompactionSettings();
         if (!model || !settings.enabled)
             return;
-        const canonicalMessages = filterContextExcludedMessages(this.sessionManager.buildSessionContext().messages);
-        const estimate = estimateContextTokens(canonicalMessages);
-        const usageMessage = estimate.lastUsageIndex === null ? undefined : canonicalMessages[estimate.lastUsageIndex];
-        const contextTokens = usageMessage?.role === "assistant" && this._isAssistantFromBeforeLatestCompaction(usageMessage)
-            ? estimateMessagesTokens(canonicalMessages)
-            : estimate.tokens;
+        const contextTokens = this._estimatePrePromptContextTokens();
         // An explicit user prompt passes the proactive policy in the compaction
         // extension's before_agent_start, which automatic continuations never emit.
         // Sampling the same predicate here makes both routes compact at the same
@@ -7379,9 +7457,13 @@ export class AgentSession {
             },
             getContextUsage: () => this.getContextUsage(),
             getCompactionSettings: () => this._getCompactionSettings(),
+            getCompactionModel: () => this.model && this._retryFallback.isProviderSpent(this.model.provider)
+                ? this._resolveCompactionModel(this.model)
+                : this.model,
             getPromptCacheSafeWaitSeconds: () => this.resolvePromptCacheSafeWaitSeconds(),
             getPromptCacheGoalBackstopMaxSeconds: () => this.settingsManager.getPromptCacheGoalBackstopMaxSeconds(),
             getPromptCacheKeepAliveSettings: () => this.settingsManager.getPromptCacheKeepAliveSettings(),
+            onUserActivity: (listener) => this._userActivity.subscribe(listener),
             getLookAtSettings: () => {
                 const global = this.settingsManager.getGlobalSettings().lookAt;
                 const project = this.settingsManager.getProjectSettings().lookAt;
@@ -8018,6 +8100,7 @@ export class AgentSession {
         return (describeProviderFailureForUser(message.errorMessage, {
             attempts,
             model,
+            usageLimit: usageLimitScope(message.errorMessage),
             recovery: this._retryFallback.hasConfiguredChain() ? "chain-exhausted" : "no-fallback-configured",
         }) ?? (message.errorMessage === undefined ? undefined : stripTurnRetrySuppressionPrefix(message.errorMessage)));
     }
@@ -8109,7 +8192,31 @@ export class AgentSession {
                 throw error;
             }
         };
-        if (sameModelRemint) {
+        if (usageLimitScope(errorMessage) === "account") {
+            switchedFallback = await tryFallback(isBillingErrorMessage(errorMessage) ? "billing" : "transient", {
+                errorMessage,
+                retryAfterMs: this._getProviderRetryDelayMs(errorMessage),
+            });
+            if (!switchedFallback) {
+                const chainKey = this._retryFallback.exhaustedChainKey;
+                if (chainKey)
+                    this._emit({ type: "retry_fallback_exhausted", chainKey, lastError: errorMessage });
+                if (this._retryAttempt > 0) {
+                    this._emit({
+                        type: "auto_retry_end",
+                        success: false,
+                        attempt: this._retryAttempt,
+                        finalError: this._terminalFailureText(message, this._retryAttempt),
+                    });
+                }
+                this._retryAttempt = 0;
+                this._resetHintTierState();
+                this._resolveRetry();
+                return "not-handled";
+            }
+            this._retryAttempt = 1;
+        }
+        else if (sameModelRemint) {
             this._retryAttempt++;
             if (this._retryAttempt > retryProfile.turn.maxRetries) {
                 if (this._retryAttempt > 1) {
@@ -8498,7 +8605,9 @@ export class AgentSession {
             attempt: this._retryAttempt,
             maxAttempts: retryProfile.turn.maxRetries,
             delayMs,
-            errorMessage,
+            errorMessage: usageLimitScope(errorMessage) === "account"
+                ? new AccountUsageLimitError(message.provider, errorMessage).message
+                : errorMessage,
         });
         // Remove error message from agent state (keep in session for history)
         const messages = this.agent.state.messages;
@@ -8535,7 +8644,7 @@ export class AgentSession {
         // before the continuation so a rejected compaction never admits that model.
         const model = this.model;
         const compactionSettings = this._getCompactionSettings();
-        const contextTokens = estimateContextTokens(filterContextExcludedMessages(this.sessionManager.buildSessionContext().messages)).tokens;
+        const contextTokens = this._estimatePrePromptContextTokens();
         if (compactionSettings.enabled &&
             model &&
             shouldCompact(contextTokens, model.contextWindow, compactionSettings)) {

package/dist/core/compaction/compaction.js

@@ -8,6 +8,7 @@ import { dropFailedAssistantTurns, getCurrentSystemMessage, normalizeContext, re
 import { streamSimple } from "@earendil-works/pi-ai/compat";
 import { estimateContextTokens as estimateProviderContextTokens } from "@earendil-works/pi-ai/utils/estimate";
 import { resolveEffectiveReserveTokens } from "../extensions/builtin/compaction/policy.js";
+import { withoutServerSearch } from "../extensions/builtin/server-search-fallback.js";
 import { convertToLlm, isContextExcludedCustomMessage } from "../messages.js";
 import { buildSessionProjection, sessionEntryToContextMessages, } from "../session-manager.js";
 import { estimateCacheKey, isTransientMessage, serializeForEstimate } from "./estimate-cache-key.js";
@@ -629,6 +630,7 @@ export async function completeSummarization(model, context, options, streamFn, r
     // opt into short retention for an exact provider-context prefix.
     const isolatedOptions = {
         ...options,
+        onPayload: withoutServerSearch(options.onPayload, options.cacheRetention),
         cacheRetention: options.cacheRetention ?? "none",
         affinitySessionId: options.affinitySessionId ?? options.sessionId,
         sessionId: uuidv7(),

package/dist/core/extensions/builtin/anthropic-web-search/index.js

@@ -1,3 +1,4 @@
+import { hasServerSearchFailed, isServerSearchDisabled, isServerSearchFallback, markServerSearchFallback, } from "../server-search-fallback.js";
 const WEB_SEARCH_MAX_USES = 8;
 const ENABLE_ENV = "PI_ANTHROPIC_WEB_SEARCH";
 const ALLOWED_DOMAINS_ENV = "PI_ANTHROPIC_WEB_SEARCH_ALLOWED_DOMAINS";
@@ -38,25 +39,26 @@ function resolveTarget(target) {
     }
     return target;
 }
-function isNativeAnthropicEndpoint(model) {
-    try {
-        return new URL(model.baseUrl).hostname === "api.anthropic.com";
-    }
-    catch {
-        return false;
-    }
-}
-// Mirrors pi-ai's `AnthropicMessagesCompat.supportsWebSearch` default:
-// first-party api.anthropic.com only. Anthropic-compatible endpoints (e.g.,
-// kimi-coding) may execute the server-side search but reject the replayed
-// server_tool_use / web_search_tool_result blocks on the next request.
+// https://platform.claude.com/docs/en/agents-and-tools/tool-use/web-search-tool
+// supportsWebSearch means BOTH main-request search and unchanged encrypted-result
+// replay. Preserve main's first-party API/Claude OAuth default; gateways opt in.
+// ccapi's Messages route passed a real search + replay for senpi#3122; opt its
+// provider/model entries in with compat.supportsWebSearch: true. Never infer that
+// compatibility from a proxy hostname. Other compatible routes remain explicit.
 export function supportsNativeAnthropicWebSearch(target) {
     const model = resolveTarget(target);
     if (model?.api !== "anthropic-messages") {
         return false;
     }
     const compat = model.compat;
-    return compat?.supportsWebSearch ?? isNativeAnthropicEndpoint(model);
+    if (compat?.supportsWebSearch !== undefined)
+        return compat.supportsWebSearch;
+    try {
+        return new URL(model.baseUrl).hostname === "api.anthropic.com";
+    }
+    catch {
+        return false;
+    }
 }
 function parseDomainListEnv(envVar) {
     const envValue = process.env[envVar];
@@ -132,6 +134,8 @@ export function addAnthropicWebSearchToPayload(target, payload) {
     if (!isRecord(payload)) {
         return payload;
     }
+    if (isServerSearchDisabled(payload) || isServerSearchFallback(payload))
+        return stripNativeAnthropicWebSearch(payload);
     if (!supportsNativeAnthropicWebSearch(model)) {
         // Anthropic-compatible endpoints (e.g., kimi-coding) may execute the
         // server-side search but reject the replayed server_tool_use /
@@ -175,7 +179,11 @@ Prefer web_search over guessing when freshness matters.
 `;
 export default function anthropicWebSearchExtension(pi) {
     pi.on("before_provider_request", (event, ctx) => {
-        return addAnthropicWebSearchToPayload(ctx.model, event.payload);
+        const model = event.model ?? ctx.model;
+        const payload = hasServerSearchFailed(ctx.sessionManager, model)
+            ? markServerSearchFallback(event.payload)
+            : event.payload;
+        return addAnthropicWebSearchToPayload(model, payload);
     });
     pi.on("session_start", async (_event, ctx) => {
         syncUi(ctx);

package/dist/core/extensions/builtin/cache-keepalive/index.js

@@ -3,6 +3,7 @@ import { convertToLlm, filterContextExcludedMessages } from "../../../messages.j
 import { noticeEntryRenderer } from "../../notice/index.js";
 import { formatWarmTokenCount } from "../goal/cache-warm.js";
 import { createSessionPrewarm } from "./session-prewarm.js";
+import { createStartupActivityGate } from "./startup-activity-gate.js";
 export const CACHE_KEEPALIVE_ENTRY_TYPE = "cache-keepalive";
 export const CACHE_WARM_PING_EVENT = "cache_warm_ping";
 export const renderCacheKeepAliveEntry = noticeEntryRenderer((entry) => {
@@ -20,6 +21,7 @@ export function createCacheKeepAliveExtension(dependencies = {}) {
     const warm = dependencies.warmPromptCache ?? warmPromptCache;
     return (pi) => {
         const prewarm = createSessionPrewarm(pi, { warm, isPrewarmModel: dependencies.isPromptCachePrewarmModel });
+        const startupActivity = createStartupActivityGate();
         let ctx;
         let timer;
         let inFlight = false;
@@ -57,7 +59,7 @@ export function createCacheKeepAliveExtension(dependencies = {}) {
             }
         }
         function arm() {
-            if (parked || timer !== undefined || inFlight)
+            if (startupActivity.waiting || parked || timer !== undefined || inFlight)
                 return;
             const current = ctx;
             const settings = current?.getPromptCacheKeepAliveSettings?.();
@@ -119,7 +121,7 @@ export function createCacheKeepAliveExtension(dependencies = {}) {
             const iteration = attempts;
             const pingGeneration = generation;
             try {
-                const preparation = await current.prepareProviderRequest?.(lastMessages);
+                const preparation = await current.prepareProviderRequest?.(lastMessages, { allowServerSearch: true });
                 if (pingGeneration !== generation) {
                     inFlight = false;
                     arm();
@@ -191,6 +193,7 @@ export function createCacheKeepAliveExtension(dependencies = {}) {
             }
         }
         pi.on("session_start", (_event, nextCtx) => {
+            prewarm.start(nextCtx);
             stop("session-restart");
             ctx = nextCtx;
             attempts = 0;
@@ -199,8 +202,7 @@ export function createCacheKeepAliveExtension(dependencies = {}) {
             const usage = lastAssistantUsage(lastMessages);
             lastUsage = usage;
             lastCompletedAtMs = lastAssistantTimestamp(lastMessages);
-            arm();
-            prewarm.start(nextCtx);
+            startupActivity.start(nextCtx, arm);
         });
         pi.on("agent_end", (event, nextCtx) => {
             ctx = nextCtx;
@@ -211,6 +213,7 @@ export function createCacheKeepAliveExtension(dependencies = {}) {
                 return;
             }
             lastMessages = [...event.messages];
+            startupActivity.release();
             lastUsage = usage;
             lastCompletedAtMs = Date.now();
             armOnSettle = true;
@@ -241,6 +244,7 @@ export function createCacheKeepAliveExtension(dependencies = {}) {
         pi.on("input", () => stop("user-input"));
         pi.on("session_shutdown", () => {
             stop("session-dispose");
+            startupActivity.release();
             prewarm.cancel();
             ctx = undefined;
         });

package/dist/core/extensions/builtin/cache-keepalive/session-prewarm.d.ts

@@ -11,7 +11,8 @@ export interface SessionPrewarm {
     cancel(): void;
 }
 /**
- * One prompt-cache prewarm per session start for OpenAI GPT-5.6+ models (senpi#2096).
+ * Arm at session start, then prewarm once on the first draft edit (senpi#3140).
+ * A submitted prompt consumes the opportunity: the real request warms its own prefix.
  * The request is the host's `getPromptCachePrefixRequest()` prefix, the first user turn's
  * request with an empty conversation, because the platform reuses a prefix only up to a
  * block boundary: a prewarmed system prompt that stops short of the turn's is never read.

package/dist/core/extensions/builtin/cache-keepalive/session-prewarm.js

@@ -2,7 +2,8 @@ import { isOpenAIResponsesPromptCacheModel, } from "@earendil-works/pi-ai";
 import { PROMPT_CACHE_PREWARM_ENTRY_TYPE } from "./prewarm-entry.js";
 export const PROMPT_CACHE_PREWARM_TIMEOUT_MS = 30_000;
 /**
- * One prompt-cache prewarm per session start for OpenAI GPT-5.6+ models (senpi#2096).
+ * Arm at session start, then prewarm once on the first draft edit (senpi#3140).
+ * A submitted prompt consumes the opportunity: the real request warms its own prefix.
  * The request is the host's `getPromptCachePrefixRequest()` prefix, the first user turn's
  * request with an empty conversation, because the platform reuses a prefix only up to a
  * block boundary: a prewarmed system prompt that stops short of the turn's is never read.
@@ -15,6 +16,11 @@ export const PROMPT_CACHE_PREWARM_TIMEOUT_MS = 30_000;
 export function createSessionPrewarm(pi, dependencies) {
     const isPrewarmModel = dependencies.isPrewarmModel ?? isOpenAIResponsesPromptCacheModel;
     let current;
+    let context;
+    let used = false;
+    let submitted = false;
+    let parked = false;
+    let unsubscribeActivity;
     function cancel() {
         current?.abort();
         current = undefined;
@@ -30,6 +36,8 @@ export function createSessionPrewarm(pi, dependencies) {
                 return;
             }
             const { request } = prefix;
+            if (submitted || ctx.getPromptCacheKeepAliveSettings?.().enabled !== true)
+                return;
             const result = await dependencies.warm(request.model, request.context, {
                 ...request.options,
                 signal,
@@ -53,15 +61,55 @@ export function createSessionPrewarm(pi, dependencies) {
     function append(data) {
         pi.appendEntry(PROMPT_CACHE_PREWARM_ENTRY_TYPE, data);
     }
+    function onActivity(kind) {
+        if (kind === "prompt") {
+            submitted = true;
+            used = true;
+            return;
+        }
+        if (context === undefined || parked || used)
+            return;
+        used = true;
+        const ctx = context;
+        const model = ctx.model;
+        if (ctx.getPromptCacheKeepAliveSettings?.().enabled !== true ||
+            model === undefined ||
+            model.cacheRetention === "none" ||
+            !isPrewarmModel(model) ||
+            !ctx.isIdle() ||
+            ctx.hasPendingMessages())
+            return;
+        const controller = new AbortController();
+        current = controller;
+        void run(ctx, model, controller);
+    }
+    pi.on("model_select", (_event, ctx) => {
+        cancel();
+        context = ctx;
+    });
+    pi.on("session_parked", () => {
+        parked = true;
+        cancel();
+    });
+    pi.on("session_resumed", (_event, ctx) => {
+        parked = false;
+        context = ctx;
+    });
+    pi.on("session_shutdown", () => {
+        unsubscribeActivity?.();
+        unsubscribeActivity = undefined;
+        context = undefined;
+        cancel();
+    });
     return {
         start(ctx) {
             cancel();
-            const model = ctx.model;
-            if (model === undefined || model.cacheRetention === "none" || !isPrewarmModel(model))
-                return;
-            const controller = new AbortController();
-            current = controller;
-            void run(ctx, model, controller);
+            unsubscribeActivity?.();
+            context = ctx;
+            used = false;
+            submitted = false;
+            parked = false;
+            unsubscribeActivity = ctx.onUserActivity?.(onActivity);
         },
         cancel,
     };

package/dist/core/extensions/builtin/cache-keepalive/startup-activity-gate.d.ts

@@ -0,0 +1,8 @@
+import type { ExtensionContext } from "../../types.ts";
+/** Restored history is not admission; real activity or a completed turn is. */
+export declare function createStartupActivityGate(): {
+    readonly waiting: boolean;
+    start(ctx: ExtensionContext, onActivity: () => void): void;
+    release: () => void;
+};
+//# sourceMappingURL=startup-activity-gate.d.ts.map