omp-vcc 0.1.7 → 0.1.9

package/README.md

@@ -19,15 +19,23 @@ New here → [`docs/setup.md`](docs/setup.md).
 - **Manual** `/omp-vcc [keep:N] [focus]` (`/pi-vcc` alias) — compact only, single-line toast `90k→22k` — e.g. `/omp-vcc keep:2 fix auth` (detailed savings via `/vcc-stats`).
 - **Recall** `vcc_recall({query, scope, page, mode, expand})` + `/vcc-recall` — regex → TF-IDF OR, 5/page, `mode:'touched'`, `#N:path` drill-down.
 - **Savings** toast `90k→22k (76% saved)` single line (inline `Last compaction` detail removed; use `/vcc-stats`), divider, `/vcc-stats` + `vcc_stats` tool (50-capped history, per-pi), `details.savings` persisted, `/tmp/omp-vcc-debug.json`.
+
 ## Commands
 
-| `/omp-vcc [keep:N] [focus]` | Compact only. `keep:0` = all. Smart-keep boosts `keep:1` (5k→25k) unless explicit. Toast single line; detail via `/vcc-stats`. |
-| `/pi-vcc` | Legacy alias for `/omp-vcc` |
-| `/vcc-recall [query] [scope:all] [page:N] [mode:touched]` | Search compacted history |
-| `/pi-vcc-recall` | Legacy alias for `/vcc-recall` |
-| `/vcc-stats [history\|all]` | Last savings + history table (single, no alias) |
+| Command | What it does | Defaults (bare invocation) |
+| --- | --- | --- |
+| `/omp-vcc [keep:N] [focus]` | Compact only. Toast single line; detail via `/vcc-stats`. | `keep:1` — smart-keep grows it while the tail stays ≤5k (cap 25k). `keep:0` summarizes everything. No focus = no follow-up prompt. Explicit `keep:N` is never boosted. |
+| `/pi-vcc` | Legacy alias for `/omp-vcc` | Same as above. |
+| `/vcc-recall [query] [scope:all] [page:N]` | Search compacted history, 5 results per page. | No query = last 25 entries of the active branch. Scope defaults to the active lineage; `scope:all` searches the whole session. `page:1`. |
+| `/pi-vcc-recall` | Legacy alias for `/vcc-recall` | Same as above. |
+| `/vcc-stats [history\|all]` | Last-compaction savings + history table (single, no alias). | Bare = last-compaction detail (history table appended once >1 compaction exists). `history`/`all` = full table first, then the last detail. |
+| `/vcc-config` | Effective config with per-key source (`file` / `host overlay` / `default`) plus resolved file path. | Args ignored — always the merged result. |
+
++
 
-Tools: `vcc_recall`, `vcc_stats` (approval `read`). Extension-only — no `commands/*.md` file slash commands (avoids duplicate `/omp-vcc`).
++Search mode (`hybrid` regex→TF-IDF search default, `touched` = touched-files list) is a `vcc_recall` tool parameter only — the slash command always searches hybrid.
++
++Tools: `vcc_recall`, `vcc_stats` (approval `read`). Extension-only — no `commands/*.md` file slash commands (avoids duplicate `/omp-vcc`).
 
 ## Configuration
 
@@ -45,7 +53,7 @@ File `~/.omp/omp-vcc/config.json` — XDG: `$OMP_VCC_CONFIG_PATH` > `$PI_VCC_CON
 ```
 
 | Flag | Default | Effect |
-|---|---|---|
+| --- | --- | --- |
 | `vccEnabled` | `true` | Master switch. `false` = no interception. |
 | `overrideDefaultCompaction` | `true` | `true` = VCC handles threshold/overflow. `false` = host `methodOrder` handles them; `/omp-vcc` still works. |
 | `smartKeepTail` | `true` | Grow `keep:1` when tail <5k (cap 25k). Explicit `keep:N` never boosted. |
@@ -53,7 +61,7 @@ File `~/.omp/omp-vcc/config.json` — XDG: `$OMP_VCC_CONFIG_PATH` > `$PI_VCC_CON
 | `debug` | `false` | Write `/tmp/omp-vcc-debug.json` per compaction. |
 | `chainShakeHint` | `false` | Eager post-VCC `shake` chain. Host rescue already auto-shakes on dead-end; this forces it. |
 
-Toggle live: `omp config set plugins."@zhulinchng/omp-vcc".debug true` or `/settings` → `@zhulinchng/omp-vcc`. File is source of truth; `ctx.settings` overlays at runtime.
+Toggle live: `omp config set plugins."@zhulinchng/omp-vcc".debug true` or `/settings` → `@zhulinchng/omp-vcc`. File is source of truth; `ctx.settings` overlays at runtime. `/vcc-config` shows the merged result — use it to confirm a toggle took effect.
 
 ## How it works
 
@@ -70,7 +78,7 @@ See [`docs/harness.md`](docs/harness.md) for host impact and [`docs/architecture
 VCC summarizes **history**; `shake` elides `artifact://` blocks in **kept tail** (disjoint); `snapcompact` is an alternative history archiver (vision bitmaps, needs `model.input includes "image"`). One `CompactionEntry` per trigger — combos are additive or sequential, never double-summarization.
 
 | Trigger | `override` | Result |
-|---|---|---|
+| --- | --- | --- |
 | threshold, `override:true` (default) | VCC handles; host auto-shakes if still over band (`#rescueCompactionDeadEnd`) | VCC + shake if dead-end |
 | threshold, `override:false` | Host walks `methodOrder` (`remote→snapcompact→handoff→shake→soft`) | VCC → snapcompact/shake fallback |
 | `/omp-vcc keep:2` | Always VCC (sentinel `__omp_vcc__`) | VCC |
@@ -82,9 +90,9 @@ Additive VCC+shake is automatic. Eager chain: `chainShakeHint:true`. Explicit mo
 
 ```sh
 bunx tsc --noEmit
-bun test                  # 515 tests, 48 files, 1443 expects, 0 fail
-bun test tests/e2e --timeout 120000  # 111 E2E
-bun run smoke             # 9 checks: 3 hooks + 4 cmds + 2 tools + pipeline
+bun test                  # 661 tests, 56 files, 2095 expects, 0 fail
+bun test tests/e2e --timeout 120000  # 124 E2E
+bun run smoke             # 13 checks: 3 hooks + 6 cmds + 2 tools + dedup (+ pipeline)
 omp plugin link . && omp plugin doctor
 ```
 
