@monotykamary/pi-vcc 0.7.4 → 0.8.0

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/index.ts

@@ -5,17 +5,14 @@ import { registerProactiveThresholdHook } from "./src/hooks/proactive-threshold"
 import { registerPiVccCommand } from "./src/commands/pi-vcc";
 import { registerVccRecallCommand } from "./src/commands/vcc-recall";
 import { registerRecallTool } from "./src/tools/recall";
-import { resetInvisibleContinue } from "./src/core/invisible-continue";
+import { registerInvisibleContinue } from "./src/core/invisible-continue";
 
 export default (pi: ExtensionAPI) => {
   scaffoldSettings();
+  registerInvisibleContinue(pi);
   registerBeforeCompactHook(pi);
   registerProactiveThresholdHook(pi);
   registerPiVccCommand(pi);
   registerVccRecallCommand(pi);
   registerRecallTool(pi);
-
-  pi.on("session_start", () => {
-    resetInvisibleContinue();
-  });
 };

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.4",
+  "version": "0.8.0",
   "description": "Algorithmic conversation compactor for pi - transcript-preserving structured summaries, no LLM calls",
   "main": "index.ts",
   "keywords": [

package/src/core/invisible-continue.ts

@@ -1,176 +1,32 @@
-import { Agent } from "@earendil-works/pi-agent-core";
-
-/**
- * Invisible continue — resume the agent loop after compaction without
- * injecting any message into context.
- *
- * Same mechanism as pi-retry: capture the live Agent instance via
- * subscribe() monkey-patch, then call agent.prompt([]) to start a
- * fresh agent loop that picks up where the compacted transcript left off.
- * The LLM sees the exact same message list — no new user prompt.
- *
- * Used after threshold compaction when the agent would otherwise stall
- * (willRetry=false, no queued messages).
- */
-
-let _agent: Agent | null = null;
-let _continueInProgress = false;
-
-// Timestamp of the last completed triggerInvisibleContinue().
-// Used by the continue() monkey-patch to detect when triggerInvisibleContinue
-// just ran (so it shouldn't fall back to prompt([]) again — the agent
-// already continued). This prevents double continuation when both
-// pi-retry and pi-vcc are installed.
-let _lastInvisibleContinueTime = 0;
-
-// Monkey-patch Agent.prototype.subscribe to capture the live instance.
-// Chain the previous patch (if pi-retry already patched it) so both
-// extensions can coexist.
-const _prevSubscribe = Agent.prototype.subscribe;
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-Agent.prototype.subscribe = function (this: Agent, ...args: any[]) {
-  _agent = this;
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  return (_prevSubscribe as any).apply(this, args);
-};
-
-// Monkey-patch continue() so that after compaction, when the rebuilt
-// context ends with an assistant message, the agent loop can still
-// continue. Without this patch, the session's continue() call throws
-// "Cannot continue from message role: assistant" and the agent loop
-// exits — leaving mid-task work unfinished.
-//
-// Note (pi 0.79+): Agent.continue() now drains queued steering/follow-up
-// messages before throwing, so this throw path only fires when there are
-// genuinely no queued messages — the prompt([]) fallback is still correct.
-//
-// The fix: when continue() would throw because the last message is an
-// assistant, fall back to prompt([]) instead. prompt([]) doesn't check
-// the last message role — it starts a fresh agent loop with the current
-// context. This is equivalent to the invisible-continue mechanism
-// (same call the extension fires from session_compact), but triggered
-// from the session's own continue() path so the while loop stays alive.
-//
-// Chains the previous patch (pi-retry, pi-invisible-continue) so all
-// mutexes are respected.
-const _prevContinue = Agent.prototype.continue;
-Agent.prototype.continue = function (this: Agent): Promise<void> {
-  const self = this;
-  return (async () => {
-    while (_continueInProgress) {
-      await new Promise(r => setTimeout(r, 10));
-    }
-    try {
-      return await (_prevContinue as any).call(self);
-    } catch (e: unknown) {
-      const msg = e instanceof Error ? e.message : String(e);
-
-      // After compaction, the rebuilt context often ends with an assistant
-      // message. The original continue() throws "Cannot continue from
-      // message role: assistant". Instead of swallowing the error and
-      // letting the agent loop die (which leaves mid-task work unfinished),
-      // fall back to prompt([]). This restarts the agent loop with the
-      // compacted context — the LLM picks up where it left off.
-      //
-      // prompt([]) is safe regardless of last message role. The agent
-      // processes the current context and continues.
-      //
-      // We only do this when the agent is NOT currently processing
-      // (no other triggerInvisibleContinue in flight) to avoid races.
-      if (msg.includes("Cannot continue from message role") ||
-          msg.includes("Cannot continue from an assistant message")) {
-        // Check stopReason of the last message — only continue if
-        // the agent was mid-task (not a clean stop or user abort).
-        const lastMsg = self.state.messages[self.state.messages.length - 1];
-        if (lastMsg?.role === "assistant" &&
-            lastMsg.stopReason !== "stop" &&
-            lastMsg.stopReason !== "aborted") {
-          // Agent was mid-task — fall through to prompt([])
-          // (after the error-handling block)
-        } else {
-          // Agent finished cleanly or was aborted — don't continue.
-          // The session loop should exit (task complete).
-          return;
-        }
-        // Fall back to prompt([]) to actually continue the agent.
-        // The while loop in _runAgentPrompt stays alive because prompt([])
-        // runs the agent (which emits events, updates _lastAssistantMessage,
-        // etc.).
-        //
-        // Guard: if triggerInvisibleContinue() just completed (within the
-        // last 500ms), the agent already continued — skip the fallback to
-        // avoid double continuation. This happens when both pi-retry and
-        // pi-vcc are installed: pi-retry's triggerInvisibleContinue runs
-        // first, then the session's continue() wrapper unblocks and would
-        // fall back to prompt([]) again.
-        if (!_continueInProgress && Date.now() - _lastInvisibleContinueTime > 500) {
-          _continueInProgress = true;
-          try {
-            await self.prompt([]);
-          } catch {
-            // Agent already processing or other transient error
-          } finally {
-            _continueInProgress = false;
-          }
-        }
-        return;
-      }
-
-      if (msg.includes("Agent is already processing")) {
-        // Another extension is driving the agent — wait it out.
-        return;
-      }
-      throw e;
-    }
-  })();
-};
-
-function sleep(ms: number): Promise<void> {
-  return new Promise(resolve => setTimeout(resolve, ms));
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+export const VCC_RESUME_CUSTOM_TYPE = "pi-vcc:resume-after-compaction";
+
+export function registerInvisibleContinue(pi: ExtensionAPI): void {
+  pi.on("context", (event) => {
+    const messages = event.messages.filter((message) => {
+      if (message.role !== "custom") return true;
+      return message.customType !== VCC_RESUME_CUSTOM_TYPE;
+    });
+    if (messages.length !== event.messages.length) return { messages };
+  });
 }
 
 /**
- * Fire an invisible continue after the agent becomes idle.
- *
- * MUST NOT be awaited — it schedules work that runs after the current
- * session loop iteration finishes.  Awaiting would deadlock inside the
- * session's _handlePostAgentRun → _runAutoCompaction call stack.
+ * Queue a hidden follow-up through AgentSession. This keeps Pi's session-level
+ * busy state, retry, compaction, and native steer/follow-up queues coherent.
  */
-export function triggerInvisibleContinue(): void {
-  if (!_agent) return;
-  if (_continueInProgress) return;
-  _continueInProgress = true;
-
-  const run = async () => {
-    try {
-      // Wait for the current run to finish (activeRun resolves in
-      // finishRun() after agent_end listeners return).
-      await _agent!.waitForIdle();
-
-      // Small delay to ensure the session's while-loop has exited
-      // after _handlePostAgentRun returns false.
-      await sleep(50);
-
-      try {
-        // Await so _continueInProgress stays true for the full cycle.
-        await _agent!.prompt([]);
-      } catch {
-        // Ignore — if prompt throws, something else is driving.
-      }
-    } finally {
-      _continueInProgress = false;
-      // Record completion time so the continue() monkey-patch can
-      // detect that an invisible continue just ran and avoid firing
-      // a duplicate prompt([]) (RC7: double continuation guard).
-      _lastInvisibleContinueTime = Date.now();
-    }
-  };
-
-  void run();
-}
-
-/** Reset state on new session. */
-export function resetInvisibleContinue(): void {
-  _continueInProgress = false;
-  _lastInvisibleContinueTime = 0;
+export function triggerInvisibleContinue(pi: ExtensionAPI): void {
+  pi.sendMessage(
+    {
+      customType: VCC_RESUME_CUSTOM_TYPE,
+      content: [],
+      display: false,
+      details: undefined,
+    },
+    {
+      triggerTurn: true,
+      deliverAs: "followUp",
+    },
+  );
 }

package/src/hooks/before-compact.ts

@@ -11,6 +11,7 @@ import {
 } from "../core/codex-output-limit";
 import { loadSettings, type PiVccSettings } from "../core/settings";
 import { triggerInvisibleContinue } from "../core/invisible-continue";
+import { isProactiveTriggerActive } from "./proactive-threshold";
 import { countPiVccCompactionsFromSession, ordinalSuffix } from "../core/compaction-count";
 import type { PiVccCompactionDetails } from "../details";
 
@@ -25,7 +26,10 @@ export interface CompactionStats {
 let lastStats: CompactionStats | null = null;
 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 => {
@@ -98,6 +102,19 @@ interface EntryWithMessage {
   message: { role: string; content: unknown };
 }
 
+const isHiddenEmptyCustomMessage = (message: unknown): boolean => {
+  if (!message || typeof message !== "object") return false;
+  const candidate = message as {
+    role?: unknown;
+    content?: unknown;
+    display?: unknown;
+  };
+  if (candidate.role !== "custom" || candidate.display !== false) return false;
+  return candidate.content === "" || (
+    Array.isArray(candidate.content) && candidate.content.length === 0
+  );
+};
+
 export type OwnCutCancelReason =
   | "no_live_messages"
   | "too_few_live_messages";
@@ -265,7 +282,11 @@ export function buildOwnCut(branchEntries: any[], options?: { maxKeptTokens?: nu
     for (let i = lastCompactionIdx + 1; i < branchEntries.length; i++) {
       const e = branchEntries[i];
       if (e.type === "compaction") continue;
-      if (e.type === "message" && e.message) {
+      if (
+        e.type === "message" &&
+        e.message &&
+        !isHiddenEmptyCustomMessage(e.message)
+      ) {
         liveMessages.push({ entry: e, message: e.message });
       }
     }
@@ -275,7 +296,11 @@ export function buildOwnCut(branchEntries: any[], options?: { maxKeptTokens?: nu
       if (!foundKept && e.id === lastKeptId) foundKept = true;
       if (!foundKept) continue;
       if (e.type === "compaction") continue;
-      if (e.type === "message" && e.message) {
+      if (
+        e.type === "message" &&
+        e.message &&
+        !isHiddenEmptyCustomMessage(e.message)
+      ) {
         liveMessages.push({ entry: e, message: e.message });
       }
     }
@@ -413,8 +438,32 @@ export const shouldResumeAfterCompaction = (
   return true;
 };
 
+export type CompactionCompletionMetadata = {
+  reason?: "manual" | "threshold" | "overflow";
+  willRetry?: boolean;
+};
+
+export function shouldTriggerResumeForCompaction(
+  event: CompactionCompletionMetadata,
+  sessionIsIdle: boolean,
+  wasProactiveCompaction: boolean,
+  wasCodexRecoveryCompaction: boolean,
+): boolean {
+  if (event.willRetry) return true;
+  if (wasCodexRecoveryCompaction || wasProactiveCompaction) return true;
+  if (event.reason === "manual" || event.reason === "overflow") return false;
+  if (event.reason === "threshold") return !sessionIsIdle;
+
+  // Pi before 0.79.10 did not expose compaction reason metadata. Be
+  // conservative there: an idle session may be manual or pre-prompt.
+  return !sessionIsIdle;
+}
+
 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();
 
@@ -451,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;
@@ -626,7 +701,9 @@ export const registerBeforeCompactHook = (pi: ExtensionAPI) => {
     lastCompactWasPiVcc = isPiVcc;
     lastCompactWasCodexRecovery =
       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
@@ -644,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
@@ -652,15 +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
@@ -708,11 +794,29 @@ export const registerBeforeCompactHook = (pi: ExtensionAPI) => {
           break;
         }
       }
-      if (!shouldResumeAfterCompaction(lastMsg, wasCodexRecoveryCompaction)) return;
-
-      // Agent was mid-task (toolUse or length). The Codex recovery marker
-      // additionally permits its known provider errors to continue.
-      triggerInvisibleContinue();
+      // A core-owned retry also gets a marker. Agent.continue() drains the
+      // queued marker before checking the assistant-tail role, so no Agent
+      // prototype fallback is needed.
+      const completion = event as CompactionCompletionMetadata;
+      const legacyActiveCompaction =
+        completion.reason === undefined &&
+        completion.willRetry === undefined &&
+        !ctx.isIdle();
+      if (
+        !completion.willRetry &&
+        !legacyActiveCompaction &&
+        !shouldResumeAfterCompaction(lastMsg, wasCodexRecoveryCompaction)
+      ) return;
+      if (!shouldTriggerResumeForCompaction(
+        completion,
+        ctx.isIdle(),
+        wasProactiveCompaction,
+        wasCodexRecoveryCompaction,
+      )) return;
+
+      // Queue through Pi's native follow-up path so a concurrent user prompt
+      // wins cleanly instead of racing a low-level Agent.prompt([]) call.
+      triggerInvisibleContinue(pi);
     } catch {
       // Non-critical — if context inspection fails, don't block compaction
     }