@skaile/workspaces 2.3.0 → 2.5.0

package/dist/{chunk-PTS3QN5P.js → chunk-EEHOMCRU.js}

@@ -1,16 +1,16 @@
 import { resolveAuthRef } from './chunk-ZNIHTT22.js';
 import { pluginRegistry } from './chunk-6E6PKKAD.js';
 import { computeStimulus } from './chunk-IFGTRL2I.js';
-import { computeFlowStateFromSnapshots } from './chunk-UQ3RJKDD.js';
-import { parseFlowDefinition } from './chunk-ZE2KEPE2.js';
-import { renderStimulusPrompt } from './chunk-FB4GPWYC.js';
-import { flowDefaults, nodeRequiresApproval, isAgentNode, nodeIsOptional, nodeLabel, nodeInstruction, nodeBindings, nodeAssets } from './chunk-DZM33LQO.js';
-import { portableSpawn } from './chunk-63ZPKREA.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 { portableSpawn } from './chunk-P43HBWKK.js';
 import { withFsDeadline, tryWithFsDeadline, FsDeadlineError, fsDeadlineMs } from './chunk-DYMWJAL4.js';
 import { createLogger } from './chunk-7GOCNYUV.js';
+import { resolve, relative, sep, isAbsolute, join, dirname } from 'path';
 import { mkdir, rename, writeFile, readFile, stat, cp, readdir, chmod, realpath } from 'fs/promises';
-import { join, dirname, resolve, sep, relative } from 'path';
-import * as zNS from 'zod';
+import * as z4 from 'zod';
 import { execFile } from 'child_process';
 import { promisify } from 'util';
 import { createReadStream, readFileSync, existsSync, mkdirSync, openSync, writeSync, closeSync, chmodSync, renameSync } from 'fs';
@@ -55,6 +55,326 @@ var AbstractConnector = class {
     };
   }
 };
