agent-sh 0.4.0 → 0.6.0

package/dist/settings.d.ts

@@ -1,9 +1,28 @@
 export declare const CONFIG_DIR: string;
+/** Provider profile — a named LLM configuration. */
+export interface ProviderConfig {
+    /** API key (supports $ENV_VAR syntax for runtime expansion). */
+    apiKey?: string;
+    /** Base URL for OpenAI-compatible API. */
+    baseURL?: string;
+    /** Default model to use. Falls back to first entry in models list. */
+    defaultModel?: string;
+    /** Models available for cycling. */
+    models?: string[];
+    /** Context window size in tokens (e.g. 128000). Used for usage display. */
+    contextWindow?: number;
+}
 export interface Settings {
     /** Extensions to load (npm packages or file paths). */
     extensions?: string[];
     /** Max agent query history entries to keep. */
     historySize?: number;
+    /** Named provider configurations. */
+    providers?: Record<string, ProviderConfig>;
+    /** Which provider to use by default. */
+    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). */
@@ -22,8 +41,12 @@ export interface Settings {
     readOutputMaxLines?: number;
     /** Max diff lines shown before "ctrl+o to expand". */
     diffMaxLines?: number;
-    /** Register MCP server for bridge tools (shell_cwd, user_shell, shell_recall). Default true. */
-    enableMcp?: boolean;
+    /** Additional directories to scan for skills (supports ~ expansion). */
+    skillPaths?: string[];
+    /** Show a startup banner when agent-sh launches. */
+    startupBanner?: boolean;
+    /** Show a subtle agent-sh indicator in the shell prompt. */
+    promptIndicator?: boolean;
 }
 declare const DEFAULTS: Required<Settings>;
 /** Load settings from disk (cached after first call). */
@@ -41,4 +64,32 @@ export declare function getSettings(): Settings & typeof DEFAULTS;
 export declare function getExtensionSettings<T extends Record<string, unknown>>(namespace: string, defaults: T): T;
 /** Reset cached settings (for testing or after external edit). */
 export declare function reloadSettings(): void;
+/**
+ * Expand $ENV_VAR references in a string.
+ * Supports $VAR and ${VAR} syntax.
+ */
+export declare function expandEnvVars(value: string): string;
+/** Resolved provider ready for use (env vars expanded, defaults applied). */
+export interface ResolvedProvider {
+    id: string;
+    apiKey?: string;
+    baseURL?: string;
+    defaultModel?: string;
+    models: string[];
+    contextWindow?: number;
+    /** Provider supports the reasoning_effort parameter. Default: true. */
+    supportsReasoningEffort?: boolean;
+    /** Per-model capabilities, keyed by model id. */
+    modelCapabilities?: Map<string, {
+        reasoning?: boolean;
+        contextWindow?: number;
+    }>;
+}
+/**
+ * Resolve a provider config by name from settings.
+ * Returns null if provider not found.
+ */
+export declare function resolveProvider(name: string): ResolvedProvider | null;
+/** Get all configured provider names. */
+export declare function getProviderNames(): string[];
 export {};

package/dist/settings.js

