omp-vcc 0.1.0

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

@@ -0,0 +1,151 @@
+// @ts-nocheck
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { dirname, join } from "path";
+
+// omp-vcc: XDG-aware config path, mirrored from pi-vcc but under ~/.omp
+// Priorities: $OMP_VCC_CONFIG_PATH > $PI_VCC_CONFIG_PATH (legacy) > ~/.omp/omp-vcc/config.json
+// Also respects $PI_CODING_AGENT_DIR / $OMP_DIR if set (oh-my-pi base dir)
+const defaultBase = process.env.OMP_DIR ?? process.env.PI_CODING_AGENT_DIR ?? join(homedir(), ".omp");
+export const SETTINGS_PATH_DEFAULT = join(defaultBase, "omp-vcc", "config.json");
+const legacyPiPath = join(homedir(), ".pi", "agent", "pi-vcc-config.json");
+const settingsPath = (): string =>
+  process.env.OMP_VCC_CONFIG_PATH ??
+  process.env.PI_VCC_CONFIG_PATH ??
+  SETTINGS_PATH_DEFAULT;
+/** Backwards-compat export. Resolves at access time, not import time. */
+export const SETTINGS_PATH = settingsPath();
+// For migration: if omp config missing but legacy pi config exists, we read legacy but write to new
+const fallbackReadPath = (): string | null => {
+  const primary = settingsPath();
+  if (existsSync(primary)) return primary;
+  if (existsSync(legacyPiPath)) return legacyPiPath;
+  return null;
+};
+
+export interface PiVccSettings {
+  /** Master switch for omp-vcc — when false, no compaction interception occurs */
+  vccEnabled: boolean;
+  /**
+   * When true (default), pi-vcc handles ALL compactions:
+   *   - /compact (no args)
+   *   - /compact <text>
+   *   - auto threshold / overflow
+   *   - /pi-vcc (always handled regardless)
+   *
+   * When false, pi-vcc only handles /pi-vcc; everything else falls back to
+   * pi core's default LLM-based compaction. Existing config files keep their
+   * stored value; the new default applies to fresh installs only.
+   */
+  overrideDefaultCompaction: boolean;
+  /**
+   * When true (default), pi-vcc boosts the default keep-tail when the current
+   * keep:1 tail is small enough. Specifically: if the estimated tail for keep:1
+   * is <= MIN_SMART_TAIL_TOKENS (5k), increase keep up to the largest N whose
+   * tail stays <= MAX_SMART_TAIL_TOKENS (25k). Explicit `keep:N` from the user
+   * is always respected and never adjusted.
+   */
+  smartKeepTail: boolean;
+  /**
+   * When true (default), pi-vcc asks the agent to continue after a successful
+   * automatic compaction (threshold, or overflow after the assistant already
+   * finished with stop). This avoids a UX cliff where the agent finishes a response,
+   * immediately compacts, and then stops instead of continuing the task.
+   * Overflow retry is still owned by pi-core via willRetry.
+   */
+  continueAfterThresholdCompact: boolean;
+  /** Write debug snapshot to /tmp/omp-vcc-debug.json on each compaction. */
+  debug: boolean;
+}
+
+export const DEFAULT_SETTINGS: PiVccSettings = {
+  vccEnabled: true,
+  overrideDefaultCompaction: true,
+  smartKeepTail: true,
+  continueAfterThresholdCompact: true,
+  debug: false,
+};
+
+const readJson = (path: string): Record<string, unknown> | null => {
+  try {
+    return JSON.parse(readFileSync(path, "utf-8"));
+  } catch {
+    return null;
+  }
+};
+
+export function loadSettings(ctx?: unknown): PiVccSettings {
+  // File is source of truth, but if the host provides plugin-scoped settings
+  // via ctx.settings (omp manifest `omp.settings` / `pi.settings` UI surface),
+  // merge them on top of file so /settings toggles take effect without restart.
+  // Host shapes vary: ctx.settings.get(key), ctx.config.get(key), or plain map.
+  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;
+  };
+  const file = (() => {
+    const primary = settingsPath();
+    const parsed = readJson(primary) ?? (() => {
+      const fb = fallbackReadPath();
+      return fb && fb !== primary ? readJson(fb) : null;
+    })();
+    if (!parsed || typeof parsed !== "object") return { ...DEFAULT_SETTINGS };
+    return { ...DEFAULT_SETTINGS, ...(parsed as Partial<PiVccSettings>) };
+  })();
+  if (!ctx) return file;
+  // Overlay plugin-scoped keys if host exposes them (e.g. plugins["@zhulinchng/omp-vcc"].vccEnabled)
+  const overlay: Partial<PiVccSettings> = {};
+  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) (overlay as any)[k] = v;
+  }
+  return Object.keys(overlay).length ? { ...file, ...overlay } : file;
+}
+
+/**
+ * Ensure ~/.omp/omp-vcc/config.json exists with default keys (migrates legacy pi path read).
+ * - File missing → create with full default block.
+ * - File exists but invalid JSON → no-op (don't clobber user file).
+ * - File exists and valid → fill in missing default keys, preserve existing values.
+ */
+export function scaffoldSettings(): void {
+  try {
+    const path = settingsPath();
+    const dir = dirname(path);
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+
+    if (!existsSync(path)) {
+      // migrate legacy pi-vcc config if present before creating fresh
+      const legacy = existsSync(legacyPiPath) ? readJson(legacyPiPath) : null;
+      if (legacy && typeof legacy === "object") {
+        const migrated = { ...DEFAULT_SETTINGS, ...(legacy as Partial<PiVccSettings>) };
+        writeFileSync(path, `${JSON.stringify(migrated, null, 2)}\n`);
+        return;
+      }
+      writeFileSync(path, `${JSON.stringify(DEFAULT_SETTINGS, null, 2)}\n`);
+      return;
+    }
+
+    const parsed = readJson(path);
+    if (!parsed || typeof parsed !== "object") return; // don't clobber
+
+    let changed = false;
+    const next: Record<string, unknown> = { ...parsed };
+    for (const [key, value] of Object.entries(DEFAULT_SETTINGS)) {
+      if (!(key in next)) {
+        next[key] = value;
+        changed = true;
+      }
+    }
+    if (changed) writeFileSync(path, `${JSON.stringify(next, null, 2)}\n`);
+  } catch {
+    // best-effort; never crash extension load
+  }
+}

