@pi-unipi/unipi 2.4.1 → 2.5.0

package/packages/compactor/src/index.ts

@@ -15,15 +15,14 @@ import {
 } from "./compaction/auto-trigger.js";
 import { SessionDB, getWorktreeSuffix } from "./session/db.js";
 import { extractEventsFromToolResult } from "./session/extract.js";
-import { injectResumeSnapshot } from "./session/resume-inject.js";
+import { buildResumeContextMessage, isSessionContinuityEnabled } from "./session/resume-inject.js";
 import { PolyglotExecutor } from "./executor/executor.js";
 import { registerCommands } from "./commands/index.js";
 import { registerCompactorTools } from "./tools/register.js";
 import { normalizeMessages } from "./compaction/normalize.js";
 import { filterNoise } from "./compaction/filter-noise.js";
 import { recallBlocksFromContext } from "./session/recall-blocks.js";
-import type { NormalizedBlock, CompactorStrategyConfig, RuntimeCounters } from "./types.js";
-import type { RuntimeStats } from "./session/analytics.js";
+import type { NormalizedBlock, CompactorStrategyConfig, RuntimeCounters, RuntimeStats } from "./types.js";
 
 /** Debug logger — only logs when config.debug === true */
 function createDebugLogger(getConfig: () => { debug: boolean }) {
@@ -63,11 +62,6 @@ function isSandboxTool(name: string): boolean {
   return name === "bash" || name === "Bash";
 }
 
-/** Check if a tool is an index tool (content goes to FTS5, not context). Future-proofing. */
-function isIndexTool(_name: string): boolean {
-  return false;
-}
-
 export default function compactorExtension(pi: ExtensionAPI): void {
   let sessionDB: SessionDB | null = null;
   let executor: PolyglotExecutor | null = null;
@@ -86,7 +80,6 @@ export default function compactorExtension(pi: ExtensionAPI): void {
 
   const runtimeStats: RuntimeStats = {
     bytesReturned: {},
-    bytesIndexed: 0,
     bytesSandboxed: 0,
     calls: {},
     sessionStart: Date.now(),
@@ -114,7 +107,7 @@ export default function compactorExtension(pi: ExtensionAPI): void {
       sessionDB = null;
     }
 
-    executor = new PolyglotExecutor();
+    executor = null;
   };
 
   // Register compaction hooks with lazy deps — sessionDB/sessionId may not be
@@ -156,7 +149,6 @@ export default function compactorExtension(pi: ExtensionAPI): void {
 
     // Reset runtime stats for new session
     runtimeStats.bytesReturned = {};
-    runtimeStats.bytesIndexed = 0;
     runtimeStats.bytesSandboxed = 0;
     runtimeStats.calls = {};
     runtimeStats.sessionStart = Date.now();
@@ -168,11 +160,19 @@ export default function compactorExtension(pi: ExtensionAPI): void {
 
     // Register all compactor tools with Pi (deps now have live sessionDB)
     if (sessionDB) {
+      const sandboxEnabled = config.sandboxExecution.enabled && config.sandboxExecution.mode !== "off";
+      executor = sandboxEnabled
+        ? new PolyglotExecutor({ hardCapBytes: config.sandboxExecution.outputLimit, projectRoot: projectDir })
+        : null;
       registerCompactorTools(pi, {
         sessionDB,
         getSessionId: () => currentSessionId,
         getBlocks: () => cachedBlocks,
         getCounters,
+        sandbox: executor ? {
+          executor,
+          allowedLanguages: config.sandboxExecution.allowedLanguages,
+        } : undefined,
       });
     }
 
@@ -277,25 +277,11 @@ export default function compactorExtension(pi: ExtensionAPI): void {
       // Non-fatal: recall will work on empty blocks
     }
 
-    if (sessionDB) {
-      const snapshot = await injectResumeSnapshot(sessionDB, currentSessionId);
-      debug("resume_snapshot", { injected: !!snapshot });
-
-      // Auto-injection on compact: inject behavioral state after compaction
-      if (snapshot && sessionDB) {
-        try {
-          const { buildAutoInjection } = await import("./session/auto-inject.js");
-          const events = sessionDB.getEvents(currentSessionId, { limit: 100 });
-          const autoInjection = buildAutoInjection(events);
-          if (autoInjection) {
-            debug("auto_injection", { tokens: autoInjection.tokens, length: autoInjection.text.length });
-            // Note: auto-injection is included in the resume snapshot context
-            // The model receives it as part of the session state restoration
-          }
-        } catch (err) {
-          debug("auto_injection_error", { error: String(err) });
-        }
-      }
+    const continuityEnabled = isSessionContinuityEnabled(config);
+    if (sessionDB && continuityEnabled) {
+      const resumeContext = await buildResumeContextMessage(sessionDB, currentSessionId);
+      debug("resume_snapshot", { injected: !!resumeContext });
+      return resumeContext;
     }
   });
 
@@ -358,7 +344,8 @@ export default function compactorExtension(pi: ExtensionAPI): void {
   });
 
   pi.on("session_before_compact", async (event, _ctx) => {
-    if (sessionDB) {
+    const continuityEnabled = isSessionContinuityEnabled(config);
+    if (sessionDB && continuityEnabled) {
       // Use closure currentSessionId — Pi's session_before_compact event
       // does not include sessionId at the top level.
       const sessionId = currentSessionId;
@@ -386,14 +373,21 @@ export default function compactorExtension(pi: ExtensionAPI): void {
       const compactionEntry = (event as any).compactionEntry;
       const tokensBefore = compactionEntry?.tokensBefore ?? 0;
 
+      let summarized = 0;
+      let kept = 0;
+      let tokensSaved = 0;
+
       if (tokensBefore > 0) {
         // Use actual token count from Pi's compactionEntry.
         // Compaction typically keeps ~10-15% of original context.
         const charsBefore = tokensBefore * 4;
-        const tokensAfter = (event as any).tokensAfter ?? Math.round(tokensBefore * 0.12);
+        const tokensAfter = Math.round(tokensBefore * 0.12);
+        kept = tokensAfter;
+        tokensSaved = tokensBefore - tokensAfter;
         const charsKept = tokensAfter * 4;
         const messagesSummarized = Math.max(1, Math.round(tokensBefore / 500));
-        counters.totalTokensCompacted += tokensBefore - tokensAfter;
+        summarized = messagesSummarized;
+        counters.totalTokensCompacted += tokensSaved;
         sessionDB.addCompactionStats(sessionId, charsBefore, charsKept, messagesSummarized);
       } else {
         // tokensBefore unavailable — use session event count as a rough heuristic.
@@ -407,13 +401,24 @@ export default function compactorExtension(pi: ExtensionAPI): void {
             const estTokensAfter = Math.round(estTokensBefore * 0.12);
             const charsBefore = estTokensBefore * 4;
             const charsKept = estTokensAfter * 4;
-            counters.totalTokensCompacted += estTokensBefore - estTokensAfter;
+            summarized = eventCount;
+            kept = estTokensAfter;
+            tokensSaved = estTokensBefore - estTokensAfter;
+            counters.totalTokensCompacted += tokensSaved;
             sessionDB.addCompactionStats(sessionId, charsBefore, charsKept, eventCount);
           }
         } catch {
           // Non-fatal: heuristic estimation failed
         }
       }
+      const totalEstimated = tokensSaved + kept;
+      emitEvent(pi, UNIPI_EVENTS.COMPACTOR_COMPACTED, {
+        sessionId,
+        summarized,
+        kept,
+        tokensSaved,
+        compressionRatio: kept > 0 ? `${Math.round(totalEstimated / kept)}:1` : "0:1",
+      });
       debug("session_compact", { sessionId, tokensBefore, hasCompactionEntry: !!compactionEntry });
     }
   });
@@ -531,34 +536,12 @@ export default function compactorExtension(pi: ExtensionAPI): void {
         if (isSandboxTool(tName)) {
           runtimeStats.bytesSandboxed += responseBytes;
         }
-        if (isIndexTool(tName)) {
-          runtimeStats.bytesIndexed += responseBytes;
-        }
       }
     } catch {
       // Non-blocking: byte tracking errors silently skipped
     }
 
-    // Apply display overrides for built-in tools
     const toolName = (event as any).toolName ?? "";
-    const td = config.toolDisplay;
-    const toolConfig = {
-      readOutputMode: td?.mode as any,
-      searchOutputMode: td?.mode as any,
-      bashOutputMode: td?.mode as any,
-      previewLines: 20,
-      bashCollapsedLines: 5,
-      showTruncationHints: true,
-    };
-    try {
-      const { applyToolDisplayOverride } = await import("./display/tool-overrides.js");
-      const override = applyToolDisplayOverride(toolName, event as any, toolConfig);
-      if (override !== undefined) {
-        return override as any;
-      }
-    } catch {
-      // Non-fatal: display override failed
-    }
 
     // Width-safe diff truncation for edit/write tool results.
     // Pi's renderDiff() does not truncate lines to terminal width,

package/packages/compactor/src/session/resume-inject.ts

@@ -2,10 +2,16 @@
  * Resume injection — inject snapshot into session context post-compaction
  */
 
+import type { BeforeAgentStartEventResult } from "@earendil-works/pi-coding-agent";
 import type { SessionDB } from "./db.js";
 import { buildResumeSnapshot } from "./snapshot.js";
 import { buildAutoInjection } from "./auto-inject.js";
 import { loadConfig } from "../config/manager.js";
+import type { CompactorConfig } from "../types.js";
+
+export function isSessionContinuityEnabled(config: CompactorConfig): boolean {
+  return config.sessionContinuity.enabled && config.sessionContinuity.mode !== "off";
+}
 
 export async function injectResumeSnapshot(
   db: SessionDB,
@@ -35,3 +41,24 @@ export async function injectResumeSnapshot(
   db.markResumeConsumed(sessionId);
   return fullSnapshot;
 }
+
+/**
+ * Build the one-shot hidden context message used on the first turn after
+ * compaction. Keeping this out of the system prompt preserves Pi's stable
+ * prompt/history prefix for provider cache reuse.
+ */
+export async function buildResumeContextMessage(
+  db: SessionDB,
+  sessionId: string,
+): Promise<BeforeAgentStartEventResult | undefined> {
+  const snapshot = await injectResumeSnapshot(db, sessionId);
+  if (!snapshot) return undefined;
+
+  return {
+    message: {
+      customType: "unipi-compactor-resume",
+      content: snapshot,
+      display: false,
+    },
+  };
+}

package/packages/compactor/src/tools/ctx-batch-execute.ts

@@ -20,9 +20,11 @@ export interface BatchResult {
   >;
 }
 
-export async function ctxBatchExecute(items: BatchItem[]): Promise<BatchResult> {
+export async function ctxBatchExecute(
+  items: BatchItem[],
+  executor = new PolyglotExecutor(),
+): Promise<BatchResult> {
   const results: BatchResult["results"] = [];
-  const executor = new PolyglotExecutor();
 
   for (const item of items) {
     if (item.type === "execute") {

package/packages/compactor/src/tools/ctx-execute-file.ts

@@ -12,11 +12,13 @@ export interface CtxExecuteFileInput {
   timeout?: number;
 }
 
-export async function ctxExecuteFile(input: CtxExecuteFileInput): Promise<ExecResult> {
+export async function ctxExecuteFile(
+  input: CtxExecuteFileInput,
+  executor = new PolyglotExecutor(),
+): Promise<ExecResult> {
   const content = readFileSync(input.path, "utf-8");
   const code = `const FILE_CONTENT = ${JSON.stringify(content)};\n// User script follows:\n`;
   
-  const executor = new PolyglotExecutor();
   return executor.executeFile({
     language: input.language,
     path: input.path,

package/packages/compactor/src/tools/ctx-execute.ts

@@ -11,8 +11,10 @@ export interface CtxExecuteInput {
   timeout?: number;
 }
 
-export async function ctxExecute(input: CtxExecuteInput): Promise<ExecResult> {
-  const executor = new PolyglotExecutor();
+export async function ctxExecute(
+  input: CtxExecuteInput,
+  executor = new PolyglotExecutor(),
+): Promise<ExecResult> {
   return executor.execute({
     language: input.language,
     code: input.code,

package/packages/compactor/src/tools/register.ts

@@ -27,7 +27,8 @@ import { recallBlocksFromContext } from "../session/recall-blocks.js";
 import { filterNoise } from "../compaction/filter-noise.js";
 import { loadConfig } from "../config/manager.js";
 import type { SessionDB } from "../session/db.js";
-import type { NormalizedBlock, RuntimeCounters } from "../types.js";
+import type { Language, NormalizedBlock, RuntimeCounters } from "../types.js";
+import type { PolyglotExecutor } from "../executor/executor.js";
 
 // --- TypeBox Schemas for each tool ---
 
@@ -127,6 +128,10 @@ export interface CompactorToolDeps {
   getSessionId: () => string;
   getBlocks: () => NormalizedBlock[];
   getCounters?: () => RuntimeCounters;
+  sandbox?: {
+    executor: PolyglotExecutor;
+    allowedLanguages: Language[];
+  };
 }
 
 /**
@@ -189,13 +194,23 @@ export function registerCompactorTools(pi: ExtensionAPI, deps: CompactorToolDeps
   pi.registerTool({ name: "session_recall", label: "Session Recall", description: "Search session history using BM25 or regex. Find previous goals, files, commits, and context.", parameters: RecallParams, execute: recallExec } as any);
   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);
 
+  // Sandbox tools are session-scoped and only registered when enabled.
+  if (deps.sandbox) {
+  const { executor, allowedLanguages } = deps.sandbox;
+  const assertAllowedLanguage = (language: Language): void => {
+    if (!allowedLanguages.includes(language)) {
+      throw new Error(`Language "${language}" is disabled by Compactor sandbox settings. Allowed: ${allowedLanguages.join(", ") || "none"}`);
+    }
+  };
+
   // 3. sandbox (new) / ctx_execute (deprecated) — run code in sandbox
   const sandboxExec = async (_toolCallId: string, params: any): Promise<import("@earendil-works/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);
+      assertAllowedLanguage(params.language as Language);
+      const result = await ctxExecute(params as CtxExecuteInput, executor);
       const parts: string[] = [];
       if (result.stdout) parts.push(result.stdout);
       if (result.stderr) parts.push(`[stderr] ${result.stderr}`);
@@ -215,7 +230,8 @@ export function registerCompactorTools(pi: ExtensionAPI, deps: CompactorToolDeps
       const c = deps.getCounters?.();
       if (c) { c.sandboxRuns++; }
       deps.sessionDB.incrementSandboxRuns(deps.getSessionId());
-      const result = await ctxExecuteFile(params as CtxExecuteFileInput);
+      assertAllowedLanguage(params.language as Language);
+      const result = await ctxExecuteFile(params as CtxExecuteFileInput, executor);
       const parts: string[] = [];
       if (result.stdout) parts.push(result.stdout);
       if (result.stderr) parts.push(`[stderr] ${result.stderr}`);
@@ -234,7 +250,8 @@ export function registerCompactorTools(pi: ExtensionAPI, deps: CompactorToolDeps
       const c = deps.getCounters?.();
       if (c) { c.sandboxRuns++; }
       deps.sessionDB.incrementSandboxRuns(deps.getSessionId());
-      const result = await ctxBatchExecute(params.items as BatchItem[]);
+      for (const item of params.items as BatchItem[]) assertAllowedLanguage(item.language);
+      const result = await ctxBatchExecute(params.items as BatchItem[], executor);
       const summaries = result.results.map((r, i) => {
         const s = r.result.stdout?.slice(0, 200) || "(no output)";
         return `[${i}] execute → ${r.result.exitCode === 0 ? "ok" : "fail"}: ${s}`;
@@ -246,6 +263,7 @@ export function registerCompactorTools(pi: ExtensionAPI, deps: CompactorToolDeps
   };
   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. compactor_stats (new) / ctx_stats (deprecated) — context savings dashboard
   const statsExec = async (): Promise<import("@earendil-works/pi-coding-agent").AgentToolResult<unknown>> => {

package/packages/compactor/src/tui/settings-overlay.ts

@@ -122,7 +122,7 @@ const STRATEGIES: StrategyDef[] = [
     key: "sessionContinuity",
     label: "Session Continuity",
     description: "XML resume snapshot for compaction survival",
-    modes: ["full", "essential-only", "off"],
+    modes: ["full", "off"],
     getEnabled: (c) => c.sessionContinuity.enabled,
     setEnabled: (c, v) => (c.sessionContinuity.enabled = v),
     getMode: (c) => c.sessionContinuity.mode,
@@ -132,31 +132,18 @@ const STRATEGIES: StrategyDef[] = [
     key: "sandboxExecution",
     label: "Sandbox Execution",
     description: "Polyglot code execution",
-    modes: ["all", "safe-only", "off"],
+    modes: ["all", "off"],
     getEnabled: (c) => c.sandboxExecution.enabled,
     setEnabled: (c, v) => (c.sandboxExecution.enabled = v),
     getMode: (c) => c.sandboxExecution.mode,
     setMode: (c, v) => (c.sandboxExecution.mode = v as any),
   },
-  {
-    key: "toolDisplay",
-    label: "Tool Display",
-    description: "Override tool output rendering",
-    modes: ["opencode", "balanced", "verbose", "custom"],
-    getEnabled: (c) => c.toolDisplay.enabled,
-    setEnabled: (c, v) => (c.toolDisplay.enabled = v),
-    getMode: (c) => c.toolDisplay.mode,
-    setMode: (c, v) => (c.toolDisplay.mode = v as any),
-  },
 ];
 
 const PIPELINE_ITEMS: PipelineDef[] = [
-  { key: "ttlCache", label: "TTL Cache", description: "Cache with time-based expiry", group: "On Compaction", getValue: (c) => c.pipeline.ttlCache, setValue: (c, v) => (c.pipeline.ttlCache = v) },
+  // Only expose implemented behavior. Reserved compatibility fields remain in
+  // the persisted schema so existing config files continue to load.
   { key: "autoInjection", label: "Auto Injection", description: "Inject behavioral state after compaction", group: "On Compaction", getValue: (c) => c.pipeline.autoInjection, setValue: (c, v) => (c.pipeline.autoInjection = v) },
-  { 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 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"];
@@ -167,20 +154,20 @@ const REPEAT_GROWTH_VALUES = ["0", "1k", "4k", "8k", "16k", "32k"];
 
 const PRESET_DESCRIPTIONS: Record<string, { summary: string; detail: string }> = {
   precise: {
-    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.",
+    summary: "Code-heavy, minimal waste — compaction: full, sandbox: all",
+    detail: "Max token savings. Compaction: full.\nSandbox: all. Auto injection: off.",
   },
   balanced: {
     summary: "Daily use (default) — all strategies moderate",
-    detail: "Moderate all strategies. Display: balanced.\nSandbox: all. Pipeline: all 6 on.",
+    detail: "Moderate all strategies.\nSandbox: all. Auto injection: on.",
   },
   thorough: {
     summary: "Debug/audit — everything on, full transcript",
-    detail: "Everything enabled. Display: verbose.\nSandbox: all. Pipeline: all 6 on.",
+    detail: "Everything enabled.\nSandbox: all. Auto injection: on.",
   },
   lean: {
     summary: "Quick fixes, short sessions — compaction only",
-    detail: "Compaction only. Display: opencode.\nSandbox: off. Pipeline: all 6 off.",
+    detail: "Compaction only.\nSandbox: off. Auto injection: off.",
   },
 };
 

package/packages/compactor/src/types.ts

@@ -49,6 +49,16 @@ export interface BriefLine {
   lines: string[];
 }
 
+/** Runtime stats tracked during a live session. */
+export interface RuntimeStats {
+  bytesReturned: Record<string, number>;
+  bytesSandboxed: number;
+  calls: Record<string, number>;
+  sessionStart: number;
+  cacheHits: number;
+  cacheBytesSaved: number;
+}
+
 // ─────────────────────────────────────────────────────────
 // Compaction input / output
 // ─────────────────────────────────────────────────────────
@@ -110,18 +120,29 @@ export interface CompactorConfig {
   outstandingContext: CompactorStrategyConfig & { mode: "full" | "critical-only" | "off"; maxItems: number };
   userPreferences: CompactorStrategyConfig & { mode: "all" | "recent-only" | "off"; maxPreferences: number };
   briefTranscript: CompactorStrategyConfig & { mode: "full" | "compact" | "minimal" | "off"; userTokenLimit: number; assistantTokenLimit: number; toolCallLimit: number };
-  sessionContinuity: CompactorStrategyConfig & { mode: "full" | "essential-only" | "off"; eventCategories: string[] };
+  sessionContinuity: CompactorStrategyConfig & {
+    mode: "full" | "essential-only" | "off";
+    /** @deprecated Category filtering was never implemented; ignored by runtime. */
+    eventCategories: string[];
+  };
+  /** @deprecated Project indexing moved to @pi-unipi/cocoindex; retained for config compatibility. */
   fts5Index: CompactorStrategyConfig & { mode: "auto" | "manual" | "off"; chunkSize: number; cacheTtlHours: number };
-  sandboxExecution: CompactorStrategyConfig & { mode: "all" | "safe-only" | "off"; allowedLanguages: string[]; outputLimit: number };
+  sandboxExecution: CompactorStrategyConfig & { mode: "all" | "safe-only" | "off"; allowedLanguages: Language[]; outputLimit: number };
+  /** @deprecated Display profiles were never connected to runtime; retained for config compatibility. */
   toolDisplay: CompactorStrategyConfig & { mode: "opencode" | "balanced" | "verbose" | "custom"; diffLayout: "auto" | "split" | "unified"; diffIndicator: "bars" | "classic" | "none"; showThinkingLabels: boolean; showUserMessageBox: boolean; showBashSpinner: boolean; showPendingPreviews: boolean };
 
   // Pipeline features
   pipeline: {
+    /** @deprecated Reserved compatibility field; ignored by runtime. */
     ttlCache: boolean;
     autoInjection: boolean;
+    /** @deprecated Reserved compatibility field; ignored by runtime. */
     proximityReranking: boolean;
+    /** @deprecated Reserved compatibility field; ignored by runtime. */
     timelineSort: boolean;
+    /** @deprecated Reserved compatibility field; ignored by runtime. */
     progressiveThrottling: boolean;
+    /** @deprecated Reserved compatibility field; ignored by runtime. */
     mmapPragma: boolean;
     customNoisePatterns: string[];
   };
@@ -132,6 +153,7 @@ export interface CompactorConfig {
   // Global settings
   overrideDefaultCompaction: boolean;
   debug: boolean;
+  /** @deprecated Truncation hints were never connected to runtime; retained for config compatibility. */
   showTruncationHints: boolean;
 }
 

package/packages/core/events.ts

@@ -9,7 +9,7 @@
 export const UNIPI_EVENTS = {
   /** Module loaded and ready */
   MODULE_READY: "unipi:module:ready",
-  /** Module unloading */
+  /** @deprecated No built-in emitter; retained for external compatibility. */
   MODULE_GONE: "unipi:module:gone",
 
   /** Workflow command started */
@@ -24,9 +24,9 @@ export const UNIPI_EVENTS = {
   /** Ralph loop iteration completed */
   RALPH_ITERATION_DONE: "unipi:ralph:iteration:done",
 
-  /** Request module status (for info-screen) */
+  /** @deprecated No built-in responders; use the info registry and /unipi:info. */
   MODULE_STATUS_REQUEST: "unipi:module:status:request",
-  /** Module status response */
+  /** @deprecated No built-in aggregator; use the info registry and /unipi:info. */
   MODULE_STATUS_RESPONSE: "unipi:module:status:response",
 
   /** Info screen group registered */
@@ -38,7 +38,7 @@ export const UNIPI_EVENTS = {
   MEMORY_STORED: "unipi:memory:stored",
   /** Memory deleted */
   MEMORY_DELETED: "unipi:memory:deleted",
-  /** Memory search performed */
+  /** @deprecated No built-in emitter; retained for external compatibility. */
   MEMORY_SEARCHED: "unipi:memory:searched",
   /** Memory consolidation completed */
   MEMORY_CONSOLIDATED: "unipi:memory:consolidated",
@@ -58,9 +58,9 @@ export const UNIPI_EVENTS = {
 
   /** Compactor: compaction completed */
   COMPACTOR_COMPACTED: "unipi:compactor:compacted",
-  /** Compactor: stats updated */
+  /** @deprecated Footer reads live Pi session data; retained for compatibility. */
   COMPACTOR_STATS_UPDATED: "unipi:compactor:stats:updated",
-  /** Utility module cleanup started */
+  /** @deprecated No built-in emitter; retained for external compatibility. */
   UTILITY_CLEANUP_START: "unipi:utility:cleanup:start",
   /** Utility module cleanup completed */
   UTILITY_CLEANUP_DONE: "unipi:utility:cleanup:done",
@@ -68,9 +68,9 @@ export const UNIPI_EVENTS = {
   UTILITY_DIAGNOSTICS_START: "unipi:utility:diagnostics:start",
   /** Utility diagnostics completed */
   UTILITY_DIAGNOSTICS_DONE: "unipi:utility:diagnostics:done",
-  /** Utility cache invalidated */
+  /** @deprecated No built-in emitter; retained for external compatibility. */
   UTILITY_CACHE_INVALIDATED: "unipi:utility:cache:invalidated",
-  /** Utility lifecycle state changed */
+  /** @deprecated No built-in emitter; retained for external compatibility. */
   UTILITY_LIFECYCLE_STATE: "unipi:utility:lifecycle:state",
 
   /** Notification sent */
@@ -91,11 +91,11 @@ export const UNIPI_EVENTS = {
   /** Update error */
   UPDATE_ERROR: "unipi:update:error",
 
-  /** CocoIndex: update started */
+  /** @deprecated Reserved external contract; no built-in emitter. */
   COCOINDEX_UPDATE_STARTED: "unipi:cocoindex:update:started",
-  /** CocoIndex: update completed */
+  /** @deprecated Reserved external contract; no built-in emitter. */
   COCOINDEX_UPDATE_COMPLETED: "unipi:cocoindex:update:completed",
-  /** CocoIndex: search performed */
+  /** @deprecated Reserved external contract; no built-in emitter. */
   COCOINDEX_SEARCH_PERFORMED: "unipi:cocoindex:search:performed",
 } as const;
 
@@ -151,13 +151,13 @@ export interface UnipiRalphIterationEvent {
   nextIteration: number;
 }
 
-/** Payload for MODULE_STATUS_REQUEST */
+/** @deprecated No built-in responders; retained for compatibility. */
 export interface UnipiStatusRequestEvent {
   /** Request ID for correlation */
   requestId: string;
 }
 
-/** Payload for MODULE_STATUS_RESPONSE */
+/** @deprecated No built-in aggregator; retained for compatibility. */
 export interface UnipiStatusResponseEvent {
   /** Request ID this responds to */
   requestId: string;

package/packages/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/core",
-  "version": "2.4.0",
+  "version": "2.5.0",
   "description": "Shared utilities, event types, and constants for Unipi extension suite",
   "type": "module",
   "license": "MIT",
@@ -17,7 +17,8 @@
   ],
   "files": [
     "*.ts",
-    "README.md"
+    "README.md",
+    "!*.test.ts"
   ],
   "publishConfig": {
     "access": "public"

package/packages/core/sandbox.ts

@@ -2,7 +2,8 @@
  * @unipi/core — Sandbox module
  *
  * Defines tool access levels for workflow commands.
- * Used with pi.setActiveTools() to enforce restrictions.
+ * Workflow enforces blocked names at tool_call time so provider tool schemas
+ * and ordering remain stable; filtering helpers remain available to other callers.
  */
 
 import { WORKFLOW_COMMANDS } from "./constants.js";
@@ -13,9 +14,9 @@ export type SandboxLevel = "read_only" | "brainstorm" | "write_unipi" | "review"
 /**
  * Built-in workflow tools used when no active tool list is supplied.
  *
- * Workflow commands should normally call filterToolsForLevel() with the current
- * active tool list. That keeps safe extension tools (memory, ask-user, web,
- * notify, etc.) available while removing only tools that violate the sandbox.
+ * Legacy fallback list used by callers that need an explicit filtered tool set.
+ * The workflow package itself keeps Pi's active tools unchanged and enforces
+ * BLOCKED_TOOLS at tool_call time.
  */
 const FALLBACK_TOOLS: Record<SandboxLevel, readonly string[]> = {
   /** Only read-only file tools — no bash, no write, no edit */
@@ -78,8 +79,8 @@ export function getSandboxLevel(commandName: string): SandboxLevel {
 /**
  * Get fallback tools for a sandbox level.
  *
- * Prefer filterToolsForLevel(level, activeTools) when applying a sandbox so
- * extension tools are preserved unless explicitly blocked.
+ * Prefer isToolAllowed() for cache-stable call-time enforcement. Filtering is
+ * retained for compatibility with callers that intentionally alter tool sets.
  */
 export function getToolsForLevel(level: SandboxLevel): readonly string[] {
   return FALLBACK_TOOLS[level];

package/packages/footer/README.md

@@ -22,7 +22,7 @@ Footer subscribes to events from every Unipi package:
 | Group | Events | Segments |
 |-------|--------|----------|
 | core | Pi SDK | model, thinking, path, git, context_pct, cost, tokens, session |
-| compactor | `COMPACTOR_STATS_UPDATED` | session_events, compactions, tokens_saved, compression_ratio |
+| compactor | Pi session data + `COMPACTOR_COMPACTED` | session_events, compactions, tokens_saved, compression_ratio |
 | memory | `MEMORY_STORED`/`DELETED`/`CONSOLIDATED` | project_count, total_count, consolidations |
 | mcp | `MCP_SERVER_STARTED`/`STOPPED`/`ERROR` | servers_total, servers_active, tools_total |
 | ralph | `RALPH_LOOP_START`/`END`/`ITERATION_DONE` | active_loops, total_iterations, loop_status |
@@ -48,7 +48,7 @@ Footer works even if packages load after it — late-arriving events update the
 | Group | Default | Data Source |
 |-------|---------|-------------|
 | **core** | ON | Pi SDK (ctx.sessionManager, footerData) |
-| **compactor** | ON | `COMPACTOR_STATS_UPDATED` event |
+| **compactor** | ON | Live Pi session data; last-compaction event |
 | **memory** | ON | `MEMORY_STORED`/`DELETED`/`CONSOLIDATED` events |
 | **mcp** | ON | `MCP_SERVER_STARTED`/`STOPPED`/`ERROR` events |
 | **ralph** | ON | `RALPH_LOOP_START`/`END`/`ITERATION_DONE` events |