opencode-blackhole 0.0.0-stage → 0.1.0

package/src/vcc/core/rank.ts

@@ -0,0 +1,283 @@
+import type { NormalizedBlock, FileOps } from "../types";
+import { extractPath } from "./tool-args";
+import { compileBrief, heredocCloseIndex } from "./brief";
+
+export interface BriefRankingOptions {
+  /** Maximum normalized blocks used to build the brief transcript. */
+  maxBlocks?: number;
+  /** Always keep this many latest blocks to preserve local continuity. */
+  preserveRecentBlocks?: number;
+  /** Hook-provided file activity, used as structural signal instead of prose guessing. */
+  fileOps?: FileOps;
+  /**
+   * Optional size budget (in characters of rendered brief) for the selected
+   * blocks. When set, this is the PRIMARY limit: blocks are added by score
+   * until the budget is reached, and lower-value blocks are skipped rather
+   * than truncating the tail. maxBlocks still applies as a safety upper bound.
+   * Callers derive this from a token budget via charsPerToken.
+   * When maxBriefCharsCeiling + briefCharsPerBlock are also set, this acts as
+   * the FLOOR of a size-relative budget (see below).
+   */
+  maxBriefChars?: number;
+  /**
+   * Optional upper bound for a size-relative char budget. When set together
+   * with maxBriefChars (floor) and briefCharsPerBlock (slope), the effective
+   * budget becomes clamp(briefCharsPerBlock * blockCount, maxBriefChars,
+   * maxBriefCharsCeiling): larger transcripts (which carry more high-value
+   * long-tail -- edits, commands, tests) get more brief budget, while small
+   * sessions stay at the floor and this hard ceiling prevents unbounded growth.
+   */
+  maxBriefCharsCeiling?: number;
+  /** Per-block slope (chars) for the size-relative budget. Requires the ceiling. */
+  briefCharsPerBlock?: number;
+}
+
+export interface RankedBlock {
+  block: NormalizedBlock;
+  index: number;
+  score: number;
+  reasons: string[];
+}
+
+const DEFAULT_MAX_BLOCKS = 80;
+const DEFAULT_RECENT_BLOCKS = 16;
+
+const EDIT_TOOL_RE = /^(edit|write|multiedit|quick_edit|target_edit|apply_patch)$/i;
+const READ_TOOL_RE = /^(read|glob|grep|ls|find|semantic_query|semantic_grep|semantic_show)$/i;
+const TEST_COMMAND_RE = /\b(?:bun|npm|pnpm|yarn|node|pytest|cargo|go|mvn|gradle)\b[^\n]*(?:test|spec|check|lint|build|tsc)/i;
+const GH_PR_POLL_RE = /(?:^|\s)gh\s+pr\s+(?:view|checks)\s+(\d+)\b/i;
+// Durable workflow facts: which PR/issue was acted on, and git state changes.
+// Structural (command shape), not prose — same spirit as TEST_COMMAND_RE.
+const WORKFLOW_COMMAND_RE =
+  /(?:^|\s)(?:gh\s+(?:pr|issue)\s+[a-z-]+|git\s+(?:commit|push|merge|rebase|revert|cherry-pick|tag|reset|checkout|branch)\b)/i;
+const MIN_SEGMENT_CLOSING_ASSISTANT_CHARS = 120;
+
+// A bash block whose every meaningful line is pure scaffolding (set -e, cd,
+// export, ls, echo, sleep, pwd, comments, heredoc bodies) carries no durable
+// fact. Such blocks get a score penalty so the size-relative budget never
+// pulls them in ahead of real edits/commands when spare chars appear.
+const TRIVIAL_BASH_LINE_RE =
+  /^(?:set\s+[-+]|cd(?:\s+\S+)?$|export\s+\w+=|(?:source|\.)\s+\S+|pwd$|true$|:$|#|ls(?:\s|$)|echo\b|clear$|sleep\b)/;
+const TRIVIAL_BASH_PENALTY = 16;
+
+const isTrivialOnlyBash = (raw: string): boolean => {
+  const lines = raw.split("\n");
+  const kept: string[] = [];
+  for (let i = 0; i < lines.length; i++) {
+    kept.push(lines[i]);
+    // Skip heredoc bodies (they are content, not scaffolding) using the same
+    // hardened detection as brief.ts: only skip when the terminator exists
+    // downstream, so a stray `<<` never swallows a later real command.
+    const close = heredocCloseIndex(lines, i);
+    if (close !== -1) i = close;
+  }
+  const meaningful = kept.map((l) => l.trim()).filter(Boolean).filter((l) => !TRIVIAL_BASH_LINE_RE.test(l));
+  return meaningful.length === 0;
+};
+
+const asPathSet = (paths?: string[]): Set<string> => new Set((paths ?? []).filter(Boolean));
+
+const bashCommandFromBlock = (block: NormalizedBlock): string | undefined => {
+  if (block.kind === "bash") return block.command;
+  if (block.kind === "tool_call" && /^bash$/i.test(block.name) && typeof block.args.command === "string") {
+    return block.args.command;
+  }
+  return undefined;
+};
+
+const pathFromBlock = (block: NormalizedBlock): string | undefined => {
+  if (block.kind === "tool_call") return extractPath(block.args) ?? undefined;
+  if (block.kind === "bash") {
+    const match = block.command.match(/(?:^|\s)([\w./-]+\.[\w-]+)(?:\s|$)/);
+    return match?.[1];
+  }
+  return undefined;
+};
+
+const add = (ranked: RankedBlock, points: number, reason: string) => {
+  ranked.score += points;
+  ranked.reasons.push(reason);
+};
+
+const scoreBlock = (
+  block: NormalizedBlock,
+  index: number,
+  total: number,
+  modifiedFiles: Set<string>,
+  readFiles: Set<string>,
+): RankedBlock => {
+  const ranked: RankedBlock = { block, index, score: 0, reasons: [] };
+  const recency = total <= 1 ? 0 : Math.round((index / (total - 1)) * 12);
+  add(ranked, recency, "recency");
+
+  if (block.kind === "user") add(ranked, 18, "user-turn");
+  if (block.kind === "assistant") add(ranked, 10, "assistant-context");
+  if (block.kind === "tool_result") add(ranked, 1, "tool-result-low-value");
+
+  if (block.kind === "tool_call") {
+    const command = bashCommandFromBlock(block);
+    if (EDIT_TOOL_RE.test(block.name)) add(ranked, 34, "edit-tool");
+    else if (command && TEST_COMMAND_RE.test(command)) add(ranked, 26, "test-command");
+    else if (READ_TOOL_RE.test(block.name)) add(ranked, 6, "read-tool");
+    else add(ranked, 12, "tool-call");
+    if (command && WORKFLOW_COMMAND_RE.test(command)) add(ranked, 14, "workflow-command");
+    if (command && isTrivialOnlyBash(command)) add(ranked, -TRIVIAL_BASH_PENALTY, "trivial-bash");
+  }
+
+  if (block.kind === "bash") {
+    add(ranked, 8, "bash");
+    if (block.exitCode != null && block.exitCode !== 0) add(ranked, 24, "nonzero-exit");
+    if (TEST_COMMAND_RE.test(block.command)) add(ranked, 22, "test-command");
+    if (WORKFLOW_COMMAND_RE.test(block.command)) add(ranked, 14, "workflow-command");
+    // Penalize scaffolding-only commands, but not ones that failed (a failed
+    // `ls`/`cd` still records a real state fact via nonzero-exit).
+    if (isTrivialOnlyBash(block.command) && !(block.exitCode != null && block.exitCode !== 0)) {
+      add(ranked, -TRIVIAL_BASH_PENALTY, "trivial-bash");
+    }
+  }
+
+  const path = pathFromBlock(block);
+  if (path) {
+    if (modifiedFiles.has(path)) add(ranked, 18, "hook-modified-file");
+    if (readFiles.has(path)) add(ranked, 6, "hook-read-file");
+  }
+
+  if (block.kind === "tool_result" && block.text.length > 1000) add(ranked, -8, "long-tool-result");
+  return ranked;
+};
+
+const boostAdjacency = (ranked: RankedBlock[]) => {
+  const important = ranked
+    .filter((r) => r.score >= 34 || r.reasons.includes("edit-tool") || r.reasons.includes("test-command") || r.reasons.includes("nonzero-exit"))
+    .map((r) => r.index);
+
+  for (const idx of important) {
+    for (let i = idx - 1; i >= Math.max(0, idx - 8); i--) {
+      if (ranked[i].block.kind === "user") {
+        add(ranked[i], 10, "near-important-event");
+        break;
+      }
+    }
+    for (let i = idx - 1; i >= Math.max(0, idx - 4); i--) {
+      if (ranked[i].block.kind === "assistant") {
+        add(ranked[i], 7, "near-important-event");
+        break;
+      }
+    }
+    for (let i = idx + 1; i <= Math.min(ranked.length - 1, idx + 4); i++) {
+      if (ranked[i].block.kind === "assistant" || ranked[i].block.kind === "bash") {
+        add(ranked[i], 5, "after-important-event");
+        break;
+      }
+    }
+  }
+};
+
+const nextNonToolResult = (ranked: RankedBlock[], index: number): NormalizedBlock | undefined => {
+  for (let i = index + 1; i < ranked.length; i++) {
+    if (ranked[i].block.kind !== "tool_result") return ranked[i].block;
+  }
+  return undefined;
+};
+
+const boostSegmentClosingAssistants = (ranked: RankedBlock[]) => {
+  for (let i = 0; i < ranked.length; i++) {
+    const current = ranked[i];
+    if (current.block.kind !== "assistant") continue;
+    if (current.block.text.trim().length < MIN_SEGMENT_CLOSING_ASSISTANT_CHARS) continue;
+    const next = nextNonToolResult(ranked, i);
+    if (!next || next.kind === "user") {
+      add(current, 14, "segment-closing-assistant");
+    }
+  }
+};
+
+const dedupKey = (block: NormalizedBlock): string | undefined => {
+  const command = bashCommandFromBlock(block);
+  const ghPrPoll = command?.match(GH_PR_POLL_RE);
+  if (ghPrPoll) return `gh-pr-poll:${ghPrPoll[1]}`;
+  if (command) {
+    const normalized = command.replace(/\s+/g, " ").trim();
+    return normalized ? `bash:${normalized}` : undefined;
+  }
+  if (block.kind === "tool_call") {
+    const path = pathFromBlock(block);
+    return path ? `tool:${block.name.toLowerCase()}:${path}` : undefined;
+  }
+  return undefined;
+};
+
+export const rankBriefBlocks = (blocks: NormalizedBlock[], options: BriefRankingOptions = {}): RankedBlock[] => {
+  const modifiedFiles = asPathSet(options.fileOps?.modifiedFiles);
+  const readFiles = asPathSet(options.fileOps?.readFiles);
+  const ranked = blocks.map((block, index) => scoreBlock(block, index, blocks.length, modifiedFiles, readFiles));
+  boostAdjacency(ranked);
+  boostSegmentClosingAssistants(ranked);
+  return ranked;
+};
+
+export const selectRankedBriefBlocks = (
+  blocks: NormalizedBlock[],
+  options: BriefRankingOptions = {},
+): NormalizedBlock[] => {
+  const maxBlocks = options.maxBlocks ?? DEFAULT_MAX_BLOCKS;
+  // Size-relative budget: when a ceiling + slope are provided, the effective
+  // char budget scales with transcript length (block count) between the floor
+  // (maxBriefChars) and the ceiling. Larger transcripts carry more high-value
+  // long-tail, so they earn more brief budget; small sessions stay at the floor.
+  const maxBriefChars =
+    options.maxBriefChars != null && options.maxBriefCharsCeiling != null && options.briefCharsPerBlock != null
+      ? Math.round(
+          Math.min(
+            options.maxBriefCharsCeiling,
+            Math.max(options.maxBriefChars, options.briefCharsPerBlock * blocks.length),
+          ),
+        )
+      : options.maxBriefChars;
+  // Fast path: nothing to trim by count and no char budget to enforce.
+  if (blocks.length <= maxBlocks && maxBriefChars == null) return blocks;
+
+  const preserveRecentBlocks = Math.min(options.preserveRecentBlocks ?? DEFAULT_RECENT_BLOCKS, maxBlocks);
+  const ranked = rankBriefBlocks(blocks, options);
+  const selected = new Set<number>();
+  const seenKeys = new Set<string>();
+
+  // Per-block rendered size, only computed when a char budget is active.
+  const costs = maxBriefChars == null
+    ? null
+    : blocks.map((b) => (b.kind === "tool_result" ? 0 : compileBrief([b]).length + 1));
+  let usedChars = 0;
+
+  // Keep the latest blocks to preserve local continuity, iterating NEWEST first
+  // so the most recent context is guaranteed. When a char budget is active these
+  // are charged against it too and over-budget blocks are skipped -- otherwise a
+  // run of large recent blocks could blow past maxBriefChars (the old bug on very
+  // long transcripts, where preserve-recent alone exceeded the budget).
+  for (let i = blocks.length - 1; i >= Math.max(0, blocks.length - preserveRecentBlocks); i--) {
+    if (blocks[i].kind === "tool_result") continue;
+    if (selected.has(i)) continue;
+    if (costs && usedChars + costs[i] > maxBriefChars!) continue;
+    selected.add(i);
+    if (costs) usedChars += costs[i];
+    const key = dedupKey(blocks[i]);
+    if (key) seenKeys.add(key);
+  }
+
+  const ordered = [...ranked].sort((a, b) => b.score - a.score || b.index - a.index);
+  for (const item of ordered) {
+    if (selected.size >= maxBlocks) break;
+    if (selected.has(item.index)) continue;
+    if (item.block.kind === "tool_result") continue;
+    const key = dedupKey(item.block);
+    if (key && seenKeys.has(key)) continue;
+    if (costs) {
+      // Skip (not break) so smaller high-value blocks can still fit the budget.
+      if (usedChars + costs[item.index] > maxBriefChars!) continue;
+      usedChars += costs[item.index];
+    }
+    selected.add(item.index);
+    if (key) seenKeys.add(key);
+  }
+
+  return [...selected].sort((a, b) => a - b).map((i) => blocks[i]);
+};

package/src/vcc/core/recall-request.ts

@@ -0,0 +1,160 @@
+import { parseDrillDown } from "./drill-down";
+import { normalizeRecallMode, normalizeRecallScope, parseRecallScope, type RecallScope } from "./recall-scope";
+
+export type DrillTarget = NonNullable<ReturnType<typeof parseDrillDown>>;
+
+/** The one thing a recall call does. Exactly one action runs per call. */
+export type RecallAction =
+  | { kind: "drill"; target: DrillTarget }
+  | { kind: "touched"; page?: number }
+  | { kind: "expand"; indices: number[] }
+  | { kind: "range"; range: unknown[]; page: number }
+  | { kind: "search"; query: string; page: number }
+  | { kind: "recent"; query?: string };
+
+export interface RecallRequest {
+  scope: RecallScope;
+  action: RecallAction;
+  /** Params the caller set that this action does not use. Defaults (page:1, expand:[]) are not listed. */
+  ignored?: string[];
+  /** Values normalizeToolParams could not repair and removed. */
+  dropped?: string[];
+}
+
+export interface RecallToolParams {
+  query?: string;
+  expand?: number[];
+  range?: unknown[];
+  page?: number;
+  scope?: string;
+  mode?: string;
+}
+
+/** Where normalizeToolParams records values it had to drop; read by parseToolRequest. */
+export const DROPPED_KEY = "_vccDropped";
+
+const KNOWN_PARAMS = new Set(["query", "range", "expand", "page", "scope", "mode"]);
+
+/** 12, "12", "#12", " 12 " -> 12. Anything else -> undefined. */
+const toIndex = (v: unknown): number | undefined => {
+  if (typeof v === "number") return Number.isInteger(v) ? v : undefined;
+  if (typeof v === "string") {
+    const m = v.trim().match(/^#?(\d+)$/);
+    return m ? Number(m[1]) : undefined;
+  }
+  return undefined;
+};
+
+/** "12", "#12, #15", "12 15" -> numbers; undefined unless the whole string is #N tokens. */
+const indexList = (s: string): number[] | undefined => {
+  const t = s.trim().replace(/^\[|\]$/g, "");
+  if (!/^\s*#?\d+(\s*[,\s]\s*#?\d+)*\s*$/.test(t)) return undefined;
+  return (t.match(/\d+/g) ?? []).map(Number);
+};
+
+/**
+ * Repair argument mistakes whose meaning is certain, before pi validates the
+ * schema: numbers sent as strings or with a leading #, a single index where a
+ * list is expected, a range written as "10-20" or reversed, enum values in
+ * the wrong case, and a scope value put in mode. Values that cannot be
+ * repaired are removed and listed under DROPPED_KEY, so the output names them
+ * instead of pi rejecting the whole call or recall dropping them silently.
+ */
+export const normalizeToolParams = (raw: unknown): Record<string, unknown> => {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return {};
+  const p: Record<string, unknown> = { ...(raw as Record<string, unknown>) };
+  const dropped: string[] = [];
+  const drop = (key: string, why: string) => { dropped.push(`${key} ${JSON.stringify(p[key])} (${why})`); delete p[key]; };
+
+  for (const key of Object.keys(p)) {
+    if (!KNOWN_PARAMS.has(key) && key !== DROPPED_KEY) drop(key, "not a vcc_recall param");
+  }
+
+  if (p.page !== undefined) {
+    const n = toIndex(p.page);
+    if (n !== undefined && n >= 1) p.page = n; else drop("page", "not a page number");
+  }
+
+  if (p.expand !== undefined) {
+    const list = Array.isArray(p.expand) ? p.expand.map(toIndex)
+      : typeof p.expand === "string" ? indexList(p.expand)
+      : [toIndex(p.expand)];
+    if (list && list.every((n) => n !== undefined)) p.expand = list; else drop("expand", "not #N indices");
+  }
+
+  if (p.range !== undefined) {
+    let pair: (number | undefined)[] | undefined;
+    if (Array.isArray(p.range)) pair = p.range.map(toIndex);
+    else if (typeof p.range === "string") {
+      const m = p.range.trim().match(/^\[?\s*#?(\d+)\s*(?:(?:-|\.\.|,|to)\s*#?(\d+)\s*)?\]?$/i);
+      pair = m ? [Number(m[1]), Number(m[2] ?? m[1])] : undefined;
+    } else pair = [toIndex(p.range)];
+    // A single index reads just that entry.
+    if (pair?.length === 1) pair = [pair[0], pair[0]];
+    if (pair && pair.length === 2 && pair.every((n) => n !== undefined)) {
+      const [a, b] = pair as number[];
+      p.range = a <= b ? [a, b] : [b, a];
+    } else drop("range", "not [from, to]");
+  }
+
+  for (const key of ["scope", "mode"] as const) {
+    if (typeof p[key] === "string") p[key] = (p[key] as string).trim().toLowerCase();
+  }
+  if ((p.mode === "all" || p.mode === "lineage") && p.scope === undefined) {
+    p.scope = p.mode;
+    delete p.mode;
+  }
+  if (p.scope !== undefined && p.scope !== "lineage" && p.scope !== "all") drop("scope", "use 'lineage' or 'all'");
+  if (p.mode !== undefined && p.mode !== "hybrid" && p.mode !== "touched") drop("mode", "use 'touched' or leave it out");
+  if (p.query !== undefined && typeof p.query !== "string") drop("query", "not text");
+
+  if (dropped.length > 0) p[DROPPED_KEY] = dropped;
+  return p;
+};
+
+/**
+ * Tool params -> request. The precedence lives here and only here:
+ * #N:path drill-down, then mode:'touched', then expand, then range, then
+ * query search, then the most recent entries.
+ */
+export const parseToolRequest = (params: RecallToolParams): RecallRequest => {
+  const scope = normalizeRecallScope(params.scope);
+  const q = params.query?.trim();
+  const indices = [...new Set(params.expand ?? [])];
+  const hasRange = Array.isArray(params.range) && params.range.length > 0;
+  const set = {
+    query: Boolean(q),
+    expand: indices.length > 0,
+    range: hasRange,
+    page: (params.page ?? 1) > 1,
+    touched: normalizeRecallMode(params.mode) === "touched",
+  };
+  const droppedRaw = (params as Record<string, unknown>)[DROPPED_KEY];
+  const dropped = Array.isArray(droppedRaw) && droppedRaw.length > 0 ? droppedRaw.map(String) : undefined;
+  const req = (action: RecallAction, uses: (keyof typeof set)[]): RecallRequest => {
+    const ignored = (Object.keys(set) as (keyof typeof set)[])
+      .filter((k) => set[k] && !uses.includes(k))
+      .map((k) => (k === "touched" ? "mode" : k));
+    const base: RecallRequest = dropped ? { scope, action, dropped } : { scope, action };
+    return ignored.length > 0 ? { ...base, ignored } : base;
+  };
+
+  const target = q ? parseDrillDown(q) : null;
+  if (target) return req({ kind: "drill", target }, ["query"]);
+  if (set.touched) return req({ kind: "touched", page: params.page }, ["touched", "page"]);
+  if (set.expand) return req({ kind: "expand", indices }, ["expand"]);
+  if (hasRange) return req({ kind: "range", range: params.range!, page: Math.max(1, params.page ?? 1) }, ["range", "page"]);
+  if (q) return req({ kind: "search", query: params.query!, page: Math.max(1, params.page ?? 1) }, ["query", "page"]);
+  return req({ kind: "recent", query: params.query }, []);
+};
+
+/** /pi-vcc-recall args -> request. A person types a query, scope:all and page:N only. */
+export const parseCommandRequest = (args: string): RecallRequest => {
+  const parsed = parseRecallScope(args.trim());
+  const scope = parsed.scope;
+  const pageMatch = parsed.text.match(/\bpage:(\d+)\b/i);
+  const page = pageMatch ? Math.max(1, parseInt(pageMatch[1], 10)) : 1;
+  const query = parsed.text.replace(/\bpage:\d+\b/i, "").trim();
+  if (!query) return { scope, action: { kind: "recent" } };
+  return { scope, action: { kind: "search", query, page } };
+};

package/src/vcc/core/recall-scope.ts

@@ -0,0 +1,30 @@
+export type RecallScope = "lineage" | "all";
+export type RecallMode = "hybrid" | "touched";
+
+const SCOPE_RE = /\bscope:(lineage|all)\b/i;
+
+const VALID_MODES = new Set(["hybrid", "touched"]);
+
+export const normalizeRecallScope = (scope?: unknown): RecallScope =>
+  typeof scope === "string" && scope.toLowerCase() === "all" ? "all" : "lineage";
+
+/**
+ * Normalize a mode param to a supported recall mode. Without OM integration,
+ * only "touched" adds behavior beyond the default hybrid search — "file"-only
+ * search is not implemented in pi-vcc, so it is not exposed.
+ *
+ * Ported from pi-blackhole (https://github.com/k0valik/pi-blackhole, MIT) by
+ * k0valik — a pi-vcc derivative.
+ */
+export const normalizeRecallMode = (mode?: unknown): RecallMode =>
+  typeof mode === "string" && VALID_MODES.has(mode.toLowerCase())
+    ? (mode.toLowerCase() as RecallMode)
+    : "hybrid";
+
+export const parseRecallScope = (text: string): { scope: RecallScope; text: string } => {
+  const match = text.match(SCOPE_RE);
+  return {
+    scope: normalizeRecallScope(match?.[1]),
+    text: text.replace(SCOPE_RE, "").replace(/\s+/g, " ").trim(),
+  };
+};

package/src/vcc/core/render-entries.ts

@@ -0,0 +1,55 @@
+import type { Message, ToolCall } from "../pi-types";
+import { clip, textOf } from "./content";
+import { summarizeToolArgs } from "./tool-args";
+import { extractPath } from "./tool-args";
+
+export interface RenderedEntry {
+  index: number;
+  role: string;
+  summary: string;
+  files?: string[];
+}
+
+const toolCallParts = (content: Message["content"]): ToolCall[] => {
+  if (!content || typeof content === "string") return [];
+  return (content as { type: string }[]).filter((c): c is ToolCall => c.type === "toolCall");
+};
+
+const toolCalls = (content: Message["content"]): string => {
+  return toolCallParts(content)
+    .map((c) => `${c.name}(${summarizeToolArgs(c.arguments)})`)
+    .join(", ");
+};
+
+const extractFilesFromContent = (content: Message["content"]): string[] => {
+  return toolCallParts(content)
+    .map((c) => extractPath(c.arguments))
+    .filter((p): p is string => p !== null);
+};
+
+export const renderMessage = (msg: Message, index: number, full = false): RenderedEntry => {
+  if (msg.role === "user") {
+    return { index, role: "user", summary: full ? textOf(msg.content) : clip(textOf(msg.content), 300) };
+  }
+  if (msg.role === "toolResult") {
+    const text = full ? textOf(msg.content) : clip(textOf(msg.content), 200);
+    return {
+      index, role: "tool_result",
+      summary: `[${msg.toolName}] ${text}`,
+    };
+  }
+  // bashExecution has command+output instead of content
+  if ((msg as any).role === "bashExecution") {
+    const cmd = (msg as any).command ?? "";
+    const out = (msg as any).output ?? "";
+    const text = full ? `$ ${cmd}\n${out}` : clip(`$ ${cmd}\n${out}`, 300);
+    return { index, role: "bash", summary: text };
+  }
+  const text = full ? textOf(msg.content) : clip(textOf(msg.content), 300);
+  const tools = toolCalls(msg.content);
+  const files = extractFilesFromContent(msg.content);
+  const summary = tools ? `${tools}\n${text}` : text;
+  return { index, role: "assistant", summary, ...(files.length > 0 && { files }) };
+};
+
+

package/src/vcc/core/sanitize.ts

@@ -0,0 +1,5 @@
+const ANSI_RE = /\x1b\[[0-9;]*[A-Za-z]/g;
+const CTRL_RE = /[\x00-\x08\x0b\x0c\x0e-\x1f]/g;
+
+export const sanitize = (text: string): string =>
+  text.replace(/\r\n/g, "\n").replace(/\r/g, "\n").replace(ANSI_RE, "").replace(CTRL_RE, "");