agent-sh 0.12.27 → 0.13.0

package/examples/extensions/ashi/src/compaction.ts

@@ -0,0 +1,157 @@
+import type { ExtensionContext } from "agent-sh/types";
+import type { MultiSessionStore } from "./multi-session-store.js";
+import type { Capture } from "./capture.js";
+import type { AgentMessage, CompactionEntry } from "./session-store.js";
+
+const KEEP_RECENT_TOKEN_BUDGET = 20_000;
+const APPROX_TOKENS_PER_CHAR = 0.25;
+
+const SUMMARY_PROMPT = `You are compacting a coding-agent conversation so the agent can continue with limited context.
+
+Produce a Markdown summary using EXACTLY this structure:
+
+## Goal
+[What the user is trying to accomplish, one or two sentences]
+
+## Constraints & Preferences
+- [Bulleted user requirements / preferences expressed so far]
+
+## Progress
+### Done
+- [x] [Completed work]
+
+### In Progress
+- [ ] [Active work and current sub-goal]
+
+### Blocked
+- [Issues, or "None"]
+
+## Key Decisions
+- **[Decision]**: [Rationale]
+
+## Next Steps
+1. [What should happen next]
+
+## Critical Context
+- [Specific paths, names, identifiers, or data the agent must remember]
+
+Be concrete. Quote file paths, function names, error strings verbatim when relevant. Do not invent details that aren't in the conversation.`;
+
+export function registerCompaction(
+  ctx: ExtensionContext,
+  getStore: () => MultiSessionStore,
+  capture: Capture,
+): void {
+  ctx.advise("conversation:compact", async (next: (...a: unknown[]) => unknown, opts: unknown) => {
+    const llm = ctx.agent?.llm;
+    if (!llm?.available) return next(opts);
+
+    await capture.flush();
+    const messages = ctx.call("conversation:get-messages") as AgentMessage[] | undefined;
+    if (!messages || messages.length < 6) return next(opts);
+
+    const cutIdx = findCutPoint(messages, KEEP_RECENT_TOKEN_BUDGET);
+    if (cutIdx < 2) return next(opts);
+
+    const firstKeptId = capture.getEntryIdAt(cutIdx);
+    if (!firstKeptId) {
+      ctx.bus.emit("ui:error", { message: "compaction: kept-message has no on-disk entry; falling back" });
+      return next(opts);
+    }
+
+    const older = messages.slice(0, cutIdx);
+    const kept = messages.slice(cutIdx);
+
+    const branch = getStore().current().getBranch();
+    const prevCompaction = [...branch].reverse().find((e) => e.type === "compaction") as CompactionEntry | undefined;
+    const prevSummary = prevCompaction?.summary;
+
+    const tokensBefore = (ctx.call("conversation:estimate-prompt-tokens") as number) ?? 0;
+
+    let summary: string;
+    try {
+      summary = await llm.ask({
+        system: SUMMARY_PROMPT,
+        query: buildQuery(older, prevSummary),
+        maxTokens: 16384,
+        reasoningEffort: "low",
+      });
+    } catch (e) {
+      ctx.bus.emit("ui:error", { message: `compaction: LLM failed (${(e as Error).message}); falling back` });
+      return next(opts);
+    }
+
+    await getStore().current().appendCompaction(summary.trim(), firstKeptId, tokensBefore);
+
+    const summaryMessage: AgentMessage = {
+      role: "user",
+      content: `[Compacted conversation summary]\n${summary.trim()}`,
+    };
+    ctx.call("conversation:replace-messages", [summaryMessage, ...kept]);
+
+    const keptIds = kept.map((_, i) => capture.getEntryIdAt(cutIdx + i));
+    if (keptIds.some((id) => id === null)) {
+      ctx.bus.emit("ui:error", { message: "compaction: a kept message has no on-disk entry — capture invariant broken" });
+    }
+    capture.resetTo([null, ...keptIds]);
+
+    const tokensAfter = (ctx.call("conversation:estimate-prompt-tokens") as number) ?? 0;
+    ctx.bus.emit("ui:info", { message: `compacted ${older.length} messages: ${tokensBefore} → ${tokensAfter} tokens` });
+
+    return { before: tokensBefore, after: tokensAfter, evictedCount: older.length };
+  });
+}
+
+function findCutPoint(messages: AgentMessage[], tokenBudget: number): number {
+  let acc = 0;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    acc += estimateMessageTokens(messages[i]!);
+    if (acc >= tokenBudget) {
+      let cut = i;
+      while (cut < messages.length && !isSafeCutPoint(messages, cut)) cut++;
+      return cut;
+    }
+  }
+  return 0;
+}
+
+function isSafeCutPoint(messages: AgentMessage[], idx: number): boolean {
+  const m = messages[idx];
+  if (!m) return true;
+  if (m.role === "tool") return false;
+  return !(m.role === "assistant" && m.tool_calls && m.tool_calls.length > 0);
+}
+
+function estimateMessageTokens(m: AgentMessage): number {
+  let chars = 0;
+  if (typeof m.content === "string") chars += m.content.length;
+  if (m.tool_calls) for (const t of m.tool_calls) chars += (t.function?.arguments?.length ?? 0);
+  return Math.ceil(chars * APPROX_TOKENS_PER_CHAR) + 20;
+}
+
+function buildQuery(messages: AgentMessage[], prevSummary?: string): string {
+  const lines: string[] = [];
+  if (prevSummary) lines.push("Previous compaction summary (continue iteratively):\n", prevSummary, "\n---\n");
+  lines.push("Conversation to summarize:");
+  for (const m of messages) {
+    const text = typeof m.content === "string" ? m.content : "";
+    if (m.role === "user") lines.push(`[User]: ${text}`);
+    else if (m.role === "assistant") {
+      if (text) lines.push(`[Assistant]: ${text}`);
+      if (m.tool_calls) {
+        for (const t of m.tool_calls) {
+          const args = t.function?.arguments ?? "";
+          lines.push(`[Assistant tool call]: ${t.function?.name ?? "?"}(${truncate(args, 400)})`);
+        }
+      }
+    } else if (m.role === "tool") {
+      lines.push(`[Tool result]: ${truncate(text, 2000)}`);
+    }
+  }
+  return lines.join("\n");
+}
+
+function truncate(s: string, max: number): string {
+  if (s.length <= max) return s;
+  return s.slice(0, max) + `\n[…truncated ${s.length - max} chars…]`;
+}

