agent-sh 0.15.7 → 0.15.9

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/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/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/package.json

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

package/src/agent/agent-loop.ts

@@ -462,6 +462,17 @@ export class AgentLoop implements AgentBackend {
   }
 
 
+  /** Resume-stable conversation id from the frontend (e.g. ashi); undefined
+   *  when the frontend tracks no session. */
+  private currentSessionId(): string | undefined {
+    try {
+      const id = this.handlers.call("session:current-id");
+      return typeof id === "string" && id ? id : undefined;
+    } catch {
+      return undefined;
+    }
+  }
+
   private resolveEndpoint(m: Model): ModelEndpoint | undefined {
     try {
       return this.handlers.call("agent:resolve-endpoint", { provider: m.provider, id: m.id }) as ModelEndpoint | undefined;
@@ -1439,7 +1450,12 @@ export class AgentLoop implements AgentBackend {
     };
     this.bus.emit("llm:request", requestParams);
 
-    const stream = await this.llmClient.stream({ ...requestParams, signal });
+    const headers = this.activeEndpoint?.buildRequestHeaders?.({ sessionId: this.currentSessionId() });
+    const stream = await this.llmClient.stream({
+      ...requestParams,
+      signal,
+      ...(headers && Object.keys(headers).length ? { headers } : {}),
+    });
 
     try {
     for await (const chunk of stream) {

package/src/agent/events.ts

@@ -22,6 +22,7 @@ declare module "../core/event-bus.js" {
       id: string;
       reasoningParams?: (level: string, model?: string) => Record<string, unknown>;
       cacheTokens?: (usage: Record<string, unknown>) => number | undefined;
+      requestHeaders?: (info: { sessionId?: string }) => Record<string, string>;
     };
 
     "agent:models-changed": Record<string, never>;

package/src/agent/host-types.ts

@@ -93,6 +93,7 @@ export interface ModelEndpoint {
   baseURL?: string;
   buildReasoningParams?: (level: string) => Record<string, unknown>;
   extractCachedTokens?: (usage: Record<string, unknown>) => number | undefined;
+  buildRequestHeaders?: (info: { sessionId?: string }) => Record<string, string>;
 }
 
 // ── Agent-host extension surface ─────────────────────────────────
@@ -111,6 +112,7 @@ export interface AgentSurface {
     configure: (id: string, opts: {
       reasoningParams?: (level: string, model?: string) => Record<string, unknown>;
       cacheTokens?: (usage: Record<string, unknown>) => number | undefined;
+      requestHeaders?: (info: { sessionId?: string }) => Record<string, string>;
     }) => void;
   };
 

package/src/agent/index.ts

@@ -128,6 +128,7 @@ export default function agentBackend(ctx: ExtensionContext): void {
   const providerHooks = new Map<string, {
     reasoningParams?: (level: string, model?: string) => Record<string, unknown>;
     cacheTokens?: (usage: Record<string, unknown>) => number | undefined;
+    requestHeaders?: (info: { sessionId?: string }) => Record<string, string>;
   }>();
 
   // Bakes model id so ModelEndpoint.buildReasoningParams keeps its (level) signature.
@@ -139,6 +140,9 @@ export default function agentBackend(ctx: ExtensionContext): void {
   const bindCacheTokens = (shapeId: string) =>
     providerHooks.get(shapeId)?.cacheTokens ?? defaultCacheTokens;
 
+  const bindRequestHeaders = (shapeId: string) =>
+    providerHooks.get(shapeId)?.requestHeaders;
+
   const agentSurface: AgentSurface = {
     llm: createLlmFacade({ list: ctx.list, call: ctx.call }),
     providers: {
@@ -345,6 +349,7 @@ export default function agentBackend(ctx: ExtensionContext): void {
       baseURL: p.baseURL,
       buildReasoningParams: bindReasoning(shapeId, modelId),
       extractCachedTokens: bindCacheTokens(shapeId),
+      buildRequestHeaders: bindRequestHeaders(shapeId),
     };
   };
 
@@ -388,10 +393,11 @@ export default function agentBackend(ctx: ExtensionContext): void {
     }
   });
 
-  bus.on("provider:configure", ({ id, reasoningParams, cacheTokens }) => {
+  bus.on("provider:configure", ({ id, reasoningParams, cacheTokens, requestHeaders }) => {
     const prev = providerHooks.get(id) ?? {};
     if (reasoningParams !== undefined) prev.reasoningParams = reasoningParams;
     if (cacheTokens !== undefined) prev.cacheTokens = cacheTokens;
+    if (requestHeaders !== undefined) prev.requestHeaders = requestHeaders;
     providerHooks.set(id, prev);
   });
 

package/src/agent/llm-client.ts

@@ -68,7 +68,7 @@ export class LlmClient {
   }
 
   stream(opts: StreamOpts) {
-    const { signal, messages, tools, model, max_tokens, ...rest } = opts;
+    const { signal, headers, messages, tools, model, max_tokens, ...rest } = opts;
     const body = {
       ...rest,
       model: model ?? this.model,
@@ -78,7 +78,7 @@ export class LlmClient {
       stream: true as const,
       stream_options: { include_usage: true },
     };
-    return this.client.chat.completions.create(body as ChatCompletionCreateParamsStreaming, { signal });
+    return this.client.chat.completions.create(body as ChatCompletionCreateParamsStreaming, { signal, headers });
   }
 
   async complete(opts: CompleteOpts): Promise<string> {
@@ -102,6 +102,8 @@ export type StreamOpts = {
   model?: string;
   max_tokens?: number;
   signal?: AbortSignal;
+  /** Per-request transport headers, forwarded to the SDK (not request body). */
+  headers?: Record<string, string>;
 } & Record<string, unknown>;
 
 export type CompleteOpts = {

package/src/agent/providers/openrouter.ts

@@ -42,7 +42,16 @@ function toModalities(input?: string[]): ("text" | "image")[] | undefined {
 
 export default function activate(ctx: AgentContext): void {
   const apiKey = resolveApiKey("openrouter").key;
-  ctx.agent.providers.configure("openrouter", { reasoningParams: buildReasoningParams });
+  ctx.agent.providers.configure("openrouter", {
+    reasoningParams: buildReasoningParams,
+    // x-session-id pins sticky provider routing across turns so prompt caches
+    // stay warm even when compaction rewrites the opening messages.
+    requestHeaders: ({ sessionId }) => {
+      const headers: Record<string, string> = {};
+      if (sessionId) headers["x-session-id"] = sessionId;
+      return headers;
+    },
+  });
   ctx.agent.providers.register({
     id: "openrouter",
     apiKey: apiKey ?? undefined,

package/src/shell/input-handler.ts

@@ -88,7 +88,8 @@ export class InputHandler {
   private loadHistory(): void {
     try {
       const data = fs.readFileSync(HISTORY_FILE, "utf-8");
-      this.history = data.split("\n").filter(Boolean);
+      this.history = data.split("\n").filter(Boolean)
+        .map((l) => l.replace(/\\([\\n])/g, (_, c: string) => c === "n" ? "\n" : "\\"));
     } catch {
     }
   }
@@ -97,7 +98,8 @@ export class InputHandler {
     try {
       const { historySize } = getSettings();
       fs.mkdirSync(path.dirname(HISTORY_FILE), { recursive: true });
-      const lines = this.history.slice(-historySize);
+      const lines = this.history.slice(-historySize)
+        .map((l) => l.replace(/\\/g, "\\\\").replace(/\n/g, "\\n"));
       fs.writeFileSync(HISTORY_FILE, lines.join("\n") + "\n");
     } catch {
     }
@@ -392,7 +394,7 @@ export class InputHandler {
           this.editor.clear();
           this.view.resetCursor();
           this.dismissAutocomplete();
-          if (query && query.startsWith("/")) {
+          if (query && query.startsWith("/") && !query.includes("\n")) {
             const spaceIdx = query.indexOf(" ");
             const name = spaceIdx === -1 ? query : query.slice(0, spaceIdx);
             const args = spaceIdx === -1 ? "" : query.slice(spaceIdx + 1).trim();

package/src/shell/strategies/bash.ts

@@ -47,8 +47,16 @@ export const bashStrategy: ShellStrategy = {
       '  [[ $__agent_sh_preexec_ran == 1 ]] && return',
       '  [[ -n $COMP_LINE ]] && return',
       "  __agent_sh_preexec_ran=1",
-      "  local this_cmd",
-      `  this_cmd=$(HISTTIMEFORMAT='' builtin history 1 | command sed 's/^ *[0-9]* *//')`,
+      "  local this_cmd hist_cmd",
+      `  hist_cmd=$(HISTTIMEFORMAT='' builtin history 1 | command sed 's/^ *[0-9]* *//')`,
+      "  # history 1 carries the full typed line but goes stale when the user's",
+      "  # PROMPT_COMMAND reloads history (history -c/-r). Trust it only when it",
+      "  # matches the command bash is about to run; else use $BASH_COMMAND.",
+      '  if [[ -n $hist_cmd && $hist_cmd == "$BASH_COMMAND"* ]]; then',
+      "    this_cmd=$hist_cmd",
+      "  else",
+      "    this_cmd=$BASH_COMMAND",
+      "  fi",
       `  printf '\\e]9997;${instanceTag};%s\\a' "$this_cmd"`,
       "}",
       "trap '__agent_sh_emit_preexec' DEBUG",

package/src/shell/terminal.ts

@@ -7,6 +7,7 @@
  * factory wires it to process.stdin/stdout for the CLI; headless hosts
  * (multi-session web hubs, tests) supply their own.
  */
+import { StringDecoder } from "node:string_decoder";
 import type { RenderSurface } from "../utils/compositor.js";
 
 export interface Terminal {
@@ -23,40 +24,50 @@ export interface Terminal {
   suspendInput?(): { resume(): void };
 }
 
-/** Default Terminal: wraps process.stdin/stdout. */
-export function processTerminal(): Terminal {
+/** Default Terminal: wraps process.stdin/stdout (injectable for tests). */
+export function processTerminal(
+  stdin: NodeJS.ReadStream = process.stdin,
+  stdout: NodeJS.WriteStream = process.stdout,
+): Terminal {
   return {
     write(data) {
-      if (process.stdout.writable) {
-        try { process.stdout.write(data); } catch { /* ignore */ }
+      if (stdout.writable) {
+        try { stdout.write(data); } catch { /* ignore */ }
       }
     },
     onInput(cb) {
-      const handler = (b: Buffer) => cb(b.toString("utf-8"));
-      process.stdin.on("data", handler);
-      return () => { process.stdin.off("data", handler); };
+      // Stateful decode: tty chunk boundaries can land mid-way through a
+      // multibyte UTF-8 sequence (large pastes), so per-chunk toString()
+      // would emit U+FFFD for the torn halves.
+      const decoder = new StringDecoder("utf-8");
+      const handler = (b: Buffer) => {
+        const text = decoder.write(b);
+        if (text) cb(text);
+      };
+      stdin.on("data", handler);
+      return () => { stdin.off("data", handler); };
     },
     onResize(cb) {
-      const handler = () => cb(process.stdout.columns || 80, process.stdout.rows || 24);
-      process.stdout.on("resize", handler);
-      return () => { process.stdout.off("resize", handler); };
+      const handler = () => cb(stdout.columns || 80, stdout.rows || 24);
+      stdout.on("resize", handler);
+      return () => { stdout.off("resize", handler); };
     },
-    cols() { return process.stdout.columns || 80; },
-    rows() { return process.stdout.rows || 24; },
+    cols() { return stdout.columns || 80; },
+    rows() { return stdout.rows || 24; },
     suspendInput() {
-      const wasRaw = process.stdin.isTTY && (process.stdin as { isRaw?: boolean }).isRaw;
-      if (process.stdin.isTTY) {
+      const wasRaw = stdin.isTTY && (stdin as { isRaw?: boolean }).isRaw;
+      if (stdin.isTTY) {
         try {
-          process.stdin.setRawMode(false);
-          process.stdin.pause();
+          stdin.setRawMode(false);
+          stdin.pause();
         } catch { /* ignore */ }
       }
       return {
         resume() {
-          if (process.stdin.isTTY) {
+          if (stdin.isTTY) {
             try {
-              process.stdin.resume();
-              if (wasRaw) process.stdin.setRawMode(true);
+              stdin.resume();
+              if (wasRaw) stdin.setRawMode(true);
             } catch { /* ignore */ }
           }
         },

package/src/shell/tui-renderer.ts

@@ -939,7 +939,7 @@ export default function activate(ctx: ExtensionContext): void {
       ? getSettings().readOutputMaxLines
       : getSettings().maxCommandOutputLines;
     s.commandOutputBuffer += chunk;
-    const lines = s.commandOutputBuffer.split("\n");
+    const lines = s.commandOutputBuffer.split(/\r?\n/);
     s.commandOutputBuffer = lines.pop()!;
     for (const line of lines) {
       if (s.commandOutputLineCount < maxLines) {

package/src/utils/ansi.ts

@@ -138,3 +138,24 @@ export function padEndToWidth(str: string, targetWidth: number): string {
 export function stripAnsi(str: string): string {
   return stripAnsiPkg(str).replace(/\r/g, "");
 }
+
+/**
+ * Sanitize text for painting at a fixed screen position: SGR (color/style)
+ * passes through; anything else that would move the cursor or mutate
+ * terminal state mid-row is dropped. Tabs become a single space so painted
+ * width matches `stripAnsi`-based measurement.
+ */
+export function stripCursorControls(str: string): string {
+  // Park SGR behind NUL placeholders so the strips below can't eat their ESC bytes.
+  const sgr: string[] = [];
+  const cleaned = str
+    .replace(/\x00/g, "")
+    .replace(/\x1b\[[0-9;:]*m/g, (m) => { sgr.push(m); return "\x00"; })
+    .replace(/\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)?/g, "")
+    .replace(/\x1b\[[0-9;:?]*[ -/]*[@-~]/g, "")
+    .replace(/\x1b./g, "")
+    .replace(/\t/g, " ")
+    .replace(/[\x01-\x08\x0a-\x1f\x7f]/g, "");
+  let i = 0;
+  return cleaned.replace(/\x00/g, () => sgr[i++] ?? "");
+}

package/src/utils/floating-panel.ts

@@ -30,7 +30,7 @@
  * Usage from extensions:
  *   import { FloatingPanel } from "agent-sh/utils/floating-panel.js";
  */
-import { stripAnsi } from "./ansi.js";
+import { stripAnsi, stripCursorControls } from "./ansi.js";
 import { wrapLine } from "./markdown.js";
 import { LineEditor } from "./line-editor.js";
 import { TerminalBuffer } from "./terminal-buffer.js";
@@ -408,10 +408,11 @@ export class FloatingPanel {
 
     // Default row builder: truncate and pad
     this.handlers.define(`${p}:build-row`, (content: string, width: number): string => {
-      const plain = stripAnsi(content);
+      const clean = stripCursorControls(content);
+      const plain = stripAnsi(clean);
       const display = plain.length > width
-        ? content.slice(0, width - 1) + "\u2026"
-        : content;
+        ? clean.slice(0, width - 1) + "\u2026"
+        : clean;
       const pad = Math.max(0, width - stripAnsi(display).length);
       return display + " ".repeat(pad);
     });