@pi-unipi/compactor 0.2.3 → 2.0.0

package/src/tools/ctx-stats.ts

@@ -1,9 +1,10 @@
 /**
  * ctx_stats tool — context savings dashboard
+ *
+ * Stats driven by compaction savings (DB-first) with runtime counter fallback.
  */
 
 import type { SessionDB } from "../session/db.js";
-import type { ContentStore } from "../store/index.js";
 import type { RuntimeCounters } from "../types.js";
 
 export interface CtxStatsResult {
@@ -11,20 +12,16 @@ export interface CtxStatsResult {
   compactions: number;
   tokensSaved: number;
   compressionRatio: string;
-  indexedDocs: number;
-  indexedChunks: number;
   sandboxRuns: number;
   searchQueries: number;
 }
 
 export async function ctxStats(
   sessionDB: SessionDB,
-  contentStore: ContentStore,
   sessionId: string,
   counters?: RuntimeCounters,
 ): Promise<CtxStatsResult> {
   const sessionStats = sessionDB.getSessionStats(sessionId);
-  const storeStats = await contentStore.getStats();
 
   // Compute tokensSaved: prefer in-memory counters (current session),
   // fall back to per-session DB stats, then all-time DB stats.
@@ -50,14 +47,50 @@ export async function ctxStats(
     compactions = allTime.allCompactions;
   }
 
+  // Compression ratio
+  let ratio = "N/A";
+  if (sessionStats) {
+    const before = (sessionStats as any).total_chars_before ?? 0;
+    const kept = (sessionStats as any).total_chars_kept ?? 0;
+    if (before > 0 && kept > 0) {
+      ratio = `${(before / kept).toFixed(1)}:1`;
+    }
+  }
+
   return {
     sessionEvents: sessionStats?.event_count ?? 0,
     compactions,
     tokensSaved,
-    compressionRatio: "N/A",
-    indexedDocs: storeStats.sources,
-    indexedChunks: storeStats.chunks,
-    sandboxRuns: counters?.sandboxRuns ?? 0,
-    searchQueries: counters?.searchQueries ?? 0,
+    compressionRatio: ratio,
+    sandboxRuns: computeSandboxRuns(counters, sessionDB, sessionId),
+    searchQueries: computeSearchQueries(counters, sessionDB, sessionId),
   };
 }
+
+/** Compute sandbox runs: prefer in-memory counter, fall back to DB. */
+function computeSandboxRuns(counters: RuntimeCounters | undefined, sessionDB: SessionDB, sessionId: string): number {
+  let sandboxRuns = counters?.sandboxRuns ?? 0;
+  if (sandboxRuns === 0) {
+    const sessionStats = sessionDB.getSessionStats(sessionId);
+    sandboxRuns = (sessionStats as any)?.sandbox_runs ?? 0;
+  }
+  if (sandboxRuns === 0) {
+    const allTime = sessionDB.getAllTimeStats();
+    sandboxRuns = allTime.allSandboxRuns;
+  }
+  return sandboxRuns;
+}
+
+/** Compute search queries: prefer in-memory counter, fall back to DB. */
+function computeSearchQueries(counters: RuntimeCounters | undefined, sessionDB: SessionDB, sessionId: string): number {
+  let searchQueries = counters?.searchQueries ?? 0;
+  if (searchQueries === 0) {
+    const sessionStats = sessionDB.getSessionStats(sessionId);
+    searchQueries = (sessionStats as any)?.search_queries ?? 0;
+  }
+  if (searchQueries === 0) {
+    const allTime = sessionDB.getAllTimeStats();
+    searchQueries = allTime.allSearchQueries;
+  }
+  return searchQueries;
+}

package/src/tools/register.ts

@@ -4,30 +4,26 @@
  * Each tool is registered via pi.registerTool() with proper TypeBox schemas
  * so the LLM can discover and invoke them.
  *
- * New naming convention (v0.2.0):
+ * Tool names:
  *   compact, session_recall, sandbox, sandbox_file, sandbox_batch,
- *   content_index, content_search, content_fetch, compactor_stats, compactor_doctor
+ *   compactor_stats, compactor_doctor, context_budget
  *
- * Old names kept as deprecated aliases for backward compatibility:
+ * Deprecated aliases for backward compatibility:
  *   vcc_recall, ctx_execute, ctx_execute_file, ctx_batch_execute,
- *   ctx_index, ctx_search, ctx_fetch_and_index, ctx_stats, ctx_doctor
+ *   ctx_stats, ctx_doctor
  */
 
-import { Type, type Static } from "@sinclair/typebox";
+import { Type } from "@sinclair/typebox";
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
 import { compactTool } from "./compact.js";
 import { vccRecall, type RecallInput } from "./vcc-recall.js";
 import { ctxExecute, type CtxExecuteInput } from "./ctx-execute.js";
 import { ctxExecuteFile, type CtxExecuteFileInput } from "./ctx-execute-file.js";
 import { ctxBatchExecute, type BatchItem } from "./ctx-batch-execute.js";
-import { ctxIndex, type CtxIndexInput } from "./ctx-index.js";
-import { ctxSearch, type CtxSearchInput } from "./ctx-search.js";
-import { ctxFetchAndIndex, type CtxFetchAndIndexInput } from "./ctx-fetch-and-index.js";
 import { ctxStats, type CtxStatsResult } from "./ctx-stats.js";
 import { ctxDoctor, type DoctorResult } from "./ctx-doctor.js";
 import { contextBudgetTool } from "./context-budget.js";
 import type { SessionDB } from "../session/db.js";
-import type { ContentStore } from "../store/index.js";
 import type { NormalizedBlock, RuntimeCounters } from "../types.js";
 
 // --- TypeBox Schemas for each tool ---
@@ -81,40 +77,11 @@ const SandboxBatchParams = Type.Object({
         code: Type.String(),
         timeout: Type.Optional(Type.Number()),
       }),
-      Type.Object({
-        type: Type.Literal("search"),
-        query: Type.String(),
-        limit: Type.Optional(Type.Number()),
-      }),
     ]),