package/examples/extensions/ashi/src/components.ts

@@ -0,0 +1,332 @@
+import {
+  Container,
+  Markdown,
+  type MarkdownTheme,
+  Spacer,
+  Text,
+} from "@earendil-works/pi-tui";
+import { markdownTheme, theme } from "./theme.js";
+import type { ToolResultMode } from "./display-config.js";
+
+const OSC133_ZONE_START = "\x1b]133;A\x07";
+const OSC133_ZONE_END = "\x1b]133;B\x07";
+const OSC133_ZONE_FINAL = "\x1b]133;C\x07";
+
+export class UserMessage extends Container {
+  constructor(text: string, md: MarkdownTheme = markdownTheme()) {
+    super();
+    this.addChild(new Spacer(1));
+    this.addChild(
+      new Markdown(text, 1, 1, md, {
+        bgColor: (t) => theme.bg("userMessageBg", t),
+        color: (t) => theme.fg("userMessageText", t),
+      }),
+    );
+  }
+  override render(width: number): string[] {
+    const lines = super.render(width);
+    if (lines.length === 0) return lines;
+    lines[0] = OSC133_ZONE_START + lines[0];
+    lines[lines.length - 1] = lines[lines.length - 1] + OSC133_ZONE_END + OSC133_ZONE_FINAL;
+    return lines;
+  }
+}
+
+export class AssistantMessage extends Container {
+  private md: Markdown;
+  private buffer = "";
+  constructor(mdTheme: MarkdownTheme = markdownTheme()) {
+    super();
+    this.md = new Markdown("", 1, 0, mdTheme);
+    this.addChild(new Spacer(1));
+    this.addChild(this.md);
+  }
+  appendText(t: string): void {
+    this.buffer += t;
+    this.md.setText(this.buffer);
+  }
+  appendCodeBlock(language: string, code: string): void {
+    const prefix = this.buffer && !this.buffer.endsWith("\n") ? "\n" : "";
+    this.buffer += `${prefix}\`\`\`${language}\n${code}\n\`\`\`\n`;
+    this.md.setText(this.buffer);
+  }
+  finalize(): void {
+    if (this.buffer === "") this.buffer = " ";
+    this.md.setText(this.buffer);
+  }
+  hasContent(): boolean {
+    return this.buffer.trim().length > 0;
+  }
+}
+
+export class ThinkingBlock extends Container {
+  private md: Markdown;
+  private placeholder: Text;
+  private buffer = "";
+  private hidden = false;
+  private mdTheme: MarkdownTheme;
+  constructor(mdTheme: MarkdownTheme = markdownTheme()) {
+    super();
+    this.mdTheme = mdTheme;
+    this.md = new Markdown("", 1, 0, mdTheme, {
+      color: (t) => theme.italic(theme.fg("thinkingText", t)),
+    });
+    this.placeholder = new Text(theme.italic(theme.fg("thinkingText", "Thinking…")), 1, 0);
+    this.addChild(new Spacer(1));
+    this.addChild(this.md);
+  }
+  appendText(t: string): void {
+    this.buffer += t;
+    if (!this.hidden) this.md.setText(this.buffer);
+  }
+  finalize(): void {
+    if (this.buffer === "") this.buffer = " ";
+    if (!this.hidden) this.md.setText(this.buffer);
+  }
+  setHidden(hidden: boolean): void {
+    if (hidden === this.hidden) return;
+    this.hidden = hidden;
+    this.clear();
+    this.addChild(new Spacer(1));
+    if (hidden) {
+      this.addChild(this.placeholder);
+    } else {
+      this.md = new Markdown(this.buffer, 1, 0, this.mdTheme, {
+        color: (t) => theme.italic(theme.fg("thinkingText", t)),
+      });
+      this.addChild(this.md);
+    }
+  }
+}
+
+export class ToolResultBody extends Container {
+  private outputText: Text;
+  private bodyText: Text;
+  private outputBuffer = "";
+  private diffLines: string[] = [];
+  private mode: ToolResultMode;
+  private previewLines: number;
+  private finalized = false;
+  private expanded = false;
+  private exitCode: number | null | undefined;
+
+  constructor(mode: ToolResultMode, previewLines: number) {
+    super();
+    this.mode = mode;
+    this.previewLines = previewLines;
+    this.outputText = new Text("", 1, 0);
+    this.bodyText = new Text("", 0, 0);
+    this.addChild(this.outputText);
+    this.addChild(this.bodyText);
+  }
+
+  appendChunk(chunk: string): void {
+    this.outputBuffer += chunk;
+    this.repaint();
+  }
+
+  setDiff(lines: string[]): void {
+    this.diffLines = lines;
+    this.repaint();
+  }
+
+  finalize(opts: { exitCode: number | null; summary?: string }): void {
+    this.finalized = true;
+    this.exitCode = opts.exitCode;
+    this.repaint();
+  }
+
+  toggleExpanded(): void {
+    this.expanded = !this.expanded;
+    this.repaint();
+  }
+
+  private repaint(): void {
+    // Hide the framed diff in hidden/summary modes — the stats already live
+    // on the call line so showing it again is noise.
+    const hasDiff = this.diffLines.length > 0;
+    const showDiff = hasDiff && (this.expanded || this.mode === "preview");
+    this.bodyText.setText(showDiff ? this.diffLines.join("\n") : "");
+
+    // When a diff exists, the textual output ("Edited /path (+12 -3)") just
+    // restates the call line — suppress its line-count hint to keep edits quiet.
+    if (hasDiff && !this.expanded) {
+      this.outputText.setText("");
+      return;
+    }
+    if (!this.outputBuffer) {
+      this.outputText.setText("");
+      return;
+    }
+    if (this.expanded) {
+      this.outputText.setText(theme.fg("toolOutput", this.outputBuffer));
+      return;
+    }
+    if (this.mode === "hidden") {
+      if (!this.finalized) { this.outputText.setText(""); return; }
+      this.outputText.setText(lineCountHint(this.outputBuffer, this.exitCode));
+      return;
+    }
+    if (this.mode === "summary") {
+      if (!this.finalized) {
+        // Brief tail while streaming; collapses to a line count on finalize.
+        const tail = this.outputBuffer.split("\n").slice(-2).join("\n");
+        this.outputText.setText(theme.fg("muted", tail));
+        return;
+      }
+      this.outputText.setText(lineCountHint(this.outputBuffer, this.exitCode));
+      return;
+    }
+    const lines = this.outputBuffer.split("\n");
+    const trimmed = lines.slice(-this.previewLines).join("\n");
+    const remaining = Math.max(0, lines.length - this.previewLines);
+    const overflow = remaining > 0
+      ? `\n${theme.fg("muted", `... (${remaining} more ${remaining === 1 ? "line" : "lines"})`)}`
+      : "";
+    this.outputText.setText(`${theme.fg("toolOutput", trimmed)}${overflow}`);
+  }
+}
+
+function lineCountHint(buffer: string, exitCode: number | null | undefined): string {
+  const lines = buffer.split("\n").filter((l) => l.length > 0);
+  const label = lines.length === 1 ? "1 line" : `${lines.length} lines`;
+  const ok = exitCode === null || exitCode === 0;
+  const arrow = ok ? theme.fg("muted", "↳ ") : theme.fg("error", "↳ ");
+  return `${arrow}${theme.fg("muted", label)}`;
+}
+
+const GROUP_ICONS: Record<string, string> = { read: "◆", search: "⌕" };
+
+interface GroupChild {
+  name: string;
+  detail: string;
+  text: Text;
+  status?: { exitCode: number | null; summary?: string };
+}
+
+const SHORT_TOOL_NAMES: Record<string, string> = {
+  read_file: "read",
+  edit_file: "edit",
+  write_file: "write",
+};
+
+function shortToolName(name: string): string {
+  return SHORT_TOOL_NAMES[name] ?? name;
+}
+
+/** A batch of parallel same-kind tool calls. Renders one header, per-call
+ *  child branch lines that each carry their own summary on completion, and
+ *  a final aggregate. Mirrors ash's grouping (read_file/ls → "read";
+ *  grep/glob → "search"). */
+export class ToolGroup extends Container {
+  private headerText: Text;
+  private childContainer: Container;
+  private aggregateText: Text;
+  private kind: string;
+  private total: number;
+  private maxVisible: number;
+  private visibleChildren = new Map<string, GroupChild>();
+  private hiddenSummaries: string[] = [];
+  private addedCount = 0;
+  private renderedCount = 0;
+  private completedCount = 0;
+  private allOk = true;
+
+  constructor(kind: string, total: number, maxVisible = 5) {
+    super();
+    this.kind = kind;
+    this.total = total;
+    this.maxVisible = maxVisible;
+    this.headerText = new Text("", 1, 0);
+    this.childContainer = new Container();
+    this.aggregateText = new Text("", 1, 0);
+    this.addChild(new Spacer(1));
+    this.addChild(this.headerText);
+    this.addChild(this.childContainer);
+    this.addChild(this.aggregateText);
+    this.repaintHeader();
+  }
+
+  addCall(toolCallId: string, name: string, detail: string): void {
+    this.addedCount++;
+    if (this.renderedCount < this.maxVisible && toolCallId) {
+      const text = new Text("", 1, 0);
+      const child: GroupChild = { name: shortToolName(name), detail: detail || "…", text };
+      this.visibleChildren.set(toolCallId, child);
+      this.childContainer.addChild(text);
+      this.renderedCount++;
+      this.repaintChild(child);
+    }
+  }
+
+  recordCompletion(toolCallId: string, exitCode: number | null, summary?: string): void {
+    this.completedCount++;
+    if (exitCode !== null && exitCode !== 0) this.allOk = false;
+    const child = this.visibleChildren.get(toolCallId);
+    if (child) {
+      child.status = { exitCode, summary };
+      this.repaintChild(child);
+    } else if (summary) {
+      this.hiddenSummaries.push(summary);
+    }
+    if (this.completedCount >= this.total) this.finalize();
+  }
+
+  finalize(): void {
+    const collapsed = this.addedCount - this.renderedCount;
+    // No overflow ⇒ no aggregate; close the tree by promoting the last
+    // visible child's ├ to a └.
+    if (collapsed === 0) {
+      this.aggregateText.setText("");
+      const last = [...this.visibleChildren.values()].pop();
+      if (last) this.repaintChild(last, true);
+      return;
+    }
+    const mark = this.allOk ? theme.fg("success", "✓") : theme.fg("error", "✗");
+    const more = theme.fg("muted", `+${collapsed} more`);
+    const sumText = this.hiddenSummaries.length > 0
+      ? ` ${theme.fg("muted", this.hiddenSummaries.join(", "))}`
+      : "";
+    this.aggregateText.setText(`${theme.fg("muted", "└")} ${more} ${mark}${sumText}`);
+  }
+
+  isComplete(): boolean { return this.completedCount >= this.total; }
+
+  private repaintChild(child: GroupChild, isLast = false): void {
+    let tail: string;
+    if (!child.status) {
+      tail = ` ${theme.fg("muted", "…")}`;
+    } else {
+      const ok = child.status.exitCode === null || child.status.exitCode === 0;
+      const mark = ok ? theme.fg("success", "✓") : theme.fg("error", "✗");
+      const sum = child.status.summary ? ` ${theme.fg("muted", child.status.summary)}` : "";
+      tail = ` ${mark}${sum}`;
+    }
+    const connector = isLast ? "└" : "├";
+    // Tool name omitted when it duplicates the kind header (e.g. read_file
+    // children under "◆ read").
+    const namePart = child.name !== this.kind
+      ? `${theme.bold(theme.fg("toolTitle", child.name))} `
+      : "";
+    child.text.setText(`${theme.fg("muted", connector)} ${namePart}${theme.fg("muted", child.detail)} ${tail}`);
+  }
+
+  private repaintHeader(): void {
+    const icon = GROUP_ICONS[this.kind] ?? "▶";
+    this.headerText.setText(`${theme.fg("warning", icon)} ${theme.bold(theme.fg("toolTitle", this.kind))}`);
+  }
+}
+
+export class ErrorLine extends Container {
+  constructor(message: string) {
+    super();
+    this.addChild(new Text(`${theme.fg("error", "✗")} ${theme.fg("error", message)}`, 1, 0));
+  }
+}
+
+export class InfoLine extends Container {
+  constructor(message: string) {
+    super();
+    this.addChild(new Text(theme.fg("muted", message), 1, 0));
+  }
+}

