@monotykamary/pi-vcc 0.7.5 → 0.8.1

package/README.md

@@ -236,12 +236,18 @@ pi -e https://github.com/monotykamary/pi-vcc@tom
 Once installed, pi-vcc registers a `session_before_compact` hook.
 
 - Run `/pi-vcc` to trigger pi-vcc compaction manually.
-- By default, pi-vcc handles all compaction paths (`/compact`, auto-threshold, `/pi-vcc`). Set `overrideDefaultCompaction: false` in the config to fall back to pi core's LLM-based compaction for `/compact` and auto-threshold.
+- By default, pi-vcc handles all compaction paths (`/compact`, auto-threshold, `/pi-vcc`). Set `overrideDefaultCompaction: false` in the config to fall back to pi core's LLM-based compaction for `/compact` and auto-threshold. When pi-fabric's compaction engine is active, pi-vcc retains its threshold and recovery triggers but delegates non-`/pi-vcc` summary compilation to pi-fabric.
 - To search older active-lineage history after compaction, use `vcc_recall`.
 - To intentionally search across all lineages, pass `scope:"all"` to `vcc_recall` or run `/pi-vcc-recall <query> scope:all`.
 - To search and feed results to agent yourself, run `/pi-vcc-recall <query> [page:N]`.
   - Tip: type `/recall` and Pi will autocomplete to `/pi-vcc-recall`.
 
+### pi-fabric interop
+
+When `PI_FABRIC_COMPACTION_ENGINE=fabric`, pi-vcc defers non-explicit summary compilation to pi-fabric while preserving its proactive-threshold and Codex recovery trigger behavior. pi-fabric marks an event it has already claimed with `_fabricCompaction === true`, which prevents pi-vcc from replacing that result. An explicit `/pi-vcc` uses the `__pi_vcc__` instruction sentinel and always runs pi-vcc's deterministic compiler.
+
+The precedence is: explicit `/pi-vcc` sentinel > pi-fabric engine > pi-vcc default override.
+
 ### How compaction works
 
 Pi splits the conversation at the **last user message**. Everything after — the **kept tail** — stays intact and untouched. pi-vcc only summarizes the older portion before that cut point.