package/extensions/vcc-core/core/skill-collapse.ts

@@ -0,0 +1,36 @@
+// @ts-nocheck
+/** Shared skill-tag collapse utilities */
+
+const SKILL_TAG_RE = /^-?\s*<skill\s+name="([^"]+)"/;
+const SKILL_CLOSE_RE = /^-?\s*<\/skill>/;
+
+/** Collapse skill tags in an array of lines — dedup by name, drop all content inside block */
+export const collapseSkillLines = (lines: string[]): string[] => {
+  const result: string[] = [];
+  const seenSkills = new Set<string>();
+  let insideSkill = false;
+
+  for (const line of lines) {
+    const skillMatch = line.match(SKILL_TAG_RE);
+    if (skillMatch) {
+      insideSkill = true;
+      const name = skillMatch[1];
+      if (!seenSkills.has(name)) {
+        seenSkills.add(name);
+        result.push(`[skill: ${name}]`);
+      }
+      continue;
+    }
+    if (insideSkill) {
+      if (SKILL_CLOSE_RE.test(line)) insideSkill = false;
+      continue;
+    }
+    result.push(line);
+  }
+  return result;
+};
+
+/** Collapse <skill name="X" ...>...</skill> blocks in raw text */
+const SKILL_BLOCK_RE = /<skill\s+name="([^"]+)"[^>]*>[\s\S]*?(?:<\/skill>|$)/g;
+export const collapseSkillText = (text: string): string =>
+  text.replace(SKILL_BLOCK_RE, (_, name) => `[skill: ${name}]`);

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