package/examples/extensions/ashi/src/default-renderers.ts

@@ -0,0 +1,153 @@
+import { Container, Spacer, Text } from "@earendil-works/pi-tui";
+import type { ExtensionContext } from "agent-sh/types";
+import { theme } from "./theme.js";
+import type { ToolCallArgs, ToolCallView } from "./hooks.js";
+
+interface StatusOpts { exitCode: number | null; elapsedMs: number; summary?: string }
+
+function fmtElapsed(ms: number): string {
+  if (ms < 1000) return `${ms}ms`;
+  if (ms < 10_000) return `${(ms / 1000).toFixed(2)}s`;
+  if (ms < 60_000) return `${(ms / 1000).toFixed(1)}s`;
+  const totalSeconds = Math.floor(ms / 1000);
+  const m = Math.floor(totalSeconds / 60);
+  const s = totalSeconds % 60;
+  return `${m}m ${s}s`;
+}
+
+function parseRaw(raw: unknown): Record<string, unknown> {
+  if (typeof raw === "string") {
+    try { return JSON.parse(raw) as Record<string, unknown>; } catch { return {}; }
+  }
+  if (raw && typeof raw === "object") return raw as Record<string, unknown>;
+  return {};
+}
+
+function str(v: unknown): string | undefined {
+  return typeof v === "string" && v.length > 0 ? v : undefined;
+}
+
+function num(v: unknown): number | undefined {
+  return typeof v === "number" && Number.isFinite(v) ? v : undefined;
+}
+
+function relativize(fp: string): string {
+  const home = process.env.HOME;
+  const cwd = process.cwd();
+  if (fp.startsWith(`${cwd}/`)) return fp.slice(cwd.length + 1);
+  if (home && fp.startsWith(`${home}/`)) return `~/${fp.slice(home.length + 1)}`;
+  return fp;
+}
+
+function statusSuffix(opts?: StatusOpts): string {
+  if (!opts) return `  ${theme.fg("muted", "…")}`;
+  const ok = opts.exitCode === null || opts.exitCode === 0;
+  const mark = ok ? theme.fg("success", "✓") : theme.fg("error", "✗");
+  const elapsed = opts.elapsedMs > 0 ? ` ${theme.fg("muted", fmtElapsed(opts.elapsedMs))}` : "";
+  const sum = opts.summary ? ` ${theme.fg("muted", opts.summary)}` : "";
+  return `  ${mark}${elapsed}${sum}`;
+}
+
+/** Renders a one-line tool call header from a label producer. The label is
+ *  recomputed on setStatus so the trailing status mark updates in place. */
+class LabeledCallLine extends Container implements ToolCallView {
+  private line: Text;
+  private status?: StatusOpts;
+  constructor(private label: () => string) {
+    super();
+    this.line = new Text("", 1, 0);
+    this.addChild(new Spacer(1));
+    this.addChild(this.line);
+    this.repaint();
+  }
+  setStatus(opts: StatusOpts): void {
+    this.status = opts;
+    this.repaint();
+  }
+  private repaint(): void {
+    this.line.setText(`${this.label()}${statusSuffix(this.status)}`);
+  }
+}
+
+const bold = (t: string): string => theme.bold(theme.fg("toolTitle", t));
+const accent = (t: string): string => theme.fg("accent", t);
+const muted = (t: string): string => theme.fg("muted", t);
+
+function bashLabel(args: ToolCallArgs): string {
+  const r = parseRaw(args.rawInput);
+  const command = str(r.command) ?? "…";
+  const timeout = num(r.timeout);
+  const to = timeout ? muted(` (timeout ${timeout}s)`) : "";
+  return `${bold("$")} ${accent(command)}${to}`;
+}
+
+function readLabel(args: ToolCallArgs): string {
+  const r = parseRaw(args.rawInput);
+  const path = str(r.file_path) ?? str(r.path);
+  const offset = num(r.offset);
+  const limit = num(r.limit);
+  let range = "";
+  if (offset !== undefined || limit !== undefined) {
+    const from = offset ?? 1;
+    const to = limit !== undefined ? from + limit - 1 : undefined;
+    range = theme.fg("warning", to ? `:${from}-${to}` : `:${from}`);
+  }
+  return `${bold("read")} ${accent(path ? relativize(path) : "…")}${range}`;
+}
+
+function grepLabel(args: ToolCallArgs): string {
+  const r = parseRaw(args.rawInput);
+  const pattern = str(r.pattern) ?? "…";
+  const scope = relativize(str(r.path) ?? ".");
+  const glob = str(r.glob);
+  const limit = num(r.limit);
+  const extras = [glob ? `(${glob})` : "", limit !== undefined ? `limit ${limit}` : ""].filter(Boolean).join(" ");
+  const tail = extras ? muted(` ${extras}`) : "";
+  return `${bold("grep")} ${accent(`/${pattern}/`)} ${muted(`in ${scope}`)}${tail}`;
+}
+
+function globLabel(args: ToolCallArgs): string {
+  const r = parseRaw(args.rawInput);
+  const pattern = str(r.pattern) ?? "…";
+  const scope = relativize(str(r.path) ?? ".");
+  return `${bold("glob")} ${accent(pattern)} ${muted(`in ${scope}`)}`;
+}
+
+function lsLabel(args: ToolCallArgs): string {
+  const r = parseRaw(args.rawInput);
+  const p = str(r.path) ?? ".";
+  return `${bold("ls")} ${accent(relativize(p))}`;
+}
+
+function pathOnlyLabel(name: string, args: ToolCallArgs): string {
+  const r = parseRaw(args.rawInput);
+  const path = str(r.file_path) ?? str(r.path);
+  return `${bold(name)} ${accent(path ? relativize(path) : "…")}`;
+}
+
+function genericLabel(args: ToolCallArgs): string {
+  const detail = args.displayDetail ? ` ${muted(args.displayDetail)}` : "";
+  return `${bold(args.title)}${detail}`;
+}
+
+export function registerDefaultToolRenderers(ctx: ExtensionContext): void {
+  const define = (name: string, fn: (args: ToolCallArgs) => ToolCallView): void => {
+    ctx.define(`ashi:render-tool-call:${name}`, fn);
+  };
+
+  define("bash", (args) => new LabeledCallLine(() => bashLabel(args)));
+
+  define("read_file", (args) => new LabeledCallLine(() => readLabel(args)));
+  define("read", (args) => new LabeledCallLine(() => readLabel(args)));
+
+  define("grep", (args) => new LabeledCallLine(() => grepLabel(args)));
+  define("glob", (args) => new LabeledCallLine(() => globLabel(args)));
+  define("ls", (args) => new LabeledCallLine(() => lsLabel(args)));
+
+  define("edit_file", (args) => new LabeledCallLine(() => pathOnlyLabel("edit", args)));
+  define("edit", (args) => new LabeledCallLine(() => pathOnlyLabel("edit", args)));
+  define("write_file", (args) => new LabeledCallLine(() => pathOnlyLabel("write", args)));
+  define("write", (args) => new LabeledCallLine(() => pathOnlyLabel("write", args)));
+
+  define("default", (args) => new LabeledCallLine(() => genericLabel(args)));
+}

