@zhijiewang/openharness 2.24.0 → 2.26.0

package/dist/Tool.d.ts

@@ -8,6 +8,7 @@ import type { PermissionMode, RiskLevel } from "./types/permissions.js";
 export type ToolResult = {
     output: string;
     isError: boolean;
+    outputType?: "json" | "markdown" | "image" | "plain";
 };
 export type ToolContext = {
     workingDir: string;

package/dist/renderer/index.js

@@ -4,6 +4,7 @@
  * right after the scrollback content each frame (no absolute positioning gap).
  */
 import { recordApproval } from "../harness/approvals.js";
+import { appendToolPermission } from "../harness/config.js";
 import { getTheme } from "../utils/theme-data.js";
 import { summarizeToolArgs } from "../utils/tool-summary.js";
 import { CellGrid } from "./cells.js";
@@ -396,9 +397,6 @@ export class TerminalRenderer {
             // exists (we don't auto-create on first interaction).
             if (k === "a" && toolName) {
                 try {
-                    // Lazy import to avoid pulling config into the renderer bundle
-                    // for callers that don't trip the permission path.
-                    const { appendToolPermission } = require("../harness/config.js");
                     appendToolPermission(toolName);
                 }
                 catch {

package/dist/renderer/json-tree.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Static JSON tree renderer for tool output.
+ * Theme-colored, indented, depth-truncated, line-truncated.
+ */
+import type { CellGrid } from "./cells.js";
+export declare function resetJsonStyleCache(): void;
+export declare function renderJsonTree(grid: CellGrid, row: number, col: number, value: unknown, width: number, opts: {
+    maxLines: number;
+    limit: number;
+}): number;
+//# sourceMappingURL=json-tree.d.ts.map

package/dist/renderer/json-tree.js

@@ -0,0 +1,194 @@
+/**
+ * Static JSON tree renderer for tool output.
+ * Theme-colored, indented, depth-truncated, line-truncated.
+ */
+import { getTheme } from "../utils/theme-data.js";
+const s = (fg, bold = false, dim = false) => ({ fg, bg: null, bold, dim, underline: false });
+const MAX_DEPTH = 3;
+let S_KEY;
+let S_STRING;
+let S_NUMBER;
+let S_PUNCT;
+let S_TRUNC;
+let _stylesInit = false;
+export function resetJsonStyleCache() {
+    _stylesInit = false;
+}
+function ensureStyles() {
+    if (_stylesInit)
+        return;
+    _stylesInit = true;
+    const t = getTheme();
+    S_KEY = s(t.user);
+    S_STRING = s(t.success);
+    S_NUMBER = s(t.tool);
+    S_PUNCT = s(null, false, true);
+    S_TRUNC = s(null, false, true);
+}
+export function renderJsonTree(grid, row, col, value, width, opts) {
+    ensureStyles();
+    const lines = [];
+    const seen = new Set();
+    emitValue(lines, value, 0, 0, seen);
+    const maxRows = Math.min(opts.limit - row, opts.maxLines);
+    if (maxRows <= 0)
+        return 0;
+    const truncated = lines.length > maxRows;
+    const visible = truncated ? lines.slice(0, maxRows - 1) : lines;
+    let r = row;
+    for (const line of visible) {
+        if (r >= opts.limit)
+            break;
+        let c = col + line.indent;
+        for (const tok of line.tokens) {
+            for (let i = 0; i < tok.text.length; i++) {
+                if (c >= col + width)
+                    break;
+                grid.setCell(r, c, tok.text[i], tok.style);
+                c++;
+            }
+        }
+        r++;
+    }
+    if (truncated && r < opts.limit) {
+        const footer = `… (${lines.length} lines total)`;
+        grid.writeText(r, col, footer.slice(0, width), S_TRUNC);
+        r++;
+    }
+    return r - row;
+}
+function emitValue(out, value, indent, depth, seen) {
+    if (value === null) {
+        out.push({ indent, tokens: [{ text: "null", style: S_NUMBER }] });
+        return;
+    }
+    if (typeof value === "string") {
+        out.push({ indent, tokens: [{ text: JSON.stringify(value), style: S_STRING }] });
+        return;
+    }
+    if (typeof value === "number" || typeof value === "boolean") {
+        out.push({ indent, tokens: [{ text: String(value), style: S_NUMBER }] });
+        return;
+    }
+    if (Array.isArray(value)) {
+        if (value.length === 0) {
+            out.push({ indent, tokens: [{ text: "[]", style: S_PUNCT }] });
+            return;
+        }
+        if (depth >= MAX_DEPTH) {
+            out.push({ indent, tokens: [{ text: `[${value.length} items]`, style: S_TRUNC }] });
+            return;
+        }
+        if (seen.has(value)) {
+            out.push({ indent, tokens: [{ text: "[Circular]", style: S_TRUNC }] });
+            return;
+        }
+        seen.add(value);
+        out.push({ indent, tokens: [{ text: "[", style: S_PUNCT }] });
+        for (let i = 0; i < value.length; i++) {
+            emitValueAsItem(out, value[i], indent + 2, depth + 1, seen, i < value.length - 1);
+        }
+        out.push({ indent, tokens: [{ text: "]", style: S_PUNCT }] });
+        seen.delete(value);
+        return;
+    }
+    if (typeof value === "object") {
+        const entries = Object.entries(value);
+        if (entries.length === 0) {
+            out.push({ indent, tokens: [{ text: "{}", style: S_PUNCT }] });
+            return;
+        }
+        if (depth >= MAX_DEPTH) {
+            out.push({ indent, tokens: [{ text: "{…}", style: S_TRUNC }] });
+            return;
+        }
+        if (seen.has(value)) {
+            out.push({ indent, tokens: [{ text: "[Circular]", style: S_TRUNC }] });
+            return;
+        }
+        seen.add(value);
+        out.push({ indent, tokens: [{ text: "{", style: S_PUNCT }] });
+        for (let i = 0; i < entries.length; i++) {
+            const [k, v] = entries[i];
+            emitObjectEntry(out, k, v, indent + 2, depth + 1, seen, i < entries.length - 1);
+        }
+        out.push({ indent, tokens: [{ text: "}", style: S_PUNCT }] });
+        seen.delete(value);
+        return;
+    }
+    out.push({ indent, tokens: [{ text: String(value), style: S_TRUNC }] });
+}
+function emitValueAsItem(out, value, indent, depth, seen, trailingComma) {
+    const before = out.length;
+    emitValue(out, value, indent, depth, seen);
+    if (trailingComma && out.length > before) {
+        const last = out[out.length - 1];
+        last.tokens.push({ text: ",", style: S_PUNCT });
+    }
+}
+function emitObjectEntry(out, key, value, indent, depth, seen, trailingComma) {
+    const keyTok = { text: JSON.stringify(key), style: S_KEY };
+    const colonTok = { text: ": ", style: S_PUNCT };
+    // Inline primitives onto the same line as the key.
+    if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+        const valStyle = typeof value === "string" ? S_STRING : S_NUMBER;
+        const valText = typeof value === "string" ? JSON.stringify(value) : String(value);
+        const tokens = [keyTok, colonTok, { text: valText, style: valStyle }];
+        if (trailingComma)
+            tokens.push({ text: ",", style: S_PUNCT });
+        out.push({ indent, tokens });
+        return;
+    }
+    // Empty container inlines too: "key": {} / "key": []
+    if (Array.isArray(value) && value.length === 0) {
+        const tokens = [keyTok, colonTok, { text: "[]", style: S_PUNCT }];
+        if (trailingComma)
+            tokens.push({ text: ",", style: S_PUNCT });
+        out.push({ indent, tokens });
+        return;
+    }
+    if (value && typeof value === "object" && !Array.isArray(value) && Object.keys(value).length === 0) {
+        const tokens = [keyTok, colonTok, { text: "{}", style: S_PUNCT }];
+        if (trailingComma)
+            tokens.push({ text: ",", style: S_PUNCT });
+        out.push({ indent, tokens });
+        return;
+    }
+    // Depth-collapsed container also inlines.
+    if (depth >= MAX_DEPTH) {
+        const collapsed = Array.isArray(value) ? `[${value.length} items]` : "{…}";
+        out.push({ indent, tokens: [keyTok, colonTok, { text: collapsed, style: S_TRUNC }] });
+        return;
+    }
+    // Circular reference: render inline, no descent.
+    if (seen.has(value)) {
+        const circ = [keyTok, colonTok, { text: "[Circular]", style: S_TRUNC }];
+        if (trailingComma)
+            circ.push({ text: ",", style: S_PUNCT });
+        out.push({ indent, tokens: circ });
+        return;
+    }
+    // Non-empty container: open bracket on key line, body indented, close bracket on its own line.
+    const opener = Array.isArray(value) ? "[" : "{";
+    const closer = Array.isArray(value) ? "]" : "}";
+    out.push({ indent, tokens: [keyTok, colonTok, { text: opener, style: S_PUNCT }] });
+    seen.add(value);
+    if (Array.isArray(value)) {
+        for (let i = 0; i < value.length; i++) {
+            emitValueAsItem(out, value[i], indent + 2, depth + 1, seen, i < value.length - 1);
+        }
+    }
+    else {
+        const entries = Object.entries(value);
+        for (let i = 0; i < entries.length; i++) {
+            const [ck, cv] = entries[i];
+            emitObjectEntry(out, ck, cv, indent + 2, depth + 1, seen, i < entries.length - 1);
+        }
+    }
+    seen.delete(value);
+    const closerTokens = [{ text: closer, style: S_PUNCT }];
+    if (trailingComma)
+        closerTokens.push({ text: ",", style: S_PUNCT });
+    out.push({ indent, tokens: closerTokens });
+}
+//# sourceMappingURL=json-tree.js.map

package/dist/renderer/layout-sections.js

@@ -4,7 +4,9 @@
  */
 import { getTheme } from "../utils/theme-data.js";
 import { renderDiff } from "./diff.js";
-import { isImageOutput, renderImageInline } from "./image.js";
+import { renderToolOutput } from "./output-renderer.js";
+import { deriveSpinnerLabel } from "./spinner-label.js";
+import { toolColor } from "./tool-color.js";
 // ── Style constants ──
 const s = (fg, bold = false, dim = false) => ({ fg, bg: null, bold, dim, underline: false });
 export const S_TEXT = s(null);
@@ -93,14 +95,14 @@ export function renderThinkingSummarySection(state, grid, r, limit) {
 export function renderSpinnerSection(state, grid, r, limit) {
     if (!state.loading || state.streamingText || state.thinkingText || r >= limit)
         return r;
-    const thinkText = "Thinking";
+    const thinkText = deriveSpinnerLabel(state.toolCalls);
     const elapsed = state.thinkingStartedAt ? Math.floor((Date.now() - state.thinkingStartedAt) / 1000) : 0;
     const t = getTheme();
     const baseColor = elapsed > 60 ? t.error : elapsed > 30 ? t.stall : t.primary;
     const shimmerColor = elapsed > 60 ? t.stallShimmer : elapsed > 30 ? t.warning : t.primaryShimmer;
     const baseStyle = { fg: baseColor, bg: null, bold: false, dim: false, underline: false };
     grid.writeText(r, 0, "◆ ", { ...baseStyle, bold: true });
-    const shimmerPos = state.spinnerFrame % (thinkText.length + 6);
+    const shimmerPos = state.spinnerFrame % 20;
     const shimmerStyle = { fg: shimmerColor, bg: null, bold: true, dim: false, underline: false };
     for (let ci = 0; ci < thinkText.length; ci++) {
         grid.setCell(r, 2 + ci, thinkText[ci], Math.abs(ci - shimmerPos) <= 1 ? shimmerStyle : baseStyle);
@@ -141,8 +143,9 @@ export function renderToolCallsSection(state, grid, r, limit, opts) {
                 : tc.status === "done"
                     ? "✓"
                     : "✗";
-        const statusStyle = tc.status === "error" ? S_ERROR : tc.status === "done" ? S_GREEN : isAgent ? S_AGENT : S_YELLOW;
-        const nameStyle = isAgent ? S_AGENT : { ...S_YELLOW, bold: true };
+        const toolStyle = { fg: toolColor(tc.toolName), bg: null, bold: false, dim: false, underline: false };
+        const statusStyle = tc.status === "error" ? S_ERROR : tc.status === "done" ? S_GREEN : isAgent ? S_AGENT : toolStyle;
+        const nameStyle = isAgent ? S_AGENT : { ...toolStyle, bold: true };
         const isExpanded = state.expandedToolCalls.has(callId);
         const canExpand = tc.status !== "running" && tc.output;
         if (canExpand) {
@@ -192,26 +195,12 @@ export function renderToolCallsSection(state, grid, r, limit, opts) {
             }
         }
         if (tc.output && tc.status !== "running" && isExpanded && r < limit) {
-            if (isImageOutput(tc.output)) {
-                const label = renderImageInline(tc.output);
-                grid.writeText(r, 6, label.slice(0, w - 8), S_DIM);
-                r++;
-                continue;
-            }
-            const outLines = tc.output.split("\n");
-            const maxOut = 20;
-            const showLines = outLines.slice(0, maxOut);
-            for (const line of showLines) {
-                if (r >= limit)
-                    break;
-                const lineStyle = tc.status === "error" ? S_ERROR : S_DIM;
-                grid.writeTextWithLinks(r, 6, line.slice(0, w - 8), lineStyle, w - 2);
-                r++;
-            }
-            if (outLines.length > maxOut && r < limit) {
-                grid.writeText(r, 6, `… (${outLines.length} lines total)`, S_DIM);
-                r++;
-            }
+            const consumed = renderToolOutput(grid, r, 6, tc.output, tc.outputType, w - 8, {
+                status: tc.status,
+                maxLines: 20,
+                limit,
+            });
+            r += consumed;
         }
     }
     return r;
@@ -427,21 +416,33 @@ export function renderInputSection(state, grid, inputRow, limit, promptText, pro
     const inputStart = promptWidth;
     const inputLines = state.inputText.split("\n");
     const maxInputLines = Math.min(inputLines.length, 5);
+    // Pre-compute the [N lines] suffix column on row 0 (if multi-line) so the
+    // wrap glyph for line 0 can yield to the suffix when they would collide.
+    // The +1 reserves the glyph column so the suffix starts one column after
+    // it (produces "text↵ [N lines]"); a +0 would let the suffix overwrite the
+    // glyph on narrow terminals.
+    let lineCountCol = -1;
+    if (inputLines.length > 1) {
+        const lineCountStr = ` [${inputLines.length} lines]`;
+        lineCountCol = Math.min(inputStart + (inputLines[0]?.length ?? 0) + 1, grid.width - lineCountStr.length - 1);
+    }
     for (let li = 0; li < maxInputLines; li++) {
         if (inputRow + li >= limit)
             break;
-        if (li === 0) {
-            grid.writeText(inputRow, inputStart, inputLines[0], S_TEXT);
-        }
-        else {
-            grid.writeText(inputRow + li, inputStart, inputLines[li], S_TEXT);
+        const lineText = inputLines[li];
+        grid.writeText(inputRow + li, inputStart, lineText, S_TEXT);
+        // Audit U-C2: append a dim ↵ continuation glyph to every non-last line.
+        if (li < inputLines.length - 1) {
+            const glyphCol = inputStart + lineText.length;
+            const wouldCollideWithLineCount = li === 0 && lineCountCol > inputStart && glyphCol >= lineCountCol;
+            if (glyphCol < grid.width && !wouldCollideWithLineCount) {
+                grid.writeText(inputRow + li, glyphCol, "↵", S_DIM);
+            }
         }
     }
-    if (inputLines.length > 1) {
+    if (inputLines.length > 1 && lineCountCol > inputStart) {
         const lineCountStr = ` [${inputLines.length} lines]`;
-        const lineCountCol = Math.min(inputStart + (inputLines[0]?.length ?? 0) + 1, grid.width - lineCountStr.length - 1);
-        if (lineCountCol > inputStart)
-            grid.writeText(inputRow, lineCountCol, lineCountStr, S_DIM);
+        grid.writeText(inputRow, lineCountCol, lineCountStr, S_DIM);
     }
     const hintsRow = inputRow + maxInputLines;
     if (hintsRow < limit) {

package/dist/renderer/layout.d.ts

@@ -12,6 +12,7 @@ export type ToolCallInfo = {
     toolName: string;
     status: "running" | "done" | "error";
     output?: string;
+    outputType?: "json" | "markdown" | "image" | "plain";
     args?: string;
     isAgent?: boolean;
     agentDescription?: string;

package/dist/renderer/output-renderer.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Tool output dispatcher.
+ *
+ * Detection chain (stops at first hit):
+ *   1. __IMAGE__: sentinel  -> renderImageInline
+ *   2. outputType="json"    -> renderJsonTree (fallback to plain on parse fail)
+ *   3. outputType="markdown" -> renderMarkdown
+ *   4. outputType="plain"|"image" -> renderPlain (image without sentinel is malformed)
+ *   5. heuristic JSON parse -> renderJsonTree
+ *   6. heuristic markdown   -> renderMarkdown
+ *   7. fallback             -> renderPlain
+ */
+import type { CellGrid } from "./cells.js";
+export type OutputType = "json" | "markdown" | "image" | "plain";
+export declare function renderToolOutput(grid: CellGrid, row: number, col: number, output: string, outputType: OutputType | undefined, width: number, opts: {
+    status: "running" | "done" | "error";
+    maxLines: number;
+    limit: number;
+}): number;
+export declare function tryParseJson(s: string): {
+    ok: true;
+    value: unknown;
+} | {
+    ok: false;
+};
+export declare function looksLikeMarkdown(s: string): boolean;
+//# sourceMappingURL=output-renderer.d.ts.map

package/dist/renderer/output-renderer.js

@@ -0,0 +1,89 @@
+/**
+ * Tool output dispatcher.
+ *
+ * Detection chain (stops at first hit):
+ *   1. __IMAGE__: sentinel  -> renderImageInline
+ *   2. outputType="json"    -> renderJsonTree (fallback to plain on parse fail)
+ *   3. outputType="markdown" -> renderMarkdown
+ *   4. outputType="plain"|"image" -> renderPlain (image without sentinel is malformed)
+ *   5. heuristic JSON parse -> renderJsonTree
+ *   6. heuristic markdown   -> renderMarkdown
+ *   7. fallback             -> renderPlain
+ */
+import { isImageOutput, renderImageInline } from "./image.js";
+import { renderJsonTree } from "./json-tree.js";
+import { renderMarkdown } from "./markdown.js";
+const S_DIM = { fg: null, bg: null, bold: false, dim: true, underline: false };
+const S_ERROR = { fg: "red", bg: null, bold: false, dim: false, underline: false };
+export function renderToolOutput(grid, row, col, output, outputType, width, opts) {
+    // 1. Image sentinel always wins.
+    if (isImageOutput(output)) {
+        if (row >= opts.limit)
+            return 0;
+        const label = renderImageInline(output);
+        grid.writeText(row, col, label.slice(0, width), S_DIM);
+        return 1;
+    }
+    // 2-4. Typed dispatch.
+    if (outputType === "json") {
+        const parsed = tryParseJson(output);
+        if (parsed.ok)
+            return renderJsonTree(grid, row, col, parsed.value, width, { maxLines: opts.maxLines, limit: opts.limit });
+        return renderPlain(grid, row, col, output, width, opts);
+    }
+    if (outputType === "markdown") {
+        return renderMarkdown(grid, row, col, output, width, false, opts.limit);
+    }
+    if (outputType === "plain" || outputType === "image") {
+        return renderPlain(grid, row, col, output, width, opts);
+    }
+    // 5-7. Heuristic fallback (outputType undefined).
+    const json = tryParseJson(output);
+    if (json.ok)
+        return renderJsonTree(grid, row, col, json.value, width, { maxLines: opts.maxLines, limit: opts.limit });
+    if (looksLikeMarkdown(output))
+        return renderMarkdown(grid, row, col, output, width, false, opts.limit);
+    return renderPlain(grid, row, col, output, width, opts);
+}
+export function tryParseJson(s) {
+    const t = s.trimStart();
+    if (t[0] !== "{" && t[0] !== "[")
+        return { ok: false };
+    try {
+        return { ok: true, value: JSON.parse(t) };
+    }
+    catch {
+        return { ok: false };
+    }
+}
+const FENCED_RE = /```[\w]*\r?\n/;
+const TABLE_RE = /^\|.+\|\s*\n\|[\s:|-]+\|/m;
+const HEADING_RE = /^#{1,6}\s+\S/gm;
+export function looksLikeMarkdown(s) {
+    if (FENCED_RE.test(s))
+        return true;
+    if (TABLE_RE.test(s))
+        return true;
+    const headings = s.match(HEADING_RE);
+    if (headings && headings.length >= 2)
+        return true;
+    return false;
+}
+function renderPlain(grid, row, col, output, width, opts) {
+    const outLines = output.split("\n");
+    const showLines = outLines.slice(0, opts.maxLines);
+    const lineStyle = opts.status === "error" ? S_ERROR : S_DIM;
+    let r = row;
+    for (const line of showLines) {
+        if (r >= opts.limit)
+            break;
+        grid.writeTextWithLinks(r, col, line.slice(0, width), lineStyle, col + width);
+        r++;
+    }
+    if (outLines.length > opts.maxLines && r < opts.limit) {
+        grid.writeText(r, col, `… (${outLines.length} lines total)`.slice(0, width), S_DIM);
+        r++;
+    }
+    return r - row;
+}
+//# sourceMappingURL=output-renderer.js.map

package/dist/renderer/spinner-label.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Derives the spinner section label from the live tool-call map.
+ */
+import type { ToolCallInfo } from "./layout.js";
+export declare function deriveSpinnerLabel(toolCalls: Map<string, ToolCallInfo>): string;
+//# sourceMappingURL=spinner-label.d.ts.map

package/dist/renderer/spinner-label.js

@@ -0,0 +1,24 @@
+/**
+ * Derives the spinner section label from the live tool-call map.
+ */
+export function deriveSpinnerLabel(toolCalls) {
+    const running = [];
+    for (const tc of toolCalls.values()) {
+        if (tc.status === "running")
+            running.push(tc);
+    }
+    if (running.length === 0)
+        return "Thinking";
+    if (running.length === 1) {
+        const name = running[0].toolName;
+        if (name.startsWith("mcp__")) {
+            const rest = name.slice("mcp__".length);
+            const idx = rest.indexOf("__");
+            if (idx > 0)
+                return `Calling ${rest.slice(0, idx)}:${rest.slice(idx + 2)}`;
+        }
+        return `Running ${name}`;
+    }
+    return `Running ${running.length} tools`;
+}
+//# sourceMappingURL=spinner-label.js.map

package/dist/renderer/tool-color.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Maps a tool name to a display color for the tool-call section.
+ * Read-class tools → cyan, Mutate-class → yellow, Exec-class → magenta,
+ * MCP tools (mcp__ prefix) → green, everything else → yellow fallback.
+ */
+export type ToolColor = "cyan" | "yellow" | "magenta" | "green";
+export declare function toolColor(toolName: string): ToolColor;
+//# sourceMappingURL=tool-color.d.ts.map

package/dist/renderer/tool-color.js

@@ -0,0 +1,20 @@
+/**
+ * Maps a tool name to a display color for the tool-call section.
+ * Read-class tools → cyan, Mutate-class → yellow, Exec-class → magenta,
+ * MCP tools (mcp__ prefix) → green, everything else → yellow fallback.
+ */
+const READ = new Set(["Read", "Glob", "Grep", "WebFetch", "WebSearch", "ExaSearch"]);
+const MUTATE = new Set(["Edit", "Write", "NotebookEdit"]);
+const EXEC = new Set(["Bash", "PowerShell"]);
+export function toolColor(toolName) {
+    if (READ.has(toolName))
+        return "cyan";
+    if (MUTATE.has(toolName))
+        return "yellow";
+    if (EXEC.has(toolName))
+        return "magenta";
+    if (toolName.startsWith("mcp__"))
+        return "green";
+    return "yellow";
+}
+//# sourceMappingURL=tool-color.js.map

package/dist/repl.js

@@ -21,6 +21,7 @@ import { isTrusted, trustSystemActive } from "./harness/trust.js";
 import { query } from "./query/index.js";
 import { resetDiffStyleCache } from "./renderer/diff.js";
 import { TerminalRenderer } from "./renderer/index.js";
+import { resetJsonStyleCache } from "./renderer/json-tree.js";
 import { resetStyleCache } from "./renderer/layout.js";
 import { resetMdStyleCache } from "./renderer/markdown.js";
 import { createAssistantMessage, createInfoMessage, createMessage } from "./types/message.js";
@@ -28,6 +29,8 @@ import { formatTokenCount } from "./utils/format.js";
 import { fuzzyFilter } from "./utils/fuzzy.js";
 import { setActiveTheme } from "./utils/theme-data.js";
 import { formatToolArgs, summarizeToolOutput } from "./utils/tool-summary.js";
+/** Per-call cap on rendered tool output in renderer state. Sized to fit typical JSON/markdown files (16 KiB) so JSON.parse / markdown detection works on real content; larger outputs render truncated. */
+const TOOL_OUTPUT_RENDER_CAP = 16384;
 export async function startREPL(config) {
     if (config.theme)
         setActiveTheme(config.theme);
@@ -814,6 +817,7 @@ export async function startREPL(config) {
             resetStyleCache();
             resetMdStyleCache();
             resetDiffStyleCache();
+            resetJsonStyleCache();
             // Persist theme to config
             try {
                 const cfg = cachedConfig ?? {
@@ -977,11 +981,11 @@ export async function startREPL(config) {
                     case "tool_call_end": {
                         const toolName = callIdToToolName.get(event.callId) ?? event.callId;
                         const prevTc = renderer.getToolCall(event.callId);
-                        const _elapsed = prevTc?.startedAt ? Math.floor((Date.now() - prevTc.startedAt) / 1000) : 0;
                         renderer.setToolCall(event.callId, {
                             toolName,
                             status: event.isError ? "error" : "done",
-                            output: event.output?.slice(0, 500),
+                            output: event.output?.slice(0, TOOL_OUTPUT_RENDER_CAP),
+                            outputType: event.outputType,
                             args: prevTc?.args,
                             resultSummary: event.output ? summarizeToolOutput(event.output) : undefined,
                             startedAt: prevTc?.startedAt,

package/dist/tools/FileReadTool/index.js

@@ -10,6 +10,15 @@ const inputSchema = z.object({
 const DEFAULT_LIMIT = 2000;
 const IMAGE_EXTENSIONS = new Set([".png", ".jpg", ".jpeg", ".gif", ".webp", ".bmp", ".svg"]);
 const NOTEBOOK_EXTENSION = ".ipynb";
+const MARKDOWN_EXTENSIONS = new Set([".md", ".markdown"]);
+const JSON_EXTENSIONS = new Set([".json"]);
+function outputTypeFromExt(ext) {
+    if (JSON_EXTENSIONS.has(ext))
+        return "json";
+    if (MARKDOWN_EXTENSIONS.has(ext))
+        return "markdown";
+    return "plain";
+}
 function parsePageRange(pages) {
     const result = [];
     for (const part of pages.split(",")) {
@@ -101,7 +110,7 @@ export const FileReadTool = {
                     }
                 }
                 if (pageTexts.length > 0) {
-                    return { output: pageTexts.join("\n\n"), isError: false };
+                    return { output: pageTexts.join("\n\n"), isError: false, outputType: "plain" };
                 }
                 // Fallback: return as base64 for multimodal analysis
                 const base64 = buffer.toString("base64");
@@ -128,7 +137,7 @@ export const FileReadTool = {
                         }
                     }
                 }
-                return { output: parts.join("\n\n"), isError: false };
+                return { output: parts.join("\n\n"), isError: false, outputType: "plain" };
             }
             // Default: text file
             const content = await fs.readFile(filePath, "utf-8");
@@ -143,7 +152,7 @@ export const FileReadTool = {
             if (shown < total) {
                 result += `\n\n(Showing lines ${offset + 1}-${offset + shown} of ${total})`;
             }
-            return { output: result, isError: false };
+            return { output: result, isError: false, outputType: outputTypeFromExt(ext) };
         }
         catch (err) {
             if (err.code === "ENOENT") {

package/dist/tools/WebFetchTool/index.js

@@ -70,7 +70,7 @@ export const WebFetchTool = {
                 signal: AbortSignal.timeout(30_000),
             });
             // Re-check host after redirect to prevent SSRF via open redirects
-            const finalUrl = new URL(response.url);
+            const finalUrl = new URL(response.url || input.url);
             if (isBlockedHost(finalUrl.hostname)) {
                 return { output: "Error: Redirect to private/internal host blocked.", isError: true };
             }
@@ -88,7 +88,10 @@ export const WebFetchTool = {
             if (text.length > MAX_OUTPUT) {
                 text = `${text.slice(0, MAX_OUTPUT)}\n... [truncated]`;
             }
-            return { output: text, isError: false };
+            const ct = contentType.toLowerCase();
+            const isJson = /^application\/(?:[a-z0-9.+-]+\+)?json\b/.test(ct);
+            const outputType = isJson ? "json" : ct.includes("text/markdown") ? "markdown" : "plain";
+            return { output: text, isError: false, outputType };
         }
         catch (err) {
             return { output: `Error fetching URL: ${err.message}`, isError: true };

package/dist/types/events.d.ts

@@ -20,6 +20,7 @@ export type ToolCallEnd = {
     readonly type: "tool_call_end";
     readonly callId: string;
     readonly output: string;
+    readonly outputType?: "json" | "markdown" | "image" | "plain";
     readonly isError: boolean;
 };
 export type PermissionRequest = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zhijiewang/openharness",
-  "version": "2.24.0",
+  "version": "2.26.0",
   "description": "Open-source terminal coding agent. Works with any LLM.",
   "type": "module",
   "bin": {