@@ -12,6 +12,9 @@ const SETTINGS_PATH = path.join(CONFIG_DIR, "settings.json");
 const DEFAULTS = {
     extensions: [],
     historySize: 500,
+    providers: {},
+    defaultProvider: undefined,
+    defaultBackend: "agent-sh",
     contextWindowSize: 20,
     contextBudget: 16384,
     shellTruncateThreshold: 10,
@@ -19,9 +22,11 @@ const DEFAULTS = {
     shellTailLines: 5,
     recallExpandMaxLines: 100,
     maxCommandOutputLines: 3,
-    readOutputMaxLines: 0,
+    readOutputMaxLines: 10,
     diffMaxLines: 20,
-    enableMcp: true,
+    skillPaths: [],
+    startupBanner: true,
+    promptIndicator: true,
 };
 let cached = null;
 /** Load settings from disk (cached after first call). */
@@ -31,7 +36,10 @@ export function getSettings() {
             const raw = fs.readFileSync(SETTINGS_PATH, "utf-8");
             cached = JSON.parse(raw);
         }
-        catch {
+        catch (err) {
+            if (err instanceof SyntaxError) {
+                console.error(`[agent-sh] Warning: invalid JSON in ${SETTINGS_PATH}: ${err.message}`);
+            }
             cached = {};
         }
     }
@@ -59,3 +67,38 @@ export function getExtensionSettings(namespace, defaults) {
 export function reloadSettings() {
     cached = null;
 }
+/**
+ * Expand $ENV_VAR references in a string.
+ * Supports $VAR and ${VAR} syntax.
+ */
+export function expandEnvVars(value) {
+    return value.replace(/\$\{([^}]+)\}|\$([A-Za-z_][A-Za-z0-9_]*)/g, (_, braced, plain) => {
+        const name = braced || plain;
+        return process.env[name] ?? "";
+    });
+}
+/**
+ * Resolve a provider config by name from settings.
+ * Returns null if provider not found.
+ */
+export function resolveProvider(name) {
+    const settings = getSettings();
+    const provider = settings.providers?.[name];
+    if (!provider)
+        return null;
+    const models = provider.models ?? (provider.defaultModel ? [provider.defaultModel] : []);
+    const defaultModel = provider.defaultModel ?? models[0];
+    return {
+        id: name,
+        apiKey: provider.apiKey ? expandEnvVars(provider.apiKey) : undefined,
+        baseURL: provider.baseURL,
+        defaultModel,
+        models: models.length ? models : (defaultModel ? [defaultModel] : []),
+        contextWindow: provider.contextWindow,
+    };
+}
+/** Get all configured provider names. */
+export function getProviderNames() {
+    const settings = getSettings();
+    return Object.keys(settings.providers ?? {});
+}

package/dist/shell.js

@@ -4,6 +4,7 @@ import * as path from "path";
 import * as pty from "node-pty";
 import { InputHandler } from "./input-handler.js";
 import { OutputParser } from "./output-parser.js";
+import { getSettings } from "./settings.js";
 export class Shell {
     ptyProcess;
     bus;
@@ -40,13 +41,16 @@ export class Shell {
         let shellArgs;
         const osc7Cmd = 'printf "\\e]7;file://%s%s\\a" "$(hostname)" "$PWD"';
         const promptMarker = 'printf "\\e]9999;PROMPT\\a"';
+        const titleCmd = 'printf "\\e]0;⚡ agent-sh: %s\\a" "${PWD/#$HOME/~}"';
         this.isZsh = isZsh;
+        const settings = getSettings();
+        const showIndicator = settings.promptIndicator !== false;
         if (isZsh) {
             // For zsh: use ZDOTDIR to source user's real config, then append
             // our hooks via precmd_functions (additive — doesn't clobber p10k/omz).
             this.tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "agent-sh-"));
             const userZdotdir = env.ZDOTDIR || env.HOME || os.homedir();
-            fs.writeFileSync(path.join(this.tmpDir, ".zshrc"), [
+            const zshrcLines = [
                 `ZDOTDIR="${userZdotdir}"`,
                 `[ -f "${userZdotdir}/.zshrc" ] && source "${userZdotdir}/.zshrc"`,
                 "",
@@ -54,32 +58,19 @@ export class Shell {
                 "__agent_sh_precmd() {",
                 `  ${osc7Cmd}`,
                 `  ${promptMarker}`,
+                ...(showIndicator ? [`  ${titleCmd}`] : []),
                 "}",
                 "precmd_functions+=(__agent_sh_precmd)",
                 "",
-                "# End-of-prompt marker via zle-line-init (fires after prompt is rendered)",
-                "# Chain onto existing widget (p10k uses zle-line-init) rather than clobbering",
-                'if (( ${+widgets[zle-line-init]} )); then',
-                "  zle -A zle-line-init __agent_sh_orig_line_init",
-                "  __agent_sh_line_init() {",
-                "    zle __agent_sh_orig_line_init",
-                '    printf "\\e]9998;READY\\a"',
-                "  }",
-                "else",
-                "  __agent_sh_line_init() {",
-                '    printf "\\e]9998;READY\\a"',
-                "  }",
-                "fi",
-                "zle -N zle-line-init __agent_sh_line_init",
-                "",
-                "# Hidden widget to trigger prompt redraw from Node.js side",
-                "# Bound to an unused escape sequence that no real key produces",
-                "__agent_sh_redraw() {",
-                "  zle reset-prompt",
+                "# Preexec hook: emit actual command text so agent-sh can track",
+                "# history-recalled and tab-completed commands accurately",
+                "__agent_sh_preexec() {",
+                '  printf "\\e]9997;%s\\a" "$1"',
                 "}",
-                "zle -N __agent_sh_redraw",
-                "bindkey '\\e[9999~' __agent_sh_redraw",
-            ].join("\n") + "\n");
+                "preexec_functions+=(__agent_sh_preexec)",
+            ];
+            zshrcLines.push("", "# End-of-prompt marker via zle-line-init (fires after prompt is rendered)", "# Chain onto existing widget (p10k uses zle-line-init) rather than clobbering", 'if (( ${+widgets[zle-line-init]} )); then', "  zle -A zle-line-init __agent_sh_orig_line_init", "  __agent_sh_line_init() {", "    zle __agent_sh_orig_line_init", '    printf "\\e]9998;READY\\a"', "  }", "else", "  __agent_sh_line_init() {", '    printf "\\e]9998;READY\\a"', "  }", "fi", "zle -N zle-line-init __agent_sh_line_init", "", "# Hidden widget to trigger prompt redraw from Node.js side", "# Bound to an unused escape sequence that no real key produces", "__agent_sh_redraw() {", "  zle reset-prompt", "}", "zle -N __agent_sh_redraw", "bindkey '\\e[9999~' __agent_sh_redraw");
+            fs.writeFileSync(path.join(this.tmpDir, ".zshrc"), zshrcLines.join("\n") + "\n");
             env.ZDOTDIR = this.tmpDir;
             shellArgs = ["--no-globalrcs"];
         }
@@ -88,15 +79,29 @@ export class Shell {
             // real bashrc then appends our hooks. No HOME override needed.
             this.tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "agent-sh-"));
             const userHome = env.HOME || os.homedir();
-            fs.writeFileSync(path.join(this.tmpDir, ".bashrc"), [
+            const bashrcLines = [
                 `[ -f "${userHome}/.bashrc" ] && source "${userHome}/.bashrc"`,
                 "",
                 "# agent-sh hooks (invisible OSC sequences for cwd + prompt detection)",
-                `PROMPT_COMMAND="\${PROMPT_COMMAND:+\$PROMPT_COMMAND;}${osc7Cmd}; ${promptMarker}"`,
+                `PROMPT_COMMAND="\${PROMPT_COMMAND:+\$PROMPT_COMMAND;}__agent_sh_preexec_ran=0; ${osc7Cmd}; ${promptMarker}${showIndicator ? `; ${titleCmd}` : ""}"`,
+                "",
+                "# Preexec hook via DEBUG trap: emit actual command text so agent-sh",
+                "# can track history-recalled and tab-completed commands accurately",
+                "__agent_sh_preexec_ran=0",
+                "__agent_sh_emit_preexec() {",
+                '  [[ $__agent_sh_preexec_ran == 1 ]] && return',
+                '  [[ -n $COMP_LINE ]] && return',
+                "  __agent_sh_preexec_ran=1",
+                "  local this_cmd",
+                `  this_cmd=$(HISTTIMEFORMAT='' builtin history 1 | command sed 's/^ *[0-9]* *//')`,
+                `  printf '\\e]9997;%s\\a' "$this_cmd"`,
+                "}",
+                "trap '__agent_sh_emit_preexec' DEBUG",
                 "",
                 "# End-of-prompt marker: append to PS1 (\\[...\\] marks it zero-width)",
                 'case "$PS1" in *9998*) ;; *) PS1="${PS1}\\[\\e]9998;READY\\a\\]";; esac',
-            ].join("\n") + "\n");
+            ];
+            fs.writeFileSync(path.join(this.tmpDir, ".bashrc"), bashrcLines.join("\n") + "\n");
             shellArgs = ["--rcfile", path.join(this.tmpDir, ".bashrc")];
         }
         // Pause stdin before spawning PTY to avoid TTY contention on macOS.
