@standardagents/builder 0.37.4 → 0.37.6

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() {
@@ -14056,7 +14095,7 @@ var init_ThreadStateImpl = __esm({
         return bytes.buffer;
       }
       async readFileStream(path21, options) {
-        const fileInfo = await this._threadInstance.statFile(path21);
+        const fileInfo = this._unwrapStatRecord(await this._threadInstance.statFile(path21));
         if (!fileInfo) {
           return null;
         }
@@ -14111,12 +14150,32 @@ var init_ThreadStateImpl = __esm({
           }
         };
       }
+      /**
+       * Unwrap the thread DO's `{ success, file }` stat envelope (older shapes
+       * returned the record directly). A failed or absent lookup is NULL — the
+       * old code mapped the envelope itself, producing a truthy record with
+       * every field defaulted (size 0, application/octet-stream) even for
+       * NONEXISTENT paths, which let a phantom asset pass an existence check and
+       * a real 1.2MB image read as "0 bytes" (2026-08-11).
+       */
+      _unwrapStatRecord(result) {
+        const record = result?.file ?? result;
+        if (!record || typeof record !== "object") return null;
+        if (!("path" in record) && !("name" in record)) return null;
+        return record;
+      }
       async statFile(path21) {
-        const result = await this._threadInstance.statFile(path21);
-        return result ? this._mapFileRecord(result) : null;
+        const record = this._unwrapStatRecord(await this._threadInstance.statFile(path21));
+        return record ? this._mapFileRecord(record) : null;
       }
       async readdirFile(path21) {
-        const entries = await this._threadInstance.readdirFile(path21);
+        const result = await this._threadInstance.readdirFile(path21);
+        const entries = Array.isArray(result) ? result : result?.files;
+        if (!Array.isArray(entries)) {
+          throw new Error(
+            result?.error || `Could not list directory: ${path21}`
+          );
+        }
         return {
           entries: entries.map((e) => this._mapFileRecord(e))
         };
@@ -22245,6 +22304,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 +22340,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 +22361,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 +24465,9 @@ var AlarmQueue = class {
       options.sourceLogId ?? null
     );
     await this.rescheduleAlarm();
+    if (method === "runEffect") {
+      await this.emitEffectRunChange(id);
+    }
     return id;
   }
   /**
@@ -24438,6 +24506,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 +24562,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 +24582,7 @@ var AlarmQueue = class {
       now,
       id
     );
+    await this.emitEffectRunChange(id);
   }
   /**
    * Clean up failed items older than 24 hours
@@ -24599,6 +24672,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 +24688,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 +24869,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 +24944,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 +24956,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 +29465,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 +29508,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 +30071,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 +30088,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 +33109,7 @@ ${resultContent}${attachmentSummary}`;
     if (isOwner) {
       void this.resendPendingClientCalls(server);
     }
+    this.notifyOwnerBridgeWaiters();
     return new Response(null, {
       status: 101,
       webSocket: client
@@ -32998,6 +33145,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 +33503,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 +33687,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 +33706,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 +33732,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 +33744,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 +33906,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 +33947,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 +33982,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 +34340,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 +34767,7 @@ ${resultContent}${attachmentSummary}`;
       } catch {
       }
       this.isExecuting = false;
+      this.notifyExecutionIdleWaiters();
       this.currentAbortController = null;
       await this.recordRegistryActivity(threadId, false);
       tookOver = true;
@@ -34702,9 +34960,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 +35114,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 +35328,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 +35455,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 +35882,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 +35901,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 };