@@ -97,6 +105,7 @@ bunx tsc --noEmit && bun test && bun run smoke
 omp -e @zhulinchng/omp-vcc
 /omp-vcc keep:1   # expect [Session Goal] + toast omp-vcc: kept 1/2 turns
 /vcc-stats        # table + history
+/vcc-config      # effective config card with per-key source
 cat /tmp/omp-vcc-debug.json  # when debug:true
 ```
 

package/extensions/main.ts

@@ -19,6 +19,7 @@ import {
   scheduleCompactionStatsNotify,
   registerVccStatsTool as registerVccStatsToolHook,
   registerVccStatsCommand as registerVccStatsCommandHook,
+  registerVccConfigCommand as registerVccConfigCommandHook,
 } from "./vcc-core/hook";
 import { searchEntriesDetailed, getTouchedFiles } from "./vcc-core/core/search-entries";
 import { formatRecallOutput, formatTouchedOutput } from "./vcc-core/core/format-recall";
@@ -342,9 +343,10 @@ export default function (pi: ExtensionAPI): void {
   });
   // ── /vcc-stats commands — show savings table (PR3) ──
   registerVccStatsCommandHook(pi);
+  registerVccConfigCommandHook(pi);
 
 }
 // ── Re-exports for pi-vcc test compatibility (not dead: tests import via hook directly,
 // but external consumers and the `vcc-recall` shim may import via main) ──
-export { registerBeforeCompactHook, PI_VCC_COMPACT_INSTRUCTION, OMP_VCC_COMPACT_INSTRUCTION, getLastCompactionStats, getCompactionHistory, formatCompactionStats, formatStatsTable, formatLastStatsDetail, scheduleCompactionStatsNotify, AUTO_CONTINUE_CUSTOM_TYPE, LEGACY_AUTO_CONTINUE_CUSTOM_TYPE, invalidExpandIndices, registerRecallTool, registerVccRecallCommand, registerPiVccCommand, registerVccStatsTool, registerVccStatsCommand, clearCompactionHistoryForTests } from "./vcc-core/hook";
+export { registerBeforeCompactHook, PI_VCC_COMPACT_INSTRUCTION, OMP_VCC_COMPACT_INSTRUCTION, getLastCompactionStats, getCompactionHistory, formatCompactionStats, formatStatsTable, formatLastStatsDetail, scheduleCompactionStatsNotify, AUTO_CONTINUE_CUSTOM_TYPE, LEGACY_AUTO_CONTINUE_CUSTOM_TYPE, invalidExpandIndices, registerRecallTool, registerVccRecallCommand, registerPiVccCommand, registerVccStatsTool, registerVccStatsCommand, registerVccConfigCommand, clearCompactionHistoryForTests } from "./vcc-core/hook";
 export { buildPiVccCustomInstructions, parseKeepAndPrompt } from "./vcc-core/core/compact-args";

package/extensions/vcc-core/core/brief.ts

@@ -321,6 +321,17 @@ export const buildBriefSections = (blocks: NormalizedBlock[]): BriefLine[] => {
         }
         break;
       }
+      case "custom": {
+        // Injected context (memory, skills): kept verbatim under its own tag
+        // so the next session can attribute it correctly.
+        const text = truncateTokens(collapseSkillText(b.text), TRUNCATE_USER);
+        if (text) {
+          const ref = b.sourceIndex != null ? ` (#${b.sourceIndex})` : "";
+          pushText("[custom]", text, ref);
+        }
+        lastHeader = "[custom]";
+        break;
+      }
       case "tool_call": {
         // Skip malformed tool calls from streaming providers (empty name / fragmented args).
         if (!b.name || b.name.trim() === "") break;

package/extensions/vcc-core/core/build-sections.ts

@@ -3,7 +3,7 @@ import type { FileOps, NormalizedBlock } from "../types";
 import { clip, clipSentence, nonEmptyLines } from "./content";
 import type { SectionData } from "../sections";
 import { extractGoals } from "../extract/goals";
-import { extractFiles } from "../extract/files";
+import { extractFiles, renderFileCategoryLines } from "../extract/files";
 import { extractPreferences, dedupPreferencesAgainstGoals } from "../extract/preferences";
 import { extractCommits, formatCommits } from "../extract/commits";
 import { buildBriefSections, stringifyBrief } from "./brief";
@@ -41,21 +41,15 @@ const extractOutstandingContext = (blocks: NormalizedBlock[]): string[] => {
 
   return items.slice(0, 5);
 };
-
 const formatFileActivity = (blocks: NormalizedBlock[], fileOps?: FileOps): string[] => {
   const act = extractFiles(blocks, fileOps);
   // Dedup: if already Modified, drop from Created (file existed before)
   for (const p of act.modified) act.created.delete(p);
-  const lines: string[] = [];
-  const cap = (set: Set<string>, limit: number) => {
-    const arr = [...set];
-    if (arr.length <= limit) return arr.join(", ");
-    return arr.slice(0, limit).join(", ") + ` (+${arr.length - limit} more)`;
-  };
-  if (act.modified.size > 0) lines.push(`Modified: ${cap(act.modified, 10)}`);
-  if (act.created.size > 0) lines.push(`Created: ${cap(act.created, 10)}`);
-  if (act.read.size > 0) lines.push(`Read: ${cap(act.read, 10)}`);
-  return lines;
+  return [
+    ...renderFileCategoryLines("Modified", [...act.modified]),
+    ...renderFileCategoryLines("Created", [...act.created]),
+    ...renderFileCategoryLines("Read", [...act.read]),
+  ];
 };
 
 export const buildSections = (input: BuildSectionsInput): SectionData => {

package/extensions/vcc-core/core/format.ts

@@ -18,14 +18,21 @@ const wrapLine = (line: string, maxChars: number): string[] => {
   const wrapped: string[] = [];
   let remaining = line;
   let prefix = "";
-
   while (prefix.length + remaining.length > maxChars) {
     const available = Math.max(20, maxChars - prefix.length);
     let splitAt = remaining.lastIndexOf(" ", available);
-    if (splitAt < Math.floor(available * 0.5)) splitAt = available;
-
-    wrapped.push(prefix + remaining.slice(0, splitAt).trimEnd());
-    remaining = remaining.slice(splitAt).trimStart();
+    const hard = splitAt < Math.floor(available * 0.5);
+    if (hard) {
+      // No usable space: mid-token break. One char shorter plus a trailing
+      // backslash marks it so parsers rejoin WITHOUT a space (see
+      // mergeFileLines); the line stays within maxChars.
+      const cut = Math.max(1, available - 1);
+      wrapped.push(prefix + remaining.slice(0, cut) + "\\");
+      remaining = remaining.slice(cut);
+    } else {
+      wrapped.push(prefix + remaining.slice(0, splitAt).trimEnd());
+      remaining = remaining.slice(splitAt).trimStart();
+    }
     prefix = continuationIndent;
   }
 

package/extensions/vcc-core/core/normalize.ts

@@ -60,6 +60,15 @@ const normalizeOne = (msg: Message, msgIndex: number): NormalizedBlock[] => {
     return blocks;
   }
 
+  // Injected context (custom_message entries: memory, skill context). Kept as
+  // its own kind so the brief can attribute it without mislabeling it as a
+  // user or assistant turn. branchSummary entries carry no content here.
+  if (msg.role === "custom") {
+    const text = sanitize(textOf(msg.content));
+    if (text) return [{ kind: "custom", text, sourceIndex: msgIndex }];
+    return [];
+  }
+
   return [];
 };
 

package/extensions/vcc-core/core/rank.ts

@@ -113,6 +113,7 @@ const scoreBlock = (
 
   if (block.kind === "user") add(ranked, 18, "user-turn");
   if (block.kind === "assistant") add(ranked, 10, "assistant-context");
+  if (block.kind === "custom") add(ranked, 12, "custom-context");
   if (block.kind === "tool_result") add(ranked, 1, "tool-result-low-value");
 
   if (block.kind === "tool_call") {

package/extensions/vcc-core/core/settings.ts

@@ -166,3 +166,80 @@ export function scaffoldSettings(): void {
     // best-effort; never crash extension load
   }
 }
+/** Live-resolved config path. Unlike the `SETTINGS_PATH` const (frozen at import
+ * time), this reflects the current `OMP_VCC_CONFIG_PATH` / `PI_VCC_CONFIG_PATH` env. */
+export function getSettingsPath(): string {
+  return settingsPath();
+}
+
+export type VccSettingSource = "file" | "overlay" | "default";
+
+export interface VccConfigView {
+  /** Live primary path — where a config file WOULD live. */
+  path: string;
+  /** Actual file parsed (primary, XDG/legacy fallback, or null when none). */
+  readPath: string | null;
+  /** True when a candidate file exists (even if unparseable). */
+  filePresent: boolean;
+  /** True when a candidate file parsed as a JSON object. */
+  fileValid: boolean;
+  /** Effective values — same merge as `loadSettings` (defaults ← file ← ctx overlay). */
+  values: PiVccSettings;
+  /** Per-key provenance. Presence check is `key in parsed`, so a file key that
+   * happens to equal the default still counts as `file`. */
+  sources: Record<keyof PiVccSettings, VccSettingSource>;
+}
+
+/**
+ * `loadSettings` plus provenance for `/vcc-config`. Read-only: never creates or
+ * repairs files (`scaffoldSettings` owns that). Merge order mirrors `loadSettings`
+ * exactly — defaults, then the first readable candidate (primary, else the same
+ * `fallbackReadPath()` order), then the identical ctx overlay chain.
+ */
+export function loadSettingsWithSources(ctx?: unknown): VccConfigView {
+  const path = settingsPath();
+  const primaryParsed = readJson(path);
+  let parsed: Record<string, unknown> | null = primaryParsed;
+  let readPath: string | null = primaryParsed ? path : null;
+  if (!parsed) {
+    const fb = fallbackReadPath();
+    if (fb && fb !== path) {
+      const fbParsed = readJson(fb);
+      if (fbParsed) {
+        parsed = fbParsed;
+        readPath = fb;
+      }
+    }
+  }
+  const candidateExists = fallbackReadPath() !== null;
+  const valid = !!parsed && typeof parsed === "object";
+  const values: PiVccSettings =
+    valid && parsed
+      ? { ...DEFAULT_SETTINGS, ...(parsed as Partial<PiVccSettings>) }
+      : { ...DEFAULT_SETTINGS };
+  const sources = {} as Record<keyof PiVccSettings, VccSettingSource>;
+  for (const k of Object.keys(DEFAULT_SETTINGS) as (keyof PiVccSettings)[]) {
+    sources[k] = valid && parsed && k in parsed ? "file" : "default";
+  }
+  if (ctx) {
+    const tryGet = (key: string): unknown => {
+      try {
+        const c = ctx as any;
+        if (!c) return undefined;
+        if (c.settings?.get) return c.settings.get(key);
+        if (c.config?.get) return c.config.get(key);
+        if (c.settings && typeof c.settings === "object" && key in c.settings) return c.settings[key];
+        if (c.config && typeof c.config === "object" && key in c.config) return c.config[key];
+      } catch {}
+      return undefined;
+    };
+    for (const k of Object.keys(DEFAULT_SETTINGS) as (keyof PiVccSettings)[]) {
+      const v = tryGet(`plugins.@zhulinchng/omp-vcc.${k}`) ?? tryGet(`plugins.omp-vcc.${k}`) ?? tryGet(`omp-vcc.${k}`) ?? tryGet(k);
+      if (v !== undefined) {
+        (values as any)[k] = v;
+        sources[k] = "overlay";
+      }
+    }
+  }
+  return { path, readPath, filePresent: candidateExists, fileValid: valid, values, sources };
+}

package/extensions/vcc-core/core/summarize.ts

@@ -6,6 +6,7 @@ import { filterNoise } from "./filter-noise";
 import { buildSections } from "./build-sections";
 import { formatSummary, capBrief, BRIEF_MAX_LINES, RECALL_NOTE, wrapLongLines } from "./format";
 import { selectRankedBriefBlocks, type BriefRankingOptions } from "./rank";
+import { renderFileCategoryLines } from "../extract/files";
 
 export interface CompileInput {
   messages: Message[];
@@ -24,86 +25,155 @@ const SEPARATOR = "\n\n---\n\n";
 /** Extract a named section from summary text */
 const sectionOf = (text: string, header: string): string => {
   const tag = `[${header}]`;
-  const start = text.indexOf(tag);
-  if (start < 0) return "";
-  const after = text.slice(start);
-  // Find next section header or separator
+  // Scope to the headers region (before the first separator) and match the
+  // tag only at a line start: value lines may contain literal "[Tags]"
+  // mid-line and the brief transcript may contain ghost tags at line starts.
+  const head = text.split(SEPARATOR)[0];
+  const startMatch = new RegExp(`(^|\\n)${escapeRegExp(tag)}`).exec(head);
+  if (!startMatch) return "";
+  const start = startMatch.index + startMatch[1].length;
+  const after = head.slice(start);
+  // Find next section header (line-anchored) as the end boundary.
   const nextSection = HEADER_NAMES
     .filter((h) => h !== header)
-    .map((h) => after.indexOf(`[${h}]`))
-    .filter((n) => n > 0);
-  const nextSep = after.indexOf("\n\n---\n\n");
-  const candidates = [...nextSection, ...(nextSep > 0 ? [nextSep] : [])].sort((a, b) => a - b);
-  const end = candidates[0];
+    .map((h) => new RegExp(`\\n${escapeRegExp(`[${h}]`)}`).exec(after))
+    .filter((m) => m && m.index > 0)
+    .map((m) => m.index);
+  const end = nextSection.sort((a, b) => a - b)[0];
   return (end ? after.slice(0, end) : after).trim();
 };
 
 /** Extract the brief transcript part (everything after ---) */
 const briefOf = (text: string): string => {
   const idx = text.indexOf(SEPARATOR);
-  if (idx < 0) return "";
-  return text.slice(idx + SEPARATOR.length).trim();
+  if (idx >= 0) return text.slice(idx + SEPARATOR.length).trim();
+  // No separator: a stripped headerless summary is all brief, while a lone
+  // headers block (starts with a known tag) has no brief.
+  const tagPattern = new RegExp(`^\\[(${HEADER_NAMES.map(escapeRegExp).join("|")})\\]`);
+  if (tagPattern.test(text.trimStart())) return "";
+  return text.trim();
+};
+
+/** Rejoin wrapLongLines continuations (indented followers) before line-level
+ * merging, so wrapped value lines survive whole. Backslash-marked hard breaks
+ * rejoin without a space, normal breaks with one. */
+const joinContinuations = (text: string): string[] => {
+  const out: string[] = [];
+  for (const line of text.split("\n")) {
+    if (out.length > 0 && /^\s+\S/.test(line)) {
+      const cont = line.trim();
+      const prev = out[out.length - 1];
+      out[out.length - 1] = prev.endsWith("\\") ? prev.slice(0, -1) + cont : `${prev} ${cont}`;
+    } else {
+      out.push(line);
+    }
+  }
+  return out;
 };
 
 /** Merge a header section */
 const mergeHeaderSection = (header: string, prev: string, fresh: string): string => {
   // Outstanding Context is volatile -- always use fresh only
   if (header === "Outstanding Context") return fresh;
-  if (!prev) return fresh;
-  if (!fresh) return prev;
 
-  // Files And Changes: merge by category (Modified/Created/Read), dedup paths
+  // Files And Changes: merge by category (Modified/Created/Read), dedup paths.
+  // Always rendered through mergeFileLines (even one-sided) so stale bare
+  // "(+N more)" counts from legacy summaries are dropped and the display
+  // form stays canonical across cycles.
   if (header === "Files And Changes") {
+    if (!prev) return fresh;
     return mergeFileLines(prev, fresh);
   }
 
+  if (!prev) return fresh;
+  if (!fresh) return prev;
+
   // Session Goal, User Preferences: line-level dedup, cap
   const isClean = (l: string) => l.startsWith("- ") && !l.includes("<skill") && !l.includes("</skill");
-  const prevLines = prev.split("\n").filter(isClean);
-  const freshLines = fresh.split("\n").filter(isClean);
+  const prevLines = joinContinuations(prev).filter(isClean);
+  const freshLines = joinContinuations(fresh).filter(isClean);
   const combined = [...new Set([...prevLines, ...freshLines])];
   const CAP = header === "Session Goal" ? 8 : header === "Commits" ? 8 : 15;
   const capped = combined.length > CAP ? combined.slice(-CAP) : combined;
   if (capped.length === 0) return "";
   return `[${header}]\n${capped.join("\n")}`;
 };
-
-/** Merge Files And Changes by category, dedup paths across compactions */
 const mergeFileLines = (prev: string, fresh: string): string => {
   const categories = ["Modified", "Created", "Read"] as const;
   const merged: Record<string, Set<string>> = {};
   for (const cat of categories) merged[cat] = new Set();
 
-  // Parse "- Modified: a, b, c (+N more)" lines from both prev and fresh
+  // Parse three line forms from both prev and fresh:
+  //   "- Modified: a, b"                        (bare; legacy relative kept verbatim)
+  //   "- Modified (in /prefix/): a, b"          (prefix-collapsed display)
+  //   "- Modified (+2 more under /d/): b1, b2"  (grouped overflow; dir may be "")
+  // formatSummary wraps long lines at 120 cols with an indented continuation:
+  // normal breaks rejoin with a space, backslash-marked mid-token breaks
+  // rejoin without one. A bare "(+N more)" line/suffix carries no names and
+  // is ignored (legacy counts were lossy by design).
+  const addPaths = (cat: string, prefix: string, rest: string) => {
+    const clean = rest.replace(/\s*\(\+\d+ more\)\s*$/, "");
+    for (const p of clean.split(",")) {
+      const trimmed = p.trim();
+      if (trimmed) merged[cat].add(prefix + trimmed);
+    }
+  };
+  const parseHead = (cat: string, tail: string): { prefix: string; rest: string } | null => {
+    if (tail.startsWith(": ")) return { prefix: "", rest: tail.slice(2) };
+    if (tail.startsWith(" (in ")) {
+      const end = tail.indexOf("): ");
+      if (end > 0) return { prefix: tail.slice(5, end), rest: tail.slice(end + 3) };
+      return null;
+    }
+    const grouped = /^ \(\+(\d+) more( under (.+?))?\): (.*)$/.exec(tail);
+    if (grouped) {
+      const dir = grouped[3] ?? "";
+      return { prefix: dir && !dir.endsWith("/") ? `${dir}/` : dir, rest: grouped[4] };
+    }
+    return null;
+  };
   for (const text of [prev, fresh]) {
+    let current: { cat: string; prefix: string; rest: string } | null = null;
+    const flush = () => {
+      if (current) {
+        addPaths(current.cat, current.prefix, current.rest);
+        current = null;
+      }
+    };
     for (const line of text.split("\n")) {
-      for (const cat of categories) {
-        const prefix = `- ${cat}: `;
-        if (!line.startsWith(prefix)) continue;
-        let rest = line.slice(prefix.length);
-        // Strip "(+N more)" suffix
-        rest = rest.replace(/\s*\(\+\d+ more\)\s*$/, "");
-        for (const p of rest.split(",")) {
-          const trimmed = p.trim();
-          if (trimmed) merged[cat].add(trimmed);
-        }
+      const head = /^- (Modified|Created|Read)(.*)$/.exec(line);
+      // "- Modified" without one of the three tails is a bare count or
+      // malformed: flush any pending accumulation and ignore.
+      if (head && (categories as readonly string[]).includes(head[1])) {
+        flush();
+        const parsed = parseHead(head[1], head[2]);
+        if (parsed) current = { cat: head[1], prefix: parsed.prefix, rest: parsed.rest };
+        continue;
+      }
+      if (current && /^\s+\S/.test(line)) {
+        const cont = line.trim();
+        if (current.rest.endsWith("\\")) current.rest = current.rest.slice(0, -1) + cont;
+        else current.rest += " " + cont;
+      } else {
+        flush();
       }
     }
+    flush();
   }
 
   // Dedup: if already in Modified, drop from Created (file existed before)
   for (const p of merged.Modified) merged.Created.delete(p);
 
-  const cap = (set: Set<string>, limit: number) => {
-    const arr = [...set];
-    if (arr.length <= limit) return arr.join(", ");
-    return arr.slice(0, limit).join(", ") + ` (+${arr.length - limit} more)`;
-  };
-
+  // Display shares the fresh path's renderer (flat + grouped overflow +
+  // honest bare count). Prefix derivation is display-only: the merged set
+  // always holds full paths, so form flips never corrupt.
   const lines: string[] = [];
-  if (merged.Modified.size > 0) lines.push(`- Modified: ${cap(merged.Modified, 10)}`);
-  if (merged.Created.size > 0) lines.push(`- Created: ${cap(merged.Created, 10)}`);
-  if (merged.Read.size > 0) lines.push(`- Read: ${cap(merged.Read, 10)}`);
+  for (const cat of categories) {
+    if (merged[cat].size === 0) continue;
+    for (const line of renderFileCategoryLines(cat, [...merged[cat]])) {
+      lines.push(`- ${line}`);
+    }
+  }
   if (lines.length === 0) return "";
   return `[Files And Changes]\n${lines.join("\n")}`;
 };
@@ -183,7 +253,7 @@ const compileWithBriefBlocks = (input: CompileInput, options: CompileWithBriefBl
     : undefined;
   const merged = prev ? mergePrevious(prev, fresh, { preserveFreshBrief: options.preserveFreshBriefOnMerge }) : fresh;
   if (!merged) return "";
-  return wrapLongLines(merged + SEPARATOR + RECALL_NOTE);
+  return wrapLongLines(merged) + SEPARATOR + RECALL_NOTE;
 };
 
 export const compile = (input: CompileInput): string =>
@@ -199,10 +269,15 @@ export const compileRanked = (input: RankedCompileInput): string =>
     preserveFreshBriefOnMerge: true,
   });
 
+const escapeRegExp = (s: string): string => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+
+const RECALL_NOTE_PATTERN = new RegExp(RECALL_NOTE.split(" ").map(escapeRegExp).join("\\s+"));
+
 const stripRecallNote = (text: string): string => {
   // Remove trailing RECALL_NOTE (and any separators surrounding it) if present.
-  // Handles both current format (---\n\nNOTE) and bare trailing NOTE.
-  const idx = text.lastIndexOf(RECALL_NOTE);
-  if (idx < 0) return text;
-  return text.slice(0, idx).replace(/\s*(?:\n\n---\n\n)?\s*$/, "").trimEnd();
+  // Whitespace-insensitive: matches the current single-line format, a bare
+  // trailing note, and legacy copies wrapped mid-sentence by wrapLongLines.
+  const match = RECALL_NOTE_PATTERN.exec(text);
+  if (!match || match.index < 0) return text;
+  return text.slice(0, match.index).replace(/\s*(?:\n\n---\n\n)?\s*$/, "").trimEnd();
 };

package/extensions/vcc-core/core/token-estimate.ts

@@ -19,6 +19,7 @@ const clamp = (value: number, min: number, max: number): number =>
 export const calibrateCharsPerToken = (
   sourceChars: number,
   sourceTokens: number | undefined,
+  sampleText?: string,
 ): TokenEstimateCalibration => {
   if (!sourceTokens || sourceTokens <= 0 || sourceChars <= 0) {
     return { mode: "heuristic", charsPerToken: DEFAULT_CHARS_PER_TOKEN };
@@ -29,6 +30,24 @@ export const calibrateCharsPerToken = (
     return { mode: "heuristic", charsPerToken: DEFAULT_CHARS_PER_TOKEN };
   }
 
+  // Slice/tokens mismatch guards (see hook calibration site): sourceChars
+  // covers the summarized slice while sourceTokens often counts the full
+  // context (plus per-message overhead), so raw is systematically <= truth
+  // for Latin text — trusting it inflates every token estimate and the
+  // pipeline over-trims. Conversely a high raw on CJK text means the token
+  // count under-describes the slice. When the ratio contradicts the
+  // content-class prior, fall back to that prior (reported as heuristic).
+  if (sampleText) {
+    const cjkChars = (sampleText.match(/[\u2E80-\u9FFF\uAC00-\uD7FF\u3000-\u303F]/g) ?? []).length;
+    const cjk = sampleText.length > 0 && cjkChars / sampleText.length >= 0.2;
+    if (!cjk && rawCharsPerToken < 2.5) {
+      return { mode: "heuristic", charsPerToken: DEFAULT_CHARS_PER_TOKEN, sourceChars, sourceTokens, rawCharsPerToken };
+    }
+    if (cjk && rawCharsPerToken > 3) {
+      return { mode: "heuristic", charsPerToken: MIN_CHARS_PER_TOKEN, sourceChars, sourceTokens, rawCharsPerToken };
+    }
+  }
+
   return {
     mode: "calibrated",
     charsPerToken: clamp(rawCharsPerToken, MIN_CHARS_PER_TOKEN, MAX_CHARS_PER_TOKEN),
@@ -130,6 +149,21 @@ export const collectUsageStats = (messages: any[]): UsageStats => {
   let outputChars = 0;
   let minTs = Infinity;
   let maxTs = -Infinity;
+  // Bounded content sample for the calibration slice/tokens guards
+  // (classification only needs a fraction of the text).
+  let sample = "";
+  const takeSample = (text: unknown) => {
+    if (sample.length >= 8000 || typeof text !== "string" || !text) return;
+    sample += (sample ? "\n" : "") + text.slice(0, 8000 - sample.length);
+  };
+  const sampleParts = (content: unknown) => {
+    if (typeof content === "string") takeSample(content);
+    else if (Array.isArray(content)) {
+      for (const part of content) {
+        if (part?.type === "text" && typeof part.text === "string") takeSample(part.text);
+      }
+    }
+  };
   const usageTotals = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
   let sawUsage = false;
   for (const m of messages ?? []) {
@@ -149,19 +183,23 @@ export const collectUsageStats = (messages: any[]): UsageStats => {
     }
     if (role === "assistant") {
       outputChars += estimateMessageContentChars(m?.content);
+      sampleParts(m?.content);
       if (Array.isArray(m?.content)) {
         for (const part of m.content) if (part?.type === "toolCall") toolCallCount++;
       }
     } else if (role === "bashExecution") {
       inputChars += (typeof m?.command === "string" ? m.command.length : 0) + 1
         + (typeof m?.output === "string" ? m.output.length : 0);
+      takeSample(m?.command);
+      takeSample(m?.output);
     } else {
       inputChars += estimateMessageContentChars(m?.content);
+      sampleParts(m?.content);
     }
   }
   const totalChars = inputChars + outputChars;
   const sourceTokens = sawUsage ? usageTotals.input + usageTotals.output : undefined;
-  const calibration = calibrateCharsPerToken(totalChars, sourceTokens);
+  const calibration = calibrateCharsPerToken(totalChars, sourceTokens, sample || undefined);
   return {
     messageCount: messages?.length ?? 0,
     byRole,

package/extensions/vcc-core/extract/files.ts

@@ -31,8 +31,10 @@ const matches = (tools: Set<string>, name: string): boolean => tools.has(name.to
 /**
  * Find the longest common directory prefix among absolute paths.
  * Returns "" if fewer than 2 absolute paths or no meaningful common prefix.
+ * Shared with core/summarize.ts, which re-derives one prefix per merge so
+ * prev-cycle and fresh paths keep a consistent display form.
  */
-const longestCommonDirPrefix = (paths: string[]): string => {
+export const longestCommonDirPrefix = (paths: string[]): string => {
   const abs = paths.filter((p) => p.startsWith("/"));
   if (abs.length < 2) return "";
   const split = abs.map((p) => p.split("/"));
@@ -47,15 +49,6 @@ const longestCommonDirPrefix = (paths: string[]): string => {
   return split[0].slice(0, i).join("/") + "/";
 };
 
-const trimPaths = (set: Set<string>, prefix: string): Set<string> => {
-  if (!prefix) return set;
-  const out = new Set<string>();
-  for (const p of set) {
-    out.add(p.startsWith(prefix) ? p.slice(prefix.length) : p);
-  }
-  return out;
-};
-
 export const extractFiles = (
   blocks: NormalizedBlock[],
   fileOps?: FileOps,
@@ -76,13 +69,47 @@ export const extractFiles = (
     if (matches(FILE_CREATE_TOOLS, b.name)) act.created.add(p);
   }
 
-  const all = [...act.read, ...act.modified, ...act.created];
-  const prefix = longestCommonDirPrefix(all);
-  if (prefix) {
-    act.read = trimPaths(act.read, prefix);
-    act.modified = trimPaths(act.modified, prefix);
-    act.created = trimPaths(act.created, prefix);
-  }
-
+  // Full paths are carried verbatim: per-cycle prefix trimming made prev-cycle
+  // and fresh paths unresolvable when mixed. Display collapse happens in
+  // renderFileCategoryLines below, re-derived every render for consistency.
   return act;
 };
+
+/** Exact file paths shown flat per category; further named paths spill into
+ * per-directory overflow groups up to FILE_CATEGORY_TOTAL_CAP. */
+export const FILE_CATEGORY_DISPLAY_CAP = 20;
+/** Max NAMED file paths per category (flat + grouped overflow). Past this,
+ * excess degrades to a bare honest (+N more) count. */
+export const FILE_CATEGORY_TOTAL_CAP = 100;
+
+/**
+ * Render one Files-And-Changes category (lines WITHOUT the "- " bullet;
+ * callers add it or route through section()). Shared by the fresh path
+ * (build-sections) and the merge path (mergeFileLines) so both carry the
+ * same lossless overflow forms:
+ *   `Modified: a, b` / `Modified (in /prefix/): a, b` (flat, prefix-collapsed)
+ *   `Modified (+2 more under /d/): b1, b2`            (grouped overflow)
+ *   `Modified (+5 more)`                              (honest bare count)
+ */
+export const renderFileCategoryLines = (cat: string, paths: string[]): string[] => {
+  if (paths.length === 0) return [];
+  const prefix = longestCommonDirPrefix(paths);
+  const strip = (p: string) => (prefix && p.startsWith(prefix) ? p.slice(prefix.length) : p);
+  const flat = paths.slice(0, FILE_CATEGORY_DISPLAY_CAP).map(strip);
+  const lines = [prefix ? `${cat} (in ${prefix}): ${flat.join(", ")}` : `${cat}: ${flat.join(", ")}`];
+  const overflow = paths.slice(FILE_CATEGORY_DISPLAY_CAP, FILE_CATEGORY_TOTAL_CAP);
+  const groups = new Map<string, string[]>();
+  for (const p of overflow) {
+    const dir = p.includes("/") ? p.slice(0, p.lastIndexOf("/") + 1) : "";
+    const base = dir ? p.slice(dir.length) : p;
+    const list = groups.get(dir) ?? [];
+    list.push(base);
+    groups.set(dir, list);
+  }
+  for (const [dir, bases] of groups) {
+    lines.push(`${cat} (+${bases.length} more${dir ? ` under ${dir}` : ""}): ${bases.join(", ")}`);
+  }
+  const dropped = paths.length - FILE_CATEGORY_DISPLAY_CAP - overflow.length;
+  if (dropped > 0) lines.push(`${cat} (+${dropped} more)`);
+  return lines;
+};

package/extensions/vcc-core/hook.ts

@@ -4,7 +4,7 @@ import { createRequire } from "node:module";
 import { writeFileSync } from "fs";
 import { compileRanked } from "./core/summarize";
 import { buildPiVccCustomInstructions, parseKeepAndPrompt, PI_VCC_COMPACT_INSTRUCTION } from "./core/compact-args";
-import { loadSettings, type PiVccSettings } from "./core/settings";
+import { loadSettings, loadSettingsWithSources, DEFAULT_SETTINGS, type PiVccSettings, type VccConfigView } from "./core/settings";
 import { calibrateCharsPerToken, estimateMessageContentChars, estimateMessageContentTokens, estimateTokensFromChars, collectUsageStats } from "./core/token-estimate";
 import type { PiVccCompactionDetails } from "./details";
 import type { CompactionReason } from "./types";
@@ -432,7 +432,7 @@ export type OwnCutResult =
     }
   | { ok: false; reason: OwnCutCancelReason };
 
-const collectLiveMessages = (branchEntries: any[]): EntryWithMessage[] => {
+export const collectLiveMessages = (branchEntries: any[]): EntryWithMessage[] => {
   // Find the last compaction entry and its firstKeptEntryId
   let lastCompactionIdx = -1;
   let lastKeptId: string | undefined;
@@ -499,7 +499,7 @@ const collectLiveMessages = (branchEntries: any[]): EntryWithMessage[] => {
   return liveMessages;
 };
 
-export function buildOwnCut(branchEntries: any[], keepUserTurns = 1): OwnCutResult {
+export function buildOwnCut(branchEntries: any[], keepUserTurns = 1, explicitKeep = false): OwnCutResult {
   const normalizedKeepUserTurns = normalizeKeepUserTurns(keepUserTurns);
   const liveMessages = collectLiveMessages(branchEntries);
 
@@ -528,13 +528,29 @@ export function buildOwnCut(branchEntries: any[], keepUserTurns = 1): OwnCutResu
   const cutIdx = targetUserIdx >= 0 ? userIndices[targetUserIdx] : -1;
 
   if (cutIdx <= 0) {
-    // Keep request cannot form a safe boundary (single user prompt, no user prompt,
-    // or keep larger than available user turns), so compact EVERYTHING and keep no tail.
+    // Explicit keep covering every user turn: keep the whole tail instead of
+    // compacting it away. Only the prefix before the first user turn (when
+    // any) is summarized. Default-path cuts and no-user-message sessions keep
+    // the old compact-all fallback so auto-compaction still makes progress
+    // (single-prompt + autonomous tail) and explicit compacts in autonomous
+    // sessions still do something.
+    if (explicitKeep && userIndices.length > 0) {
+      const firstUserIdx = userIndices[0];
+      return {
+        ok: true,
+        messages: liveMessages.slice(0, firstUserIdx).map((e) => e.message),
+        firstKeptEntryId: liveMessages[firstUserIdx].entry.id,
+        compactAll: false,
+        keptUserTurns: userIndices.length,
+        totalUserTurns: userIndices.length,
+        requestedKeepUserTurns: normalizedKeepUserTurns,
+        keepFallbackToCompactAll: false,
+      };
+    }
     // firstKeptEntryId="" is a sentinel: pi-core's buildSessionContext won't match it
     // (so 0 kept from pre-compaction), and next buildOwnCut triggers orphan recovery.
     return compactAll(true);
   }
-
   return {
     ok: true,
     messages: liveMessages.slice(0, cutIdx).map((e) => e.message),
@@ -652,12 +668,18 @@ export interface ResolveSmartKeepResult {
  */
 const tailTokensForKeep = (branchEntries: any[], keepUserTurns: number, charsPerToken?: number): number | null => {
   const cut = buildOwnCut(branchEntries, keepUserTurns);
-  if (!cut.ok || cut.compactAll) return null;
-  const idx = branchEntries.findIndex((e: any) => e.id === cut.firstKeptEntryId);
-  if (idx < 0) return null;
-  const kept = branchEntries.slice(idx).filter((e: any) => e.type === "message");
-  const chars = kept.reduce(
-    (sum: number, e: any) => sum + estimateMessageContentChars(e.message?.content),
+  // Null when keep would trigger compact-all, cancel, or summarize nothing
+  // (keep-all cut with an empty prefix): the resolver stops growing instead
+  // of selecting a value that discards the tail or compacts nothing new.
+  if (!cut.ok || cut.compactAll || cut.messages.length === 0) return null;
+  // Measure over the live window (message + custom_message/branch_summary via
+  // toLiveMessage), not branchEntries filtered to type === "message": custom
+  // tails otherwise undercount and smart-keep over-grows (under-compaction).
+  const live = collectLiveMessages(branchEntries);
+  const keptIdx = live.findIndex((e) => e.entry.id === cut.firstKeptEntryId);
+  if (keptIdx < 0) return null;
+  const chars = live.slice(keptIdx).reduce(
+    (sum: number, e) => sum + estimateMessageContentChars(e.message?.content),
     0,
   );
   return estimateTokensFromChars(chars, charsPerToken);
@@ -755,9 +777,20 @@ export const registerBeforeCompactHook = (pi: ExtensionAPI) => {
     const calibrationSummaryChars = typeof preparation.previousSummary === "string"
       ? preparation.previousSummary.length
       : 0;
+    // Content sample for the slice/tokens mismatch guards: slice text when the
+    // calibration cut has any, else the previous summary. Bounded (first 50
+    // string contents, 8k chars) — classification only needs a fraction.
+    const calibrationSample = calibrationCut.ok
+      ? calibrationCut.messages
+          .slice(0, 50)
+          .map((message: any) => (typeof message.content === "string" ? message.content : ""))
+          .join("\n")
+          .slice(0, 8000)
+      : "";
     const tokenEstimate = calibrateCharsPerToken(
       calibrationMessageChars + calibrationSummaryChars,
       preparation.tokensBefore,
+      calibrationSample || (typeof preparation.previousSummary === "string" ? preparation.previousSummary.slice(0, 8000) : undefined),
     );
 
     // Smart keep-tail: boost default keep when the tail is small.
@@ -769,7 +802,7 @@ export const registerBeforeCompactHook = (pi: ExtensionAPI) => {
       smartKeepTail: settings.smartKeepTail,
       charsPerToken: tokenEstimate.charsPerToken,
     });
-    let ownCut = buildOwnCut(branchEntries as any[], smartKeep.keepUserTurns);
+    let ownCut = buildOwnCut(branchEntries as any[], smartKeep.keepUserTurns, keepUserTurnsExplicit);
     // Default path only: rescue autonomous / oversized-tail sessions with a
     // token-budget cut. Explicit keep:N is respected absolutely (no-op here).
     if (ownCut.ok && !keepUserTurnsExplicit) {
@@ -921,6 +954,17 @@ export const registerBeforeCompactHook = (pi: ExtensionAPI) => {
       },
     });
 
+    // Keep-all cut with an empty prefix and no previous summary yields nothing
+    // new to summarize. Never hand the host an empty summary — cancel and keep
+    // the session intact. (A non-empty prefix that compiles to "" falls through
+    // with the pre-existing behavior; custom-only prefixes carry no sections.)
+    if (!summary && agentMessages.length === 0) {
+      try {
+        ctx?.ui?.notify?.("omp-vcc: Nothing new to compact (keep covers all turns)", "info");
+      } catch {}
+      return { cancel: true };
+    }
+
     const tokensBefore = typeof preparation.tokensBefore === "number" ? preparation.tokensBefore : 0;
     const summaryChars = summary.length;
     const summaryTokensEst = estimateTokensFromChars(summaryChars, tokenEstimate.charsPerToken);
@@ -1332,4 +1376,31 @@ export const registerVccStatsCommand = (pi: any) => {
     try { ctx?.ui?.notify?.(`vcc_stats: ${history.length} compaction(s)`, "info"); } catch {}
   };
   pi.registerCommand("vcc-stats", { description: "Show omp-vcc compaction savings (last + history)", handler });
+};
+// ── /vcc-config command — show effective configuration with per-key source ──
+export const formatVccConfigCard = (view: VccConfigView): string => {
+  const header = `**omp-vcc config** (\`${view.path}\`)`;
+  const status = !view.filePresent
+    ? "No config file found — showing defaults."
+    : !view.fileValid
+      ? "Config file unparseable — showing defaults."
+      : view.readPath === view.path
+        ? `Source: file ${view.readPath}`
+        : `Source: fallback file ${view.readPath}`;
+  const lines = (Object.keys(DEFAULT_SETTINGS) as (keyof PiVccSettings)[]).map(
+    (k) => `- ${k}: ${view.values[k] ? "on" : "off"} (${view.sources[k] === "overlay" ? "host overlay" : view.sources[k]})`,
+  );
+  return [header, status, ...lines].join("\n");
+};
+
+export const registerVccConfigCommand = (pi: any) => {
+  const handler = async (_args: string, ctx: any) => {
+    // args deliberately ignored — always show the effective config
+    const view = loadSettingsWithSources(ctx);
+    const output = formatVccConfigCard(view);
+    const piAny = pi as unknown as { sendMessage?: (msg: unknown, opts?: unknown) => void };
+    try { piAny.sendMessage?.({ customType: "vcc-config", content: output, display: true }, { triggerTurn: false }); } catch {}
+    try { ctx?.ui?.notify?.(`vcc_config: ${Object.keys(view.values).length} keys from ${view.readPath ?? "defaults"}`, "info"); } catch {}
+  };
+  pi.registerCommand("vcc-config", { description: "Show omp-vcc effective configuration with per-key source", handler });
 };

package/extensions/vcc-core/types.ts

@@ -12,6 +12,7 @@ export interface FileOps {
 export type NormalizedBlock =
   | { kind: "user"; text: string; sourceIndex?: number }
   | { kind: "assistant"; text: string; sourceIndex?: number }
+  | { kind: "custom"; text: string; sourceIndex?: number }
   | { kind: "thinking"; text: string; sourceIndex?: number }
   | { kind: "tool_call"; name: string; args: Record<string, unknown>; sourceIndex?: number }
   | { kind: "tool_result"; name: string; text: string; sourceIndex?: number }

package/package.json

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

package/scripts/smoke.ts

@@ -75,6 +75,10 @@ try {
     "vcc-stats command registered",
     commands.some((c) => c.name === "vcc-stats"),
   );
+  check(
+    "vcc-config command registered",
+    commands.some((c) => c.name === "vcc-config"),
+  );
   check(
     "no omp-vcc-stats duplicate",
     !commands.some((c) => c.name === "omp-vcc-stats"),

package/skills/omp-vcc/SKILL.md

@@ -49,6 +49,7 @@ Use `vcc_recall` to search for prior work … Do not redo work already completed
 | 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. |
+| **View config** | `/vcc-config` | Effective config with per-key source (`file` / `host overlay` / `default`) plus resolved file path. Args ignored. Use to confirm a `/settings` toggle took effect. |
 | **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. |