@pi-unipi/compactor 2.6.1 → 2.6.2

package/README.md

@@ -51,7 +51,7 @@ Per-project config is merged over global config when the current project directo
 | `/unipi:compact-preset <name>` | Applies a preset globally. | Names: `precise`, `balanced`, `thorough`, `lean`. Old names map to new ones: `opencode→precise`, `verbose→thorough`, `minimal→lean`. |
 | `/unipi:compact-help` | Shows compact help inside Pi. | Quick command reference. |
 
-Content/project indexing is handled by `@pi-unipi/cocoindex`, not this package. Use `/unipi:cocoindex-init`, `/unipi:cocoindex-update`, and `cocoindex_search` for indexed project search.
+Content/project indexing is not part of this package. Use `read`/`bash` (rg) for project search.
 
 ---
 
@@ -102,7 +102,7 @@ These settings control what is extracted into compaction summaries or how relate
 | `Session Continuity` | `full`, `off` | Controls XML-style resume snapshots. Off prevents snapshot creation and injection; Pi’s normal compaction summary still remains. |
 | `Sandbox Execution` | `all`, `off` | Controls sandbox tool registration. Changes require a session reload. Allowed languages and output limit are enforced from config. |
 
-Config-only legacy field: `fts5Index` remains in the schema for compatibility, but project indexing has moved to `@pi-unipi/cocoindex`. It is hidden from Compactor settings and presets. Legacy `sessionContinuity.mode: "essential-only"`, `eventCategories`, and `sandboxExecution.mode: "safe-only"` values remain loadable; essential-only behaves as full and safe-only behaves as enabled/all until explicit filtering/security policies are designed. Legacy `toolDisplay` and `showTruncationHints` fields also remain loadable but are deprecated and ignored; their profile names were never mapped to runtime renderer modes. Narrow-terminal diff clamping remains active as independent safety behavior.
+Config-only legacy field: `fts5Index` remains in the schema for compatibility. It is hidden from Compactor settings and presets. Legacy `sessionContinuity.mode: "essential-only"`, `eventCategories`, and `sandboxExecution.mode: "safe-only"` values remain loadable; essential-only behaves as full and safe-only behaves as enabled/all until explicit filtering/security policies are designed. Legacy `toolDisplay` and `showTruncationHints` fields also remain loadable but are deprecated and ignored; their profile names were never mapped to runtime renderer modes. Narrow-terminal diff clamping remains active as independent safety behavior.
 
 ### Auto tab
 
@@ -112,7 +112,7 @@ These settings control UniPi-managed percentage auto-compaction. They are separa
 
 | Setting | Default | Meaning |
 |---|---:|---|
-| `Percentage Trigger` | `off` | When on, UniPi checks context usage at `turn_end` and can call compaction when the threshold is reached. Disabled by default for backward compatibility. |
+| `Percentage Trigger` | `off` | When on, UniPi checks context usage at `agent_end` (after the agent run settles) and can call compaction when the threshold is reached. Disabled by default for backward compatibility. |
 | `Threshold` | `80%` | Trigger point using Pi's live `ctx.getContextUsage().percent`. |
 | `Cooldown` | `60s` | Minimum time between UniPi-triggered compaction attempts. Prevents loops. |
 | `Repeat Growth` | `4k` | If usage is still above threshold after compaction, require this many new tokens before triggering again. |
@@ -217,10 +217,11 @@ Typical session order:
    - Updates runtime byte/tool counters.
    - Applies display overrides and width-safe diff clamping before output reaches the TUI.
 
-6. **`turn_end`**
+6. **`agent_end`**
    - If percentage auto-compaction is enabled, reads `ctx.getContextUsage()`.
    - Runs cooldown/repeat-growth safeguards.
    - Calls `ctx.compact({ customInstructions: COMPACTOR_INSTRUCTION })` when eligible.
+   - Fires only after the agent run settles: `ctx.compact()` aborts any active operation first, so triggering mid-run (e.g. at `turn_end`) would kill the next provider request.
 
 7. **Pi decides to compact**
    - This can be from `/unipi:lossless-compact`, UniPi percentage auto-compaction, or Pi core's reserve-token fallback.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/compactor",