@@ -0,0 +1,208 @@
+// @ts-nocheck
+import type { Message } from "@oh-my-pi/pi-ai";
+import type { FileOps } from "../types";
+import { normalize } from "./normalize";
+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";
+
+export interface CompileInput {
+  messages: Message[];
+  previousSummary?: string;
+  fileOps?: FileOps;
+}
+
+export interface RankedCompileInput extends CompileInput {
+  ranking?: BriefRankingOptions;
+}
+
+const HEADER_NAMES = ["Session Goal", "Files And Changes", "Commits", "Outstanding Context", "User Preferences"];
+
+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
+  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];
+  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();
+};
+
+/** 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
+  if (header === "Files And Changes") {
+    return mergeFileLines(prev, fresh);
+  }
+
+  // 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 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
+  for (const text of [prev, fresh]) {
+    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);
+        }
+      }
+    }
+  }
+
+  // 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)`;
+  };
+
+  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)}`);
+  if (lines.length === 0) return "";
+  return `[Files And Changes]\n${lines.join("\n")}`;
+};
+
+const mergeBriefTranscript = (prev: string, fresh: string): string => {
+  if (!prev) return fresh;
+  if (!fresh) return prev;
+  return prev + "\n\n" + fresh;
+};
+
+const briefLineCount = (text: string): number =>
+  text ? text.split("\n").length : 0;
+
+const capBriefToLineBudget = (text: string, maxLines: number): string => {
+  if (!text || maxLines <= 0) return "";
+  const lines = text.split("\n");
+  if (lines.length <= maxLines) return text;
+  const kept = lines.slice(-maxLines);
+  const firstHeader = kept.findIndex((l) => /^\[.+\]/.test(l));
+  const clean = firstHeader > 0 ? kept.slice(firstHeader) : kept;
+  const omitted = lines.length - clean.length;
+  return `...(${omitted} earlier lines omitted)\n\n${clean.join("\n")}`;
+};
+
+const mergeBriefTranscriptWithFreshBudget = (prev: string, fresh: string): string => {
+  if (!prev) return fresh;
+  if (!fresh) return capBrief(prev);
+  const freshLines = briefLineCount(fresh);
+  const remainingPrevLines = Math.max(0, BRIEF_MAX_LINES - freshLines);
+  const prevTail = capBriefToLineBudget(prev, remainingPrevLines);
+  return prevTail ? `${prevTail}\n\n${fresh}` : fresh;
+};
+
+const mergePrevious = (prev: string, fresh: string, options: { preserveFreshBrief?: boolean } = {}): string => {
+  // Merge header sections
+  const headers = HEADER_NAMES
+    .map((header) => {
+      const freshSec = sectionOf(fresh, header);
+      const prevSec = sectionOf(prev, header);
+      return mergeHeaderSection(header, prevSec, freshSec);
+    })
+    .filter(Boolean);
+
+  // Merge brief transcript
+  const prevBrief = briefOf(prev);
+  const freshBrief = briefOf(fresh);
+  const mergedBrief = options.preserveFreshBrief
+    ? mergeBriefTranscriptWithFreshBudget(prevBrief, freshBrief)
+    : mergeBriefTranscript(prevBrief, freshBrief);
+
+  const parts: string[] = [];
+  if (headers.length > 0) {
+    parts.push(headers.join("\n\n"));
+  }
+  if (mergedBrief) {
+    parts.push(options.preserveFreshBrief ? mergedBrief : capBrief(mergedBrief));
+  }
+
+  return parts.join(SEPARATOR);
+};
+
+interface CompileWithBriefBlocksOptions {
+  briefBlocksFor?: (blocks: ReturnType<typeof normalize>) => ReturnType<typeof normalize>;
+  capFreshBrief?: boolean;
+  preserveFreshBriefOnMerge?: boolean;
+}
+
+const compileWithBriefBlocks = (input: CompileInput, options: CompileWithBriefBlocksOptions = {}): string => {
+  const blocks = filterNoise(normalize(input.messages));
+  const briefBlocks = options.briefBlocksFor?.(blocks);
+  const data = buildSections({ blocks, briefBlocks, fileOps: input.fileOps });
+  const fresh = formatSummary(data, { capBriefTranscript: options.capFreshBrief ?? true });
+  // Strip any legacy RECALL_NOTE baked into prev summary (pre-fix format)
+  // so merge doesn't re-stack it inside the brief.
+  const prev = input.previousSummary
+    ? stripRecallNote(input.previousSummary)
+    : undefined;
+  const merged = prev ? mergePrevious(prev, fresh, { preserveFreshBrief: options.preserveFreshBriefOnMerge }) : fresh;
+  if (!merged) return "";
+  return wrapLongLines(merged + SEPARATOR + RECALL_NOTE);
+};
+
+export const compile = (input: CompileInput): string =>
+  compileWithBriefBlocks(input);
+
+export const compileRanked = (input: RankedCompileInput): string =>
+  compileWithBriefBlocks(input, {
+    briefBlocksFor: (blocks) => selectRankedBriefBlocks(blocks, {
+      ...input.ranking,
+      fileOps: input.ranking?.fileOps ?? input.fileOps,
+    }),
+    capFreshBrief: false,
+    preserveFreshBriefOnMerge: true,
+  });
+
+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();
+};

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

@@ -0,0 +1,101 @@
+// @ts-nocheck
+export const DEFAULT_CHARS_PER_TOKEN = 4;
+export const MIN_CHARS_PER_TOKEN = 2;
+export const MAX_CHARS_PER_TOKEN = 6;
+
+export type TokenEstimateMode = "heuristic" | "calibrated";
+
+export interface TokenEstimateCalibration {
+  mode: TokenEstimateMode;
+  charsPerToken: number;
+  sourceChars?: number;
+  sourceTokens?: number;
+  rawCharsPerToken?: number;
+}
+
+const clamp = (value: number, min: number, max: number): number =>
+  Math.min(max, Math.max(min, value));
+
+export const calibrateCharsPerToken = (
+  sourceChars: number,
+  sourceTokens: number | undefined,
+): TokenEstimateCalibration => {
+  if (!sourceTokens || sourceTokens <= 0 || sourceChars <= 0) {
+    return { mode: "heuristic", charsPerToken: DEFAULT_CHARS_PER_TOKEN };
+  }
+
+  const rawCharsPerToken = sourceChars / sourceTokens;
+  if (!Number.isFinite(rawCharsPerToken) || rawCharsPerToken <= 0) {
+    return { mode: "heuristic", charsPerToken: DEFAULT_CHARS_PER_TOKEN };
+  }
+
+  return {
+    mode: "calibrated",
+    charsPerToken: clamp(rawCharsPerToken, MIN_CHARS_PER_TOKEN, MAX_CHARS_PER_TOKEN),
+    sourceChars,
+    sourceTokens,
+    rawCharsPerToken,
+  };
+};
+
+export const estimateTokensFromChars = (
+  chars: number,
+  charsPerToken = DEFAULT_CHARS_PER_TOKEN,
+): number => Math.ceil(chars / charsPerToken);
+
+/**
+ * Chars attributed to one image part, mirroring pi-agent-core's own
+ * estimateTokens heuristic (4800 chars ≈ 1200 tokens at 4 chars/token).
+ */
+export const IMAGE_CONTENT_CHARS = 4800;
+
+const safeJsonStringify = (value: unknown): string => {
+  try {
+    return JSON.stringify(value ?? "") ?? "";
+  } catch {
+    return "";
+  }
+};
+
+/**
+ * Estimate the char length of a message's content (string or content-parts
+ * array). Counts every token-bearing part that pi-agent-core's harness
+ * estimateTokens counts, so the calibrated chars/token ratio is not deflated:
+ *  - text       → text.length
+ *  - thinking   → thinking.length   (opus emits large reasoning blocks)
+ *  - toolCall   → name + arguments  (Pi uses `arguments`; `input` kept for compat)
+ *  - image      → IMAGE_CONTENT_CHARS
+ *  - toolResult → nested content    (legacy part shape)
+ */
+export const estimateMessageContentChars = (content: unknown): number => {
+  if (typeof content === "string") return content.length;
+  if (!Array.isArray(content)) return 0;
+  return content.reduce((sum: number, part: any) => {
+    if (!part || typeof part !== "object") return sum;
+    switch (part.type) {
+      case "text":
+        return sum + (typeof part.text === "string" ? part.text.length : 0);
+      case "thinking":
+        return sum + (typeof part.thinking === "string" ? part.thinking.length : 0);
+      case "toolCall": {
+        const args = part.arguments ?? part.input;
+        const argLength = typeof args === "string" ? args.length : safeJsonStringify(args).length;
+        return sum + (part.name?.length ?? 0) + argLength;
+      }
+      case "toolResult": {
+        const c = part.content;
+        return sum + (typeof c === "string" ? c.length : safeJsonStringify(c).length);
+      }
+      case "image":
+        return sum + IMAGE_CONTENT_CHARS;
+      default:
+        // Unknown part: fall back to any text field so we never undercount.
+        return sum + (typeof part.text === "string" ? part.text.length : 0);
+    }
+  }, 0);
+};
+
+export const estimateMessageContentTokens = (
+  content: unknown,
+  charsPerToken = DEFAULT_CHARS_PER_TOKEN,
+): number => estimateTokensFromChars(estimateMessageContentChars(content), charsPerToken);

