@monotykamary/pi-vcc 0.7.0 → 0.7.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@monotykamary/pi-vcc",
-  "version": "0.7.0",
+  "version": "0.7.2",
   "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,26 @@
+export const CODEX_OUTPUT_LIMIT_COMPACT_INSTRUCTION = "__pi_vcc_codex_output_limit__";
+
+/** 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;
+
+  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";
+
+  return (
+    candidate.role === "assistant" &&
+    isCodexMessage &&
+    candidate.stopReason === "error" &&
+    typeof candidate.errorMessage === "string" &&
+    /maximum output token limit/i.test(candidate.errorMessage)
+  );
+};

package/src/hooks/before-compact.ts

@@ -1,6 +1,10 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { writeFileSync } from "fs";
 import { compile, type CompileInput } from "../core/summarize";
+import {
+  CODEX_OUTPUT_LIMIT_COMPACT_INSTRUCTION,
+  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 +20,7 @@ export interface CompactionStats {
 
 let lastStats: CompactionStats | null = null;
 let lastCompactWasPiVcc = false;
+let lastCompactWasCodexOutputLimit = false;
 let lastCompactHandledByVcc = false;
 export const getLastCompactionStats = () => lastStats;
 
@@ -150,7 +155,88 @@ const findMidCycleBoundary = (liveMessages: EntryWithMessage[]): number => {
   return best;
 };
 
-export function buildOwnCut(branchEntries: any[]): OwnCutResult {
+/** Rough token estimate (chars/4) for a live message, consistent with the
+ * kept-tokens estimate used elsewhere in this module. */
+function estimateMessageTokens(message: { content: unknown }): number {
+  const c = message.content;
+  let chars = 0;
+  if (typeof c === "string") {
+    chars = c.length;
+  } else if (Array.isArray(c)) {
+    for (const part of c as any[]) {
+      if (part.text) chars += part.text.length;
+      else if (part.type === "toolCall") {
+        const args = part.arguments ?? part.input;
+        chars += (part.name?.length ?? 0) + (typeof args === "string" ? args.length : JSON.stringify(args ?? "").length);
+      } else if (part.type === "toolResult") {
+        chars += typeof part.content === "string" ? part.content.length : JSON.stringify(part.content ?? "").length;
+      } else if (part.type === "thinking") {
+        chars += (part.thinking?.length ?? 0);
+      }
+    }
+  }
+  return Math.ceil(chars / 4);
+}
+
+/** Find a completed tool-cycle boundary within `suffix` such that the kept
+ * tail (suffix[boundary+1 .. end]) fits within `budgetTokens`, keeping as
+ * much recent context as possible. Returns the index of the first message to
+ * KEEP, or -1 when the suffix can't be split to fit (single oversized cycle,
+ * or no completed cycles). */
+const findSuffixSplitPoint = (
+  suffix: EntryWithMessage[],
+  budgetTokens: number,
+): number => {
+  if (suffix.length <= 2) return -1;
+
+  // Completed-cycle end-indices (toolResult closing a cycle). Same detection
+  // as findMidCycleBoundary.
+  const cycleEnds: number[] = [];
+  let currentAssistantIdx = -1;
+  const pendingCalls = new Set<string>();
+  for (let i = 0; i < suffix.length; i++) {
+    const msg = suffix[i].message;
+    if (msg.role === "user") { currentAssistantIdx = -1; pendingCalls.clear(); continue; }
+    if (msg.role === "assistant") {
+      currentAssistantIdx = i;
+      pendingCalls.clear();
+      const content = msg.content;
+      if (Array.isArray(content)) {
+        for (const part of content) {
+          if (part.type === "toolCall" && part.id) pendingCalls.add(part.id);
+        }
+      }
+      continue;
+    }
+    if (msg.role === "toolResult") {
+      const callId = (msg as any).toolCallId as string | undefined;
+      if (callId) pendingCalls.delete(callId);
+      if (pendingCalls.size === 0 && currentAssistantIdx >= 0) {
+        cycleEnds.push(i);
+        currentAssistantIdx = -1;
+      }
+    }
+  }
+  if (cycleEnds.length === 0) return -1;
+
+  // tailTokens[i] = tokens of suffix[i .. end].
+  const tailTokens: number[] = new Array(suffix.length + 1).fill(0);
+  for (let i = suffix.length - 1; i >= 0; i--) {
+    tailTokens[i] = tailTokens[i + 1] + estimateMessageTokens(suffix[i].message);
+  }
+  // Earliest cycle boundary whose kept tail fits — keeps the most recent
+  // context while staying under budget. boundary+1 must be < length so the
+  // kept tail is non-empty.
+  for (const boundary of cycleEnds) {
+    if (boundary + 1 < suffix.length && tailTokens[boundary + 1] <= budgetTokens) {
+      return boundary + 1;
+    }
+  }
+  return -1;
+};
+
+export function buildOwnCut(branchEntries: any[], options?: { maxKeptTokens?: number }): OwnCutResult {
+  const maxKeptTokens = options?.maxKeptTokens ?? 0;
   // Find the last compaction entry and its firstKeptEntryId
   let lastCompactionIdx = -1;
   let lastKeptId: string | undefined;
@@ -235,6 +321,38 @@ export function buildOwnCut(branchEntries: any[]): OwnCutResult {
     }
   }
 
