ultimate-pi 0.4.0 → 0.4.1

package/vendor/pi-vcc/src/extract/commits.ts

@@ -0,0 +1,69 @@
+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/vendor/pi-vcc/src/extract/files.ts

@@ -0,0 +1,80 @@
+import type { FileOps, NormalizedBlock } from "../types";
+import { extractPath } from "../core/tool-args";
+
+interface FileActivity {
+  read: Set<string>;
+  modified: Set<string>;
+  created: Set<string>;
+}
+
+const FILE_READ_TOOLS = new Set([
+  "Read", "read_file", "View",
+]);
+
+const FILE_WRITE_TOOLS = new Set([
+  "Edit", "Write", "edit", "write", "edit_file", "write_file",
+  "MultiEdit",
+]);
+
+const FILE_CREATE_TOOLS = new Set([
+  "Write", "write", "write_file",
+]);
+
+/**
+ * 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 (FILE_READ_TOOLS.has(b.name)) act.read.add(p);
+    if (FILE_WRITE_TOOLS.has(b.name)) act.modified.add(p);
+    if (FILE_CREATE_TOOLS.has(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/vendor/pi-vcc/src/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);
+};

package/vendor/pi-vcc/src/extract/preferences.ts

@@ -0,0 +1,55 @@
+import type { NormalizedBlock } from "../types";
+import { clip, nonEmptyLines } from "../core/content";
+
+// Tightened patterns: require a clear preference construction, not bare keywords.
+const PREF_PATTERNS = [
+  /\bprefer(?:s|red|ring)?\s+\w/i,
+  /\bdon'?t want\b/i,
+  /\balways (?:use|do|run|prefer|keep|make|format|write|add|set|put|prefix|start|include|append)\b/i,
+  /\bnever (?:use|do|run|push|commit|write|ignore|add|set|put|remove|delete|include|deploy)\b/i,
+  /\bplease (?:use|avoid|keep|make|don'?t|do not|format|write)\b/i,
+  /\b(?:style|format|language|naming)\s*[:=]\s*\S/i,
+];
+
+export const extractPreferences = (blocks: NormalizedBlock[]): string[] => {
+  const prefs: string[] = [];
+  const seen = new Set<string>();
+
+  for (const b of blocks) {
+    if (b.kind !== "user") continue;
+
+    let perBlock = 0;
+    for (const line of nonEmptyLines(b.text)) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.length < 5) continue;
+      if (trimmed.length > 200) continue;
+      // Reject questions.
+      if (trimmed.endsWith("?") || trimmed.includes("?...")) continue;
+      if (!PREF_PATTERNS.some((p) => p.test(trimmed))) continue;
+
+      const clipped = clip(trimmed, 200);
+      const key = clipped.toLowerCase();
+      if (seen.has(key)) continue;
+      seen.add(key);
+      prefs.push(clipped);
+
+      // Cap per user block to avoid pasting long rule lists as many prefs.
+      if (++perBlock >= 1) break;
+    }
+  }
+
+  return prefs.slice(0, 10);
+};
+
+/**
+ * Remove preferences that duplicate goals (case-insensitive, trimmed).
+ * Called by `buildSections` so that the two sections do not overlap.
+ */
+export const dedupPreferencesAgainstGoals = (
+  prefs: string[],
+  goals: string[],
+): string[] => {
+  const norm = (s: string) => s.trim().toLowerCase();
+  const goalSet = new Set(goals.map(norm));
+  return prefs.filter((p) => !goalSet.has(norm(p)));
+};

package/vendor/pi-vcc/src/hooks/before-compact.ts

