@skaile/workspaces 2.8.0 → 2.9.0

package/dist/{chunk-HVQWLYZB.js → chunk-E5VGAW4E.js}

@@ -1,10 +1,10 @@
 import { resolveAuthRef } from './chunk-ZNIHTT22.js';
 import { pluginRegistry } from './chunk-6E6PKKAD.js';
 import { computeStimulus } from './chunk-IFGTRL2I.js';
-import { getConsumedOutputSchema, validateConsumedNodeOutput, resolveNodeBindings, computeFlowStateFromSnapshots, availableRouterFrontier, evaluateRouterSelection, routerSelectionOutput, planRouterSkips, unsettledRouterBranchIds, interpolateNodeInstruction, persistedRouterSelection } from './chunk-E4AVJMOJ.js';
-import { parseFlowDefinition } from './chunk-XJ74XFIZ.js';
-import { renderStimulusPrompt } from './chunk-SCR3WGW7.js';
-import { flowDefaults, isAgentNode, isGateNode, nodeRequiresApproval, isSubFlowNode, isFunctionNode, nodeIsOptional, isRouterNode, isActiveRuntimeNode, nodeLabel, nodeInstruction, nodeAssets } from './chunk-TUYN2HDT.js';
+import { getConsumedOutputSchema, validateConsumedNodeOutput, appendAttempt, remainingActiveExecutionMs, resolveNodeBindings, deriveCheckEvidence, computeFlowStateFromSnapshots, availableRouterFrontier, evaluateRouterSelection, routerSelectionOutput, planRouterSkips, unsettledRouterBranchIds, countFailedAttempts, hasAutomaticRetryBudget, interpolateNodeInstruction, persistedRouterSelection } from './chunk-UAIR3K6X.js';
+import { parseFlowDefinition } from './chunk-INHE5U74.js';
+import { renderStimulusPrompt } from './chunk-OHLKWUO3.js';
+import { deterministicNodeKindLabel, flowDefaults, isAgentNode, isGateNode, isCheckNode, nodeRequiresApproval, isSubFlowNode, isFunctionNode, nodeIsOptional, isRouterNode, isActiveRuntimeNode, nodeLabel, nodeInstruction, nodeAssets } from './chunk-AGFAOSCZ.js';
 import { portableSpawn } from './chunk-P43HBWKK.js';
 import { withFsDeadline, tryWithFsDeadline, FsDeadlineError, fsDeadlineMs } from './chunk-DYMWJAL4.js';
 import { createLogger } from './chunk-7GOCNYUV.js';
@@ -324,11 +324,11 @@ function stableJsonStringify(value) {
     );
   });
 }
