@cortexkit/aft-pi 0.14.0 → 0.15.0

package/dist/index.js

@@ -3,7 +3,7 @@ var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // src/index.ts
 import { createRequire as createRequire3 } from "node:module";
-import { homedir as homedir5 } from "node:os";
+import { homedir as homedir7 } from "node:os";
 import { join as join8 } from "node:path";
 
 // src/shared/status.ts
@@ -1342,6 +1342,197 @@ function registerShutdownCleanup(fn) {
 // src/tools/ast.ts
 import { StringEnum } from "@mariozechner/pi-ai";
 import { Type } from "@sinclair/typebox";
+
+// src/tools/render-helpers.ts
+import { homedir as homedir5 } from "node:os";
+import { renderDiff } from "@mariozechner/pi-coding-agent";
+import { Container, Spacer, Text } from "@mariozechner/pi-tui";
+function reuseText(last) {
+  return last instanceof Text ? last : new Text("", 0, 0);
+}
+function reuseContainer(last) {
+  return last instanceof Container ? last : new Container;
+}
+function shortenPath(path2) {
+  const home = homedir5();
+  if (path2.startsWith(home))
+    return `~${path2.slice(home.length)}`;
+  return path2;
+}
+function renderToolCall(toolName, summary, theme, context) {
+  const text = reuseText(context.lastComponent);
+  const suffix = summary ? ` ${summary}` : "";
+  text.setText(`${theme.fg("toolTitle", theme.bold(toolName))}${suffix}`);
+  return text;
+}
+function accentPath(theme, path2) {
+  if (!path2)
+    return theme.fg("toolOutput", "...");
+  return theme.fg("accent", shortenPath(path2));
+}
+function collectTextContent(result) {
+  return result.content.filter((part) => part.type === "text").map((part) => part.text ?? "").join(`
+`).trim();
+}
+function extractStructuredPayload(result) {
+  if (result.details !== undefined)
+    return result.details;
+  const text = collectTextContent(result);
+  if (!text)
+    return;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return;
+  }
+}
+function renderErrorResult(result, fallback, theme, context) {
+  const text = reuseText(context.lastComponent);
+  const message = collectTextContent(result) || fallback;
+  text.setText(`
+${theme.fg("error", message)}`);
+  return text;
+}
+function renderSections(sections, context) {
+  const container = reuseContainer(context.lastComponent);
+  container.clear();
+  const visibleSections = sections.filter((section) => section.trim().length > 0);
+  if (visibleSections.length === 0)
+    return container;
+  container.addChild(new Spacer(1));
+  visibleSections.forEach((section, index) => {
+    if (index > 0)
+      container.addChild(new Spacer(1));
+    container.addChild(new Text(section, 0, 0));
+  });
+  return container;
+}
+function asRecord2(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return;
+  return value;
+}
+function asRecords(value) {
+  return Array.isArray(value) ? value.map(asRecord2).filter(Boolean) : [];
+}
+function asString(value) {
+  return typeof value === "string" ? value : undefined;
+}
+function asNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+function asBoolean(value) {
+  return typeof value === "boolean" ? value : undefined;
+}
+function formatValue(value) {
+  if (Array.isArray(value))
+    return value.map(formatValue).join(", ");
+  if (typeof value === "string")
+    return value;
+  if (typeof value === "number" || typeof value === "boolean")
+    return String(value);
+  if (value === null || value === undefined)
+    return "—";
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+function groupByFile(items, getFile) {
+  const groups = new Map;
+  items.forEach((item) => {
+    const file = getFile(item) ?? "(unknown file)";
+    const current = groups.get(file) ?? [];
+    current.push(item);
+    groups.set(file, current);
+  });
+  return groups;
+}
+function distinctCount(values) {
+  return new Set(values.filter((value) => Boolean(value))).size;
+}
+function severityBadge(theme, severity) {
+  const label = severity === "information" ? "info" : severity;
+  switch (severity) {
+    case "error":
+      return theme.fg("error", `[${label}]`);
+    case "warning":
+      return theme.fg("warning", `[${label}]`);
+    case "information":
+      return theme.fg("accent", `[${label}]`);
+    case "hint":
+      return theme.fg("muted", `[${label}]`);
+    default:
+      return theme.fg("muted", `[${label}]`);
+  }
+}
+function formatTimestamp(value) {
+  if (typeof value === "string" && value.length > 0)
+    return value;
+  if (typeof value !== "number" || !Number.isFinite(value))
+    return;
+  const millis = value > 1000000000000 ? value : value * 1000;
+  const date = new Date(millis);
+  if (Number.isNaN(date.getTime()))
+    return String(value);
+  return date.toISOString().replace("T", " ").replace(".000Z", "Z");
+}
+function formatUnifiedDiffForPi(unifiedDiff) {
+  if (!unifiedDiff.trim())
+    return "";
+  const entries = [];
+  const hunkHeader = /^@@ -(\d+)(?:,\d+)? \+(\d+)(?:,\d+)? @@/;
+  let oldLine = 1;
+  let newLine = 1;
+  for (const line of unifiedDiff.split(`
+`)) {
+    if (!line)
+      continue;
+    if (line.startsWith("--- ") || line.startsWith("+++ "))
+      continue;
+    if (line.startsWith("\"))
+      continue;
+    const headerMatch = line.match(hunkHeader);
+    if (headerMatch) {
+      oldLine = Number(headerMatch[1]);
+      newLine = Number(headerMatch[2]);
+      continue;
+    }
+    if (line.startsWith("+") && !line.startsWith("+++")) {
+      entries.push({ prefix: "+", line: newLine, text: line.slice(1) });
+      newLine += 1;
+      continue;
+    }
+    if (line.startsWith("-") && !line.startsWith("---")) {
+      entries.push({ prefix: "-", line: oldLine, text: line.slice(1) });
+      oldLine += 1;
+      continue;
+    }
+    if (line.startsWith(" ")) {
+      entries.push({ prefix: " ", line: oldLine, text: line.slice(1) });
+      oldLine += 1;
+      newLine += 1;
+    }
+  }
+  if (entries.length === 0)
+    return "";
+  const width = String(entries.reduce((max, entry) => Math.max(max, entry.line), 1)).length;
+  return entries.map((entry) => `${entry.prefix}${String(entry.line).padStart(width, " ")} ${entry.text}`).join(`
+`);
+}
+function renderUnifiedDiff(unifiedDiff) {
+  const piDiff = formatUnifiedDiffForPi(unifiedDiff);
+  if (!piDiff)
+    return "";
+  try {
+    return renderDiff(piDiff);
+  } catch {
+    return piDiff;
+  }
+}
+
+// src/tools/ast.ts
 var AstLang = StringEnum(["typescript", "tsx", "javascript", "python", "rust", "go"], {
   description: "Target language"
 });
@@ -1362,6 +1553,107 @@ var ReplaceParams = Type.Object({
   globs: Type.Optional(Type.Array(Type.String(), { description: "Include/exclude globs" })),
   dryRun: Type.Optional(Type.Boolean({ description: "Preview without applying (default: false)" }))
 });
+function buildAstSearchSections(payload, theme) {
+  const response = asRecord2(payload);
+  if (!response)
+    return [theme.fg("muted", "No AST search results.")];
+  const matches = asRecords(response.matches);
+  const totalMatches = asNumber(response.total_matches) ?? matches.length;
+  const filesWithMatches = asNumber(response.files_with_matches) ?? groupByFile(matches, (match) => asString(match.file)).size;
+  const filesSearched = asNumber(response.files_searched);
+  const header = [
+    theme.fg("success", `${totalMatches} match${totalMatches === 1 ? "" : "es"}`),
+    theme.fg("accent", `${filesWithMatches} file${filesWithMatches === 1 ? "" : "s"}`),
+    filesSearched !== undefined ? theme.fg("muted", `${filesSearched} searched`) : undefined
+  ].filter(Boolean).join(" · ");
+  if (matches.length === 0)
+    return [header, theme.fg("muted", "No AST matches found.")];
+  const grouped = groupByFile(matches, (match) => asString(match.file));
+  const sections = [header];
+  for (const [file, fileMatches] of grouped.entries()) {
+    const lines = [theme.fg("accent", shortenPath(file))];
+    fileMatches.forEach((match, index) => {
+      const line = asNumber(match.line) ?? 0;
+      const column = asNumber(match.column) ?? 0;
+      const snippet = asString(match.text)?.trim() || "(empty match)";
+      lines.push(`  ${index + 1}. ${theme.fg("muted", `${line}:${column}`)} ${snippet}`);
+      const metaVars = asRecord2(match.meta_variables);
+      if (metaVars && Object.keys(metaVars).length > 0) {
+        Object.entries(metaVars).forEach(([name, value]) => {
+          lines.push(`     ${theme.fg("muted", `${name} =`)} ${formatValue(value)}`);
+        });
+      }
+      const context = asRecords(match.context);
+      context.forEach((ctxLine) => {
+        const ctxNumber = asNumber(ctxLine.line) ?? 0;
+        const prefix = ctxLine.is_match === true ? theme.fg("accent", ">") : theme.fg("muted", "|");
+        lines.push(`     ${prefix} ${ctxNumber}: ${asString(ctxLine.text) ?? ""}`);
+      });
+    });
+    sections.push(lines.join(`
+`));
+  }
+  return sections;
+}
+function buildAstReplaceSections(payload, theme) {
+  const response = asRecord2(payload);
+  if (!response)
+    return [theme.fg("muted", "No AST replace results.")];
+  const files = asRecords(response.files);
+  const totalReplacements = asNumber(response.total_replacements) ?? 0;
+  const totalFiles = asNumber(response.total_files) ?? files.length;
+  const filesWithMatches = asNumber(response.files_with_matches);
+  const dryRun = response.dry_run === true;
+  const headerParts = [
+    dryRun ? theme.fg("warning", "[dry run]") : theme.fg("success", "[applied]"),
+    `${totalReplacements} replacement${totalReplacements === 1 ? "" : "s"}`,
+    `${totalFiles} file${totalFiles === 1 ? "" : "s"}`,
+    filesWithMatches !== undefined ? theme.fg("muted", `${filesWithMatches} matched`) : undefined
+  ];
+  const sections = [headerParts.filter(Boolean).join(" ")];
+  if (files.length === 0) {
+    sections.push(theme.fg("muted", "No files changed."));
+    return sections;
+  }
+  files.forEach((fileResult) => {
+    const file = shortenPath(asString(fileResult.file) ?? "(unknown file)");
+    const replacements = asNumber(fileResult.replacements) ?? 0;
+    const error2 = asString(fileResult.error);
+    const diff = asString(fileResult.diff);
+    const lines = [
+      `${theme.fg("accent", file)} ${theme.fg("muted", `(${replacements} replacement${replacements === 1 ? "" : "s"})`)}`
+    ];
+    if (error2) {
+      lines.push(theme.fg("error", error2));
+    } else if (diff) {
+      const rendered = renderUnifiedDiff(diff);
+      lines.push(rendered || theme.fg("muted", "No diff available."));
+    } else {
+      const backupId = asString(fileResult.backup_id);
+      lines.push(backupId ? `${theme.fg("success", "saved")} ${theme.fg("muted", backupId)}` : theme.fg("success", "saved"));
+    }
+    sections.push(lines.join(`
+`));
+  });
+  return sections;
+}
+function renderAstCall(toolName, args, theme, context) {
+  const lang = theme.fg("accent", args.lang);
+  const summary = toolName === "ast_grep_replace" ? `${lang} ${theme.fg("toolOutput", `${args.pattern} → ${args.rewrite}`)}` : `${lang} ${theme.fg("toolOutput", args.pattern)}`;
+  return renderToolCall(toolName === "ast_grep_replace" ? "ast replace" : "ast search", summary, theme, context);
+}
+function renderAstResult(toolName, result, theme, context) {
+  if (context.isError) {
+    return renderErrorResult(result, `${toolName} failed`, theme, context);
+  }
+  const payload = extractStructuredPayload(result);
+  if (!payload) {
+    const text = collectTextContent(result);
+    return renderSections([text || theme.fg("muted", "No result.")], context);
+  }
+  const sections = toolName === "ast_grep_replace" ? buildAstReplaceSections(payload, theme) : buildAstSearchSections(payload, theme);
+  return renderSections(sections, context);
+}
 function registerAstTools(pi, ctx, surface) {
   if (surface.astSearch) {
     pi.registerTool({
@@ -1383,6 +1675,12 @@ function registerAstTools(pi, ctx, surface) {
           req.context_lines = params.contextLines;
         const response = await callBridge(bridge, "ast_search", req);
         return textResult(response.text ?? JSON.stringify(response));
+      },
+      renderCall(args, theme, context) {
+        return renderAstCall("ast_grep_search", args, theme, context);
+      },
+      renderResult(result, _options, theme, context) {
+        return renderAstResult("ast_grep_search", result, theme, context);
       }
     });
   }
@@ -1406,6 +1704,12 @@ function registerAstTools(pi, ctx, surface) {
         req.dry_run = params.dryRun === true;
         const response = await callBridge(bridge, "ast_replace", req);
         return textResult(response.text ?? JSON.stringify(response));
+      },
+      renderCall(args, theme, context) {
+        return renderAstCall("ast_grep_replace", args, theme, context);
+      },
+      renderResult(result, _options, theme, context) {
+        return renderAstResult("ast_grep_replace", result, theme, context);
       }
     });
   }
@@ -1414,6 +1718,32 @@ function registerAstTools(pi, ctx, surface) {
 // src/tools/conflicts.ts
 import { Type as Type2 } from "@sinclair/typebox";
 var ConflictsParams = Type2.Object({});
+function renderConflictCall(theme, context) {
+  return renderToolCall("conflicts", undefined, theme, context);
+}
+function buildConflictSections(text) {
+  const trimmed = text.trim();
+  if (!trimmed)
+    return ["No merge conflicts found."];
+  const [header, ...rest] = trimmed.split(/\n\n+/);
+  const match = header.match(/^(\d+)\s+files?,\s+(\d+)\s+conflicts?/i);
+  const sections = [
+    match ? `${match[1]} conflicted file${match[1] === "1" ? "" : "s"} · ${match[2]} region${match[2] === "1" ? "" : "s"}` : header
+  ];
+  if (rest.length === 0)
+    return sections;
+  sections.push(...rest.map((section) => section.trim()).filter(Boolean));
+  return sections;
+}
+function renderConflictResult(text, theme, context) {
+  const sections = buildConflictSections(text).map((section, index) => index === 0 ? theme.fg("warning", section) : section);
+  return renderSections(sections, context);
+}
+function renderConflictToolResult(result, theme, context) {
+  if (context.isError)
+    return renderErrorResult(result, "conflicts failed", theme, context);
+  return renderConflictResult(collectTextContent(result), theme, context);
+}
 function registerConflictsTool(pi, ctx) {
   pi.registerTool({
     name: "aft_conflicts",
@@ -1424,6 +1754,12 @@ function registerConflictsTool(pi, ctx) {
       const bridge = bridgeFor(ctx, extCtx.cwd);
       const response = await callBridge(bridge, "git_conflicts");
       return textResult(response.text ?? JSON.stringify(response, null, 2));
+    },
+    renderCall(_args, theme, context) {
+      return renderConflictCall(theme, context);
+    },
+    renderResult(result, _options, theme, context) {
+      return renderConflictToolResult(result, theme, context);
     }
   });
 }
@@ -1437,6 +1773,27 @@ var MoveParams = Type3.Object({
   filePath: Type3.String({ description: "Source file path to move" }),
   destination: Type3.String({ description: "Destination file path" })
 });
+function renderFsCall(toolName, args, theme, context) {
+  if (toolName === "aft_delete") {
+    return renderToolCall("delete", accentPath(theme, args.filePath), theme, context);
+  }
+  const moveArgs = args;
+  return renderToolCall("move", `${accentPath(theme, moveArgs.filePath)} ${theme.fg("muted", "→")} ${accentPath(theme, moveArgs.destination)}`, theme, context);
+}
+function renderFsResult(toolName, args, result, theme, context) {
+  if (context.isError) {
+    return renderErrorResult(result, `${toolName} failed`, theme, context);
+  }
+  if (toolName === "aft_delete") {
+    const filePath = shortenPath(args.filePath);
+    return renderSections([`${theme.fg("success", "✓ deleted")} ${theme.fg("accent", filePath)}`], context);
+  }
+  const moveArgs = args;
+  return renderSections([
+    `${theme.fg("success", "✓ moved")} ${theme.fg("accent", shortenPath(moveArgs.filePath))}`,
+    `${theme.fg("muted", "to")} ${theme.fg("accent", shortenPath(moveArgs.destination))}`
+  ], context);
+}
 function registerFsTools(pi, ctx, surface) {
   if (surface.delete) {
     pi.registerTool({
@@ -1448,6 +1805,12 @@ function registerFsTools(pi, ctx, surface) {
         const bridge = bridgeFor(ctx, extCtx.cwd);
         const response = await callBridge(bridge, "delete_file", { file: params.filePath });
         return textResult(`Deleted ${params.filePath}`, response);
+      },
+      renderCall(args, theme, context) {
+        return renderFsCall("aft_delete", args, theme, context);
+      },
+      renderResult(result, _options, theme, context) {
+        return renderFsResult("aft_delete", context.args, result, theme, context);
       }
     });
   }
@@ -1464,6 +1827,12 @@ function registerFsTools(pi, ctx, surface) {
           destination: params.destination
         });
         return textResult(`Moved ${params.filePath} → ${params.destination}`, response);
+      },
+      renderCall(args, theme, context) {
+        return renderFsCall("aft_move", args, theme, context);
+      },
+      renderResult(result, _options, theme, context) {
+        return renderFsResult("aft_move", context.args, result, theme, context);
       }
     });
   }
