@aexol/spectral 0.9.229 → 0.9.231

package/dist/sdk/coding-agent/core/compaction/cut-points.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Cut point detection for compaction.
+ *
+ * Pure functions for finding valid compaction cut points and turn boundaries.
+ */
+import type { SessionEntry } from "../session-manager.js";
+/**
+ * Find the user message (or bashExecution) that starts the turn containing the given entry index.
+ * Returns -1 if no turn start found before the index.
+ * BashExecutionMessage is treated like a user message for turn boundaries.
+ */
+export declare function findTurnStartIndex(entries: SessionEntry[], entryIndex: number, startIndex: number): number;
+export interface CutPointResult {
+    /** Index of first entry to keep */
+    firstKeptEntryIndex: number;
+    /** Index of user message that starts the turn being split, or -1 if not splitting */
+    turnStartIndex: number;
+    /** Whether this cut splits a turn (cut point is not a user message) */
+    isSplitTurn: boolean;
+}
+export interface FindCutPointOptions {
+    /**
+     * Explicit phase-boundary compaction should prefer the newest safe boundary
+     * over retaining a large just-finished turn as the recent raw suffix.
+     */
+    phaseBoundary?: boolean;
+    /**
+     * When provided, use this entry id as a fixed cut point instead of walking
+     * backwards from the newest entry. This lets request-time adapters freeze a
+     * previously-computed cut without regenerating the summary.
+     */
+    anchorEntryId?: string;
+    /**
+     * When true, ensure the most recent user message is never folded into the
+     * compaction summary — the cut point is pulled back to (or before) the
+     * latest user message so it survives verbatim. This protects the current
+     * task/brief from being reduced to a truncated excerpt mid-run.
+     */
+    pinLatestUserMessage?: boolean;
+}
+/**
+ * Find the cut point in session entries that keeps approximately `keepRecentTokens`.
+ *
+ * Algorithm: Walk backwards from newest, accumulating estimated message sizes.
+ * Stop when we've accumulated >= keepRecentTokens. Cut at that point.
+ *
+ * Can cut at user OR assistant messages (never tool results). When cutting at an
+ * assistant message with tool calls, its tool results come after and will be kept.
+ *
+ * Returns CutPointResult with:
+ * - firstKeptEntryIndex: the entry index to start keeping from
+ * - turnStartIndex: if cutting mid-turn, the user message that started that turn
+ * - isSplitTurn: whether we're cutting in the middle of a turn
+ *
+ * Only considers entries between `startIndex` and `endIndex` (exclusive).
+ */
+export declare function findCutPoint(entries: SessionEntry[], startIndex: number, endIndex: number, keepRecentTokens: number, options?: FindCutPointOptions): CutPointResult;
+//# sourceMappingURL=cut-points.d.ts.map

package/dist/sdk/coding-agent/core/compaction/cut-points.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cut-points.d.ts","sourceRoot":"","sources":["../../../../../src/sdk/coding-agent/core/compaction/cut-points.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAkD1D;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,CAe1G;AAED,MAAM,WAAW,cAAc;IAC9B,mCAAmC;IACnC,mBAAmB,EAAE,MAAM,CAAC;IAC5B,qFAAqF;IACrF,cAAc,EAAE,MAAM,CAAC;IACvB,uEAAuE;IACvE,WAAW,EAAE,OAAO,CAAC;CACrB;AAED,MAAM,WAAW,mBAAmB;IACnC;;;OAGG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB;;;;OAIG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;;;;;OAKG;IACH,oBAAoB,CAAC,EAAE,OAAO,CAAC;CAC/B;AAcD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,YAAY,CAC3B,OAAO,EAAE,YAAY,EAAE,EACvB,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,EAChB,gBAAgB,EAAE,MAAM,EACxB,OAAO,GAAE,mBAAwB,GAC/B,cAAc,CAgGhB"}

package/dist/sdk/coding-agent/core/compaction/cut-points.js

