@zhijiewang/openharness 2.25.0 → 2.27.0

package/dist/Tool.d.ts

@@ -4,10 +4,12 @@
  */
 import type { z } from "zod";
 import type { Provider } from "./providers/base.js";
+import type { ToolCallComplete, ToolCallEnd, ToolCallStart, ToolOutputDelta } from "./types/events.js";
 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;
@@ -25,6 +27,8 @@ export type ToolContext = {
     askUserQuestion?: (question: string, options?: string[]) => Promise<string>;
     /** Auto-commit after file-modifying tools */
     gitCommitPerTool?: boolean;
+    /** Forward an inner-query tool event to the outer event stream, stamped with the parent's callId. Used by AgentTool and AgentDispatcher to surface nested tool calls. */
+    emitChildEvent?: (event: ToolCallStart | ToolCallComplete | ToolCallEnd | ToolOutputDelta) => void;
 };
 export type Tool<Input extends z.ZodType = z.ZodType> = {
     readonly name: string;

package/dist/query/tools.js

@@ -311,15 +311,18 @@ export async function executeSingleTool(toolCall, tools, context, permissionMode
 }
 export async function* executeToolCalls(toolCalls, tools, context, permissionMode, askUser, state, permissionPromptTool) {
     const batches = partitionToolCalls(toolCalls, tools);
-    const outputChunks = [];
+    const childEvents = [];
     const onOutputChunk = (callId, chunk) => {
-        outputChunks.push({ type: "tool_output_delta", callId, chunk });
+        childEvents.push({ type: "tool_output_delta", callId, chunk });
+    };
+    const emitChildEvent = (event) => {
+        childEvents.push(event);
     };
     const allToolNames = toolCalls.map((tc) => tc.toolName);
     for (const batch of batches) {
         if (batch.concurrent) {
-            const results = await Promise.all(batch.calls.map((tc) => executeSingleTool(tc, tools, { ...context, callId: tc.id, onOutputChunk }, permissionMode, askUser, permissionPromptTool)));
-            for (const chunk of outputChunks.splice(0))
+            const results = await Promise.all(batch.calls.map((tc) => executeSingleTool(tc, tools, { ...context, callId: tc.id, onOutputChunk, emitChildEvent }, permissionMode, askUser, permissionPromptTool)));
+            for (const chunk of childEvents.splice(0))
                 yield chunk;
             for (let i = 0; i < batch.calls.length; i++) {
                 const tc = batch.calls[i];
@@ -330,8 +333,8 @@ export async function* executeToolCalls(toolCalls, tools, context, permissionMod
         }
         else {
             for (const tc of batch.calls) {
-                const result = await executeSingleTool(tc, tools, { ...context, callId: tc.id, onOutputChunk }, permissionMode, askUser, permissionPromptTool);
-                for (const chunk of outputChunks.splice(0))
+                const result = await executeSingleTool(tc, tools, { ...context, callId: tc.id, onOutputChunk, emitChildEvent }, permissionMode, askUser, permissionPromptTool);
+                for (const chunk of childEvents.splice(0))
                     yield chunk;
                 yield { type: "tool_call_end", callId: tc.id, output: result.output, isError: result.isError };
                 state?.messages.push(createToolResultMessage({ callId: tc.id, output: result.output, isError: result.isError }));

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,9 +4,10 @@
  */
 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";
+import { buildToolCallTree } from "./tool-tree.js";
 // ── Style constants ──
 const s = (fg, bold = false, dim = false) => ({ fg, bg: null, bold, dim, underline: false });
 export const S_TEXT = s(null);
@@ -128,9 +129,10 @@ export function renderErrorSection(state, grid, r, limit) {
 }
 export function renderToolCallsSection(state, grid, r, limit, opts) {
     const w = grid.width;
-    for (const [callId, tc] of state.toolCalls) {
-        if (r >= limit)
-            break;
+    const tree = buildToolCallTree(state.toolCalls);
+    const MAX_DEPTH = 3;
+    const renderSingleCall = (callId, tc, depth) => {
+        const colOffset = depth * 4;
         const isAgent = tc.isAgent || tc.toolName === "Agent" || tc.toolName === "ParallelAgents";
         const icon = isAgent
             ? tc.status === "running"
@@ -149,11 +151,11 @@ export function renderToolCallsSection(state, grid, r, limit, opts) {
         const isExpanded = state.expandedToolCalls.has(callId);
         const canExpand = tc.status !== "running" && tc.output;
         if (canExpand) {
-            grid.writeText(r, 0, isExpanded ? "▼" : "▶", S_DIM);
+            grid.writeText(r, 0 + colOffset, isExpanded ? "▼" : "▶", S_DIM);
         }
-        grid.writeText(r, 2, `${icon} `, statusStyle);
-        grid.writeText(r, 4, tc.toolName, nameStyle);
-        let afterName = 4 + tc.toolName.length + 1;
+        grid.writeText(r, 2 + colOffset, `${icon} `, statusStyle);
+        grid.writeText(r, 4 + colOffset, tc.toolName, nameStyle);
+        let afterName = 4 + colOffset + tc.toolName.length + 1;
         if (tc.args) {
             const maxArgs = w - afterName - 15;
             if (maxArgs > 5) {
@@ -177,48 +179,57 @@ export function renderToolCallsSection(state, grid, r, limit, opts) {
         }
         r++;
         if (isAgent && tc.agentDescription && r < limit) {
-            grid.writeText(r, 6, tc.agentDescription.slice(0, w - 8), S_DIM);
+            grid.writeText(r, 6 + colOffset, tc.agentDescription.slice(0, w - 8 - colOffset), S_DIM);
             r++;
         }
         if (tc.status === "running" && tc.liveOutput && tc.liveOutput.length > 0) {
             const overflow = tc.liveOutput.length > opts.maxLiveLines ? tc.liveOutput.length - opts.maxLiveLines : 0;
             if (opts.showOverflow && overflow > 0 && r < limit) {
-                grid.writeText(r, 6, `… (${overflow} earlier lines)`, S_DIM);
+                grid.writeText(r, 6 + colOffset, `… (${overflow} earlier lines)`, S_DIM);
                 r++;
             }
             const visible = overflow > 0 ? tc.liveOutput.slice(-opts.maxLiveLines) : tc.liveOutput;
             for (const line of visible) {
                 if (r >= limit)
                     break;
-                grid.writeTextWithLinks(r, 6, line.slice(0, w - 8), S_DIM, w - 2);
+                grid.writeTextWithLinks(r, 6 + colOffset, line.slice(0, w - 8 - colOffset), S_DIM, w - 2);
                 r++;
             }
         }
         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 + colOffset, tc.output, tc.outputType, w - 8 - colOffset, {
+                status: tc.status,
+                maxLines: 20,
+                limit,
+            });
+            r += consumed;
         }
-    }
+    };
+    const renderNode = (node) => {
+        if (r >= limit)
+            return;
+        if (node.depth > MAX_DEPTH) {
+            const descendants = countDescendants(node) + 1;
+            const colOffset = MAX_DEPTH * 4;
+            const noun = descendants === 1 ? "level" : "levels";
+            grid.writeText(r, colOffset, `… (${descendants} more ${noun})`, S_DIM);
+            r++;
+            return;
+        }
+        renderSingleCall(node.callId, node.call, node.depth);
+        for (const child of node.children)
+            renderNode(child);
+    };
+    for (const root of tree)
+        renderNode(root);
     return r;
 }
+function countDescendants(node) {
+    let n = node.children.length;
+    for (const c of node.children)
+        n += countDescendants(c);
+    return n;
+}
 export function renderContextWarningSection(state, grid, r, limit) {
     if (!state.contextWarning || r >= limit)
         return r;

package/dist/renderer/layout.d.ts

@@ -11,7 +11,9 @@ export { resetStyleCache } from "./layout-sections.js";
 export type ToolCallInfo = {
     toolName: string;
     status: "running" | "done" | "error";
+    parentCallId?: string;
     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/tool-tree.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Tree builder for tool calls — walks the flat callId map and produces a
+ * depth-first parent-child tree for rendering.
+ */
+import type { ToolCallInfo } from "./layout.js";
+export type TreeNode = {
+    callId: string;
+    call: ToolCallInfo;
+    children: TreeNode[];
+    depth: number;
+};
+export declare function buildToolCallTree(toolCalls: Map<string, ToolCallInfo>): TreeNode[];
+//# sourceMappingURL=tool-tree.d.ts.map

package/dist/renderer/tool-tree.js

@@ -0,0 +1,49 @@
+/**
+ * Tree builder for tool calls — walks the flat callId map and produces a
+ * depth-first parent-child tree for rendering.
+ */
+export function buildToolCallTree(toolCalls) {
+    const childrenOf = new Map();
+    const allIds = new Set();
+    for (const [callId, info] of toolCalls) {
+        allIds.add(callId);
+        const parent = info.parentCallId;
+        if (parent === undefined)
+            continue;
+        const list = childrenOf.get(parent) ?? [];
+        list.push(callId);
+        childrenOf.set(parent, list);
+    }
+    const roots = [];
+    for (const [callId, info] of toolCalls) {
+        const parent = info.parentCallId;
+        if (parent === undefined || !allIds.has(parent)) {
+            roots.push(callId);
+        }
+    }
+    const seen = new Set();
+    const build = (callId, depth) => {
+        if (seen.has(callId))
+            return null;
+        seen.add(callId);
+        const info = toolCalls.get(callId);
+        if (!info)
+            return null;
+        const childIds = childrenOf.get(callId) ?? [];
+        const children = [];
+        for (const cid of childIds) {
+            const child = build(cid, depth + 1);
+            if (child)
+                children.push(child);
+        }
+        return { callId, call: info, children, depth };
+    };
+    const result = [];
+    for (const rootId of roots) {
+        const node = build(rootId, 0);
+        if (node)
+            result.push(node);
+    }
+    return result;
+}
+//# sourceMappingURL=tool-tree.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 ?? {
@@ -936,6 +940,7 @@ export async function startREPL(config) {
                             status: "running",
                             startedAt: Date.now(),
                             isAgent: isAgentTool,
+                            parentCallId: event.parentCallId,
                         });
                         break;
                     }
@@ -952,6 +957,7 @@ export async function startREPL(config) {
                             status: "running",
                             args: formatToolArgs(tcToolName, event.arguments),
                             agentDescription: agentDesc ?? existingTc?.agentDescription,
+                            parentCallId: event.parentCallId ?? existingTc?.parentCallId,
                         });
                         break;
                     }
@@ -980,7 +986,9 @@ export async function startREPL(config) {
                         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,
+                            parentCallId: event.parentCallId ?? prevTc?.parentCallId,
                             args: prevTc?.args,
                             resultSummary: event.output ? summarizeToolOutput(event.output) : undefined,
                             startedAt: prevTc?.startedAt,

package/dist/services/AgentDispatcher.d.ts

@@ -7,7 +7,13 @@
  */
 import type { Provider } from "../providers/base.js";
 import type { Tools } from "../Tool.js";
+import type { StreamEvent, ToolCallComplete, ToolCallEnd, ToolCallStart, ToolOutputDelta } from "../types/events.js";
 import type { PermissionMode } from "../types/permissions.js";
+/**
+ * Forward inner-loop tool events to the outer stream, stamping parentCallId.
+ * Exported for direct unit testing.
+ */
+export declare function forwardChildEvent(event: StreamEvent, parentCallId: string | undefined, emit: ((e: ToolCallStart | ToolCallComplete | ToolCallEnd | ToolOutputDelta) => void) | undefined): boolean;
 export type AgentTask = {
     id: string;
     prompt: string;
@@ -29,10 +35,12 @@ export declare class AgentDispatcher {
     private model?;
     private workingDir?;
     private abortSignal?;
+    private parentCallId?;
+    private emitChildEvent?;
     private tasks;
     private results;
     private maxConcurrency;
-    constructor(provider: Provider, tools: Tools, systemPrompt: string, permissionMode: PermissionMode, model?: string | undefined, workingDir?: string | undefined, abortSignal?: AbortSignal | undefined, maxConcurrency?: number);
+    constructor(provider: Provider, tools: Tools, systemPrompt: string, permissionMode: PermissionMode, model?: string | undefined, workingDir?: string | undefined, abortSignal?: AbortSignal | undefined, maxConcurrency?: number, parentCallId?: string | undefined, emitChildEvent?: ((event: ToolCallStart | ToolCallComplete | ToolCallEnd | ToolOutputDelta) => void) | undefined);
     addTask(task: AgentTask): void;
     addTasks(tasks: AgentTask[]): void;
     /** Execute all tasks respecting dependencies. Returns results in completion order. */

package/dist/services/AgentDispatcher.js

@@ -6,6 +6,22 @@
  * and triggers dependent tasks when their blockers complete.
  */
 import { createWorktree, isGitRepo, removeWorktree } from "../git/index.js";
+/**
+ * Forward inner-loop tool events to the outer stream, stamping parentCallId.
+ * Exported for direct unit testing.
+ */
+export function forwardChildEvent(event, parentCallId, emit) {
+    if (!emit || !parentCallId)
+        return false;
+    if (event.type === "tool_call_start" ||
+        event.type === "tool_call_complete" ||
+        event.type === "tool_call_end" ||
+        event.type === "tool_output_delta") {
+        emit({ ...event, parentCallId });
+        return true;
+    }
+    return false;
+}
 export class AgentDispatcher {
     provider;
     tools;
@@ -14,10 +30,12 @@ export class AgentDispatcher {
     model;
     workingDir;
     abortSignal;
+    parentCallId;
+    emitChildEvent;
     tasks;
     results = new Map();
     maxConcurrency;
-    constructor(provider, tools, systemPrompt, permissionMode, model, workingDir, abortSignal, maxConcurrency = 4) {
+    constructor(provider, tools, systemPrompt, permissionMode, model, workingDir, abortSignal, maxConcurrency = 4, parentCallId, emitChildEvent) {
         this.provider = provider;
         this.tools = tools;
         this.systemPrompt = systemPrompt;
@@ -25,6 +43,8 @@ export class AgentDispatcher {
         this.model = model;
         this.workingDir = workingDir;
         this.abortSignal = abortSignal;
+        this.parentCallId = parentCallId;
+        this.emitChildEvent = emitChildEvent;
         this.tasks = new Map();
         this.maxConcurrency = maxConcurrency;
     }
@@ -162,6 +182,7 @@ export class AgentDispatcher {
                     if (event.type === "error") {
                         return { id: task.id, output: `Error: ${event.message}`, isError: true, durationMs: Date.now() - start };
                     }
+                    forwardChildEvent(event, this.parentCallId, this.emitChildEvent);
                 }
             }
             finally {

package/dist/tools/AgentTool/index.d.ts

@@ -1,5 +1,17 @@
 import { z } from "zod";
-import type { Tool } from "../../Tool.js";
+import type { Tool, ToolContext } from "../../Tool.js";
+import type { StreamEvent } from "../../types/events.js";
+/**
+ * Forward a single inner-query event to the outer stream via `context.emitChildEvent`,
+ * stamping it with `parentCallId = context.callId`.
+ *
+ * Handles: tool_call_start, tool_call_complete, tool_call_end, tool_output_delta.
+ * Returns true when the event was forwarded, false otherwise.
+ *
+ * Exported for unit testing — the hot path in AgentTool.call() calls this inline
+ * to keep the forwarding logic isolated and testable without stubbing query().
+ */
+export declare function forwardInnerEvent(event: StreamEvent, context: ToolContext): boolean;
 declare const inputSchema: z.ZodObject<{
     prompt: z.ZodString;
     description: z.ZodOptional<z.ZodString>;

package/dist/tools/AgentTool/index.js

@@ -2,6 +2,28 @@ import { z } from "zod";
 import { createWorktree, hasWorktreeChanges, isGitRepo, removeWorktree } from "../../git/index.js";
 import { emitHook } from "../../harness/hooks.js";
 import { getMessageBus } from "../../services/agent-messaging.js";
+/**
+ * Forward a single inner-query event to the outer stream via `context.emitChildEvent`,
+ * stamping it with `parentCallId = context.callId`.
+ *
+ * Handles: tool_call_start, tool_call_complete, tool_call_end, tool_output_delta.
+ * Returns true when the event was forwarded, false otherwise.
+ *
+ * Exported for unit testing — the hot path in AgentTool.call() calls this inline
+ * to keep the forwarding logic isolated and testable without stubbing query().
+ */
+export function forwardInnerEvent(event, context) {
+    if (!context.emitChildEvent || !context.callId)
+        return false;
+    if (event.type === "tool_call_start" ||
+        event.type === "tool_call_complete" ||
+        event.type === "tool_call_end" ||
+        event.type === "tool_output_delta") {
+        context.emitChildEvent({ ...event, parentCallId: event.parentCallId ?? context.callId });
+        return true;
+    }
+    return false;
+}
 const inputSchema = z.object({
     prompt: z.string(),
     description: z.string().optional(),
@@ -146,6 +168,12 @@ export const AgentTool = {
                         if (context.onOutputChunk && context.callId) {
                             context.onOutputChunk(context.callId, event.chunk);
                         }
+                        forwardInnerEvent(event, context);
+                    }
+                    else if (event.type === "tool_call_start" ||
+                        event.type === "tool_call_complete" ||
+                        event.type === "tool_call_end") {
+                        forwardInnerEvent(event, context);
                     }
                     else if (event.type === "error") {
                         return { output: `Sub-agent error: ${event.message}`, isError: true };

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/ParallelAgentTool/index.js

@@ -25,7 +25,8 @@ export const ParallelAgentTool = {
             return { output: "Parallel agents unavailable: provider not in context.", isError: true };
         }
         const systemPrompt = context.systemPrompt ?? "You are a sub-agent. Complete the delegated task concisely.";
-        const dispatcher = new AgentDispatcher(context.provider, context.tools, systemPrompt, context.permissionMode ?? "trust", context.model, context.workingDir, context.abortSignal);
+        const dispatcher = new AgentDispatcher(context.provider, context.tools, systemPrompt, context.permissionMode ?? "trust", context.model, context.workingDir, context.abortSignal, 4, // maxConcurrency default
+        context.callId, context.emitChildEvent);
         dispatcher.addTasks(input.tasks);
         const results = await dispatcher.execute();
         const output = results

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

@@ -9,18 +9,22 @@ export type ToolCallStart = {
     readonly type: "tool_call_start";
     readonly toolName: string;
     readonly callId: string;
+    readonly parentCallId?: string;
 };
 export type ToolCallComplete = {
     readonly type: "tool_call_complete";
     readonly callId: string;
     readonly toolName: string;
     readonly arguments: Record<string, unknown>;
+    readonly parentCallId?: string;
 };
 export type ToolCallEnd = {
     readonly type: "tool_call_end";
     readonly callId: string;
     readonly output: string;
+    readonly outputType?: "json" | "markdown" | "image" | "plain";
     readonly isError: boolean;
+    readonly parentCallId?: string;
 };
 export type PermissionRequest = {
     readonly type: "permission_request";
@@ -58,6 +62,7 @@ export type ToolOutputDelta = {
     readonly type: "tool_output_delta";
     readonly callId: string;
     readonly chunk: string;
+    readonly parentCallId?: string;
 };
 export type AskUserRequest = {
     readonly type: "ask_user";

package/package.json

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