@@ -259,6 +264,7 @@ export class Shell {
             this.echoSkip = true;
             this.paused = false;
             process.stdout.write("\n");
+            this.bus.emit("shell:agent-exec-start", {});
             const output = await new Promise((resolve, reject) => {
                 const timeout = setTimeout(() => {
                     this.bus.off("shell:command-done", handler);
@@ -268,7 +274,7 @@ export class Shell {
                 const handler = (e) => {
                     clearTimeout(timeout);
                     this.bus.off("shell:command-done", handler);
-                    resolve({ output: e.output, cwd: e.cwd });
+                    resolve({ output: e.output, cwd: e.cwd, exitCode: e.exitCode });
                 };
                 this.bus.on("shell:command-done", handler);
                 this.outputParser.onCommandEntered(payload.command, this.outputParser.getCwd());
@@ -276,7 +282,8 @@ export class Shell {
             });
             this.paused = true;
             this.echoSkip = false;
-            return { ...payload, output: output.output, cwd: output.cwd, done: true };
+            this.bus.emit("shell:agent-exec-done", {});
+            return { ...payload, output: output.output, cwd: output.cwd, exitCode: output.exitCode, done: true };
         });
     }
     // ── Public API (used by index.ts) ──

package/dist/types.d.ts

@@ -1,18 +1,38 @@
 import type { EventBus } from "./event-bus.js";
 import type { ContextManager } from "./context-manager.js";
-import type { AcpClient } from "./acp-client.js";
+import type { LlmClient } from "./utils/llm-client.js";
 import type { ColorPalette } from "./utils/palette.js";
 import type { BlockTransformOptions, FencedBlockTransformOptions } from "./utils/stream-transform.js";
+import type { ToolDefinition } from "./agent/types.js";
 export type { ContentBlock } from "./event-bus.js";
 export type { BlockTransformOptions, FencedBlockTransformOptions } from "./utils/stream-transform.js";
+/** A model entry in the cycling list, optionally tied to a provider. */
+export interface AgentMode {
+    model: string;
+    /** Provider id — when cycling changes provider, LlmClient is reconfigured. */
+    provider?: string;
+    /** Provider-specific config for reconfiguring LlmClient on switch. */
+    providerConfig?: {
+        apiKey: string;
+        baseURL?: string;
+    };
+    /** Context window size in tokens (for usage display). */
+    contextWindow?: number;
+    /** Model supports reasoning/thinking tokens. */
+    reasoning?: boolean;
+    /** Provider supports the reasoning_effort parameter. */
+    supportsReasoningEffort?: boolean;
+}
 export interface AgentShellConfig {
-    agentCommand: string;
-    agentArgs: string[];
     shell?: string;
     model?: string;
     extensions?: string[];
-    /** Full shell environment (from user's rc files) for agent subprocess. */
-    shellEnv?: Record<string, string>;
+    /** API key for OpenAI-compatible provider. */
+    apiKey?: string;
+    /** Base URL for OpenAI-compatible API. */
+    baseURL?: string;
+    /** Named provider to use from settings.json. */
+    provider?: string;
 }
 /**
  * Context passed to user/third-party extensions.
@@ -23,7 +43,8 @@ export interface AgentShellConfig {
 export interface ExtensionContext {
     bus: EventBus;
     contextManager: ContextManager;
-    getAcpClient: () => AcpClient;
+    /** LLM client for fast-path features (null in ACP mode). */
+    llmClient: LlmClient | null;
     quit: () => void;
     /** Override color palette slots for theming. */
     setPalette: (overrides: Partial<ColorPalette>) => void;
@@ -33,6 +54,12 @@ export interface ExtensionContext {
     createFencedBlockTransform: (opts: FencedBlockTransformOptions) => void;
     /** Read extension-namespaced settings from ~/.agent-sh/settings.json. */
     getExtensionSettings: <T extends Record<string, unknown>>(namespace: string, defaults: T) => T;
+    /** Register a slash command available in any input mode. */
+    registerCommand: (name: string, description: string, handler: (args: string) => Promise<void> | void) => void;
+    /** Register a tool for the built-in agent. No-op when using bridge backends. */
+    registerTool: (tool: ToolDefinition) => void;
+    /** Get all registered tools (for subagent tool subsets). Returns [] when using bridge backends. */
+    getTools: () => ToolDefinition[];
     /** Register a named handler. */
     define: (name: string, fn: (...args: any[]) => any) => void;
     /** Wrap a named handler. Receives `next` (original) + args. */

package/dist/utils/box-frame.d.ts

@@ -6,8 +6,10 @@ export interface BoxFrameOptions {
     style?: BorderStyle;
     /** Border color (ANSI escape). Default DIM. */
     borderColor?: string;
-    /** Title text shown in the top border. */
+    /** Title text shown on the left of the top border. */
     title?: string;
+    /** Title text shown on the right of the top border. */
+    titleRight?: string;
     /** Footer lines shown below a divider, inside the box. */
     footer?: string[];
 }

package/dist/utils/box-frame.js

@@ -30,11 +30,18 @@ export function renderBoxFrame(content, opts) {
     // Content area width = total - 2 borders - 2 padding spaces
     const innerW = Math.max(1, width - 4);
     const output = [];
-    // Top border (with optional title)
-    if (opts.title) {
-        const titleVis = visibleLen(opts.title);
-        const afterDashes = Math.max(1, width - titleVis - 4);
-        output.push(`${bc}${b.tl}${p.reset} ${opts.title} ${bc}${b.h.repeat(afterDashes)}${b.tr}${p.reset}`);
+    // Top border (with optional left/right titles)
+    if (opts.title || opts.titleRight) {
+        const leftPart = opts.title
+            ? `${p.reset} ${opts.title} ${bc}`
+            : "";
+        const leftVis = opts.title ? visibleLen(opts.title) + 2 : 0; // +2 for spaces
+        const rightPart = opts.titleRight
+            ? `${p.reset} ${opts.titleRight} ${bc}`
+            : "";
+        const rightVis = opts.titleRight ? visibleLen(opts.titleRight) + 2 : 0;
+        const dashCount = Math.max(1, width - 2 - leftVis - rightVis);
+        output.push(`${bc}${b.tl}${leftPart}${b.h.repeat(dashCount)}${rightPart}${b.tr}${p.reset}`);
     }
     else {
         output.push(`${bc}${b.tl}${b.h.repeat(width - 2)}${b.tr}${p.reset}`);

package/dist/utils/diff.js

@@ -39,6 +39,16 @@ export function computeDiff(oldText, newText) {
     // Build LCS table and backtrack to produce diff lines
     const a = oldText.split("\n");
     const b = newText.split("\n");
+    // Bail out if LCS table would be too large (avoids OOM / hang)
+    if (a.length * b.length > 10_000_000) {
+        return {
+            hunks: [],
+            added: b.length,
+            removed: a.length,
+            isIdentical: false,
+            isNewFile: false,
+        };
+    }
     const dp = buildLcs(a, b);
     const raw = backtrack(dp, a, b);
     let added = 0;

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

@@ -0,0 +1,45 @@
+/**
+ * Thin, stateless wrapper around the OpenAI SDK.
+ * No agent-sh knowledge — just a configured client.
+ *
+ * Used by both AgentLoop (full tool loop) and fast-path features
+ * (command suggestions, completions).
+ */
+import OpenAI from "openai";
+import type { ChatCompletionMessageParam, ChatCompletionTool } from "openai/resources/chat/completions.js";
+export type { ChatCompletionMessageParam, ChatCompletionTool };
+export interface LlmClientConfig {
+    apiKey: string;
+    baseURL?: string;
+    model: string;
+}
+export declare class LlmClient {
+    private config;
+    private client;
+    model: string;
+    constructor(config: LlmClientConfig);
+    /** Swap the underlying client config at runtime (e.g. provider switch). */
+    reconfigure(newConfig: LlmClientConfig): void;
+    /**
+     * Create a streaming chat completion.
+     * Returns an async iterable of chunks.
+     */
+    stream(opts: {
+        messages: ChatCompletionMessageParam[];
+        tools?: ChatCompletionTool[];
+        model?: string;
+        max_tokens?: number;
+        /** Reasoning effort level (e.g. "low", "medium", "high"). Provider-dependent. */
+        reasoning_effort?: string;
+        signal?: AbortSignal;
+    }): import("openai").APIPromise<import("openai/core/streaming.mjs").Stream<OpenAI.Chat.Completions.ChatCompletionChunk>>;
+    /**
+     * Single-shot completion (no streaming) — for fast-path features.
+     * Returns the text content of the first choice.
+     */
+    complete(opts: {
+        messages: ChatCompletionMessageParam[];
+        model?: string;
+        max_tokens?: number;
+    }): Promise<string>;
+}

package/dist/utils/llm-client.js

@@ -0,0 +1,60 @@
+/**
+ * Thin, stateless wrapper around the OpenAI SDK.
+ * No agent-sh knowledge — just a configured client.
+ *
+ * Used by both AgentLoop (full tool loop) and fast-path features
+ * (command suggestions, completions).
+ */
+import OpenAI from "openai";
+export class LlmClient {
+    config;
+    client;
+    model;
+    constructor(config) {
+        this.config = config;
+        this.client = new OpenAI({
+            apiKey: config.apiKey,
+            baseURL: config.baseURL,
+        });
+        this.model = config.model;
+    }
+    /** Swap the underlying client config at runtime (e.g. provider switch). */
+    reconfigure(newConfig) {
+        this.config = newConfig;
+        this.client = new OpenAI({
+            apiKey: newConfig.apiKey,
+            baseURL: newConfig.baseURL,
+        });
+        this.model = newConfig.model;
+    }
+    /**
+     * Create a streaming chat completion.
+     * Returns an async iterable of chunks.
+     */
+    stream(opts) {
+        const body = {
+            model: opts.model ?? this.model,
+            messages: opts.messages,
+            tools: opts.tools?.length ? opts.tools : undefined,
+            max_tokens: opts.max_tokens ?? 8192,
+            stream: true,
+            stream_options: { include_usage: true },
+            ...(opts.reasoning_effort
+                ? { reasoning_effort: opts.reasoning_effort }
+                : {}),
+        };
+        return this.client.chat.completions.create(body, { signal: opts.signal });
+    }
+    /**
+     * Single-shot completion (no streaming) — for fast-path features.
+     * Returns the text content of the first choice.
+     */
+    async complete(opts) {
+        const response = await this.client.chat.completions.create({
+            model: opts.model ?? this.model,
+            messages: opts.messages,
+            max_tokens: opts.max_tokens ?? 1024,
+        });
+        return response.choices[0]?.message?.content ?? "";
+    }
+}

package/dist/utils/markdown.d.ts

@@ -15,6 +15,7 @@ export declare class MarkdownRenderer {
     private buffer;
     private contentWidth;
     private firstLine;
+    private lastLineBlank;
     private pendingLines;
     private width;
     private tableRows;

package/dist/utils/markdown.js

@@ -83,6 +83,7 @@ export class MarkdownRenderer {
     buffer = "";
     contentWidth;
     firstLine = true;
+    lastLineBlank = false;
     pendingLines = [];
     width;
     tableRows = [];
@@ -192,6 +193,9 @@ export class MarkdownRenderer {
         }
         // Render rows
         const hasHeader = sepIdx.includes(1) && dataRows.length > 1;
+        // Top border
+        const topBorder = colWidths.map((w) => "─".repeat(w)).join(`─┬─`);
+        this.writeLine(`${p.dim}┌─${topBorder}─┐${p.reset}`);
         for (let i = 0; i < dataRows.length; i++) {
             const row = dataRows[i];
             const isHeader = hasHeader && i === 0;
@@ -207,6 +211,9 @@ export class MarkdownRenderer {
                 this.writeLine(`${p.dim}├─${sep}─┤${p.reset}`);
             }
         }
+        // Bottom border
+        const bottomBorder = colWidths.map((w) => "─".repeat(w)).join(`─┴─`);
+        this.writeLine(`${p.dim}└─${bottomBorder}─┘${p.reset}`);
     }
     renderLine(line) {
         if (line.trim() === "")
@@ -224,14 +231,24 @@ export class MarkdownRenderer {
         const h4 = line.match(/^#{4,} (.+)/);
         if (h4)
             return `${p.bold}${h4[1]}${p.reset}`;
-        // Horizontal rule
+        // Horizontal rule — subtle short separator, not full-width
         if (/^(-{3,}|_{3,}|\*{3,})\s*$/.test(line)) {
-            return `${p.muted}${"─".repeat(this.contentWidth)}${p.reset}`;
+            return "";
         }
         // Blockquote
         const bq = line.match(/^>\s?(.*)/);
         if (bq)
             return `${p.muted}│${p.reset} ${p.dim}${p.italic}${this.renderInline(bq[1] || "")}${p.reset}`;
+        // Task list (checkbox items) — must come before generic unordered list
+        const task = line.match(/^(\s*)[*\-+]\s+\[([ xX])\]\s+(.*)/);
+        if (task) {
+            const indent = task[1] || "";
+            const checked = task[2] !== " ";
+            const box = checked
+                ? `${p.success}☑${p.reset}`
+                : `${p.dim}☐${p.reset}`;
+            return `${indent}  ${box} ${this.renderInline(task[3] || "")}`;
+        }
         // Unordered list
         const ul = line.match(/^(\s*)[*\-+]\s+(.*)/);
         if (ul) {
@@ -268,9 +285,14 @@ export class MarkdownRenderer {
      * The line is accumulated internally — call drainLines() to extract.
      */
     writeLine(text) {
-        if (this.firstLine && visibleLen(text) === 0)
+        const isBlank = visibleLen(text) === 0;
+        if (this.firstLine && isBlank)
+            return;
+        // Collapse consecutive blank lines to a single one
+        if (isBlank && this.lastLineBlank)
             return;
         this.firstLine = false;
+        this.lastLineBlank = isBlank;
         this.pendingLines.push(`  ${text}`);
     }
 }