agent-sh 0.15.6 → 0.15.8

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

@@ -7,6 +7,8 @@ export type RenderBlock =
 
 export type ContentTransform = (blocks: RenderBlock[]) => RenderBlock[];
 
+const stripTrailing = (s: string): string => s.replace(/\s+$/, "");
+
 export class AssistantMessage {
   readonly node: RenderNode;
   private container: ContainerView;
@@ -23,20 +25,22 @@ export class AssistantMessage {
 
   appendText(t: string): void {
     this.buffer += t;
-    this.md.setText(this.buffer);
+    this.md.setText(stripTrailing(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);
+    this.md.setText(stripTrailing(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);
+      // Render the transformed text, not the raw buffer — transforms may rewrite
+      // content in place (e.g. inline-image sentinels) while staying all-text.
+      this.md.setText(stripTrailing(blocks.map((b) => (b.type === "text" ? b.text : "")).join("")));
       return;
     }
     this.rebuild(blocks);
@@ -55,7 +59,7 @@ export class AssistantMessage {
         this.container.addChild(m.node);
       } else if (block.text.trim()) {
         const m = this.nodes.markdown({ paddingX: 1 });
-        m.setText(block.text);
+        m.setText(stripTrailing(block.text));
         this.container.addChild(m.node);
       }
     }

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

@@ -34,6 +34,7 @@ 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 { registerInlineImage, supportsInlineImages } from "./renderers/pi-tui/inline-image.js";
 import type { Renderer } from "./renderer.js";
 import { loadRendererPreference } from "./display-config.js";
 import { applyOutputMode } from "./terminal-mode.js";
@@ -177,6 +178,8 @@ async function main(): Promise<void> {
 
   const ctx = core.extensionContext({ quit: cleanup });
 
+  ctx.define("session:current-id", () => store.current().id);
+
   activateAgent(ctx);
   activateShellContext(ctx);
   await loadBuiltinExtensions(ctx);
@@ -238,6 +241,11 @@ async function main(): Promise<void> {
   registerRenderDefaults(ctx, renderer);
   registerDefaultSchemaRenderers(ctx);
 
+  // Handler presence is how producers detect that inline images are available.
+  if (rendererName === "pi-tui" && supportsInlineImages()) {
+    ctx.define("ashi:inline-image:register", (png: Buffer) => registerInlineImage(png));
+  }
+
   ctx.advise("system-prompt:frontend", (next) => {
     const base = (next() as string) ?? "";
     return base ? `${base}\n\n${ASHI_SURFACE}` : ASHI_SURFACE;

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

@@ -39,19 +39,16 @@ export function registerCompaction(
     }
 
     const older = messages.slice(0, cutIdx);
-    const kept = messages.slice(cutIdx);
     const tokensBefore = (ctx.call("conversation:estimate-prompt-tokens") as number) ?? 0;
     const customSummary = (await ctx.call("ashi:compact:build-summary", older)) as string | null | undefined;
 
     const store = getStore().current();
     await store.appendCompaction(firstKeptId, tokensBefore, customSummary ?? undefined);
-    ctx.call("conversation:replace-messages", store.buildMessages());
 
-    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]);
+    // Take messages and ids from one rebuild so capture's index→id map can't drift.
+    const { messages: rebuilt, entryIds } = store.buildBranchWithIds();
+    ctx.call("conversation:replace-messages", rebuilt);
+    capture.resetTo(entryIds);
 
     const tokensAfter = (ctx.call("conversation:estimate-prompt-tokens") as number) ?? 0;
     return { before: tokensBefore, after: tokensAfter, evictedCount: older.length };

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

@@ -399,7 +399,7 @@ export function mountAshi(
       app.requestRender();
       return;
     }
-    pendingUserShell.push({ private: !!opts?.private });
+    pendingUserShell.push({ private: !!opts?.private, command: line });
     if (opts?.private) bus.emit("shell:user-exec-exclude-next", {});
     bus.emit("shell:pty-write", { data: line + "\n" });
   };
@@ -650,6 +650,8 @@ export function mountAshi(
     activeThinking = null;
     activeTools.clear();
     openGroup = null;
+    compactions = 0;
+    statusFooter.update({ compactions });
     clearChat();
     const branch = getStore().current().getBranch();
     const toolMap = new Map<string, ReplayEntry>();
@@ -814,12 +816,13 @@ export function mountAshi(
   bus.on("shell:foreground-busy", ({ busy }) => { shellForegroundBusy = busy; });
 
   let activeUserShell: { pair: ToolPair; command: string; isPrivate: boolean } | null = null;
-  bus.on("shell:command-start", ({ command }) => {
+  bus.on("shell:command-start", () => {
     if (agentShellActive) return;
     const intent = pendingUserShell.consume();
     if (!intent) return;
     finalizeThinking();
     if (activeAssistant) { activeAssistant.finalize(); activeAssistant = null; }
+    const command = intent.command;
     const isPrivate = intent.private;
     const name = isPrivate ? "user_bash_private" : "user_bash";
     const pair = renderToolPair({
@@ -859,7 +862,7 @@ export function mountAshi(
     // Drain shell queue before queries so its output lands in the next turn's <shell_events>.
     while (queuedShellLines.length > 0) {
       const item = queuedShellLines.shift()!;
-      pendingUserShell.push({ private: item.private });
+      pendingUserShell.push({ private: item.private, command: item.line });
       if (item.private) bus.emit("shell:user-exec-exclude-next", {});
       bus.emit("shell:pty-write", { data: item.line + "\n" });
     }

package/examples/extensions/ashi/src/renderers/pi-tui/inline-image.ts

@@ -0,0 +1,145 @@
+/**
+ * Inline images in markdown text via the kitty/Ghostty Unicode placeholder
+ * protocol. The image is transmitted out-of-band (cursor-neutral); the frame
+ * carries only `cols` width-1 placeholder cells, so the renderer's wrap/measure
+ * math is unaffected and the line is never treated as an image line. kitty-only.
+ */
+import {
+  allocateImageId,
+  getCapabilities,
+  getCellDimensions,
+  getImageDimensions,
+} from "@earendil-works/pi-tui";
+
+export const SENTINEL_RE = /\x01LI:(\d+)\x01/g;
+export const PLACEHOLDER = String.fromCodePoint(0x10eeee);
+
+// kitty rowcolumn-diacritics: the Nth entry encodes row/column index N
+// (gen/rowcolumn-diacritics.txt in the kitty source).
+const DIACRITICS = [0x0305,0x030D,0x030E,0x0310,0x0312,0x033D,0x033E,0x033F,0x0346,0x034A,0x034B,0x034C,0x0350,0x0351,0x0352,0x0357,0x035B,0x0363,0x0364,0x0365,0x0366,0x0367,0x0368,0x0369,0x036A,0x036B,0x036C,0x036D,0x036E,0x036F,0x0483,0x0484,0x0485,0x0486,0x0487,0x0592,0x0593,0x0594,0x0595,0x0597,0x0598,0x0599,0x059C,0x059D,0x059E,0x059F,0x05A0,0x05A1,0x05A8,0x05A9,0x05AB,0x05AC,0x05AF,0x05C4,0x0610,0x0611,0x0612,0x0613,0x0614,0x0615,0x0616,0x0617,0x0657,0x0658,0x0659,0x065A,0x065B,0x065D,0x065E,0x06D6,0x06D7,0x06D8,0x06D9,0x06DA,0x06DB,0x06DC,0x06DF,0x06E0,0x06E1,0x06E2,0x06E4,0x06E7,0x06E8,0x06EB,0x06EC,0x0730,0x0732,0x0733,0x0735,0x0736,0x073A,0x073D,0x073F,0x0740,0x0741,0x0743,0x0745,0x0747,0x0749,0x074A,0x07EB,0x07EC,0x07ED,0x07EE,0x07EF,0x07F0,0x07F1,0x07F3,0x0816,0x0817,0x0818,0x0819,0x081B,0x081C,0x081D,0x081E,0x081F,0x0820,0x0821,0x0822,0x0823,0x0825,0x0826,0x0827,0x0829,0x082A,0x082B,0x082C,0x082D,0x0951,0x0953,0x0954,0x0F82,0x0F83,0x0F86,0x0F87,0x135D,0x135E,0x135F,0x17DD,0x193A,0x1A17,0x1A75,0x1A76,0x1A77,0x1A78,0x1A79,0x1A7A,0x1A7B,0x1A7C,0x1B6B,0x1B6D,0x1B6E,0x1B6F,0x1B70,0x1B71,0x1B72,0x1B73,0x1CD0,0x1CD1,0x1CD2,0x1CDA,0x1CDB,0x1CE0,0x1DC0,0x1DC1,0x1DC3,0x1DC4,0x1DC5,0x1DC6,0x1DC7,0x1DC8,0x1DC9,0x1DCB,0x1DCC,0x1DD1,0x1DD2,0x1DD3,0x1DD4,0x1DD5,0x1DD6,0x1DD7,0x1DD8,0x1DD9,0x1DDA,0x1DDB,0x1DDC,0x1DDD,0x1DDE,0x1DDF,0x1DE0,0x1DE1,0x1DE2,0x1DE3,0x1DE4,0x1DE5,0x1DE6,0x1DFE,0x20D0,0x20D1,0x20D4,0x20D5,0x20D6,0x20D7,0x20DB,0x20DC,0x20E1,0x20E7,0x20E9,0x20F0,0x2CEF,0x2CF0,0x2CF1,0x2DE0,0x2DE1,0x2DE2,0x2DE3,0x2DE4,0x2DE5,0x2DE6,0x2DE7,0x2DE8,0x2DE9,0x2DEA,0x2DEB,0x2DEC,0x2DED,0x2DEE,0x2DEF,0x2DF0,0x2DF1,0x2DF2,0x2DF3,0x2DF4,0x2DF5,0x2DF6,0x2DF7,0x2DF8,0x2DF9,0x2DFA,0x2DFB,0x2DFC,0x2DFD,0x2DFE,0x2DFF,0xA66F,0xA67C,0xA67D,0xA6F0,0xA6F1,0xA8E0,0xA8E1,0xA8E2,0xA8E3,0xA8E4,0xA8E5,0xA8E6,0xA8E7,0xA8E8,0xA8E9,0xA8EA,0xA8EB,0xA8EC,0xA8ED,0xA8EE,0xA8EF,0xA8F0,0xA8F1,0xAAB0,0xAAB2,0xAAB3,0xAAB7,0xAAB8,0xAABE,0xAABF,0xAAC1,0xFE20,0xFE21,0xFE22,0xFE23,0xFE24,0xFE25,0xFE26,0x10A0F,0x10A38,0x1D185,0x1D186,0x1D187,0x1D188,0x1D189,0x1D1AA,0x1D1AB,0x1D1AC,0x1D1AD,0x1D242,0x1D243,0x1D244];
+
+const ESC = "\x1b";
+const diacritic = (i: number): string =>
+  String.fromCodePoint(DIACRITICS[Math.min(i, DIACRITICS.length - 1)]!);
+
+interface Entry {
+  base64: string;
+  widthPx: number;
+  heightPx: number;
+  transmitted: boolean;
+  placedCols: number;
+}
+
+const registry = new Map<number, Entry>();
+
+export function supportsInlineImages(): boolean {
+  return getCapabilities().images === "kitty";
+}
+
+export function registerInlineImage(png: Buffer): number | null {
+  if (!supportsInlineImages()) return null;
+  const base64 = png.toString("base64");
+  const dims = getImageDimensions(base64, "image/png");
+  if (!dims || dims.heightPx <= 0) return null;
+  const id = allocateImageId();
+  registry.set(id, { base64, widthPx: dims.widthPx, heightPx: dims.heightPx, transmitted: false, placedCols: 0 });
+  return id;
+}
+
+const maxInlineCols = (): number => Math.max(8, (process.stdout.columns ?? 80) - 4);
+
+export function inlineCols(id: number, maxCols = maxInlineCols()): number | null {
+  const e = registry.get(id);
+  if (!e) return null;
+  const cell = getCellDimensions();
+  const cols = Math.round((e.widthPx / e.heightPx) * (cell.heightPx / cell.widthPx));
+  // Column index is carried by a diacritic, so cols can't exceed the table.
+  return Math.max(1, Math.min(maxCols, DIACRITICS.length, cols));
+}
+
+// Transmits once, then re-places only when cols changes (resize). `write` must
+// target the same stream as the composed frame so the data lands before the cells.
+export function emitInlineImage(id: number, cols: number, write: (s: string) => void): void {
+  const e = registry.get(id);
+  if (!e) return;
+  if (!e.transmitted) {
+    e.transmitted = true;
+    e.placedCols = cols;
+    const b64 = e.base64;
+    const CHUNK = 4096;
+    for (let i = 0; i < b64.length; i += CHUNK) {
+      const chunk = b64.slice(i, i + CHUNK);
+      const last = i + CHUNK >= b64.length;
+      write(
+        i === 0
+          ? `${ESC}_Gq=2,a=T,U=1,f=100,t=d,i=${id},c=${cols},r=1,m=${last ? 0 : 1};${chunk}${ESC}\\`
+          : `${ESC}_Gq=2,m=${last ? 0 : 1};${chunk}${ESC}\\`,
+      );
+    }
+  } else if (e.placedCols !== cols) {
+    e.placedCols = cols;
+    write(`${ESC}_Gq=2,a=p,U=1,i=${id},c=${cols},r=1${ESC}\\`);
+  }
+}
+
+// Each cell encodes the id's low 24 bits in the fg colour and its high byte in the
+// third diacritic (row, column, id-high) — allocateImageId() ids use all 32 bits.
+// `colStart` offsets the column index so an image split across lines (wrap) keeps
+// continuous columns instead of repeating its left edge.
+export function inlinePlaceholder(id: number, count: number, colStart = 0): string {
+  const hi = diacritic((id >> 24) & 255);
+  let s = `${ESC}[38;2;${(id >> 16) & 255};${(id >> 8) & 255};${id & 255}m`;
+  for (let j = 0; j < count; j++) s += PLACEHOLDER + diacritic(0) + diacritic(colStart + j) + hi;
+  return s + `${ESC}[39m`;
+}
+
+export interface InlineItem {
+  id: number;
+  cols: number;
+}
+
+// Repaint the reserved PLACEHOLDER runs as real kitty placeholder cells. Cells are
+// partitioned by each image's reserved `cols` rather than by contiguous run, so
+// adjacent images (`$a$$b$` → one fused run) and an image the wrapper split across
+// lines both keep their ids aligned. `transmit` fires once per image, when its
+// first cell is placed. Pure apart from the injected `transmit` callback.
+export function paintInlineImages(
+  lines: string[],
+  items: InlineItem[],
+  transmit: (id: number, cols: number) => void,
+): string[] {
+  if (items.length === 0) return lines;
+  let k = 0; // index of the image currently being placed
+  let placed = 0; // cells of image k already emitted across prior lines
+  return lines.map((line) => {
+    if (k >= items.length || !line.includes(PLACEHOLDER)) return line;
+    let out = "";
+    let i = 0;
+    while (i < line.length) {
+      const ch = String.fromCodePoint(line.codePointAt(i)!);
+      if (ch === PLACEHOLDER && k < items.length) {
+        const item = items[k]!;
+        let count = 0;
+        while (
+          i < line.length &&
+          String.fromCodePoint(line.codePointAt(i)!) === PLACEHOLDER &&
+          placed + count < item.cols
+        ) {
+          count++;
+          i += PLACEHOLDER.length;
+        }
+        if (placed === 0) transmit(item.id, item.cols);
+        out += inlinePlaceholder(item.id, count, placed);
+        placed += count;
+        if (placed >= item.cols) {
+          k++;
+          placed = 0;
+        }
+      } else {
+        out += ch;
+        i += ch.length;
+      }
+    }
+    return out;
+  });
+}

package/examples/extensions/ashi/src/renderers/pi-tui/nodes.ts

@@ -14,6 +14,14 @@ import {
 } from "@earendil-works/pi-tui";
 import { theme } from "../../theme.js";
 import { markdownTheme } from "./theme-adapters.js";
+import {
+  emitInlineImage,
+  inlineCols,
+  paintInlineImages,
+  PLACEHOLDER,
+  SENTINEL_RE,
+  type InlineItem,
+} from "./inline-image.js";
 import type {
   ContainerView,
   MarkdownOptions,
@@ -118,6 +126,48 @@ class ZonedMarkdown extends Markdown {
   }
 }
 
+// Each sentinel becomes a bare run of `cols` placeholder cells so the wrapper
+// reserves the right width; render() later paints the image into that run.
+// Exported for tests: with no sentinels (latex-images off / non-kitty terminal,
+// where the sentinel producer never runs) this is a pass-through.
+export function reserveSentinels(full: string): { display: string; items: InlineItem[] } {
+  const items: InlineItem[] = [];
+  const display = full.replace(SENTINEL_RE, (_m, idStr) => {
+    const cols = inlineCols(Number(idStr));
+    if (cols === null) return "";
+    items.push({ id: Number(idStr), cols });
+    return PLACEHOLDER.repeat(cols);
+  });
+  return { display, items };
+}
+
+function injectInlineImages(lines: string[], items: InlineItem[]): string[] {
+  const write = (s: string): boolean => process.stdout.write(s);
+  return paintInlineImages(lines, items, (id, cols) => emitInlineImage(id, cols, write));
+}
+
+type MarkdownCtor = new (...args: ConstructorParameters<typeof Markdown>) => Markdown;
+
+// Subclass that flows inline images where the text carries sentinels; a no-op
+// superset of the base when none are present.
+function withInlineImages<T extends MarkdownCtor>(Base: T): T {
+  class InlineImageMarkdown extends (Base as MarkdownCtor) {
+    private inlineItems: InlineItem[] = [];
+    override setText(full: string): void {
+      const { display, items } = reserveSentinels(full);
+      this.inlineItems = items;
+      super.setText(display);
+    }
+    override render(width: number): string[] {
+      return injectInlineImages(super.render(width), this.inlineItems);
+    }
+  }
+  return InlineImageMarkdown as unknown as T;
+}
+
+const InlineMarkdown = withInlineImages(Markdown);
+const InlineZonedMarkdown = withInlineImages(ZonedMarkdown);
+
 class FooterSlot extends Container {
   constructor(private readonly hasContentAbove: () => boolean) {
     super();
@@ -157,7 +207,7 @@ export function createNodes(opts: { imageScale?: number } = {}): RenderNodes {
         opts?.color || opts?.bgColor
           ? { ...(opts.color ? { color: opts.color } : {}), ...(opts.bgColor ? { bgColor: opts.bgColor } : {}) }
           : undefined;
-      const Ctor = opts?.osc133Zones ? ZonedMarkdown : Markdown;
+      const Ctor = opts?.osc133Zones ? InlineZonedMarkdown : InlineMarkdown;
       const md = new Ctor("", opts?.paddingX ?? 0, opts?.paddingY ?? 0, markdownTheme(), colorOpts);
       const view: MarkdownView = {
         node: asNode(md),

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

@@ -1,4 +1,5 @@
 import { theme } from "./theme.js";
+import { truncateToWidth } from "@earendil-works/pi-tui";
 import { highlight, supportsLanguage } from "cli-highlight";
 import type { ThemeColor } from "./theme.js";
 import type { ToolEntryConfig } from "./display-config.js";
@@ -188,6 +189,11 @@ export function renderBody(body: Body, env: Env, diff: DiffSlot): string {
 // The tail is capped even when expanded so a huge result can't flood scrollback; the agent still sees it all.
 const DEFAULT_EXPANDED_LINES = 200;
 
+function clampLines(lines: string[], width: number): string {
+  if (width <= 0) return lines.join("\n");
+  return lines.map((l) => truncateToWidth(l, width, "…")).join("\n");
+}
+
 function renderStream(buffer: string, env: Env): string {
   const display = buffer.replace(/\n+$/, "");
   if (env.expanded) {
@@ -205,14 +211,14 @@ function renderStream(buffer: string, env: Env): string {
   }
   if (env.mode === "summary") {
     if (!env.finalized) {
-      const tail = display.split("\n").slice(-2).join("\n");
+      const tail = clampLines(display.split("\n").slice(-2), env.width);
       return theme.fg("muted", tail);
     }
     return lineCountHint(buffer);
   }
   if (!display) return "";
   const lines = display.split("\n");
-  const trimmed = lines.slice(-env.previewLines).join("\n");
+  const trimmed = clampLines(lines.slice(-env.previewLines), env.width);
   const remaining = Math.max(0, lines.length - env.previewLines);
   // The preview is the tail, so the hidden lines come before it — note goes above.
   const overflow = remaining > 0

package/examples/extensions/ashi/src/user-shell-intents.ts

@@ -1,7 +1,10 @@
 /** Pending intents for ashi-issued shell pty-writes. shell:command-start fires
- *  for any OSC 9997 — orphans (bash DEBUG-trap noise) are dropped on consume. */
+ *  for any OSC 9997 — orphans (bash DEBUG-trap noise) are dropped on consume.
+ *  Carries the command ashi sent so the rendered label is the exact text we
+ *  wrote to the pty, not whatever the shell echoes back. */
 export interface UserShellIntent {
   private: boolean;
+  command: string;
 }
 
 export class UserShellIntents {

package/examples/extensions/command-suggest.ts

@@ -15,6 +15,10 @@ import type { ExtensionContext } from "agent-sh/types";
 
 export default function activate(ctx: ExtensionContext): void {
   const { bus } = ctx;
+
+  // No shell to deliver to (e.g. ashi) — the suggestion would go nowhere.
+  if (!ctx.shell) return;
+
   let pendingCommand: string | null = null;
 
   // ── Tool ────────────────────────────────────────────────────────

package/examples/extensions/latex-images.ts

@@ -22,7 +22,10 @@ import * as path from "node:path";
 import type { ExtensionContext } from "agent-sh/types";
 
 // Settings loaded in activate() via ctx.getExtensionSettings
-let config = { dpi: 300, fgColor: "d4d4d4" };
+// inlineScale: inline math font vs ~1 em of text (1.0 ≈ text, <1 smaller).
+let config = { dpi: 300, fgColor: "d4d4d4", inlineScale: 1.0 };
+
+let magickBin: string | null = null;
 
 /** Encode PNG as iTerm2 or Kitty inline image escape sequence. */
 function encodeImage(data: Buffer): string {
@@ -56,6 +59,17 @@ $\\displaystyle ${equation}$
 \\end{document}
 `;
 
+// Inline equations: text-style (no \displaystyle) so sizing matches a text line.
+const LATEX_INLINE_TEMPLATE = (equation: string, fg: string) => `
+\\documentclass[border=1pt]{standalone}
+\\usepackage{amsmath,amssymb,amsfonts}
+\\usepackage{xcolor}
+\\begin{document}
+\\color[HTML]{${fg}}
+$ ${equation} $
+\\end{document}
+`;
+
 let tmpDir: string | null = null;
 let renderCounter = 0;
 
@@ -66,7 +80,10 @@ function ensureTmpDir(): string {
   return tmpDir;
 }
 
-function renderEquation(equation: string): Buffer | null {
+function renderEquation(
+  equation: string,
+  template: (eq: string, fg: string) => string,
+): Buffer | null {
   const dir = ensureTmpDir();
   const idx = renderCounter++;
   const texPath = path.join(dir, `eq${idx}.tex`);
@@ -74,7 +91,7 @@ function renderEquation(equation: string): Buffer | null {
   const pngPath = path.join(dir, `eq${idx}.png`);
 
   try {
-    fs.writeFileSync(texPath, LATEX_TEMPLATE(equation, config.fgColor));
+    fs.writeFileSync(texPath, template(equation, config.fgColor));
 
     execSync(
       `latex -interaction=nonstopmode -output-directory="${dir}" "${texPath}"`,
@@ -98,10 +115,50 @@ function renderEquation(equation: string): Buffer | null {
 
 const equationCache = new Map<string, Buffer | null>();
 function renderEquationCached(equation: string): Buffer | null {
-  if (!equationCache.has(equation)) {
-    equationCache.set(equation, renderEquation(equation));
+  const key = `d:${equation}`;
+  if (!equationCache.has(key)) {
+    equationCache.set(key, renderEquation(equation, LATEX_TEMPLATE));
+  }
+  return equationCache.get(key) ?? null;
+}
+
+// 1 TeX pt = 1/72.27 inch; standalone's default body font is 10pt.
+const PT_PER_INCH = 72.27;
+
+// Pad each equation's height up to a shared ~1 em reference (transparent, centered)
+// so short and tall expressions render at the same font — only their heights differ.
+// Cols are derived downstream from this padded height. No-op for already-tall content.
+function normalizeInlineHeight(buf: Buffer): Buffer {
+  if (!magickBin) return buf;
+  const w = buf.readUInt32BE(16);
+  const h = buf.readUInt32BE(20);
+  const emPx = (config.dpi * 10) / PT_PER_INCH;
+  const scale = config.inlineScale > 0 ? config.inlineScale : 1;
+  const targetH = Math.round(emPx / scale);
+  if (h >= targetH) return buf;
+  const dir = ensureTmpDir();
+  const idx = renderCounter++;
+  const inPath = path.join(dir, `pad${idx}-in.png`);
+  const outPath = path.join(dir, `pad${idx}-out.png`);
+  try {
+    fs.writeFileSync(inPath, buf);
+    execSync(
+      `${magickBin} "${inPath}" -background none -gravity center -extent ${w}x${targetH} "${outPath}"`,
+      { timeout: 10000, stdio: "pipe" },
+    );
+    return fs.readFileSync(outPath);
+  } catch {
+    return buf;
   }
-  return equationCache.get(equation) ?? null;
+}
+
+function renderInlineCached(equation: string): Buffer | null {
+  const key = `i:${equation}`;
+  if (!equationCache.has(key)) {
+    const png = renderEquation(equation, LATEX_INLINE_TEMPLATE);
+    equationCache.set(key, png ? normalizeInlineHeight(png) : null);
+  }
+  return equationCache.get(key) ?? null;
 }
 
 const EQ_DELIM = "$$";
@@ -132,6 +189,65 @@ function splitEquations(text: string): Block[] {
   return out;
 }
 
+// ── Inline math ($…$) ────────────────────────────────────────────
+
+// KaTeX-style `$…$` rules so prose/currency don't false-match: no space after the
+// opening `$`; no space before the closing `$` and no digit after it; one line; \$.
+export function matchInline(text: string, open: number): { eq: string; end: number } | null {
+  if (open + 1 >= text.length || /\s/.test(text[open + 1]!)) return null;
+  for (let j = open + 1; j < text.length; j++) {
+    const ch = text[j]!;
+    if (ch === "\n") return null;
+    if (ch === "\\") { j++; continue; }
+    if (ch !== "$") continue;
+    if (/\s/.test(text[j - 1]!)) continue;
+    if (/[0-9]/.test(text[j + 1] ?? "")) continue;
+    const eq = text.slice(open + 1, j);
+    return eq.trim() === "" ? null : { eq, end: j + 1 };
+  }
+  return null;
+}
+
+// Replace inline `$…$` with `\x01LI:<id>\x01` sentinels; leaves escapes and inline
+// code spans untouched, and falls back to literal text when register() returns null.
+export function replaceInline(text: string, register: (eq: string) => number | null): string {
+  let out = "";
+  let i = 0;
+  while (i < text.length) {
+    const c = text[i]!;
+    if (c === "\\") { out += text.slice(i, i + 2); i += 2; continue; }
+    if (c === "`") {
+      // Code span: a run of N backticks closes on the next run of exactly N.
+      // An unmatched opening run is a literal backtick — keep scanning after it.
+      let n = 1;
+      while (text[i + n] === "`") n++;
+      let j = i + n;
+      let close = -1;
+      while (j < text.length) {
+        if (text[j] === "`") {
+          let m = 1;
+          while (text[j + m] === "`") m++;
+          if (m === n) { close = j; break; }
+          j += m;
+        } else j++;
+      }
+      if (close === -1) { out += text.slice(i, i + n); i += n; continue; }
+      out += text.slice(i, close + n); i = close + n; continue;
+    }
+    if (c === "$" && text[i + 1] !== "$") {
+      const m = matchInline(text, i);
+      if (m) {
+        const id = register(m.eq);
+        out += id === null ? text.slice(i, m.end) : `\x01LI:${id}\x01`;
+        i = m.end;
+        continue;
+      }
+    }
+    out += c; i++;
+  }
+  return out;
+}
+
 // ── Extension entry point ────────────────────────────────────────
 
 export default function activate(ctx: ExtensionContext) {
@@ -151,6 +267,15 @@ export default function activate(ctx: ExtensionContext) {
     return;
   }
 
+  // ImageMagick is optional; only used to shrink inline glyphs (config.inlineScale).
+  for (const bin of ["magick", "convert"]) {
+    try {
+      execSync(`${bin} --version`, { stdio: "ignore", timeout: 3000 });
+      magickBin = bin;
+      break;
+    } catch { /* not installed */ }
+  }
+
   ctx.define("latex:render-equation", (equation: string): Buffer | null => renderEquationCached(equation));
 
   if (ctx.shell) {
@@ -172,14 +297,34 @@ export default function activate(ctx: ExtensionContext) {
       ctx.call("render:image", png);
     });
   } else {
+    // Cache the id per equation so each image is registered (and transmitted) once.
+    const inlineIds = new Map<string, number>();
+    const registerInline = (eq: string): number | null => {
+      const cached = inlineIds.get(eq);
+      if (cached !== undefined) return cached;
+      const png = renderInlineCached(eq);
+      if (!png) return null;
+      const id = ctx.call("ashi:inline-image:register", png) as number | null;
+      if (typeof id === "number") inlineIds.set(eq, id);
+      return typeof id === "number" ? id : null;
+    };
+
     (bus.onPipe as unknown as (e: string, fn: (p: ContentPipe) => ContentPipe) => void)(
       "render:assistant-content",
       (payload) => {
         // Can't show images reliably → leave $$…$$ as text.
         if (!payload.images) return payload;
+        const canInline = ctx.list().includes("ashi:inline-image:register");
         return {
           ...payload,
-          blocks: payload.blocks.flatMap((b) => (b.type === "text" ? splitEquations(b.text) : [b])),
+          blocks: payload.blocks.flatMap((b) => {
+            if (b.type !== "text") return [b];
+            return splitEquations(b.text).map((blk) =>
+              blk.type === "text" && canInline
+                ? { type: "text" as const, text: replaceInline(blk.text, registerInline) }
+                : blk,
+            );
+          }),
         };
       },
     );

package/examples/extensions/solarized-theme.ts

@@ -23,5 +23,16 @@ export default function activate(ctx: ShellContext) {
     errorBg:       "\x1b[48;2;42;30;30m",   // base03 with red tint
     successBgEmph: "\x1b[48;2;20;70;50m",   // stronger green tint
     errorBgEmph:   "\x1b[48;2;70;30;30m",   // stronger red tint
+
+    mdHeading:         "\x1b[38;2;181;137;0m",  // yellow (#b58900)
+    mdLink:            "\x1b[38;2;38;139;210m", // blue (#268bd2)
+    mdLinkUrl:         "\x1b[38;2;88;110;117m", // base01 (#586e75)
+    mdCode:            "\x1b[38;2;42;161;152m", // cyan (#2aa198)
+    mdCodeBlock:       "\x1b[38;2;133;153;0m",  // green (#859900)
+    mdCodeBlockBorder: "\x1b[38;2;88;110;117m", // base01 (#586e75)
+    mdQuote:           "\x1b[38;2;88;110;117m", // base01 (#586e75)
+    mdQuoteBorder:     "\x1b[38;2;88;110;117m", // base01 (#586e75)
+    mdHr:              "\x1b[38;2;88;110;117m", // base01 (#586e75)
+    mdListBullet:      "\x1b[38;2;38;139;210m", // blue (#268bd2)
   });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-sh",
-  "version": "0.15.6",
+  "version": "0.15.8",
   "description": "A composable agent runtime — pair any frontend with any agent backend over one shared extension layer",
   "type": "module",
   "workspaces": [