@monotykamary/pi-vcc 0.7.3 → 0.7.5

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@monotykamary/pi-vcc",
-  "version": "0.7.3",
+  "version": "0.7.5",
   "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/core/settings.ts

@@ -1,6 +1,6 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { dirname, join } from "path";
-import { getAgentDir } from "@earendil-works/pi-coding-agent";
+import { CONFIG_DIR_NAME, getAgentDir } from "@earendil-works/pi-coding-agent";
 
 const settingsPath = (): string =>
   process.env.PI_VCC_CONFIG_PATH ?? join(getAgentDir(), "pi-vcc-config.json");
@@ -181,6 +181,32 @@ const readJson = (path: string): Record<string, unknown> | null => {
   }
 };
 
+const readPiCoreCompactionEnabled = (path: string): boolean | undefined => {
+  const parsed = readJson(path);
+  if (!parsed) return undefined;
+  const enabled = (parsed as { compaction?: { enabled?: unknown } }).compaction?.enabled;
+  return typeof enabled === "boolean" ? enabled : undefined;
+};
+
+/**
+ * Read pi-core's effective `compaction.enabled` setting.
+ *
+ * pi-core's `_checkCompaction` bails immediately when this is false, so neither
+ * overflow nor threshold auto-compaction fires. When that happens pi-vcc must
+ * drive compaction itself via `ctx.compact()` (the manual path skips the
+ * `enabled` gate). Mirrors pi-core's merge: project (`<cwd>/<CONFIG_DIR_NAME>/
+ * settings.json`) overrides global (`<agentDir>/settings.json`); defaults true.
+ */
+export function isPiCoreCompactionEnabled(projectCwd?: string): boolean {
+  const globalEnabled = readPiCoreCompactionEnabled(join(getAgentDir(), "settings.json"));
+  if (projectCwd) {
+    const projectEnabled = readPiCoreCompactionEnabled(join(projectCwd, CONFIG_DIR_NAME, "settings.json"));
+    if (typeof projectEnabled === "boolean") return projectEnabled;
+  }
+  if (typeof globalEnabled === "boolean") return globalEnabled;
+  return true;
+}
+
 export function loadSettings(): PiVccSettings {
   const parsed = readJson(settingsPath());
   if (!parsed || typeof parsed !== "object") return { ...DEFAULT_SETTINGS };

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,6 +26,7 @@ export interface CompactionStats {
 let lastStats: CompactionStats | null = null;
 let lastCompactWasPiVcc = false;
 let lastCompactWasCodexRecovery = false;
+let lastCompactWasProactive = false;
 let lastCompactHandledByVcc = false;
 export const getLastCompactionStats = () => lastStats;
 
@@ -98,6 +100,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 +280,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 +294,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,6 +436,27 @@ 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) => {
     const { preparation, branchEntries, customInstructions } = event;
@@ -626,6 +670,7 @@ export const registerBeforeCompactHook = (pi: ExtensionAPI) => {
     lastCompactWasPiVcc = isPiVcc;
     lastCompactWasCodexRecovery =
       isCodexOutputLimitCompaction || isCodexContextOverflowCompaction;
+    lastCompactWasProactive = isProactiveTriggerActive();
     lastCompactHandledByVcc = true;
 
     // Signal to neuralwatt-mcr that pi-vcc is handling compaction
@@ -655,8 +700,10 @@ export const registerBeforeCompactHook = (pi: ExtensionAPI) => {
     // Only act when pi-vcc drove the compaction
     if (!lastCompactHandledByVcc) return;
     const wasCodexRecoveryCompaction = lastCompactWasCodexRecovery;
+    const wasProactiveCompaction = lastCompactWasProactive;
     lastCompactHandledByVcc = false;
     lastCompactWasCodexRecovery = false;
+    lastCompactWasProactive = 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.
@@ -708,11 +755,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
     }

package/src/hooks/proactive-threshold.ts

@@ -7,13 +7,14 @@ import {
   isCodexOutputLimitError,
   markCodexContextOverflowPending,
 } from "../core/codex-output-limit";
-import { loadSettings, getModelThreshold, resolveTriggerTokens } from "../core/settings";
+import { loadSettings, getModelThreshold, isPiCoreCompactionEnabled, resolveTriggerTokens } from "../core/settings";
 
 type ProactiveContext = {
   model?: any;
   getContextUsage?: () => any;
   compact?: (options?: any) => void;
   ui?: any;
+  sessionManager?: { getCwd?: () => string };
 };
 
 const formatTokens = (n: number): string => {
@@ -182,11 +183,17 @@ export const registerProactiveThresholdHook = (pi: ExtensionAPI) => {
     }
     if (isCodexContextOverflowError(lastMessage)) {
       markCodexContextOverflowPending();
-      // pi-core's overflow check also requires the assistant message to carry
-      // the current model identity. Codex can omit it on failed responses;
-      // force the recovery only for that case so matching responses continue
-      // through pi-core's normal auto-retry path.
-      if (!hasCurrentModelIdentity(lastMessage, ctx.model)) {
+      // pi-core's overflow compaction only fires when compaction is enabled AND
+      // the assistant message carries the current model identity. If either
+      // is missing pi-core bails (or its LLM compaction would re-overflow), so
+      // pi-vcc must drive the recovery compaction itself via ctx.compact(),
+      // whose manual path skips the `enabled` gate and uses pi-vcc's static
+      // summary. When pi-core will handle it, defer to avoid a racing second
+      // compaction that would abort pi-core's own retry.
+      const piCoreWillHandle =
+        hasCurrentModelIdentity(lastMessage, ctx.model) &&
+        isPiCoreCompactionEnabled(ctx.sessionManager?.getCwd?.());
+      if (!piCoreWillHandle) {
         triggerCodexContextOverflowCompaction(ctx);
       }
       return;