pi-smart-compact 7.5.0

package/src/phases/explore.ts

@@ -0,0 +1,371 @@
+/**
+ * Phase 2: Targeted LLM Exploration.
+ */
+
+import type { Model, Api } from "@earendil-works/pi-ai";
+import type { LlmMessage, StructuredExtraction, ExplorationReport, TopicBoundary, CacheAwareOptions } from "../types.ts";
+import { COMPACT_SYSTEM_PREFIX, EXPLORER_SYSTEM_PROMPT } from "../constants.ts";
+import { extractText, extractMainGoal, extractStructured } from "../utils/extraction.ts";
+import { trackedComplete, cacheOpts } from "../utils/cache.ts";
+
+// ── Tool Support Cache with TTL ──
+const _toolSupportCache = new Map<string, { result: boolean; timestamp: number }>();
+const TOOL_CACHE_TTL = 30 * 60 * 1000; // 30 minutes
+
+export function clearToolSupportCache(): void {
+  const now = Date.now();
+  for (const [k, v] of _toolSupportCache) {
+    if (now - v.timestamp > TOOL_CACHE_TTL) _toolSupportCache.delete(k);
+  }
+}
+
+/**
+ * Determine whether exploration is worthwhile based on session complexity.
+ * Simple sessions (few topics, few errors, few decisions) skip exploration
+ * and rely on heuristic boundaries instead — saving 3-8 LLM calls.
+ */
+export function shouldExplore(extraction: StructuredExtraction): boolean {
+  const unresolvedErrors = extraction.errors.filter(e => !e.resolved).length;
+  const topicCount = extraction.topics.length;
+  const decisionCount = extraction.decisions.length;
+  const crossFileWork = new Set(extraction.modifiedFiles.map(f => {
+    const parts = f.path.split("/");
+    return parts.length > 1 ? parts.slice(0, -1).join("/") : "root";
+  })).size;
+
+  // Skip exploration if session is simple
+  if (topicCount <= 3 && unresolvedErrors <= 1 && decisionCount <= 2 && crossFileWork <= 2) {
+    return false;
+  }
+  return true;
+}
+
+const EXPLORATION_TOOLS = [
+  {
+    name: "get_message_range", description: "Get compact summaries of messages from start to end index (0-based).",
+    parameters: { type: "object", properties: { start: { type: "number" }, end: { type: "number" } }, required: ["start", "end"] },
+  },
+  {
+    name: "search_conversation", description: "Search for text in conversation messages.",
+    parameters: { type: "object", properties: { query: { type: "string" } }, required: ["query"] },
+  },
+  {
+    name: "get_recent_user_messages", description: "Get the last N user messages.",
+    parameters: { type: "object", properties: { count: { type: "number" } } },
+  },
+  {
+    name: "get_context_around", description: "Get context around a specific message index.",
+    parameters: { type: "object", properties: { index: { type: "number" }, radius: { type: "number" } }, required: ["index"] },
+  },
+  {
+    name: "get_file_changes", description: "Get tool calls that modified a specific file.",
+    parameters: { type: "object", properties: { path: { type: "string" } }, required: ["path"] },
+  },
+  {
+    name: "get_error_chain", description: "Get all messages related to a specific error.",
+    parameters: { type: "object", properties: { index: { type: "number" }, context_radius: { type: "number" } }, required: ["index"] },
+  },
+];
+
+export function executeExplorationTool(call: { name: string; arguments: Record<string, unknown> }, llmMessages: LlmMessage[]): string {
+  const args = call.arguments ?? {};
+  switch (call.name) {
+    case "get_message_range": {
+      const s = (args.start as number) ?? 0, e = Math.min((args.end as number) ?? llmMessages.length, llmMessages.length);
+      return JSON.stringify(llmMessages.slice(s, e).map((m, i) => ({
+        idx: s + i, role: m?.role,
+        preview: extractText(m?.content).slice(0, 150),
+        toolCalls: ((m?.content ?? []) as unknown[]).filter((b: any) => b?.type === "toolCall").map((b: any) => b.name),
+        isError: m?.isError,
+      })));
+    }
+    case "search_conversation": {
+      const q = ((args.query as string) ?? "").toLowerCase();
+      return JSON.stringify(llmMessages.filter((m) => JSON.stringify(m).toLowerCase().includes(q)).slice(0, 10).map((m) => ({
+        idx: llmMessages.indexOf(m), role: m?.role, preview: extractText(m?.content).slice(0, 150),
+      })));
+    }
+    case "get_recent_user_messages": {
+      const count = (args.count as number) ?? 10;
+      return JSON.stringify(llmMessages.filter((m) => m?.role === "user").slice(-count).map((m) => extractText(m.content)));
+    }
+    case "get_context_around": {
+      const idx = (args.index as number) ?? 0, radius = (args.radius as number) ?? 5;
+      const s = Math.max(0, idx - radius), e = Math.min(llmMessages.length, idx + radius + 1);
+      return JSON.stringify(llmMessages.slice(s, e).map((m, i) => ({
+        idx: s + i, role: m?.role,
+        text: extractText(m?.content).slice(0, 300),
+        toolCalls: ((m?.content ?? []) as unknown[]).filter((b: any) => b?.type === "toolCall").map((b: any) => b.name),
+        isError: m?.isError,
+      })));
+    }
+    case "get_file_changes": {
+      const target = ((args.path as string) ?? "").toLowerCase();
+      const results: unknown[] = [];
+      for (let i = 0; i < llmMessages.length; i++) {
+        const blocks = (llmMessages[i]?.content ?? []) as unknown[];
+        for (const b of blocks) {
+          const block = b as { type?: string; name?: string; arguments?: Record<string, unknown> };
+          if (block?.type === "toolCall" && block.name === "edit" && JSON.stringify(block).toLowerCase().includes(target)) {
+            results.push({ idx: i, role: "assistant", toolCall: "edit", args: block.arguments, preview: extractText(llmMessages[i]?.content).slice(0, 400) });
+          }
+          if (block?.type === "toolCall" && block.name === "write" && JSON.stringify(block).toLowerCase().includes(target)) {
+            results.push({ idx: i, role: "assistant", toolCall: "write", preview: extractText(llmMessages[i]?.content).slice(0, 400) });
+          }
+        }
+      }
+      return JSON.stringify(results.slice(0, 15) || [{ info: "No edits found for: " + args.path }]);
+    }
+    case "get_error_chain": {
+      const errIdx = (args.index as number) ?? 0;
+      const ctxRadius = (args.context_radius as number) ?? 8;
+      const s = Math.max(0, errIdx - ctxRadius), e = Math.min(llmMessages.length, errIdx + ctxRadius + 1);
+      return JSON.stringify(llmMessages.slice(s, e).map((m, i) => ({
+        idx: s + i, role: m?.role,
+        text: extractText(m?.content).slice(0, 500),
+        isError: m?.isError,
+        toolCalls: ((m?.content ?? []) as unknown[]).filter((b: any) => b?.type === "toolCall").map((b: any) => b.name),
+      })));
+    }
+    default: return "Unknown tool: " + call.name;
+  }
+}
+
+export function parseExplorationReport(text: string, llmMessages: LlmMessage[]): ExplorationReport {
+  let json = text.trim();
+  const md = text.match(/```(?:json)?\s*([\s\S]*?)```/);
+  if (md) json = md[1].trim();
+
+  let s = json.indexOf("{"), e = json.lastIndexOf("}");
+  if (s === -1 || e === -1) return fallbackExplorationReport(llmMessages);
+  let rawJson = json.slice(s, e + 1);
+
+  try { return buildExplorationReportFromParsed(JSON.parse(rawJson), llmMessages); } catch {}
+
+  const cleaned = rawJson.replace(/,\s*([}\]])/g, "$1").replace(/'/g, "\"").replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "");
+  try { return buildExplorationReportFromParsed(JSON.parse(cleaned), llmMessages); } catch {}
+
+  const boundaryMatch = rawJson.match(/"boundaries"\s*:\s*\[([\s\S]*?)\]/);
+  if (boundaryMatch) {
+    try {
+      const boundaries = JSON.parse("[" + boundaryMatch[1] + "]");
+      return { ...fallbackExplorationReport(llmMessages), boundaries: boundaries.filter((b: any) => typeof b?.afterIndex === "number").map((b: any) => ({
+        afterIndex: Math.min(b.afterIndex, llmMessages.length - 2),
+        topic: String(b.topic ?? "").slice(0, 100),
+        priority: ["critical", "high", "normal", "low"].includes(b.priority) ? b.priority : "normal",
+        confidence: Math.min(1, Math.max(0, b.confidence ?? 0.5)),
+      })) };
+    } catch {}
+  }
+  return fallbackExplorationReport(llmMessages);
+}
+
+export function buildExplorationReportFromParsed(parsed: any, llmMessages: LlmMessage[]): ExplorationReport {
+  return {
+    boundaries: (parsed.boundaries ?? []).filter((b: any) => typeof b?.afterIndex === "number").map((b: any) => ({
+      afterIndex: Math.min(b.afterIndex, llmMessages.length - 2),
+      topic: String(b.topic ?? "").slice(0, 100),
+      priority: ["critical", "high", "normal", "low"].includes(b.priority) ? b.priority : "normal",
+      confidence: Math.min(1, Math.max(0, b.confidence ?? 0.5)),
+    })),
+    mainGoal: parsed.mainGoal ?? "",
+    sessionType: ["implementation", "review", "debugging", "discussion"].includes(parsed.sessionType) ? parsed.sessionType : "implementation",
+    enrichedConstraints: Array.isArray(parsed.enrichedConstraints) ? parsed.enrichedConstraints.map(String) : [],
+    crossReferences: Array.isArray(parsed.crossReferences) ? parsed.crossReferences.map(String) : [],
+    statusAssessment: {
+      done: Array.isArray(parsed.statusAssessment?.done) ? parsed.statusAssessment.done.map(String) : [],
+      inProgress: Array.isArray(parsed.statusAssessment?.inProgress) ? parsed.statusAssessment.inProgress.map(String) : [],
+      blocked: Array.isArray(parsed.statusAssessment?.blocked) ? parsed.statusAssessment.blocked.map(String) : [],
+    },
+    criticalContext: Array.isArray(parsed.criticalContext) ? parsed.criticalContext.map(String) : [],
+    keyDecisions: Array.isArray(parsed.keyDecisions) ? parsed.keyDecisions.map(String) : [],
+  };
+}
+
+export function fallbackExplorationReport(llmMessages: LlmMessage[]): ExplorationReport {
+  return {
+    boundaries: [], mainGoal: extractMainGoal(llmMessages) ?? "", sessionType: "implementation",
+    enrichedConstraints: [], crossReferences: [],
+    statusAssessment: { done: [], inProgress: [], blocked: [] },
+    criticalContext: [], keyDecisions: [],
+  };
+}
+
+export async function exploreConversation(
+  llmMessages: LlmMessage[], extraction: StructuredExtraction,
+  model: Model<Api>, auth: { apiKey: string; headers?: Record<string, string> },
+  prevSummary: string | undefined, userNote: string | undefined,
+  signal?: AbortSignal, maxRounds = 8,
+  notify?: (msg: string, type?: "info" | "success" | "warning" | "error") => void,
+): Promise<{ report: ExplorationReport; rounds: number; toolSupported: boolean }> {
+
+  const extractionContext = [
+    "## Deterministic Extraction (verified facts)",
+    "Message count: " + extraction.messageCount,
+    "Main goal: " + (extraction.mainGoal ?? "unknown"),
+    "Files modified (" + extraction.modifiedFiles.length + "): " + (extraction.modifiedFiles.map(f => f.path).join(", ") || "none"),
+    "Files read (" + extraction.readFiles.length + "): " + (extraction.readFiles.join(", ") || "none"),
+    "Errors (" + extraction.errors.length + "): " + (extraction.errors.map(e => "[" + e.tool + "] " + e.message.slice(0, 80) + (e.resolved ? " (resolved)" : e.retryAttempted ? " (retry attempted)" : "")).join("; ") || "none"),
+    "Decisions (" + extraction.decisions.length + "): " + (extraction.decisions.map(d => d.type + ": " + d.summary.slice(0, 80)).join("; ") || "none"),
+    "Constraints (" + extraction.constraints.length + "): " + (extraction.constraints.map(cc => "[" + cc.category + "] " + cc.text.slice(0, 80)).join("; ") || "none"),
+    "Heuristic topics (" + extraction.topics.length + "): " + (extraction.topics.map(t => "[" + t.startIndex + "-" + t.endIndex + "] " + t.type).join("; ") || "none"),
+    extraction.lastUserMessages.length ? "Last user messages: " + extraction.lastUserMessages.map(m => m.slice(0, 100)).join(" | ") : "",
+    extraction.lastErrors.length ? "Last errors: " + extraction.lastErrors.map(e => e.slice(0, 100)).join(" | ") : "",
+  ].filter(Boolean).join("\n");
+
+  const userContent = "Explore this conversation and produce the structured report.\n\n" +
+    extractionContext +
+    (prevSummary ? "\n\n## Previous Summary\n" + prevSummary : "") +
+    (userNote ? "\n\n## User Steering\n\"" + userNote + "\"" : "");
+
+  // Check tool support cache before probe
+  const cacheKey = model.provider + "/" + model.id;
+  const cachedSupport = _toolSupportCache.get(cacheKey);
+  const cacheValid = cachedSupport && Date.now() - cachedSupport.timestamp < TOOL_CACHE_TTL;
+
+  let supportsTools = false;
+  try {
+    if (cacheValid && !cachedSupport!.result) {
+      // Provider known to not support tools — skip probe
+      if (notify) notify("Tool support cached: unsupported (" + cacheKey + ")", "info");
+      const report = await directExploration(llmMessages, extraction, model, auth, prevSummary, userNote, signal);
+      if (!report.boundaries.length) {
+        const retried = await explorationRetry(model, auth, llmMessages, extraction, prevSummary, userNote, signal);
+        if (retried.boundaries.length) return { report: retried, rounds: 1, toolSupported: false };
+      }
+      return { report, rounds: 0, toolSupported: false };
+    }
+
+    const probeResp = await trackedComplete("explore", model, {
+      systemPrompt: COMPACT_SYSTEM_PREFIX,
+      messages: [{ role: "user", content: [{ type: "text", text: userContent }] }],
+      tools: EXPLORATION_TOOLS as any,
+    }, cacheOpts({ apiKey: auth.apiKey, headers: auth.headers, signal }));
+
+    const toolCalls = ((probeResp?.content ?? []) as unknown[]).filter((c: any) => c?.type === "toolCall");
+
+    if (toolCalls.length > 0) {
+      supportsTools = true;
+      _toolSupportCache.set(cacheKey, { result: true, timestamp: Date.now() });
+      const messages: any[] = [
+        { role: "user", content: [{ type: "text", text: userContent }], timestamp: Date.now() },
+        { role: "assistant", content: probeResp.content, timestamp: Date.now() },
+      ];
+      for (const tc of toolCalls) {
+        const result = executeExplorationTool({ name: tc.name, arguments: tc.arguments }, llmMessages);
+        messages.push({ role: "toolResult", toolCallId: tc.id, toolName: tc.name, content: [{ type: "text", text: result }], isError: false, timestamp: Date.now() });
+      }
+
+      let rounds = 1;
+      while (rounds < maxRounds) {
+        rounds++;
+        let response: any;
+        try {
+          response = await trackedComplete("explore-loop", model, {
+            systemPrompt: COMPACT_SYSTEM_PREFIX + "\n\n" + EXPLORER_SYSTEM_PROMPT,
+            messages,
+            tools: EXPLORATION_TOOLS as any,
+          }, cacheOpts({ apiKey: auth.apiKey, headers: auth.headers, signal }));
+        } catch {
+          break;
+        }
+
+        const nextToolCalls = ((response?.content ?? []) as unknown[]).filter((c: any) => c?.type === "toolCall");
+        if (nextToolCalls.length === 0) {
+          const text = ((response?.content ?? []) as unknown[]).filter((c: any) => c?.type === "text").map((c: any) => c.text).join("\n").trim();
+          let report = parseExplorationReport(text, llmMessages);
+          if (!report.boundaries.length) {
+            report = await directExploration(llmMessages, extraction, model, auth, prevSummary, userNote, signal);
+            if (report.boundaries.length) rounds++;
+          }
+          return { report, rounds, toolSupported: true };
+        }
+
+        messages.push({ role: "assistant", content: response.content, timestamp: Date.now() });
+        for (const tc of nextToolCalls) {
+          const result = executeExplorationTool({ name: tc.name, arguments: tc.arguments }, llmMessages);
+          messages.push({ role: "toolResult", toolCallId: tc.id, toolName: tc.name, content: [{ type: "text", text: result }], isError: false, timestamp: Date.now() });
+        }
+      }
+
+      const lastAssistant = messages.filter((m: any) => m.role === "assistant").pop();
+      if (lastAssistant) {
+        const text = (lastAssistant.content ?? []).filter((c: any) => c?.type === "text").map((c: any) => c.text).join("\n").trim();
+        const report = parseExplorationReport(text, llmMessages);
+        if (report.boundaries.length) return { report, rounds, toolSupported: true };
+      }
+    } else {
+      const text = ((probeResp?.content ?? []) as unknown[]).filter((c: any) => c?.type === "text").map((c: any) => c.text).join("\n").trim();
+      let report = parseExplorationReport(text, llmMessages);
+      if (!report.boundaries.length) {
+        report = await directExploration(llmMessages, extraction, model, auth, prevSummary, userNote, signal);
+      }
+      return { report, rounds: 1, toolSupported: true };
+    }
+    // Provider responded without tool calls — still counts as tool-capable for this session
+  } catch {
+    // Probe failed — cache as unsupported
+    _toolSupportCache.set(cacheKey, { result: false, timestamp: Date.now() });
+    if (notify) notify("Tool calling not supported, using direct exploration", "warning");
+  }
+
+  const report = await directExploration(llmMessages, extraction, model, auth, prevSummary, userNote, signal);
+  if (!report.boundaries.length) {
+    const retried = await explorationRetry(model, auth, llmMessages, extraction, prevSummary, userNote, signal);
+    if (retried.boundaries.length) return { report: retried, rounds: 1, toolSupported: false };
+  }
+  return { report, rounds: 0, toolSupported: supportsTools };
+}
+
+export async function explorationRetry(
+  model: Model<Api>, auth: { apiKey: string; headers?: Record<string, string> },
+  llmMessages: LlmMessage[], extraction: StructuredExtraction,
+  prevSummary: string | undefined, userNote: string | undefined,
+  signal?: AbortSignal,
+): Promise<ExplorationReport> {
+  const last5 = llmMessages.slice(-5).map((m) => "[" + m?.role + "] " + extractText(m?.content).slice(0, 150)).join("\n");
+  const retryPrompt = "IMPORTANT: Output ONLY valid raw JSON. No markdown. No explanation. No code fences. Just the JSON object.\n\n" +
+    "Produce this exact structure:\n{\"mainGoal\":\"...\",\"sessionType\":\"implementation|review|debugging|discussion\",\"boundaries\":[{\"afterIndex\":N,\"topic\":\"...\",\"priority\":\"normal\",\"confidence\":0.5}],\"enrichedConstraints\":[],\"crossReferences\":[],\"statusAssessment\":{\"done\":[],\"inProgress\":[],\"blocked\":[]},\"criticalContext\":[],\"keyDecisions\":[]}\n\n" +
+    "Context:\nFiles: " + extraction.modifiedFiles.map(f => f.path).join(", ") + "\n" +
+    "Topics heuristic: " + extraction.topics.map(t => "[" + t.startIndex + "-" + t.endIndex + "]").join(", ") + "\n" +
+    "Last messages:\n" + last5 +
+    (userNote ? "\nUser steering: " + userNote : "");
+
+  try {
+    const resp = await trackedComplete("explore-retry", model, {
+      systemPrompt: COMPACT_SYSTEM_PREFIX,
+      messages: [{ role: "user", content: [{ type: "text", text: retryPrompt }] }],
+    }, cacheOpts({ apiKey: auth.apiKey, headers: auth.headers, maxTokens: 4096, signal }));
+    const text = (resp.content as any[]).filter((c: any) => c?.type === "text").map((c: any) => c.text).join("").trim();
+    return parseExplorationReport(text, llmMessages);
+  } catch { return fallbackExplorationReport(llmMessages); }
+}
+
+export async function directExploration(
+  llmMessages: LlmMessage[], extraction: StructuredExtraction,
+  model: Model<Api>, auth: { apiKey: string; headers?: Record<string, string> },
+  prevSummary: string | undefined, userNote: string | undefined,
+  signal?: AbortSignal,
+): Promise<ExplorationReport> {
+  const first3 = llmMessages.filter((m) => m?.role === "user").slice(0, 3).map((m) => extractText(m?.content).slice(0, 200)).join("\n---\n");
+  const last30 = llmMessages.slice(-30).map((m) => "[" + m?.role + "] " + extractText(m?.content).slice(0, 300)).join("\n");
+  const prompt = "Analyze this conversation and produce a JSON report.\n\nFirst user messages:\n" + first3 +
+    "\n\nDeterministic data:\n" +
+    "- Files modified: " + (extraction.modifiedFiles.map(f => f.path).join(", ") || "none") +
+    "\n- Errors: " + (extraction.errors.map(e => e.message.slice(0, 80)).join("; ") || "none") +
+    "\n- Decisions: " + (extraction.decisions.map(d => d.summary.slice(0, 80)).join("; ") || "none") +
+    "\n- Constraints: " + (extraction.constraints.map(c => c.text.slice(0, 80)).join("; ") || "none") +
+    "\n\nLast 30 messages:\n" + last30 +
+    (prevSummary ? "\n\nPrevious summary:\n" + prevSummary : "") +
+    (userNote ? "\n\nUser note: \"" + userNote + "\"" : "") +
+    "\n\nOutput ONLY JSON: {\"mainGoal\":\"...\",\"sessionType\":\"implementation|review|debugging|discussion\",\"boundaries\":[{\"afterIndex\":N,\"topic\":\"...\",\"priority\":\"normal\",\"confidence\":0.5}],\"enrichedConstraints\":[...],\"crossReferences\":[...],\"statusAssessment\":{\"done\":[...],\"inProgress\":[...],\"blocked\":[...]},\"criticalContext\":[...],\"keyDecisions\":[...]}";
+
+  try {
+    const resp = await trackedComplete("explore-direct", model, {
+      systemPrompt: COMPACT_SYSTEM_PREFIX,
+      messages: [{ role: "user", content: [{ type: "text", text: prompt }] }],
+    }, cacheOpts({ apiKey: auth.apiKey, headers: auth.headers, maxTokens: 4096, signal }));
+    const text = (resp.content as any[]).filter((c: any) => c?.type === "text").map((c: any) => c.text).join("\n").trim();
+    return parseExplorationReport(text, llmMessages);
+  } catch { return fallbackExplorationReport(llmMessages); }
+}

