@zhijiewang/openharness 2.0.0 → 2.3.0

package/dist/services/a2a.js

@@ -12,10 +12,10 @@
  *
  * Based on the emerging A2A (Agent-to-Agent) protocol standard.
  */
-import { readFileSync, writeFileSync, mkdirSync, readdirSync, existsSync, unlinkSync } from 'node:fs';
-import { join } from 'node:path';
-import { homedir } from 'node:os';
-const AGENT_REGISTRY_DIR = join(homedir(), '.oh', 'agents');
+import { existsSync, mkdirSync, readdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+const AGENT_REGISTRY_DIR = join(homedir(), ".oh", "agents");
 // ── Registry Operations ──
 /** Publish an agent card to the shared registry */
 export function publishCard(card) {
@@ -29,16 +29,18 @@ export function unpublishCard(agentId) {
     try {
         unlinkSync(filePath);
     }
-    catch { /* ignore */ }
+    catch {
+        /* ignore */
+    }
 }
 /** Discover all registered agents */
 export function discoverAgents() {
     if (!existsSync(AGENT_REGISTRY_DIR))
         return [];
     const cards = [];
-    for (const file of readdirSync(AGENT_REGISTRY_DIR).filter(f => f.endsWith('.json'))) {
+    for (const file of readdirSync(AGENT_REGISTRY_DIR).filter((f) => f.endsWith(".json"))) {
         try {
-            const raw = readFileSync(join(AGENT_REGISTRY_DIR, file), 'utf-8');
+            const raw = readFileSync(join(AGENT_REGISTRY_DIR, file), "utf-8");
             const card = JSON.parse(raw);
             // Check if the agent process is still alive
             if (isProcessAlive(card.pid)) {
@@ -49,20 +51,24 @@ export function discoverAgents() {
                 try {
                     unlinkSync(join(AGENT_REGISTRY_DIR, file));
                 }
-                catch { /* ignore */ }
+                catch {
+                    /* ignore */
+                }
             }
         }
-        catch { /* skip malformed cards */ }
+        catch {
+            /* skip malformed cards */
+        }
     }
     return cards;
 }
 /** Find agents by capability name */
 export function findAgentsByCapability(capabilityName) {
-    return discoverAgents().filter(card => card.capabilities.some(c => c.name.toLowerCase() === capabilityName.toLowerCase()));
+    return discoverAgents().filter((card) => card.capabilities.some((c) => c.name.toLowerCase() === capabilityName.toLowerCase()));
 }
 /** Find an agent by name */
 export function findAgentByName(name) {
-    return discoverAgents().find(c => c.name.toLowerCase() === name.toLowerCase()) ?? null;
+    return discoverAgents().find((c) => c.name.toLowerCase() === name.toLowerCase()) ?? null;
 }
 // ── Message Routing ──
 /**
@@ -75,13 +81,13 @@ export async function routeMessage(message) {
     let targetCard = null;
     // Try by agent ID first
     const agents = discoverAgents();
-    targetCard = agents.find(a => a.id === message.to) ?? null;
+    targetCard = agents.find((a) => a.id === message.to) ?? null;
     // Try by name
     if (!targetCard) {
-        targetCard = agents.find(a => a.name.toLowerCase() === message.to.toLowerCase()) ?? null;
+        targetCard = agents.find((a) => a.name.toLowerCase() === message.to.toLowerCase()) ?? null;
     }
     // Try by capability
-    if (!targetCard && message.type === 'task' && message.payload.kind === 'task') {
+    if (!targetCard && message.type === "task" && message.payload.kind === "task") {
         const capable = findAgentsByCapability(message.payload.capability);
         if (capable.length > 0)
             targetCard = capable[0];
@@ -90,25 +96,27 @@ export async function routeMessage(message) {
         return null;
     // Route based on endpoint type
     switch (targetCard.endpoint.type) {
-        case 'http': {
+        case "http": {
             try {
-                const url = `${targetCard.endpoint.address}${targetCard.endpoint.port ? ':' + targetCard.endpoint.port : ''}/a2a`;
+                const url = `${targetCard.endpoint.address}${targetCard.endpoint.port ? `:${targetCard.endpoint.port}` : ""}/a2a`;
                 const res = await fetch(url, {
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json' },
+                    method: "POST",
+                    headers: { "Content-Type": "application/json" },
                     body: JSON.stringify(message),
                     signal: AbortSignal.timeout(30_000),
                 });
                 if (res.ok) {
-                    return await res.json();
+                    return (await res.json());
                 }
             }
-            catch { /* delivery failed */ }
+            catch {
+                /* delivery failed */
+            }
             return null;
         }
-        case 'ipc': {
+        case "ipc": {
             // File-based inbox for local IPC
-            const inboxDir = join(AGENT_REGISTRY_DIR, 'inboxes', targetCard.id);
+            const inboxDir = join(AGENT_REGISTRY_DIR, "inboxes", targetCard.id);
             mkdirSync(inboxDir, { recursive: true });
             const msgFile = join(inboxDir, `${message.id}.json`);
             writeFileSync(msgFile, JSON.stringify(message, null, 2));
@@ -120,18 +128,20 @@ export async function routeMessage(message) {
 }
 /** Read pending messages from an agent's inbox */
 export function readInbox(agentId) {
-    const inboxDir = join(AGENT_REGISTRY_DIR, 'inboxes', agentId);
+    const inboxDir = join(AGENT_REGISTRY_DIR, "inboxes", agentId);
     if (!existsSync(inboxDir))
         return [];
     const messages = [];
-    for (const file of readdirSync(inboxDir).filter(f => f.endsWith('.json'))) {
+    for (const file of readdirSync(inboxDir).filter((f) => f.endsWith(".json"))) {
         try {
-            const raw = readFileSync(join(inboxDir, file), 'utf-8');
+            const raw = readFileSync(join(inboxDir, file), "utf-8");
             messages.push(JSON.parse(raw));
             // Remove after reading
             unlinkSync(join(inboxDir, file));
         }
-        catch { /* skip */ }
+        catch {
+            /* skip */
+        }
     }
     return messages.sort((a, b) => a.timestamp - b.timestamp);
 }
@@ -155,17 +165,17 @@ export function createSessionCard(sessionId, opts = {}) {
     return {
         id: `oh-${sessionId}`,
         name: `openharness-${sessionId.slice(0, 6)}`,
-        version: '1.0.0',
+        version: "1.0.0",
         capabilities: [
-            { name: 'code-generation', description: 'Generate, edit, and review code' },
-            { name: 'code-review', description: 'Review code for bugs and quality' },
-            { name: 'test-generation', description: 'Write tests for existing code' },
-            { name: 'file-operations', description: 'Read, write, search files' },
-            { name: 'bash-execution', description: 'Run shell commands' },
+            { name: "code-generation", description: "Generate, edit, and review code" },
+            { name: "code-review", description: "Review code for bugs and quality" },
+            { name: "test-generation", description: "Write tests for existing code" },
+            { name: "file-operations", description: "Read, write, search files" },
+            { name: "bash-execution", description: "Run shell commands" },
         ],
         endpoint: opts.port
-            ? { type: 'http', address: 'http://localhost', port: opts.port }
-            : { type: 'ipc', address: join(AGENT_REGISTRY_DIR, 'inboxes', `oh-${sessionId}`) },
+            ? { type: "http", address: "http://localhost", port: opts.port }
+            : { type: "ipc", address: join(AGENT_REGISTRY_DIR, "inboxes", `oh-${sessionId}`) },
         registeredAt: Date.now(),
         pid: process.pid,
         provider: opts.provider,

package/dist/services/agent-messaging.d.ts

@@ -1,18 +1,7 @@
-/**
- * Agent messaging — peer-to-peer communication between sub-agents.
- *
- * Provides a message bus for agents to send/receive messages, share state,
- * and coordinate work. Uses file-based locking for concurrent file access.
- *
- * Architecture (inspired by Claude Code Agent Teams):
- * - Each agent has a unique ID
- * - Messages are stored in a shared inbox (in-memory for same-process agents)
- * - File locking prevents concurrent edits to the same file
- */
 export type AgentMessage = {
     from: string;
     to: string;
-    type: 'request' | 'response' | 'status' | 'error';
+    type: "request" | "response" | "status" | "error";
     content: string;
     timestamp: number;
     metadata?: Record<string, unknown>;
@@ -20,9 +9,23 @@ export type AgentMessage = {
 export type AgentInfo = {
     id: string;
     role: string;
-    status: 'idle' | 'working' | 'done' | 'error';
+    status: "idle" | "working" | "done" | "error";
     currentTask?: string;
 };
+/**
+ * Background agent entry — tracks running/completed background agents
+ * so they can be continued via SendMessage.
+ */
+export type BackgroundAgent = {
+    id: string;
+    role: string;
+    status: "running" | "completed" | "error";
+    startedAt: number;
+    completedAt?: number;
+    result?: string;
+    /** Queue of messages sent to this agent while it was running */
+    pendingMessages: string[];
+};
 /**
  * Message bus for agent-to-agent communication.
  */
@@ -30,22 +33,37 @@ export declare class AgentMessageBus {
     private inboxes;
     private agents;
     private fileLocks;
+    private backgroundAgents;
     /** Register an agent with the bus */
     registerAgent(id: string, role: string): void;
     /** Unregister an agent */
     unregisterAgent(id: string): void;
     /** Send a message to a specific agent or broadcast */
-    send(message: Omit<AgentMessage, 'timestamp'>): void;
+    send(message: Omit<AgentMessage, "timestamp">): void;
     /** Receive pending messages for an agent (drains inbox) */
     receive(agentId: string): AgentMessage[];
     /** Peek at inbox without draining */
     peek(agentId: string): AgentMessage[];
     /** Update agent status */
-    updateStatus(agentId: string, status: AgentInfo['status'], currentTask?: string): void;
+    updateStatus(agentId: string, status: AgentInfo["status"], currentTask?: string): void;
     /** Get all registered agents */
     getAgents(): AgentInfo[];
     /** Get a specific agent's info */
     getAgent(id: string): AgentInfo | undefined;
+    /** Register a background agent for later continuation */
+    registerBackgroundAgent(id: string, role: string): void;
+    /** Mark a background agent as completed with its result */
+    completeBackgroundAgent(id: string, result: string): void;
+    /** Mark a background agent as errored */
+    errorBackgroundAgent(id: string, error: string): void;
+    /** Queue a message for a background agent */
+    sendToBackgroundAgent(id: string, content: string): boolean;
+    /** Get a background agent's info */
+    getBackgroundAgent(id: string): BackgroundAgent | undefined;
+    /** List all background agents */
+    getBackgroundAgents(): BackgroundAgent[];
+    /** Drain pending messages for a background agent */
+    drainBackgroundMessages(id: string): string[];
     /** Acquire a lock on a file path. Returns true if acquired, false if already locked. */
     acquireLock(agentId: string, filePath: string): boolean;
     /** Release a lock on a file path */

package/dist/services/agent-messaging.js

@@ -1,14 +1,3 @@
-/**
- * Agent messaging — peer-to-peer communication between sub-agents.
- *
- * Provides a message bus for agents to send/receive messages, share state,
- * and coordinate work. Uses file-based locking for concurrent file access.
- *
- * Architecture (inspired by Claude Code Agent Teams):
- * - Each agent has a unique ID
- * - Messages are stored in a shared inbox (in-memory for same-process agents)
- * - File locking prevents concurrent edits to the same file
- */
 /**
  * Message bus for agent-to-agent communication.
  */
@@ -16,9 +5,10 @@ export class AgentMessageBus {
     inboxes = new Map();
     agents = new Map();
     fileLocks = new Map(); // filePath → agentId
+    backgroundAgents = new Map();
     /** Register an agent with the bus */
     registerAgent(id, role) {
-        this.agents.set(id, { id, role, status: 'idle' });
+        this.agents.set(id, { id, role, status: "idle" });
         this.inboxes.set(id, []);
     }
     /** Unregister an agent */
@@ -34,7 +24,7 @@ export class AgentMessageBus {
     /** Send a message to a specific agent or broadcast */
     send(message) {
         const msg = { ...message, timestamp: Date.now() };
-        if (msg.to === '*') {
+        if (msg.to === "*") {
             // Broadcast to all agents except sender
             for (const [id, inbox] of this.inboxes) {
                 if (id !== msg.from)
@@ -76,6 +66,68 @@ export class AgentMessageBus {
     getAgent(id) {
         return this.agents.get(id);
     }
+    // ── Background Agent Registry ──
+    /** Register a background agent for later continuation */
+    registerBackgroundAgent(id, role) {
+        this.backgroundAgents.set(id, {
+            id,
+            role,
+            status: "running",
+            startedAt: Date.now(),
+            pendingMessages: [],
+        });
+        // Evict completed/errored agents older than 30 minutes to prevent unbounded growth
+        const EVICT_AGE_MS = 30 * 60 * 1000;
+        const now = Date.now();
+        for (const [agentId, agent] of this.backgroundAgents) {
+            if (agent.status !== "running" && agent.completedAt && now - agent.completedAt > EVICT_AGE_MS) {
+                this.backgroundAgents.delete(agentId);
+            }
+        }
+    }
+    /** Mark a background agent as completed with its result */
+    completeBackgroundAgent(id, result) {
+        const agent = this.backgroundAgents.get(id);
+        if (agent) {
+            agent.status = "completed";
+            agent.completedAt = Date.now();
+            agent.result = result;
+        }
+    }
+    /** Mark a background agent as errored */
+    errorBackgroundAgent(id, error) {
+        const agent = this.backgroundAgents.get(id);
+        if (agent) {
+            agent.status = "error";
+            agent.completedAt = Date.now();
+            agent.result = error;
+        }
+    }
+    /** Queue a message for a background agent */
+    sendToBackgroundAgent(id, content) {
+        const agent = this.backgroundAgents.get(id);
+        if (!agent)
+            return false;
+        agent.pendingMessages.push(content);
+        return true;
+    }
+    /** Get a background agent's info */
+    getBackgroundAgent(id) {
+        return this.backgroundAgents.get(id);
+    }
+    /** List all background agents */
+    getBackgroundAgents() {
+        return [...this.backgroundAgents.values()];
+    }
+    /** Drain pending messages for a background agent */
+    drainBackgroundMessages(id) {
+        const agent = this.backgroundAgents.get(id);
+        if (!agent || agent.pendingMessages.length === 0)
+            return [];
+        const msgs = [...agent.pendingMessages];
+        agent.pendingMessages.length = 0;
+        return msgs;
+    }
     // ── File Locking ──
     /** Acquire a lock on a file path. Returns true if acquired, false if already locked. */
     acquireLock(agentId, filePath) {

package/dist/services/cron.js

@@ -7,19 +7,19 @@
  * This is a simple implementation using setInterval for minute-level granularity.
  * For production use, consider node-cron or similar.
  */
-import { readFileSync, writeFileSync, mkdirSync, readdirSync, existsSync, unlinkSync } from 'node:fs';
-import { join } from 'node:path';
-import { homedir } from 'node:os';
-const CRON_DIR = join(homedir(), '.oh', 'crons');
+import { existsSync, mkdirSync, readdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+const CRON_DIR = join(homedir(), ".oh", "crons");
 /** List all cron definitions */
 export function listCrons() {
     if (!existsSync(CRON_DIR))
         return [];
     return readdirSync(CRON_DIR)
-        .filter(f => f.endsWith('.json'))
-        .map(f => {
+        .filter((f) => f.endsWith(".json"))
+        .map((f) => {
         try {
-            return JSON.parse(readFileSync(join(CRON_DIR, f), 'utf-8'));
+            return JSON.parse(readFileSync(join(CRON_DIR, f), "utf-8"));
         }
         catch {
             return null;
@@ -61,19 +61,19 @@ export function parseScheduleMs(schedule) {
     // "every 5m" → 5 minutes
     const minMatch = schedule.match(/^every\s+(\d+)\s*m(?:in(?:ute)?s?)?$/i);
     if (minMatch)
-        return parseInt(minMatch[1]) * 60 * 1000;
+        return parseInt(minMatch[1], 10) * 60 * 1000;
     // "every 2h" → 2 hours
     const hourMatch = schedule.match(/^every\s+(\d+)\s*h(?:ours?)?$/i);
     if (hourMatch)
-        return parseInt(hourMatch[1]) * 60 * 60 * 1000;
+        return parseInt(hourMatch[1], 10) * 60 * 60 * 1000;
     // "every 1d" → 1 day
     const dayMatch = schedule.match(/^every\s+(\d+)\s*d(?:ays?)?$/i);
     if (dayMatch)
-        return parseInt(dayMatch[1]) * 24 * 60 * 60 * 1000;
+        return parseInt(dayMatch[1], 10) * 24 * 60 * 60 * 1000;
     return null;
 }
 // ── Result Persistence ──
-const HISTORY_DIR = join(CRON_DIR, 'history');
+const HISTORY_DIR = join(CRON_DIR, "history");
 /** Save a cron execution result to history */
 export function saveCronResult(result) {
     mkdirSync(HISTORY_DIR, { recursive: true });
@@ -85,13 +85,13 @@ export function getCronHistory(cronId, limit = 10) {
     if (!existsSync(HISTORY_DIR))
         return [];
     return readdirSync(HISTORY_DIR)
-        .filter(f => f.startsWith(`${cronId}-`) && f.endsWith('.json'))
+        .filter((f) => f.startsWith(`${cronId}-`) && f.endsWith(".json"))
         .sort()
         .reverse()
         .slice(0, limit)
-        .map(f => {
+        .map((f) => {
         try {
-            return JSON.parse(readFileSync(join(HISTORY_DIR, f), 'utf-8'));
+            return JSON.parse(readFileSync(join(HISTORY_DIR, f), "utf-8"));
         }
         catch {
             return null;
@@ -104,14 +104,14 @@ export function getCronHistory(cronId, limit = 10) {
  */
 export function getDueCrons(crons) {
     const now = Date.now();
-    return crons.filter(c => {
+    return crons.filter((c) => {
         if (!c.enabled)
             return false;
         const intervalMs = parseScheduleMs(c.schedule);
         if (!intervalMs)
             return false;
         const lastRun = c.lastRun ?? c.createdAt;
-        return (now - lastRun) >= intervalMs;
+        return now - lastRun >= intervalMs;
     });
 }
 //# sourceMappingURL=cron.js.map

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

@@ -4,6 +4,7 @@ declare const inputSchema: z.ZodObject<{
     prompt: z.ZodString;
     description: z.ZodOptional<z.ZodString>;
     isolated: z.ZodOptional<z.ZodBoolean>;
+    isolation: z.ZodOptional<z.ZodEnum<["worktree"]>>;
     run_in_background: z.ZodOptional<z.ZodBoolean>;
     model: z.ZodOptional<z.ZodString>;
     subagent_type: z.ZodOptional<z.ZodString>;
@@ -12,16 +13,18 @@ declare const inputSchema: z.ZodObject<{
     prompt: string;
     model?: string | undefined;
     description?: string | undefined;
-    run_in_background?: boolean | undefined;
     isolated?: boolean | undefined;
+    isolation?: "worktree" | undefined;
+    run_in_background?: boolean | undefined;
     subagent_type?: string | undefined;
     allowed_tools?: string[] | undefined;
 }, {
     prompt: string;
     model?: string | undefined;
     description?: string | undefined;
-    run_in_background?: boolean | undefined;
     isolated?: boolean | undefined;
+    isolation?: "worktree" | undefined;
+    run_in_background?: boolean | undefined;
     subagent_type?: string | undefined;
     allowed_tools?: string[] | undefined;
 }>;

package/dist/tools/AgentTool/index.js

@@ -1,10 +1,15 @@
 import { z } from "zod";
-import { createWorktree, removeWorktree, hasWorktreeChanges, isGitRepo } from "../../git/index.js";
+import { createWorktree, hasWorktreeChanges, isGitRepo, removeWorktree } from "../../git/index.js";
 import { emitHook } from "../../harness/hooks.js";
+import { getMessageBus } from "../../services/agent-messaging.js";
 const inputSchema = z.object({
     prompt: z.string(),
     description: z.string().optional(),
-    isolated: z.boolean().optional(),
+    isolated: z.boolean().optional().describe("Whether to run in an isolated git worktree (default: true in git repos)"),
+    isolation: z
+        .enum(["worktree"])
+        .optional()
+        .describe("Isolation mode — 'worktree' creates a temporary git worktree (Claude Code compatible)"),
     run_in_background: z.boolean().optional(),
     model: z.string().optional(),
     subagent_type: z.string().optional(),
@@ -30,7 +35,9 @@ export const AgentTool = {
         }
         const { query } = await import("../../query.js");
         // Worktree isolation: create isolated copy of repo if requested or if in git repo
-        const useWorktree = input.isolated !== false && isGitRepo(context.workingDir);
+        // Supports both `isolation: "worktree"` (Claude Code) and `isolated: boolean` (legacy)
+        const explicitWorktree = input.isolation === "worktree";
+        const useWorktree = (explicitWorktree || input.isolated !== false) && isGitRepo(context.workingDir);
         let worktreePath = null;
         let agentWorkingDir = context.workingDir;
         if (useWorktree) {
@@ -49,14 +56,14 @@ export const AgentTool = {
             };
             const hint = builtinHints[input.subagent_type.toLowerCase()];
             if (hint) {
-                systemPrompt = hint + "\n\n" + systemPrompt;
+                systemPrompt = `${hint}\n\n${systemPrompt}`;
             }
             else {
                 // Check agent roles (code-reviewer, test-writer, debugger, evaluator, etc.)
                 const { getRole } = await import("../../agents/roles.js");
                 role = getRole(input.subagent_type.toLowerCase());
                 if (role) {
-                    systemPrompt = role.systemPromptSupplement + "\n\n" + systemPrompt;
+                    systemPrompt = `${role.systemPromptSupplement}\n\n${systemPrompt}`;
                 }
             }
         }
@@ -64,9 +71,9 @@ export const AgentTool = {
         let agentTools = context.tools;
         const allowList = input.allowed_tools ?? (role?.suggestedTools?.length ? role.suggestedTools : null);
         if (allowList) {
-            const allowSet = new Set(allowList.map(n => n.toLowerCase()));
-            allowSet.add('askuser'); // Always allow user communication
-            const filtered = context.tools.filter(t => allowSet.has(t.name.toLowerCase()));
+            const allowSet = new Set(allowList.map((n) => n.toLowerCase()));
+            allowSet.add("askuser"); // Always allow user communication
+            const filtered = context.tools.filter((t) => allowSet.has(t.name.toLowerCase()));
             if (filtered.length > 0)
                 agentTools = filtered; // Fallback to all tools if filter produces empty set
         }
@@ -82,10 +89,12 @@ export const AgentTool = {
             abortSignal: context.abortSignal,
         };
         const agentId = Date.now().toString(36) + Math.random().toString(36).slice(2, 6);
-        emitHook("subagentStart", { agentId, toolName: input.subagent_type ?? 'general' });
+        emitHook("subagentStart", { agentId, toolName: input.subagent_type ?? "general" });
         // Background execution: start agent and return immediately
         if (input.run_in_background) {
             const bgId = agentId;
+            const bus = getMessageBus();
+            bus.registerBackgroundAgent(bgId, input.subagent_type ?? "general");
             const runAgent = async () => {
                 let finalText = "";
                 const originalCwd = process.cwd();
@@ -94,7 +103,9 @@ export const AgentTool = {
                         try {
                             process.chdir(agentWorkingDir);
                         }
-                        catch { /* ignore */ }
+                        catch {
+                            /* ignore */
+                        }
                     }
                     for await (const event of query(input.prompt, config)) {
                         if (event.type === "text_delta")
@@ -106,7 +117,9 @@ export const AgentTool = {
                         try {
                             process.chdir(originalCwd);
                         }
-                        catch { /* ignore */ }
+                        catch {
+                            /* ignore */
+                        }
                     }
                     // Clean up worktree only if no changes were made
                     if (worktreePath) {
@@ -119,17 +132,20 @@ export const AgentTool = {
                         }
                     }
                 }
+                bus.completeBackgroundAgent(bgId, finalText);
                 if (context.onOutputChunk && context.callId) {
                     context.onOutputChunk(context.callId, `\n[background:${bgId} completed]\n${finalText}`);
                 }
             };
             runAgent().catch((err) => {
+                const errMsg = err instanceof Error ? err.message : String(err);
+                bus.errorBackgroundAgent(bgId, errMsg);
                 if (context.onOutputChunk && context.callId) {
-                    context.onOutputChunk(context.callId, `\n[background:${bgId} failed: ${err instanceof Error ? err.message : String(err)}]`);
+                    context.onOutputChunk(context.callId, `\n[background:${bgId} failed: ${errMsg}]`);
                 }
             });
             return {
-                output: `Background agent started (id: ${bgId}). You will be notified when it completes.`,
+                output: `Background agent started (id: ${bgId}). You will be notified when it completes. Use SendMessage with to:'${bgId}' to send it messages.`,
                 isError: false,
             };
         }
@@ -142,7 +158,9 @@ export const AgentTool = {
                 try {
                     process.chdir(agentWorkingDir);
                 }
-                catch { /* ignore */ }
+                catch {
+                    /* ignore */
+                }
             }
             try {
                 for await (const event of query(input.prompt, config)) {
@@ -171,7 +189,9 @@ export const AgentTool = {
                     try {
                         process.chdir(originalCwd);
                     }
-                    catch { /* ignore */ }
+                    catch {
+                        /* ignore */
+                    }
                 }
             }
         }

package/dist/tools/AskUserTool/index.js

@@ -22,7 +22,7 @@ export const AskUserTool = {
         // Headless fallback — return question as text so LLM can see it
         let output = `[AskUser] ${input.question}`;
         if (input.options && input.options.length > 0) {
-            output += "\nOptions:\n" + input.options.map((o, i) => `  ${i + 1}. ${o}`).join("\n");
+            output += `\nOptions:\n${input.options.map((o, i) => `  ${i + 1}. ${o}`).join("\n")}`;
         }
         output += "\n(No interactive session available — please answer in your next message.)";
         return { output, isError: false };

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

@@ -7,13 +7,13 @@ declare const inputSchema: z.ZodObject<{
     run_in_background: z.ZodOptional<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
     command: string;
-    description?: string | undefined;
     timeout?: number | undefined;
+    description?: string | undefined;
     run_in_background?: boolean | undefined;
 }, {
     command: string;
-    description?: string | undefined;
     timeout?: number | undefined;
+    description?: string | undefined;
     run_in_background?: boolean | undefined;
 }>;
 export declare const BashTool: Tool<typeof inputSchema>;