-  "version": "2.6.1",
+  "version": "2.6.2",
   "description": "Context engine for Pi — zero-LLM compaction, session continuity, sandbox execution, and tool display optimization",
   "type": "module",
   "main": "src/index.ts",

package/skills/compactor/SKILL.md

@@ -12,7 +12,7 @@ description: Context management — compact session, recall history, run code, s
 
 ## Finding Past Work
 - `session_recall(query)` → search this session (BM25 or regex), including raw messages that may no longer be in live context after compaction.
-- For indexed project/file search, use the CocoIndex package (`cocoindex_search`) when installed; content indexing no longer lives in compactor.
+- For project/file search, use `read`/`bash` (rg) directly; content indexing is not part of compactor.
 
 ## Running Code
 - `sandbox(lang, code)` → single script. `sandbox_batch(items)` → atomic.

package/skills/compactor-detail/SKILL.md

@@ -88,7 +88,7 @@ Estimate remaining context tokens and percent full. Uses Pi's live context usage
 ## Anti-Patterns
 
 1. **Don't compact in a tight loop.** Use `context_budget` first and compact at natural break points.
-2. **Don't use `session_recall` for project-wide code search.** It searches the conversation/session. Use CocoIndex (`cocoindex_search`) for indexed files when installed.
+2. **Don't use `session_recall` for project-wide code search.** It searches the conversation/session only — use `read`/`bash`(rg) for files.
 3. **Don't use `sandbox` for file operations.** Use normal file tools for reads/writes; sandbox is for computation or quick scripts.
 4. **Don't use empty or vague recall queries.** Search for specific filenames, issue numbers, commands, or decisions.
 5. **Don't compact mid-thought if avoidable.** Finish the current step, then compact.
@@ -112,7 +112,5 @@ Estimate remaining context tokens and percent full. Uses Pi's live context usage
 3. `compactor_stats` — confirm compactions/savings are recorded.
 
 ### Project Search
-Compactor no longer owns project content indexing. Use the CocoIndex package if installed:
-1. `/unipi:cocoindex-init`
-2. `/unipi:cocoindex-update`
-3. `cocoindex_search(query)`
+Compactor does not own project content indexing. For code search use `bash` with rg.
+1. `bash` with `rg` for code search

package/skills/compactor-doctor/SKILL.md

