@monotykamary/pi-vcc 0.7.3 → 0.7.4

package/package.json

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

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/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;