@skaile/workspaces 2.5.0 → 2.6.0

package/dist/{chunk-EEHOMCRU.js → chunk-LX7OUTU2.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, interpolateNodeInstruction } from './chunk-4O2RAXKJ.js';
-import { parseFlowDefinition } from './chunk-OEGHKO5N.js';
-import { renderStimulusPrompt } from './chunk-FKBQRV4J.js';
-import { flowDefaults, isAgentNode, isGateNode, nodeRequiresApproval, isSubFlowNode, isFunctionNode, nodeIsOptional, isActiveRuntimeNode, nodeLabel, nodeInstruction, nodeAssets } from './chunk-4QROZZ5Z.js';
+import { getConsumedOutputSchema, validateConsumedNodeOutput, resolveNodeBindings, computeFlowStateFromSnapshots, availableRouterFrontier, evaluateRouterSelection, routerSelectionOutput, planRouterSkips, unsettledRouterBranchIds, interpolateNodeInstruction, persistedRouterSelection } from './chunk-J7K6K5DH.js';
+import { parseFlowDefinition } from './chunk-MNPDB7WD.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 { portableSpawn } from './chunk-P43HBWKK.js';
 import { withFsDeadline, tryWithFsDeadline, FsDeadlineError, fsDeadlineMs } from './chunk-DYMWJAL4.js';
 import { createLogger } from './chunk-7GOCNYUV.js';