@@ -0,0 +1,191 @@
+/**
+ * Cut point detection for compaction.
+ *
+ * Pure functions for finding valid compaction cut points and turn boundaries.
+ */
+import { estimateTokens } from "./tokens.js";
+/**
+ * Find valid cut points: indices of user, assistant, custom, or bashExecution messages.
+ * Never cut at tool results (they must follow their tool call).
+ * When we cut at an assistant message with tool calls, its tool results follow it
+ * and will be kept.
+ * BashExecutionMessage is treated like a user message (user-initiated context).
+ */
+function findValidCutPoints(entries, startIndex, endIndex) {
+    const cutPoints = [];
+    for (let i = startIndex; i < endIndex; i++) {
+        const entry = entries[i];
+        switch (entry.type) {
+            case "message": {
+                const role = entry.message.role;
+                switch (role) {
+                    case "bashExecution":
+                    case "custom":
+                    case "branchSummary":
+                    case "compactionSummary":
+                    case "user":
+                    case "assistant":
+                        cutPoints.push(i);
+                        break;
+                    case "toolResult":
+                        break;
+                }
+                break;
+            }
+            case "thinking_level_change":
+            case "model_change":
+            case "compaction":
+            case "branch_summary":
+            case "custom":
+            case "custom_message":
+            case "label":
+            case "session_info":
+                break;
+        }
+        // branch_summary and custom_message are user-role messages, valid cut points
+        if (entry.type === "branch_summary" || entry.type === "custom_message") {
+            cutPoints.push(i);
+        }
+    }
+    return cutPoints;
+}
+/**
+ * Find the user message (or bashExecution) that starts the turn containing the given entry index.
+ * Returns -1 if no turn start found before the index.
+ * BashExecutionMessage is treated like a user message for turn boundaries.
+ */
+export function findTurnStartIndex(entries, entryIndex, startIndex) {
+    for (let i = entryIndex; i >= startIndex; i--) {
+        const entry = entries[i];
+        // branch_summary and custom_message are user-role messages, can start a turn
+        if (entry.type === "branch_summary" || entry.type === "custom_message") {
+            return i;
+        }
+        if (entry.type === "message") {
+            const role = entry.message.role;
+            if (role === "user" || role === "bashExecution") {
+                return i;
+            }
+        }
+    }
+    return -1;
+}
+function isTurnBoundaryEntry(entry) {
+    if (!entry)
+        return false;
+    if (entry.type === "branch_summary" || entry.type === "custom_message")
+        return true;
+    if (entry.type !== "message")
+        return false;
+    const role = entry.message.role;
+    return role === "user" ||
+        role === "bashExecution" ||
+        role === "custom" ||
+        role === "branchSummary" ||
+        role === "compactionSummary";
+}
+/**
+ * Find the cut point in session entries that keeps approximately `keepRecentTokens`.
+ *
+ * Algorithm: Walk backwards from newest, accumulating estimated message sizes.
+ * Stop when we've accumulated >= keepRecentTokens. Cut at that point.
+ *
+ * Can cut at user OR assistant messages (never tool results). When cutting at an
+ * assistant message with tool calls, its tool results come after and will be kept.
+ *
+ * Returns CutPointResult with:
+ * - firstKeptEntryIndex: the entry index to start keeping from
+ * - turnStartIndex: if cutting mid-turn, the user message that started that turn
+ * - isSplitTurn: whether we're cutting in the middle of a turn
+ *
+ * Only considers entries between `startIndex` and `endIndex` (exclusive).
+ */
+export function findCutPoint(entries, startIndex, endIndex, keepRecentTokens, options = {}) {
+    if (options.anchorEntryId) {
+        const anchorIndex = entries.findIndex((entry) => entry.id === options.anchorEntryId);
+        if (anchorIndex >= startIndex && anchorIndex < endIndex) {
+            return { firstKeptEntryIndex: anchorIndex, turnStartIndex: -1, isSplitTurn: false };
+        }
+    }
+    const cutPoints = findValidCutPoints(entries, startIndex, endIndex);
+    if (cutPoints.length === 0) {
+        return { firstKeptEntryIndex: startIndex, turnStartIndex: -1, isSplitTurn: false };
+    }
+    // Walk backwards from newest, accumulating estimated message sizes.
+    // Phase-boundary callers provide an explicit marker, so the newest valid
+    // boundary is the desired cut point and the usual recent-token suffix is not
+    // retained raw.
+    let accumulatedTokens = 0;
+    let cutIndex = options.phaseBoundary
+        ? cutPoints[cutPoints.length - 1]
+        : cutPoints[0]; // Default: keep from first message (not header)
+    if (!options.phaseBoundary) {
+        for (let i = endIndex - 1; i >= startIndex; i--) {
+            const entry = entries[i];
+            if (entry.type !== "message")
+                continue;
+            // Estimate this message's size
+            const messageTokens = estimateTokens(entry.message);
+            accumulatedTokens += messageTokens;
+            // Check if we've exceeded the budget
+            if (accumulatedTokens >= keepRecentTokens) {
+                // Find the closest valid cut point at or after this entry
+                for (let c = 0; c < cutPoints.length; c++) {
+                    if (cutPoints[c] >= i) {
+                        cutIndex = cutPoints[c];
+                        break;
+                    }
+                }
+                break;
+            }
+        }
+    }
+    // Scan backwards from cutIndex to include any non-message entries (bash, settings, etc.)
+    while (cutIndex > startIndex) {
+        const prevEntry = entries[cutIndex - 1];
+        // Stop at session header or compaction boundaries
+        if (prevEntry.type === "compaction") {
+            break;
+        }
+        if (prevEntry.type === "message") {
+            // Stop if we hit any message
+            break;
+        }
+        // Include this non-message entry (bash, settings change, etc.)
+        cutIndex--;
+    }
+    // Pin latest user message: never fold the most recent user message into the
+    // compaction summary. If the computed cut point lands after the latest user
+    // message, pull it back so that message (and everything after) survives
+    // verbatim. This protects the current task/brief from truncation mid-run.
+    if (options.pinLatestUserMessage) {
+        let latestUserIndex = -1;
+        for (let i = endIndex - 1; i >= startIndex; i--) {
+            const entry = entries[i];
+            if (entry.type === "message" && entry.message.role === "user") {
+                latestUserIndex = i;
+                break;
+            }
+        }
+        if (latestUserIndex >= 0 && cutIndex > latestUserIndex) {
+            cutIndex = latestUserIndex;
+            // Re-include any non-message entries (bash, settings, etc.) immediately
+            // before the pinned user message, so we don't lose adjacent context.
+            while (cutIndex > startIndex) {
+                const prevEntry = entries[cutIndex - 1];
+                if (prevEntry.type === "compaction" || prevEntry.type === "message")
+                    break;
+                cutIndex--;
+            }
+        }
+    }
+    // Determine if this is a split turn
+    const cutEntry = entries[cutIndex];
+    const isTurnBoundary = isTurnBoundaryEntry(cutEntry);
+    const turnStartIndex = isTurnBoundary ? -1 : findTurnStartIndex(entries, cutIndex, startIndex);
+    return {
+        firstKeptEntryIndex: cutIndex,
+        turnStartIndex,
+        isSplitTurn: !isTurnBoundary && turnStartIndex !== -1,
+    };
+}

