@standardagents/builder 0.37.4 → 0.37.5

package/dist/{index-DceFbLG9.d.ts → index-Lfan8QMN.d.ts}

@@ -1154,6 +1154,46 @@ declare function requireAuth(request: Request, env: any): Promise<AuthContext |
  */
 declare function requireAdmin(request: Request, env: any): Promise<AuthContext | Response>;
 
+/**
+ * Same-request reuse of the router's authentication and thread-authorization
+ * work (AB-05, coordinator docs/plans/active/CLOUDFLARE_COST_FINDINGS.md).
+ *
+ * The generated runtime router authenticates every protected API request and,
+ * for thread routes, loads the registry record and checks thread access —
+ * then controllers historically repeated the exact same singleton RPCs
+ * (validateSession/validateApiKey + getUserById, getThread), doubling
+ * singleton traffic on every protected request.
+ *
+ * SECURITY CONTRACT (the AB-05 gate):
+ * - Reuse happens ONLY within one incoming request: the router computes these
+ *   values per request and passes them as explicit controller-context data.
+ *   There is NO cross-request cache, NO module-global map, NO retained
+ *   tokens/cookies/identities — revocation is effective on the next request
+ *   because the next request re-authenticates from scratch.
+ * - Thread authorization is bound to the EXACT thread id the router
+ *   authorized. A controller asking about any other id (including nested
+ *   route params also named `id`) gets null and falls back to its own
+ *   lookup + access check.
+ * - Permission-specific checks stay at the operation boundary: reusing the
+ *   authenticated identity never implies a permission; helpers re-evaluate
+ *   `hasPermission`/role against the reused context on every call.
+ * - Controllers invoked WITHOUT router context (direct tests, standalone
+ *   invocation, trusted-local public routes) execute their historical
+ *   authentication path unchanged.
+ */
+
+/** The router's thread-authorization result, bound to one exact thread id. */
+interface RouterThreadAccess {
+    /** The thread id (as matched from the route) the router authorized. */
+    threadId: string;
+    /**
+     * The registry record the router loaded while authorizing. Same-request
+     * read-only reuse only — a controller that mutates thread metadata must
+     * re-read after its mutation rather than trusting this snapshot.
+     */
+    thread: Record<string, unknown>;
+}
+
 /**
  * Router and endpoint definition module for AgentBuilder.
  *
@@ -1740,6 +1780,12 @@ interface BuilderControllerContext<Env extends ThreadEnv = ThreadEnv> extends Om
     registry?: NamespacedRegistry;
     /** Authenticated caller, populated by the generated runtime router. */
     auth?: AuthContext | null;