@@ -0,0 +1,314 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { convertToLlm } from "@mariozechner/pi-coding-agent";
+import { writeFileSync } from "fs";
+import { compile } from "../core/summarize";
+import { loadSettings, type PiVccSettings } from "../core/settings";
+import type { PiVccCompactionDetails } from "../details";
+
+export const PI_VCC_COMPACT_INSTRUCTION = "__pi_vcc__";
+
+export interface CompactionStats {
+  summarized: number;
+  kept: number;
+  keptTokensEst: number;
+}
+
+let lastStats: CompactionStats | null = null;
+let lastCompactWasPiVcc = false;
+export const getLastCompactionStats = () => lastStats;
+
+const formatTokens = (n: number): string => {
+  if (n >= 1000) return `${(n / 1000).toFixed(1)}k`;
+  return String(n);
+};
+
+const dbg = (settings: PiVccSettings, data: Record<string, unknown>) => {
+  if (!settings.debug) return;
+  try { writeFileSync("/tmp/pi-vcc-debug.json", JSON.stringify(data, null, 2)); } catch {}
+};
+
+const previewContent = (content: unknown): string => {
+  if (typeof content === "string") return content.slice(0, 300);
+  if (Array.isArray(content)) {
+    return content
+      .map((c: any) => {
+        if (c?.type === "text") return c.text ?? "";
+        if (c?.type === "toolCall") return `[toolCall:${c.name}]`;
+        if (c?.type === "thinking") return `[thinking]`;
+        if (c?.type === "image") return `[image:${c.mimeType}]`;
+        return `[${c?.type ?? "unknown"}]`;
+      })
+      .join("\n")
+      .slice(0, 300);
+  }
+  return "";
+};
+
+interface EntryWithMessage {
+  entry: { id: string; type: string };
+  message: { role: string; content: unknown };
+}
+
+export type OwnCutCancelReason =
+  | "no_live_messages"
+  | "too_few_live_messages";
+
+export type OwnCutResult =
+  | { ok: true; messages: any[]; firstKeptEntryId: string; compactAll: boolean }
+  | { ok: false; reason: OwnCutCancelReason };
+
+export function buildOwnCut(branchEntries: any[]): OwnCutResult {
+  // Find the last compaction entry and its firstKeptEntryId
+  let lastCompactionIdx = -1;
+  let lastKeptId: string | undefined;
+  for (let i = branchEntries.length - 1; i >= 0; i--) {
+    if (branchEntries[i].type === "compaction") {
+      lastCompactionIdx = i;
+      lastKeptId = branchEntries[i].firstKeptEntryId;
+      break;
+    }
+  }
+
+  // Orphan recovery: triggers when lastKeptId is set to "" (sentinel from prior
+  // compact-all) OR set to an id that no longer exists in the branch. In both cases,
+  // start collecting from right after the last compaction entry.
+  const hasPriorCompaction = lastCompactionIdx >= 0;
+  const hasValidKeptId = !!lastKeptId && branchEntries.some((e: any) => e.id === lastKeptId);
+  const orphanRecovery = hasPriorCompaction && !hasValidKeptId;
+
+  // Collect live messages
+  const liveMessages: EntryWithMessage[] = [];
+  if (orphanRecovery) {
+    for (let i = lastCompactionIdx + 1; i < branchEntries.length; i++) {
+      const e = branchEntries[i];
+      if (e.type === "compaction") continue;
+      if (e.type === "message" && e.message) {
+        liveMessages.push({ entry: e, message: e.message });
+      }
+    }
+  } else {
+    let foundKept = !lastKeptId; // if no prior compaction, start collecting immediately
+    for (const e of branchEntries) {
+      if (!foundKept && e.id === lastKeptId) foundKept = true;
+      if (!foundKept) continue;
+      if (e.type === "compaction") continue;
+      if (e.type === "message" && e.message) {
+        liveMessages.push({ entry: e, message: e.message });
+      }
+    }
+  }
+
+  if (liveMessages.length === 0) return { ok: false, reason: "no_live_messages" };
+  if (liveMessages.length <= 2) return { ok: false, reason: "too_few_live_messages" };
+
+  // Summarize all messages, keep only the last user message as context
+  let cutIdx = liveMessages.length - 1;
+  while (cutIdx > 0 && liveMessages[cutIdx].message.role !== "user") {
+    cutIdx--;
+  }
+
+  if (cutIdx <= 0) {
+    // Single user prompt scenario (or no user at all).
+    // Compact EVERYTHING and keep no tail. This handles both:
+    //  - Single user prompt at index 0: compact all, fresh start after summary
+    //  - No user message at all (e.g., long assistant/tool chain): still compact
+    //    to recover from context overflow rather than cancelling and leaving
+    //    the session unrecoverable.
+    // 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 {
+      ok: true,
+      messages: liveMessages.map((e) => e.message),
+      firstKeptEntryId: "",
+      compactAll: true,
+    };
+  }
+
+  return {
+    ok: true,
+    messages: liveMessages.slice(0, cutIdx).map((e) => e.message),
+    firstKeptEntryId: liveMessages[cutIdx].entry.id,
+    compactAll: false,
+  };
+}
+
+const REASON_MESSAGES: Record<OwnCutCancelReason, string> = {
+  no_live_messages: "pi-vcc: Nothing to compact (no live messages)",
+  too_few_live_messages: "pi-vcc: Too few messages to compact",
+};
+
+export const registerBeforeCompactHook = (pi: ExtensionAPI) => {
+  pi.on("session_before_compact", (event, ctx) => {
+    const { preparation, branchEntries, customInstructions } = event;
+    const settings = loadSettings();
+
+    // Always handle explicit /pi-vcc marker.
+    // Otherwise, only handle when user opted in via settings.
+    const isPiVcc = customInstructions === PI_VCC_COMPACT_INSTRUCTION;
+    if (!isPiVcc && !settings.overrideDefaultCompaction) return;
+
+    const ownCut = buildOwnCut(branchEntries as any[]);
+    if (!ownCut.ok) {
+      const lastComp = [...branchEntries].reverse().find((e: any) => e.type === "compaction");
+      const lastCompIdx = lastComp ? (branchEntries as any[]).indexOf(lastComp) : -1;
+
+      // Recompute liveMessages view (same logic as buildOwnCut) for diagnostic
+      const lastKeptId: string | undefined = lastComp?.firstKeptEntryId;
+      const hasPriorCompaction = lastCompIdx >= 0;
+      const hasValidKeptId = !!lastKeptId && (branchEntries as any[]).some((e: any) => e.id === lastKeptId);
+      const diagOrphan = hasPriorCompaction && !hasValidKeptId;
+      const liveRoles: string[] = [];
+      if (diagOrphan) {
+        for (let i = lastCompIdx + 1; i < branchEntries.length; i++) {
+          const e = (branchEntries as any[])[i];
+          if (e.type === "compaction") continue;
+          if (e.type === "message" && e.message) liveRoles.push(e.message.role);
+        }
+      } else {
+        let foundKept = !lastKeptId;
+        for (const e of branchEntries as any[]) {
+          if (!foundKept && e.id === lastKeptId) foundKept = true;
+          if (!foundKept) continue;
+          if (e.type === "compaction") continue;
+          if (e.type === "message" && e.message) liveRoles.push(e.message.role);
+        }
+      }
+      const userIndices = liveRoles.reduce<number[]>((acc, r, i) => (r === "user" ? (acc.push(i), acc) : acc), []);
+
+      dbg(settings, {
+        cancelled: true,
+        reason: ownCut.reason,
+        isPiVcc,
+        counts: {
+          total: branchEntries.length,
+          messages: (branchEntries as any[]).filter((e: any) => e.type === "message").length,
+          compactions: (branchEntries as any[]).filter((e: any) => e.type === "compaction").length,
+          entriesAfterLastCompaction: lastCompIdx >= 0 ? branchEntries.length - lastCompIdx - 1 : null,
+        },
+        liveMessages: {
+          count: liveRoles.length,
+          userCount: userIndices.length,
+          firstUserIdx: userIndices[0] ?? null,
+          lastUserIdx: userIndices[userIndices.length - 1] ?? null,
+          roleSequence: liveRoles.length <= 30
+            ? liveRoles
+            : [...liveRoles.slice(0, 10), "...", ...liveRoles.slice(-10)],
+        },
+        lastCompaction: lastComp ? {
+          hasFirstKeptEntryId: !!lastComp.firstKeptEntryId,
+          foundInBranch: lastComp.firstKeptEntryId
+            ? (branchEntries as any[]).some((e: any) => e.id === lastComp.firstKeptEntryId)
+            : null,
+        } : null,
+        tail: (branchEntries as any[]).slice(-5).map((e: any) => ({
+          type: e.type,
+          role: e.type === "message" ? e.message?.role : undefined,
+          hasContent: e.type === "message" ? e.message?.content != null : undefined,
+        })),
+      });
+
+      try {
+        ctx?.ui?.notify?.(REASON_MESSAGES[ownCut.reason], "warning");
+      } catch {}
+      return { cancel: true };
+    }
+
+    const agentMessages = ownCut.messages;
+    const firstKeptEntryId = ownCut.firstKeptEntryId;
+    const messages = convertToLlm(agentMessages);
+
+    // Count kept messages and estimate tokens
+    const keptIdx = (branchEntries as any[]).findIndex((e: any) => e.id === firstKeptEntryId);
+    const keptEntries = keptIdx >= 0
+      ? (branchEntries as any[]).slice(keptIdx).filter((e: any) => e.type === "message")
+      : [];
+    const keptChars = keptEntries.reduce((sum: number, e: any) => {
+      const c = e.message?.content;
+      if (typeof c === "string") return sum + c.length;
+      if (Array.isArray(c)) return sum + c.reduce((s: number, p: any) => {
+        if (p.text) return s + p.text.length;
+        if (p.type === "toolCall") return s + (p.name?.length ?? 0) + (typeof p.input === "string" ? p.input.length : JSON.stringify(p.input ?? "").length);
+        if (p.type === "toolResult") return s + (typeof p.content === "string" ? p.content.length : JSON.stringify(p.content ?? "").length);
+        return s;
+      }, 0);
+      return sum;
+    }, 0);
+    lastStats = {
+      summarized: agentMessages.length,
+      kept: keptEntries.length,
+      keptTokensEst: Math.round(keptChars / 4),
+    };
+
+    const config = settings;
+
+    const summary = compile({
+      messages,
+      previousSummary: preparation.previousSummary,
+      fileOps: {
+        readFiles: [...preparation.fileOps.read],
+        modifiedFiles: [...preparation.fileOps.written, ...preparation.fileOps.edited],
+      },
+    });
+
+    const branchIds = branchEntries.map((e: any) => e.id);
+    const cutIdx = branchIds.indexOf(firstKeptEntryId);
+    const cutWindow = cutIdx >= 0
+      ? branchEntries.slice(Math.max(0, cutIdx - 3), Math.min(branchEntries.length, cutIdx + 3)).map((e: any) => ({
+          id: e.id,
+          type: e.type,
+          role: e.type === "message" ? e.message?.role : undefined,
+          preview: e.type === "message" ? previewContent(e.message?.content) : undefined,
+        }))
+      : [];
+
+    dbg(config, {
+      usedOwnCut: true,
+      messagesToSummarize: agentMessages.length,
+      messagesPreviewHead: agentMessages.slice(0, 3).map((m: any) => ({ role: m.role, preview: previewContent(m.content) })),
+      messagesPreviewTail: agentMessages.slice(-3).map((m: any) => ({ role: m.role, preview: previewContent(m.content) })),
+      convertedMessages: messages.length,
+      firstKeptEntryId,
+      cutWindow,
+      tokensBefore: preparation.tokensBefore,
+      summaryLength: summary.length,
+      summaryPreview: summary.slice(0, 500),
+      sections: [...summary.matchAll(/^\[(.+?)\]/gm)].map((m) => m[1]),
+    });
+
+    const details: PiVccCompactionDetails = {
+      compactor: "ultimate-pi-vcc",
+      version: 1,
+      sections: [...summary.matchAll(/^\[(.+?)\]/gm)].map((m) => m[1]),
+      sourceMessageCount: agentMessages.length,
+      previousSummaryUsed: Boolean(preparation.previousSummary),
+    };
+
+    lastCompactWasPiVcc = isPiVcc;
+
+    return {
+      compaction: {
+        summary,
+        details,
+        tokensBefore: preparation.tokensBefore,
+        firstKeptEntryId,
+      },
+    };
+  });
+
+  // Fire success toast for /compact path only (delayed to let UI settle).
+  // /pi-vcc path uses its own onComplete callback in the command handler.
+  pi.on("session_compact", (event, ctx) => {
+    if (!event.fromExtension) return;
+    if (lastCompactWasPiVcc) return; // /pi-vcc handles its own toast via onComplete
+    const stats = lastStats;
+    if (!stats) return;
+    setTimeout(() => {
+      try {
+        ctx?.ui?.notify?.(
+          `pi-vcc: ${stats.summarized} source entries processed; tail kept ${stats.kept} (~${formatTokens(stats.keptTokensEst)} tok).`,
+          "info",
+        );
+      } catch {}
+    }, 500);
+  });
+};

package/vendor/pi-vcc/src/sections.ts

@@ -0,0 +1,12 @@
+import type { TranscriptEntry } from "./core/brief";
+
+export interface SectionData {
+  sessionGoal: string[];
+  outstandingContext: string[];
+  filesAndChanges: string[];
+  commits: string[];
+  userPreferences: string[];
+  briefTranscript: string;
+  /** Structured transcript entries (verbose object format) */
+  transcriptEntries: TranscriptEntry[];
+}