agent-sh 0.10.0 → 0.10.2

package/dist/context-manager.js

@@ -1,32 +1,43 @@
 import { getSettings } from "./settings.js";
+import { spillOutput } from "./utils/shell-output-spill.js";
 export class ContextManager {
     exchanges = [];
     nextId = 1;
     currentCwd;
-    sessionStart;
-    firstPrompt = true;
     agentShellActive = false; // true while user_shell command is executing
-    handlers = null;
-    constructor(bus, handlers) {
-        if (handlers) {
-            this.handlers = handlers;
-            // Extensions can advise this to inject extra context (e.g. terminal buffer)
-            handlers.define("context:build-extra", () => "");
-        }
+    constructor(bus, _handlers) {
         this.currentCwd = process.cwd();
-        this.sessionStart = Date.now();
         // ── Subscribe to shell events ──
         bus.on("shell:command-done", (e) => {
             const lines = e.output.split("\n");
+            const s = getSettings();
+            // Spill long outputs to a tempfile so the agent can `read_file` them
+            // on demand instead of carrying the full text in LLM context.
+            let output = e.output;
+            let spillPath;
+            if (lines.length > s.shellTruncateThreshold) {
+                // Reserve the id we're about to assign so the tempfile name matches.
+                const id = this.nextId;
+                try {
+                    spillPath = spillOutput(id, e.output);
+                    output = buildSpillStub(lines, s.shellHeadLines, s.shellTailLines, spillPath);
+                }
+                catch {
+                    // If spill fails (e.g. disk full), fall back to keeping output in memory.
+                    output = e.output;
+                    spillPath = undefined;
+                }
+            }
             this.addExchange({
                 type: "shell_command",
                 command: e.command,
-                output: e.output,
+                output,
                 cwd: e.cwd,
                 exitCode: e.exitCode,
                 outputLines: lines.length,
                 outputBytes: e.output.length,
                 source: this.agentShellActive ? "agent" : "user",
+                spillPath,
             });
         });
         bus.on("shell:cwd-change", (e) => {
@@ -46,16 +57,6 @@ export class ContextManager {
     getCwd() {
         return this.currentCwd;
     }
-    /**
-     * Build the <shell_context> block for the agent prompt.
-     * Pipeline: window → truncate → format
-     */
-    getContext(budget) {
-        budget ??= getSettings().contextBudget;
-        let exchanges = this.applyWindow(this.exchanges);
-        exchanges = this.applyTruncation(exchanges, budget);
-        return this.formatContext(exchanges);
-    }
     /**
      * Regex/keyword search across all exchanges. Returns formatted results.
      */
@@ -106,40 +107,6 @@ export class ContextManager {
         }
         return parts.join("\n");
     }
-    /**
-     * Return content for specific exchange IDs.
-     * Optional start/end restrict to a line range (1-indexed).
-     */
-    expand(ids, start, end) {
-        const results = [];
-        for (const id of ids) {
-            const ex = this.exchanges.find((e) => e.id === id);
-            if (!ex) {
-                results.push(`#${id}: not found`);
-                continue;
-            }
-            const text = this.formatExchangeFull(ex);
-            const lines = text.split("\n");
-            const total = lines.length;
-            if (start != null || end != null) {
-                // Line range requested
-                const s = Math.max(0, (start ?? 1) - 1);
-                const e = end ?? total;
-                results.push(lines.slice(s, e).join("\n") +
-                    `\n[showing lines ${s + 1}-${Math.min(e, total)} of ${total}]`);
-            }
-            else if (total > getSettings().recallExpandMaxLines) {
-                // Too large — tell the agent to narrow down
-                results.push(`#${ex.id}: output is ${total} lines, too large to expand fully. ` +
-                    `Use start/end params to select a line range (e.g. start=1, end=50), ` +
-                    `or use search with a regex to find specific content.`);
-            }
-            else {
-                results.push(text);
-            }
-        }
-        return results.join("\n\n");
-    }
     /**
      * Return shell events with id > afterId, formatted as an incremental
      * delta suitable for injection into conversation history. Skips
@@ -156,18 +123,8 @@ export class ContextManager {
         if (fresh.length === 0)
             return null;
         const lastSeq = this.exchanges[this.exchanges.length - 1].id;
-        // Apply per-type truncation so giant outputs don't blow up the turn.
-        const truncated = fresh.map((ex) => {
-            if (ex.type === "shell_command") {
-                const s = getSettings();
-                return {
-                    ...ex,
-                    output: truncateOutput(ex.output, s.shellTruncateThreshold, s.shellHeadLines, s.shellTailLines, ex.id),
-                };
-            }
-            return { ...ex };
-        });
-        const body = truncated.map((ex) => this.formatExchangeTruncated(ex)).join("\n");
+        // Outputs already carry head+tail+spillPath stubs from capture time.
+        const body = fresh.map((ex) => this.formatExchangeTruncated(ex)).join("\n");
         return {
             text: `<shell-events>\n${body}</shell-events>`,
             lastSeq,
@@ -186,104 +143,13 @@ export class ContextManager {
             return "No exchanges yet.";
         return recent.map((ex) => this.exchangeOneLiner(ex)).join("\n");
     }
-    /**
-     * Parse and handle shell_recall commands.
-     */
-    handleRecallCommand(command) {
-        const args = command.replace(/^_*shell_recall\s*/, "").trim();
-        if (!args || args === "--help") {
-            return [
-                "Usage:",
-                "  shell_recall                    Browse recent exchanges",
-                "  shell_recall --search <query>   Search all exchanges",
-                "  shell_recall --expand <id,...>   Show full content of exchanges",
-                "",
-                "Examples:",
-                '  shell_recall --search "test fail"',
-                "  shell_recall --expand 41",
-                "  shell_recall --expand 41,42,43",
-            ].join("\n");
-        }
-        const searchMatch = args.match(/^--search\s+(?:"([^"]+)"|(\S+))/);
-        if (searchMatch) {
-            return this.search(searchMatch[1] ?? searchMatch[2] ?? "");
-        }
-        const expandMatch = args.match(/^--expand\s+([\d,\s]+)/);
-        if (expandMatch) {
-            const ids = expandMatch[1]
-                .split(/[,\s]+/)
-                .map(Number)
-                .filter((n) => !isNaN(n));
-            if (ids.length === 0)
-                return "No valid IDs provided.";
-            return this.expand(ids);
-        }
-        // Default: browse
-        return this.getRecentSummary();
-    }
     /**
      * Clear exchange history (used by /clear command).
      */
     clear() {
         this.exchanges = [];
-        this.firstPrompt = true;
         // Don't reset nextId — IDs should be globally unique within a session
     }
-    // ── Pipeline stages ───────────────────────────────────────────
-    applyWindow(exchanges, windowSize) {
-        windowSize ??= getSettings().contextWindowSize;
-        return exchanges.slice(-windowSize);
-    }
-    applyTruncation(exchanges, budget) {
-        // Deep clone so we don't mutate the source
-        const result = exchanges.map((e) => ({ ...e }));
-        // Pass 1: per-type truncation
-        for (const ex of result) {
-            if (ex.type === "shell_command") {
-                const s = getSettings();
-                ex.output = truncateOutput(ex.output, s.shellTruncateThreshold, s.shellHeadLines, s.shellTailLines, ex.id);
-            }
-            // agent_query has no output to truncate
-        }
-        // Pass 2: budget enforcement — strip output from oldest if over budget
-        let totalSize = result.reduce((sum, ex) => sum + this.exchangeSize(ex), 0);
-        for (let i = 0; i < result.length - 1 && totalSize > budget; i++) {
-            const ex = result[i];
-            const before = this.exchangeSize(ex);
-            if (ex.type === "shell_command") {
-                ex.output = `[output omitted, use shell_recall tool to expand id ${ex.id}]`;
-            }
-            totalSize -= before - this.exchangeSize(ex);
-        }
-        return result;
-    }
-    formatContext(exchanges) {
-        const elapsed = Math.round((Date.now() - this.sessionStart) / 60000);
-        const totalCount = this.exchanges.length;
-        let out = "<shell_context>\n";
-        if (this.firstPrompt) {
-            out += `You are an AI assistant living inside agent-sh, a shell-first terminal.\n`;
-            out += `The user interacts with a real shell (PTY) and sends you queries inline. You are there to help them with their tasks.\n`;
-            out += `\n`;
-            out += `IMPORTANT tool usage rules:\n`;
-            out += `- Your internal tools (bash, read, write, ls, etc.) run in an isolated subprocess. The user CANNOT see their output.\n`;
-            out += `- Only use internal tools when YOU need to reason about content silently (e.g. reading a file to answer a question about it).\n`;
-            out += `- You can browse or search shell history with shell_recall.\n`;
-            out += `\n`;
-            this.firstPrompt = false;
-        }
-        out += `cwd: ${this.currentCwd}\n`;
-        out += `session: ${totalCount} exchanges, ${elapsed}m elapsed\n`;
-        for (const ex of exchanges) {
-            out += "\n" + this.formatExchangeTruncated(ex);
-        }
-        // Allow extensions to inject extra context (e.g. terminal buffer snapshot)
-        const extra = this.handlers?.call("context:build-extra");
-        if (extra)
-            out += "\n" + extra + "\n";
-        out += "\n</shell_context>\n";
-        return out;
-    }
     // ── Internal helpers ──────────────────────────────────────────
     addExchange(partial) {
         const exchange = {
@@ -352,14 +218,11 @@ export class ContextManager {
     }
 }
 // ── Utility functions ─────────────────────────────────────────
-function truncateOutput(text, threshold, headLines, tailLines, id) {
-    const lines = text.split("\n");
-    if (lines.length <= threshold)
-        return text;
+function buildSpillStub(lines, headLines, tailLines, spillPath) {
     const omitted = lines.length - headLines - tailLines;
     return [
         ...lines.slice(0, headLines),
-        `[... ${omitted} lines truncated, use shell_recall tool with expand and id ${id} to see full output ...]`,
+        `[... ${omitted} lines truncated — full output at ${spillPath}; use read_file to expand ...]`,
         ...lines.slice(-tailLines),
     ].join("\n");
 }

package/dist/event-bus.d.ts

@@ -238,7 +238,6 @@ export interface ShellEvents {
         active: string | null;
     };
     "config:changed": Record<string, never>;
-    "config:cycle": Record<string, never>;
     "config:switch-model": {
         model: string;
     };

package/dist/extension-loader.js

@@ -5,12 +5,33 @@ const EXT_DIR = path.join(CONFIG_DIR, "extensions");
 const TS_EXTS = [".ts", ".tsx", ".mts"];
 const SCRIPT_EXTS = [".js", ".mjs", ".ts", ".tsx", ".mts"];
 let tsRegistered = false;
-async function ensureTsSupport() {
-    if (tsRegistered)
+let tsxUnregister = null;
+/**
+ * Register tsx's ESM loader for .ts file support.
+ *
+ * Called before importing .ts extensions. The tsx loader uses Node's
+ * module.register() which creates a background thread with a MessageChannel.
+ * On reload, the old loader may become stale (the MessageChannel port can be
+ * GC'd or the loader thread can stop responding), so we unregister the old
+ * handle and re-register on each reload.
+ *
+ * Initial load: registers fresh.
+ * Reload: unregisters old handle, registers new one.
+ * Non-reload calls within the same load: no-op (tsRegistered guard).
+ */
+async function ensureTsSupport(force = false) {
+    if (tsRegistered && !force)
         return;
     try {
+        // Unregister previous loader if reloading
+        if (tsxUnregister) {
+            try {
+                await tsxUnregister();
+            }
+            catch { /* ignore stale handle */ }
+        }
         const { register } = await import("tsx/esm/api");
-        register();
+        tsxUnregister = register();
         tsRegistered = true;
     }
     catch {
@@ -166,7 +187,7 @@ async function loadSpecifiers(specifiers, ctx, bustCache, userSpecifiers) {
         try {
             let importPath = await resolveSpecifier(specifier);
             if (TS_EXTS.some((ext) => importPath.endsWith(ext))) {
-                await ensureTsSupport();
+                await ensureTsSupport(bustCache);
             }
             // Append timestamp query to bust Node's module cache on reload
             if (bustCache) {

package/dist/extensions/agent-backend.js

@@ -1,6 +1,7 @@
 import { AgentLoop } from "../agent/agent-loop.js";
 import { LlmClient } from "../utils/llm-client.js";
 import { resolveProvider, getProviderNames, getSettings } from "../settings.js";
+import { PACKAGE_VERSION } from "../utils/package-version.js";
 /** Read the user's persisted defaultModel for a provider, if any. */
 function persistedModelFor(providerName) {
     if (!providerName)
@@ -71,7 +72,7 @@ export default function agentBackend(ctx) {
             agentLoop.wire();
             bus.emit("agent:info", {
                 name: "ash",
-                version: "0.4",
+                version: PACKAGE_VERSION,
                 model: llmClient.model,
                 provider: modes[initialModeIndex]?.provider,
                 contextWindow: modes[initialModeIndex]?.contextWindow,
@@ -181,7 +182,7 @@ export default function agentBackend(ctx) {
             };
         });
         bus.emit("config:set-modes", { modes: newModes });
-        bus.emit("agent:info", { name: "ash", version: "0.4", model: switchModel, provider: name, contextWindow: p.contextWindow });
+        bus.emit("agent:info", { name: "ash", version: PACKAGE_VERSION, model: switchModel, provider: name, contextWindow: p.contextWindow });
         bus.emit("ui:info", { message: `Switched to ${name} (${switchModel})` });
         bus.emit("config:changed", {});
     });

package/dist/extensions/index.js

@@ -3,7 +3,6 @@ export const BUILTIN_EXTENSIONS = [
     { name: "tui-renderer", load: () => import("./tui-renderer.js").then(m => m.default) },
     { name: "slash-commands", load: () => import("./slash-commands.js").then(m => m.default) },
     { name: "file-autocomplete", load: () => import("./file-autocomplete.js").then(m => m.default) },
-    { name: "shell-recall", load: () => import("./shell-recall.js").then(m => m.default) },
     { name: "command-suggest", load: () => import("./command-suggest.js").then(m => m.default) },
 ];
 /**

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: [],
@@ -74,8 +76,11 @@ export default function activate(ctx) {
     bus.on("shell:cwd-change", (e) => { shellCwd = e.cwd; });
     /** Shorthand — get the current agent surface. */
     function out() { return compositor.surface("agent"); }
-    /** Capped width for borders, tool lines, and content — keeps everything aligned. */
-    function cappedW() { return Math.min(MAX_CONTENT_WIDTH + 2, out().columns); }
+    /** Capped width for borders, tool lines, and content — keeps everything aligned.
+     *  MarkdownRenderer.writeLine prepends a 2-char indent ("  ") to every line,
+     *  so available width for actual content is columns - 2.  Subtract an additional
+     *  1 to prevent terminal auto-wrap when a line lands exactly at the right edge. */
+    function cappedW() { return Math.min(MAX_CONTENT_WIDTH + 2, out().columns) - 2 - 1; }
     // Gate: other extensions (e.g. overlay) can advise this to suppress
     // TUI rendering of agent output while they own the display.
     define("tui:should-render-agent", () => true);
@@ -228,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("");
@@ -297,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) => {
@@ -333,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();
@@ -731,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)
@@ -810,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;
         }
@@ -833,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/settings.d.ts

@@ -32,20 +32,12 @@ export interface Settings {
     defaultProvider?: string;
     /** Preferred agent backend (extension name, e.g. "pi", "claude-code"). */
     defaultBackend?: string;
-    /** Recent exchanges included in agent context window. */
-    contextWindowSize?: number;
-    /** Context budget in bytes (~4 chars per token). */
-    contextBudget?: number;
-    /** Shell output lines before truncation kicks in. */
+    /** Shell output lines before spill-to-tempfile kicks in. */
     shellTruncateThreshold?: number;
-    /** Lines kept from start of truncated shell output. */
+    /** Lines kept from start of spilled shell output. */
     shellHeadLines?: number;
-    /** Lines kept from end of truncated shell output. */
+    /** Lines kept from end of spilled shell output. */
     shellTailLines?: number;
-    /** Max lines for recall expand before requiring line ranges. */
-    recallExpandMaxLines?: number;
-    /** Fraction of content budget allocated to shell context (0-1, default 0.35). */
-    shellContextRatio?: number;
     /** Max history file size in bytes (default: 102400 = 100KB). */
     historyMaxBytes?: number;
     /** Number of prior history entries to load on startup (default: 50). */

package/dist/settings.js

@@ -16,13 +16,9 @@ const DEFAULTS = {
     defaultProvider: undefined,
     defaultBackend: "ash",
     toolMode: "api",
-    contextWindowSize: 20,
-    contextBudget: 32768,
     shellTruncateThreshold: 20,
     shellHeadLines: 10,
     shellTailLines: 10,
-    recallExpandMaxLines: 500,
-    shellContextRatio: 0.35,
     historyMaxBytes: 104857600, // 100MB — history is only accessed via search/expand, never loaded wholesale
     historyStartupEntries: 100,
     autoCompactThreshold: 0.5,

package/dist/shell/input-handler.js

@@ -107,11 +107,11 @@ export class InputHandler {
                 p.accent + after + p.reset +
                 "\x1b8" // DECRC — restore cursor position
             );
-            // Clearing on next redraw needs total rows, so measure the full
-            // content width — not just up to the cursor.
-            const totalVisLen = promptVisLen + visibleLen(display);
-            this.cursorRowsBelow = totalVisLen > 0 ? Math.ceil(totalVisLen / termW) - 1 : 0;
+            // cursorRowsBelow is distance from cursor (restored by DECRC, sitting at
+            // the cursor col) back up to the prompt's top row. Next redraw uses it
+            // with \x1b[${n}A then \x1b[J — moving past the top scrolls the screen.
             const cursorVisCol = promptVisLen + visibleLen(before);
+            this.cursorRowsBelow = cursorVisCol > 0 ? Math.ceil(cursorVisCol / termW) - 1 : 0;
             this.cursorTermCol = cursorVisCol === 0 ? 1 : (cursorVisCol % termW === 0 ? termW : (cursorVisCol % termW) + 1);
         }
         else {
@@ -157,8 +157,10 @@ export class InputHandler {
                 rowsSoFar += lineTermRows;
             }
             process.stdout.write(output + "\x1b8"); // DECRC — restore cursor position
-            // Total rows (not cursor row) so next redraw clears the whole area.
-            this.cursorRowsBelow = rowsSoFar - 1 > 0 ? rowsSoFar - 1 : 0;
+            // Distance from cursor (where DECRC lands) back to the top row. Next
+            // redraw moves up by this and clears to end-of-screen — \x1b[J handles
+            // everything below, including rows after the cursor's logical line.
+            this.cursorRowsBelow = cursorRowFromTop;
         }
     }
     handleInput(data) {
@@ -216,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)
@@ -519,9 +527,6 @@ export class InputHandler {
                         this.applyAutocomplete();
                     }
                     break;
-                case "shift+tab":
-                    this.bus.emit("config:cycle", {});
-                    break;
                 case "arrow-up":
                     if (this.autocompleteActive) {
                         this.autocompleteIndex =

package/dist/types.d.ts

@@ -158,12 +158,15 @@ export type Exchange = {
     timestamp: number;
     cwd: string;
     command: string;
+    /** In-context representation: full text if short, head+tail+path stub if spilled. */
     output: string;
     exitCode: number | null;
     outputLines: number;
     outputBytes: number;
     /** Who initiated this command: "user" (typed) or "agent" (via user_shell). */
     source: "user" | "agent";
+    /** Path to the tempfile holding the full captured output, if spilled. */
+    spillPath?: string;
 } | {
     type: "agent_query";
     id: number;

package/dist/utils/ansi.d.ts

@@ -8,7 +8,9 @@ export declare const BOLD = "\u001B[1m";
 export declare const RESET = "\u001B[0m";
 /**
  * Check if a Unicode code point is a wide character (CJK, fullwidth, emoji, etc.)
- * Returns 2 for wide chars, 1 for normal chars.
+ * Returns 2 for wide chars, 1 for normal chars, 0 for combining chars.
+ *
+ * Based on East Asian Width and Unicode categories.
  */
 export declare function charWidth(codePoint: number): number;
 /**
@@ -21,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.