@superblocksteam/vite-plugin-file-sync 2.0.123-next.0 → 2.0.124-next.0

package/dist/ai-service/llm/context-v2/context.d.ts

@@ -1,7 +1,9 @@
-import type { LanguageModel, ModelMessage, UserModelMessage, SystemModelMessage, LanguageModelUsage } from "ai";
+import type { ModelMessage, UserModelMessage, SystemModelMessage, LanguageModelUsage } from "ai";
 import type { LLMObsTracer } from "../../llmobs/tracer.js";
+import type { CompactionStrategy } from "./compaction/compaction-strategy.js";
 import type { ContextOptionsV2, CachingConfig } from "./config.js";
-import type { ContextRecordV2, CompactionCallbacks, CompactionPhase, ModeState, AttachmentsRecord, CompactionSummary } from "./types.js";
+import type { EventStore } from "./storage/event-store.js";
+import type { ContextRecordV2, ContextId, ModeState, AttachmentsRecord, CompactionSummary, CompactionCallbacks } from "./types.js";
 /** Strip base64 media from screenshot tool results, replacing with a text placeholder. */
 export declare function stripScreenshotMediaFromToolMessage(msg: ModelMessage): ModelMessage;
 export interface Context {
@@ -10,16 +12,29 @@ export interface Context {
     addResponse(response: ModelMessage, usage: LanguageModelUsage): Promise<void>;
     getMessages(): Promise<ModelMessage[]>;
 }
-export type { CompactionCallbacks, CompactionPhase, ModeState };
+export type { ModeState };
 export interface ContextV2Options {
     rootDir: string;
-    summarizationModel: LanguageModel;
     config?: Partial<ContextOptionsV2>;
     caching?: Partial<CachingConfig>;
     onPersist?: (record: ContextRecordV2) => Promise<void>;
-    compactionCallbacks?: CompactionCallbacks;
     tracer?: LLMObsTracer;
     getModeState?: () => ModeState | undefined;
+    /** Event store for appending live conversation events (prompt_sent, response_received). */
+    eventStore?: EventStore;
+    /**
+     * Full context identifier (appId + userId + name) used to partition event
+     * log writes. Keying on `appId` alone would let two users sharing the same
+     * application surface each other's conversation history.
+     */
+    contextId?: ContextId;
+    /**
+     * Compaction strategy. Defaults to {@link ServerSideCompactionStrategy} when
+     * not provided so tests and ad-hoc callers can construct a ContextV2 without
+     * picking one. Production code paths (via ContextManagerV2) always supply a
+     * strategy derived from runtime config.
+     */
+    compaction?: CompactionStrategy;
 }
 export declare class ContextV2 implements Context {
     private systemPrompt?;
@@ -27,23 +42,32 @@ export declare class ContextV2 implements Context {
     private attachments?;
     private config;
     private caching;
-    private summarizationModel;
     private queue;
     private onPersist?;
-    private compactionCallbacks?;
     private tracer?;
     private rootDir;
-    private pendingInputSummaries;
-    private pendingOutputSummaries;
-    private pendingProtection;
     private skillsNeedReload;
     private getModeState?;
+    private readonly eventStore?;
+    private readonly contextId?;
+    private compaction;
+    private compactionCallbacks?;
     private isDisposed;
     constructor(options: ContextV2Options);
-    setCompactionCallbacks(callbacks: CompactionCallbacks | undefined): void;
     updateConfig(config: Partial<ContextOptionsV2>): void;
+    /**
+     * Swap the active compaction strategy on a live context. Called from
+     * `ContextManagerV2.getOrCreateContext` on a cache hit when the
+     * incoming `contextManagement` selection (derived from the per-request
+     * LD flag) differs from whatever the cached context was first
+     * constructed with. Without this, the first caller's strategy locks
+     * in for the lifetime of the cache entry and the kill-switch flag
+     * silently no-ops.
+     */
+    setCompactionStrategy(strategy: CompactionStrategy): void;
     dispose(): void;
     storeSummary(toolCallId: string, summary: CompactionSummary): void;
+    setCompactionCallbacks(callbacks: CompactionCallbacks | undefined): void;
     markSkillsNeedReload(): void;
     checkAndClearSkillsNeedReload(): boolean;
     setAttachments(attachments: AttachmentsRecord): void;
@@ -52,25 +76,43 @@ export declare class ContextV2 implements Context {
     static fromRecord(record: ContextRecordV2, options: ContextV2Options): ContextV2;
     toRecord(): ContextRecordV2;
     setSystemPrompt(prompt: SystemModelMessage): void;
-    private collectPendingInputSummaries;
-    private collectPendingOutputSummaries;
+    addUserMessage(message: UserModelMessage): Promise<void>;
+    addResponse(response: ModelMessage, usage: LanguageModelUsage): Promise<void>;
     /**
-     * Collect protection flags for tool results in this message.
-     * Returns a record mapping toolCallId to protection status, or undefined if none are protected.
-     * Clears the pending protection flags as they are consumed.
+     * Runs the configured compaction strategy after the most recent response
+     * has been stored. For the server-side strategy this is a no-op; for the
+     * client-side strategy it may replace `this.messages` with a compacted set
+     * and flip `skillsNeedReload`.
+     *
+     * Defers when `this.messages` ends in an assistant turn whose `tool_use`
+     * blocks haven't been matched by a `tool_result` message yet. Running
+     * compaction at that point would summarize the assistant message away;
+     * when the matching tool result arrives in the next step it would
+     * reference a `toolCallId` that no longer exists, and
+     * `repairOrphanedToolResults` would strip it on the next `getMessages`.
+     * Waiting for the tool result to arrive first means both halves of the
+     * pair are summarized together — no orphan.
+     *
+     * Triggered from both assistant and tool responses (drop the original
+     * assistant-only gate) so the deferred run can fire on the tool_result
+     * that closes out a step's pending tool calls.
      */
-    private collectPendingProtection;
-    addUserMessage(message: UserModelMessage): Promise<void>;
-    addResponse(response: ModelMessage, usage: LanguageModelUsage, options?: {
-        skipCompaction?: boolean;
-    }): Promise<void>;
+    private runCompactionIfNeeded;
     getMessages(): Promise<ModelMessage[]>;
+    onCompactionDetected(): Promise<void>;
+    /**
+     * Returns deduplicated tool names from messages marked as protected.
+     * Delegates to the active compaction strategy.
+     */
+    getProtectedToolNames(): string[];
+    private appendEvent;
+    private appendCompactionWindow;
+    private toEventLogEntry;
     /**
      * Returns the last known input token count from the most recent assistant message.
      * This represents the cumulative context size at the time of that turn.
      */
     private getLastKnownInputTokens;
     private persist;
-    private compactIfNeeded;
 }
 //# sourceMappingURL=context.d.ts.map

package/dist/ai-service/llm/context-v2/context.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../../../src/ai-service/llm/context-v2/context.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../../../src/ai-service/llm/context-v2/context.ts"],"names":[],"mappings":"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"}

package/dist/ai-service/llm/context-v2/context.js

@@ -1,13 +1,28 @@
 import { getPrefixedLogger } from "../../../util/logger.js";
-import { buildModeMessage } from "../../util/mode-message.js";
 import { findBreakpoints } from "./caching.js";
-import { compact } from "./compactor.js";
+import { ServerSideCompactionStrategy } from "./compaction/server-side.js";
 import { DEFAULT_OPTIONS, DEFAULT_CACHING } from "./config.js";
 import { OperationQueue } from "./operation-queue.js";
-import { getTotalInputTokens, getTotalTokens } from "./token-tracker.js";
-import { toStoredMessage, toSdkMessages, CACHE_BREAKPOINT_PROVIDER_OPTIONS, normalizeToolMessage, stripUndefinedFromToolOutputs, repairBrokenToolCalls, repairOrphanedToolResults, normalizeReasoningProviderOptions, stripUnsignedReasoning, stripTrailingAssistantPrefill, } from "./types.js";
+import { getTotalInputTokens } from "./token-tracker.js";
+import { toStoredMessage, toSdkMessages, CACHE_BREAKPOINT_PROVIDER_OPTIONS, normalizeToolMessage, stripUndefinedFromToolOutputs, repairBrokenToolCalls, repairOrphanedToolResults, normalizeReasoningProviderOptions, stripUnsignedReasoning, stripTrailingAssistantPrefill, extractTokenUsage, } from "./types.js";
 import { uniquifyFilePartFilenames } from "./uniquify-filenames.js";
 const logger = getPrefixedLogger("[context-v2]");
+/**
+ * Whether an assistant message contains `tool-call` content parts whose
+ * matching `tool-result` messages have not been stored yet. Used by
+ * `runCompactionIfNeeded` to defer compaction past the assistant turn that
+ * produced the call until the tool result arrives (otherwise the assistant
+ * tool_use gets summarized away and the upcoming tool_result is orphaned).
+ */
+function hasPendingToolCalls(msg) {
+    if (msg.role !== "assistant" || !Array.isArray(msg.content)) {
+        return false;
+    }
+    return msg.content.some((part) => typeof part === "object" &&
+        part !== null &&
+        "type" in part &&
+        part.type === "tool-call");
+}
 /** Check if a tool message contains an unstripped screenshot media result. */
 function hasScreenshotMedia(msg) {
     if (msg.role !== "tool" || !Array.isArray(msg.content)) {
@@ -65,51 +80,60 @@ export class ContextV2 {
     attachments;
     config;
     caching;
-    summarizationModel;
     queue = new OperationQueue();
     onPersist;
-    compactionCallbacks;
     tracer;
     rootDir;
-    // Pending summaries waiting to be attached to messages
-    pendingInputSummaries = new Map();
-    pendingOutputSummaries = new Map();
-    // Pending protection flags for tool calls (e.g., system skill reads)
-    pendingProtection = new Set();
     skillsNeedReload = false;
     getModeState;
+    eventStore;
+    contextId;
+    compaction;
+    compactionCallbacks;
     // When disposed, this context may still be referenced by in-flight streams.
     // Keep it inert so stale generations cannot persist cleared history.
     isDisposed = false;
     constructor(options) {
         this.rootDir = options.rootDir;
-        this.summarizationModel = options.summarizationModel;
         this.config = { ...DEFAULT_OPTIONS, ...options.config };
         this.caching = { ...DEFAULT_CACHING, ...options.caching };
         this.onPersist = options.onPersist;
-        this.compactionCallbacks = options.compactionCallbacks;
         this.tracer = options.tracer;
         this.getModeState = options.getModeState;
-    }
-    setCompactionCallbacks(callbacks) {
-        this.compactionCallbacks = callbacks;
+        this.eventStore = options.eventStore;
+        this.contextId = options.contextId;
+        this.compaction = options.compaction ?? new ServerSideCompactionStrategy();
     }
     updateConfig(config) {
         this.config = { ...this.config, ...config };
+        this.compaction.updateConfig(config);
+    }
+    /**
+     * Swap the active compaction strategy on a live context. Called from
+     * `ContextManagerV2.getOrCreateContext` on a cache hit when the
+     * incoming `contextManagement` selection (derived from the per-request
+     * LD flag) differs from whatever the cached context was first
+     * constructed with. Without this, the first caller's strategy locks
+     * in for the lifetime of the cache entry and the kill-switch flag
+     * silently no-ops.
+     */
+    setCompactionStrategy(strategy) {
+        if (this.compaction === strategy)
+            return;
+        this.compaction = strategy;
+        this.compaction.updateConfig(this.config);
+        this.compaction.setCallbacks(this.compactionCallbacks);
     }
     dispose() {
         this.isDisposed = true;
         this.onPersist = undefined;
     }
     storeSummary(toolCallId, summary) {
-        if (summary.input) {
-            this.pendingInputSummaries.set(toolCallId, summary.input);
-        }
-        this.pendingOutputSummaries.set(toolCallId, summary.output);
-        // If the summary indicates protection, store that too
-        if (summary.protected) {
-            this.pendingProtection.add(toolCallId);
-        }
+        this.compaction.storeSummary(toolCallId, summary);
+    }
+    setCompactionCallbacks(callbacks) {
+        this.compactionCallbacks = callbacks;
+        this.compaction.setCallbacks(callbacks);
     }
     markSkillsNeedReload() {
         this.skillsNeedReload = true;
@@ -154,70 +178,16 @@ export class ContextV2 {
     setSystemPrompt(prompt) {
         this.systemPrompt = toStoredMessage(prompt);
     }
-    collectPendingInputSummaries(message) {
-        if (message.role !== "assistant" || typeof message.content === "string") {
-            return undefined;
-        }
-        const toolCallIds = message.content
-            .filter((p) => p.type === "tool-call" && p.toolCallId)
-            .map((p) => p.toolCallId);
-        const summaries = {};
-        for (const id of toolCallIds) {
-            const summary = this.pendingInputSummaries.get(id);
-            if (summary) {
-                summaries[id] = summary;
-                this.pendingInputSummaries.delete(id);
-            }
-        }
-        return Object.keys(summaries).length > 0 ? summaries : undefined;
-    }
-    collectPendingOutputSummaries(message) {
-        if (message.role !== "tool" || !Array.isArray(message.content)) {
-            return undefined;
-        }
-        const toolCallIds = message.content
-            .filter((p) => p.type === "tool-result" && p.toolCallId)
-            .map((p) => p.toolCallId);
-        const summaries = {};
-        for (const id of toolCallIds) {
-            const summary = this.pendingOutputSummaries.get(id);
-            if (summary) {
-                summaries[id] = summary;
-                this.pendingOutputSummaries.delete(id);
-            }
-        }
-        return Object.keys(summaries).length > 0 ? summaries : undefined;
-    }
-    /**
-     * Collect protection flags for tool results in this message.
-     * Returns a record mapping toolCallId to protection status, or undefined if none are protected.
-     * Clears the pending protection flags as they are consumed.
-     */
-    collectPendingProtection(message) {
-        if (message.role !== "tool" || !Array.isArray(message.content)) {
-            return undefined;
-        }
-        const toolCallIds = message.content
-            .filter((p) => p.type === "tool-result" && p.toolCallId)
-            .map((p) => p.toolCallId);
-        const protectedResults = {};
-        for (const id of toolCallIds) {
-            if (this.pendingProtection.has(id)) {
-                protectedResults[id] = true;
-                this.pendingProtection.delete(id);
-            }
-        }
-        return Object.keys(protectedResults).length > 0
-            ? protectedResults
-            : undefined;
-    }
     async addUserMessage(message) {
         return this.queue.enqueue(async () => {
-            this.messages.push(toStoredMessage(message));
+            const storedMessage = toStoredMessage(message);
+            this.messages.push(storedMessage);
+            await this.appendEvent("prompt_sent", storedMessage);
         });
     }
-    async addResponse(response, usage, options) {
-        return this.queue.enqueue(async () => {
+    async addResponse(response, usage) {
+        await this.queue.enqueue(async () => {
+            let storedResponse;
             switch (response.role) {
                 case "assistant": {
                     // Total input tokens = non-cached + cached (prompt caching splits these)
@@ -227,14 +197,14 @@ export class ContextV2 {
                     // Use the higher of reported tokens or last known to maintain monotonicity.
                     const lastKnownTokens = this.getLastKnownInputTokens();
                     const cumulativeInputTokens = Math.max(reportedInputTokens, lastKnownTokens);
-                    // Collect pending input summaries for tool-calls in this message
-                    const toolSummaries = this.collectPendingInputSummaries(response);
                     normalizeReasoningProviderOptions(response);
-                    this.messages.push(toStoredMessage(response, {
+                    const extraMeta = this.compaction.collectAssistantMetadata(response) ?? {};
+                    storedResponse = toStoredMessage(response, {
                         cumulativeInputTokens,
                         tokenCount: usage.outputTokens,
-                        ...(toolSummaries && { toolSummaries }),
-                    }));
+                        ...extraMeta,
+                    });
+                    this.messages.push(storedResponse);
                     break;
                 }
                 case "tool": {
@@ -253,31 +223,97 @@ export class ContextV2 {
                             logger.info(`Stripped media from ${strippedCount} older screenshot(s)`);
                         }
                     }
-                    // Collect pending output summaries for tool-results in this message
-                    const toolSummaries = this.collectPendingOutputSummaries(normalized);
-                    // Collect protection flags for individual tool results
-                    const protectedResults = this.collectPendingProtection(normalized);
-                    this.messages.push(toStoredMessage(normalized, {
-                        ...(toolSummaries && { toolSummaries }),
-                        ...(protectedResults && { protected: protectedResults }),
-                    }));
+                    const extraMeta = this.compaction.collectToolMetadata(normalized) ?? {};
+                    storedResponse = toStoredMessage(normalized, extraMeta);
+                    this.messages.push(storedResponse);
                     break;
                 }
                 default:
-                    this.messages.push(toStoredMessage(response));
+                    storedResponse = toStoredMessage(response);
+                    this.messages.push(storedResponse);
                     break;
             }
-            if (!options?.skipCompaction) {
-                await this.compactIfNeeded(usage);
+            if (response.role === "assistant" || response.role === "tool") {
+                const eventUsage = response.role === "assistant" ? extractTokenUsage(usage) : undefined;
+                await this.appendEvent("response_received", storedResponse, eventUsage);
             }
             await this.persist();
         });
+        // After the queued write completes, give the compaction strategy a chance
+        // to react. Server-side is a no-op; client-side may compact this.messages
+        // and flip skillsNeedReload. Must be `await` (not `return`) because the
+        // earlier `await ... .enqueue(...)` already settles before we reach here
+        // — a `return` over the previous line would have made this unreachable.
+        await this.runCompactionIfNeeded(response, usage);
+    }
+    /**
+     * Runs the configured compaction strategy after the most recent response
+     * has been stored. For the server-side strategy this is a no-op; for the
+     * client-side strategy it may replace `this.messages` with a compacted set
+     * and flip `skillsNeedReload`.
+     *
+     * Defers when `this.messages` ends in an assistant turn whose `tool_use`
+     * blocks haven't been matched by a `tool_result` message yet. Running
+     * compaction at that point would summarize the assistant message away;
+     * when the matching tool result arrives in the next step it would
+     * reference a `toolCallId` that no longer exists, and
+     * `repairOrphanedToolResults` would strip it on the next `getMessages`.
+     * Waiting for the tool result to arrive first means both halves of the
+     * pair are summarized together — no orphan.
+     *
+     * Triggered from both assistant and tool responses (drop the original
+     * assistant-only gate) so the deferred run can fire on the tool_result
+     * that closes out a step's pending tool calls.
+     */
+    async runCompactionIfNeeded(response, usage) {
+        if (this.isDisposed)
+            return;
+        if (response.role !== "assistant" && response.role !== "tool")
+            return;
+        return this.queue.enqueue(async () => {
+            const last = this.messages[this.messages.length - 1];
+            if (!last)
+                return;
+            if (last.role === "assistant" && hasPendingToolCalls(last)) {
+                return;
+            }
+            const result = await this.compaction.afterResponse({
+                messages: this.messages,
+                usage,
+            });
+            if (result.messages) {
+                this.messages = result.messages;
+            }
+            if (result.skillsNeedReload) {
+                this.skillsNeedReload = true;
+            }
+            if (result.eventLogAnchor && result.messages) {
+                await this.appendCompactionWindow(result.messages);
+            }
+            if (result.messages) {
+                await this.persist();
+            }
+        });
     }
     async getMessages() {
         return this.queue.enqueue(async () => {
+            // Strip system-role messages from the conversation array before
+            // building the wire payload. The `compaction_received` marker
+            // (written by `onCompactionDetected`, surfaced by
+            // `JsonlEventStore.loadMessages` as the anchor StoredMessage, and
+            // inserted in memory by `ServerSideCompactionStrategy`) carries
+            // `role: "system"` and is useful as an in-memory / on-disk
+            // breadcrumb but is not a valid conversation turn — Anthropic
+            // (and most other providers) only accept system messages at the
+            // start of the request, routed through the dedicated `system`
+            // parameter we set from `this.systemPrompt` below. Letting the
+            // marker through would put a second system-role message in the
+            // middle of the `messages` array and 400 the request on the
+            // first post-compaction turn.
+            const conversationMessages = this.messages.filter((msg) => msg.role !== "system");
             const allMessages = this.systemPrompt
-                ? [this.systemPrompt, ...this.messages]
-                : [...this.messages];
+                ? [this.systemPrompt, ...conversationMessages]
+                : [...conversationMessages];
             // Convert to SDK format (removes _superblocks metadata)
             const sanitized = toSdkMessages(allMessages);
             // Normalize malformed tool outputs and repair broken tool calls.
@@ -332,6 +368,101 @@ export class ContextV2 {
             return deduped;
         });
     }
+    async onCompactionDetected() {
+        // Serialize with `addUserMessage` / `addResponse` / `getMessages`: this
+        // method is driven by the stream observer and can otherwise interleave
+        // with a queued write, leading to lost mutations or torn state.
+        await this.queue.enqueue(async () => {
+            const result = this.compaction.onCompactionDetected(this.messages);
+            if (result.messages) {
+                this.messages = result.messages;
+            }
+            if (result.skillsNeedReload) {
+                this.skillsNeedReload = true;
+            }
+            if (!this.eventStore || !this.contextId) {
+                logger.info("Server-side compaction detected (no event store configured)");
+                return;
+            }
+            const marker = result.messages?.[0];
+            const entry = {
+                type: "compaction_received",
+                timestamp: marker?._superblocks?.timestamp ?? Date.now(),
+                role: "system",
+                content: marker?.content ?? "Server-side compaction applied",
+            };
+            const retainedMessages = result.messages?.slice(1) ?? [];
+            try {
+                await this.eventStore.appendEvent(this.contextId, entry);
+                for (const message of retainedMessages) {
+                    await this.eventStore.appendEvent(this.contextId, this.toEventLogEntry(message));
+                }
+            }
+            catch (err) {
+                logger.error(`Failed to append compaction_received event: ${err}`);
+            }
+            logger.info(`Server-side compaction detected, wrote compaction_received event and replayed ${retainedMessages.length} retained message(s)`);
+        });
+    }
+    /**
+     * Returns deduplicated tool names from messages marked as protected.
+     * Delegates to the active compaction strategy.
+     */
+    getProtectedToolNames() {
+        return this.compaction.getProtectedToolNames(this.messages);
+    }
+    async appendEvent(type, message, usage) {
+        if (!this.eventStore || !this.contextId) {
+            return;
+        }
+        const raw = message;
+        const providerMetadata = raw.providerMetadata;
+        const entry = {
+            type,
+            timestamp: message._superblocks?.timestamp ?? Date.now(),
+            role: message.role,
+            content: message.content,
+            ...(message._superblocks != null
+                ? { _superblocks: message._superblocks }
+                : {}),
+            ...(providerMetadata != null ? { providerMetadata } : {}),
+            ...(usage && { usage }),
+        };
+        try {
+            await this.eventStore.appendEvent(this.contextId, entry);
+        }
+        catch (err) {
+            logger.error(`Failed to append ${type} event: ${err}`);
+        }
+    }
+    async appendCompactionWindow(messages) {
+        if (!this.eventStore || !this.contextId) {
+            return;
+        }
+        try {
+            for (const message of messages) {
+                await this.eventStore.appendEvent(this.contextId, this.toEventLogEntry(message));
+            }
+            logger.info(`Wrote ${messages.length} client-side compaction message(s) to event log`);
+        }
+        catch (err) {
+            logger.error(`Failed to append client-side compaction window: ${err}`);
+        }
+    }
+    toEventLogEntry(message) {
+        const raw = message;
+        const providerMetadata = raw.providerMetadata;
+        return {
+            type: message.role === "user" ? "prompt_sent" : "response_received",
+            timestamp: message._superblocks?.timestamp ?? Date.now(),
+            role: message.role,
+            content: message.content,
+            ...(message._superblocks != null
+                ? { _superblocks: message._superblocks }
+                : {}),
+            ...(providerMetadata != null ? { providerMetadata } : {}),
+        };
+    }
     /**
      * Returns the last known input token count from the most recent assistant message.
      * This represents the cumulative context size at the time of that turn.
@@ -358,60 +489,5 @@ export class ContextV2 {
             }
         }
     }
-    async compactIfNeeded(usage) {
-        const llmReportedTokens = getTotalTokens(usage);
-        const threshold = this.config.contextLimit -
-            this.config.maxOutputTokens -
-            this.config.contextBufferTokens;
-        if (llmReportedTokens <= threshold) {
-            return;
-        }
-        logger.info(`Compaction triggered: ${llmReportedTokens} tokens > ${threshold} threshold ` +
-            `(${this.messages.length} messages)`);
-        const result = await compact({
-            messages: this.messages,
-            usage,
-            model: this.summarizationModel,
-            config: this.config,
-            callbacks: this.compactionCallbacks,
-            tracer: this.tracer,
-            rootDir: this.rootDir,
-        });
-        let phase = "none";
-        if (result.phase2Applied) {
-            phase = "phase1+phase2";
-        }
-        else if (result.phase1Applied) {
-            phase = "phase1";
-        }
-        logger.info(`Compaction complete (${phase}): saved ${result.tokensSaved} tokens, ${this.messages.length}→${result.messages.length} messages`);
-        this.messages = result.messages.map((msg) => ({
-            ...msg,
-            _superblocks: {
-                ...msg._superblocks,
-                timestamp: msg._superblocks?.timestamp ?? Date.now(),
-            },
-        }));
-        if (result.phase2Applied) {
-            // Re-inject mode context that was lost when messages were replaced by the summary.
-            try {
-                const modeState = this.getModeState?.();
-                if (modeState) {
-                    this.messages.push(toStoredMessage({
-                        role: "user",
-                        content: buildModeMessage(modeState.mode, modeState.planApproved),
-                    }));
-                    logger.info(`Re-injected mode context after phase 2 compaction (mode=${modeState.mode})`);
-                }
-                else if (this.getModeState) {
-                    logger.warn("Phase 2 compaction completed but getModeState() returned undefined; " +
-                        "mode context will NOT be re-injected");
-                }
-            }
-            catch (err) {
-                logger.error(`Failed to re-inject mode state after phase 2 compaction: ${err}`);
-            }
-        }
-    }
 }
 //# sourceMappingURL=context.js.map