package/dist/sdk/coding-agent/core/compaction/dedupe.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Tool call deduplication for compaction.
+ *
+ * Removes repeated tool calls from message arrays before summarization.
+ */
+import type { AgentMessage } from "../../../agent-core/index.js";
+/**
+ * Deduplicate repeated tool calls in a message array by keeping only the
+ * most recent occurrence of each (tool, args) pair.
+ *
+ * Strategy:
+ * - **Idempotent-read tools** (read, grep, glob): same (name, args) → keep last only.
+ *   These tools return the same content for the same arguments.
+ * - **Output-dependent tools** (bash): same (name, args, output) → keep last only.
+ *   Two bash calls with same command but different output are NOT duplicates.
+ * - **Mutating tools** (edit, write): never deduplicated. Chronological ordering
+ *   of mutations matters for correctness.
+ * - **Unknown tools** (extensions, MCP, custom): never deduplicated. Conservative
+ *   by default — only tools in the known sets above participate.
+ *
+ * Deduplication removes both the ToolCall block from the assistant message
+ * and the corresponding ToolResultMessage from the array.
+ *
+ * Recalculated each time compaction runs — prompt cache is only impacted
+ * alongside compression, not on every turn.
+ */
+export declare function deduplicateToolCalls(messages: AgentMessage[]): AgentMessage[];
+//# sourceMappingURL=dedupe.d.ts.map

package/dist/sdk/coding-agent/core/compaction/dedupe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dedupe.d.ts","sourceRoot":"","sources":["../../../../../src/sdk/coding-agent/core/compaction/dedupe.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAoEjE;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,YAAY,EAAE,GAAG,YAAY,EAAE,CA8E7E"}

package/dist/sdk/coding-agent/core/compaction/dedupe.js