+    /**
+     * The router's thread-authorization result for this request, bound to the
+     * exact matched thread id (AB-05 same-request reuse). Populated only after
+     * the router's own getThread + canAccessThread checks passed.
+     */
+    threadAccess?: RouterThreadAccess | null;
 }
 /**
  * Builder-specific controller type with typed env.

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 import { ModelDefinition, AgentDefinition } from './runtime.js';
 export { AgentBuilderEnv, AgentBuilderEvent, BroadcastOptions, CodeExecutionBridge, DurableAgentBuilder, DurableThread, DurableUserHub, FlowStateSdk, FlowStateWithSdk, HubClientInfo, ImageContextConfig, InjectMessageOptions, LLMProviderInterface, NamespaceResolutionError, PromptContent, PromptDefinition, PromptIncludePart, PromptPart, PromptToolConfig, Provider, ProviderContentPart, ProviderFilePart, ProviderImagePart, ProviderRegistry, ProviderTextPart, SessionToolBinding, SessionToolConfig, SideConfig, SubagentToolConfig, SubpromptConfig, ThreadEventPayload, ThreadRegistryEntry, ThreadWatchdog, ThreadWatchdogState, ToolConfig, UpdateThreadParams, User, WatchdogCheckin, WatchdogProbeResult, buildImageDescription, canAccessThread, cat, createNamespaceContext, emitThreadEvent, enhanceFlowState, exists, find, forceTurn, generateImageDescription, getFileStats, getMessages, getMessagesToSummarize, getShortName, getThumbnail, getUnsummarizedImageAttachments, getVisibleAgentNames, getVisibleModelNames, getVisiblePromptNames, getVisibleToolNames, grep, hasImageAttachments, head, injectMessage, isAdminOnlyApiRoute, isHostedInstance, isPublicApiRoute, isQualifiedName, isTrustedLocalDevelopmentRequest, linkFile, mkdir, move, optimizeImageContext, parseQualifiedName, qualifyName, queueTool, readFile, readdir, reloadHistory, rename, replaceImagesWithDescriptions, resolveAgent, resolveHook, resolveModel, resolvePrompt, resolveTool, rmdir, stat, tail, unlink, updateThread, writeFile, writeImage } from './runtime.js';
 export { AgentPluginOptions, agentbuilder, builder } from './plugin.js';
-export { v as Agent, H as AttachmentRef, i as AuthContext, A as AuthUser, f as BuilderThreadEndpointHandler, C as CLIENT_STREAM_CHUNK_BYTES, t as ClientDuplex, u as ClientForwarding, p as ClientStreamRequest, q as ClientStreamResponse, n as ClientToolRequest, o as ClientToolResponse, B as Controller, a as ControllerContext, E as Env, G as FileRecord, K as FileStats, z as FlowResult, F as FlowState, J as GrepResult, O as ImageContentPart, I as ImageMetadata, L as LLMResponse, M as Message, Q as MessageContent, P as MultimodalContent, R as RequestContext, S as StorageBackend, D as TelemetryEvent, N as TextContentPart, b as ThreadEndpointContext, e as ThreadEnv, w as ThreadInstance, x as ThreadMetadata, T as ToolCall, y as ToolResult, g as authenticate, j as callClient, k as callClientStream, c as createThreadEndpointHandler, m as decodeStreamChunk, d as defineController, l as encodeStreamChunk, h as requireAdmin, r as requireAuth, s as supportsClientForwarding } from './index-DceFbLG9.js';
+export { v as Agent, H as AttachmentRef, i as AuthContext, A as AuthUser, f as BuilderThreadEndpointHandler, C as CLIENT_STREAM_CHUNK_BYTES, t as ClientDuplex, u as ClientForwarding, p as ClientStreamRequest, q as ClientStreamResponse, n as ClientToolRequest, o as ClientToolResponse, B as Controller, a as ControllerContext, E as Env, G as FileRecord, K as FileStats, z as FlowResult, F as FlowState, J as GrepResult, O as ImageContentPart, I as ImageMetadata, L as LLMResponse, M as Message, Q as MessageContent, P as MultimodalContent, R as RequestContext, S as StorageBackend, D as TelemetryEvent, N as TextContentPart, b as ThreadEndpointContext, e as ThreadEnv, w as ThreadInstance, x as ThreadMetadata, T as ToolCall, y as ToolResult, g as authenticate, j as callClient, k as callClientStream, c as createThreadEndpointHandler, m as decodeStreamChunk, d as defineController, l as encodeStreamChunk, h as requireAdmin, r as requireAuth, s as supportsClientForwarding } from './index-Lfan8QMN.js';
 export { AgentType, DefinitionLoader, GlobalNamespaceContext, HookSignatures, ImageContent, ModelCapabilities, ModelProvider, NamespaceContext, PackageSignature, PackedExports, PackedMeta, PackedMetadata, PackedNamespaceContext, PromptInput, PromptTextPart, ProviderAssistantMessage, ProviderConfigSlot, ProviderConfigSlots, ProviderConfigValueSource, ProviderDefinition, ProviderError, ProviderErrorCode, ProviderFactory, ProviderFactoryConfig, ProviderFinishReason, ProviderGeneratedImage, ProviderMessage, ProviderMessageContent, ProviderMethodOverrides, ModelCapabilities as ProviderModelCapabilities, ProviderOverride, ProviderOverrideContext, ProviderReasoningDetail, ProviderRequest, ProviderResponse, ProviderStreamChunk, ProviderSyncOverride, ProviderSystemMessage, ProviderTool, ProviderToolCallPart, ProviderToolMessage, ProviderToolResultContent, ProviderUsage, ProviderUserMessage, ReasoningConfig, StructuredPrompt, TextContent, Tool, ToolArgs, ToolArgsNode, ToolArgsRawShape, ToolContent, belongsToPackage, defineAgent, defineHook, defineModel, definePrompt, defineProvider, defineTool, isPacked, isVisibleInNamespace, mapReasoningLevel, providerConst, providerEnv, providerValue } from '@standardagents/spec';
 export { C as ConstituentItem, D as DiscoveredPackage, N as NamespacedRegistry, P as PackingAnalysis, a as PackingOptions, b as PackingResult, c as UnpackOptions, d as UnpackResult } from './types-Bpe7IANZ.js';
 export { D as DiscoveryConfig, P as PackageDiscoveryService, d as discoverPackages } from './discovery-DiMJWisl.js';

package/dist/index.js

@@ -13738,8 +13738,25 @@ var init_ThreadStateImpl = __esm({
         const mustParkForApproval = await this.forwardedCallNeedsApproval(request);
         if (mustParkForApproval && canPark && toolCallId && typeof instance.hasBridge === "function" && await instance.hasBridge()) {
           await instance.dispatchClientTool(request, toolCallId, side);
-          const getDelivered = instance.getDeliveredClientToolResult;
-          if (typeof getDelivered === "function") {
+          const withDelivery = instance;
+          if (typeof withDelivery.awaitDeliveredClientToolResult === "function") {
+            try {
+              const delivered = await withDelivery.awaitDeliveredClientToolResult.call(
+                instance,
+                toolCallId,
+                4e3
+              );
+              if (delivered) {
+                return {
+                  ok: delivered.toolStatus !== "error",
+                  result: delivered.content,
+                  data: { toolCallId }
+                };
+              }
+            } catch {
+            }
+          } else if (typeof withDelivery.getDeliveredClientToolResult === "function") {
+            const getDelivered = withDelivery.getDeliveredClientToolResult;
             const graceDeadline = Date.now() + 4e3;
             while (Date.now() < graceDeadline) {
               await new Promise((r) => setTimeout(r, 150));
@@ -13829,7 +13846,14 @@ var init_ThreadStateImpl = __esm({
             if (typeof stub.proxyStreamOpen === "function") {
               const opened = await stub.proxyStreamOpen(withWake(parentId));
               if (opened.ok && opened.id) {
-                return { ok: true, duplex: this.buildProxyDuplex(stub, opened.id) };
+                return {
+                  ok: true,
+                  duplex: this.buildProxyDuplex(
+                    stub,
+                    opened.id,
+                    opened.parkedPull === true
+                  )
+                };
               }
               if (opened.error && !opened.noClient) {
                 return {
@@ -13847,11 +13871,15 @@ var init_ThreadStateImpl = __esm({
       }
       /**
        * Build a client duplex that bridges to a stream opened on an ancestor DO
-       * (the bridge holder) via chunk-pull RPCs. `readable` polls `proxyStreamPull`;
-       * `writable` forwards each chunk with `proxyStreamWrite`; teardown calls
+       * (the bridge holder) via chunk-pull RPCs. `readable` issues PARKED pulls —
+       * a current ancestor holds one `proxyStreamPull` until bytes, completion,
+       * error, or abort, so an idle open stream performs zero repeated pulls.
+       * Older ancestors use the bounded long-pull compatibility path. `writable`
+       * forwards each chunk with `proxyStreamWrite`; teardown calls
        * `proxyStreamAbort`.
        */
