zigmini 0.8.0-beta.6 → 0.9.0-beta.1

package/host/omo-check/patches/omo-5.1.44-compaction-port.patch

@@ -0,0 +1,2630 @@
+--- a/@code-yeongyu/senpi/dist/core/agent-session.d.ts
++++ b/@code-yeongyu/senpi/dist/core/agent-session.d.ts
+@@ -32,7 +32,7 @@
+ import { type PendingModelSwitch } from "./extensions/builtin/compaction/switch-admission.ts";
+ import { type ServiceTier } from "./extensions/builtin/service-tier.ts";
+ import { type ContextUsage, type ExecuteToolOptions, type ExtensionCommandContextActions, type ExtensionErrorListener, type ExtensionMode, ExtensionRunner, type ExtensionToolHookLifecycleEvent, type ExtensionUIContext, type InputSource, type ReplacedSessionContext, type SessionStartEvent, type ShutdownHandler, type SystemPromptChangeEvent, type ToolDefinition, type ToolInfo } from "./extensions/index.ts";
+-import type { ApplyCompactionOptions, ApplyCompactionResult, CompactionReason, CompactionRejectionCause, ModelSelectSource } from "./extensions/types.ts";
++import type { ApplyCompactionOptions, ApplyCompactionResult, CompactionReason, CompactionRejectionCause, CompactionFailure, ModelSelectSource } from "./extensions/types.ts";
+ import { type UserActivityKind } from "./extensions/user-activity.ts";
+ import { ExternalAdmission } from "./external-admission.ts";
+ import { type HoldInputResult } from "./held-inputs.ts";
+@@ -116,6 +116,10 @@
+ } | {
+     type: "session_abort";
+ } | SessionHoldEvent | {
++    type: "queued_input_resume";
++    clientInputId: string;
++    disposition: "stale_epoch" | "busy" | "not_head" | "resumed";
++} | {
+     type: "resume_compaction_required";
+     projection: ModelUsabilityBudgetProjection;
+     notice: string;
+@@ -166,12 +170,14 @@
+     type: "pending_input_update";
+ } & PendingInputUpdate) | {
+     type: "queue_update";
++    queueEpoch: string;
+     steering: readonly string[];
+     followUp: readonly string[];
+     ordered: readonly QueuedInput[];
+ } | {
+     type: "compaction_start";
+     reason: CompactionReason;
++    blocking?: boolean;
+     requestId?: string;
+ } | {
+     type: "compaction_progress";
+@@ -260,7 +266,9 @@
+     autoCompactionEnabled: boolean;
+ } | {
+     type: "compaction_end";
++    failure?: CompactionFailure;
+     reason: CompactionReason;
++    blocking?: boolean;
+     result: CompactionResult | undefined;
+     aborted: boolean;
+     willRetry: boolean;
+@@ -609,6 +617,10 @@
+ export { CURSOR_TOOL_RESULT_MAX_CHARS, truncateToolResultBodies } from "./cursor-history-admission.ts";
+ export declare function providerRetryWatchdogAbortMessage(retryTimeoutMs: number | undefined, streamStartTimeoutMs: number | undefined): string;
+ export declare class AgentSession {
++    queueEpoch: string;
++    resumeQueuedInput(clientInputId: string, queueEpoch: string): {
++        disposition: "stale_epoch" | "not_queued" | "busy" | "scheduled";
++    };
+     readonly agent: Agent;
+     readonly sessionManager: SessionManager;
+     readonly settingsManager: SettingsManager;
+@@ -889,9 +901,8 @@
+      * `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.
+-     * Unset, malformed, unknown, spent, or credential-less overrides keep a usable session model;
+-     * a set override that cannot serve logs why the session model was used.
+-     * A spent account instead uses the held target or another authenticated model.
++     * Auto selection stays within the active provider; explicit values never fall back.
++     * Selection uses the availability snapshot. Authentication remains request-time.
+      */
+     private _resolveCompactionModel;
+     private _logCompactionModelFallback;
+@@ -2291,4 +2302,4 @@
+      */
+     get extensionRunner(): ExtensionRunner;
+ }
+-//# sourceMappingURL=agent-session.d.ts.map
+
++//# sourceMappingURL=agent-session.d.ts.map
+--- a/@code-yeongyu/senpi/dist/core/agent-session.js
++++ b/@code-yeongyu/senpi/dist/core/agent-session.js
+@@ -43,6 +43,7 @@
+ import { envValue } from "./brand.js";
+ import { clientMessageIdentity, readClientMessageIdentity, } from "./client-message-identity.js";
+ import { calculateContextTokens, collectEntriesForBranchSummary, compact, estimateContextTokens, estimateProjectedContextTokens, estimateTokens, generateBranchSummary, prepareCompaction, resolveThresholdContextTokens, shouldCompact, } from "./compaction/index.js";
++import { compactionFailure, validateSummaryResponse } from "./extensions/builtin/compaction/speculative.js";
+ import { CompactionLifecycleCoordinator } from "./compaction/lifecycle.js";
+ import { isTurnStuckOnContextOverflow } from "./compaction/stuck-overflow.js";
+ import { isWarmSummaryAnchorValid } from "./compaction/warm-anchor.js";
+@@ -223,12 +224,13 @@
+     }
+ }
+ class CompactionRejectedError extends Error {
+-    constructor(rejectionCause) {
+-        super(rejectionCause === "cancelled-by-extension"
++    constructor(rejectionCause, failure) {
++        super(failure ? "Compaction failed; previous context retained" : rejectionCause === "cancelled-by-extension"
+             ? "Compaction cancelled"
+             : describeCompactionRejection(rejectionCause));
+         this.name = "CompactionRejectedError";
+         this.rejectionCause = rejectionCause;
++        this.failure = failure;
+     }
+ }
+ class CompactionCancelledError extends Error {
+@@ -248,6 +250,7 @@
+         this.name = "CompactionExecutionError";
+         this.ownsTerminalTransition = ownsTerminalTransition;
+         this.aborted = aborted;
++        this.failure = aborted ? undefined : compactionFailure(error);
+     }
+ }
+ function compactionExecutionOwnsTerminalTransition(error) {
+@@ -417,6 +420,7 @@
+         this._userInputSources = new WeakMap();
+         /** Recently delivered `queuedId`s (bounded), so a late dequeue answers `already_delivered`, not `not_found`. */
+         this._deliveredQueuedIds = new Set();
++        this.queueEpoch = randomUUID();
+         this._supersededCompactionLogAttemptIds = new Set();
+         /** Messages queued to be included with the next user prompt as context ("asides"). */
+         this._pendingNextTurnMessages = [];
+@@ -920,58 +924,58 @@
+      * `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.
+-     * Unset, malformed, unknown, spent, or credential-less overrides keep a usable session model;
+-     * a set override that cannot serve logs why the session model was used.
+-     * A spent account instead uses the held target or another authenticated model.
++     * Auto selection stays within the active provider; explicit values never fall back.
++     * Selection uses the availability snapshot. Authentication remains request-time.
+      */
+-    _resolveCompactionModel(sessionModel) {
+-        const override = this._getCompactionSettings().model;
+-        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)) {
+-            if (!override)
+-                return sessionModel;
+-            const fallbackReason = !configured
+-                ? slash > 0
+-                    ? "unknown_model"
+-                    : "malformed"
+-                : !usable(configured)
+-                    ? "provider_spent"
+-                    : this._modelRuntime.hasFreshAvailabilitySnapshot() &&
+-                        !this._modelRuntime.hasConfiguredAuth(configured.provider)
+-                        ? // Only a published availability pass can say "no credentials": before it (or
+-                            // after a busy store read) the answer is unknown, the override is kept, and
+-                            // request-time auth decides.
+-                            "no_credentials"
+-                        : undefined;
+-            if (configured && fallbackReason === undefined) {
+-                this._compactionModelFallbackNotice = undefined;
+-                return configured;
+-            }
+-            if (fallbackReason)
+-                this._logCompactionModelFallback(override, fallbackReason, sessionModel);
+-            return sessionModel;
+-        }
+-        const pending = this._pendingModelSwitch?.model;
+-        if (pending && usable(pending))
+-            return pending;
+-        if (configured && usable(configured))
++    _resolveCompactionModel(sessionModel, inputTokens = 0) {
++        const settings = this._getCompactionSettings();
++        const override = settings.model;
++        const explicit = override !== undefined && override !== "auto";
++        const fail = (kind, model = sessionModel) => {
++            throw Object.assign(new Error(
++                explicit ? "Compaction model unavailable; check compaction.model or set it to auto."
++                    : "No usable compaction model within the active provider."),
++                { failure: { kind, provider: model.provider, model: model.id } });
++        };
++        const chat = this._modelRuntime.getModels();
++        const available = this._modelRuntime.getAvailableSnapshot();
++        const same = (left, right) => left.provider === right.provider && left.id === right.id;
++        const usable = (model) => chat.some((entry) => same(entry, model)) && (!available.some((entry) => entry.provider === model.provider) || available.some((entry) => same(entry, model))) &&
++            !this._retryFallback.isProviderSpent(model.provider) &&
++            this._modelRuntime.isFallbackEligible(model.provider);
++        const fits = (model) => {
++            const output = Math.min(32768, model.maxTokens > 0 ? model.maxTokens : 32768, Math.floor(model.contextWindow / 2));
++            return model.contextWindow > 0 && inputTokens + Math.max(settings.reserveTokens, output) <= model.contextWindow;
++        };
++        if (explicit) {
++            if (typeof override !== "string" || !/^[^/\s]+\/\S+$/.test(override))
++                return fail("invalid_model");
++            const slash = override.indexOf("/");
++            const configured = this._modelRuntime.getModel(override.slice(0, slash), override.slice(slash + 1));
++            if (!configured || !chat.some((model) => same(model, configured)))
++                return fail("invalid_model");
++            if (this._retryFallback.isProviderSpent(configured.provider))
++                return fail("quota", configured);
++            if (!usable(configured))
++                return fail("model_unavailable", configured);
++            if (!fits(configured))
++                return fail("context_budget", 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));
++        }
++        if (this._retryFallback.isProviderSpent(sessionModel.provider))
++            return fail("quota");
++        const family = ["anthropic", "anthropic-subscription"].includes(sessionModel.provider) && /^claude-/.test(sessionModel.id) ? /^claude-sonnet-/
++            : ["openai", "chatgpt-subscription"].includes(sessionModel.provider) && /^gpt-/.test(sessionModel.id) ? /^gpt-.*-luna(?:-fast)?$/ : undefined;
++        const preferred = family ? available.filter((model) =>
++            model.provider === sessionModel.provider && family.test(model.id)) : [];
++        // Stable sort preserves registry order within the regular and fast Luna groups.
++        preferred.sort((left, right) => Number(/-luna-fast$/.test(left.id)) - Number(/-luna-fast$/.test(right.id)));
++        const candidates = [...(family?.test(sessionModel.id) ? [sessionModel] : []), ...preferred, sessionModel];
++        for (const candidate of candidates) {
++            if (candidate.provider === sessionModel.provider && usable(candidate) && fits(candidate))
++                return candidate;
++        }
++        return fail(usable(sessionModel) ? "context_budget" : "model_unavailable");
+     }
+     _logCompactionModelFallback(override, reason, sessionModel) {
+         const notice = `${override}\u0000${reason}`;
+@@ -985,11 +989,10 @@
+         });
+     }
+     async _getCompactionRequestAuth(model, signal, callbacks) {
+-        const auth = await this._getSummarizationRequestAuth(model, signal, callbacks);
+-        return {
+-            ...auth,
+-            extraBody: this._modelRuntime.getCompatibilityRequestConfig(model).extraBody,
+-        };
++        const prepared = await retryTransientCall(() => this._modelRuntime.prepareRequest(model, { signal }),
++            isOAuthRefreshUnavailableError, this.settingsManager.getRetrySettings(), signal,
++            callbacks ?? this._summarizationRetryCallbacks({ source: "compaction" }));
++        return { ...prepared.options, model: prepared.model, thinkingLevel: this.thinkingLevel };
+     }
+     /**
+      * The model whose limits apply to `message`, or undefined when the message came from another
+@@ -1771,6 +1774,7 @@
+             steering: [...this._steeringMessages],
+             followUp: [...this._followUpMessages],
+             ordered: [...this._queuedInputOrder].sort((a, b) => a.enqueueOrder - b.enqueueOrder),
++            queueEpoch: this.queueEpoch,
+         });
+     }
+     _incrementMessageRevision() {
+@@ -5705,6 +5709,16 @@
+         this._nextQueuedId += 1;
+         return `q_${this._nextQueuedId}`;
+     }
++    resumeQueuedInput(clientInputId, queueEpoch) {
++        if (queueEpoch !== this.queueEpoch)
++            return { disposition: "stale_epoch" };
++        if (!this._queuedInputOrder.some((input) => input.clientInputId === clientInputId))
++            return { disposition: "not_queued" };
++        if (this.isStreaming || this.isCompacting)
++            return { disposition: "busy" };
++        this._scheduleContinuationAfterCurrentEvent({ retainedInput: { clientInputId, queueEpoch } });
++        return { disposition: "scheduled" };
++    }
+     /** A queued input reached a turn: forget its record and remember its id as delivered. */
+     _removeQueuedInput(text, mode, clientMessageId) {
+         const index = this._queuedInputOrder.findIndex((message) => clientMessageId === undefined
+@@ -5843,6 +5857,7 @@
+             });
+         });
+         this._queueClearRecorded = recorded;
++        this.queueEpoch = randomUUID();
+         this._postCompactionDeferredSteeringMessages = [];
+         this._postCompactionDeferredFollowUpMessages = [];
+         this.agent.clearAllQueues();
+@@ -7016,9 +7031,22 @@
+                 };
+             }
+         }
++        const checkedStream = async (model, context, options) => {
++            const stream = await this.agent.streamFunction(model, context, {
++                ...options, refusalFallbacks: undefined, streamKind: "auxiliary",
++            });
++            return {
++                [Symbol.asyncIterator]: () => stream[Symbol.asyncIterator](),
++                result: async () => {
++                    const response = await stream.result();
++                    validateSummaryResponse(response);
++                    return response;
++                },
++            };
++        };
+         return compact(preparation, requestModel, apiKey, headers, customInstructions, signal, extraBody, 
+         // The routed thinking level under a virtual selection, the session's otherwise.
+-        thinkingLevel, this.agent.streamFunction, env, this.agent.transformContext, this.settingsManager.getRetrySettings(), this._summarizationRetryCallbacks({ source: "compaction", reason }), this.sessionManager.getSessionId(), cacheFriendly);
++        thinkingLevel, checkedStream, env, this.agent.transformContext, this.settingsManager.getRetrySettings(), this._summarizationRetryCallbacks({ source: "compaction", reason }), this.sessionManager.getSessionId(), cacheFriendly);
+     }
+     /**
+      * Manually compact the session context.
+@@ -7090,7 +7118,7 @@
+                 willRetry: false,
+             });
+             if (!execution.accepted) {
+-                throw new CompactionRejectedError(execution.rejectionCause);
++                throw new CompactionRejectedError(execution.rejectionCause, execution.failure);
+             }
+             outcome = "completed";
+             this._clearResumeCompactionRequirementIfFits();
+@@ -7099,7 +7127,7 @@
+         catch (error) {
+             outcome = isCompactionExecutionAborted(error) ? "aborted" : "failed";
+             if (error instanceof CompactionRejectedError) {
+-                throw new Error(error.message);
++                throw Object.assign(new Error(error.message), { failure: error.failure });
+             }
+             if (!compactionExecutionOwnsTerminalTransition(error)) {
+                 throw error;
+@@ -7157,6 +7185,7 @@
+             this._emit({
+                 type: "compaction_start",
+                 reason: options.reason,
++                blocking: options.blocking,
+                 requestId,
+             });
+         }
+@@ -7169,6 +7198,7 @@
+                 controller,
+                 owner: "compaction",
+                 reason: options.reason,
++                blocking: options.blocking,
+                 requestId,
+                 willRetry: false,
+                 precomputed,
+@@ -7189,6 +7219,7 @@
+             this._emit({
+                 type: "compaction_end",
+                 reason: options.reason,
++                blocking: options.blocking,
+                 result: undefined,
+                 aborted,
+                 willRetry: false,
+@@ -7254,11 +7285,12 @@
+             aborted,
+             willRetry: false,
+             requestId: operation.operationId,
++            accepted: false,
++            failure: aborted ? undefined : options.failure ?? { kind: "provider" },
+             errorMessage: aborted ? undefined : (options.errorMessage ?? "Compaction did not apply"),
+         });
+         this._releaseCompactionController(options.signal);
+-        if (!aborted)
+-            this._resumeQueuedMessagesAfterCompaction();
++
+     }
+     async _executeCompaction(request) {
+         const model = this.model;
+@@ -7302,7 +7334,6 @@
+                     }
+                     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({
+@@ -7325,7 +7356,7 @@
+                         throw new CompactionCancelledError();
+                     }
+                     if (extensionResult?.cancel) {
+-                        return await this._rejectCompaction(request, requestId, operationId, extensionResult.rejectionCause ?? "cancelled-by-extension", true, extensionResult.reason);
++                        return await this._rejectCompaction(request, requestId, operationId, extensionResult.rejectionCause ?? "cancelled-by-extension", signal.aborted, extensionResult.reason, extensionResult.failure);
+                     }
+                     if (extensionResult?.compaction) {
+                         compactionResult = extensionResult.compaction;
+@@ -7333,13 +7364,17 @@
+                     }
+                 }
+                 if (!compactionResult) {
+-                    // A configured compaction.model override redirects only the
+-                    // summarization call to that model; every other part of the session
+-                    // (lifecycle record, preparation, branch) still tracks the session
+-                    // model. Falls back to the session model when the override is unset
+-                    // or cannot be resolved.
++                    // Size the complete source, including control text, before selecting a model.
++                    // The final serialized request is checked again at the dispatch boundary.
++                    const inputTokens = estimateMessagesTokens([...preparation.messagesToSummarize, ...preparation.turnPrefixMessages]) +
++                        Math.ceil(JSON.stringify([this.agent.state.systemPrompt, this.agent.state.tools,
++                            preparation.previousSummary, request.customInstructions]).length / 4) + 8192;
++                    const compactionModel = this._resolveCompactionModel(model, inputTokens);
+                     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);
++                    compactionResult.details = { ...compactionResult.details,
++                        selectionMode: settings.model === undefined || settings.model === "auto" ? "auto" : "explicit",
++                        requestedProvider: compactionModel.provider, requestedModel: compactionModel.id };
+                 }
+             }
+             if (signal.aborted) {
+@@ -7366,24 +7401,20 @@
+             if (sourceChanged) {
+                 return await this._rejectCompaction(request, requestId, operationId, "stale-revision", false);
+             }
+-            if (await this._wouldCompactionOverflow(pathEntries, compactionResult, fromExtension, model)) {
++            if (typeof compactionResult.summary !== "string" || !compactionResult.summary.trim())
++                return await this._rejectCompaction(request, requestId, operationId, "cancelled-by-extension", false,
++                    "Compaction summary body is empty", { kind: "empty" });
++            const fitModel = this._limitsModel() ?? model;
++            if (await this._wouldCompactionOverflow(pathEntries, compactionResult, fromExtension, fitModel)) {
+                 return await this._rejectCompaction(request, requestId, operationId, "would-overflow", false);
+             }
+-            const latestConfigurationEffort = this.sessionManager
+-                .getBranch()
+-                .findLast((entry) => entry.type === "configuration_update")?.reasoning.effort;
+-            const compactionEntryId = this.sessionManager.appendCompaction(compactionResult.summary, compactionResult.firstKeptEntryId, compactionResult.tokensBefore, compactionResult.details, fromExtension, compactionResult.usage);
+-            const savedEntry = this.sessionManager.getEntry(compactionEntryId);
+-            if (savedEntry?.type !== "compaction") {
+-                throw new Error("Compaction entry was not saved");
+-            }
+-            const modelAfterCompaction = this.model;
+-            if (latestConfigurationEffort !== undefined &&
+-                modelAfterCompaction !== undefined &&
+-                supportsConfigurationUpdate(modelAfterCompaction)) {
+-                this.sessionManager.appendConfigurationUpdate(latestConfigurationEffort);
+-            }
+-            const sessionContext = this.sessionManager.buildSessionContext();
++            if (signal.aborted)
++                throw new CompactionCancelledError();
++            if (this._limitsModel() !== fitModel || this._messageRevision !== lifecycleState.startedRevision + compactionOwnedDiagnosticMessages.size ||
++                !agentMessagesAtStart.every((message, index) => this.agent.state.messages[index] === message) ||
++                !this.agent.state.messages.slice(agentMessagesAtStart.length).every((message) =>
++                    this._messageEndsAwaitingPersistence.has(message) || compactionOwnedDiagnosticMessages.has(message)))
++                return await this._rejectCompaction(request, requestId, operationId, "stale-revision", false);
+             const currentAgentMessages = this.agent.state.messages;
+             const hasUnchangedPrefix = agentMessagesAtStart.every((message, index) => currentAgentMessages[index] === message);
+             const messagesAppendedDuringCompaction = hasUnchangedPrefix
+@@ -7400,6 +7431,24 @@
+                 }
+             }
+             const preservedPendingMessages = currentAgentMessages.filter((message) => preservedIdentities.delete(message));
++            if (preservedPendingMessages.length > 0 &&
++                wouldCompactionOverflow(pathEntries, compactionResult, fromExtension, fitModel, this._getCompactionSettings(), preservedPendingMessages))
++                return await this._rejectCompaction(request, requestId, operationId, "would-overflow", false);
++            const latestConfigurationEffort = this.sessionManager
++                .getBranch()
++                .findLast((entry) => entry.type === "configuration_update")?.reasoning.effort;
++            const compactionEntryId = this.sessionManager.appendCompaction(compactionResult.summary, compactionResult.firstKeptEntryId, compactionResult.tokensBefore, compactionResult.details, fromExtension, compactionResult.usage);
++            const savedEntry = this.sessionManager.getEntry(compactionEntryId);
++            if (savedEntry?.type !== "compaction") {
++                throw new Error("Compaction entry was not saved");
++            }
++            const modelAfterCompaction = this.model;
++            if (latestConfigurationEffort !== undefined &&
++                modelAfterCompaction !== undefined &&
++                supportsConfigurationUpdate(modelAfterCompaction)) {
++                this.sessionManager.appendConfigurationUpdate(latestConfigurationEffort);
++            }
++            const sessionContext = this.sessionManager.buildSessionContext();
+             this._skipNextPostCompactionAssistantCheck = true;
+             for (const message of preservedPendingMessages) {
+                 if (message.role === "assistant") {
+@@ -7407,7 +7456,7 @@
+                 }
+             }
+             this.agent.state.messages = [...sessionContext.messages, ...preservedPendingMessages];
+-            compactionResult.estimatedTokensAfter = estimateMessagesTokens(sessionContext.messages);
++            compactionResult.estimatedTokensAfter = estimateMessagesTokens(this.agent.state.messages);
+             this._incrementMessageRevision();
+             if (!this._compactionLifecycle.finish({
+                 operationId,
+@@ -7423,6 +7472,7 @@
+             this._emit({
+                 type: "compaction_end",
+                 reason: request.reason,
++                blocking: request.blocking,
+                 result: compactionResult,
+                 aborted: false,
+                 willRetry: request.willRetry,
+@@ -7456,15 +7506,10 @@
+             }
+             const lifecycleState = this._compactionLifecycle.state;
+             const ownsTerminalTransition = lifecycleState.status !== "idle" && lifecycleState.operationId === operationId;
+-            const aborted = signal.aborted || isCompactionExecutionAborted(error);
+-            if (ownsTerminalTransition && lifecycleState.status === "running") {
+-                this._compactionLifecycle.finish({
+-                    operationId,
+-                    status: aborted ? "aborted" : "failed",
+-                    endedRevision: this._messageRevision,
+-                    errorMessage: error instanceof Error ? error.message : String(error),
+-                });
+-            }
++            const aborted = signal.aborted;
++            if (ownsTerminalTransition && lifecycleState.status === "running")
++                return await this._rejectCompaction(request, requestId, operationId, "cancelled-by-extension", aborted,
++                    aborted ? undefined : "Compaction failed; previous context retained", aborted ? undefined : compactionFailure(error, model));
+             throw new CompactionExecutionError(error, ownsTerminalTransition, aborted);
+         }
+         finally {
+@@ -7512,7 +7557,8 @@
+         }
+         this.agent.state.messages = [...sessionMessages, ...pendingMessages];
+     }
+-    async _rejectCompaction(request, requestId, operationId, rejectionCause, aborted, extensionReason) {
++    async _rejectCompaction(request, requestId, operationId, rejectionCause, aborted, extensionReason, failure) {
++        failure = aborted || rejectionCause === "external-owner" ? undefined : failure ?? { kind: rejectionCause === "stale-revision" ? "stale" : rejectionCause === "would-overflow" ? "context_budget" : "provider" };
+         // Per plan Section 1: rejection must never be silent. The compaction_end event
+         // carries a non-empty human-readable errorMessage (unless the user aborted, where
+         // the aborted branch already renders "Compaction cancelled"). session_compact is
+@@ -7529,7 +7575,7 @@
+         const errorMessage = aborted && !trimmedExtensionReason ? undefined : detailedMessage;
+         if (!this._compactionLifecycle.finish({
+             operationId,
+-            status: "failed",
++            status: aborted ? "aborted" : "failed",
+             endedRevision: this._messageRevision,
+             rejectionCause,
+             ...(trimmedExtensionReason !== undefined ? { errorMessage: trimmedExtensionReason } : {}),
+@@ -7539,12 +7585,14 @@
+         this._emit({
+             type: "compaction_end",
+             reason: request.reason,
++            blocking: request.blocking,
+             result: undefined,
+             aborted,
+             willRetry: false,
+             requestId,
+             accepted: false,
+             rejectionCause,
++            failure,
+             errorMessage,
+         });
+         await this._extensionRunner.emit({
+@@ -7553,10 +7601,11 @@
+             requestId,
+             accepted: false,
+             rejectionCause,
++            failure,
+             fromExtension: false,
+             willRetry: false,
+         });
+-        return { accepted: false, requestId, rejectionCause };
++        return { accepted: false, requestId, rejectionCause, aborted, failure };
+     }
+     /**
+      * Cancel in-progress compaction (manual or auto).
+@@ -8138,6 +8187,23 @@
+                 this._transcriptWriteFailures.startRun();
+             await runBoundedRetryContinuation({
+                 continueRun: async () => {
++                    if (options.retainedInput) {
++                        const { retainedInput, ...continuationOptions } = options;
++                        const disposition = retainedInput.queueEpoch !== this.queueEpoch
++                            ? "stale_epoch"
++                            : await this.agent.continueQueuedInput(retainedInput.clientInputId, {
++                                ...continuationOptions,
++                                onStart: () => {
++                                    this._isAgentRunActive = true;
++                                },
++                            });
++                        this._emit({
++                            type: "queued_input_resume",
++                            clientInputId: retainedInput.clientInputId,
++                            disposition,
++                        });
++                        return;
++                    }
+                     if (this._continueWithQueuedInput) {
+                         // Joined input of a start that never ran: the transcript tail may be anything, even empty.
+                         this._continueWithQueuedInput = false;
+@@ -8395,6 +8461,8 @@
+                 willRetry: false,
+                 requestId,
+                 errorMessage: formattedErrorMessage,
++                accepted: false,
++                failure: aborted ? undefined : compactionFailure(error, model),
+             });
+             await this._emitSessionCompactFailed({
+                 reason,
+@@ -8718,9 +8786,10 @@
+             },
+             getContextUsage: () => this.getContextUsage(),
+             getCompactionSettings: () => this._getCompactionSettings(),
+-            // One resolver for core and builtin compaction: a configured `compaction.model`
+-            // summarizes on a healthy provider too, not only after the account is spent (#830).
+-            getCompactionModel: () => (this.model ? this._resolveCompactionModel(this.model) : undefined),
++            getCompactionModel: (inputTokens) => {
++                const model = this._limitsModel();
++                return model && this._resolveCompactionModel(model, inputTokens);
++            },
+             getPromptCacheSafeWaitSeconds: () => this.resolvePromptCacheSafeWaitSeconds(),
+             getPromptCacheGoalBackstopMaxSeconds: () => this.settingsManager.getPromptCacheGoalBackstopMaxSeconds(),
+             getPromptCacheKeepAliveSettings: () => this.settingsManager.getPromptCacheKeepAliveSettings(),
+@@ -10818,4 +10887,4 @@
+     const requestContext = usage?.contextUsage;
+     return `${size}:${usage?.input ?? ""}:${usage?.output ?? ""}:${usage?.totalTokens ?? ""}:${requestContext?.input}:${requestContext?.output}:${requestContext === null}`;
+ }
+-//# sourceMappingURL=agent-session.js.map
+
++//# sourceMappingURL=agent-session.js.map
+--- a/@code-yeongyu/senpi/dist/core/compaction/compaction.js
++++ b/@code-yeongyu/senpi/dist/core/compaction/compaction.js
+@@ -636,8 +636,13 @@
+         onPayload: withoutServerSearch(options.onPayload, options.cacheRetention),
+         cacheRetention: options.cacheRetention ?? "none",
+         affinitySessionId: options.affinitySessionId ?? options.sessionId,
++        streamKind: "auxiliary",
+         sessionId: uuidv7(),
+     };
++    if (model.contextWindow <= 0 || estimateProviderContextTokens(context).tokens + options.maxTokens > model.contextWindow) {
++        throw Object.assign(new Error("Compaction request exceeds the selected model context budget"),
++            { failure: { kind: "context_budget", provider: model.provider, model: model.id } });
++    }
+     const callerSignal = options.signal;
+     // The 120s floor was tuned for healthy summaries; a large session feeds the
+     // summarizer hundreds of thousands of tokens, which legitimately takes longer
+@@ -946,4 +951,4 @@
+ // Main compaction function
+ // ============================================================================
+ export { compact } from "./compaction-execution.js";
+-//# sourceMappingURL=compaction.js.map
+
++//# sourceMappingURL=compaction.js.map
+--- a/@code-yeongyu/senpi/dist/core/extensions/builtin/compaction/context-pipeline.js
++++ b/@code-yeongyu/senpi/dist/core/extensions/builtin/compaction/context-pipeline.js
+@@ -1,64 +1,21 @@
+ import { convertToLlm } from "../../../messages.js";
+-import { BUILTIN_CONTEXT_REDUCTION_OPTIONS, reduceContextMessages } from "./context-reduction.js";
+-import { reduceContextWithFrontier } from "./context-reduction-frontier.js";
+ import { createContextReductionState } from "./context-reduction-state.js";
+ import { markOpenAiRemoteReplayBoundary } from "./openai-remote.js";
+-import { isOpenAiRemoteCompactionModel } from "./openai-remote-model.js";
+-import { admitContextToolResults, injectTokenBudgetReminder } from "./orchestration.js";
++import { injectTokenBudgetReminder } from "./orchestration.js";
+ import { estimateTotalTokens } from "./overflow-retry.js";
+ import { repairOrphanedToolResults } from "./repair-tool-pairs.js";
+-import { hardLimitEmergencyPrune } from "./speculative.js";
+ export { createContextReductionState, readContextReductionState } from "./context-reduction-state.js";
+ export function buildCompactionContext(input) {
+     if (input.laneOwnsCompaction) {
+         return repairOrphanedToolResults(convertToLlm(input.event.messages));
+     }
+-    const admittedMessages = admitContextToolResults(input.event.messages, input.contextWindow, input.toolAdmissionEnabled);
+     const state = input.contextReductionState ?? createContextReductionState();
+-    const native = isOpenAiRemoteCompactionModel(input.ctx.model);
+-    const managed = input.appendOnlyTranscript !== true && !native;
+-    const sourceMessages = managed
+-        ? reduceContextWithFrontier(admittedMessages, state, {
+-            unreducedMessages: input.event.messages,
+-            contextWindow: input.contextWindow,
+-            ceilingTokens: input.reductionCeilingTokens ?? input.promptContextWindow,
+-            overheadTokens: input.contextOverheadTokens ?? 0,
+-            blockBudgetRatio: input.contextReductionBlockBudgetRatio,
+-            force: input.breakerFallback,
+-        })
+-        : native && input.breakerFallback && input.appendOnlyTranscript !== true
+-            ? reduceContextMessages(admittedMessages, BUILTIN_CONTEXT_REDUCTION_OPTIONS).messages
+-            : admittedMessages;
+-    const emergency = input.laneOwnsCompaction
+-        ? { messages: sourceMessages, needsAggressiveCompaction: false }
+-        : hardLimitEmergencyPrune(sourceMessages, managed && state.engaged
+-            ? Math.max(0, input.promptContextWindow - (input.contextOverheadTokens ?? 0))
+-            : input.promptContextWindow, input.emergencyPruneLatch);
+-    // This is the ONE site that actually prunes, so the emergency_prune counter must be
+-    // emitted here. Engagement shows up either as a rewritten message array or as
+-    // needsAggressiveCompaction when nothing prunable remained.
+-    if (!input.laneOwnsCompaction && (emergency.needsAggressiveCompaction || emergency.messages !== sourceMessages)) {
+-        input.logEmergencyPrune?.({
+-            route: "context-event",
+-            tokensBefore: estimateTotalTokens(sourceMessages),
+-            tokens: estimateTotalTokens(emergency.messages),
+-        });
+-    }
+-    const marked = markOpenAiRemoteReplayBoundary(emergency.messages, {
+-        model: input.ctx.model,
+-        branchEntries: input.ctx.sessionManager.getBranch(),
++    const marked = markOpenAiRemoteReplayBoundary(input.event.messages, {
++        model: input.ctx.model, branchEntries: input.ctx.sessionManager.getBranch(),
+     });
+-    const reminded = injectTokenBudgetReminder(marked, input.reminder);
+-    const outgoing = repairOrphanedToolResults(convertToLlm(reminded));
+-    const overhead = input.contextOverheadTokens ?? 0;
+-    const beforePrune = estimateTotalTokens(sourceMessages) + overhead;
+-    const afterPrune = estimateTotalTokens(outgoing) + overhead;
+-    if (managed &&
+-        (state.engaged || emergency.messages !== sourceMessages) &&
+-        (emergency.needsAggressiveCompaction ||
+-            afterPrune > input.promptContextWindow ||
+-            (afterPrune < beforePrune && input.emergencyPruneLatch.engaged)))
+-        state.compactionRequired = true;
++    const outgoing = repairOrphanedToolResults(convertToLlm(injectTokenBudgetReminder(marked, input.reminder)));
++    const ceiling = input.reductionCeilingTokens ?? input.promptContextWindow;
++    state.compactionRequired = estimateTotalTokens(outgoing) + (input.contextOverheadTokens ?? 0) > ceiling;
+     return outgoing;
+ }
+-//# sourceMappingURL=context-pipeline.js.map
+
++//# sourceMappingURL=context-pipeline.js.map
+--- a/@code-yeongyu/senpi/dist/core/extensions/builtin/compaction/context-reduction-handoff.js
++++ b/@code-yeongyu/senpi/dist/core/extensions/builtin/compaction/context-reduction-handoff.js
+@@ -17,7 +17,7 @@
+                 customInstructions,
+                 onError: () => {
+                     if (active === request)
+-                        active = undefined;
++                        ctx.abort("system");
+                 },
+                 onComplete: () => {
+                     if (active !== request)
+@@ -37,4 +37,4 @@
+         },
+     };
+ }
+-//# sourceMappingURL=context-reduction-handoff.js.map
+
++//# sourceMappingURL=context-reduction-handoff.js.map
+--- a/@code-yeongyu/senpi/dist/core/extensions/builtin/compaction/context-reduction-lifecycle.js
++++ b/@code-yeongyu/senpi/dist/core/extensions/builtin/compaction/context-reduction-lifecycle.js
+@@ -46,6 +46,7 @@
+     pi.on("session_start", resetForNavigation);
+     pi.on("session_tree", resetForNavigation);
+     pi.on("session_shutdown", resetForNavigation);
++    pi.on("before_agent_start", () => handoff.reset());
+     pi.on("message_end", (event, ctx) => {
+         const request = pending;
+         if (!request || sessionId !== ctx.sessionManager.getSessionId() || event.message.role !== "assistant")
+@@ -108,7 +109,7 @@
+             emergencyPruneLatch: live ? options.emergencyPruneLatch : { ...options.emergencyPruneLatch },
+             logEmergencyPrune: (fields) => options.logEmergencyPrune(ctx, fields),
+         });
+-        const managed = !policy.laneOwnsCompaction && !policy.appendOnlyTranscript && !isOpenAiRemoteCompactionModel(ctx.model);
++        const managed = !policy.laneOwnsCompaction;
+         if (!live)
+             return { messages };
+         if (!managed) {
+@@ -120,7 +121,10 @@
+             persist(before);
+             // Never dispatch a prompt that is legal only because pruning changed
+             // its lineage. Only an accepted, current handoff can resume work.
+-            handoff.request(ctx);
++            if (policy.breakerTripped)
++                ctx.abort("system");
++            else
++                handoff.request(ctx);
+         }
+         else {
+             persist(before);
+@@ -135,4 +139,4 @@
+     }, { mutatesMessages: false });
+     return { reset };
+ }
+-//# sourceMappingURL=context-reduction-lifecycle.js.map
+
++//# sourceMappingURL=context-reduction-lifecycle.js.map
+--- a/@code-yeongyu/senpi/dist/core/extensions/builtin/compaction/deterministic-fallback.js
++++ b/@code-yeongyu/senpi/dist/core/extensions/builtin/compaction/deterministic-fallback.js
+@@ -98,6 +98,8 @@
+     return error instanceof SummaryRequestError && !error.transient && !error.refused && error.failureKind === undefined;
+ }
+ export function classifyRequiredCompactionFallbackFailure(error) {
++    if (error instanceof SummaryRequestError && error.refused)
++        return undefined;
+     if (error instanceof UnsafeRetainedSuffixError)
+         return "unsafe-retained-content";
+     if (error instanceof StreamDurationBudgetError ||
+@@ -448,4 +450,4 @@
+         diagnostics.candidatesChecked = candidateCount;
+     return undefined;
+ }
+-//# sourceMappingURL=deterministic-fallback.js.map
+
++//# sourceMappingURL=deterministic-fallback.js.map
+--- a/@code-yeongyu/senpi/dist/core/extensions/builtin/compaction/emergency-prune.js
++++ b/@code-yeongyu/senpi/dist/core/extensions/builtin/compaction/emergency-prune.js
+@@ -53,13 +53,6 @@
+     if (!engaged) {
+         return { messages, needsAggressiveCompaction: false };
+     }
+-    const noLlmPruned = truncateContextMessages(pruneToolResults(messages, contextWindow, SUMMARIZATION_INPUT_BUDGET_RATIO));
+-    if (estimateTotalTokens(noLlmPruned) <= targetTokens) {
+-        return { messages: noLlmPruned, needsAggressiveCompaction: false };
+-    }
+-    return {
+-        messages: pruneOldMessagesToBudget(noLlmPruned, targetTokens),
+-        needsAggressiveCompaction: true,
+-    };
++    return { messages, needsAggressiveCompaction: true };
+ }
+-//# sourceMappingURL=emergency-prune.js.map
+
++//# sourceMappingURL=emergency-prune.js.map
+--- a/@code-yeongyu/senpi/dist/core/extensions/builtin/compaction/extension-wiring.js
++++ b/@code-yeongyu/senpi/dist/core/extensions/builtin/compaction/extension-wiring.js
+@@ -63,7 +63,8 @@
+         const errorMessage = signal?.aborted || parts.length === 0
+             ? undefined
+             : `Compaction did not apply: ${parts.join("; local fallback ")}`;
+-        ctx.endCompaction?.({ reason: "extension", signal, aborted: signal?.aborted, errorMessage });
++        ctx.endCompaction?.({ reason: "extension", signal, aborted: signal?.aborted, errorMessage,
++            failure: signal?.aborted ? undefined : { kind: result.reason === "stale" ? "stale" : "provider" } });
+     }
+ }
+ /**
+@@ -101,4 +102,4 @@
+         signal,
+     };
+ }
+-//# sourceMappingURL=extension-wiring.js.map
+
++//# sourceMappingURL=extension-wiring.js.map
+--- a/@code-yeongyu/senpi/dist/core/extensions/builtin/compaction/index.js
++++ b/@code-yeongyu/senpi/dist/core/extensions/builtin/compaction/index.js
+@@ -1,12 +1,9 @@
+ import { createWarmAnchorSnapshot, isWarmSummaryAnchorValid } from "../../../compaction/warm-anchor.js";
+-import { AccountUsageLimitError } from "../../../retry-fallback/usage-limit.js";
+ import * as checkpointState from "./checkpoint-state.js";
+ import * as breaker from "./circuit-breaker.js";
+ import { registerContextReductionLifecycle } from "./context-reduction-lifecycle.js";
+ import { createDegradationMonitorState, handleMessageEnd, handleTurnEnd, RECOVERY_INSTRUCTIONS, resetOnSessionCompact, } from "./degradation-monitor.js";
+-import { classifyRequiredCompactionFallbackFailure, createRequiredCompactionFallback, formatRequiredCompactionFallbackNotice, formatRequiredCompactionFallbackRejection, stripTurnRetrySuppressionPrefix, UnsafeRetainedSuffixError, } from "./deterministic-fallback.js";
+ import * as idle from "./idle.js";
+-import * as idleRetry from "./idle-retry.js";
+ import { ANTHROPIC_SUBSCRIPTION_COMPACT_ENTRY_TYPE, collectCompactBoundaryEntries, createCompactionLanePolicy, SDK_NATIVE_LANE_REJECTION_REASON, } from "./lane-policy.js";
+ import { createCompactionLogger } from "./log.js";
+ import { handleCompactionModelSelect } from "./model-selection.js";
+@@ -17,7 +14,7 @@
+ import * as policy from "./policy.js";
+ import { compactionRecoveryStateKey, isAutomaticCompactionBlocked, REJECTED_RECOVERY_ENTRY, wouldCompactionOverflow, } from "./rejected-recovery.js";
+ import * as restoration from "./restoration-tracker.js";
+-import { applyGeneratedCompaction, createEmergencyPruneLatch, createSpeculativeCompactionSnapshot, getPromptVariant, runExtensionCompaction, SummaryGenerationError, } from "./speculative.js";
++import { applyGeneratedCompaction, createEmergencyPruneLatch, createSpeculativeCompactionSnapshot, getPromptVariant, runExtensionCompaction, SummaryGenerationError, compactionFailure, } from "./speculative.js";
+ import { trackSpeculativeJob } from "./speculative-job.js";
+ import { createInitialState, resetTurnCounter } from "./state.js";
+ import { resolveInheritedTaskIntent } from "./task-intent.js";
+@@ -60,7 +57,6 @@
+         }
+     }
+     let idleWarmupTimer;
+-    let idleWarmupAttempt = 0;
+     // True from the `agent_end` idle trigger until the next turn starts (or the
+     // session shuts down). The idle-apply watcher below is fenced on it so a
+     // summary that lands after the user has already prompted is never applied
+@@ -95,68 +91,6 @@
+     // Fenced on the observed job: a prompt, invalidation, a reload, or a newer
+     // warm-up stands this watcher down before it can start a duplicate
+     // summarization.
+-    function armIdleWarmupRetry(ctx) {
+-        const job = speculativeJob;
+-        if (!job)
+-            return;
+-        void job.failure.then((failure) => {
+-            if (failure === undefined) {
+-                idleWarmupAttempt = 0;
+-                return;
+-            }
+-            if (speculativeJob !== job)
+-                return;
+-            // A reload between arming and this continuation retires the context.
+-            if (isContextRetired(ctx)) {
+-                cancelIdleWarmupRetry();
+-                return;
+-            }
+-            const usage = ctx.getContextUsage();
+-            const contextWindow = usage?.contextWindow ?? ctx.model?.contextWindow ?? DEFAULT_CONTEXT_WINDOW;
+-            const settings = ctx.getCompactionSettings();
+-            const breakerTripped = breaker.isTripped(state, Date.now());
+-            const retryDecision = {
+-                attempt: idleWarmupAttempt,
+-                transient: isTransientSummarizationFailure(failure, failure.message),
+-                isIdle: ctx.isIdle(),
+-                breakerTripped,
+-                stillWarmEligible: idle.shouldWarmAtIdle({
+-                    willRetry: false,
+-                    aborted: false,
+-                    settings,
+-                    usage,
+-                    contextWindow,
+-                    breakerTripped,
+-                    lastYield: state.lastYield ?? undefined,
+-                    mode: ctx.mode,
+-                }),
+-            };
+-            if (!idleRetry.shouldRetryIdleWarmup(retryDecision))
+-                return;
+-            cancelIdleWarmupRetry();
+-            idleWarmupTimer = setTimeout(() => {
+-                idleWarmupTimer = undefined;
+-                if (speculativeJob !== job)
+-                    return;
+-                // The reload may land after the timer was armed; a throw here would
+-                // escape into the timer queue as an uncaughtException.
+-                if (isContextRetired(ctx))
+-                    return;
+-                if (!ctx.isIdle())
+-                    return;
+-                idleWarmupAttempt += 1;
+-                getLogger(ctx).debug("idle_trigger", {
+-                    contextWindow,
+-                    tokens: usage?.tokens ?? 0,
+-                    count: idleWarmupAttempt,
+-                });
+-                invalidateSpeculativeCompaction(ctx);
+-                startSpeculativeCompaction(ctx, idle.IDLE_COMPACTION_INSTRUCTIONS);
+-                armIdleWarmupRetry(ctx);
+-                armIdleApply(ctx);
+-            }, idleRetry.IDLE_WARMUP_RETRY_DELAY_MS);
+-        });
+-    }
+     /**
+      * Apply the idle warm summary as soon as it finishes generating, while the
+      * session is still idle. Holding it warm until the next `before_agent_start`
+@@ -201,7 +135,7 @@
+                 !policy.shouldTriggerCompaction(usage, contextWindow, ctx.getCompactionSettings(), state.lastYield ?? undefined)) {
+                 return;
+             }
+-            const result = await applyGeneratedCompaction(ctx, job.snapshot, () => speculativeGeneration, compaction);
++            const result = await applyGeneratedCompaction(ctx, job.snapshot, () => speculativeGeneration, compaction, undefined, false);
+             if (!result.applied)
+                 return;
+             // The job is consumed: clearing it here is also what stands the idle
+@@ -300,388 +234,122 @@
+         todoBridge.persistTodoSnapshot(pi, metadata.todoSnapshot);
+     }
+     async function generateCompaction(ctx, snapshot, signal, onProgress) {
+-        const compaction = await runExtensionCompaction(ctx, snapshot, signal, onProgress);
+-        if (!compaction || signal?.aborted)
+-            return compaction;
+-        if (!wouldCompactionOverflow(snapshot.branchEntries ?? [], compaction, true, snapshot.model, snapshot.preparation.settings))
+-            return compaction;
+-        if (!wouldCompactionOverflow(snapshot.branchEntries ?? [], { ...compaction, summary: "" }, true, snapshot.model, snapshot.preparation.settings))
+-            return compaction;
+-        // #3061: only a SUCCESSFUL summary can establish a terminal context fault.
+-        // A failed summary plus a rejected emergency checkpoint says nothing about
+-        // whether a recovered provider could produce a smaller, usable summary.
+-        // Probe with zero summary text so marker/previous-summary overhead alone
+-        // cannot turn a provider failure or an oversized summary into a durable latch.
+-        const diagnostics = {};
+-        const viable = createRequiredCompactionFallback(snapshot.preparation, snapshot.contextWindow, "unsafe-retained-content", { summary: "" }, snapshot.branchEntries, diagnostics);
+-        if (!viable &&
+-            (diagnostics.rejectionReason === "unsafe-retained-content" ||
+-                diagnostics.rejectionReason === "atomic-tool-chain-cut" ||
+-                diagnostics.rejectionReason === "retained-token-budget-exceeded")) {
+-            throw new UnsafeRetainedSuffixError(diagnostics);
+-        }
+-        return compaction;
++        return await runExtensionCompaction(ctx, snapshot, signal, onProgress);
+     }
+-    function recoverRequiredCompaction(ctx, snapshot, failureKind, cause) {
+-        const terminal = cause instanceof UnsafeRetainedSuffixError;
+-        const diagnostics = terminal ? cause.diagnostics : {};
+-        const compaction = terminal
+-            ? undefined
+-            : createRequiredCompactionFallback(snapshot.preparation, snapshot.contextWindow, failureKind, { taskIntent: resolveInheritedTaskIntent(snapshot.branchEntries ?? []) }, snapshot.branchEntries, diagnostics);
+-        if (!compaction) {
+-            const branch = snapshot.branchEntries ?? [];
+-            // Provider/timeout/abort/empty-summary failures never create or replace
+-            // this record, even when their opportunistic deterministic fallback fails.
+-            if (terminal && !isAutomaticCompactionBlocked(branch, snapshot.model, ctx.getCompactionSettings())) {
+-                pi.appendEntry(REJECTED_RECOVERY_ENTRY, {
+-                    failureKind: "unsafe-retained-content",
+-                    stateKey: compactionRecoveryStateKey(branch, snapshot.model, ctx.getCompactionSettings()),
+-                    reason: diagnostics.rejectionReason,
+-                    entryId: diagnostics.candidateRejections?.at(-1)?.unsafeEntryId ??
+-                        diagnostics.candidateRejections?.at(-1)?.firstKeptEntryId,
+-                });
+-            }
+-            return { rejectionReason: formatRequiredCompactionFallbackRejection(diagnostics, terminal) };
+-        }
+-        // The compaction itself succeeds, so nothing else tells the user their
+-        // transcript was reduced without a provider summary. Say it plainly here,
+-        // and never with the internal retry-suppression marker (#1741).
+-        ctx.ui.notify(formatRequiredCompactionFallbackNotice(failureKind, cause), "warning");
+-        return { compaction };
+-    }
+     async function applyBlockingCompaction(ctx, customInstructions) {
+-        if (isAutomaticCompactionBlocked(ctx.sessionManager.getBranch(), ctx.model, ctx.getCompactionSettings())) {
+-            return { applied: false, reason: "rejected" };
+-        }
+-        const provider = ctx.model?.provider;
+-        if ((provider === "cursor" || provider === "cursor-cli-oauth") && !ctx.isIdle()) {
+-            getLogger(ctx).debug("skip_cursor_mid_turn", { route: "blocking" });
+-            return { applied: false, reason: "rejected" };
+-        }
+-        if (breaker.isTripped(state, Date.now())) {
+-            getLogger(ctx).debug("skip_breaker", { route: "blocking" });
+-            return { applied: false, reason: "rejected" };
+-        }
+-        if (cap.shouldRejectByCap(state).cancel) {
+-            getLogger(ctx).debug("skip_cap", { route: "blocking" });
+-            return { applied: false, reason: "rejected" };
+-        }
+-        let feedbackSignal = ctx.beginCompaction?.({ reason: "extension" });
++        const feedbackSignal = ctx.beginCompaction?.({ reason: "extension" });
+         try {
+-            let remoteFallbackReason;
+-            if (isOpenAiRemoteCompactionModel(ctx.model) && (ctx.getCompactionModel?.() ?? ctx.model) === ctx.model) {
+-                const remoteGeneration = speculativeGeneration + 1;
+-                const remoteSnapshot = createSpeculativeCompactionSnapshot(ctx, {
+-                    generation: remoteGeneration,
+-                    customInstructions,
+-                    origin: "blocking",
+-                });
+-                getLogger(ctx).debug("blocking_started", { generation: remoteGeneration, origin: "blocking" });
+-                if (remoteSnapshot) {
+-                    const remoteSignal = feedbackSignal ?? new AbortController().signal;
+-                    const remoteCompaction = await runOpenAiRemoteCompaction(ctx, createBlockingRemoteCompactionEvent(ctx, remoteSnapshot, customInstructions, remoteSignal), (data) => {
+-                        if (data?.action === "remote_fallback" && typeof data.reason === "string") {
+-                            remoteFallbackReason = data.reason;
+-                        }
+-                        reportRemoteCompactionTimeout(ctx, "extension", feedbackSignal, data);
+-                        pi.events.emit(SENPI_COMPACTION_EVENT, data);
+-                    }, remoteCompactionDependencies);
+-                    if (remoteCompaction) {
+-                        if (speculativeGeneration !== remoteGeneration - 1) {
+-                            const result = { applied: false, reason: "stale" };
+-                            getLogger(ctx).debug("speculative_stale", { generation: remoteGeneration });
+-                            endCompactionFeedback(ctx, feedbackSignal, result);
+-                            return result;
+-                        }
+-                        speculativeGeneration = remoteGeneration;
+-                        speculativeJob?.controller.abort();
+-                        speculativeJob = undefined;
+-                        const result = await applyGeneratedCompaction(ctx, remoteSnapshot, () => speculativeGeneration, remoteCompaction, feedbackSignal);
+-                        getLogger(ctx).debug("speculative_applied", { generation: remoteGeneration, origin: "blocking" });
+-                        endCompactionFeedback(ctx, feedbackSignal, result);
+-                        return result;
+-                    }
+-                }
+-            }
++            const provider = ctx.model?.provider;
++            if ((provider === "cursor" || provider === "cursor-cli-oauth") && !ctx.isIdle())
++                throw new SummaryGenerationError("provider", "Compaction unavailable while provider is busy");
++            if (isAutomaticCompactionBlocked(ctx.sessionManager.getBranch(), ctx.model, ctx.getCompactionSettings()) ||
++                breaker.isTripped(state, Date.now()) || cap.shouldRejectByCap(state).cancel)
++                throw new SummaryGenerationError("provider", "Compaction is blocked after an earlier failure");
+             const pendingJob = speculativeJob;
++            speculativeJob = undefined;
++            let snapshot;
++            let compaction;
+             if (pendingJob) {
+-                const unlinkAbort = linkAbortSignal(feedbackSignal, pendingJob.controller);
+-                let compaction;
+-                let inheritedFailure;
++                snapshot = pendingJob.snapshot;
++                const unlink = linkAbortSignal(feedbackSignal, pendingJob.controller);
+                 try {
+                     compaction = await pendingJob.promise;
+-                    inheritedFailure = await pendingJob.failure;
+-                    if (compaction)
+-                        getLogger(ctx).debug("warm_consumed", { generation: pendingJob.generation, route: "speculative" });
++                    const failure = await pendingJob.failure;
++                    if (failure !== undefined)
++                        throw failure;
+                 }
+-                finally {
+-                    unlinkAbort();
+-                }
+-                if (inheritedFailure !== undefined) {
+-                    speculativeJob = undefined;
+-                    const failureKind = classifyRequiredCompactionFallbackFailure(inheritedFailure);
+-                    if (failureKind !== undefined &&
+-                        !feedbackSignal?.aborted &&
+-                        pendingJob.snapshot.generation === speculativeGeneration &&
+-                        pendingJob.snapshot.expectedRevision === ctx.getMessageRevision()) {
+-                        const recovery = recoverRequiredCompaction(ctx, pendingJob.snapshot, failureKind, inheritedFailure);
+-                        compaction = recovery.compaction;
+-                        if (!compaction) {
+-                            const result = { applied: false, reason: "failed" };
+-                            endCompactionFeedback(ctx, feedbackSignal, result, recovery.rejectionReason);
+-                            return result;
+-                        }
+-                    }
+-                    else if (failureKind === undefined &&
+-                        isTransientSummarizationFailure(inheritedFailure, inheritedFailure.message)) {
+-                        ctx.endCompaction?.({
+-                            reason: "extension",
+-                            signal: feedbackSignal,
+-                            aborted: feedbackSignal?.aborted,
+-                            errorMessage: `Compaction failed: ${stripTurnRetrySuppressionPrefix(inheritedFailure.message)}`,
+-                        });
+-                        state = breaker.recordFailure(state, Date.now(), { route: "extension" });
+-                        return { applied: false, reason: "failed" };
+-                    }
+-                }
+-                const result = await applyGeneratedCompaction(ctx, pendingJob.snapshot, () => speculativeGeneration, compaction, feedbackSignal);
+-                if (result.applied) {
+-                    speculativeJob = undefined;
+-                    getLogger(ctx).debug("speculative_applied", {
+-                        generation: pendingJob.generation,
+-                        origin: "speculative",
+-                    });
+-                    endCompactionFeedback(ctx, feedbackSignal, result);
+-                    return result;
+-                }
+-                if (result.reason === "stale") {
+-                    getLogger(ctx).debug("speculative_stale", { generation: pendingJob.generation });
+-                }
+-                else if (result.reason === "rejected") {
+-                    feedbackSignal = ctx.beginCompaction?.({ reason: "extension" });
+-                }
+-                speculativeJob = undefined;
+-            }
+-            const generation = ++speculativeGeneration;
+-            const snapshot = createSpeculativeCompactionSnapshot(ctx, {
+-                generation,
+-                customInstructions,
+-                origin: "core-route",
+-                tools: getSummarizationTools(),
+-            });
+-            if (!snapshot) {
+-                const result = { applied: false, reason: "unavailable" };
+-                getLogger(ctx).debug("summary_failed", { reason: "unavailable" });
+-                endCompactionFeedback(ctx, feedbackSignal, result, remoteFallbackReason);
+-                return result;
+-            }
+-            let compaction;
+-            try {
+-                compaction = await generateCompaction(ctx, snapshot, feedbackSignal, (delta) => ctx.updateCompaction?.({
+-                    reason: "extension",
+-                    signal: feedbackSignal,
+-                    delta,
+-                }));
+-            }
+-            catch (error) {
+-                const failureKind = classifyRequiredCompactionFallbackFailure(error);
+-                if (failureKind !== undefined && !feedbackSignal?.aborted) {
+-                    const recovery = recoverRequiredCompaction(ctx, snapshot, failureKind, error);
+-                    compaction = recovery.compaction;
+-                    if (!compaction) {
+-                        const result = { applied: false, reason: "failed" };
+-                        endCompactionFeedback(ctx, feedbackSignal, result, recovery.rejectionReason);
+-                        return result;
+-                    }
++                finally { unlink(); }
++            }
++            else {
++                snapshot = createSpeculativeCompactionSnapshot(ctx, {
++                    generation: ++speculativeGeneration, customInstructions, origin: "blocking", tools: getSummarizationTools(),
++                });
++                if (!snapshot)
++                    throw new SummaryGenerationError("empty", "No compaction source available");
++                if (isOpenAiRemoteCompactionModel(ctx.model) && (ctx.getCompactionModel?.() ?? ctx.model) === ctx.model) {
++                    const remote = await runOpenAiRemoteCompaction(ctx,
++                        createBlockingRemoteCompactionEvent(ctx, snapshot, customInstructions, feedbackSignal ?? new AbortController().signal),
++                        (data) => pi.events.emit(SENPI_COMPACTION_EVENT, data), remoteCompactionDependencies);
++                    if (remote.status === "failed")
++                        throw Object.assign(new Error("Remote compaction failed"), { failure: remote.failure });
++                    if (remote.status === "accepted")
++                        compaction = remote.compaction;
+                 }
+-                else {
+-                    if (!(error instanceof SummaryGenerationError))
+-                        throw error;
+-                    getLogger(ctx).debug("summary_failed", { reason: error.kind });
+-                }
++                if (!compaction)
++                    compaction = await generateCompaction(ctx, snapshot, feedbackSignal,
++                        (delta) => ctx.updateCompaction?.({ reason: "extension", signal: feedbackSignal, delta }));
+             }
+             const result = await applyGeneratedCompaction(ctx, snapshot, () => speculativeGeneration, compaction, feedbackSignal);
+-            endCompactionFeedback(ctx, feedbackSignal, result, remoteFallbackReason);
++            endCompactionFeedback(ctx, feedbackSignal, result);
+             return result;
+         }
+         catch (error) {
+-            if (feedbackSignal?.aborted) {
+-                // An aborted blocking compaction is a cancellation, not a failure: no
+-                // red "Compaction failed" line, no breaker debit, no rethrow through
+-                // the before_agent_start handler (issue #886). The faux-route flavor
+-                // of this contract is pinned by blocking-compaction-review-hardening.
+-                getLogger(ctx).debug("blocking_aborted", { route: "blocking" });
+-                ctx.endCompaction?.({ reason: "extension", signal: feedbackSignal, aborted: true });
+-                return { applied: false, reason: "rejected" };
+-            }
+-            const message = error instanceof Error ? error.message : String(error);
+-            ctx.endCompaction?.({
+-                reason: "extension",
+-                signal: feedbackSignal,
+-                aborted: feedbackSignal?.aborted,
+-                errorMessage: `Compaction failed: ${stripTurnRetrySuppressionPrefix(message)}`,
+-            });
+-            const transient = isTransientSummarizationFailure(error, message);
+-            if (transient) {
++            const aborted = feedbackSignal?.aborted === true;
++            const failure = aborted ? undefined : compactionFailure(error, ctx.model);
++            ctx.endCompaction?.({ reason: "extension", signal: feedbackSignal, aborted,
++                errorMessage: aborted ? undefined : "Compaction failed; previous context retained", failure });
++            if (!aborted)
+                 state = breaker.recordFailure(state, Date.now(), { route: "extension" });
+-                return { applied: false, reason: "failed" };
+-            }
+-            throw error;
++            return { applied: false, reason: "failed", failure };
+         }
+     }
+     pi.on("session_before_compact", async (event, ctx) => {
+-        // A pre-aborted request (superseded admission or user cancel) must stand
+-        // down before touching warm-job ownership: core's own post-emit abort
+-        // checks turn it into a clean cancellation (issue #886).
+         if (event.signal.aborted)
+-            return undefined;
++            return { cancel: true };
+         const claimedWarmJob = claimWarmSummaryForCoreRoute(event, ctx);
+-        // The claim detaches the job without aborting it, so ownership must survive every
+-        // exit from this handler - including a throw - or the request it already paid for
+-        // keeps streaming for a result nobody will read.
+-        let warmJobConsumed = false;
+         invalidateSpeculativeCompaction(ctx);
+-        const claimedGeneration = speculativeGeneration;
+         try {
+-            if (!lanePolicy.ownsCompaction(ctx, event.reason)) {
+-                return {
+-                    cancel: true,
+-                    rejectionCause: "external-owner",
+-                    reason: SDK_NATIVE_LANE_REJECTION_REASON,
+-                };
+-            }
+-            if (cap.shouldRejectByCap(state).cancel) {
+-                getLogger(ctx).debug("skip_cap", { reason: event.reason, count: state.acceptedAbsolute });
+-                return {
+-                    cancel: true,
+-                    rejectionCause: "per-turn-cap",
+-                    reason: "absolute compaction cap reached for this session",
+-                };
+-            }
+-            const now = Date.now();
+-            if (breaker.isTripped(state, now) && !breaker.shouldBypass(state, { reason: event.reason })) {
+-                const remainingMs = state.trippedAt !== null ? Math.max(0, state.trippedAt + breaker.COOLDOWN_MS - now) : 0;
+-                getLogger(ctx).debug("skip_breaker", { reason: event.reason, remainingSec: Math.ceil(remainingMs / 1000) });
+-                return {
+-                    cancel: true,
+-                    rejectionCause: "circuit-breaker",
+-                    reason: `compaction circuit breaker cooling down (${Math.ceil(remainingMs / 1000)}s left)`,
+-                };
+-            }
++            if (!lanePolicy.ownsCompaction(ctx, event.reason))
++                return { cancel: true, rejectionCause: "external-owner", reason: SDK_NATIVE_LANE_REJECTION_REASON };
++            if (cap.shouldRejectByCap(state).cancel)
++                return { cancel: true, rejectionCause: "per-turn-cap", failure: { kind: "provider" } };
++            if (breaker.isTripped(state, Date.now()) && !breaker.shouldBypass(state, { reason: event.reason }))
++                return { cancel: true, rejectionCause: "circuit-breaker", failure: { kind: "provider" } };
+             capturePendingMetadata(event.requestId, ctx);
+             const model = ctx.model;
+-            if (!model) {
+-                return undefined;
+-            }
+-            let remoteCompaction;
+-            try {
+-                // Native remote compaction is tied to the active provider's replay origin.
+-                // A different summary model must use the bounded local summary route.
+-                remoteCompaction =
+-                    (ctx.getCompactionModel?.() ?? model) !== model
+-                        ? undefined
+-                        : await runOpenAiRemoteCompaction(ctx, event, (data) => {
+-                            reportRemoteCompactionTimeout(ctx, event.reason, event.signal, data);
+-                            pi.events.emit(SENPI_COMPACTION_EVENT, data);
+-                        }, remoteCompactionDependencies);
+-            }
+-            catch (error) {
+-                if (error instanceof AccountUsageLimitError)
+-                    return { cancel: true, reason: error.message };
+-                // The remote route deliberately rethrows once its signal aborts; the
+-                // handler converts that into a silent stand-down so the abort is not
+-                // reported as an extension error with a stack (issue #886).
+-                if (!event.signal.aborted)
+-                    throw error;
+-                getLogger(ctx).debug("remote_aborted", { route: "core-route", requestId: event.requestId });
+-                return undefined;
+-            }
+-            if (remoteCompaction) {
+-                getLogger(ctx).debug("core_route_generated", { route: "core-route", requestId: event.requestId });
+-                return { compaction: remoteCompaction };
+-            }
+-            let inheritedWarmFailure;
++            if (!model)
++                throw new SummaryGenerationError("model_unavailable", "Compaction model unavailable");
+             if (claimedWarmJob) {
+-                const unlinkAbort = linkAbortSignal(event.signal, claimedWarmJob.controller);
+-                let warmCompaction;
+-                let warmFailure;
++                const unlink = linkAbortSignal(event.signal, claimedWarmJob.controller);
+                 try {
+-                    warmCompaction = await claimedWarmJob.promise;
+-                    warmFailure = await claimedWarmJob.failure;
++                    const compaction = await claimedWarmJob.promise;
++                    const failure = await claimedWarmJob.failure;
++                    if (failure !== undefined)
++                        throw failure;
++                    if (!compaction)
++                        throw new SummaryGenerationError("incomplete", "Warm compaction returned no result");
++                    return { compaction };
+                 }
+-                finally {
+-                    unlinkAbort();
+-                }
+-                if (warmFailure === undefined && warmCompaction && !event.signal.aborted) {
+-                    getLogger(ctx).debug("warm_consumed", { generation: claimedWarmJob.generation, route: "core-route" });
+-                    warmJobConsumed = true;
+-                    return { compaction: warmCompaction };
+-                }
+-                if (warmFailure !== undefined &&
+-                    requiresDeterministicCompactionFallback(event, ctx.getContextUsage()) &&
+-                    classifyRequiredCompactionFallbackFailure(warmFailure) !== undefined &&
+-                    !event.signal.aborted &&
+-                    speculativeGeneration === claimedGeneration &&
+-                    claimedWarmJob.snapshot.expectedRevision === ctx.getMessageRevision()) {
+-                    inheritedWarmFailure = warmFailure;
+-                }
++                finally { unlink(); }
+             }
++            if ((ctx.getCompactionModel?.() ?? model) === model) {
++                const remote = await runOpenAiRemoteCompaction(ctx, event,
++                    (data) => pi.events.emit(SENPI_COMPACTION_EVENT, data), remoteCompactionDependencies);
++                if (remote.status === "failed")
++                    throw Object.assign(new Error("Remote compaction failed"), { failure: remote.failure });
++                if (remote.status === "accepted")
++                    return { compaction: remote.compaction };
++            }
+             const snapshot = {
+-                generation: ++speculativeGeneration,
+-                expectedRevision: ctx.getMessageRevision(),
+-                model,
++                generation: ++speculativeGeneration, expectedRevision: ctx.getMessageRevision(), model,
+                 contextWindow: ctx.getContextUsage()?.contextWindow ?? model.contextWindow ?? DEFAULT_CONTEXT_WINDOW,
+-                preparation: event.preparation,
+-                branchEntries: event.branchEntries,
+-                promptVariant: getPromptVariant(event),
+-                origin: "core-route",
+-                customInstructions: event.customInstructions,
+-                systemPrompt: ctx.getSystemPrompt(),
+-                tools: getSummarizationTools(),
+-            };
+-            let compaction;
+-            try {
+-                if (inheritedWarmFailure)
+-                    throw inheritedWarmFailure;
+-                compaction = await generateCompaction(ctx, snapshot, event.signal, (delta) => ctx.updateCompaction?.({ reason: event.reason, signal: event.signal, delta }));
+-            }
+-            catch (error) {
+-                const message = error instanceof Error ? error.message : String(error);
+-                const failureKind = classifyRequiredCompactionFallbackFailure(error);
+-                if ((requiresDeterministicCompactionFallback(event, ctx.getContextUsage()) ||
+-                    failureKind === "unsafe-retained-content") &&
+-                    failureKind !== undefined &&
+-                    !event.signal.aborted) {
+-                    const recovery = recoverRequiredCompaction(ctx, snapshot, failureKind, error);
+-                    if (recovery.compaction)
+-                        return { compaction: recovery.compaction };
+-                    pendingMetadata.delete(event.requestId);
+-                    return {
+-                        cancel: true,
+-                        reason: recovery.rejectionReason,
+-                    };
+-                }
+-                pendingMetadata.delete(event.requestId);
+-                if (error instanceof SummaryGenerationError) {
+-                    return { cancel: true, reason: stripTurnRetrySuppressionPrefix(error.message) };
+-                }
+-                return { cancel: true, reason: `compaction generator failed: ${stripTurnRetrySuppressionPrefix(message)}` };
+-            }
+-            if (!compaction) {
+-                pendingMetadata.delete(event.requestId);
+-                if (event.signal.aborted) {
+-                    return { cancel: true };
+-                }
+-                return { cancel: true, reason: "compaction generator returned no summary" };
+-            }
+-            return {
+-                compaction,
++                preparation: event.preparation, branchEntries: event.branchEntries, promptVariant: getPromptVariant(event),
++                origin: "core-route", customInstructions: event.customInstructions,
++                systemPrompt: ctx.getSystemPrompt(), tools: getSummarizationTools(),
+             };
++            const compaction = await generateCompaction(ctx, snapshot, event.signal,
++                (delta) => ctx.updateCompaction?.({ reason: event.reason, signal: event.signal, delta }));
++            if (!compaction)
++                throw new SummaryGenerationError("incomplete", "Compaction returned no summary");
++            return { compaction };
+         }
+-        finally {
+-            if (!warmJobConsumed)
+-                claimedWarmJob?.controller.abort();
++        catch (error) {
++            pendingMetadata.delete(event.requestId);
++            return { cancel: true, ...(event.signal.aborted ? {} : {
++                reason: "Compaction failed; previous context retained", failure: compactionFailure(error, ctx.model),
++            }) };
+         }
++        finally { claimedWarmJob?.controller.abort(); }
+     });
+     pi.on("model_select", (event, ctx) => handleCompactionModelSelect({
+         event,
+@@ -782,7 +450,8 @@
+                 tokens: usage.tokens ?? 0,
+                 threshold: settings.reserveTokens,
+             });
+-            await applyBlockingCompaction(ctx, EMERGENCY_COMPACTION_INSTRUCTIONS);
++            const result = await applyBlockingCompaction(ctx, EMERGENCY_COMPACTION_INSTRUCTIONS);
++            if (!result.applied) { ctx.abort("system"); return; }
+         }
+         else if (!breakerCoolingDown &&
+             usageWithPendingPrompt &&
+@@ -801,7 +470,8 @@
+                 compactionInFlight: speculativeJob !== undefined && !speculativeJob.completed,
+                 graceBandEnabled: settings.graceBandEnabled,
+             })) {
+-                await applyBlockingCompaction(ctx, PROACTIVE_COMPACTION_INSTRUCTIONS);
++                const result = await applyBlockingCompaction(ctx, PROACTIVE_COMPACTION_INSTRUCTIONS);
++                if (!result.applied) { ctx.abort("system"); return; }
+             }
+             else {
+                 getLogger(ctx).debug("grace_deferred", {
+@@ -912,10 +582,8 @@
+             mode: ctx.mode,
+         })) {
+             getLogger(ctx).debug("idle_trigger", { contextWindow, tokens: usage?.tokens ?? 0 });
+-            idleWarmupAttempt = 0;
+             sessionIdleSinceAgentEnd = true;
+             startSpeculativeCompaction(ctx, idle.IDLE_COMPACTION_INSTRUCTIONS);
+-            armIdleWarmupRetry(ctx);
+             armIdleApply(ctx);
+         }
+         else {
+@@ -940,11 +608,9 @@
+             if (warmAction === "replace")
+                 invalidateSpeculativeCompaction(ctx);
+             if (warmAction !== "none") {
+-                idleWarmupAttempt = 0;
+                 sessionIdleSinceAgentEnd = true;
+                 startSpeculativeCompaction(ctx, idle.IDLE_COMPACTION_INSTRUCTIONS);
+-                armIdleWarmupRetry(ctx);
+-                armIdleApply(ctx);
++                    armIdleApply(ctx);
+             }
+         }
+     });
+@@ -974,9 +640,8 @@
+     pi.on("session_shutdown", () => {
+         sessionIdleSinceAgentEnd = false;
+         cancelIdleWarmupRetry();
+-        idleWarmupAttempt = 0;
+         speculativeJob?.controller.abort();
+         speculativeJob = undefined;
+     });
+ }
+-//# sourceMappingURL=index.js.map
+
++//# sourceMappingURL=index.js.map
+--- a/@code-yeongyu/senpi/dist/core/extensions/builtin/compaction/lane-policy.js
++++ b/@code-yeongyu/senpi/dist/core/extensions/builtin/compaction/lane-policy.js
+@@ -91,7 +91,8 @@
+         // A configured compaction model override makes senpi own summarization
+         // for the lane, so the SDK-native stand-down no longer applies. This is
+         // the escape hatch for lanes whose SDK never fires native compaction.
+-        if (context.getCompactionSettings?.().model)
++        const override = context.getCompactionSettings?.().model;
++        if (typeof override === "string" && /^[^/\s]+\/\S+$/.test(override))
+             return false;
+         // A settings read failure must never silently disable senpi compaction.
+         const providerSettings = readProviderSettings(context.cwd);
+@@ -157,4 +158,4 @@
+     }
+     return entries;
+ }
+-//# sourceMappingURL=lane-policy.js.map
+
++//# sourceMappingURL=lane-policy.js.map
+--- a/@code-yeongyu/senpi/dist/core/extensions/builtin/compaction/openai-remote-convert.js
++++ b/@code-yeongyu/senpi/dist/core/extensions/builtin/compaction/openai-remote-convert.js
+@@ -1,5 +1,6 @@
++import { protectedRemoteInput } from "./task-intent.js";
+ import { convertToLlm } from "../../../messages.js";
+-import { sessionEntryToContextMessages } from "../../../session-manager.js";
++import { sessionEntryToContextMessages, getSessionContextEntryId, SESSION_CONTEXT_ENTRY_ID } from "../../../session-manager.js";
+ import { getOpenAiRemoteCompactionDetails, isRecord, } from "./openai-remote-schema.js";
+ export { getOpenAiRemoteCompactionDetails, isOpenAiContextCompactionItem, isOpenAiRemoteCompactionOutputItem, isRecord, isRetainedRemoteOutputItem, isRetainedResponsesStreamInputItem, OPENAI_REMOTE_COMPACTION_SCHEMA, } from "./openai-remote-schema.js";
+ function parseJsonRecord(value) {
+@@ -139,8 +140,12 @@
+ }
+ function convertLlmMessage(message, messageIndex, model) {
+     switch (message.role) {
+-        case "user":
+-            return [{ role: "user", content: convertUserContent(message.content) }];
++        case "user": {
++            const item = { role: "user", content: convertUserContent(message.content) };
++            const sourceId = getSessionContextEntryId(message) ?? message[SESSION_CONTEXT_ENTRY_ID];
++            if (sourceId) Object.defineProperty(item, "__senpiCompactionSourceId", { value: sourceId });
++            return [item];
++        }
+         case "assistant":
+             return convertAssistantMessage(message, messageIndex);
+         case "toolResult":
+@@ -185,7 +190,7 @@
+             const details = getOpenAiRemoteCompactionDetails(entry.details);
+             if (details) {
+                 flush();
+-                items.push(...details.replacementInput);
++                items.push(...protectedRemoteInput(details.replacementInput, details.intentProtection));
+                 continue;
+             }
+         }
+@@ -194,4 +199,4 @@
+     flush();
+     return items;
+ }
+-//# sourceMappingURL=openai-remote-convert.js.map
+
++//# sourceMappingURL=openai-remote-convert.js.map
+--- a/@code-yeongyu/senpi/dist/core/extensions/builtin/compaction/openai-remote-responses-v2.js
++++ b/@code-yeongyu/senpi/dist/core/extensions/builtin/compaction/openai-remote-responses-v2.js
+@@ -1,3 +1,4 @@
++import { compactionFailure } from "./speculative.js";
+ import { isOpenAiRemoteCompactionOutputItem, isRecord, OPENAI_REMOTE_COMPACTION_SCHEMA, providerNativeItem, } from "./openai-remote-convert.js";
+ import { openAiRemoteCompactionIdentity, } from "./openai-remote-model.js";
+ import { runWithRemoteTimeout } from "./openai-remote-timeout.js";
+@@ -60,7 +61,8 @@
+         extraBody: args.auth.extraBody,
+         headers: withRemoteCompactionV2Header(args.headers),
+         // One remote request per compaction on the subscription lane: a failure falls back to the local summary.
+-        ...(args.model.api === "openai-codex-responses" ? { maxRetries: 0 } : {}),
++        maxRetries: 0,
++        streamKind: "auxiliary",
+         sessionId: args.sessionId,
+         signal: args.event.signal,
+         transport: "sse",
+@@ -84,8 +86,10 @@
+         },
+     });
+     const assistant = await stream.result();
+-    if (assistant.stopReason === "error" || assistant.stopReason === "aborted")
+-        return undefined;
++    if (assistant.stopReason !== "stop" || assistant.stopDetails?.type === "refusal")
++        throw Object.assign(new Error("Remote compaction did not finish normally"), {
++            failure: assistant.stopDetails?.type === "refusal" ? { kind: "refused" } : assistant.failure ?? { kind: "incomplete" },
++        });
+     const compaction = findCompactionOutput(assistant);
+     if (compaction === undefined)
+         return undefined;
+@@ -102,6 +106,7 @@
+             transport: "responses-v2",
+             modelId: args.model.id,
+             responseId,
++            ...(assistant.responseModel ? { observedProvider: assistant.provider, observedModel: assistant.responseModel } : {}),
+             createdAt,
+             requestInputItemCount: args.request.inputItemCount,
+             retainedInputItemCount: 1,
+@@ -170,9 +175,10 @@
+             requestId: args.requestId,
+             modelId: args.model.id,
+             reason: "responses-v2-error",
++            failure: compactionFailure(error, args.model),
+             transport: "responses-v2",
+         });
+         return undefined;
+     }
+ }
+-//# sourceMappingURL=openai-remote-responses-v2.js.map
+
++//# sourceMappingURL=openai-remote-responses-v2.js.map
+--- a/@code-yeongyu/senpi/dist/core/extensions/builtin/compaction/openai-remote-schema.js
++++ b/@code-yeongyu/senpi/dist/core/extensions/builtin/compaction/openai-remote-schema.js
+@@ -49,6 +49,7 @@
+         ...(parseOpenAiRemoteCompactionOrigin(value.origin)
+             ? { origin: parseOpenAiRemoteCompactionOrigin(value.origin) }
+             : {}),
++        ...(isRecord(value.intentProtection) ? { intentProtection: value.intentProtection } : {}),
+         ...(isRecord(value.usage) ? { usage: value.usage } : {}),
+     };
+ }
+@@ -71,4 +72,4 @@
+         return item.role === "user";
+     return "role" in item && item.role === "user";
+ }
+-//# sourceMappingURL=openai-remote-schema.js.map
+
++//# sourceMappingURL=openai-remote-schema.js.map
+--- a/@code-yeongyu/senpi/dist/core/extensions/builtin/compaction/openai-remote-timeout.d.ts
++++ b/@code-yeongyu/senpi/dist/core/extensions/builtin/compaction/openai-remote-timeout.d.ts
+@@ -11,7 +11,7 @@
+  */
+ export declare function openAiRemoteCompactionTimeoutMs(model: OpenAiRemoteCompactionModel, compactionTokens: number): number;
+ /** What the compaction does after a remote attempt runs out of its budget. */
+-export type RemoteCompactionTimeoutNextStep = "websocket" | "compact-endpoint" | "local-summary";
++export type RemoteCompactionTimeoutNextStep = "websocket" | "compact-endpoint" | "local-summary" | "stop";
+ /**
+  * One deadline for every remote attempt of a compaction: a lane that falls through v2, WebSocket
+  * and the compact endpoint never holds the session longer than {@link SUMMARIZATION_TOTAL_BUDGET_MS}
+@@ -35,4 +35,4 @@
+     run: (signal: AbortSignal) => Promise<T>;
+     onTimeout: (waitedMs: number) => void;
+ }): Promise<T | undefined>;
+-//# sourceMappingURL=openai-remote-timeout.d.ts.map
+
++//# sourceMappingURL=openai-remote-timeout.d.ts.map
+--- a/@code-yeongyu/senpi/dist/core/extensions/builtin/compaction/openai-remote-timeout.js
++++ b/@code-yeongyu/senpi/dist/core/extensions/builtin/compaction/openai-remote-timeout.js
+@@ -39,6 +39,7 @@
+     };
+ }
+ const NEXT_STEP_TEXT = {
++    stop: "stopping with previous context retained",
+     websocket: "retrying over the WebSocket route",
+     "compact-endpoint": "retrying through the compact endpoint",
+     "local-summary": "falling back to a local summary",
+@@ -88,4 +89,4 @@
+         options.signal.removeEventListener("abort", abortFromSource);
+     }
+ }
+-//# sourceMappingURL=openai-remote-timeout.js.map
+
++//# sourceMappingURL=openai-remote-timeout.js.map
+--- a/@code-yeongyu/senpi/dist/core/extensions/builtin/compaction/openai-remote.d.ts
++++ b/@code-yeongyu/senpi/dist/core/extensions/builtin/compaction/openai-remote.d.ts
+@@ -2,7 +2,7 @@
+ import { type Api, type AssistantMessage, type Model, type ProviderHeaders } from "@earendil-works/pi-ai";
+ import type { CompactionResult } from "../../../compaction/index.ts";
+ import { type SessionEntry } from "../../../session-manager.ts";
+-import type { ProviderRequestPreparation, ServiceTier, SessionBeforeCompactEvent } from "../../types.ts";
++import type { CompactionFailure, ProviderRequestPreparation, ServiceTier, SessionBeforeCompactEvent } from "../../types.ts";
+ import type { OpenAiCompactBody, OpenAiRemoteCompactionDetails, OpenAiRemoteInputItem, OpenAiRemoteTransport } from "./openai-remote-convert.ts";
+ import { type OpenAiRemoteCompactionModel, type OpenAiRemoteCompactionOrigin } from "./openai-remote-model.ts";
+ import { type RemoteCompactionTimeout } from "./openai-remote-timeout.ts";
+@@ -121,7 +121,7 @@
+     now: () => number;
+     origin?: OpenAiRemoteCompactionOrigin;
+ }): OpenAiRemoteCompactionResult;
+-export declare function runOpenAiRemoteCompaction(ctx: OpenAiRemoteCompactionContext, event: SessionBeforeCompactEvent, emit?: EmitCompactionEvent, dependencies?: OpenAiRemoteCompactionDependencies): Promise<OpenAiRemoteCompactionResult | undefined>;
++export declare function runOpenAiRemoteCompaction(ctx: OpenAiRemoteCompactionContext, event: SessionBeforeCompactEvent, emit?: EmitCompactionEvent, dependencies?: OpenAiRemoteCompactionDependencies): Promise<{ status: "ineligible" } | { status: "failed"; failure: CompactionFailure } | { status: "accepted"; compaction: OpenAiRemoteCompactionResult }>;
+ /**
+  * Mark the exact checkpoint-owned messages before later context hooks run.
+  * The markers carry entry identity, not payload values; the Responses converter
+@@ -136,4 +136,4 @@
+     branchEntries: SessionEntry[];
+     origin?: OpenAiRemoteCompactionOrigin;
+ }, emit?: EmitCompactionEvent): unknown | undefined;
+-//# sourceMappingURL=openai-remote.d.ts.map
+
++//# sourceMappingURL=openai-remote.d.ts.map
+--- a/@code-yeongyu/senpi/dist/core/extensions/builtin/compaction/openai-remote.js
++++ b/@code-yeongyu/senpi/dist/core/extensions/builtin/compaction/openai-remote.js
+@@ -1,6 +1,10 @@
+ import { convertResponsesMessages, getContextProvenance, normalizeContext, } from "@earendil-works/pi-ai";
+ import { deriveOpenAIPromptCacheKey } from "@earendil-works/pi-ai/api/openai-prompt-cache";
+ import { streamSimple } from "@earendil-works/pi-ai/compat";
++import { compactionFailure } from "./speculative.js";
++import { collectIntentProtection, protectedRemoteInput, taskIntentSummary, retainedUserText } from "./task-intent.js";
++import { estimateTokens } from "../../../compaction/index.js";
++import { resolveEffectiveReserveTokens } from "./policy.js";
+ import { convertToLlm } from "../../../messages.js";
+ import { buildContextEntries, buildSessionContext, getSessionContextEntryId, SESSION_CONTEXT_ENTRY_ID, sessionEntryToContextMessages, } from "../../../session-manager.js";
+ import { convertBranchEntries, convertPendingMessages, getOpenAiRemoteCompactionDetails, isOpenAiContextCompactionItem, isOpenAiRemoteCompactionOutputItem, isRecord, isRetainedRemoteOutputItem, isRetainedResponsesStreamInputItem, OPENAI_REMOTE_COMPACTION_SCHEMA, providerNativeItem, } from "./openai-remote-convert.js";
+@@ -20,9 +24,10 @@
+ export function createOpenAiRemoteCompactionRequest(options) {
+     if (!isOpenAiRemoteCompactionModel(options.model))
+         return undefined;
+-    const input = options.messages
++    const converted = options.messages
+         ? convertPendingMessages(options.messages, options.model)
+         : convertBranchEntries(options.branchEntries, options.model);
++    const input = protectedRemoteInput(converted, collectIntentProtection(options.branchEntries));
+     if (input.length === 0)
+         return undefined;
+     return {
+@@ -53,6 +58,7 @@
+         created_at: typeof options.value.created_at === "number" ? options.value.created_at : Math.floor(options.now() / 1000),
+         object: "response.compaction",
+         output: options.value.output.filter((item) => isRecord(item)),
++        ...(typeof options.value.model === "string" ? { observedModel: options.value.model } : {}),
+         ...(isRecord(options.value.usage) ? { usage: options.value.usage } : {}),
+     };
+ }
+@@ -69,6 +75,7 @@
+         transport: "compact-endpoint",
+         modelId: options.model.id,
+         responseId: options.response.id,
++        ...(options.response.observedModel ? { observedProvider: options.model.provider, observedModel: options.response.observedModel } : {}),
+         createdAt: options.response.created_at,
+         requestInputItemCount: options.requestInputItemCount,
+         retainedInputItemCount: replacementInput.length,
+@@ -137,6 +144,7 @@
+         transport: "websocket",
+         modelId: options.model.id,
+         responseId: options.response.responseId ?? `response-${options.now()}`,
++        ...(options.response.responseModel ? { observedProvider: options.response.provider, observedModel: options.response.responseModel } : {}),
+         createdAt: Math.floor(options.response.timestamp / 1000),
+         requestInputItemCount: options.requestInput.length,
+         retainedInputItemCount: replacementInput.length,
+@@ -177,10 +185,14 @@
+         sessionId: options.request.sessionId,
+         signal: options.signal,
+         transport: "websocket",
++        streamKind: "auxiliary",
++        maxRetries: 0,
+     });
+     const response = await stream.result();
+-    if (response.stopReason === "error" || response.stopReason === "aborted") {
+-        return undefined;
++    if (response.stopReason !== "stop" || response.stopDetails?.type === "refusal") {
++        throw Object.assign(new Error("Remote compaction did not finish normally"), {
++            failure: response.stopDetails?.type === "refusal" ? { kind: "refused" } : response.failure ?? { kind: "incomplete" },
++        });
+     }
+     return buildOpenAiResponsesStreamCompactionResult({
+         model: options.model,
+@@ -221,6 +233,7 @@
+             requestId: options.requestId,
+             modelId: options.model.id,
+             reason: error instanceof Error ? error.message : String(error),
++            failure: compactionFailure(error, options?.model),
+             transport: "compact-endpoint",
+         });
+         return undefined;
+@@ -233,6 +246,7 @@
+             requestId: options.requestId,
+             modelId: options.model.id,
+             reason: `HTTP ${response.status}`,
++            failure: { kind: response.status === 429 ? "quota" : response.status === 401 ? "auth_expired" : response.status === 403 ? "org_denied" : "provider" },
+             transport: "compact-endpoint",
+         });
+         return undefined;
+@@ -249,6 +263,7 @@
+             requestId: options.requestId,
+             modelId: options.model.id,
+             reason: error instanceof Error ? error.message : String(error),
++            failure: compactionFailure(error, options?.model),
+             transport: "compact-endpoint",
+         });
+         return undefined;
+@@ -290,6 +305,7 @@
+             requestId: options.requestId,
+             modelId: options.model.id,
+             reason: error instanceof Error ? error.message : String(error),
++            failure: compactionFailure(error, options?.model),
+             transport: "compact-endpoint",
+         });
+         return undefined;
+@@ -323,6 +339,51 @@
+     return (model, context, options) => streamSimple(model, context, options);
+ }
+ export async function runOpenAiRemoteCompaction(ctx, event, emit, dependencies = {}) {
++    const protection = collectIntentProtection(event.branchEntries);
++    const protectedInput = protectedRemoteInput([], protection);
++    const model = ctx.model;
++    const settings = ctx.getCompactionSettings?.() ?? event.preparation.settings;
++    const protectionTokens = estimateTokens({ role: "user", content: JSON.stringify(protectedInput) });
++    if (model && protectionTokens > model.contextWindow - resolveEffectiveReserveTokens(model.contextWindow, settings))
++        return { status: "ineligible" }; // Before dispatch only: same-model text compaction is permitted.
++    const attempt = await runOpenAiRemoteCompactionAttempt(ctx, event, emit, dependencies);
++    if (attempt.status !== "accepted") return attempt;
++    const result = attempt.compaction;
++    const checkpointTexts = new Set(convertPendingMessages(buildSessionContext(event.branchEntries).messages.filter((message) => message.role === "compactionSummary"), model).map(retainedUserText));
++    // The accepted native envelope already covers the request checkpoint. Keep its original intent outside it, not a second raw copy of the old summary.
++    const retained = result.details.replacementInput.filter((item) => !checkpointTexts.has(retainedUserText(item)));
++    const replacementInput = protectedRemoteInput(retained, protection);
++    return { status: "accepted", compaction: { ...result,
++        summary: taskIntentSummary(result.summary, protection.taskIntent) + (protection.sources.length ? `\n<source-user-text>\n${JSON.stringify(protection.sources)}\n</source-user-text>` : ""),
++        details: { ...result.details, intentProtection: protection, replacementInput, retainedInputItemCount: replacementInput.length,
++            selectionMode: settings.model === undefined || settings.model === "auto" ? "auto" : "explicit",
++            requestedProvider: model.provider, requestedModel: model.id },
++    } };
++}
++async function runOpenAiRemoteCompactionAttempt(ctx, event, emit, dependencies = {}) {
++    let dispatched = false;
++    let failure;
++    try {
++        const compaction = await runRemoteAttempt(ctx, event, (data) => {
++            if (data.action === "remote_started")
++                dispatched = true;
++            if (data.failure)
++                failure = data.failure;
++            if (data.reason === REMOTE_COMPACTION_TIMEOUT_REASON || data.reason === REMOTE_COMPACTION_BUDGET_EXHAUSTED_REASON)
++                failure = { kind: "timeout" };
++            emit?.(data);
++        }, dependencies);
++        if (compaction)
++            return { status: "accepted", compaction };
++        return dispatched ? { status: "failed", failure: failure ?? { kind: "provider" } } : { status: "ineligible" };
++    }
++    catch (error) {
++        if (event.signal.aborted)
++            throw error;
++        return { status: "failed", failure: compactionFailure(error, ctx.model) };
++    }
++}
++async function runRemoteAttempt(ctx, event, emit, dependencies) {
+     const model = ctx.model;
+     if (!isOpenAiRemoteCompactionModel(model) || event.reason === "branch") {
+         emit?.({
+@@ -376,12 +437,16 @@
+         });
+         return undefined;
+     }
++    const requestTokens = estimateTokens({ role: "user", content: JSON.stringify(request.body) });
++    const requestSettings = ctx.getCompactionSettings?.() ?? event.preparation.settings;
++    if (requestTokens > requestModel.contextWindow - resolveEffectiveReserveTokens(requestModel.contextWindow, requestSettings))
++        return undefined;
+     const remoteTimeoutMs = dependencies.remoteTimeoutMs ?? openAiRemoteCompactionTimeoutMs(requestModel, request.tokensBefore);
+     const remoteDeadline = createRemoteCompactionDeadline(remoteTimeoutMs);
+     const timedOut = (waitedMs, next) => ({
+         waitedMs,
+         tokens: request.tokensBefore,
+-        next: remoteDeadline.remainingMs() > 0 ? next : "local-summary",
++        next: "stop",
+     });
+     const remoteBudgetExhausted = (transport) => {
+         if (remoteDeadline.remainingMs() > 0)
+@@ -454,8 +519,7 @@
+                     ? "websocket"
+                     : "compact-endpoint"),
+         });
+-        if (result || requestModel.api === "openai-codex-responses")
+-            return result;
++        return result;
+     }
+     if (supportsOpenAiResponsesWebSocket(requestModel) && !remoteBudgetExhausted("websocket")) {
+         const websocketHeaders = Object.fromEntries(requestHeaders.entries());
+@@ -529,9 +593,11 @@
+                 requestId: event.requestId,
+                 modelId: requestModel.id,
+                 reason: error instanceof Error ? error.message : String(error),
++            failure: compactionFailure(error, requestModel),
+                 transport: "websocket",
+             });
+         }
++        return undefined;
+     }
+     const transformedPayload = providerRequest ? await providerRequest.transformPayload(request.body) : request.body;
+     if (!isOpenAiCompactBody(transformedPayload)) {
+@@ -730,7 +796,7 @@
+     }
+     const input = [
+         ...payloadInput.slice(0, checkpointStart).filter(isRecord),
+-        ...remote.details.replacementInput,
++        ...protectedRemoteInput(remote.details.replacementInput, remote.details.intentProtection),
+         ...payloadInput.slice(checkpointStart + expectedOrdinals.length).filter(isRecord),
+     ];
+     emit?.({
+@@ -743,4 +809,4 @@
+     });
+     return { ...payload, input };
+ }
+-//# sourceMappingURL=openai-remote.js.map
+
++//# sourceMappingURL=openai-remote.js.map
+--- a/@code-yeongyu/senpi/dist/core/extensions/builtin/compaction/prompts.js
++++ b/@code-yeongyu/senpi/dist/core/extensions/builtin/compaction/prompts.js
+@@ -6,12 +6,12 @@
+ const TASK_INTENT_UPDATE_ACQUIRE_GPT = `Write one <task-intent> block with ORIGINAL_REQUEST, TASK_TYPE, MUST_PRESERVE, and MUST_NOT_LOSE before <summary>.`;
+ const TASK_INTENT_UPDATE_ANCHOR_CLAUDE = `<task-intent>
+ {{taskIntent}}
+-Immutable provenance of the original task. Do not rewrite it. Newer explicit user steering overrides it.
+-</task-intent>`;
++</task-intent>
++Immutable provenance of the original task. Do not rewrite it. Newer explicit user steering overrides it.`;
+ const TASK_INTENT_UPDATE_ANCHOR_GPT = `<task-intent>
+ {{taskIntent}}
+-Immutable provenance of the original task. Do not rewrite it. Newer explicit user steering overrides it.
+-</task-intent>`;
++</task-intent>
++Immutable provenance of the original task. Do not rewrite it. Newer explicit user steering overrides it.`;
+ export const MERGED_COMPACTION_PROMPT_SYSTEM = `[SYSTEM DIRECTIVE: OH-MY-OPENCODE - COMPACTION CONTEXT]
+ 
+ You are the COMPACTION ARCHIVIST. Create a structured handoff summary that lets the next agent continue this exact session without restarting, re-searching, or losing constraints.
+@@ -19,7 +19,7 @@
+ Cardinal rules:
+ R1. Quote user requests and constraints VERBATIM. Do not paraphrase.
+ R2. If a section has no content, write "None." Never delete a section.
+-R3. Where a previous summary is supplied, treat its User Requests, Final Goal, and Constraints fields as IMMUTABLE. Append, never rewrite, those three sections.
++R3. Preserve original requests and durable constraints as quoted provenance. Latest explicit user steering governs the current goal and next action. An answer-local restriction applies only to that answer.
+ R4. Preserve every session_id, file path, and identifier byte-for-byte.
+ 
+ Do NOT use tools. Output only the requested summary block.`;
+@@ -83,7 +83,7 @@
+ [INTERNAL COMPACTION UPDATE INSTRUCTION — NOT CONVERSATION HISTORY]
+ The messages above are NEW conversation messages to incorporate into the existing summary provided in <previous-summary> tags.
+ 
+-R3 enforcement: R3. Where a previous summary is supplied, treat its User Requests, Final Goal, and Constraints fields as IMMUTABLE. Append, never rewrite, those three sections.
++Preserve original requests and durable constraints as quoted provenance. Latest explicit user steering governs the current goal and next action. Keep answer-local restrictions local to their answer.
+ 
+ PASS 1 — Internal task-intent extraction
+ {{taskIntentInstruction}}
+@@ -176,7 +176,7 @@
+ Create a compact prefix summary for the next turn. Emit only the sections listed below.
+ 
+ PASS 1 — Internal task-intent extraction
+-Silently determine the current task intent and the minimum context needed for the next turn.
++Preserve the original request and durable constraints from the entire history together with the split turn. Latest explicit steering governs the current goal and next action. Do not promote answer-local restrictions into durable constraints.
+ 
+ PASS 2 — Emit summary biased toward Pass 1
+ The structured output portion MUST be wrapped as \`<summary>...</summary>\` XML.
+@@ -214,9 +214,7 @@
+         case "branch":
+             return MERGED_COMPACTION_PROMPT_BRANCH;
+         case "turn_prefix":
+-            return options.taskIntent
+-                ? MERGED_COMPACTION_PROMPT_TURN_PREFIX
+-                : mergeTaskIntent(MERGED_COMPACTION_PROMPT_TURN_PREFIX, promptFamilyText(options.promptFamily, TASK_INTENT_ACQUISITION_CLAUDE, TASK_INTENT_ACQUISITION_GPT));
++            return buildUserPrompt({ ...options, variant: options.previousSummary || options.taskIntent ? "update" : "default" });
+     }
+     const exhaustiveCheck = options.variant;
+     return exhaustiveCheck;
+@@ -254,4 +252,4 @@
+ function sanitizeTaskIntent(text) {
+     return text.split("</task-intent>").join("[/task-intent]");
+ }
+-//# sourceMappingURL=prompts.js.map
+
++//# sourceMappingURL=prompts.js.map
+--- a/@code-yeongyu/senpi/dist/core/extensions/builtin/compaction/rejected-recovery.d.ts
++++ b/@code-yeongyu/senpi/dist/core/extensions/builtin/compaction/rejected-recovery.d.ts
+@@ -3,9 +3,9 @@
+ import { type SessionEntry } from "../../../session-manager.ts";
+ export declare const REJECTED_RECOVERY_ENTRY = "compaction-recovery-rejected";
+ /** Shared with core admission: a fallback's conservative estimate cannot overrule a usable summary. */
+-export declare function wouldCompactionOverflow(pathEntries: SessionEntry[], compactionResult: CompactionResult, fromExtension: boolean, model: Model<string>, settings: CompactionPreparation["settings"]): boolean;
++export declare function wouldCompactionOverflow(pathEntries: SessionEntry[], compactionResult: CompactionResult, fromExtension: boolean, model: Model<string>, settings: CompactionPreparation["settings"], pendingMessages?: CompactionPreparation["messagesToSummarize"]): boolean;
+ /** State, not elapsed time or a synthetic message revision, releases the latch. */
+ export declare function compactionRecoveryStateKey(branch: readonly SessionEntry[], model: Model<string> | undefined, settings: CompactionPreparation["settings"]): string;
+ /** Persisted on the branch, so extension reload and session reopen cannot retry it. */
+ export declare function isAutomaticCompactionBlocked(branch: readonly SessionEntry[], model: Model<string> | undefined, settings: CompactionPreparation["settings"]): boolean;
+-//# sourceMappingURL=rejected-recovery.d.ts.map
+
++//# sourceMappingURL=rejected-recovery.d.ts.map
+--- a/@code-yeongyu/senpi/dist/core/extensions/builtin/compaction/rejected-recovery.js
++++ b/@code-yeongyu/senpi/dist/core/extensions/builtin/compaction/rejected-recovery.js
+@@ -3,10 +3,12 @@
+ import { admitCursorHistory, cursorAdmissionBudgetBytes } from "../../../cursor-history-admission.js";
+ import { filterContextExcludedMessages } from "../../../messages.js";
+ import { buildContextEntries, buildSessionContext, } from "../../../session-manager.js";
++import { getOpenAiRemoteCompactionDetails, convertPendingMessages } from "./openai-remote-convert.js";
++import { protectedRemoteInput } from "./task-intent.js";
+ import { resolveEffectiveReserveTokens } from "./policy.js";
+ export const REJECTED_RECOVERY_ENTRY = "compaction-recovery-rejected";
+ /** Shared with core admission: a fallback's conservative estimate cannot overrule a usable summary. */
+-export function wouldCompactionOverflow(pathEntries, compactionResult, fromExtension, model, settings) {
++export function wouldCompactionOverflow(pathEntries, compactionResult, fromExtension, model, settings, pendingMessages = []) {
+     const currentLeaf = pathEntries.at(-1);
+     if (!currentLeaf)
+         return false;
+@@ -29,7 +31,13 @@
+                 budgetBytes: cursorAdmissionBudgetBytes(model.contextWindow),
+             }).messages ?? messages;
+     }
+-    const tokens = filterContextExcludedMessages(messages).reduce((total, message) => total + estimateTokens(message), 0);
++    messages = [...messages, ...pendingMessages];
++    const remote = getOpenAiRemoteCompactionDetails(compactionResult.details);
++    const budgetMessages = remote ? [{ role: "user", content: JSON.stringify([
++        ...protectedRemoteInput(remote.replacementInput, remote.intentProtection),
++        ...convertPendingMessages(pendingMessages, model),
++    ]) }] : messages;
++    const tokens = filterContextExcludedMessages(budgetMessages).reduce((total, message) => total + estimateTokens(message), 0);
+     return tokens > model.contextWindow - resolveEffectiveReserveTokens(model.contextWindow, settings);
+ }
+ /** State, not elapsed time or a synthetic message revision, releases the latch. */
+@@ -70,4 +78,4 @@
+         return false;
+     return ("stateKey" in rejection.data && rejection.data.stateKey === compactionRecoveryStateKey(branch, model, settings));
+ }
+-//# sourceMappingURL=rejected-recovery.js.map
+
++//# sourceMappingURL=rejected-recovery.js.map
+--- a/@code-yeongyu/senpi/dist/core/extensions/builtin/compaction/speculative-summary.js
++++ b/@code-yeongyu/senpi/dist/core/extensions/builtin/compaction/speculative-summary.js
+@@ -4,6 +4,7 @@
+ import { consumeStreamWithIdleTimeout, DEFAULT_SUMMARIZATION_IDLE_TIMEOUT_MS, summarizationMaxDurationMs, } from "../../../compaction/stream-watchdog.js";
+ import { convertToLlm } from "../../../messages.js";
+ import { repairOrphanedToolResults } from "./repair-tool-pairs.js";
++import { estimateTotalTokens } from "./overflow-retry.js";
+ import { normalizeSummarizationTurnOrder } from "./summarization-turn-order.js";
+ const SUMMARY_TOKEN_HEADROOM = 32_768;
+ const SUMMARY_CONTEXT_WINDOW_RESERVE_RATIO = 0.5;
+@@ -106,6 +107,15 @@
+             messages: repairOrphanedToolResults(normalizeSummarizationTurnOrder(convertToLlm(providerRequest?.messages ?? requestMessages))),
+             ...(options.snapshot.tools && options.snapshot.tools.length > 0 ? { tools: options.snapshot.tools } : {}),
+         };
++        const inputTokens = estimateTotalTokens([
++            ...requestContext.messages,
++            { role: "user", content: requestContext.systemPrompt },
++            { role: "user", content: JSON.stringify(requestContext.tools ?? []) },
++        ]);
++        if (inputTokens + summaryMaxTokens(options.snapshot.model, options.snapshot.contextWindow) > options.snapshot.contextWindow) {
++            throw Object.assign(new Error("Compaction request exceeds the selected model context budget"),
++                { failure: { kind: "context_budget", provider: options.snapshot.model.provider, model: options.snapshot.model.id } });
++        }
+         const headers = providerRequest
+             ? await providerRequest.transformHeaders(options.auth.headers ?? {})
+             : options.auth.headers;
+@@ -113,6 +123,8 @@
+             apiKey: options.auth.apiKey,
+             headers,
+             extraBody: options.auth.extraBody,
++            env: options.auth.env,
++            streamKind: "auxiliary",
+             onPayload: async (payload, model) => {
+                 const sanitized = model.api === "anthropic-messages" ? sanitizeAnthropicPayload(payload) : payload;
+                 return providerRequest ? await providerRequest.transformPayload(sanitized) : sanitized;
+@@ -142,4 +154,4 @@
+             options.signal.removeEventListener("abort", onCallerAbort);
+     }
+ }
+-//# sourceMappingURL=speculative-summary.js.map
+
++//# sourceMappingURL=speculative-summary.js.map
+--- a/@code-yeongyu/senpi/dist/core/extensions/builtin/compaction/speculative.d.ts
++++ b/@code-yeongyu/senpi/dist/core/extensions/builtin/compaction/speculative.d.ts
+@@ -4,7 +4,7 @@
+ import { type WarmAnchorSnapshot } from "../../../compaction/warm-anchor.ts";
+ import type { ModelRegistry } from "../../../model-registry.ts";
+ import type { ReadonlySessionManager } from "../../../session-manager.ts";
+-import type { ApplyCompactionResult, ContextUsage, ProviderRequestPreparation } from "../../types.ts";
++import type { CompactionFailure, ApplyCompactionResult, ContextUsage, ProviderRequestPreparation } from "../../types.ts";
+ import { type MergedCompactionPromptVariant } from "./prompts.ts";
+ export { createEmergencyPruneLatch, type EmergencyPruneLatch, hardLimitEmergencyPrune, truncateContextMessages, } from "./emergency-prune.ts";
+ type CompactionProgressCallback = (delta: string) => void;
+@@ -14,13 +14,14 @@
+     modelRegistry?: ModelRegistry;
+     getContextUsage(): ContextUsage | undefined;
+     getCompactionSettings?(): CompactionPreparation["settings"];
+-    getCompactionModel?(): Model<any> | undefined;
++    getCompactionModel?(inputTokens?: number): Model<any> | undefined;
+     getMessageRevision(): number;
+     getSystemPrompt?(): string;
+     prepareProviderRequest?(messages: AgentMessage[]): Promise<ProviderRequestPreparation>;
+     isIdle?(): boolean;
+     applyCompaction(precomputed: CompactionResult, options: {
+         reason: "extension";
++        blocking?: boolean;
+         expectedRevision?: number;
+         expectedWarmAnchor?: WarmAnchorSnapshot;
+         signal?: AbortSignal;
+@@ -56,7 +57,7 @@
+  * text happens to look retryable must still surface loudly; the message
+  * string alone cannot encode that.
+  */
+-export type SummaryRequestFailureKind = "upstream-stream-truncated";
++export type SummaryRequestFailureKind = "upstream-stream-truncated" | CompactionFailure["kind"];
+ export declare class SummaryRequestError extends Error {
+     readonly transient: boolean;
+     readonly failureKind?: SummaryRequestFailureKind;
+@@ -70,9 +71,12 @@
+     constructor(message: string, transient: boolean, failureKind?: SummaryRequestFailureKind, refused?: boolean);
+ }
+ export declare class SummaryGenerationError extends Error {
+-    readonly kind: "auth" | "empty-summary";
+-    constructor(kind: "auth" | "empty-summary", message: string);
++    readonly kind: CompactionFailure["kind"];
++    readonly failure: CompactionFailure;
++    constructor(kind: CompactionFailure["kind"], message: string);
+ }
++export declare function compactionFailure(error: unknown, model?: { provider: string; id: string }): CompactionFailure;
++export declare function validateSummaryResponse(response: unknown): { summaryText: string; taskIntent?: string };
+ /**
+  * Output budget for one summarization request. Adaptive-thinking models emit
+  * reasoning tokens before the summary text, so the legacy flat 8192 cap could
+@@ -104,6 +108,6 @@
+  * misreports as an auth failure.
+  */
+ export declare function runExtensionCompaction(context: SpeculativeCompactionContext, snapshot: SpeculativeCompactionSnapshot, signal?: AbortSignal, onProgress?: CompactionProgressCallback): Promise<CompactionResult | undefined>;
+-export declare function applyGeneratedCompaction(context: SpeculativeCompactionContext, snapshot: SpeculativeCompactionSnapshot | undefined, getCurrentGeneration: () => number, compaction: CompactionResult | undefined, signal?: AbortSignal): Promise<SpeculativeCompactionResult>;
++export declare function applyGeneratedCompaction(context: SpeculativeCompactionContext, snapshot: SpeculativeCompactionSnapshot | undefined, getCurrentGeneration: () => number, compaction: CompactionResult | undefined, signal?: AbortSignal, blocking?: boolean): Promise<SpeculativeCompactionResult>;
+ export declare function applySpeculativeCompaction(context: SpeculativeCompactionContext, snapshot: SpeculativeCompactionSnapshot | undefined, getCurrentGeneration: () => number, generate: () => Promise<CompactionResult | undefined>): Promise<SpeculativeCompactionResult>;
+-//# sourceMappingURL=speculative.d.ts.map
+
++//# sourceMappingURL=speculative.d.ts.map
+--- a/@code-yeongyu/senpi/dist/core/extensions/builtin/compaction/speculative.js
++++ b/@code-yeongyu/senpi/dist/core/extensions/builtin/compaction/speculative.js
+@@ -5,12 +5,12 @@
+ import { CredentialFailoverError, TURN_RETRY_SUPPRESSION_PREFIX } from "../../../credential-pool/failover.js";
+ import { convertToLlm } from "../../../messages.js";
+ import { pruneToolResults } from "./emergency-prune.js";
+-import { allowOverflowRetry, boundSummarizationInput, SUMMARIZATION_INPUT_BUDGET_RATIO, SummarizationOverflowExhaustedError, shrinkSummarizationInputForOverflowRetry, } from "./overflow-retry.js";
++import { estimateTotalTokens, SummarizationOverflowExhaustedError } from "./overflow-retry.js";
+ import { computeEffectiveKeepRecentTokens, computeEffectiveThreshold } from "./policy.js";
+ import { buildPrompt } from "./prompts.js";
+ import { generateSummaryMessage, getSummaryText, hasSummarizationReasoningOverride, isAssistantMessage, } from "./speculative-summary.js";
+ import { allowSummarizationRetry, DEFAULT_SUMMARIZATION_RETRY_POLICY } from "./summarization-retry.js";
+-import { extractTaskIntent, resolveInheritedTaskIntent } from "./task-intent.js";
++import { extractTaskIntent, resolveInheritedTaskIntent, taskIntentSummary, taskIntentMetadata } from "./task-intent.js";
+ export { createEmergencyPruneLatch, hardLimitEmergencyPrune, truncateContextMessages, } from "./emergency-prune.js";
+ import { computeStructuralYield } from "./yield.js";
+ const DEFAULT_CONTEXT_WINDOW = 200_000;
+@@ -30,23 +30,35 @@
+         this.transient = transient;
+         this.failureKind = failureKind;
+         this.refused = refused;
++        this.failure = { kind: refused ? "refused" : failureKind === "upstream-stream-truncated" ? "incomplete" : failureKind ?? "provider" };
+     }
+ }
++export function compactionFailure(error, model) {
++    const kind = error?.refused ? "refused" : error?.failure?.kind ?? error?.kind;
++    const known = ["invalid_model", "auth_missing", "auth_expired", "quota", "org_denied", "model_unavailable", "refused", "timeout", "incomplete", "empty", "context_budget", "stale", "provider"];
++    return { kind: known.includes(kind) ? kind
++        : error instanceof StreamDurationBudgetError || error instanceof StreamIdleTimeoutError || error instanceof SummarizationTotalBudgetError || error?.name === "TimeoutError" ? "timeout"
++        : error instanceof SummarizationOverflowExhaustedError ? "context_budget" : "provider",
++        ...(model ? { provider: model.provider, model: model.id } : {}),
++        ...(error?.failure?.provider ? { provider: error.failure.provider } : {}),
++        ...(error?.failure?.model ? { model: error.failure.model } : {}) };
++}
++export function validateSummaryResponse(response) {
++    if (response && isRefusalStop(response))
++        throw new SummaryRequestError("Compaction summary refused", false, undefined, true);
++    if (!response || !isAssistantMessage(response) || response.stopReason !== "stop" ||
++        response.content.some((block) => block.type === "toolCall" || block.type === "toolUse"))
++        throw new SummaryGenerationError("incomplete", "Compaction summary did not finish normally");
++    const parsed = extractTaskIntent(getSummaryText(response));
++    if (!parsed.summaryText.trim())
++        throw new SummaryGenerationError("empty", "Compaction summary body is empty");
++    return parsed;
++}
+ const UPSTREAM_STREAM_TRUNCATED_PATTERN = /(?:^|[^A-Za-z0-9_])upstream_stream_truncated(?:[^A-Za-z0-9_]|$)/;
+-/**
+- * Only failures with no cheaper recovery earn another billed request.
+- *
+- * Every class that `classifyRequiredCompactionFallbackFailure` recognizes
+- * (watchdog timeouts, the compaction-wide total budget, terminal provider and
+- * credential failures, `upstream-stream-truncated`, overflow exhaustion,
+- * empty-summary generation failures) already
+- * has a deterministic zero-LLM recovery, and context overflow is answered by
+- * shrinking the input in the surrounding loop - replaying those would pay for a
+- * summarization the fallback can rebuild for free. The classes checked here are
+- * mirrored from that classifier rather than imported, because
+- * `deterministic-fallback.ts` imports this module.
+- */
++/** Only pre-output transient failures may retry the same selected model. */
+ function isRetryableSummaryAttempt(error) {
++    if (error?.failure?.kind && error.failure.kind !== "provider")
++        return false;
+     if (error instanceof StreamDurationBudgetError || error instanceof StreamIdleTimeoutError)
+         return false;
+     if (error instanceof SummarizationTotalBudgetError)
+@@ -55,17 +67,12 @@
+         return false;
+     if (error instanceof SummaryGenerationError)
+         return false;
+-    // Mirrors the `summarization-provider-failure` class: credential rotation has
+-    // already spent every slot it may spend, and the marker means output was
+-    // committed, so another billed attempt buys nothing the fallback cannot
+-    // rebuild for free. Message text alone must not re-authorize it - the wrapped
+-    // provider detail can read as transient (#1741).
+     if (error instanceof CredentialFailoverError)
+         return false;
+     if (error instanceof Error && error.message.startsWith(TURN_RETRY_SUPPRESSION_PREFIX))
+         return false;
+     if (error instanceof SummaryRequestError)
+-        return error.failureKind === undefined && error.transient;
++        return !error.refused && error.failureKind === undefined && error.transient;
+     if (error instanceof Error)
+         return isRetryableErrorMessage(error.message);
+     return false;
+@@ -76,6 +83,9 @@
+ function summaryRequestFailureKind(response) {
+     if (isRefusalStop(response))
+         return undefined;
++    const kind = response.failure?.kind;
++    if (["auth_missing", "auth_expired", "quota", "org_denied", "model_unavailable", "timeout", "incomplete", "context_budget"].includes(kind))
++        return kind;
+     return UPSTREAM_STREAM_TRUNCATED_PATTERN.test(response.errorMessage ?? "") ? "upstream-stream-truncated" : undefined;
+ }
+ export class SummaryGenerationError extends Error {
+@@ -83,6 +93,7 @@
+         super(message);
+         this.name = "SummaryGenerationError";
+         this.kind = kind;
++        this.failure = { kind };
+     }
+ }
+ /**
+@@ -131,7 +142,7 @@
+ }
+ /**
+  * Generate a compaction summary for the snapshot. Resolves `undefined` only
+- * when the request was aborted (caller signal or an aborted stream); every
++ * when the caller signal was aborted; every
+  * other failure throws — {@link SummaryGenerationError} for diagnosable
+  * generation failures, the raw provider error otherwise. Abort is checked
+  * before and after credential resolution so a cancelled request never
+@@ -140,51 +151,54 @@
+ export async function runExtensionCompaction(context, snapshot, signal, onProgress) {
+     if (signal?.aborted)
+         return undefined;
+-    // A provider is authenticated for summarization by a resolved key, a credential
+-    // request header, or ambient request-time auth. The ambient marker comes from the
+-    // same provider resolution normal turns use; an unconfigured keyed provider still
+-    // has none of these and is rejected before a request.
+-    const authenticated = (resolved) => resolved?.ok === true && Boolean(resolved.apiKey || hasCredentialHeaders(resolved.headers) || resolved.ambient);
+-    let selectedModel = context.getCompactionModel?.() ?? snapshot.model;
+-    let auth = await context.modelRegistry?.getApiKeyAndHeaders(selectedModel);
+-    if (signal?.aborted)
+-        return undefined;
+-    // A configured summary model whose credentials could not be confirmed earlier (#830) must not
+-    // disable compaction: without credentials at request time, summarize on the session model.
+-    if (selectedModel !== snapshot.model && !authenticated(auth)) {
+-        selectedModel = snapshot.model;
+-        auth = await context.modelRegistry?.getApiKeyAndHeaders(selectedModel);
++    const prompt = buildPrompt({
++        variant: snapshot.promptVariant,
++        previousSummary: snapshot.preparation.previousSummary,
++        taskIntent: resolveInheritedTaskIntent(snapshot.branchEntries ?? []),
++        customInstructions: snapshot.customInstructions,
++    });
++    const messages = [...snapshot.preparation.messagesToSummarize, ...snapshot.preparation.turnPrefixMessages];
++    const inputTokens = estimateTotalTokens([
++        ...messages,
++        { role: "user", content: prompt.user },
++        { role: "user", content: snapshot.systemPrompt ?? prompt.system },
++        { role: "user", content: JSON.stringify(snapshot.tools ?? []) },
++    ]);
++    const selectedModel = context.getCompactionModel?.(inputTokens) ?? snapshot.model;
++    const selectedSnapshot = { ...snapshot, model: selectedModel, contextWindow: selectedModel.contextWindow, selectionMode: context.getCompactionSettings?.().model === undefined || context.getCompactionSettings?.().model === "auto" ? "auto" : "explicit" };
++    let auth;
++    try {
++        const runtime = context.modelRegistry?.modelRuntime;
++        if (runtime) {
++            const prepared = await runtime.prepareRequest(selectedModel, { signal });
++            auth = { ok: true, ...prepared.options, baseUrl: prepared.model.baseUrl, ambient: true };
++        }
++        else {
++            auth = await context.modelRegistry?.getApiKeyAndHeaders(selectedModel);
++        }
++    }
++    catch (error) {
+         if (signal?.aborted)
+             return undefined;
++        const kind = error?.failure?.kind ?? error?.kind;
++        const known = ["auth_missing", "auth_expired", "quota", "org_denied", "model_unavailable"];
++        const failure = { kind: kind === "auth" ? "auth_missing" : known.includes(kind) ? kind : "provider",
++            provider: selectedModel.provider, model: selectedModel.id };
++        throw Object.assign(new SummaryGenerationError(failure.kind, "Compaction request authentication failed"), { failure, cause: error });
+     }
+-    const selectedSnapshot = selectedModel === snapshot.model
+-        ? snapshot
+-        : { ...snapshot, model: selectedModel, contextWindow: selectedModel.contextWindow };
+-    if (!auth?.ok || !authenticated(auth)) {
+-        const detail = auth && !auth.ok ? auth.error : `no credentials resolved for provider "${selectedModel.provider}"`;
+-        throw new SummaryGenerationError("auth", `summarization credentials unavailable: ${detail}`);
++    if (signal?.aborted)
++        return undefined;
++    if (!auth?.ok || !(auth.apiKey || hasCredentialHeaders(auth.headers) || auth.ambient)) {
++        const failure = { kind: "auth_missing", provider: selectedModel.provider, model: selectedModel.id };
++        throw Object.assign(new SummaryGenerationError(failure.kind, "Compaction request authentication unavailable"), { failure });
+     }
+     const requestSnapshot = auth.baseUrl
+         ? { ...selectedSnapshot, model: { ...selectedModel, baseUrl: auth.baseUrl } }
+         : selectedSnapshot;
+-    const prompt = buildPrompt({
+-        variant: requestSnapshot.promptVariant,
+-        previousSummary: requestSnapshot.preparation.previousSummary,
+-        taskIntent: resolveInheritedTaskIntent(requestSnapshot.branchEntries ?? []),
+-        customInstructions: requestSnapshot.customInstructions,
+-    });
+-    const promptTokens = approxTokens(prompt.user);
+-    let messages = boundSummarizationInput(pruneToolResults([...requestSnapshot.preparation.messagesToSummarize, ...requestSnapshot.preparation.turnPrefixMessages], requestSnapshot.contextWindow, SUMMARIZATION_INPUT_BUDGET_RATIO), requestSnapshot.contextWindow, promptTokens);
+     // One deadline for the whole compaction. The per-attempt budget scales with the
+     // input and every retry re-arms it, so without this a large session could hold
+     // the turn for attempt-budget x attempts with no bound the user can predict.
+     const deadline = createSummarizationDeadline(summarizationTotalBudgetMs(requestSnapshot.preparation.settings.summarizationMaxDurationMs));
+-    const overflowRetryStartMs = Date.now();
+-    let overflowAttempts = 0;
+-    const summarizationToolsOffered = (requestSnapshot.tools?.length ?? 0) > 0;
+-    const reasoningOverrideOffered = hasSummarizationReasoningOverride(requestSnapshot.model);
+-    let toolUseRetrySpent = false;
+-    let reasoningOverrideRetrySpent = false;
+     while (true) {
+         if (signal?.aborted)
+             return undefined;
+@@ -210,7 +224,7 @@
+             response = await retryTransientCall(async () => {
+                 const attempt = await generateSummaryMessage({
+                     context,
+-                    forbidToolCalls: toolUseRetrySpent,
++                    forbidToolCalls: true,
+                     // Re-clamped per attempt, not per loop turn: a retry that starts
+                     // near the deadline gets only what is left, and none starts past it.
+                     maxDurationMs: deadline.attemptBudgetMs(attemptBudgetMs),
+@@ -223,15 +237,15 @@
+                         apiKey: auth.apiKey,
+                         headers: auth.headers,
+                         extraBody: auth.extraBody,
++                        env: auth.env,
+                     },
+-                    ...(reasoningOverrideRetrySpent ? { omitReasoningOptions: true } : {}),
+                 });
+                 if (attempt &&
+                     isAssistantMessage(attempt) &&
+-                    attempt.stopReason === "error" &&
++                    (attempt.stopReason === "error" || isRefusalStop(attempt)) &&
+                     !isContextOverflow(attempt, requestSnapshot.contextWindow)) {
+                     const failureKind = summaryRequestFailureKind(attempt);
+-                    throw new SummaryRequestError(attempt.errorMessage || "Compaction summary request failed", failureKind !== undefined || isRetryableAssistantError(attempt), failureKind, isRefusalStop(attempt));
++                    throw new SummaryRequestError(attempt.errorMessage || "Compaction summary request failed", attempt.content.length === 0 && failureKind === undefined && isRetryableAssistantError(attempt), failureKind, isRefusalStop(attempt));
+                 }
+                 return attempt;
+             }, (error) => retryEligible &&
+@@ -244,88 +258,49 @@
+                 return undefined;
+             throw error;
+         }
+-        if (!response)
++        if (!response && signal?.aborted)
+             return undefined;
+-        if (isAssistantMessage(response) && isContextOverflow(response, requestSnapshot.contextWindow)) {
+-            overflowAttempts++;
+-            const elapsedMs = Date.now() - overflowRetryStartMs;
+-            const retryMessages = allowOverflowRetry(overflowAttempts, elapsedMs)
+-                ? shrinkSummarizationInputForOverflowRetry(messages, requestSnapshot.contextWindow, promptTokens)
+-                : undefined;
+-            if (!retryMessages) {
+-                throw new SummarizationOverflowExhaustedError(overflowAttempts, elapsedMs);
+-            }
+-            messages = retryMessages;
+-            continue;
++        if (response && isAssistantMessage(response) && isContextOverflow(response, requestSnapshot.contextWindow)) {
++            const failure = { kind: "context_budget", provider: selectedModel.provider, model: selectedModel.id };
++            throw Object.assign(new SummaryGenerationError(failure.kind, "Compaction input exceeds the provider context budget"), { failure });
+         }
+-        if (isAssistantMessage(response) && response.stopReason === "aborted") {
+-            // A partial summary from an aborted stream must never be applied.
+-            return undefined;
+-        }
+-        if (isAssistantMessage(response) && response.stopReason === "error") {
+-            // Surface the real provider failure instead of silently degrading
+-            // into a generic "Compaction cancelled". Preserve the structured
+-            // truncation class here so downstream recovery never trusts arbitrary
+-            // thrown error text as authorization for destructive context reduction.
+-            const failureKind = summaryRequestFailureKind(response);
+-            throw new SummaryRequestError(response.errorMessage || "Compaction summary request failed", failureKind !== undefined || isRetryableAssistantError(response), failureKind, isRefusalStop(response));
+-        }
+-        const summary = getSummaryText(response);
+-        if (!summary) {
+-            const stopReason = isAssistantMessage(response) ? response.stopReason : "unknown";
+-            // A summarizer can hijack the forwarded agent tools and answer with a
+-            // bare tool call (observed on chatgpt-subscription gpt-5.6-sol, 2026-08-31),
+-            // which used to surface as a terminal empty-summary failure. Spend one
+-            // retry with tool calling forbidden; the tools stay in the request
+-            // because Anthropic rejects tool_use history without the tools param.
+-            if (stopReason === "toolUse" && summarizationToolsOffered && !toolUseRetrySpent) {
+-                toolUseRetrySpent = true;
+-                continue;
+-            }
+-            // Some OpenAI-completions relays complete with a normal stop but zero
+-            // text when the summarization prompt pins an explicit reasoning effort
+-            // (GLM-5.3-flash behind a custom relay, 2026-09-17: HTTP 200 carrying
+-            // only the role prelude). Spend one retry without the reasoning
+-            // override, but only when the first attempt carried one: a model with
+-            // no override would just replay the identical prompt. On Anthropic the
+-            // override is `thinkingEnabled: false`, so the retry runs with the
+-            // provider's default thinking, clamped by the compaction deadline.
+-            // Persistent emptiness still throws and the deterministic fallback
+-            // owns recovery.
+-            if (stopReason === "stop" && reasoningOverrideOffered && !reasoningOverrideRetrySpent) {
+-                reasoningOverrideRetrySpent = true;
+-                continue;
+-            }
+-            throw new SummaryGenerationError("empty-summary", `summarization response contained no text (stopReason: ${stopReason})`);
+-        }
++        const parsedSummary = validateSummaryResponse(response);
++        const inheritedIntent = resolveInheritedTaskIntent(snapshot.branchEntries ?? []);
++        if (inheritedIntent && parsedSummary.taskIntent && parsedSummary.taskIntent !== inheritedIntent)
++            throw new SummaryGenerationError("incomplete", "Compaction changed protected task intent");
++        const taskIntent = inheritedIntent ?? parsedSummary.taskIntent;
++        const summary = taskIntentSummary(parsedSummary.summaryText, taskIntent);
+         // Informational only: the core rejects an applied compaction that would
+         // still overflow (_wouldCompactionOverflow). Rejecting here based on the
+         // size of the *discarded* input made large sessions uncompactable.
+         const tokenEstimate = estimateContextTokens(convertToLlm(messages)).tokens + approxTokens(summary);
+-        const parsedSummary = extractTaskIntent(summary);
+-        const taskIntent = parsedSummary.taskIntent ?? resolveInheritedTaskIntent(snapshot.branchEntries ?? []);
+         return {
+-            summary: parsedSummary.summaryText,
++            summary,
+             firstKeptEntryId: snapshot.preparation.firstKeptEntryId,
+             tokensBefore: snapshot.preparation.tokensBefore,
+             details: {
+                 schema: SUMMARY_SCHEMA,
++                selectionMode: selectedSnapshot.selectionMode,
++                requestedProvider: selectedModel.provider,
++                requestedModel: selectedModel.id,
++                ...(isAssistantMessage(response) && response.provider && response.responseModel
++                    ? { observedProvider: response.provider, observedModel: response.responseModel } : {}),
+                 promptVariant: snapshot.promptVariant,
+                 tokenEstimate,
+                 structuralYield: computeStructuralYield({
+                     previousSummary: snapshot.preparation.previousSummary ?? "",
+                     messagesToSummarize: snapshot.preparation.messagesToSummarize,
+                     turnPrefixMessages: snapshot.preparation.turnPrefixMessages,
+-                    summary: parsedSummary.summaryText,
++                    summary,
+                     tokensBefore: snapshot.preparation.tokensBefore,
+                 }),
+                 ...(snapshot.origin ? { origin: snapshot.origin } : {}),
+-                ...(taskIntent ? { taskIntent } : {}),
++                ...(taskIntent ? { taskIntent: taskIntentMetadata(taskIntent) } : {}),
+             },
+         };
+     }
+ }
+-export async function applyGeneratedCompaction(context, snapshot, getCurrentGeneration, compaction, signal) {
++export async function applyGeneratedCompaction(context, snapshot, getCurrentGeneration, compaction, signal, blocking = true) {
+     const provider = context.model?.provider;
+     if ((provider === "cursor" || provider === "cursor-cli-oauth") && context.isIdle && !context.isIdle()) {
+         return { applied: false, reason: "rejected" };
+@@ -343,6 +318,7 @@
+     }
+     return await context.applyCompaction(compaction, {
+         reason: "extension",
++        blocking,
+         ...(revisionUnchanged || !warmAnchor
+             ? { expectedRevision: snapshot.expectedRevision }
+             : { expectedWarmAnchor: warmAnchor }),
+@@ -355,4 +331,4 @@
+     const compaction = await generate();
+     return await applyGeneratedCompaction(context, snapshot, getCurrentGeneration, compaction);
+ }
+-//# sourceMappingURL=speculative.js.map
+
++//# sourceMappingURL=speculative.js.map
+--- a/@code-yeongyu/senpi/dist/core/extensions/builtin/compaction/task-intent.js
++++ b/@code-yeongyu/senpi/dist/core/extensions/builtin/compaction/task-intent.js
+@@ -13,7 +13,7 @@
+         if (!block)
+             break;
+         if (taskIntent === undefined)
+-            taskIntent = capUtf8Bytes(block.inner.trim(), TASK_INTENT_BYTE_CAP);
++            taskIntent = block.inner.trim();
+         remaining = `${remaining.slice(0, block.start)}${remaining.slice(block.end)}`;
+     }
+     const summaryBlocks = collectWellFormedBlocks(remaining, SUMMARY_OPEN, SUMMARY_CLOSE);
+@@ -41,15 +41,16 @@
+             continue;
+         const typedDetails = details;
+         const schema = typeof typedDetails.schema === "string" ? typedDetails.schema : entry.schema;
+-        if (schema === REMOTE_SCHEMA || schema !== SUMMARY_SCHEMA)
++        if (schema !== REMOTE_SCHEMA && schema !== SUMMARY_SCHEMA)
+             continue;
+-        const taskIntent = typedDetails.taskIntent;
++        const fullIntent = typeof entry.summary === "string" ? extractTaskIntent(entry.summary).taskIntent : undefined;
++        const taskIntent = fullIntent ?? typedDetails.intentProtection?.taskIntent ?? typedDetails.taskIntent;
+         if (typeof taskIntent !== "string")
+             continue;
+         const trimmed = taskIntent.trim();
+         if (!trimmed)
+             continue;
+-        return capUtf8Bytes(trimmed, TASK_INTENT_BYTE_CAP);
++        return trimmed;
+     }
+     return undefined;
+ }
+@@ -89,4 +90,61 @@
+     }
+     return text.slice(0, end).trim();
+ }
+-//# sourceMappingURL=task-intent.js.map
+
++
++/** Full-body provenance is separate from the bounded display metadata. */
++export function taskIntentSummary(body, taskIntent) {
++    return taskIntent ? `<task-intent>
++${taskIntent}
++</task-intent>
++
++Quoted original-task provenance, not a renewed instruction. Latest explicit user steering governs current action. Answer-local restrictions do not become durable constraints.
++
++${body}` : body;
++}
++export function taskIntentMetadata(taskIntent) {
++    return taskIntent ? capUtf8Bytes(taskIntent, TASK_INTENT_BYTE_CAP) : undefined;
++}
++export function collectIntentProtection(branchEntries) {
++    const sources = new Map();
++    const previous = branchEntries.findLast((entry) => entry.type === "compaction")?.details?.intentProtection;
++    for (const source of previous?.sources ?? []) sources.set(source.id, source);
++    for (const entry of branchEntries) {
++        for (const source of entry.details?.intentProtection?.sources ?? [])
++            sources.set(source.id, source);
++        if (entry.type !== "message" || entry.message?.role !== "user")
++            continue;
++        const content = entry.message.content;
++        const text = typeof content === "string" ? content : content.filter((block) => block.type === "text").map((block) => block.text).join("\n");
++        if (text) sources.set(entry.id, { id: entry.id, text });
++    }
++    return { taskIntent: resolveInheritedTaskIntent(branchEntries), sources: [...sources.values()] };
++}
++export function retainedUserText(item) {
++    if (item.role !== "user") return undefined;
++    if (typeof item.content === "string") return item.content;
++    if (!Array.isArray(item.content) || !item.content.every((block) => block.type === "input_text")) return undefined;
++    return item.content.map((block) => block.text).join("\n");
++}
++export function protectedRemoteInput(replacementInput, protection) {
++    if (!protection) return replacementInput;
++    const input = replacementInput.filter((item) => {
++        const text = retainedUserText(item);
++        if (!text) return true;
++        if (protection.sources.some((source) => source.id === item.__senpiCompactionSourceId && source.text === text)) return false;
++        if (protection.taskIntent && text === taskIntentSummary("", protection.taskIntent)) return false;
++        const start = text.indexOf("<source-user-text>\n");
++        const end = text.indexOf("\n</source-user-text>", start);
++        if (start < 0 || end < 0) return true;
++        let records;
++        try { records = JSON.parse(text.slice(start + 19, end)); } catch { return true; }
++        if (!Array.isArray(records) || !records.every((source) => protection.sources.some((known) => known.id === source.id && known.text === source.text))) return true;
++        const canonical = taskIntentSummary(`Quoted user source records; newer explicit steering takes precedence.\n<source-user-text>\n${JSON.stringify(records)}\n</source-user-text>`, protection.taskIntent);
++        return text !== canonical;
++    });
++    const remaining = protection.sources;
++    const text = taskIntentSummary(remaining.length ? `Quoted user source records; newer explicit steering takes precedence.\n<source-user-text>
++${JSON.stringify(remaining)}
++</source-user-text>` : "", protection.taskIntent);
++    return text ? [...input, { type: "message", role: "user", content: [{ type: "input_text", text }] }] : input;
++}
++//# sourceMappingURL=task-intent.js.map
+--- a/@code-yeongyu/senpi/dist/core/extensions/runner.js
++++ b/@code-yeongyu/senpi/dist/core/extensions/runner.js
+@@ -1191,9 +1191,9 @@
+             get getCompactionModel() {
+                 runner.assertActive();
+                 return runner.getCompactionModelFn
+-                    ? () => {
++                    ? (inputTokens) => {
+                         runner.assertActive();
+-                        return runner.getCompactionModelFn?.();
++                        return runner.getCompactionModelFn?.(inputTokens);
+                     }
+                     : undefined;
+             },
+@@ -1861,7 +1861,7 @@
+                     const event = {
+                         type: "before_provider_request",
+                         payload: currentPayload,
+-                        ...(request ? { model: request.model, headers: request.headers } : {}),
++                        ...(request ? { model: request.model, headers: request.headers, streamKind: request.streamKind } : {}),
+                     };
+                     const handlerResult = await handler(event, this.createContext(ext.path));
+                     if (handlerResult !== undefined) {
+@@ -2058,4 +2058,4 @@
+             : { action: "continue" };
+     }
+ }
+-//# sourceMappingURL=runner.js.map
+
++//# sourceMappingURL=runner.js.map
+--- a/@code-yeongyu/senpi/dist/core/extensions/types.d.ts
++++ b/@code-yeongyu/senpi/dist/core/extensions/types.d.ts
+@@ -55,6 +55,14 @@
+ export type CompactionRejectionCause = "cancelled-by-extension" | "external-owner" | "would-overflow" | "circuit-breaker" | "per-turn-cap" | "stale-revision";
+ /** Options for extension UI dialogs. */
+ export interface ExtensionUIDialogOptions {
++    /** Exact native permission identity; correlation only, never an approval. */
++    nativePermission?: {
++        sessionID: string;
++        requestID: string;
++        correlationId: string;
++    };
++    /** Whether answering this dialog is required; omitted means required. */
++    required?: boolean;
+     /** AbortSignal to programmatically dismiss the dialog. */
+     signal?: AbortSignal;
+     /** Timeout in milliseconds. Dialog auto-dismisses with live countdown display. */
+@@ -302,6 +310,7 @@
+ }
+ export interface ApplyCompactionOptions {
+     reason: CompactionReason;
++    blocking?: boolean;
+     expectedRevision?: number;
+     /**
+      * Content anchor for a warm summary: the compaction applies while this snapshot
+@@ -327,8 +336,14 @@
+     signal?: AbortSignal;
+     delta?: string;
+     text?: string;
++}
++export interface CompactionFailure {
++    kind: "invalid_model" | "auth_missing" | "auth_expired" | "quota" | "org_denied" | "model_unavailable" | "refused" | "timeout" | "incomplete" | "empty" | "context_budget" | "stale" | "provider";
++    provider?: string;
++    model?: string;
+ }
+ export interface EndCompactionOptions {
++    failure?: CompactionFailure;
+     reason: CompactionReason;
+     signal?: AbortSignal;
+     aborted?: boolean;
+@@ -479,8 +494,8 @@
+     getContextUsage(): ContextUsage | undefined;
+     /** Get resolved compaction settings from global/project/user overrides. */
+     getCompactionSettings(): CompactionPreparation["settings"];
+-    /** Session-selected usable summarization model; throws when every authenticated account is spent. */
+-    getCompactionModel?(): Model<Api> | undefined;
++    /** Select a budget-fitting summary model; auto stays within the active provider and explicit failures never fall back. */
++    getCompactionModel?(inputTokens?: number): Model<Api> | undefined;
+     /**
+      * Longest a tool may block in the foreground before the active model's prompt
+      * cache expires, or `undefined` when no cache-derived budget applies. Reads the
+@@ -1162,6 +1177,7 @@
+     willRetry: boolean;
+ }
+ export interface SessionCompactRejectedEvent {
++    failure?: CompactionFailure;
+     type: "session_compact";
+     reason: CompactionReason;
+     requestId: string;
+@@ -1298,6 +1314,7 @@
+     model?: Model<Api>;
+     /** Final header transform output for this request. Values are never persisted. */
+     headers?: ProviderHeaders;
++    streamKind?: "main" | "auxiliary";
+ }
+ /**
+  * Fired after request headers are assembled, before the provider HTTP call.
+@@ -1833,6 +1850,7 @@
+     reason?: string;
+ }
+ export interface SessionBeforeCompactResult {
++    failure?: CompactionFailure;
+     cancel?: boolean;
+     compaction?: CompactionResult;
+     /**
+@@ -2685,7 +2703,7 @@
+     shutdown: () => void;
+     getContextUsage: () => ContextUsage | undefined;
+     getCompactionSettings: () => CompactionPreparation["settings"];
+-    getCompactionModel?: () => Model<Api> | undefined;
++    getCompactionModel?: (inputTokens?: number) => Model<Api> | undefined;
+     getPromptCacheSafeWaitSeconds?: () => number | undefined;
+     getPromptCacheGoalBackstopMaxSeconds?: () => number;
+     onUserActivity?: (listener: (kind: UserActivityKind) => void) => () => void;
+@@ -2850,4 +2868,4 @@
+     error: string;
+     stack?: string;
+ }
+-//# sourceMappingURL=types.d.ts.map
+
++//# sourceMappingURL=types.d.ts.map