@@ -0,0 +1,156 @@
+/**
+ * Tool call deduplication for compaction.
+ *
+ * Removes repeated tool calls from message arrays before summarization.
+ */
+// ============================================================================
+// Tool Call Deduplication
+// ============================================================================
+/**
+ * Tools that always return the same result for the same arguments.
+ * Same (name, args) from any point in the session = duplicate.
+ * Only the most recent call is kept.
+ */
+const IDEMPOTENT_READ_TOOLS = new Set(["read"]);
+/**
+ * Tools whose output may differ between calls with the same arguments.
+ * Deduplication requires comparing actual outputs to determine equivalence.
+ */
+const OUTPUT_DEPENDENT_TOOLS = new Set(["bash"]);
+/**
+ * Tools that mutate state. Never deduplicated — chronological ordering matters.
+ */
+const MUTABLE_TOOLS = new Set(["edit", "write"]);
+/**
+ * Build a stable string key from a Record's sorted keys.
+ * Ensures {a:1, b:2} and {b:2, a:1} produce the same key.
+ */
+function stableArgs(args) {
+    const sortedKeys = Object.keys(args).sort();
+    const sorted = {};
+    for (const key of sortedKeys) {
+        sorted[key] = args[key];
+    }
+    return JSON.stringify(sorted);
+}
+/**
+ * Compute the deduplication key for a tool call.
+ * - Idempotent-read tools: keyed by (name, args) — same args always same result
+ * - Output-dependent tools: keyed by (name, args, output) — output comparison needed
+ */
+function toolCallDedupKey(toolName, args, toolCallId, resultMap) {
+    const argsKey = stableArgs(args);
+    if (OUTPUT_DEPENDENT_TOOLS.has(toolName)) {
+        const output = resultMap.get(toolCallId) ?? "";
+        return `${toolName}:${argsKey}:${output}`;
+    }
+    return `${toolName}:${argsKey}`;
+}
+/**
+ * Check whether a tool should be excluded from deduplication.
+ * Mutating tools and unknown tools are never deduplicated (conservative).
+ */
+function isMutableOrUnknownTool(toolName) {
+    if (MUTABLE_TOOLS.has(toolName))
+        return true;
+    if (IDEMPOTENT_READ_TOOLS.has(toolName))
+        return false;
+    if (OUTPUT_DEPENDENT_TOOLS.has(toolName))
+        return false;
+    // Unknown tools: conservative — never deduplicate
+    return true;
+}
+/**
+ * Deduplicate repeated tool calls in a message array by keeping only the
+ * most recent occurrence of each (tool, args) pair.
+ *
+ * Strategy:
+ * - **Idempotent-read tools** (read, grep, glob): same (name, args) → keep last only.
+ *   These tools return the same content for the same arguments.
+ * - **Output-dependent tools** (bash): same (name, args, output) → keep last only.
+ *   Two bash calls with same command but different output are NOT duplicates.
+ * - **Mutating tools** (edit, write): never deduplicated. Chronological ordering
+ *   of mutations matters for correctness.
+ * - **Unknown tools** (extensions, MCP, custom): never deduplicated. Conservative
+ *   by default — only tools in the known sets above participate.
+ *
+ * Deduplication removes both the ToolCall block from the assistant message
+ * and the corresponding ToolResultMessage from the array.
+ *
+ * Recalculated each time compaction runs — prompt cache is only impacted
+ * alongside compression, not on every turn.
+ */
+export function deduplicateToolCalls(messages) {
+    if (messages.length === 0)
+        return messages;
+    // Phase 1: Build result lookup for output-dependent tools
+    const resultMap = new Map();
+    for (const msg of messages) {
+        if (msg.role === "toolResult" && Array.isArray(msg.content)) {
+            const text = msg.content
+                .filter((c) => c.type === "text")
+                .map((c) => c.text)
+                .join("\n");
+            resultMap.set(msg.toolCallId, text);
+        }
+    }
+    // Phase 2: Walk newest→oldest, collect keys. The first encounter
+    // (newest) wins; all earlier tool calls with the same key are duplicates.
+    const seen = new Map(); // key → toolCallId (keep newest)
+    const duplicateIds = new Set();
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const msg = messages[i];
+        if (msg.role !== "assistant")
+            continue;
+        if (!("content" in msg) || !Array.isArray(msg.content))
+            continue;
+        // Iterate blocks newest-first: within a single assistant message,
+        // the rightmost tool call is the "most recent" one.
+        for (let j = msg.content.length - 1; j >= 0; j--) {
+            const block = msg.content[j];
+            if (typeof block !== "object" || block === null)
+                continue;
+            if (!("type" in block) || block.type !== "toolCall")
+                continue;
+            const toolBlock = block;
+            if (isMutableOrUnknownTool(toolBlock.name))
+                continue;
+            const key = toolCallDedupKey(toolBlock.name, toolBlock.arguments, toolBlock.id, resultMap);
+            if (seen.has(key)) {
+                duplicateIds.add(toolBlock.id);
+            }
+            else {
+                seen.set(key, toolBlock.id);
+            }
+        }
+    }
+    if (duplicateIds.size === 0)
+        return messages;
+    // Phase 3: Filter out duplicate tool results and strip duplicate
+    // ToolCall blocks from assistant messages.
+    const deduped = [];
+    let modified = false;
+    for (const msg of messages) {
+        if (msg.role === "toolResult" && duplicateIds.has(msg.toolCallId)) {
+            modified = true;
+            continue;
+        }
+        if (msg.role === "assistant" && "content" in msg && Array.isArray(msg.content)) {
+            const originalLength = msg.content.length;
+            const filteredContent = msg.content.filter((block) => {
+                if (typeof block !== "object" || block === null)
+                    return true;
+                if (!("type" in block) || block.type !== "toolCall")
+                    return true;
+                return !duplicateIds.has(block.id);
+            });
+            if (filteredContent.length < originalLength) {
+                modified = true;
+                deduped.push({ ...msg, content: filteredContent });
+                continue;
+            }
+        }
+        deduped.push(msg);
+    }
+    return modified ? deduped : messages;
+}