-    { description: "Array of execute or search commands to run atomically" },
+    { description: "Array of execute commands to run atomically" },
   ),
 });
 
-const ContentIndexParams = Type.Object({
-  label: Type.String({ description: "Label for the indexed content" }),
-  content: Type.Optional(Type.String({ description: "Content to index (or use filePath)" })),
-  filePath: Type.Optional(Type.String({ description: "Path to file to index" })),
-  contentType: Type.Optional(Type.Union([
-    Type.Literal("markdown"),
-    Type.Literal("json"),
-    Type.Literal("plain"),
-  ], { description: "Content type for chunking strategy" })),
-  chunkSize: Type.Optional(Type.Number({ description: "Chunk size in characters", minimum: 100 })),
-});
-
-const ContentSearchParams = Type.Object({
-  query: Type.String({ description: "Search query against indexed content" }),
-  limit: Type.Optional(Type.Number({ description: "Max results (default 10)", minimum: 1 })),
-  offset: Type.Optional(Type.Number({ description: "Pagination offset", minimum: 0 })),
-});
-
-const ContentFetchParams = Type.Object({
-  url: Type.String({ description: "URL to fetch, convert to markdown, and index" }),
-  label: Type.Optional(Type.String({ description: "Label for the indexed content" })),
-  chunkSize: Type.Optional(Type.Number({ description: "Chunk size in characters", minimum: 100 })),
-});
-
 const StatsParams = Type.Object({});
 
 const DoctorParams = Type.Object({});
@@ -147,9 +114,6 @@ const VccRecallParams = RecallParams;
 const CtxExecuteParams = SandboxParams;
 const CtxExecuteFileParams = SandboxFileParams;
 const CtxBatchExecuteParams = SandboxBatchParams;
-const CtxIndexParams = ContentIndexParams;
-const CtxSearchParams = ContentSearchParams;
-const CtxFetchAndIndexParams = ContentFetchParams;
 const CtxStatsParams = StatsParams;
 const CtxDoctorParams = DoctorParams;
 
