@pi-unipi/compactor 2.0.0 → 2.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/compactor",
-  "version": "2.0.0",
+  "version": "2.0.2",
   "description": "Context engine for Pi — zero-LLM compaction, session continuity, sandbox execution, and tool display optimization",
   "type": "module",
   "license": "MIT",

package/src/commands/index.ts

@@ -13,6 +13,8 @@ import { getLastCompactionStats } from "../compaction/hooks.js";
 import { vccRecall } from "../tools/vcc-recall.js";
 import { ctxStats } from "../tools/ctx-stats.js";
 import { ctxDoctor } from "../tools/ctx-doctor.js";
+import { recallBlocksFromContext } from "../session/recall-blocks.js";
+import { filterNoise } from "../compaction/filter-noise.js";
 import type { SessionDB } from "../session/db.js";
 import type { NormalizedBlock, RuntimeCounters } from "../types.js";
 
@@ -90,13 +92,19 @@ export function registerCommands(pi: ExtensionAPI, deps?: CommandDeps): void {
   });
 
   // ── /unipi:session-recall (new) ─────────────────────
-  const sessionRecallHandler = async (args: string, ctx: ExtensionCommandContext) => {
+  const sessionRecallHandler = async (args: string, ctx: ExtensionCommandContext, commandName = "/unipi:session-recall") => {
     const query = args.trim();
     if (!query) {
-      ctx.ui.notify("Usage: /unipi:session-recall <query>", "warning");
+      const suffix = commandName === "/unipi:compact-recall" ? " (deprecated; use /unipi:session-recall <query>)" : "";
+      ctx.ui.notify(`Usage: ${commandName} <query>${suffix}`, "warning");
       return;
     }
-    const blocks = deps?.getBlocks() ?? [];
+
+    // Prefer the live session branch over cached blocks. The branch includes raw
+    // pre-compaction messages that are omitted from the compacted LLM context.
+    const config = loadConfig((ctx as any).cwd ?? process.cwd());
+    const liveBlocks = filterNoise(recallBlocksFromContext(ctx), config.pipeline?.customNoisePatterns);
+    const blocks = liveBlocks.length > 0 ? liveBlocks : (deps?.getBlocks() ?? []);
     if (blocks.length === 0) {
       ctx.ui.notify("No session history available for search.", "warning");
       return;
@@ -120,7 +128,7 @@ export function registerCommands(pi: ExtensionAPI, deps?: CommandDeps): void {
     description: "(DEPRECATED) Search session history — use /unipi:session-recall instead",
     handler: async (args: string, ctx: ExtensionCommandContext) => {
       deprecationLog("/unipi:compact-recall", "/unipi:session-recall");
-      return sessionRecallHandler(args, ctx);
+      return sessionRecallHandler(args, ctx, "/unipi:compact-recall");
     },
   });
 

package/src/index.ts

@@ -14,6 +14,7 @@ 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";
 
@@ -242,12 +243,20 @@ export default function compactorExtension(pi: ExtensionAPI): void {
       // Non-fatal
     }
 
-    // Re-cache normalized blocks for vcc_recall
+    // Re-cache normalized blocks for session_recall/vcc_recall.
+    // Command/event contexts do not expose ctx.messages; use the append-only
+    // session branch so recall can find raw messages hidden by compaction.
     try {
-      const messages = (ctx as any).messages ?? [];
-      if (messages.length > 0) {
-        const normalized = normalizeMessages(messages);
-        cachedBlocks = filterNoise(normalized, config.pipeline?.customNoisePatterns);
+      const sessionBlocks = recallBlocksFromContext(ctx);
+      if (sessionBlocks.length > 0) {
+        cachedBlocks = filterNoise(sessionBlocks, config.pipeline?.customNoisePatterns);
+      } else {
+        // Defensive fallback for older Pi contexts that happened to expose messages.
+        const messages = (ctx as any).messages ?? [];
+        if (messages.length > 0) {
+          const normalized = normalizeMessages(messages);
+          cachedBlocks = filterNoise(normalized, config.pipeline?.customNoisePatterns);
+        }
       }
     } catch {
       // Non-fatal: recall will work on empty blocks

package/src/session/recall-blocks.ts

@@ -0,0 +1,112 @@
+/**
+ * Build searchable recall blocks from Pi session entries.
+ *
+ * `ctx.messages` is not available to command handlers and compacted session
+ * context only contains summaries/kept messages. The append-only session branch
+ * still contains the raw pre-compaction messages, so recall should index that
+ * branch directly.
+ */
+
+import type { SessionEntry } from "@mariozechner/pi-coding-agent";
+import type { AgentMessage } from "@mariozechner/pi-agent-core";
+import { normalizeMessages } from "../compaction/normalize.js";
+import { sanitize } from "../compaction/sanitize.js";
+import { textOf } from "../compaction/content.js";
+import type { NormalizedBlock } from "../types.js";
+
+function block(kind: "user" | "assistant", text: string, sourceIndex?: number): NormalizedBlock[] {
+  const clean = sanitize(text);
+  return clean ? [{ kind, text: clean, sourceIndex }] : [];
+}
+
+function normalizeAgentMessage(message: AgentMessage, sourceIndex: number): NormalizedBlock[] {
+  const role = (message as { role?: string }).role;
+
+  // Standard LLM message roles are handled by the existing normalizer.
+  if (role === "user" || role === "assistant" || role === "toolResult") {
+    return normalizeMessages([message as Parameters<typeof normalizeMessages>[0][number]]).map((b) => ({
+      ...b,
+      sourceIndex,
+    }));
+  }
+
+  // Pi-specific session message roles that do not participate in pi-ai Message.
+  if (role === "bashExecution") {
+    const msg = message as AgentMessage & {
+      command?: string;
+      output?: string;
+      exitCode?: number;
+      cancelled?: boolean;
+    };
+    const text = [`$ ${msg.command ?? ""}`, msg.output ?? ""].filter(Boolean).join("\n");
+    return text
+      ? [{ kind: "tool_result", name: "bash", text: sanitize(text), isError: Boolean(msg.cancelled || (msg.exitCode ?? 0) !== 0), sourceIndex }]
+      : [];
+  }
+
+  if (role === "custom") {
+    const msg = message as AgentMessage & { customType?: string; content?: unknown };
+    return block("user", [msg.customType, textOf(msg.content)].filter(Boolean).join("\n"), sourceIndex);
+  }
+
+  if (role === "branchSummary") {
+    const msg = message as AgentMessage & { summary?: string };
+    return block("assistant", msg.summary ?? "", sourceIndex);
+  }
+
+  if (role === "compactionSummary") {
+    const msg = message as AgentMessage & { summary?: string };
+    return block("assistant", msg.summary ?? "", sourceIndex);
+  }
+
+  return [];
+}
+
+/** Convert the active append-only session branch into searchable blocks. */
+export function recallBlocksFromSessionEntries(entries: SessionEntry[]): NormalizedBlock[] {
+  return entries.flatMap((entry, i) => {
+    if (entry.type === "message") {
+      return normalizeAgentMessage(entry.message, i);
+    }
+
+    if (entry.type === "custom_message") {
+      return block("user", [entry.customType, textOf(entry.content)].filter(Boolean).join("\n"), i);
+    }
+
+    if (entry.type === "branch_summary") {
+      return block("assistant", entry.summary, i);
+    }
+
+    if (entry.type === "compaction") {
+      return block("assistant", entry.summary, i);
+    }
+
+    return [];
+  });
+}
+
+/** Best-effort read of searchable blocks from an extension context. */
+export function recallBlocksFromContext(ctx: unknown): NormalizedBlock[] {
+  const sessionManager = (ctx as { sessionManager?: { getBranch?: () => SessionEntry[]; buildSessionContext?: () => { messages?: AgentMessage[] } } })?.sessionManager;
+
+  try {
+    const entries = sessionManager?.getBranch?.();
+    if (Array.isArray(entries) && entries.length > 0) {
+      const blocks = recallBlocksFromSessionEntries(entries);
+      if (blocks.length > 0) return blocks;
+    }
+  } catch {
+    // Fall through to compacted context fallback.
+  }
+
+  try {
+    const messages = sessionManager?.buildSessionContext?.().messages ?? [];
+    if (messages.length > 0) {
+      return messages.flatMap((message, i) => normalizeAgentMessage(message, i));
+    }
+  } catch {
+    // No session context available.
+  }
+
+  return [];
+}

package/src/tools/register.ts

@@ -14,7 +14,7 @@
  */
 
 import { Type } from "@sinclair/typebox";
-import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { ExtensionAPI, ExtensionContext } 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";
@@ -23,6 +23,9 @@ import { ctxBatchExecute, type BatchItem } from "./ctx-batch-execute.js";
 import { ctxStats, type CtxStatsResult } from "./ctx-stats.js";
 import { ctxDoctor, type DoctorResult } from "./ctx-doctor.js";
 import { contextBudgetTool } from "./context-budget.js";
+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";
 
@@ -157,10 +160,12 @@ 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<import("@mariozechner/pi-coding-agent").AgentToolResult<unknown>> => {
+  const recallExec = async (_toolCallId: string, params: any, _signal?: AbortSignal, _onUpdate?: unknown, ctx?: ExtensionContext): Promise<import("@mariozechner/pi-coding-agent").AgentToolResult<unknown>> => {
     const c = deps.getCounters?.();
     if (c) { c.recallQueries++; }
-    const blocks = deps.getBlocks();
+    const config = loadConfig(ctx?.cwd ?? process.cwd());
+    const liveBlocks = ctx ? filterNoise(recallBlocksFromContext(ctx), config.pipeline?.customNoisePatterns) : [];
+    const blocks = liveBlocks.length > 0 ? liveBlocks : deps.getBlocks();
     const input: RecallInput = {
       query: params.query,
       mode: params.mode,