package/dist/sdk/coding-agent/core/compaction/summarize.d.ts

@@ -0,0 +1,21 @@
+/**
+ * LLM summarization for compaction.
+ *
+ * Prompts and helpers for generating conversation summaries via the LLM.
+ */
+import type { AgentMessage, StreamFn, ThinkingLevel } from "../../../agent-core/index.js";
+import type { Model } from "../../../ai/index.js";
+/**
+ * Generate a summary of the conversation using the LLM.
+ * If previousSummary is provided, uses the update prompt to merge.
+ *
+ * @deprecated The active coding-agent session path uses deterministic DCP-lite
+ * (`compactDcpLite`) plus `session_before_compact` hook details. This legacy
+ * LLM summarizer remains exported for compatibility with older callers only.
+ */
+export declare function generateSummary(currentMessages: AgentMessage[], model: Model<any>, reserveTokens: number, apiKey: string | undefined, headers?: Record<string, string>, signal?: AbortSignal, customInstructions?: string, previousSummary?: string, thinkingLevel?: ThinkingLevel, streamFn?: StreamFn): Promise<string>;
+/**
+ * Generate a summary for a turn prefix (when splitting a turn).
+ */
+export declare function generateTurnPrefixSummary(messages: AgentMessage[], model: Model<any>, reserveTokens: number, apiKey: string | undefined, headers?: Record<string, string>, signal?: AbortSignal, thinkingLevel?: ThinkingLevel, streamFn?: StreamFn): Promise<string>;
+//# sourceMappingURL=summarize.d.ts.map

package/dist/sdk/coding-agent/core/compaction/summarize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"summarize.d.ts","sourceRoot":"","sources":["../../../../../src/sdk/coding-agent/core/compaction/summarize.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAC1F,OAAO,KAAK,EAA6B,KAAK,EAAuB,MAAM,sBAAsB,CAAC;AAmHlG;;;;;;;GAOG;AACH,wBAAsB,eAAe,CACpC,eAAe,EAAE,YAAY,EAAE,EAC/B,KAAK,EAAE,KAAK,CAAC,GAAG,CAAC,EACjB,aAAa,EAAE,MAAM,EACrB,MAAM,EAAE,MAAM,GAAG,SAAS,EAC1B,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAChC,MAAM,CAAC,EAAE,WAAW,EACpB,kBAAkB,CAAC,EAAE,MAAM,EAC3B,eAAe,CAAC,EAAE,MAAM,EACxB,aAAa,CAAC,EAAE,aAAa,EAC7B,QAAQ,CAAC,EAAE,QAAQ,GACjB,OAAO,CAAC,MAAM,CAAC,CAmDjB;AAiBD;;GAEG;AACH,wBAAsB,yBAAyB,CAC9C,QAAQ,EAAE,YAAY,EAAE,EACxB,KAAK,EAAE,KAAK,CAAC,GAAG,CAAC,EACjB,aAAa,EAAE,MAAM,EACrB,MAAM,EAAE,MAAM,GAAG,SAAS,EAC1B,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAChC,MAAM,CAAC,EAAE,WAAW,EACpB,aAAa,CAAC,EAAE,aAAa,EAC7B,QAAQ,CAAC,EAAE,QAAQ,GACjB,OAAO,CAAC,MAAM,CAAC,CA+BjB"}