@@ -157,7 +121,6 @@ const CtxDoctorParams = DoctorParams;
 
 export interface CompactorToolDeps {
   sessionDB: SessionDB;
-  contentStore: ContentStore | null;
   getSessionId: () => string;
   getBlocks: () => NormalizedBlock[];
   getCounters?: () => RuntimeCounters;
@@ -174,7 +137,7 @@ export function registerCompactorTools(pi: ExtensionAPI, deps: CompactorToolDeps
     label: "Compact",
     description: "Trigger manual context compaction. Reduces session history while preserving continuity. Use dryRun:true to preview without compacting.",
     parameters: CompactParams,
-    async execute(_toolCallId: string, params: any): Promise<any> {
+    async execute(_toolCallId: string, params: any): Promise<import("@mariozechner/pi-coding-agent").AgentToolResult<unknown>> {
       if (params.dryRun) {
         const blocks = deps.getBlocks();
         const totalMessages = blocks.length;
@@ -194,7 +157,7 @@ export function registerCompactorTools(pi: ExtensionAPI, deps: CompactorToolDeps
   } as any));
 
   // 2. session_recall (new) / vcc_recall (deprecated) — search session history
-  const recallExec = async (_toolCallId: string, params: any): Promise<any> => {
+  const recallExec = async (_toolCallId: string, params: any): Promise<import("@mariozechner/pi-coding-agent").AgentToolResult<unknown>> => {
     const c = deps.getCounters?.();
     if (c) { c.recallQueries++; }
     const blocks = deps.getBlocks();
@@ -222,10 +185,11 @@ export function registerCompactorTools(pi: ExtensionAPI, deps: CompactorToolDeps
   pi.registerTool({ name: "vcc_recall", label: "Session Recall", description: "Search session history using BM25 or regex. (DEPRECATED: use session_recall instead)", parameters: VccRecallParams, async execute(tcId: string, p: any) { deprecationLog("vcc_recall", "session_recall"); return recallExec(tcId, p); } } as any);
 
   // 3. sandbox (new) / ctx_execute (deprecated) — run code in sandbox
-  const sandboxExec = async (_toolCallId: string, params: any): Promise<any> => {
+  const sandboxExec = async (_toolCallId: string, params: any): Promise<import("@mariozechner/pi-coding-agent").AgentToolResult<unknown>> => {
     try {
       const c = deps.getCounters?.();
       if (c) { c.sandboxRuns++; }
+      deps.sessionDB.incrementSandboxRuns(deps.getSessionId());
       const result = await ctxExecute(params as CtxExecuteInput);
       const parts: string[] = [];
       if (result.stdout) parts.push(result.stdout);
@@ -241,10 +205,11 @@ export function registerCompactorTools(pi: ExtensionAPI, deps: CompactorToolDeps
   pi.registerTool({ name: "ctx_execute", label: "Sandbox", description: "Run code in sandbox. (DEPRECATED: use sandbox instead)", parameters: CtxExecuteParams, async execute(tcId: string, p: any) { deprecationLog("ctx_execute", "sandbox"); return sandboxExec(tcId, p); } } as any);
 
   // 4. sandbox_file (new) / ctx_execute_file (deprecated) — execute file
-  const sandboxFileExec = async (_toolCallId: string, params: any): Promise<any> => {
+  const sandboxFileExec = async (_toolCallId: string, params: any): Promise<import("@mariozechner/pi-coding-agent").AgentToolResult<unknown>> => {
     try {
       const c = deps.getCounters?.();
       if (c) { c.sandboxRuns++; }
+      deps.sessionDB.incrementSandboxRuns(deps.getSessionId());
       const result = await ctxExecuteFile(params as CtxExecuteFileInput);
       const parts: string[] = [];
       if (result.stdout) parts.push(result.stdout);
@@ -258,91 +223,34 @@ export function registerCompactorTools(pi: ExtensionAPI, deps: CompactorToolDeps
   pi.registerTool({ name: "sandbox_file", label: "Sandbox File", description: "Execute a file in the sandbox. File content is injected as FILE_CONTENT variable.", parameters: SandboxFileParams, execute: sandboxFileExec } as any);
   pi.registerTool({ name: "ctx_execute_file", label: "Sandbox File", description: "Execute file in sandbox. (DEPRECATED: use sandbox_file instead)", parameters: CtxExecuteFileParams, async execute(tcId: string, p: any) { deprecationLog("ctx_execute_file", "sandbox_file"); return sandboxFileExec(tcId, p); } } as any);
 
-  // 5. sandbox_batch (new) / ctx_batch_execute (deprecated) — atomic batch
-  const sandboxBatchExec = async (_toolCallId: string, params: any): Promise<any> => {
+  // 5. sandbox_batch (new) / ctx_batch_execute (deprecated) — atomic batch (execute only)
+  const sandboxBatchExec = async (_toolCallId: string, params: any): Promise<import("@mariozechner/pi-coding-agent").AgentToolResult<unknown>> => {
     try {
       const c = deps.getCounters?.();
-      if (c) { c.sandboxRuns++; c.searchQueries++; }
-      const result = await ctxBatchExecute(deps.contentStore!, params.items as BatchItem[]);
+      if (c) { c.sandboxRuns++; }
+      deps.sessionDB.incrementSandboxRuns(deps.getSessionId());
+      const result = await ctxBatchExecute(params.items as BatchItem[]);
       const summaries = result.results.map((r, i) => {
-        if (r.type === "execute") {
-          const s = r.result.stdout?.slice(0, 200) || "(no output)";
-          return `[${i}] execute → ${r.result.exitCode === 0 ? "ok" : "fail"}: ${s}`;
-        }
-        return `[${i}] search → ${r.results.length} results`;
+        const s = r.result.stdout?.slice(0, 200) || "(no output)";
+        return `[${i}] execute → ${r.result.exitCode === 0 ? "ok" : "fail"}: ${s}`;
       });
       return textResult(`Batch results (${result.results.length} items):\n${summaries.join("\n")}`, result as unknown as Record<string, unknown>);
     } catch (err) {
       return textResult(`Batch error: ${err}`, { error: true });
     }
   };
-  pi.registerTool({ name: "sandbox_batch", label: "Sandbox Batch", description: "Run multiple code executions and searches atomically as a batch.", parameters: SandboxBatchParams, execute: sandboxBatchExec } as any);
+  pi.registerTool({ name: "sandbox_batch", label: "Sandbox Batch", description: "Run multiple code executions atomically as a batch.", parameters: SandboxBatchParams, execute: sandboxBatchExec } as any);
   pi.registerTool({ name: "ctx_batch_execute", label: "Sandbox Batch", description: "Run batch operations. (DEPRECATED: use sandbox_batch instead)", parameters: CtxBatchExecuteParams, async execute(tcId: string, p: any) { deprecationLog("ctx_batch_execute", "sandbox_batch"); return sandboxBatchExec(tcId, p); } } as any);
 
-  // 6. content_index (new) / ctx_index (deprecated) — index content into FTS5
-  const contentIndexExec = async (_toolCallId: string, params: any): Promise<any> => {
-    try {
-      const result = await ctxIndex(deps.contentStore!, params as CtxIndexInput);
-      return textResult(
-        `Indexed "${result.label}": ${result.totalChunks} chunks (${result.codeChunks} code)`,
-        result as unknown as Record<string, unknown>,
-      );
-    } catch (err) {
-      return textResult(`Index error: ${err}`, { error: true });
-    }
-  };
-  pi.registerTool({ name: "content_index", label: "Content Index", description: "Chunk content or a file and index into FTS5 for fast search.", parameters: ContentIndexParams, execute: contentIndexExec } as any);
-  pi.registerTool({ name: "ctx_index", label: "Content Index", description: "Index content into FTS5. (DEPRECATED: use content_index instead)", parameters: CtxIndexParams, async execute(tcId: string, p: any) { deprecationLog("ctx_index", "content_index"); return contentIndexExec(tcId, p); } } as any);
-
-  // 7. content_search (new) / ctx_search (deprecated) — query FTS5 content store
-  const contentSearchExec = async (_toolCallId: string, params: any): Promise<any> => {
-    try {
-      const c = deps.getCounters?.();
-      if (c) { c.searchQueries++; }
-      const results = await ctxSearch(deps.contentStore!, params as CtxSearchInput);
-      if (results.length === 0) {
-        return textResult(`No results for "${params.query}".`);
-      }
-      const lines = results.map(
-        (r, i) =>
-          `[${i + 1}] ${r.title} (rank: ${r.rank.toFixed(3)})\n${r.content.slice(0, 300)}`,
-      );
-      return textResult(
-        `Found ${results.length} results:\n\n${lines.join("\n\n")}`,
-        { results } as unknown as Record<string, unknown>,
-      );
-    } catch (err) {
-      return textResult(`Search error: ${err}`, { error: true });
-    }
-  };
-  pi.registerTool({ name: "content_search", label: "Content Search", description: "Search indexed content using FTS5 full-text search.", parameters: ContentSearchParams, execute: contentSearchExec } as any);
-  pi.registerTool({ name: "ctx_search", label: "Content Search", description: "Search indexed content. (DEPRECATED: use content_search instead)", parameters: CtxSearchParams, async execute(tcId: string, p: any) { deprecationLog("ctx_search", "content_search"); return contentSearchExec(tcId, p); } } as any);
-
-  // 8. content_fetch (new) / ctx_fetch_and_index (deprecated) — fetch URL
-  const contentFetchExec = async (_toolCallId: string, params: any): Promise<any> => {
-    try {
-      const result = await ctxFetchAndIndex(deps.contentStore!, params as CtxFetchAndIndexInput);
-      return textResult(
-        `Fetched and indexed "${result.label}": ${result.totalChunks} chunks`,
-        result as unknown as Record<string, unknown>,
-      );
-    } catch (err) {
-      return textResult(`Fetch error: ${err}`, { error: true });
-    }
-  };
-  pi.registerTool({ name: "content_fetch", label: "Content Fetch", description: "Fetch a URL, convert to markdown, and index into FTS5 content store.", parameters: ContentFetchParams, execute: contentFetchExec } as any);
-  pi.registerTool({ name: "ctx_fetch_and_index", label: "Content Fetch", description: "Fetch URL and index. (DEPRECATED: use content_fetch instead)", parameters: CtxFetchAndIndexParams, async execute(tcId: string, p: any) { deprecationLog("ctx_fetch_and_index", "content_fetch"); return contentFetchExec(tcId, p); } } as any);
-
-  // 9. compactor_stats (new) / ctx_stats (deprecated) — context savings dashboard
-  const statsExec = async (): Promise<any> => {
+  // 6. compactor_stats (new) / ctx_stats (deprecated) — context savings dashboard
+  const statsExec = async (): Promise<import("@mariozechner/pi-coding-agent").AgentToolResult<unknown>> => {
     try {
-      const result = await ctxStats(deps.sessionDB, deps.contentStore!, deps.getSessionId(), deps.getCounters?.());
+      const result = await ctxStats(deps.sessionDB, deps.getSessionId(), deps.getCounters?.());
       const lines = [
         `📊 Compactor Stats`,
         `Session events: ${result.sessionEvents}`,
         `Compactions: ${result.compactions}`,
         `Tokens saved: ${result.tokensSaved}`,
-        `Indexed docs: ${result.indexedDocs} (${result.indexedChunks} chunks)`,
         `Sandbox runs: ${result.sandboxRuns}`,
         `Search queries: ${result.searchQueries}`,
       ];
@@ -351,13 +259,13 @@ export function registerCompactorTools(pi: ExtensionAPI, deps: CompactorToolDeps
       return textResult(`Stats error: ${err}`, { error: true });
     }
   };
-  pi.registerTool({ name: "compactor_stats", label: "Compactor Stats", description: "Show context savings dashboard — session events, compactions, indexed content.", parameters: StatsParams, execute: statsExec } as any);
+  pi.registerTool({ name: "compactor_stats", label: "Compactor Stats", description: "Show context savings dashboard — session events, compactions, tool usage.", parameters: StatsParams, execute: statsExec } as any);
   pi.registerTool({ name: "ctx_stats", label: "Compactor Stats", description: "Show stats dashboard. (DEPRECATED: use compactor_stats instead)", parameters: CtxStatsParams, async execute() { deprecationLog("ctx_stats", "compactor_stats"); return statsExec(); } } as any);
 
-  // 10. compactor_doctor (new) / ctx_doctor (deprecated) — diagnostics checklist
-  const doctorExec = async (): Promise<any> => {
+  // 7. compactor_doctor (new) / ctx_doctor (deprecated) — diagnostics checklist
+  const doctorExec = async (): Promise<import("@mariozechner/pi-coding-agent").AgentToolResult<unknown>> => {
     try {
-      const result = await ctxDoctor(deps.sessionDB, deps.contentStore!);
+      const result = await ctxDoctor(deps.sessionDB);
       const icon = (s: string) => (s === "pass" ? "✅" : s === "warn" ? "⚠️" : "❌");
       const lines = [
         result.healthy ? "🩺 All checks passed" : "🩺 Issues found",
@@ -369,16 +277,16 @@ export function registerCompactorTools(pi: ExtensionAPI, deps: CompactorToolDeps
       return textResult(`Doctor error: ${err}`, { error: true });
     }
   };
-  pi.registerTool({ name: "compactor_doctor", label: "Compactor Doctor", description: "Run diagnostics checklist — validate config, DB, FTS5, runtimes.", parameters: DoctorParams, execute: doctorExec } as any);
+  pi.registerTool({ name: "compactor_doctor", label: "Compactor Doctor", description: "Run diagnostics checklist — validate config, DB, runtimes.", parameters: DoctorParams, execute: doctorExec } as any);
   pi.registerTool({ name: "ctx_doctor", label: "Compactor Doctor", description: "Run diagnostics. (DEPRECATED: use compactor_doctor instead)", parameters: CtxDoctorParams, async execute() { deprecationLog("ctx_doctor", "compactor_doctor"); return doctorExec(); } } as any);
 
-  // 11. context_budget — estimate remaining context window
+  // 8. context_budget — estimate remaining context window
   pi.registerTool(({
     name: "context_budget",
     label: "Context Budget",
     description: "Estimate remaining context window (% full, tokens left) and get advice on whether to compact.",
     parameters: Type.Object({}),
-    async execute(): Promise<any> {
+    async execute(): Promise<import("@mariozechner/pi-coding-agent").AgentToolResult<unknown>> {
       const blocks = deps.getBlocks();
       const estimatedTokens = blocks.reduce((sum, b) => {
         const text = b.kind === "tool_call"

package/src/tui/settings-overlay.ts

@@ -7,8 +7,9 @@
  * preset preview, per-project override.
  */
 
-import type { Component } from "@mariozechner/pi-tui";
+import type { Component, TUI } from "@mariozechner/pi-tui";
 import { truncateToWidth, visibleWidth, SettingsList, type SettingItem, type SettingsListTheme } from "@mariozechner/pi-tui";
+import type { Theme, KeybindingsManager } from "@mariozechner/pi-coding-agent";
 import { loadConfig, saveConfig, projectConfigPath } from "../config/manager.js";
 import { applyPreset, detectPreset } from "../config/presets.js";
 import type { CompactorPreset } from "../types.js";
@@ -126,16 +127,6 @@ const STRATEGIES: StrategyDef[] = [
     getMode: (c) => c.sessionContinuity.mode,
     setMode: (c, v) => (c.sessionContinuity.mode = v as any),
   },
-  {
-    key: "fts5Index",
-    label: "FTS5 Index",
-    description: "Full-text search index",
-    modes: ["auto", "manual", "off"],
-    getEnabled: (c) => c.fts5Index.enabled,
-    setEnabled: (c, v) => (c.fts5Index.enabled = v),
-    getMode: (c) => c.fts5Index.mode,
-    setMode: (c, v) => (c.fts5Index.mode = v as any),
-  },
   {
     key: "sandboxExecution",
     label: "Sandbox Execution",
@@ -164,27 +155,27 @@ const PIPELINE_ITEMS: PipelineDef[] = [
   { key: "mmapPragma", label: "MMap Pragma", description: "Use mmap for SQLite I/O", group: "On Compaction", getValue: (c) => c.pipeline.mmapPragma, setValue: (c, v) => (c.pipeline.mmapPragma = v) },
   { key: "proximityReranking", label: "Proximity Reranking", description: "Rerank search results by proximity", group: "On Search", getValue: (c) => c.pipeline.proximityReranking, setValue: (c, v) => (c.pipeline.proximityReranking = v) },
   { key: "timelineSort", label: "Timeline Sort", description: "Sort session events chronologically", group: "On Search", getValue: (c) => c.pipeline.timelineSort, setValue: (c, v) => (c.pipeline.timelineSort = v) },
-  { key: "progressiveThrottling", label: "Progressive Throttling", description: "Slow down indexing for large projects", group: "On Index", getValue: (c) => c.pipeline.progressiveThrottling, setValue: (c, v) => (c.pipeline.progressiveThrottling = v) },
+  { key: "progressiveThrottling", label: "Progressive Throttling", description: "Slow down processing for large projects", group: "On Compaction", getValue: (c) => c.pipeline.progressiveThrottling, setValue: (c, v) => (c.pipeline.progressiveThrottling = v) },
 ];
 
 const PRESETS: CompactorPreset[] = ["precise", "balanced", "thorough", "lean"];
 
 const PRESET_DESCRIPTIONS: Record<string, { summary: string; detail: string }> = {
   precise: {
-    summary: "Code-heavy, minimal waste — compaction: full, FTS5: manual, pipeline: 2/6 on",
-    detail: "Max token savings. Compaction: full. Display: minimal.\nFTS5: manual. Sandbox: safe-only. Pipeline: ttlCache+mmap on.",
+    summary: "Code-heavy, minimal waste — compaction: full, sandbox: safe-only",
+    detail: "Max token savings. Compaction: full. Display: minimal.\nSandbox: safe-only. Pipeline: ttlCache+mmap on.",
   },
   balanced: {
-    summary: "Daily use (default) — all strategies moderate, pipeline: all on",
-    detail: "Moderate all strategies. Display: balanced.\nFTS5: auto. Sandbox: all. Pipeline: all 6 on.",
+    summary: "Daily use (default) — all strategies moderate",
+    detail: "Moderate all strategies. Display: balanced.\nSandbox: all. Pipeline: all 6 on.",
   },
   thorough: {
-    summary: "Debug/audit — everything on, full transcript, pipeline: all on",
-    detail: "Everything enabled. Display: verbose.\nFTS5: auto. Sandbox: all. Pipeline: all 6 on.",
+    summary: "Debug/audit — everything on, full transcript",
+    detail: "Everything enabled. Display: verbose.\nSandbox: all. Pipeline: all 6 on.",
   },
   lean: {
-    summary: "Quick fixes, short sessions — compaction only, pipeline: all off",
-    detail: "Compaction only. Display: opencode.\nFTS5: off. Sandbox: off. Pipeline: all 6 off.",
+    summary: "Quick fixes, short sessions — compaction only",
+    detail: "Compaction only. Display: opencode.\nSandbox: off. Pipeline: all 6 off.",
   },
 };
 
@@ -502,7 +493,7 @@ export class CompactorSettingsOverlay implements Component {
  * Factory function for ctx.ui.custom() integration.
  */
 export function renderSettingsOverlay(cwd?: string) {
-  return (_tui: any, _theme: any, _kb: any, done: (result: any) => void) => {
+  return (_tui: TUI, _theme: Theme, _kb: KeybindingsManager, done: (result: CompactorSettingsOverlay) => void) => {
     const overlay = new CompactorSettingsOverlay({ cwd });
     overlay.onClose = () => done(overlay);
 

package/src/types.ts

@@ -62,7 +62,11 @@ export interface CompileInput {
 export interface CompactionStats {
   summarized: number;
   kept: number;
-  keptTokensEst: number;
+  totalMessages: number;
+  /** Actual token count from Pi's preparation */
+  tokensBefore: number;
+  /** Estimated tokens after compaction (proportional from kept/total chars) */
+  tokensAfterEst: number;
 }
 
 export type OwnCutCancelReason =
@@ -71,7 +75,7 @@ export type OwnCutCancelReason =
   | "no_user_message";
 
 export type OwnCutResult =
-  | { ok: true; messages: any[]; firstKeptEntryId: string; compactAll: boolean }
+  | { ok: true; messages: Message[]; firstKeptEntryId: string; compactAll: boolean }
   | { ok: false; reason: OwnCutCancelReason };
 
 // ─────────────────────────────────────────────────────────
@@ -193,32 +197,10 @@ export type Language =
   | "elixir";
 
 // ─────────────────────────────────────────────────────────
-// Content store (from context-mode)
+// Content store — REMOVED (moved to @pi-unipi/cocoindex)
+// SearchResult, IndexResult, StoreStats types no longer needed.
 // ─────────────────────────────────────────────────────────
 
-export interface IndexResult {
-  sourceId: number;
-  label: string;
-  totalChunks: number;
-  codeChunks: number;
-}
-
-export interface SearchResult {
-  title: string;
-  content: string;
-  source: string;
-  rank: number;
-  contentType: "code" | "prose";
-  matchLayer?: "porter" | "trigram" | "fuzzy" | "rrf" | "rrf-fuzzy";
-  highlighted?: string;
-}
-
-export interface StoreStats {
-  sources: number;
-  chunks: number;
-  codeChunks: number;
-}
-
 // ─────────────────────────────────────────────────────────
 // Security (from context-mode)
 // ─────────────────────────────────────────────────────────

package/src/store/chunking.ts

@@ -1,126 +0,0 @@
-/**
- * Content chunking — markdown by headings, JSON recursive, plain text
- */
-
-export interface Chunk {
-  title: string;
-  content: string;
-  hasCode: boolean;
-}
-
-export function chunkMarkdown(text: string, maxChunkSize: number = 4096): Chunk[] {
-  const chunks: Chunk[] = [];
-  const lines = text.split("\n");
-  let currentTitle = "";
-  let currentLines: string[] = [];
-  let inCodeBlock = false;
-
-  const flush = () => {
-    if (currentLines.length === 0) return;
-    const content = currentLines.join("\n");
-    chunks.push({
-      title: currentTitle || "Untitled",
-      content,
-      hasCode: content.includes("```"),
-    });
-    currentLines = [];
-  };
-
-  for (const line of lines) {
-    if (line.startsWith("```")) inCodeBlock = !inCodeBlock;
-
-    if (!inCodeBlock && /^#{1,6}\s/.test(line)) {
-      flush();
-      currentTitle = line.replace(/^#{1,6}\s*/, "").trim();
-      continue;
-    }
-
-    currentLines.push(line);
-
-    if (currentLines.join("\n").length > maxChunkSize && !inCodeBlock) {
-      flush();
-      currentTitle = currentTitle ? `${currentTitle} (continued)` : "Continued";
-    }
-  }
-
-  flush();
-  return chunks;
-}
-
-export function chunkJSON(text: string, maxChunkSize: number = 4096): Chunk[] {
-  try {
-    const obj = JSON.parse(text);
-    return chunkObject(obj, "root", maxChunkSize);
-  } catch {
-    return chunkPlainText(text, maxChunkSize);
-  }
-}
-
-function chunkObject(obj: any, path: string, maxChunkSize: number): Chunk[] {
-  const chunks: Chunk[] = [];
-
-  if (typeof obj !== "object" || obj === null) {
-    const content = String(obj);
-    if (content.length > maxChunkSize) {
-      for (let i = 0; i < content.length; i += maxChunkSize) {
-        chunks.push({
-          title: `${path} [${i}-${i + maxChunkSize}]`,
-          content: content.slice(i, i + maxChunkSize),
-          hasCode: false,
-        });
-      }
-    } else {
-      chunks.push({ title: path, content, hasCode: false });
-    }
-    return chunks;
-  }
-
-  if (Array.isArray(obj)) {
-    for (let i = 0; i < obj.length; i++) {
-      const sub = chunkObject(obj[i], `${path}[${i}]`, maxChunkSize);
-      chunks.push(...sub);
-    }
-    return chunks;
-  }
-
-  for (const [key, val] of Object.entries(obj)) {
-    const sub = chunkObject(val, `${path}.${key}`, maxChunkSize);
-    chunks.push(...sub);
-  }
-
-  return chunks;
-}
-
-export function chunkPlainText(text: string, maxChunkSize: number = 4096): Chunk[] {
-  const chunks: Chunk[] = [];
-  const paragraphs = text.split(/\n\s*\n/);
-  let current: string[] = [];
-
-  const flush = () => {
-    if (current.length === 0) return;
-    chunks.push({
-      title: "Text",
-      content: current.join("\n\n"),
-      hasCode: false,
-    });
-    current = [];
-  };
-
-  for (const para of paragraphs) {
-    if ((current.join("\n\n").length + para.length) > maxChunkSize) {
-      flush();
-    }
-    current.push(para);
-  }
-
-  flush();
-  return chunks;
-}
-
-export function autoChunk(text: string, contentType: "markdown" | "json" | "plain", maxChunkSize?: number): Chunk[] {
-  switch (contentType) {
-    case "markdown": return chunkMarkdown(text, maxChunkSize);
-    case "json": return chunkJSON(text, maxChunkSize);
-    default: return chunkPlainText(text, maxChunkSize);
-  }
-}