omp-vcc 0.1.12 → 0.1.13

package/extensions/main.ts

@@ -21,6 +21,7 @@ import {
   registerVccStatsCommand as registerVccStatsCommandHook,
   registerVccConfigCommand as registerVccConfigCommandHook,
   invalidExpandIndices,
+  getCompactForm,
 } from "./vcc-core/hook";
 import { searchEntriesDetailed, getTouchedFiles } from "./vcc-core/core/search-entries";
 import { formatRecallOutput, formatTouchedOutput } from "./vcc-core/core/format-recall";
@@ -180,43 +181,91 @@ export default function (pi: ExtensionAPI): void {
   // ── vcc_stats tool — stats surface for savings (paper § verification) ──
   registerVccStatsToolHook(pi);
 
-  pi.registerCommand("omp-vcc", {
-    description: "Compact conversation with omp-vcc structured summary (keep:N + optional focus)",
-    handler: async (args: string, ctx: unknown) => {
-      const c = ctx as {
-        compact: (instructions?: string) => Promise<void>;
-        ui: { notify: (msg: string, level?: string) => void };
-        sessionManager?: { getSessionFile?: () => string | undefined };
-      };
-      const parsed = parseKeepAndPrompt(args);
-      const keep = parsed.keepUserTurns;
-      const followUpPrompt = parsed.followUpPrompt;
-      const customInstructions = buildOmpCustomInstructions(keep);
+  // Shared /omp-vcc + /pi-vcc runner. The two hosts expose incompatible
+  // ctx.compact shapes, so the call form branches per live ctx:
+  // - omp: compact(string | CompactOptions) => Promise<void>; instructions
+  //   ride the string (the host splits string|object and drops instructions
+  //   from the object form), completion = awaited resolution, errors throw
+  //   ("Compaction cancelled" / "Already compacted" / "Nothing to compact…").
+  // - pi: compact(CompactOptions) => void; instructions ONLY via
+  //   options.customInstructions (a bare string reads as undefined), outcome
+  //   arrives via onComplete/onError. `settled` keeps one outcome.
+  // Form detection is layered (explicit test override → getSystemPrompt
+  // shape → module scope → legacy omp default) so bundled runtimes without
+  // module scope still decide correctly off the live ctx.
+  const runCompactCommand = async (
+    args: string,
+    c: {
+      compact: (arg?: unknown) => Promise<void> | void;
+      ui: { notify: (msg: string, level?: string) => void };
+    },
+    buildInstructions: (keep: number | null) => string,
+    fallbackToast: string,
+    preNotify: boolean,
+    compactForm: "object" | "string",
+  ): Promise<void> => {
+    const parsed = parseKeepAndPrompt(args);
+    const keep = parsed.keepUserTurns;
+    const followUpPrompt = parsed.followUpPrompt;
+    const customInstructions = buildInstructions(keep);
+    if (preNotify) {
       try {
         c.ui.notify(`omp-vcc: compacting with keep:${keep ?? 1}${followUpPrompt ? ` + focus` : ""}...`, "info");
       } catch {}
+    }
+    let settled = false;
+    const finishOk = (): void => {
+      if (settled) return;
+      settled = true;
+      const stats = getLastCompactionStats(pi);
+      if (stats) {
+        scheduleCompactionStatsNotify(c as unknown as { ui: { notify: (msg: string, level?: string) => void } }, stats);
+      } else {
+        try { c.ui.notify(fallbackToast, "info"); } catch {}
+      }
+      if (followUpPrompt) {
+        try {
+          const piAny = pi as unknown as { sendUserMessage?: (content: string) => unknown };
+          const sent = piAny.sendUserMessage?.(followUpPrompt) as Promise<void> | undefined;
+          if (sent && typeof sent.catch === "function") sent.catch(() => {});
+        } catch {}
+      }
+    };
+    const finishErr = (err: unknown): void => {
+      if (settled) return;
+      settled = true;
+      const msg = err instanceof Error ? err.message : String(err);
+      if (msg === "Compaction cancelled" || msg === "Already compacted" || msg.startsWith("Nothing to compact")) {
+        try { c.ui.notify("Nothing to compact", "warning"); } catch {}
+      } else {
+        try { c.ui.notify(`Compaction failed: ${msg}`, "error"); } catch {}
+      }
+    };
+    if (compactForm === "object") {
       try {
-        await c.compact(customInstructions);
-        const stats = getLastCompactionStats(pi);
-        if (stats) {
-          scheduleCompactionStatsNotify(c as unknown as { ui: { notify: (msg: string, level?: string) => void } }, stats);
-        } else {
-          try { c.ui.notify("Compacted with omp-vcc", "info"); } catch {}
-        }
-        if (followUpPrompt) {
-          try {
-            const piAny = pi as unknown as { sendUserMessage?: (content: string) => Promise<void> | void };
-            if (piAny.sendUserMessage) await piAny.sendUserMessage(followUpPrompt);
-          } catch {}
-        }
+        c.compact({ customInstructions, onComplete: finishOk, onError: finishErr });
       } catch (err: unknown) {
-        const msg = err instanceof Error ? err.message : String(err);
-        if (msg === "Compaction cancelled" || msg === "Already compacted") {
-          try { c.ui.notify("Nothing to compact", "warning"); } catch {}
-        } else {
-          try { c.ui.notify(`Compaction failed: ${msg}`, "error"); } catch {}
-        }
+        finishErr(err);
       }
+      return;
+    }
+    try {
+      await c.compact(customInstructions);
+      finishOk();
+    } catch (err: unknown) {
+      finishErr(err);
+    }
+  };
+
+  pi.registerCommand("omp-vcc", {
+    description: "Compact conversation with omp-vcc structured summary (keep:N + optional focus)",
+    handler: async (args: string, ctx: unknown) => {
+      const c = ctx as {
+        compact: (options?: unknown) => Promise<void> | void;
+        ui: { notify: (msg: string, level?: string) => void };
+        getSystemPrompt?: () => unknown;
+      };
+      await runCompactCommand(args, c, buildOmpCustomInstructions, "Compacted with omp-vcc", true, getCompactForm(() => c.getSystemPrompt?.()));
     },
   });
 
@@ -225,30 +274,11 @@ export default function (pi: ExtensionAPI): void {
     description: "Alias for /omp-vcc (pi-vcc compat)",
     handler: async (args: string, ctx: unknown) => {
       const c = ctx as {
-        compact: (instructions?: string) => Promise<void>;
+        compact: (options?: unknown) => Promise<void> | void;
         ui: { notify: (msg: string, level?: string) => void };
+        getSystemPrompt?: () => unknown;
       };
-      const parsed = parseKeepAndPrompt(args);
-      const keep = parsed.keepUserTurns;
-      const followUpPrompt = parsed.followUpPrompt;
-      const customInstructions = buildPiVccCustomInstructions(keep);
-      try {
-        await c.compact(customInstructions);
-        const stats = getLastCompactionStats(pi);
-        if (stats) scheduleCompactionStatsNotify(c as unknown as { ui: { notify: (msg: string, level?: string) => void } }, stats);
-        else try { c.ui.notify("Compacted with pi-vcc (via omp-vcc)", "info"); } catch {}
-        if (followUpPrompt) {
-          try {
-            const piAny = pi as unknown as { sendUserMessage?: (content: string) => Promise<void> | void };
-            if (piAny.sendUserMessage) await piAny.sendUserMessage(followUpPrompt);
-          } catch {}
-        }
-      } catch (err: unknown) {
-        const msg = err instanceof Error ? err.message : String(err);
-        const cancelled = msg === "Compaction cancelled" || msg === "Already compacted";
-        const note = cancelled ? "Nothing to compact" : `Compaction failed: ${msg}`;
-        try { c.ui.notify(note, cancelled ? "warning" : "error"); } catch {}
-      }
+      await runCompactCommand(args, c, buildPiVccCustomInstructions, "Compacted with pi-vcc (via omp-vcc)", false, getCompactForm(() => c.getSystemPrompt?.()));
     },
   });
 

package/extensions/vcc-core/hook.ts

@@ -9,20 +9,99 @@ import { calibrateCharsPerToken, estimateMessageContentChars, estimateMessageCon
 import type { PiVccCompactionDetails } from "./details";
 import type { CompactionReason } from "./types";
 
-// convertToLlm shim: try host export, fallback to identity (preserves AgentMessage for omp compileRanked)
+// convertToLlm shim: resolve the host export, fallback to identity (identity
+// is fine for bashExecution/custom, which the pipeline renders natively, but
+// it leaks !!-excluded spans and drops branchSummary entries — so the
+// @earendil-works root (pi's canonical export path) is tried first.
+const CONVERT_TO_LLM_CANDIDATES = [
+  "@earendil-works/pi-coding-agent",
+  "@oh-my-pi/pi-coding-agent",
+  "@oh-my-pi/pi-coding-agent/session/messages",
+] as const;
+// Pure loader-driven resolver: first candidate whose module exports a
+// convertToLlm function wins, else null (caller keeps identity).
+export const resolveConvertToLlm = (
+  load: (id: string) => any,
+): ((messages: any[]) => any[]) | null => {
+  for (const id of CONVERT_TO_LLM_CANDIDATES) {
+    try {
+      const mod = load(id);
+      if (mod && typeof mod.convertToLlm === "function") return mod.convertToLlm;
+    } catch {}
+  }
+  return null;
+};
 let convertToLlm: (messages: any[]) => any[] = (m) => m;
 try {
   const req = createRequire(import.meta.url);
-  const mod = req("@oh-my-pi/pi-coding-agent/session/messages") as any;
-  if (mod?.convertToLlm) convertToLlm = mod.convertToLlm;
+  convertToLlm = resolveConvertToLlm((id) => req(id)) ?? convertToLlm;
 } catch {}
-try {
-  if (convertToLlm.length === 0 || (convertToLlm as any).toString().includes("=> m")) {
-    const req2 = createRequire(import.meta.url);
-    const mod2 = req2("@oh-my-pi/pi-coding-agent") as any;
-    if (mod2?.convertToLlm) convertToLlm = mod2.convertToLlm;
+// Test-only override for the module-level binding (mirrors
+// clearCompactionHistoryForTests): lets suites pin convertToLlm wiring without
+// stubbing node module resolution. Null resets to the identity fallback.
+export const __setConvertToLlmForTests = (fn: ((messages: Array<unknown>) => Array<unknown>) | null): void => {
+  convertToLlm = fn ?? ((m) => m);
+};
+// Host-kind detection: omp and pi expose incompatible ctx.compact shapes
+// (omp: (string|CompactOptions)=>Promise<void> with instructions on the
+// string; pi: (CompactOptions)=>void with instructions only via
+// options.customInstructions). Three layers, first hit wins:
+// 1. Explicit test override (__setHostKindForTests).
+// 2. Observable ctx shape — works in bundled runtimes where module
+//    resolution misses: pi's getSystemPrompt() returns a string, omp's
+//    returns string[]. Pure getters, safe to call.
+// 3. Module scope — works in dev/source runtimes: @earendil-works is
+//    pi-exclusive (same mechanism as the convertToLlm shim above).
+// Default "omp" preserves the legacy string-form call when host-free.
+const HOST_KIND_CANDIDATES = ["@earendil-works/pi-coding-agent", "@oh-my-pi/pi-coding-agent"] as const;
+export type VccHostKind = "pi" | "omp";
+export type VccCompactForm = "object" | "string";
+// Pure loader-driven resolver: first resolvable scope wins (@earendil-works
+// first, mirroring CONVERT_TO_LLM_CANDIDATES), else "omp".
+export const resolveHostKind = (load: (id: string) => unknown): VccHostKind => {
+  for (const id of HOST_KIND_CANDIDATES) {
+    try {
+      if (load(id)) return id.startsWith("@earendil-works") ? "pi" : "omp";
+    } catch {}
   }
+  return "omp";
+};
+let defaultHostKind: VccHostKind = "omp";
+try {
+  defaultHostKind = resolveHostKind((id) => createRequire(import.meta.url)(id));
 } catch {}
+let hostKindOverride: VccHostKind | null = null;
+export const getHostKind = (): VccHostKind => hostKindOverride ?? defaultHostKind;
+// Test-only override (mirrors __setConvertToLlmForTests). Null restores the
+// detected default.
+export const __setHostKindForTests = (kind: VccHostKind | null): void => {
+  hostKindOverride = kind;
+};
+// Layered compact-form decision for a live ctx. getSystemPrompt is read off
+// the calling ctx (command or event); absent (host-free mocks) falls through
+// to module scope, then the legacy default.
+export const resolveCompactForm = (
+  load: (id: string) => unknown,
+  getSystemPrompt?: () => unknown,
+): VccCompactForm => {
+  if (hostKindOverride) return hostKindOverride === "pi" ? "object" : "string";
+  try {
+    const sp = getSystemPrompt?.();
+    if (typeof sp === "string") return "object";
+    if (Array.isArray(sp)) return "string";
+  } catch {}
+  return resolveHostKind(load) === "pi" ? "object" : "string";
+};
+export const getCompactForm = (getSystemPrompt?: () => unknown): VccCompactForm => {
+  let load: (id: string) => unknown = () => {
+    throw new Error("no loader");
+  };
+  try {
+    const req = createRequire(import.meta.url);
+    load = (id) => req(id);
+  } catch {}
+  return resolveCompactForm(load, getSystemPrompt);
+};
 
 export { PI_VCC_COMPACT_INSTRUCTION } from "./core/compact-args";
 export const OMP_VCC_COMPACT_INSTRUCTION = "__omp_vcc__";
@@ -786,18 +865,26 @@ export const registerBeforeCompactHook = (pi: ExtensionAPI) => {
     // Always handle explicit /pi-vcc or /omp-vcc marker.
     // Otherwise, only handle when user opted in via settings.
     const { isPiVcc, keepUserTurns, keepUserTurnsExplicit, followUpPrompt } = parseCompactionInstructions(customInstructions);
-    setPendingFollowUpPrompt(pi, null);
     // Explicit host mode bypass: when the host signals an explicit compact mode
-    // (e.g. /compact snapcompact or --mode shake), let the host walker handle it
-    // even though overrideDefaultCompaction is true. This enables sequential
-    // VCC → snapcompact/shake combinations. The event field is only present when
-    // the optional native vcc patch is applied or a future host exposes it; when
-    // absent this branch is no-op and the existing override semantics remain.
+    // via an event field, let the host walker handle it even though
+    // overrideDefaultCompaction is true. This enables sequential VCC →
+    // snapcompact/shake combinations. No shipped host exposes such a field
+    // today — omp carries the mode in the compact() options (never the event)
+    // and pi has no modes (its /compact text is raw focus instructions, so
+    // lone mode words must NEVER bypass: on pi `/compact shake` means
+    // "focus on shake"). The branch stays as the contract for the optional
+    // native patch / future hosts; unpatched, override:true serves explicit
+    // omp modes via VCC (use override:false for native modes).
     const explicitMode = (event as any).compactMode ?? (event as any).explicitMode ?? (event as any).mode;
     if (!isPiVcc && typeof explicitMode === "string" && explicitMode) {
       const m = explicitMode.toLowerCase();
       if (m === "snapcompact" || m === "shake" || m === "soft" || m === "remote" || m === "handoff") return;
     }
+    // Chain-shake yield: while a {mode:"shake"} chain is in flight (see
+    // session_compact below), let the host run it — otherwise VCC would
+    // swallow the modeless call into a second VCC pass. Sentinel compactions
+    // still handled (isPiVcc path falls through below).
+    if (!isPiVcc && pendingChainShake.has(pi as unknown as object)) return;
     if (!isPiVcc && !settings.overrideDefaultCompaction) return;
 
     const calibrationCut = buildOwnCut(branchEntries as any[], 0);
@@ -1203,13 +1290,21 @@ export const registerBeforeCompactHook = (pi: ExtensionAPI) => {
     const isLargeCompaction = (stats.summarized > 10) || (stats.kept > 5) || (stats.keptTokensEst > 2000);
     const shouldContinueAfterAutoCompact = (reason === "threshold" || reason === "overflow" || (reason == null && isLargeCompaction)) && loadSettings(ctx).continueAfterThresholdCompact;
     scheduleCompactionStatsNotify(ctx, stats);
-    // Eager post-VCC shake chain (chainShakeHint). Host rescue already handles
-    // dead-end; this forces a second shake entry even when headroom was made.
+    // Eager post-VCC shake chain (chainShakeHint, omp only). {mode:"shake"}
+    // is the omp native spelling; the before handler above yields while
+    // pendingChainShake is set so the host actually runs shake instead of
+    // VCC swallowing the modeless call. pi's CompactOptions has no mode key
+    // (the call would trigger a spurious default compaction), so pi never
+    // chains — host rescue remains the only shake path there.
     try {
       const cfgChain = loadSettings(ctx);
       const ctxMaybe = ctx as unknown as Record<string, unknown>;
       const compactFn = ctxMaybe["compact"];
-      if (cfgChain.chainShakeHint && typeof compactFn === "function" && !pendingChainShake.has(pi as unknown as object) && !willRetry && !isPiVccLast) {
+      const promptOf = ctxMaybe["getSystemPrompt"] as ((this: unknown) => unknown) | undefined;
+      // Form is detected off the live ctx so bundled runtimes (no module
+      // scope) still decide correctly.
+      const chainForm = getCompactForm(() => promptOf?.call(ctx));
+      if (cfgChain.chainShakeHint && chainForm === "string" && typeof compactFn === "function" && !pendingChainShake.has(pi as unknown as object) && !willRetry && !isPiVccLast) {
         pendingChainShake.add(pi as unknown as object);
         const maybePromise = (compactFn as unknown as (o: unknown) => Promise<void>).call(ctx, { mode: "shake" } as unknown);
         const asPromise = maybePromise as unknown as Promise<void> | void;
@@ -1223,8 +1318,12 @@ export const registerBeforeCompactHook = (pi: ExtensionAPI) => {
       }
     } catch {}
     if (followUpPrompt) {
+      // Fire-and-forget: pi's sendUserMessage returns void, omp's returns a
+      // promise — never await either, but swallow async rejections so a
+      // failed redelivery cannot surface as an unhandled rejection.
       try {
-        await pi.sendUserMessage(followUpPrompt);
+        const sent = (pi as any).sendUserMessage?.(followUpPrompt) as Promise<void> | undefined;
+        if (sent && typeof sent.catch === "function") sent.catch(() => {});
       } catch {}
     } else if (shouldContinueAfterAutoCompact) {
       scheduleAutoContinueForPi(pi);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omp-vcc",
-  "version": "0.1.12",
+  "version": "0.1.13",
   "type": "module",
   "description": "Algorithmic VCC compaction for omp - fast lossless no-LLM",
   "author": "Zhu Lin <zhulin@czl.my>",

package/scripts/smoke.ts

@@ -59,6 +59,14 @@ try {
     "vcc_stats registered",
     tools.some((t) => t.name === "vcc_stats"),
   );
+  check(
+    "vcc_recall schema has query/expand/page/scope/mode",
+    (() => {
+      const t = tools.find((t) => t.name === "vcc_recall");
+      const keys = t?.parameters ? Object.keys(t.parameters) : [];
+      return ["query", "expand", "page", "scope", "mode"].every((k) => keys.includes(k));
+    })(),
+  );
   check(
     "omp-vcc command registered",
     commands.some((c) => c.name === "omp-vcc"),

package/types.d.ts

@@ -14,13 +14,13 @@ declare module "@oh-my-pi/pi-coding-agent" {
       getBranch(fromId?: string): any[];
       getEntries(): any[];
     };
-    compact(instructionsOrOptions?: string | any): Promise<void>;
+    compact(instructionsOrOptions?: string | any): Promise<void> | void;
     sendMessage?: any;
     sendUserMessage?: any;
     [key: string]: unknown;
   }
   export interface ExtensionCommandContext extends ExtensionContext {
-    compact(instructionsOrOptions?: string | any): Promise<void>;
+    compact(instructionsOrOptions?: string | any): Promise<void> | void;
   }
   export interface ExtensionAPI {
     registerTool(tool: unknown): void;