zigmini 0.8.0-beta.5 → 0.8.0-beta.7

package/host/omo-check/patches/omo-5.1.35-compaction-preservation.patch

@@ -0,0 +1,1063 @@
+--- a/@code-yeongyu/senpi/dist/core/extensions/builtin/compaction/speculative.js
++++ b/@code-yeongyu/senpi/dist/core/extensions/builtin/compaction/speculative.js
+@@ -33,0 +33,1 @@
++        this.failure = { kind: refused ? "refused" : failureKind === "upstream-stream-truncated" ? "incomplete" : failureKind ?? "provider" };
+@@ -35,15 +36,26 @@
+-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.
+- */
+-function isRetryableSummaryAttempt(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"];
++    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 pre-output transient failures may retry the same selected model. */
++function isRetryableSummaryAttempt(error) {
++    if (error?.failure?.kind && error.failure.kind !== "provider")
++        return false;
+@@ -58,5 +70,0 @@
+-    // 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).
+@@ -68,1 +75,1 @@
+-        return error.failureKind === undefined && error.transient;
++        return !error.refused && error.failureKind === undefined && error.transient;
+@@ -79,0 +86,3 @@
++    const kind = response.failure?.kind;
++    if (["auth_missing", "auth_expired", "quota", "org_denied", "model_unavailable", "timeout", "incomplete", "context_budget"].includes(kind))
++        return kind;
+@@ -86,0 +96,1 @@
++        this.failure = { kind };
+@@ -134,1 +145,1 @@
+- * when the request was aborted (caller signal or an aborted stream); every
++ * when the caller signal was aborted; every
+@@ -191,4 +202,0 @@
+-    const summarizationToolsOffered = (requestSnapshot.tools?.length ?? 0) > 0;
+-    const reasoningOverrideOffered = hasSummarizationReasoningOverride(requestSnapshot.model);
+-    let toolUseRetrySpent = false;
+-    let reasoningOverrideRetrySpent = false;
+@@ -220,1 +227,1 @@
+-                    forbidToolCalls: toolUseRetrySpent,
++                    forbidToolCalls: true,
+@@ -235,1 +242,0 @@
+-                    ...(reasoningOverrideRetrySpent ? { omitReasoningOptions: true } : {}),
+@@ -239,1 +245,1 @@
+-                    attempt.stopReason === "error" &&
++                    (attempt.stopReason === "error" || isRefusalStop(attempt)) &&
+@@ -242,1 +248,1 @@
+-                    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));
+@@ -255,3 +261,3 @@
+-        if (!response)
+-            return undefined;
+-        if (isAssistantMessage(response) && isContextOverflow(response, requestSnapshot.contextWindow)) {
++        if (!response && signal?.aborted)
++            return undefined;
++        if (response && isAssistantMessage(response) && isContextOverflow(response, requestSnapshot.contextWindow)) {
+@@ -261,40 +267,2 @@
+-        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 summary = parsedSummary.summaryText;
+@@ -305,1 +273,0 @@
+-        const parsedSummary = extractTaskIntent(summary);
+--- a/@code-yeongyu/senpi/dist/core/extensions/builtin/compaction/index.js
++++ b/@code-yeongyu/senpi/dist/core/extensions/builtin/compaction/index.js
+@@ -2,1 +2,0 @@
+-import { AccountUsageLimitError } from "../../../retry-fallback/usage-limit.js";
+@@ -7,1 +6,0 @@
+-import { classifyRequiredCompactionFallbackFailure, createRequiredCompactionFallback, formatRequiredCompactionFallbackNotice, formatRequiredCompactionFallbackRejection, stripTurnRetrySuppressionPrefix, UnsafeRetainedSuffixError, } from "./deterministic-fallback.js";
+@@ -9,1 +7,0 @@
+-import * as idleRetry from "./idle-retry.js";
+@@ -20,1 +17,1 @@
+-import { applyGeneratedCompaction, createEmergencyPruneLatch, createSpeculativeCompactionSnapshot, getPromptVariant, runExtensionCompaction, SummaryGenerationError, } from "./speculative.js";
++import { applyGeneratedCompaction, createEmergencyPruneLatch, createSpeculativeCompactionSnapshot, getPromptVariant, runExtensionCompaction, SummaryGenerationError, compactionFailure, } from "./speculative.js";
+@@ -63,1 +60,0 @@
+-    let idleWarmupAttempt = 0;
+@@ -98,62 +94,0 @@
+-    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);
+-        });
+-    }
+@@ -303,21 +237,1 @@
+-        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);
+@@ -325,27 +239,0 @@
+-    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 };
+-    }
+@@ -353,17 +240,1 @@
+-        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" });
+@@ -371,35 +242,6 @@
+-            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");
+@@ -407,0 +249,3 @@
++            speculativeJob = undefined;
++            let snapshot;
++            let compaction;
+@@ -408,3 +253,2 @@
+-                const unlinkAbort = linkAbortSignal(feedbackSignal, pendingJob.controller);
+-                let compaction;
+-                let inheritedFailure;
++                snapshot = pendingJob.snapshot;
++                const unlink = linkAbortSignal(feedbackSignal, pendingJob.controller);
+@@ -413,3 +257,3 @@
+-                    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;
+@@ -417,79 +261,16 @@
+-                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;
+@@ -497,5 +278,3 @@
+-                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 }));
+@@ -504,1 +283,1 @@
+-            endCompactionFeedback(ctx, feedbackSignal, result, remoteFallbackReason);
++            endCompactionFeedback(ctx, feedbackSignal, result);
+@@ -508,18 +287,5 @@
+-            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)
+@@ -527,3 +293,1 @@
+-                return { applied: false, reason: "failed" };
+-            }
+-            throw error;
++            return { applied: false, reason: "failed", failure };
+@@ -533,3 +297,0 @@
+-        // 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).
+@@ -537,1 +298,1 @@
+-            return undefined;
++            return { cancel: true };
+@@ -539,4 +300,0 @@
+-        // 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;
+@@ -544,1 +301,0 @@
+-        const claimedGeneration = speculativeGeneration;
+@@ -546,25 +302,6 @@
+-            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" } };
+@@ -573,31 +310,2 @@
+-            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");
+@@ -605,3 +313,1 @@
+-                const unlinkAbort = linkAbortSignal(event.signal, claimedWarmJob.controller);
+-                let warmCompaction;
+-                let warmFailure;
++                const unlink = linkAbortSignal(event.signal, claimedWarmJob.controller);
+@@ -609,2 +315,7 @@
+-                    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 };
+@@ -612,16 +323,1 @@
+-                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(); }
+@@ -629,0 +325,8 @@
++            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 };
++            }
+@@ -630,3 +334,1 @@
+-                generation: ++speculativeGeneration,
+-                expectedRevision: ctx.getMessageRevision(),
+-                model,
++                generation: ++speculativeGeneration, expectedRevision: ctx.getMessageRevision(), model,
+@@ -634,45 +336,3 @@
+-                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(),
+@@ -680,0 +340,5 @@
++            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 };
+@@ -681,3 +346,5 @@
+-        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),
++            }) };
+@@ -685,0 +352,1 @@
++        finally { claimedWarmJob?.controller.abort(); }
+@@ -785,1 +453,2 @@
+-            await applyBlockingCompaction(ctx, EMERGENCY_COMPACTION_INSTRUCTIONS);
++            const result = await applyBlockingCompaction(ctx, EMERGENCY_COMPACTION_INSTRUCTIONS);
++            if (!result.applied) { ctx.abort("system"); return; }
+@@ -804,1 +473,2 @@
+-                await applyBlockingCompaction(ctx, PROACTIVE_COMPACTION_INSTRUCTIONS);
++                const result = await applyBlockingCompaction(ctx, PROACTIVE_COMPACTION_INSTRUCTIONS);
++                if (!result.applied) { ctx.abort("system"); return; }
+@@ -915,1 +585,0 @@
+-            idleWarmupAttempt = 0;
+@@ -918,1 +587,0 @@
+-            armIdleWarmupRetry(ctx);
+@@ -943,1 +611,0 @@
+-                idleWarmupAttempt = 0;
+@@ -946,2 +613,1 @@
+-                armIdleWarmupRetry(ctx);
+-                armIdleApply(ctx);
++                    armIdleApply(ctx);
+@@ -977,1 +643,0 @@
+-        idleWarmupAttempt = 0;
+--- 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
+@@ -49,0 +49,1 @@
++    pi.on("before_agent_start", () => handoff.reset());
+@@ -109,1 +110,1 @@
+-        const managed = !policy.laneOwnsCompaction && !policy.appendOnlyTranscript && !isOpenAiRemoteCompactionModel(ctx.model);
++        const managed = !policy.laneOwnsCompaction;
+@@ -121,1 +122,4 @@
+-            handoff.request(ctx);
++            if (policy.breakerTripped)
++                ctx.abort("system");
++            else
++                handoff.request(ctx);
+--- a/@code-yeongyu/senpi/dist/core/extensions/builtin/compaction/context-pipeline.js
++++ b/@code-yeongyu/senpi/dist/core/extensions/builtin/compaction/context-pipeline.js
+@@ -2,2 +2,0 @@
+-import { BUILTIN_CONTEXT_REDUCTION_OPTIONS, reduceContextMessages } from "./context-reduction.js";
+-import { reduceContextWithFrontier } from "./context-reduction-frontier.js";
+@@ -6,2 +4,1 @@
+-import { isOpenAiRemoteCompactionModel } from "./openai-remote-model.js";
+-import { admitContextToolResults, injectTokenBudgetReminder } from "./orchestration.js";
++import { injectTokenBudgetReminder } from "./orchestration.js";
+@@ -10,1 +7,0 @@
+-import { hardLimitEmergencyPrune } from "./speculative.js";
+@@ -16,46 +12,7 @@
+-    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 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 state = input.contextReductionState ?? createContextReductionState();
++    const marked = markOpenAiRemoteReplayBoundary(input.event.messages, {
++        model: input.ctx.model, branchEntries: input.ctx.sessionManager.getBranch(),
++    });
++    const outgoing = repairOrphanedToolResults(convertToLlm(injectTokenBudgetReminder(marked, input.reminder)));
++    const ceiling = input.reductionCeilingTokens ?? input.promptContextWindow;
++    state.compactionRequired = estimateTotalTokens(outgoing) + (input.contextOverheadTokens ?? 0) > ceiling;
+--- a/@code-yeongyu/senpi/dist/core/extensions/builtin/compaction/emergency-prune.js
++++ b/@code-yeongyu/senpi/dist/core/extensions/builtin/compaction/emergency-prune.js
+@@ -56,8 +56,1 @@
+-    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 };
+--- a/@code-yeongyu/senpi/dist/core/extensions/builtin/compaction/openai-remote.js
++++ b/@code-yeongyu/senpi/dist/core/extensions/builtin/compaction/openai-remote.js
+@@ -3,0 +3,1 @@
++import { compactionFailure } from "./speculative.js";
+@@ -179,0 +180,2 @@
++        streamKind: "auxiliary",
++        maxRetries: 0,
+@@ -181,2 +184,4 @@
+-    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" },
++        });
+@@ -223,0 +228,1 @@
++            failure: compactionFailure(error, options?.model),
+@@ -235,0 +241,1 @@
++            failure: { kind: response.status === 429 ? "quota" : response.status === 401 ? "auth_expired" : response.status === 403 ? "org_denied" : "provider" },
+@@ -251,0 +258,1 @@
++            failure: compactionFailure(error, options?.model),
+@@ -292,0 +300,1 @@
++            failure: compactionFailure(error, options?.model),
+@@ -325,0 +334,23 @@
++    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) {
+@@ -383,1 +415,1 @@
+-        next: remoteDeadline.remainingMs() > 0 ? next : "local-summary",
++        next: "stop",
+@@ -456,2 +488,1 @@
+-        if (result || requestModel.api === "openai-codex-responses")
+-            return result;
++        return result;
+@@ -531,0 +562,1 @@
++            failure: compactionFailure(error, requestModel),
+@@ -534,0 +566,1 @@
++        return undefined;
+--- a/@code-yeongyu/senpi/dist/core/agent-session.js
++++ b/@code-yeongyu/senpi/dist/core/agent-session.js
+@@ -43,0 +43,1 @@
++import { compactionFailure, validateSummaryResponse } from "./extensions/builtin/compaction/speculative.js";
+@@ -201,2 +202,2 @@
+-    constructor(rejectionCause) {
+-        super(rejectionCause === "cancelled-by-extension"
++    constructor(rejectionCause, failure) {
++        super(failure ? "Compaction failed; previous context retained" : rejectionCause === "cancelled-by-extension"
+@@ -207,0 +208,1 @@
++        this.failure = failure;
+@@ -226,0 +228,1 @@
++        this.failure = aborted ? undefined : compactionFailure(error);
+@@ -6041,0 +6044,13 @@
++        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;
++                },
++            };
++        };
+@@ -6043,1 +6059,1 @@
+-        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);
+@@ -6115,1 +6131,1 @@
+-                throw new CompactionRejectedError(execution.rejectionCause);
++                throw new CompactionRejectedError(execution.rejectionCause, execution.failure);
+@@ -6124,1 +6140,1 @@
+-                throw new Error(error.message);
++                throw Object.assign(new Error(error.message), { failure: error.failure });
+@@ -6279,0 +6295,2 @@
++            accepted: false,
++            failure: aborted ? undefined : options.failure ?? { kind: "provider" },
+@@ -6282,2 +6300,1 @@
+-        if (!aborted)
+-            this._resumeQueuedMessagesAfterCompaction();
++
+@@ -6349,1 +6366,1 @@
+-                        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);
+@@ -6394,1 +6411,5 @@
+-            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)) {
+@@ -6397,15 +6418,7 @@
+-            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);
+@@ -6428,0 +6441,18 @@
++            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();
+@@ -6435,1 +6466,1 @@
+-            compactionResult.estimatedTokensAfter = estimateMessagesTokens(sessionContext.messages);
++            compactionResult.estimatedTokensAfter = estimateMessagesTokens(this.agent.state.messages);
+@@ -6484,9 +6515,4 @@
+-            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));
+@@ -6540,1 +6566,2 @@
+-    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" };
+@@ -6557,1 +6584,1 @@
+-            status: "failed",
++            status: aborted ? "aborted" : "failed",
+@@ -6573,0 +6600,1 @@
++            failure,
+@@ -6581,0 +6609,1 @@
++            failure,
+@@ -6584,1 +6613,1 @@
+-        return { accepted: false, requestId, rejectionCause };
++        return { accepted: false, requestId, rejectionCause, aborted, failure };
+@@ -7440,0 +7469,2 @@
++                accepted: false,
++                failure: aborted ? undefined : compactionFailure(error, model),
+--- a/@code-yeongyu/senpi/dist/core/extensions/types.d.ts
++++ b/@code-yeongyu/senpi/dist/core/extensions/types.d.ts
+@@ -325,1 +325,7 @@
+-export interface EndCompactionOptions {
++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;
+@@ -1039,0 +1045,1 @@
++    failure?: CompactionFailure;
+@@ -1667,0 +1674,1 @@
++    failure?: CompactionFailure;
+--- 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
+@@ -20,1 +20,1 @@
+-                        active = undefined;
++                        ctx.abort("system");
+--- 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,0 +1,1 @@
++import { compactionFailure } from "./speculative.js";
+@@ -63,1 +64,2 @@
+-        ...(args.model.api === "openai-codex-responses" ? { maxRetries: 0 } : {}),
++        maxRetries: 0,
++        streamKind: "auxiliary",
+@@ -87,2 +89,4 @@
+-    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" },
++        });
+@@ -173,0 +177,1 @@
++            failure: compactionFailure(error, args.model),
+--- 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
+@@ -42,0 +42,1 @@
++    stop: "stopping with previous context retained",
+--- a/@code-yeongyu/senpi/dist/core/extensions/builtin/compaction/extension-wiring.js
++++ b/@code-yeongyu/senpi/dist/core/extensions/builtin/compaction/extension-wiring.js
+@@ -66,1 +66,2 @@
+-        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" } });
+--- a/@code-yeongyu/senpi/dist/core/agent-session.d.ts
++++ b/@code-yeongyu/senpi/dist/core/agent-session.d.ts
+@@ -31,1 +31,1 @@
+-import type { ApplyCompactionOptions, ApplyCompactionResult, CompactionReason, CompactionRejectionCause, ModelSelectSource } from "./extensions/types.ts";
++import type { ApplyCompactionOptions, ApplyCompactionResult, CompactionReason, CompactionRejectionCause, CompactionFailure, ModelSelectSource } from "./extensions/types.ts";
+@@ -230,0 +230,1 @@
++    failure?: CompactionFailure;
+--- a/@code-yeongyu/senpi/dist/core/extensions/builtin/compaction/speculative.d.ts
++++ b/@code-yeongyu/senpi/dist/core/extensions/builtin/compaction/speculative.d.ts
+@@ -7,1 +7,1 @@
+-import type { ApplyCompactionResult, ContextUsage, ProviderRequestPreparation } from "../../types.ts";
++import type { CompactionFailure, ApplyCompactionResult, ContextUsage, ProviderRequestPreparation } from "../../types.ts";
+@@ -17,1 +17,1 @@
+-    getCompactionModel?(): Model<any> | undefined;
++    getCompactionModel?(inputTokens?: number): Model<any> | undefined;
+@@ -59,1 +59,1 @@
+-export type SummaryRequestFailureKind = "upstream-stream-truncated";
++export type SummaryRequestFailureKind = "upstream-stream-truncated" | CompactionFailure["kind"];
+@@ -73,3 +73,6 @@
+-    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 };
+--- 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
+@@ -5,1 +5,1 @@
+-import type { ProviderRequestPreparation, ServiceTier, SessionBeforeCompactEvent } from "../../types.ts";
++import type { CompactionFailure, ProviderRequestPreparation, ServiceTier, SessionBeforeCompactEvent } from "../../types.ts";
+@@ -123,1 +123,1 @@
+-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 }>;
+--- 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
+@@ -14,1 +14,1 @@
+-export type RemoteCompactionTimeoutNextStep = "websocket" | "compact-endpoint" | "local-summary";
++export type RemoteCompactionTimeoutNextStep = "websocket" | "compact-endpoint" | "local-summary" | "stop";
+--- a/@code-yeongyu/senpi/dist/core/extensions/builtin/compaction/rejected-recovery.js
++++ b/@code-yeongyu/senpi/dist/core/extensions/builtin/compaction/rejected-recovery.js
+@@ -9,1 +9,1 @@
+-export function wouldCompactionOverflow(pathEntries, compactionResult, fromExtension, model, settings) {
++export function wouldCompactionOverflow(pathEntries, compactionResult, fromExtension, model, settings, pendingMessages = []) {
+@@ -32,0 +32,1 @@
++    messages = [...messages, ...pendingMessages];
+--- 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
+@@ -6,1 +6,1 @@
+-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;