@zhijiewang/openharness 2.26.0 → 2.28.0

package/dist/Tool.d.ts

@@ -4,6 +4,7 @@
  */
 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;
@@ -26,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/layout-sections.js

@@ -7,6 +7,7 @@ import { renderDiff } from "./diff.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,10 +129,11 @@ 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 isAgent = tc.isAgent || tc.toolName === "Agent" || tc.toolName === "ParallelAgents";
+    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" || tc.toolName === "Task";
         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,34 +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) {
-            const consumed = renderToolOutput(grid, r, 6, tc.output, tc.outputType, w - 8, {
+            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,6 +11,7 @@ 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;

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

@@ -934,19 +934,20 @@ export async function startREPL(config) {
                         break;
                     case "tool_call_start": {
                         callIdToToolName.set(event.callId, event.toolName);
-                        const isAgentTool = event.toolName === "Agent" || event.toolName === "ParallelAgents";
+                        const isAgentTool = event.toolName === "Agent" || event.toolName === "ParallelAgents" || event.toolName === "Task";
                         renderer.setToolCall(event.callId, {
                             toolName: event.toolName,
                             status: "running",
                             startedAt: Date.now(),
                             isAgent: isAgentTool,
+                            parentCallId: event.parentCallId,
                         });
                         break;
                     }
                     case "tool_call_complete": {
                         const tcToolName = callIdToToolName.get(event.callId) ?? "";
                         const existingTc = renderer.getToolCall(event.callId);
-                        const isAgentCall = tcToolName === "Agent" || tcToolName === "ParallelAgents";
+                        const isAgentCall = tcToolName === "Agent" || tcToolName === "ParallelAgents" || tcToolName === "Task";
                         const agentDesc = isAgentCall
                             ? event.arguments.description
                             : undefined;
@@ -956,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;
                     }
@@ -986,6 +988,7 @@ export async function startREPL(config) {
                             status: event.isError ? "error" : "done",
                             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;
     }
@@ -108,6 +128,25 @@ export class AgentDispatcher {
         const cwd = this.workingDir ?? process.cwd();
         const useWorktree = isGitRepo(cwd);
         let worktreePath = null;
+        let result;
+        const taskCallId = `task-${task.id}-${Date.now().toString(36)}`;
+        const taskDescription = task.description ?? task.id;
+        const synthEnabled = !!this.emitChildEvent && !!this.parentCallId;
+        if (synthEnabled) {
+            this.emitChildEvent({
+                type: "tool_call_start",
+                toolName: "Task",
+                callId: taskCallId,
+                parentCallId: this.parentCallId,
+            });
+            this.emitChildEvent({
+                type: "tool_call_complete",
+                toolName: "Task",
+                callId: taskCallId,
+                arguments: { description: taskDescription },
+                parentCallId: this.parentCallId,
+            });
+        }
         if (useWorktree) {
             worktreePath = createWorktree(cwd);
         }
@@ -155,13 +194,16 @@ export class AgentDispatcher {
                 }
             }
             let output = "";
+            let errorMessage = null;
             try {
                 for await (const event of query(promptWithContext, config)) {
                     if (event.type === "text_delta")
                         output += event.content;
                     if (event.type === "error") {
-                        return { id: task.id, output: `Error: ${event.message}`, isError: true, durationMs: Date.now() - start };
+                        errorMessage = event.message;
+                        break;
                     }
+                    forwardChildEvent(event, taskCallId, this.emitChildEvent);
                 }
             }
             finally {
@@ -174,10 +216,15 @@ export class AgentDispatcher {
                     }
                 }
             }
-            return { id: task.id, output: output || "(no output)", isError: false, durationMs: Date.now() - start };
+            if (errorMessage !== null) {
+                result = { id: task.id, output: `Error: ${errorMessage}`, isError: true, durationMs: Date.now() - start };
+            }
+            else {
+                result = { id: task.id, output: output || "(no output)", isError: false, durationMs: Date.now() - start };
+            }
         }
         catch (err) {
-            return {
+            result = {
                 id: task.id,
                 output: `Failed: ${err instanceof Error ? err.message : String(err)}`,
                 isError: true,
@@ -188,7 +235,17 @@ export class AgentDispatcher {
             if (worktreePath) {
                 removeWorktree(worktreePath, cwd);
             }
+            if (synthEnabled) {
+                this.emitChildEvent({
+                    type: "tool_call_end",
+                    callId: taskCallId,
+                    output: result.output,
+                    isError: result.isError,
+                    parentCallId: this.parentCallId,
+                });
+            }
         }
+        return result;
     }
 }
 //# sourceMappingURL=AgentDispatcher.js.map

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/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/types/events.d.ts

@@ -9,12 +9,14 @@ 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";
@@ -22,6 +24,7 @@ export type ToolCallEnd = {
     readonly output: string;
     readonly outputType?: "json" | "markdown" | "image" | "plain";
     readonly isError: boolean;
+    readonly parentCallId?: string;
 };
 export type PermissionRequest = {
     readonly type: "permission_request";
@@ -59,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.26.0",
+  "version": "2.28.0",
   "description": "Open-source terminal coding agent. Works with any LLM.",
   "type": "module",
   "bin": {