@@ -68,4 +68,4 @@ python3 --version
 bash --version
 ```
 
-Project content indexing diagnostics live in the CocoIndex package, not compactor.
+Project content indexing is not part of compactor.

package/skills/compactor-stats/SKILL.md

@@ -48,4 +48,4 @@ This means:
 - 3 compactions saved roughly 15K tokens.
 - 7 sandbox executions and 15 recall/search queries were recorded.
 
-Project content indexing stats are not owned by compactor anymore; use the CocoIndex package for indexed file search/status.
+Project content indexing stats are not owned by compactor; use `read`/`bash` (rg) for file search.

package/src/commands/index.ts

@@ -8,13 +8,14 @@
 import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
 import { loadConfig, saveConfig } from "../config/manager.js";
 import { applyPreset, parsePreset } from "../config/presets.js";
-import { COMPACTOR_INSTRUCTION } from "@pi-unipi/core";
-import { getLastCompactionStats } from "../compaction/hooks.js";
+import { COMPACTOR_INSTRUCTION, formatTokens } from "@pi-unipi/core";
+import { getLastCompactionStats, formatCompactionStats } from "../compaction/hooks.js";
 import { vccRecall } from "../tools/vcc-recall.js";
 import { ctxStats } from "../tools/ctx-stats.js";
 import { ctxDoctor } from "../tools/ctx-doctor.js";
 import { recallBlocksFromContext } from "../session/recall-blocks.js";
 import { filterNoise } from "../compaction/filter-noise.js";
+import { parseRecallScope } from "../compaction/recall-scope.js";
 import type { SessionDB } from "../session/db.js";
 import type { NormalizedBlock, RuntimeCounters } from "../types.js";
 
@@ -25,77 +26,55 @@ export interface CommandDeps {
   getCounters?: () => RuntimeCounters;
 }
 
-function deprecationLog(_oldName: string, _newName: string): void {
-  // Deprecation logging disabled — was writing to stdout causing TUI rendering issues.
-}
-
-const formatTokens = (n: number): string => {
-  if (n >= 1000) return `${(n / 1000).toFixed(1)}k`;
-  return String(n);
-};
-
 export function registerCommands(pi: ExtensionAPI, deps?: CommandDeps): void {
   // ── /unipi:lossless-compact ──────────────────────────
+  const losslessCompactHandler = async (_args: string, ctx: ExtensionCommandContext) => {
+    ctx.compact({
+      customInstructions: COMPACTOR_INSTRUCTION,
+      onComplete: () => {
+        const stats = getLastCompactionStats();
+        if (stats) {
+          ctx.ui.notify(formatCompactionStats(stats), "info");
+        } else {
+          ctx.ui.notify("Compaction completed.", "info");
+        }
+      },
+      onError: (err: Error) => {
+        if (err.message === "Compaction cancelled" || err.message === "Already compacted") {
+          ctx.ui.notify("Nothing to compact.", "info");
+        } else {
+          ctx.ui.notify(`Compaction failed: ${err.message}`, "error");
+        }
+      },
+    });
+  };
   pi.registerCommand("unipi:lossless-compact", {
     description: "Immediate zero-LLM compaction — structured summary with full recall",
-    handler: async (_args: string, ctx: ExtensionCommandContext) => {
-      ctx.compact({
-        customInstructions: COMPACTOR_INSTRUCTION,
-        onComplete: () => {
-          const stats = getLastCompactionStats();
-          if (stats) {
-            ctx.ui.notify(
-              `Compacted ${stats.totalMessages} messages (~${formatTokens(stats.tokensBefore)} tokens) → ${stats.kept} messages (~${formatTokens(stats.tokensAfterEst)} tokens)`,
-              "info",
-            );
-          } else {
-            ctx.ui.notify("Compaction completed.", "info");
-          }
-        },
-        onError: (err: Error) => {
-          if (err.message === "Compaction cancelled" || err.message === "Already compacted") {
-            ctx.ui.notify("Nothing to compact.", "info");
-          } else {
-            ctx.ui.notify(`Compaction failed: ${err.message}`, "error");
-          }
-        },
-      });
-    },
+    handler: losslessCompactHandler,
   });
-  // Deprecated alias — old name
   pi.registerCommand("unipi:compact", {
-    description: "(DEPRECATED) Use /unipi:lossless-compact instead",
-    handler: async (_args: string, ctx: ExtensionCommandContext) => {
-      deprecationLog("/unipi:compact", "/unipi:lossless-compact");
-      ctx.compact({
-        customInstructions: COMPACTOR_INSTRUCTION,
-        onComplete: () => {
-          const stats = getLastCompactionStats();
-          if (stats) {
-            ctx.ui.notify(
-              `Compacted ${stats.totalMessages} messages (~${formatTokens(stats.tokensBefore)} tokens) → ${stats.kept} messages (~${formatTokens(stats.tokensAfterEst)} tokens)`,
-              "info",
-            );
-          } else {
-            ctx.ui.notify("Compaction completed.", "info");
-          }
-        },
-        onError: (err: Error) => {
-          if (err.message === "Compaction cancelled" || err.message === "Already compacted") {
-            ctx.ui.notify("Nothing to compact.", "info");
-          } else {
-            ctx.ui.notify(`Compaction failed: ${err.message}`, "error");
-          }
-        },
-      });
-    },
+    description: "Alias for /unipi:lossless-compact",
+    handler: losslessCompactHandler,
   });
 
   // ── /unipi:session-recall (new) ─────────────────────
+  // pi-vcc parity: results are sent as a visible custom message AND fed to the
+  // agent as context (triggerTurn), so recall results drive the next turn.
   const sessionRecallHandler = async (args: string, ctx: ExtensionCommandContext, commandName = "/unipi:session-recall") => {
-    const query = args.trim();
+    const raw = args.trim();
+    const suffix = commandName === "/unipi:compact-recall" ? " (deprecated; use /unipi:session-recall <query>)" : "";
+    if (!raw) {
+      ctx.ui.notify(`Usage: ${commandName} <query>${suffix}`, "warning");
+      return;
+    }
+
+    // Parse scope:all and page:N inline (pi-vcc parity)
+    const parsed = parseRecallScope(raw);
+    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) {
-      const suffix = commandName === "/unipi:compact-recall" ? " (deprecated; use /unipi:session-recall <query>)" : "";
       ctx.ui.notify(`Usage: ${commandName} <query>${suffix}`, "warning");
       return;
     }
@@ -109,25 +88,20 @@ export function registerCommands(pi: ExtensionAPI, deps?: CommandDeps): void {
       ctx.ui.notify("No session history available for search.", "warning");
       return;
     }
-    const result = vccRecall(blocks, { query, limit: 10 });
-    if (result.hits.length === 0) {
-      ctx.ui.notify(`No results for "${query}".`, "info");
-      return;
-    }
-    const lines = result.hits.map(
-      (h, i) => `[${i + 1}] score=${h.score.toFixed(2)} kind=${h.kind}\n${h.text.slice(0, 200)}`,
+    const result = vccRecall(blocks, { query, scope: parsed.scope, page });
+    pi.sendMessage(
+      { customType: "compactor-recall", content: result.text, display: true },
+      { triggerTurn: true },
     );
-    ctx.ui.notify(`Found ${result.total} results:\n${lines.join("\n\n")}`, "info");
   };
   pi.registerCommand("unipi:session-recall", {
-    description: "Search session history (BM25 or regex)",
+    description: "Recall earlier parts of this session. Plain keywords work best; add scope:all to reach edited or retried turns.",
     handler: sessionRecallHandler,
   });
   // Deprecated alias
   pi.registerCommand("unipi:compact-recall", {
     description: "(DEPRECATED) Search session history — use /unipi:session-recall instead",
     handler: async (args: string, ctx: ExtensionCommandContext) => {
-      deprecationLog("/unipi:compact-recall", "/unipi:session-recall");
       return sessionRecallHandler(args, ctx, "/unipi:compact-recall");
     },
   });
@@ -233,12 +207,7 @@ export function registerCommands(pi: ExtensionAPI, deps?: CommandDeps): void {
         "  /unipi:compact-preset <name> — apply preset\n" +
         "\n" +
         "Percentage trigger:\n" +
-        "  Disabled by default. Enable in /unipi:compact-settings to compact at a context % before Pi's reserve-token limit.\n" +
-        "\n" +
-        "Content indexing has moved to @pi-unipi/cocoindex:\n" +
-        "  /unipi:cocoindex-init — initialize pipeline\n" +
-        "  /unipi:cocoindex-update — index project files\n" +
-        "  cocoindex_search — search indexed content",
+        "  Disabled by default. Enable in /unipi:compact-settings to compact at a context % before Pi's reserve-token limit.",
         "info",
       );
     },

package/src/compaction/brief.ts

@@ -3,11 +3,16 @@
  */
 
 import type { NormalizedBlock } from "../types.js";
-import { clip, firstLine } from "./content.js";
+import { clip } from "./content.js";
 import { extractPath } from "./extract/files.js";
+import { collapseSkillText } from "./skill-collapse.js";
 
 const TRUNCATE_USER = 256;
-const TRUNCATE_ASSISTANT = 200;
+const SEGMENT_CLOSING_ASSISTANT_HEAD_WORDS = 120;
+const SEGMENT_CLOSING_ASSISTANT_TAIL_WORDS = 120;
+const ASSISTANT_HEAD_WORDS = 80;
+const ASSISTANT_TAIL_WORDS = 120;
+const MIN_SEGMENT_CLOSING_ASSISTANT_CHARS = 120;
 
 const SELF_TALK_PREFIX_RE =
   /^\s*(?:hmm|wait|actually|oh|okay|ok|well|so)[,.!\s-]+/i;
@@ -33,8 +38,15 @@ const STOP_WORDS = new Set([
   "if", "then", "than", "when", "where", "how", "just", "also",
 ]);
 
+const normalizeForTokenBudget = (text: string): string =>
+  text
+    .replace(/\r\n?/g, "\n")
+    .replace(/[^\S\n]+/g, " ")
+    .replace(/\n{3,}/g, "\n\n")
+    .trim();
+
 const truncateTokens = (text: string, limit: number): string => {
-  const flat = text.replace(/\s+/g, " ").trim();
+  const flat = normalizeForTokenBudget(text);
   let count = 0;
   let lastEnd = 0;
   for (const seg of segmenter.segment(flat)) {
@@ -51,17 +63,138 @@ const truncateTokens = (text: string, limit: number): string => {
   return flat;
 };
 
-const BASH_CAP = 120;
+/** Word spans excluding stop words — positions into the normalized flat text */
+const significantWordSpans = (flat: string): { start: number; end: number }[] => {
+  const words: { start: number; end: number }[] = [];
+  for (const seg of segmenter.segment(flat)) {
+    if (!isWord(seg)) continue;
+    if (STOP_WORDS.has(seg.segment.toLowerCase())) continue;
+    words.push({ start: seg.index, end: seg.index + seg.segment.length });
+  }
+  return words;
+};
+
+/** Keep the first headLimit and last tailLimit significant words; elide the middle */
+const truncateTokensHeadTail = (text: string, headLimit: number, tailLimit: number): string => {
+  const flat = normalizeForTokenBudget(text);
+  if (headLimit <= 0 || tailLimit <= 0) return flat;
+  const words = significantWordSpans(flat);
+  if (words.length <= headLimit + tailLimit) return flat;
+  const head = flat.slice(0, words[headLimit - 1].end).trimEnd();
+  const tail = flat.slice(words[words.length - tailLimit].start).trimStart();
+  return `${head}\n...(middle truncated)...\n${tail}`;
+};
+
+const nextRenderableBlock = (blocks: NormalizedBlock[], index: number): NormalizedBlock | undefined => {
+  for (let i = index + 1; i < blocks.length; i++) {
+    if (blocks[i].kind !== "tool_result") return blocks[i];
+  }
+  return undefined;
+};
+
+const isSegmentClosingAssistant = (blocks: NormalizedBlock[], index: number): boolean => {
+  if (blocks[index]?.kind !== "assistant") return false;
+  const next = nextRenderableBlock(blocks, index);
+  return !next || next.kind === "user";
+};
+
+// ── bash command compression ──
+
+const BASH_CAP = 240;
 const PIPE_TAIL_RE = /\s*\|\s*(?:head|tail|sort|wc|column|tr|cut|awk|uniq|python3|node|bun)(?:\s[^|]*)?$/;
+// Preamble/boilerplate lines that carry no durable fact on their own. Dropped
+// when a script has more informative lines, so `set -euo pipefail\ngit commit`
+// renders the commit rather than the shell option.
+const TRIVIAL_LINE_RE = /^(?:set\s+[-+]|cd\s+\S+$|export\s+\w+=|(?:source|\.)\s+\S+|pwd$|true$|:$|#)/;
+// A real heredoc opener: `<<` at a command boundary — not preceded by a word
+// char or `)`, so shift ops (`8 << 20`, `Rd<<8`) are not misread — with an
+// identifier terminator starting [A-Za-z_], so numeric `<< 10` is rejected too.
+export const HEREDOC_OPEN_RE = /(?<![\w)])<<-?\s*["']?([A-Za-z_]\w*)["']?/;
+// File-writer heredocs (`cat > f <<EOF`, tee, dd) already name their target, so
+// the opener alone is informative → body-only. EVERY other heredoc has a
+// content-free opener (interpreters python3/node, remote shells `ssh host <<CMD`,
+// sqlite3, ...) → we surface a one-line body preview.
+const FILEWRITER_HEREDOC_RE = /(?:^|[|&;]\s*)(?:cat|tee|dd)\b/;
+const HEREDOC_BODY_CAP = 80;
+// Body lines that are pure boilerplate and make a poor preview.
+const BODY_NOISE_RE = /^(?:import\s|from\s+\S+\s+import|require\(|const\s+\w+\s*=\s*require|#|\/\/|"""|'''|"use strict"|use\s+strict|<\?php)/;
 
-const compressBash = (raw: string): string => {
-  let cmd = raw.split("\n").map((l) => l.trim()).filter(Boolean)[0] ?? raw;
-  cmd = cmd.replace(/^cd\s+\S+\s*&&\s*/, "");
+/**
+ * If `lines[i]` opens a heredoc whose terminator actually appears on a later
+ * line, return that terminator's line index; otherwise -1. Callers use -1 to
+ * leave following lines intact instead of treating a stray `<<` (a shift op, a
+ * quoted string, or a truncated body) as a heredoc and skipping real commands.
+ */
+export const heredocCloseIndex = (lines: string[], i: number): number => {
+  const hd = lines[i].match(HEREDOC_OPEN_RE);
+  if (!hd) return -1;
+  const term = hd[1];
+  for (let j = i + 1; j < lines.length; j++) {
+    if (lines[j].trim() === term) return j;
+  }
+  return -1;
+};
+
+const stripCdPrefix = (line: string): string => line.replace(/^cd\s+\S+\s*&&\s*/, "").trim();
+const stripPipeTail = (line: string): string => {
+  let c = line;
   for (let i = 0; i < 3; i++) {
-    const stripped = cmd.replace(PIPE_TAIL_RE, "");
-    if (stripped === cmd) break;
-    cmd = stripped;
+    const stripped = c.replace(PIPE_TAIL_RE, "");
+    if (stripped === c) break;
+    c = stripped;
   }
+  return c.trim();
+};
+
+/**
+ * Semantic compression of a (possibly multi-line) bash command.
+ * 1. Drop heredoc BODIES (keep the opener line, e.g. `cat > f <<EOF` or
+ *    `python3 - <<PY`): the body is prose/script content that bloats the brief
+ *    without adding countable facts, while the opener still records what ran.
+ * 2. Drop trivial preamble lines (set -euo pipefail, cd-only, export, source,
+ *    comments) unless they are the ONLY line, so real work below them surfaces.
+ * 3. Strip `cd <path> &&` prefixes and pipe-tail formatting per line.
+ * 4. Join the remaining meaningful lines with `; ` and cap length.
+ */
+const compressBash = (raw: string): string => {
+  // Pass 1: keep heredoc opener lines, skip their bodies + terminators.
+  const rawLines = raw.split("\n");
+  const withoutHeredocBodies: string[] = [];
+  for (let i = 0; i < rawLines.length; i++) {
+    const line = rawLines[i];
+    withoutHeredocBodies.push(line);
+    // Only treat this as a heredoc when its terminator appears downstream; a
+    // stray `<<` (string/expression or truncated body) leaves later lines intact.
+    const close = heredocCloseIndex(rawLines, i);
+    if (close === -1) continue;
+    // File-writer heredocs (`cat > f <<EOF`) name their target → keep opener only.
+    // Every other heredoc has a content-free opener → grab the first meaningful
+    // body line as a preview (`python3 - <<PY`, `ssh host <<CMD`, `sqlite3 <<SQL`).
+    const wantPreview = !FILEWRITER_HEREDOC_RE.test(line);
+    let preview = "";
+    for (let j = i + 1; wantPreview && !preview && j < close; j++) {
+      const t = rawLines[j].trim();
+      if (t && !BODY_NOISE_RE.test(t)) preview = t;
+    }
+    if (preview) {
+      const clipped = preview.length > HEREDOC_BODY_CAP ? preview.slice(0, HEREDOC_BODY_CAP - 1) + "\u2026" : preview;
+      withoutHeredocBodies[withoutHeredocBodies.length - 1] = `${line.trim()} ${clipped}`;
+    }
+    i = close; // for-loop's i++ then skips past the terminator line
+  }
+
+  const lines = withoutHeredocBodies.map((l) => l.trim()).filter(Boolean);
+  if (lines.length === 0) return raw.trim();
+
+  const meaningful = lines
+    .filter((l) => !TRIVIAL_LINE_RE.test(l))
+    .map((l) => stripPipeTail(stripCdPrefix(l)))
+    .filter(Boolean);
+  // If everything was trivial (e.g. a bare `set -e` or `ls`), fall back to the
+  // first line so we never emit an empty marker.
+  const chosen = meaningful.length ? meaningful : [stripPipeTail(stripCdPrefix(lines[0]))].filter(Boolean);
+
+  const cmd = chosen.join("; ");
   if (cmd.length > BASH_CAP) {
     return cmd.slice(0, BASH_CAP - 3) + "...";
   }
@@ -97,15 +230,6 @@ export interface BriefLine {
   lines: string[];
 }
 
-export interface TranscriptEntry {
-  role: "user" | "assistant" | "tool_error";
-  text?: string;
-  tool?: string;
-  cmd?: string;
-  ref?: string;
-  count?: number;
-}
-
 export const buildBriefSections = (blocks: NormalizedBlock[]): BriefLine[] => {
   const sections: BriefLine[] = [];
   let lastHeader = "";
@@ -119,14 +243,23 @@ export const buildBriefSections = (blocks: NormalizedBlock[]): BriefLine[] => {
     lastHeader = header;
   };
 
-  for (const b of blocks) {
+  const pushText = (header: string, text: string, ref = "") => {
+    const lines = text.split("\n");
+    if (ref && lines.length > 0) {
+      lines[lines.length - 1] = `${lines[lines.length - 1]}${ref}`;
+    }
+    for (const line of lines) push(header, line);
+  };
+
+  for (let blockIndex = 0; blockIndex < blocks.length; blockIndex++) {
+    const b = blocks[blockIndex];
     switch (b.kind) {
       case "user": {
         if (!b.text.trim()) break;
-        const text = truncateTokens(b.text, TRUNCATE_USER);
+        const text = truncateTokens(collapseSkillText(b.text), TRUNCATE_USER);
         if (text) {
           const ref = b.sourceIndex != null ? ` (#${b.sourceIndex})` : "";
-          push("[user]", text + ref);
+          pushText("[user]", text, ref);
         }
         lastHeader = "[user]";
         break;
