@poncho-ai/harness 0.26.0 → 0.28.0

package/src/harness.ts

@@ -32,6 +32,7 @@ import { addPromptCacheBreakpoints } from "./prompt-cache.js";
 import { jsonSchemaToZod } from "./schema-converter.js";
 import type { SkillMetadata } from "./skill-context.js";
 import { createSkillTools, normalizeScriptPolicyPath } from "./skill-tools.js";
+import { createSearchTools } from "./search-tools.js";
 import { createSubagentTools } from "./subagent-tools.js";
 import type { SubagentManager } from "./subagent-manager.js";
 import { LatitudeTelemetry } from "@latitude-data/telemetry";
@@ -562,7 +563,7 @@ export class AgentHarness {
   private insideTelemetryCapture = false;
   private _browserSession?: unknown;
   private _browserMod?: {
-    createBrowserTools: (getSession: () => unknown, getConversationId: () => string) => ToolDefinition[];
+    createBrowserTools: (getSession: () => unknown, getConversationId?: () => string) => ToolDefinition[];
     BrowserSession: new (sessionId: string, config: Record<string, unknown>) => unknown;
   };
 
@@ -622,11 +623,7 @@ export class AgentHarness {
   setSubagentManager(manager: SubagentManager): void {
     this.subagentManager = manager;
     this.dispatcher.registerMany(
-      createSubagentTools(
-        manager,
-        () => this._currentRunConversationId,
-        () => this._currentRunOwnerId ?? "anonymous",
-      ),
+      createSubagentTools(manager),
     );
   }
 
@@ -648,6 +645,11 @@ export class AgentHarness {
     if (this.isToolEnabled("delete_directory")) {
       this.registerIfMissing(createDeleteDirectoryTool(this.workingDir));
     }
+    for (const tool of createSearchTools()) {
+      if (this.isToolEnabled(tool.name)) {
+        this.registerIfMissing(tool);
+      }
+    }
     if (this.environment === "development" && this.isToolEnabled("poncho_docs")) {
       this.registerIfMissing(ponchoDocsTool);
     }
@@ -1165,7 +1167,7 @@ export class AgentHarness {
   private async initBrowserTools(config: PonchoConfig): Promise<void> {
     const spec = ["@poncho-ai", "browser"].join("/");
     let browserMod: {
-      createBrowserTools: (getSession: () => unknown, getConversationId: () => string) => ToolDefinition[];
+      createBrowserTools: (getSession: () => unknown, getConversationId?: () => string) => ToolDefinition[];
       BrowserSession: new (sessionId: string, cfg?: Record<string, unknown>) => unknown;
     };
     try {
@@ -1209,7 +1211,10 @@ export class AgentHarness {
 
     const tools = browserMod.createBrowserTools(
       () => session,
-      () => this._currentRunConversationId ?? "__default__",
+      // Backward compat: older @poncho-ai/browser versions expect a second
+      // getConversationId callback.  Current versions read from ToolContext
+      // and ignore extra args.
+      () => "__default__",
     );
     for (const tool of tools) {
       if (this.isToolEnabled(tool.name)) {
@@ -1218,10 +1223,6 @@ export class AgentHarness {
     }
   }
 
-  /** Conversation ID of the currently executing run (set during run, cleared after). */
-  private _currentRunConversationId?: string;
-  /** Owner ID of the currently executing run (used by subagent tools). */
-  private _currentRunOwnerId?: string;
 
   get browserSession(): unknown {
     return this._browserSession;
@@ -1369,13 +1370,6 @@ export class AgentHarness {
     await this.refreshAgentIfChanged();
     await this.refreshSkillsIfChanged();
 
-    // Track which conversation/owner this run belongs to so browser & subagent tools resolve correctly
-    this._currentRunConversationId = input.conversationId;
-    const ownerParam = input.parameters?.__ownerId;
-    if (typeof ownerParam === "string") {
-      this._currentRunOwnerId = ownerParam;
-    }
-
     let agent = this.parsedAgent as ParsedAgent;
     const runId = `run_${randomUUID()}`;
     const start = now();
@@ -1385,9 +1379,9 @@ export class AgentHarness {
       ? 0 // no hard timeout in development unless explicitly configured
       : (configuredTimeout ?? 300) * 1000;
     const platformMaxDurationSec = Number(process.env.PONCHO_MAX_DURATION) || 0;
-    const softDeadlineMs = platformMaxDurationSec > 0
-      ? platformMaxDurationSec * 800
-      : 0;
+    const softDeadlineMs = (input.disableSoftDeadline || platformMaxDurationSec <= 0)
+      ? 0
+      : platformMaxDurationSec * 800;
     const messages: Message[] = [...(input.messages ?? [])];
     const inputMessageCount = messages.length;
     const events: AgentEvent[] = [];
@@ -1541,6 +1535,18 @@ ${boundedMainMemory.trim()}`
           metadata: { timestamp: now(), id: randomUUID() },
         });
       }
+    } else {
+      // Continuation run (no explicit task). Some providers (Anthropic) require
+      // the conversation to end with a user message. Inject a transient signal
+      // that is sent to the LLM but never persisted to the conversation store.
+      const lastMsg = messages[messages.length - 1];
+      if (lastMsg && lastMsg.role !== "user") {
+        messages.push({
+          role: "user",
+          content: "[System: Your previous turn was interrupted by a time limit. Continue from where you left off — do NOT repeat what you already said. Proceed directly with the next action or tool call.]",
+          metadata: { timestamp: now(), id: randomUUID() },
+        });
+      }
     }
 
     let responseText = "";
@@ -1577,6 +1583,7 @@ ${boundedMainMemory.trim()}`
             tokens: { input: totalInputTokens, output: totalOutputTokens, cached: totalCachedTokens },
             duration: now() - start,
             continuation: true,
+            continuationMessages: [...messages],
             maxSteps,
           };
           yield pushEvent({ type: "run:completed", runId, result });
@@ -1727,6 +1734,9 @@ ${boundedMainMemory.trim()}`
             } catch {
               // Not JSON, treat as regular assistant text.
             }
+            if (!assistantText || assistantText.trim().length === 0) {
+              return [];
+            }
             return [{ role: "assistant" as const, content: assistantText }];
           }
 
@@ -2403,6 +2413,7 @@ ${boundedMainMemory.trim()}`
         tokens: { input: totalInputTokens, output: totalOutputTokens, cached: totalCachedTokens },
         duration: now() - start,
         continuation: true,
+        continuationMessages: [...messages],
         maxSteps,
       };
       yield pushEvent({ type: "run:completed", runId, result });

package/src/index.ts

@@ -9,6 +9,7 @@ export * from "./memory.js";
 export * from "./mcp.js";
 export * from "./model-factory.js";
 export * from "./schema-converter.js";
+export * from "./search-tools.js";
 export * from "./skill-context.js";
 export * from "./skill-tools.js";
 export * from "./state.js";

package/src/kv-store.ts

@@ -38,17 +38,27 @@ class UpstashKVStore implements RawKVStore {
   }
 
   async set(key: string, value: string): Promise<void> {
-    await fetch(
-      `${this.baseUrl}/set/${encodeURIComponent(key)}/${encodeURIComponent(value)}`,
-      { method: "POST", headers: this.headers() },
-    );
+    const response = await fetch(this.baseUrl, {
+      method: "POST",
+      headers: this.headers(),
+      body: JSON.stringify(["SET", key, value]),
+    });
+    if (!response.ok) {
+      const text = await response.text().catch(() => "");
+      console.error(`[kv][upstash] SET failed (${response.status}): ${text.slice(0, 200)}`);
+    }
   }
 
   async setWithTtl(key: string, value: string, ttl: number): Promise<void> {
-    await fetch(
-      `${this.baseUrl}/setex/${encodeURIComponent(key)}/${Math.max(1, ttl)}/${encodeURIComponent(value)}`,
-      { method: "POST", headers: this.headers() },
-    );
+    const response = await fetch(this.baseUrl, {
+      method: "POST",
+      headers: this.headers(),
+      body: JSON.stringify(["SETEX", key, Math.max(1, ttl), value]),
+    });
+    if (!response.ok) {
+      const text = await response.text().catch(() => "");
+      console.error(`[kv][upstash] SETEX failed (${response.status}): ${text.slice(0, 200)}`);
+    }
   }
 }
 

package/src/search-tools.ts

@@ -0,0 +1,181 @@
+import { load as cheerioLoad, type CheerioAPI } from "cheerio";
+import { defineTool, type ToolDefinition } from "@poncho-ai/sdk";
+
+const SEARCH_UA =
+  "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36";
+
+const FETCH_TIMEOUT_MS = 15_000;
+
+// ---------------------------------------------------------------------------
+// web_search — Brave Search HTML scraping (no API key)
+// ---------------------------------------------------------------------------
+
+interface SearchResult {
+  title: string;
+  url: string;
+  snippet: string;
+}
+
+async function braveSearch(query: string, maxResults: number): Promise<SearchResult[]> {
+  const url = `https://search.brave.com/search?q=${encodeURIComponent(query)}`;
+  const res = await fetch(url, {
+    headers: {
+      "User-Agent": SEARCH_UA,
+      Accept: "text/html,application/xhtml+xml",
+      "Accept-Language": "en-US,en;q=0.9",
+    },
+    signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
+  });
+  if (!res.ok) {
+    throw new Error(`Search request failed (${res.status} ${res.statusText})`);
+  }
+  const html = await res.text();
+  return parseBraveResults(html, maxResults);
+}
+
+function parseBraveResults(html: string, max: number): SearchResult[] {
+  const $ = cheerioLoad(html);
+  const results: SearchResult[] = [];
+
+  $('div.snippet[data-type="web"]').each((_i, el) => {
+    if (results.length >= max) return false;
+
+    const $el = $(el);
+    const anchor = $el.find(".result-content a").first();
+    const href = anchor.attr("href") ?? "";
+    if (!href.startsWith("http")) return;
+
+    const title = $el.find(".title").first().text().trim();
+    const snippet = $el.find(".generic-snippet .content").first().text().trim();
+
+    if (title) {
+      results.push({ title, url: href, snippet });
+    }
+  });
+
+  return results;
+}
+
+// ---------------------------------------------------------------------------
+// web_fetch — fetch a URL and extract readable text via cheerio
+// ---------------------------------------------------------------------------
+
+const DEFAULT_MAX_LENGTH = 16_000;
+
+function extractReadableText($: CheerioAPI, maxLength: number): { title: string; content: string } {
+  const title = $("title").first().text().trim();
+
+  $("script, style, noscript, nav, footer, header, aside, [role='navigation'], [role='banner'], [role='contentinfo']").remove();
+  $("svg, iframe, form, button, input, select, textarea").remove();
+
+  let root = $("article").first();
+  if (!root.length) root = $("main").first();
+  if (!root.length) root = $("[role='main']").first();
+  if (!root.length) root = $("body").first();
+
+  const text = root
+    .text()
+    .replace(/[ \t]+/g, " ")
+    .replace(/\n{3,}/g, "\n\n")
+    .trim();
+
+  const content =
+    text.length > maxLength ? text.slice(0, maxLength) + "\n…(truncated)" : text;
+
+  return { title, content };
+}
+
+// ---------------------------------------------------------------------------
+// Tool definitions
+// ---------------------------------------------------------------------------
+
+export const createSearchTools = (): ToolDefinition[] => [
+  defineTool({
+    name: "web_search",
+    description:
+      "Search the web and return a list of results (title, URL, snippet). " +
+      "Use this instead of opening a browser when you need to find information online.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          description: "The search query",
+        },
+        max_results: {
+          type: "number",
+          description: "Maximum number of results to return (1-10, default 5)",
+        },
+      },
+      required: ["query"],
+      additionalProperties: false,
+    },
+    handler: async (input) => {
+      const query = typeof input.query === "string" ? input.query.trim() : "";
+      if (!query) {
+        return { error: "A non-empty query string is required." };
+      }
+      const max = Math.min(Math.max(Number(input.max_results) || 5, 1), 10);
+      try {
+        const results = await braveSearch(query, max);
+        if (results.length === 0) {
+          return { query, results: [], note: "No results found. Try rephrasing your query." };
+        }
+        return { query, results };
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return {
+          error: `Search failed: ${msg}`,
+          hint: "The search provider may be rate-limiting requests. Try again shortly, or use browser tools as a fallback.",
+        };
+      }
+    },
+  }),
+
+  defineTool({
+    name: "web_fetch",
+    description:
+      "Fetch a web page and return its text content (HTML tags stripped). " +
+      "Useful for reading articles, documentation, or any web page without opening a browser.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        url: {
+          type: "string",
+          description: "The URL to fetch",
+        },
+        max_length: {
+          type: "number",
+          description: `Maximum character length of returned content (default ${DEFAULT_MAX_LENGTH})`,
+        },
+      },
+      required: ["url"],
+      additionalProperties: false,
+    },
+    handler: async (input) => {
+      const url = typeof input.url === "string" ? input.url.trim() : "";
+      if (!url) {
+        return { error: 'A "url" string is required.' };
+      }
+      const maxLength = Math.max(Number(input.max_length) || DEFAULT_MAX_LENGTH, 1_000);
+
+      try {
+        const res = await fetch(url, {
+          headers: { "User-Agent": SEARCH_UA, Accept: "text/html,application/xhtml+xml" },
+          redirect: "follow",
+          signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
+        });
+        if (!res.ok) {
+          return { url, status: res.status, error: res.statusText };
+        }
+        const html = await res.text();
+        const $ = cheerioLoad(html);
+        const { title, content } = extractReadableText($, maxLength);
+        return { url, status: res.status, title, content };
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return { url, error: `Fetch failed: ${msg}` };
+      }
+    },
+  }),
+];

package/src/state.ts

@@ -21,6 +21,15 @@ export interface StateStore {
   delete(runId: string): Promise<void>;
 }
 
+export interface PendingSubagentResult {
+  subagentId: string;
+  task: string;
+  status: "completed" | "error" | "stopped";
+  result?: import("@poncho-ai/sdk").RunResult;
+  error?: import("@poncho-ai/sdk").AgentFailure;
+  timestamp: number;
+}
+
 export interface Conversation {
   conversationId: string;
   title: string;
@@ -55,6 +64,13 @@ export interface Conversation {
     channelId: string;
     platformThreadId: string;
   };
+  pendingSubagentResults?: PendingSubagentResult[];
+  subagentCallbackCount?: number;
+  runningCallbackSince?: number;
+  lastActivityAt?: number;
+  /** Harness-internal message chain preserved across continuation runs.
+   *  Cleared when a run completes without continuation. */
+  _continuationMessages?: Message[];
   createdAt: number;
   updatedAt: number;
 }
@@ -67,6 +83,7 @@ export interface ConversationStore {
   update(conversation: Conversation): Promise<void>;
   rename(conversationId: string, title: string): Promise<Conversation | undefined>;
   delete(conversationId: string): Promise<boolean>;
+  appendSubagentResult(conversationId: string, result: PendingSubagentResult): Promise<void>;
 }
 
 export type StateProviderName =
@@ -300,6 +317,14 @@ export class InMemoryConversationStore implements ConversationStore {
   async delete(conversationId: string): Promise<boolean> {
     return this.conversations.delete(conversationId);
   }
+
+  async appendSubagentResult(conversationId: string, result: PendingSubagentResult): Promise<void> {
+    const conversation = this.conversations.get(conversationId);
+    if (!conversation) return;
+    if (!conversation.pendingSubagentResults) conversation.pendingSubagentResults = [];
+    conversation.pendingSubagentResults.push(result);
+    conversation.updatedAt = Date.now();
+  }
 }
 
 export type ConversationSummary = {
@@ -572,6 +597,16 @@ class FileConversationStore implements ConversationStore {
     }
     return removed;
   }
+
+  async appendSubagentResult(conversationId: string, result: PendingSubagentResult): Promise<void> {
+    await this.ensureLoaded();
+    const conversation = await this.get(conversationId);
+    if (!conversation) return;
+    if (!conversation.pendingSubagentResults) conversation.pendingSubagentResults = [];
+    conversation.pendingSubagentResults.push(result);
+    conversation.updatedAt = Date.now();
+    await this.update(conversation);
+  }
 }
 
 type LocalStateFile = {
@@ -689,6 +724,7 @@ abstract class KeyValueConversationStoreBase implements ConversationStore {
   protected readonly ttl?: number;
   private readonly agentIdPromise: Promise<string>;
   private readonly ownerLocks = new Map<string, Promise<void>>();
+  private readonly appendLocks = new Map<string, Promise<void>>();
   protected readonly memoryFallback: InMemoryConversationStore;
 
   constructor(ttl: number | undefined, workingDir: string, agentId?: string) {
@@ -712,6 +748,19 @@ abstract class KeyValueConversationStoreBase implements ConversationStore {
     }
   }
 
+  private async withAppendLock(conversationId: string, task: () => Promise<void>): Promise<void> {
+    const prev = this.appendLocks.get(conversationId) ?? Promise.resolve();
+    const next = prev.then(task, task);
+    this.appendLocks.set(conversationId, next);
+    try {
+      await next;
+    } finally {
+      if (this.appendLocks.get(conversationId) === next) {
+        this.appendLocks.delete(conversationId);
+      }
+    }
+  }
+
   private async namespace(): Promise<string> {
     const agentId = await this.agentIdPromise;
     return `poncho:${STORAGE_SCHEMA_VERSION}:${slugifyStorageComponent(agentId)}`;
@@ -945,6 +994,17 @@ abstract class KeyValueConversationStoreBase implements ConversationStore {
     });
     return true;
   }
+
+  async appendSubagentResult(conversationId: string, result: PendingSubagentResult): Promise<void> {
+    await this.withAppendLock(conversationId, async () => {
+      const conversation = await this.get(conversationId);
+      if (!conversation) return;
+      if (!conversation.pendingSubagentResults) conversation.pendingSubagentResults = [];
+      conversation.pendingSubagentResults.push(result);
+      conversation.updatedAt = Date.now();
+      await this.update(conversation);
+    });
+  }
 }
 
 class UpstashConversationStore extends KeyValueConversationStoreBase {
@@ -991,23 +1051,28 @@ class UpstashConversationStore extends KeyValueConversationStoreBase {
         return (payload.result ?? []).map((v) => v ?? undefined);
       },
       set: async (key: string, value: string, ttl?: number) => {
-        const endpoint =
-          typeof ttl === "number"
-            ? `${this.baseUrl}/setex/${encodeURIComponent(key)}/${Math.max(
-                1,
-                ttl,
-              )}/${encodeURIComponent(value)}`
-            : `${this.baseUrl}/set/${encodeURIComponent(key)}/${encodeURIComponent(value)}`;
-        await fetch(endpoint, {
+        const command = typeof ttl === "number"
+          ? ["SETEX", key, Math.max(1, ttl), value]
+          : ["SET", key, value];
+        const response = await fetch(this.baseUrl, {
           method: "POST",
           headers: this.headers(),
+          body: JSON.stringify(command),
         });
+        if (!response.ok) {
+          const text = await response.text().catch(() => "");
+          console.error(`[store][upstash] SET failed (${response.status}): ${text.slice(0, 200)}`);
+        }
       },
       del: async (key: string) => {
-        await fetch(`${this.baseUrl}/del/${encodeURIComponent(key)}`, {
+        const response = await fetch(`${this.baseUrl}/del/${encodeURIComponent(key)}`, {
           method: "POST",
           headers: this.headers(),
         });
+        if (!response.ok) {
+          const text = await response.text().catch(() => "");
+          console.error(`[store][upstash] DEL failed (${response.status}): ${text.slice(0, 200)}`);
+        }
       },
     };
   }

package/src/subagent-manager.ts

@@ -15,14 +15,18 @@ export interface SubagentSummary {
   messageCount: number;
 }
 
+export interface SubagentSpawnResult {
+  subagentId: string;
+}
+
 export interface SubagentManager {
   spawn(opts: {
     task: string;
     parentConversationId: string;
     ownerId: string;
-  }): Promise<SubagentResult>;
+  }): Promise<SubagentSpawnResult>;
 
-  sendMessage(subagentId: string, message: string): Promise<SubagentResult>;
+  sendMessage(subagentId: string, message: string): Promise<SubagentSpawnResult>;
 
   stop(subagentId: string): Promise<void>;
 

package/src/subagent-tools.ts

@@ -1,48 +1,18 @@
-import { defineTool, type Message, type ToolDefinition, getTextContent } from "@poncho-ai/sdk";
-import type { SubagentManager, SubagentResult } from "./subagent-manager.js";
-
-const LAST_MESSAGES_TO_RETURN = 10;
-
-const summarizeResult = (r: SubagentResult): Record<string, unknown> => {
-  const summary: Record<string, unknown> = {
-    subagentId: r.subagentId,
-    status: r.status,
-  };
-  if (r.result) {
-    summary.result = {
-      status: r.result.status,
-      response: r.result.response,
-      steps: r.result.steps,
-      duration: r.result.duration,
-    };
-  }
-  if (r.error) {
-    summary.error = r.error;
-  }
-  if (r.latestMessages && r.latestMessages.length > 0) {
-    summary.latestMessages = r.latestMessages
-      .slice(-LAST_MESSAGES_TO_RETURN)
-      .map((m: Message) => ({
-        role: m.role,
-        content: getTextContent(m).slice(0, 2000),
-      }));
-  }
-  return summary;
-};
+import { defineTool, type ToolContext, type ToolDefinition } from "@poncho-ai/sdk";
+import type { SubagentManager } from "./subagent-manager.js";
 
 export const createSubagentTools = (
   manager: SubagentManager,
-  getConversationId: () => string | undefined,
-  getOwnerId: () => string,
 ): ToolDefinition[] => [
   defineTool({
     name: "spawn_subagent",
     description:
-      "Spawn a subagent to work on a task and wait for it to finish. The subagent is a full copy of " +
-      "yourself running in its own conversation context with access to the same tools (except memory writes). " +
-      "This call blocks until the subagent completes and returns its result.\n\n" +
+      "Spawn a subagent to work on a task in the background. Returns immediately with a subagent ID. " +
+      "The subagent runs independently and its result will be delivered to you as a message in the " +
+      "conversation when it completes.\n\n" +
       "Guidelines:\n" +
-      "- Use subagents to parallelize work: call spawn_subagent multiple times in one response for independent sub-tasks -- they run concurrently.\n" +
+      "- Spawn all needed subagents in a SINGLE response (they run concurrently), then end your turn with a brief message to the user.\n" +
+      "- Do NOT spawn more subagents in follow-up steps. Wait for results to be delivered before deciding if more work is needed.\n" +
       "- Prefer doing work yourself for simple or quick tasks. Spawn subagents for substantial, self-contained work.\n" +
       "- The subagent has no memory of your conversation -- write thorough, self-contained instructions in the task.",
     inputSchema: {
@@ -58,29 +28,32 @@ export const createSubagentTools = (
       required: ["task"],
       additionalProperties: false,
     },
-    handler: async (input) => {
+    handler: async (input: Record<string, unknown>, context: ToolContext) => {
       const task = typeof input.task === "string" ? input.task : "";
       if (!task.trim()) {
         return { error: "task is required" };
       }
-      const conversationId = getConversationId();
+      const conversationId = context.conversationId;
       if (!conversationId) {
         return { error: "no active conversation to spawn subagent from" };
       }
-      const result = await manager.spawn({
+      const ownerId = typeof context.parameters.__ownerId === "string"
+        ? context.parameters.__ownerId
+        : "anonymous";
+      const { subagentId } = await manager.spawn({
         task: task.trim(),
         parentConversationId: conversationId,
-        ownerId: getOwnerId(),
+        ownerId,
       });
-      return summarizeResult(result);
+      return { subagentId, status: "running" };
     },
   }),
 
   defineTool({
     name: "message_subagent",
     description:
-      "Send a follow-up message to a completed or stopped subagent and wait for it to finish. " +
-      "This restarts the subagent with the new message and blocks until it completes. " +
+      "Send a follow-up message to a completed or stopped subagent. The subagent restarts in the " +
+      "background and its result will be delivered to you as a message when it completes. " +
       "Only works when the subagent is not currently running.",
     inputSchema: {
       type: "object",
@@ -103,8 +76,8 @@ export const createSubagentTools = (
       if (!subagentId || !message.trim()) {
         return { error: "subagent_id and message are required" };
       }
-      const result = await manager.sendMessage(subagentId, message.trim());
-      return summarizeResult(result);
+      const { subagentId: id } = await manager.sendMessage(subagentId, message.trim());
+      return { subagentId: id, status: "running" };
     },
   }),
 
@@ -145,8 +118,8 @@ export const createSubagentTools = (
       properties: {},
       additionalProperties: false,
     },
-    handler: async () => {
-      const conversationId = getConversationId();
+    handler: async (_input: Record<string, unknown>, context: ToolContext) => {
+      const conversationId = context.conversationId;
       if (!conversationId) {
         return { error: "no active conversation" };
       }