@@ -7566,6 +7566,10 @@ function prepareExecutionSnapshot(flowDef, execution) {
   const snapshot = cloned.data;
   for (const [nodeId, node] of Object.entries(snapshot.nodes ?? {})) {
     if (node.status !== "complete") continue;
+    const definitionNode = flowDef.nodes.find(({ id }) => id === nodeId);
+    if (definitionNode && isRouterNode(definitionNode) && !persistedRouterSelection(definitionNode, node)) {
+      throw new Error(`FlowAdapter: invalid execution output for router node ${nodeId}`);
+    }
     const validation = validateConsumedNodeOutput(flowDef, nodeId, node.output?.fields);
     if (!validation.valid) {
       throw new Error(
@@ -8575,7 +8579,8 @@ var FlowAdapter = class extends AbstractConnector {
   }
   /**
    * Drain runtime-owned nodes in definition order until only agent work or a human decision
-   * remains. Function nodes use NodeExecutor, gates park, and sub-flows delegate to the host.
+   * remains. Routers select branches, function nodes use NodeExecutor, gates park, and sub-flows
+   * delegate to the host.
    */
   async drainRuntimeNodes(handle) {
     return this.drainAvailableRuntimeNodes(handle, true);
@@ -8588,17 +8593,18 @@ var FlowAdapter = class extends AbstractConnector {
   async executeAvailableFunctionNodes(handle) {
     return this.drainAvailableRuntimeNodes(handle, false);
   }
-  async drainAvailableRuntimeNodes(handle, includeGates) {
+  async drainAvailableRuntimeNodes(handle, includeRoutersAndGates) {
     const advancedSubFlows = /* @__PURE__ */ new Set();
     while (true) {
       const state = this.s(handle);
       if (state.execution.status === "cancelled" || state.execution.status === "failed") break;
+      if (includeRoutersAndGates && this.settleAvailableRouters(handle)) continue;
       const node = state.flowDef.nodes.find((candidate) => {
         const status = state.execution.nodes[candidate.id]?.status;
         if (isSubFlowNode(candidate) && !advancedSubFlows.has(candidate.id) && (status === "available" || status === "running")) {
           return true;
         }
-        return (isFunctionNode(candidate) || includeGates && isGateNode(candidate)) && status === "available";
+        return (isFunctionNode(candidate) || includeRoutersAndGates && isGateNode(candidate)) && status === "available";
       });
       if (!node) break;
       if (isGateNode(node)) {
@@ -8812,6 +8818,110 @@ var FlowAdapter = class extends AbstractConnector {
     return this.getExecution(handle);
   }
   // ── Private helpers ──
+  /** Settle one decidable router per source ownership component before runtime side effects. */
+  settleAvailableRouters(handle) {
+    const state = this.s(handle);
+    const snapshots = snapshotMap(state.execution);
+    const settlements = [];
+    const availableRouterSnapshots = new Map(snapshots);
+    const computed = computeFlowStateFromSnapshots(state.flowDef, snapshots);
+    for (const nodeId of computed.available) {
+      const execution = availableRouterSnapshots.get(nodeId);
+      if (execution && execution.status !== "available") {
+        availableRouterSnapshots.set(nodeId, { ...execution, status: "available" });
+      }
+    }
+    const frontier = availableRouterFrontier(state.flowDef, availableRouterSnapshots);
+    for (const node of frontier) {
+      const resolution = evaluateRouterSelection(state.flowDef, node, snapshots);
+      if ("unresolved" in resolution) continue;
+      settlements.push({ routerNodeId: node.id, selectedTarget: resolution.selectedTarget });
+    }
+    if (settlements.length === 0) return false;
+    const preparedSettlements = settlements.map((settlement) => {
+      const output = routerSelectionOutput(settlement.selectedTarget);
+      return {
+        settlement,
+        output,
+        validation: validateConsumedNodeOutput(
+          state.flowDef,
+          settlement.routerNodeId,
+          output.fields
+        )
+      };
+    });
+    const validSettlements = preparedSettlements.flatMap(
+      ({ settlement, validation }) => validation.valid ? [settlement] : []
+    );
+    const settlementPlan = [...validSettlements];
+    let skippedNodeIds = [];
+    if (settlementPlan.length > 0) {
+      while (true) {
+        skippedNodeIds = planRouterSkips(state.flowDef, snapshots, settlementPlan);
+        const settledIds = new Set(settlementPlan.map(({ routerNodeId }) => routerNodeId));
+        const losingRouters = skippedNodeIds.flatMap((nodeId) => {
+          const node = state.flowDef.nodes.find(({ id }) => id === nodeId);
+          return node && isRouterNode(node) && !settledIds.has(node.id) ? [node] : [];
+        });
+        if (losingRouters.length === 0) break;
+        settlementPlan.push(
+          ...losingRouters.map(({ id }) => ({ routerNodeId: id, selectedTarget: null }))
+        );
+      }
+    }
+    const settledAt = now();
+    this.mutate(
+      handle,
+      (current) => {
+        for (const prepared of preparedSettlements) {
+          const { settlement, output, validation } = prepared;
+          const execution = current.execution.nodes[settlement.routerNodeId];
+          assertLegal(execution, `node not in execution: ${settlement.routerNodeId}`);
+          assertLegal(
+            execution.status === "available",
+            `cannot resolve router node ${settlement.routerNodeId}: status is ${execution.status}`
+          );
+          if (!validation.valid) {
+            const error = {
+              message: `Router node ${settlement.routerNodeId} failed: output does not match its consumed schema: ${validation.issues.join("; ")}`,
+              recoverable: false,
+              at: settledAt
+            };
+            current.execution.nodes[settlement.routerNodeId] = {
+              ...execution,
+              status: "failed",
+              startedAt: execution.startedAt ?? settledAt,
+              completedAt: settledAt,
+              output,
+              error,
+              errorHistory: [...execution.errorHistory, error]
+            };
+            continue;
+          }
+          current.execution.nodes[settlement.routerNodeId] = {
+            ...execution,
+            status: "complete",
+            startedAt: execution.startedAt ?? settledAt,
+            completedAt: settledAt,
+            output
+          };
+        }
+        for (const skippedNodeId of skippedNodeIds) {
+          const execution = current.execution.nodes[skippedNodeId];
+          if (!execution || execution.status !== "not_started" && execution.status !== "available") {
+            continue;
+          }
+          current.execution.nodes[skippedNodeId] = {
+            ...execution,
+            status: "skipped",
+            completedAt: settledAt
+          };
+        }
+      },
+      false
+    );
+    return true;
+  }
   s(handle) {
     return handle.state;
   }
@@ -8855,13 +8965,15 @@ var FlowAdapter = class extends AbstractConnector {
   recompute(s) {
     const snapshots = snapshotMap(s.execution);
     const computed = computeFlowStateFromSnapshots(s.flowDef, snapshots);
+    const routerGatedNodes = unsettledRouterBranchIds(s.flowDef, snapshots);
     const nodes = nodeExecutionRecord(Object.entries(s.execution.nodes));
     for (const ns of computed.nodes) {
       const existing = nodes[ns.nodeId];
       if (!existing) continue;
       if (existing.status === "not_started" || existing.status === "available") {
+        const definitionNode = s.flowDef.nodes.find(({ id }) => id === ns.nodeId);
         const hasFailedPreconditions = (ns.failedPreconditions?.length ?? 0) > 0;
-        const status = existing.status === "available" && ns.status === "not_started" && !hasFailedPreconditions ? "available" : ns.status;
+        const status = existing.status === "available" && ns.status === "not_started" && !hasFailedPreconditions && !routerGatedNodes.has(ns.nodeId) && !(definitionNode && isRouterNode(definitionNode)) ? "available" : ns.status;
         nodes[ns.nodeId] = {
           ...existing,
           status,
@@ -8955,8 +9067,9 @@ Artifacts: ${output.artifacts.map((a) => a.uri).join(", ")}` : "";
 Concerns: ${output.concerns.join("; ")}` : "";
       const predecessor = s.flowDef.nodes.find((n) => n.id === depId);
       const label = predecessor ? nodeLabel(predecessor) : depId;
+      const summary = predecessor && isRouterNode(predecessor) ? routerSelectionHandoffSummary(predecessor, exec) ?? output.summary : output.summary;
       handoff.push(`### ${label} (${exec?.status})
-${output.summary}${artifacts}${concerns}`);
+${summary}${artifacts}${concerns}`);
     }
     sections.push(
       `## Upstream handoff
@@ -8969,6 +9082,11 @@ ${handoff.length > 0 ? handoff.join("\n\n") : "(no prior context)"}`
 function flowPredecessors(flowDef, nodeId) {
   return flowDef.edges.filter((e) => e.target === nodeId && e.type === "flow").map((e) => e.source);
 }
+function routerSelectionHandoffSummary(router, execution) {
+  const selection = persistedRouterSelection(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) {
   const capturedFields = [];
   for (const channel of ["stdout", "stderr"]) {
@@ -9058,5 +9176,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-EEHOMCRU.js.map
-//# sourceMappingURL=chunk-EEHOMCRU.js.map
+//# sourceMappingURL=chunk-LX7OUTU2.js.map
+//# sourceMappingURL=chunk-LX7OUTU2.js.map