@poncho-ai/harness 0.50.2 → 0.50.4

package/.turbo/turbo-build.log

@@ -1,5 +1,5 @@
 
-> @poncho-ai/harness@0.50.2 build /home/runner/work/poncho-ai/poncho-ai/packages/harness
+> @poncho-ai/harness@0.50.4 build /home/runner/work/poncho-ai/poncho-ai/packages/harness
 > node scripts/embed-docs.js && tsup src/index.ts --format esm --dts
 
 [embed-docs] Generated poncho-docs.ts with 4 topics
@@ -8,9 +8,9 @@
 CLI tsup v8.5.1
 CLI Target: es2022
 ESM Build start
-ESM dist/isolate-BNQ6P3HI.js 51.41 KB
-ESM dist/index.js            530.76 KB
-ESM ⚡️ Build success in 181ms
+ESM dist/index.js            533.24 KB
+ESM dist/isolate-F2PPSUL6.js 53.82 KB
+ESM ⚡️ Build success in 250ms
 DTS Build start
-DTS ⚡️ Build success in 5658ms
-DTS dist/index.d.ts 89.28 KB
+DTS ⚡️ Build success in 9179ms
+DTS dist/index.d.ts 89.97 KB

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # @poncho-ai/harness
 
+## 0.50.4
+
+### Patch Changes
+
+- [`9a39327`](https://github.com/cesr/poncho-ai/commit/9a393274d8a8061371d268fa81db3501cb0a8308) Thanks [@cesr](https://github.com/cesr)! - harness: fix three `run_code` / cancellation bugs.
+  - **Timers polyfill never fired delayed callbacks.** `setTimeout(fn, ms)` only ran the callback when `ms === 0`; any non-zero delay was stored and never invoked, so `await new Promise(r => setTimeout(r, 50))` (the standard sleep) hung forever. The polyfill now drains pending timers on the microtask queue in delay order against a virtual clock, so sleeps resolve and `setInterval`/`clearInterval` work.
+  - **No wall-clock bound on `run_code`.** isolated-vm's `timeout` only bounds synchronous execution; a script that returns a never-settling promise hung the whole turn indefinitely. `runtime.execute` now races the eval against a host timer that disposes the isolate, so `isolate.timeLimit` bounds total execution and returns a `TimeoutError`.
+  - **Stopping a turn mid-tool-call dropped the assistant turn from canonical history.** On cancellation the in-flight assistant message (its text + tool calls) lives only in step-local state — it's pushed to `messages` together with the tool results, which never arrive when stopped. The cancellation snapshot now re-attaches that turn with a synthesized "cancelled by user" tool result for each pending tool call, so the next request keeps a valid record instead of showing the model back-to-back user messages.
+
+- [`c604fd6`](https://github.com/cesr/poncho-ai/commit/c604fd6b41dfd06600af85daa892ab4fd3852bad) Thanks [@cesr](https://github.com/cesr)! - harness: harden subagent → parent result delivery so a step-exhausted subagent stops surfacing as `(no response)`.
+  - **Force a closing text turn on the final step.** On the last permitted step (`step === maxSteps`) the run loop now strips the tools and appends a one-shot "summarize now, no tools" nudge to that model request, so a run that hits its step ceiling produces a real text summary instead of terminating on a dangling tool call. Previously such a run ended on a tool-call turn with no final text — common in subagents doing many tool calls — and the parent received an empty result. `maxSteps` itself is unchanged; the nudge is request-only and never written to history.
+  - **Content-shape-robust result extraction.** Pulling a subagent's response no longer requires the last assistant message to be a plain `string`. The new `lastAssistantText` helper handles `string`, `ContentPart[]`, and the run loop's `{"text":...,"tool_calls":[...]}` envelope, and walks backwards to the last non-empty assistant text — so a transcript that ends on a text-less tool turn still yields the prose produced just before it.
+  - **Actionable empty-result sentinel.** When a subagent genuinely produced no summary, the injected parent message now says how many steps ran and points at `read_subagent(<id>, mode:"assistant")` to recover the work, instead of a dead-end `(no response)`.
+
+## 0.50.3
+
+### Patch Changes
+
+- [`a67fb45`](https://github.com/cesr/poncho-ai/commit/a67fb45162823d832296ae9af137eb566d9f2f97) Thanks [@cesr](https://github.com/cesr)! - harness: forward `tenantId` through `continueFromToolResult`. Resumed runs (after an approval checkpoint) ran tools with `ctx.tenantId` undefined, so tenant-scoped stores (memory, VFS, todos) resolved the default `"__default__"` tenant instead of the caller's — surfacing as `memory_main_get` returning empty after an approval resume.
+
 ## 0.50.2
 
 ### Patch Changes

package/dist/index.d.ts

@@ -1434,6 +1434,11 @@ declare class AgentHarness {
             error?: string;
         }>;
         conversationId?: string;
+        /** Must be forwarded for the continuation run, otherwise tenant-scoped
+         *  tool stores (memory, VFS, todos) resolve the default "__default__"
+         *  tenant on resume instead of the caller's — e.g. memory_main_get
+         *  returns empty after an approval checkpoint. */
+        tenantId?: string;
         parameters?: Record<string, unknown>;
         abortSignal?: AbortSignal;
     }): AsyncGenerator<AgentEvent>;
@@ -1976,6 +1981,13 @@ declare const MAX_SUBAGENT_CALLBACK_COUNT = 20;
 declare const CALLBACK_LOCK_STALE_MS: number;
 declare const STALE_SUBAGENT_THRESHOLD_MS: number;
 
+/**
+ * Find the last non-empty assistant text in a subagent transcript. Walking
+ * backwards (rather than reading only the final message) means a subagent
+ * that ended on a tool-call turn still yields the prose it produced just
+ * before — instead of surfacing to the parent as an empty result.
+ */
+declare const lastAssistantText: (messages: Message[]) => string;
 type ActiveConversationRun = {
     ownerId: string;
     abortController: AbortController;
@@ -2138,4 +2150,4 @@ interface RunConversationTurnResult {
 }
 declare const runConversationTurn: (opts: RunConversationTurnOpts) => Promise<RunConversationTurnResult>;
 
-export { type ActiveConversationRun, type ActiveSubagentRun, type AgentFrontmatter, AgentHarness, type AgentIdentity, type AgentLimitsConfig, type AgentModelConfig, AgentOrchestrator, type ApprovalEventItem, type ArchivedToolResult$1 as ArchivedToolResult, type BashConfig, BashEnvironmentManager, type BashExecutionLimits, type BuiltInToolToggles, CALLBACK_LOCK_STALE_MS, type CompactMessagesOptions, type CompactResult, type CompactionConfig, type ContinuationHooks, type Conversation, type ConversationCreateInit, type ConversationState, type ConversationStatusSnapshot, type ConversationStore, type ConversationSummary, type CreateSkillToolsOptions, type CronJobConfig, DEFAULT_AGENT_DESCRIPTION, DEFAULT_AGENT_NAME, DEFAULT_MAX_STEPS, DEFAULT_MODEL_NAME, DEFAULT_MODEL_PROVIDER, DEFAULT_TEMPERATURE, DEFAULT_TIMEOUT, type DefaultAgentDefinitionOptions, type EventSink, type ExecuteTurnResult, type HarnessOptions, type HarnessRunOutput, type HistorySource, InMemoryConversationStore, InMemoryEngine, InMemoryStateStore, type IsolateBinding, type IsolateConfig, LocalMcpBridge, LocalUploadStore, MAX_CONCURRENT_SUBAGENTS, MAX_CONTINUATION_COUNT, MAX_SUBAGENT_CALLBACK_COUNT, MAX_SUBAGENT_NESTING, type MainMemory, type McpConfig, type MemoryConfig, type MemoryStore, type MessagingChannelConfig, type ModelProviderFactory, type MountProvider, type NetworkConfig, OPENAI_CODEX_CLIENT_ID, type OpenAICodexAuthConfig, type OpenAICodexDeviceAuthRequest, type OpenAICodexSession, type OrchestratorHooks, type OrchestratorOptions, type OtlpConfig, type OtlpOption, PONCHO_UPLOAD_SCHEME, type ParsedAgent, type PendingSubagentApproval, type PendingSubagentResult, type PendingToolCall, type PonchoConfig, PonchoFsAdapter, PostgresEngine, type ProviderConfig, type Recurrence, type RecurrenceType, type Reminder, type ReminderCreateInput, type ReminderStatus, type ReminderStore, type RemoteMcpServerConfig, type RunConversationTurnOpts, type RunConversationTurnResult, type RunOutcome, type RunRequest, type RuntimeRenderContext, S3UploadStore, STALE_SUBAGENT_THRESHOLD_MS, STORAGE_SCHEMA_VERSION, type SecretsStore, type SkillContextEntry, type SkillMetadata, type SkillSource, SqliteEngine, type StateConfig, type StateProviderName, type StateStore, type StorageConfig, type StorageEngine, type StorageFactoryOptions, type StorageProvider, type StoredApproval, type SubagentManager, type SubagentResult, type SubagentSpawnResult, type SubagentSummary, type SubagentTranscript, type SubagentTranscriptMode, TOOL_RESULT_ARCHIVE_PARAM, type TelemetryConfig, TelemetryEmitter, type TenantTokenPayload, type ToolAccess, type ToolCall, ToolDispatcher, type ToolExecutionResult, type TurnDraftState, type TurnResultMetadata, type TurnSection, type UploadStore, type UploadsConfig, VFS_SCHEME, VercelBlobUploadStore, type VfsDirEntry, type VfsStat, type VirtualMount, applyTurnMetadata, buildAgentDirectoryName, buildApprovalCheckpoints, buildAssistantMetadata, buildSkillContextWindow, buildToolCompletedText, cloneSections, compactMessages, completeOpenAICodexDeviceAuth, computeNextOccurrence, createBashTool, createConversationStore, createConversationStoreFromEngine, createDefaultTools, createDeleteDirectoryTool, createDeleteTool, createEditTool, createMemoryStore, createMemoryStoreFromEngine, createMemoryTools, createModelProvider, createReminderStore, createReminderStoreFromEngine, createReminderTools, createSearchTools, createSecretsStore, createSkillTools, createStateStore, createStorageEngine, createSubagentTools, createTodoStoreFromEngine, createTurnDraftState, createUploadStore, createWriteTool, decodeFileInputData, defaultAgentDefinition, deleteOpenAICodexSession, deriveUploadKey, ensureAgentIdentity, estimateTokens, estimateTotalTokens, executeConversationTurn, findSafeSplitPoint, flushTurnDraft, generateAgentId, getAgentStoreDirectory, getModelContextWindow, getOpenAICodexAccessToken, getOpenAICodexAuthFilePath, getOpenAICodexRequiredScopes, getPonchoStoreRoot, isMessageArray, jsonSchemaToZod, loadCanonicalHistory, loadPonchoConfig, loadRunHistory, loadSkillContext, loadSkillInstructions, loadSkillMetadata, loadSkillMetadataFromDirs, loadVfsSkillMetadata, mergeSkills, normalizeApprovalCheckpoint, normalizeOtlp, normalizeScriptPolicyPath, normalizeToolAccess, parseAgentFile, parseAgentMarkdown, parseSkillFrontmatter, ponchoDocsTool, readOpenAICodexSession, readSkillResource, recordStandardTurnEvent, renderAgentPrompt, resolveAgentIdentity, resolveCompactionConfig, resolveEnv, resolveMemoryConfig, resolveRunRequest, resolveSkillDirs, resolveStateConfig, runConversationTurn, slugifyStorageComponent, startOpenAICodexDeviceAuth, verifyTenantToken, withToolResultArchiveParam, writeOpenAICodexSession };
+export { type ActiveConversationRun, type ActiveSubagentRun, type AgentFrontmatter, AgentHarness, type AgentIdentity, type AgentLimitsConfig, type AgentModelConfig, AgentOrchestrator, type ApprovalEventItem, type ArchivedToolResult$1 as ArchivedToolResult, type BashConfig, BashEnvironmentManager, type BashExecutionLimits, type BuiltInToolToggles, CALLBACK_LOCK_STALE_MS, type CompactMessagesOptions, type CompactResult, type CompactionConfig, type ContinuationHooks, type Conversation, type ConversationCreateInit, type ConversationState, type ConversationStatusSnapshot, type ConversationStore, type ConversationSummary, type CreateSkillToolsOptions, type CronJobConfig, DEFAULT_AGENT_DESCRIPTION, DEFAULT_AGENT_NAME, DEFAULT_MAX_STEPS, DEFAULT_MODEL_NAME, DEFAULT_MODEL_PROVIDER, DEFAULT_TEMPERATURE, DEFAULT_TIMEOUT, type DefaultAgentDefinitionOptions, type EventSink, type ExecuteTurnResult, type HarnessOptions, type HarnessRunOutput, type HistorySource, InMemoryConversationStore, InMemoryEngine, InMemoryStateStore, type IsolateBinding, type IsolateConfig, LocalMcpBridge, LocalUploadStore, MAX_CONCURRENT_SUBAGENTS, MAX_CONTINUATION_COUNT, MAX_SUBAGENT_CALLBACK_COUNT, MAX_SUBAGENT_NESTING, type MainMemory, type McpConfig, type MemoryConfig, type MemoryStore, type MessagingChannelConfig, type ModelProviderFactory, type MountProvider, type NetworkConfig, OPENAI_CODEX_CLIENT_ID, type OpenAICodexAuthConfig, type OpenAICodexDeviceAuthRequest, type OpenAICodexSession, type OrchestratorHooks, type OrchestratorOptions, type OtlpConfig, type OtlpOption, PONCHO_UPLOAD_SCHEME, type ParsedAgent, type PendingSubagentApproval, type PendingSubagentResult, type PendingToolCall, type PonchoConfig, PonchoFsAdapter, PostgresEngine, type ProviderConfig, type Recurrence, type RecurrenceType, type Reminder, type ReminderCreateInput, type ReminderStatus, type ReminderStore, type RemoteMcpServerConfig, type RunConversationTurnOpts, type RunConversationTurnResult, type RunOutcome, type RunRequest, type RuntimeRenderContext, S3UploadStore, STALE_SUBAGENT_THRESHOLD_MS, STORAGE_SCHEMA_VERSION, type SecretsStore, type SkillContextEntry, type SkillMetadata, type SkillSource, SqliteEngine, type StateConfig, type StateProviderName, type StateStore, type StorageConfig, type StorageEngine, type StorageFactoryOptions, type StorageProvider, type StoredApproval, type SubagentManager, type SubagentResult, type SubagentSpawnResult, type SubagentSummary, type SubagentTranscript, type SubagentTranscriptMode, TOOL_RESULT_ARCHIVE_PARAM, type TelemetryConfig, TelemetryEmitter, type TenantTokenPayload, type ToolAccess, type ToolCall, ToolDispatcher, type ToolExecutionResult, type TurnDraftState, type TurnResultMetadata, type TurnSection, type UploadStore, type UploadsConfig, VFS_SCHEME, VercelBlobUploadStore, type VfsDirEntry, type VfsStat, type VirtualMount, applyTurnMetadata, buildAgentDirectoryName, buildApprovalCheckpoints, buildAssistantMetadata, buildSkillContextWindow, buildToolCompletedText, cloneSections, compactMessages, completeOpenAICodexDeviceAuth, computeNextOccurrence, createBashTool, createConversationStore, createConversationStoreFromEngine, createDefaultTools, createDeleteDirectoryTool, createDeleteTool, createEditTool, createMemoryStore, createMemoryStoreFromEngine, createMemoryTools, createModelProvider, createReminderStore, createReminderStoreFromEngine, createReminderTools, createSearchTools, createSecretsStore, createSkillTools, createStateStore, createStorageEngine, createSubagentTools, createTodoStoreFromEngine, createTurnDraftState, createUploadStore, createWriteTool, decodeFileInputData, defaultAgentDefinition, deleteOpenAICodexSession, deriveUploadKey, ensureAgentIdentity, estimateTokens, estimateTotalTokens, executeConversationTurn, findSafeSplitPoint, flushTurnDraft, generateAgentId, getAgentStoreDirectory, getModelContextWindow, getOpenAICodexAccessToken, getOpenAICodexAuthFilePath, getOpenAICodexRequiredScopes, getPonchoStoreRoot, isMessageArray, jsonSchemaToZod, lastAssistantText, loadCanonicalHistory, loadPonchoConfig, loadRunHistory, loadSkillContext, loadSkillInstructions, loadSkillMetadata, loadSkillMetadataFromDirs, loadVfsSkillMetadata, mergeSkills, normalizeApprovalCheckpoint, normalizeOtlp, normalizeScriptPolicyPath, normalizeToolAccess, parseAgentFile, parseAgentMarkdown, parseSkillFrontmatter, ponchoDocsTool, readOpenAICodexSession, readSkillResource, recordStandardTurnEvent, renderAgentPrompt, resolveAgentIdentity, resolveCompactionConfig, resolveEnv, resolveMemoryConfig, resolveRunRequest, resolveSkillDirs, resolveStateConfig, runConversationTurn, slugifyStorageComponent, startOpenAICodexDeviceAuth, verifyTenantToken, withToolResultArchiveParam, writeOpenAICodexSession };

package/dist/index.js

@@ -8626,6 +8626,7 @@ var now = () => Date.now();
 var FIRST_CHUNK_TIMEOUT_MS = 9e4;
 var MAX_TRANSIENT_STEP_RETRIES = 1;
 var COMPACTION_CHECK_INTERVAL_STEPS = 3;
+var FINAL_STEP_SUMMARY_PROMPT = "You have reached the maximum number of steps for this run and cannot call any more tools. Do NOT attempt any tool calls. Using only the work you have already done, write your final response now: summarize what you found or accomplished, include any concrete results, and flag anything left unfinished.";
 var TOOL_RESULT_ARCHIVE_PARAM = "__toolResultArchive";
 var TOOL_RESULT_TRUNCATED_PREFIX = "[TRUNCATED_TOOL_RESULT]";
 var TOOL_RESULT_PREVIEW_CHARS = 700;
@@ -9951,7 +9952,7 @@ var AgentHarness = class _AgentHarness {
     this.registerIfMissing(createEditFileTool(getFs));
     this.registerIfMissing(createWriteFileTool(getFs));
     if (config?.isolate) {
-      const { createRunCodeTool, buildRunCodeDescription, bundleLibraries } = await import("./isolate-BNQ6P3HI.js");
+      const { createRunCodeTool, buildRunCodeDescription, bundleLibraries } = await import("./isolate-F2PPSUL6.js");
       let libraryPreamble = null;
       if (config.isolate.libraries?.length) {
         libraryPreamble = await bundleLibraries(config.isolate.libraries, this.workingDir);
@@ -10327,7 +10328,7 @@ Examples:${this.environment !== "production" ? `
 Files in the VFS are accessible to the user via \`/api/vfs/{path}\`. For example, a file at \`/downloads/report.pdf\` can be linked as \`/api/vfs/downloads/report.pdf\`. Use this to share downloadable files with the user.` : "";
     let isolateContext = "";
     if (this.loadedConfig?.isolate && this.dispatcher.get("run_code")) {
-      const { generateIsolateTypeStubs } = await import("./isolate-BNQ6P3HI.js");
+      const { generateIsolateTypeStubs } = await import("./isolate-F2PPSUL6.js");
       const typeStubs = generateIsolateTypeStubs(this.loadedConfig.isolate);
       isolateContext = `
 
@@ -10374,10 +10375,40 @@ ${this.skillFingerprint}`;
     };
     const isCancelled = () => input.abortSignal?.aborted === true;
     let cancellationEmitted = false;
+    let inflightTurn = null;
     const emitCancellation = () => {
       cancellationEmitted = true;
-      const snapshot = trimToValidPrefix([...messages]);
-      return pushEvent({ type: "run:cancelled", runId, messages: snapshot });
+      const snapshot = [...messages];
+      if (inflightTurn && (inflightTurn.text.length > 0 || inflightTurn.toolCalls.length > 0)) {
+        const hasToolCalls = inflightTurn.toolCalls.length > 0;
+        const assistantContent = hasToolCalls ? JSON.stringify({
+          text: inflightTurn.text,
+          tool_calls: inflightTurn.toolCalls.map((tc) => ({
+            id: tc.id,
+            name: tc.name,
+            input: tc.input
+          }))
+        }) : inflightTurn.text;
+        snapshot.push({
+          role: "assistant",
+          content: assistantContent,
+          metadata: { timestamp: now(), id: randomUUID5(), runId }
+        });
+        if (hasToolCalls) {
+          const cancelledResults = inflightTurn.toolCalls.map((tc) => ({
+            type: "tool_result",
+            tool_use_id: tc.id,
+            tool_name: tc.name,
+            content: "Tool execution cancelled by user."
+          }));
+          snapshot.push({
+            role: "tool",
+            content: JSON.stringify(cancelledResults),
+            metadata: { timestamp: now(), id: randomUUID5(), runId }
+          });
+        }
+      }
+      return pushEvent({ type: "run:cancelled", runId, messages: trimToValidPrefix(snapshot) });
     };
     const resolvedModelName = agent.frontmatter.model?.name ?? "claude-opus-4-5";
     const contextWindow = agent.frontmatter.model?.contextWindow ?? getModelContextWindow(resolvedModelName);
@@ -10460,6 +10491,7 @@ ${this.skillFingerprint}`;
       let cachedCoreMessages = [];
       let convertedUpTo = 0;
       for (let step = 1; step <= maxSteps; step += 1) {
+        inflightTurn = null;
         try {
           yield* drainBrowserEvents();
           if (isCancelled()) {
@@ -10817,11 +10849,14 @@ ${textContent}` };
             ...cachedMessages
           ] : cachedMessages;
           const telemetryEnabled = this.loadedConfig?.telemetry?.enabled !== false;
+          const isFinalStep = step === maxSteps;
+          const toolsForStep = isFinalStep ? {} : tools;
+          const messagesForStep = isFinalStep ? [...finalMessages, { role: "user", content: FINAL_STEP_SUMMARY_PROMPT }] : finalMessages;
           const result = await streamText({
             model: modelInstance,
             ...useStaticCache ? {} : { system: systemPrompt },
-            messages: finalMessages,
-            tools,
+            messages: messagesForStep,
+            tools: toolsForStep,
             temperature,
             abortSignal: input.abortSignal,
             ...typeof maxTokens === "number" ? { maxTokens } : {},
@@ -10950,6 +10985,7 @@ ${textContent}` };
             yield pushEvent({ type: "run:completed", runId, result: result_ });
             return;
           }
+          inflightTurn = { text: fullText, toolCalls: [] };
           if (isCancelled()) {
             yield emitCancellation();
             return;
@@ -11036,6 +11072,7 @@ ${textContent}` };
             name: tc.toolName,
             input: tc.input
           }));
+          if (inflightTurn) inflightTurn.toolCalls = toolCalls;
           if (toolCalls.length === 0) {
             if (fullText.length === 0) {
               const isExpectedEmpty = finishReason === "stop";
@@ -11416,6 +11453,7 @@ ${textContent}` };
             content: JSON.stringify(toolResultsForModel),
             metadata: toolMsgMeta
           });
+          inflightTurn = null;
           if (softDeadlineMs > 0 && now() - start > softDeadlineMs) {
             const result_ = {
               status: "completed",
@@ -11568,6 +11606,7 @@ ${this.skillFingerprint}`;
     yield* this.runWithTelemetry({
       messages,
       conversationId: input.conversationId,
+      tenantId: input.tenantId,
       parameters: input.parameters,
       abortSignal: input.abortSignal
     });
@@ -12281,6 +12320,26 @@ var CALLBACK_LOCK_STALE_MS = 5 * 60 * 1e3;
 var STALE_SUBAGENT_THRESHOLD_MS = 5 * 60 * 1e3;
 
 // src/orchestrator/orchestrator.ts
+import { getTextContent as getTextContent3 } from "@poncho-ai/sdk";
+var assistantMessageText = (message) => {
+  const raw = getTextContent3(message).trim();
+  if (raw.startsWith("{") && raw.includes('"tool_calls"')) {
+    try {
+      const parsed = JSON.parse(raw);
+      if (typeof parsed.text === "string") return parsed.text.trim();
+    } catch {
+    }
+  }
+  return raw;
+};
+var lastAssistantText = (messages) => {
+  for (let i = messages.length - 1; i >= 0; i -= 1) {
+    if (messages[i].role !== "assistant") continue;
+    const text = assistantMessageText(messages[i]);
+    if (text) return text;
+  }
+  return "";
+};
 var AgentOrchestrator = class {
   harness;
   conversationStore;
@@ -12998,14 +13057,11 @@ var AgentOrchestrator = class {
         subagentId: childConversationId,
         conversationId: childConversationId
       });
-      let subagentResponse = runResult?.response ?? draft.assistantResponse;
+      let subagentResponse = (runResult?.response ?? draft.assistantResponse ?? "").trim();
       if (!subagentResponse) {
         const freshSubConv = await this.conversationStore.get(childConversationId);
         if (freshSubConv) {
-          const lastAssistant = [...freshSubConv.messages].reverse().find((m) => m.role === "assistant");
-          if (lastAssistant && typeof lastAssistant.content === "string") {
-            subagentResponse = lastAssistant.content;
-          }
+          subagentResponse = lastAssistantText(freshSubConv.messages);
         }
       }
       const pendingResult = {
@@ -13094,8 +13150,10 @@ var AgentOrchestrator = class {
     const callbackCount = (conversation.subagentCallbackCount ?? 0) + 1;
     conversation.subagentCallbackCount = callbackCount;
     for (const pr of pendingResults) {
+      const responseText = (pr.result?.response ?? "").trim();
+      const responseLine = responseText || `(subagent produced no final summary after ${pr.result?.steps ?? 0} step(s); its work may be incomplete. Call read_subagent with subagent_id "${pr.subagentId}" and mode "assistant" to retrieve what it did.)`;
       const resultBody = pr.result ? `Status: ${pr.result.status}
-Response: ${pr.result.response ?? "(no response)"}
+Response: ${responseLine}
 Steps: ${pr.result.steps}, Duration: ${pr.result.duration}ms` : pr.error ? `Error: ${pr.error.message}` : "(no result)";
       conversation.messages.push({
         role: "user",
@@ -13347,14 +13405,11 @@ ${resultBody}`,
         subagentId: conversationId,
         conversationId
       });
-      let subagentResponse = runResult?.response ?? draft.assistantResponse;
+      let subagentResponse = (runResult?.response ?? draft.assistantResponse ?? "").trim();
       if (!subagentResponse) {
         const freshSubConv = await this.conversationStore.get(conversationId);
         if (freshSubConv) {
-          const lastAssistant = [...freshSubConv.messages].reverse().find((m) => m.role === "assistant");
-          if (lastAssistant) {
-            subagentResponse = typeof lastAssistant.content === "string" ? lastAssistant.content : "";
-          }
+          subagentResponse = lastAssistantText(freshSubConv.messages);
         }
       }
       const parentConv = await this.conversationStore.get(parentConversationId);
@@ -14047,6 +14102,7 @@ export {
   getPonchoStoreRoot,
   isMessageArray,
   jsonSchemaToZod,
+  lastAssistantText,
   loadCanonicalHistory,
   loadPonchoConfig,
   loadRunHistory,

package/dist/{isolate-BNQ6P3HI.js → isolate-F2PPSUL6.js}

@@ -89,6 +89,8 @@ function createIsolateRuntime(config) {
       }
       const t0 = performance.now();
       let context;
+      let timedOut = false;
+      let wallTimer;
       try {
         context = await isolate.createContext();
         const jail = context.global;
@@ -121,12 +123,29 @@ function createIsolateRuntime(config) {
         const wrapped = `(async () => {
 ${code}
 })()`;
-        const rawResult = await context.eval(wrapped, {
+        const evalPromise = context.eval(wrapped, {
           filename: "<user-code>",
           promise: true,
           copy: true,
           timeout: config.timeout
         });
+        const rawResult = config.timeout > 0 ? await Promise.race([
+          evalPromise,
+          new Promise((_resolve, reject) => {
+            wallTimer = setTimeout(() => {
+              timedOut = true;
+              try {
+                isolate.dispose();
+              } catch {
+              }
+              reject(new Error("Execution timed out"));
+            }, config.timeout);
+          })
+        ]) : await evalPromise;
+        if (wallTimer) {
+          clearTimeout(wallTimer);
+          wallTimer = void 0;
+        }
         const stdout = await context.eval("__stdout.join('\\n')", { copy: true });
         const stderr = await context.eval("__stderr.join('\\n')", { copy: true });
         let result;
@@ -151,6 +170,17 @@ ${code}
             executionTimeMs: elapsed
           };
         }
+        if (timedOut) {
+          return {
+            stdout: "",
+            stderr: "",
+            error: {
+              message: `Execution timed out after ${config.timeout}ms`,
+              name: "TimeoutError"
+            },
+            executionTimeMs: elapsed
+          };
+        }
         let stdout = "";
         let stderr = "";
         if (context) {
@@ -169,6 +199,7 @@ ${code}
           executionTimeMs: elapsed
         };
       } finally {
+        if (wallTimer) clearTimeout(wallTimer);
         if (abortHandler && signal) {
           signal.removeEventListener("abort", abortHandler);
         }
@@ -927,50 +958,79 @@ var POLYFILL_FETCH_STUB = `
 `;
 var POLYFILL_TIMERS = `
 // --- Timers polyfill ---
+//
+// The isolate has no host event loop, so real wall-clock delays can't be
+// honoured. What we *can* do is drain pending timers on the microtask queue
+// (which isolated-vm does pump while resolving the run's promise), firing
+// them in order of their requested delay against a virtual clock. This makes
+// the overwhelmingly common pattern \u2014 \`await new Promise(r => setTimeout(r, n))\`
+// as a sleep \u2014 actually resolve instead of hanging the whole run forever.
+// Delays collapse to "as soon as possible, in delay order"; that's the right
+// trade for a sandbox with no real time. A runaway setInterval is bounded by
+// __MAX_FIRES here and, ultimately, by the host-side wall-clock timeout.
 (function() {
   let __timerId = 0;
-  const __timers = new Map();
+  const __timers = new Map();   // id -> { fn, due, type }
+  const __intervals = new Set(); // ids that should reschedule
+  let __vclock = 0;             // virtual clock (ms)
+  let __draining = false;
+  let __fired = 0;
+  const __MAX_FIRES = 1000000;  // backstop against a runaway interval
+
+  function __schedule(fn, delayMs, type, id) {
+    __timers.set(id, { fn, due: __vclock + delayMs, type });
+    if (!__draining) __drain();
+    return id;
+  }
+
+  function __drain() {
+    __draining = true;
+    const step = function() {
+      if (__timers.size === 0) { __draining = false; return; }
+      // Pick the earliest-due timer (ties broken by insertion id for FIFO).
+      let pick = null;
+      for (const [id, t] of __timers) {
+        if (pick === null || t.due < pick.t.due || (t.due === pick.t.due && id < pick.id)) {
+          pick = { id, t };
+        }
+      }
+      __timers.delete(pick.id);
+      if (pick.t.due > __vclock) __vclock = pick.t.due;
+      __fired++;
+      try { pick.t.fn(); } catch (e) { /* host timers swallow callback throws */ }
+      if (__fired > __MAX_FIRES) { __draining = false; return; }
+      Promise.resolve().then(step);
+    };
+    Promise.resolve().then(step);
+  }
 
   globalThis.setTimeout = function(fn, delay) {
     const id = ++__timerId;
     const ms = Math.max(0, Number(delay) || 0);
-    const start = Date.now();
-    __timers.set(id, { fn, ms, start, type: "timeout" });
-    // In the isolate, setTimeout returns the id but the callback is
-    // executed via a polling mechanism in the async wrapper.
-    // For simple cases (delay=0), we can use a microtask.
-    if (ms === 0) {
-      Promise.resolve().then(() => {
-        if (__timers.has(id)) {
-          __timers.delete(id);
-          fn();
-        }
-      });
-    }
-    return id;
+    return __schedule(typeof fn === "function" ? fn : function() {}, ms, "timeout", id);
   };
 
   globalThis.clearTimeout = function(id) {
     __timers.delete(id);
+    __intervals.delete(id);
   };
 
   globalThis.setInterval = function(fn, delay) {
     const id = ++__timerId;
     const ms = Math.max(1, Number(delay) || 1);
-    const wrapper = () => {
-      if (!__timers.has(id)) return;
-      fn();
-      if (__timers.has(id)) {
-        globalThis.setTimeout(wrapper, ms);
+    __intervals.add(id);
+    const tick = function() {
+      if (!__intervals.has(id)) return;
+      try { fn(); } finally {
+        if (__intervals.has(id)) __schedule(tick, ms, "interval", id);
       }
     };
-    __timers.set(id, { fn: wrapper, ms, type: "interval" });
-    globalThis.setTimeout(wrapper, ms);
-    return id;
+    return __schedule(tick, ms, "interval", id);
   };
 
   globalThis.clearInterval = function(id) {
     __timers.delete(id);
+    __intervals.delete(id);
   };
 
   // queueMicrotask if not available

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@poncho-ai/harness",
-  "version": "0.50.2",
+  "version": "0.50.4",
   "description": "Agent execution runtime - conversation loop, tool dispatch, streaming",
   "repository": {
     "type": "git",

package/src/harness.ts

@@ -159,6 +159,16 @@ const now = (): number => Date.now();
 const FIRST_CHUNK_TIMEOUT_MS = 90_000; // 90s to receive the first chunk from the model
 const MAX_TRANSIENT_STEP_RETRIES = 1;
 const COMPACTION_CHECK_INTERVAL_STEPS = 3;
+// Injected as a trailing user turn on the final allowed step, with tools
+// disabled, so a step-exhausted run produces a text summary instead of
+// terminating on a dangling tool call (which surfaces to a parent agent as
+// an empty "(no response)" subagent result). See the `isFinalStep` branch in
+// the run loop.
+const FINAL_STEP_SUMMARY_PROMPT =
+  "You have reached the maximum number of steps for this run and cannot call " +
+  "any more tools. Do NOT attempt any tool calls. Using only the work you have " +
+  "already done, write your final response now: summarize what you found or " +
+  "accomplished, include any concrete results, and flag anything left unfinished.";
 const TOOL_RESULT_ARCHIVE_PARAM = "__toolResultArchive";
 const TOOL_RESULT_TRUNCATED_PREFIX = "[TRUNCATED_TOOL_RESULT]";
 const TOOL_RESULT_PREVIEW_CHARS = 700;
@@ -2297,14 +2307,61 @@ Code is wrapped in an async IIFE — use \`return\` to return a value to the too
     };
     const isCancelled = (): boolean => input.abortSignal?.aborted === true;
     let cancellationEmitted = false;
+    // The assistant turn for the current step, captured as it streams. The
+    // assistant message + its tool results are only pushed to `messages`
+    // *together*, after the tool batch finishes — so between "model streamed
+    // a tool call" and "tools done" the turn lives only in these locals. If a
+    // cancellation lands in that window we'd otherwise drop the whole turn
+    // from the canonical history, leaving the next request with back-to-back
+    // user messages and a model with no record of what it just said (the user
+    // still sees it, since the display history is built separately). Cleared
+    // once the turn is committed, and reset at the top of every step.
+    let inflightTurn: {
+      text: string;
+      toolCalls: Array<{ id: string; name: string; input: Record<string, unknown> }>;
+    } | null = null;
     const emitCancellation = (): AgentEvent => {
       cancellationEmitted = true;
       // Snapshot the in-flight messages so the orchestrator can persist them
-      // as the canonical history. Drop a trailing assistant tool_use message
-      // that has no matching tool result — sending that to the API on the next
-      // turn would be rejected.
-      const snapshot = trimToValidPrefix([...messages]);
-      return pushEvent({ type: "run:cancelled", runId, messages: snapshot });
+      // as the canonical history.
+      const snapshot: Message[] = [...messages];
+      // Re-attach the in-flight assistant turn (if any). Synthesize a
+      // tool_result for every pending tool_use so the turn is a valid prefix —
+      // an assistant tool_use with no following tool result is rejected by the
+      // API on the next turn, which is exactly why a naive snapshot drops it.
+      if (inflightTurn && (inflightTurn.text.length > 0 || inflightTurn.toolCalls.length > 0)) {
+        const hasToolCalls = inflightTurn.toolCalls.length > 0;
+        const assistantContent = hasToolCalls
+          ? JSON.stringify({
+              text: inflightTurn.text,
+              tool_calls: inflightTurn.toolCalls.map((tc) => ({
+                id: tc.id,
+                name: tc.name,
+                input: tc.input,
+              })),
+            })
+          : inflightTurn.text;
+        snapshot.push({
+          role: "assistant",
+          content: assistantContent,
+          metadata: { timestamp: now(), id: randomUUID(), runId },
+        });
+        if (hasToolCalls) {
+          const cancelledResults = inflightTurn.toolCalls.map((tc) => ({
+            type: "tool_result" as const,
+            tool_use_id: tc.id,
+            tool_name: tc.name,
+            content: "Tool execution cancelled by user.",
+          }));
+          snapshot.push({
+            role: "tool",
+            content: JSON.stringify(cancelledResults),
+            metadata: { timestamp: now(), id: randomUUID(), runId },
+          });
+        }
+      }
+      // Defensive: drop any trailing dangling tool_use we didn't pair above.
+      return pushEvent({ type: "run:cancelled", runId, messages: trimToValidPrefix(snapshot) });
     };
 
     const resolvedModelName = agent.frontmatter.model?.name ?? "claude-opus-4-5";
@@ -2424,6 +2481,7 @@ Code is wrapped in an async IIFE — use \`return\` to return a value to the too
     let convertedUpTo = 0;
 
     for (let step = 1; step <= maxSteps; step += 1) {
+      inflightTurn = null;
       try {
         yield* drainBrowserEvents();
         if (isCancelled()) {
@@ -2883,12 +2941,24 @@ Code is wrapped in an async IIFE — use \`return\` to return a value to the too
 
         const telemetryEnabled = this.loadedConfig?.telemetry?.enabled !== false;
 
+        // On the last permitted step, force a closing text turn: strip the
+        // tools so the model cannot start another tool call it has no step
+        // left to resolve, and append a one-shot nudge instructing it to
+        // summarize. This is what keeps a step-exhausted run (very common in
+        // subagents) from ending on a dangling tool call that a parent would
+        // see as an empty result. The nudge is appended only to this model
+        // request — it is never written into `messages`/history.
+        const isFinalStep = step === maxSteps;
+        const toolsForStep = isFinalStep ? {} : tools;
+        const messagesForStep: ModelMessage[] = isFinalStep
+          ? [...finalMessages, { role: "user", content: FINAL_STEP_SUMMARY_PROMPT }]
+          : finalMessages;
 
         const result = await streamText({
           model: modelInstance,
           ...(useStaticCache ? {} : { system: systemPrompt }),
-          messages: finalMessages,
-          tools,
+          messages: messagesForStep,
+          tools: toolsForStep,
           temperature,
           abortSignal: input.abortSignal,
           ...(typeof maxTokens === "number" ? { maxTokens } : {}),
@@ -3026,6 +3096,11 @@ Code is wrapped in an async IIFE — use \`return\` to return a value to the too
           return;
         }
 
+        // The model finished streaming this step's text. Capture it so a
+        // cancellation from here on persists what the user already saw; the
+        // tool calls are attached once they're parsed below.
+        inflightTurn = { text: fullText, toolCalls: [] };
+
         if (isCancelled()) {
           yield emitCancellation();
           return;
@@ -3135,6 +3210,7 @@ Code is wrapped in an async IIFE — use \`return\` to return a value to the too
         name: tc.toolName,
         input: (tc as any).input as Record<string, unknown>,
       }));
+      if (inflightTurn) inflightTurn.toolCalls = toolCalls;
 
       if (toolCalls.length === 0) {
         // Detect silent empty responses — likely an SDK or model
@@ -3593,6 +3669,9 @@ Code is wrapped in an async IIFE — use \`return\` to return a value to the too
         content: JSON.stringify(toolResultsForModel),
         metadata: toolMsgMeta as Message["metadata"],
       });
+      // Turn is now committed to `messages`; a later cancellation must not
+      // re-append it from the in-flight holder.
+      inflightTurn = null;
 
       // Post-tool-execution soft deadline: long-running tool batches (e.g.
       // multiple web_search calls) can push past the deadline. Checkpoint
@@ -3727,6 +3806,11 @@ Code is wrapped in an async IIFE — use \`return\` to return a value to the too
     messages: Message[];
     toolResults: Array<{ callId: string; toolName: string; result?: unknown; error?: string }>;
     conversationId?: string;
+    /** Must be forwarded for the continuation run, otherwise tenant-scoped
+     *  tool stores (memory, VFS, todos) resolve the default "__default__"
+     *  tenant on resume instead of the caller's — e.g. memory_main_get
+     *  returns empty after an approval checkpoint. */
+    tenantId?: string;
     parameters?: Record<string, unknown>;
     abortSignal?: AbortSignal;
   }): AsyncGenerator<AgentEvent> {
@@ -3784,6 +3868,7 @@ Code is wrapped in an async IIFE — use \`return\` to return a value to the too
     yield* this.runWithTelemetry({
       messages,
       conversationId: input.conversationId,
+      tenantId: input.tenantId,
       parameters: input.parameters,
       abortSignal: input.abortSignal,
     });

package/src/isolate/polyfills.ts

@@ -610,50 +610,79 @@ const POLYFILL_FETCH_STUB = `
 
 const POLYFILL_TIMERS = `
 // --- Timers polyfill ---
+//
+// The isolate has no host event loop, so real wall-clock delays can't be
+// honoured. What we *can* do is drain pending timers on the microtask queue
+// (which isolated-vm does pump while resolving the run's promise), firing
+// them in order of their requested delay against a virtual clock. This makes
+// the overwhelmingly common pattern — \`await new Promise(r => setTimeout(r, n))\`
+// as a sleep — actually resolve instead of hanging the whole run forever.
+// Delays collapse to "as soon as possible, in delay order"; that's the right
+// trade for a sandbox with no real time. A runaway setInterval is bounded by
+// __MAX_FIRES here and, ultimately, by the host-side wall-clock timeout.
 (function() {
   let __timerId = 0;
-  const __timers = new Map();
+  const __timers = new Map();   // id -> { fn, due, type }
+  const __intervals = new Set(); // ids that should reschedule
+  let __vclock = 0;             // virtual clock (ms)
+  let __draining = false;
+  let __fired = 0;
+  const __MAX_FIRES = 1000000;  // backstop against a runaway interval
+
+  function __schedule(fn, delayMs, type, id) {
+    __timers.set(id, { fn, due: __vclock + delayMs, type });
+    if (!__draining) __drain();
+    return id;
+  }
+
+  function __drain() {
+    __draining = true;
+    const step = function() {
+      if (__timers.size === 0) { __draining = false; return; }
+      // Pick the earliest-due timer (ties broken by insertion id for FIFO).
+      let pick = null;
+      for (const [id, t] of __timers) {
+        if (pick === null || t.due < pick.t.due || (t.due === pick.t.due && id < pick.id)) {
+          pick = { id, t };
+        }
+      }
+      __timers.delete(pick.id);
+      if (pick.t.due > __vclock) __vclock = pick.t.due;
+      __fired++;
+      try { pick.t.fn(); } catch (e) { /* host timers swallow callback throws */ }
+      if (__fired > __MAX_FIRES) { __draining = false; return; }
+      Promise.resolve().then(step);
+    };
+    Promise.resolve().then(step);
+  }
 
   globalThis.setTimeout = function(fn, delay) {
     const id = ++__timerId;
     const ms = Math.max(0, Number(delay) || 0);
-    const start = Date.now();
-    __timers.set(id, { fn, ms, start, type: "timeout" });
-    // In the isolate, setTimeout returns the id but the callback is
-    // executed via a polling mechanism in the async wrapper.
-    // For simple cases (delay=0), we can use a microtask.
-    if (ms === 0) {
-      Promise.resolve().then(() => {
-        if (__timers.has(id)) {
-          __timers.delete(id);
-          fn();
-        }
-      });
-    }
-    return id;
+    return __schedule(typeof fn === "function" ? fn : function() {}, ms, "timeout", id);
   };
 
   globalThis.clearTimeout = function(id) {
     __timers.delete(id);
+    __intervals.delete(id);
   };
 
   globalThis.setInterval = function(fn, delay) {
     const id = ++__timerId;
     const ms = Math.max(1, Number(delay) || 1);
-    const wrapper = () => {
-      if (!__timers.has(id)) return;
-      fn();
-      if (__timers.has(id)) {
-        globalThis.setTimeout(wrapper, ms);
+    __intervals.add(id);
+    const tick = function() {
+      if (!__intervals.has(id)) return;
+      try { fn(); } finally {
+        if (__intervals.has(id)) __schedule(tick, ms, "interval", id);
       }
     };
-    __timers.set(id, { fn: wrapper, ms, type: "interval" });
-    globalThis.setTimeout(wrapper, ms);
-    return id;
+    return __schedule(tick, ms, "interval", id);
   };
 
   globalThis.clearInterval = function(id) {
     __timers.delete(id);
+    __intervals.delete(id);
   };
 
   // queueMicrotask if not available

package/src/isolate/runtime.ts

@@ -153,6 +153,14 @@ export function createIsolateRuntime(config: {
       const t0 = performance.now();
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
       let context: any;
+      // Wall-clock guard. isolated-vm's `timeout` option only bounds the
+      // *synchronous* portion of an eval; when the script returns a promise
+      // (which ours always does — it's an async IIFE) a never-settling promise
+      // would hang here forever (e.g. `await new Promise(() => {})`, or a
+      // bound host call that never resolves). Race the eval against a host
+      // timer that disposes the isolate, so `timeLimit` bounds total execution.
+      let timedOut = false;
+      let wallTimer: ReturnType<typeof setTimeout> | undefined;
       try {
         context = await isolate.createContext();
         const jail = context.global;
@@ -197,12 +205,35 @@ export function createIsolateRuntime(config: {
         // (context.eval + promise option handles Reference.apply resolution
         // correctly, unlike compileScript().run())
         const wrapped = `(async () => {\n${code}\n})()`;
-        const rawResult = await context.eval(wrapped, {
+        const evalPromise = context.eval(wrapped, {
           filename: "<user-code>",
           promise: true,
           copy: true,
           timeout: config.timeout,
         });
+        const rawResult =
+          config.timeout > 0
+            ? await Promise.race([
+                evalPromise,
+                new Promise((_resolve, reject) => {
+                  wallTimer = setTimeout(() => {
+                    timedOut = true;
+                    // Disposing rejects the pending eval; this reject is the
+                    // one that wins the race when the promise never settles.
+                    try {
+                      isolate.dispose();
+                    } catch {
+                      /* already disposed */
+                    }
+                    reject(new Error("Execution timed out"));
+                  }, config.timeout);
+                }),
+              ])
+            : await evalPromise;
+        if (wallTimer) {
+          clearTimeout(wallTimer);
+          wallTimer = undefined;
+        }
 
         // Read captured stdout/stderr from isolate
         const stdout = (await context.eval("__stdout.join('\\n')", { copy: true })) as string;
@@ -237,6 +268,18 @@ export function createIsolateRuntime(config: {
           };
         }
 
+        if (timedOut) {
+          return {
+            stdout: "",
+            stderr: "",
+            error: {
+              message: `Execution timed out after ${config.timeout}ms`,
+              name: "TimeoutError",
+            },
+            executionTimeMs: elapsed,
+          };
+        }
+
         // Try to recover stdout/stderr captured before the error
         let stdout = "";
         let stderr = "";
@@ -258,6 +301,7 @@ export function createIsolateRuntime(config: {
           executionTimeMs: elapsed,
         };
       } finally {
+        if (wallTimer) clearTimeout(wallTimer);
         if (abortHandler && signal) {
           signal.removeEventListener("abort", abortHandler);
         }

package/src/orchestrator/index.ts

@@ -46,6 +46,7 @@ export {
 
 export {
   AgentOrchestrator,
+  lastAssistantText,
   type ActiveConversationRun,
   type EventSink,
   type OrchestratorHooks,

package/src/orchestrator/orchestrator.ts

@@ -1,4 +1,4 @@
-import type { AgentEvent, Message } from "@poncho-ai/sdk";
+import { getTextContent, type AgentEvent, type Message } from "@poncho-ai/sdk";
 import type { Conversation, ConversationStore, PendingSubagentResult } from "../state.js";
 import type { AgentHarness } from "../harness.js";
 import type { TelemetryEmitter } from "../telemetry.js";
@@ -28,6 +28,45 @@ import {
   STALE_SUBAGENT_THRESHOLD_MS,
 } from "./subagents.js";
 
+// ── Subagent result extraction ──
+
+/**
+ * Pull the human-readable text out of a single assistant message.
+ *
+ * Beyond the `string | ContentPart[]` shapes `getTextContent` handles, the
+ * harness serializes an assistant turn that ALSO made tool calls as a JSON
+ * string `{"text":"...","tool_calls":[...]}` (see the run loop's
+ * `assistantContent`). A naive `typeof content === "string"` read would hand
+ * that raw JSON blob back as the "response"; here we unwrap it to its `.text`.
+ */
+const assistantMessageText = (message: Message): string => {
+  const raw = getTextContent(message).trim();
+  if (raw.startsWith("{") && raw.includes("\"tool_calls\"")) {
+    try {
+      const parsed = JSON.parse(raw) as { text?: unknown };
+      if (typeof parsed.text === "string") return parsed.text.trim();
+    } catch {
+      // Not the envelope we expected — fall through to the raw string.
+    }
+  }
+  return raw;
+};
+
+/**
+ * Find the last non-empty assistant text in a subagent transcript. Walking
+ * backwards (rather than reading only the final message) means a subagent
+ * that ended on a tool-call turn still yields the prose it produced just
+ * before — instead of surfacing to the parent as an empty result.
+ */
+export const lastAssistantText = (messages: Message[]): string => {
+  for (let i = messages.length - 1; i >= 0; i -= 1) {
+    if (messages[i].role !== "assistant") continue;
+    const text = assistantMessageText(messages[i]);
+    if (text) return text;
+  }
+  return "";
+};
+
 // ── Types ──
 
 export type ActiveConversationRun = {
@@ -933,14 +972,11 @@ export class AgentOrchestrator {
         conversationId: childConversationId,
       });
 
-      let subagentResponse = runResult?.response ?? draft.assistantResponse;
+      let subagentResponse = (runResult?.response ?? draft.assistantResponse ?? "").trim();
       if (!subagentResponse) {
         const freshSubConv = await this.conversationStore.get(childConversationId);
         if (freshSubConv) {
-          const lastAssistant = [...freshSubConv.messages].reverse().find(m => m.role === "assistant");
-          if (lastAssistant && typeof lastAssistant.content === "string") {
-            subagentResponse = lastAssistant.content;
-          }
+          subagentResponse = lastAssistantText(freshSubConv.messages);
         }
       }
       const pendingResult: PendingSubagentResult = {
@@ -1040,8 +1076,16 @@ export class AgentOrchestrator {
     conversation.subagentCallbackCount = callbackCount;
 
     for (const pr of pendingResults) {
+      // An empty response is recoverable, not a dead end: the subagent's work
+      // lives in its transcript even when it produced no closing summary (e.g.
+      // it ran out of steps mid-task). Hand the parent an actionable pointer
+      // instead of a silent "(no response)" it can't act on.
+      const responseText = (pr.result?.response ?? "").trim();
+      const responseLine = responseText
+        || `(subagent produced no final summary after ${pr.result?.steps ?? 0} step(s); its work may be incomplete. `
+          + `Call read_subagent with subagent_id "${pr.subagentId}" and mode "assistant" to retrieve what it did.)`;
       const resultBody = pr.result
-        ? `Status: ${pr.result.status}\nResponse: ${pr.result.response ?? "(no response)"}\nSteps: ${pr.result.steps}, Duration: ${pr.result.duration}ms`
+        ? `Status: ${pr.result.status}\nResponse: ${responseLine}\nSteps: ${pr.result.steps}, Duration: ${pr.result.duration}ms`
         : pr.error
           ? `Error: ${pr.error.message}`
           : "(no result)";
@@ -1322,14 +1366,11 @@ export class AgentOrchestrator {
         conversationId,
       });
 
-      let subagentResponse = runResult?.response ?? draft.assistantResponse;
+      let subagentResponse = (runResult?.response ?? draft.assistantResponse ?? "").trim();
       if (!subagentResponse) {
         const freshSubConv = await this.conversationStore.get(conversationId);
         if (freshSubConv) {
-          const lastAssistant = [...freshSubConv.messages].reverse().find(m => m.role === "assistant");
-          if (lastAssistant) {
-            subagentResponse = typeof lastAssistant.content === "string" ? lastAssistant.content : "";
-          }
+          subagentResponse = lastAssistantText(freshSubConv.messages);
         }
       }
 

package/test/isolate.test.ts

@@ -1,8 +1,10 @@
 import { describe, expect, it } from "vitest";
 import { createIsolateRuntime } from "../src/isolate/runtime.js";
+import { buildPolyfillPreamble } from "../src/isolate/polyfills.js";
 import type { IsolateBinding } from "../src/config.js";
 
 const DEFAULT_CONFIG = { memoryLimit: 64, timeout: 5000, outputLimit: 65536 };
+const POLYFILLS = buildPolyfillPreamble(false);
 
 describe("IsolateRuntime", () => {
   it("executes basic JavaScript and returns a result", async () => {
@@ -136,6 +138,79 @@ describe("IsolateRuntime", () => {
   });
 });
 
+describe("IsolateRuntime timers + wall-clock", () => {
+  it("resolves a non-zero setTimeout sleep instead of hanging", async () => {
+    const runtime = createIsolateRuntime(DEFAULT_CONFIG);
+    const res = await runtime.execute(
+      `await new Promise(r => setTimeout(r, 50)); return "slept";`,
+      {},
+      null,
+      undefined,
+      POLYFILLS,
+    );
+
+    expect(res.error).toBeUndefined();
+    expect(res.result).toBe("slept");
+  });
+
+  it("runs awaited timers in delay order against the virtual clock", async () => {
+    const runtime = createIsolateRuntime(DEFAULT_CONFIG);
+    const res = await runtime.execute(
+      `const order = [];
+       async function at(ms, label) {
+         await new Promise(r => setTimeout(r, ms));
+         order.push(label);
+       }
+       await Promise.all([at(100, "a"), at(10, "b"), at(50, "c")]);
+       return order;`,
+      {},
+      null,
+      undefined,
+      POLYFILLS,
+    );
+
+    expect(res.error).toBeUndefined();
+    expect(res.result).toEqual(["b", "c", "a"]);
+  });
+
+  it("supports setInterval + clearInterval", async () => {
+    const runtime = createIsolateRuntime(DEFAULT_CONFIG);
+    const res = await runtime.execute(
+      `let n = 0;
+       await new Promise(resolve => {
+         const id = setInterval(() => {
+           n += 1;
+           if (n >= 3) { clearInterval(id); resolve(); }
+         }, 10);
+       });
+       return n;`,
+      {},
+      null,
+      undefined,
+      POLYFILLS,
+    );
+
+    expect(res.error).toBeUndefined();
+    expect(res.result).toBe(3);
+  });
+
+  it("times out a never-resolving promise via the wall-clock guard", async () => {
+    const runtime = createIsolateRuntime({ ...DEFAULT_CONFIG, timeout: 200 });
+    const start = performance.now();
+    const res = await runtime.execute(
+      `await new Promise(() => {}); return "never";`,
+      {},
+      null,
+    );
+
+    expect(res.error).toBeDefined();
+    expect(res.error!.message).toMatch(/timed out/i);
+    expect(res.error!.name).toBe("TimeoutError");
+    // Bounded by the wall clock, not hanging forever.
+    expect(performance.now() - start).toBeLessThan(2000);
+  });
+});
+
 describe("IsolateRuntime bindings", () => {
   it("calls async bindings and returns results", async () => {
     const runtime = createIsolateRuntime(DEFAULT_CONFIG);

package/test/orchestrator.test.ts

@@ -8,6 +8,7 @@ import {
   createTurnDraftState,
   recordStandardTurnEvent,
   executeConversationTurn,
+  lastAssistantText,
 } from "../src/orchestrator/index.js";
 import type { Conversation } from "../src/state.js";
 
@@ -174,3 +175,65 @@ describe("orchestrator helpers", () => {
     expect(seenTypes).toEqual(["run:started", "tool:started", "model:chunk", "run:completed"]);
   });
 });
+
+describe("lastAssistantText (subagent result extraction)", () => {
+  it("returns a plain-string assistant message", () => {
+    const messages: Message[] = [
+      { role: "user", content: "find me 3 creators" },
+      { role: "assistant", content: "Here are 3 creators: ..." },
+    ];
+    expect(lastAssistantText(messages)).toBe("Here are 3 creators: ...");
+  });
+
+  it("unwraps the {text,tool_calls} envelope to its text", () => {
+    // How the run loop serializes an assistant turn that also called tools.
+    const envelope = JSON.stringify({
+      text: "Searching for candidates now.",
+      tool_calls: [{ id: "t1", name: "web_search", input: { q: "creators" } }],
+    });
+    const messages: Message[] = [{ role: "assistant", content: envelope }];
+    expect(lastAssistantText(messages)).toBe("Searching for candidates now.");
+  });
+
+  it("walks back past a trailing tool-call turn with no text", () => {
+    // The reported bug: subagent ends on a pure tool call (empty text), but it
+    // produced a real summary the turn before. We must surface that summary,
+    // not an empty string.
+    const toolOnly = JSON.stringify({
+      text: "",
+      tool_calls: [{ id: "t9", name: "web_search", input: { q: "x" } }],
+    });
+    const messages: Message[] = [
+      { role: "user", content: "go" },
+      { role: "assistant", content: "Found 12 candidates, here they are: ..." },
+      { role: "tool", content: "[]" },
+      { role: "assistant", content: toolOnly },
+    ];
+    expect(lastAssistantText(messages)).toBe("Found 12 candidates, here they are: ...");
+  });
+
+  it("extracts text from ContentPart[] content", () => {
+    const messages: Message[] = [
+      {
+        role: "assistant",
+        content: [
+          { type: "text", text: "part one" },
+          { type: "file", data: "Zm9v", mediaType: "image/png" },
+          { type: "text", text: " part two" },
+        ],
+      },
+    ];
+    expect(lastAssistantText(messages)).toBe("part one part two");
+  });
+
+  it("returns empty string when there is genuinely no assistant text", () => {
+    const messages: Message[] = [
+      { role: "user", content: "hi" },
+      {
+        role: "assistant",
+        content: JSON.stringify({ text: "", tool_calls: [{ id: "t1", name: "x", input: {} }] }),
+      },
+    ];
+    expect(lastAssistantText(messages)).toBe("");
+  });
+});