agent-sh 0.10.1 → 0.10.2

package/README.md

@@ -4,6 +4,7 @@ An agent that lives in a shell — not a shell that lives in an agent.
 
 [![npm version](https://img.shields.io/npm/v/agent-sh.svg)](https://www.npmjs.com/package/agent-sh)
 [![license](https://img.shields.io/npm/l/agent-sh.svg)](https://github.com/guanyilun/agent-sh/blob/main/LICENSE)
+[![website](https://img.shields.io/badge/website-agent--sh.dev-blue)](https://agent-sh.dev)
 
 ![demo](assets/demo.gif)
 

package/dist/agent/agent-loop.js

@@ -280,6 +280,9 @@ export class AgentLoop {
             if (beforeTokens > this.peakConversationTokens) {
                 this.peakConversationTokens = beforeTokens;
             }
+            // The "File unchanged" stub assumes the prior read output is still
+            // in context; compaction can evict it. Clear so the next read re-emits.
+            this.fileReadCache.clear();
         });
         on("shell:cwd-change", ({ cwd }) => {
             const projectSkills = discoverProjectSkills(cwd);
@@ -1035,7 +1038,10 @@ export class AgentLoop {
             const contextWindow = this.currentMode.contextWindow ?? DEFAULT_CONTEXT_WINDOW;
             const threshold = Math.floor((contextWindow - RESPONSE_RESERVE) * getSettings().autoCompactThreshold);
             if (totalEstimate > threshold) {
-                const result = this.compactWithHooks(threshold);
+                // Compact deeply — shallow targets buy only 1–2 turns of runway on
+                // tool-heavy workloads.
+                const target = Math.floor(threshold * 0.25);
+                const result = this.compactWithHooks(target, 6);
                 if (!result) {
                     // Auto-compact fired but nothing was evictable. This can happen
                     // in short conversations with heavy tool output where the pin

package/dist/agent/nuclear-form.d.ts

@@ -43,6 +43,8 @@ export declare function createSessionMarker(iid: string, seq?: number): NuclearE
 export declare function isSessionMarker(entry: NuclearEntry): boolean;
 /** Read-only tools whose results are dropped at Tier 1→2 (agent can re-read). */
 export declare const READ_ONLY_TOOLS: Set<string>;
+export declare function registerReadOnlyTool(name: string): void;
+export declare function unregisterReadOnlyTool(name: string): void;
 /** State-changing tools whose summaries are kept in nuclear memory. */
 export declare const WRITE_TOOLS: Set<string>;
 /**

package/dist/agent/nuclear-form.js

@@ -15,6 +15,14 @@ export function isSessionMarker(entry) {
 export const READ_ONLY_TOOLS = new Set([
     "read_file", "grep", "glob", "ls", "search",
 ]);
+/** Extensions opt their tools in via ToolRegistry.register when readOnly is set. */
+const extraReadOnlyTools = new Set();
+export function registerReadOnlyTool(name) {
+    extraReadOnlyTools.add(name);
+}
+export function unregisterReadOnlyTool(name) {
+    extraReadOnlyTools.delete(name);
+}
 /** State-changing tools whose summaries are kept in nuclear memory. */
 export const WRITE_TOOLS = new Set([
     "write_file", "edit_file", "write", "edit", "patch",
@@ -188,7 +196,9 @@ export function deserializeEntry(line) {
 // ── Classification helpers ────────────────────────────────────────
 /** Check if a nuclear entry represents a read-only action (should be dropped). */
 export function isReadOnly(entry) {
-    return entry.kind === "tool" && entry.tool != null && READ_ONLY_TOOLS.has(entry.tool);
+    if (entry.kind !== "tool" || entry.tool == null)
+        return false;
+    return READ_ONLY_TOOLS.has(entry.tool) || extraReadOnlyTools.has(entry.tool);
 }
 // ── Internal helpers ──────────────────────────────────────────────
 function truncate(text, maxLen) {

package/dist/agent/system-prompt.js

@@ -89,7 +89,7 @@ function loadConventionFiles(dir) {
  * Static system prompt — identical across all queries, cacheable.
  * Contains only identity and behavioral instructions.
  */
-export const STATIC_SYSTEM_PROMPT = `You are an AI coding assistant running inside agent-sh, a terminal shell.
+export const STATIC_SYSTEM_PROMPT = `You are ash, an AI coding assistant running inside agent-sh, a terminal shell.
 You have access to the user's shell environment and can read, write, and execute code.
 You share the user's working directory, environment variables, and shell history.
 agent-sh documentation is at ${path.join(CODE_DIR, "docs")} — start with README.md for an index. Read the docs when you need to understand how the runtime works.

package/dist/agent/tool-registry.js

@@ -1,3 +1,4 @@
+import { registerReadOnlyTool, unregisterReadOnlyTool } from "./nuclear-form.js";
 /**
  * Registry for agent tools. Holds tool definitions and converts them
  * to OpenAI-compatible function schemas for API calls.
@@ -6,9 +7,14 @@ export class ToolRegistry {
     tools = new Map();
     register(tool) {
         this.tools.set(tool.name, tool);
+        if (tool.readOnly)
+            registerReadOnlyTool(tool.name);
+        else
+            unregisterReadOnlyTool(tool.name);
     }
     unregister(name) {
         this.tools.delete(name);
+        unregisterReadOnlyTool(name);
     }
     get(name) {
         return this.tools.get(name);

package/dist/agent/types.d.ts

@@ -77,6 +77,9 @@ export interface ToolDefinition {
     showOutput?: boolean;
     /** Whether this tool may modify files — triggers file watcher (default: false). */
     modifiesFiles?: boolean;
+    /** Results are re-fetchable; nuclear compaction drops the tool_result
+     *  body on eviction (like the builtin read_file/grep/ls). Default: false. */
+    readOnly?: boolean;
     /** Whether to gate execution via permission:request (default: false). */
     requiresPermission?: boolean;
     /** Derive display metadata (icon kind, file paths) for the TUI. */

package/dist/extensions/tui-renderer.js

@@ -48,7 +48,8 @@ function createRenderState() {
         spinnerOpts: {},
         spinnerInterval: null,
         spinnerStartTime: 0,
-        toolLineOpen: false,
+        openTool: null,
+        pendingToolCompletes: new Map(),
         currentToolKind: undefined,
         toolStartTime: 0,
         toolExitCode: null,
@@ -58,6 +59,7 @@ function createRenderState() {
         commandOverflowLines: [],
         toolGroupKind: undefined,
         toolGroupCount: 0,
+        toolGroupCompletedCount: 0,
         toolGroupAllOk: true,
         toolGroupRendered: 0,
         toolGroupSummaries: [],
@@ -231,6 +233,9 @@ export default function activate(ctx) {
             return;
         s.isThinking = false;
         if (pendingUsage && s.renderer) {
+            // Flush any buffered partial line first — otherwise responses that
+            // don't end with a newline emit the usage line before their final text.
+            s.renderer.flush();
             const { prompt_tokens, completion_tokens } = pendingUsage;
             const maxTokens = backendInfo?.contextWindow ?? DEFAULT_CONTEXT_WINDOW;
             s.renderer.writeLine("");
@@ -300,29 +305,26 @@ export default function activate(ctx) {
                 group.headerShown = true;
                 s.toolGroupKind = kind;
                 s.toolGroupCount = 0;
+                s.toolGroupCompletedCount = 0;
                 s.toolGroupRendered = 0;
                 s.toolGroupAllOk = true;
                 s.toolGroupSummaries = [];
             }
             s.toolGroupCount++;
             if (s.toolGroupRendered < GROUP_MAX_VISIBLE) {
-                showToolCall(e.title, "", {
-                    ...e,
-                    batchIndex: e.batchIndex,
-                    batchTotal: e.batchTotal,
-                    groupContinuation: true,
-                });
+                showToolCall(e.title, "", { ...e, groupContinuation: true });
                 s.toolGroupRendered++;
             }
+            // Record identity so late completes (after a premature finalize
+            // from a cross-kind standalone start) can render as labeled ⎿ lines.
+            if (e.toolCallId) {
+                s.pendingToolCompletes.set(e.toolCallId, { title: e.title });
+            }
         }
         else {
             // Standalone tool — single in its batch kind, or not groupable
             finalizeToolGroup();
-            showToolCall(e.title, "", {
-                ...e,
-                batchIndex: e.batchIndex,
-                batchTotal: e.batchTotal,
-            });
+            showToolCall(e.title, "", { ...e });
         }
     });
     bus.on("agent:tool-completed", (e) => {
@@ -336,10 +338,17 @@ export default function activate(ctx) {
             // Don't restart spinner between grouped tools — it's already running from group start.
             if (e.resultDisplay?.summary)
                 s.toolGroupSummaries.push(e.resultDisplay.summary);
+            if (e.toolCallId)
+                s.pendingToolCompletes.delete(e.toolCallId);
+            s.toolGroupCompletedCount++;
             s.currentToolKind = undefined;
         }
         else {
-            showToolComplete(e.exitCode, e.resultDisplay);
+            // Route by callId — tools that lost the inline slot get a labeled ⎿ line.
+            const pending = e.toolCallId ? s.pendingToolCompletes.get(e.toolCallId) : undefined;
+            if (pending)
+                s.pendingToolCompletes.delete(e.toolCallId);
+            showToolComplete(e.exitCode, e.resultDisplay, pending?.title);
             s.currentToolKind = undefined;
             s.spinnerStartTime = 0;
             startThinkingSpinner();
@@ -734,37 +743,37 @@ export default function activate(ctx) {
                 // Grouped tools: close the line immediately — checkmarks go on the ⎿ summary
                 s.renderer.writeLine(`  ${batchPrefix}${lines[lines.length - 1]}`);
                 drain();
-                s.toolLineOpen = false;
             }
             else {
                 out().write(`  ${batchPrefix}${lines[lines.length - 1]}`);
-                s.toolLineOpen = true;
+                if (extra?.toolCallId)
+                    s.openTool = { callId: extra.toolCallId, title };
             }
         }
         s.hadToolCalls = true;
         s.commandOutputLineCount = 0;
         s.commandOutputOverflow = 0;
     }
-    function showToolComplete(exitCode, resultDisplay) {
+    function showToolComplete(exitCode, resultDisplay, labelTitle) {
         if (!s.renderer)
             return;
         stopCurrentSpinner();
         const elapsed = s.toolStartTime ? formatElapsed(Date.now() - s.toolStartTime) : "";
         const mark = ctx.call("tui:render-tool-complete", exitCode, elapsed, resultDisplay?.summary);
-        if (s.toolLineOpen && s.commandOutputLineCount === 0) {
+        if (!labelTitle && s.openTool && s.commandOutputLineCount === 0) {
             out().write(` ${mark}\n`);
-            s.toolLineOpen = false;
+            s.openTool = null;
         }
         else {
             closeToolLine();
             flushCommandOutput();
-            s.renderer.writeLine(`  ${mark}`);
+            s.renderer.writeLine(labelTitle
+                ? `  ${p.muted}⎿${p.reset} ${p.dim}${labelTitle}${p.reset} ${mark}`
+                : `  ${mark}`);
             drain();
         }
-        // Render structured body if present
-        if (resultDisplay?.body) {
+        if (resultDisplay?.body)
             renderResultBody(resultDisplay.body);
-        }
     }
     function renderResultBody(body) {
         if (!s.renderer)
@@ -813,18 +822,23 @@ export default function activate(ctx) {
         }
     }
     function closeToolLine() {
-        if (s.toolLineOpen) {
+        if (s.openTool) {
             out().write("\n");
-            s.toolLineOpen = false;
+            // Stash identity so the completion renders as ⎿ labeled, not orphan ✓.
+            s.pendingToolCompletes.set(s.openTool.callId, { title: s.openTool.title });
+            s.openTool = null;
         }
     }
-    /** Finalize a group of collapsed tool calls, rendering the summary. */
+    /** Render the group aggregate ⎿ line, or skip if no members have
+     *  completed yet (late completes will render individually as ⎿ labeled). */
     function finalizeToolGroup() {
-        if (s.toolGroupCount <= 1) {
-            // 0–1 tools: standalone, nothing to finalize
+        const skipAggregate = s.toolGroupCount > 1 && s.toolGroupCompletedCount === 0;
+        if (s.toolGroupCount <= 1 || skipAggregate) {
             s.toolGroupKind = undefined;
             s.toolGroupCount = 0;
+            s.toolGroupCompletedCount = 0;
             s.toolGroupRendered = 0;
+            s.toolGroupAllOk = true;
             s.toolGroupSummaries = [];
             return;
         }
@@ -836,6 +850,7 @@ export default function activate(ctx) {
         drain();
         s.toolGroupKind = undefined;
         s.toolGroupCount = 0;
+        s.toolGroupCompletedCount = 0;
         s.toolGroupAllOk = true;
         s.toolGroupRendered = 0;
         s.toolGroupSummaries = [];

package/dist/shell/input-handler.js

@@ -218,6 +218,12 @@ export class InputHandler {
                 this.lineBuffer = "";
                 this.ctx.writeToPty(ch);
             }
+            else if (ch === "\x0b" || ch === "\x15") {
+                // Ctrl-K / Ctrl-U kill the line in the shell; mirror that so the
+                // mode-trigger check sees an empty buffer. Not cursor-accurate.
+                this.lineBuffer = "";
+                this.ctx.writeToPty(ch);
+            }
             else if (ch === "\x1b") {
                 // Escape sequence — forward the entire sequence to the PTY but
                 // don't let it corrupt lineBuffer.  Skip CSI (ESC [ ... final)

package/dist/utils/ansi.d.ts

@@ -23,6 +23,9 @@ export declare function visibleLen(str: string): number;
  * Accounts for CJK double-width characters. Appends `…` if truncated.
  */
 export declare function truncateToWidth(str: string, maxWidth: number): string;
+/** Truncate to visible width while preserving SGR sequences — use when
+ *  input carries color/bold codes. `truncateToWidth` strips them. */
+export declare function truncateAnsiToWidth(str: string, maxWidth: number): string;
 /**
  * Pad a string with spaces to fill `targetWidth` visible columns.
  * Accounts for CJK double-width characters.

package/dist/utils/ansi.js

@@ -52,9 +52,22 @@ export function charWidth(codePoint) {
     if (codePoint >= 0x1fa00 && codePoint <= 0x1faff)
         return 2; // Chess Symbols, Symbols and Pictographs Extended-A
     // NOTE: 0x2300-0x23ff (Misc Technical), 0x2600-0x26ff (Misc Symbols),
-    // and 0x2700-0x27bf (Dingbats) are intentionally NOT width 2 — these ranges
-    // contain mostly "Ambiguous" width characters that render as 1 column in
-    // non-CJK terminal locales (e.g. ❯, ⌘, ★, ♦).
+    // and 0x2700-0x27bf (Dingbats) are mostly "Ambiguous" width — render as
+    // 1 column in non-CJK terminal locales (e.g. ❯, ⌘, ★, ♦). But a handful
+    // of dingbats have Emoji_Presentation=Yes and render as 2 cols everywhere.
+    if (codePoint === 0x2705 || // ✅ white heavy check mark
+        codePoint === 0x270a || // ✊ raised fist
+        codePoint === 0x270b || // ✋ raised hand
+        codePoint === 0x2728 || // ✨ sparkles
+        codePoint === 0x274c || // ❌ cross mark
+        codePoint === 0x274e || // ❎ negative squared cross mark
+        (codePoint >= 0x2753 && codePoint <= 0x2755) || // ❓❔❕
+        codePoint === 0x2757 || // ❗ heavy exclamation mark
+        (codePoint >= 0x2795 && codePoint <= 0x2797) || // ➕➖➗
+        codePoint === 0x27b0 || // ➰ curly loop
+        codePoint === 0x27bf // ➿ double curly loop
+    )
+        return 2;
     // Regional indicator symbols (flag emoji components)
     if (codePoint >= 0x1f1e6 && codePoint <= 0x1f1ff)
         return 2;
@@ -150,6 +163,39 @@ export function truncateToWidth(str, maxWidth) {
         return "…";
     return clean.slice(0, i) + "…";
 }
+/** Truncate to visible width while preserving SGR sequences — use when
+ *  input carries color/bold codes. `truncateToWidth` strips them. */
+export function truncateAnsiToWidth(str, maxWidth) {
+    if (maxWidth <= 0)
+        return "";
+    if (visibleLen(str) <= maxWidth)
+        return str;
+    if (maxWidth === 1)
+        return "…";
+    const target = maxWidth - 1;
+    let width = 0;
+    let out = "";
+    let i = 0;
+    while (i < str.length) {
+        if (str[i] === "\x1b" && str[i + 1] === "[") {
+            const end = str.indexOf("m", i);
+            if (end !== -1) {
+                out += str.slice(i, end + 1);
+                i = end + 1;
+                continue;
+            }
+        }
+        const cp = str.codePointAt(i) ?? 0;
+        const cw = charWidth(cp);
+        if (width + cw > target)
+            break;
+        const chLen = cp > 0xffff ? 2 : 1;
+        out += str.slice(i, i + chLen);
+        width += cw;
+        i += chLen;
+    }
+    return out + "\x1b[0m…";
+}
 /**
  * Pad a string with spaces to fill `targetWidth` visible columns.
  * Accounts for CJK double-width characters.

package/dist/utils/llm-client.d.ts

@@ -12,6 +12,10 @@ export interface LlmClientConfig {
     apiKey: string;
     baseURL?: string;
     model: string;
+    /** Sent as OpenRouter X-Title; ignored by other providers. */
+    appName?: string;
+    /** Sent as OpenRouter HTTP-Referer; ignored by other providers. */
+    appUrl?: string;
 }
 export declare class LlmClient {
     private config;

package/dist/utils/llm-client.js

@@ -6,6 +6,12 @@
  * (command suggestions, completions).
  */
 import OpenAI from "openai";
+function attributionHeaders(config) {
+    return {
+        "HTTP-Referer": config.appUrl ?? "https://agent-sh.dev",
+        "X-Title": config.appName ?? "agent-sh",
+    };
+}
 export class LlmClient {
     config;
     client;
@@ -15,6 +21,7 @@ export class LlmClient {
         this.client = new OpenAI({
             apiKey: config.apiKey,
             baseURL: config.baseURL,
+            defaultHeaders: attributionHeaders(config),
         });
         this.model = config.model;
     }
@@ -24,6 +31,7 @@ export class LlmClient {
         this.client = new OpenAI({
             apiKey: newConfig.apiKey,
             baseURL: newConfig.baseURL,
+            defaultHeaders: attributionHeaders(newConfig),
         });
         this.model = newConfig.model;
     }

package/dist/utils/markdown.d.ts

@@ -2,6 +2,10 @@ export declare const MAX_CONTENT_WIDTH = 90;
 /**
  * Word-wrap a string (which may contain ANSI codes) to a maximum visible width.
  * Returns an array of lines, each fitting within `maxWidth` visible characters.
+ *
+ * Handles CJK text by breaking between wide characters and applying basic
+ * CJK rules (closing punctuation sticks to the previous line; opening
+ * punctuation sticks to the next).
  */
 export declare function wrapLine(text: string, maxWidth: number): string[];
 /**

package/dist/utils/markdown.js

@@ -1,9 +1,65 @@
-import { visibleLen, truncateToWidth, padEndToWidth, charWidth } from "./ansi.js";
+import { visibleLen, truncateAnsiToWidth, padEndToWidth, charWidth } from "./ansi.js";
 import { palette as p } from "./palette.js";
 export const MAX_CONTENT_WIDTH = 90;
+// CJK line-breaking rules: closing punctuation must not start a line,
+// opening punctuation must not end a line. Both CJK fullwidth and ASCII
+// equivalents are included so mixed text wraps correctly.
+const CJK_NO_LINE_START = new Set([
+    "。", "，", "、", "．", "；", "：", "！", "？",
+    "）", "」", "』", "】", "》", "〉", "〕", "］", "｝",
+    "・", "々", "〜", "～", "ー",
+    ".", ",", ";", ":", "!", "?", ")", "]", "}",
+]);
+const CJK_NO_LINE_END = new Set([
+    "（", "「", "『", "【", "《", "〈", "〔", "［", "｛",
+    "(", "[", "{",
+]);
+/**
+ * Tokenize a visible-text run into units suitable for wrapping.
+ * Each width-2 character (CJK, fullwidth, emoji) becomes its own token so the
+ * wrapper can break between them; ASCII runs stay together as word tokens.
+ */
+function tokenizeVisible(text) {
+    const tokens = [];
+    let ascii = "";
+    const flush = () => { if (ascii) {
+        tokens.push(ascii);
+        ascii = "";
+    } };
+    let i = 0;
+    while (i < text.length) {
+        const cp = text.codePointAt(i) ?? 0;
+        const chLen = cp > 0xffff ? 2 : 1;
+        const ch = text.slice(i, i + chLen);
+        if (ch === " ") {
+            flush();
+            let spaces = "";
+            while (i < text.length && text[i] === " ") {
+                spaces += " ";
+                i += 1;
+            }
+            tokens.push(spaces);
+            continue;
+        }
+        if (charWidth(cp) === 2) {
+            flush();
+            tokens.push(ch);
+            i += chLen;
+            continue;
+        }
+        ascii += ch;
+        i += chLen;
+    }
+    flush();
+    return tokens;
+}
 /**
  * Word-wrap a string (which may contain ANSI codes) to a maximum visible width.
  * Returns an array of lines, each fitting within `maxWidth` visible characters.
+ *
+ * Handles CJK text by breaking between wide characters and applying basic
+ * CJK rules (closing punctuation sticks to the previous line; opening
+ * punctuation sticks to the next).
  */
 export function wrapLine(text, maxWidth) {
     if (!(maxWidth > 0))
@@ -11,40 +67,44 @@ export function wrapLine(text, maxWidth) {
     if (visibleLen(text) <= maxWidth)
         return [text];
     const result = [];
-    // Split into segments: ANSI codes and visible text
     const segments = text.match(/(\x1b\[[^m]*m|[^\x1b]+)/g) || [text];
-    let currentLine = "";
-    let currentWidth = 0;
-    let activeStyles = ""; // track ANSI styles to reapply after wraps
+    let lineTokens = [];
+    let lineWidth = 0;
+    let activeStyles = "";
+    let lastVisibleIdx = -1;
+    const commit = () => {
+        result.push(lineTokens.join("") + p.reset);
+        lineTokens = activeStyles ? [activeStyles] : [];
+        lineWidth = 0;
+        lastVisibleIdx = -1;
+    };
     for (const seg of segments) {
         if (seg.startsWith("\x1b[")) {
-            // ANSI code — track it, add to current line
-            currentLine += seg;
-            if (seg === p.reset) {
+            lineTokens.push(seg);
+            if (seg === p.reset)
                 activeStyles = "";
-            }
-            else {
+            else
                 activeStyles += seg;
-            }
             continue;
         }
-        // Visible text — split into words
-        const words = seg.split(/( +)/);
-        for (const word of words) {
-            if (word.length === 0)
+        for (const token of tokenizeVisible(seg)) {
+            const tokenWidth = visibleLen(token);
+            const isSpace = token[0] === " ";
+            if (lineWidth + tokenWidth <= maxWidth) {
+                lineTokens.push(token);
+                lineWidth += tokenWidth;
+                if (!isSpace)
+                    lastVisibleIdx = lineTokens.length - 1;
                 continue;
-            const wordWidth = visibleLen(word);
-            if (currentWidth + wordWidth <= maxWidth) {
-                currentLine += word;
-                currentWidth += wordWidth;
             }
-            else if (currentWidth === 0) {
-                // Single word longer than maxWidth — hard break by visible width
-                let remaining = word;
+            // Token doesn't fit on the current line.
+            if (isSpace)
+                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) {
-                    // Find the largest prefix that fits
-                    let fitLen = 0;
-                    let fitWidth = 0;
+                    let fitLen = 0, fitWidth = 0;
                     for (const ch of remaining) {
                         const cw = charWidth(ch.codePointAt(0) ?? 0);
                         if (fitWidth + cw > maxWidth)
@@ -52,37 +112,47 @@ export function wrapLine(text, maxWidth) {
                         fitWidth += cw;
                         fitLen += ch.length;
                     }
-                    if (fitLen === 0) {
-                        // Even one char doesn't fit — force take one char to avoid infinite loop
+                    if (fitLen === 0)
                         fitLen = remaining[0]?.length ?? 1;
-                    }
                     const chunk = remaining.slice(0, fitLen);
                     remaining = remaining.slice(fitLen);
-                    currentLine += chunk;
-                    if (remaining.length > 0) {
-                        result.push(currentLine + p.reset);
-                        currentLine = activeStyles;
-                        currentWidth = 0;
-                    }
-                    else {
-                        currentWidth += fitWidth;
-                    }
+                    lineTokens.push(chunk);
+                    lineWidth += visibleLen(chunk);
+                    lastVisibleIdx = lineTokens.length - 1;
+                    if (remaining.length > 0)
+                        commit();
                 }
+                continue;
             }
-            else {
-                // Wrap to next line
-                result.push(currentLine + p.reset);
-                currentLine = activeStyles;
-                currentWidth = 0;
-                // Skip leading spaces on new line
-                const trimmed = word.replace(/^ +/, "");
-                currentLine += trimmed;
-                currentWidth = visibleLen(trimmed);
+            // Rule (a): closing punctuation must not start a line. Allow up to 2
+            // columns of overflow so the punctuation stays with its phrase.
+            if (CJK_NO_LINE_START.has(token)) {
+                lineTokens.push(token);
+                lineWidth += tokenWidth;
+                commit();
+                continue;
+            }
+            // Rule (b): opening punctuation must not end a line. Pull the trailing
+            // opener down to the next line with us.
+            let carried = [];
+            if (lastVisibleIdx >= 0 && CJK_NO_LINE_END.has(lineTokens[lastVisibleIdx])) {
+                carried = lineTokens.splice(lastVisibleIdx);
+                while (lineTokens.length > 0 && /^ +$/.test(lineTokens[lineTokens.length - 1])) {
+                    lineTokens.pop();
+                }
+            }
+            commit();
+            for (const t of carried) {
+                lineTokens.push(t);
+                lineWidth += visibleLen(t);
             }
+            lineTokens.push(token);
+            lineWidth += tokenWidth;
+            lastVisibleIdx = lineTokens.length - 1;
         }
     }
-    if (currentLine.length > 0) {
-        result.push(currentLine);
+    if (lineWidth > 0) {
+        result.push(lineTokens.join(""));
     }
     return result;
 }
@@ -188,17 +258,17 @@ export class MarkdownRenderer {
             while (row.length < numCols)
                 row.push("");
         }
-        // Calculate column widths from content
+        // Width from rendered cell — raw `**bold**` over-counts by 4 per pair.
         const colWidths = new Array(numCols).fill(0);
         for (const row of dataRows) {
             for (let c = 0; c < numCols; c++) {
-                colWidths[c] = Math.max(colWidths[c], visibleLen(row[c]));
+                colWidths[c] = Math.max(colWidths[c], visibleLen(this.renderInline(row[c])));
             }
         }
-        // Shrink columns proportionally if total exceeds content width
-        // Account for separators: " │ " between cols (3 chars each) + 2 outer padding
+        // Tables bypass the prose width cap — borders guide the eye, so wider is fine.
         const separatorWidth = (numCols - 1) * 3;
-        const availableWidth = this.contentWidth - separatorWidth;
+        const tableWidth = Math.max(10, this.width - 2);
+        const availableWidth = tableWidth - separatorWidth;
         const totalWidth = colWidths.reduce((a, b) => a + b, 0);
         if (totalWidth > availableWidth && availableWidth > numCols) {
             const scale = availableWidth / totalWidth;
@@ -216,7 +286,10 @@ export class MarkdownRenderer {
             const isHeader = hasHeader && i === 0;
             const cells = row.map((cell, c) => {
                 const w = colWidths[c];
-                const text = visibleLen(cell) > w ? truncateToWidth(cell, w) : padEndToWidth(cell, w);
+                const rendered = this.renderInline(cell);
+                const text = visibleLen(rendered) > w
+                    ? truncateAnsiToWidth(rendered, w)
+                    : padEndToWidth(rendered, w);
                 return isHeader ? `${p.bold}${text}${p.reset}` : text;
             });
             this.writeLine(`${p.dim}│${p.reset} ${cells.join(` ${p.dim}│${p.reset} `)} ${p.dim}│${p.reset}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-sh",
-  "version": "0.10.1",
+  "version": "0.10.2",
   "description": "A shell-first terminal where AI is one keystroke away",
   "type": "module",
   "main": "dist/core.js",
@@ -70,6 +70,14 @@
       "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"
+    },
     "./executor": {
       "types": "./dist/executor.d.ts",
       "default": "./dist/executor.js"