package/extensions/vcc-core/core/tool-args.ts

@@ -0,0 +1,17 @@
+// @ts-nocheck
+export const PATH_KEYS = ["path", "file_path", "filePath", "file"] as const;
+
+export const extractPath = (args: Record<string, unknown>): string | null => {
+  for (const key of ["path", "file_path", "filePath", "file"]) {
+    if (typeof args[key] === "string") return args[key] as string;
+  }
+  return null;
+};
+
+export const summarizeToolArgs = (args: Record<string, unknown>): string => {
+  const path = extractPath(args);
+  if (path) return `path=${path}`;
+  if (typeof args.command === "string") return `command=${args.command}`;
+  if (typeof args.query === "string") return `query=${args.query}`;
+  return Object.keys(args).join(", ");
+};

package/extensions/vcc-core/details.ts

@@ -0,0 +1,12 @@
+// @ts-nocheck
+import type { CompactionReason } from "./types";
+
+export interface PiVccCompactionDetails {
+  compactor: "pi-vcc";
+  version: number;
+  sections: string[];
+  sourceMessageCount: number;
+  previousSummaryUsed: boolean;
+  reason?: CompactionReason;
+  willRetry?: boolean;
+}

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

@@ -0,0 +1,70 @@
+// @ts-nocheck
+import type { NormalizedBlock } from "../types";
+
+interface CommitInfo {
+  hash?: string;
+  message: string;
+}
+
+const COMMIT_MSG_RE = /git\s+commit[^\n]*?-m\s+(?:"((?:[^"\\]|\\.)*)"|'((?:[^'\\]|\\.)*)'|\$?'((?:[^'\\]|\\.)*)')/;
+// Match short hash from git output: "[branch hash]" or "main hash" or 7-12 hex
+const HASH_RE = /\b([0-9a-f]{7,12})\b/;
+
+const firstLineOf = (text: string): string => {
+  const line = text.split(/\\n|\n/)[0] ?? "";
+  return line.trim();
+};
+
+const cleanMessage = (msg: string): string =>
+  msg.replace(/\\"/g, '"').replace(/\\'/g, "'").trim();
+
+/**
+ * Extract git commits from bash tool calls (`git commit -m "..."`) and pair
+ * with hash from the immediately following tool_result.
+ */
+export const extractCommits = (blocks: NormalizedBlock[]): CommitInfo[] => {
+  const commits: CommitInfo[] = [];
+
+  for (let i = 0; i < blocks.length; i++) {
+    const b = blocks[i];
+    if (b.kind !== "tool_call" || b.name !== "bash") continue;
+    const cmd = typeof b.args.command === "string" ? b.args.command : "";
+    if (!/\bgit\s+commit\b/.test(cmd)) continue;
+    const m = cmd.match(COMMIT_MSG_RE);
+    if (!m) continue;
+    const message = firstLineOf(cleanMessage(m[1] ?? m[2] ?? m[3] ?? ""));
+    if (!message) continue;
+
+    let hash: string | undefined;
+    // Look at next tool_result for hash
+    for (let j = i + 1; j < Math.min(blocks.length, i + 3); j++) {
+      const r = blocks[j];
+      if (r.kind !== "tool_result") continue;
+      // Common git commit output: `[branch <hash>] message` or `<branch> <hash>..<hash>`
+      const bracket = r.text.match(/\[\S+\s+([0-9a-f]{7,12})\]/);
+      if (bracket) { hash = bracket[1]; break; }
+      const range = r.text.match(/\b([0-9a-f]{7,12})\.\.([0-9a-f]{7,12})\b/);
+      if (range) { hash = range[2]; break; }
+      const plain = r.text.match(HASH_RE);
+      if (plain) { hash = plain[1]; break; }
+    }
+
+    // Dedup by message+hash
+    const key = `${hash ?? ""}::${message}`;
+    if (!commits.some((c) => `${c.hash ?? ""}::${c.message}` === key)) {
+      commits.push({ hash, message });
+    }
+  }
+
+  return commits;
+};
+
+export const formatCommits = (commits: CommitInfo[], limit = 8): string[] => {
+  const lines: string[] = [];
+  const items = commits.slice(-limit); // keep most recent
+  for (const c of items) {
+    const prefix = c.hash ? `${c.hash}: ` : "";
+    lines.push(`${prefix}${c.message}`);
+  }
+  return lines;
+};

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

