opencode-blackhole 0.0.0-stage → 0.1.0

package/src/vcc/core/summarize.ts

@@ -0,0 +1,289 @@
+import type { Message } from "../pi-types";
+import type { FileOps } from "../types";
+import { normalize } from "./normalize";
+import { filterNoise } from "./filter-noise";
+import { buildSections } from "./build-sections";
+import { formatSummary, capBrief, capItems, stripCapMarker, BRIEF_MAX_LINES, RECALL_NOTE, wrapLongLines } from "./format";
+import { COMMAND_SEPARATOR, COMMANDS_PER_NAME } from "../extract/tracked-commands";
+import { selectRankedBriefBlocks, type BriefRankingOptions } from "./rank";
+
+export interface CompileInput {
+  messages: Message[];
+  previousSummary?: string;
+  fileOps?: FileOps;
+  /**
+   * Session-global `#N` index per message position (see
+   * src/core/global-indices.ts). Parallel to `messages`; a missing entry
+   * renders as no ref (fail-closed). Omitted entirely → legacy positional.
+   */
+  sourceIndices?: Array<number | undefined>;
+  /** See BuildSectionsInput.trackCommands (core/build-sections.ts) --
+   * empty/omitted by default, threaded through from
+   * PiVccSettings.trackCommands by the caller (hooks/before-compact.ts). */
+  trackCommands?: readonly string[];
+}
+
+export interface RankedCompileInput extends CompileInput {
+  ranking?: BriefRankingOptions;
+}
+
+const HEADER_NAMES = ["Session Goal", "Files And Changes", "Commits", "Tracked Commands", "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);
+  }
+
+  // Tracked Commands: same categorized-merge shape as Files And Changes, but
+  // categories are whatever command names the user configured in
+  // trackCommands -- discover them from the actual text rather than a
+  // fixed list, so a config change between compactions doesn't orphan a
+  // category that was already recorded.
+  if (header === "Tracked Commands") {
+    return mergeTrackedCommandLines(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")}`;
+};
+
+/**
+ * Generic categorized-section merge: parses "- Category: a, b, c (+N more)"
+ * lines from both prev and fresh text, unions each category's items across
+ * compactions (deduped via Set), and re-renders. Extracted from what used
+ * to be Files And Changes' only inline implementation, in preparation for
+ * a second categorized section reusing the identical shape (see the
+ * follow-up `feat/track-commands-section` branch/PR).
+ */
+const mergeCategorizedLines = (
+  categories: readonly string[],
+  prev: string,
+  fresh: string,
+  splitOn: string,
+  touchOnDup = false,
+): Record<string, Set<string>> => {
+  const merged: Record<string, Set<string>> = {};
+  for (const cat of categories) merged[cat] = new Set();
+
+  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;
+        // Strip the overflow marker so it never merges back in as an entry.
+        const rest = stripCapMarker(line.slice(prefix.length));
+        for (const p of rest.split(splitOn)) {
+          const trimmed = p.trim();
+          if (!trimmed) continue;
+          // touchOnDup: re-inserting an existing entry moves it to the
+          // tail — with tail-capping this makes the section "N most-
+          // recently-USED" rather than "N most-recently-first-seen".
+          if (touchOnDup && merged[cat].has(trimmed)) merged[cat].delete(trimmed);
+          merged[cat].add(trimmed);
+        }
+      }
+    }
+  }
+  return merged;
+};
+
+const formatCategorizedLines = (
+  header: string,
+  merged: Record<string, Set<string>>,
+  categories: readonly string[],
+  joinWith: string,
+  itemLimit = 10,
+  keep: "head" | "tail" = "head",
+): string => {
+  const lines: string[] = [];
+  for (const cat of categories) {
+    if (merged[cat].size > 0) lines.push(`- ${cat}: ${capItems([...merged[cat]], itemLimit, joinWith, keep)}`);
+  }
+  if (lines.length === 0) return "";
+  return `[${header}]\n${lines.join("\n")}`;
+};
+
+const FILE_CATEGORIES = ["Modified", "Created", "Read"] as const;
+
+/** Merge Files And Changes by category, dedup paths across compactions */
+const mergeFileLines = (prev: string, fresh: string): string => {
+  const merged = mergeCategorizedLines(FILE_CATEGORIES, prev, fresh, ",");
+  // Dedup: if already in Modified, drop from Created (file existed before)
+  for (const p of merged.Modified) merged.Created.delete(p);
+  return formatCategorizedLines("Files And Changes", merged, FILE_CATEGORIES, ", ");
+};
+
+/** Category names actually present in "- <name>: ..." lines in `text`. */
+const discoverCategoryNames = (text: string): string[] => {
+  const names = new Set<string>();
+  for (const line of text.split("\n")) {
+    const m = line.match(/^- ([^:]+): /);
+    if (m) names.add(m[1]);
+  }
+  return [...names];
+};
+
+/**
+ * Merge Tracked Commands by whatever command names actually appear in prev/
+ * fresh (not a fixed category list, since trackCommands is user-config).
+ * Line format (separator, cap) is owned by extract/tracked-commands.ts.
+ */
+const mergeTrackedCommandLines = (prev: string, fresh: string): string => {
+  const categories = [...new Set([...discoverCategoryNames(prev), ...discoverCategoryNames(fresh)])];
+  const merged = mergeCategorizedLines(categories, prev, fresh, COMMAND_SEPARATOR, true);
+  return formatCategorizedLines("Tracked Commands", merged, categories, COMMAND_SEPARATOR, COMMANDS_PER_NAME, "tail");
+};
+
+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);
+      // The stored summary went through wrapLongLines; rejoin each item's
+      // indented continuation lines so the per-section merges, which read
+      // only "- " lines, see whole items.
+      const prevSec = sectionOf(prev, header).replace(/\n[ \t]+(?=\S)/g, " ");
+      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, input.sourceIndices));
+  const briefBlocks = options.briefBlocksFor?.(blocks);
+  const data = buildSections({ blocks, briefBlocks, fileOps: input.fileOps, trackCommands: input.trackCommands });
+  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,
+  });
+
+/**
+ * RECALL_NOTE as stored: wrapLongLines breaks it across lines (it is longer
+ * than the wrap width), so match its words separated by any whitespace,
+ * together with the separator in front of it.
+ */
+const RECALL_NOTE_RE = new RegExp(
+  "\\n*(?:---\\n+)?" +
+    RECALL_NOTE.split(/\s+/).map((w) => w.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("\\s+") +
+    "\\n*",
+  "g",
+);
+
+/**
+ * Remove every RECALL_NOTE from a previous summary before merging. The exact
+ * match this replaced never found the wrapped note, so each compaction kept
+ * the old note inside the brief and stacked one more; this also cleans those.
+ */
+const stripRecallNote = (text: string): string =>
+  text.replace(RECALL_NOTE_RE, "\n\n").trimEnd();

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

@@ -0,0 +1,100 @@
+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/src/vcc/core/tool-args.ts

@@ -0,0 +1,16 @@
+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/src/vcc/details.ts

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

package/src/vcc/extract/commits.ts

@@ -0,0 +1,96 @@
+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 cleanMessage = (msg: string): string =>
+  msg.replace(/\\"/g, '"').replace(/\\'/g, "'").trim();
+
+const linesOf = (text: string): string[] => text.split(/\\n|\n/);
+
+const firstLineOf = (text: string): string => {
+  const line = linesOf(text)[0] ?? "";
+  return line.trim();
+};
+
+// COMMIT_MSG_RE only yields the `$(cat <<...` opener (truncated at the inner quote for <<"DELIM"), so heredoc -m is re-read from the raw command.
+const HEREDOC_COMMIT_CMD_RE =
+  /^git\s+commit[^\n"'&;|]*?-m\s+"\$\(cat\s+<<-?\s*(?:'([^']+)'|"([^"]+)"|([A-Za-z_]\w*))(?:\r?\n|\\n)/;
+
+const firstHeredocBodyLine = (rest: string, delim: string): string => {
+  for (const line of linesOf(rest)) {
+    const trimmed = line.replace(/^\t+/, "").trim();
+    if (trimmed === delim) break;
+    if (trimmed) return trimmed;
+  }
+  return "";
+};
+
+const subjectFromHeredocCmd = (cmd: string): string | null => {
+  const m = cmd.match(HEREDOC_COMMIT_CMD_RE);
+  if (!m) return null;
+  const delim = m[1] ?? m[2] ?? m[3] ?? "";
+  return cleanMessage(firstHeredocBodyLine(cmd.slice(m.index! + m[0].length), delim));
+};
+
+/**
+ * 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;
+    // First -m is `"$(cat <<DELIM ...`: COMMIT_MSG_RE only sees `$(cat <<...`, so read the heredoc body.
+    const heredoc = m[1] !== undefined && /^\$\(cat\s+<</.test(m[1])
+      ? subjectFromHeredocCmd(cmd.slice(m.index!))
+      : null;
+    const message = heredoc ?? firstLineOf(cleanMessage(m[1] ?? m[2] ?? m[3] ?? ""));
+    if (heredoc === null && /^\$\(cat\s+<</.test(message)) continue;
+    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/src/vcc/extract/files.ts

@@ -0,0 +1,87 @@
+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;
+};

package/src/vcc/extract/goals.ts

@@ -0,0 +1,79 @@
+import type { NormalizedBlock } from "../types";
+import { nonEmptyLines, clip } from "../core/content";
+import { collapseSkillLines } from "../core/skill-collapse";
+
+const SCOPE_CHANGE_RE =
+  /\b(instead|actually|change of plan|forget that|new task|switch to|now I want|pivot|let'?s do|stop .* and)\b/i;
+
+const TASK_RE =
+  /\b(fix|implement|add|create|build|refactor|debug|investigate|update|remove|delete|migrate|deploy|test|write|set up)\b/i;
+
+const NOISE_SHORT_RE = /^(ok|yes|no|sure|yeah|yep|go|hi|hey|thx|thanks|ok\b.*|y|n|k)\s*[.!?]*$/i;
+
+// Reject lines that are clearly not user goals (pasted output, code, paths, tool dumps)
+// or meta-prompt boilerplate (command templates like `/issues` that start with "For each issue:"
+// followed by numbered "Read the issue in full..." steps).
+const NON_GOAL_RE =
+  /^\s*[\[│├└─╭╰]|```|^\s*(=[A-Z]+\(|function |const |let |var |import |export |class )|^(https?:|file:|\/[A-Za-z])|\\n|^\s*For each\b|\bin full\b[^\n]*\b(comments|issue|issues|PRs?|linked)\b/;
+
+// Signals that the rest of the user message is a command template (e.g. /issues),
+// in which case we should stop collecting goals at the signal line.
+const TEMPLATE_SIGNAL_RE =
+  /^\s*(For each\b|Do NOT implement\b|Analyze and propose\b|If Task\/context\b|Output:\s*$)/i;
+
+const truncateAtTemplate = (lines: string[]): string[] => {
+  const idx = lines.findIndex((l) => TEMPLATE_SIGNAL_RE.test(l));
+  return idx >= 0 ? lines.slice(0, idx) : lines;
+};
+
+const stripLeadingBullet = (line: string): string =>
+  line.replace(/^\s*(?:[-*+]|\d+\.)\s+/, "").trim();
+
+const MAX_GOAL_CHARS = 200;
+
+const isSubstantiveGoal = (text: string): boolean => {
+  const t = text.trim();
+  if (t.length <= 5) return false;
+  if (t.length > MAX_GOAL_CHARS) return false;
+  if (NOISE_SHORT_RE.test(t)) return false;
+  if (NON_GOAL_RE.test(t)) return false;
+  return true;
+};
+
+// Test scope-change / task intent only on the leading portion of a user block
+// so that pasted outputs below the actual instruction do not trigger matches.
+const LEADING_CHARS = 200;
+
+export const extractGoals = (blocks: NormalizedBlock[]): string[] => {
+  const goals: string[] = [];
+  let latestScopeChange: string[] | null = null;
+
+  for (const b of blocks) {
+    if (b.kind !== "user") continue;
+    const rawLines = nonEmptyLines(b.text);
+    const truncated = truncateAtTemplate(rawLines);
+    const lines = collapseSkillLines(truncated.filter(isSubstantiveGoal))
+      .map(stripLeadingBullet)
+      .filter((l) => l.length > 5);
+    if (lines.length === 0) continue;
+
+    if (goals.length === 0) {
+      goals.push(...lines.slice(0, 6));
+      continue;
+    }
+
+    const leading = b.text.slice(0, LEADING_CHARS);
+    if (SCOPE_CHANGE_RE.test(leading)) {
+      latestScopeChange = lines.slice(0, 3).map((l) => clip(l, MAX_GOAL_CHARS));
+    } else if (TASK_RE.test(leading) && lines[0].length > 15) {
+      latestScopeChange = lines.slice(0, 2).map((l) => clip(l, MAX_GOAL_CHARS));
+    }
+  }
+
+  // Only emit the [Scope change] marker when we actually captured bullets.
+  if (latestScopeChange && latestScopeChange.length > 0) {
+    goals.push("[Scope change]", ...latestScopeChange);
+  }
+
+  return goals.slice(0, 8);
+};