@code-yeongyu/senpi 2026.8.29 → 2026.8.30-3

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

@@ -1,112 +1,34 @@
-import { randomUUID } from "node:crypto";
 import { createWarmAnchorSnapshot, isWarmSummaryAnchorValid } from "../../../compaction/warm-anchor.js";
-import { convertToLlm } from "../../../messages.js";
 import * as checkpointState from "./checkpoint-state.js";
 import * as breaker from "./circuit-breaker.js";
-import { BUILTIN_CONTEXT_REDUCTION_OPTIONS, reduceContextMessages, shouldApplyContextReduction, } from "./context-reduction.js";
+import { buildCompactionContext } from "./context-pipeline.js";
 import { createDegradationMonitorState, handleMessageEnd, handleTurnEnd, RECOVERY_INSTRUCTIONS, resetOnSessionCompact, } from "./degradation-monitor.js";
 import { classifyRequiredCompactionFallbackFailure, createRequiredCompactionFallback, } from "./deterministic-fallback.js";
 import * as idle from "./idle.js";
 import * as idleRetry from "./idle-retry.js";
 import { CLAUDE_SDK_OAUTH_COMPACT_ENTRY_TYPE, collectCompactBoundaryEntries, createCompactionLanePolicy, SDK_NATIVE_LANE_REJECTION_REASON, } from "./lane-policy.js";
 import { createCompactionLogger } from "./log.js";
-import { markOpenAiRemoteReplayBoundary, rewriteOpenAiPayloadWithRemoteCompaction, runOpenAiRemoteCompaction, SENPI_COMPACTION_EVENT, } from "./openai-remote.js";
+import { handleCompactionModelSelect } from "./model-selection.js";
+import { rewriteOpenAiPayloadWithRemoteCompaction, runOpenAiRemoteCompaction, SENPI_COMPACTION_EVENT, } from "./openai-remote.js";
 import { createOpenAiRemoteCompactionHeaders, isOpenAiRemoteCompactionModel, openAiRemoteCompactionOrigin, } from "./openai-remote-model.js";
+import { resolveBeforeAgentStartMessage, resolveCompactionGeometry, resolveIdleWarmAction, resolveReminderSystemPrompt, shouldDeferGraceBand, } from "./orchestration.js";
 import * as cap from "./per-turn-cap.js";
 import * as policy from "./policy.js";
-import { repairOrphanedToolResults } from "./repair-tool-pairs.js";
 import * as restoration from "./restoration-tracker.js";
-import { applyGeneratedCompaction, createEmergencyPruneLatch, createSpeculativeCompactionSnapshot, getPromptVariant, hardLimitEmergencyPrune, runExtensionCompaction, SummaryGenerationError, } from "./speculative.js";
+import { applyGeneratedCompaction, createEmergencyPruneLatch, createSpeculativeCompactionSnapshot, getPromptVariant, runExtensionCompaction, SummaryGenerationError, } from "./speculative.js";
+import { trackSpeculativeJob } from "./speculative-job.js";
 import { createInitialState, resetTurnCounter } from "./state.js";
 import { resolveInheritedTaskIntent } from "./task-intent.js";
 import * as todoBridge from "./todo-bridge.js";
+import { computeTokenBudgetReminder, createInitialReminderState, } from "./token-budget-reminder.js";
 import { isTransientSummarizationFailure } from "./transient-failure.js";
+export { getPromptContextWindow } from "./extension-wiring.js";
+import { createBlockingRemoteCompactionEvent, endCompactionFeedback, estimatePendingPromptTokens, getPromptContextWindow, isAbortedAssistantMessage, isMonitorableMessageEvent, isRequiredCompactionFallbackReason, linkAbortSignal, recentCheckpoint, withAdditionalTokens, } from "./extension-wiring.js";
 import { isIneffectiveCompaction } from "./yield.js";
 const DEFAULT_CONTEXT_WINDOW = 200_000;
 const EMERGENCY_COMPACTION_INSTRUCTIONS = "EMERGENCY: hard context limit reached. Produce an aggressive recovery summary that preserves current goal, constraints, files touched, tool outcomes, and exact next steps. Prefer concise factual state over transcript detail.";
 const PROACTIVE_COMPACTION_INSTRUCTIONS = "Proactively compact before the next agent turn.";
 const MAX_PENDING_METADATA = 8;