@@ -0,0 +1,88 @@
+// @ts-nocheck
+import type { FileOps, NormalizedBlock } from "../types";
+import { extractPath } from "../core/tool-args";
+
+interface FileActivity {
+  read: Set<string>;
+  modified: Set<string>;
+  created: Set<string>;
+}
+
+// Tool names are matched case-insensitively (see `matches`), mirroring the /i
+// regexes in core/rank.ts. Entries must be lowercase.
+const FILE_READ_TOOLS = new Set([
+  "read", "read_file", "view",
+]);
+
+// Multi-file patch tools (apply_patch) carry their paths inside the diff payload,
+// not in a path arg, so extractPath yields nothing for them; those files are
+// recovered from the hook-provided fileOps below.
+const FILE_WRITE_TOOLS = new Set([
+  "edit", "write", "edit_file", "write_file",
+  "multiedit", "quick_edit", "target_edit", "apply_patch",
+]);
+
+const FILE_CREATE_TOOLS = new Set([
+  "write", "write_file",
+]);
+
+const matches = (tools: Set<string>, name: string): boolean => tools.has(name.toLowerCase());
+
+/**
+ * Find the longest common directory prefix among absolute paths.
+ * Returns "" if fewer than 2 absolute paths or no meaningful common prefix.
+ */
+const longestCommonDirPrefix = (paths: string[]): string => {
+  const abs = paths.filter((p) => p.startsWith("/"));
+  if (abs.length < 2) return "";
+  const split = abs.map((p) => p.split("/"));
+  const min = Math.min(...split.map((s) => s.length));
+  let i = 0;
+  while (i < min - 1) {
+    const seg = split[0][i];
+    if (!split.every((s) => s[i] === seg)) break;
+    i++;
+  }
+  if (i < 2) return ""; // require at least /a/b common
+  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,
+): FileActivity => {
+  const act: FileActivity = {
+    read: new Set(fileOps?.readFiles ?? []),
+    modified: new Set(fileOps?.modifiedFiles ?? []),
+    created: new Set(fileOps?.createdFiles ?? []),
+  };
+
+  for (const b of blocks) {
+    if (b.kind !== "tool_call") continue;
+    const p = extractPath(b.args);
+    if (!p) continue;
+
+    if (matches(FILE_READ_TOOLS, b.name)) act.read.add(p);
+    if (matches(FILE_WRITE_TOOLS, b.name)) act.modified.add(p);
+    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);
+  }
+
+  return act;
+};