pi-smart-compact 7.5.2 → 7.7.0

package/src/phases/synthesize.ts

@@ -1,184 +0,0 @@
-/**
- * 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");
-}

package/src/phases/verify.ts

@@ -1,191 +0,0 @@
-/**
- * Phase 4: Verification + Quality Score.
- */
-
-import type { Model, Api } from "@earendil-works/pi-ai";
-import type { StructuredExtraction, VerificationResult, CacheAwareOptions } from "../types.ts";
-import { COMPACT_SYSTEM_PREFIX } from "../constants.ts";
-import { trackedComplete, cacheOpts } from "../utils/cache.ts";
-
-export function verifySummary(summary: string, extraction: StructuredExtraction): VerificationResult {
-  const gaps: string[] = [];
-  const lower = summary.toLowerCase();
-  let score = 100;
-
-  for (const f of extraction.modifiedFiles) {
-    const pathLower = f.path.toLowerCase();
-    // Build path suffix array: "src/index.ts", "index.ts", "index"
-    const parts = pathLower.split("/");
-    const suffixes: string[] = [];
-    for (let j = 0; j < parts.length; j++) {
-      suffixes.push(parts.slice(j).join("/"));
-    }
-    const pathMatch = suffixes.some(s => s.length > 2 && lower.includes(s));
-    if (!pathMatch) {
-      gaps.push("Missing modified file: " + f.path);
-      score -= 5;
-    }
-  }
-
-  for (const e of extraction.errors.filter(e => !e.resolved)) {
-    const snippet = e.message.slice(0, 30).toLowerCase();
-    if (snippet.length > 5 && !lower.includes(snippet)) {
-      gaps.push("Missing error: " + e.message.slice(0, 80));
-      score -= 5;
-    }
-  }
-
-  for (const c of extraction.constraints.filter(c => c.confidence >= 0.8)) {
-    const keywords = c.text.split(/\s+/).filter(w => w.length > 4).slice(0, 3);
-    const found = keywords.some(k => lower.includes(k.toLowerCase()));
-    if (!found && keywords.length > 0) {
-      gaps.push("Missing constraint: " + c.text.slice(0, 100));
-      score -= 3;
-    }
-  }
-
-  if (extraction.mainGoal) {
-    const goalWords = extraction.mainGoal.split(/\s+/).filter(w => w.length > 3).slice(0, 4);
-    const goalFound = goalWords.some(w => lower.includes(w.toLowerCase()));
-    if (!goalFound) { gaps.push("Main goal may be missing from summary"); score -= 10; }
-  }
-
-  if (!lower.includes("## goal")) score -= 5;
-  if (!lower.includes("## progress")) score -= 5;
-  if (!lower.includes("## critical context")) score -= 3;
-
-  const summaryFileRefs = (summary.match(/[\w.\/-]+\.[\w]+/g) ?? []).filter(
-    p => p.includes("/") || p.match(/\.(ts|tsx|js|jsx|rs|py|go|java|rb|css|html|json|yaml|yml|toml|md|sh|sql)$/i)
-  );
-  const knownFiles = new Set([
-    ...extraction.modifiedFiles.map(f => f.path.toLowerCase()),
-    ...extraction.readFiles.map(f => f.toLowerCase()),
-  ]);
-  for (const ref of summaryFileRefs) {
-    const refLower = ref.toLowerCase();
-    const isKnown = [...knownFiles].some(kf => kf.endsWith("/" + refLower) || kf === refLower || kf.endsWith(refLower) && refLower.length > 3);
-    if (!isKnown) {
-      gaps.push("Potentially fabricated file: " + ref);
-      score -= 4;
-    }
-  }
-
-  const errorFiles = new Set(extraction.errors.map(e => e.message));
-  if (errorFiles.size > 0) {
-    const doneSection = (summary.match(/### Done[\s\S]*?(?=###|$)/i) ?? [""])[0];
-    if (doneSection) {
-      for (const f of extraction.modifiedFiles) {
-        const bn = f.path.split("/").pop() ?? "";
-        const hasError = [...errorFiles].some(e => e.toLowerCase().includes(bn.toLowerCase()));
-        const markedDone = doneSection.toLowerCase().includes(bn.toLowerCase());
-        if (hasError && markedDone) {
-          const unresolved = extraction.errors.find(e => e.message.toLowerCase().includes(bn.toLowerCase()) && !e.resolved);
-          if (unresolved) {
-            gaps.push("Inconsistency: " + bn + " marked Done but has unresolved error");
-            score -= 5;
-          }
-        }
-      }
-    }
-  }
-
-  const highConfDecisions = extraction.decisions.filter(d => d.type === "explicit");
-  if (highConfDecisions.length > 0) {
-    const decisionSection = (summary.match(/## Key Decisions[\s\S]*?(?=##|$)/i) ?? [""])[0];
-    for (const d of highConfDecisions) {
-      const keywords = d.summary.split(/\s+/).filter(w => w.length > 4).slice(0, 3);
-      if (keywords.length > 0 && !keywords.some(k => decisionSection.toLowerCase().includes(k.toLowerCase()))) {
-        gaps.push("Missing decision: " + d.summary.slice(0, 100));
-        score -= 3;
-      }
-    }
-  }
-
-  return { ok: gaps.length === 0, gaps, score: Math.max(0, score) };
-}
-
-/**
- * Deterministic patch — injects missing items directly into the summary
- * without an LLM call. Appends gaps to the relevant sections.
- */
-export function patchDeterministic(summary: string, gaps: string[], extraction: StructuredExtraction): string {
-  let patched = summary;
-  const fileGaps = gaps.filter(g => g.startsWith("Missing modified file:"));
-  const errorGaps = gaps.filter(g => g.startsWith("Missing error:"));
-  const constraintGaps = gaps.filter(g => g.startsWith("Missing constraint:"));
-  const decisionGaps = gaps.filter(g => g.startsWith("Missing decision:"));
-  const otherGaps = gaps.filter(g =>
-    !g.startsWith("Missing modified file:") &&
-    !g.startsWith("Missing error:") &&
-    !g.startsWith("Missing constraint:") &&
-    !g.startsWith("Missing decision:") &&
-    !g.startsWith("Potentially fabricated") &&
-    !g.startsWith("Inconsistency")
-  );
-
-  // Inject missing files into Files Modified section
-  if (fileGaps.length > 0) {
-    const filesSection = patched.match(/## Files Modified\n/);
-    if (filesSection) {
-      const insertPos = filesSection.index! + filesSection[0].length;
-      const entries = fileGaps.map(g => "- " + g.replace("Missing modified file: ", "")).join("\n") + "\n";
-      patched = patched.slice(0, insertPos) + entries + patched.slice(insertPos);
-    }
-  }
-
-  // Inject missing errors into Critical Context section
-  if (errorGaps.length > 0) {
-    const ctxSection = patched.match(/## Critical Context\n/);
-    if (ctxSection) {
-      const insertPos = ctxSection.index! + ctxSection[0].length;
-      const entries = errorGaps.map(g => "- " + g).join("\n") + "\n";
-      patched = patched.slice(0, insertPos) + entries + patched.slice(insertPos);
-    }
-  }
-
-  // Inject missing constraints into Constraints section
-  if (constraintGaps.length > 0) {
-    const constrSection = patched.match(/## Constraints & Preferences\n/);
-    if (constrSection) {
-      const insertPos = constrSection.index! + constrSection[0].length;
-      const entries = constraintGaps.map(g => "- " + g).join("\n") + "\n";
-      patched = patched.slice(0, insertPos) + entries + patched.slice(insertPos);
-    }
-  }
-
-  // Inject missing decisions into Key Decisions section
-  if (decisionGaps.length > 0) {
-    const decSection = patched.match(/## Key Decisions\n/);
-    if (decSection) {
-      const insertPos = decSection.index! + decSection[0].length;
-      const entries = decisionGaps.map(g => "- **" + g.replace("Missing decision: ", "") + "**").join("\n") + "\n";
-      patched = patched.slice(0, insertPos) + entries + patched.slice(insertPos);
-    }
-  }
-
-  // Append any remaining gaps as a verification note
-  if (otherGaps.length > 0) {
-    patched += "\n## Verification Note\n" + otherGaps.map(g => "- " + g).join("\n");
-  }
-
-  return patched;
-}
-
-export async function patchSummary(
-  summary: string, gaps: string[],
-  model: Model<Api>, auth: { apiKey: string; headers?: Record<string, string> }, signal?: AbortSignal,
-): Promise<string> {
-  const patchPrompt = "The summary below is missing some critical information. Add the missing items WITHOUT restructuring the summary.\n\nMissing items:\n" +
-    gaps.map((g, i) => (i + 1) + ". " + g).join("\n") +
-    "\n\nCurrent summary:\n" + summary +
-    "\n\nReturn the COMPLETE updated summary with missing items integrated. Keep the same format.";
-
-  try {
-    const resp = await trackedComplete("patch", model, {
-      systemPrompt: COMPACT_SYSTEM_PREFIX,
-      messages: [{ role: "user" as const, content: [{ type: "text" as const, text: patchPrompt }] }],
-    }, cacheOpts({ apiKey: auth.apiKey, headers: auth.headers, maxTokens: 8192, signal }));
-    const patched = (resp.content as any[]).filter((c: any): c is { type: "text"; text: string } => c?.type === "text").map(c => c.text).join("\n").trim();
-    return patched.startsWith("##") ? patched : summary;
-  } catch { return summary; }
-}

package/src/types.ts

@@ -1,176 +0,0 @@
-/**
- * Core type definitions for the Smart Compact extension.
- */
-
-import type { Model, Api } from "@earendil-works/pi-ai";
-
-export type CompressionProfile = "light" | "balanced" | "aggressive";
-
-export interface ProfileConfig {
-  summaryBudgetTokens: number;
-  keepRecentTokens: number;
-  minChunkTokens: number;
-  maxChunkTokens: number;
-  singlePassMaxTokens: number;
-  batchMaxTokens: number;
-}
-
-export interface CompactConfig {
-  profile: CompressionProfile;
-  profiles: Record<CompressionProfile, ProfileConfig>;
-  summaryModel: string | null;
-  segmentationModel: string | null;
-  autoTrigger: boolean;
-  backupEnabled: boolean;
-  backupDir: string;
-}
-
-export interface ProviderCapabilities {
-  maxOutputTokens: number;
-  supportsTools: boolean | "probe";
-  jsonReliability: "high" | "medium" | "low";
-  instructionFollowing: "high" | "medium" | "low";
-  tokenRatioEstimate: number;
-  concurrencyLimit: number;
-  cacheStrategy: "anthropic" | "openai" | "none";
-}
-
-export interface LLMCallMetric {
-  phase: "probe" | "explore" | "explore-loop" | "explore-retry" | "explore-direct" | "single-pass" | "batch" | "assemble" | "patch";
-  model: string;
-  inputTokens: number;
-  outputTokens: number;
-  cacheHitTokens: number;
-  latencyMs: number;
-  success: boolean;
-}
-
-export interface TopicBoundary {
-  afterIndex: number;
-  topic: string;
-  priority: "critical" | "high" | "normal" | "low";
-  confidence: number;
-}
-
-export interface ChunkSummary {
-  topic: string;
-  startIndex: number;
-  endIndex: number;
-  summary: string;
-  keyDecisions: string[];
-  filesModified: string[];
-  filesRead: string[];
-  priority: "critical" | "high" | "normal" | "low";
-}
-
-export interface SmartCompactDetails {
-  method: "eesv" | "single-pass" | "heuristic";
-  chunkCount: number;
-  topics: string[];
-  readFiles: string[];
-  modifiedFiles: string[];
-  totalMessages: number;
-  totalTokensSummarized: number;
-  llmCalls: number;
-  profile: CompressionProfile;
-  backupPath: string | null;
-  tokensSaved: number;
-  verified: boolean;
-  gaps: string[];
-  explorationRounds: number;
-  explorationBoundaries: number;
-  model: string;
-  qualityScore: number;
-  tokensBefore: number;
-}
-
-export interface PendingCompaction {
-  summary: string;
-  firstKeptEntryId: string;
-  tokensBefore: number;
-  details: SmartCompactDetails;
-}
-
-export interface ModelOption {
-  value: string;
-  label: string;
-  model: Model<Api>;
-  supportsTools: boolean;
-}
-
-export interface VerificationResult {
-  ok: boolean;
-  gaps: string[];
-  score: number;
-}
-
-export interface ExplorationReport {
-  boundaries: TopicBoundary[];
-  mainGoal: string;
-  sessionType: "implementation" | "review" | "debugging" | "discussion";
-  enrichedConstraints: string[];
-  crossReferences: string[];
-  statusAssessment: { done: string[]; inProgress: string[]; blocked: string[] };
-  criticalContext: string[];
-  keyDecisions: string[];
-}
-
-export interface StructuredExtraction {
-  modifiedFiles: Array<{ path: string; toolCalls: number; lastModifiedIndex: number }>;
-  readFiles: string[];
-  deletedFiles: string[];
-  errors: Array<{ index: number; tool: string; message: string; retryAttempted: boolean; resolved: boolean }>;
-  decisions: Array<{ index: number; type: "explicit" | "implicit"; summary: string; userResponse?: string }>;
-  constraints: Array<{ index: number; text: string; category: "requirement" | "preference" | "prohibition"; confidence: number }>;
-  topics: Array<{ startIndex: number; endIndex: number; primaryFile: string | null; type: "implementation" | "debugging" | "exploration" | "review"; errorDensity: number }>;
-  timeline: Array<{ index: number; event: string; summary: string }>;
-  mainGoal: string | null;
-  lastUserMessages: string[];
-  lastErrors: string[];
-  messageCount: number;
-}
-
-export interface LlmChunk {
-  startIndex: number;
-  endIndex: number;
-  tokenEstimate: number;
-  topic: string;
-  priority: "critical" | "high" | "normal" | "low";
-  messages: LlmMessage[];
-}
-
-export interface LlmMessage {
-  role: "user" | "assistant" | "toolResult";
-  content?: unknown;
-  isError?: boolean;
-  toolCallId?: string;
-  timestamp?: number;
-}
-
-export interface ToolCallBlock {
-  type: "toolCall";
-  id?: string;
-  name: string;
-  arguments: Record<string, unknown>;
-}
-
-export interface TextBlock {
-  type: "text";
-  text: string;
-}
-
-export interface LlmTextBlock { type: "text"; text: string; }
-export interface LlmToolCallBlock { type: "toolCall"; id?: string; name: string; arguments: Record<string, unknown>; }
-export type LlmContentBlock = LlmTextBlock | LlmToolCallBlock | string;
-
-export interface ProgressState {
-  phase: number;
-  phaseName: string;
-  detail: string;
-  extraction?: StructuredExtraction;
-  explorationRounds?: number;
-  totalBatches?: number;
-  currentBatch?: number;
-  model?: string;
-  profile?: string;
-}