@@ -138,10 +271,12 @@ export const buildBriefSections = (blocks: NormalizedBlock[]): BriefLine[] => {
           if (stripped === raw) break;
           raw = stripped;
         }
-        const text = truncateTokens(raw, TRUNCATE_ASSISTANT);
+        const text = isSegmentClosingAssistant(blocks, blockIndex)
+          ? truncateTokensHeadTail(raw, SEGMENT_CLOSING_ASSISTANT_HEAD_WORDS, SEGMENT_CLOSING_ASSISTANT_TAIL_WORDS)
+          : truncateTokensHeadTail(raw, ASSISTANT_HEAD_WORDS, ASSISTANT_TAIL_WORDS);
         if (text) {
           const ref = b.sourceIndex != null ? ` (#${b.sourceIndex})` : "";
-          push("[assistant]", text + ref);
+          pushText("[assistant]", text, ref);
         }
         break;
       }
@@ -154,7 +289,7 @@ export const buildBriefSections = (blocks: NormalizedBlock[]): BriefLine[] => {
       }
       case "tool_result": {
         if (b.isError) {
-          const body = firstLine(b.text, 150);
+          const body = b.text.split("\n").map((l) => l.trim()).filter(Boolean)[0] ?? "";
           if (!body || body === "(no output)") break;
           const ref = b.sourceIndex != null ? ` (#${b.sourceIndex})` : "";
           const header = `[tool_error] ${b.name}${ref}`;
@@ -265,70 +400,6 @@ export const stringifyBrief = (sections: BriefLine[]): string => {
   return out.join("\n");
 };
 
-const parseToolLine = (line: string): { tool: string; cmd?: string; ref?: string; count?: number } | null => {
-  const m = line.match(/^\* (\S+)\s*(?:"([^"]*)")?\s*(?:\((#[\d, #]+)\))?\s*(?:x(\d+))?$/);
-  if (!m) return null;
-  return {
-    tool: m[1],
-    cmd: m[2] || undefined,
-    ref: m[3] || undefined,
-    count: m[4] ? parseInt(m[4]) : undefined,
-  };
-};
-
-const extractRef = (text: string): { clean: string; ref?: string } => {
-  const m = text.match(/\s*\(#(\d+)\)$/);
-  if (!m) return { clean: text };
-  return { clean: text.slice(0, m.index).trimEnd(), ref: `#${m[1]}` };
-};
-
-export const sectionsToTranscript = (sections: BriefLine[]): TranscriptEntry[] => {
-  const entries: TranscriptEntry[] = [];
-
-  for (const sec of sections) {
-    if (sec.header === "[user]") {
-      for (const line of sec.lines) {
-        const { clean, ref } = extractRef(line);
-        entries.push({ role: "user", text: clean, ...(ref && { ref }) });
-      }
-    } else if (sec.header === "[assistant]") {
-      for (const line of sec.lines) {
-        if (line.startsWith("* ")) {
-          const parsed = parseToolLine(line);
-          if (parsed) {
-            entries.push({
-              role: "assistant",
-              tool: parsed.tool,
-              ...(parsed.cmd && { cmd: parsed.cmd }),
-              ...(parsed.ref && { ref: parsed.ref }),
-              ...(parsed.count && { count: parsed.count }),
-            });
-          } else {
-            const { clean, ref } = extractRef(line.slice(2));
-            entries.push({ role: "assistant", text: clean, ...(ref && { ref }) });
-          }
-        } else {
-          const { clean, ref } = extractRef(line);
-          entries.push({ role: "assistant", text: clean, ...(ref && { ref }) });
-        }
-      }
-    } else if (sec.header.startsWith("[tool_error]")) {
-      const headerMatch = sec.header.match(/^\[tool_error\]\s+(\S+)\s*(?:\(#(\d+)\))?/);
-      const tool = headerMatch?.[1] ?? "unknown";
-      const ref = headerMatch?.[2] ? `#${headerMatch[2]}` : undefined;
-      for (const line of sec.lines) {
-        entries.push({
-          role: "tool_error",
-          tool,
-          text: line,
-          ...(ref && { ref }),
-        });
-      }
-    }
-  }
-
-  return entries;
-};
-
+/** Render a set of blocks to a brief transcript string (used by ranked selection cost calc) */
 export const compileBrief = (blocks: NormalizedBlock[]): string =>
   stringifyBrief(buildBriefSections(blocks));

package/src/compaction/build-sections.ts

@@ -8,7 +8,7 @@ import { extractGoals } from "./extract/goals.js";
 import { extractFiles } from "./extract/files.js";
 import { extractPreferences, dedupPreferencesAgainstGoals } from "./extract/preferences.js";
 import { extractCommits, formatCommits } from "./extract/commits.js";
-import { buildBriefSections, sectionsToTranscript, stringifyBrief } from "./brief.js";
+import { buildBriefSections, stringifyBrief } from "./brief.js";
 import type { SectionData } from "../types.js";
 export type { SectionData } from "../types.js";
 
@@ -57,9 +57,9 @@ const formatFileActivity = (blocks: NormalizedBlock[]): string[] => {
   return lines;
 };
 
-export const buildSections = (input: { blocks: NormalizedBlock[] }): SectionData => {
+export const buildSections = (input: { blocks: NormalizedBlock[]; briefBlocks?: NormalizedBlock[] }): SectionData => {
   const { blocks } = input;
-  const briefSections = buildBriefSections(blocks);
+  const briefSections = buildBriefSections(input.briefBlocks ?? blocks);
   const sessionGoal = extractGoals(blocks);
   const userPreferences = dedupPreferencesAgainstGoals(
     extractPreferences(blocks),
@@ -72,6 +72,5 @@ export const buildSections = (input: { blocks: NormalizedBlock[] }): SectionData
     commits: formatCommits(extractCommits(blocks)),
     userPreferences,
     briefTranscript: stringifyBrief(briefSections),
-    transcriptEntries: sectionsToTranscript(briefSections),
   };
 };