agent-sh 0.14.10 → 0.15.0

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

@@ -2,8 +2,10 @@ import type { ExtensionContext } from "agent-sh/types";
 import type { MultiSessionStore } from "./multi-session-store.js";
 import type { AgentShMessage as AgentMessage } from "agent-sh/session-store";
 
-/** Maintains an `(entryId | null)[]` parallel to the live messages array;
- *  null slots are synthetics like compaction summaries that have no entry. */
+interface DiffEntry { diff: unknown; filePath: string }
+export interface NestedDiff extends DiffEntry { name: string }
+
+// liveEntryIds is parallel to the live messages array; null slots are synthetics (e.g. compaction summaries) with no entry.
 export interface Capture {
   flush(): Promise<void>;
   getEntryIdAt(messageIndex: number): string | null;
@@ -15,24 +17,59 @@ export function registerCapture(
   getStore: () => MultiSessionStore,
 ): Capture {
   let liveEntryIds: (string | null)[] = [];
-  const diffMeta = new Map<string, { diff: unknown; filePath: string }>();
+  // A bridged tool call re-emitted under a synthetic id has no conversation message
+  // of its own, so bucket its diff under the enclosing real call for replay as a
+  // separate edit pair.
+  const diffMeta = new Map<string, DiffEntry>();
+  const nestedDiffs = new Map<string, NestedDiff[]>();
+  const summaryMeta = new Map<string, string>();
+  const bridgedNames = new Map<string, string>();
+  let activeRealToolId: string | undefined;
+
+  // `nested` is a bridge-set bus convention (a host tool run inside another tool),
+  // not on the core event type — read it defensively.
+  const isNested = (e: unknown): boolean => !!(e as { nested?: boolean }).nested;
+
+  ctx.bus.on("agent:tool-started", (e) => {
+    const id = e.toolCallId;
+    if (!id) return;
+    if (isNested(e)) bridgedNames.set(id, e.name ?? e.title);
+    else activeRealToolId = id;
+  });
 
   ctx.bus.on("agent:tool-completed", (e) => {
     const id = e.toolCallId;
-    const body = e.resultDisplay?.body;
-    if (id && body?.kind === "diff") {
-      diffMeta.set(id, { diff: body.diff, filePath: body.filePath });
+    if (!id) return;
+    const display = e.resultDisplay;
+    const body = display?.body;
+    if (isNested(e)) {
+      if (body?.kind === "diff" && activeRealToolId) {
+        const arr = nestedDiffs.get(activeRealToolId) ?? [];
+        arr.push({ name: bridgedNames.get(id) ?? "edit_file", diff: body.diff, filePath: body.filePath });
+        nestedDiffs.set(activeRealToolId, arr);
+      }
+      return;
     }
+    // resultDisplay isn't persisted; capture the summary for every tool so resume
+    // doesn't fall back to re-deriving only a handful.
+    if (typeof display?.summary === "string" && display.summary) summaryMeta.set(id, display.summary);
+    if (body?.kind === "diff") diffMeta.set(id, { diff: body.diff, filePath: body.filePath });
   });
 
   const enrich = (m: AgentMessage): AgentMessage => {
     if (m.role !== "tool" || !m.tool_call_id) return m;
-    const meta = diffMeta.get(m.tool_call_id);
-    if (!meta) return m;
-    return { ...m, meta: { ...m.meta, diff: meta.diff, filePath: meta.filePath } };
+    const single = diffMeta.get(m.tool_call_id);
+    const nested = nestedDiffs.get(m.tool_call_id);
+    const summary = summaryMeta.get(m.tool_call_id);
+    if (!single && !nested && !summary) return m;
+    const meta: Record<string, unknown> = { ...m.meta };
+    if (single) { meta.diff = single.diff; meta.filePath = single.filePath; }
+    if (nested) meta.diffs = nested;
+    if (summary) meta.summary = summary;
+    return { ...m, meta };
   };
 
-  const flush = async (): Promise<void> => {
+  const writeNewMessages = async (): Promise<void> => {
     const messages = ctx.call("conversation:get-messages") as AgentMessage[] | undefined;
     if (!messages || messages.length <= liveEntryIds.length) return;
     const newMessages = messages.slice(liveEntryIds.length).map(enrich);
@@ -41,6 +78,13 @@ export function registerCapture(
     getStore().markLastSession();
   };
 
+  // Serialize flushes so an exit-time flush can't race processing-done and double-append.
+  let chain: Promise<void> = Promise.resolve();
+  const flush = (): Promise<void> => {
+    chain = chain.then(writeNewMessages, writeNewMessages);
+    return chain;
+  };
+
   ctx.bus.on("agent:processing-done", () => { void flush(); });
 
   return {

package/examples/extensions/ashi/src/chat/assistant.ts

@@ -0,0 +1,67 @@
+import type { ContainerView, MarkdownView, RenderNode, RenderNodes } from "../renderer.js";
+
+export type RenderBlock =
+  | { type: "text"; text: string }
+  | { type: "code-block"; language: string; code: string }
+  | { type: "image"; data: Buffer };
+
+export type ContentTransform = (blocks: RenderBlock[]) => RenderBlock[];
+
+export class AssistantMessage {
+  readonly node: RenderNode;
+  private container: ContainerView;
+  private md: MarkdownView;
+  private buffer = "";
+
+  constructor(private nodes: RenderNodes, private transform: ContentTransform = (b) => b) {
+    this.container = nodes.container();
+    this.md = nodes.markdown({ paddingX: 1, bullet: true });
+    this.container.addChild(nodes.spacer(1));
+    this.container.addChild(this.md.node);
+    this.node = this.container.node;
+  }
+
+  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 = " ";
+    const blocks = this.transform([{ type: "text", text: this.buffer }]);
+    if (blocks.every((b) => b.type === "text")) {
+      this.md.setText(this.buffer);
+      return;
+    }
+    this.rebuild(blocks);
+  }
+
+  private rebuild(blocks: RenderBlock[]): void {
+    this.container.clear();
+    this.container.addChild(this.nodes.spacer(1));
+    for (const block of blocks) {
+      if (block.type === "image") {
+        const img = this.nodes.image(block.data);
+        if (img) this.container.addChild(img);
+      } else if (block.type === "code-block") {
+        const m = this.nodes.markdown({ paddingX: 1 });
+        m.setText(`\`\`\`${block.language}\n${block.code}\n\`\`\``);
+        this.container.addChild(m.node);
+      } else if (block.text.trim()) {
+        const m = this.nodes.markdown({ paddingX: 1 });
+        m.setText(block.text);
+        this.container.addChild(m.node);
+      }
+    }
+  }
+
+  hasContent(): boolean {
+    return this.buffer.trim().length > 0;
+  }
+}

package/examples/extensions/ashi/src/chat/lines.ts

@@ -0,0 +1,39 @@
+import type { RenderNode, RenderNodes } from "../renderer.js";
+import { theme, type ThemeColor } from "../theme.js";
+
+export class InfoLine {
+  readonly node: RenderNode;
+  constructor(nodes: RenderNodes, message: string) {
+    const t = nodes.text({ paddingX: 1 });
+    t.setText(theme.fg("muted", message));
+    this.node = t.node;
+  }
+}
+
+export class ErrorLine {
+  readonly node: RenderNode;
+  constructor(nodes: RenderNodes, message: string) {
+    const t = nodes.text({ paddingX: 1 });
+    t.setText(`${theme.fg("error", "✗")} ${theme.fg("error", message)}`);
+    this.node = t.node;
+  }
+}
+
+export type NoticeLevel = "info" | "warn" | "error" | "success";
+
+const NOTICE: Record<NoticeLevel, { color: ThemeColor; prefix: string }> = {
+  info: { color: "muted", prefix: "" },
+  success: { color: "success", prefix: "✓ " },
+  warn: { color: "warning", prefix: "! " },
+  error: { color: "error", prefix: "✗ " },
+};
+
+export class NoticeLine {
+  readonly node: RenderNode;
+  constructor(nodes: RenderNodes, message: string, level: NoticeLevel = "info") {
+    const { color, prefix } = NOTICE[level];
+    const t = nodes.text({ paddingX: 1 });
+    t.setText(`${theme.fg(color, prefix)}${theme.fg(color, message)}`);
+    this.node = t.node;
+  }
+}

package/examples/extensions/ashi/src/chat/thinking.ts

@@ -0,0 +1,42 @@
+// Hidden clears the block but keeps the buffer so a toggle restores it.
+import type { ContainerView, MarkdownView, RenderNode, RenderNodes } from "../renderer.js";
+import { theme } from "../theme.js";
+
+const thinkingColor = (t: string): string => theme.dim(theme.italic(theme.fg("thinkingText", t)));
+
+export class ThinkingBlock {
+  readonly node: RenderNode;
+  private container: ContainerView;
+  private md: MarkdownView;
+  private buffer = "";
+  private hidden = false;
+
+  constructor(private nodes: RenderNodes) {
+    this.container = nodes.container();
+    this.md = nodes.markdown({ paddingX: 1, color: thinkingColor });
+    this.container.addChild(nodes.spacer(1));
+    this.container.addChild(this.md.node);
+    this.node = this.container.node;
+  }
+
+  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.container.clear();
+    if (hidden) return;
+    this.container.addChild(this.nodes.spacer(1));
+    this.md = this.nodes.markdown({ paddingX: 1, color: thinkingColor });
+    this.md.setText(this.buffer);
+    this.container.addChild(this.md.node);
+  }
+}

package/examples/extensions/ashi/src/chat/tool-group.ts

@@ -0,0 +1,84 @@
+import type { Renderer, RenderNode, ToolGroupChild, ToolGroupModel, ToolGroupView } from "../renderer.js";
+
+export const GROUP_ICONS: Record<string, string> = { read: "◆", search: "⌕" };
+
+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;
+}
+
+export class ToolGroup {
+  readonly node: RenderNode;
+  readonly kind: string;
+  private view: ToolGroupView;
+  private maxVisible: number;
+  private allChildren: ToolGroupChild[] = [];
+  private callsById = new Map<string, ToolGroupChild>();
+  private expanded = false;
+  private open = true;
+
+  constructor(renderer: Renderer, kind: string, maxVisible: number = Infinity) {
+    this.kind = kind;
+    this.maxVisible = maxVisible;
+    this.view = renderer.mountToolGroup!();
+    this.node = this.view.node;
+    this.repaint();
+  }
+
+  addCall(toolCallId: string, name: string, detail: string): void {
+    const child: ToolGroupChild = { name: shortToolName(name), detail: detail || "…" };
+    if (toolCallId) this.callsById.set(toolCallId, child);
+    this.allChildren.push(child);
+    this.repaint();
+  }
+
+  recordCompletion(toolCallId: string, exitCode: number | null, summary?: string): void {
+    const child = this.callsById.get(toolCallId);
+    if (!child) return;
+    child.status = { exitCode, summary };
+    this.repaint();
+  }
+
+  toggleExpanded(): void {
+    this.expanded = !this.expanded;
+    this.repaint();
+  }
+
+  seal(): void {
+    if (!this.open) return;
+    this.open = false;
+    this.repaint();
+  }
+
+  // When collapsed and over-cap, one visible slot is reserved for the summary.
+  private visibleSliceStart(): number {
+    if (this.expanded || !Number.isFinite(this.maxVisible)) return 0;
+    if (this.allChildren.length <= this.maxVisible) return 0;
+    return this.allChildren.length - (this.maxVisible - 1);
+  }
+
+  private repaint(): void {
+    const start = this.visibleSliceStart();
+    const evicted = this.allChildren.slice(0, start);
+    const hidden = evicted.length === 0
+      ? null
+      : {
+          count: evicted.length,
+          ok: evicted.every((c) => !c.status || c.status.exitCode === null || c.status.exitCode === 0),
+        };
+    const model: ToolGroupModel = {
+      kind: this.kind,
+      icon: GROUP_ICONS[this.kind] ?? "▶",
+      children: this.allChildren.slice(start),
+      hidden,
+      expanded: this.expanded,
+      open: this.open,
+    };
+    this.view.update(model);
+  }
+}

package/examples/extensions/ashi/src/chat/user-message.ts

@@ -0,0 +1,20 @@
+import type { RenderNode, RenderNodes } from "../renderer.js";
+import { theme } from "../theme.js";
+
+export class UserMessage {
+  readonly node: RenderNode;
+  constructor(nodes: RenderNodes, text: string) {
+    const container = nodes.container();
+    container.addChild(nodes.spacer(1));
+    const md = nodes.markdown({
+      paddingX: 1,
+      paddingY: 1,
+      bgColor: (t) => theme.bg("userMessageBg", t),
+      color: (t) => theme.fg("userMessageText", t),
+      osc133Zones: true,
+    });
+    md.setText(text);
+    container.addChild(md.node);
+    this.node = container.node;
+  }
+}

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

@@ -8,11 +8,12 @@ import { loadExtensions } from "agent-sh/extension-loader";
 import { activateAgent } from "agent-sh/agent";
 import { getSettings } from "agent-sh/settings";
 import { Shell } from "agent-sh/shell";
+import { TerminalBuffer } from "agent-sh/utils/terminal-buffer";
 import type { Terminal } from "agent-sh/shell/terminal";
 import activateShellContext from "agent-sh/shell/context";
 import type { AppConfig } from "agent-sh/types";
 
-/** No-op: ashi renders via pi-tui, the PTY only needs to exist. */
+/** ashi renders through its own Renderer; this PTY only needs to exist. */
 function headlessTerminal(): Terminal {
   return {
     write() {},
@@ -23,23 +24,41 @@ function headlessTerminal(): Terminal {
   };
 }
 
+import "./events.js";
 import { mountAshi } from "./frontend.js";
 import { MultiSessionStore } from "./multi-session-store.js";
 import { registerForkCommands, applyBranchMessages } from "./commands.js";
 import { registerSessionCommands } from "./session-commands.js";
 import { registerCompaction } from "./compaction.js";
-import { registerCapture } from "./capture.js";
+import { registerCapture, type Capture } from "./capture.js";
 import { registerRenderDefaults } from "./hooks.js";
 import { registerDefaultSchemaRenderers } from "./default-schema-renderers.js";
+import { createPiTuiRenderer } from "./renderers/pi-tui/index.js";
+import type { Renderer } from "./renderer.js";
+import { loadRendererPreference } from "./display-config.js";
+import { applyOutputMode } from "./terminal-mode.js";
 import * as os from "node:os";
 import * as path from "node:path";
+import { fileURLToPath } from "node:url";
 
-function parseArgs(argv: string[]): AppConfig & { extensions?: string[]; continueLast: boolean } {
+// Package root (dist/cli.js and src/cli.ts both sit one level down) — the running copy.
+const ASHI_ROOT = path.dirname(path.dirname(fileURLToPath(import.meta.url)));
+const ASHI_SURFACE = `You're attached through ashi, an interactive terminal UI. A person is at the keyboard reading your replies as they render — address them directly and keep the exchange conversational.
+
+Your working directory is ${process.cwd()}; your tools run there and it stays fixed. The user can also run shell commands with a \`!\` prefix — those run in a separate shell that may sit elsewhere, and don't change your working directory.
+
+ashi's own source lives at ${ASHI_ROOT}. Read it when the user asks how the TUI works, or wants to change how it looks or behaves:
+- ${path.join(ASHI_ROOT, "README.md")} — what ashi is and how rendering decouples into swappable render extensions
+- ${path.join(ASHI_ROOT, "EXTENDING.md")} — the render-extension contract
+- ${path.join(ASHI_ROOT, "src")} — the frontend, session capture/resume, and the pi-tui renderer`;
+
+function parseArgs(argv: string[]): AppConfig & { extensions?: string[]; continueLast: boolean; renderer?: string } {
   let model: string | undefined;
   let apiKey: string | undefined;
   let baseURL: string | undefined;
   let provider: string | undefined;
   let backend: string | undefined;
+  let renderer: string | undefined;
   let continueLast = false;
   const extensions: string[] = [];
 
@@ -50,6 +69,7 @@ function parseArgs(argv: string[]): AppConfig & { extensions?: string[]; continu
     else if (a === "--base-url" && argv[i + 1]) baseURL = argv[++i];
     else if (a === "--provider" && argv[i + 1]) provider = argv[++i];
     else if (a === "--backend" && argv[i + 1]) backend = argv[++i];
+    else if (a === "--renderer" && argv[i + 1]) renderer = argv[++i];
     else if ((a === "-e" || a === "--extensions") && argv[i + 1]) {
       extensions.push(...argv[++i]!.split(",").map(s => s.trim()).filter(Boolean));
     } else if (a === "-c" || a === "--continue") {
@@ -60,7 +80,7 @@ function parseArgs(argv: string[]): AppConfig & { extensions?: string[]; continu
     }
   }
 
-  return { shell: "/bin/sh", model, apiKey, baseURL, provider, backend, extensions, continueLast };
+  return { shell: "/bin/sh", model, apiKey, baseURL, provider, backend, renderer, extensions, continueLast };
 }
 
 const MANAGEMENT_HELP = `ashi — ash (agent-sh's built-in agent) in an interactive TUI
@@ -76,9 +96,12 @@ Management:
 
 Launch (default):
   ashi [--provider <name>] [--model <id>] [--api-key <key>] [--base-url <url>]
-       [--backend <name>] [-e <ext>[,<ext>...]] [-c | --continue]
+       [--backend <name>] [--renderer <name>] [-e <ext>[,<ext>...]] [-c | --continue]
 
   -c, --continue   Resume the last session in this cwd (fresh session if none)
+  --renderer       TUI renderer (default: pi-tui). Also ASHI_RENDERER, or
+                   ashi.renderer in settings.json. A renderer is an extension;
+                   install it (or -e it) so its ashi:renderer:<name> is registered.
 
 Reads ~/.agent-sh/settings.json for providers and defaults.`;
 
@@ -139,7 +162,11 @@ async function main(): Promise<void> {
   let stopFrontend: (() => void) | null = null;
 
   let shellRef: { kill(): void } | null = null;
-  const cleanup = (): void => {
+  let captureRef: Capture | null = null;
+  const cleanup = async (): Promise<void> => {
+    // The per-turn flush is fire-and-forget; await it so a quick exit can't drop
+    // a just-completed turn.
+    try { await captureRef?.flush(); } catch {}
     try { stopFrontend?.(); } catch {}
     try { shellRef?.kill(); } catch {}
     try { core.kill(); } catch {}
@@ -153,7 +180,7 @@ async function main(): Promise<void> {
 
   activateAgent(ctx);
   activateShellContext(ctx);
-  await loadBuiltinExtensions(ctx, ["rolling-history"]);
+  const builtinExtensions = await loadBuiltinExtensions(ctx);
 
   const shell = new Shell({
     bus: core.bus,
@@ -167,6 +194,17 @@ async function main(): Promise<void> {
   });
   shellRef = shell;
 
+  let terminalBuffer: TerminalBuffer | null | undefined;
+  ctx.define("terminal-buffer", (): TerminalBuffer | null => {
+    if (terminalBuffer !== undefined) return terminalBuffer;
+    try {
+      terminalBuffer = TerminalBuffer.createWired(core.bus);
+    } catch {
+      terminalBuffer = null;
+    }
+    return terminalBuffer;
+  });
+
   const loaded = await loadExtensions(ctx, config.extensions);
   core.bus.emit("core:extensions-loaded", { names: loaded });
 
@@ -179,29 +217,59 @@ async function main(): Promise<void> {
   }
 
   const capture = registerCapture(ctx, getStore);
+  captureRef = capture;
   registerCompaction(ctx, getStore, capture);
-  registerRenderDefaults(ctx);
+
+  // Renderers are extensions; selection is --renderer > ASHI_RENDERER >
+  // ashi.renderer (settings) > pi-tui.
+  ctx.define("ashi:renderer:pi-tui", () => createPiTuiRenderer());
+  const rendererName = (
+    config.renderer ?? process.env.ASHI_RENDERER ?? loadRendererPreference() ?? "pi-tui"
+  ).trim();
+  const rendererKey = `ashi:renderer:${rendererName}`;
+  if (!ctx.list().includes(rendererKey)) {
+    process.stderr.write(
+      `ashi: no renderer registered for "${rendererName}" (${rendererKey}). ` +
+      `Install the extension that provides it (or pass -e <ext>) so it registers ${rendererKey}.\n`,
+    );
+    process.exit(1);
+  }
+  const renderer = ctx.call(rendererKey) as Renderer;
+  applyOutputMode(renderer.capabilities.rawOutput);
+  registerRenderDefaults(ctx, renderer);
   registerDefaultSchemaRenderers(ctx);
 
-  ctx.advise("system-prompt:build", (next) => `${next()}\n\n<cwd>${process.cwd()}</cwd>`);
+  ctx.advise("system-prompt:frontend", (next) => {
+    const base = (next() as string) ?? "";
+    return base ? `${base}\n\n${ASHI_SURFACE}` : ASHI_SURFACE;
+  });
 
-  const handle = mountAshi(ctx, getStore, capture);
+  const handle = mountAshi(ctx, getStore, capture, renderer);
   stopFrontend = handle.stop;
 
+  core.bus.emit("ashi:ready", {});
+
   registerForkCommands(ctx, getStore, handle.openTreePicker, handle.rebuildChat, capture);
   registerSessionCommands(ctx, getStore, capture, {
     openSessionPicker: handle.openSessionPicker,
     rebuildChat: handle.rebuildChat,
   });
 
+  await core.activateBackend(config.backend ?? getSettings().defaultBackend);
+
   if (resumeId) {
+    // After activateBackend: conversation:replace-messages is a no-op until the agent backend exists.
     applyBranchMessages(ctx, getStore, capture);
     await handle.rebuildChat();
     ctx.bus.emit("ui:info", { message: `continued session ${resumeId.slice(0, 12)}…` });
+  } else {
+    // New-session only: skip on resume so a restored transcript isn't prefixed with this.
+    const loadedExtensions = [...new Set([...builtinExtensions, ...loaded])];
+    if (loadedExtensions.length > 0) {
+      ctx.bus.emit("ui:info", { message: `extensions: ${loadedExtensions.join(" · ")}` });
+    }
   }
 
-  await core.activateBackend(config.backend ?? getSettings().defaultBackend);
-
   process.on("SIGTERM", cleanup);
   process.on("SIGHUP", cleanup);
 }

package/examples/extensions/ashi/src/clipboard-image.ts

@@ -0,0 +1,41 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { readFile, unlink } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+const exec = promisify(execFile);
+
+export interface CapturedImage {
+  /** Base64-encoded image data (no data: URL prefix). */
+  data: string;
+  mimeType: string;
+}
+
+let counter = 0;
+
+/** Terminals don't deliver image bytes through paste, so we read the macOS
+ *  pasteboard directly via osascript. Null when the clipboard holds no image. */
+export async function readClipboardImage(): Promise<CapturedImage | null> {
+  if (process.platform !== "darwin") return null;
+  const tmp = join(tmpdir(), `ashi-clip-${process.pid}-${counter++}.png`);
+  try {
+    await exec("osascript", [
+      "-e", "set png_data to (the clipboard as «class PNGf»)",
+      "-e", `set fp to open for access POSIX file ${JSON.stringify(tmp)} with write permission`,
+      "-e", "write png_data to fp",
+      "-e", "close access fp",
+    ], { timeout: 10_000 });
+  } catch {
+    return null;
+  }
+  try {
+    const buf = await readFile(tmp);
+    if (buf.length === 0) return null;
+    return { data: buf.toString("base64"), mimeType: "image/png" };
+  } catch {
+    return null;
+  } finally {
+    void unlink(tmp).catch(() => {});
+  }
+}

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

@@ -40,7 +40,17 @@ export function applyBranchMessages(
   capture: Capture,
 ): void {
   const store = getStore().current();
-  ctx.call("conversation:replace-messages", store.buildMessages());
+  const messages = store.buildMessages();
+  ctx.call("conversation:replace-messages", messages);
+
+  // replace-messages no-ops until the agent backend is active; seeding then desyncs
+  // capture's baseline against an empty conversation and silently drops later turns.
+  const live = ctx.call("conversation:get-messages") as unknown[] | undefined;
+  if ((live?.length ?? 0) !== messages.length) {
+    throw new Error(
+      `applyBranchMessages: conversation not seeded (live ${live?.length ?? 0} vs ${messages.length}); call after the agent backend is active`,
+    );
+  }
 
   const branch = store.getBranch();
   let compaction: { firstKeptId: string } | null = null;

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

@@ -0,0 +1,67 @@
+import type { App, Renderer } from "./renderer.js";
+import { InfoLine } from "./chat/lines.js";
+
+export interface SelectChoice {
+  value: string;
+  label: string;
+  description?: string;
+}
+export interface SelectOpts {
+  title?: string;
+  items: SelectChoice[];
+}
+export interface ConfirmOpts {
+  title: string;
+}
+
+export interface DialogGuard {
+  isOpen(): boolean;
+  setOpen(open: boolean): void;
+}
+
+export interface Dialogs {
+  select(opts: SelectOpts): Promise<string | undefined>;
+  confirm(opts: ConfirmOpts): Promise<boolean>;
+}
+
+export function createDialogs(app: App, renderer: Renderer, guard: DialogGuard): Dialogs {
+  const select = (opts: SelectOpts): Promise<string | undefined> => {
+    if (guard.isOpen() || opts.items.length === 0) return Promise.resolve(undefined);
+    return new Promise((resolve) => {
+      const hint = new InfoLine(renderer, opts.title ?? "↑↓ move · enter: select · esc: cancel");
+      const picker = app.createSelectList(
+        opts.items.map((c) => ({ value: c.value, label: c.label, description: c.description })),
+        { visibleRows: Math.min(15, Math.max(1, opts.items.length)) },
+      );
+      let settled = false;
+      const close = (result?: string): void => {
+        if (settled) return;
+        settled = true;
+        guard.setOpen(false);
+        app.footerSlot.removeChild(picker.node);
+        app.footerSlot.removeChild(hint.node);
+        app.focusInput();
+        app.requestRender();
+        resolve(result);
+      };
+      picker.onSelect((item) => close(item.value));
+      picker.onCancel(() => close());
+      guard.setOpen(true);
+      app.footerSlot.addChild(hint.node);
+      app.footerSlot.addChild(picker.node);
+      app.setFocus(picker.node);
+      app.requestRender();
+    });
+  };
+
+  const confirm = (opts: ConfirmOpts): Promise<boolean> =>
+    select({
+      title: opts.title,
+      items: [
+        { value: "yes", label: "Yes" },
+        { value: "no", label: "No" },
+      ],
+    }).then((v) => v === "yes");
+
+  return { select, confirm };
+}