-function serializeEnvironmentInput(name, value) {
+function serializeEnvironmentInput(name, value, nodeLabel2) {
   if (typeof value === "string") return value;
   const serialized = stableJsonStringify(value);
   if (serialized === void 0) {
-    throw new Error(`Function node input ${name} is not JSON-serializable`);
+    throw new Error(`${nodeLabel2} input ${name} is not JSON-serializable`);
   }
   return serialized;
 }
@@ -348,19 +348,18 @@ var SessionNodeExecutor = class {
   constructor(options) {
     this.workspaceDir = resolve(options.workspaceDir);
   }
-  /** Runs one function node process with session environment and binding overrides. */
+  /** Runs one function or check node process with session environment and binding overrides. */
   async execute(request) {
+    const nodeLabel2 = `${deterministicNodeKindLabel(request.node.run.kind)} node ${request.node.id}`;
     const cwd = resolve(this.workspaceDir, request.node.run.cwd ?? ".");
     const workspaceRelative = relative(this.workspaceDir, cwd);
     if (workspaceRelative === ".." || workspaceRelative.startsWith(`..${sep}`) || isAbsolute(workspaceRelative)) {
-      throw new Error(
-        `Function node ${request.node.id} cwd escapes the session workspace: ${request.node.run.cwd}`
-      );
+      throw new Error(`${nodeLabel2} cwd escapes the session workspace: ${request.node.run.cwd}`);
     }
     const boundEnvironment = Object.fromEntries(
       Object.entries(request.inputs).map(([name, value]) => [
         name,
-        serializeEnvironmentInput(name, value)
+        serializeEnvironmentInput(name, value, nodeLabel2)
       ])
     );
     const process2 = portableSpawn(commandFor(request.node), {
@@ -7487,6 +7486,28 @@ var AGENT_INLINE_OPERATIONS = /* @__PURE__ */ new Set([
   "skip_node",
   "fail_node"
 ]);
+var NodeTimeoutError = class extends Error {
+};
+function raceWithTimeout(promise, ms, timeoutMessage) {
+  return new Promise((resolve6, reject) => {
+    const timer = setTimeout(() => {
+      reject(new NodeTimeoutError(timeoutMessage));
+      promise.catch(() => {
+      });
+    }, ms);
+    timer.unref?.();
+    promise.then(
+      (value) => {
+        clearTimeout(timer);
+        resolve6(value);
+      },
+      (err) => {
+        clearTimeout(timer);
+        reject(err);
+      }
+    );
+  });
+}
 function mergeInteractionHistory(history, interaction) {
   if (!interaction) return history;
   const next = [...history];
@@ -7507,7 +7528,8 @@ function emptyNode(nodeId) {
     status: "not_started",
     approvalHistory: [],
     inputHistory: [],
-    errorHistory: []
+    errorHistory: [],
+    outputHistory: []
   };
 }
 function nodeExecutionRecord(entries = []) {
@@ -7648,14 +7670,18 @@ var FlowAdapter = class extends AbstractConnector {
       inlineOperationTargets: /* @__PURE__ */ new Map(),
       flowInputOrigins: options.flowInputOrigins,
       inlineSubFlowAncestry: options.inlineSubFlowAncestry ?? [flowDef.id],
-      executionGeneration: 0
+      executionGeneration: 0,
+      wakeTimer: null
     };
     state.execution = this.recompute(state);
-    return this.makeHandle(declaration, state);
+    const handle = this.makeHandle(declaration, state);
+    this.rearmWakeTimer(handle);
+    return handle;
   }
   async disconnect(handle) {
     const state = this.s(handle);
     state.executionGeneration += 1;
+    this.clearWakeTimer(state);
     await this.cancelInlineTargets(state);
     handle.status = "disconnected";
   }
@@ -7703,6 +7729,7 @@ var FlowAdapter = class extends AbstractConnector {
     const changed = JSON.stringify(prepared) !== JSON.stringify(execution);
     s.executionGeneration += 1;
     s.execution = prepared;
+    this.rearmWakeTimer(handle);
     if (changed && s.onChange) s.onChange(s.execution);
   }
   // ── Base operations (private — wired into tools face in constructor) ──
@@ -8315,17 +8342,27 @@ var FlowAdapter = class extends AbstractConnector {
       this.mutate(handle, (current) => {
         const execution = current.execution.nodes[nodeId];
         assertLegal(execution, `node not in execution: ${nodeId}`);
+        const completedAt = now();
         const error = {
           message: `Node ${nodeId} output failed schema validation after one correction: ${issueText}`,
           recoverable: false,
-          at: now()
+          at: completedAt
         };
+        const outputHistory = execution.startedAt ? appendAttempt(
+          execution.outputHistory,
+          "failed",
+          execution.startedAt,
+          completedAt,
+          execution.output,
+          error
+        ) : execution.outputHistory;
         current.execution.nodes[nodeId] = {
           ...execution,
           status: "failed",
-          completedAt: now(),
+          completedAt,
           error,
-          errorHistory: [...execution.errorHistory, error]
+          errorHistory: [...execution.errorHistory, error],
+          outputHistory
         };
       });
       throw new Error(
@@ -8335,11 +8372,21 @@ var FlowAdapter = class extends AbstractConnector {
     return this.mutate(handle, (current) => {
       const execution = current.execution.nodes[nodeId];
       assertLegal(execution, `node not in execution: ${nodeId}`);
+      const completedAt = now();
+      const outputHistory = execution.startedAt ? appendAttempt(
+        execution.outputHistory,
+        "complete",
+        execution.startedAt,
+        completedAt,
+        output,
+        void 0
+      ) : execution.outputHistory;
       current.execution.nodes[nodeId] = {
         ...execution,
         status: "complete",
-        completedAt: now(),
-        output
+        completedAt,
+        output,
+        outputHistory
       };
       return JSON.stringify({ ok: true, status: "complete" });
     });
@@ -8357,10 +8404,20 @@ var FlowAdapter = class extends AbstractConnector {
         `cannot skip node ${nodeId}: it is a mandatory approval gate \u2014 call request_approval and wait for an approved decision`
       );
       assertLegal(isOptional(s.flowDef, nodeId), `cannot skip required node ${nodeId}`);
+      const completedAt = now();
+      const outputHistory = node.startedAt ? appendAttempt(
+        node.outputHistory,
+        "skipped",
+        node.startedAt,
+        completedAt,
+        node.output,
+        void 0
+      ) : node.outputHistory;
       s.execution.nodes[nodeId] = {
         ...node,
         status: "skipped",
-        completedAt: now()
+        completedAt,
+        outputHistory
       };
       return JSON.stringify({ ok: true, status: "skipped" });
     });
@@ -8375,19 +8432,40 @@ var FlowAdapter = class extends AbstractConnector {
       assertLegal(node, `node not in execution: ${nodeId}`);
       const error = { message, recoverable, at: now() };
       if (recoverable) {
+        const completedAt = error.at;
+        const outputHistory = node.startedAt ? appendAttempt(
+          node.outputHistory,
+          "failed",
+          node.startedAt,
+          completedAt,
+          node.output,
+          error,
+          { selfRetry: true }
+        ) : node.outputHistory;
         s.execution.nodes[nodeId] = {
           ...node,
           status: "available",
           error,
-          errorHistory: [...node.errorHistory, error]
+          errorHistory: [...node.errorHistory, error],
+          outputHistory
         };
       } else {
+        const completedAt = now();
+        const outputHistory = node.startedAt ? appendAttempt(
+          node.outputHistory,
+          "failed",
+          node.startedAt,
+          completedAt,
+          node.output,
+          error
+        ) : node.outputHistory;
         s.execution.nodes[nodeId] = {
           ...node,
           status: "failed",
-          completedAt: now(),
+          completedAt,
           error,
-          errorHistory: [...node.errorHistory, error]
+          errorHistory: [...node.errorHistory, error],
+          outputHistory
         };
       }
       return JSON.stringify({ ok: true, status: s.execution.nodes[nodeId].status });
@@ -8397,7 +8475,9 @@ var FlowAdapter = class extends AbstractConnector {
   /**
    * Record an approval decision on a node currently `awaiting_approval`.
    * A first-class gate completes directly when approved and remains parked when rejected.
-   * Agent-node approvals keep their existing resume behavior.
+   * Agent-node approvals keep their existing resume behavior. A check's escalation is a
+   * one-way door: only `rejected` is legal, and it ends the node terminally `failed` —
+   * there is no decision that resumes or passes a check.
    */
   applyApproval(handle, nodeId, decision, feedback, decidedBy) {
     this.mutate(handle, (s) => {
@@ -8414,6 +8494,12 @@ var FlowAdapter = class extends AbstractConnector {
           `applyApproval: gate ${nodeId} approval attempt is already decided; request approval again before applying another decision`
         );
       }
+      if (isCheckNode(definition)) {
+        assertLegal(
+          decision === "rejected",
+          `applyApproval: check ${nodeId} cannot be approved \u2014 a failed check has no passing state to approve into; only "rejected" is a legal decision`
+        );
+      }
       const base = node.approval ?? { requestedAt: now(), summary: "" };
       const approval = {
         ...base,
@@ -8440,6 +8526,14 @@ var FlowAdapter = class extends AbstractConnector {
           approval,
           approvalHistory: history
         };
+      } else if (isCheckNode(definition)) {
+        s.execution.nodes[nodeId] = {
+          ...node,
+          status: "failed",
+          completedAt: now(),
+          approval,
+          approvalHistory: history
+        };
       } else if (decision === "approved") {
         s.execution.nodes[nodeId] = { ...node, approval, approvalHistory: history };
       } else {
@@ -8513,10 +8607,17 @@ var FlowAdapter = class extends AbstractConnector {
       return void 0;
     });
   }
-  /** Cancel the flow run. Status transitions to `cancelled`; dependents stay put. */
+  /**
+   * Cancel the flow run. Status transitions to `cancelled`; dependents stay
+   * put. Bumps `executionGeneration` — the sole late-settlement rejection
+   * mechanism every in-flight await (function executor, sub-flow child)
+   * checks after resolving, so a result that arrives after cancellation can
+   * never write state.
+   */
   cancel(handle) {
     this.mutate(handle, (s) => {
       s.execution = { ...s.execution, status: "cancelled" };
+      s.executionGeneration += 1;
       return void 0;
     });
   }
@@ -8586,9 +8687,11 @@ var FlowAdapter = class extends AbstractConnector {
     return this.drainAvailableRuntimeNodes(handle, true);
   }
   /**
-   * Run every currently available function node through the configured
-   * NodeExecutor. Newly-unblocked function nodes are drained in definition
-   * order before returning control to the runner's agent-turn decision.
+   * Run every currently available function and check node through the
+   * configured NodeExecutor. Newly-unblocked function/check nodes are
+   * drained in definition order before returning control to the runner's
+   * agent-turn decision. Routers and gates are excluded — see
+   * {@link drainRuntimeNodes} for the full drain.
    */
   async executeAvailableFunctionNodes(handle) {
     return this.drainAvailableRuntimeNodes(handle, false);
@@ -8604,7 +8707,7 @@ var FlowAdapter = class extends AbstractConnector {
         if (isSubFlowNode(candidate) && !advancedSubFlows.has(candidate.id) && (status === "available" || status === "running")) {
           return true;
         }
-        return (isFunctionNode(candidate) || includeRoutersAndGates && isGateNode(candidate)) && status === "available";
+        return (isFunctionNode(candidate) || isCheckNode(candidate) || includeRoutersAndGates && isGateNode(candidate)) && status === "available";
       });
       if (!node) break;
       if (isGateNode(node)) {
@@ -8653,6 +8756,9 @@ var FlowAdapter = class extends AbstractConnector {
           );
         }
         const executionGeneration = state.executionGeneration;
+        const timeoutSec = node.control?.timeoutSec;
+        const runningExecution = state.execution.nodes[node.id];
+        const remainingMs = runningExecution ? remainingActiveExecutionMs(runningExecution, timeoutSec, Date.now()) : void 0;
         let result;
         try {
           const runner = state.inlineSubFlowRunner;
@@ -8665,7 +8771,7 @@ var FlowAdapter = class extends AbstractConnector {
             snapshotMap(state.execution),
             state.flowInputOrigins
           );
-          result = await runner.run({
+          const runPromise = runner.run({
             node,
             flowId: node.run.flow,
             inputs: resolved.values,
@@ -8682,50 +8788,86 @@ var FlowAdapter = class extends AbstractConnector {
               else state.inlineOperationTargets.delete(node.id);
             }
           });
+          result = remainingMs !== void 0 ? await raceWithTimeout(
+            runPromise,
+            Math.max(0, remainingMs),
+            `Sub-flow node ${node.id} timed out after ${timeoutSec}s`
+          ) : await runPromise;
         } catch (error) {
-          result = {
-            status: "failed",
-            error: {
-              message: `Sub-flow node ${node.id} failed: ${error instanceof Error ? error.message : String(error)}`,
-              recoverable: false,
-              at: now()
+          if (error instanceof NodeTimeoutError) {
+            const target = state.inlineOperationTargets.get(node.id);
+            if (target) {
+              state.inlineOperationTargets.delete(node.id);
+              void target.cancel().catch(() => {
+              });
             }
-          };
+            result = {
+              status: "failed",
+              error: { message: error.message, recoverable: false, at: now() }
+            };
+          } else {
+            result = {
+              status: "failed",
+              error: {
+                message: `Sub-flow node ${node.id} failed: ${error instanceof Error ? error.message : String(error)}`,
+                recoverable: false,
+                at: now()
+              }
+            };
+          }
         }
         if (this.s(handle).executionGeneration !== executionGeneration) break;
         if (result.status === "paused") {
           this.projectInlineInteraction(handle, node.id, result.projection);
           continue;
         }
-        if (this.s(handle).execution.status === "cancelled") break;
+        let subFlowRetrying = false;
         this.mutate(
           handle,
           (current) => {
             const execution2 = current.execution.nodes[node.id];
             assertLegal(execution2, `node not in execution: ${node.id}`);
+            const completedAt = now();
             if (result.status === "complete") {
+              const outputHistory = appendAttempt(
+                execution2.outputHistory,
+                "complete",
+                execution2.startedAt ?? completedAt,
+                completedAt,
+                result.output,
+                void 0
+              );
               current.execution.nodes[node.id] = {
                 ...execution2,
                 status: "complete",
-                completedAt: now(),
-                output: result.output
+                completedAt,
+                output: result.output,
+                outputHistory
               };
               return;
             }
-            current.execution.nodes[node.id] = {
+            const { retry, patch } = this.planAutomaticRetry(
+              node,
+              execution2,
+              result.error.message,
+              completedAt,
+              result.output,
+              result.error.at
+            );
+            subFlowRetrying = retry;
+            current.execution.nodes[node.id] = retry ? { ...execution2, ...patch, status: "available", error: void 0 } : {
               ...execution2,
+              ...patch,
               status: nodeIsOptional(node) ? "skipped" : "failed",
-              completedAt: now(),
-              output: result.output,
-              error: result.error,
-              errorHistory: [...execution2.errorHistory, result.error]
+              completedAt
             };
           },
           false
         );
+        if (subFlowRetrying) advancedSubFlows.delete(node.id);
         continue;
       }
-      if (!isFunctionNode(node)) continue;
+      if (!isFunctionNode(node) && !isCheckNode(node)) continue;
       this.mutate(
         handle,
         (current) => {
@@ -8733,7 +8875,7 @@ var FlowAdapter = class extends AbstractConnector {
           assertLegal(execution, `node not in execution: ${node.id}`);
           assertLegal(
             execution.status === "available",
-            `cannot execute function node ${node.id}: status is ${execution.status}`
+            `cannot execute ${node.run.kind} node ${node.id}: status is ${execution.status}`
           );
           current.execution.nodes[node.id] = {
             ...execution,
@@ -8743,73 +8885,178 @@ var FlowAdapter = class extends AbstractConnector {
         },
         false
       );
+      const deterministicExecutionGeneration = state.executionGeneration;
+      const deterministicTimeoutSec = node.control?.timeoutSec;
+      const deterministicRunningExecution = state.execution.nodes[node.id];
+      const deterministicRemainingMs = deterministicRunningExecution ? remainingActiveExecutionMs(
+        deterministicRunningExecution,
+        deterministicTimeoutSec,
+        Date.now()
+      ) : void 0;
+      const deterministicKindLabel = deterministicNodeKindLabel(node.run.kind);
       let capturedOutput;
+      let checkEvidence;
+      let deterministicOutcome;
       try {
         const executor = state.nodeExecutor;
-        if (!executor) throw new Error(`no NodeExecutor configured for function node ${node.id}`);
+        if (!executor)
+          throw new Error(`no NodeExecutor configured for ${node.run.kind} node ${node.id}`);
         const resolved = resolveNodeBindings(
           state.flowDef,
           node,
           snapshotMap(state.execution),
           state.flowInputOrigins
         );
-        const result = await executor.execute({
+        const runPromise = executor.execute({
           node,
           inputs: resolved.values,
           inputOrigins: resolved.origins
         });
-        capturedOutput = functionNodeOutput(node, result);
+        const result = deterministicRemainingMs !== void 0 ? await raceWithTimeout(
+          runPromise,
+          Math.max(0, deterministicRemainingMs),
+          `${deterministicKindLabel} node ${node.id} timed out after ${deterministicTimeoutSec}s`
+        ) : await runPromise;
         const successfulStatuses = node.run.successExit ?? [0];
-        if (!successfulStatuses.includes(result.exitStatus)) {
-          const detail = result.stderr.trim() || result.stdout.trim();
-          throw new Error(
-            `Function node ${node.id} exited with unsuccessful exit status ${result.exitStatus}${detail ? `: ${detail}` : ""}`
+        const passed = successfulStatuses.includes(result.exitStatus);
+        capturedOutput = deterministicNodeOutput(node, result, passed);
+        const detail = passed ? "" : result.stderr.trim() || result.stdout.trim();
+        const detailSuffix = detail ? `: ${detail}` : "";
+        if (passed) {
+          const validation = validateConsumedNodeOutput(
+            state.flowDef,
+            node.id,
+            capturedOutput.fields
           );
+          if (!validation.valid) {
+            throw new Error(
+              `output does not match its consumed schema: ${validation.issues.join("; ")}`
+            );
+          }
         }
-        const validation = validateConsumedNodeOutput(
-          state.flowDef,
-          node.id,
-          capturedOutput.fields
-        );
-        if (!validation.valid) {
+        if (isCheckNode(node)) {
+          checkEvidence = deriveCheckEvidence(
+            resolved,
+            {
+              runtime: node.run.runtime ?? "shell",
+              command: node.run.command,
+              cwd: node.run.cwd,
+              successExit: successfulStatuses,
+              exitStatus: result.exitStatus,
+              passed
+            },
+            now()
+          );
+          deterministicOutcome = passed ? { kind: "success" } : {
+            kind: "check-fail",
+            message: `Check node ${node.id} failed with exit status ${result.exitStatus}${detailSuffix}`,
+            onFail: node.run.onFail
+          };
+        } else if (!passed) {
           throw new Error(
-            `output does not match its consumed schema: ${validation.issues.join("; ")}`
+            `Function node ${node.id} exited with unsuccessful exit status ${result.exitStatus}${detailSuffix}`
           );
+        } else {
+          deterministicOutcome = { kind: "success" };
         }
+      } catch (error) {
+        deterministicOutcome = error instanceof NodeTimeoutError ? { kind: "failure", message: error.message } : {
+          kind: "failure",
+          message: `${deterministicKindLabel} node ${node.id} failed: ${error instanceof Error ? error.message : String(error)}`
+        };
+      }
+      if (this.s(handle).executionGeneration !== deterministicExecutionGeneration) break;
+      if (deterministicOutcome.kind === "success") {
         this.mutate(
           handle,
           (current) => {
             const execution = current.execution.nodes[node.id];
             assertLegal(execution, `node not in execution: ${node.id}`);
+            const completedAt = now();
+            const outputHistory = appendAttempt(
+              execution.outputHistory,
+              "complete",
+              execution.startedAt ?? completedAt,
+              completedAt,
+              capturedOutput,
+              void 0,
+              { check: checkEvidence }
+            );
             current.execution.nodes[node.id] = {
               ...execution,
               status: "complete",
-              completedAt: now(),
-              output: capturedOutput
+              completedAt,
+              output: capturedOutput,
+              outputHistory
             };
           },
           false
         );
-      } catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
+      } else if (deterministicOutcome.kind === "check-fail") {
+        const { message: failureMessage, onFail } = deterministicOutcome;
         this.mutate(
           handle,
           (current) => {
             const execution = current.execution.nodes[node.id];
             assertLegal(execution, `node not in execution: ${node.id}`);
-            const nodeError = {
-              message: `Function node ${node.id} failed: ${message}`,
-              recoverable: false,
-              at: now()
-            };
-            current.execution.nodes[node.id] = {
-              ...execution,
-              status: "failed",
-              completedAt: now(),
-              output: capturedOutput,
-              error: nodeError,
-              errorHistory: [...execution.errorHistory, nodeError]
-            };
+            assertLegal(checkEvidence, `check node ${node.id} completed without evidence`);
+            const completedAt = now();
+            const { retry, patch } = this.planAutomaticRetry(
+              node,
+              execution,
+              failureMessage,
+              completedAt,
+              capturedOutput,
+              void 0,
+              checkEvidence
+            );
+            if (retry) {
+              current.execution.nodes[node.id] = {
+                ...execution,
+                ...patch,
+                status: "available",
+                error: void 0
+              };
+            } else if (onFail === "fail") {
+              current.execution.nodes[node.id] = {
+                ...execution,
+                ...patch,
+                status: "failed",
+                completedAt
+              };
+            } else {
+              const provenanceNote = checkEvidence.provenance ? ` (${checkEvidence.provenance})` : "";
+              const approval = {
+                requestedAt: now(),
+                summary: `Check node ${node.id} failed with exit status ${checkEvidence.exitStatus}${provenanceNote}.`
+              };
+              current.execution.nodes[node.id] = {
+                ...execution,
+                ...patch,
+                status: "awaiting_approval",
+                approval,
+                approvalHistory: [...execution.approvalHistory, approval]
+              };
+            }
+          },
+          false
+        );
+      } else {
+        const failureMessage = deterministicOutcome.message;
+        this.mutate(
+          handle,
+          (current) => {
+            const execution = current.execution.nodes[node.id];
+            assertLegal(execution, `node not in execution: ${node.id}`);
+            const completedAt = now();
+            const { retry, patch } = this.planAutomaticRetry(
+              node,
+              execution,
+              failureMessage,
+              completedAt,
+              capturedOutput
+            );
+            current.execution.nodes[node.id] = retry ? { ...execution, ...patch, status: "available", error: void 0 } : { ...execution, ...patch, status: "failed", completedAt };
           },
           false
         );
@@ -8955,6 +9202,7 @@ var FlowAdapter = class extends AbstractConnector {
         s.lastSignaledExecution = s.execution;
       }
     }
+    this.rearmWakeTimer(handle);
     return typeof result === "string" ? result : JSON.stringify({ ok: true });
   }
   /**
@@ -9000,6 +9248,181 @@ var FlowAdapter = class extends AbstractConnector {
       done: computed.done && flowStatus === "complete"
     };
   }
+  // ── Agent-node deadline wake timer ────────────────────────────────────────
+  //
+  // Agent nodes have no `await` the adapter can wrap — it marks the node
+  // started and waits for the model to call `complete_node`, which may never
+  // come. The derived deadline (see `engine/node-deadline.ts`) is the source
+  // of truth: it is a pure function of `startedAt` + `approvalHistory` +
+  // `inputHistory`, so it is correct on its own after `hydrate()` or a
+  // reconnect with no timer required. This wake timer exists only so a
+  // genuinely hung run — by definition nothing else happening — still gets
+  // *some* event that triggers a re-evaluation of that deadline.
+  clearWakeTimer(s) {
+    if (s.wakeTimer !== null) {
+      clearTimeout(s.wakeTimer);
+      s.wakeTimer = null;
+    }
+  }
+  /**
+   * Whether `execution` counts as "actively running" for `control.timeoutSec`
+   * evaluation. Ordinarily this is just `status === "running"`. The one
+   * exception: a non-gate agent node whose approval was just decided
+   * `approved` stays at `awaiting_approval` — `applyApproval` deliberately
+   * does not restore `running` there, because `doCompleteNode`'s
+   * `approvedPrior` check requires exactly that status (a mandatory-approval
+   * node has no `runningAutonomous` fallback). Without this second clause the
+   * timeout would pause for the approval wait (correctly, via
+   * `remainingActiveExecutionMs` reading the now-resolved `approvalHistory`
+   * entry) and then never resume, since nothing re-evaluates a node that
+   * never looks "running" again.
+   */
+  isDeadlineEligible(execution) {
+    if (execution.status === "running") return true;
+    return execution.status === "awaiting_approval" && execution.approval?.decision === "approved";
+  }
+  /**
+   * Recomputes the pending wake timer against the current state: cancels any
+   * previously-armed timer, then arms a fresh one for the earliest deadline
+   * among currently `running` agent nodes with a `control.timeoutSec`. A
+   * no-op when nothing is running against a timeout, or the flow is already
+   * terminal. Called after every {@link mutate}, plus `connect()` and
+   * `hydrate()` (which bypass `mutate()`).
+   *
+   * `disconnect()` clears the timer and bumps `executionGeneration`, but a
+   * `mutate()` already in flight (or one that lands after teardown for any
+   * other reason) still calls this on its way out — bail here on
+   * `handle.status` so a post-disconnect mutation can never re-arm a timer
+   * that would fire against a handle nothing is watching anymore.
+   */
+  rearmWakeTimer(handle) {
+    const s = this.s(handle);
+    this.clearWakeTimer(s);
+    if (handle.status === "disconnected") return;
+    if (s.execution.done || s.execution.status === "failed" || s.execution.status === "cancelled") {
+      return;
+    }
+    const nowMs = Date.now();
+    let earliestRemainingMs;
+    for (const node of s.flowDef.nodes) {
+      if (!isAgentNode(node)) continue;
+      const timeoutSec = node.control?.timeoutSec;
+      if (timeoutSec === void 0) continue;
+      const execution = s.execution.nodes[node.id];
+      if (!execution || !this.isDeadlineEligible(execution)) continue;
+      const remaining = remainingActiveExecutionMs(execution, timeoutSec, nowMs);
+      if (remaining === void 0) continue;
+      if (earliestRemainingMs === void 0 || remaining < earliestRemainingMs) {
+        earliestRemainingMs = remaining;
+      }
+    }
+    if (earliestRemainingMs === void 0) return;
+    const delayMs = Math.max(0, earliestRemainingMs);
+    const timer = setTimeout(() => {
+      s.wakeTimer = null;
+      void this.evaluateAgentNodeDeadlines(handle);
+    }, delayMs);
+    timer.unref?.();
+    s.wakeTimer = timer;
+  }
+  /**
+   * Re-checks every `running` agent node's derived deadline and, for any that
+   * have expired, either auto-retries (bounded by `control.retries`, composing
+   * with the existing `doFailNode(recoverable: true)` and `retryNode`
+   * pathways) or terminally fails the node. Safe to call at any time — the
+   * derived deadline means this is a no-op unless something has actually
+   * expired. Goes through {@link mutate}, so a state change here republishes
+   * `onChange`/stimulus exactly like any other mutation, waking a fresh turn
+   * when the node retries or the flow rolls up to `failed`.
+   */
+  async evaluateAgentNodeDeadlines(handle) {
+    const s = this.s(handle);
+    const nowMs = Date.now();
+    const expired = s.flowDef.nodes.filter((node) => {
+      if (!isAgentNode(node)) return false;
+      const timeoutSec = node.control?.timeoutSec;
+      if (timeoutSec === void 0) return false;
+      const execution = s.execution.nodes[node.id];
+      if (!execution || !this.isDeadlineEligible(execution)) return false;
+      const remaining = remainingActiveExecutionMs(execution, timeoutSec, nowMs);
+      return remaining !== void 0 && remaining <= 0;
+    });
+    for (const node of expired) {
+      this.mutate(
+        handle,
+        (current) => {
+          const execution = current.execution.nodes[node.id];
+          if (!execution || !this.isDeadlineEligible(execution)) return;
+          const completedAt = now();
+          const message = `Agent node ${node.id} timed out after ${node.control?.timeoutSec}s`;
+          const { retry, patch } = this.planAutomaticRetry(
+            node,
+            execution,
+            message,
+            completedAt,
+            execution.output
+          );
+          current.execution.nodes[node.id] = retry ? { ...execution, ...patch, status: "available", error: void 0 } : { ...execution, ...patch, status: "failed", completedAt };
+        },
+        true
+      );
+    }
+  }
+  /**
+   * Records one failed attempt on `nodeId`'s execution and decides whether
+   * the automatic bounded retry (`control.retries`) still has budget. Shared
+   * by every automatic-failure seam (agent-node timeout, function/check
+   * execution/timeout failure, sub-flow execution/timeout failure, and a
+   * check's fail verdict) so the budget — derived from prior `'failed'`
+   * entries in `outputHistory`, not a separate durable counter — is computed
+   * once, the same way, everywhere.
+   *
+   * Returns the `NodeExecution` patch (error/errorHistory/outputHistory/
+   * output) plus whether budget remains; the caller decides the resulting
+   * `status` because that differs by kind (e.g. sub-flow degrades an
+   * optional node's exhausted failure to `skipped`; agent/function do not,
+   * preserving their existing behavior). A terminal failure whose node has
+   * any `control.retries` configured carries `recoverable: true` so the
+   * manual `retryNode` operator override — which sits outside this budget
+   * entirely — remains usable once the automatic budget runs out.
+   *
+   * @param sourceErrorAtIso - The failure's own timestamp, when the caller has
+   *   one more precise than `completedAtIso` (e.g. a sub-flow child reports
+   *   its own `error.at`, which can predate this node's parent-side
+   *   `completedAt` by however long the result took to propagate). Defaults
+   *   to `completedAtIso` for callers (agent-timeout, function-node) whose
+   *   failure message is synthesized at the moment of detection.
+   * @param checkEvidence - Derived evidence for a check's fail verdict, so it
+   *   rides on the same appended attempt as the failure it explains.
+   */
+  planAutomaticRetry(node, execution, message, completedAtIso, capturedOutput, sourceErrorAtIso, checkEvidence) {
+    const retries = node.control?.retries;
+    const priorFailures = countFailedAttempts(execution.outputHistory);
+    const retry = hasAutomaticRetryBudget(priorFailures, retries);
+    const error = {
+      message,
+      recoverable: !retry && !!retries,
+      at: sourceErrorAtIso ?? completedAtIso
+    };
+    const outputHistory = appendAttempt(
+      execution.outputHistory,
+      "failed",
+      execution.startedAt ?? completedAtIso,
+      completedAtIso,
+      capturedOutput,
+      error,
+      { check: checkEvidence }
+    );
+    return {
+      retry,
+      patch: {
+        error,
+        errorHistory: [...execution.errorHistory, error],
+        outputHistory,
+        output: capturedOutput ?? execution.output
+      }
+    };
+  }
   /**
    * Build the selected agent node's complete turn briefing plus upstream context.
    */
@@ -9087,7 +9510,8 @@ function routerSelectionHandoffSummary(router, execution) {
   if (!selection) return void 0;
   return selection.selectedTarget === null ? "Router completed without selecting a target." : `Router selected ${selection.selectedTarget}.`;
 }
-function functionNodeOutput(node, result) {
+function deterministicNodeOutput(node, result, passed) {
+  const kindLabel = deterministicNodeKindLabel(node.run.kind);
   const capturedFields = [];
   for (const channel of ["stdout", "stderr"]) {
     const destination = node.run.capture?.[channel];
@@ -9095,14 +9519,15 @@ function functionNodeOutput(node, result) {
     const match = /^fields\.([^.]+)$/.exec(destination);
     if (!match?.[1]) {
       throw new Error(
-        `Function node ${node.id} run.capture.${channel} destination "${destination}" is invalid; expected fields.<name>`
+        `${kindLabel} node ${node.id} run.capture.${channel} destination "${destination}" is invalid; expected fields.<name>`
       );
     }
     capturedFields.push([match[1], result[channel]]);
   }
   const fields = Object.fromEntries(capturedFields);
+  const summary = node.run.kind === "check" ? `Check node ${node.id} ${passed ? "passed" : "failed"} with exit status ${result.exitStatus}.` : `Function node ${node.id} exited with status ${result.exitStatus}.`;
   return {
-    summary: `Function node ${node.id} exited with status ${result.exitStatus}.`,
+    summary,
     artifacts: [],
     ...Object.keys(fields).length > 0 ? { fields } : {}
   };
@@ -9176,5 +9601,5 @@ function createConnector() {
 }
 
 export { AbstractConnector, BUILTIN_CONNECTOR_CATALOG, BoxConnector, ConnectorFieldMissingError, ConnectorManager, ConnectorStartupError, DeployConnector, DevServerConnector, FlowAdapter, GitConnector, GmailConnector, GoogleDriveConnector, LocalConnector, LogBuffer, ManagedGitconfigCollisionError, MattermostConnector, MemoryConnector, MinIOConnector, PortPool, PostgresConnector, S3Connector, SQLiteConnector, SessionInlineSubFlowRunner, SessionNodeExecutor, SharePointConnector, StaticServerConnector, TunnelConnector, WebDAVConnector, XStateConnector, XStateStoreConnector, __test, atomicReplaceCredential, buildConnectorPromptSection, buildSdkConnectorTools, buildSdkFlowTools, createConnector, createConnector10, createConnector11, createConnector12, createConnector13, createConnector14, createConnector15, createConnector16, createConnector17, createConnector18, createConnector19, createConnector2, createConnector20, createConnector3, createConnector4, createConnector5, createConnector6, createConnector7, createConnector8, createConnector9, createFsWatcher, createWorktree, defaultSpawn, ensureDirMode, ensureFleetMounted, findGitRoot, findMissingPackages, getConnector, installNpmPackages, isFleetManaged, isPackageResolvable, listConnectors, listWorktrees, readGitSyncStatus, registerBuiltinConnectors, removeMountBlock, renderCredentialHelperScript, tryGetConnector, worktreeRegistry, writeHelperScript, writeMountBlock };
-//# sourceMappingURL=chunk-HVQWLYZB.js.map
-//# sourceMappingURL=chunk-HVQWLYZB.js.map
+//# sourceMappingURL=chunk-E5VGAW4E.js.map
+//# sourceMappingURL=chunk-E5VGAW4E.js.map