@monotykamary/pi-vcc 0.7.2 → 0.7.4

package/package.json

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

package/src/core/codex-output-limit.ts

@@ -1,8 +1,10 @@
 export const CODEX_OUTPUT_LIMIT_COMPACT_INSTRUCTION = "__pi_vcc_codex_output_limit__";
+export const CODEX_CONTEXT_OVERFLOW_COMPACT_INSTRUCTION = "__pi_vcc_codex_context_overflow__";
 
-/** Identify the Codex provider error used when a response reaches its output cap. */
-export const isCodexOutputLimitError = (message: unknown): boolean => {
-  if (!message || typeof message !== "object") return false;
+let codexContextOverflowPending = false;
+
+const codexErrorMessage = (message: unknown): string | undefined => {
+  if (!message || typeof message !== "object") return undefined;
 
   const candidate = message as {
     role?: unknown;
@@ -16,11 +18,39 @@ export const isCodexOutputLimitError = (message: unknown): boolean => {
     candidate.provider === "openai-codex" ||
     candidate.api === "openai-codex-responses";
 
-  return (
-    candidate.role === "assistant" &&
-    isCodexMessage &&
-    candidate.stopReason === "error" &&
-    typeof candidate.errorMessage === "string" &&
-    /maximum output token limit/i.test(candidate.errorMessage)
-  );
+  if (
+    candidate.role !== "assistant" ||
+    !isCodexMessage ||
+    candidate.stopReason !== "error" ||
+    typeof candidate.errorMessage !== "string"
+  ) {
+    return undefined;
+  }
+
+  return candidate.errorMessage;
+};
+
+/** Identify the Codex provider error used when a response reaches its output cap. */
+export const isCodexOutputLimitError = (message: unknown): boolean => {
+  const errorMessage = codexErrorMessage(message);
+  return errorMessage !== undefined && /maximum output token limit/i.test(errorMessage);
+};
+
+/** Identify the Codex provider error used when the request input is too large. */
+export const isCodexContextOverflowError = (message: unknown): boolean => {
+  const errorMessage = codexErrorMessage(message);
+  return errorMessage !== undefined && /exceeds the context window/i.test(errorMessage);
+};
+
+/** Mark a Codex context overflow until pi-core begins its recovery compaction. */
+export const markCodexContextOverflowPending = (): void => {
+  codexContextOverflowPending = true;
+};
+
+/** Check whether the pending Codex overflow belongs to the next compaction. */
+export const isCodexContextOverflowPending = (): boolean => codexContextOverflowPending;
+
+/** Clear pending Codex overflow state after compaction or session reset. */
+export const clearCodexContextOverflowPending = (): void => {
+  codexContextOverflowPending = false;
 };

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

@@ -2,7 +2,11 @@ import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { writeFileSync } from "fs";
 import { compile, type CompileInput } from "../core/summarize";
 import {
+  CODEX_CONTEXT_OVERFLOW_COMPACT_INSTRUCTION,
   CODEX_OUTPUT_LIMIT_COMPACT_INSTRUCTION,
+  clearCodexContextOverflowPending,
+  isCodexContextOverflowError,
+  isCodexContextOverflowPending,
   isCodexOutputLimitError,
 } from "../core/codex-output-limit";
 import { loadSettings, type PiVccSettings } from "../core/settings";
@@ -20,7 +24,7 @@ export interface CompactionStats {
 
 let lastStats: CompactionStats | null = null;
 let lastCompactWasPiVcc = false;
-let lastCompactWasCodexOutputLimit = false;
+let lastCompactWasCodexRecovery = false;
 let lastCompactHandledByVcc = false;
 export const getLastCompactionStats = () => lastStats;
 
@@ -394,14 +398,17 @@ const REASON_MESSAGES: Record<OwnCutCancelReason, string> = {
 
 export const shouldResumeAfterCompaction = (
   lastMsg: unknown,
-  allowCodexOutputLimit = false,
+  allowCodexRecovery = false,
 ): boolean => {
   if (!lastMsg || typeof lastMsg !== "object") return false;
   const message = lastMsg as { role?: unknown; stopReason?: unknown };
   if (message.role !== "assistant") return false;
   if (message.stopReason === "stop" || message.stopReason === "aborted") return false;
   if (message.stopReason === "error") {
-    return allowCodexOutputLimit && isCodexOutputLimitError(lastMsg);
+    return allowCodexRecovery && (
+      isCodexOutputLimitError(lastMsg) ||
+      isCodexContextOverflowError(lastMsg)
+    );
   }
   return true;
 };
@@ -430,11 +437,24 @@ export const registerBeforeCompactHook = (pi: ExtensionAPI) => {
     const isPiVcc = customInstructions === PI_VCC_COMPACT_INSTRUCTION;
     const isCodexOutputLimitCompaction =
       customInstructions === CODEX_OUTPUT_LIMIT_COMPACT_INSTRUCTION;
-    const isPiVccHandled = isPiVcc || isCodexOutputLimitCompaction;
-
-    // Always handle explicit /pi-vcc and Codex output-limit markers.
-    // Otherwise, only handle when user opted in via settings.
+    const isCodexContextOverflowMarker =
+      customInstructions === CODEX_CONTEXT_OVERFLOW_COMPACT_INSTRUCTION;
+    const lastBranchAssistant = [...(branchEntries as any[])]
+      .reverse()
+      .find((entry: any) => entry.type === "message" && entry.message?.role === "assistant")
+      ?.message;
+    const isCodexContextOverflowCompaction =
+      isCodexContextOverflowMarker ||
+      (settings.overrideDefaultCompaction &&
+        isCodexContextOverflowPending() &&
+        isCodexContextOverflowError(lastBranchAssistant));
+    const isPiVccHandled =
+      isPiVcc || isCodexOutputLimitCompaction || isCodexContextOverflowCompaction;
+
+    // Always handle explicit /pi-vcc and Codex recovery markers. Otherwise,
+    // only handle when the user opted in via settings.
     if (!isPiVccHandled && !settings.overrideDefaultCompaction) return;
+    if (isCodexContextOverflowCompaction) clearCodexContextOverflowPending();
 
     // Budget the kept tail so that summary + kept + system/tools + the model's
     // OUTPUT budget (maxTokens) all fit in the window. Without reserving
@@ -604,7 +624,8 @@ export const registerBeforeCompactHook = (pi: ExtensionAPI) => {
     };
 
     lastCompactWasPiVcc = isPiVcc;
-    lastCompactWasCodexOutputLimit = isCodexOutputLimitCompaction;
+    lastCompactWasCodexRecovery =
+      isCodexOutputLimitCompaction || isCodexContextOverflowCompaction;
     lastCompactHandledByVcc = true;
 
     // Signal to neuralwatt-mcr that pi-vcc is handling compaction
@@ -633,9 +654,9 @@ export const registerBeforeCompactHook = (pi: ExtensionAPI) => {
   pi.on("session_compact", (event, ctx) => {
     // Only act when pi-vcc drove the compaction
     if (!lastCompactHandledByVcc) return;
-    const wasCodexOutputLimitCompaction = lastCompactWasCodexOutputLimit;
+    const wasCodexRecoveryCompaction = lastCompactWasCodexRecovery;
     lastCompactHandledByVcc = false;
-    lastCompactWasCodexOutputLimit = false;
+    lastCompactWasCodexRecovery = 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.
@@ -667,13 +688,13 @@ export const registerBeforeCompactHook = (pi: ExtensionAPI) => {
     // - Last message is assistant with stopReason=stop (task finished)
     // - Last message is assistant with stopReason=aborted (user cancelled)
     // - Last message is assistant with stopReason=error, unless this was
-    //   the pi-vcc Codex maximum-output recovery compaction
+    //   a pi-vcc Codex recovery compaction
     //
     // We DO continue when:
     // - Last message is assistant with stopReason=toolUse (mid-tool cycle)
     // - Last message is assistant with stopReason=length (hit max tokens)
-    // - Last message is the known Codex maximum-output error from the
-    //   pi-vcc recovery compaction
+    // - Last message is a known Codex recovery error from the pi-vcc
+    //   recovery compaction
     // - Compact-all (firstKeptEntryId="") — context is just the summary,
     //   the agent needs to re-enter the loop to continue the task
     try {
@@ -687,10 +708,10 @@ export const registerBeforeCompactHook = (pi: ExtensionAPI) => {
           break;
         }
       }
-      if (!shouldResumeAfterCompaction(lastMsg, wasCodexOutputLimitCompaction)) return;
+      if (!shouldResumeAfterCompaction(lastMsg, wasCodexRecoveryCompaction)) return;
 
       // Agent was mid-task (toolUse or length). The Codex recovery marker
-      // additionally permits its maximum-output error to continue.
+      // additionally permits its known provider errors to continue.
       triggerInvisibleContinue();
     } catch {
       // Non-critical — if context inspection fails, don't block compaction

package/src/hooks/proactive-threshold.ts

@@ -1,15 +1,20 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import {
+  CODEX_CONTEXT_OVERFLOW_COMPACT_INSTRUCTION,
   CODEX_OUTPUT_LIMIT_COMPACT_INSTRUCTION,
+  clearCodexContextOverflowPending,
+  isCodexContextOverflowError,
   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 => {
@@ -40,6 +45,7 @@ export const isProactiveTriggerActive = () => proactiveTriggerActive;
 export const resetProactiveState = () => {
   lastCompactTime = 0;
   proactiveTriggerActive = false;
+  clearCodexContextOverflowPending();
 };
 
 /**
@@ -105,6 +111,28 @@ const triggerCodexOutputLimitCompaction = (ctx: ProactiveContext) => {
   ctx.compact?.({ customInstructions: CODEX_OUTPUT_LIMIT_COMPACT_INSTRUCTION });
 };
 
+/** Force compaction when Codex omits the model identity from an overflow error. */
+const triggerCodexContextOverflowCompaction = (ctx: ProactiveContext) => {
+  if (isCoolingDown()) return;
+
+  try {
+    ctx?.ui?.notify?.(
+      "pi-vcc: Codex input exceeded the context window. Compacting...",
+      "info",
+    );
+  } catch {}
+
+  setCooldown();
+  proactiveTriggerActive = true;
+  ctx.compact?.({ customInstructions: CODEX_CONTEXT_OVERFLOW_COMPACT_INSTRUCTION });
+};
+
+const hasCurrentModelIdentity = (message: unknown, model: any): boolean => {
+  if (!message || typeof message !== "object" || !model) return false;
+  const candidate = message as { model?: unknown; provider?: unknown };
+  return candidate.model === model.id && candidate.provider === model.provider;
+};
+
 const lastAssistantMessage = (event: unknown): unknown => {
   const messages = (event as any)?.messages;
   if (!Array.isArray(messages)) return undefined;
@@ -142,14 +170,34 @@ const lastAssistantMessage = (event: unknown): unknown => {
  * "Compacting..." then "Skipped compaction" notifications.
  */
 export const registerProactiveThresholdHook = (pi: ExtensionAPI) => {
-  // Codex reports some output-limit responses as errors instead of the
-  // standard "length" stop reason. The error has no usable context usage,
-  // so pi-core cannot discover the need to compact from its normal checks.
+  // Codex reports output-limit responses as errors instead of the standard
+  // "length" stop reason. Those errors have no usable context usage, so
+  // pi-core cannot discover the need to compact from its normal checks.
+  // Context-window errors are tracked separately because pi-core already
+  // recognizes and compacts those.
   pi.on("agent_end", (event, ctx) => {
-    if (isCodexOutputLimitError(lastAssistantMessage(event))) {
+    const lastMessage = lastAssistantMessage(event);
+    if (isCodexOutputLimitError(lastMessage)) {
       triggerCodexOutputLimitCompaction(ctx);
       return;
     }
+    if (isCodexContextOverflowError(lastMessage)) {
+      markCodexContextOverflowPending();
+      // 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;
+    }
     checkAndTrigger(ctx, "auto");
   });
 
@@ -162,11 +210,13 @@ export const registerProactiveThresholdHook = (pi: ExtensionAPI) => {
   pi.on("session_compact", () => {
     setCooldown();
     proactiveTriggerActive = false;
+    clearCodexContextOverflowPending();
   });
 
   // Reset state on session start so state doesn't leak between sessions
   pi.on("session_start", () => {
     lastCompactTime = 0;
     proactiveTriggerActive = false;
+    clearCodexContextOverflowPending();
   });
 };