omp-vcc 0.1.2 → 0.1.5

package/scripts/smoke.ts

@@ -55,6 +55,10 @@ try {
     "vcc_recall registered",
     tools.some((t) => t.name === "vcc_recall"),
   );
+  check(
+    "vcc_stats registered",
+    tools.some((t) => t.name === "vcc_stats"),
+  );
   check(
     "omp-vcc command registered",
     commands.some((c) => c.name === "omp-vcc"),
@@ -67,7 +71,23 @@ try {
     "pi-vcc alias registered",
     commands.some((c) => c.name === "pi-vcc"),
   );
-} catch (e) {
+  check(
+    "vcc-stats command registered",
+    commands.some((c) => c.name === "vcc-stats"),
+  );
+  check(
+    "no omp-vcc-stats duplicate",
+    !commands.some((c) => c.name === "omp-vcc-stats"),
+  );
+  check(
+    "pi-vcc-recall alias registered",
+    commands.some((c) => c.name === "pi-vcc-recall"),
+  );
+  check(
+    "no file slash command duplication (only extension commands)",
+    commands.filter((c) => c.name === "omp-vcc").length === 1,
+  );
+  } catch (e) {
   check("extension loads", false, String(e));
 }
 

package/scripts/uninstall-reset.js

@@ -1,73 +1,302 @@
 #!/usr/bin/env node
 /**
- * postuninstall hook: reset ownership marker if this plugin owned global state.
- * Generic postuninstall reset for ownership marker
- * Marker: ~/.config/@zhulinchng/omp-vcc/.ownership.json with { state: "owned", previous: boolean }
+ * postuninstall hook: reset ownership marker and clean stale plugin entries.
+ *
+ * 1. Marker: ~/.config/@zhulinchng/omp-vcc/.ownership.json with { state: "owned" }
+ *    When the plugin set `startup.quiet: true` in the global config, restore.
+ *    No-op when marker missing or not owned.
+ *
+ * 2. Stale plugin entries: historic `package.json:name` renames left
+ *    `@zhu/omp-vcc` → `@zhulinchng/omp-vcc` → `omp-vcc`. `omp plugin link .`
+ *    under an old name creates a symlink+lock entry that survives the rename
+ *    (host `PluginManager.link` did not clean same-realpath stale keys, and
+ *    `PluginManager.uninstall` for linked plugins left the symlink behind).
+ *    This script removes those stale symlinks+lock entries without touching
+ *    correctly installed `omp-vcc` (or npm `dependencies` entries which are
+ *    real directories, not symlinks).
+ *    Safe to run repeatedly; also runs on extension activation (see
+ *    extensions/vcc-core/core/migrate-stale.ts).
  */
