agent-sh 0.15.6 → 0.15.8

package/dist/shell/tui-renderer.js

@@ -50,7 +50,6 @@ function createRenderState() {
         spinnerStartTime: 0,
         openTool: null,
         pendingToolCompletes: new Map(),
-        orphanContHeaderKind: undefined,
         currentToolKind: undefined,
         toolStartTime: 0,
         toolExitCode: null,
@@ -58,12 +57,6 @@ function createRenderState() {
         commandOutputLineCount: 0,
         commandOutputOverflow: 0,
         commandOverflowLines: [],
-        toolGroupKind: undefined,
-        toolGroupCount: 0,
-        toolGroupCompletedCount: 0,
-        toolGroupAllOk: true,
-        toolGroupRendered: 0,
-        toolGroupSummaries: [],
         isThinking: false,
         showThinkingText: false,
         thinkingPending: false,
@@ -113,15 +106,6 @@ export default function activate(ctx) {
             return `${p.success}✓${p.reset}${summaryStr}${timer}`;
         return `${p.error}✗ exit ${exitCode}${p.reset}${summaryStr}${timer}`;
     });
-    define("tui:render-tool-group-summary", (count, rendered, allOk, summaries) => {
-        const mark = allOk ? `${p.success}✓${p.reset}` : `${p.error}✗${p.reset}`;
-        const summaryStr = summaries.length > 0 ? ` ${p.dim}${summaries.join(", ")}${p.reset}` : "";
-        const collapsed = count - rendered;
-        if (collapsed > 0) {
-            return `  ${p.muted}└${p.reset} ${p.dim}+${collapsed} more${p.reset} ${mark}${summaryStr}`;
-        }
-        return `  ${p.muted}└${p.reset} ${mark}${summaryStr}`;
-    });
     define("tui:render-command-output", (line, _kind) => `${p.dim}  ${line}${p.reset}`);
     define("tui:render-spinner", (label, frame, elapsed, hint) => {
         const timer = elapsed ? ` ${p.dim}${elapsed}${p.reset}` : "";
@@ -245,33 +229,35 @@ export default function activate(ctx) {
     const GROUPABLE_KINDS = new Set(["read", "search"]);
     const GROUP_MAX_VISIBLE = 5;
     const KIND_ICONS = { read: "◆", search: "⌕" };
-    // Batch groups: kind → { total, rendered, headerShown }
     let batchGroups = new Map();
+    let batchSize = 0;
+    /** A lone tool has nothing to interleave with, so deferral applies only to
+     *  read-only kinds in a multi-tool batch. */
+    function isDeferred(kind) {
+        return batchSize > 1 && GROUPABLE_KINDS.has(kind) && batchGroups.has(kind);
+    }
     bus.on("agent:tool-batch", (e) => {
         if (!shouldRender())
             return;
         fencedTransform.flush();
-        finalizeToolGroup();
-        s.orphanContHeaderKind = undefined;
+        finalizeAllGroups();
+        closeToolLine();
         batchGroups = new Map();
+        batchSize = 0;
         for (const group of e.groups) {
-            batchGroups.set(group.kind, {
-                total: group.tools.length,
-                rendered: 0,
-                headerShown: false,
-            });
+            batchSize += group.tools.length;
+            batchGroups.set(group.kind, { total: group.tools.length, completed: 0, finalized: false, order: [], members: new Map() });
         }
     });
     bus.on("agent:tool-started", (e) => {
         if (!shouldRender())
             return;
         fencedTransform.flush();
-        stopCurrentSpinner();
         s.currentToolKind = e.kind;
         s.toolStartTime = Date.now();
-        s.orphanContHeaderKind = undefined;
         if (e.title === "user_shell") {
-            finalizeToolGroup();
+            stopCurrentSpinner();
+            finalizeAllGroups();
             closeToolLine();
             if (!s.renderer)
                 startAgentResponse();
@@ -284,89 +270,57 @@ export default function activate(ctx) {
             return;
         }
         const kind = e.kind ?? "execute";
-        const group = batchGroups.get(kind);
-        const isGrouped = group && group.total > 1 && GROUPABLE_KINDS.has(kind);
-        if (isGrouped) {
-            // Render group header on first tool of this kind in the batch
-            if (!group.headerShown) {
-                finalizeToolGroup();
-                closeToolLine();
-                if (!s.renderer)
-                    startAgentResponse();
-                showCollapsedThinking();
-                contentGap("tool");
-                s.renderer.flush();
-                drain();
-                const icon = KIND_ICONS[kind] ?? "▶";
-                s.renderer.writeLine(`${p.warning}${icon}${p.reset} ${kind}`);
-                drain();
-                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, groupContinuation: true });
-                s.toolGroupRendered++;
-            }
-            if (e.toolCallId) {
-                s.pendingToolCompletes.set(e.toolCallId, {
-                    title: e.title,
-                    kind,
-                    displayDetail: e.displayDetail ?? extractDetail(e),
-                });
-            }
-        }
-        else {
-            // Standalone tool — single in its batch kind, or not groupable
-            finalizeToolGroup();
-            showToolCall(e.title, "", { ...e });
+        if (isDeferred(kind)) {
+            const group = batchGroups.get(kind);
+            const id = e.toolCallId ?? `${kind}-${group.order.length}`;
+            group.order.push(id);
+            group.members.set(id, { detail: e.displayDetail ?? extractDetail(e), ok: true, done: false });
+            s.hadToolCalls = true;
+            if (!s.spinner)
+                startThinkingSpinner(); // nothing's drawn yet — stand in until the block renders
+            return;
         }
+        // Eager: a single-tool turn, or a sequential mutating/streaming tool.
+        stopCurrentSpinner();
+        showToolCall(e.title, "", { ...e });
     });
     bus.on("agent:tool-completed", (e) => {
         if (!shouldRender())
             return;
         s.toolExitCode = e.exitCode;
-        if (e.exitCode !== 0)
-            s.toolGroupAllOk = false;
         const resultDisplay = e.resultDisplay;
-        if (s.toolGroupKind) {
-            // Grouped tool — track success/failure and summaries, show aggregate on ⎿ line.
-            // Don't restart spinner between grouped tools — it's already running from group start.
-            if (resultDisplay?.summary)
-                s.toolGroupSummaries.push(resultDisplay.summary);
-            if (e.toolCallId)
-                s.pendingToolCompletes.delete(e.toolCallId);
-            s.toolGroupCompletedCount++;
-            s.currentToolKind = undefined;
-            // Finalize as soon as all members return so aggregate lands right
-            // after its children, not below out-of-band renders from the next tool.
-            const batchGroup = batchGroups.get(s.toolGroupKind);
-            if (batchGroup && s.toolGroupCompletedCount >= batchGroup.total) {
-                finalizeToolGroup();
+        const kind = e.kind ?? "execute";
+        const group = batchGroups.get(kind);
+        if (isDeferred(kind) && group) {
+            const id = e.toolCallId ?? group.order[group.completed];
+            const member = id ? group.members.get(id) : undefined;
+            if (member) {
+                member.done = true;
+                member.ok = e.exitCode === 0;
+                member.summary = resultDisplay?.summary;
             }
+            group.completed++;
+            s.currentToolKind = undefined;
+            flushReadyGroups();
+            if (!s.spinner)
+                startThinkingSpinner(); // keep the spinner up for in-flight siblings
         }
         else {
-            // Tools that lost the inline slot render as a labeled ⎿. Orphans
-            // (group finalized before they returned) reroute via showOrphanedComplete.
             const pending = e.toolCallId ? s.pendingToolCompletes.get(e.toolCallId) : undefined;
             if (pending)
                 s.pendingToolCompletes.delete(e.toolCallId);
-            if (pending?.orphaned) {
-                showOrphanedComplete(e.exitCode, resultDisplay, pending.title, pending.kind, pending.displayDetail);
-            }
-            else {
-                showToolComplete(e.exitCode, resultDisplay, pending?.displayDetail ?? pending?.title);
-            }
+            showToolComplete(e.exitCode, resultDisplay, pending?.displayDetail ?? pending?.title);
             s.currentToolKind = undefined;
             s.spinnerStartTime = 0;
             startThinkingSpinner();
         }
     });
+    bus.on("agent:tool-batch-complete", () => {
+        if (!shouldRender())
+            return;
+        // Backstop for a group whose members didn't all complete (e.g. errored).
+        finalizeAllGroups();
+    });
     bus.on("agent:tool-output-chunk", (e) => { if (shouldRender())
         writeCommandOutput(e.chunk); });
     bus.on("agent:tool-output", () => { if (shouldRender())
@@ -465,7 +419,7 @@ export default function activate(ctx) {
         }
     }
     function endAgentResponse() {
-        finalizeToolGroup();
+        finalizeAllGroups();
         closeToolLine();
         stopCurrentSpinner();
         if (s.renderer) {
@@ -502,7 +456,7 @@ export default function activate(ctx) {
         }
     }
     function writeAgentText(text) {
-        finalizeToolGroup();
+        finalizeAllGroups();
         closeToolLine();
         s.hadToolCalls = false;
         if (s.isThinking) {
@@ -526,7 +480,7 @@ export default function activate(ctx) {
         flushForRaw();
         contentGap("code");
         if (language) {
-            s.renderer.writeLine(`${p.dim}${language}${p.reset}`);
+            s.renderer.writeLine(`${p.mdCodeBlockBorder}${language}${p.reset}`);
         }
         let highlighted;
         try {
@@ -549,7 +503,10 @@ export default function activate(ctx) {
             }
         }
         catch {
-            highlighted = code;
+            highlighted = code
+                .split("\n")
+                .map((l) => `${p.mdCodeBlock}${l}${p.reset}`)
+                .join("\n");
         }
         const contentWidth = Math.min(90, width - 2);
         for (const line of highlighted.split("\n")) {
@@ -711,9 +668,7 @@ export default function activate(ctx) {
         if (!s.renderer)
             startAgentResponse();
         showCollapsedThinking();
-        // No gap between grouped tools — they're visually connected
-        if (!extra?.groupContinuation)
-            contentGap("tool");
+        contentGap("tool");
         s.renderer.flush();
         drain();
         const lines = renderToolCall({
@@ -725,37 +680,19 @@ export default function activate(ctx) {
             rawInput: extra?.rawInput,
             displayDetail: extra?.displayDetail,
         }, cappedW(), shellCwd);
-        if (extra?.groupContinuation && lines.length > 0) {
-            // Swap the colored kind icon for a muted tree connector,
-            // and strip the tool name prefix — show detail only.
-            const detail = extra.displayDetail || extractDetail(extra);
-            const maxW = Math.max(1, cappedW() - 6);
-            const text = detail.length > maxW ? detail.slice(0, maxW - 1) + "…" : detail;
-            lines[0] = detail
-                ? `${p.muted}├${p.reset} ${p.dim}${text}${p.reset}`
-                : lines[0].replace(/^\x1b\[[^m]*m.\x1b\[0m/, `${p.muted}├${p.reset}`);
-        }
-        const batchPrefix = "";
         for (let i = 0; i < lines.length - 1; i++) {
             s.renderer.writeLine(lines[i]);
         }
         drain();
         if (lines.length > 0) {
-            if (extra?.groupContinuation) {
-                // Grouped tools: close the line immediately — checkmarks go on the ⎿ summary
-                s.renderer.writeLine(`  ${batchPrefix}${lines[lines.length - 1]}`);
-                drain();
-            }
-            else {
-                out().write(`  ${batchPrefix}${lines[lines.length - 1]}`);
-                if (extra?.toolCallId) {
-                    s.openTool = {
-                        callId: extra.toolCallId,
-                        title,
-                        kind: extra.kind,
-                        displayDetail: extra.displayDetail ?? extractDetail(extra),
-                    };
-                }
+            out().write(`  ${lines[lines.length - 1]}`);
+            if (extra?.toolCallId) {
+                s.openTool = {
+                    callId: extra.toolCallId,
+                    title,
+                    kind: extra.kind,
+                    displayDetail: extra.displayDetail ?? extractDetail(extra),
+                };
             }
         }
         s.hadToolCalls = true;
@@ -783,26 +720,6 @@ export default function activate(ctx) {
         if (resultDisplay?.body)
             renderResultBody(resultDisplay.body);
     }
-    /** Late completion from a finalized group — re-emit the kind header
-     *  in muted "(cont.)" form so the ⎿ has a legitimate parent, then
-     *  render the completion as a normal labeled ⎿. Subsequent orphans
-     *  of the same kind reuse the existing (cont.) header. */
-    function showOrphanedComplete(exitCode, resultDisplay, title, kind, displayDetail) {
-        if (s.orphanContHeaderKind !== kind) {
-            stopCurrentSpinner();
-            closeToolLine();
-            flushCommandOutput();
-            if (!s.renderer)
-                startAgentResponse();
-            showCollapsedThinking();
-            const icon = (kind && KIND_ICONS[kind]) ?? "▶";
-            const label = kind ?? "tool";
-            s.renderer.writeLine(`${p.muted}${icon} ${label} (cont.)${p.reset}`);
-            drain();
-            s.orphanContHeaderKind = kind;
-        }
-        showToolComplete(exitCode, resultDisplay, displayDetail || title);
-    }
     function renderResultBody(body) {
         if (!s.renderer)
             return;
@@ -849,7 +766,7 @@ export default function activate(ctx) {
     function closeToolLine() {
         if (s.openTool) {
             out().write("\n");
-            // Stash identity so the completion renders as ⎿ labeled, not orphan ✓.
+            // Stash identity so the completion renders as ⎿ labeled, not inline ✓.
             s.pendingToolCompletes.set(s.openTool.callId, {
                 title: s.openTool.title,
                 kind: s.openTool.kind,
@@ -858,40 +775,64 @@ export default function activate(ctx) {
             s.openTool = null;
         }
     }
-    /** Render the group aggregate ⎿ line, or skip if no members have
-     *  completed yet (late completes will render individually as ⎿ labeled). */
-    function finalizeToolGroup() {
-        // Late completes from this group have lost their inline slot; mark
-        // them so showOrphanedComplete re-emits a (cont.) header for their ⎿.
-        if (s.toolGroupKind) {
-            for (const pending of s.pendingToolCompletes.values()) {
-                if (pending.kind === s.toolGroupKind)
-                    pending.orphaned = true;
-            }
-        }
-        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 = [];
+    /** Render a deferred group as one contiguous block, skipping a group with no
+     *  completed members (e.g. all errored before their events fired). */
+    function finalizeGroup(kind) {
+        const group = batchGroups.get(kind);
+        if (!group || group.finalized)
+            return;
+        group.finalized = true;
+        const members = group.order
+            .map((id) => group.members.get(id))
+            .filter((m) => !!m && m.done);
+        if (members.length === 0)
             return;
-        }
         stopCurrentSpinner();
         closeToolLine();
         if (!s.renderer)
             startAgentResponse();
-        const groupLine = ctx.call("tui:render-tool-group-summary", s.toolGroupCount, s.toolGroupRendered, s.toolGroupAllOk, s.toolGroupSummaries);
-        s.renderer.writeLine(groupLine);
+        showCollapsedThinking();
+        contentGap("tool");
+        s.renderer.flush();
         drain();
-        s.toolGroupKind = undefined;
-        s.toolGroupCount = 0;
-        s.toolGroupCompletedCount = 0;
-        s.toolGroupAllOk = true;
-        s.toolGroupRendered = 0;
-        s.toolGroupSummaries = [];
+        const icon = KIND_ICONS[kind] ?? "▶";
+        const mark = (m) => ctx.call("tui:render-tool-complete", m.ok ? 0 : 1, "", m.summary);
+        if (members.length === 1) {
+            const m = members[0];
+            s.renderer.writeLine(`${p.warning}${icon}${p.reset} ${kind} ${p.dim}${m.detail}${p.reset} ${mark(m)}`);
+        }
+        else {
+            s.renderer.writeLine(`${p.warning}${icon}${p.reset} ${kind}`);
+            const shown = Math.min(members.length, GROUP_MAX_VISIBLE);
+            const allShown = members.length <= GROUP_MAX_VISIBLE;
+            for (let i = 0; i < shown; i++) {
+                const m = members[i];
+                const connector = allShown && i === shown - 1 ? "└" : "├";
+                s.renderer.writeLine(`  ${p.muted}${connector}${p.reset} ${p.dim}${m.detail}${p.reset} ${mark(m)}`);
+            }
+            if (!allShown) {
+                s.renderer.writeLine(`  ${p.muted}└${p.reset} ${p.dim}+${members.length - shown} more${p.reset}`);
+            }
+        }
+        drain();
+    }
+    function finalizeAllGroups() {
+        for (const kind of batchGroups.keys())
+            finalizeGroup(kind);
+    }
+    /** Finalize ready groups in batch order, stopping at the first still in
+     *  flight — so blocks render in dispatch order, not completion order. */
+    function flushReadyGroups() {
+        for (const [kind, group] of batchGroups) {
+            if (group.finalized)
+                continue;
+            // Eager (non-groupable) groups never increment `completed`, so one earlier
+            // in batch order is a barrier here: a deferred group after it renders at
+            // the tool-batch-complete backstop, not incrementally. Order is preserved.
+            if (group.completed < group.total)
+                break;
+            finalizeGroup(kind);
+        }
     }
     function renderCommandLine(line) {
         return ctx.call("tui:render-command-output", line, s.currentToolKind);

package/dist/utils/executor.js

@@ -1,5 +1,6 @@
 import { spawn, spawnSync } from "node:child_process";
 import { existsSync } from "node:fs";
+import { StringDecoder } from "node:string_decoder";
 import { stripAnsi } from "./ansi.js";
 // Node reports a missing cwd as `spawn <binary> ENOENT` — disambiguate.
 function explainSpawnError(err, cwd) {
@@ -77,21 +78,23 @@ export function executeCommand(opts) {
         return { session, done };
     }
     session.process = child;
-    const handleData = (data) => {
-        const raw = data.toString("utf-8");
+    const handleText = (raw) => {
+        if (!raw)
+            return;
         const clean = stripAnsi(raw);
-        // Accumulate cleaned output for the agent
         session.output += clean;
-        // Enforce output cap — truncate from beginning, keep tail
         if (session.output.length > maxOutput) {
             session.output = session.output.slice(-maxOutput);
             session.truncated = true;
         }
-        // Real-time streaming callback
         opts.onOutput?.(raw);
     };
-    child.stdout?.on("data", handleData);
-    child.stderr?.on("data", handleData);
+    const outDecoder = new StringDecoder("utf-8");
+    const errDecoder = new StringDecoder("utf-8");
+    child.stdout?.on("data", (d) => handleText(outDecoder.write(d)));
+    child.stderr?.on("data", (d) => handleText(errDecoder.write(d)));
+    child.stdout?.on("end", () => handleText(outDecoder.end()));
+    child.stderr?.on("end", () => handleText(errDecoder.end()));
     let cancelKill;
     const timer = setTimeout(() => {
         if (!session.done) {
@@ -169,8 +172,9 @@ export function executeArgv(opts) {
         return { session, done };
     }
     session.process = child;
-    const handleData = (data) => {
-        const raw = data.toString("utf-8");
+    const handleText = (raw) => {
+        if (!raw)
+            return;
         const clean = stripAnsi(raw);
         session.output += clean;
         if (session.output.length > maxOutput) {
@@ -179,8 +183,12 @@ export function executeArgv(opts) {
         }
         opts.onOutput?.(raw);
     };
-    child.stdout?.on("data", handleData);
-    child.stderr?.on("data", handleData);
+    const outDecoder = new StringDecoder("utf-8");
+    const errDecoder = new StringDecoder("utf-8");
+    child.stdout?.on("data", (d) => handleText(outDecoder.write(d)));
+    child.stderr?.on("data", (d) => handleText(errDecoder.write(d)));
+    child.stdout?.on("end", () => handleText(outDecoder.end()));
+    child.stderr?.on("end", () => handleText(errDecoder.end()));
     const timer = setTimeout(() => {
         if (!session.done && session.process) {
             try {

package/dist/utils/floating-panel.d.ts

@@ -222,6 +222,7 @@ export declare class FloatingPanel {
     private updateAutocomplete;
     private applyAutocomplete;
     private clearAutocomplete;
+    private moveAutocomplete;
     private handleIntercept;
     /**
      * Handle scroll input. Returns true if consumed.

package/dist/utils/floating-panel.js

@@ -637,6 +637,13 @@ export class FloatingPanel {
         this.autocompleteItems = [];
         this.autocompleteIndex = 0;
     }
+    moveAutocomplete(delta) {
+        const n = this.autocompleteItems.length;
+        if (n === 0)
+            return;
+        this.autocompleteIndex = (this.autocompleteIndex + delta + n) % n;
+        this.render();
+    }
     // ── Input handling ──────────────────────────────────────────
     handleIntercept(payload) {
         const consumed = { ...payload, consumed: true };
@@ -746,6 +753,16 @@ export class FloatingPanel {
         }
         if (this.handleScroll(data, false))
             return;
+        if (data === "\x10" || data === "\x0e") {
+            const forward = data === "\x0e";
+            if (this.autocompleteActive) {
+                this.moveAutocomplete(forward ? 1 : -1);
+            }
+            else if (forward ? this.editor.historyForward() : this.editor.historyBack()) {
+                this.render();
+            }
+            return;
+        }
         const actions = this.editor.feed(data);
         for (const action of actions) {
             switch (action.action) {
@@ -760,6 +777,7 @@ export class FloatingPanel {
                     this.editor.pushHistory(query);
                     this.editor.clear();
                     this.clearAutocomplete();
+                    this.userScrolled = false;
                     // Phase change is the submit handler's call — sync slash commands
                     // (e.g. /model, /help) keep the user in input mode.
                     this.handlers.call(`${this.prefix}:submit`, query);
@@ -782,34 +800,18 @@ export class FloatingPanel {
                 case "shift+tab":
                     this.render();
                     break;
-                case "arrow-up": {
-                    if (this.autocompleteActive) {
-                        this.autocompleteIndex = this.autocompleteIndex === 0
-                            ? this.autocompleteItems.length - 1
-                            : this.autocompleteIndex - 1;
-                        this.render();
-                    }
-                    else {
-                        const hist = this.editor.historyBack();
-                        if (hist)
-                            this.render();
-                    }
+                case "arrow-up":
+                    if (this.autocompleteActive)
+                        this.moveAutocomplete(-1);
+                    else
+                        this.scrollUp(1);
                     break;
-                }
-                case "arrow-down": {
-                    if (this.autocompleteActive) {
-                        this.autocompleteIndex = this.autocompleteIndex === this.autocompleteItems.length - 1
-                            ? 0
-                            : this.autocompleteIndex + 1;
-                        this.render();
-                    }
-                    else {
-                        const hist = this.editor.historyForward();
-                        if (hist)
-                            this.render();
-                    }
+                case "arrow-down":
+                    if (this.autocompleteActive)
+                        this.moveAutocomplete(1);
+                    else
+                        this.scrollDown(1);
                     break;
-                }
                 case "changed":
                 case "delete-empty":
                     this.updateAutocomplete();

package/dist/utils/markdown.js

@@ -332,27 +332,25 @@ export class MarkdownRenderer {
     renderLine(line) {
         if (line.trim() === "")
             return "";
-        // Headings
-        const h1 = line.match(/^# (.+)/);
-        if (h1)
-            return `${p.bold}${p.warning}${h1[1]}${p.reset}`;
-        const h2 = line.match(/^## (.+)/);
-        if (h2)
-            return `${p.bold}${p.accent}${h2[1]}${p.reset}`;
-        const h3 = line.match(/^### (.+)/);
-        if (h3)
-            return `${p.bold}${h3[1]}${p.reset}`;
-        const h4 = line.match(/^#{4,} (.+)/);
-        if (h4)
-            return `${p.bold}${h4[1]}${p.reset}`;
-        // Horizontal rule — subtle short separator, not full-width
+        // Headings — H3+ keep the `###` marker; H1/H2 don't
+        const heading = line.match(/^(#{1,6}) (.+)/);
+        if (heading) {
+            const level = heading[1].length;
+            const text = heading[2];
+            if (level === 1)
+                return `${p.bold}${p.underline}${p.mdHeading}${text}${p.reset}`;
+            if (level === 2)
+                return `${p.bold}${p.mdHeading}${text}${p.reset}`;
+            return `${p.bold}${p.mdHeading}${"#".repeat(level)} ${text}${p.reset}`;
+        }
+        // Horizontal rule
         if (/^(-{3,}|_{3,}|\*{3,})\s*$/.test(line)) {
-            return "";
+            return `${p.mdHr}${"─".repeat(Math.min(this.contentWidth, 80))}${p.reset}`;
         }
         // Blockquote
         const bq = line.match(/^>\s?(.*)/);
         if (bq)
-            return `${p.muted}│${p.reset} ${p.dim}${p.italic}${this.renderInline(bq[1] || "")}${p.reset}`;
+            return `${p.mdQuoteBorder}│${p.reset} ${p.mdQuote}${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) {
@@ -367,21 +365,21 @@ export class MarkdownRenderer {
         const ul = line.match(/^(\s*)[*\-+]\s+(.*)/);
         if (ul) {
             const indent = ul[1] || "";
-            return `${indent}  ${p.accent}*${p.reset} ${this.renderInline(ul[2] || "")}`;
+            return `${indent}  ${p.mdListBullet}-${p.reset} ${this.renderInline(ul[2] || "")}`;
         }
         // Ordered list
         const ol = line.match(/^(\s*)(\d+)[.)]\s+(.*)/);
         if (ol) {
             const indent = ol[1] || "";
-            return `${indent}  ${p.accent}${ol[2]}.${p.reset} ${this.renderInline(ol[3] || "")}`;
+            return `${indent}  ${p.mdListBullet}${ol[2]}.${p.reset} ${this.renderInline(ol[3] || "")}`;
         }
         return this.renderInline(line);
     }
     renderInline(text) {
         // Links first — later subs inject `\x1b[…m` whose `[` would be eaten here.
-        text = text.replace(/\[([^\]]+)\]\(([^)]+)\)/g, `$1 ${p.muted}${p.underline}($2)${p.reset}`);
+        text = text.replace(/\[([^\]]+)\]\(([^)]+)\)/g, `${p.mdLink}${p.underline}$1${p.reset} ${p.mdLinkUrl}($2)${p.reset}`);
         // Inline code
-        text = text.replace(/`([^`]+)`/g, `${p.accent}$1${p.reset}`);
+        text = text.replace(/`([^`]+)`/g, `${p.mdCode}$1${p.reset}`);
         // Bold + italic
         text = text.replace(/\*\*\*(.+?)\*\*\*/g, `${p.bold}${p.italic}$1${p.reset}`);
         // Bold
@@ -391,7 +389,7 @@ export class MarkdownRenderer {
         text = text.replace(/\*(.+?)\*/g, `${p.italic}$1${p.reset}`);
         text = text.replace(/(?<!\w)_(.+?)_(?!\w)/g, `${p.italic}$1${p.reset}`);
         // Strikethrough
-        text = text.replace(/~~(.+?)~~/g, `${p.dim}$1${p.reset}`);
+        text = text.replace(/~~(.+?)~~/g, `${p.strikethrough}$1${p.reset}`);
         return text;
     }
     /**