package/dist/sdk/coding-agent/core/compaction/summarize.js

@@ -0,0 +1,181 @@
+/**
+ * LLM summarization for compaction.
+ *
+ * Prompts and helpers for generating conversation summaries via the LLM.
+ */
+import { completeSimple } from "../../../ai/index.js";
+import { convertToLlm } from "../messages.js";
+import { SUMMARIZATION_SYSTEM_PROMPT, serializeConversation } from "./utils.js";
+// ============================================================================
+// Summarization
+// ============================================================================
+// Legacy LLM summarization path. AgentSession now builds persisted compaction
+// entries with deterministic DCP-lite (`compactDcpLite`) and lets
+// `session_before_compact` hooks provide memory details. Keep these exports for
+// compatibility with external SDK callers and older harness code, but do not
+// route new session compaction work through this model-generated fallback.
+const SUMMARIZATION_PROMPT = `The messages above are a conversation to summarize. Create a structured context checkpoint summary that another LLM will use to continue the work.
+
+Use this EXACT format:
+
+## Goal
+[What is the user trying to accomplish? Can be multiple items if the session covers different tasks.]
+
+## Constraints & Preferences
+- [Any constraints, preferences, or requirements mentioned by user]
+- [Or "(none)" if none were mentioned]
+
+## Progress
+### Done
+- [x] [Completed tasks/changes]
+
+### In Progress
+- [ ] [Current work]
+
+### Blocked
+- [Issues preventing progress, if any]
+
+## Key Decisions
+- **[Decision]**: [Brief rationale]
+
+## Next Steps
+1. [Ordered list of what should happen next]
+
+## Critical Context
+- [Any data, examples, or references needed to continue]
+- [Or "(none)" if not applicable]
+
+Keep each section concise. Preserve exact file paths, function names, and error messages.`;
+const UPDATE_SUMMARIZATION_PROMPT = `The messages above are NEW conversation messages to incorporate into the existing summary provided in <previous-summary> tags.
+
+Update the existing structured summary with new information. RULES:
+- PRESERVE all existing information from the previous summary
+- ADD new progress, decisions, and context from the new messages
+- UPDATE the Progress section: move items from "In Progress" to "Done" when completed
+- UPDATE "Next Steps" based on what was accomplished
+- PRESERVE exact file paths, function names, and error messages
+- If something is no longer relevant, you may remove it
+
+Use this EXACT format:
+
+## Goal
+[Preserve existing goals, add new ones if the task expanded]
+
+## Constraints & Preferences
+- [Preserve existing, add new ones discovered]
+
+## Progress
+### Done
+- [x] [Include previously done items AND newly completed items]
+
+### In Progress
+- [ ] [Current work - update based on progress]
+
+### Blocked
+- [Current blockers - remove if resolved]
+
+## Key Decisions
+- **[Decision]**: [Brief rationale] (preserve all previous, add new)
+
+## Next Steps
+1. [Update based on current state]
+
+## Critical Context
+- [Preserve important context, add new if needed]
+
+Keep each section concise. Preserve exact file paths, function names, and error messages.`;
+function createSummarizationOptions(model, maxTokens, apiKey, headers, signal, thinkingLevel) {
+    const options = { maxTokens, signal, apiKey, headers };
+    if (model.reasoning && thinkingLevel && thinkingLevel !== "off") {
+        options.reasoning = thinkingLevel;
+    }
+    return options;
+}
+async function completeSummarization(model, context, options, streamFn) {
+    if (!streamFn) {
+        return completeSimple(model, context, options);
+    }
+    const stream = await streamFn(model, context, options);
+    return stream.result();
+}
+/**
+ * Generate a summary of the conversation using the LLM.
+ * If previousSummary is provided, uses the update prompt to merge.
+ *
+ * @deprecated The active coding-agent session path uses deterministic DCP-lite
+ * (`compactDcpLite`) plus `session_before_compact` hook details. This legacy
+ * LLM summarizer remains exported for compatibility with older callers only.
+ */
+export async function generateSummary(currentMessages, model, reserveTokens, apiKey, headers, signal, customInstructions, previousSummary, thinkingLevel, streamFn) {
+    const maxTokens = Math.min(Math.floor(0.8 * reserveTokens), model.maxTokens > 0 ? model.maxTokens : Number.POSITIVE_INFINITY);
+    // Use update prompt if we have a previous summary, otherwise initial prompt
+    let basePrompt = previousSummary ? UPDATE_SUMMARIZATION_PROMPT : SUMMARIZATION_PROMPT;
+    if (customInstructions) {
+        basePrompt = `${basePrompt}\n\nAdditional focus: ${customInstructions}`;
+    }
+    // Serialize conversation to text so model doesn't try to continue it
+    // Convert to LLM messages first (handles custom types like bashExecution, custom, etc.)
+    const llmMessages = convertToLlm(currentMessages);
+    const conversationText = serializeConversation(llmMessages);
+    // Build the prompt with conversation wrapped in tags
+    let promptText = `<conversation>\n${conversationText}\n</conversation>\n\n`;
+    if (previousSummary) {
+        promptText += `<previous-summary>\n${previousSummary}\n</previous-summary>\n\n`;
+    }
+    promptText += basePrompt;
+    const summarizationMessages = [
+        {
+            role: "user",
+            content: [{ type: "text", text: promptText }],
+            timestamp: Date.now(),
+        },
+    ];
+    const completionOptions = createSummarizationOptions(model, maxTokens, apiKey, headers, signal, thinkingLevel);
+    const response = await completeSummarization(model, { systemPrompt: SUMMARIZATION_SYSTEM_PROMPT, messages: summarizationMessages }, completionOptions, streamFn);
+    if (response.stopReason === "error") {
+        throw new Error(`Summarization failed: ${response.errorMessage || "Unknown error"}`);
+    }
+    const textContent = response.content
+        .filter((c) => c.type === "text")
+        .map((c) => c.text)
+        .join("\n");
+    return textContent;
+}
+const TURN_PREFIX_SUMMARIZATION_PROMPT = `This is the PREFIX of a turn that was too large to keep. The SUFFIX (recent work) is retained.
+
+Summarize the prefix to provide context for the retained suffix:
+
+## Original Request
+[What did the user ask for in this turn?]
+
+## Early Progress
+- [Key decisions and work done in the prefix]
+
+## Context for Suffix
+- [Information needed to understand the retained recent work]
+
+Be concise. Focus on what's needed to understand the kept suffix.`;
+/**
+ * Generate a summary for a turn prefix (when splitting a turn).
+ */
+export async function generateTurnPrefixSummary(messages, model, reserveTokens, apiKey, headers, signal, thinkingLevel, streamFn) {
+    const maxTokens = Math.min(Math.floor(0.5 * reserveTokens), model.maxTokens > 0 ? model.maxTokens : Number.POSITIVE_INFINITY); // Smaller budget for turn prefix
+    const llmMessages = convertToLlm(messages);
+    const conversationText = serializeConversation(llmMessages);
+    const promptText = `<conversation>\n${conversationText}\n</conversation>\n\n${TURN_PREFIX_SUMMARIZATION_PROMPT}`;
+    const summarizationMessages = [
+        {
+            role: "user",
+            content: [{ type: "text", text: promptText }],
+            timestamp: Date.now(),
+        },
+    ];
+    const response = await completeSummarization(model, { systemPrompt: SUMMARIZATION_SYSTEM_PROMPT, messages: summarizationMessages }, createSummarizationOptions(model, maxTokens, apiKey, headers, signal, thinkingLevel), streamFn);
+    if (response.stopReason === "error") {
+        throw new Error(`Turn prefix summarization failed: ${response.errorMessage || "Unknown error"}`);
+    }
+    return response.content
+        .filter((c) => c.type === "text")
+        .map((c) => c.text)
+        .join("\n");
+}