+  // Oversized-turn guard (opt-in via options.maxKeptTokens > 0). When the
+  // kept suffix — the most recent turn from the last user message — exceeds
+  // the budget, keeping it whole would re-overflow on the compaction retry.
+  // Split the turn at a completed tool-cycle boundary so the oversized early
+  // part (typically a giant tool result) is summarized and only recent cycles
+  // that fit are kept. If a single cycle is itself oversized (or there are no
+  // completed cycles to split at), fall back to compact-all — safe because
+  // pi-vcc compiles summaries statically (no LLM call that could overflow).
+  if (cutIdx > 0 && maxKeptTokens > 0) {
+    const suffix = liveMessages.slice(cutIdx);
+    let suffixTokens = 0;
+    for (const e of suffix) suffixTokens += estimateMessageTokens(e.message);
+    if (suffixTokens > maxKeptTokens) {
+      const splitIdx = findSuffixSplitPoint(suffix, maxKeptTokens);
+      if (splitIdx >= 0) {
+        const globalIdx = cutIdx + splitIdx;
+        return {
+          ok: true,
+          messages: liveMessages.slice(0, globalIdx).map((e) => e.message),
+          firstKeptEntryId: liveMessages[globalIdx].entry.id,
+          compactAll: false,
+        };
+      }
+      return {
+        ok: true,
+        messages: liveMessages.map((e) => e.message),
+        firstKeptEntryId: "",
+        compactAll: true,
+      };
+    }
+  }
+
   if (cutIdx <= 0) {
     // Single user prompt (or no user at all) with a long agentic chain.
     // Instead of compact-all (which destroys the tail), find a completed
@@ -274,6 +392,20 @@ const REASON_MESSAGES: Record<OwnCutCancelReason, string> = {
   too_few_live_messages: "pi-vcc: Too few messages to compact",
 };
 
+export const shouldResumeAfterCompaction = (
+  lastMsg: unknown,
+  allowCodexOutputLimit = 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 true;
+};
+
 export const registerBeforeCompactHook = (pi: ExtensionAPI) => {
   pi.on("session_before_compact", (event, ctx) => {
     const { preparation, branchEntries, customInstructions } = event;
@@ -296,12 +428,28 @@ 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;
+    const isCodexOutputLimitCompaction =
+      customInstructions === CODEX_OUTPUT_LIMIT_COMPACT_INSTRUCTION;
+    const isPiVccHandled = isPiVcc || isCodexOutputLimitCompaction;
 
-    // Always handle explicit /pi-vcc marker.
+    // Always handle explicit /pi-vcc and Codex output-limit markers.
     // Otherwise, only handle when user opted in via settings.
-    if (!isPiVcc && !settings.overrideDefaultCompaction) return;
-
-    const ownCut = buildOwnCut(branchEntries as any[]);
+    if (!isPiVccHandled && !settings.overrideDefaultCompaction) return;
+
+    // Budget the kept tail so that summary + kept + system/tools + the model's
+    // OUTPUT budget (maxTokens) all fit in the window. Without reserving
+    // maxTokens, the compaction-retry request can be rejected upfront
+    // (input + maxTokens > contextWindow) and re-overflow. Falls back to
+    // pi-core's keepRecentTokens when the window is unknown.
+    const contextWindow = (ctx as any)?.model?.contextWindow ?? 0;
+    const maxTokens = (ctx as any)?.model?.maxTokens ?? 0;
+    const keepRecentTokens = (preparation as any)?.settings?.keepRecentTokens ?? 20000;
+    const overhead = contextWindow > 0 ? Math.min(32768, Math.floor(contextWindow * 0.2)) : 32768;
+    const outputReserve = maxTokens > 0 ? maxTokens : Math.floor(contextWindow * 0.5);
+    const maxKeptTokens = contextWindow > 0
+      ? Math.max(2048, contextWindow - outputReserve - overhead)
+      : keepRecentTokens;
+    const ownCut = buildOwnCut(branchEntries as any[], { maxKeptTokens });
     if (!ownCut.ok) {
       const lastComp = [...branchEntries].reverse().find((e: any) => e.type === "compaction");
       const lastCompIdx = lastComp ? (branchEntries as any[]).indexOf(lastComp) : -1;
@@ -456,6 +604,7 @@ export const registerBeforeCompactHook = (pi: ExtensionAPI) => {
     };
 
     lastCompactWasPiVcc = isPiVcc;
+    lastCompactWasCodexOutputLimit = isCodexOutputLimitCompaction;
     lastCompactHandledByVcc = true;
 
     // Signal to neuralwatt-mcr that pi-vcc is handling compaction
@@ -484,7 +633,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;
     lastCompactHandledByVcc = false;
+    lastCompactWasCodexOutputLimit = 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.
@@ -515,12 +666,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
+    //   the pi-vcc Codex maximum-output 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
     // - Compact-all (firstKeptEntryId="") — context is just the summary,
     //   the agent needs to re-enter the loop to continue the task
     try {
@@ -534,21 +687,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, wasCodexOutputLimitCompaction)) 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 maximum-output error to continue.
       triggerInvisibleContinue();
     } catch {
       // Non-critical — if context inspection fails, don't block compaction

package/src/hooks/proactive-threshold.ts

@@ -1,6 +1,17 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import {
+  CODEX_OUTPUT_LIMIT_COMPACT_INSTRUCTION,
+  isCodexOutputLimitError,
+} 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);
@@ -36,7 +47,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 +89,32 @@ 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 });
+};
+
+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 +142,14 @@ 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 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.
+  pi.on("agent_end", (event, ctx) => {
+    if (isCodexOutputLimitError(lastAssistantMessage(event))) {
+      triggerCodexOutputLimitCompaction(ctx);
+      return;
+    }
     checkAndTrigger(ctx, "auto");
   });