@standardagents/builder 0.25.7 → 0.26.1

package/dist/runtime.js

@@ -1070,6 +1070,24 @@ function resolveWatchdogStaleCeilingMs(env) {
   );
   return Math.max(firstChunk, stall) + 6e4;
 }
+async function awaitBounded(work, budgetMs, label) {
+  let timer;
+  work.catch(() => {
+  });
+  const timeout = new Promise((resolve) => {
+    timer = setTimeout(() => {
+      console.error(
+        `[LLMRequest] ${label} did not settle within ${budgetMs}ms \u2014 continuing without it`
+      );
+      resolve(void 0);
+    }, budgetMs);
+  });
+  try {
+    return await Promise.race([work, timeout]);
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
 function modelSupportsImageInput(modelDef) {
   const supportsImages = modelDef.capabilities?.supportsImages;
   if (typeof supportsImages === "boolean") {
@@ -1283,13 +1301,42 @@ function transformMessages(messages) {
           arguments: typeof tc.function.arguments === "string" ? JSON.parse(tc.function.arguments) : tc.function.arguments,
           extraContent: tc.extra_content && typeof tc.extra_content === "object" ? tc.extra_content : void 0
         }));
+        const storedDetails = msg.reasoning_details;
+        const reasoningDetails = Array.isArray(
+          storedDetails
+        ) ? storedDetails.flatMap((entry) => {
+          if (!entry || typeof entry !== "object") return [];
+          const raw = entry;
+          const type = raw.type === "summary" || raw.type === "encrypted" ? raw.type : "text";
+          return [
+            {
+              type,
+              id: typeof raw.id === "string" ? raw.id : void 0,
+              text: typeof raw.text === "string" ? raw.text : void 0,
+              data: typeof raw.data === "string" ? raw.data : void 0,
+              format: typeof raw.format === "string" ? raw.format : void 0
+            }
+          ];
+        }) : void 0;
+        const storedReasoning = msg.reasoning_content;
+        let reasoning = typeof storedReasoning === "string" && storedReasoning.length > 0 ? storedReasoning : void 0;
+        if (!reasoning && Array.isArray(reasoningDetails)) {
+          const seen = /* @__PURE__ */ new Set();
+          const texts = [];
+          for (const d of reasoningDetails) {
+            if (typeof d?.text === "string" && d.text.length > 0 && !seen.has(d.text)) {
+              seen.add(d.text);
+              texts.push(d.text);
+            }
+          }
+          if (texts.length) reasoning = texts.join("\n");
+        }
         return {
           role: "assistant",
           content: typeof msg.content === "string" ? msg.content : null,
           toolCalls: toolCalls?.length ? toolCalls : void 0,
-          // Pass reasoning for multi-turn context
-          reasoning: msg.reasoning_content || void 0,
-          reasoningDetails: msg.reasoning_details || void 0
+          reasoning,
+          reasoningDetails: reasoningDetails?.length ? reasoningDetails : void 0
         };
       }
       case "tool":
@@ -1464,7 +1511,7 @@ function normalizeProviderMetadataValue(value) {
   if (!trimmed || trimmed.toLowerCase() === "unknown") return void 0;
   return trimmed;
 }
-var NON_VISION_PLACEHOLDER_TEXT, STREAM_FIRST_CHUNK_TIMEOUT_MS, STREAM_STALL_TIMEOUT_MS, LLMRequest;
+var NON_VISION_PLACEHOLDER_TEXT, STREAM_FIRST_CHUNK_TIMEOUT_MS, STREAM_STALL_TIMEOUT_MS, HOOK_AWAIT_BUDGET_MS, STREAM_CLEANUP_BUDGET_MS, LLMRequest;
 var init_LLMRequest = __esm({
   "src/agents/LLMRequest.ts"() {
     init_pricing();
@@ -1475,6 +1522,8 @@ var init_LLMRequest = __esm({
     NON_VISION_PLACEHOLDER_TEXT = "[Image omitted: model does not support vision]";
     STREAM_FIRST_CHUNK_TIMEOUT_MS = 12e4;
     STREAM_STALL_TIMEOUT_MS = 45e3;
+    HOOK_AWAIT_BUDGET_MS = 3e4;
+    STREAM_CLEANUP_BUDGET_MS = 5e3;
     LLMRequest = class {
       /**
        * Execute an LLM request with full retry/fallback logic
@@ -1958,7 +2007,14 @@ var init_LLMRequest = __esm({
                 parentSignal.removeEventListener("abort", onParentAbort);
               }
               try {
-                await iterator.return?.();
+                const cleanup = iterator.return?.();
+                if (cleanup) {
+                  await awaitBounded(
+                    Promise.resolve(cleanup),
+                    STREAM_CLEANUP_BUDGET_MS,
+                    "stream iterator cleanup"
+                  );
+                }
               } catch {
               }
             }
@@ -2091,7 +2147,11 @@ var init_LLMRequest = __esm({
        */
       static async resolveProgressArgument(state, toolName) {
         try {
-          const mod = await state.thread.instance.loadTool(toolName);
+          const mod = await awaitBounded(
+            state.thread.instance.loadTool(toolName),
+            HOOK_AWAIT_BUDGET_MS,
+            `loadTool(${toolName}) for progress argument`
+          );
           const pa = mod?.progressArgument ?? mod?.default?.progressArgument;
           return typeof pa === "string" && pa ? pa : void 0;
         } catch {
@@ -2112,7 +2172,11 @@ var init_LLMRequest = __esm({
           function: { name: entry.name, arguments: entry.argumentsDelta || "" }
         };
         try {
-          await FlowEngine.runToolCallStartedHook(state, toolCall, progress);
+          await awaitBounded(
+            FlowEngine.runToolCallStartedHook(state, toolCall, progress),
+            HOOK_AWAIT_BUDGET_MS,
+            `tool_call_started hook for ${entry.name}`
+          );
         } catch (error) {
           console.error("[LLMRequest] Error firing tool_call_started:", error);
         }
@@ -12697,8 +12761,12 @@ var init_ThreadStateImpl = __esm({
           options?.includeSilent,
           options?.maxDepth
         );
+        const messages = result.messages.map(this._mapMessage);
+        if (options?.order === "desc") {
+          messages.reverse();
+        }
         return {
-          messages: result.messages.map(this._mapMessage),
+          messages,
           total: result.total,
           hasMore: result.hasMore
         };
@@ -16906,6 +16974,11 @@ var DurableThread = class _DurableThread extends DurableObject {
     if (this.currentAbortController) {
       this.currentAbortController.abort();
     }
+    try {
+      await this.watchdogCompanion(threadId)?.destroy();
+    } catch (error) {
+      console.error("[DurableThread] Failed to destroy watchdog companion (non-fatal):", error);
+    }
     const agentBuilderId = this.env.AGENT_BUILDER.idFromName("singleton");
     const agentBuilder = this.env.AGENT_BUILDER.get(agentBuilderId);
     await agentBuilder.updateThread(threadId, { terminated: terminatedAt });
@@ -18065,6 +18138,7 @@ ${resultContent}${attachmentSummary}`;
    */
   async getMessages(limit = 100, offset = 0, order = "DESC", includeSilent = false, maxDepth = 0) {
     await this.ensureMigrated();
+    const normalizedOrder = String(order).toUpperCase() === "ASC" ? "ASC" : "DESC";
     try {
       const whereClauses = [];
       if (!includeSilent) {
@@ -18072,7 +18146,7 @@ ${resultContent}${attachmentSummary}`;
       }
       whereClauses.push(`(depth <= ${maxDepth} OR depth IS NULL)`);
       const whereClause = whereClauses.length > 0 ? `WHERE ${whereClauses.join(" AND ")}` : "";
-      const orderDirection = order === "ASC" ? "ASC" : "DESC";
+      const orderDirection = normalizedOrder;
       const combinedMessagesSql = `
         WITH combined_messages AS (
           SELECT
@@ -18198,7 +18272,7 @@ ${resultContent}${attachmentSummary}`;
           return projection ? { ...message, ...projection } : message;
         });
       }
-      if (order === "DESC") {
+      if (normalizedOrder === "DESC") {
         messages = messages.reverse();
       }
       const hasMore = offset + messages.length < total;
@@ -19031,6 +19105,14 @@ ${resultContent}${attachmentSummary}`;
       }
       this.logSockets.clear();
       this.messageSockets.clear();
+      try {
+        const threadId = this.ctx.id.name;
+        if (threadId) {
+          await this.watchdogCompanion(threadId)?.destroy();
+        }
+      } catch (error) {
+        console.error("[DurableThread] Failed to destroy watchdog companion (non-fatal):", error);
+      }
       await this.ctx.storage.deleteAlarm();
       await this.ctx.storage.deleteAll();
       this.migratedToVersion = null;
@@ -19686,6 +19768,18 @@ ${resultContent}${attachmentSummary}`;
   noteExecutionProgress() {
     this.lastProgressAt = Date.now();
   }
+  /**
+   * The per-thread companion watchdog DO (ThreadWatchdog), derived from the
+   * thread id. It exists because this thread's OWN alarm cannot fire while a
+   * queue-dispatched turn runs inside alarm() — the companion delivers the
+   * same check via RPC, which interleaves at await points even mid-turn.
+   * Returns null on deployments whose generated config predates the binding.
+   */
+  watchdogCompanion(threadId) {
+    const namespace = this.env.AGENT_BUILDER_WATCHDOG;
+    if (!namespace || typeof namespace.idFromName !== "function") return null;
+    return namespace.get(namespace.idFromName(threadId));
+  }
   /** Arm the standing watchdog for an execution start. One pending row max. */
   async armExecutionWatchdog(threadId) {
     try {
@@ -19694,14 +19788,20 @@ ${resultContent}${attachmentSummary}`;
       const pending = (await this.ctx.storage.sql.exec(
         `SELECT id FROM alarm_queue WHERE method = 'watchdogCheck' AND status = 'pending' LIMIT 1`
       )).toArray();
-      if (pending.length > 0) return;
-      await this.alarmQueue.enqueue("watchdogCheck", { threadId }, this.watchdogIntervalMs);
+      if (pending.length === 0) {
+        await this.alarmQueue.enqueue("watchdogCheck", { threadId }, this.watchdogIntervalMs);
+      }
     } catch (error) {
       console.error("[DurableThread] Failed to arm execution watchdog (non-fatal):", error);
     }
+    try {
+      await this.watchdogCompanion(threadId)?.arm(threadId);
+    } catch (error) {
+      console.error("[DurableThread] Failed to arm watchdog companion (non-fatal):", error);
+    }
   }
   /** Disarm on clean execution end. Completed check rows are noise, not history. */
-  async disarmExecutionWatchdog() {
+  async disarmExecutionWatchdog(threadId) {
     try {
       await this.ctx.storage.sql.exec(
         `DELETE FROM alarm_queue WHERE method = 'watchdogCheck' AND status IN ('pending', 'completed')`
@@ -19710,10 +19810,21 @@ ${resultContent}${attachmentSummary}`;
     } catch (error) {
       console.error("[DurableThread] Failed to disarm execution watchdog (non-fatal):", error);
     }
+    if (threadId) {
+      try {
+        await this.watchdogCompanion(threadId)?.disarmHint();
+      } catch (error) {
+        console.error("[DurableThread] Failed to hint watchdog companion (non-fatal):", error);
+      }
+    }
   }
   /**
-   * The standing check. Evaluates the thread's state AT FIRE TIME — it knows
-   * nothing about whichever request was in flight when it was armed.
+   * The standing check, alarm-queue delivery. Evaluates the thread's state AT
+   * FIRE TIME — it knows nothing about whichever request was in flight when it
+   * was armed. NOTE this delivery path cannot fire while a queue-dispatched
+   * turn runs (the turn owns this DO's single alarm invocation); the
+   * ThreadWatchdog companion delivers the same assessment via watchdogProbe()
+   * in exactly that window.
    */
   async watchdogCheck(threadId) {
     const rearm = () => this.alarmQueue.enqueue("watchdogCheck", { threadId }, this.watchdogIntervalMs);
@@ -19721,80 +19832,190 @@ ${resultContent}${attachmentSummary}`;
       await this.ctx.storage.sql.exec(
         `DELETE FROM alarm_queue WHERE method = 'watchdogCheck' AND status = 'completed'`
       );
-      const readIncomplete = async () => (await this.ctx.storage.sql.exec(
-        `SELECT id FROM logs WHERE is_complete = 0`
-      )).toArray();
-      let incomplete = await readIncomplete();
-      const ceiling = resolveWatchdogStaleCeilingMs(this.env);
-      const silenceMs = this.lastProgressAt === 0 ? Number.POSITIVE_INFINITY : Date.now() - this.lastProgressAt;
-      if (this.isExecuting) {
-        if (incomplete.length === 0) {
-          this.watchdogWedgeStrikes = 0;
-          await rearm();
-          return;
-        }
-        if (silenceMs <= ceiling) {
-          this.watchdogWedgeStrikes = 0;
-          await rearm();
-          return;
-        }
-        this.watchdogWedgeStrikes++;
-        if (this.watchdogWedgeStrikes < 2) {
-          console.warn(
-            `[DurableThread] Watchdog: execution silent for ${Math.round(silenceMs / 1e3)}s (ceiling ${Math.round(ceiling / 1e3)}s) \u2014 observing; takeover next cycle if still silent`
-          );
-          await rearm();
-          return;
-        }
-        console.error(
-          `[DurableThread] Watchdog: wedged execution (${Math.round(silenceMs / 1e3)}s silent across two cycles) \u2014 forcing takeover`
-        );
-        try {
-          this.currentAbortController?.abort();
-        } catch {
-        }
-        this.isExecuting = false;
-        this.currentAbortController = null;
-      } else if (incomplete.length > 0 && silenceMs <= ceiling) {
+      const result = await this.performWatchdogAssessment(threadId);
+      if (result.verdict === "healthy" || result.verdict === "observing") {
         await rearm();
         return;
       }
-      incomplete = await readIncomplete();
-      if (this.isExecuting) {
+      await this.disarmExecutionWatchdog(threadId);
+    } catch (error) {
+      console.error("[DurableThread] Watchdog check failed (non-fatal):", error);
+      try {
         await rearm();
-        return;
-      }
-      if (incomplete.length > 0) {
-        await this.finalizeLostExecutionLogs(incomplete.map((row) => row.id));
+      } catch {
       }
-      const stopped = await this.shouldStop();
-      const queued = (await this.ctx.storage.sql.exec(
-        `SELECT COUNT(*) AS c FROM message_queue`
-      )).toArray()[0]?.c ?? 0;
-      if (stopped || incomplete.length === 0 && queued === 0) {
-        await this.disarmExecutionWatchdog();
-        return;
+    }
+  }
+  /**
+   * RPC delivery of the standing check — called by the ThreadWatchdog
+   * companion (and the diagnostics revive endpoint). Runs in a fresh request
+   * context, so it interleaves with a running turn at await points and its
+   * own awaits/timers are alive even when a wedged turn's context is frozen.
+   * Does NOT touch the internal watchdogCheck alarm rows — those belong to
+   * the alarm delivery path.
+   */
+  async watchdogProbe(threadId) {
+    await this.ensureMigrated();
+    return await this.performWatchdogAssessment(threadId);
+  }
+  /**
+   * Reset this Durable Object instance on request. Used by the watchdog
+   * companion after a wedged-executor takeover: the zombie turn may still own
+   * this DO's single alarm invocation, which would block the just-enqueued
+   * recovery alarm forever. Aborting guarantees a fresh instance whose alarm
+   * chain re-arms from persisted queue state on first wake.
+   */
+  async forceRestart(reason) {
+    console.error(`[DurableThread] Force restart requested: ${reason}`);
+    this.ctx.abort(reason);
+  }
+  /**
+   * Execution-health snapshot for the diagnostics endpoint and `agents diag`.
+   * Exposes the state the 2026-07-08 post-mortem could not see from outside:
+   * the alarm queue (was a turn item pending/processing/failed? was the
+   * watchdog row gone?), the volatile execution flags, and open request logs.
+   * Read-only; safe to call at any time.
+   */
+  async getDiagnostics() {
+    await this.ensureMigrated();
+    const incompleteLogs = (await this.ctx.storage.sql.exec(
+      `SELECT id, model, provider, created_at FROM logs WHERE is_complete = 0 ORDER BY created_at DESC LIMIT 20`
+    )).toArray();
+    const alarmQueue = (await this.ctx.storage.sql.exec(
+      `SELECT id, method, status, scheduled_at, created_at, attempts, error
+         FROM alarm_queue
+         ORDER BY CASE WHEN status IN ('pending', 'processing') THEN 0 ELSE 1 END ASC,
+                  scheduled_at DESC
+         LIMIT 50`
+    )).toArray();
+    const messageQueueCount = (await this.ctx.storage.sql.exec(
+      `SELECT COUNT(*) AS c FROM message_queue`
+    )).toArray()[0]?.c ?? 0;
+    let contextUsage = null;
+    try {
+      const row = (await this.ctx.storage.sql.exec(
+        `SELECT value FROM thread_values WHERE key = 'context_usage' LIMIT 1`
+      )).toArray()[0];
+      if (row?.value) {
+        const parsed = JSON.parse(row.value);
+        contextUsage = this.normalizePlainRecord(parsed);
       }
-      if (await this.consumeWatchdogResumeBudget()) {
-        const side = await this.getLatestQueuedMessageSide() ?? "a";
-        await this.alarmQueue.enqueue("continueExecution", { threadId, side }, 0);
+    } catch {
+    }
+    return {
+      executing: this.isExecuting,
+      lastProgressAt: this.lastProgressAt > 0 ? this.lastProgressAt : null,
+      silenceMs: this.lastProgressAt > 0 ? Date.now() - this.lastProgressAt : null,
+      watchdogStrikes: this.watchdogWedgeStrikes,
+      watchdogCeilingMs: resolveWatchdogStaleCeilingMs(this.env),
+      stopped: await this.shouldStop(),
+      incompleteLogs,
+      alarmQueue,
+      messageQueueCount,
+      contextUsage
+    };
+  }
+  /**
+   * The shared watchdog decision core. Both deliveries (alarm + companion
+   * probe) evaluate and ACT through this method; the caller only decides what
+   * to do with its own scheduling based on the verdict.
+   */
+  async performWatchdogAssessment(threadId) {
+    const readIncomplete = async () => (await this.ctx.storage.sql.exec(
+      `SELECT id FROM logs WHERE is_complete = 0`
+    )).toArray();
+    let incomplete = await readIncomplete();
+    const ceiling = resolveWatchdogStaleCeilingMs(this.env);
+    const silenceMs = this.lastProgressAt === 0 ? Number.POSITIVE_INFINITY : Date.now() - this.lastProgressAt;
+    const reportedSilence = Number.isFinite(silenceMs) ? silenceMs : null;
+    const report = (verdict, action, extra = {}) => ({
+      verdict,
+      action,
+      executing: this.isExecuting,
+      incompleteLogs: incomplete.length,
+      queuedMessages: 0,
+      silenceMs: reportedSilence,
+      ceilingMs: ceiling,
+      strikes: this.watchdogWedgeStrikes,
+      requestRestart: false,
+      ...extra
+    });
+    let tookOver = false;
+    if (this.isExecuting) {
+      if (incomplete.length === 0) {
+        this.watchdogWedgeStrikes = 0;
+        return report("healthy", "none");
+      }
+      if (silenceMs <= ceiling) {
+        this.watchdogWedgeStrikes = 0;
+        return report("healthy", "none");
+      }
+      this.watchdogWedgeStrikes++;
+      if (this.watchdogWedgeStrikes < 2) {
         console.warn(
-          `[DurableThread] Watchdog: lost execution recovered \u2014 resuming thread ${threadId}`
-        );
-      } else {
-        console.error(
-          `[DurableThread] Watchdog: resume budget exhausted for thread ${threadId} \u2014 leaving thread stopped`
+          `[DurableThread] Watchdog: execution silent for ${Math.round(silenceMs / 1e3)}s (ceiling ${Math.round(ceiling / 1e3)}s) \u2014 observing; takeover next cycle if still silent`
         );
-        await this.notifyParentOfLostExecution(threadId);
+        return report("observing", "none");
       }
-      await this.disarmExecutionWatchdog();
-    } catch (error) {
-      console.error("[DurableThread] Watchdog check failed (non-fatal):", error);
+      console.error(
+        `[DurableThread] Watchdog: wedged execution (${Math.round(silenceMs / 1e3)}s silent across two cycles) \u2014 forcing takeover`
+      );
       try {
-        await rearm();
+        this.currentAbortController?.abort();
       } catch {
       }
+      this.isExecuting = false;
+      this.currentAbortController = null;
+      tookOver = true;
+    } else if (incomplete.length > 0 && silenceMs <= ceiling) {
+      return report("observing", "none");
+    }
+    incomplete = await readIncomplete();
+    if (this.isExecuting) {
+      return report("healthy", "none");
+    }
+    const finalizedCount = incomplete.length;
+    if (incomplete.length > 0) {
+      await this.finalizeLostExecutionLogs(incomplete.map((row) => row.id));
+    }
+    const stopped = await this.shouldStop();
+    const queued = (await this.ctx.storage.sql.exec(
+      `SELECT COUNT(*) AS c FROM message_queue`
+    )).toArray()[0]?.c ?? 0;
+    if (stopped || finalizedCount === 0 && queued === 0) {
+      if (finalizedCount > 0) {
+        return report("parked", "finalized_parked", {
+          queuedMessages: queued,
+          requestRestart: tookOver
+        });
+      }
+      return report("idle", "none", { queuedMessages: queued });
+    }
+    if (await this.hasPendingTurnAlarm()) {
+      return report("recovered", "finalized_deferred", {
+        queuedMessages: queued,
+        requestRestart: tookOver
+      });
+    }
+    if (await this.consumeWatchdogResumeBudget()) {
+      const side = await this.getLatestQueuedMessageSide() ?? "a";
+      await this.alarmQueue.enqueue("continueExecution", { threadId, side }, 0);
+      console.warn(
+        `[DurableThread] Watchdog: lost execution recovered \u2014 resuming thread ${threadId}`
+      );
+      return report("recovered", tookOver ? "aborted_takeover_resumed" : "finalized_resumed", {
+        queuedMessages: queued,
+        requestRestart: tookOver
+      });
     }
+    console.error(
+      `[DurableThread] Watchdog: resume budget exhausted for thread ${threadId} \u2014 leaving thread stopped`
+    );
+    await this.notifyParentOfLostExecution(threadId);
+    return report("parked", "finalized_parked", {
+      queuedMessages: queued,
+      requestRestart: tookOver
+    });
   }
   /** Mark logs the dead executor abandoned, and tell connected clients. */
   async finalizeLostExecutionLogs(logIds) {
@@ -19903,6 +20124,18 @@ Its execution was lost (the executor restarted or hung) and automatic recovery w
    */
   async executeFlow(threadId, agentName, initial_messages, data, awaitCompletion = true) {
     await this.assertNotTerminated();
+    if (this.isExecuting) {
+      const busyWaitBudgetMs = 3e4;
+      const waitStartedAt = Date.now();
+      while (this.isExecuting && Date.now() - waitStartedAt < busyWaitBudgetMs) {
+        await new Promise((resolve) => setTimeout(resolve, 500));
+      }
+      if (this.isExecuting) {
+        throw new Error(
+          `Thread ${threadId} is already executing; refusing to start a second concurrent flow`
+        );
+      }
+    }
     this.isExecuting = true;
     this.currentAbortController = new AbortController();
     await this.armExecutionWatchdog(threadId);
@@ -20036,7 +20269,7 @@ Its execution was lost (the executor restarted or hung) and automatic recovery w
     } finally {
       this.isExecuting = false;
       this.currentAbortController = null;
-      await this.disarmExecutionWatchdog();
+      await this.disarmExecutionWatchdog(threadId);
     }
   }
   /**
@@ -20076,6 +20309,19 @@ Its execution was lost (the executor restarted or hung) and automatic recovery w
    */
   async processMessage(threadId, content, role = "user", attachments, queuedMessageId, queuedAt) {
     await this.assertNotTerminated();
+    if (this.isExecuting) {
+      console.warn(
+        `[DurableThread] processMessage while executing \u2014 diverting message to queue for thread ${threadId}`
+      );
+      await this.queueMessage(threadId, {
+        role: role === "assistant" ? "assistant" : "user",
+        content,
+        attachments: this.parseAttachmentRefsJson(attachments ?? null) ?? [],
+        silent: false,
+        metadata: { diverted_from: "processMessage" }
+      });
+      return;
+    }
     if (role === "user") {
       await this.ctx.storage.sql.exec(
         `UPDATE execution_state SET value = 'false' WHERE key = 'stopped'`
@@ -20222,7 +20468,7 @@ Its execution was lost (the executor restarted or hung) and automatic recovery w
     } finally {
       this.isExecuting = false;
       this.currentAbortController = null;
-      await this.disarmExecutionWatchdog();
+      await this.disarmExecutionWatchdog(threadId);
     }
   }
   /**
@@ -20231,6 +20477,12 @@ Its execution was lost (the executor restarted or hung) and automatic recovery w
    */
   async doContinueExecution(threadId, side = "a") {
     await this.assertNotTerminated();
+    if (this.isExecuting) {
+      console.warn(
+        `[DurableThread] continueExecution while executing \u2014 skipping (running flow owns the queue) for thread ${threadId}`
+      );
+      return;
+    }
     this.isExecuting = true;
     this.currentAbortController = new AbortController();
     await this.armExecutionWatchdog(threadId);
@@ -20342,7 +20594,7 @@ Its execution was lost (the executor restarted or hung) and automatic recovery w
     } finally {
       this.isExecuting = false;
       this.currentAbortController = null;
-      await this.disarmExecutionWatchdog();
+      await this.disarmExecutionWatchdog(threadId);
       const latestQueuedSide = await this.getLatestQueuedMessageSide();
       if (latestQueuedSide) {
         await this.ensureQueuedMessageExecution(threadId, latestQueuedSide);
@@ -24159,6 +24411,179 @@ var CodeExecutionBridge = class extends WorkerEntrypoint {
     return thread.callCodeExecutionBridge(runId, functionId, encodedArgs);
   }
 };
+var CHECK_CADENCE_MS = 3e4;
+var DISARM_CONFIRM_DELAY_MS = 3e3;
+var PROBE_TIMEOUT_MS = 15e3;
+var MAX_UNREACHABLE_STRIKES = 40;
+var HISTORY_CAP = 20;
+var KEY_ARMED = "armed";
+var KEY_HISTORY = "history";
+var KEY_UNREACHABLE = "unreachable_strikes";
+var ThreadWatchdog = class extends DurableObject {
+  /**
+   * Arm (or re-arm) the standing check for a thread execution. Idempotent —
+   * called at every execution start. Resets the unreachable counter because a
+   * fresh arm proves the thread is answering RPCs right now.
+   */
+  async arm(threadId) {
+    await this.ctx.storage.put(KEY_ARMED, {
+      threadId,
+      armedAt: Date.now()
+    });
+    await this.ctx.storage.delete(KEY_UNREACHABLE);
+    const existing = await this.ctx.storage.getAlarm();
+    if (existing === null) {
+      await this.ctx.storage.setAlarm(Date.now() + CHECK_CADENCE_MS);
+    }
+  }
+  /**
+   * Hint that the thread believes its execution ended cleanly. The companion
+   * does NOT trust this (a bogus "clean end" was one of the incident's failure
+   * modes) — it just moves the next check close so a genuinely clean thread
+   * stands down in seconds instead of a full cadence.
+   */
+  async disarmHint() {
+    const armed = await this.ctx.storage.get(KEY_ARMED);
+    if (!armed) return;
+    await this.ctx.storage.setAlarm(Date.now() + DISARM_CONFIRM_DELAY_MS);
+  }
+  /** Diagnostics view for the thread inspector UI and the diag CLI. */
+  async getState() {
+    const armed = await this.ctx.storage.get(KEY_ARMED);
+    const history = await this.ctx.storage.get(KEY_HISTORY) ?? [];
+    return {
+      armed: Boolean(armed),
+      threadId: armed?.threadId ?? null,
+      armedAt: armed?.armedAt ?? null,
+      history
+    };
+  }
+  /**
+   * Explicit cascade from the parent thread (delete/terminate). Cloudflare
+   * has no automatic parent-child cleanup — this IS the cleanup.
+   */
+  async destroy() {
+    await this.ctx.storage.deleteAlarm();
+    await this.ctx.storage.deleteAll();
+  }
+  async alarm() {
+    const armed = await this.ctx.storage.get(KEY_ARMED);
+    if (!armed) {
+      return;
+    }
+    await this.ctx.storage.setAlarm(Date.now() + CHECK_CADENCE_MS);
+    const startedAt = Date.now();
+    let checkin;
+    let requestRestart = false;
+    let standDown = false;
+    try {
+      const result = await this.probeThread(armed.threadId);
+      await this.ctx.storage.delete(KEY_UNREACHABLE);
+      requestRestart = result.requestRestart;
+      standDown = result.verdict === "idle" || result.verdict === "parked";
+      checkin = {
+        at: startedAt,
+        verdict: result.verdict,
+        action: describeAction(result),
+        executing: result.executing,
+        incompleteLogs: result.incompleteLogs,
+        silenceMs: result.silenceMs,
+        probeMs: Date.now() - startedAt
+      };
+    } catch (error) {
+      const strikes = (await this.ctx.storage.get(KEY_UNREACHABLE) ?? 0) + 1;
+      await this.ctx.storage.put(KEY_UNREACHABLE, strikes);
+      checkin = {
+        at: startedAt,
+        verdict: "unreachable",
+        action: `probe failed (${strikes} consecutive)`,
+        executing: null,
+        incompleteLogs: null,
+        silenceMs: null,
+        probeMs: Date.now() - startedAt,
+        error: error instanceof Error ? error.message : String(error)
+      };
+      if (strikes >= MAX_UNREACHABLE_STRIKES) {
+        console.error(
+          `[ThreadWatchdog] CRITICAL: thread ${armed.threadId} unreachable for ${strikes} consecutive probes \u2014 standing down. Manual intervention required.`
+        );
+        standDown = true;
+      }
+    }
+    await this.recordCheckin(checkin);
+    if (requestRestart) {
+      try {
+        const stub = this.getThreadStub(armed.threadId);
+        await stub.forceRestart(
+          "watchdog takeover: wedged execution aborted; restarting so the recovery alarm can fire"
+        );
+      } catch {
+      }
+    }
+    if (standDown) {
+      await this.ctx.storage.delete(KEY_ARMED);
+      await this.ctx.storage.delete(KEY_UNREACHABLE);
+      await this.ctx.storage.deleteAlarm();
+    }
+  }
+  getThreadStub(threadId) {
+    const namespace = this.env.AGENT_BUILDER_THREAD;
+    const id = namespace.idFromName(threadId);
+    return namespace.get(id);
+  }
+  async probeThread(threadId) {
+    const stub = this.getThreadStub(threadId);
+    let timer;
+    const timeout = new Promise((_resolve, reject) => {
+      timer = setTimeout(
+        () => reject(new Error(`probe timed out after ${PROBE_TIMEOUT_MS}ms`)),
+        PROBE_TIMEOUT_MS
+      );
+    });
+    try {
+      return await Promise.race([stub.watchdogProbe(threadId), timeout]);
+    } finally {
+      if (timer) clearTimeout(timer);
+    }
+  }
+  async recordCheckin(checkin) {
+    const history = await this.ctx.storage.get(KEY_HISTORY) ?? [];
+    history.unshift(checkin);
+    await this.ctx.storage.put(KEY_HISTORY, history.slice(0, HISTORY_CAP));
+  }
+};
+function describeAction(result) {
+  switch (result.action) {
+    case "finalized_resumed":
+      return `finalized ${result.incompleteLogs} lost request(s), resumed thread`;
+    case "finalized_parked":
+      return `finalized ${result.incompleteLogs} lost request(s), left thread stopped`;
+    case "finalized_deferred":
+      return `finalized ${result.incompleteLogs} lost request(s); queued turn will continue`;
+    case "aborted_takeover_resumed":
+      return `took over wedged execution (silent ${formatMs(result.silenceMs)}), finalized and resumed`;
+    case "none":
+    default:
+      if (result.verdict === "observing") {
+        return `execution silent ${formatMs(result.silenceMs)} (ceiling ${formatMs(result.ceilingMs)}) \u2014 observing`;
+      }
+      if (result.verdict === "idle") {
+        return "thread idle and clean \u2014 standing down";
+      }
+      if (result.executing) {
+        return result.incompleteLogs > 0 ? `streaming, last progress ${formatMs(result.silenceMs)} ago` : "executing (tool run, no open request)";
+      }
+      return "no action needed";
+  }
+}
+function formatMs(ms) {
+  if (ms === null || !Number.isFinite(ms)) return "\u221E";
+  if (ms < 1e3) return `${ms}ms`;
+  const seconds = Math.round(ms / 1e3);
+  if (seconds < 60) return `${seconds}s`;
+  const minutes = Math.floor(seconds / 60);
+  return `${minutes}m${String(seconds % 60).padStart(2, "0")}s`;
+}
 
 // src/runtime.ts
 init_utilities();
@@ -24521,6 +24946,6 @@ init_context();
 init_ProviderRegistry();
 init_types2();
 
-export { CodeExecutionBridge, DurableAgentBuilder, DurableThread, FlowStateSdk, NamespaceResolutionError, ProviderRegistry, authenticate, buildImageDescription, cat, createNamespaceContext, createThreadEndpointHandler, defineController2 as defineController, emitThreadEvent, enhanceFlowState, exists, find, forceTurn, generateImageDescription, getFileStats, getMessages, getMessagesToSummarize, getShortName, getThumbnail, getUnsummarizedImageAttachments, getVisibleAgentNames, getVisibleModelNames, getVisiblePromptNames, getVisibleToolNames, grep, hasImageAttachments, head, injectMessage, isQualifiedName, linkFile, mkdir, move, optimizeImageContext, parseQualifiedName, qualifyName, queueTool, readFile, readdir, reloadHistory, rename, replaceImagesWithDescriptions, requireAdmin, requireAuth, resolveAgent, resolveHook, resolveModel, resolvePrompt, resolveTool, rmdir, stat, tail, unlink, updateThread, writeFile, writeImage };
+export { CodeExecutionBridge, DurableAgentBuilder, DurableThread, FlowStateSdk, NamespaceResolutionError, ProviderRegistry, ThreadWatchdog, authenticate, buildImageDescription, cat, createNamespaceContext, createThreadEndpointHandler, defineController2 as defineController, emitThreadEvent, enhanceFlowState, exists, find, forceTurn, generateImageDescription, getFileStats, getMessages, getMessagesToSummarize, getShortName, getThumbnail, getUnsummarizedImageAttachments, getVisibleAgentNames, getVisibleModelNames, getVisiblePromptNames, getVisibleToolNames, grep, hasImageAttachments, head, injectMessage, isQualifiedName, linkFile, mkdir, move, optimizeImageContext, parseQualifiedName, qualifyName, queueTool, readFile, readdir, reloadHistory, rename, replaceImagesWithDescriptions, requireAdmin, requireAuth, resolveAgent, resolveHook, resolveModel, resolvePrompt, resolveTool, rmdir, stat, tail, unlink, updateThread, writeFile, writeImage };
 //# sourceMappingURL=runtime.js.map
 //# sourceMappingURL=runtime.js.map