-      buildProxyDuplex(stub, id) {
+      static PROXY_PULL_MAX_WAIT_MS = 2e4;
+      buildProxyDuplex(stub, id, supportsParkedPull = false) {
         let settleDone;
         const done = new Promise((r) => settleDone = r);
         let closed = false;
@@ -13864,9 +13892,13 @@ var init_ThreadStateImpl = __esm({
         const readable = new ReadableStream({
           async pull(controller) {
             while (!closed) {
+              const pullStartedAt = Date.now();
               let res;
               try {
-                res = await stub.proxyStreamPull(id);
+                res = await stub.proxyStreamPull(
+                  id,
+                  supportsParkedPull ? void 0 : _ThreadStateImpl.PROXY_PULL_MAX_WAIT_MS
+                );
               } catch (error) {
                 controller.error(error instanceof Error ? error : new Error(String(error)));
                 settle({ ok: false, error: "proxy stream pull failed" });
@@ -13881,7 +13913,14 @@ var init_ThreadStateImpl = __esm({
                 return;
               }
               if (res.chunks.length > 0) return;
-              await new Promise((r) => setTimeout(r, 25));
+              if (supportsParkedPull) {
+                controller.error(new Error("parked proxy pull returned without data"));
+                settle({ ok: false, error: "parked proxy pull returned without data" });
+                return;
+              }
+              if (Date.now() - pullStartedAt < 250) {
+                await new Promise((r) => setTimeout(r, 250));
+              }
             }
           },
           cancel() {
@@ -22245,6 +22284,10 @@ ${packedThreadRouteCode}
     const isApiRoute = routePath.startsWith('/api/');
 
     let authContext = null;
+    // The router's thread-authorization result, bound to the exact matched
+    // thread id, for same-request reuse by controllers (AB-05). Never cached
+    // across requests.
+    let threadAccess = null;
 
     // Require authentication for all API routes except public ones
     if (isApiRoute && !publicRoute) {
@@ -22277,6 +22320,7 @@ ${packedThreadRouteCode}
           if (!canAccessThread(authContext, thread)) {
             return addCorsHeaders(Response.json({ error: "Forbidden: You don't have access to this thread" }, { status: 403 }));
           }
+          threadAccess = { threadId, thread };
         }
       }
     }
@@ -22297,6 +22341,7 @@ ${packedThreadRouteCode}
       config,
       tools,
       auth: authContext, // Add auth context to controller context
+      threadAccess, // Router's thread authorization, bound to the exact id
     };
     const result = await controller(context);
 
@@ -24400,6 +24445,9 @@ var AlarmQueue = class {
       options.sourceLogId ?? null
     );
     await this.rescheduleAlarm();
+    if (method === "runEffect") {
+      await this.emitEffectRunChange(id);
+    }
     return id;
   }
   /**
@@ -24438,6 +24486,9 @@ var AlarmQueue = class {
         `UPDATE alarm_queue SET status = 'processing', attempts = attempts + 1 WHERE id = ?`,
         item.id
       );
+      if (item.method === "runEffect") {
+        await this.emitEffectRunChange(item.id);
+      }
       try {
         const args = JSON.parse(item.args);
         await this.executeMethod(item.method, args, item.id);
@@ -24491,6 +24542,7 @@ var AlarmQueue = class {
       now,
       id
     );
+    await this.emitEffectRunChange(id);
   }
   /**
    * Mark an item as failed but keep it for 24 hours for debugging
@@ -24510,6 +24562,7 @@ var AlarmQueue = class {
       now,
       id
     );
+    await this.emitEffectRunChange(id);
   }
   /**
    * Clean up failed items older than 24 hours
@@ -24599,6 +24652,10 @@ var AlarmQueue = class {
    */
   async recoverOrphanedProcessing(maxAttempts = 3) {
     const now = Date.now() * 1e3;
+    const orphanedEffectsCursor = await this.sql.exec(
+      `SELECT id FROM alarm_queue WHERE status = 'processing' AND method = 'runEffect'`
+    );
+    const orphanedEffectIds = orphanedEffectsCursor.toArray().map((row) => row.id);
     await this.sql.exec(
       `UPDATE alarm_queue
        SET status = 'failed',
@@ -24611,6 +24668,9 @@ var AlarmQueue = class {
     await this.sql.exec(
       `UPDATE alarm_queue SET status = 'pending' WHERE status = 'processing'`
     );
+    for (const id of orphanedEffectIds) {
+      await this.emitEffectRunChange(id);
+    }
   }
   // ============================================================
   // Effect-specific Methods
@@ -24789,6 +24849,7 @@ var AlarmQueue = class {
     const canceled = changesRows.length > 0 && changesRows[0].changes > 0;
     if (canceled) {
       await this.rescheduleAlarm();
+      await this.emitEffectRunChange(id);
     }
     return canceled;
   }
@@ -24863,6 +24924,7 @@ var AlarmQueue = class {
     if (!changed) {
       throw new Error(`Effect run ${item.id} is no longer pending`);
     }
+    await this.emitEffectRunChange(item.id);
     try {
       await this.executeMethod(item.method, JSON.parse(item.args), item.id);
       await this.complete(item.id, item.method);
@@ -24874,6 +24936,45 @@ var AlarmQueue = class {
       await this.rescheduleAlarm();
     }
   }
+  /**
+   * Read one effect row and hand its bounded projection (no args payload) to
+   * the change listener. Self-filtering: operational (non-effect) rows and
+   * already-deleted rows emit nothing, and a listener failure must never
+   * disturb queue processing.
+   */
+  async emitEffectRunChange(id) {
+    const listener = this.options.onEffectRunChanged;
+    if (!listener) return;
+    try {
+      const cursor = await this.sql.exec(
+        `
+        SELECT id, args, scheduled_at, created_at, status, attempts, error, completed_at, manual_run, manual_run_at, replayed_from
+        FROM alarm_queue
+        WHERE id = ? AND method = 'runEffect'
+        LIMIT 1
+        `,
+        id
+      );
+      const row = cursor.toArray()[0];
+      if (!row) return;
+      const { effectName } = this.parseEffectPayload(row.args);
+      listener({
+        id: row.id,
+        name: effectName,
+        scheduledAt: row.scheduled_at,
+        createdAt: row.created_at,
+        status: row.status,
+        attempts: row.attempts,
+        error: row.error,
+        completedAt: row.completed_at,
+        manualRun: row.manual_run === 1,
+        manualRunAt: row.manual_run_at,
+        replayedFrom: row.replayed_from
+      });
+    } catch (error) {
+      console.error(`[AlarmQueue] Failed to emit effect run change for ${id}:`, error);
+    }
+  }
   normalizeOffset(value) {
     const parsed = typeof value === "number" ? Math.trunc(value) : Number.NaN;
     if (!Number.isFinite(parsed)) return 0;
@@ -29344,6 +29445,25 @@ var DurableThread = class _DurableThread extends DurableObject {
   alarmQueueRearmed = false;
   currentAbortController = null;
   isExecuting = false;
+  /**
+   * In-memory waiters parked until the running flow finishes (AB-09): the
+   * executeFlow busy-guard awaits this signal instead of re-checking
+   * isExecuting every 500ms. Every isExecuting=false transition (execution
+   * finallys and the watchdog takeover) notifies. In-memory only — a DO
+   * restart drops waiters together with the busy caller.
+   */
+  executionIdleWaiters = /* @__PURE__ */ new Set();
+  notifyExecutionIdleWaiters() {
+    if (!this.executionIdleWaiters || this.executionIdleWaiters.size === 0) return;
+    const waiters = Array.from(this.executionIdleWaiters);
+    this.executionIdleWaiters.clear();
+    for (const wake of waiters) {
+      try {
+        wake();
+      } catch {
+      }
+    }
+  }
   // ── Execution watchdog state (see watchdogCheck) ─────────────────────────
   // In-memory heartbeat: bumped by noteExecutionProgress() on every streamed
   // chunk and request attempt. Deliberately NOT persisted — after a DO restart
@@ -29368,7 +29488,11 @@ var DurableThread = class _DurableThread extends DurableObject {
     this.alarmQueue = new AlarmQueue(ctx, {
       retentionEnabled: env.AGENT_BUILDER_ALARM_RETENTION_ENABLED !== "false",
       isForensicHold: async () => (await this.runtimeSafety.getStatus()).forensicHold,
-      invocationSqlLimits: { rowsRead: 1e6, rowsWritten: 1e4 }
+      invocationSqlLimits: { rowsRead: 1e6, rowsWritten: 1e4 },
+      // Effect lifecycle transitions broadcast on the thread event channel so
+      // inspectors stay live from the already-open message socket instead of
+      // polling the effects list.
+      onEffectRunChanged: (change) => this.broadcastEvent("effect_changed", change)
     });
     this.alarmQueue.setExecutor(
       async (method, args, itemId) => {
@@ -29927,6 +30051,7 @@ var DurableThread = class _DurableThread extends DurableObject {
     if (value === null || value === void 0) {
       await this.ctx.storage.sql.exec(`DELETE FROM thread_values WHERE key = ?`, key);
       this.broadcastLog({ type: "kv_data", key, deleted: true, updated_at: updatedAt });
+      this.broadcastEvent("kv_changed", { key, deleted: true, updated_at: updatedAt });
       return;
     }
     const serialized = this.serializeThreadValue(value);
@@ -29943,6 +30068,7 @@ var DurableThread = class _DurableThread extends DurableObject {
       updatedAt
     );
     this.broadcastLog({ type: "kv_data", key, deleted: false, updated_at: updatedAt });
+    this.broadcastEvent("kv_changed", { key, deleted: false, updated_at: updatedAt });
   }
   async listValues(options = {}) {
     await this.ensureMigrated();
@@ -32963,6 +33089,7 @@ ${resultContent}${attachmentSummary}`;
     if (isOwner) {
       void this.resendPendingClientCalls(server);
     }
+    this.notifyOwnerBridgeWaiters();
     return new Response(null, {
       status: 101,
       webSocket: client
@@ -32998,6 +33125,7 @@ ${resultContent}${attachmentSummary}`;
   /** Persist + cache the execution-owner record (null releases ownership). */
   async setExecutionOwner(owner) {
     await this.setValue(EXECUTION_OWNER_KEY, owner);
+    this.notifyOwnerBridgeWaiters();
   }
   /** Whether the given client id has an open bridge socket (excluding `except`).
    * Idle bridge heartbeats are handled by Cloudflare without waking this object,
@@ -33355,6 +33483,55 @@ ${resultContent}${attachmentSummary}`;
    * permission level covers the call) otherwise race the placeholder into
    * stored history, leaving the model blind to its own tool outcomes.
    */
+  /**
+   * In-memory waiters parked on a forwarded call's result delivery (AB-09).
+   * `deliverClientToolResult` resolves them so the approval grace-wait reads
+   * delivered state exactly once instead of re-polling it every 150ms.
+   * In-memory only: a DO restart drops waiters along with the caller that
+   * registered them, and the durable park path still resumes the turn.
+   */
+  deliveredResultWaiters = /* @__PURE__ */ new Map();
+  notifyDeliveredResultWaiters(toolCallId) {
+    const waiters = this.deliveredResultWaiters?.get(toolCallId);
+    if (!waiters) return;
+    this.deliveredResultWaiters.delete(toolCallId);
+    for (const wake of waiters) {
+      try {
+        wake();
+      } catch {
+      }
+    }
+  }
+  /**
+   * Await a parked forwarded call's delivered result: one immediate read,
+   * then a single parked wait resolved by result delivery, bounded by one
+   * hard deadline, then one final read. Replaces the caller-side 150ms
+   * re-poll of {@link getDeliveredClientToolResult}.
+   */
+  async awaitDeliveredClientToolResult(toolCallId, maxWaitMs) {
+    const immediate = await this.getDeliveredClientToolResult(toolCallId);
+    if (immediate) return immediate;
+    if (!(maxWaitMs > 0)) return null;
+    await new Promise((resolve3) => {
+      let waiters = this.deliveredResultWaiters.get(toolCallId);
+      if (!waiters) {
+        waiters = /* @__PURE__ */ new Set();
+        this.deliveredResultWaiters.set(toolCallId, waiters);
+      }
+      const registered = waiters;
+      const deadline = setTimeout(() => {
+        registered.delete(wake);
+        if (registered.size === 0) this.deliveredResultWaiters.delete(toolCallId);
+        resolve3();
+      }, maxWaitMs);
+      const wake = () => {
+        clearTimeout(deadline);
+        resolve3();
+      };
+      registered.add(wake);
+    });
+    return this.getDeliveredClientToolResult(toolCallId);
+  }
   async getDeliveredClientToolResult(toolCallId) {
     await this.ensureMigrated();
     await this.ensurePendingClientTable();
@@ -33490,6 +33667,7 @@ ${resultContent}${attachmentSummary}`;
       `UPDATE pending_client_calls SET status = 'resolved' WHERE tool_call_id = ?`,
       toolCallId
     );
+    this.notifyDeliveredResultWaiters(toolCallId);
     try {
       const msgCursor = await this.ctx.storage.sql.exec(
         `SELECT id, role, content, name, tool_call_id, tool_status, created_at, depth
@@ -33508,8 +33686,24 @@ ${resultContent}${attachmentSummary}`;
   // they are bound to one bridge socket and never park.
   /** Default time to wait for the client to accept a stream open. */
   static CLIENT_STREAM_OPEN_TIMEOUT_MS = 3e4;
-  /** Poll cadence while waiting for a disconnected owner's bridge to return. */
-  static OWNER_REATTACH_POLL_MS = 250;
+  /**
+   * In-memory waiters parked on the owner's bridge socket returning (AB-09).
+   * Resolved by bridge attach and by execution-owner changes; each waiter
+   * re-evaluates against the CURRENT owner on wake. In-memory only: a DO
+   * restart drops waiters with the stream-open call that registered them.
+   */
+  ownerBridgeWaiters = /* @__PURE__ */ new Set();
+  notifyOwnerBridgeWaiters() {
+    if (!this.ownerBridgeWaiters || this.ownerBridgeWaiters.size === 0) return;
+    const waiters = Array.from(this.ownerBridgeWaiters);
+    this.ownerBridgeWaiters.clear();
+    for (const wake of waiters) {
+      try {
+        wake();
+      } catch {
+      }
+    }
+  }
   /**
    * The thread HAS an elected execution owner, but its bridge socket is gone
    * (daemon restart, network blip, DO handoff). Summon the owning machine
@@ -33518,6 +33712,11 @@ ${resultContent}${attachmentSummary}`;
    * Sama One turns with "workspace unavailable" whenever a slow tool/approval
    * outlived the socket. Threads with NO recorded owner (subagent children)
    * still fail fast so ancestor walk-up routing stays immediate.
+   *
+   * The wait parks on bridge-attach/owner-change signals under ONE hard
+   * deadline — no re-poll cadence. Each wake re-reads the owner because the
+   * returning daemon may reclaim with a new generation, and the socket must
+   * match the CURRENT owner.
    */
   async awaitOwnerBridgeSocket(request) {
     if (request.wake?.userId) {
@@ -33525,15 +33724,25 @@ ${resultContent}${attachmentSummary}`;
     }
     const timeoutMs = typeof request.timeoutMs === "number" && request.timeoutMs > 0 ? request.timeoutMs : _DurableThread.CLIENT_STREAM_OPEN_TIMEOUT_MS;
     const deadline = Date.now() + timeoutMs;
-    while (Date.now() < deadline) {
-      await new Promise(
-        (resolve3) => setTimeout(resolve3, _DurableThread.OWNER_REATTACH_POLL_MS)
-      );
+    this.ownerBridgeWaiters ??= /* @__PURE__ */ new Set();
+    while (true) {
       const owner = await this.getExecutionOwner();
       const socket = this.getOpenBridgeSocket(owner?.client_id ?? null);
       if (socket) return socket;
+      const remainingMs = deadline - Date.now();
+      if (remainingMs <= 0) return null;
+      await new Promise((resolve3) => {
+        const timer = setTimeout(() => {
+          this.ownerBridgeWaiters.delete(wake);
+          resolve3();
+        }, remainingMs);
+        const wake = () => {
+          clearTimeout(timer);
+          resolve3();
+        };
+        this.ownerBridgeWaiters.add(wake);
+      });
     }
-    return null;
   }
   /** Open a bidirectional byte stream to the connected owner client. */
   async openClientStream(request) {
@@ -33677,27 +33886,38 @@ ${resultContent}${attachmentSummary}`;
       done: false,
       error: void 0,
       pump: Promise.resolve(),
-      close: (error) => duplex.close(error)
+      close: (error) => duplex.close(error),
+      waiter: null,
+      notify: () => {
+        const waiter = entry.waiter;
+        entry.waiter = null;
+        waiter?.();
+      }
     };
     entry.pump = (async () => {
       try {
         while (true) {
           const { value, done } = await reader.read();
           if (done) break;
-          if (value) entry.buffer.push(value);
+          if (value) {
+            entry.buffer.push(value);
+            entry.notify();
+          }
         }
       } catch (error) {
         entry.error = error instanceof Error ? error.message : String(error);
       } finally {
         entry.done = true;
+        entry.notify();
       }
     })();
     void duplex.done.then((d) => {
       entry.done = true;
       if (!d.ok && !entry.error) entry.error = d.error;
+      entry.notify();
     });
     this.proxyStreams.set(id, entry);
-    return { ok: true, id };
+    return { ok: true, id, parkedPull: true };
   }
   async proxyStreamWrite(id, dataB64) {
     const entry = this.proxyStreams.get(id);
@@ -33707,9 +33927,22 @@ ${resultContent}${attachmentSummary}`;
     } catch {
     }
   }
-  async proxyStreamPull(id) {
+  async proxyStreamPull(id, maxWaitMs) {
     const entry = this.proxyStreams.get(id);
     if (!entry) return { chunks: [], done: true, error: "unknown proxy stream" };
+    if (entry.buffer.length === 0 && !entry.done) {
+      await new Promise((resolve3) => {
+        const deadline = typeof maxWaitMs === "number" && maxWaitMs > 0 ? setTimeout(() => {
+          if (entry.waiter === wake) entry.waiter = null;
+          resolve3();
+        }, maxWaitMs) : null;
+        const wake = () => {
+          if (deadline) clearTimeout(deadline);
+          resolve3();
+        };
+        entry.waiter = wake;
+      });
+    }
     const chunks = entry.buffer.splice(0).map((b) => encodeStreamChunk(b));
     if (entry.done && entry.buffer.length === 0) {
       this.proxyStreams.delete(id);
@@ -33729,6 +33962,9 @@ ${resultContent}${attachmentSummary}`;
     const entry = this.proxyStreams.get(id);
     if (!entry) return;
     this.proxyStreams.delete(id);
+    entry.done = true;
+    if (!entry.error) entry.error = "aborted";
+    entry.notify();
     try {
       entry.close("aborted");
     } catch {
@@ -34084,6 +34320,7 @@ ${resultContent}${attachmentSummary}`;
     this.broadcastEvent(type, data);
   }
   broadcastEvent(type, data) {
+    if (!this.messageSockets || this.messageSockets.size === 0) return;
     const payload = JSON.stringify({
       type: "event",
       eventType: type,
@@ -34510,6 +34747,7 @@ ${resultContent}${attachmentSummary}`;
       } catch {
       }
       this.isExecuting = false;
+      this.notifyExecutionIdleWaiters();
       this.currentAbortController = null;
       await this.recordRegistryActivity(threadId, false);
       tookOver = true;
@@ -34702,9 +34940,22 @@ Its execution was lost (the executor restarted or hung) and automatic recovery w
     await this.assertNotTerminated();
     if (this.isExecuting) {
       const busyWaitBudgetMs = 3e4;
-      const waitStartedAt = Date.now();
-      while (this.isExecuting && Date.now() - waitStartedAt < busyWaitBudgetMs) {
-        await new Promise((resolve3) => setTimeout(resolve3, 500));
+      const deadline = Date.now() + busyWaitBudgetMs;
+      this.executionIdleWaiters ??= /* @__PURE__ */ new Set();
+      while (this.isExecuting) {
+        const remainingMs = deadline - Date.now();
+        if (remainingMs <= 0) break;
+        await new Promise((resolve3) => {
+          const timer = setTimeout(() => {
+            this.executionIdleWaiters.delete(wake);
+            resolve3();
+          }, remainingMs);
+          const wake = () => {
+            clearTimeout(timer);
+            resolve3();
+          };
+          this.executionIdleWaiters.add(wake);
+        });
       }
       if (this.isExecuting) {
         throw new Error(
@@ -34843,6 +35094,7 @@ Its execution was lost (the executor restarted or hung) and automatic recovery w
       return flowResult;
     } finally {
       this.isExecuting = false;
+      this.notifyExecutionIdleWaiters();
       this.currentAbortController = null;
       await this.disarmExecutionWatchdog(threadId);
       await this.recordRegistryActivity(threadId, false);
@@ -35056,6 +35308,7 @@ Its execution was lost (the executor restarted or hung) and automatic recovery w
       }, true);
     } finally {
       this.isExecuting = false;
+      this.notifyExecutionIdleWaiters();
       this.currentAbortController = null;
       await this.disarmExecutionWatchdog(threadId);
       await this.recordRegistryActivity(threadId, false);
@@ -35182,6 +35435,7 @@ Its execution was lost (the executor restarted or hung) and automatic recovery w
       );
     } finally {
       this.isExecuting = false;
+      this.notifyExecutionIdleWaiters();
       this.currentAbortController = null;
       await this.disarmExecutionWatchdog(threadId);
       await this.recordRegistryActivity(threadId, false);
@@ -35608,6 +35862,7 @@ Its execution was lost (the executor restarted or hung) and automatic recovery w
       const fs19 = this.getFileStorage();
       const from = normalizePath2(sourcePath);
       const record = await fs19.move(sourcePath, destinationPath);
+      this.broadcastEvent("file_moved", { from, path: record.path, file: record });
       this.broadcastEvent("file_deleted", { path: from });
       this.broadcastEvent("file_created", { path: record.path, file: record });
       return { success: true, file: record };
@@ -35626,6 +35881,7 @@ Its execution was lost (the executor restarted or hung) and automatic recovery w
       const fs19 = this.getFileStorage();
       const from = normalizePath2(path21);
       const record = await fs19.rename(path21, newName);
+      this.broadcastEvent("file_moved", { from, path: record.path, file: record });
       this.broadcastEvent("file_deleted", { path: from });
       this.broadcastEvent("file_created", { path: record.path, file: record });
       return { success: true, file: record };