-import { readFileSync, rmSync, writeFileSync } from "node:fs";
+import { readFileSync, rmSync, writeFileSync, existsSync, lstatSync, readdirSync, realpathSync } from "node:fs";
+import { readFile, lstat, readdir, realpath, rm, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
-import { join } from "node:path";
+import { join, resolve, dirname } from "node:path";
 import { pathToFileURL } from "node:url";
 
+const HISTORIC_NAMES = ["@zhu/omp-vcc", "@zhulinchng/omp-vcc"];
+const CURRENT_NAME = "omp-vcc";
+
 export function resetOwnedQuiet(home) {
-  const markerPath = join(
-    home,
-    ".config",
-    "@zhulinchng/omp-vcc",
-    ".ownership.json",
-  );
-  const configPath = join(home, ".omp", "agent", "config.yml");
+  const baseHome = home || homedir();
+  const markerPath = join(baseHome, ".config", "@zhulinchng/omp-vcc", ".ownership.json");
+  const configCandidates = [
+    join(baseHome, ".omp", "agent", "config.yml"),
+    join(baseHome, ".omp", "config.yml"),
+  ];
+
   let marker;
   try {
     marker = JSON.parse(readFileSync(markerPath, "utf8"));
   } catch {
     return "no-marker";
   }
+
   const clearMarker = () => {
     try {
       rmSync(markerPath, { force: true });
     } catch {}
   };
+
   if (marker?.state !== "owned") {
     clearMarker();
     return "not-owned";
   }
+
   let content;
-  try {
-    content = readFileSync(configPath, "utf8");
-  } catch {
+  let configPath;
+  for (const p of configCandidates) {
+    try {
+      content = readFileSync(p, "utf8");
+      configPath = p;
+      break;
+    } catch {}
+  }
+  if (!configPath || content === undefined) {
     clearMarker();
     return "config-missing";
   }
+
   const lines = content.split("\n");
   let inStartup = false;
   let changed = false;
   for (let i = 0; i < lines.length; i++) {
     const line = lines[i] ?? "";
     if (/^startup:\s*$/.test(line)) inStartup = true;
-    else if (inStartup && /^[^ \t]/.test(line) && line.trim() !== "")
-      inStartup = false;
+    else if (inStartup && /^[^ \t]/.test(line) && line.trim() !== "") inStartup = false;
     if (inStartup && /quiet:\s*true/.test(line)) {
       lines[i] = line.replace("true", "false");
       changed = true;
       break;
     }
   }
+
   if (changed) {
     try {
       writeFileSync(configPath, lines.join("\n"), "utf8");
     } catch {
+      clearMarker();
       return "write-failed";
     }
   }
+
   clearMarker();
   return changed ? "restored" : "already-default";
 }
 
-if (
+// --- stale plugin cleanup (in-plugin, no host changes) ---
+
+function isSymlinkSync(p) {
+  try {
+    return lstatSync(p).isSymbolicLink();
+  } catch {
+    return false;
+  }
+}
+
+function readJsonSync(p, fallback = null) {
+  try {
+    return JSON.parse(readFileSync(p, "utf8"));
+  } catch {
+    return fallback;
+  }
+}
+
+/**
+ * Remove stale `omp-vcc` plugin entries left by historic package.json renames
+ * and by `omp plugin uninstall` for linked plugins (which left the symlink
+ * behind on old hosts).
+ *
+ * - Only touches lockfile-only entries (not in `package.json:dependencies`)
+ *   where `package.json:name` mismatches the lock key, or where two keys
+ *   point at the same realpath.
+ * - Only removes symlinks, never real directories (npm installs).
+ * - Returns a summary string for logging.
+ */
+export function cleanupStalePluginEntries(home) {
+  const baseHome = home || homedir();
+  const pluginsDir = join(baseHome, ".omp", "plugins");
+  const lockPath = join(pluginsDir, "omp-plugins.lock.json");
+  const pkgPath = join(pluginsDir, "package.json");
+  const nm = join(pluginsDir, "node_modules");
+
+  const lock = readJsonSync(lockPath, null);
+  if (!lock || typeof lock !== "object") return "no-lock";
+
+  const pkg = readJsonSync(pkgPath, { dependencies: {} });
+  const deps = (pkg && typeof pkg.dependencies === "object" && pkg.dependencies) || {};
+
+  const pluginKeys = lock.plugins && typeof lock.plugins === "object" ? Object.keys(lock.plugins) : [];
+  const ompKeys = pluginKeys.filter((k) => k.includes("omp-vcc"));
+
+  // If no omp-vcc keys at all, still check for orphaned symlinks at historic
+  // paths that may remain after `omp plugin uninstall` (old host left symlink).
+  const candidates = new Set([...ompKeys, ...HISTORIC_NAMES, CURRENT_NAME]);
+
+  let removedLocks = [];
+  let removedLinks = [];
+
+  // Helper to get package.json:name for a node_modules entry, without throwing
+  const getPkgName = (name) => {
+    try {
+      const jp = readJsonSync(join(nm, name, "package.json"), null);
+      return jp && typeof jp.name === "string" ? jp.name : null;
+    } catch {
+      return null;
+    }
+  };
+
+  // Helper to get realpath for dedup, null if not exists or not symlink
+  const getReal = (name) => {
+    const p = join(nm, name);
+    if (!isSymlinkSync(p)) return null;
+    try {
+      return realpathSync(p);
+    } catch {
+      return null;
+    }
+  };
+
+  // Map realpath -> list of lock keys that resolve to it (for dedup)
+  const realToKeys = new Map();
+  for (const k of ompKeys) {
+    const rp = getReal(k);
+    if (!rp) continue;
+    const list = realToKeys.get(rp) || [];
+    list.push(k);
+    realToKeys.set(rp, list);
+  }
+
+  // 1. lock-only mismatch: lock key !== pkg name -> stale (e.g. @zhu/omp-vcc -> omp-vcc)
+  for (const k of [...ompKeys]) {
+    if (k in deps) continue; // npm-declared, keep even if name mismatches (dual publish)
+    const pkgName = getPkgName(k);
+    if (pkgName && pkgName !== k) {
+      // Historic rename leftover: lock key is old name, package is new name
+      const isHistoric = HISTORIC_NAMES.includes(k) || k !== CURRENT_NAME;
+      if (isHistoric) {
+        // Remove symlink if it exists
+        const p = join(nm, k);
+        if (isSymlinkSync(p)) {
+          try {
+            rmSync(p, { force: true });
+            removedLinks.push(k);
+            // try to remove empty scope dir e.g. .../node_modules/@zhu
+            if (k.startsWith("@")) {
+              const scopeDir = join(nm, k.split("/")[0]);
+              try {
+                if (readdirSync(scopeDir).length === 0) rmSync(scopeDir, { force: true });
+              } catch {}
+            }
+          } catch {}
+        }
+        // Remove lock entry
+        if (lock.plugins[k]) {
+          delete lock.plugins[k];
+          removedLocks.push(k);
+        }
+        if (lock.settings && lock.settings[k]) delete lock.settings[k];
+      }
+    }
+  }
+
+  // 2. duplicate realpath: two lock keys point at same directory -> keep the
+  //    one where lock key === pkg name, remove the other(s)
+  for (const [, keys] of realToKeys) {
+    if (keys.length <= 1) continue;
+    // Determine keeper: prefer CURRENT_NAME or key that matches pkg name
+    let keeper = null;
+    for (const k of keys) {
+      const pkgName = getPkgName(k);
+      if (pkgName === k) {
+        keeper = k;
+        break;
+      }
+    }
+    if (!keeper) keeper = keys.includes(CURRENT_NAME) ? CURRENT_NAME : keys[0];
+    for (const k of keys) {
+      if (k === keeper) continue;
+      // Only remove if lock-only (not deps) and symlink
+      if (k in deps) continue;
+      const p = join(nm, k);
+      if (isSymlinkSync(p)) {
+        try {
+          rmSync(p, { force: true });
+          if (!removedLinks.includes(k)) removedLinks.push(k);
+          if (k.startsWith("@")) {
+            const scopeDir = join(nm, k.split("/")[0]);
+            try {
+              if (readdirSync(scopeDir).length === 0) rmSync(scopeDir, { force: true });
+            } catch {}
+          }
+        } catch {}
+      }
+      if (lock.plugins[k]) {
+        delete lock.plugins[k];
+        if (!removedLocks.includes(k)) removedLocks.push(k);
+      }
+      if (lock.settings && lock.settings[k]) delete lock.settings[k];
+    }
+  }
+
+  // 3. orphaned symlinks at candidate paths that have no lock entry (old
+  //    host left symlink after uninstall). Remove them if they are symlinks
+  //    and their package name is omp-vcc (so we don't delete unrelated).
+  for (const cand of candidates) {
+    const p = join(nm, cand);
+    if (!isSymlinkSync(p)) continue;
+    const hasLock = !!lock.plugins[cand];
+    if (hasLock) continue; // already handled
+    const pkgName = getPkgName(cand);
+    // Only remove orphaned omp-vcc symlinks, not other plugins
+    if (pkgName === CURRENT_NAME || pkgName === "@zhu/omp-vcc" || pkgName === "@zhulinchng/omp-vcc") {
+      try {
+        rmSync(p, { force: true });
+        if (!removedLinks.includes(cand)) removedLinks.push(cand);
+        if (cand.startsWith("@")) {
+          const scopeDir = join(nm, cand.split("/")[0]);
+          try {
+            if (readdirSync(scopeDir).length === 0) rmSync(scopeDir, { force: true });
+          } catch {}
+        }
+      } catch {}
+    }
+  }
+
+  if (removedLocks.length > 0 || removedLinks.length > 0) {
+    try {
+      writeFileSync(lockPath, JSON.stringify(lock, null, 2));
+    } catch {}
+    return `cleaned locks:${removedLocks.join(",") || "none"} links:${removedLinks.join(",") || "none"}`;
+  }
+  return "no-stale";
+}
+
+const isDirectRun =
   process.argv[1] &&
-  import.meta.url === pathToFileURL(process.argv[1]).href
-) {
-  const result = resetOwnedQuiet(homedir());
-  console.log(`uninstall-reset: ${result}`);
+  (() => {
+    try {
+      return import.meta.url === pathToFileURL(resolve(process.argv[1])).href;
+    } catch {
+      return false;
+    }
+  })();
+
+if (isDirectRun) {
+  try {
+    const r1 = resetOwnedQuiet(homedir());
+    const r2 = cleanupStalePluginEntries(homedir());
+    console.log(`uninstall-reset: ${r1} ${r2}`);
+  } catch (err) {
+    console.log(`uninstall-reset: error ${err?.message ?? err}`);
+  }
 }

package/skills/omp-vcc/SKILL.md

@@ -1,35 +1,116 @@
+---
+name: omp-vcc
+description: VCC-inspired algorithmic compaction for oh-my-pi — lossless V_ui summary + ranked brief + V_adapt recall via vcc_recall. Use after auto-compaction (toast 90k→22k), when context grows 50+ turns, or before /omp-vcc keep:N boundaries.
+---
+
 # omp-vcc Skill — VCC-Inspired Algorithmic Compaction
 
-> Lossless, transcript-preserving structured summaries — no LLM calls. Based on `sting8k/pi-vcc` (TypeScript) and `lllyasviel/VCC` (View-oriented Conversation Compiler, arXiv 2603.29678).
+> Lossless, deterministic summarization — no LLM. `V_full` = full transcript, `V_ui` = structured summary + ranked brief, `V_adapt(b, ρ)` = structure-preserving recall. Use `V_ui → V_adapt(query) → V_full[s:e]`: scan summary, query, drill to verbatim lines.
+
+## When to Use
+
+- **After auto compaction** — read `V_ui` first, then `vcc_recall` for anything missing before asking the user to repeat. Toast `omp-vcc: 90.0k→22.0k (76% saved) · kept 1/5 turns` + divider `── 📷 compacted ──` means you just got a `V_ui`.
+- **Context is growing** (50+ turns, heavy tool output) — prefer small keep + recall over a huge tail. Recall is cheap and preserves turn/header/block.
+- **Before risky work** — create a clean boundary: `/omp-vcc keep:2 <focus>` (e.g. `/omp-vcc keep:2 fix auth`). The focus text is sent as the next user message after compaction.
+
+## What You Get (V_ui)
+
+Compacted summary replaces the old transcript; `V_ui` + kept tail is what you see next:
+
+```sh
+[Session Goal]
+- …
+
+[Files And Changes]
+- …
+
+[Commits]
+- …
+
+[Outstanding Context]
+- …
+
+[User Preferences]
+- …
+
+---
+* Read "src/pets.py" (file.txt:18-20)          ← ranked brief, one line per block
+* Edit src/auth.ts { old: "…" (#12:auth.ts:10-40) }
+
+Use `vcc_recall` to search for prior work … Do not redo work already completed.
+```
+
+- **5 sections** are extraction-only (no hallucination): Session Goal, Files And Changes, Commits, Outstanding Context, User Preferences.
+- **Ranked brief**: TF-IDF-ranked tool summaries, capped at **120 lines** (`BRIEF_MAX_LINES=120`), token-budgeted **1100 → 2000 tokens** (`RANKED_BRIEF_BUDGET_TOKENS` floor, `CEILING` 2000, ~15 tok/block). `---` separates sections from brief; earlier lines beyond 120 are dropped tail-first.
+- **Every line keeps a pointer** `(#N)` or `(path:s-e)` so `V_ui → V_full[s:e]` is structural. Trust the summary's pointers; drill for verbatim.
+
+## Commands & Tools
+
+| Task | How | Notes |
+|---|---|---|
+| **Check savings** | `/vcc-stats` · `vcc_stats({history:true})` | Last + history table (50-capped, no `omp-vcc-stats` alias). `/omp-vcc` toast is single line only; detailed savings via `/vcc-stats`. Use to confirm headroom before long edits. |
+| **Recall search** | `/vcc-recall <query> [scope:all] [page:2]` · alias `/pi-vcc-recall` · tool `vcc_recall({query, scope, mode, page, expand})` | 5 hits/page, up to 50 total. See cookbook below. |
+| **Stats tool** | `vcc_stats({history?: boolean})` | Same as `/vcc-stats`. `history:true` = full 50-row table. |
+
+`vcc_recall` params (all optional): `query?: string`, `page?: number` (1-indexed), `scope?: "lineage" | "all"` (default `lineage` = active branch), `mode?: "hybrid" | "touched"` (default `hybrid`), `expand?: number[]` (valid indices only).
+
+No config needed for normal use. Auto `threshold`/`overflow` compaction is already `V_ui` (deterministic, no model call, ~30–470 ms benchmark) when `overrideDefaultCompaction:true` (default). Don't fight it — just use the summary.
+
+## Recall Cookbook — V_adapt
+
+**How search works**: regex first; if invalid or no hits → TF-IDF keyword OR (rare terms weighted, stopwords removed). Each hit preserves turn/header/block, role tags, and `(#N)`. ±2 lines around the match are shown.
 
-## Philosophy
+```sh
+# basic keyword (TF-IDF OR)
+vcc_recall({query:"redis cache"})
+/vcc-recall redis cache
 
-- **Agent trace as structured document** (`user`, `assistant`, `thinking`, `tool_call/result`, `subagent`, compaction boundaries, harness directives). Like VCC's `V_full` identity view defines a line-number coordinate system; `V_ui` gives a one-line tool summary (`* Read "src/pets.py" (file.txt:18-20)`); `V_adapt(b, ρ)` projects via relevance predicate `ρ` (regex / BM25 / embedding / LLM) preserving turn headers, role tags, and `(f:s-e)` pointers.
-- **Fast, deterministic, lossless** — pure extraction, not LLM summarization. 30–470 ms, 35–99% context reduction, pointer invariant `V_ui → V_full[s:e]` holds structurally (SSA-like).
-- **Progressive disclosure** — brief transcript → ranked recall via `vcc_recall` (`ρ = regex→OR`) → drill-down `#N:path` resolves `(session.jsonl:s-e)` into the full view.
+# regex (contains | * + ? {} () [] \ ^ $ .)
+vcc_recall({query:"hook|inject"})
+/vcc-recall hook|inject
 
-## Pipeline
+# scope: include abandoned branches (default is active branch only)
+vcc_recall({query:"auth", scope:"all"})
+/vcc-recall auth scope:all
 
-Calibrated `charsPerToken` from `preparation.tokensBefore` (heuristic fallback 4) → Smart keep-tail (5 k → 25 k) → Build own cut (`firstKeptEntryId`, orphan recovery) → Token-budget tail rescue (`no_anchor` / `oversized_tail` ×2.5) → Normalize (IR lex: escaped JSON→`|` block, `digits→` strip, `<system-reminder>` filter, `TodoWrite`/`ToolSearch`/ANSI strip, `same message.id` merge, `queue-operation` discard, base64 image extract) → Filter noise → Build 5 sections (Session Goal, Files And Changes, Commits, Outstanding Context, User Preferences) → Ranked brief transcript (TF-IDF, `RANKED_BRIEF_BUDGET_TOKENS=1100` ceiling 2000, ~15 tok/block) → Format bracketed sections + separator `---` → Bounded merge (sticky dedup, volatile replace, transcript roll, 120-line cap).
+# pagination (5/page, up to 50)
+vcc_recall({query:"auth", page:2})
+/vcc-recall auth page:2 scope:all
 
-## Usage
+# file index — what was touched, not text search
+vcc_recall({query:"", mode:"touched"})
+/vcc-recall touched mode:touched
 
-- **Auto**: threshold/overflow compaction intercepts `session_before_compact` when `overrideDefaultCompaction=true` (default). No LLM summary; token-budgeted.
-- **Manual**: `/omp-vcc [keep:N] [focus]` — e.g. `/omp-vcc keep:2 fix auth` keeps last 2 user turns. Also `/pi-vcc` alias.
-- **Recall**: `vcc_recall({query:"redis cache", scope:"all", page:1})` or `/vcc-recall hook|inject scope:all page:2`. Regex first, then TF-IDF OR fallback. `mode:'touched'` lists files, `#12:src/auth.ts` drills. 5 per page.
+# drill to verbatim lines — resolves (#N) or (path:s-e)
+vcc_recall({query:"#12:src/auth.ts"})
+/vcc-recall #12:src/auth.ts
+vcc_recall({query:"#18"})                 # whole turn 18
+vcc_recall({query:"#18:src/auth.ts:40-80"}) # slice (offset/limit via drill-down)
 
-## Configuration
+# expand multiple turns by index (from a prior recall's #N)
+vcc_recall({query:"", expand:[12,18,25]})
+```
 
-File `~/.omp/omp-vcc/config.json` (XDG-aware via `$OMP_DIR`/`$PI_CODING_AGENT_DIR`/`$OMP_VCC_CONFIG_PATH`, migrates legacy `~/.pi/agent/pi-vcc-config.json`). Manifest `omp.settings` also exposed: `vccEnabled`, `overrideDefaultCompaction`, `smartKeepTail`, `continueAfterThresholdCompact`, `debug` (`/tmp/omp-vcc-debug.json`).
+**Pick the right query:**
 
-Optional native strategy: add `vcc` to `COMPACTION_METHOD_CHOICES` in `oh-my-pi` (see `docs/configuration.md#native-strategy`).
+- Find an edit/file: `mode:touched` then drill, or `query:"src/auth.ts"` then `#N:path`.
+- Find a decision: `query:"why did we choose|decision|ADR"` (regex).
+- Find an error/tool output: keyword of the error message — full tool output is searchable.
+- Nothing found in `lineage` but you know it existed: retry `scope:all` (abandoned `/clear` branches are excluded by default).
 
-## Verification
+**If you get:**
 
-`bunx tsc --noEmit` → `bun test` → `bun run smoke` → `omp plugin link` → `/omp-vcc keep:1` shows `[Session Goal]` toast `omp-vcc: kept 1/5 turns, ~2.1k tok`.
+- `0 matches` — try keywords (no regex chars) or `scope:all`; check spelling of path.
+- `truncated — showing 50 of 120 matches, refine…` — narrow regex/keywords.
+- `Page 3 is outside 1-2 (7 matches)…` — use `page` in range or refine.
+- `Cannot expand indices outside active lineage: 42. Use scope:'all'` — add `scope:"all"` or pick index from the same lineage.
+- `#N` outside active lineage → same: retry with `scope:"all"` or use a `lineage` hit.
 
-## Related
+## Agent Playbook
 
-- VCC paper `arxiv:2603.29678` — three views, AppWorld evaluation (+1.1–4.2 pts, ½–⅔ tokens)
-- `sting8k/pi-vcc` `@0.7.0` — ported core `extensions/vcc-core/*` verbatim, imports adapted to `@oh-my-pi/*`
-- `lllyasviel/VCC` `VCC.py` — adaptive `SEP`, `match_lines`, transposed modalities
+1. **After any compaction, re-orient from V_ui.** Read Session Goal → Files → Outstanding → brief. Don't re-ask the user for what's already in the summary.
+2. **Small keep + recall beats large keep.** `/omp-vcc keep:1` + `vcc_recall({query:"auth"})` keeps the focused tail small and lets you pull exact history on demand. Only `keep:3+` when you need verbatim recent context immediately after compaction.
+3. **Recall before synthesis.** For any question about prior work (file changed, test added, decision made), call `vcc_recall` proportionally to context size: small session → 1 recall with broad keywords; long/complex session → 2–3 targeted recalls (keywords then drill).
+4. **Create boundaries intentionally.** Before a multi-file refactor or hand-off doc: `/omp-vcc keep:2 continue auth refactor` — next turn starts from a fresh, citable `V_ui`. Verify with `/vcc-stats` (`kept 2/18 turns, 76% saved`) before continuing.
+5. **Don't stall after threshold.** Auto threshold/overflow compaction auto-continues via invisible follow-up (you'll just see the summary and your next turn proceeds). If you issued `/omp-vcc keep:2 <focus>`, that focus text arrives as the next user message — treat it as the goal.
+6. **Use pointers, don't re-derive.** When you quote prior work, cite `(#N)` or `(file:s-e)` from the brief; drill `#N:path` for verbatim to paste, not guessed content.

package/commands/omp-vcc.md

@@ -1,19 +0,0 @@
----
-description: Compact conversation with omp-vcc structured summary (keep:N + optional focus)
----
-
-# /omp-vcc
-
-Algorithmic VCC compaction — fast lossless no-LLM. Registered by `@zhulinchng/omp-vcc` extension.
-
-Usage:
-
-- `/omp-vcc` — compact with default keep:1 (smart-keep may boost to keep:N up to 25k tokens)
-- `/omp-vcc keep:2` — keep last 2 user turns, summarize the rest
-- `/omp-vcc keep:0` — compact all (no tail, sentinel firstKeptEntryId="")
-- `/omp-vcc some prompt text` — compact with additional prompt/focus for the summary
-- `/omp-vcc keep:2 some prompt text` — both keep and prompt
-
-This command is handled by the `omp-vcc` extension (`extensions/main.ts`). It delegates to the VCC pipeline (calibrate → smart-keep → budget-cut → normalize → filter-noise → build-sections → brief transcript → format → merge) and writes a structured summary with `[Session Goal]` / `[Files And Changes]` / `[Brief transcript]` sections.
-
-Arguments: `$ARGUMENTS`

package/commands/vcc-recall.md

@@ -1,21 +0,0 @@
----
-description: Recall earlier parts of this session via ranked search (V_adapt)
----
-
-# /vcc-recall
-
-Search compacted history — implements VCC `V_adapt` with rho predicate (regex or BM25-like ranked OR).
-
-Registered by `@zhulinchng/omp-vcc` extension.
-
-Usage:
-
-- `/vcc-recall` — show 25 most recent entries
-- `/vcc-recall auth token` — keyword search (OR-ranked, TF-IDF)
-- `/vcc-recall "hook|inject" scope:all` — regex search across all branches
-- `/vcc-recall cache page:2` — paginated results (5 per page)
-- `vcc_recall` tool: `{"query":"redis cache","scope":"all","page":1}` — same engine, also supports `mode:'touched'` for file index and `expand:[12,34]` or `#12:path` drill-down
-
-The tool preserves VCC invariants: role tags, line range pointers `(#N)`, and progressive disclosure `V_ui → V_adapt → V_full[s:e]`.
-
-Arguments: `$ARGUMENTS`