package/examples/extensions/ashi/src/display-config.ts

@@ -0,0 +1,62 @@
+import { getExtensionSettings } from "agent-sh/settings";
+
+export type ToolResultMode = "hidden" | "summary" | "preview";
+
+export interface ToolEntryConfig {
+  result: ToolResultMode;
+  previewLines: number;
+}
+
+export interface ToolDisplayConfig {
+  default: ToolEntryConfig;
+  [toolName: string]: ToolEntryConfig;
+}
+
+const DEFAULT_ENTRY: ToolEntryConfig = { result: "preview", previewLines: 8 };
+
+const BUILTIN_OVERRIDES: Record<string, Partial<ToolEntryConfig>> = {
+  read: { result: "hidden" },
+  ls: { result: "hidden" },
+  grep: { result: "summary" },
+  find: { result: "summary" },
+  glob: { result: "summary" },
+  bash: { result: "preview", previewLines: 12 },
+  edit: { result: "preview" },
+  edit_file: { result: "preview" },
+  write: { result: "preview" },
+  write_file: { result: "preview" },
+};
+
+interface AshiSettings extends Record<string, unknown> {
+  display?: Record<string, Partial<ToolEntryConfig>>;
+}
+
+function mergeEntry(base: ToolEntryConfig, patch?: Partial<ToolEntryConfig>): ToolEntryConfig {
+  if (!patch) return { ...base };
+  return {
+    result: patch.result ?? base.result,
+    previewLines: patch.previewLines ?? base.previewLines,
+  };
+}
+
+export function loadToolDisplayConfig(): ToolDisplayConfig {
+  const ashi = getExtensionSettings<AshiSettings>("ashi", {});
+  const userDisplay = ashi.display ?? {};
+  const userDefault = mergeEntry(DEFAULT_ENTRY, userDisplay.default);
+  const config: ToolDisplayConfig = { default: userDefault };
+  const names = new Set([
+    ...Object.keys(BUILTIN_OVERRIDES),
+    ...Object.keys(userDisplay).filter((k) => k !== "default"),
+  ]);
+  for (const name of names) {
+    config[name] = mergeEntry(
+      mergeEntry(userDefault, BUILTIN_OVERRIDES[name]),
+      userDisplay[name],
+    );
+  }
+  return config;
+}
+
+export function entryFor(config: ToolDisplayConfig, name: string): ToolEntryConfig {
+  return config[name] ?? config.default;
+}