-const IMAGE_PROMPT_TOKEN_ESTIMATE = 1_200;
-const MAX_OUTPUT_RESERVE_RATIO = 0.5;
-function approxTokens(text) {
-    return Math.ceil(text.length / 4);
-}
-function estimatePendingPromptTokens(event) {
-    return approxTokens(event.prompt ?? "") + (event.images?.length ?? 0) * IMAGE_PROMPT_TOKEN_ESTIMATE;
-}
-export function getPromptContextWindow(contextWindow, maxTokens) {
-    if (typeof maxTokens !== "number" || !Number.isFinite(maxTokens) || maxTokens <= 0 || contextWindow <= 0) {
-        return contextWindow;
-    }
-    const outputReserve = Math.min(maxTokens, Math.floor(contextWindow * MAX_OUTPUT_RESERVE_RATIO));
-    return contextWindow - outputReserve;
-}
-function withAdditionalTokens(usage, additionalTokens) {
-    if (usage.tokens === null || additionalTokens <= 0)
-        return usage;
-    const tokens = usage.tokens + additionalTokens;
-    return {
-        ...usage,
-        tokens,
-        percent: usage.contextWindow > 0 ? (tokens / usage.contextWindow) * 100 : usage.percent,
-    };
-}
-function isMonitorableMessageEvent(event) {
-    return "content" in event.message && Array.isArray(event.message.content);
-}
-function isAbortedAssistantMessage(event) {
-    return event.message.role === "assistant" && "stopReason" in event.message && event.message.stopReason === "aborted";
-}
-function isRequiredCompactionFallbackReason(reason) {
-    return reason === "threshold" || reason === "overflow";
-}
-function recentCheckpoint(ctx) {
-    const checkpoint = checkpointState.getLatestCheckpoint(ctx);
-    if (!checkpoint?.timestamp)
-        return null;
-    return Date.now() - checkpoint.timestamp <= 60_000 ? checkpoint : null;
-}
-function shouldEndFeedback(result) {
-    return !result.applied && result.reason !== "rejected";
-}
-function endCompactionFeedback(ctx, signal, result, remoteFallbackReason) {
-    if (shouldEndFeedback(result)) {
-        // Surface the concrete failure instead of the generic "Compaction did not
-        // apply": the remote stage's reason (e.g. remote-compaction-timeout) and the
-        // terminal local reason (unavailable / stale), so the decision log and TUI
-        // show what actually happened. An aborted compaction renders "Compaction
-        // cancelled" downstream and must not carry a failure message.
-        const localReason = result.applied ? undefined : result.reason;
-        const parts = [remoteFallbackReason, localReason].filter((part) => Boolean(part));
-        const errorMessage = signal?.aborted || parts.length === 0
-            ? undefined
-            : `Compaction did not apply: ${parts.join("; local fallback ")}`;
-        ctx.endCompaction?.({ reason: "extension", signal, aborted: signal?.aborted, errorMessage });
-    }
-}
-function linkAbortSignal(source, target) {
-    if (!source)
-        return () => { };
-    if (source.aborted) {
-        target.abort();
-        return () => { };
-    }
-    const abort = () => target.abort();
-    source.addEventListener("abort", abort, { once: true });
-    return () => source.removeEventListener("abort", abort);
-}
-function createBlockingRemoteCompactionEvent(ctx, snapshot, customInstructions, signal) {
-    return {
-        type: "session_before_compact",
-        reason: "extension",
-        willRetry: false,
-        requestId: randomUUID(),
-        preparation: snapshot.preparation,
-        branchEntries: ctx.sessionManager.getBranch(),
-        customInstructions,
-        signal,
-    };
-}
 export default function compactionExtension(pi, remoteCompactionDependencies = {}) {
     let state = createInitialState();
     const lanePolicy = createCompactionLanePolicy();
@@ -116,6 +38,7 @@ export default function compactionExtension(pi, remoteCompactionDependencies = {
     const restorationState = state.restoration ?? restoration.createRestorationTrackerState();
     state = { ...state, restoration: restorationState };
     let speculativeGeneration = 0;
+    let reminderState = createInitialReminderState();
     let speculativeJob;
     const pendingMetadata = new Map();
     let logger;
@@ -188,13 +111,23 @@ export default function compactionExtension(pi, remoteCompactionDependencies = {
             }
             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: breaker.isTripped(state, Date.now()),
-                stillOverThreshold: usage !== undefined &&
-                    policy.shouldTriggerCompaction(usage, contextWindow, ctx.getCompactionSettings(), state.lastYield ?? undefined),
+                breakerTripped,
+                stillWarmEligible: idle.shouldWarmAtIdle({
+                    willRetry: false,
+                    aborted: false,
+                    settings,
+                    usage,
+                    contextWindow,
+                    breakerTripped,
+                    lastYield: state.lastYield ?? undefined,
+                    mode: ctx.mode,
+                }),
             };
             if (!idleRetry.shouldRetryIdleWarmup(retryDecision))
                 return;
@@ -333,9 +266,14 @@ export default function compactionExtension(pi, remoteCompactionDependencies = {
         getLogger(ctx).debug("speculative_started", { generation, origin: "speculative" });
         const controller = new AbortController();
         const settled = runExtensionCompaction(ctx, snapshot, controller.signal).then((result) => ({ result, error: undefined }), (error) => ({ result: undefined, error: error instanceof Error ? error : new Error(String(error)) }));
-        const promise = settled.then(({ result }) => result);
-        const failure = settled.then(({ error }) => error);
-        speculativeJob = { generation, snapshot, controller, promise, failure };
+        speculativeJob = trackSpeculativeJob({
+            generation,
+            snapshot,
+            controller,
+            settled,
+            armedAtTokens: ctx.getContextUsage()?.tokens ?? 0,
+        });
+        void settled.then(() => remoteCompactionDependencies.onSpeculativeJobSettled?.());
     }
     function capturePendingMetadata(requestId, ctx) {
         pendingMetadata.set(requestId, {
@@ -638,37 +576,16 @@ export default function compactionExtension(pi, remoteCompactionDependencies = {
                 claimedWarmJob?.controller.abort();
         }
     });
-    pi.on("model_select", (event, ctx) => {
-        if (lanePolicy.disablesSenpiCompaction(ctx)) {
-            invalidateSpeculativeCompaction(ctx);
-            return;
-        }
-        const jobModel = speculativeJob?.snapshot.model;
-        const selectedModel = ctx.model;
-        const alreadySpeculatingForSelectedModel = jobModel !== undefined &&
-            selectedModel !== undefined &&
-            jobModel.api === selectedModel.api &&
-            jobModel.provider === selectedModel.provider &&
-            jobModel.id === selectedModel.id &&
-            jobModel.baseUrl === selectedModel.baseUrl &&
-            jobModel.contextWindow === selectedModel.contextWindow;
-        if (!alreadySpeculatingForSelectedModel) {
-            invalidateSpeculativeCompaction(ctx);
-        }
-        const previousWindow = event.previousModel?.contextWindow ?? 0;
-        const contextWindow = ctx.model?.contextWindow ?? 0;
-        if (previousWindow <= contextWindow)
-            return;
-        const usage = ctx.getContextUsage();
-        if (!usage)
-            return;
-        if (breaker.isTripped(state, Date.now()))
-            return;
-        const settings = ctx.getCompactionSettings();
-        if (policy.shouldStartSpeculativeCompaction(usage, contextWindow, settings, state.lastYield ?? undefined)) {
-            startSpeculativeCompaction(ctx, PROACTIVE_COMPACTION_INSTRUCTIONS);
-        }
-    });
+    pi.on("model_select", (event, ctx) => handleCompactionModelSelect({
+        event,
+        ctx,
+        state,
+        speculativeSnapshot: speculativeJob?.snapshot,
+        laneOwnsCompaction: lanePolicy.disablesSenpiCompaction(ctx),
+        breakerTripped: breaker.isTripped(state, Date.now()),
+        invalidate: () => invalidateSpeculativeCompaction(ctx),
+        start: () => startSpeculativeCompaction(ctx, PROACTIVE_COMPACTION_INSTRUCTIONS),
+    }));
     pi.on("session_compact", async (event, ctx) => {
         const compactEvent = event;
         invalidateSpeculativeCompaction(ctx);
@@ -679,6 +596,7 @@ export default function compactionExtension(pi, remoteCompactionDependencies = {
             const keptEntries = firstKeptIndex === -1 ? [] : branchEntries.slice(firstKeptIndex);
             state = cap.incrementAccepted(state);
             state = breaker.recordSuccess(state);
+            reminderState = createInitialReminderState();
             const details = compactEvent.compactionEntry.details;
             const sy = details?.structuralYield;
             if (sy && typeof sy.savedTokens === "number" && typeof sy.savingsRatio === "number") {
@@ -710,7 +628,7 @@ export default function compactionExtension(pi, remoteCompactionDependencies = {
                     compactionEntryId: compactEvent.compactionEntry.id,
                     contextWindow: usage?.contextWindow ?? ctx.model?.contextWindow ?? DEFAULT_CONTEXT_WINDOW,
                     usageTokens: usage?.tokens ?? null,
-                    reserveTokens: settings.reserveTokens,
+                    reserveTokens: policy.resolveEffectiveReserveTokens(usage?.contextWindow ?? ctx.model?.contextWindow ?? DEFAULT_CONTEXT_WINDOW, settings),
                     settings,
                     keptMessages: keptEntries.flatMap((entry) => {
                         if (entry.type !== "message")
@@ -721,7 +639,11 @@ export default function compactionExtension(pi, remoteCompactionDependencies = {
             }
             return;
         }
-        state = breaker.recordFailure(state, Date.now(), { route: compactEvent.reason });
+        if (compactEvent.rejectionCause === "external-owner")
+            return;
+        if (!lanePolicy.disablesSenpiCompaction(ctx)) {
+            state = breaker.recordFailure(state, Date.now(), { route: compactEvent.reason });
+        }
     });
     pi.on("before_agent_start", async (event, ctx) => {
         sessionIdleSinceAgentEnd = false;
@@ -736,9 +658,14 @@ export default function compactionExtension(pi, remoteCompactionDependencies = {
         // 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 { reserveTokens, thresholdTokens, leadTokens } = resolveCompactionGeometry({
+            contextWindow,
+            settings,
+            lastYield: state.lastYield ?? undefined,
+        });
         if (!laneOwnsCompaction &&
             usage &&
-            policy.isAtHardLimit(usage, contextWindow, settings.reserveTokens, pendingPromptTokens)) {
+            policy.isAtHardLimit(usage, contextWindow, reserveTokens, pendingPromptTokens)) {
             getLogger(ctx).debug("hard_limit_trigger", {
                 contextWindow,
                 tokens: usage.tokens ?? 0,
@@ -754,42 +681,84 @@ export default function compactionExtension(pi, remoteCompactionDependencies = {
                 tokens: usageWithPendingPrompt.tokens ?? 0,
                 threshold: settings.reserveTokens,
             });
-            await applyBlockingCompaction(ctx, PROACTIVE_COMPACTION_INSTRUCTIONS);
+            if (!shouldDeferGraceBand({
+                tokens: usageWithPendingPrompt.tokens ?? 0,
+                thresholdTokens,
+                leadTokens,
+                contextWindow,
+                reserveTokens,
+                compactionInFlight: speculativeJob !== undefined && !speculativeJob.completed,
+                graceBandEnabled: settings.graceBandEnabled,
+            })) {
+                await applyBlockingCompaction(ctx, PROACTIVE_COMPACTION_INSTRUCTIONS);
+            }
+            else {
+                getLogger(ctx).debug("grace_deferred", {
+                    tokens: usageWithPendingPrompt.tokens ?? 0,
+                    threshold: thresholdTokens,
+                });
+            }
         }
         else if (!breakerCoolingDown &&
+            !isOpenAiRemoteCompactionModel(ctx.model) &&
             usageWithPendingPrompt &&
-            policy.shouldStartSpeculativeCompaction(usageWithPendingPrompt, contextWindow, settings, state.lastYield ?? undefined)) {
+            policy.shouldStartSpeculativeCompaction(usageWithPendingPrompt, contextWindow, settings, state.lastYield ?? undefined, leadTokens)) {
             getLogger(ctx).debug("emergency_prune", {
                 route: "context-event",
                 tokens: usageWithPendingPrompt.tokens ?? 0,
             });
             startSpeculativeCompaction(ctx, PROACTIVE_COMPACTION_INSTRUCTIONS);
         }
-        return message ? { message } : undefined;
+        const reminder = computeTokenBudgetReminder({
+            contextTokens: usageWithPendingPrompt?.tokens ?? 0,
+            contextWindow,
+            thresholdTokens,
+            leadTokens,
+            compactionEpoch: speculativeGeneration,
+            state: reminderState,
+        });
+        reminderState = reminder.nextState;
+        const deliveredMessage = resolveBeforeAgentStartMessage({
+            message,
+            reminder: reminder.message,
+            reminderEnabled: settings.reminderEnabled,
+        });
+        const reminderSystemPrompt = resolveReminderSystemPrompt({
+            systemPrompt: event.systemPrompt,
+            reminder: !message ? reminder.message : undefined,
+            reminderEnabled: settings.reminderEnabled,
+        });
+        if (!deliveredMessage && !reminderSystemPrompt)
+            return undefined;
+        return {
+            ...(deliveredMessage ? { message: deliveredMessage } : {}),
+            ...(reminderSystemPrompt ? { systemPrompt: reminderSystemPrompt } : {}),
+        };
     });
     pi.on("context", (event, ctx) => {
         const usage = ctx.getContextUsage();
+        const settings = ctx.getCompactionSettings();
         const contextWindow = usage?.contextWindow ?? ctx.model?.contextWindow ?? DEFAULT_CONTEXT_WINDOW;
-        const promptContextWindow = getPromptContextWindow(contextWindow, ctx.model?.maxTokens);
-        const sourceMessages = shouldApplyContextReduction({
-            usageTokens: usage?.tokens ?? null,
-            contextWindow,
-            isProviderNativeCompactionPath: isOpenAiRemoteCompactionModel(ctx.model) || lanePolicy.disablesSenpiCompaction(ctx),
-        })
-            ? reduceContextMessages(event.messages, BUILTIN_CONTEXT_REDUCTION_OPTIONS).messages
-            : event.messages;
-        // The claude-sdk-oauth lane stands down from senpi compaction entirely:
-        // destructively pruning the provider context near the hard limit would
-        // break the resident SDK session's continuity the same way the gated
-        // reduction lane would.
-        const emergency = lanePolicy.disablesSenpiCompaction(ctx)
-            ? { messages: sourceMessages, needsAggressiveCompaction: false }
-            : hardLimitEmergencyPrune(sourceMessages, promptContextWindow, emergencyPruneLatch);
-        const marked = markOpenAiRemoteReplayBoundary(emergency.messages, {
-            model: ctx.model,
-            branchEntries: ctx.sessionManager.getBranch(),
-        });
-        return { messages: repairOrphanedToolResults(convertToLlm(marked)) };
+        const laneOwnsCompaction = lanePolicy.disablesSenpiCompaction(ctx);
+        const breakerFallback = !laneOwnsCompaction &&
+            breaker.isTripped(state, Date.now()) &&
+            usage?.tokens !== null &&
+            usage !== undefined &&
+            usage.tokens >= contextWindow * policy.computeEffectiveThreshold(contextWindow, state.lastYield ?? undefined);
+        if (breakerFallback)
+            getLogger(ctx).debug("breaker_deterministic_fallback", { route: "context-event", tokens: usage.tokens ?? 0 });
+        return {
+            messages: buildCompactionContext({
+                event,
+                ctx,
+                contextWindow,
+                promptContextWindow: getPromptContextWindow(contextWindow, ctx.model?.maxTokens),
+                toolAdmissionEnabled: settings.toolAdmissionEnabled !== false,
+                breakerFallback,
+                laneOwnsCompaction,
+                emergencyPruneLatch,
+            }),
+        };
     });
     pi.on("before_provider_request", async (event, ctx) => {
         const model = event.model ?? ctx.model;
@@ -850,6 +819,35 @@ export default function compactionExtension(pi, remoteCompactionDependencies = {
             armIdleWarmupRetry(ctx);
             armIdleApply(ctx);
         }
+        else {
+            // A sub-threshold OpenAI warm-up cannot be consumed by the remote
+            // compaction route. Once threshold admission succeeds remotely, it would
+            // only abort and discard this paid local summary. Above threshold we keep
+            // the existing local idle apply, which can finish before the next prompt;
+            // if remote compaction later falls back, blocking local generation remains
+            // unchanged.
+            if (isOpenAiRemoteCompactionModel(ctx.model))
+                return;
+            const warmAction = resolveIdleWarmAction({
+                willRetry: event.willRetry ?? false,
+                aborted: event.aborted === true,
+                settings,
+                usage,
+                contextWindow,
+                breakerTripped: breaker.isTripped(state, Date.now()),
+                lastYield: state.lastYield ?? undefined,
+                mode: ctx.mode,
+            }, speculativeJob);
+            if (warmAction === "replace")
+                invalidateSpeculativeCompaction(ctx);
+            if (warmAction !== "none") {
+                idleWarmupAttempt = 0;
+                sessionIdleSinceAgentEnd = true;
+                startSpeculativeCompaction(ctx, idle.IDLE_COMPACTION_INSTRUCTIONS);
+                armIdleWarmupRetry(ctx);
+                armIdleApply(ctx);
+            }
+        }
     });
     pi.on("message_end", async (event, ctx) => {
         for (const entry of collectCompactBoundaryEntries(event.message)) {