agent-sh 0.15.4 → 0.15.6

package/dist/agent/types.d.ts

@@ -49,7 +49,10 @@ export type ToolResultBody = {
     maxLines?: number;
 };
 export interface ToolDisplayInfo {
-    kind: "read" | "write" | "execute" | "search";
+    /** Verb shown next to the detail (e.g. "execute foo.py"). Omit when a custom
+     *  `icon` already makes the action self-evident — the renderer then shows
+     *  icon + detail with no verb. */
+    kind?: "read" | "write" | "execute" | "search";
     locations?: {
         path: string;
         line?: number | null;

package/dist/cli/shell-env.js

@@ -1,8 +1,48 @@
 import { spawn } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
 import { pickStrategy, FALLBACK_STRATEGY } from "../shell/strategies/index.js";
+import { CONFIG_DIR } from "../core/settings.js";
+const CACHE_FILE = path.join(CONFIG_DIR, "cache", "shell-env.json");
+function captureSignature(shell, strategy, captureCmd) {
+    const files = strategy.envCaptureFiles?.(process.env) ?? [];
+    const stamps = files.sort().map((f) => {
+        try {
+            return [f, fs.statSync(f).mtimeMs];
+        }
+        catch {
+            return [f, 0];
+        }
+    });
+    return JSON.stringify({ shell, captureCmd, stamps });
+}
+function readCachedEnv(sig) {
+    try {
+        const raw = JSON.parse(fs.readFileSync(CACHE_FILE, "utf-8"));
+        if (raw?.sig === sig && raw.env && typeof raw.env === "object")
+            return raw.env;
+    }
+    catch { }
+    return null;
+}
+function writeCachedEnv(sig, env) {
+    try {
+        fs.mkdirSync(path.dirname(CACHE_FILE), { recursive: true });
+        fs.writeFileSync(CACHE_FILE, JSON.stringify({ sig, env }));
+    }
+    catch { }
+}
 export async function captureShellEnvAsync(shell) {
     if (process.env.AGENT_SH_SKIP_SHELL_ENV)
         return {};
+    const strategy = pickStrategy(shell) ?? FALLBACK_STRATEGY;
+    const captureCmd = strategy.envCaptureCommand();
+    const sig = captureSignature(shell, strategy, captureCmd);
+    if (!process.env.AGENT_SH_SHELL_ENV_NOCACHE) {
+        const cached = readCachedEnv(sig);
+        if (cached)
+            return cached;
+    }
     return new Promise((resolve) => {
         let settled = false;
         const done = (result) => {
@@ -12,8 +52,6 @@ export async function captureShellEnvAsync(shell) {
             resolve(result);
         };
         try {
-            const strategy = pickStrategy(shell) ?? FALLBACK_STRATEGY;
-            const captureCmd = strategy.envCaptureCommand();
             const child = spawn(shell, ["-l", "-c", captureCmd], {
                 stdio: ["ignore", "pipe", "ignore"],
                 timeout: 5000,
@@ -34,6 +72,7 @@ export async function captureShellEnvAsync(shell) {
                     if (eq > 0)
                         env[entry.slice(0, eq)] = entry.slice(eq + 1);
                 }
+                writeCachedEnv(sig, env);
                 done(env);
             });
             child.on("error", () => {

package/dist/shell/strategies/bash.js

@@ -66,6 +66,12 @@ export const bashStrategy = {
     envCaptureCommand() {
         return "[ -f ~/.bashrc ] && source ~/.bashrc 2>/dev/null; env -0";
     },
+    envCaptureFiles(env) {
+        const home = env.HOME;
+        if (!home)
+            return [];
+        return [".bashrc", ".bash_profile", ".bash_login", ".profile"].map((f) => path.join(home, f));
+    },
     redrawEscape() {
         return "\x1b[9999~";
     },

package/dist/shell/strategies/fish.js

@@ -59,6 +59,12 @@ export const fishStrategy = {
         // `fish -l` already sources config.fish + conf.d, so no explicit source.
         return "env -0";
     },
+    envCaptureFiles(env) {
+        const config = env.XDG_CONFIG_HOME || (env.HOME ? path.join(env.HOME, ".config") : undefined);
+        if (!config)
+            return [];
+        return [path.join(config, "fish", "config.fish"), path.join(config, "fish", "conf.d")];
+    },
     redrawEscape() {
         return "\x1b[57400u";
     },

package/dist/shell/strategies/types.d.ts

@@ -41,6 +41,7 @@ export interface ShellStrategy {
      * config and dump env. Used at startup to inherit shell-only env vars.
      */
     envCaptureCommand(): string;
+    envCaptureFiles?(env: Record<string, string | undefined>): string[];
     /**
      * Escape sequence to write to the PTY to ask the shell to repaint its
      * prompt in place. The corresponding binding is set up in prepareSpawn.

package/dist/shell/strategies/zsh.js

@@ -66,6 +66,12 @@ export const zshStrategy = {
     envCaptureCommand() {
         return "source ~/.zshrc 2>/dev/null; env -0";
     },
+    envCaptureFiles(env) {
+        const zdot = env.ZDOTDIR || env.HOME;
+        if (!zdot)
+            return [];
+        return [".zshenv", ".zprofile", ".zshrc", ".zlogin"].map((f) => path.join(zdot, f));
+    },
     redrawEscape() {
         return "\x1b[9999~";
     },

package/dist/shell/tui-renderer.js

@@ -644,6 +644,7 @@ export default function activate(ctx) {
             filePath,
             maxLines,
             trueColor: true,
+            gutterLine: false,
         });
         const body = diffLines.length > 1 ? ["", ...diffLines.slice(1), ""] : diffLines;
         return renderBoxFrame(body, {

package/dist/utils/diff-renderer.js

@@ -8,6 +8,7 @@
 import { highlight } from "cli-highlight";
 import { visibleLen, charWidth } from "./ansi.js";
 import { palette as p } from "./palette.js";
+import { wrapLine } from "./markdown.js";
 // ── Constants ────────────────────────────────────────────────────
 const SPLIT_MIN_WIDTH = 120;
 const UNIFIED_MIN_WIDTH = 40;
@@ -102,6 +103,42 @@ function tokenLcs(a, b) {
     }
     return { oldMatch, newMatch };
 }
+/**
+ * Anchors the shared prefix/suffix as unchanged and runs the O(m·n) LCS only on
+ * the differing middle. Null when that middle exceeds maxProduct.
+ */
+function inlineMatches(a, b, maxProduct) {
+    const m = a.length;
+    const n = b.length;
+    let pre = 0;
+    while (pre < m && pre < n && a[pre].text === b[pre].text)
+        pre++;
+    let suf = 0;
+    while (suf < m - pre && suf < n - pre && a[m - 1 - suf].text === b[n - 1 - suf].text)
+        suf++;
+    const midM = m - pre - suf;
+    const midN = n - pre - suf;
+    if (midM * midN > maxProduct)
+        return null;
+    const oldMatch = new Array(m).fill(false);
+    const newMatch = new Array(n).fill(false);
+    for (let i = 0; i < pre; i++) {
+        oldMatch[i] = true;
+        newMatch[i] = true;
+    }
+    for (let i = 0; i < suf; i++) {
+        oldMatch[m - 1 - i] = true;
+        newMatch[n - 1 - i] = true;
+    }
+    if (midM > 0 && midN > 0) {
+        const mid = tokenLcs(a.slice(pre, m - suf), b.slice(pre, n - suf));
+        for (let i = 0; i < midM; i++)
+            oldMatch[pre + i] = mid.oldMatch[i];
+        for (let j = 0; j < midN; j++)
+            newMatch[pre + j] = mid.newMatch[j];
+    }
+    return { oldMatch, newMatch };
+}
 /**
  * Rewrite full ANSI resets (\x1b[0m) to foreground-only resets,
  * preserving the given background color across the line.
@@ -139,14 +176,14 @@ function highlightInlineChanges(oldLine, newLine, oldPalette, newPalette, useTru
             new: language ? highlightLine(newLine, language) : newLine,
         };
     }
-    // Safety guard: skip if LCS matrix would be too large
-    if (oldTokens.length * newTokens.length > 50000) {
+    const matches = inlineMatches(oldTokens, newTokens, 1_000_000);
+    if (!matches) {
         return {
             old: language ? highlightLine(oldLine, language) : oldLine,
             new: language ? highlightLine(newLine, language) : newLine,
         };
     }
-    const { oldMatch, newMatch } = tokenLcs(oldTokens, newTokens);
+    const { oldMatch, newMatch } = matches;
     const buildHighlighted = (tokens, matched, palette) => {
         let result = "";
         for (let i = 0; i < tokens.length; i++) {
@@ -248,13 +285,19 @@ function renderUnifiedHunk(hunk, layout) {
     const pairs = findChangePairs(hunk);
     const bgWidth = Math.max(1, textWidth - noW - 3);
     const gutter = (n) => `${p.dim}${n} │${p.reset} `;
+    const continuationNo = " ".repeat(noW);
+    // Wrapped rows after the first blank the line number and sigil.
     const change = (no, sigil, bg, fg, text) => {
-        if (!gutterLine) {
-            return `${bg}${padToWidth(`${fg}${no} ${sigil}${p.diffText} ${preserveBg(text, bg)}`, textWidth)}${p.reset}`;
-        }
-        if (useTrueColor)
-            return gutter(no) + padToWidth(`${bg}${fg}${sigil}${p.diffText} ${preserveBg(text, bg)}`, bgWidth) + p.reset;
-        return `${gutter(no)}${fg}${sigil} ${text}${p.reset}`;
+        return wrapLine(text, lineTextW).map((seg, r) => {
+            const n = r === 0 ? no : continuationNo;
+            const sg = r === 0 ? sigil : " ";
+            if (!gutterLine) {
+                return `${bg}${padToWidth(`${fg}${n} ${sg}${p.diffText} ${preserveBg(seg, bg)}`, textWidth)}${p.reset}`;
+            }
+            if (useTrueColor)
+                return gutter(n) + padToWidth(`${bg}${fg}${sg}${p.diffText} ${preserveBg(seg, bg)}`, bgWidth) + p.reset;
+            return `${gutter(n)}${fg}${sg} ${seg}${p.reset}`;
+        });
     };
     const hlCache = new Map();
     const highlightedPair = (pair) => {
@@ -269,33 +312,25 @@ function renderUnifiedHunk(hunk, layout) {
         const line = hunk.lines[i];
         const no = String(line.type === "removed" ? (line.oldNo ?? "") : (line.newNo ?? line.oldNo ?? "")).padStart(noW);
         if (line.type === "context") {
-            const raw = truncateText(line.text, lineTextW);
-            const text = lang ? highlightLine(raw, lang) : raw;
-            out.push(!gutterLine ? `${p.dim}${no}${p.reset}   ${text}` : `${gutter(no)}  ${p.dim}${text}${p.reset}`);
+            const text = lang ? highlightLine(line.text, lang) : line.text;
+            wrapLine(text, lineTextW).forEach((seg, r) => {
+                const n = r === 0 ? no : continuationNo;
+                out.push(!gutterLine ? `${p.dim}${n}${p.reset}   ${seg}` : `${gutter(n)}  ${p.dim}${seg}${p.reset}`);
+            });
             continue;
         }
         const pair = pairs.get(i);
         if (line.type === "removed") {
-            let removedText;
-            if (pair) {
-                removedText = truncateText(highlightedPair(pair).old, lineTextW);
-            }
-            else {
-                const raw = truncateText(line.text, lineTextW);
-                removedText = lang ? highlightLine(raw, lang) : raw;
-            }
-            out.push(change(no, "-", p.errorBg, p.error, removedText));
+            const removedText = pair
+                ? highlightedPair(pair).old
+                : (lang ? highlightLine(line.text, lang) : line.text);
+            out.push(...change(no, "-", p.errorBg, p.error, removedText));
         }
         else {
-            let addedText;
-            if (pair) {
-                addedText = truncateText(highlightedPair(pair).new, lineTextW);
-            }
-            else {
-                const raw = truncateText(line.text, lineTextW);
-                addedText = lang ? highlightLine(raw, lang) : raw;
-            }
-            out.push(change(no, "+", p.successBg, p.success, addedText));
+            const addedText = pair
+                ? highlightedPair(pair).new
+                : (lang ? highlightLine(line.text, lang) : line.text);
+            out.push(...change(no, "+", p.successBg, p.success, addedText));
         }
     }
     return out;

package/dist/utils/markdown.js

@@ -78,6 +78,34 @@ export function wrapLine(text, maxWidth) {
         lineWidth = 0;
         lastVisibleIdx = -1;
     };
+    const hardBreak = (token) => {
+        let remaining = token;
+        while (remaining.length > 0) {
+            let fitLen = 0, fitWidth = 0;
+            for (const ch of remaining) {
+                const cw = charWidth(ch.codePointAt(0) ?? 0);
+                if (fitWidth + cw > maxWidth - lineWidth)
+                    break;
+                fitWidth += cw;
+                fitLen += ch.length;
+            }
+            if (fitLen === 0) {
+                // Force one char on an empty line so an over-wide char can't loop forever.
+                if (lineWidth > 0) {
+                    commit();
+                    continue;
+                }
+                fitLen = remaining[0]?.length ?? 1;
+            }
+            const chunk = remaining.slice(0, fitLen);
+            remaining = remaining.slice(fitLen);
+            lineTokens.push(chunk);
+            lineWidth += visibleLen(chunk);
+            lastVisibleIdx = lineTokens.length - 1;
+            if (remaining.length > 0)
+                commit();
+        }
+    };
     for (const seg of segments) {
         if (seg.startsWith("\x1b[")) {
             lineTokens.push(seg);
@@ -102,26 +130,7 @@ export function wrapLine(text, maxWidth) {
                 continue; // spaces at wrap points are dropped
             if (lineWidth === 0) {
                 // Token longer than the entire line — hard-break by char width.
-                let remaining = token;
-                while (remaining.length > 0) {
-                    let fitLen = 0, fitWidth = 0;
-                    for (const ch of remaining) {
-                        const cw = charWidth(ch.codePointAt(0) ?? 0);
-                        if (fitWidth + cw > maxWidth)
-                            break;
-                        fitWidth += cw;
-                        fitLen += ch.length;
-                    }
-                    if (fitLen === 0)
-                        fitLen = remaining[0]?.length ?? 1;
-                    const chunk = remaining.slice(0, fitLen);
-                    remaining = remaining.slice(fitLen);
-                    lineTokens.push(chunk);
-                    lineWidth += visibleLen(chunk);
-                    lastVisibleIdx = lineTokens.length - 1;
-                    if (remaining.length > 0)
-                        commit();
-                }
+                hardBreak(token);
                 continue;
             }
             // Rule (a): closing punctuation must not start a line. Allow up to 2
@@ -146,9 +155,14 @@ export function wrapLine(text, maxWidth) {
                 lineTokens.push(t);
                 lineWidth += visibleLen(t);
             }
-            lineTokens.push(token);
-            lineWidth += tokenWidth;
-            lastVisibleIdx = lineTokens.length - 1;
+            if (lineWidth + tokenWidth <= maxWidth) {
+                lineTokens.push(token);
+                lineWidth += tokenWidth;
+                lastVisibleIdx = lineTokens.length - 1;
+            }
+            else {
+                hardBreak(token);
+            }
         }
     }
     if (lineWidth > 0) {

package/examples/extensions/command-suggest.ts

@@ -0,0 +1,86 @@
+/**
+ * command-suggest extension
+ *
+ * Registers the suggest_command tool. When the agent calls it, the response
+ * finishes and the user drops to the shell prompt with the command pre-typed
+ * — no copy-paste, no mode toggle, just review and press Enter.
+ *
+ * Usage:
+ *   agent-sh -e ./examples/extensions/command-suggest.ts
+ *
+ *   # Or install permanently:
+ *   cp examples/extensions/command-suggest.ts ~/.agent-sh/extensions/
+ */
+import type { ExtensionContext } from "agent-sh/types";
+
+export default function activate(ctx: ExtensionContext): void {
+  const { bus } = ctx;
+  let pendingCommand: string | null = null;
+
+  // ── Tool ────────────────────────────────────────────────────────
+
+  ctx.agent?.registerTool({
+    name: "suggest_command",
+    description:
+      "Stage a shell command at the user's prompt. After this response " +
+      "completes, the command appears in their shell prompt (not inside " +
+      "agent-input mode), ready to edit or run with Enter. " +
+      "Only call this when the user is asking for a command to run, or otherwise " +
+      "signals they want one staged — e.g. \"give me the command to …\", " +
+      "\"what do I run to …\". Do NOT call it unprompted after a general question, " +
+      "an explanation, or any turn where no command was requested. " +
+      "Prefer it over telling the user to copy-paste a command. " +
+      "Only the most recent call matters. Call with an empty string to clear.",
+    input_schema: {
+      type: "object",
+      properties: {
+        command: {
+          type: "string",
+          description:
+            "The shell command to place in the user's prompt. " +
+            "Multi-line commands are collapsed to a single line.",
+        },
+      },
+      required: ["command"],
+    },
+    showOutput: true,
+
+    getDisplayInfo: () => ({ icon: "⏎" }),
+
+    formatCall: (args) => {
+      const cmd = (args.command as string).trim();
+      if (!cmd) return "(clear suggestion)";
+      return cmd.length > 60 ? cmd.slice(0, 57) + "..." : cmd;
+    },
+
+    async execute(args) {
+      const cmd = (args.command as string).trim();
+      if (!cmd) {
+        pendingCommand = null;
+        return { content: "Cleared pending command suggestion.", exitCode: 0, isError: false };
+      }
+      // Collapse newlines to spaces so the command stays on one readline buffer.
+      pendingCommand = cmd.replace(/\n/g, " ");
+      return {
+        content: `Will suggest at shell prompt: ${pendingCommand}`,
+        exitCode: 0,
+        isError: false,
+      };
+    },
+  });
+
+  // ── Injection hook ──────────────────────────────────────────────
+
+  // Replace the default handler — which re-enters agent-input mode when sticky —
+  // so a pending command lands at a fresh shell prompt instead. The "\n" leads
+  // the same PTY write so the new prompt appears before the command text fills it.
+  ctx.advise("shell:on-processing-redraw", (next) => {
+    if (pendingCommand) {
+      const cmd = pendingCommand;
+      pendingCommand = null;
+      bus.emit("shell:pty-write", { data: "\n" + cmd });
+    } else {
+      next();
+    }
+  });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-sh",
-  "version": "0.15.4",
+  "version": "0.15.6",
   "description": "A composable agent runtime — pair any frontend with any agent backend over one shared extension layer",
   "type": "module",
   "workspaces": [
@@ -73,6 +73,10 @@
       "types": "./dist/agent/types.d.ts",
       "default": "./dist/agent/types.js"
     },
+    "./skills": {
+      "types": "./dist/agent/skills.d.ts",
+      "default": "./dist/agent/skills.js"
+    },
     "./store": {
       "types": "./dist/agent/store.d.ts",
       "default": "./dist/agent/store.js"
@@ -109,10 +113,6 @@
       "types": "./dist/agent/token-budget.d.ts",
       "default": "./dist/agent/token-budget.js"
     },
-    "./agent/history-file": {
-      "types": "./dist/agent/history-file.d.ts",
-      "default": "./dist/agent/history-file.js"
-    },
     "./agent/nuclear-form": {
       "types": "./dist/agent/nuclear-form.d.ts",
       "default": "./dist/agent/nuclear-form.js"

package/src/agent/types.ts

@@ -54,7 +54,10 @@ export type ToolResultBody =
   | { kind: "lines"; lines: string[]; maxLines?: number }
 
 export interface ToolDisplayInfo {
-  kind: "read" | "write" | "execute" | "search";
+  /** Verb shown next to the detail (e.g. "execute foo.py"). Omit when a custom
+   *  `icon` already makes the action self-evident — the renderer then shows
+   *  icon + detail with no verb. */
+  kind?: "read" | "write" | "execute" | "search";
   locations?: { path: string; line?: number | null }[];
   /** Custom icon character for TUI display (e.g., "◆", "⌕"). When set, the TUI shows
    *  icon + detail only. When absent, the tool name is shown alongside the detail. */

package/src/cli/shell-env.ts

@@ -1,8 +1,50 @@
 import { spawn } from "node:child_process";
-import { pickStrategy, FALLBACK_STRATEGY } from "../shell/strategies/index.js";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { pickStrategy, FALLBACK_STRATEGY, type ShellStrategy } from "../shell/strategies/index.js";
+import { CONFIG_DIR } from "../core/settings.js";
+
+const CACHE_FILE = path.join(CONFIG_DIR, "cache", "shell-env.json");
+
+function captureSignature(shell: string, strategy: ShellStrategy, captureCmd: string): string {
+  const files = strategy.envCaptureFiles?.(process.env) ?? [];
+  const stamps = files.sort().map((f) => {
+    try {
+      return [f, fs.statSync(f).mtimeMs];
+    } catch {
+      return [f, 0];
+    }
+  });
+  return JSON.stringify({ shell, captureCmd, stamps });
+}
+
+function readCachedEnv(sig: string): Record<string, string> | null {
+  try {
+    const raw = JSON.parse(fs.readFileSync(CACHE_FILE, "utf-8"));
+    if (raw?.sig === sig && raw.env && typeof raw.env === "object") return raw.env;
+  } catch {}
+  return null;
+}
+
+function writeCachedEnv(sig: string, env: Record<string, string>): void {
+  try {
+    fs.mkdirSync(path.dirname(CACHE_FILE), { recursive: true });
+    fs.writeFileSync(CACHE_FILE, JSON.stringify({ sig, env }));
+  } catch {}
+}
 
 export async function captureShellEnvAsync(shell: string): Promise<Record<string, string>> {
   if (process.env.AGENT_SH_SKIP_SHELL_ENV) return {};
+
+  const strategy = pickStrategy(shell) ?? FALLBACK_STRATEGY;
+  const captureCmd = strategy.envCaptureCommand();
+  const sig = captureSignature(shell, strategy, captureCmd);
+
+  if (!process.env.AGENT_SH_SHELL_ENV_NOCACHE) {
+    const cached = readCachedEnv(sig);
+    if (cached) return cached;
+  }
+
   return new Promise((resolve) => {
     let settled = false;
     const done = (result: Record<string, string>): void => {
@@ -12,9 +54,6 @@ export async function captureShellEnvAsync(shell: string): Promise<Record<string
     };
 
     try {
-      const strategy = pickStrategy(shell) ?? FALLBACK_STRATEGY;
-      const captureCmd = strategy.envCaptureCommand();
-
       const child = spawn(shell, ["-l", "-c", captureCmd], {
         stdio: ["ignore", "pipe", "ignore"],
         timeout: 5000,
@@ -36,6 +75,7 @@ export async function captureShellEnvAsync(shell: string): Promise<Record<string
           const eq = entry.indexOf("=");
           if (eq > 0) env[entry.slice(0, eq)] = entry.slice(eq + 1);
         }
+        writeCachedEnv(sig, env);
         done(env);
       });
 

package/src/shell/strategies/bash.ts

@@ -77,6 +77,12 @@ export const bashStrategy: ShellStrategy = {
     return "[ -f ~/.bashrc ] && source ~/.bashrc 2>/dev/null; env -0";
   },
 
+  envCaptureFiles(env): string[] {
+    const home = env.HOME;
+    if (!home) return [];
+    return [".bashrc", ".bash_profile", ".bash_login", ".profile"].map((f) => path.join(home, f));
+  },
+
   redrawEscape(): string {
     return "\x1b[9999~";
   },

package/src/shell/strategies/fish.ts

@@ -71,6 +71,12 @@ export const fishStrategy: ShellStrategy = {
     return "env -0";
   },
 
+  envCaptureFiles(env): string[] {
+    const config = env.XDG_CONFIG_HOME || (env.HOME ? path.join(env.HOME, ".config") : undefined);
+    if (!config) return [];
+    return [path.join(config, "fish", "config.fish"), path.join(config, "fish", "conf.d")];
+  },
+
   redrawEscape(): string {
     return "\x1b[57400u";
   },

package/src/shell/strategies/types.ts

@@ -48,6 +48,8 @@ export interface ShellStrategy {
    */
   envCaptureCommand(): string;
 
+  envCaptureFiles?(env: Record<string, string | undefined>): string[];
+
   /**
    * Escape sequence to write to the PTY to ask the shell to repaint its
    * prompt in place. The corresponding binding is set up in prepareSpawn.

package/src/shell/strategies/zsh.ts

@@ -77,6 +77,12 @@ export const zshStrategy: ShellStrategy = {
     return "source ~/.zshrc 2>/dev/null; env -0";
   },
 
+  envCaptureFiles(env): string[] {
+    const zdot = env.ZDOTDIR || env.HOME;
+    if (!zdot) return [];
+    return [".zshenv", ".zprofile", ".zshrc", ".zlogin"].map((f) => path.join(zdot, f));
+  },
+
   redrawEscape(): string {
     return "\x1b[9999~";
   },

package/src/shell/tui-renderer.ts

@@ -731,6 +731,7 @@ export default function activate(ctx: ExtensionContext): void {
       filePath,
       maxLines,
       trueColor: true,
+      gutterLine: false,
     });
     const body = diffLines.length > 1 ? ["", ...diffLines.slice(1), ""] : diffLines;
 

package/src/utils/diff-renderer.ts

@@ -140,6 +140,39 @@ function tokenLcs(
   return { oldMatch, newMatch };
 }
 
+/**
+ * Anchors the shared prefix/suffix as unchanged and runs the O(m·n) LCS only on
+ * the differing middle. Null when that middle exceeds maxProduct.
+ */
+function inlineMatches(
+  a: Token[],
+  b: Token[],
+  maxProduct: number,
+): { oldMatch: boolean[]; newMatch: boolean[] } | null {
+  const m = a.length;
+  const n = b.length;
+  let pre = 0;
+  while (pre < m && pre < n && a[pre].text === b[pre].text) pre++;
+  let suf = 0;
+  while (suf < m - pre && suf < n - pre && a[m - 1 - suf].text === b[n - 1 - suf].text) suf++;
+
+  const midM = m - pre - suf;
+  const midN = n - pre - suf;
+  if (midM * midN > maxProduct) return null;
+
+  const oldMatch = new Array<boolean>(m).fill(false);
+  const newMatch = new Array<boolean>(n).fill(false);
+  for (let i = 0; i < pre; i++) { oldMatch[i] = true; newMatch[i] = true; }
+  for (let i = 0; i < suf; i++) { oldMatch[m - 1 - i] = true; newMatch[n - 1 - i] = true; }
+
+  if (midM > 0 && midN > 0) {
+    const mid = tokenLcs(a.slice(pre, m - suf), b.slice(pre, n - suf));
+    for (let i = 0; i < midM; i++) oldMatch[pre + i] = mid.oldMatch[i];
+    for (let j = 0; j < midN; j++) newMatch[pre + j] = mid.newMatch[j];
+  }
+  return { oldMatch, newMatch };
+}
+
 /**
  * Rewrite full ANSI resets (\x1b[0m) to foreground-only resets,
  * preserving the given background color across the line.
@@ -193,15 +226,14 @@ function highlightInlineChanges(
     };
   }
 
-  // Safety guard: skip if LCS matrix would be too large
-  if (oldTokens.length * newTokens.length > 50000) {
+  const matches = inlineMatches(oldTokens, newTokens, 1_000_000);
+  if (!matches) {
     return {
       old: language ? highlightLine(oldLine, language) : oldLine,
       new: language ? highlightLine(newLine, language) : newLine,
     };
   }
-
-  const { oldMatch, newMatch } = tokenLcs(oldTokens, newTokens);
+  const { oldMatch, newMatch } = matches;
 
   const buildHighlighted = (
     tokens: Token[],
@@ -340,12 +372,19 @@ function renderUnifiedHunk(hunk: DiffHunk, layout: UnifiedLayout): string[] {
   const bgWidth = Math.max(1, textWidth - noW - 3);
   const gutter = (n: string): string => `${p.dim}${n} │${p.reset} `;
 
-  const change = (no: string, sigil: string, bg: string, fg: string, text: string): string => {
-    if (!gutterLine) {
-      return `${bg}${padToWidth(`${fg}${no} ${sigil}${p.diffText} ${preserveBg(text, bg)}`, textWidth)}${p.reset}`;
-    }
-    if (useTrueColor) return gutter(no) + padToWidth(`${bg}${fg}${sigil}${p.diffText} ${preserveBg(text, bg)}`, bgWidth) + p.reset;
-    return `${gutter(no)}${fg}${sigil} ${text}${p.reset}`;
+  const continuationNo = " ".repeat(noW);
+
+  // Wrapped rows after the first blank the line number and sigil.
+  const change = (no: string, sigil: string, bg: string, fg: string, text: string): string[] => {
+    return wrapLine(text, lineTextW).map((seg, r) => {
+      const n = r === 0 ? no : continuationNo;
+      const sg = r === 0 ? sigil : " ";
+      if (!gutterLine) {
+        return `${bg}${padToWidth(`${fg}${n} ${sg}${p.diffText} ${preserveBg(seg, bg)}`, textWidth)}${p.reset}`;
+      }
+      if (useTrueColor) return gutter(n) + padToWidth(`${bg}${fg}${sg}${p.diffText} ${preserveBg(seg, bg)}`, bgWidth) + p.reset;
+      return `${gutter(n)}${fg}${sg} ${seg}${p.reset}`;
+    });
   };
 
   const hlCache = new Map<ChangePair, { old: string; new: string }>();
@@ -367,31 +406,25 @@ function renderUnifiedHunk(hunk: DiffHunk, layout: UnifiedLayout): string[] {
     ).padStart(noW);
 
     if (line.type === "context") {
-      const raw = truncateText(line.text, lineTextW);
-      const text = lang ? highlightLine(raw, lang) : raw;
-      out.push(!gutterLine ? `${p.dim}${no}${p.reset}   ${text}` : `${gutter(no)}  ${p.dim}${text}${p.reset}`);
+      const text = lang ? highlightLine(line.text, lang) : line.text;
+      wrapLine(text, lineTextW).forEach((seg, r) => {
+        const n = r === 0 ? no : continuationNo;
+        out.push(!gutterLine ? `${p.dim}${n}${p.reset}   ${seg}` : `${gutter(n)}  ${p.dim}${seg}${p.reset}`);
+      });
       continue;
     }
 
     const pair = pairs.get(i);
     if (line.type === "removed") {
-      let removedText: string;
-      if (pair) {
-        removedText = truncateText(highlightedPair(pair).old, lineTextW);
-      } else {
-        const raw = truncateText(line.text, lineTextW);
-        removedText = lang ? highlightLine(raw, lang) : raw;
-      }
-      out.push(change(no, "-", p.errorBg, p.error, removedText));
+      const removedText = pair
+        ? highlightedPair(pair).old
+        : (lang ? highlightLine(line.text, lang) : line.text);
+      out.push(...change(no, "-", p.errorBg, p.error, removedText));
     } else {
-      let addedText: string;
-      if (pair) {
-        addedText = truncateText(highlightedPair(pair).new, lineTextW);
-      } else {
-        const raw = truncateText(line.text, lineTextW);
-        addedText = lang ? highlightLine(raw, lang) : raw;
-      }
-      out.push(change(no, "+", p.successBg, p.success, addedText));
+      const addedText = pair
+        ? highlightedPair(pair).new
+        : (lang ? highlightLine(line.text, lang) : line.text);
+      out.push(...change(no, "+", p.successBg, p.success, addedText));
     }
   }
   return out;

package/src/utils/markdown.ts

@@ -79,6 +79,30 @@ export function wrapLine(text: string, maxWidth: number): string[] {
     lastVisibleIdx = -1;
   };
 
+  const hardBreak = (token: string): void => {
+    let remaining = token;
+    while (remaining.length > 0) {
+      let fitLen = 0, fitWidth = 0;
+      for (const ch of remaining) {
+        const cw = charWidth(ch.codePointAt(0) ?? 0);
+        if (fitWidth + cw > maxWidth - lineWidth) break;
+        fitWidth += cw;
+        fitLen += ch.length;
+      }
+      if (fitLen === 0) {
+        // Force one char on an empty line so an over-wide char can't loop forever.
+        if (lineWidth > 0) { commit(); continue; }
+        fitLen = remaining[0]?.length ?? 1;
+      }
+      const chunk = remaining.slice(0, fitLen);
+      remaining = remaining.slice(fitLen);
+      lineTokens.push(chunk);
+      lineWidth += visibleLen(chunk);
+      lastVisibleIdx = lineTokens.length - 1;
+      if (remaining.length > 0) commit();
+    }
+  };
+
   for (const seg of segments) {
     if (seg.startsWith("\x1b[")) {
       lineTokens.push(seg);
@@ -103,23 +127,7 @@ export function wrapLine(text: string, maxWidth: number): string[] {
 
       if (lineWidth === 0) {
         // Token longer than the entire line — hard-break by char width.
-        let remaining = token;
-        while (remaining.length > 0) {
-          let fitLen = 0, fitWidth = 0;
-          for (const ch of remaining) {
-            const cw = charWidth(ch.codePointAt(0) ?? 0);
-            if (fitWidth + cw > maxWidth) break;
-            fitWidth += cw;
-            fitLen += ch.length;
-          }
-          if (fitLen === 0) fitLen = remaining[0]?.length ?? 1;
-          const chunk = remaining.slice(0, fitLen);
-          remaining = remaining.slice(fitLen);
-          lineTokens.push(chunk);
-          lineWidth += visibleLen(chunk);
-          lastVisibleIdx = lineTokens.length - 1;
-          if (remaining.length > 0) commit();
-        }
+        hardBreak(token);
         continue;
       }
 
@@ -147,9 +155,13 @@ export function wrapLine(text: string, maxWidth: number): string[] {
         lineTokens.push(t);
         lineWidth += visibleLen(t);
       }
-      lineTokens.push(token);
-      lineWidth += tokenWidth;
-      lastVisibleIdx = lineTokens.length - 1;
+      if (lineWidth + tokenWidth <= maxWidth) {
+        lineTokens.push(token);
+        lineWidth += tokenWidth;
+        lastVisibleIdx = lineTokens.length - 1;
+      } else {
+        hardBreak(token);
+      }
     }
   }