@monotykamary/pi-vcc 0.7.1 → 0.7.3

package/package.json

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

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

@@ -0,0 +1,56 @@
+export const CODEX_OUTPUT_LIMIT_COMPACT_INSTRUCTION = "__pi_vcc_codex_output_limit__";
+export const CODEX_CONTEXT_OVERFLOW_COMPACT_INSTRUCTION = "__pi_vcc_codex_context_overflow__";
+
+let codexContextOverflowPending = false;
+
+const codexErrorMessage = (message: unknown): string | undefined => {
+  if (!message || typeof message !== "object") return undefined;
+
+  const candidate = message as {
+    role?: unknown;
+    provider?: unknown;
+    api?: unknown;
+    stopReason?: unknown;
+    errorMessage?: unknown;
+  };
+
+  const isCodexMessage =
+    candidate.provider === "openai-codex" ||
+    candidate.api === "openai-codex-responses";
+
+  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/hooks/before-compact.ts

@@ -1,6 +1,14 @@
 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";
 import { triggerInvisibleContinue } from "../core/invisible-continue";
 import { countPiVccCompactionsFromSession, ordinalSuffix } from "../core/compaction-count";
@@ -16,6 +24,7 @@ export interface CompactionStats {
 
 let lastStats: CompactionStats | null = null;
 let lastCompactWasPiVcc = false;
+let lastCompactWasCodexRecovery = false;
 let lastCompactHandledByVcc = false;
 export const getLastCompactionStats = () => lastStats;
 
@@ -387,6 +396,23 @@ const REASON_MESSAGES: Record<OwnCutCancelReason, string> = {
   too_few_live_messages: "pi-vcc: Too few messages to compact",
 };
 
+export const shouldResumeAfterCompaction = (
+  lastMsg: unknown,
+  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 allowCodexRecovery && (
+      isCodexOutputLimitError(lastMsg) ||
+      isCodexContextOverflowError(lastMsg)
+    );
+  }
+  return true;
+};
+
 export const registerBeforeCompactHook = (pi: ExtensionAPI) => {
   pi.on("session_before_compact", (event, ctx) => {
     const { preparation, branchEntries, customInstructions } = event;
@@ -409,10 +435,26 @@ export const registerBeforeCompactHook = (pi: ExtensionAPI) => {
     // per-model threshold's perspective, but this is preferable to blocking
     // an explicit user action (/compact).
     const isPiVcc = customInstructions === PI_VCC_COMPACT_INSTRUCTION;
-
-    // Always handle explicit /pi-vcc marker.
-    // Otherwise, only handle when user opted in via settings.
-    if (!isPiVcc && !settings.overrideDefaultCompaction) return;
+    const isCodexOutputLimitCompaction =
+      customInstructions === CODEX_OUTPUT_LIMIT_COMPACT_INSTRUCTION;
+    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
@@ -582,6 +624,8 @@ export const registerBeforeCompactHook = (pi: ExtensionAPI) => {
     };
 
     lastCompactWasPiVcc = isPiVcc;
+    lastCompactWasCodexRecovery =
+      isCodexOutputLimitCompaction || isCodexContextOverflowCompaction;
     lastCompactHandledByVcc = true;
 
     // Signal to neuralwatt-mcr that pi-vcc is handling compaction
@@ -610,7 +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 wasCodexRecoveryCompaction = lastCompactWasCodexRecovery;
     lastCompactHandledByVcc = 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.
@@ -641,12 +687,14 @@ export const registerBeforeCompactHook = (pi: ExtensionAPI) => {
     // - Last message is user/toolResult (agent can continue naturally)
     // - 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 (pi-retry handles
-    //   retry via its agent_end handler — avoid duplicate triggerInvisibleContinue)
+    // - Last message is assistant with stopReason=error, unless this was
+    //   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 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 {
@@ -660,21 +708,10 @@ export const registerBeforeCompactHook = (pi: ExtensionAPI) => {
           break;
         }
       }
-      if (!lastMsg || lastMsg.role !== "assistant") return;
-
-      // Agent completed its turn cleanly — no continuation needed
-      if (lastMsg.stopReason === "stop") return;
-
-      // Agent was aborted by user — don't auto-continue
-      if (lastMsg.stopReason === "aborted") return;
-
-      // Agent hit an error — pi-retry handles this via its agent_end handler.
-      // If we also fire triggerInvisibleContinue, both extensions race
-      // to call prompt([]), causing "Agent is already processing" (wasteful)
-      // or a duplicate continuation. Let pi-retry own error retries.
-      if (lastMsg.stopReason === "error") return;
+      if (!shouldResumeAfterCompaction(lastMsg, wasCodexRecoveryCompaction)) return;
 
-      // Agent was mid-task (toolUse or length) — needs to continue.
+      // Agent was mid-task (toolUse or length). The Codex recovery marker
+      // 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,6 +1,21 @@
 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";
 
+type ProactiveContext = {
+  model?: any;
+  getContextUsage?: () => any;
+  compact?: (options?: any) => void;
+  ui?: any;
+};
+
 const formatTokens = (n: number): string => {
   if (n >= 1000) return `${(n / 1000).toFixed(1)}k`;
   return String(n);
@@ -29,6 +44,7 @@ export const isProactiveTriggerActive = () => proactiveTriggerActive;
 export const resetProactiveState = () => {
   lastCompactTime = 0;
   proactiveTriggerActive = false;
+  clearCodexContextOverflowPending();
 };
 
 /**
@@ -36,7 +52,7 @@ export const resetProactiveState = () => {
  * if so. Safe to call from multiple event handlers — cooldown prevents
  * double-triggering.
  */
-const checkAndTrigger = (ctx: { model?: any; getContextUsage?: () => any; compact?: () => void; ui?: any }, source: string) => {
+const checkAndTrigger = (ctx: ProactiveContext, source: string) => {
   const settings = loadSettings();
   const threshold = getModelThreshold(settings, ctx.model);
 
@@ -78,6 +94,54 @@ const checkAndTrigger = (ctx: { model?: any; getContextUsage?: () => any; compac
   ctx.compact?.();
 };
 
+/** Force compaction for Codex responses that report an output limit as an error. */
+const triggerCodexOutputLimitCompaction = (ctx: ProactiveContext) => {
+  if (isCoolingDown()) return;
+
+  try {
+    ctx?.ui?.notify?.(
+      "pi-vcc: Codex reached its maximum output token limit. Compacting...",
+      "info",
+    );
+  } catch {}
+
+  setCooldown();
+  proactiveTriggerActive = true;
+  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;
+
+  for (let i = messages.length - 1; i >= 0; i--) {
+    if (messages[i]?.role === "assistant") return messages[i];
+  }
+  return undefined;
+};
+
 /**
  * Registers proactive configured compaction thresholds.
  *
@@ -105,8 +169,28 @@ const checkAndTrigger = (ctx: { model?: any; getContextUsage?: () => any; compac
  * "Compacting..." then "Skipped compaction" notifications.
  */
 export const registerProactiveThresholdHook = (pi: ExtensionAPI) => {
-  // Proactive compaction after each agent run
-  pi.on("agent_end", (_event, ctx) => {
+  // 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) => {
+    const lastMessage = lastAssistantMessage(event);
+    if (isCodexOutputLimitError(lastMessage)) {
+      triggerCodexOutputLimitCompaction(ctx);
+      return;
+    }
+    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)) {
+        triggerCodexContextOverflowCompaction(ctx);
+      }
+      return;
+    }
     checkAndTrigger(ctx, "auto");
   });
 
@@ -119,11 +203,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();
   });
 };