pi-optimizer 0.7.0-alpha.4

package/index.js

@@ -0,0 +1,1984 @@
+// src/optimizer/deduplicator/index.ts
+import "@earendil-works/pi-coding-agent";
+
+// src/optimizer/entries.ts
+import { existsSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
+
+// src/utils.ts
+import { spawn } from "node:child_process";
+import { readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import {
+  keyHint,
+  SettingsManager,
+  truncateToVisualLines
+} from "@earendil-works/pi-coding-agent";
+import { Spacer, Text } from "@earendil-works/pi-tui";
+import { Container } from "@earendil-works/pi-tui";
+var PI_PATHS = {
+  web: "web-results",
+  agents: "agents",
+  settings: "settings.json",
+  mcp: "mcp.json",
+  permissions: "permissions.json",
+  checkpoints: "checkpoints",
+  subsessions: "subsessions.json",
+  subsessionsDir: "subsessions",
+  plans: "plans",
+  grammars: "grammars",
+  system: "SYSTEM.md"
+};
+function getPiPath(key, ...full) {
+  const path = PI_PATHS[key];
+  const remaining = path.includes(".") ? [] : full.slice(1);
+  const isGlobal = !full[0] || full[0] === "global";
+  const baseDir = isGlobal ? homedir() : full[0];
+  const piPath = isGlobal ? [".pi", "agent"] : [".pi"];
+  return join(baseDir, ...piPath, path, ...remaining);
+}
+async function readJson(filePath, fallback) {
+  try {
+    return JSON.parse(await readFile(filePath, "utf8"));
+  } catch {
+    return fallback;
+  }
+}
+async function writeJson(filePath, data) {
+  await writeFile(filePath, JSON.stringify(data, null, 2) + "\n", "utf8");
+}
+async function runCommand(cwd, command, argumentsList, options) {
+  const abortMessage = options?.abortMessage ?? "command aborted";
+  if (options?.signal?.aborted) {
+    throw new Error(abortMessage);
+  }
+  return await new Promise(
+    (resolveCommand, rejectCommand) => {
+      const executable = process.platform === "win32" ? `${command}.cmd` : command;
+      const childProcess = spawn(executable, argumentsList, {
+        cwd,
+        env: process.env,
+        signal: options?.signal,
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      let stdout = "";
+      let stderr = "";
+      childProcess.stdout.on("data", (chunk) => {
+        stdout += chunk.toString();
+      });
+      childProcess.stderr.on("data", (chunk) => {
+        stderr += chunk.toString();
+      });
+      childProcess.on("error", (error) => {
+        rejectCommand(error);
+      });
+      childProcess.on("close", (exitCode) => {
+        if (options?.signal?.aborted) {
+          rejectCommand(new Error(abortMessage));
+          return;
+        }
+        const successExitCodes = options?.successExitCodes ?? [0];
+        if (!successExitCodes.includes(exitCode ?? -1)) {
+          const commandText = `${command} ${argumentsList.join(" ")}`;
+          const stderrText = stderr.trim();
+          rejectCommand(
+            new Error(
+              `${commandText} failed with exit code ${exitCode ?? "unknown"}${stderrText ? `: ${stderrText}` : ""}`
+            )
+          );
+          return;
+        }
+        resolveCommand({ stdout, stderr, exitCode });
+      });
+    }
+  );
+}
+function unique(values) {
+  return [...new Set(values)];
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isMissingFileError(error) {
+  return Boolean(error) && typeof error === "object" && "code" in error && error.code === "ENOENT";
+}
+function renderCallText(text, isPartial) {
+  const container = new Container();
+  container.addChild(new Text(text, 0, 0));
+  if (!isPartial) {
+    container.addChild(new Spacer(1));
+  }
+  return container;
+}
+
+// src/optimizer/entries.ts
+function readSessionEntries(sessionFile) {
+  if (!sessionFile || !existsSync(sessionFile)) return;
+  try {
+    const sessionText = readFileSync(sessionFile, "utf8");
+    const entries = [];
+    for (const line of sessionText.split("\n")) {
+      if (line.trim().length === 0) continue;
+      const entry = JSON.parse(line);
+      if (!isRecord(entry)) return;
+      entries.push(entry);
+    }
+    return entries;
+  } catch {
+    return;
+  }
+}
+function writeSessionEntries(sessionFile, entries) {
+  const temporaryFile = `${sessionFile}.${process.pid}.${Date.now()}.tmp`;
+  try {
+    writeFileSync(
+      temporaryFile,
+      `${entries.map((entry) => JSON.stringify(entry)).join("\n")}
+`,
+      "utf8"
+    );
+    renameSync(temporaryFile, sessionFile);
+  } finally {
+    if (existsSync(temporaryFile)) unlinkSync(temporaryFile);
+  }
+}
+function getEntryId(entry) {
+  const entryId = entry.id;
+  if (typeof entryId !== "string" || entryId.length === 0) return;
+  return entryId;
+}
+function getMessage(entry) {
+  if (entry.type !== "message") return;
+  const message = entry.message;
+  if (!isRecord(message)) return;
+  return message;
+}
+function getToolResultMessage(entry) {
+  const message = getMessage(entry);
+  if (!message || message.role !== "toolResult") return;
+  if (typeof message.toolCallId !== "string" || message.toolCallId.length === 0) return;
+  if (typeof message.toolName !== "string" || message.toolName.length === 0) return;
+  return message;
+}
+function getParentId(entry) {
+  if (typeof entry.parentId === "string") return entry.parentId;
+  return null;
+}
+function getBranchEntries(entries, leafId) {
+  if (!leafId) return [];
+  const entriesById = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const entryId = getEntryId(entry);
+    if (entryId) entriesById.set(entryId, entry);
+  }
+  if (!entriesById.has(leafId)) return [];
+  const branch = [];
+  const visitedIds = /* @__PURE__ */ new Set();
+  let currentId = leafId;
+  while (currentId && !visitedIds.has(currentId)) {
+    const entry = entriesById.get(currentId);
+    if (!entry) break;
+    visitedIds.add(currentId);
+    branch.push(entry);
+    currentId = getParentId(entry);
+  }
+  return branch.reverse();
+}
+function getLastEntryId(entries) {
+  for (let index = entries.length - 1; index >= 0; index -= 1) {
+    const entryId = getEntryId(entries[index]);
+    if (entryId) return entryId;
+  }
+  return null;
+}
+
+// src/optimizer/deduplicator/helpers.ts
+function filterDeduplicatedMessages(messages, state) {
+  const prunedIds = /* @__PURE__ */ new Set();
+  for (const [toolCallId, repeatIds] of state.replacements) {
+    if (repeatIds.every((repeatId) => state.resultEntryIds.has(repeatId))) {
+      prunedIds.add(toolCallId);
+    }
+  }
+  if (prunedIds.size === 0) {
+    return { changed: false, messages };
+  }
+  const retained = [];
+  let changed = false;
+  for (const message of messages) {
+    if (message.role === "toolResult" && prunedIds.has(message.toolCallId)) {
+      changed = true;
+      continue;
+    }
+    if (message.role !== "assistant") {
+      retained.push(message);
+      continue;
+    }
+    const retainedContent = message.content.filter(
+      (block) => block.type !== "toolCall" || !prunedIds.has(block.id)
+    );
+    if (retainedContent.length === message.content.length) {
+      retained.push(message);
+      continue;
+    }
+    changed = true;
+    if (retainedContent.some((block) => block.type !== "thinking")) {
+      retained.push({ ...message, content: retainedContent });
+    }
+  }
+  return { changed, messages: retained };
+}
+function mergeRanges(ranges) {
+  const sorted = ranges.toSorted(([firstStart], [secondStart]) => firstStart - secondStart);
+  const merged = [];
+  for (const range of sorted) {
+    const previousRange = merged.at(-1);
+    if (!previousRange || previousRange[1] < range[0] - 1) {
+      merged.push([range[0], range[1]]);
+      continue;
+    }
+    previousRange[1] = Math.max(previousRange[1], range[1]);
+  }
+  return merged;
+}
+function hasFullCoverage(range, candidates) {
+  const intersections = [];
+  for (const candidate of candidates) {
+    const start = Math.max(range[0], candidate[0]);
+    const end = Math.min(range[1], candidate[1]);
+    if (start <= end) intersections.push([start, end]);
+  }
+  if (intersections.length === 0) return false;
+  const merged = mergeRanges(intersections);
+  return merged.reduce((lines, [start, end]) => lines + end - start + 1, 0) === range[1] - range[0] + 1;
+}
+
+// src/optimizer/deduplicator/resources.ts
+import { realpathSync } from "node:fs";
+import { normalize, resolve } from "node:path";
+
+// src/optimizer/inspector/helpers.ts
+function parseInspectToolDetails(inspected) {
+  if (!inspected || typeof inspected !== "object") return;
+  const path = inspected.path;
+  const symbol = inspected.symbol;
+  const range = inspected.range;
+  if (typeof path !== "string" || path.length === 0) return;
+  if (typeof symbol !== "string" || symbol.length === 0) return;
+  if (!Array.isArray(range) || range.length !== 2) return;
+  const start = range[0];
+  const end = range[1];
+  if (typeof start !== "number" || typeof end !== "number" || !Number.isInteger(start) || !Number.isInteger(end) || start < 1 || end < start) {
+    return;
+  }
+  return { path, symbol, range: [start, end] };
+}
+
+// src/optimizer/deduplicator/resources.ts
+function getResultText(message) {
+  if (!Array.isArray(message.content) || message.content.length !== 1) return;
+  const content = message.content[0];
+  if (!isRecord(content) || content.type !== "text" || typeof content.text !== "string") return;
+  return content.text;
+}
+function normalizeResourcePath(sourcePath, cwd) {
+  const absolutePath = resolve(cwd, sourcePath);
+  try {
+    return normalize(realpathSync(absolutePath));
+  } catch {
+    return normalize(absolutePath);
+  }
+}
+function getResourceCoverage(toolName, input, result, cwd) {
+  if (!isRecord(result)) return;
+  if (toolName === "inspect") {
+    const inspected = parseInspectToolDetails(result.details);
+    if (!inspected) return;
+    return {
+      resource: normalizeResourcePath(inspected.path, cwd),
+      range: inspected.range
+    };
+  }
+  if (toolName !== "read") return;
+  const sourcePath = input.path;
+  const offset = input.offset;
+  if (typeof sourcePath !== "string" || sourcePath.length === 0) return;
+  if (offset !== void 0 && (typeof offset !== "number" || !Number.isInteger(offset) || offset < 1)) {
+    return;
+  }
+  const details = isRecord(result.details) ? result.details : void 0;
+  const truncation = details?.truncation;
+  if (truncation !== void 0 && !isRecord(truncation)) return;
+  if (isRecord(truncation) && truncation.firstLineExceedsLimit === true) return;
+  const resultText = getResultText(result);
+  if (resultText === void 0) return;
+  const continuation = resultText.match(/\n\n\[[^\n]*Use offset=\d+ to continue\.\]$/)?.[0];
+  const visibleText = continuation ? resultText.slice(0, -continuation.length) : resultText;
+  const outputLines = isRecord(truncation) && truncation.truncated === true ? truncation.outputLines : visibleText.split("\n").length;
+  if (typeof outputLines !== "number" || !Number.isInteger(outputLines) || outputLines <= 0) return;
+  const start = typeof offset === "number" ? offset : 1;
+  return {
+    resource: normalizeResourcePath(sourcePath, cwd),
+    range: [start, start + outputLines - 1]
+  };
+}
+
+// src/optimizer/deduplicator/state.ts
+function collectToolCallInputs(activeEntries) {
+  const inputsByCallId = /* @__PURE__ */ new Map();
+  for (const entry of activeEntries) {
+    const message = getMessage(entry);
+    if (message?.role !== "assistant" || !Array.isArray(message.content)) continue;
+    for (const block of message.content) {
+      if (!isRecord(block) || block.type !== "toolCall") continue;
+      if (typeof block.id !== "string" || !isRecord(block.arguments)) continue;
+      inputsByCallId.set(block.id, block.arguments);
+    }
+  }
+  return inputsByCallId;
+}
+function collectResourceResults(activeEntries, inputsByCallId, cwd) {
+  const results = [];
+  for (const entry of activeEntries) {
+    const entryId = getEntryId(entry);
+    const message = getToolResultMessage(entry);
+    if (!entryId || !message || message.isError === true || typeof message.toolCallId !== "string") {
+      continue;
+    }
+    const input = inputsByCallId.get(message.toolCallId);
+    if (!input || message.toolName !== "read" && message.toolName !== "inspect") continue;
+    const coverage = getResourceCoverage(message.toolName, input, message, cwd);
+    if (!coverage) continue;
+    results.push({
+      entryId,
+      range: coverage.range,
+      resource: coverage.resource,
+      toolCallId: message.toolCallId,
+      prunable: true
+    });
+  }
+  return results;
+}
+function collectReplacementsById(results) {
+  const retainedByResource = /* @__PURE__ */ new Map();
+  const replacementsById = /* @__PURE__ */ new Map();
+  for (let index = results.length - 1; index >= 0; index -= 1) {
+    const result = results[index];
+    const retained = retainedByResource.get(result.resource) ?? [];
+    const covering = retained.filter(
+      (candidate) => candidate.range[0] <= result.range[1] && candidate.range[1] >= result.range[0]
+    );
+    if (hasFullCoverage(
+      result.range,
+      covering.map(({ range }) => range)
+    )) {
+      if (result.prunable) {
+        replacementsById.set(result.entryId, [
+          ...new Set(covering.map((candidate) => candidate.entryId))
+        ]);
+      }
+      continue;
+    }
+    retained.push(result);
+    retainedByResource.set(result.resource, retained);
+  }
+  return replacementsById;
+}
+function buildDeduplicatorState(entries, leafId, cwd) {
+  let activeEntries = getBranchEntries(entries, leafId);
+  if (activeEntries.length === 0 && leafId !== null) {
+    activeEntries = getBranchEntries(entries, getLastEntryId(entries));
+  }
+  const results = collectResourceResults(activeEntries, collectToolCallInputs(activeEntries), cwd);
+  const replacementsById = collectReplacementsById(results);
+  const replacements = /* @__PURE__ */ new Map();
+  for (const result of results) {
+    if (!result.prunable) continue;
+    const replacement = replacementsById.get(result.entryId);
+    if (!replacement) continue;
+    replacements.set(result.toolCallId, replacement);
+  }
+  return { replacements, resultEntryIds: new Set(results.map((result) => result.entryId)) };
+}
+
+// src/optimizer/deduplicator/index.ts
+function deduplicator_default(pi) {
+  let state = buildDeduplicatorState([], null, "");
+  pi.on("session_start", (_event, ctx) => {
+    const entries = readSessionEntries(ctx.sessionManager.getSessionFile()) ?? [];
+    state = buildDeduplicatorState(entries, ctx.sessionManager.getLeafId(), ctx.cwd);
+  });
+  pi.on("session_tree", (event, ctx) => {
+    const entries = readSessionEntries(ctx.sessionManager.getSessionFile()) ?? [];
+    state = buildDeduplicatorState(entries, event.newLeafId, ctx.cwd);
+  });
+  pi.on("context", (event) => {
+    const deduplicated = filterDeduplicatedMessages(event.messages, state);
+    if (deduplicated.changed) return { messages: deduplicated.messages };
+  });
+}
+
+// src/optimizer/compactor/index.ts
+import { statSync } from "node:fs";
+import {
+  createBashToolDefinition,
+  createGrepToolDefinition,
+  isGrepToolResult
+} from "@earendil-works/pi-coding-agent";
+
+// src/optimizer/compactor/bash.ts
+import { stripVTControlCharacters } from "node:util";
+import { createLocalBashOperations } from "@earendil-works/pi-coding-agent";
+var localBash = createLocalBashOperations();
+var MIN_SIMILAR_LENGTH = 10;
+var SIMILARITY_THRESHOLD = 0.8;
+function isSimilarLine(previousLine, nextLine) {
+  if (Math.min(previousLine.length, nextLine.length) < MIN_SIMILAR_LENGTH) return false;
+  const longestLength = Math.max(previousLine.length, nextLine.length);
+  if (1 - Math.abs(previousLine.length - nextLine.length) / longestLength < SIMILARITY_THRESHOLD) {
+    return false;
+  }
+  const distances = new Uint32Array(nextLine.length + 1);
+  for (let nextIndex = 0; nextIndex <= nextLine.length; nextIndex++) {
+    distances[nextIndex] = nextIndex;
+  }
+  for (let previousIndex = 1; previousIndex <= previousLine.length; previousIndex++) {
+    let diagonalDistance = distances[0];
+    distances[0] = previousIndex;
+    for (let nextIndex = 1; nextIndex <= nextLine.length; nextIndex++) {
+      const upperDistance = distances[nextIndex];
+      const editCost = previousLine[previousIndex - 1] === nextLine[nextIndex - 1] ? 0 : 1;
+      distances[nextIndex] = Math.min(
+        upperDistance + 1,
+        distances[nextIndex - 1] + 1,
+        diagonalDistance + editCost
+      );
+      diagonalDistance = upperDistance;
+    }
+  }
+  return 1 - distances[nextLine.length] / longestLength >= SIMILARITY_THRESHOLD;
+}
+var BashResultCompactor = class {
+  decoder = new TextDecoder();
+  onData;
+  // Exact regex and carriage-return handling require holding one logical line.
+  currentLine = "";
+  carriageLine;
+  hasPendingLine = false;
+  pendingLine;
+  pendingTerminated = false;
+  omittedLines = 0;
+  hasSimilarLines = false;
+  constructor(onData) {
+    this.onData = onData;
+  }
+  append(data) {
+    this.process(this.decoder.decode(data, { stream: true }));
+  }
+  finish() {
+    this.process(this.decoder.decode());
+    if (this.hasPendingLine) {
+      this.emit(this.getNormalizedLine(), false);
+      this.resetLine();
+    }
+    this.flushPending();
+  }
+  process(text) {
+    for (const character of text) {
+      if (character === "\r") {
+        if (this.carriageLine === void 0 || stripVTControlCharacters(this.currentLine).length > 0) {
+          this.carriageLine = this.currentLine;
+        }
+        this.currentLine = "";
+        this.hasPendingLine = true;
+        continue;
+      }
+      if (character === "\n") {
+        this.emit(this.getNormalizedLine(), true);
+        this.resetLine();
+        continue;
+      }
+      this.currentLine += character;
+      this.hasPendingLine = true;
+    }
+  }
+  getNormalizedLine() {
+    const normalizedLine = stripVTControlCharacters(this.currentLine);
+    if (this.carriageLine !== void 0 && normalizedLine.length === 0) {
+      return stripVTControlCharacters(this.carriageLine);
+    }
+    return normalizedLine;
+  }
+  emit(normalizedLine, terminated) {
+    if (this.pendingLine === void 0) {
+      this.pendingLine = normalizedLine;
+      this.pendingTerminated = terminated;
+      return;
+    }
+    if (normalizedLine === this.pendingLine) {
+      this.omittedLines++;
+      return;
+    }
+    if (isSimilarLine(this.pendingLine, normalizedLine)) {
+      this.pendingLine = normalizedLine;
+      this.pendingTerminated = terminated;
+      this.omittedLines++;
+      this.hasSimilarLines = true;
+      return;
+    }
+    this.flushPending();
+    this.pendingLine = normalizedLine;
+    this.pendingTerminated = terminated;
+  }
+  flushPending() {
+    if (this.pendingLine === void 0) return;
+    const suffix = this.hasSimilarLines ? ` (similar line x${this.omittedLines})` : "";
+    this.onData(Buffer.from(`${this.pendingLine}${suffix}${this.pendingTerminated ? "\n" : ""}`));
+    this.pendingLine = void 0;
+    this.pendingTerminated = false;
+    this.omittedLines = 0;
+    this.hasSimilarLines = false;
+  }
+  resetLine() {
+    this.currentLine = "";
+    this.carriageLine = void 0;
+    this.hasPendingLine = false;
+  }
+};
+function createCompactingBashOperations(filter) {
+  return {
+    async exec(command, cwd, options) {
+      const compactor = new BashResultCompactor(options.onData);
+      try {
+        return await localBash.exec(command, cwd, {
+          ...options,
+          onData: (data) => compactor.append(data)
+        });
+      } finally {
+        compactor.finish();
+      }
+    }
+  };
+}
+
+// src/optimizer/compactor/grep.ts
+import {
+  appendFileSync,
+  existsSync as existsSync2,
+  readFileSync as readFileSync2,
+  renameSync as renameSync2,
+  unlinkSync as unlinkSync2,
+  writeFileSync as writeFileSync2
+} from "node:fs";
+function extractGrepSummary(contentText) {
+  if (contentText === "No matches found") return null;
+  const notice = contentText.match(/\n\n(\[[^\n]+\])$/)?.[1];
+  const fileLines = /* @__PURE__ */ new Map();
+  const contentLines = contentText.split("\n");
+  let filePath;
+  let matched = false;
+  for (let lineIndex = 0; lineIndex < contentLines.length; lineIndex++) {
+    const contentLine = contentLines[lineIndex] ?? "";
+    const lineMatch = contentLine.match(/^(\d+): /);
+    if (!lineMatch) {
+      const nextLine = contentLines[lineIndex + 1] ?? "";
+      if (contentLine && !/^\d+- /.test(contentLine) && /^\d+[:-] /.test(nextLine)) {
+        filePath = contentLine;
+      }
+      continue;
+    }
+    const lineNumStr = lineMatch[1];
+    if (!filePath || !lineNumStr) continue;
+    matched = true;
+    const lineNum = parseInt(lineNumStr, 10);
+    const existing = fileLines.get(filePath);
+    if (existing) {
+      existing.add(lineNum);
+    } else {
+      fileLines.set(filePath, /* @__PURE__ */ new Set([lineNum]));
+    }
+  }
+  if (!matched) return null;
+  return Array.from(fileLines.entries()).map(([filePath2, lines]) => `${filePath2}: lines_matched=[${Array.from(lines).join(", ")}]`).join("\n") + (notice ? `
+
+${notice}` : "");
+}
+function rewriteTailWithSummaries(sessionFile, offset, summaries) {
+  if (summaries.size === 0) return;
+  const sessionBuffer = readFileSync2(sessionFile);
+  if (offset > sessionBuffer.length) return;
+  const prefixBuffer = sessionBuffer.subarray(0, offset);
+  const tailText = sessionBuffer.subarray(offset).toString("utf-8");
+  if (tailText.length === 0) return;
+  let changed = false;
+  const rewrittenTail = tailText.split("\n").filter((line) => line.trim().length > 0).map((line) => {
+    const entry = JSON.parse(line);
+    const message = entry.message;
+    if (entry.type === "message" && message?.role === "toolResult" && typeof message.toolCallId === "string" && summaries.has(message.toolCallId)) {
+      changed = true;
+      return JSON.stringify({
+        ...entry,
+        message: {
+          ...message,
+          content: [{ type: "text", text: summaries.get(message.toolCallId) }]
+        }
+      });
+    }
+    return line;
+  }).join("\n");
+  if (!changed) return;
+  const tempFile = `${sessionFile}.${process.pid}.${Date.now()}.tmp`;
+  try {
+    writeFileSync2(tempFile, prefixBuffer);
+    appendFileSync(tempFile, `${rewrittenTail}
+`, "utf8");
+    renameSync2(tempFile, sessionFile);
+  } finally {
+    if (existsSync2(tempFile)) {
+      unlinkSync2(tempFile);
+    }
+  }
+}
+function formatGrepResult(content) {
+  const formattedLines = [];
+  const formattedIndexes = /* @__PURE__ */ new Map();
+  let currentFilePath;
+  let changed = false;
+  for (const line of content.split("\n")) {
+    const matchLine = line.match(/^(.+?):(\d+): (.*)$/);
+    const contextLine = matchLine ? null : line.match(/^(.+?)-(\d+)- (.*)$/);
+    const filePath = matchLine?.[1] ?? contextLine?.[1];
+    const lineNumber = matchLine?.[2] ?? contextLine?.[2];
+    const lineText = matchLine?.[3] ?? contextLine?.[3];
+    if (!filePath || !lineNumber || lineText === void 0) {
+      formattedLines.push(line);
+      continue;
+    }
+    const lineKey = `${filePath}\0${lineNumber}`;
+    const formattedIndex = formattedIndexes.get(lineKey);
+    if (formattedIndex !== void 0) {
+      if (matchLine) formattedLines[formattedIndex] = `${lineNumber}: ${lineText}`;
+      continue;
+    }
+    if (filePath !== currentFilePath) {
+      formattedLines.push(filePath);
+      currentFilePath = filePath;
+    }
+    formattedIndexes.set(lineKey, formattedLines.length);
+    formattedLines.push(`${lineNumber}${matchLine ? ":" : "-"} ${lineText}`);
+    changed = true;
+  }
+  return changed ? formattedLines.join("\n") : content;
+}
+
+// src/optimizer/compactor/index.ts
+import Type from "typebox";
+function compactor_default(pi) {
+  let writeStartOffset = 0;
+  const store = /* @__PURE__ */ new Map();
+  const grepTool = createGrepToolDefinition(process.cwd());
+  const bashTool = createBashToolDefinition(process.cwd(), {
+    operations: createCompactingBashOperations()
+  });
+  pi.registerTool({
+    ...grepTool,
+    parameters: Type.Object({
+      ...grepTool.parameters.properties,
+      context: Type.Optional(
+        Type.Number({
+          description: "Number of lines to show before and after each match (default: 0)",
+          maximum: 3
+        })
+      )
+    })
+  });
+  pi.registerTool({
+    ...bashTool,
+    description: "Execute a bash command in the current working directory. Strips ANSI escapes, collapses carriage-return updates, removes consecutive duplicate lines, then optionally filters lines with a JavaScript regex before truncating to the last 2000 lines or 50KB. Saved full output is compacted.",
+    parameters: Type.Object({
+      ...bashTool.parameters.properties,
+      purpose: Type.String({
+        description: "Briefly explain what this command will do and why before running it",
+        minLength: 1,
+        maxLength: 256,
+        pattern: "\\S"
+      })
+    }),
+    prepareArguments: void 0,
+    execute(toolCallId, params, signal, onUpdate, ctx) {
+      return bashTool.execute(
+        toolCallId,
+        { command: params.command, timeout: params.timeout },
+        signal,
+        onUpdate,
+        ctx
+      );
+    }
+  });
+  pi.on("agent_start", async (_event, ctx) => {
+    if (store.size > 0) return;
+    const sessionFile = ctx.sessionManager.getSessionFile();
+    if (!sessionFile) {
+      writeStartOffset = 0;
+      return;
+    }
+    try {
+      writeStartOffset = statSync(sessionFile).size;
+    } catch {
+      writeStartOffset = 0;
+    }
+  });
+  pi.on("agent_end", async (event) => {
+    for (const message of event.messages) {
+      if (message.role !== "toolResult" || message.toolName !== "grep") continue;
+      const text = message.content.find((content) => content.type === "text")?.text;
+      if (text === void 0) continue;
+      const summary = extractGrepSummary(text);
+      if (!summary) continue;
+      store.set(message.toolCallId, summary);
+    }
+  });
+  pi.on("session_shutdown", (event, ctx) => {
+    if (store.size === 0) return;
+    const sessionFile = ctx.sessionManager.getSessionFile();
+    if (sessionFile) {
+      rewriteTailWithSummaries(sessionFile, writeStartOffset, store);
+    }
+    if (event.targetSessionFile && event.targetSessionFile !== sessionFile) {
+      rewriteTailWithSummaries(event.targetSessionFile, writeStartOffset, store);
+    }
+  });
+  pi.on("context", async (event) => {
+    if (store.size === 0) return;
+    let changed = false;
+    for (const message of event.messages) {
+      if (message.role !== "toolResult" || message.toolName !== "grep") continue;
+      const summary = store.get(message.toolCallId);
+      if (summary === void 0) continue;
+      message.content = [{ type: "text", text: summary }];
+      changed = true;
+    }
+    if (!changed) return;
+    return { messages: event.messages };
+  });
+  pi.on("tool_result", async (event) => {
+    if (!isGrepToolResult(event) || event.isError) return;
+    let changed = false;
+    const content = event.content.map((item) => {
+      if (item.type !== "text") return item;
+      const text = formatGrepResult(item.text);
+      if (text === item.text) return item;
+      changed = true;
+      return { ...item, text };
+    });
+    if (changed) return { content };
+  });
+}
+
+// src/optimizer/mapper/index.ts
+import { defineTool, truncateHead } from "@earendil-works/pi-coding-agent";
+import { Type as Type2 } from "typebox";
+
+// src/optimizer/mapper/files.ts
+import picomatch from "picomatch";
+var SKIPPED_DIRECTORIES = /* @__PURE__ */ new Set([".git", ".pi", "build", "coverage", "dist", "node_modules"]);
+function normalizePath(pathValue) {
+  const normalizedPath = pathValue.replaceAll("\\", "/");
+  return normalizedPath.startsWith("./") ? normalizedPath.slice(2) : normalizedPath;
+}
+async function rgFiles(projectPath, globTargets, signal) {
+  const args = ["--files", "--hidden"];
+  for (const skipped of SKIPPED_DIRECTORIES) {
+    args.push("--glob", `!**/${skipped}/**`);
+  }
+  for (const globTarget of globTargets) {
+    args.push("--glob", globTarget);
+  }
+  args.push(".");
+  const commandResult = await runCommand(projectPath, "rg", args, {
+    signal,
+    successExitCodes: [0, 1],
+    abortMessage: "mapper aborted"
+  });
+  return commandResult.stdout.split("\n").map((line) => normalizePath(line.trim())).filter((line) => line.length > 0);
+}
+async function grepFiles(projectPath, globTargets, signal) {
+  const args = ["-r", "-I", "-l"];
+  for (const skipped of SKIPPED_DIRECTORIES) {
+    args.push("--exclude-dir", skipped);
+  }
+  args.push("-e", "", ".");
+  const commandResult = await runCommand(projectPath, "grep", args, {
+    signal,
+    successExitCodes: [0, 1],
+    abortMessage: "mapper aborted"
+  });
+  const paths = commandResult.stdout.split("\n").map((line) => normalizePath(line.trim())).filter((line) => line.length > 0);
+  const matchers = globTargets.map((globTarget) => picomatch(globTarget, { dot: true }));
+  return paths.filter((pathValue) => matchers.some((matcher) => matcher(pathValue)));
+}
+async function resolveTargetPaths(projectPath, targets, signal) {
+  const globTargets = targets.flatMap((target) => {
+    const normalized = normalizePath(target);
+    if (normalized.length === 0) return [];
+    if (normalized === ".") return ["**"];
+    if (/[*?[\]{}]/.test(normalized)) return [normalized];
+    return [normalized, `${normalized}/**`];
+  });
+  if (globTargets.length === 0) return [];
+  try {
+    const paths = await rgFiles(projectPath, globTargets, signal);
+    return unique(paths).sort();
+  } catch (rgError) {
+    const rgMessage = rgError instanceof Error ? rgError.message : String(rgError);
+    if (rgMessage === "mapper aborted") {
+      throw rgError;
+    }
+    try {
+      const paths = await grepFiles(projectPath, globTargets, signal);
+      return unique(paths).sort();
+    } catch (grepError) {
+      const grepMessage = grepError instanceof Error ? grepError.message : String(grepError);
+      throw new Error(`mapper file scan failed: rg=${rgMessage}; grep=${grepMessage}`);
+    }
+  }
+}
+
+// src/optimizer/languages/grammar.ts
+import { existsSync as existsSync3 } from "node:fs";
+import { readFile as readFile2 } from "node:fs/promises";
+import { resolve as resolve2 } from "node:path";
+import { createRequire } from "node:module";
+import { pathToFileURL } from "node:url";
+var GRAMMAR_COVERAGE_TARGET = 0.9;
+var GRAMMAR_INSTALL_KEY = "grammarInstall";
+async function ensureGrammarCachePackage() {
+  const grammarCacheDir = getPiPath("grammars");
+  const jsonPath = resolve2(grammarCacheDir, "package.json");
+  try {
+    await readFile2(jsonPath, "utf8");
+  } catch (error) {
+    if (!isMissingFileError(error)) {
+      throw error;
+    }
+    await writeJson(jsonPath, {
+      name: "tree-sitter-grammars",
+      private: true,
+      dependencies: {}
+    });
+  }
+}
+async function getRepositoryRoot(cwd) {
+  try {
+    const { stdout } = await runCommand(cwd, "git", ["rev-parse", "--show-toplevel"]);
+    const repoRoot = stdout.trim();
+    return repoRoot.length > 0 ? repoRoot : void 0;
+  } catch {
+  }
+}
+async function selectSupportedBuckets(cwd) {
+  const bucketCounts = /* @__PURE__ */ new Map();
+  let totalFileCount = 0;
+  const { stdout } = await runCommand(cwd, "bash", [
+    "-lc",
+    "git ls-files | sed 's/.*\\.//' | sort | uniq -c | sort -rn"
+  ]);
+  for (const line of stdout.split(/\r?\n/)) {
+    const lineMatch = line.trim().match(/^(\d+)\s+(.+)$/);
+    if (!lineMatch) continue;
+    const rawCount = lineMatch[1];
+    const rawExtension = lineMatch[2];
+    if (!rawCount || !rawExtension) continue;
+    const count = Number.parseInt(rawCount, 10);
+    const extension = `.${rawExtension.toLowerCase()}`;
+    if (!Number.isFinite(count) || count <= 0) continue;
+    totalFileCount += count;
+    for (const languageEntry of LANGUAGE_REGISTRY) {
+      if (!languageEntry.profile.extensions.has(extension)) continue;
+      const nextCount = bucketCounts.get(languageEntry.bucketName) ?? 0;
+      bucketCounts.set(languageEntry.bucketName, nextCount + count);
+      break;
+    }
+  }
+  if (totalFileCount === 0) return [];
+  const rankedBuckets = LANGUAGE_REGISTRY.map((languageEntry) => ({
+    count: bucketCounts.get(languageEntry.bucketName) ?? 0,
+    packageName: languageEntry.packageName,
+    version: languageEntry.version
+  })).filter((bucket) => bucket.count > 0).sort((leftBucket, rightBucket) => rightBucket.count - leftBucket.count);
+  let coveredCount = 0;
+  const pickedBuckets = [];
+  for (const bucket of rankedBuckets) {
+    if (coveredCount / totalFileCount >= GRAMMAR_COVERAGE_TARGET) break;
+    coveredCount += bucket.count;
+    pickedBuckets.push({
+      packageName: bucket.packageName,
+      version: bucket.version
+    });
+  }
+  return pickedBuckets;
+}
+function getMissingGrammarPackages(pickedBuckets) {
+  const grammarCacheDir = getPiPath("grammars");
+  return pickedBuckets.filter((bucket) => {
+    const packagePath = resolve2(
+      grammarCacheDir,
+      "node_modules",
+      bucket.packageName,
+      "package.json"
+    );
+    return !existsSync3(packagePath);
+  }).map((bucket) => `${bucket.packageName}@${bucket.version}`);
+}
+function readGrammarInstallSettings(settings) {
+  const rawSettings = settings[GRAMMAR_INSTALL_KEY];
+  if (!rawSettings || typeof rawSettings !== "object") return {};
+  const settingsMap = rawSettings;
+  const allowed = Array.isArray(settingsMap.allowedRepos) ? settingsMap.allowedRepos.filter((repo) => typeof repo === "string") : void 0;
+  const denied = Array.isArray(settingsMap.deniedRepos) ? settingsMap.deniedRepos.filter((repo) => typeof repo === "string") : void 0;
+  return { allowedRepos: allowed, deniedRepos: denied };
+}
+async function updateGrammarInstallSettings(settings, installSettings) {
+  settings[GRAMMAR_INSTALL_KEY] = installSettings;
+  await writeJson(getPiPath("settings"), settings);
+}
+async function ensureGrammarCache(ctx) {
+  await ensureGrammarCachePackage();
+  const repoRoot = await getRepositoryRoot(ctx.cwd);
+  if (!repoRoot) return;
+  const settings = await readJson(getPiPath("settings"), {});
+  const installSettings = readGrammarInstallSettings(settings);
+  const allowed = new Set(installSettings.allowedRepos ?? []);
+  const denied = new Set(installSettings.deniedRepos ?? []);
+  if (denied.has(repoRoot)) return;
+  const pickedBuckets = await selectSupportedBuckets(ctx.cwd);
+  if (pickedBuckets.length === 0) return;
+  const missingPkgs = getMissingGrammarPackages(pickedBuckets);
+  if (missingPkgs.length === 0) return;
+  let canInstall = allowed.has(repoRoot);
+  if (!canInstall) {
+    if (!ctx.hasUI) return;
+    canInstall = await ctx.ui.confirm(
+      "Install tree-sitter grammars for this repo?",
+      "surgent installs missing parser grammars for optimized code read, input tokens and context optimizations."
+    );
+    if (!canInstall) {
+      denied.add(repoRoot);
+      await updateGrammarInstallSettings(settings, {
+        allowedRepos: [...allowed],
+        deniedRepos: [...denied]
+      });
+      return;
+    }
+    allowed.add(repoRoot);
+    await updateGrammarInstallSettings(settings, {
+      allowedRepos: [...allowed],
+      deniedRepos: [...denied]
+    });
+  }
+  await runCommand(getPiPath("grammars"), "npm", ["install", "--save-exact", ...missingPkgs]);
+}
+async function loadGrammarModule(pkgName) {
+  const grammarCacheDir = getPiPath("grammars");
+  const cacheRequire = createRequire(resolve2(grammarCacheDir, "package.json"));
+  let entryPath = "";
+  try {
+    entryPath = cacheRequire.resolve(pkgName);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(
+      `grammar package not installed in cache (${grammarCacheDir}): ${pkgName}. ${message}`
+    );
+  }
+  try {
+    return await import(pathToFileURL(entryPath).href);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(
+      `failed loading grammar module from cache (${grammarCacheDir}): ${pkgName}. ${message}`
+    );
+  }
+}
+
+// src/optimizer/languages/types.ts
+var RuleBasedLanguageProfile = class {
+  constructor(extensions, nameFieldByType, topLevelRoots, topLevelParents, typeRule) {
+    this.extensions = extensions;
+    this.nameFieldByType = nameFieldByType;
+    this.topLevelRoots = topLevelRoots;
+    this.topLevelParents = topLevelParents;
+    this.typeRule = typeRule;
+  }
+  extensions;
+  nameFieldByType;
+  topLevelRoots;
+  topLevelParents;
+  typeRule;
+  findContainerNode(node) {
+    let current = node.parent;
+    while (current) {
+      if (this.typeRule.has(current.type)) {
+        return current;
+      }
+      current = current.parent;
+    }
+  }
+  matchesTopLevelRule(node) {
+    let current = node.parent;
+    while (current) {
+      if (this.topLevelRoots.has(current.type)) {
+        return true;
+      }
+      if (this.topLevelParents.size > 0 && !this.topLevelParents.has(current.type)) {
+        return false;
+      }
+      current = current.parent;
+    }
+    return false;
+  }
+  readFieldText(node, fieldName) {
+    return this.readNodeText(node.childForFieldName(fieldName));
+  }
+  readNameField(node) {
+    const fieldName = this.nameFieldByType[node.type] ?? this.nameFieldByType.__default__;
+    return this.readFieldText(node, fieldName);
+  }
+  readNodeText(node) {
+    if (!node) return;
+    const nodeText = node.text.trim().replaceAll("\n", " ");
+    return nodeText.length > 0 ? nodeText : void 0;
+  }
+  readContainerName(node) {
+    const containerNode = this.findContainerNode(node);
+    return containerNode ? this.readNodeName(containerNode) : void 0;
+  }
+  isPublicSymbol(node) {
+    return this.findContainerNode(node)?.type === "export_statement";
+  }
+  resolveSymbolKind(node) {
+    const symbolKindRules = this.typeRule.get(node.type);
+    if (!symbolKindRules) return;
+    for (const symbolKindRule of symbolKindRules) {
+      if (symbolKindRule.parent && node.parent?.type !== symbolKindRule.parent) {
+        continue;
+      }
+      if (symbolKindRule.container) {
+        const containerNode = this.findContainerNode(node);
+        if (!containerNode || containerNode.type !== symbolKindRule.container) {
+          continue;
+        }
+      }
+      if (symbolKindRule.topLevelOnly && !this.matchesTopLevelRule(node)) {
+        continue;
+      }
+      return symbolKindRule.kind;
+    }
+  }
+  shouldSkipSymbol(_node) {
+    return false;
+  }
+};
+
+// src/optimizer/languages/typescript.ts
+var TypeScriptLanguageProfile = class extends RuleBasedLanguageProfile {
+  constructor() {
+    super(
+      /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".mjs", ".cjs", ".jsx"]),
+      { __default__: "name" },
+      /* @__PURE__ */ new Set(["program"]),
+      /* @__PURE__ */ new Set([
+        "lexical_declaration",
+        "variable_declaration",
+        "variable_declarator",
+        "export_statement"
+      ]),
+      /* @__PURE__ */ new Map([
+        ["function_declaration", [{ kind: "func", topLevelOnly: true }]],
+        ["arrow_function", [{ kind: "func", topLevelOnly: true }]],
+        ["function_expression", [{ kind: "func", topLevelOnly: true }]],
+        ["abstract_class_declaration", [{ kind: "class" }]],
+        ["class_declaration", [{ kind: "class" }]],
+        ["abstract_method_signature", [{ kind: "method", parent: "class_body" }]],
+        [
+          "method_definition",
+          [
+            { kind: "method", parent: "class_body" },
+            { kind: "method", parent: "object" }
+          ]
+        ],
+        ["variable_declarator", [{ kind: "decl", topLevelOnly: true }]],
+        ["import_specifier", [{ kind: "deps" }]],
+        ["namespace_import", [{ kind: "deps" }]],
+        ["identifier", [{ kind: "deps", parent: "import_clause" }]],
+        ["export_statement", [{ kind: "public", topLevelOnly: true }]]
+      ])
+    );
+  }
+  async loadLanguage(extension) {
+    const languagePack = await loadGrammarModule("tree-sitter-typescript");
+    const languageExports = typeof languagePack.default === "object" && languagePack.default !== null ? languagePack.default : languagePack;
+    const typeScriptLanguage = languageExports.typescript;
+    if (!typeScriptLanguage) {
+      throw new Error("tree-sitter-typescript missing typescript export");
+    }
+    if (extension === ".tsx" || extension === ".jsx") {
+      return languageExports.tsx ?? typeScriptLanguage;
+    }
+    return typeScriptLanguage;
+  }
+  readNodeName(node) {
+    if (node.type === "export_statement") {
+      return "exports";
+    }
+    if (node.type === "import_specifier") {
+      const aliasText = this.readFieldText(node, "alias");
+      if (aliasText) {
+        return aliasText;
+      }
+    }
+    const nodeName = this.readNameField(node);
+    if (nodeName) {
+      return nodeName;
+    }
+    if (node.type === "namespace_import") {
+      return this.readNodeText(node.namedChild(0));
+    }
+    if (node.type === "identifier") {
+      return this.readNodeText(node);
+    }
+    if (node.type === "arrow_function" || node.type === "function_expression" || node.type === "function_declaration") {
+      const declaratorNode = node.parent?.type === "variable_declarator" ? node.parent : void 0;
+      if (declaratorNode) {
+        const declaratorName = this.readFieldText(declaratorNode, "name");
+        if (declaratorName) {
+          return declaratorName;
+        }
+      }
+      return "anonymous";
+    }
+  }
+  shouldSkipSymbol(node) {
+    if (node.type === "export_statement") {
+      const inlineNode = node.namedChild(0);
+      return node.childForFieldName("declaration") !== null || inlineNode?.type === "arrow_function" || inlineNode?.type === "function_expression" || inlineNode?.type === "function_declaration" || inlineNode?.type === "class_declaration" && inlineNode.childForFieldName("name") !== null;
+    }
+    if (node.type === "variable_declarator") {
+      return node.childForFieldName("value")?.type === "arrow_function";
+    }
+    return node.type === "function_expression" && node.childForFieldName("name") !== null;
+  }
+};
+
+// src/optimizer/languages/python.ts
+var PythonLanguageProfile = class extends RuleBasedLanguageProfile {
+  constructor() {
+    super(
+      /* @__PURE__ */ new Set([".py"]),
+      {
+        __default__: "name",
+        assignment: "left",
+        future_import_statement: "name",
+        import_from_statement: "name",
+        import_statement: "name"
+      },
+      /* @__PURE__ */ new Set(["module"]),
+      /* @__PURE__ */ new Set(["decorated_definition", "expression_statement"]),
+      /* @__PURE__ */ new Map([
+        ["class_definition", [{ kind: "class" }]],
+        [
+          "function_definition",
+          [
+            { kind: "method", container: "class_definition" },
+            { kind: "func", topLevelOnly: true }
+          ]
+        ],
+        ["assignment", [{ kind: "decl", topLevelOnly: true }]],
+        ["future_import_statement", [{ kind: "deps", topLevelOnly: true }]],
+        ["import_from_statement", [{ kind: "deps", topLevelOnly: true }]],
+        ["import_statement", [{ kind: "deps", topLevelOnly: true }]]
+      ])
+    );
+  }
+  async loadLanguage(_extension) {
+    const languagePack = await loadGrammarModule("tree-sitter-python");
+    const languageExport = languagePack.default ?? languagePack;
+    return languageExport;
+  }
+  resolveSymbolKind(node) {
+    if (node.type === "assignment" && this.matchesTopLevelRule(node) && this.readFieldText(node, "left") === "__all__") {
+      return "public";
+    }
+    return super.resolveSymbolKind(node);
+  }
+  readNodeName(node) {
+    const nodeName = this.readNameField(node);
+    if (nodeName) {
+      return nodeName;
+    }
+    if (node.type === "dotted_name" || node.type === "identifier") {
+      return this.readNodeText(node);
+    }
+  }
+};
+
+// src/optimizer/languages/go.ts
+var GoLanguageProfile = class extends RuleBasedLanguageProfile {
+  constructor() {
+    super(
+      /* @__PURE__ */ new Set([".go"]),
+      { __default__: "name" },
+      /* @__PURE__ */ new Set(["source_file"]),
+      /* @__PURE__ */ new Set([
+        "const_declaration",
+        "import_declaration",
+        "import_spec_list",
+        "type_declaration",
+        "var_declaration",
+        "var_spec_list"
+      ]),
+      /* @__PURE__ */ new Map([
+        ["function_declaration", [{ kind: "func", topLevelOnly: true }]],
+        ["method_declaration", [{ kind: "method" }]],
+        ["method_elem", [{ kind: "method", parent: "interface_type", container: "type_spec" }]],
+        ["const_spec", [{ kind: "decl", topLevelOnly: true }]],
+        ["import_spec", [{ kind: "deps", topLevelOnly: true }]],
+        ["type_alias", [{ kind: "class", topLevelOnly: true }]],
+        ["type_spec", [{ kind: "class", topLevelOnly: true }]],
+        ["var_spec", [{ kind: "decl", topLevelOnly: true }]]
+      ])
+    );
+  }
+  async loadLanguage(_extension) {
+    const languagePack = await loadGrammarModule("tree-sitter-go");
+    const languageExport = languagePack.default ?? languagePack;
+    return languageExport;
+  }
+  readNodeName(node) {
+    if (node.type === "import_spec") {
+      const importName = this.readFieldText(node, "name");
+      if (importName) {
+        return importName;
+      }
+      const importPath = this.readFieldText(node, "path");
+      if (importPath) {
+        return importPath.replace(/^("|')(.*)\1$/, "$2");
+      }
+    }
+    const nodeName = this.readNameField(node);
+    if (nodeName) {
+      return nodeName;
+    }
+    if (node.type === "field_identifier" || node.type === "identifier" || node.type === "package_identifier" || node.type === "type_identifier") {
+      return this.readNodeText(node);
+    }
+  }
+  readContainerName(node) {
+    if (node.type === "method_declaration") {
+      const receiverNode = node.childForFieldName("receiver");
+      const receiverParameterNode = receiverNode?.namedChild(0);
+      const receiverTypeNode = receiverParameterNode?.childForFieldName("type");
+      const receiverType = this.readNodeText(receiverTypeNode);
+      if (receiverType) {
+        return receiverType.replace(/^\*+/, "");
+      }
+    }
+    return super.readContainerName(node);
+  }
+};
+
+// src/optimizer/languages/java.ts
+var JavaLanguageProfile = class extends RuleBasedLanguageProfile {
+  constructor() {
+    super(
+      /* @__PURE__ */ new Set([".java"]),
+      { __default__: "name", exports_module_directive: "package" },
+      /* @__PURE__ */ new Set(["program"]),
+      /* @__PURE__ */ new Set(),
+      /* @__PURE__ */ new Map([
+        ["annotation_type_declaration", [{ kind: "class" }]],
+        ["class_declaration", [{ kind: "class" }]],
+        ["enum_declaration", [{ kind: "class" }]],
+        ["interface_declaration", [{ kind: "class" }]],
+        ["record_declaration", [{ kind: "class" }]],
+        [
+          "constructor_declaration",
+          [
+            { kind: "method", parent: "class_body" },
+            { kind: "method", parent: "enum_body_declarations" }
+          ]
+        ],
+        [
+          "method_declaration",
+          [
+            { kind: "method", parent: "class_body" },
+            { kind: "method", parent: "enum_body_declarations" },
+            { kind: "method", parent: "interface_body" }
+          ]
+        ],
+        ["import_declaration", [{ kind: "deps" }]],
+        ["exports_module_directive", [{ kind: "public", parent: "module_body" }]]
+      ])
+    );
+  }
+  async loadLanguage(_extension) {
+    const languagePack = await loadGrammarModule("tree-sitter-java");
+    const languageExport = languagePack.default ?? languagePack;
+    return languageExport;
+  }
+  readNodeName(node) {
+    const nodeName = this.readNameField(node);
+    if (nodeName) {
+      return nodeName;
+    }
+    if (node.type === "import_declaration") {
+      const importText = node.text.replace(/^import\s+/, "").replace(/\s*;\s*$/, "").trim().replaceAll("\n", " ");
+      return importText.length > 0 ? importText : void 0;
+    }
+    if (node.type === "identifier" || node.type === "scoped_identifier") {
+      return this.readNodeText(node);
+    }
+  }
+};
+
+// src/optimizer/languages/rust.ts
+var RustLanguageProfile = class extends RuleBasedLanguageProfile {
+  constructor() {
+    super(
+      /* @__PURE__ */ new Set([".rs"]),
+      { __default__: "name", use_declaration: "argument" },
+      /* @__PURE__ */ new Set(["source_file"]),
+      /* @__PURE__ */ new Set(["declaration_list", "foreign_mod_item", "mod_item"]),
+      /* @__PURE__ */ new Map([
+        [
+          "function_item",
+          [
+            { kind: "method", container: "impl_item" },
+            { kind: "method", container: "trait_item" },
+            { kind: "func", topLevelOnly: true }
+          ]
+        ],
+        [
+          "function_signature_item",
+          [
+            { kind: "method", container: "trait_item" },
+            { kind: "func", topLevelOnly: true }
+          ]
+        ],
+        ["struct_item", [{ kind: "class", topLevelOnly: true }]],
+        ["enum_item", [{ kind: "class", topLevelOnly: true }]],
+        ["union_item", [{ kind: "class", topLevelOnly: true }]],
+        ["trait_item", [{ kind: "class", topLevelOnly: true }]],
+        ["type_item", [{ kind: "class", topLevelOnly: true }]],
+        ["mod_item", [{ kind: "class", topLevelOnly: true }]],
+        ["impl_item", [{ kind: "class" }]],
+        ["macro_definition", [{ kind: "func", topLevelOnly: true }]],
+        ["const_item", [{ kind: "decl", topLevelOnly: true }]],
+        ["static_item", [{ kind: "decl", topLevelOnly: true }]],
+        ["use_declaration", [{ kind: "deps", topLevelOnly: true }]]
+      ])
+    );
+  }
+  async loadLanguage(_extension) {
+    const languagePack = await loadGrammarModule("tree-sitter-rust");
+    const languageExport = languagePack.default ?? languagePack;
+    return languageExport;
+  }
+  readNodeName(node) {
+    if (node.type === "impl_item") {
+      return this.readFieldText(node, "type");
+    }
+    const nodeName = this.readNameField(node);
+    if (nodeName) {
+      return nodeName;
+    }
+    if (node.type === "identifier" || node.type === "type_identifier") {
+      return this.readNodeText(node);
+    }
+  }
+  isPublicSymbol(node) {
+    return node.namedChildren.some((childNode) => childNode.type === "visibility_modifier");
+  }
+  shouldSkipSymbol(node) {
+    return node.type === "impl_item";
+  }
+};
+
+// src/optimizer/languages/symbols.ts
+import { readFile as readFile3 } from "node:fs/promises";
+import { extname, resolve as resolve3 } from "node:path";
+import Parser from "tree-sitter";
+async function createCodeParser(extension) {
+  const languageProfile = getLanguageProfile(extension);
+  if (!languageProfile) {
+    throw new Error(`missing grammar for extension: ${extension}`);
+  }
+  const parser = new Parser();
+  parser.setLanguage(await languageProfile.loadLanguage(extension));
+  return parser;
+}
+async function getParserForPath(path, parsers) {
+  const extension = extname(path).toLowerCase();
+  const parser = parsers.get(extension);
+  if (parser) return parser;
+  const createdParser = await createCodeParser(extension);
+  parsers.set(extension, createdParser);
+  return createdParser;
+}
+async function getRootNode(cwd, path) {
+  const parsers = /* @__PURE__ */ new Map();
+  const absolutePath = resolve3(cwd, path);
+  let code = "";
+  try {
+    code = await readFile3(absolutePath, "utf8");
+  } catch {
+    return;
+  }
+  const parser = await getParserForPath(path, parsers);
+  const tree = parser.parse(code);
+  return tree.rootNode;
+}
+async function collectSymbols(cwd, path, kinds) {
+  const extension = extname(path).toLowerCase();
+  const profile = getLanguageProfile(extension);
+  if (!profile) return [];
+  const root = await getRootNode(cwd, path);
+  if (!root) return [];
+  const symbols = [];
+  const pendingNodes = [root];
+  const symbolIdCounts = /* @__PURE__ */ new Map();
+  while (pendingNodes.length > 0) {
+    const currentNode = pendingNodes.pop();
+    if (!currentNode) continue;
+    for (let childIndex = currentNode.namedChildCount - 1; childIndex >= 0; childIndex -= 1) {
+      const namedChild = currentNode.namedChild(childIndex);
+      if (namedChild) {
+        pendingNodes.push(namedChild);
+      }
+    }
+    const symbolKind = profile.resolveSymbolKind(currentNode);
+    if (!symbolKind || !kinds.has(symbolKind) || profile.shouldSkipSymbol(currentNode)) {
+      continue;
+    }
+    const baseName = profile.readNodeName(currentNode);
+    if (!baseName) continue;
+    const containerName = profile.readContainerName(currentNode);
+    const symbolName = symbolKind === "method" && containerName ? `${containerName}.${baseName}` : baseName;
+    const symbolIdCount = (symbolIdCounts.get(symbolName) ?? 0) + 1;
+    symbolIdCounts.set(symbolName, symbolIdCount);
+    const isAnonymous = symbolName === "anonymous" && !currentNode.childForFieldName("name");
+    symbols.push({
+      name: isAnonymous || symbolIdCount > 1 ? `${symbolName}~${symbolIdCount}` : symbolName,
+      path,
+      kind: symbolKind,
+      node: currentNode,
+      range: [currentNode.startPosition.row + 1, currentNode.endPosition.row + 1],
+      public: profile.isPublicSymbol(currentNode)
+    });
+  }
+  return symbols;
+}
+
+// src/optimizer/languages/index.ts
+var LANGUAGE_REGISTRY = [
+  {
+    bucketName: "typescript",
+    packageName: "tree-sitter-typescript",
+    version: "0.23.2",
+    profile: new TypeScriptLanguageProfile()
+  },
+  {
+    bucketName: "python",
+    packageName: "tree-sitter-python",
+    version: "0.25.0",
+    profile: new PythonLanguageProfile()
+  },
+  {
+    bucketName: "go",
+    packageName: "tree-sitter-go",
+    version: "0.25.0",
+    profile: new GoLanguageProfile()
+  },
+  {
+    bucketName: "java",
+    packageName: "tree-sitter-java",
+    version: "0.23.5",
+    profile: new JavaLanguageProfile()
+  },
+  {
+    bucketName: "rust",
+    packageName: "tree-sitter-rust",
+    version: "0.24.0",
+    profile: new RustLanguageProfile()
+  }
+];
+function getLanguageProfile(extension) {
+  return LANGUAGE_REGISTRY.find(({ profile }) => profile.extensions.has(extension))?.profile;
+}
+function languages_default(pi) {
+  pi.on("session_start", async (_event, ctx) => {
+    try {
+      await ensureGrammarCache(ctx);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (ctx.hasUI) {
+        ctx.ui.notify(`tree-sitter grammar install failed: ${message}`, "error");
+      }
+    }
+  });
+}
+var SYMBOL_KINDS = ["func", "class", "method", "decl", "deps", "public"];
+
+// src/optimizer/mapper/index.ts
+function collapseGroupedSymbols(symbols) {
+  let groupedSymbolKind;
+  let importsGroupIndex = 0;
+  let exportsGroupIndex = 0;
+  return symbols.flatMap((symbol) => {
+    if (symbol.kind !== "deps" && symbol.kind !== "public") {
+      groupedSymbolKind = void 0;
+      return [symbol];
+    }
+    if (symbol.kind === groupedSymbolKind) return [];
+    groupedSymbolKind = symbol.kind;
+    if (symbol.kind === "deps") {
+      importsGroupIndex += 1;
+      return [{ ...symbol, name: `imports~${importsGroupIndex}`, range: void 0 }];
+    }
+    exportsGroupIndex += 1;
+    return [{ ...symbol, name: `exports~${exportsGroupIndex}`, range: void 0 }];
+  });
+}
+var codeMap = defineTool({
+  name: "code_map",
+  label: "Code map",
+  description: "Fast symbol and code blocks offset/limit indexing. Best for: narrowing targets to inspect/read or code discovery.",
+  parameters: Type2.Object({
+    targets: Type2.Array(Type2.String(), {
+      description: "Paths or globs to scan (relative to cwd). Keep scope narrow."
+    }),
+    kinds: Type2.Optional(
+      Type2.Array(Type2.Union(SYMBOL_KINDS.map((kind) => Type2.Literal(kind))), {
+        description: "Abstraction kinds to include. Omit to include all supported."
+      })
+    )
+  }),
+  async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+    const kinds = new Set(params.kinds ?? SYMBOL_KINDS);
+    const result = { symbols: [], failed: [] };
+    let paths = [];
+    try {
+      paths = await resolveTargetPaths(ctx.cwd, params.targets, signal);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return {
+        isError: true,
+        details: `code_map target scan failed: ${message}`,
+        content: [{ type: "text", text: `code_map target scan failed: ${message}` }]
+      };
+    }
+    if (paths.length === 0) {
+      return {
+        isError: false,
+        details: "(no symbols found) targets matched no supported files or symbols",
+        content: [
+          {
+            type: "text",
+            text: "(no symbols found) targets matched no supported files or symbols"
+          }
+        ]
+      };
+    }
+    for (const path of paths) {
+      if (signal?.aborted) {
+        return {
+          isError: true,
+          details: "code_map aborted",
+          content: [{ type: "text", text: "code_map aborted" }]
+        };
+      }
+      try {
+        const symbols = collapseGroupedSymbols(await collectSymbols(ctx.cwd, path, kinds));
+        result.symbols.push(...symbols);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        result.failed.push(`${path}: ${message}`);
+      }
+    }
+    const outputLines = [];
+    let outputPath = "";
+    for (const symbol of result.symbols) {
+      if (symbol.path !== outputPath) {
+        outputPath = symbol.path;
+        outputLines.push(symbol.path);
+      }
+      let line = `  [${symbol.public ? "public " : ""}${symbol.kind}] ${symbol.name}`;
+      if (symbol.range) {
+        line += ` L${symbol.range[0]}-L${symbol.range[1]}`;
+      }
+      outputLines.push(line);
+    }
+    if (result.failed.length > 0) {
+      outputLines.push(...result.failed.map((failure) => `failed ${failure}`));
+    }
+    if (outputLines.length === 0) {
+      outputLines.push("(no symbols found) targets matched no supported files or symbols");
+    }
+    const truncation = truncateHead(outputLines.join("\n"));
+    const output = truncation.truncated ? `${truncation.content}
+
+[Output truncated at 2000 lines or 50KB. Narrow targets or kinds.]` : truncation.content;
+    return { isError: false, details: output, content: [{ type: "text", text: output }] };
+  },
+  renderCall(args, theme, { isPartial }) {
+    const targets = Array.isArray(args.targets) ? args.targets.join(", ") : "";
+    const kinds = Array.isArray(args.kinds) ? args.kinds.join(", ") : "default";
+    return renderCallText(
+      `${theme.fg("toolTitle", "code_map")} ${theme.underline(theme.fg("accent", targets))} ${theme.fg("dim", `[${kinds}]`)}`,
+      isPartial
+    );
+  }
+});
+var mapper_default = codeMap;
+
+// src/optimizer/inspector/index.ts
+import { defineTool as defineTool2 } from "@earendil-works/pi-coding-agent";
+import { Text as Text2 } from "@earendil-works/pi-tui";
+import { Type as Type3 } from "typebox";
+
+// src/optimizer/inspector/inspect.ts
+function inspectGroupedSymbols(path, symbolName, symbols) {
+  const groupedSymbolsMatch = /^(imports|exports)~([1-9]\d*)$/.exec(symbolName);
+  if (!groupedSymbolsMatch) return;
+  const groupedSymbolKind = groupedSymbolsMatch[1] === "imports" ? "deps" : "public";
+  const requestedGroup = Number(groupedSymbolsMatch[2]);
+  const groupedNodes = [];
+  const groupedRanges = /* @__PURE__ */ new Set();
+  let symbolsCollapsed = false;
+  let symbolsGroupIndex = 0;
+  for (const symbol of symbols) {
+    if (symbol.kind !== groupedSymbolKind) {
+      symbolsCollapsed = false;
+      continue;
+    }
+    if (!symbolsCollapsed) {
+      symbolsCollapsed = true;
+      symbolsGroupIndex += 1;
+    }
+    if (symbolsGroupIndex !== requestedGroup) continue;
+    let groupedNode = symbol.node;
+    if (groupedSymbolKind === "deps") {
+      while (groupedNode.parent?.parent) {
+        groupedNode = groupedNode.parent;
+      }
+    }
+    const groupedRange = `${groupedNode.startIndex}-${groupedNode.endIndex}`;
+    if (groupedRanges.has(groupedRange)) continue;
+    groupedRanges.add(groupedRange);
+    groupedNodes.push(groupedNode);
+  }
+  const firstNode = groupedNodes[0];
+  const lastNode = groupedNodes[groupedNodes.length - 1];
+  if (!firstNode || !lastNode) return;
+  return {
+    path,
+    symbol: symbolName,
+    text: groupedNodes.map((groupedNode) => groupedNode.text).join("\n"),
+    range: [
+      firstNode.startPosition.row + 1,
+      lastNode.endPosition.row + (lastNode.endPosition.column > 0 ? 1 : 0)
+    ]
+  };
+}
+async function inspectSymbol(cwd, path, symbolName, signal) {
+  if (signal?.aborted) {
+    throw new Error("inspector aborted");
+  }
+  const kinds = new Set(SYMBOL_KINDS);
+  const symbols = await collectSymbols(cwd, path, kinds);
+  const inspectedGroup = inspectGroupedSymbols(path, symbolName, symbols);
+  if (inspectedGroup) return inspectedGroup;
+  for (const symbol of symbols) {
+    if (symbol.name !== symbolName) continue;
+    return {
+      path: symbol.path,
+      symbol: symbol.name,
+      range: [
+        symbol.node.startPosition.row + 1,
+        symbol.node.endPosition.row + (symbol.node.endPosition.column > 0 ? 1 : 0)
+      ],
+      text: symbol.node.text
+    };
+  }
+}
+
+// src/optimizer/inspector/index.ts
+var inspect = defineTool2({
+  name: "inspect",
+  label: "Inspect",
+  description: "Fetch one symbol's full body from one file. Output is safe for targeted edits.",
+  parameters: Type3.Object({
+    path: Type3.String({
+      description: "Exact file path containing target symbol (relative to cwd or absolute)"
+    }),
+    symbol: Type3.String({
+      description: "Exact symbol string for one declaration in file: function name, class name, method name (MyClass.method), synthetic anonymous name (anonymous~1), or duplicate form name~2"
+    })
+  }),
+  async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+    const path = params.path.trim().replaceAll("\\", "/");
+    const symbol = params.symbol.trim();
+    if (path.length === 0 || symbol.length === 0 || symbol.includes("#")) {
+      return {
+        isError: false,
+        details: null,
+        content: [
+          {
+            type: "text",
+            text: "inspect symbol format invalid. path/symbol must be non-empty; symbol cannot include '#'. use symbol name, e.g. name or name~2"
+          }
+        ]
+      };
+    }
+    try {
+      const inspected = await inspectSymbol(ctx.cwd, path, symbol, signal);
+      if (!inspected) {
+        return {
+          isError: false,
+          details: null,
+          content: [
+            {
+              type: "text",
+              text: "inspect symbol not found. verify path/symbol; for duplicates use ~n suffix (name~2). then try container symbol. if still missing, run code_map with broader kinds"
+            }
+          ]
+        };
+      }
+      const details = {
+        path: inspected.path,
+        symbol: inspected.symbol,
+        range: inspected.range
+      };
+      return { isError: false, details, content: [{ type: "text", text: inspected.text }] };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return {
+        isError: true,
+        details: null,
+        content: [{ type: "text", text: `inspect failed: ${message}` }]
+      };
+    }
+  },
+  renderCall(args, theme) {
+    return new Text2(
+      `${theme.fg("toolTitle", "inspect")} ${theme.underline(theme.fg("accent", args.path))} ${theme.fg("warning", args.symbol)}`,
+      0,
+      0
+    );
+  },
+  renderResult(result, { expanded }, theme, context) {
+    if (!expanded && !context.isError) {
+      return new Text2("", 0, 0);
+    }
+    const output = result.content[0];
+    return new Text2(
+      `
+${output?.type === "text" ? theme.fg("toolOutput", output.text) : ""}`,
+      0,
+      0
+    );
+  }
+});
+var inspector_default = inspect;
+
+// src/optimizer/pruner/cleanup.ts
+function resolveRemovedId(entryId, replacementParents) {
+  const visitedIds = /* @__PURE__ */ new Set();
+  let resolvedId = entryId;
+  while (resolvedId && replacementParents.has(resolvedId) && !visitedIds.has(resolvedId)) {
+    visitedIds.add(resolvedId);
+    resolvedId = replacementParents.get(resolvedId) ?? null;
+  }
+  return resolvedId;
+}
+function hasEmptyResult(message) {
+  if (message.toolName !== "ls" && message.toolName !== "find") {
+    return false;
+  }
+  if (!Array.isArray(message.content) || message.content.length !== 1) return false;
+  const content = message.content[0];
+  if (!isRecord(content) || content.type !== "text" || typeof content.text !== "string") return false;
+  return content.text === "(empty directory)" || content.text === "No files found matching pattern" || content.text === "No changes found." || content.text === "No changes in selected files.";
+}
+function getRemovedToolCallId(message) {
+  if (typeof message.toolCallId !== "string") return;
+  if (message.isError === true) return message.toolName === "bash" ? void 0 : message.toolCallId;
+  return hasEmptyResult(message) ? message.toolCallId : void 0;
+}
+function removeEntries(entries) {
+  const removedToolCallIds = /* @__PURE__ */ new Set();
+  const replacementParents = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const message = getToolResultMessage(entry);
+    const entryId = getEntryId(entry);
+    const toolCallId = message ? getRemovedToolCallId(message) : void 0;
+    if (!entryId || !toolCallId) continue;
+    removedToolCallIds.add(toolCallId);
+    replacementParents.set(entryId, getParentId(entry));
+  }
+  if (removedToolCallIds.size === 0) {
+    return { changed: false, entries, replacementParents };
+  }
+  const retainedEntries = [];
+  for (const entry of entries) {
+    const entryId = getEntryId(entry);
+    if (entryId && replacementParents.has(entryId)) continue;
+    const message = getMessage(entry);
+    if (message?.role !== "assistant" || !Array.isArray(message.content)) {
+      retainedEntries.push(entry);
+      continue;
+    }
+    const retainedContent = message.content.filter(
+      (block) => !isRecord(block) || block.type !== "toolCall" || typeof block.id !== "string" || !removedToolCallIds.has(block.id)
+    );
+    if (retainedContent.length === message.content.length) {
+      retainedEntries.push(entry);
+      continue;
+    }
+    if (entryId && retainedContent.every((block) => isRecord(block) && block.type === "thinking")) {
+      replacementParents.set(entryId, getParentId(entry));
+      continue;
+    }
+    retainedEntries.push({ ...entry, message: { ...message, content: retainedContent } });
+  }
+  const repairedEntries = [];
+  for (const entry of retainedEntries) {
+    const updatedEntry = { ...entry };
+    let changed = false;
+    const parentId = getParentId(entry);
+    const repairedParentId = resolveRemovedId(parentId, replacementParents);
+    if (parentId !== repairedParentId) {
+      updatedEntry.parentId = repairedParentId;
+      changed = true;
+    }
+    for (const referenceField of ["fromId", "targetId", "firstKeptEntryId"]) {
+      const referenceId = entry[referenceField];
+      if (typeof referenceId !== "string") continue;
+      const repairedReferenceId = resolveRemovedId(referenceId, replacementParents);
+      if (repairedReferenceId && repairedReferenceId !== referenceId) {
+        updatedEntry[referenceField] = repairedReferenceId;
+        changed = true;
+      }
+    }
+    repairedEntries.push(changed ? updatedEntry : entry);
+  }
+  return { changed: true, entries: repairedEntries, replacementParents };
+}
+
+// src/optimizer/pruner/context.ts
+function buildPrunerState(entries) {
+  const removedToolCallIds = /* @__PURE__ */ new Set();
+  for (const entry of entries) {
+    const message = getToolResultMessage(entry);
+    const toolCallId = message ? getRemovedToolCallId(message) : void 0;
+    if (toolCallId) removedToolCallIds.add(toolCallId);
+  }
+  return removedToolCallIds;
+}
+function filterContextMessages(messages, state) {
+  if (state.size === 0) return { changed: false, messages };
+  const retainedMessages = [];
+  let changed = false;
+  for (const message of messages) {
+    if (message.role === "toolResult" && state.has(message.toolCallId)) {
+      changed = true;
+      continue;
+    }
+    if (message.role !== "assistant") {
+      retainedMessages.push(message);
+      continue;
+    }
+    const retainedContent = message.content.filter(
+      (block) => block.type !== "toolCall" || !state.has(block.id)
+    );
+    if (retainedContent.length === message.content.length) {
+      retainedMessages.push(message);
+      continue;
+    }
+    changed = true;
+    if (retainedContent.some((block) => block.type !== "thinking")) {
+      retainedMessages.push({ ...message, content: retainedContent });
+    }
+  }
+  return { changed, messages: retainedMessages };
+}
+
+// src/optimizer/pruner/session.ts
+function pruneEntries(entries, leafId) {
+  const entryRemoval = removeEntries(entries);
+  let activeLeafId = leafId;
+  while (activeLeafId && entryRemoval.replacementParents.has(activeLeafId)) {
+    activeLeafId = entryRemoval.replacementParents.get(activeLeafId) ?? null;
+  }
+  return {
+    activeLeafId,
+    changed: entryRemoval.changed,
+    entries: entryRemoval.entries
+  };
+}
+function rewritePrunedSessionFile(sessionFile, leafId, fallbackToLastEntry) {
+  const entries = readSessionEntries(sessionFile);
+  if (!entries) return;
+  const effectiveLeafId = leafId ?? (fallbackToLastEntry ? getLastEntryId(entries) : null);
+  const pruned = pruneEntries(entries, effectiveLeafId);
+  if (!pruned.changed) return;
+  writeSessionEntries(sessionFile, pruned.entries);
+}
+
+// src/optimizer/pruner/index.ts
+function loadPrunerState(sessionFile) {
+  const entries = readSessionEntries(sessionFile);
+  return entries ? buildPrunerState(entries) : /* @__PURE__ */ new Set();
+}
+function pruner_default(pi) {
+  let state = /* @__PURE__ */ new Set();
+  pi.on("session_start", (_event, ctx) => {
+    state = loadPrunerState(ctx.sessionManager.getSessionFile());
+  });
+  pi.on("session_tree", (_event, ctx) => {
+    state = loadPrunerState(ctx.sessionManager.getSessionFile());
+  });
+  pi.on("agent_end", (event) => {
+    for (const message of event.messages) {
+      if (message.role !== "toolResult") continue;
+      const toolCallId = getRemovedToolCallId(message);
+      if (toolCallId) state.add(toolCallId);
+    }
+  });
+  pi.on("session_shutdown", (event, ctx) => {
+    const sessionFile = ctx.sessionManager.getSessionFile();
+    if (sessionFile) {
+      rewritePrunedSessionFile(sessionFile, ctx.sessionManager.getLeafId(), false);
+    }
+    if (event.targetSessionFile && event.targetSessionFile !== sessionFile) {
+      rewritePrunedSessionFile(event.targetSessionFile, null, true);
+    }
+  });
+  pi.on("context", (event) => {
+    const pruned = filterContextMessages(event.messages, state);
+    if (pruned.changed) return { messages: pruned.messages };
+  });
+}
+
+// src/optimizer/index.ts
+function index_default(pi) {
+  compactor_default(pi);
+  languages_default(pi);
+  deduplicator_default(pi);
+  pruner_default(pi);
+  pi.registerTool(mapper_default);
+  pi.registerTool(inspector_default);
+}
+export {
+  index_default as default
+};
+//# sourceMappingURL=index.js.map