zigmini 0.9.0-beta.2 → 1.0.0-beta.1

package/host/omo-check/patches/omo-5.1.51-compaction-recovery.patch

@@ -0,0 +1,911 @@
+--- a/@code-yeongyu/senpi/dist/core/agent-session.js
++++ b/@code-yeongyu/senpi/dist/core/agent-session.js
+@@ -43,7 +43,7 @@ import { executeBashWithOperations } from "./bash-executor.js";
+ 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 { compactionFailure, validateSummaryResponse, summaryUnavailable, summaryFailureDetails, noteSummaryUnavailable } 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";
+@@ -1042,6 +1042,11 @@ export class AgentSession {
+                     : "No usable compaction model within the active provider."),
+                 { failure: { kind, provider: model.provider, model: model.id } });
+         };
++        const admit = (model) => {
++            const unavailable = summaryUnavailable(this.sessionManager, model);
++            if (unavailable) throw Object.assign(new Error("Compaction summary provider unavailable"), { failure: { ...unavailable, inputTokens, inputTokensSource: "estimate", requestSent: false } });
++            return model;
++        };
+         const chat = this._modelRuntime.getModels();
+         const available = this._modelRuntime.getAvailableSnapshot();
+         const same = (left, right) => left.provider === right.provider && left.id === right.id;
+@@ -1065,7 +1070,7 @@ export class AgentSession {
+                 return fail("model_unavailable", configured);
+             if (!fits(configured))
+                 return fail("context_budget", configured);
+-            return configured;
++            return admit(configured);
+         }
+         if (this._retryFallback.isProviderSpent(sessionModel.provider))
+             return fail("quota");
+@@ -1078,7 +1083,7 @@ export class AgentSession {
+         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 admit(candidate);
+         }
+         return fail(usable(sessionModel) ? "context_budget" : "model_unavailable");
+     }
+@@ -1094,6 +1099,8 @@ export class AgentSession {
+         });
+     }
+     async _getCompactionRequestAuth(model, signal, callbacks) {
++        if (this._modelRuntime.couldRotateCredentials?.(model, { signal }))
++            return { model, thinkingLevel: this.thinkingLevel };
+         const prepared = await retryTransientCall(() => this._modelRuntime.prepareRequest(model, { signal }),
+             isOAuthRefreshUnavailableError, this.settingsManager.getRetrySettings(), signal,
+             callbacks ?? this._summarizationRetryCallbacks({ source: "compaction" }));
+@@ -1711,6 +1718,15 @@ export class AgentSession {
+         this._emitEntryAppended(entry.id);
+     }
+     _emit(event, captureSource = event) {
++        if (event.type === "compaction_end" && !event.aborted && (event.failure || event.errorMessage || event.accepted === false)) {
++            const failure = compactionFailure({ failure: event.failure }, this._activeCompactionModel ?? this.model);
++            const catalog = this._modelRuntime.getModels();
++            if (!catalog.some((model) => model.provider === failure.provider && model.id === failure.model)) {
++                delete failure.provider;
++                delete failure.model;
++            }
++            event = { ...event, failure, errorMessage: "Compaction failed; previous context retained" };
++        }
+         if (event.type === "session_paused" ||
+             event.type === "session_resumed" ||
+             event.type === "compaction_start" ||
+@@ -6903,18 +6919,34 @@ export class AgentSession {
+      * fits is allowed to carry the switch. The deterministic slice is the floor when
+      * summarization did not get there, so a repairable switch cannot strand itself.
+      */
++    _summaryUnavailableForSwitch() {
++        if (!this.model) return false;
++        try {
++            return summaryUnavailable(this.sessionManager, this._resolveCompactionModel(this.model)) !== undefined;
++        } catch (error) {
++            if (["quota", "account_blocked"].includes(error?.failure?.kind)) return true;
++            throw error;
++        }
++    }
+     async _applyPendingModelSwitch(assistantMessage, skipAbortedCheck, inlineReason) {
+         const pending = this._pendingModelSwitch;
+         if (pending === undefined)
+             return false;
+         if (!this.model)
+             throw new RequiredCompactionError();
+-        await this._runPrePromptCompaction(assistantMessage, skipAbortedCheck, inlineReason, false, false, pendingSwitchKeepRecentTokens(pending.projection));
++        if (skipAbortedCheck && assistantMessage?.stopReason === "aborted") return false;
++        const abortGeneration = this._userAbortGeneration;
+         let projection = this._projectSwitchFit(pending.model);
++        if (!projection.usable && !this._summaryUnavailableForSwitch()) {
++            await this._runPrePromptCompaction(assistantMessage, skipAbortedCheck, inlineReason, false, false, pendingSwitchKeepRecentTokens(pending.projection));
++            if (this._pendingModelSwitch !== pending || this._userAbortGeneration !== abortGeneration || this._lastPrePromptCompactionAborted) return false;
++            projection = this._projectSwitchFit(pending.model);
++        }
++        if (this._pendingModelSwitch !== pending) return false;
+         if (!projection.usable) {
+             const plan = planResumeSlice({ entries: this.sessionManager.getBranch(), projection });
+             if (plan) {
+-                this.applyResumeSlice(plan);
++                this.applyResumeSlice(plan, "explicit-model-switch");
+                 projection = this._projectSwitchFit(pending.model);
+             }
+         }
+@@ -6924,6 +6956,10 @@ export class AgentSession {
+             this._recordRejectedModelChange(pending.model, error);
+             throw error;
+         }
++        const hadActiveFallback = this._retryFallback.activeState !== undefined;
++        this._probeBackScheduler.cancel("manual-model-change");
++        this._retryFallback.clearForManualModelChange(pending.model);
++        if (hadActiveFallback && this._retryAbortController) this.abortRetry();
+         this._pendingModelSwitch = undefined;
+         try {
+             await this._switchActiveModel(pending.model, {
+@@ -6975,10 +7011,11 @@ export class AgentSession {
+         this._resumeCompactionRequirement = createResumeCompactionRequirement(projection);
+     }
+     /** Reduce an over-window restored context deterministically while the recorded transcript stays intact. */
+-    applyResumeSlice(plan) {
++    applyResumeSlice(plan, recoveryOrigin) {
+         this.sessionManager.appendCompaction(plan.summary, plan.firstKeptEntryId, plan.tokensBefore, {
+             schema: RESUME_SLICE_SCHEMA,
+             origin: RESUME_SLICE_ORIGIN,
++            ...(recoveryOrigin ? { recoveryOrigin, originalLeafId: this.sessionManager.getLeafId() } : {}),
+         });
+         this.agent.state.messages = this.sessionManager.buildSessionContext().messages;
+         this._resumeSlice = plan;
+@@ -7109,6 +7146,8 @@ export class AgentSession {
+         // surface its failure a whole message later.
+         if (deferral !== undefined) {
+             this._admitSwitchCompactionRequired(model, deferral, updateGlobalDefaults, origin);
++            if (this.isIdle && !this.isCompacting && this._summaryUnavailableForSwitch())
++                await this._applyPendingModelSwitch(undefined, false, "pre_prompt");
+             return undefined;
+         }
+         // A manual model change abandons any active fallback window; if a fallback
+@@ -7814,6 +7853,9 @@ export class AgentSession {
+             }
+         }
+         const checkedStream = async (model, context, options) => {
++            const unavailable = summaryUnavailable(this.sessionManager, model);
++            if (unavailable) throw Object.assign(new Error("Compaction summary provider unavailable"), { failure: { ...unavailable, requestSent: false } });
++            const inputTokens = estimateMessagesTokens(context.messages) + Math.ceil(JSON.stringify([context.systemPrompt, context.tools]).length / 4);
+             const stream = await this.agent.streamFunction(model, context, {
+                 ...options, refusalFallbacks: undefined, streamKind: "auxiliary",
+             });
+@@ -7821,7 +7863,13 @@ export class AgentSession {
+                 [Symbol.asyncIterator]: () => stream[Symbol.asyncIterator](),
+                 result: async () => {
+                     const response = await stream.result();
+-                    validateSummaryResponse(response);
++                    if (response?.stopReason === "error") {
++                        const failure = summaryFailureDetails(response, model, inputTokens);
++                        noteSummaryUnavailable(this.sessionManager, model, failure);
++                        throw Object.assign(new Error("Compaction summary failed"), { failure });
++                    }
++                    try { validateSummaryResponse(response); }
++                    catch (error) { error.failure = { ...summaryFailureDetails(response, model, inputTokens), kind: error.failure?.kind ?? "provider" }; throw error; }
+                     return response;
+                 },
+             };
+@@ -7916,7 +7964,7 @@ export class AgentSession {
+             }
+             const message = error instanceof Error ? error.message : String(error);
+             const aborted = isCompactionExecutionAborted(error);
+-            const errorMessage = aborted ? undefined : `Compaction failed: ${message}`;
++            const errorMessage = aborted ? undefined : "Compaction failed; previous context retained";
+             this._emit({
+                 type: "compaction_end",
+                 reason: "manual",
+@@ -7925,6 +7973,7 @@ export class AgentSession {
+                 willRetry: false,
+                 requestId,
+                 errorMessage,
++                failure: aborted ? undefined : compactionFailure(error, this._activeCompactionModel ?? this.model),
+             });
+             await this._emitSessionCompactFailed({
+                 reason: "manual",
+@@ -8006,7 +8055,8 @@ export class AgentSession {
+                 aborted,
+                 willRetry: false,
+                 requestId,
+-                errorMessage: aborted ? undefined : `Compaction failed: ${message}`,
++                errorMessage: aborted ? undefined : "Compaction failed; previous context retained",
++                failure: aborted ? undefined : compactionFailure(error, this._activeCompactionModel ?? this.model),
+             });
+             return { applied: false, reason: "rejected" };
+         }
+@@ -8076,6 +8126,7 @@ export class AgentSession {
+     }
+     async _executeCompaction(request) {
+         const model = this.model;
++        this._activeCompactionModel = model;
+         if (!model)
+             throw new Error(formatNoModelSelectedMessage());
+         const controller = request.controller;
+@@ -8152,8 +8203,20 @@ export class AgentSession {
+                         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);
++                    this._activeCompactionModel = compactionModel;
++                    let authReady = false;
++                    try {
++                        const { model: requestModel, apiKey, headers, extraBody, env, thinkingLevel, } = await this._getCompactionRequestAuth(compactionModel, signal, this._summarizationRetryCallbacks({ source: "compaction", reason: request.reason }));
++                        authReady = true;
++                        compactionResult = await this._runDefaultCompaction(preparation, requestModel, apiKey, headers, extraBody, request.customInstructions, signal, env, request.reason, thinkingLevel);
++                    } catch (error) {
++                        if (signal.aborted) throw error;
++                        const failure = compactionFailure(error, compactionModel);
++                        if (!failure.inputTokens) failure.inputTokens = inputTokens;
++                        if (!authReady) failure.requestSent = false;
++                        noteSummaryUnavailable(this.sessionManager, compactionModel, failure);
++                        throw Object.assign(error, { failure });
++                    }
+                     compactionResult.details = { ...compactionResult.details,
+                         selectionMode: settings.model === undefined || settings.model === "auto" ? "auto" : "explicit",
+                         requestedProvider: compactionModel.provider, requestedModel: compactionModel.id };
+@@ -8291,7 +8354,7 @@ export class AgentSession {
+             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));
++                    aborted ? undefined : "Compaction failed; previous context retained", aborted ? undefined : compactionFailure(error, this._activeCompactionModel ?? model));
+             throw new CompactionExecutionError(error, ownsTerminalTransition, aborted);
+         }
+         finally {
+@@ -8424,6 +8487,8 @@ export class AgentSession {
+      * deeper in compaction or the provider request.
+      */
+     async _assertModelReadyForTurn() {
++        if (this._pendingModelSwitch !== undefined && this._summaryUnavailableForSwitch())
++            await this._applyPendingModelSwitch(undefined, false, "pre_prompt");
+         if (!this.model) {
+             throw new ModelNotReadyError(formatNoModelSelectedMessage());
+         }
+@@ -8461,6 +8526,11 @@ export class AgentSession {
+      * @returns Whether the post-run loop should call `agent.continue()` for overflow recovery or queued messages
+      */
+     async _enforceCompactionBeforeProvider(assistantMessage, skipAbortedCheck, inlineReason, retryAfterCompaction = false) {
++        if (this._pendingModelSwitch !== undefined) {
++            const applied = await this._applyPendingModelSwitch(assistantMessage, skipAbortedCheck, inlineReason);
++            this._releaseBlockedPostCompactionAdmissionIfReduced();
++            return applied;
++        }
+         this._releaseBlockedPostCompactionAdmissionIfReduced();
+         const blockedAdmission = this._blockedPostCompactionAssistant;
+         if (blockedAdmission !== undefined && blockedAdmission.assistant === assistantMessage) {
+@@ -8468,9 +8538,6 @@ export class AgentSession {
+         }
+         const settings = this._getCompactionSettings();
+         const model = this.model;
+-        if (this._pendingModelSwitch !== undefined) {
+-            return await this._applyPendingModelSwitch(assistantMessage, skipAbortedCheck, inlineReason);
+-        }
+         if (this._resumeCompactionRequirement !== undefined) {
+             if (!model)
+                 throw new RequiredCompactionError();
+@@ -8854,6 +8921,7 @@ export class AgentSession {
+         // The flag reports THIS attempt's "nothing to compact" outcome only; a value left by an earlier attempt
+         // must not make a caller treat a cancelled or rejected compaction as too small (senpi#2925 review).
+         this._compactionSkippedTooSmall = false;
++        this._lastPrePromptCompactionAborted = false;
+         if (isAutomaticCompactionBlocked(this.sessionManager.getBranch(), this.model, this._getCompactionSettings())) {
+             return false;
+         }
+@@ -8883,9 +8951,11 @@ export class AgentSession {
+                 isContextOverflow(lastAssistantMessage, this.model?.contextWindow ?? 0)) {
+                 this._overflowRecoveryRungs = 0;
+             }
++            this._lastPrePromptCompactionAborted = controller.signal.aborted || execution.aborted || ["stale-revision", "external-owner"].includes(execution.rejectionCause);
+             return execution.accepted;
+         }
+         catch (error) {
++            this._lastPrePromptCompactionAborted = isCompactionExecutionAborted(error) || !compactionExecutionOwnsTerminalTransition(error);
+             if (!compactionExecutionOwnsTerminalTransition(error)) {
+                 return false;
+             }
+@@ -8902,7 +8972,8 @@ export class AgentSession {
+                 aborted,
+                 willRetry: false,
+                 requestId,
+-                errorMessage: aborted ? undefined : `Pre-prompt compaction failed: ${errorMessage}`,
++                errorMessage: aborted ? undefined : "Compaction failed; previous context retained",
++                failure: aborted ? undefined : compactionFailure(error, this._activeCompactionModel ?? this.model),
+             });
+             return false;
+         }
+@@ -9552,6 +9623,7 @@ export class AgentSession {
+         }, {
+             offload: (id, args, options) => offload(this._toolDispatcher, this._extensionRunner.getAllChildModules(), id, args, options),
+             getModel: () => this.model,
++            getModelSwitchState: () => ({ current: this.model, pending: this._pendingModelSwitch?.model }),
+             getServiceTier: () => this.serviceTier,
+             getEffectiveServiceTier: () => this.effectiveServiceTier,
+             getScopedModels: () => this._scopedModels,
+@@ -9700,7 +9772,8 @@ export class AgentSession {
+                             aborted,
+                             willRetry: false,
+                             requestId,
+-                            errorMessage: aborted ? undefined : `Compaction failed: ${message}`,
++                            errorMessage: aborted ? undefined : "Compaction failed; previous context retained",
++                failure: aborted ? undefined : compactionFailure(error, this._activeCompactionModel ?? this.model),
+                         });
+                         const err = error instanceof Error ? error : new Error(String(error));
+                         options?.onError?.(err);
+--- a/@code-yeongyu/senpi/dist/core/extensions/builtin/anthropic-subscription/stream.js
++++ b/@code-yeongyu/senpi/dist/core/extensions/builtin/anthropic-subscription/stream.js
+@@ -1,6 +1,7 @@
+ import { createAssistantMessageDiagnostic, createAssistantMessageEventStream, } from "@earendil-works/pi-ai";
+ import { getSessionClaudeAccountPin } from "./account-command.js";
+ import { queryWithAuthLane } from "./auth-lane.js";
++import { AllAccountsBlockedError } from "./affinity.js";
+ import { markColdSeedOverflow } from "./cold-seed-budget.js";
+ import { buildCustomToolServers } from "./custom-tools.js";
+ import { sdkAssistantFailure, sdkResultFailure, sdkResultFailureUsage } from "./errors.js";
+@@ -166,6 +167,7 @@ export function streamAnthropicSubscription(model, context, options) {
+                     buildOptions,
+                 });
+             for await (const message of messages) {
++                if (message.type === "assistant" || message.type === "result" || message.type === "stream_event") output.requestSent = true;
+                 const refusal = refusalError(message);
+                 if (refusal)
+                     throw refusal;
+@@ -265,6 +267,14 @@ export function streamAnthropicSubscription(model, context, options) {
+             if (billed)
+                 updateUsage(model, output, billed, "query");
+             output.errorMessage = withAuthGuidance(error, errorMessage(error), claudeCodeRun);
++            if (error instanceof AllAccountsBlockedError) {
++                output.failure = { kind: "account_blocked",
++                    ...(Number.isFinite(error.soonestUnblockAt) ? { retryAt: error.soonestUnblockAt } : {}),
++                    ...(output.requestSent === true ? { requestSent: true } : sdkQuery === undefined ? { requestSent: false } : {}) };
++            }
++            if (error?.name === "AccountUsageLimitError" || error?.errorCause?.type === "usage_limit") {
++                output.failure = { kind: "quota", ...(Number.isFinite(error.retryAt) ? { retryAt: error.retryAt } : {}) };
++            }
+             markColdSeedOverflow(output, model, coldSeedAttempt, coldSeedEstimate, options?.sessionId);
+             stream.push({ type: "error", reason: output.stopReason, error: output });
+         }
+--- 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
+@@ -1,3 +1,4 @@
++import { buildSessionContext, getSessionContextEntryId } from "../../../session-manager.js";
+ import { buildCompactionContext } from "./context-pipeline.js";
+ import { createReductionHandoff } from "./context-reduction-handoff.js";
+ import { CONTEXT_REDUCTION_ENTRY_TYPE, clearReductionAnchor, createContextReductionState, readContextReductionState, recordReductionUsage, snapshotReductionState, } from "./context-reduction-state.js";
+@@ -63,7 +64,7 @@ export function registerContextReductionLifecycle(pi, options) {
+         pending = undefined;
+         persist(before);
+     });
+-    pi.on("context", (event, ctx) => {
++    pi.on("context", async (event, ctx) => {
+         restore(ctx);
+         // The journal may not yet contain the current user/tool message.
+         // The dispatcher, not transcript equality, owns request provenance.
+@@ -78,6 +79,7 @@ export function registerContextReductionLifecycle(pi, options) {
+         const contextWindow = usage?.contextWindow ?? ctx.model?.contextWindow ?? 200_000;
+         const settings = ctx.getCompactionSettings();
+         const policy = options.getPolicy(ctx);
++        const automatic = settings.enabled !== false && !options.isSummaryUnavailable?.(ctx);
+         const overheadTokens = estimateTotalTokens([
+             { role: "user", content: `${ctx.getSystemPrompt()}\n${JSON.stringify(options.getTools())}`, timestamp: 0 },
+         ]);
+@@ -94,21 +96,22 @@ export function registerContextReductionLifecycle(pi, options) {
+             usage.tokens >= contextWindow * computeEffectiveThreshold(contextWindow, policy.lastYield);
+         if (breakerFallback)
+             options.logBreakerFallback(ctx, usage.tokens ?? 0);
+-        const messages = buildCompactionContext({
++        const buildInput = {
+             event,
+             ctx,
+             contextWindow,
+             promptContextWindow,
+             contextReductionState: working,
+             contextOverheadTokens: overheadTokens,
+-            reductionCeilingTokens: Math.min(promptContextWindow, contextWindow - reserveTokens, thresholdTokens),
++            reductionCeilingTokens: Math.min(promptContextWindow, contextWindow - reserveTokens, automatic ? thresholdTokens : Infinity),
+             toolAdmissionEnabled: settings.toolAdmissionEnabled !== false,
+             breakerFallback,
+             laneOwnsCompaction: policy.laneOwnsCompaction,
+             appendOnlyTranscript: policy.appendOnlyTranscript,
+             emergencyPruneLatch: live ? options.emergencyPruneLatch : { ...options.emergencyPruneLatch },
+             logEmergencyPrune: (fields) => options.logEmergencyPrune(ctx, fields),
+-        });
++        };
++        let messages = buildCompactionContext(buildInput);
+         const managed = !policy.laneOwnsCompaction;
+         if (!live)
+             return { messages };
+@@ -116,6 +119,21 @@ export function registerContextReductionLifecycle(pi, options) {
+             pending = undefined;
+             return { messages };
+         }
++        if (state.compactionRequired && !automatic && options.reduceContext) {
++            const ids = new Set(ctx.sessionManager.getBranch().map((entry) => entry.id));
++            const additions = event.messages.filter((message) => !ids.has(getSessionContextEntryId(message)));
++            const result = await options.reduceContext(ctx, estimateTotalTokens(additions));
++            if (!result.applied) {
++                ctx.abort("system");
++                return { messages };
++            }
++            messages = buildCompactionContext({ ...buildInput, contextReductionState: state,
++                event: { ...event, messages: [...buildSessionContext(ctx.sessionManager.getBranch()).messages, ...additions] } });
++            if (state.compactionRequired) {
++                ctx.abort("system");
++                return { messages };
++            }
++        }
+         if (state.compactionRequired) {
+             pending = undefined;
+             persist(before);
+--- a/@code-yeongyu/senpi/dist/core/extensions/builtin/compaction/index.js
++++ b/@code-yeongyu/senpi/dist/core/extensions/builtin/compaction/index.js
+@@ -14,7 +14,9 @@ import * as cap from "./per-turn-cap.js";
+ 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, compactionFailure, } from "./speculative.js";
++import { applyGeneratedCompaction, createEmergencyPruneLatch, createSpeculativeCompactionSnapshot, getPromptVariant, runExtensionCompaction, SummaryGenerationError, compactionFailure, canStartSummary, summaryUnavailable, } from "./speculative.js";
++import { planResumeSlice } from "./resume-slice.js";
++import { projectModelUsabilityBudget } from "./model-usability-budget.js";
+ import { trackSpeculativeJob } from "./speculative-job.js";
+ import { createInitialState, resetTurnCounter } from "./state.js";
+ import { resolveInheritedTaskIntent } from "./task-intent.js";
+@@ -121,6 +123,8 @@ export default function compactionExtension(pi, remoteCompactionDependencies = {
+                 return;
+             if (isContextRetired(ctx))
+                 return;
++            if (ctx.getCompactionSettings().enabled === false)
++                return;
+             if (!ctx.isIdle())
+                 return;
+             if (lanePolicy.disablesSenpiCompaction(ctx))
+@@ -188,19 +192,22 @@ export default function compactionExtension(pi, remoteCompactionDependencies = {
+         speculativeJob = undefined;
+     }
+     function startSpeculativeCompaction(ctx, customInstructions) {
++        if (ctx.getCompactionSettings().enabled === false)
++            return;
+         if (speculativeJob)
+             return;
+         if (isAutomaticCompactionBlocked(ctx.sessionManager.getBranch(), ctx.model, ctx.getCompactionSettings()))
+             return;
+-        const generation = ++speculativeGeneration;
++        const generation = speculativeGeneration + 1;
+         const snapshot = createSpeculativeCompactionSnapshot(ctx, {
+             generation,
+             customInstructions,
+             origin: "speculative",
+             tools: getSummarizationTools(),
+         });
+-        if (!snapshot)
++        if (!snapshot || !canStartSummary(ctx, snapshot))
+             return;
++        speculativeGeneration = generation;
+         getLogger(ctx).debug("speculative_started", { generation, origin: "speculative" });
+         const controller = new AbortController();
+         const settled = generateCompaction(ctx, snapshot, controller.signal).then((result) => ({ result, error: undefined }), (error) => ({ result: undefined, error: error instanceof Error ? error : new Error(String(error)) }));
+@@ -236,9 +243,43 @@ export default function compactionExtension(pi, remoteCompactionDependencies = {
+     async function generateCompaction(ctx, snapshot, signal, onProgress) {
+         return await runExtensionCompaction(ctx, snapshot, signal, onProgress);
+     }
+-    async function applyBlockingCompaction(ctx, customInstructions) {
++    function summaryIsUnavailable(ctx) {
++        try {
++            return summaryUnavailable(ctx.sessionManager, ctx.getCompactionModel?.() ?? ctx.model) !== undefined;
++        }
++        catch (error) {
++            if (error?.failure?.kind === "quota" || error?.failure?.kind === "account_blocked")
++                return true;
++            throw error;
++        }
++    }
++    function deterministicCompaction(ctx, pendingTokens = 0) {
++        const entries = ctx.sessionManager.getBranch();
++        const projection = projectModelUsabilityBudget({
++            model: ctx.model,
++            liveContextTokens: ctx.getContextUsage()?.tokens ?? 0,
++            systemPrompt: ctx.getSystemPrompt(), tools: getSummarizationTools(),
++            compaction: { ...ctx.getCompactionSettings(), enabled: true, speculativeEnabled: false },
++            includeSpeculationLead: false,
++        });
++        projection.safetyMarginTokens += pendingTokens;
++        const plan = planResumeSlice({ entries, projection });
++        if (!plan)
++            throw new SummaryGenerationError("context_budget", "No replay-safe context suffix fits the request budget");
++        return { ...plan, details: { schema: "senpi.compaction.resume-slice.v1", recoveryOrigin: "turn-start",
++            originalLeafId: ctx.sessionManager.getLeafId() } };
++    }
++    async function applyBlockingCompaction(ctx, customInstructions, pendingTokens = 0) {
+         const feedbackSignal = ctx.beginCompaction?.({ reason: "extension" });
+         try {
++            if (ctx.getCompactionSettings().enabled === false || summaryIsUnavailable(ctx)) {
++                invalidateSpeculativeCompaction(ctx);
++                const result = await ctx.applyCompaction(deterministicCompaction(ctx, pendingTokens), {
++                    reason: "extension", blocking: true, expectedRevision: ctx.getMessageRevision(), signal: feedbackSignal,
++                });
++                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");
+@@ -306,6 +347,8 @@ export default function compactionExtension(pi, remoteCompactionDependencies = {
+             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);
++            if (event.reason !== "manual" && (ctx.getCompactionSettings().enabled === false || summaryIsUnavailable(ctx)))
++                return { compaction: deterministicCompaction(ctx) };
+             const model = ctx.model;
+             if (!model)
+                 throw new SummaryGenerationError("model_unavailable", "Compaction model unavailable");
+@@ -436,7 +479,7 @@ export default function compactionExtension(pi, remoteCompactionDependencies = {
+         // The SDK owns this lane's context entirely, so even the hard-limit valve stands down;
+         // the circuit breaker never blocks that valve for senpi-owned lanes.
+         const laneOwnsCompaction = lanePolicy.disablesSenpiCompaction(ctx);
+-        const breakerCoolingDown = breaker.isTripped(state, Date.now()) || laneOwnsCompaction;
++        const breakerCoolingDown = breaker.isTripped(state, Date.now()) || laneOwnsCompaction || settings.enabled === false || summaryIsUnavailable(ctx);
+         const { reserveTokens, thresholdTokens, leadTokens } = resolveCompactionGeometry({
+             contextWindow,
+             settings,
+@@ -450,7 +493,7 @@ export default function compactionExtension(pi, remoteCompactionDependencies = {
+                 tokens: usage.tokens ?? 0,
+                 threshold: settings.reserveTokens,
+             });
+-            const result = await applyBlockingCompaction(ctx, EMERGENCY_COMPACTION_INSTRUCTIONS);
++            const result = await applyBlockingCompaction(ctx, EMERGENCY_COMPACTION_INSTRUCTIONS, pendingPromptTokens);
+             if (!result.applied) { ctx.abort("system"); return; }
+         }
+         else if (!breakerCoolingDown &&
+@@ -512,6 +555,8 @@ export default function compactionExtension(pi, remoteCompactionDependencies = {
+     pi.on("before_agent_start", onBeforeAgentStart, { previewSafe: true });
+     const contextReduction = registerContextReductionLifecycle(pi, {
+         emergencyPruneLatch,
++        isSummaryUnavailable: summaryIsUnavailable,
++        reduceContext: (ctx, pendingTokens) => applyBlockingCompaction(ctx, EMERGENCY_COMPACTION_INSTRUCTIONS, pendingTokens),
+         emergencyInstructions: EMERGENCY_COMPACTION_INSTRUCTIONS,
+         getTools: getSummarizationTools,
+         getPolicy: (ctx) => ({
+@@ -545,7 +590,7 @@ export default function compactionExtension(pi, remoteCompactionDependencies = {
+     });
+     pi.on("turn_end", async (_event, ctx) => {
+         try {
+-            if (lanePolicy.disablesSenpiCompaction(ctx))
++            if (lanePolicy.disablesSenpiCompaction(ctx) || ctx.getCompactionSettings().enabled === false)
+                 return;
+             handleTurnEnd(degradationState);
+             if (degradationState.recoveryTriggeredThisCycle)
+@@ -560,7 +605,7 @@ export default function compactionExtension(pi, remoteCompactionDependencies = {
+     });
+     pi.on("agent_end", async (event, ctx) => {
+         state = resetTurnCounter(state, "");
+-        if (lanePolicy.disablesSenpiCompaction(ctx))
++        if (lanePolicy.disablesSenpiCompaction(ctx) || ctx.getCompactionSettings().enabled === false)
+             return;
+         const usage = ctx.getContextUsage();
+         const contextWindow = usage?.contextWindow ?? ctx.model?.contextWindow ?? DEFAULT_CONTEXT_WINDOW;
+@@ -615,7 +660,7 @@ export default function compactionExtension(pi, remoteCompactionDependencies = {
+         if (isAbortedAssistantMessage(event)) {
+             invalidateSpeculativeCompaction(ctx);
+         }
+-        if (isMonitorableMessageEvent(event) && !lanePolicy.disablesSenpiCompaction(ctx)) {
++        if (ctx.getCompactionSettings().enabled !== false && isMonitorableMessageEvent(event) && !lanePolicy.disablesSenpiCompaction(ctx)) {
+             await handleMessageEnd(degradationState, event, {
+                 applyCompaction: async (options) => {
+                     return await applyBlockingCompaction(ctx, options.customInstructions);
+--- a/@code-yeongyu/senpi/dist/core/extensions/builtin/compaction/speculative-summary.js
++++ b/@code-yeongyu/senpi/dist/core/extensions/builtin/compaction/speculative-summary.js
+@@ -83,6 +83,8 @@ export async function generateSummaryMessage(options) {
+     // Request-local controller: the idle watchdog must be able to tear down a
+     // stalled summarization request without aborting the caller's own signal.
+     const requestController = new AbortController();
++    let requestSent;
++    let requestInputTokens;
+     const onCallerAbort = () => requestController.abort(options.signal?.reason);
+     if (options.signal) {
+         if (options.signal.aborted)
+@@ -112,9 +114,10 @@ export async function generateSummaryMessage(options) {
+             { role: "user", content: requestContext.systemPrompt },
+             { role: "user", content: JSON.stringify(requestContext.tools ?? []) },
+         ]);
++        requestInputTokens = inputTokens;
+         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 } });
++                { failure: { kind: "context_budget", provider: options.snapshot.model.provider, model: options.snapshot.model.id, error: "Compaction request exceeds the selected model context budget", inputTokens, inputTokensSource: "estimate", requestSent: false } });
+         }
+         const headers = providerRequest
+             ? await providerRequest.transformHeaders(options.auth.headers ?? {})
+@@ -126,6 +129,7 @@ export async function generateSummaryMessage(options) {
+             env: options.auth.env,
+             cwd: options.context.cwd,
+             streamKind: "auxiliary",
++            onResponse: () => { requestSent = true; },
+             onPayload: async (payload, model) => {
+                 const sanitized = model.api === "anthropic-messages" ? sanitizeAnthropicPayload(payload) : payload;
+                 return providerRequest ? await providerRequest.transformPayload(sanitized) : sanitized;
+@@ -137,7 +141,7 @@ export async function generateSummaryMessage(options) {
+         });
+         // Settlement rides inside the watchdog: a provider whose iterator ends
+         // without a terminal event used to park here with every timer cleared.
+-        return await consumeStreamWithIdleTimeout(responseStream, {
++        const response = await consumeStreamWithIdleTimeout(responseStream, {
+             idleTimeoutMs: DEFAULT_SUMMARIZATION_IDLE_TIMEOUT_MS,
+             maxDurationMs,
+             abort: () => requestController.abort(),
+@@ -149,6 +153,17 @@ export async function generateSummaryMessage(options) {
+             },
+             settle: async () => await responseStream.result(),
+         });
++        if (response) {
++            response.failure = { ...response.failure, inputTokens, inputTokensSource: "estimate",
++                ...(requestSent === true ? { requestSent: true } : {}) };
++        }
++        return response;
++    }
++    catch (error) {
++        error.failure = { ...error.failure, provider: options.snapshot.model.provider, model: options.snapshot.model.id,
++            ...(requestInputTokens === undefined ? {} : { inputTokens: requestInputTokens, inputTokensSource: "estimate" }),
++            ...(requestSent === true ? { requestSent: true } : {}) };
++        throw error;
+     }
+     finally {
+         if (options.signal)
+--- a/@code-yeongyu/senpi/dist/core/extensions/builtin/compaction/speculative.js
++++ b/@code-yeongyu/senpi/dist/core/extensions/builtin/compaction/speculative.js
+@@ -13,6 +13,76 @@ import { allowSummarizationRetry, DEFAULT_SUMMARIZATION_RETRY_POLICY } from "./s
+ import { extractTaskIntent, resolveInheritedTaskIntent, taskIntentSummary, taskIntentMetadata } from "./task-intent.js";
+ export { createEmergencyPruneLatch, hardLimitEmergencyPrune, truncateContextMessages, } from "./emergency-prune.js";
+ import { computeStructuralYield } from "./yield.js";
++import { usageLimitResetMs } from "../../../credential-pool/reset-time.js";
++import { homedir } from "node:os";
++// Availability belongs to the session, not a speculative generation. Stable session files
++// retain it through extension reloads; fixture-only managers use their object identity.
++const summaryAvailability = new Map();
++function summaryBlocks(manager) {
++    const key = manager.getSessionFile?.() ?? manager.getSessionId?.() ?? manager;
++    let blocks = summaryAvailability.get(key);
++    if (!blocks) summaryAvailability.set(key, blocks = new Map());
++    return blocks;
++}
++export function summaryUnavailable(manager, model, now = Date.now()) {
++    if (!model) return undefined;
++    const key = model.provider + "/" + model.id;
++    const failure = summaryBlocks(manager).get(key);
++    if (!failure || now >= failure.retryAt) return undefined;
++    return failure;
++}
++export function noteSummaryUnavailable(manager, model, failure, now = Date.now()) {
++    if (failure.kind !== "quota" && failure.kind !== "account_blocked") return;
++    const retryAt = failure.retryAt ?? now + 30 * 60_000;
++    summaryBlocks(manager).set(model.provider + "/" + model.id, { ...failure, retryAt });
++}
++export function sanitizeSummaryDiagnostic(value) {
++    if (typeof value !== "string") return "Compaction provider failed";
++    // Read only the provider's message, never nested errors, payloads, or stacks.
++    const body = /(?:\r?\n\s*at\s+|\b(?:request[ _-]?body|response[ _-]?body|request[ _-]?payload|response[ _-]?payload|prompt|summary|conversation)\s*[:=])/i.exec(value);
++    let text = body ? value.slice(0, body.index) + "[redacted]" : value;
++    text = text.replace(/-----BEGIN [^-]*PRIVATE KEY-----[\s\S]*?(?:-----END [^-]*PRIVATE KEY-----|$)/g, "[redacted]")
++        .replace(/(\bauthorization\b\s*[:=]\s*)(?:"[^"]*"|'[^']*'|[^\r\n,;]+)/gi, "$1[redacted]")
++        .replace(/\b(?:Bearer|Basic)\s+[^\s"'<>]+/gi, "[redacted]")
++        .replace(/(\b(?:api[_-]?key|access[_-]?token|refresh[_-]?token|token|password|secret)\b\s*[:=]\s*)(?:"[^"]*"|'[^']*'|[^\s,;]+)/gi, "$1[redacted]")
++        .replace(/\bsk-[A-Za-z0-9_-]+\b/g, "[redacted]")
++        .replace(/\b[A-Za-z0-9_-]{6,}\.[A-Za-z0-9_-]{6,}\.[A-Za-z0-9_-]{6,}\b/g, "[redacted]")
++        .replace(/\b(?:eyJ[A-Za-z0-9_-]*|e30)\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]*(?=$|[^A-Za-z0-9_-])/g, "[redacted]")
++        .replace(/\/(?:Users|home)\/[^/\s"']+(?=\/|\s|$)/g, "~")
++        .split(homedir()).join("~")
++        .replace(/(?<![A-Za-z0-9+/_-])[A-Za-z0-9+/_-]{24,}={0,2}/g, "[redacted]")
++        .replace(/[A-Z0-9.!#$%&'*+/=?^_\x60{|}~-]+@[A-Z0-9.-]+\.[A-Z]{2,}/gi, "[redacted]")
++        .replace(/(https?:\/\/)[^/@\s]+:[^/@\s]+@/gi, "$1[redacted]@")
++        .replace(/(https?:\/\/[^\s?"'<>]+)\?[^\s"'<>]*/gi, "$1")
++        .replace(/(\baccount(?:[ _-]?(?:name|id))?\s*(?:[:=]\s*)?)(?:'[^']*'|"[^"]*")/gi, "$1[redacted]")
++        .replace(/(\baccount[ _-]?(?:name|id)\s*[:=]\s*)[^\s,;]+/gi, "$1[redacted]");
++    return text.slice(0, 512);
++}
++const WITHHELD = "Compaction provider failed";
++const CHATGPT_LIMIT = "You have hit your ChatGPT usage limit.";
++const POOL_REFUSAL = "No request was sent: the account pool refused it locally.";
++const LOCAL_BUDGET = "Compaction request exceeds the selected model context budget";
++export function summaryFailureDetails(value, model, inputTokens = 0) {
++    const message = value?.errorMessage ?? value?.message ?? "";
++    const pool = value?.name === "AllAccountsBlockedError" ||
++        (model?.provider === "anthropic-subscription" && message.includes(POOL_REFUSAL));
++    const chatgpt = model?.provider === "chatgpt-subscription" && message.startsWith("You have hit your ChatGPT usage limit");
++    const kind = pool ? "account_blocked" : chatgpt || value?.name === "AccountUsageLimitError" || value?.errorCause?.type === "usage_limit" ? "quota" : value?.failure?.kind ?? value?.kind;
++    const reset = (pool || chatgpt || kind === "quota") ? usageLimitResetMs(message, Date.now()) : undefined;
++    const retryAt = value?.failure?.retryAt ?? value?.retryAt ?? value?.soonestUnblockAt ?? (reset === undefined ? undefined : Date.now() + reset);
++    const usage = value?.usage?.contextUsage;
++    const measured = typeof usage?.input === "number" && Number.isFinite(usage.input) && usage.input >= 0;
++    return {
++        kind: kind ?? "provider",
++        ...(model ? { provider: model.provider, model: model.id } : {}),
++        error: sanitizeSummaryDiagnostic(message || value?.failure?.error || WITHHELD),
++        inputTokens: measured ? usage.input : value?.failure?.inputTokens ?? inputTokens,
++        inputTokensSource: measured ? "provider" : "estimate",
++        ...(typeof value?.failure?.requestSent === "boolean" ? { requestSent: value.failure.requestSent }
++            : typeof value?.requestSent === "boolean" ? { requestSent: value.requestSent } : {}),
++        ...(Number.isFinite(retryAt) ? { retryAt } : {}),
++    };
++}
+ const DEFAULT_CONTEXT_WINDOW = 200_000;
+ // Hysteresis: the emergency prune engages at EMERGENCY_CONTEXT_TARGET_RATIO but only
+ // releases once the context falls below this lower ratio. A single threshold makes a
+@@ -34,14 +104,22 @@ export class SummaryRequestError extends Error {
+     }
+ }
+ 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"];
++    const details = error?.failure ?? summaryFailureDetails(error, model);
++    const kind = error?.refused ? "refused" : details.kind;
++    const known = ["invalid_model", "auth_missing", "auth_expired", "quota", "account_blocked", "org_denied", "model_unavailable", "refused", "timeout", "incomplete", "empty", "context_budget", "stale", "provider"];
++    const diagnostic = sanitizeSummaryDiagnostic(details.error ?? error?.message ?? WITHHELD);
+     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 } : {}) };
++        ...(details.provider ? { provider: details.provider } : {}),
++        ...(details.model ? { model: details.model } : {}),
++        error: diagnostic,
++        inputTokens: Number.isFinite(details.inputTokens) && details.inputTokens >= 0 ? details.inputTokens : 0,
++        inputTokensSource: details.inputTokensSource === "provider" ? "provider" : "estimate",
++        ...(typeof details.requestSent === "boolean" ? { requestSent: details.requestSent } : {}),
++        ...(Number.isFinite(details.retryAt) ? { retryAt: details.retryAt } : {}),
++    };
+ }
+ export function validateSummaryResponse(response) {
+     if (response && isRefusalStop(response))
+@@ -80,11 +158,11 @@ function isRetryableSummaryAttempt(error) {
+ function isRefusalStop(response) {
+     return response.stopDetails?.type === "refusal" || response.stopDetails?.type === "sensitive";
+ }
+-function summaryRequestFailureKind(response) {
++function summaryRequestFailureKind(response, model) {
+     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))
++    const kind = summaryFailureDetails(response, model).kind;
++    if (["auth_missing", "auth_expired", "quota", "account_blocked", "org_denied", "model_unavailable", "timeout", "incomplete", "context_budget"].includes(kind))
+         return kind;
+     return UPSTREAM_STREAM_TRUNCATED_PATTERN.test(response.errorMessage ?? "") ? "upstream-stream-truncated" : undefined;
+ }
+@@ -148,9 +226,7 @@ export function createSpeculativeCompactionSnapshot(context, options) {
+  * before and after credential resolution so a cancelled request never
+  * misreports as an auth failure.
+  */
+-export async function runExtensionCompaction(context, snapshot, signal, onProgress) {
+-    if (signal?.aborted)
+-        return undefined;
++export function selectSummaryModel(context, snapshot) {
+     const prompt = buildPrompt({
+         variant: snapshot.promptVariant,
+         previousSummary: snapshot.preparation.previousSummary,
+@@ -165,11 +241,33 @@ export async function runExtensionCompaction(context, snapshot, signal, onProgre
+         { role: "user", content: JSON.stringify(snapshot.tools ?? []) },
+     ]);
+     const selectedModel = context.getCompactionModel?.(inputTokens) ?? snapshot.model;
++    return { prompt, messages, inputTokens, selectedModel };
++}
++export function canStartSummary(context, snapshot) {
++    try {
++        const { selectedModel } = selectSummaryModel(context, snapshot);
++        return !summaryUnavailable(context.sessionManager, selectedModel);
++    } catch (error) {
++        if (["quota", "account_blocked"].includes(error?.failure?.kind)) return false;
++        return true;
++    }
++}
++export async function runExtensionCompaction(context, snapshot, signal, onProgress) {
++    if (signal?.aborted)
++        return undefined;
++    const { prompt, messages, inputTokens, selectedModel } = selectSummaryModel(context, snapshot);
++    const unavailable = summaryUnavailable(context.sessionManager, selectedModel);
++    if (unavailable) throw Object.assign(new SummaryGenerationError(unavailable.kind, "Compaction summary provider unavailable"), { failure: { ...unavailable, inputTokens, inputTokensSource: "estimate", requestSent: false } });
+     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) {
++        if (runtime?.couldRotateCredentials?.(selectedModel, { signal })) {
++            // Let the runtime select and authenticate a healthy slot. A resolved OAuth
++            // token here would become an explicit request key and disable rotation.
++            auth = { ok: true, ambient: true };
++        }
++        else if (runtime) {
+             const prepared = await runtime.prepareRequest(selectedModel, { signal });
+             auth = { ok: true, ...prepared.options, baseUrl: prepared.model.baseUrl, ambient: true };
+         }
+@@ -180,16 +278,17 @@ export async function runExtensionCompaction(context, snapshot, signal, onProgre
+     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 };
++        const details = summaryFailureDetails(error, selectedModel, inputTokens);
++        const kind = details.kind;
++        const known = ["auth_missing", "auth_expired", "quota", "account_blocked", "org_denied", "model_unavailable"];
++        const failure = { ...details, kind: kind === "auth" ? "auth_missing" : known.includes(kind) ? kind : "provider", requestSent: false };
++        noteSummaryUnavailable(context.sessionManager, selectedModel, failure);
+         throw Object.assign(new SummaryGenerationError(failure.kind, "Compaction request authentication failed"), { failure, cause: error });
+     }
+     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 };
++        const failure = { ...summaryFailureDetails(undefined, selectedModel, inputTokens), kind: "auth_missing", requestSent: false };
+         throw Object.assign(new SummaryGenerationError(failure.kind, "Compaction request authentication unavailable"), { failure });
+     }
+     const requestSnapshot = auth.baseUrl
+@@ -222,6 +321,8 @@ export async function runExtensionCompaction(context, snapshot, signal, onProgre
+             // surrounding loop keeps overflow shrinking and abort handling, which
+             // must never be answered by replaying the same request.
+             response = await retryTransientCall(async () => {
++                const blocked = summaryUnavailable(context.sessionManager, selectedModel);
++                if (blocked) throw Object.assign(new SummaryGenerationError(blocked.kind, "Compaction summary provider unavailable"), { failure: { ...blocked, inputTokens, inputTokensSource: "estimate", requestSent: false } });
+                 const attempt = await generateSummaryMessage({
+                     context,
+                     forbidToolCalls: true,
+@@ -244,8 +345,10 @@ export async function runExtensionCompaction(context, snapshot, signal, onProgre
+                     isAssistantMessage(attempt) &&
+                     (attempt.stopReason === "error" || isRefusalStop(attempt)) &&
+                     !isContextOverflow(attempt, requestSnapshot.contextWindow)) {
+-                    const failureKind = summaryRequestFailureKind(attempt);
+-                    throw new SummaryRequestError(attempt.errorMessage || "Compaction summary request failed", attempt.content.length === 0 && failureKind === undefined && isRetryableAssistantError(attempt), failureKind, isRefusalStop(attempt));
++                    const failureKind = summaryRequestFailureKind(attempt, selectedModel);
++                    const error = new SummaryRequestError(attempt.errorMessage || "Compaction summary request failed", attempt.content.length === 0 && failureKind === undefined && isRetryableAssistantError(attempt), failureKind, isRefusalStop(attempt));
++                    error.failure = { ...summaryFailureDetails(attempt, selectedModel, inputTokens), kind: error.failure.kind };
++                    throw error;
+                 }
+                 return attempt;
+             }, (error) => retryEligible &&
+@@ -256,15 +359,23 @@ export async function runExtensionCompaction(context, snapshot, signal, onProgre
+         catch (error) {
+             if (signal?.aborted)
+                 return undefined;
++            error.failure = compactionFailure(error, selectedModel);
++            if (!error.failure.inputTokens) error.failure.inputTokens = inputTokens;
++            noteSummaryUnavailable(context.sessionManager, selectedModel, error.failure);
+             throw error;
+         }
+         if (!response && signal?.aborted)
+             return undefined;
+         if (response && isAssistantMessage(response) && isContextOverflow(response, requestSnapshot.contextWindow)) {
+-            const failure = { kind: "context_budget", provider: selectedModel.provider, model: selectedModel.id };
++            const failure = { ...summaryFailureDetails(response, selectedModel, inputTokens), kind: "context_budget" };
+             throw Object.assign(new SummaryGenerationError(failure.kind, "Compaction input exceeds the provider context budget"), { failure });
+         }
+-        const parsedSummary = validateSummaryResponse(response);
++        let parsedSummary;
++        try { parsedSummary = validateSummaryResponse(response); }
++        catch (error) {
++            error.failure = { ...summaryFailureDetails(response, selectedModel, inputTokens), kind: error.failure?.kind ?? "provider" };
++            throw error;
++        }
+         const inheritedIntent = resolveInheritedTaskIntent(snapshot.branchEntries ?? []);
+         if (inheritedIntent && parsedSummary.taskIntent && parsedSummary.taskIntent !== inheritedIntent)
+             throw new SummaryGenerationError("incomplete", "Compaction changed protected task intent");
+--- a/@code-yeongyu/senpi/dist/core/extensions/runner.js
++++ b/@code-yeongyu/senpi/dist/core/extensions/runner.js
+@@ -397,6 +397,7 @@ export class ExtensionRunner {
+         this.offloadFn = contextActions.offload;
+         // Context actions (required)
+         this.getModel = contextActions.getModel;
++        this.getModelSwitchState = contextActions.getModelSwitchState;
+         this.getServiceTier = contextActions.getServiceTier;
+         this.getEffectiveServiceTier = contextActions.getEffectiveServiceTier ?? contextActions.getServiceTier;
+         this.getScopedModels = contextActions.getScopedModels;
+@@ -1119,6 +1120,10 @@ export class ExtensionRunner {
+                 runner.assertActive();
+                 return getModel();
+             },
++            getModelSwitchState: () => {
++                runner.assertActive();
++                return runner.getModelSwitchState?.() ?? { current: getModel(), pending: undefined };
++            },
+             get serviceTier() {
+                 runner.assertActive();
+                 return getServiceTier();
+--- a/@code-yeongyu/senpi/dist/core/extensions/types.d.ts
++++ b/@code-yeongyu/senpi/dist/core/extensions/types.d.ts
+@@ -363,9 +363,14 @@ export interface UpdateCompactionOptions {
+     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";
++    kind: "invalid_model" | "auth_missing" | "auth_expired" | "quota" | "account_blocked" | "org_denied" | "model_unavailable" | "refused" | "timeout" | "incomplete" | "empty" | "context_budget" | "stale" | "provider";
+     provider?: string;
+     model?: string;
++    error?: string;
++    inputTokens?: number;
++    inputTokensSource?: "estimate" | "provider";
++    requestSent?: boolean;
++    retryAt?: number;
+ }
+ export interface EndCompactionOptions {
+     failure?: CompactionFailure;
+@@ -521,6 +526,8 @@ export interface ExtensionContext {
+     getCompactionSettings(): CompactionPreparation["settings"];
+     /** Select a budget-fitting summary model; auto stays within the active provider and explicit failures never fall back. */
+     getCompactionModel?(inputTokens?: number): Model<Api> | undefined;
++    /** Actual current and held model identities, resolved lazily from the session. */
++    getModelSwitchState?(): { current: Model<Api> | undefined; pending: 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