@@ -1471,8 +1840,117 @@ function registerFsTools(pi, ctx, surface) {
 
 // src/tools/hoisted.ts
 import { stat } from "node:fs/promises";
+import { homedir as homedir6 } from "node:os";
 import { resolve } from "node:path";
+import {
+  renderDiff as renderDiff2
+} from "@mariozechner/pi-coding-agent";
+import { Container as Container2, Spacer as Spacer2, Text as Text2 } from "@mariozechner/pi-tui";
 import { Type as Type4 } from "@sinclair/typebox";
+
+// src/tools/diff-format.ts
+import { diffLines } from "diff";
+var DEFAULT_CONTEXT_LINES = 4;
+function formatDiffForPi(oldContent, newContent, contextLines = DEFAULT_CONTEXT_LINES) {
+  const parts = diffLines(oldContent, newContent);
+  const output = [];
+  const oldLines = oldContent.split(`
+`);
+  const newLines = newContent.split(`
+`);
+  const maxLineNum = Math.max(oldLines.length, newLines.length);
+  const lineNumWidth = String(maxLineNum).length;
+  const pad = (n) => String(n).padStart(lineNumWidth, " ");
+  const blank = " ".repeat(lineNumWidth);
+  let oldLineNum = 1;
+  let newLineNum = 1;
+  let lastWasChange = false;
+  let firstChangedLine;
+  for (let i = 0;i < parts.length; i++) {
+    const part = parts[i];
+    const raw = part.value.split(`
+`);
+    if (raw[raw.length - 1] === "")
+      raw.pop();
+    if (part.added || part.removed) {
+      if (firstChangedLine === undefined)
+        firstChangedLine = newLineNum;
+      for (const line of raw) {
+        if (part.added) {
+          output.push(`+${pad(newLineNum)} ${line}`);
+          newLineNum++;
+        } else {
+          output.push(`-${pad(oldLineNum)} ${line}`);
+          oldLineNum++;
+        }
+      }
+      lastWasChange = true;
+      continue;
+    }
+    const nextIsChange = i < parts.length - 1 && (parts[i + 1].added || parts[i + 1].removed);
+    const hasLeading = lastWasChange;
+    const hasTrailing = nextIsChange;
+    if (hasLeading && hasTrailing) {
+      if (raw.length <= contextLines * 2) {
+        for (const line of raw) {
+          output.push(` ${pad(oldLineNum)} ${line}`);
+          oldLineNum++;
+          newLineNum++;
+        }
+      } else {
+        for (const line of raw.slice(0, contextLines)) {
+          output.push(` ${pad(oldLineNum)} ${line}`);
+          oldLineNum++;
+          newLineNum++;
+        }
+        const skipped = raw.length - contextLines * 2;
+        output.push(` ${blank} ...`);
+        oldLineNum += skipped;
+        newLineNum += skipped;
+        for (const line of raw.slice(raw.length - contextLines)) {
+          output.push(` ${pad(oldLineNum)} ${line}`);
+          oldLineNum++;
+          newLineNum++;
+        }
+      }
+    } else if (hasLeading) {
+      const shown = raw.slice(0, contextLines);
+      for (const line of shown) {
+        output.push(` ${pad(oldLineNum)} ${line}`);
+        oldLineNum++;
+        newLineNum++;
+      }
+      const skipped = raw.length - shown.length;
+      if (skipped > 0) {
+        output.push(` ${blank} ...`);
+        oldLineNum += skipped;
+        newLineNum += skipped;
+      }
+    } else if (hasTrailing) {
+      const shownCount = Math.min(contextLines, raw.length);
+      const shown = raw.slice(raw.length - shownCount);
+      const skipped = raw.length - shown.length;
+      if (skipped > 0) {
+        output.push(` ${blank} ...`);
+        oldLineNum += skipped;
+        newLineNum += skipped;
+      }
+      for (const line of shown) {
+        output.push(` ${pad(oldLineNum)} ${line}`);
+        oldLineNum++;
+        newLineNum++;
+      }
+    } else {
+      oldLineNum += raw.length;
+      newLineNum += raw.length;
+    }
+    lastWasChange = false;
+  }
+  return { diff: output.join(`
+`), firstChangedLine };
+}
+
+// src/tools/hoisted.ts
 var ReadParams = Type4.Object({
   path: Type4.String({ description: "Path to the file to read (relative or absolute)" }),
   offset: Type4.Optional(Type4.Number({ description: "Line number to start reading from (1-indexed)" })),
@@ -1504,6 +1982,8 @@ function registerHoistedTools(pi, ctx, surface) {
       name: "read",
       label: "read",
       description: "Read file contents with line numbers. Backed by AFT's indexed Rust reader — faster than the built-in `read` on large repos and correctly handles images/PDFs as attachments.",
+      promptSnippet: "Read file contents (supports offset/limit for large files)",
+      promptGuidelines: ["Use read to examine files instead of cat or sed."],
       parameters: ReadParams,
       async execute(_toolCallId, params, _signal, _onUpdate, extCtx) {
         const bridge = bridgeFor(ctx, extCtx.cwd);
@@ -1530,30 +2010,24 @@ function registerHoistedTools(pi, ctx, surface) {
     pi.registerTool({
       name: "write",
       label: "write",
-      description: "Write a file atomically with per-file backup, optional auto-format, and inline LSP diagnostics. Parent directories are created automatically. Overwrites existing files.",
+      description: "Write a file atomically with per-file backup, optional auto-format, and inline LSP diagnostics. Parent directories are created automatically. Overwrites existing files. Uses `filePath` (not `path`).",
+      promptSnippet: "Create or overwrite files (uses filePath; auto-formats; returns LSP diagnostics inline)",
+      promptGuidelines: ["Use write only for new files or complete rewrites."],
       parameters: WriteParams,
       async execute(_toolCallId, params, _signal, _onUpdate, extCtx) {
         const bridge = bridgeFor(ctx, extCtx.cwd);
         const response = await callBridge(bridge, "write", {
           file: params.filePath,
-          content: params.content
-        });
-        const diffAdd = response.diff?.additions ?? 0;
-        const diffDel = response.diff?.deletions ?? 0;
-        const diagnostics = response.lsp_diagnostics;
-        let summary = `Wrote ${params.filePath} (+${diffAdd}/-${diffDel})`;
-        if (diagnostics && diagnostics.length > 0) {
-          summary += `
-
-LSP diagnostics:
-${JSON.stringify(diagnostics, null, 2)}`;
-        }
-        return textResult(summary, {
-          filePath: params.filePath,
-          additions: diffAdd,
-          deletions: diffDel,
-          diagnostics
+          content: params.content,
+          include_diff: true
         });
+        return buildMutationResult(params.filePath, response);
+      },
+      renderCall(args, theme, context) {
+        return renderMutationCall("write", args?.filePath, theme, context);
+      },
+      renderResult(result, _options, theme, context) {
+        return renderMutationResult(result, theme, context);
       }
     });
   }
@@ -1561,39 +2035,33 @@ ${JSON.stringify(diagnostics, null, 2)}`;
     pi.registerTool({
       name: "edit",
       label: "edit",
-      description: "Find-and-replace edit with progressive fuzzy matching (handles whitespace and Unicode drift). Returns an error if multiple matches are found — use `occurrence` to select one, or `replaceAll: true` to replace all. Always returns inline LSP diagnostics for the edited file.",
+      description: "Find-and-replace edit with progressive fuzzy matching (handles whitespace and Unicode drift). Uses `filePath`, `oldString`, `newString`. Errors on multiple matches — use `occurrence` to pick one, or `replaceAll: true`. Always returns LSP diagnostics inline.",
+      promptSnippet: "Targeted find-and-replace (uses filePath/oldString/newString; occurrence or replaceAll for disambiguation; fuzzy whitespace matching)",
+      promptGuidelines: [
+        "Prefer edit over write when changing part of an existing file.",
+        "Include enough surrounding context in oldString to make the match unique, or set replaceAll/occurrence explicitly."
+      ],
       parameters: EditParams,
       async execute(_toolCallId, params, _signal, _onUpdate, extCtx) {
         const bridge = bridgeFor(ctx, extCtx.cwd);
         const req = {
           file: params.filePath,
           match: params.oldString ?? "",
-          replacement: params.newString ?? ""
+          replacement: params.newString ?? "",
+          include_diff: true
         };
         if (params.replaceAll === true)
           req.replace_all = true;
         if (params.occurrence !== undefined)
           req.occurrence = params.occurrence;
         const response = await callBridge(bridge, "edit_match", req);
-        const diff = response.diff;
-        const diffAdd = diff?.additions ?? 0;
-        const diffDel = diff?.deletions ?? 0;
-        const replacements = response.replacements;
-        const diagnostics = response.lsp_diagnostics;
-        let summary = `Edited ${params.filePath} (+${diffAdd}/-${diffDel}, ${replacements ?? 1} replacement${replacements === 1 ? "" : "s"})`;
-        if (diagnostics && diagnostics.length > 0) {
-          summary += `
-
-LSP diagnostics:
-${JSON.stringify(diagnostics, null, 2)}`;
-        }
-        return textResult(summary, {
-          filePath: params.filePath,
-          additions: diffAdd,
-          deletions: diffDel,
-          replacements,
-          diagnostics
-        });
+        return buildMutationResult(params.filePath, response);
+      },
+      renderCall(args, theme, context) {
+        return renderMutationCall("edit", args?.filePath, theme, context);
+      },
+      renderResult(result, _options, theme, context) {
+        return renderMutationResult(result, theme, context);
       }
     });
   }
@@ -1602,6 +2070,8 @@ ${JSON.stringify(diagnostics, null, 2)}`;
       name: "grep",
       label: "grep",
       description: "Search for a regex pattern across files. Uses AFT's trigram index inside the project root for fast repeated queries, and falls back to ripgrep for paths outside the project root.",
+      promptSnippet: "Fast regex search across files (trigram-indexed inside the project root)",
+      promptGuidelines: ["Prefer grep over bash-invoked find/rg for in-project searches."],
       parameters: GrepParams,
       async execute(_toolCallId, params, _signal, _onUpdate, extCtx) {
         const bridge = bridgeFor(ctx, extCtx.cwd);
@@ -1621,6 +2091,112 @@ ${JSON.stringify(diagnostics, null, 2)}`;
     });
   }
 }
+function buildMutationResult(filePath, response) {
+  const diffObj = response.diff;
+  const additions = diffObj?.additions ?? 0;
+  const deletions = diffObj?.deletions ?? 0;
+  const replacements = response.replacements;
+  const diagnostics = response.lsp_diagnostics;
+  const truncated = diffObj?.truncated === true;
+  let diffText;
+  let firstChangedLine;
+  if (diffObj && !truncated && typeof diffObj.before === "string" && typeof diffObj.after === "string") {
+    const formatted = formatDiffForPi(diffObj.before, diffObj.after);
+    diffText = formatted.diff;
+    firstChangedLine = formatted.firstChangedLine;
+  }
+  const summaryHeader = replacements !== undefined ? `Edited ${filePath} (+${additions}/-${deletions}, ${replacements} replacement${replacements === 1 ? "" : "s"})` : `Wrote ${filePath} (+${additions}/-${deletions})`;
+  let text = summaryHeader;
+  if (diffText)
+    text += `
+
+${diffText}`;
+  if (truncated) {
+    text += `
+
+(diff truncated — file too large to include before/after content)`;
+  }
+  if (diagnostics && diagnostics.length > 0) {
+    text += `
+
+LSP diagnostics:
+${formatDiagnosticsText(diagnostics)}`;
+  }
+  return {
+    content: [{ type: "text", text }],
+    details: {
+      diff: diffText,
+      firstChangedLine,
+      additions,
+      deletions,
+      replacements,
+      diagnostics,
+      truncated: truncated || undefined
+    }
+  };
+}
+function formatDiagnosticsText(diagnostics) {
+  try {
+    return diagnostics.map((d) => {
+      if (d && typeof d === "object") {
+        const obj = d;
+        const line = obj.line ?? obj.startLine ?? "?";
+        const severity = obj.severity ?? "info";
+        const msg = obj.message ?? JSON.stringify(obj);
+        return `  [${severity}] line ${line}: ${msg}`;
+      }
+      return `  ${String(d)}`;
+    }).join(`
+`);
+  } catch {
+    return JSON.stringify(diagnostics, null, 2);
+  }
+}
+function reuseText2(last) {
+  return last instanceof Text2 ? last : new Text2("", 0, 0);
+}
+function reuseContainer2(last) {
+  return last instanceof Container2 ? last : new Container2;
+}
+function renderMutationCall(toolName, filePath, theme, context) {
+  const text = reuseText2(context.lastComponent);
+  const pathDisplay = filePath ? theme.fg("accent", shortenPath2(filePath)) : theme.fg("toolOutput", "...");
+  text.setText(`${theme.fg("toolTitle", theme.bold(toolName))} ${pathDisplay}`);
+  return text;
+}
+function renderMutationResult(result, theme, context) {
+  if (context.isError) {
+    const errorText = result.content.filter((c) => c.type === "text").map((c) => c.text ?? "").join(`
+`).trim();
+    const text = reuseText2(context.lastComponent);
+    text.setText(`
+${theme.fg("error", errorText || "edit failed")}`);
+    return text;
+  }
+  const details = result.details;
+  const diff = typeof details?.diff === "string" ? details.diff : undefined;
+  if (!diff) {
+    const additions = details?.additions ?? 0;
+    const deletions = details?.deletions ?? 0;
+    const text = reuseText2(context.lastComponent);
+    const summary = theme.fg("success", `+${additions}/-${deletions}`);
+    const suffix = details?.truncated ? ` ${theme.fg("muted", "(diff truncated)")}` : "";
+    text.setText(`
+${summary}${suffix}`);
+    return text;
+  }
+  const container = reuseContainer2(context.lastComponent);
+  container.clear();
+  container.addChild(new Spacer2(1));
+  container.addChild(new Text2(renderDiff2(diff), 1, 0));
+  return container;
+}
+function shortenPath2(path2) {
+  const home = homedir6();
+  if (path2.startsWith(home))
+    return `~${path2.slice(home.length)}`;
+  return path2;
+}
 async function resolvePathArg(cwd, path2) {
   const abs = resolve(cwd, path2);
   try {
@@ -1650,6 +2226,54 @@ var ImportParams = Type5.Object({
     description: "Post-edit validation level (default: syntax)"
   }))
 });
+function buildImportSections(args, payload, theme) {
+  const response = asRecord2(payload);
+  if (!response)
+    return [theme.fg("muted", "No import result.")];
+  if (response.dry_run === true) {
+    return [
+      theme.fg("warning", `[dry run] ${args.op}`),
+      asString(response.diff) || theme.fg("muted", "No diff available.")
+    ];
+  }
+  if (args.op === "organize") {
+    const groups = asRecords(response.groups);
+    const groupText = groups.length > 0 ? groups.map((group) => `${asString(group.name) ?? "unknown"}: ${asNumber(group.count) ?? 0}`).join(" · ") : "No imports found";
+    return [
+      `${theme.fg("success", "organized")} ${theme.fg("accent", asString(response.file) ?? args.filePath)}`,
+      `${theme.fg("muted", "groups")} ${groupText}`,
+      `${theme.fg("muted", "duplicates removed")} ${asNumber(response.removed_duplicates) ?? 0}`
+    ];
+  }
+  if (args.op === "add") {
+    const moduleName = asString(response.module) ?? args.module ?? "(module)";
+    const status = response.already_present === true ? theme.fg("warning", "already present") : theme.fg("success", "added");
+    return [
+      `${status} ${theme.fg("accent", moduleName)}`,
+      `${theme.fg("muted", "file")} ${theme.fg("accent", asString(response.file) ?? args.filePath)}`,
+      `${theme.fg("muted", "group")} ${asString(response.group) ?? "—"}`
+    ];
+  }
+  return [
+    `${theme.fg("success", "removed")} ${theme.fg("accent", asString(response.module) ?? args.module ?? "(module)")}`,
+    `${theme.fg("muted", "file")} ${theme.fg("accent", asString(response.file) ?? args.filePath)}`,
+    args.removeName ? `${theme.fg("muted", "name")} ${args.removeName}` : `${theme.fg("muted", "scope")} entire import`
+  ];
+}
+function renderImportCall(args, theme, context) {
+  const summary = [
+    theme.fg("accent", args.op),
+    accentPath(theme, args.filePath),
+    args.module ? theme.fg("toolOutput", args.module) : undefined
+  ].filter(Boolean).join(" ");
+  return renderToolCall("import", summary, theme, context);
+}
+function renderImportResult(result, args, theme, context) {
+  if (context.isError)
+    return renderErrorResult(result, "import failed", theme, context);
+  const payload = extractStructuredPayload(result);
+  return renderSections(buildImportSections(args, payload, theme), context);
+}
 function registerImportTools(pi, ctx) {
   pi.registerTool({
     name: "aft_import",
@@ -1683,6 +2307,12 @@ function registerImportTools(pi, ctx) {
         req.validate = params.validate;
       const response = await callBridge(bridge, commandMap[params.op], req);
       return textResult(JSON.stringify(response, null, 2));
+    },
+    renderCall(args, theme, context) {
+      return renderImportCall(args, theme, context);
+    },
+    renderResult(result, _options, theme, context) {
+      return renderImportResult(result, context.args, theme, context);
     }
   });
 }
@@ -1702,6 +2332,51 @@ var LspDiagnosticsParams = Type6.Object({
     description: "Wait N ms for fresh diagnostics (max 10000, default: 0)"
   }))
 });
+function buildDiagnosticsSections(payload, theme) {
+  const response = asRecord2(payload);
+  if (!response)
+    return [theme.fg("muted", "No diagnostics available.")];
+  const diagnostics = asRecords(response.diagnostics);
+  const total = asNumber(response.total) ?? diagnostics.length;
+  const filesWithErrors = asNumber(response.files_with_errors) ?? distinctCount(diagnostics.filter((diag) => asString(diag.severity) === "error").map((diag) => asString(diag.file)));
+  const filesCount = distinctCount(diagnostics.map((diag) => asString(diag.file)));
+  const sections = [
+    `${theme.fg(total > 0 ? "warning" : "success", `${total} diagnostic${total === 1 ? "" : "s"}`)} ${theme.fg("muted", `across ${filesCount} file${filesCount === 1 ? "" : "s"}, ${filesWithErrors} error file${filesWithErrors === 1 ? "" : "s"}`)}`
+  ];
+  if (diagnostics.length === 0) {
+    sections.push(theme.fg("muted", "No diagnostics found."));
+    return sections;
+  }
+  const grouped = groupByFile(diagnostics, (diag) => asString(diag.file));
+  for (const [file, fileDiagnostics] of grouped.entries()) {
+    const lines = [theme.fg("accent", shortenPath(file))];
+    fileDiagnostics.forEach((diagnostic) => {
+      const severity = asString(diagnostic.severity) ?? "information";
+      const line = asNumber(diagnostic.line) ?? 0;
+      const column = asNumber(diagnostic.column) ?? 0;
+      const code = asString(diagnostic.code);
+      const message = asString(diagnostic.message) ?? "(no message)";
+      const location = `${line}:${column}`;
+      lines.push(`  ${severityBadge(theme, severity)} ${location}${code ? ` ${theme.fg("muted", code)}` : ""} ${message}`);
+    });
+    sections.push(lines.join(`
+`));
+  }
+  return sections;
+}
+function renderDiagnosticsCall(args, theme, context) {
+  const target = args.filePath ?? args.directory;
+  const summary = [
+    target ? accentPath(theme, target) : undefined,
+    args.severity ? theme.fg("toolOutput", args.severity) : undefined
+  ].filter(Boolean).join(" ");
+  return renderToolCall("lsp diagnostics", summary, theme, context);
+}
+function renderDiagnosticsResult(result, theme, context) {
+  if (context.isError)
+    return renderErrorResult(result, "lsp diagnostics failed", theme, context);
+  return renderSections(buildDiagnosticsSections(extractStructuredPayload(result), theme), context);
+}
 function registerLspTools(pi, ctx) {
   pi.registerTool({
     name: "lsp_diagnostics",
@@ -1726,6 +2401,12 @@ function registerLspTools(pi, ctx) {
         req.wait_ms = params.waitMs;
       const response = await callBridge(bridge, "lsp_diagnostics", req);
       return textResult(JSON.stringify(response, null, 2));
+    },
+    renderCall(args, theme, context) {
+      return renderDiagnosticsCall(args, theme, context);
+    },
+    renderResult(result, _options, theme, context) {
+      return renderDiagnosticsResult(result, theme, context);
     }
   });
 }
@@ -1742,6 +2423,121 @@ var NavigateParams = Type7.Object({
   depth: Type7.Optional(Type7.Number({ description: "Max traversal depth" })),
   expression: Type7.Optional(Type7.String({ description: "Expression to track (required for trace_data)" }))
 });
+function treeLine(depth, text) {
+  return `${"  ".repeat(depth)}${depth === 0 ? "" : "↳ "}${text}`;
+}
+function renderCallTreeNode(node, depth, lines) {
+  const name = asString(node.name) ?? "(unknown)";
+  const file = shortenPath(asString(node.file) ?? "(unknown file)");
+  const line = asNumber(node.line);
+  lines.push(treeLine(depth, `${name} ${line !== undefined ? `[${file}:${line}]` : `[${file}]`}`));
+  asRecords(node.children).forEach((child) => {
+    renderCallTreeNode(child, depth + 1, lines);
+  });
+}
+function renderTracePath(path2, index, lines) {
+  lines.push(`Path ${index + 1}`);
+  asRecords(path2.hops).forEach((hop, hopIndex) => {
+    const symbol = asString(hop.symbol) ?? "(unknown)";
+    const file = shortenPath(asString(hop.file) ?? "(unknown file)");
+    const line = asNumber(hop.line);
+    const entry = hop.is_entry_point === true ? " [entry]" : "";
+    lines.push(treeLine(hopIndex + 1, `${symbol}${entry} ${line !== undefined ? `[${file}:${line}]` : `[${file}]`}`));
+  });
+}
+function buildNavigateSections(args, payload, theme) {
+  const response = asRecord2(payload);
+  if (!response)
+    return [theme.fg("muted", "No navigation result.")];
+  if (args.op === "call_tree") {
+    const lines = [];
+    renderCallTreeNode(response, 0, lines);
+    return lines.length > 0 ? lines : [theme.fg("muted", "No call tree available.")];
+  }
+  if (args.op === "callers") {
+    const groups = asRecords(response.callers);
+    const sections2 = [
+      `${theme.fg("success", `${asNumber(response.total_callers) ?? 0} caller${(asNumber(response.total_callers) ?? 0) === 1 ? "" : "s"}`)} ${theme.fg("muted", `${groups.length} file group${groups.length === 1 ? "" : "s"}`)}`
+    ];
+    groups.forEach((group) => {
+      const file = shortenPath(asString(group.file) ?? "(unknown file)");
+      const lines = [theme.fg("accent", file)];
+      asRecords(group.callers).forEach((caller) => {
+        lines.push(`  ↳ ${asString(caller.symbol) ?? "(unknown)"} ${theme.fg("muted", `line ${asNumber(caller.line) ?? "?"}`)}`);
+      });
+      sections2.push(lines.join(`
+`));
+    });
+    return sections2;
+  }
+  if (args.op === "trace_to") {
+    const paths = asRecords(response.paths);
+    const sections2 = [
+      `${theme.fg("success", `${asNumber(response.total_paths) ?? paths.length} path${(asNumber(response.total_paths) ?? paths.length) === 1 ? "" : "s"}`)} ${theme.fg("muted", `${asNumber(response.entry_points_found) ?? 0} entry point${(asNumber(response.entry_points_found) ?? 0) === 1 ? "" : "s"}`)}`
+    ];
+    if (paths.length === 0)
+      sections2.push(theme.fg("muted", "No entry paths found."));
+    paths.forEach((path2, index) => {
+      const lines = [];
+      renderTracePath(path2, index, lines);
+      sections2.push(lines.join(`
+`));
+    });
+    return sections2;
+  }
+  if (args.op === "impact") {
+    const callers = asRecords(response.callers);
+    const sections2 = [
+      `${theme.fg("warning", `${asNumber(response.total_affected) ?? callers.length} affected call site${(asNumber(response.total_affected) ?? callers.length) === 1 ? "" : "s"}`)} ${theme.fg("muted", `${asNumber(response.affected_files) ?? 0} file${(asNumber(response.affected_files) ?? 0) === 1 ? "" : "s"}`)}`
+    ];
+    if (callers.length === 0)
+      sections2.push(theme.fg("muted", "No impacted callers found."));
+    callers.forEach((caller) => {
+      const file = shortenPath(asString(caller.caller_file) ?? "(unknown file)");
+      const symbol = asString(caller.caller_symbol) ?? "(unknown)";
+      const line = asNumber(caller.line) ?? 0;
+      const entry = caller.is_entry_point === true ? ` ${theme.fg("warning", "[entry]")}` : "";
+      const expression = asString(caller.call_expression);
+      const params = Array.isArray(caller.parameters) ? caller.parameters.map(String).join(", ") : "";
+      sections2.push([
+        `${theme.fg("accent", file)}:${line}`,
+        `  ↳ ${symbol}${entry}`,
+        expression ? `  ${theme.fg("muted", expression)}` : undefined,
+        params ? `  ${theme.fg("muted", `params: ${params}`)}` : undefined
+      ].filter(Boolean).join(`
+`));
+    });
+    return sections2;
+  }
+  const hops = asRecords(response.hops);
+  const sections = [
+    `${theme.fg("success", `${hops.length} hop${hops.length === 1 ? "" : "s"}`)} ${asBoolean(response.depth_limited) ? theme.fg("warning", "(depth limited)") : ""}`.trim()
+  ];
+  if (hops.length === 0)
+    sections.push(theme.fg("muted", "No data-flow hops found."));
+  hops.forEach((hop, index) => {
+    const file = shortenPath(asString(hop.file) ?? "(unknown file)");
+    const symbol = asString(hop.symbol) ?? "(unknown)";
+    const variable = asString(hop.variable) ?? "(unknown)";
+    const line = asNumber(hop.line) ?? 0;
+    const approximate = hop.approximate === true ? ` ${theme.fg("warning", "[approx]")}` : "";
+    sections.push(treeLine(index, `${variable} ${theme.fg("muted", `${asString(hop.flow_type) ?? "flow"}`)} ${symbol} [${file}:${line}]${approximate}`));
+  });
+  return sections;
+}
+function renderNavigateCall(args, theme, context) {
+  const summary = [
+    theme.fg("accent", args.op),
+    accentPath(theme, args.filePath),
+    theme.fg("toolOutput", args.symbol)
+  ].filter(Boolean).join(" ");
+  return renderToolCall("navigate", summary, theme, context);
+}
+function renderNavigateResult(result, args, theme, context) {
+  if (context.isError)
+    return renderErrorResult(result, "navigate failed", theme, context);
+  return renderSections(buildNavigateSections(args, extractStructuredPayload(result), theme), context);
+}
 function registerNavigateTool(pi, ctx) {
   pi.registerTool({
     name: "aft_navigate",
@@ -1764,6 +2560,12 @@ function registerNavigateTool(pi, ctx) {
         req.expression = params.expression;
       const response = await callBridge(bridge, params.op, req);
       return textResult(JSON.stringify(response, null, 2));
+    },
+    renderCall(args, theme, context) {
+      return renderNavigateCall(args, theme, context);
+    },
+    renderResult(result, _options, theme, context) {
+      return renderNavigateResult(result, context.args, theme, context);
     }
   });
 }
@@ -1876,6 +2678,71 @@ var ZoomParams = Type8.Object({
   symbols: Type8.Optional(Type8.Array(Type8.String(), { description: "Multiple symbols — returns array of matches" })),
   contextLines: Type8.Optional(Type8.Number({ description: "Lines of context before/after (default: 3)" }))
 });
+function buildOutlineSections(text, theme) {
+  const trimmed = text.trim();
+  if (!trimmed)
+    return [theme.fg("muted", "No outline available.")];
+  const lines = trimmed.split(`
+`);
+  if (lines.length === 1)
+    return [theme.fg("accent", lines[0])];
+  return [theme.fg("accent", lines[0]), lines.slice(1).join(`
+`)];
+}
+function buildZoomSections(args, payload, theme) {
+  const items = Array.isArray(payload) ? payload : payload ? [payload] : [];
+  if (items.length === 0)
+    return [theme.fg("muted", "No zoom result available.")];
+  return items.map((item) => {
+    const record = asRecord2(item);
+    if (!record)
+      return theme.fg("muted", "No zoom result available.");
+    const name = asString(record.name) ?? "(unknown symbol)";
+    const kind = asString(record.kind) ?? "symbol";
+    const range = asRecord2(record.range);
+    const startLine = range && typeof range.start_line === "number" ? range.start_line : undefined;
+    const endLine = range && typeof range.end_line === "number" ? range.end_line : undefined;
+    const location = startLine !== undefined ? `${shortenPath(args.filePath)}:${startLine}${endLine && endLine !== startLine ? `-${endLine}` : ""}` : shortenPath(args.filePath);
+    const lines = [`${theme.fg("accent", name)} ${theme.fg("muted", `[${kind}] ${location}`)}`];
+    const content = asString(record.content);
+    if (content) {
+      lines.push(content.split(`
+`).map((line) => `  ${line}`).join(`
+`));
+    }
+    const annotations = asRecord2(record.annotations);
+    const callsOut = annotations ? asRecords(annotations.calls_out) : [];
+    const calledBy = annotations ? asRecords(annotations.called_by) : [];
+    if (callsOut.length > 0) {
+      lines.push(`${theme.fg("muted", "calls out")}`, callsOut.map((call) => `  ↳ ${asString(call.name) ?? "(unknown)"}${typeof call.line === "number" ? `:${call.line}` : ""}`).join(`
+`));
+    }
+    if (calledBy.length > 0) {
+      lines.push(`${theme.fg("muted", "called by")}`, calledBy.map((call) => `  ↳ ${asString(call.name) ?? "(unknown)"}${typeof call.line === "number" ? `:${call.line}` : ""}`).join(`
+`));
+    }
+    return lines.join(`
+`);
+  }).filter(Boolean);
+}
+function renderOutlineCall(args, theme, context) {
+  const summary = args.filePath ? accentPath(theme, args.filePath) : args.directory ? `${theme.fg("muted", "dir")} ${accentPath(theme, args.directory)}` : args.files && args.files.length > 0 ? theme.fg("accent", `${args.files.length} files`) : undefined;
+  return renderToolCall("outline", summary, theme, context);
+}
+function renderOutlineResult(result, theme, context) {
+  if (context.isError)
+    return renderErrorResult(result, "outline failed", theme, context);
+  return renderSections(buildOutlineSections(collectTextContent(result), theme), context);
+}
+function renderZoomCall(args, theme, context) {
+  const target = args.symbol ? theme.fg("toolOutput", args.symbol) : args.symbols && args.symbols.length > 0 ? theme.fg("toolOutput", `${args.symbols.length} symbols`) : theme.fg("toolOutput", "lines");
+  return renderToolCall("zoom", `${accentPath(theme, args.filePath)} ${target}`, theme, context);
+}
+function renderZoomResult(result, args, theme, context) {
+  if (context.isError)
+    return renderErrorResult(result, "zoom failed", theme, context);
+  return renderSections(buildZoomSections(args, extractStructuredPayload(result), theme), context);
+}
 function registerReadingTools(pi, ctx, surface) {
   if (surface.outline) {
     pi.registerTool({
@@ -1919,6 +2786,12 @@ function registerReadingTools(pi, ctx, surface) {
         }
         const response = await callBridge(bridge, "outline", { file: params.filePath });
         return textResult(response.text ?? "");
+      },
+      renderCall(args, theme, context) {
+        return renderOutlineCall(args, theme, context);
+      },
+      renderResult(result, _options, theme, context) {
+        return renderOutlineResult(result, theme, context);
       }
     });
   }
@@ -1946,6 +2819,12 @@ function registerReadingTools(pi, ctx, surface) {
           req.context_lines = params.contextLines;
         const response = await callBridge(bridge, "zoom", req);
         return textResult(JSON.stringify(response, null, 2));
+      },
+      renderCall(args, theme, context) {
+        return renderZoomCall(args, theme, context);
+      },
+      renderResult(result, _options, theme, context) {
+        return renderZoomResult(result, context.args, theme, context);
       }
     });
   }
@@ -1966,6 +2845,63 @@ var RefactorParams = Type9.Object({
   callSiteLine: Type9.Optional(Type9.Number({ description: "1-based call site line (for inline)" })),
   dryRun: Type9.Optional(Type9.Boolean({ description: "Preview as diff" }))
 });
+function buildRefactorSections(args, payload, theme) {
+  const response = asRecord2(payload);
+  if (!response)
+    return [theme.fg("muted", "No refactor result.")];
+  if (response.dry_run === true) {
+    const diffs = asRecords(response.diffs);
+    const sections = [theme.fg("warning", `[dry run] ${args.op}`)];
+    if (diffs.length === 0) {
+      sections.push(theme.fg("muted", "No diff available."));
+      return sections;
+    }
+    diffs.forEach((diff) => {
+      const file = shortenPath(asString(diff.file) ?? "(unknown file)");
+      const rendered = renderUnifiedDiff(asString(diff.diff) ?? "") || theme.fg("muted", "No diff available.");
+      sections.push(`${theme.fg("accent", file)}
+${rendered}`);
+    });
+    return sections;
+  }
+  if (args.op === "move") {
+    const results = asRecords(response.results);
+    return [
+      `${theme.fg("success", "moved symbol")} ${theme.fg("toolOutput", args.symbol ?? "(symbol)")}`,
+      `${theme.fg("muted", "files modified")} ${asNumber(response.files_modified) ?? results.length}`,
+      `${theme.fg("muted", "consumers updated")} ${asNumber(response.consumers_updated) ?? 0}`,
+      results.length > 0 ? results.map((entry) => `  ↳ ${shortenPath(asString(entry.file) ?? "(unknown file)")}`).join(`
+`) : theme.fg("muted", "No files reported.")
+    ];
+  }
+  if (args.op === "extract") {
+    return [
+      `${theme.fg("success", "extracted")} ${theme.fg("toolOutput", asString(response.name) ?? args.name ?? "(function)")}`,
+      `${theme.fg("muted", "file")} ${theme.fg("accent", shortenPath(asString(response.file) ?? args.filePath))}`,
+      `${theme.fg("muted", "params")} ${Array.isArray(response.parameters) ? response.parameters.join(", ") || "none" : "none"}`,
+      `${theme.fg("muted", "return type")} ${asString(response.return_type) ?? "unknown"}`
+    ];
+  }
+  return [
+    `${theme.fg("success", "inlined")} ${theme.fg("toolOutput", asString(response.symbol) ?? args.symbol ?? "(symbol)")}`,
+    `${theme.fg("muted", "file")} ${theme.fg("accent", shortenPath(asString(response.file) ?? args.filePath))}`,
+    `${theme.fg("muted", "context")} ${asString(response.call_context) ?? "unknown"}`,
+    `${theme.fg("muted", "substitutions")} ${asNumber(response.substitutions) ?? 0}`
+  ];
+}
+function renderRefactorCall(args, theme, context) {
+  const summary = [
+    theme.fg("accent", args.op),
+    accentPath(theme, args.filePath),
+    args.symbol ? theme.fg("toolOutput", args.symbol) : undefined
+  ].filter(Boolean).join(" ");
+  return renderToolCall("refactor", summary, theme, context);
+}
+function renderRefactorResult(result, args, theme, context) {
+  if (context.isError)
+    return renderErrorResult(result, "refactor failed", theme, context);
+  return renderSections(buildRefactorSections(args, extractStructuredPayload(result), theme), context);
+}
 function registerRefactorTool(pi, ctx) {
   pi.registerTool({
     name: "aft_refactor",
@@ -1999,6 +2935,12 @@ function registerRefactorTool(pi, ctx) {
         req.dry_run = params.dryRun;
       const response = await callBridge(bridge, commandMap[params.op], req);
       return textResult(JSON.stringify(response, null, 2));
+    },
+    renderCall(args, theme, context) {
+      return renderRefactorCall(args, theme, context);
+    },
+    renderResult(result, _options, theme, context) {
+      return renderRefactorResult(result, context.args, theme, context);
     }
   });
 }
@@ -2016,6 +2958,78 @@ var SafetyParams = Type10.Object({
     description: "Specific files for checkpoint (optional, defaults to all tracked)"
   }))
 });
+function buildSafetySections(args, payload, theme) {
+  const response = asRecord2(payload);
+  if (!response)
+    return [theme.fg("muted", "No safety result.")];
+  if (args.op === "undo") {
+    return [
+      `${theme.fg("success", "restored")} ${theme.fg("accent", shortenPath(asString(response.path) ?? args.filePath ?? "(file)"))}`,
+      `${theme.fg("muted", "backup")} ${asString(response.backup_id) ?? "—"}`
+    ];
+  }
+  if (args.op === "history") {
+    const entries = asRecords(response.entries);
+    const sections2 = [
+      theme.fg("accent", shortenPath(asString(response.file) ?? args.filePath ?? "(file)"))
+    ];
+    if (entries.length === 0) {
+      sections2.push(theme.fg("muted", "No history entries."));
+      return sections2;
+    }
+    sections2.push(entries.map((entry, index) => {
+      const backupId = asString(entry.backup_id) ?? `entry-${index + 1}`;
+      const timestamp = formatTimestamp(entry.timestamp) ?? "unknown time";
+      const description = asString(entry.description) ?? "";
+      return `${index + 1}. ${backupId} ${theme.fg("muted", timestamp)}${description ? `
+   ${description}` : ""}`;
+    }).join(`
+`));
+    return sections2;
+  }
+  if (args.op === "checkpoint") {
+    const skipped = asRecords(response.skipped);
+    return [
+      `${theme.fg("success", "checkpoint created")} ${theme.fg("accent", asString(response.name) ?? args.name ?? "(checkpoint)")}`,
+      `${theme.fg("muted", "files")} ${asNumber(response.file_count) ?? 0}`,
+      skipped.length > 0 ? `${theme.fg("warning", "skipped")}
+${skipped.map((entry) => `  ↳ ${shortenPath(asString(entry.file) ?? "(file)")}: ${asString(entry.error) ?? "unknown error"}`).join(`
+`)}` : theme.fg("muted", "No skipped files.")
+    ];
+  }
+  if (args.op === "restore") {
+    return [
+      `${theme.fg("success", "checkpoint restored")} ${theme.fg("accent", asString(response.name) ?? args.name ?? "(checkpoint)")}`,
+      `${theme.fg("muted", "files")} ${asNumber(response.file_count) ?? 0}`
+    ];
+  }
+  const checkpoints = asRecords(response.checkpoints);
+  const sections = [
+    theme.fg("accent", `${checkpoints.length} checkpoint${checkpoints.length === 1 ? "" : "s"}`)
+  ];
+  if (checkpoints.length === 0) {
+    sections.push(theme.fg("muted", "No checkpoints saved."));
+    return sections;
+  }
+  sections.push(checkpoints.map((checkpoint, index) => {
+    const name = asString(checkpoint.name) ?? `checkpoint-${index + 1}`;
+    const count = asNumber(checkpoint.file_count) ?? 0;
+    const created = formatTimestamp(checkpoint.created_at) ?? "unknown time";
+    return `${index + 1}. ${name} ${theme.fg("muted", `${count} file${count === 1 ? "" : "s"} · ${created}`)}`;
+  }).join(`
+`));
+  return sections;
+}
+function renderSafetyCall(args, theme, context) {
+  const target = args.filePath ?? args.name;
+  const summary = [theme.fg("accent", args.op), target ? accentPath(theme, target) : undefined].filter(Boolean).join(" ");
+  return renderToolCall("safety", summary, theme, context);
+}
+function renderSafetyResult(result, args, theme, context) {
+  if (context.isError)
+    return renderErrorResult(result, "safety failed", theme, context);
+  return renderSections(buildSafetySections(args, extractStructuredPayload(result), theme), context);
+}
 function registerSafetyTool(pi, ctx) {
   pi.registerTool({
     name: "aft_safety",
@@ -2038,14 +3052,28 @@ function registerSafetyTool(pi, ctx) {
         list: "list_checkpoints"
       };
       const req = {};
-      if (params.filePath)
-        req.file = params.filePath;
       if (params.name)
         req.name = params.name;
-      if (params.files)
-        req.files = params.files;
+      if (params.op === "checkpoint") {
+        if (params.files) {
+          req.files = params.files;
+        } else if (params.filePath) {
+          req.files = [params.filePath];
+        }
+      } else {
+        if (params.filePath)
+          req.file = params.filePath;
+        if (params.files)
+          req.files = params.files;
+      }
       const response = await callBridge(bridge, commandMap[params.op], req);
       return textResult(JSON.stringify(response, null, 2));
+    },
+    renderCall(args, theme, context) {
+      return renderSafetyCall(args, theme, context);
+    },
+    renderResult(result, _options, theme, context) {
+      return renderSafetyResult(result, context.args, theme, context);
     }
   });
 }
@@ -2056,6 +3084,53 @@ var SearchParams2 = Type11.Object({
   query: Type11.String({ description: "Natural-language description of the code to find" }),
   topK: Type11.Optional(Type11.Number({ description: "Maximum number of results (default: 10, max: 100)" }))
 });
+function buildSemanticSections(args, payload, theme) {
+  const response = asRecord2(payload);
+  if (!response)
+    return [theme.fg("muted", "No semantic search result.")];
+  const status = asString(response.status) ?? "unknown";
+  const sections = [
+    `${theme.fg(status === "ready" ? "success" : "warning", `index: ${status}`)} ${theme.fg("muted", `query=${JSON.stringify(args.query)} topK=${args.topK ?? 10}`)}`
+  ];
+  if (status !== "ready") {
+    sections.push(asString(response.text) ?? theme.fg("muted", "Semantic index is not ready."));
+    return sections;
+  }
+  const results = asRecords(response.results);
+  if (results.length === 0) {
+    sections.push(theme.fg("muted", "No semantic matches found."));
+    return sections;
+  }
+  const grouped = groupByFile(results, (result) => asString(result.file));
+  for (const [file, fileResults] of grouped.entries()) {
+    const lines = [theme.fg("accent", shortenPath(file))];
+    fileResults.forEach((result) => {
+      const score = asNumber(result.score);
+      const startLine = asNumber(result.start_line);
+      const endLine = asNumber(result.end_line);
+      const range = startLine !== undefined ? `${startLine}${endLine && endLine !== startLine ? `-${endLine}` : ""}` : "?";
+      const kind = asString(result.kind) ?? "symbol";
+      const name = asString(result.name) ?? "(unknown)";
+      lines.push(`  ↳ ${name} ${theme.fg("muted", `[${kind}] lines ${range}${score !== undefined ? ` score ${score.toFixed(3)}` : ""}`)}`);
+      const snippet = asString(result.snippet);
+      if (snippet) {
+        lines.push(...snippet.split(`
+`).map((line) => `     ${line}`));
+      }
+    });
+    sections.push(lines.join(`
+`));
+  }
+  return sections;
+}
+function renderSemanticCall(args, theme, context) {
+  return renderToolCall("semantic search", theme.fg("toolOutput", args.query), theme, context);
+}
+function renderSemanticResult(result, args, theme, context) {
+  if (context.isError)
+    return renderErrorResult(result, "semantic search failed", theme, context);
+  return renderSections(buildSemanticSections(args, extractStructuredPayload(result), theme), context);
+}
 function registerSemanticTool(pi, ctx) {
   pi.registerTool({
     name: "aft_search",
@@ -2069,6 +3144,12 @@ function registerSemanticTool(pi, ctx) {
         req.top_k = params.topK;
       const response = await callBridge(bridge, "semantic_search", req);
       return textResult(response.text ?? JSON.stringify(response, null, 2));
+    },
+    renderCall(args, theme, context) {
+      return renderSemanticCall(args, theme, context);
+    },
+    renderResult(result, _options, theme, context) {
+      return renderSemanticResult(result, context.args, theme, context);
     }
   });
 }
@@ -2096,6 +3177,37 @@ var TransformParams = Type12.Object({
     description: "Validation level (default: syntax)"
   }))
 });
+function buildTransformSections(args, payload, theme) {
+  const response = asRecord2(payload);
+  if (!response)
+    return [theme.fg("muted", "No transform result.")];
+  if (response.dry_run === true) {
+    return [
+      theme.fg("warning", `[dry run] ${args.op}`),
+      asString(response.diff) ?? theme.fg("muted", "No diff available.")
+    ];
+  }
+  const target = asString(response.target) ?? asString(response.scope) ?? args.target ?? args.container ?? args.field ?? args.filePath;
+  return [
+    `${theme.fg("success", "transformed")} ${theme.fg("accent", args.op)}`,
+    `${theme.fg("muted", "file")} ${theme.fg("accent", asString(response.file) ?? args.filePath)}`,
+    target ? `${theme.fg("muted", "target")} ${target}` : theme.fg("muted", "No target metadata.")
+  ];
+}
+function renderTransformCall(args, theme, context) {
+  const target = args.target ?? args.container ?? args.field;
+  const summary = [
+    theme.fg("accent", args.op),
+    accentPath(theme, args.filePath),
+    target ? theme.fg("toolOutput", target) : undefined
+  ].filter(Boolean).join(" ");
+  return renderToolCall("transform", summary, theme, context);
+}
+function renderTransformResult(result, args, theme, context) {
+  if (context.isError)
+    return renderErrorResult(result, "transform failed", theme, context);
+  return renderSections(buildTransformSections(args, extractStructuredPayload(result), theme), context);
+}
 function registerStructureTool(pi, ctx) {
   pi.registerTool({
     name: "aft_transform",
@@ -2131,6 +3243,12 @@ function registerStructureTool(pi, ctx) {
         req.validate = params.validate;
       const response = await callBridge(bridge, params.op, req);
       return textResult(JSON.stringify(response, null, 2));
+    },
+    renderCall(args, theme, context) {
+      return renderTransformCall(args, theme, context);
+    },
+    renderResult(result, _options, theme, context) {
+      return renderTransformResult(result, context.args, theme, context);
     }
   });
 }
@@ -2145,7 +3263,7 @@ var PLUGIN_VERSION = (() => {
   }
 })();
 function resolveStorageDir() {
-  return join8(homedir5(), ".pi", "agent", "aft");
+  return join8(homedir7(), ".pi", "agent", "aft");
 }
 function resolveToolSurface(config) {
   const surface = config.tool_surface ?? "recommended";