+
+// factory-assets/connectors/flow/inline-sub-flow-host.ts
+var INLINE_SUB_FLOW_MAX_DEPTH = 16;
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function childDefinition(request, authored) {
+  const childRunInput = authored.defaults?.run_input;
+  const parentRunInput = request.parentFlow.defaults?.run_input;
+  const hasBoundInputs = Object.keys(request.inputs).length > 0;
+  const hasParentContext = request.passContext && parentRunInput !== void 0;
+  if (!hasBoundInputs && !hasParentContext) return authored;
+  let runInput;
+  if ((childRunInput === void 0 || isRecord(childRunInput)) && (!hasParentContext || isRecord(parentRunInput))) {
+    runInput = {
+      ...isRecord(childRunInput) ? childRunInput : {},
+      ...hasParentContext && isRecord(parentRunInput) ? parentRunInput : {},
+      ...request.inputs
+    };
+  } else if (hasBoundInputs) {
+    runInput = request.inputs;
+  } else {
+    runInput = parentRunInput;
+  }
+  return {
+    ...authored,
+    defaults: {
+      ...authored.defaults,
+      run_input: runInput
+    }
+  };
+}
+function terminalError(execution) {
+  const failed = Object.values(execution.nodes).find((node) => node.status === "failed");
+  if (failed?.error) return failed.error;
+  return {
+    message: `Inline child flow ${execution.flowId} ended with status ${execution.status}`,
+    recoverable: false,
+    at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function projection(session) {
+  const execution = session.adapter.getExecution(session.handle);
+  for (const definition of session.flow.nodes) {
+    const node = execution.nodes[definition.id];
+    if (node?.status === "awaiting_approval" && node.approval?.decision == null) {
+      return { status: "awaiting_approval", approval: structuredClone(node.approval) };
+    }
+    if (node?.status === "awaiting_input" && node.input?.providedAt == null) {
+      return { status: "awaiting_input", input: structuredClone(node.input) };
+    }
+  }
+  const approvals = Object.values(execution.nodes).flatMap((node) => node.approvalHistory).sort((left, right) => left.requestedAt.localeCompare(right.requestedAt));
+  const inputs = Object.values(execution.nodes).flatMap((node) => node.inputHistory).sort((left, right) => left.requestedAt.localeCompare(right.requestedAt));
+  return {
+    status: "running",
+    approval: approvals.at(-1) ? structuredClone(approvals.at(-1)) : void 0,
+    input: inputs.at(-1) ? structuredClone(inputs.at(-1)) : void 0
+  };
+}
+function currentInteractionNode(session, status) {
+  const execution = session.adapter.getExecution(session.handle);
+  const node = session.flow.nodes.find(
+    (definition) => execution.nodes[definition.id]?.status === status
+  );
+  if (!node) {
+    throw new Error(`Inline child ${session.flow.id} is not ${status.replaceAll("_", " ")}`);
+  }
+  return node.id;
+}
+var SessionInlineSubFlowRunner = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  sessions = /* @__PURE__ */ new Map();
+  sessionKey(request) {
+    return `${request.parentExecution.runId}\0${request.node.id}`;
+  }
+  async dispose(session) {
+    if (session.closed) return;
+    session.closed = true;
+    this.sessions.delete(session.key);
+    session.request.routeOperationsTo(void 0);
+    await session.adapter.disconnect(session.handle);
+  }
+  async cancel(session) {
+    if (session.closed) return;
+    try {
+      await session.adapter.executeOp(session.handle, "cancel", {});
+    } finally {
+      await this.dispose(session);
+    }
+  }
+  async createSession(request) {
+    if (request.ancestry.includes(request.flowId)) {
+      throw new Error(
+        `Inline sub-flow cycle detected: ${[...request.ancestry, request.flowId].join(" -> ")}`
+      );
+    }
+    if (request.ancestry.length >= INLINE_SUB_FLOW_MAX_DEPTH) {
+      throw new Error(
+        `Inline sub-flow depth exceeds ${INLINE_SUB_FLOW_MAX_DEPTH}: ${[
+          ...request.ancestry,
+          request.flowId
+        ].join(" -> ")}`
+      );
+    }
+    const authored = await this.options.resolveFlow(request.flowId);
+    if (request.ancestry.includes(authored.id)) {
+      throw new Error(
+        `Inline sub-flow cycle detected after resolving ${request.flowId}: ${[
+          ...request.ancestry,
+          authored.id
+        ].join(" -> ")}`
+      );
+    }
+    const flow = childDefinition(request, authored);
+    const adapter = new FlowAdapter();
+    const handle = await adapter.connect(
+      {
+        id: `flow:${request.parentExecution.runId}:${request.node.id}`,
+        driver: "flow",
+        access: "read-write",
+        options: {
+          flow,
+          flowInputOrigins: request.inputOrigins,
+          inlineSubFlowAncestry: [...request.ancestry, flow.id],
+          inlineSubFlowRunner: this,
+          nodeExecutor: this.options.nodeExecutor,
+          seed: {
+            runId: `${request.parentExecution.runId}:${request.node.id}`,
+            startedBy: request.parentExecution.startedBy,
+            autonomousMode: request.parentExecution.autonomousMode
+          }
+        }
+      },
+      {}
+    );
+    const key = this.sessionKey(request);
+    let session;
+    const target = {
+      parentNodeId: request.node.id,
+      isAgentTurnActive: () => session.agentTurnActive || adapter.hasActiveInlineAgentTurn(handle),
+      executeAgentOp: (operation, args) => adapter.executeOp(handle, operation, args),
+      applyParentApproval: async (args) => {
+        const nodeId = currentInteractionNode(session, "awaiting_approval");
+        await adapter.executeOp(handle, "applyApproval", { ...args, nodeId });
+        session.stimulus = {
+          kind: "approval_received",
+          nodeId,
+          decision: args.decision === "rejected" ? "rejected" : "approved",
+          feedback: typeof args.feedback === "string" ? args.feedback : void 0,
+          decidedBy: String(args.decidedBy ?? "")
+        };
+        return projection(session);
+      },
+      applyParentInput: async (args) => {
+        const nodeId = currentInteractionNode(session, "awaiting_input");
+        await adapter.executeOp(handle, "applyInput", { ...args, nodeId });
+        session.stimulus = {
+          kind: "input_received",
+          nodeId,
+          response: args.response,
+          providedBy: String(args.providedBy ?? "")
+        };
+        return projection(session);
+      },
+      cancel: () => this.cancel(session),
+      getExecution: () => adapter.getAgentExecution(handle),
+      getMandatoryAgentApprovalNodeIds: () => adapter.getMandatoryAgentApprovalNodeIds(handle)
+    };
+    session = {
+      key,
+      request,
+      adapter,
+      handle,
+      flow,
+      target,
+      stimulus: { kind: "flow_started" },
+      changeVersion: 0,
+      agentTurnActive: false,
+      closed: false
+    };
+    adapter.onStateChange(handle, () => {
+      session.changeVersion += 1;
+    });
+    this.sessions.set(key, session);
+    request.routeOperationsTo(target);
+    return session;
+  }
+  async run(request) {
+    const key = this.sessionKey(request);
+    const session = this.sessions.get(key) ?? await this.createSession(request);
+    session.request = request;
+    request.routeOperationsTo(session.target);
+    try {
+      while (!session.closed) {
+        await session.adapter.drainRuntimeNodes(session.handle);
+        const execution = session.adapter.getExecution(session.handle);
+        if (execution.done || execution.status === "complete") {
+          await this.dispose(session);
+          return {
+            status: "complete",
+            output: {
+              summary: `Inline child flow ${session.flow.id} completed`,
+              artifacts: []
+            }
+          };
+        }
+        if (execution.status === "failed" || execution.status === "cancelled") {
+          const error = terminalError(execution);
+          await this.dispose(session);
+          return { status: "failed", error };
+        }
+        if (session.adapter.shouldDriveAgentTurn(session.handle, session.stimulus)) {
+          const versionBeforeTurn = session.changeVersion;
+          session.agentTurnActive = true;
+          try {
+            await this.options.driveAgentTurn({
+              adapter: session.adapter,
+              handle: session.handle,
+              flow: session.flow,
+              execution,
+              stimulus: session.stimulus
+            });
+          } finally {
+            session.agentTurnActive = false;
+          }
+          if (session.closed) {
+            return { status: "failed", error: terminalError(execution) };
+          }
+          session.stimulus = { kind: "state_changed" };
+          if (session.changeVersion === versionBeforeTurn) {
+            return { status: "paused", projection: projection(session) };
+          }
+          continue;
+        }
+        return { status: "paused", projection: projection(session) };
+      }
+      return {
+        status: "failed",
+        error: {
+          message: `Inline child flow ${request.flowId} was cancelled`,
+          recoverable: false,
+          at: (/* @__PURE__ */ new Date()).toISOString()
+        }
+      };
+    } catch (error) {
+      try {
+        await this.dispose(session);
+      } catch {
+      }
+      throw error;
+    }
+  }
+};
+function stableJsonStringify(value) {
+  return JSON.stringify(value, (_key, nested) => {
+    if (nested === null || Array.isArray(nested) || typeof nested !== "object") return nested;
+    return Object.fromEntries(
+      Object.entries(nested).sort(([left], [right]) => {
+        if (left < right) return -1;
+        if (left > right) return 1;
+        return 0;
+      })
+    );
+  });
+}
+function serializeEnvironmentInput(name, value) {
+  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`);
+  }
+  return serialized;
+}
+function commandFor(node) {
+  switch (node.run.runtime ?? "shell") {
+    case "shell":
+      return ["sh", "-c", node.run.command];
+    case "node":
+      return ["node", "-e", node.run.command];
+    case "python":
+      return ["python3", "-c", node.run.command];
+  }
+}
+var SessionNodeExecutor = class {
+  workspaceDir;
+  /** Creates an executor scoped to one already-materialized session workspace. */
+  constructor(options) {
+    this.workspaceDir = resolve(options.workspaceDir);
+  }
+  /** Runs one function node process with session environment and binding overrides. */
+  async execute(request) {
+    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}`
+      );
+    }
+    const boundEnvironment = Object.fromEntries(
+      Object.entries(request.inputs).map(([name, value]) => [
+        name,
+        serializeEnvironmentInput(name, value)
+      ])
+    );
+    const process2 = portableSpawn(commandFor(request.node), {
+      cwd,
+      env: { ...globalThis.process.env, ...boundEnvironment }
+    });
+    const [stdout, stderr, exitStatus] = await Promise.all([
+      new Response(process2.stdout).text(),
+      new Response(process2.stderr).text(),
+      process2.exited
+    ]);
+    return { exitStatus, stdout, stderr };
+  }
+};
 var execFileAsync = promisify(execFile);
 var GIT_REV_PARSE_TIMEOUT_MS = 15e3;
 var DeployConnector = class extends AbstractConnector {
@@ -231,7 +551,7 @@ var DeployConnector = class extends AbstractConnector {
     }
   }
   _mockPush(state, opts) {
-    const record = {
+    const record2 = {
       id: opts.deploymentId,
       url: `https://mock.deploy.example.com/${opts.deploymentId}`,
       ref: opts.ref,
@@ -240,8 +560,8 @@ var DeployConnector = class extends AbstractConnector {
       deployedAt: (/* @__PURE__ */ new Date()).toISOString(),
       status: "live"
     };
-    state.deployments.set(opts.deploymentId, record);
-    return JSON.stringify({ deployment_id: record.id, url: record.url, ref: record.ref ?? null });
+    state.deployments.set(opts.deploymentId, record2);
+    return JSON.stringify({ deployment_id: record2.id, url: record2.url, ref: record2.ref ?? null });
   }
   _opStatus(state, args) {
     const id = args.deployment ? String(args.deployment) : void 0;
@@ -3126,7 +3446,7 @@ var MinIOConnector = class extends AbstractConnector {
     const { client, bucket } = handle.state;
     const entries = [];
     const stream = client.listObjects(bucket, path ?? "", recursive);
-    return new Promise((resolve5, reject) => {
+    return new Promise((resolve6, reject) => {
       stream.on("data", (obj) => {
         entries.push({
           name: obj.name,
@@ -3136,7 +3456,7 @@ var MinIOConnector = class extends AbstractConnector {
           modifiedAt: obj.lastModified
         });
       });
-      stream.on("end", () => resolve5(entries));
+      stream.on("end", () => resolve6(entries));
       stream.on("error", reject);
     });
   }
@@ -3144,9 +3464,9 @@ var MinIOConnector = class extends AbstractConnector {
     const { client, bucket } = handle.state;
     const chunks = [];
     const stream = await client.getObject(bucket, path);
-    return new Promise((resolve5, reject) => {
+    return new Promise((resolve6, reject) => {
       stream.on("data", (chunk) => chunks.push(chunk));
-      stream.on("end", () => resolve5({ data: Buffer.concat(chunks).toString() }));
+      stream.on("end", () => resolve6({ data: Buffer.concat(chunks).toString() }));
       stream.on("error", reject);
     });
   }
@@ -4414,7 +4734,7 @@ async function checkCliExists(cli) {
   }
 }
 async function spawnCloudflaredTunnel(port) {
-  return new Promise((resolve5, reject) => {
+  return new Promise((resolve6, reject) => {
     const proc = portableSpawn(["cloudflared", "tunnel", "--url", `http://localhost:${port}`]);
     const decoder = new TextDecoder();
     const reader = proc.stderr.getReader();
@@ -4425,7 +4745,7 @@ async function spawnCloudflaredTunnel(port) {
         const chunk = decoder.decode(value);
         const match = chunk.match(/https:\/\/[^\s"]+\.trycloudflare\.com/);
         if (match) {
-          resolve5({ url: match[0], process: proc });
+          resolve6({ url: match[0], process: proc });
           return;
         }
       }
@@ -5128,7 +5448,7 @@ function connectorTargetFromFactory(id, factory) {
     id,
     displayName: id,
     apiVersion: 1,
-    configSchema: zNS.unknown(),
+    configSchema: z4.unknown(),
     create: (_config, _ctx) => factory()
   };
 }
@@ -5425,7 +5745,7 @@ var ConnectorManager = class {
         id: driver,
         displayName: driver,
         apiVersion: 1,
-        configSchema: zNS.unknown(),
+        configSchema: z4.unknown(),
         create: () => connector
       });
     }
@@ -6083,7 +6403,7 @@ var ConnectorManager = class {
     return buildSkillBody(descriptor, ops, shellAccess);
   }
 };
-var zStatic = zNS.z ?? zNS.default ?? zNS;
+var zStatic = z4.z ?? z4.default ?? z4;
 async function buildSdkConnectorTools(manager, options) {
   const shellAccess = options?.shellAccess ?? true;
   let sdk = options?.sdk;
@@ -6094,7 +6414,7 @@ async function buildSdkConnectorTools(manager, options) {
       return null;
     }
   }
-  const z4 = options?.z ?? zStatic;
+  const z5 = options?.z ?? zStatic;
   const tools = [];
   tools.push({
     name: "connector_list",
@@ -6116,7 +6436,7 @@ async function buildSdkConnectorTools(manager, options) {
     name: "connector_load_skill",
     description: "Load full instructions for a specific connector into context. Returns a markdown document describing the connector and its available CLI commands.",
     inputSchema: {
-      connector_id: z4.string().describe("Connector ID (use connector_list to enumerate)")
+      connector_id: z5.string().describe("Connector ID (use connector_list to enumerate)")
     },
     handler: async ({ connector_id }) => {
       try {
@@ -6134,8 +6454,8 @@ async function buildSdkConnectorTools(manager, options) {
     name: "connector_read",
     description: 'Read content from a connector by path. For KV stores, path is the key. For databases, path is "table/pk".',
     inputSchema: {
-      connector_id: z4.string().describe("Connector ID"),
-      path: z4.string().describe("Path within the connector")
+      connector_id: z5.string().describe("Connector ID"),
+      path: z5.string().describe("Path within the connector")
     },
     handler: async ({ connector_id, path }) => {
       try {
@@ -6155,9 +6475,9 @@ async function buildSdkConnectorTools(manager, options) {
     name: "connector_write",
     description: "Write content to a connector at a path.",
     inputSchema: {
-      connector_id: z4.string().describe("Connector ID"),
-      path: z4.string().describe("Path within the connector"),
-      content: z4.string().describe("Content to write")
+      connector_id: z5.string().describe("Connector ID"),
+      path: z5.string().describe("Path within the connector"),
+      content: z5.string().describe("Content to write")
     },
     handler: async ({
       connector_id,
@@ -6179,9 +6499,9 @@ async function buildSdkConnectorTools(manager, options) {
     name: "connector_list_entries",
     description: "List entries in a connector (files, keys, rows, etc).",
     inputSchema: {
-      connector_id: z4.string().describe("Connector ID"),
-      path: z4.string().optional().describe("Path prefix or directory"),
-      recursive: z4.boolean().optional().describe("Include nested entries")
+      connector_id: z5.string().describe("Connector ID"),
+      path: z5.string().optional().describe("Path prefix or directory"),
+      recursive: z5.boolean().optional().describe("Include nested entries")
     },
     handler: async ({
       connector_id,
@@ -6203,8 +6523,8 @@ async function buildSdkConnectorTools(manager, options) {
     name: "connector_search",
     description: "Search within a connector for matching content.",
     inputSchema: {
-      connector_id: z4.string().describe("Connector ID"),
-      query: z4.string().describe("Search query")
+      connector_id: z5.string().describe("Connector ID"),
+      query: z5.string().describe("Search query")
     },
     handler: async ({ connector_id, query }) => {
       try {
@@ -6222,8 +6542,8 @@ async function buildSdkConnectorTools(manager, options) {
     name: "connector_delete",
     description: "Delete an entry from a connector.",
     inputSchema: {
-      connector_id: z4.string().describe("Connector ID"),
-      path: z4.string().describe("Path to delete")
+      connector_id: z5.string().describe("Connector ID"),
+      path: z5.string().describe("Path to delete")
     },
     handler: async ({ connector_id, path }) => {
       try {
@@ -6242,9 +6562,9 @@ async function buildSdkConnectorTools(manager, options) {
       name: "connector_exec",
       description: "Execute a custom connector operation by name. Use only when shell access is unavailable. Load the connector skill first to see available operations and their arguments.",
       inputSchema: {
-        connector_id: z4.string().describe("Connector ID"),
-        operation: z4.string().describe("Operation name (e.g. 'send_message', 'query')"),
-        args: z4.record(z4.unknown()).describe("Named arguments for the operation (without -- prefix)")
+        connector_id: z5.string().describe("Connector ID"),
+        operation: z5.string().describe("Operation name (e.g. 'send_message', 'query')"),
+        args: z5.record(z5.unknown()).describe("Named arguments for the operation (without -- prefix)")
       },
       handler: async ({
         connector_id,
@@ -6287,7 +6607,7 @@ async function buildSdkFlowTools(manager, connectorId, options) {
       return null;
     }
   }
-  const z4 = options?.z ?? zStatic;
+  const z5 = options?.z ?? zStatic;
   let ops;
   try {
     ops = manager.getOperations(connectorId);
@@ -6299,7 +6619,7 @@ async function buildSdkFlowTools(manager, connectorId, options) {
   const tools = agentOps.map((op) => ({
     name: op.name,
     description: op.description,
-    inputSchema: buildOperationInputSchema(op.args, z4),
+    inputSchema: buildOperationInputSchema(op.args, z5),
     handler: async (input) => {
       try {
         const result = await manager.executeOp(connectorId, op.name, input ?? {});
@@ -6314,22 +6634,22 @@ async function buildSdkFlowTools(manager, connectorId, options) {
   }));
   return sdk.createSdkMcpServer({ name: "skaile-flow", tools });
 }
-function buildOperationInputSchema(args, z4) {
+function buildOperationInputSchema(args, z5) {
   const shape = {};
   for (const arg of args) {
     let schema;
     switch (arg.type) {
       case "boolean":
-        schema = z4.boolean();
+        schema = z5.boolean();
         break;
       case "number":
-        schema = z4.number();
+        schema = z5.number();
         break;
       case "json":
-        schema = z4.union([z4.string(), z4.record(z4.unknown()), z4.array(z4.unknown())]);
+        schema = z5.json();
         break;
       default:
-        schema = z4.string();
+        schema = z5.string();
     }
     if (arg.description) schema = schema.describe(arg.description);
     if (!arg.required) schema = schema.optional();
@@ -6625,7 +6945,7 @@ async function ensureFleetMounted(dir, log, options) {
       return;
     } catch (err) {
       lastErr = err;
-      await new Promise((resolve5) => setTimeout(resolve5, pollIntervalMs));
+      await new Promise((resolve6) => setTimeout(resolve6, pollIntervalMs));
     }
   }
   throw new Error(
@@ -6922,19 +7242,19 @@ var PortPool = class _PortPool {
   }
   /** Quick TCP connect test — returns true if nothing is listening. */
   static isPortFree(port, host = "127.0.0.1") {
-    return new Promise((resolve5) => {
+    return new Promise((resolve6) => {
       const socket = createConnection({ port, host });
       socket.once("connect", () => {
         socket.destroy();
-        resolve5(false);
+        resolve6(false);
       });
       socket.once("error", () => {
         socket.destroy();
-        resolve5(true);
+        resolve6(true);
       });
       socket.setTimeout(500, () => {
         socket.destroy();
-        resolve5(true);
+        resolve6(true);
       });
     });
   }
@@ -7153,9 +7473,28 @@ async function listWorktrees(repoRoot) {
   if (current.path) trees.push(current);
   return trees;
 }
-
-// factory-assets/connectors/flow/adapter.ts
 var now = () => (/* @__PURE__ */ new Date()).toISOString();
+var AGENT_INLINE_OPERATIONS = /* @__PURE__ */ new Set([
+  "get_available",
+  "get_state",
+  "get_globals",
+  "build_handoff",
+  "validate_node",
+  "start_node",
+  "request_approval",
+  "request_input",
+  "complete_node",
+  "skip_node",
+  "fail_node"
+]);
+function mergeInteractionHistory(history, interaction) {
+  if (!interaction) return history;
+  const next = [...history];
+  const index = next.findIndex((entry) => entry.requestedAt === interaction.requestedAt);
+  if (index >= 0) next[index] = interaction;
+  else next.push(interaction);
+  return next;
+}
 function normalizeRuntimeFlow(authored) {
   const parsed = parseFlowDefinition(authored);
   if (parsed.ok) return parsed.data;
@@ -7171,10 +7510,15 @@ function emptyNode(nodeId) {
     errorHistory: []
   };
 }
+function nodeExecutionRecord(entries = []) {
+  const record2 = /* @__PURE__ */ Object.create(null);
+  for (const [nodeId, execution] of entries) record2[nodeId] = execution;
+  return record2;
+}
 function buildInitialExecution(flowDef, seed) {
-  const nodes = {};
+  const nodes = nodeExecutionRecord();
   for (const n of flowDef.nodes) {
-    if (isAgentNode(n)) {
+    if (isActiveRuntimeNode(n)) {
       nodes[n.id] = emptyNode(n.id);
     }
   }
@@ -7197,7 +7541,8 @@ function toSnapshot(exec) {
     approval: exec.approval,
     input: exec.input,
     output: exec.output,
-    error: exec.error
+    error: exec.error,
+    failedPreconditions: exec.failedPreconditions
   };
 }
 function snapshotMap(execution) {
@@ -7207,6 +7552,50 @@ function snapshotMap(execution) {
   }
   return map;
 }
+function prepareExecutionSnapshot(flowDef, execution) {
+  let json2;
+  try {
+    json2 = JSON.stringify(execution);
+  } catch {
+    throw new Error("FlowAdapter: execution snapshot must be a JSON object");
+  }
+  const cloned = z4.json().safeParse(JSON.parse(json2));
+  if (!cloned.success || typeof cloned.data !== "object" || Array.isArray(cloned.data)) {
+    throw new Error("FlowAdapter: execution snapshot must be a JSON object");
+  }
+  const snapshot = cloned.data;
+  for (const [nodeId, node] of Object.entries(snapshot.nodes ?? {})) {
+    if (node.status !== "complete") continue;
+    const validation = validateConsumedNodeOutput(flowDef, nodeId, node.output?.fields);
+    if (!validation.valid) {
+      throw new Error(
+        `FlowAdapter: invalid execution output for node ${nodeId}: ${validation.issues.join("; ")}`
+      );
+    }
+  }
+  const nodes = nodeExecutionRecord(Object.entries(snapshot.nodes ?? {}));
+  for (const node of flowDef.nodes) {
+    const existing = nodes[node.id];
+    if (isSubFlowNode(node) && existing && ["running", "awaiting_approval", "awaiting_input"].includes(existing.status)) {
+      nodes[node.id] = {
+        ...existing,
+        status: "not_started",
+        startedAt: void 0,
+        completedAt: void 0,
+        output: void 0,
+        approval: void 0,
+        input: void 0,
+        error: void 0
+      };
+      continue;
+    }
+    if (isActiveRuntimeNode(node) && !Object.hasOwn(nodes, node.id)) {
+      nodes[node.id] = emptyNode(node.id);
+    }
+  }
+  snapshot.nodes = nodes;
+  return snapshot;
+}
 function assertLegal(cond, message) {
   if (!cond) throw new Error(`FlowAdapter: ${message}`);
 }
@@ -7218,7 +7607,7 @@ function findNode(flowDef, nodeId) {
 function isOptional(flowDef, nodeId) {
   return nodeIsOptional(findNode(flowDef, nodeId));
 }
-function isMandatoryGate(flowDef, nodeId) {
+function requiresAgentApproval(flowDef, nodeId) {
   return nodeRequiresApproval(findNode(flowDef, nodeId));
 }
 var FlowAdapter = class extends AbstractConnector {
@@ -7240,7 +7629,7 @@ var FlowAdapter = class extends AbstractConnector {
     const options = declaration.options ?? {};
     if (!options.flow) throw new Error("FlowAdapter requires options.flow (FlowDefinition)");
     const flowDef = normalizeRuntimeFlow(options.flow);
-    const execution = options.execution ?? buildInitialExecution(
+    const execution = options.execution ? prepareExecutionSnapshot(flowDef, options.execution) : buildInitialExecution(
       flowDef,
       options.seed ?? { runId: "local", startedBy: "system", autonomousMode: false }
     );
@@ -7249,14 +7638,46 @@ var FlowAdapter = class extends AbstractConnector {
       execution,
       stimulusBus: options.stimulusBus,
       connectorId: declaration.id,
-      useBusForStimulus: options.useBusForStimulus ?? false
+      useBusForStimulus: options.useBusForStimulus ?? false,
+      nodeExecutor: options.nodeExecutor,
+      inlineSubFlowRunner: options.inlineSubFlowRunner,
+      inlineOperationTargets: /* @__PURE__ */ new Map(),
+      flowInputOrigins: options.flowInputOrigins,
+      inlineSubFlowAncestry: options.inlineSubFlowAncestry ?? [flowDef.id],
+      executionGeneration: 0
     };
     state.execution = this.recompute(state);
     return this.makeHandle(declaration, state);
   }
   async disconnect(handle) {
+    const state = this.s(handle);
+    state.executionGeneration += 1;
+    await this.cancelInlineTargets(state);
     handle.status = "disconnected";
   }
+  async cancelInlineTargets(s) {
+    const targets = [...s.inlineOperationTargets.values()];
+    s.inlineOperationTargets.clear();
+    for (const target of targets) await target.cancel();
+  }
+  projectInlineInteraction(handle, parentNodeId, projection2) {
+    this.mutate(
+      handle,
+      (s) => {
+        const node = s.execution.nodes[parentNodeId];
+        assertLegal(node, `inline projection: unknown parent node ${parentNodeId}`);
+        s.execution.nodes[parentNodeId] = {
+          ...node,
+          status: projection2.status,
+          approval: projection2.approval ?? node.approval,
+          approvalHistory: mergeInteractionHistory(node.approvalHistory, projection2.approval),
+          input: projection2.input ?? node.input,
+          inputHistory: mergeInteractionHistory(node.inputHistory, projection2.input)
+        };
+      },
+      false
+    );
+  }
   // ── State change subscription ──
   onStateChange(handle, cb) {
     this.s(handle).onChange = cb;
@@ -7264,13 +7685,21 @@ var FlowAdapter = class extends AbstractConnector {
   /**
    * Replace the current execution snapshot with a host-provided one.
    * Used on container rehydration via the extended `configure` command.
-   * Does NOT fire `onChange` — the host already has the state; we don't
-   * want to loop it back on startup.
+   * Publishes only when compatibility preparation changes the supplied snapshot,
+   * such as seeding a node kind activated after the snapshot was persisted.
    */
   hydrate(handle, execution) {
     const s = this.s(handle);
-    s.execution = { ...execution };
-    s.execution = this.recompute(s);
+    assertLegal(
+      s.inlineOperationTargets.size === 0,
+      "hydrate requires live inline children to be cancelled first"
+    );
+    const candidate = prepareExecutionSnapshot(s.flowDef, execution);
+    const prepared = this.recompute({ ...s, execution: candidate });
+    const changed = JSON.stringify(prepared) !== JSON.stringify(execution);
+    s.executionGeneration += 1;
+    s.execution = prepared;
+    if (changed && s.onChange) s.onChange(s.execution);
   }
   // ── Base operations (private — wired into tools face in constructor) ──
   async read(handle, path) {
@@ -7360,7 +7789,7 @@ var FlowAdapter = class extends AbstractConnector {
       ops.push(
         {
           name: "start_node",
-          description: "Mark an available node as running (records startedAt).",
+          description: "Mark an available agent node as running (records startedAt).",
           accessLevel: "write",
           args: [
             { name: "nodeId", description: "Node ID to start", type: "string", required: true }
@@ -7368,7 +7797,7 @@ var FlowAdapter = class extends AbstractConnector {
         },
         {
           name: "request_approval",
-          description: "Request human approval for a running node. Ends your turn \u2014 the runner yields until the user approves or rejects.",
+          description: "Request human approval for a running agent node, or replace a rejected first-class gate decision with a fresh pending request. Ends your turn \u2014 the runner yields until the user approves or rejects.",
           accessLevel: "write",
           args: [
             { name: "nodeId", description: "Node ID", type: "string", required: true },
@@ -7388,7 +7817,7 @@ var FlowAdapter = class extends AbstractConnector {
         },
         {
           name: "request_input",
-          description: "Request typed input from the user for a node. Ends your turn. Legal from `available`, `running`, or `awaiting_approval`.",
+          description: "Request typed input for an agent node. Ends your turn. Legal from `available`, `running`, or `awaiting_approval`; never legal for a first-class gate.",
           accessLevel: "write",
           args: [
             { name: "nodeId", description: "Node ID", type: "string", required: true },
@@ -7408,7 +7837,7 @@ var FlowAdapter = class extends AbstractConnector {
         },
         {
           name: "complete_node",
-          description: "Mark a node as complete with structured output. Requires `awaiting_approval` with an `approved` decision, OR `running` when autonomous mode is on. Mandatory approval gates always require the approved decision \u2014 autonomous mode cannot skip them.",
+          description: "Mark an agent node as complete with structured output. Consumed fields must match the declared output schema; an agent gets one corrective call before failure. Requires `awaiting_approval` with an `approved` decision, OR `running` when autonomous mode is on. Agent nodes with mandatory approval always require the approved decision. First-class gates complete directly through host approval and never use this operation.",
           accessLevel: "write",
           args: [
             { name: "nodeId", description: "Node ID to complete", type: "string", required: true },
@@ -7418,6 +7847,12 @@ var FlowAdapter = class extends AbstractConnector {
               type: "string",
               required: true
             },
+            {
+              name: "fields",
+              description: "Named JSON object consumed by downstream nodes.",
+              type: "json",
+              required: false
+            },
             {
               name: "artifacts",
               description: "JSON array of ArtifactRef objects produced by this node.",
@@ -7581,6 +8016,29 @@ var FlowAdapter = class extends AbstractConnector {
   }
   async executeOp(handle, operation, args) {
     const s = this.s(handle);
+    const agentTarget = [...s.inlineOperationTargets.values()].find(
+      (target) => target.isAgentTurnActive()
+    );
+    if (agentTarget && AGENT_INLINE_OPERATIONS.has(operation)) {
+      return agentTarget.executeAgentOp(operation, args);
+    }
+    if (operation === "applyApproval" || operation === "applyInput") {
+      const parentNodeId = String(args.nodeId ?? "");
+      const target = s.inlineOperationTargets.get(parentNodeId);
+      if (target) {
+        const projection2 = operation === "applyApproval" ? await target.applyParentApproval(args) : await target.applyParentInput(args);
+        this.projectInlineInteraction(handle, parentNodeId, projection2);
+        return JSON.stringify(s.execution);
+      }
+    }
+    if (operation === "cancel") {
+      await this.cancelInlineTargets(s);
+      this.cancel(handle);
+      return JSON.stringify(s.execution);
+    }
+    if (operation === "hydrate" || operation === "start") {
+      await this.cancelInlineTargets(s);
+    }
     switch (operation) {
       case "get_available":
         return this.opGetAvailable(s);
@@ -7613,8 +8071,7 @@ var FlowAdapter = class extends AbstractConnector {
       case "applyInput":
         return this.opApplyInput(handle, s, args);
       case "cancel":
-        this.cancel(handle);
-        return JSON.stringify(s.execution);
+        throw new Error("FlowAdapter: cancel routing invariant violated");
       case "setAutonomousMode":
         return this.opSetAutonomousMode(handle, s, args);
       case "retryNode":
@@ -7629,14 +8086,18 @@ var FlowAdapter = class extends AbstractConnector {
   }
   // ── executeOp branch handlers (private dispatch helpers) ─────────────────
   opGetAvailable(s) {
+    const agentNodeIds = new Set(s.flowDef.nodes.filter(isAgentNode).map((node) => node.id));
     const nodes = Object.values(s.execution.nodes);
-    const available = nodes.filter((n) => n.status === "available").map((n) => n.id);
+    const available = nodes.filter((n) => agentNodeIds.has(n.id) && n.status === "available").map((n) => n.id);
     return JSON.stringify(available);
   }
   opValidateNode(s, args) {
     const nodeId = String(args.nodeId ?? "");
     const node = s.execution.nodes[nodeId];
     if (!node) return JSON.stringify({ valid: false, reason: "Node not found" });
+    if (!isAgentNode(findNode(s.flowDef, nodeId))) {
+      return JSON.stringify({ valid: false, reason: "Node is not an active agent node" });
+    }
     const predsMet = flowPredecessors(s.flowDef, nodeId).every((pid) => {
       const predStatus = s.execution.nodes[pid]?.status ?? "not_started";
       return predStatus === "complete" || predStatus === "skipped";
@@ -7644,7 +8105,8 @@ var FlowAdapter = class extends AbstractConnector {
     return JSON.stringify({
       valid: node.status === "available",
       status: node.status,
-      predecessorsReady: predsMet
+      predecessorsReady: predsMet,
+      failedPreconditions: node.failedPreconditions ?? []
     });
   }
   opStartNode(handle, args) {
@@ -7665,12 +8127,14 @@ var FlowAdapter = class extends AbstractConnector {
   }
   opCompleteNode(handle, args) {
     const nodeId = String(args.nodeId ?? "");
+    const parsedFields = args.fields === void 0 ? { issues: [] } : safeParseFields(args.fields);
     const output = {
       summary: String(args.summary ?? "Completed"),
       artifacts: safeParseArtifacts(args.artifacts),
-      concerns: safeParseStringArray(args.concerns)
+      concerns: safeParseStringArray(args.concerns),
+      ...parsedFields.fields ? { fields: parsedFields.fields } : {}
     };
-    return this.doCompleteNode(handle, nodeId, output);
+    return this.doCompleteNode(handle, nodeId, output, parsedFields.issues);
   }
   opSkipNode(handle, args) {
     const nodeId = String(args.nodeId ?? "");
@@ -7727,6 +8191,7 @@ var FlowAdapter = class extends AbstractConnector {
       throw new Error("FlowAdapter: start requires args.seed.runId + args.seed.startedBy");
     }
     s.flowDef = flow;
+    s.executionGeneration += 1;
     s.execution = buildInitialExecution(flow, {
       runId: seed.runId,
       startedBy: seed.startedBy,
@@ -7739,6 +8204,10 @@ var FlowAdapter = class extends AbstractConnector {
   // ── Agent-side mutations (tool calls) ─────────────────────────────────────
   doStartNode(handle, nodeId) {
     return this.mutate(handle, (s) => {
+      assertLegal(
+        isAgentNode(findNode(s.flowDef, nodeId)),
+        `node is not an active agent node: ${nodeId}`
+      );
       const node = s.execution.nodes[nodeId];
       assertLegal(node, `node not in execution: ${nodeId}`);
       assertLegal(node.status === "available", `cannot start ${nodeId}: status is ${node.status}`);
@@ -7752,11 +8221,17 @@ var FlowAdapter = class extends AbstractConnector {
   }
   doRequestApproval(handle, nodeId, summary, artifacts) {
     return this.mutate(handle, (s) => {
+      const definition = findNode(s.flowDef, nodeId);
       const node = s.execution.nodes[nodeId];
       assertLegal(node, `node not in execution: ${nodeId}`);
+      const rejectedGateRerequest = isGateNode(definition) && node.status === "awaiting_approval" && node.approval?.decision === "rejected";
+      assertLegal(
+        isAgentNode(definition) || rejectedGateRerequest,
+        `node is not an active agent node or rejected gate: ${nodeId}`
+      );
       assertLegal(
-        node.status === "running",
-        `request_approval requires running, got ${node.status}`
+        isAgentNode(definition) && node.status === "running" || rejectedGateRerequest,
+        `request_approval requires a running agent node or rejected gate, got ${node.status}`
       );
       const approval = { requestedAt: now(), summary };
       const history = [...node.approvalHistory, approval];
@@ -7774,6 +8249,10 @@ var FlowAdapter = class extends AbstractConnector {
   }
   doRequestInput(handle, nodeId, prompt, schema) {
     return this.mutate(handle, (s) => {
+      assertLegal(
+        isAgentNode(findNode(s.flowDef, nodeId)),
+        `node is not an active agent node: ${nodeId}`
+      );
       const node = s.execution.nodes[nodeId];
       assertLegal(node, `node not in execution: ${nodeId}`);
       assertLegal(
@@ -7796,20 +8275,64 @@ var FlowAdapter = class extends AbstractConnector {
       return JSON.stringify({ ok: true, status: "awaiting_input" });
     });
   }
-  doCompleteNode(handle, nodeId, output) {
-    return this.mutate(handle, (s) => {
-      const node = s.execution.nodes[nodeId];
-      assertLegal(node, `node not in execution: ${nodeId}`);
-      const autonomous = s.execution.autonomousMode;
-      const mandatory = isMandatoryGate(s.flowDef, nodeId);
-      const approvedPrior = node.status === "awaiting_approval" && node.approval?.decision === "approved";
-      const runningAutonomous = node.status === "running" && autonomous && !mandatory;
-      assertLegal(
-        approvedPrior || runningAutonomous,
-        mandatory && node.status === "running" ? `complete_node blocked: node ${nodeId} is a mandatory approval gate \u2014 call request_approval and wait for an approved decision (autonomous mode cannot skip it)` : `complete_node requires awaiting_approval+approved OR running+autonomous; node is ${node.status}${node.approval?.decision ? ` with approval ${node.approval.decision}` : ""}, autonomous=${autonomous}`
+  doCompleteNode(handle, nodeId, output, fieldIssues = []) {
+    const state = this.s(handle);
+    assertLegal(
+      isAgentNode(findNode(state.flowDef, nodeId)),
+      `node is not an active agent node: ${nodeId}`
+    );
+    const node = state.execution.nodes[nodeId];
+    assertLegal(node, `node not in execution: ${nodeId}`);
+    const autonomous = state.execution.autonomousMode;
+    const mandatory = requiresAgentApproval(state.flowDef, nodeId);
+    const approvedPrior = node.status === "awaiting_approval" && node.approval?.decision === "approved";
+    const runningAutonomous = node.status === "running" && autonomous && !mandatory;
+    assertLegal(
+      approvedPrior || runningAutonomous,
+      mandatory && node.status === "running" ? `complete_node blocked: node ${nodeId} is a mandatory approval gate \u2014 call request_approval and wait for an approved decision (autonomous mode cannot skip it)` : `complete_node requires awaiting_approval+approved OR running+autonomous; node is ${node.status}${node.approval?.decision ? ` with approval ${node.approval.decision}` : ""}, autonomous=${autonomous}`
+    );
+    const validation = fieldIssues.length > 0 && getConsumedOutputSchema(state.flowDef, nodeId) ? { valid: false, issues: fieldIssues } : validateConsumedNodeOutput(state.flowDef, nodeId, output.fields);
+    if (!validation.valid) {
+      const issueText = validation.issues.join("; ");
+      if (!node.outputCorrection) {
+        const correction = {
+          requestedAt: now(),
+          issues: validation.issues
+        };
+        this.mutate(handle, (current) => {
+          const execution = current.execution.nodes[nodeId];
+          assertLegal(execution, `node not in execution: ${nodeId}`);
+          current.execution.nodes[nodeId] = { ...execution, outputCorrection: correction };
+        });
+        throw new Error(
+          `FlowAdapter: output for node ${nodeId} does not match its consumed schema. Submit one corrected complete_node call. ${issueText}`
+        );
+      }
+      this.mutate(handle, (current) => {
+        const execution = current.execution.nodes[nodeId];
+        assertLegal(execution, `node not in execution: ${nodeId}`);
+        const error = {
+          message: `Node ${nodeId} output failed schema validation after one correction: ${issueText}`,
+          recoverable: false,
+          at: now()
+        };
+        current.execution.nodes[nodeId] = {
+          ...execution,
+          status: "failed",
+          completedAt: now(),
+          error,
+          errorHistory: [...execution.errorHistory, error]
+        };
+      });
+      throw new Error(
+        `FlowAdapter: node ${nodeId} failed after one output correction. ${issueText}`
       );
-      s.execution.nodes[nodeId] = {
-        ...node,
+    }
+    return this.mutate(handle, (current) => {
+      const execution = current.execution.nodes[nodeId];
+      assertLegal(execution, `node not in execution: ${nodeId}`);
+      current.execution.nodes[nodeId] = {
+        ...execution,
         status: "complete",
         completedAt: now(),
         output
@@ -7819,10 +8342,14 @@ var FlowAdapter = class extends AbstractConnector {
   }
   doSkipNode(handle, nodeId) {
     return this.mutate(handle, (s) => {
+      assertLegal(
+        isAgentNode(findNode(s.flowDef, nodeId)),
+        `node is not an active agent node: ${nodeId}`
+      );
       const node = s.execution.nodes[nodeId];
       assertLegal(node, `node not in execution: ${nodeId}`);
       assertLegal(
-        !isMandatoryGate(s.flowDef, nodeId),
+        !requiresAgentApproval(s.flowDef, nodeId),
         `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}`);
@@ -7836,6 +8363,10 @@ var FlowAdapter = class extends AbstractConnector {
   }
   doFailNode(handle, nodeId, message, recoverable) {
     return this.mutate(handle, (s) => {
+      assertLegal(
+        isAgentNode(findNode(s.flowDef, nodeId)),
+        `node is not an active agent node: ${nodeId}`
+      );
       const node = s.execution.nodes[nodeId];
       assertLegal(node, `node not in execution: ${nodeId}`);
       const error = { message, recoverable, at: now() };
@@ -7861,18 +8392,24 @@ var FlowAdapter = class extends AbstractConnector {
   // ── Host-side mutations (not exposed as agent tools) ─────────────────────
   /**
    * Record an approval decision on a node currently `awaiting_approval`.
-   * `approved` leaves the node in `awaiting_approval` — the agent
-   * transitions it to `complete` on the next turn. `rejected` drops the
-   * node back to `available` so the agent can retry.
+   * A first-class gate completes directly when approved and remains parked when rejected.
+   * Agent-node approvals keep their existing resume behavior.
    */
   applyApproval(handle, nodeId, decision, feedback, decidedBy) {
     this.mutate(handle, (s) => {
+      const definition = findNode(s.flowDef, nodeId);
       const node = s.execution.nodes[nodeId];
       assertLegal(node, `applyApproval: unknown node ${nodeId}`);
       assertLegal(
         node.status === "awaiting_approval",
         `applyApproval: node ${nodeId} is ${node.status}, not awaiting_approval`
       );
+      if (isGateNode(definition)) {
+        assertLegal(
+          node.approval?.decidedAt == null && node.approval?.decision == null,
+          `applyApproval: gate ${nodeId} approval attempt is already decided; request approval again before applying another decision`
+        );
+      }
       const base = node.approval ?? { requestedAt: now(), summary: "" };
       const approval = {
         ...base,
@@ -7884,7 +8421,22 @@ var FlowAdapter = class extends AbstractConnector {
       const history = [...node.approvalHistory];
       if (history.length > 0) history[history.length - 1] = approval;
       else history.push(approval);
-      if (decision === "approved") {
+      if (isGateNode(definition) && decision === "approved") {
+        s.execution.nodes[nodeId] = {
+          ...node,
+          status: "complete",
+          completedAt: now(),
+          approval,
+          approvalHistory: history
+        };
+      } else if (isGateNode(definition)) {
+        s.execution.nodes[nodeId] = {
+          ...node,
+          status: "awaiting_approval",
+          approval,
+          approvalHistory: history
+        };
+      } else if (decision === "approved") {
         s.execution.nodes[nodeId] = { ...node, approval, approvalHistory: history };
       } else {
         s.execution.nodes[nodeId] = {
@@ -7968,9 +8520,296 @@ var FlowAdapter = class extends AbstractConnector {
   getExecution(handle) {
     return this.s(handle).execution;
   }
-  /** Node IDs marked as mandatory approval gates in strict v2 or legacy definitions. */
+  /** @internal Whether a nested inline descendant owns the current agent turn. */
+  hasActiveInlineAgentTurn(handle) {
+    return [...this.s(handle).inlineOperationTargets.values()].some(
+      (target) => target.isAgentTurnActive()
+    );
+  }
+  /** Snapshot currently visible through agent-facing tools, including a live inline child. */
+  getAgentExecution(handle) {
+    const state = this.s(handle);
+    return [...state.inlineOperationTargets.values()].find((target) => target.isAgentTurnActive())?.getExecution() ?? state.execution;
+  }
+  /** Agent node IDs whose approval policy remains mandatory in autonomous mode. */
+  getMandatoryAgentApprovalNodeIds(handle) {
+    const state = this.s(handle);
+    const target = [...state.inlineOperationTargets.values()].find(
+      (candidate) => candidate.isAgentTurnActive()
+    );
+    if (target) return target.getMandatoryAgentApprovalNodeIds();
+    return state.flowDef.nodes.filter(nodeRequiresApproval).map((n) => n.id);
+  }
+  /** @deprecated Use {@link getMandatoryAgentApprovalNodeIds}. */
   getMandatoryGates(handle) {
-    return this.s(handle).flowDef.nodes.filter(nodeRequiresApproval).map((n) => n.id);
+    return this.getMandatoryAgentApprovalNodeIds(handle);
+  }
+  /**
+   * Decide whether the current state and stimulus require the session agent's conversation.
+   * Runtime-owned gates stay dark while pending; a rejected gate is the exception because the
+   * rejection starts the revision conversation promised by the gate lifecycle.
+   */
+  shouldDriveAgentTurn(handle, stimulus) {
+    const state = this.s(handle);
+    const execution = state.execution;
+    if (execution.done || execution.status === "failed" || execution.status === "cancelled") {
+      return false;
+    }
+    if (stimulus.kind === "user_message") return true;
+    for (const node of state.flowDef.nodes) {
+      const current = execution.nodes[node.id];
+      if (isGateNode(node) && current?.status === "awaiting_approval" && current.approval?.decision === "rejected") {
+        return true;
+      }
+    }
+    for (const node of state.flowDef.nodes) {
+      if (!isAgentNode(node)) continue;
+      const current = execution.nodes[node.id];
+      if (!current) continue;
+      if (current.status === "available" || current.status === "running") return true;
+      if (current.status === "awaiting_approval" && current.approval?.decision === "approved") {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * 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.
+   */
+  async drainRuntimeNodes(handle) {
+    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.
+   */
+  async executeAvailableFunctionNodes(handle) {
+    return this.drainAvailableRuntimeNodes(handle, false);
+  }
+  async drainAvailableRuntimeNodes(handle, includeGates) {
+    const advancedSubFlows = /* @__PURE__ */ new Set();
+    while (true) {
+      const state = this.s(handle);
+      if (state.execution.status === "cancelled" || state.execution.status === "failed") break;
+      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";
+      });
+      if (!node) break;
+      if (isGateNode(node)) {
+        this.mutate(
+          handle,
+          (current) => {
+            const execution = current.execution.nodes[node.id];
+            assertLegal(execution, `node not in execution: ${node.id}`);
+            assertLegal(
+              execution.status === "available",
+              `cannot park gate node ${node.id}: status is ${execution.status}`
+            );
+            const approval = { requestedAt: now(), summary: node.run.prompt };
+            current.execution.nodes[node.id] = {
+              ...execution,
+              status: "awaiting_approval",
+              approval,
+              approvalHistory: [...execution.approvalHistory, approval]
+            };
+          },
+          false
+        );
+        continue;
+      }
+      if (isSubFlowNode(node)) {
+        advancedSubFlows.add(node.id);
+        const execution = state.execution.nodes[node.id];
+        assertLegal(execution, `node not in execution: ${node.id}`);
+        if (execution.status === "available") {
+          this.mutate(
+            handle,
+            (current) => {
+              const currentExecution = current.execution.nodes[node.id];
+              assertLegal(currentExecution, `node not in execution: ${node.id}`);
+              assertLegal(
+                currentExecution.status === "available",
+                `cannot execute sub-flow node ${node.id}: status is ${currentExecution.status}`
+              );
+              current.execution.nodes[node.id] = {
+                ...currentExecution,
+                status: "running",
+                startedAt: now()
+              };
+            },
+            false
+          );
+        }
+        const executionGeneration = state.executionGeneration;
+        let result;
+        try {
+          const runner = state.inlineSubFlowRunner;
+          if (!runner) {
+            throw new Error(`no inline sub-flow runner configured for node ${node.id}`);
+          }
+          const resolved = resolveNodeBindings(
+            state.flowDef,
+            node,
+            snapshotMap(state.execution),
+            state.flowInputOrigins
+          );
+          result = await runner.run({
+            node,
+            flowId: node.run.flow,
+            inputs: resolved.values,
+            inputOrigins: {
+              ...node.run.passContext ? state.flowInputOrigins : {},
+              ...resolved.origins
+            },
+            passContext: node.run.passContext ?? false,
+            parentFlow: state.flowDef,
+            parentExecution: state.execution,
+            ancestry: state.inlineSubFlowAncestry,
+            routeOperationsTo: (target) => {
+              if (target) state.inlineOperationTargets.set(node.id, target);
+              else state.inlineOperationTargets.delete(node.id);
+            }
+          });
+        } 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 (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;
+        this.mutate(
+          handle,
+          (current) => {
+            const execution2 = current.execution.nodes[node.id];
+            assertLegal(execution2, `node not in execution: ${node.id}`);
+            if (result.status === "complete") {
+              current.execution.nodes[node.id] = {
+                ...execution2,
+                status: "complete",
+                completedAt: now(),
+                output: result.output
+              };
+              return;
+            }
+            current.execution.nodes[node.id] = {
+              ...execution2,
+              status: nodeIsOptional(node) ? "skipped" : "failed",
+              completedAt: now(),
+              output: result.output,
+              error: result.error,
+              errorHistory: [...execution2.errorHistory, result.error]
+            };
+          },
+          false
+        );
+        continue;
+      }
+      if (!isFunctionNode(node)) continue;
+      this.mutate(
+        handle,
+        (current) => {
+          const execution = current.execution.nodes[node.id];
+          assertLegal(execution, `node not in execution: ${node.id}`);
+          assertLegal(
+            execution.status === "available",
+            `cannot execute function node ${node.id}: status is ${execution.status}`
+          );
+          current.execution.nodes[node.id] = {
+            ...execution,
+            status: "running",
+            startedAt: now()
+          };
+        },
+        false
+      );
+      let capturedOutput;
+      try {
+        const executor = state.nodeExecutor;
+        if (!executor) throw new Error(`no NodeExecutor configured for function node ${node.id}`);
+        const resolved = resolveNodeBindings(
+          state.flowDef,
+          node,
+          snapshotMap(state.execution),
+          state.flowInputOrigins
+        );
+        const result = await executor.execute({
+          node,
+          inputs: resolved.values,
+          inputOrigins: resolved.origins
+        });
+        capturedOutput = functionNodeOutput(node, result);
+        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 validation = validateConsumedNodeOutput(
+          state.flowDef,
+          node.id,
+          capturedOutput.fields
+        );
+        if (!validation.valid) {
+          throw new Error(
+            `output does not match its consumed schema: ${validation.issues.join("; ")}`
+          );
+        }
+        this.mutate(
+          handle,
+          (current) => {
+            const execution = current.execution.nodes[node.id];
+            assertLegal(execution, `node not in execution: ${node.id}`);
+            current.execution.nodes[node.id] = {
+              ...execution,
+              status: "complete",
+              completedAt: now(),
+              output: capturedOutput
+            };
+          },
+          false
+        );
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        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]
+            };
+          },
+          false
+        );
+      }
+    }
+    return this.getExecution(handle);
   }
   // ── Private helpers ──
   s(handle) {
@@ -7979,23 +8818,21 @@ var FlowAdapter = class extends AbstractConnector {
   /**
    * Central mutation pipeline: runs the mutator, recomputes derived
    * fields, updates the flow-level `status` if the mutation completed
-   * or failed the flow, fires `onChange` once, and (Phase 3, 2026-05-08)
-   * optionally signals the {@link FlowAdapterStimulusBus} so the runner
-   * can kick a turn outside the legacy orchestrator path.
-   *
-   * The bus signal path is gated by the `useBusForStimulus` flag set at
-   * connect time — Phase 3 builds the path; Phase 4 flips the default to
-   * true globally and removes the orchestrator's onStateChange
-   * subscription.
+   * or failed the flow, fires `onChange` once, and optionally signals the
+   * {@link FlowAdapterStimulusBus}. The signal path is gated by the
+   * `useBusForStimulus` flag set at connect time.
    */
-  mutate(handle, fn) {
+  mutate(handle, fn, signalStimulus = true) {
     const s = this.s(handle);
     const previousExecution = s.lastSignaledExecution;
-    s.execution = { ...s.execution, nodes: { ...s.execution.nodes } };
+    s.execution = {
+      ...s.execution,
+      nodes: nodeExecutionRecord(Object.entries(s.execution.nodes))
+    };
     const result = fn(s);
     s.execution = this.recompute(s);
     if (s.onChange) s.onChange(s.execution);
-    if (s.useBusForStimulus && s.stimulusBus) {
+    if (signalStimulus && s.useBusForStimulus && s.stimulusBus) {
       const stim = computeStimulus(previousExecution, s.execution);
       if (stim) {
         const fragment = renderStimulusPrompt(stim);
@@ -8018,17 +8855,23 @@ var FlowAdapter = class extends AbstractConnector {
   recompute(s) {
     const snapshots = snapshotMap(s.execution);
     const computed = computeFlowStateFromSnapshots(s.flowDef, snapshots);
-    const nodes = { ...s.execution.nodes };
+    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" && ns.status === "available") {
-        nodes[ns.nodeId] = { ...existing, status: "available" };
+      if (existing.status === "not_started" || existing.status === "available") {
+        const hasFailedPreconditions = (ns.failedPreconditions?.length ?? 0) > 0;
+        const status = existing.status === "available" && ns.status === "not_started" && !hasFailedPreconditions ? "available" : ns.status;
+        nodes[ns.nodeId] = {
+          ...existing,
+          status,
+          failedPreconditions: hasFailedPreconditions ? ns.failedPreconditions : void 0
+        };
       }
     }
     let flowStatus = s.execution.status;
     if (flowStatus !== "cancelled") {
-      const anyRequiredFailed = s.flowDef.nodes.filter((n) => isAgentNode(n) && !nodeIsOptional(n)).some((n) => nodes[n.id]?.status === "failed");
+      const anyRequiredFailed = s.flowDef.nodes.filter((n) => isActiveRuntimeNode(n) && !nodeIsOptional(n)).some((n) => nodes[n.id]?.status === "failed");
       if (anyRequiredFailed) {
         flowStatus = "failed";
       } else if (computed.done) {
@@ -8058,20 +8901,42 @@ var FlowAdapter = class extends AbstractConnector {
       `cannot build handoff for ${nodeId}: status is ${targetExecution.status}`
     );
     const sections = [`# Agent node: ${nodeLabel(target)}`, `Node ID: ${target.id}`];
+    const resolved = resolveNodeBindings(
+      s.flowDef,
+      target,
+      snapshotMap(s.execution),
+      s.flowInputOrigins
+    );
     const instruction = nodeInstruction(target);
-    if (instruction) sections.push(`## Instruction
+    if (instruction) {
+      sections.push(
+        `## Instruction
 
-${instruction}`);
-    const bindings = nodeBindings(target);
-    if (Object.keys(bindings).length > 0) {
+${interpolateNodeInstruction(instruction, resolved.values)}`
+      );
+    }
+    if (Object.keys(resolved.values).length > 0) {
       sections.push(
         `## Supplied bindings
 
 \`\`\`json
-${JSON.stringify(bindings, null, 2)}
+${JSON.stringify(resolved.values, null, 2)}
+\`\`\``,
+        `## Binding origins
+
+\`\`\`json
+${JSON.stringify(resolved.origins, null, 2)}
 \`\`\``
       );
     }
+    if (targetExecution.outputCorrection) {
+      sections.push(
+        `## Output correction required
+
+This node has one corrective output call available. Fix every issue before calling \`complete_node\` again:
+${targetExecution.outputCorrection.issues.map((issue) => `- ${issue}`).join("\n")}`
+      );
+    }
     const assets = nodeAssets(target);
     if (assets.length > 0) {
       sections.push(`## Required assets
@@ -8104,6 +8969,26 @@ ${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 functionNodeOutput(node, result) {
+  const capturedFields = [];
+  for (const channel of ["stdout", "stderr"]) {
+    const destination = node.run.capture?.[channel];
+    if (!destination) continue;
+    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>`
+      );
+    }
+    capturedFields.push([match[1], result[channel]]);
+  }
+  const fields = Object.fromEntries(capturedFields);
+  return {
+    summary: `Function node ${node.id} exited with status ${result.exitStatus}.`,
+    artifacts: [],
+    ...Object.keys(fields).length > 0 ? { fields } : {}
+  };
+}
 function safeParseStringArray(value) {
   if (!value) return [];
   if (Array.isArray(value)) return value.map(String);
@@ -8117,6 +9002,27 @@ function safeParseStringArray(value) {
   }
   return [];
 }
+var JsonFieldsSchema = z4.record(z4.string(), z4.json());
+function safeParseFields(value) {
+  let parsed = value;
+  if (typeof value === "string") {
+    try {
+      parsed = JSON.parse(value);
+    } catch {
+      return { issues: ["fields: malformed JSON; expected an object"] };
+    }
+  }
+  const result = JsonFieldsSchema.safeParse(parsed);
+  if (!result.success) {
+    return {
+      issues: result.error.issues.map((issue) => {
+        const suffix = issue.path.map(String).join(".");
+        return `fields${suffix ? `.${suffix}` : ""}: ${issue.message}`;
+      })
+    };
+  }
+  return { fields: result.data, issues: [] };
+}
 function safeParseArtifacts(value) {
   if (!value) return [];
   const raw = typeof value === "string" ? safeJsonArray(value) : Array.isArray(value) ? value : [];
@@ -8151,6 +9057,6 @@ function createConnector() {
   return new FlowAdapter();
 }
 
-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, 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-PTS3QN5P.js.map
-//# sourceMappingURL=chunk-PTS3QN5P.js.map
+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