@@ -573,7 +579,7 @@ Config lives at `~/.pi/agent/pi-vcc-config.json` (auto-scaffolded on first load
 }
 ```
 
-- **`overrideDefaultCompaction`** *(default `true`)*: when `true` (default), pi-vcc handles all compaction paths (`/compact`, auto-threshold, `/pi-vcc`). Set `false` to let pi core handle `/compact` and auto-threshold compactions via its default LLM-based compaction.
+- **`overrideDefaultCompaction`** *(default `true`)*: when `true` (default), pi-vcc handles all compaction paths (`/compact`, auto-threshold, `/pi-vcc`) unless the active pi-fabric engine owns summary compilation. Set `false` to let pi core handle `/compact` and auto-threshold compactions via its default LLM-based compaction. Explicit `/pi-vcc` always uses pi-vcc.
 - **`debug`** *(default `false`)*: when `true`, each compaction writes detailed info to `/tmp/pi-vcc-debug.json` — message counts, cut boundary, summary preview, sections.
 - **`modelThresholds`** *(default: none)*: per-model compaction thresholds. Keys match against `"provider/modelId"` (e.g., `"neuralwatt/zai-org/GLM-5.1-FP8"`) or just `"modelId"` (e.g., `"GLM-5.1"` — matched only when `provider/modelId` doesn't). Each value has:
   - **`reserveTokens`**: tokens to reserve for the LLM response. Overrides pi-core's global `compaction.reserveTokens` for matching models. Controls *when* compaction triggers: `contextTokens > contextWindow − reserveTokens`. A higher value compacts earlier (more conservative); a lower value lets context grow larger. Takes precedence over `compactAtTokens` and `compactPercent` when multiple are set.

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@monotykamary/pi-vcc",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@monotykamary/pi-vcc",
-      "version": "0.7.0",
+      "version": "0.8.0",
       "devDependencies": {
         "knip": "6.14.1",
         "typescript": "6.0.3"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@monotykamary/pi-vcc",
-  "version": "0.7.5",
+  "version": "0.8.1",
   "description": "Algorithmic conversation compactor for pi - transcript-preserving structured summaries, no LLM calls",
   "main": "index.ts",
   "keywords": [

package/src/core/content.ts

@@ -59,6 +59,28 @@ const thinkingParts = (content: Message["content"]): string[] => {
 export const thinkingOf = (content: Message["content"]): string =>
   thinkingParts(content).join("\n");
 
+const toolCallArgText = (args: Record<string, unknown>): string => {
+  const vals: string[] = [];
+  for (const v of Object.values(args ?? {})) {
+    if (typeof v === "string" && v.length > 0) vals.push(v);
+  }
+  return vals.join("\n");
+};
+
+const toolCallParts = (content: Message["content"]): string[] => {
+  if (!content || typeof content === "string") return [];
+  return content
+    .filter((part) => part.type === "toolCall")
+    .map((part) => toolCallArgText(part.arguments));
+};
+
+/** Extract all string-valued arguments from toolCall content parts.
+ *  Lets vcc_recall match against tool invocations — e.g. a bash
+ *  toolCall's `arguments.command`, a grep's `pattern`, an edit's
+ *  `oldText`/`newText`. Non-string args are skipped. */
+export const toolCallsOf = (content: Message["content"]): string =>
+  toolCallParts(content).filter(Boolean).join("\n");
+
 /** Extract a snippet of ~`radius` chars around the first match of `term` in `text`. */
 const snippet = (text: string, term: string, radius = 60): string | null => {
   const idx = text.toLowerCase().indexOf(term.toLowerCase());

package/src/core/search-entries.ts

@@ -1,6 +1,6 @@
 import type { Message } from "@earendil-works/pi-ai";
 import type { RenderedEntry } from "./render-entries";
-import { textOf, thinkingOf } from "./content";
+import { textOf, thinkingOf, toolCallsOf } from "./content";
 
 export interface SearchHit extends RenderedEntry {
   /** Context snippet around the first matched term (only when query provided) */
@@ -270,10 +270,13 @@ const fullText = (msg: Message): string => {
   if ((msg as any).role === "bashExecution") {
     return `${(msg as any).command ?? ""} ${(msg as any).output ?? ""}`;
   }
-  // Include thinking content so recall can match against model reasoning
+  // Include thinking + toolCall arguments so recall can match against
+  // model reasoning and tool invocations (e.g. a bash toolCall's command).
   let text = textOf(msg.content);
   const thinking = thinkingOf(msg.content);
   if (thinking) text = thinking + "\n" + text;
+  const toolArgs = toolCallsOf(msg.content);
+  if (toolArgs) text = toolArgs + "\n" + text;
   return text;
 };
 

package/src/hooks/before-compact.ts

@@ -28,6 +28,8 @@ let lastCompactWasPiVcc = false;
 let lastCompactWasCodexRecovery = false;
 let lastCompactWasProactive = false;
 let lastCompactHandledByVcc = false;
+let lastCompactDeferredToFabric = false;
+let hasNotifiedFabricDeferral = false;
 export const getLastCompactionStats = () => lastStats;
 
 const formatTokens = (n: number): string => {
@@ -459,6 +461,9 @@ export function shouldTriggerResumeForCompaction(
 
 export const registerBeforeCompactHook = (pi: ExtensionAPI) => {
   pi.on("session_before_compact", (event, ctx) => {
+    // pi-fabric may run before pi-vcc and mark the shared event after claiming it.
+    if ((event as any)._fabricCompaction === true) return;
+
     const { preparation, branchEntries, customInstructions } = event;
     const settings = loadSettings();
 
@@ -495,6 +500,32 @@ export const registerBeforeCompactHook = (pi: ExtensionAPI) => {
     const isPiVccHandled =
       isPiVcc || isCodexOutputLimitCompaction || isCodexContextOverflowCompaction;
 
+    // Explicit /pi-vcc takes precedence over the pi-fabric engine. For every
+    // other compaction, retain pi-vcc's trigger/recovery bookkeeping but let
+    // pi-fabric compile the summary.
+    if (!isPiVcc && process.env.PI_FABRIC_COMPACTION_ENGINE === "fabric") {
+      if (!isPiVccHandled && !settings.overrideDefaultCompaction) return;
+      if (isCodexContextOverflowCompaction) clearCodexContextOverflowPending();
+
+      lastCompactWasPiVcc = false;
+      lastCompactWasCodexRecovery =
+        isCodexOutputLimitCompaction || isCodexContextOverflowCompaction;
+      lastCompactWasProactive = isProactiveTriggerActive();
+      lastCompactHandledByVcc = true;
+      lastCompactDeferredToFabric = true;
+
+      if (settings.overrideDefaultCompaction && !hasNotifiedFabricDeferral) {
+        hasNotifiedFabricDeferral = true;
+        try {
+          ctx?.ui?.notify?.(
+            "pi-vcc: deferring compaction to pi-fabric engine (explicit /pi-vcc still uses pi-vcc)",
+            "info",
+          );
+        } catch {}
+      }
+      return;
+    }
+
     // Always handle explicit /pi-vcc and Codex recovery markers. Otherwise,
     // only handle when the user opted in via settings.
     if (!isPiVccHandled && !settings.overrideDefaultCompaction) return;
@@ -672,6 +703,7 @@ export const registerBeforeCompactHook = (pi: ExtensionAPI) => {
       isCodexOutputLimitCompaction || isCodexContextOverflowCompaction;
     lastCompactWasProactive = isProactiveTriggerActive();
     lastCompactHandledByVcc = true;
+    lastCompactDeferredToFabric = false;
 
     // Signal to neuralwatt-mcr that pi-vcc is handling compaction
     // so it doesn't cancel the event. Without this flag, neuralwatt-mcr
@@ -689,6 +721,10 @@ export const registerBeforeCompactHook = (pi: ExtensionAPI) => {
     };
   });
 
+  pi.on("session_start", () => {
+    hasNotifiedFabricDeferral = false;
+  });
+
   // After compaction completes, check if the agent loop stalled and needs
   // an invisible continue to resume.  This handles threshold compaction
   // where willRetry=false — pi-core doesn't auto-retry, and the agent loop
@@ -697,17 +733,20 @@ export const registerBeforeCompactHook = (pi: ExtensionAPI) => {
   // that isn't a clean end_turn), the agent was interrupted and should
   // continue.
   pi.on("session_compact", (event, ctx) => {
-    // Only act when pi-vcc drove the compaction
+    // Act when pi-vcc compiled the summary or tracked a compaction delegated
+    // to pi-fabric so proactive and Codex recovery continuation still works.
     if (!lastCompactHandledByVcc) return;
     const wasCodexRecoveryCompaction = lastCompactWasCodexRecovery;
     const wasProactiveCompaction = lastCompactWasProactive;
+    const wasDeferredToFabric = lastCompactDeferredToFabric;
     lastCompactHandledByVcc = false;
     lastCompactWasCodexRecovery = false;
     lastCompactWasProactive = false;
+    lastCompactDeferredToFabric = false;
 
-    // Fire success toast for /compact path only (delayed to let UI settle).
-    // /pi-vcc path uses its own onComplete callback in the command handler.
-    if (!lastCompactWasPiVcc) {
+    // Fire success toast for pi-vcc's /compact path only (delayed to let UI
+    // settle). /pi-vcc has its own callback, and pi-fabric owns delegated UI.
+    if (!lastCompactWasPiVcc && !wasDeferredToFabric) {
       const stats = lastStats;
       const count = countPiVccCompactionsFromSession(ctx?.sessionManager as any);
       const compactionLabel = count > 0