package/src/phases/synthesize.ts

@@ -0,0 +1,184 @@
+/**
+ * Phase 3: Hierarchical Synthesis.
+ */
+
+import type { Model, Api } from "@earendil-works/pi-ai";
+import type {
+  LlmMessage, LlmChunk, ChunkSummary, StructuredExtraction,
+  ExplorationReport, ProfileConfig, CacheAwareOptions,
+} from "../types.ts";
+import { COMPACT_SYSTEM_PREFIX, SINGLE_PASS_PREFIX, SINGLE_PASS_SUFFIX, BATCH_PROMPT_PREFIX, BATCH_PROMPT_SUFFIX, ASSEMBLY_PROMPT_PREFIX, ASSEMBLY_PROMPT_SUFFIX, SESSION_TYPE_INSTRUCTIONS } from "../constants.ts";
+import { estimateTokens } from "../utils/tokens.ts";
+import { trackedComplete, cacheOpts } from "../utils/cache.ts";
+import { extractText } from "../utils/extraction.ts";
+import { buildExtractionContext, buildExplorationContext, createBatches, preProcessSummaries } from "../utils/helpers.ts";
+
+export function chunkLlmMessages(msgs: LlmMessage[], boundaries: import("../types.ts").TopicBoundary[], pc: ProfileConfig): LlmChunk[] {
+  if (!msgs.length) return [];
+  if (!boundaries.length) {
+    return [{
+      startIndex: 0, endIndex: msgs.length - 1,
+      tokenEstimate: estimateTokens(JSON.stringify(msgs)),
+      topic: "Full conversation", priority: "normal", messages: msgs,
+    }];
+  }
+
+  const sorted = [...boundaries].sort((a, b) => a.afterIndex - b.afterIndex);
+  const chunks: LlmChunk[] = [];
+  let start = 0;
+
+  for (const bp of sorted) {
+    const end = bp.afterIndex + 1;
+    if (end > start && end <= msgs.length) {
+      const slice = msgs.slice(start, end);
+      chunks.push({
+        startIndex: start, endIndex: end - 1,
+        tokenEstimate: estimateTokens(JSON.stringify(slice)),
+        topic: bp.topic || "Segment " + (chunks.length + 1),
+        priority: bp.priority,
+        messages: slice,
+      });
+    }
+    start = end;
+  }
+
+  if (start < msgs.length) {
+    const slice = msgs.slice(start);
+    const lastTopic = sorted.length ? "After: " + sorted[sorted.length - 1].topic : "Full conversation";
+    chunks.push({
+      startIndex: start, endIndex: msgs.length - 1,
+      tokenEstimate: estimateTokens(JSON.stringify(slice)),
+      topic: lastTopic, priority: "normal", messages: slice,
+    });
+  }
+
+  const merged: LlmChunk[] = [];
+  for (const ch of chunks) {
+    if (merged.length && ch.tokenEstimate < pc.minChunkTokens) {
+      const prev = merged[merged.length - 1];
+      prev.endIndex = ch.endIndex;
+      prev.tokenEstimate += ch.tokenEstimate;
+      prev.messages = msgs.slice(prev.startIndex, prev.endIndex + 1);
+      prev.topic = prev.topic + " + " + ch.topic;
+    } else {
+      merged.push(ch);
+    }
+  }
+  return merged;
+}
+
+export async function singlePassCompact(
+  convText: string, extraction: StructuredExtraction, report: ExplorationReport | null,
+  prevContext: string,
+  model: Model<Api>, auth: { apiKey: string; headers?: Record<string, string> }, signal?: AbortSignal,
+): Promise<{ summary: string; llmCalls: 1 }> {
+  const extractionCtx = buildExtractionContext(extraction);
+  const explorationCtx = report ? buildExplorationContext(report) : "";
+  // Session-aware prompt adaptation
+  const sessionType = report?.sessionType ?? "implementation";
+  const sessionInstruction = SESSION_TYPE_INSTRUCTIONS[sessionType] ?? SESSION_TYPE_INSTRUCTIONS.implementation;
+  const adaptedPrefix = SINGLE_PASS_PREFIX + "\nSession-specific instructions:\n" + sessionInstruction;
+  const dynamicSuffix = SINGLE_PASS_SUFFIX
+    .replace("{PREV_CONTEXT}", prevContext)
+    .replace("{EXTRACTION_CONTEXT}", extractionCtx)
+    .replace("{EXPLORATION_CONTEXT}", explorationCtx)
+    .replace("{CONVERSATION}", convText);
+
+  const resp = await trackedComplete("single-pass", model, {
+    systemPrompt: COMPACT_SYSTEM_PREFIX,
+    messages: [
+      { role: "user" as const, content: [{ type: "text" as const, text: adaptedPrefix }] },
+      { role: "user" as const, content: [{ type: "text" as const, text: dynamicSuffix }] },
+    ],
+  }, cacheOpts({ apiKey: auth.apiKey, headers: auth.headers, maxTokens: 8192, signal }));
+  const summary = (resp.content as any[]).filter((c: any): c is { type: "text"; text: string } => c?.type === "text").map(c => c.text).join("\n").trim();
+  if (!summary.startsWith("##")) throw new Error("Single-pass malformed output");
+  return { summary, llmCalls: 1 };
+}
+
+export async function summarizeBatch(
+  batch: LlmChunk[], extraction: StructuredExtraction,
+  model: Model<Api>, auth: { apiKey: string; headers?: Record<string, string> }, signal?: AbortSignal,
+): Promise<ChunkSummary[]> {
+  const range = { start: batch[0].startIndex, end: batch[batch.length - 1].endIndex };
+  const extractionCtx = buildExtractionContext(extraction, range);
+  // Decision propagation: inject decisions from before this batch's range
+  const activeDecisions = extraction.decisions
+    .filter(d => d.index < range.start)
+    .map(d => "- " + d.summary.slice(0, 120) + (d.userResponse ? " → " + d.userResponse.slice(0, 60) : ""));
+  const decisionCtx = activeDecisions.length
+    ? "\n## Active Decisions from previous segments (honour these):\n" + activeDecisions.join("\n")
+    : "";
+  const text = batch.map(ch => "--- Topic: " + ch.topic + " (" + ch.priority + ") ---\n" + ch.messages.map((m) => {
+    const role = m?.role ?? "unknown";
+    const content = extractText(m?.content).slice(0, 500);
+    return "[" + role + "] " + content;
+  }).join("\n")).join("\n\n");
+  const dynamicSuffix = BATCH_PROMPT_SUFFIX.replace("{EXTRACTION_CONTEXT}", extractionCtx + decisionCtx).replace("{TEXT}", text);
+
+  const resp = await trackedComplete("batch", model, {
+    systemPrompt: COMPACT_SYSTEM_PREFIX,
+    messages: [
+      { role: "user" as const, content: [{ type: "text" as const, text: BATCH_PROMPT_PREFIX }] },
+      { role: "user" as const, content: [{ type: "text" as const, text: dynamicSuffix }] },
+    ],
+  }, cacheOpts({ apiKey: auth.apiKey, headers: auth.headers, maxTokens: 4096, signal }));
+  const output = (resp.content as any[]).filter((c: any): c is { type: "text"; text: string } => c?.type === "text").map(c => c.text).join("\n");
+  const sections = output.split(/^### /m).filter(s => s.trim());
+  return batch.map((ch, i) => {
+    const sec = sections[i] ?? "";
+    const f = (n: string) => { const m = sec.match(new RegExp("\\*\\*" + n + "\\*\\*:\\s*(.+?)(?:\\n|$)", "i")); return m ? m[1].trim() : ""; };
+    const l = (n: string) => { const v = f(n); return !v || v === "None" ? [] : v.split(",").map(s => s.trim()).filter(Boolean); };
+    const prio = f("Priority").toLowerCase();
+    return {
+      topic: ch.topic,
+      startIndex: ch.startIndex, endIndex: ch.endIndex,
+      summary: f("Summary") || sec.split("\n").slice(1).join("\n").trim().slice(0, 500),
+      keyDecisions: l("Decisions"), filesModified: l("Modified"), filesRead: l("Read"),
+      priority: ["critical", "high", "normal", "low"].includes(prio) ? prio as ChunkSummary["priority"] : ch.priority,
+    };
+  });
+}
+
+export async function assembleLLM(
+  summaries: ChunkSummary[], extraction: StructuredExtraction, report: ExplorationReport | null,
+  model: Model<Api>, auth: { apiKey: string; headers?: Record<string, string> }, budget: number,
+  prevContext: string, signal?: AbortSignal,
+): Promise<string> {
+  const pp = preProcessSummaries(summaries, budget);
+  const detModified = extraction.modifiedFiles.map(f => f.path);
+  const detRead = extraction.readFiles;
+  const explorationCtx = report ? buildExplorationContext(report) : "";
+  const dynamicSuffix = ASSEMBLY_PROMPT_SUFFIX
+    .replace("{DECISIONS}", pp.decisions.join("; ") || "None")
+    .replace("{MODIFIED}", detModified.join(", ") || "None")
+    .replace("{READ}", detRead.join(", ") || "None")
+    .replace("{EXPLORATION_CONTEXT}", explorationCtx)
+    .replace("{PREV_CONTEXT}", prevContext)
+    .replace("{SUMMARIES}", pp.text);
+
+  const resp = await trackedComplete("assemble", model, {
+    systemPrompt: COMPACT_SYSTEM_PREFIX,
+    messages: [
+      { role: "user" as const, content: [{ type: "text" as const, text: ASSEMBLY_PROMPT_PREFIX }] },
+      { role: "user" as const, content: [{ type: "text" as const, text: dynamicSuffix }] },
+    ],
+  }, cacheOpts({ apiKey: auth.apiKey, headers: auth.headers, maxTokens: Math.min(budget, 8192), signal }));
+  return (resp.content as any[]).filter((c: any): c is { type: "text"; text: string } => c?.type === "text").map(c => c.text).join("\n").trim();
+}
+
+export function assembleFallback(summaries: ChunkSummary[], extraction: StructuredExtraction): string {
+  const detModified = extraction.modifiedFiles.map(f => f.path);
+  const detRead = extraction.readFiles;
+  return [
+    "## Goal", extraction.mainGoal ?? "See topics below.", "",
+    "## Constraints & Preferences", ...extraction.constraints.map(c => "- [" + c.category + "] " + c.text.slice(0, 200)), "",
+    "## Progress", "### Done", "- See topics below", "### In Progress", ...summaries.filter(s => s.priority === "high").map(s => "- [ ] " + s.summary.slice(0, 150)), "### Blocked", "- None", "",
+    "## Key Decisions", ...extraction.decisions.map(d => "- **" + d.summary.slice(0, 100) + "**" + (d.userResponse ? " → " + d.userResponse : "")), "",
+    "## Files Modified", ...detModified.map(f => "- " + f), "",
+    "## Files Read", ...detRead.map(f => "- " + f), "",
+    "## Next Steps", "1. See topics below", "",
+    "## Critical Context", ...extraction.errors.filter(e => !e.resolved).map(e => "- Unresolved error: " + e.message.slice(0, 100)), "",
+    "## Topics Covered", ...summaries.map(s => "- **" + s.topic + "** [" + s.priority + "]: " + s.summary.slice(0, 200)),
+  ].join("\n");
+}