@oomol-lab/open-flow 0.1.0-beta.85 → 0.1.0-beta.86

package/src/control/common/workflowAuthoring.ts

@@ -0,0 +1,120 @@
+import type { JsonValue } from '../../flow/common/change.ts'
+import type { WorkflowFile } from '../../flow/common/workflowFile.ts'
+import type { ControlClient } from './api.ts'
+import type { AuthoringHost, AuthoringRead, AuthoringRequest, AuthoringSearch, AuthoringType } from './authoring.ts'
+
+import { currentFlowModelVersion } from '../../flow/common/changeSchema.ts'
+import { canonicalJsonBytes, digestBytes } from '../../flow/common/encoding.ts'
+import { validateFlow } from '../../flow/common/semantics.ts'
+import { decodeWorkflowFile } from '../../flow/common/workflowFile.ts'
+import { currentEngineContract, findEngineContract } from '../../runtime/common/engineContract.ts'
+import { workflowCandidate } from '../../workflow/common/workflow.ts'
+import { AuthoringError, authoringDiagnostics, compileAuthoring, readAuthoring, searchAuthoring } from './authoring.ts'
+import { authoringRequestSchema, authoringSchema, authoringSchemaQuery } from './authoringSchema.ts'
+
+export interface WorkflowAuthoringOptions {
+  /** Flow API metadata is already normalized; no Connector catalog adapter runs here. */
+  readonly client?: ControlClient
+  readonly locale?: string
+  readonly engineContract?: string
+  /** Override only for callers that own their deterministic node/module identity scope. */
+  readonly id?: AuthoringHost['id']
+}
+
+async function revision(file: WorkflowFile): Promise<string> {
+  return digestBytes(canonicalJsonBytes(JSON.parse(JSON.stringify(file)) as JsonValue))
+}
+
+async function checkedRevision(file: WorkflowFile, expected?: string): Promise<string> {
+  const actual = await revision(file)
+  if (expected != null && expected != actual)
+    throw new AuthoringError('flow.revision-conflict', 'The workflow file changed. Read it before submitting another edit.', { revision: actual })
+  return actual
+}
+
+/** File objects in, file objects out. Persistence and transport belong to the caller. */
+export function createWorkflowAuthoring(options: WorkflowAuthoringOptions = {}) {
+  function client(): ControlClient {
+    if (options.client == null) throw new AuthoringError('catalog.unavailable', 'A Control client is required to discover this capability.')
+    return options.client
+  }
+  const engineContract = options.engineContract ?? currentEngineContract
+  const engine = findEngineContract(engineContract)
+  if (engine == null) throw new AuthoringError('engine.unsupported', 'The Engine contract is not supported.', { engineContract })
+
+  async function check(file: WorkflowFile) {
+    const decoded = decodeWorkflowFile(file)
+    const validation = await validateFlow(decoded.content, engine!)
+    return {
+      revision: await revision(decoded),
+      valid: validation.valid,
+      diagnostics: authoringDiagnostics(decoded.content, validation.diagnostics),
+    }
+  }
+
+  return {
+    create(metadata: Omit<WorkflowFile, 'kind' | 'version' | 'content'> = {}): WorkflowFile {
+      return decodeWorkflowFile({
+        ...metadata,
+        kind: 'open-flow-workflow',
+        version: 1,
+        content: { modelVersion: currentFlowModelVersion, document: { graph: { nodes: {}, edges: [] }, bindings: {} }, modules: {} },
+      })
+    },
+
+    async read(file: WorkflowFile, query: AuthoringRead = {}) {
+      const decoded = decodeWorkflowFile(file)
+      return { revision: await checkedRevision(decoded, query.revision), data: readAuthoring(decoded.content, query) }
+    },
+
+    async search(file: WorkflowFile, query: AuthoringSearch) {
+      const decoded = decodeWorkflowFile(file)
+      return { revision: await checkedRevision(decoded, query.revision), data: searchAuthoring(decoded.content, query) }
+    },
+
+    async schema(query: { readonly type?: AuthoringType; readonly action?: string } = {}) {
+      const parsed = authoringSchemaQuery.parse(query)
+      if (parsed.action != null) {
+        const action = await client().getConnectorActionMetadata(parsed.action, undefined, undefined, options.locale ?? 'en')
+        return { action: action.actionId, name: action.name, inputs: action.inputs, outputs: action.outputs, version: 1 as const }
+      }
+      return { ...authoringSchema(parsed.type), version: 1 as const }
+    },
+
+    async edit(file: WorkflowFile, request: AuthoringRequest) {
+      const decoded = decodeWorkflowFile(file)
+      const parsed = authoringRequestSchema.parse(request)
+      const baseRevision = await checkedRevision(decoded, parsed.baseRevision)
+      const prefix = (await digestBytes(canonicalJsonBytes([baseRevision, parsed.requestId]))).slice(7, 31)
+      const ids = new Map<string, string>()
+      const compiled = await compileAuthoring(decoded.content, parsed, {
+        id: (label) => {
+          if (options.id != null) return options.id(label)
+          let id = ids.get(label)
+          if (id == null) {
+            id = `${prefix}_${ids.size}`
+            ids.set(label, id)
+          }
+          return id
+        },
+        action: (action) => client().getConnectorActionMetadata(action, undefined, undefined, options.locale ?? 'en'),
+        trigger: (key) => client().getTriggerKey(key),
+        openapi: (url) => client().loadOpenApiDocument(url),
+        workflow: async (flowId) => {
+          const candidate = workflowCandidate(await client().getFlow(flowId))
+          return candidate.problem == null ? client().getWorkflowContract(flowId) : candidate
+        },
+      })
+      const next = { ...decoded, content: compiled.content }
+      const validation = await check(next)
+      return {
+        file: next,
+        revision: validation.revision,
+        nodes: compiled.nodes,
+        validation: { status: validation.valid ? ('valid' as const) : ('invalid' as const), diagnostics: validation.diagnostics },
+      }
+    },
+
+    check,
+  }
+}

package/src/execution/common/checkpoint.ts

@@ -1,6 +1,6 @@
 import type { Graph, JsonValue } from '../../flow/common/change.ts'
 import type { AgentCheckpoint } from '../../runtime/common/runtime.ts'
-import type { DependenciesCheckpoint } from './dependencies.ts'
+import type { Dependencies, DependenciesCheckpoint } from './dependencies.ts'
 import type { ExecutableNode } from './node-execution.ts'
 
 import { z } from 'zod'
@@ -9,7 +9,7 @@ import { nodeErrorSchema, nodeSystemOutputPorts } from '../../flow/common/errorH
 import { nodeInputPorts as nodePorts, isResolutionNode, resolutionActions } from '../../flow/common/graph.ts'
 import { matchesSchema } from '../../flow/common/schema.ts'
 import { matchesTriggerOutputs } from '../../trigger/common/contract.ts'
-import { dependenciesSchema, dependencyValues } from './dependencies.ts'
+import { decodeDependenciesCheckpoint } from './dependencies.ts'
 import { agentCheckpointSchema, agentConfig, agentApproval, jsonEqual, jsonValue, outputRecord, usesPending, validateOutputs } from './node-execution.ts'
 
 export interface PendingWait {
@@ -44,7 +44,7 @@ export interface FlowRunCheckpoint {
   >
   readonly counts: Readonly<Record<string, Readonly<Record<string, number>>>>
   readonly dependencies: DependenciesCheckpoint
-  readonly version: 6
+  readonly version: 7
   readonly waits: readonly PendingWait[]
   readonly agents: Readonly<
     Record<
@@ -81,7 +81,8 @@ export function decodeFlowRunCheckpoint(input: unknown): FlowRunCheckpoint {
     ['agents', 'bindingValues', 'counts', 'dependencies', 'inputs', 'results', 'version', 'waits', ...(source.calls === undefined ? [] : ['calls'])],
     'Flow Run checkpoint',
   )
-  if (source.version != 6) throw new Error('Flow Run checkpoint version is unsupported.')
+  const version = source.version
+  if (version !== 6 && version !== 7) throw new Error('Flow Run checkpoint version is unsupported.')
   const bindingValues = Object.fromEntries(
     Object.entries(checkpointRecord(source.bindingValues, 'Checkpoint bindings')).map(([id, value]) => {
       if (typeof value != 'string') throw new Error('Checkpoint binding must be a string.')
@@ -119,7 +120,7 @@ export function decodeFlowRunCheckpoint(input: unknown): FlowRunCheckpoint {
     }),
   )
   const counts = z.record(z.string(), z.record(z.string(), z.number().int().positive().max(Number.MAX_SAFE_INTEGER))).parse(source.counts)
-  const dependencies = dependenciesSchema.parse(source.dependencies)
+  const dependencies = decodeDependenciesCheckpoint(source.dependencies, version)
   const savedWaitFields = {
     jobId: z.string().min(1),
     nodeId: z.string().min(1),
@@ -171,12 +172,13 @@ export function decodeFlowRunCheckpoint(input: unknown): FlowRunCheckpoint {
   if (Object.values(dependencies.nodes).some((state) => state.status == 'running' && !jobs.has(state.jobId!)))
     throw new Error('Checkpoint dependency has no waiting execution.')
   if (Object.keys(agents).some((id) => !jobs.has(id))) throw new Error('Checkpoint Agent has no waiting execution.')
-  return { agents, bindingValues, counts, dependencies, inputs, results, version: 6, waits: pendingWaits, ...(source.calls === undefined ? {} : { calls }) }
+  return { agents, bindingValues, counts, dependencies, inputs, results, version: 7, waits: pendingWaits, ...(source.calls === undefined ? {} : { calls }) }
 }
 
 export function validateCheckpoint(
   target: { readonly graph: Graph },
   checkpoint: FlowRunCheckpoint,
+  dependencies: Dependencies,
   resolveInputs: (nodeId: string, node: ExecutableNode) => Readonly<Record<string, JsonValue>>,
 ): void {
   const launch = checkpoint.inputs
@@ -249,12 +251,16 @@ export function validateCheckpoint(
       throw new Error('Checkpoint launch inputs do not match the prepared graph.')
   }
 
-  for (const [nodeId, state] of Object.entries(checkpoint.dependencies.nodes)) {
-    const frame = dependencyValues(state.input)
-    validateResults(frame, true, state.input)
+  for (const result of checkpoint.dependencies.results) validateResults({ [result.nodeId]: result.outputs }, true, { [result.nodeId]: result })
+  const graphTriggers = Object.keys(target.graph.nodes).filter((id) => isTriggerNode(target.graph.nodes[id]!))
+  for (const [nodeId, state] of Object.entries(dependencies.state.nodes)) {
     if (!isTriggerNode(target.graph.nodes[nodeId]!) && (state.status == 'running' || state.status == 'completed')) {
-      const triggers = Object.keys(frame).filter((id) => isTriggerNode(target.graph.nodes[id]!))
-      if (triggers.length != 1 || triggers[0] != triggerIds[0] || !jsonEqual(frame[triggers[0]!]!, checkpoint.results[triggers[0]!]!.outputs))
+      const triggers = graphTriggers.filter((id) => dependencies.input(nodeId, id) != null)
+      if (
+        triggers.length != 1 ||
+        triggers[0] != triggerIds[0] ||
+        !jsonEqual(dependencies.input(nodeId, triggers[0]!)!.outputs, checkpoint.results[triggers[0]!]!.outputs)
+      )
         throw new Error('Checkpoint input Trigger does not match the Run.')
     }
     if (state.output != null) validateResults({ [nodeId]: state.output }, state.status == 'running')
@@ -284,7 +290,7 @@ export function validateCheckpoint(
   for (const waiting of checkpoint.waits) {
     const node = target.graph.nodes[waiting.nodeId]
     if (node == null || isTriggerNode(node)) throw new Error('Checkpoint waiting node is missing.')
-    const state = checkpoint.dependencies.nodes[waiting.nodeId]!
+    const state = dependencies.state.nodes[waiting.nodeId]!
     const expectedOutput = waiting.pending == null ? undefined : { pending: waiting.pending }
     if ((state.output == null) != (expectedOutput == null) || (state.output != null && !jsonEqual(state.output, expectedOutput!)))
       throw new Error('Checkpoint waiting dependency output is inconsistent.')

package/src/execution/common/dependencies.ts

@@ -1,9 +1,23 @@
 import type { Graph, JsonValue } from '../../flow/common/change.ts'
 
+import { dequal } from 'dequal/lite'
 import { z } from 'zod'
 import { isTriggerNode } from '../../flow/common/change.ts'
 
 export interface DependenciesCheckpoint {
+  nextId: number
+  iterations: Record<string, number>
+  nodes: Record<string, Omit<DependencyState, 'input' | 'output' | 'systemOutputs'> & { input: number; output?: number }>
+  frames: readonly { readonly parent?: number; readonly input: Readonly<Record<string, number>> }[]
+  results: readonly {
+    readonly nodeId: string
+    readonly execution: number
+    readonly outputs: Readonly<Record<string, JsonValue>>
+    readonly systemOutputs?: Readonly<Record<string, JsonValue>>
+  }[]
+}
+
+interface DependenciesState {
   nextId: number
   iterations: Record<string, number>
   nodes: Record<string, DependencyState>
@@ -29,15 +43,11 @@ const inputSchema = z.record(
   z.string(),
   z.strictObject({ execution: z.number().int().nonnegative(), outputs: outputsSchema, systemOutputs: outputsSchema.optional() }),
 )
-type InputSnapshot = DependenciesCheckpoint['nodes'][string]['input']
+type InputSnapshot = DependencyState['input']
 type InputFrame =
   | { values: InputSnapshot }
   | { values?: InputSnapshot; source: string; result: InputSnapshot[string]; parent: InputFrame; cache: Map<string, InputSnapshot[string] | undefined> }
 
-export function dependencyValues(input: InputSnapshot): Readonly<Record<string, Readonly<Record<string, JsonValue>>>> {
-  return Object.fromEntries(Object.entries(input).map(([id, result]) => [id, result.outputs]))
-}
-
 const stateSchema = z.strictObject({
   id: z.number().int().nonnegative(),
   status: z.enum(['pending', 'running', 'completed', 'skipped']),
@@ -49,11 +59,97 @@ const stateSchema = z.strictObject({
   jobId: z.string().optional(),
   seeded: z.boolean(),
 })
-export const dependenciesSchema = z.strictObject({
+const legacyDependenciesSchema = z.strictObject({
   nextId: z.number().int().nonnegative(),
   iterations: z.record(z.string(), z.number().int().nonnegative()),
   nodes: z.record(z.string(), stateSchema),
 })
+
+const referenceSchema = z.number().int().nonnegative()
+const dependenciesSchema = z.strictObject({
+  nextId: referenceSchema,
+  iterations: z.record(z.string(), referenceSchema),
+  nodes: z.record(
+    z.string(),
+    stateSchema.omit({ input: true, output: true, systemOutputs: true }).extend({ input: referenceSchema, output: referenceSchema.optional() }),
+  ),
+  frames: z.array(z.strictObject({ parent: referenceSchema.optional(), input: z.record(z.string(), referenceSchema) })),
+  results: z.array(z.strictObject({ nodeId: z.string(), execution: referenceSchema, outputs: outputsSchema, systemOutputs: outputsSchema.optional() })),
+})
+
+export function decodeDependenciesCheckpoint(input: unknown, version: 6 | 7): DependenciesCheckpoint {
+  const saved = version == 6 ? saveDependencies(legacyDependenciesSchema.parse(input)) : dependenciesSchema.parse(input)
+  for (const [index, frame] of saved.frames.entries()) {
+    if (frame.parent != null && (frame.parent >= index || Object.keys(frame.input).length != 1)) throw new Error('Checkpoint input frame parent is invalid.')
+    for (const [nodeId, reference] of Object.entries(frame.input)) {
+      const result = saved.results[reference]
+      if (result == null || result.nodeId != nodeId) throw new Error('Checkpoint input result reference is invalid.')
+    }
+  }
+  for (const [nodeId, state] of Object.entries(saved.nodes)) {
+    if (saved.frames[state.input] == null) throw new Error('Checkpoint input frame reference is invalid.')
+    if (state.output != null) {
+      const result = saved.results[state.output]
+      if (result == null || result.nodeId != nodeId || result.execution != state.id) throw new Error('Checkpoint output result reference is invalid.')
+    }
+  }
+  for (const result of saved.results) {
+    if (saved.nodes[result.nodeId] == null || result.execution > saved.nodes[result.nodeId]!.id || result.execution >= saved.nextId)
+      throw new Error('Checkpoint dependency result identity is invalid.')
+  }
+  return saved
+}
+
+function saveDependencies(state: DependenciesState, frames?: ReadonlyMap<string, InputFrame>): DependenciesCheckpoint {
+  const results: DependenciesCheckpoint['results'][number][] = []
+  const references = new Map<string, number>()
+  const saveResult = (nodeId: string, result: InputSnapshot[string]) => {
+    const key = JSON.stringify([nodeId, result.execution, Object.keys(result.outputs).toSorted()])
+    let reference = references.get(key)
+    if (reference == null) {
+      reference = results.length
+      references.set(key, reference)
+      results.push({ nodeId, ...result })
+    } else if (!dequal(results[reference]!.outputs, result.outputs) || !dequal(results[reference]!.systemOutputs, result.systemOutputs))
+      throw new Error('Checkpoint invocation results conflict.')
+    return reference
+  }
+  const savedFrames: DependenciesCheckpoint['frames'][number][] = []
+  const frameIds = new Map<InputFrame, number>()
+  const saveFrame = (frame: InputFrame): number => {
+    const existing = frameIds.get(frame)
+    if (existing != null) return existing
+    const saved =
+      'source' in frame
+        ? { parent: saveFrame(frame.parent), input: { [frame.source]: saveResult(frame.source, frame.result) } }
+        : { input: Object.fromEntries(Object.entries(frame.values).map(([id, result]) => [id, saveResult(id, result)])) }
+    const id = savedFrames.length
+    savedFrames.push(saved)
+    frameIds.set(frame, id)
+    return id
+  }
+  const nodes = Object.fromEntries(
+    Object.entries(state.nodes).map(([id, current]) => {
+      const { id: execution, status, previous, released, jobId, seeded, output, systemOutputs } = current
+      return [
+        id,
+        {
+          id: execution,
+          status,
+          previous,
+          released,
+          seeded,
+          ...(jobId == null ? {} : { jobId }),
+          input: saveFrame(frames?.get(id) ?? { values: current.input }),
+          ...(output == null
+            ? {}
+            : { output: saveResult(id, { execution: current.id, outputs: output, ...(systemOutputs == null ? {} : { systemOutputs }) }) }),
+        },
+      ]
+    }),
+  )
+  return { nextId: state.nextId, iterations: { ...state.iterations }, nodes, frames: savedFrames, results }
+}
 type Edge = Graph['edges'][number]
 interface Loop {
   readonly header: string
@@ -64,7 +160,7 @@ interface Loop {
 
 /** Dependency completion belongs to an invocation, never to a Run-wide latest-result table. */
 export class Dependencies {
-  readonly state: DependenciesCheckpoint
+  readonly state: DependenciesState
   private readonly forward: Edge[] = []
   private readonly loops = new Map<string, Loop>()
   private readonly innerLoopsFirst: readonly Loop[]
@@ -135,15 +231,40 @@ export class Dependencies {
       this.loops.set(header, { header, feedback: edges, body, continuation: descendants })
     }
     this.innerLoopsFirst = [...this.loops.values()].toSorted((a, b) => a.body.size - b.body.size || a.header.localeCompare(b.header))
-    this.state = saved == null ? { nextId: 0, iterations: {}, nodes: {} } : structuredClone(saved)
+    this.state = { nextId: saved?.nextId ?? 0, iterations: { ...saved?.iterations }, nodes: {} }
     if (saved == null) for (const id of ids) this.state.nodes[id] = this.fresh()
-    else this.validate()
+    else {
+      const frames: InputFrame[] = []
+      for (const frame of saved.frames) {
+        if (frame.parent == null)
+          frames.push({ values: Object.fromEntries(Object.entries(frame.input).map(([id, reference]) => [id, saved.results[reference]!])) })
+        else {
+          const [source, reference] = Object.entries(frame.input)[0]!
+          frames.push({ source, result: saved.results[reference]!, parent: frames[frame.parent]!, cache: new Map() })
+        }
+      }
+      for (const [id, current] of Object.entries(saved.nodes)) {
+        const { input, output, ...node } = current
+        const result = output == null ? undefined : saved.results[output]!
+        const frame = frames[input]!
+        this.frames.set(id, frame)
+        const restored: DependencyState = { ...node, input: {}, ...(result == null ? {} : { output: result.outputs, systemOutputs: result.systemOutputs }) }
+        if (this.loops.size == 0) Object.defineProperty(restored, 'input', { enumerable: true, configurable: true, get: () => this.snapshot(frame) })
+        else restored.input = this.snapshot(frame)
+        this.state.nodes[id] = restored
+      }
+      this.validate()
+    }
     for (const id of ids) {
       if (this.state.nodes[id]!.status == 'pending') this.candidates.add(id)
-      this.frames.set(id, { values: this.state.nodes[id]!.input })
+      if (saved == null) this.frames.set(id, { values: this.state.nodes[id]!.input })
     }
   }
 
+  checkpoint(): DependenciesCheckpoint {
+    return saveDependencies(this.state, this.loops.size == 0 ? this.frames : undefined)
+  }
+
   private fresh(): DependencyState {
     return { id: this.state.nextId++, status: 'pending', input: {}, previous: [], released: [], seeded: false }
   }
@@ -170,11 +291,7 @@ export class Dependencies {
         throw new Error('Checkpoint predecessor does not match the graph.')
       if (state.previous.length != new Set(state.previous).size) throw new Error('Checkpoint predecessors are duplicated.')
       if (state.status == 'completed' && state.output == null) throw new Error('Checkpoint completed dependency has no output.')
-      if (state.previous.some((source) => state.input[source] == null)) throw new Error('Checkpoint predecessor has no input snapshot.')
-      for (const [source, result] of Object.entries(state.input)) {
-        if (nodes[source] == null || result.execution > nodes[source]!.id || result.execution >= nextId)
-          throw new Error('Checkpoint dependency result identity is invalid.')
-      }
+      if (state.previous.some((source) => this.input(id, source) == null)) throw new Error('Checkpoint predecessor has no input snapshot.')
     }
     if (Object.keys(iterations).some((id) => !this.loops.has(id))) throw new Error('Checkpoint loop scope is invalid.')
   }

package/src/execution/common/events.ts

@@ -19,6 +19,7 @@ const nodeKinds = new Set([
   'approval',
   'condition',
   'connector',
+  'connector-proxy',
   'decision',
   'javascript',
   'openapi',
@@ -53,6 +54,7 @@ function nodeKind(
   | 'approval'
   | 'condition'
   | 'connector'
+  | 'connector-proxy'
   | 'decision'
   | 'javascript'
   | 'openapi'
@@ -74,6 +76,7 @@ function nodeKind(
     | 'approval'
     | 'condition'
     | 'connector'
+    | 'connector-proxy'
     | 'decision'
     | 'javascript'
     | 'openapi'

package/src/execution/common/node-execution.ts

@@ -20,6 +20,7 @@ interface NodeExecutionContext {
   readonly createId: FlowRunOptions['createId']
   readonly emit: (event: SchedulerEvent) => Effect.Effect<void, Error>
   readonly invokeTask: FlowRunOptions['invokeTask']
+  readonly admitTask?: FlowRunOptions['admitTask']
   readonly projectFailure: FlowRunOptions['projectFailure']
 }
 
@@ -105,6 +106,7 @@ function nodeKind(
   | 'approval'
   | 'condition'
   | 'connector'
+  | 'connector-proxy'
   | 'decision'
   | 'javascript'
   | 'openapi'
@@ -217,7 +219,11 @@ export function validateOutputs(nodeId: string, node: ExecutableNode, value: unk
             : {}
   const outputs = outputRecord(
     jsonValue(
-      Object.fromEntries(Object.entries(raw).map(([handle, item]) => [handle, Object.hasOwn(ports, handle) && item === undefined ? null : item])),
+      Object.fromEntries(
+        Object.entries(raw)
+          .filter(([handle]) => !discardUndeclared || Object.hasOwn(ports, handle))
+          .map(([handle, item]) => [handle, Object.hasOwn(ports, handle) && item === undefined ? null : item]),
+      ),
       `Node "${nodeId}" outputs`,
     ),
     nodeId,
@@ -227,11 +233,7 @@ export function validateOutputs(nodeId: string, node: ExecutableNode, value: unk
   const validated: [string, JsonValue][] = []
   for (const [handle, output] of Object.entries(complete)) {
     const port = ports[handle]
-    if (port == null) {
-      if (discardUndeclared) continue
-      throw new PortValidationError(`Node "${nodeId}" output "${handle}" does not match its declaration.`)
-    }
-    if (!(output === null && port.nullable) && !matchesSchema(output, port.jsonSchema))
+    if (port == null || (!(output === null && port.nullable) && !matchesSchema(output, port.jsonSchema)))
       throw new PortValidationError(`Node "${nodeId}" output "${handle}" does not match its declaration.`)
     validated.push([handle, output])
   }
@@ -316,8 +318,9 @@ export function executeNode(
   const { nodeId, node, jobId, nodeInputs, flowId, runId, graph, dependencies, previousIds, saved, workflowRunId, resolution } = input
   const config = agentConfig(node)
   const nodeRemainingMs = saved?.remainingMs ?? node.timeoutMs
-  const startedAt = performance.now()
+  let startedAt = 0
   const execution = Effect.gen(function* () {
+    startedAt = performance.now()
     const kind = nodeKind(node)
     const title = nodeTitle(node)
     const projectedInputs = Object.fromEntries(
@@ -461,12 +464,16 @@ export function executeNode(
       catch: (error) => new NodeValidationError('node.output-invalid', error),
     })
   })
-  return nodeRemainingMs == null
-    ? execution
-    : execution.pipe(
-        Effect.timeoutOrElse({
-          duration: nodeRemainingMs,
-          orElse: () => Effect.fail(new Error(`Node "${nodeId}" timed out.`)),
-        }),
-      )
+  const timed =
+    nodeRemainingMs == null
+      ? execution
+      : execution.pipe(
+          Effect.timeoutOrElse({
+            duration: nodeRemainingMs,
+            orElse: () => Effect.fail(new Error(`Node "${nodeId}" timed out.`)),
+          }),
+        )
+  // Waiting for deployment admission is queueing, not node execution time.
+  // Pending workflow calls only read child state and do not consume Task capacity.
+  return node.kind == 'task' && workflowRunId == null && context.admitTask != null ? Effect.andThen(context.admitTask({ runId, nodeId, jobId }), timed) : timed
 }

package/src/execution/common/scheduler.ts

@@ -67,6 +67,7 @@ export type SchedulerEvent =
         | 'approval'
         | 'condition'
         | 'connector'
+        | 'connector-proxy'
         | 'decision'
         | 'javascript'
         | 'openapi'
@@ -157,8 +158,6 @@ export interface WaitHost {
   readonly resolutions: (waitIds: readonly string[], block: boolean) => Effect.Effect<Readonly<Record<string, WaitResolution>>, Error>
 }
 
-export const waitRetentionMs = 120_000
-
 export type FlowRunOutcome =
   | FlowRunResult
   | {
@@ -199,11 +198,19 @@ export interface SchedulerFailure {
   readonly message: string
 }
 
+export interface TaskAdmission {
+  readonly runId: string
+  readonly nodeId: string
+  readonly jobId: string
+}
+
 export type FlowRunOptions = {
   readonly createId: () => string
   readonly emit?: (event: SchedulerEvent) => Effect.Effect<void, Error>
   readonly flowId: string
   readonly invokeTask: (invocation: TaskInvocation) => Effect.Effect<unknown, Error>
+  /** Deployment admission for each Task invocation; it completes before the node timeout starts. */
+  readonly admitTask?: (admission: TaskAdmission) => Effect.Effect<void, Error>
   readonly projectFailure?: (error: unknown) => SchedulerFailure
   readonly runId: string
   readonly waits?: WaitHost
@@ -239,6 +246,7 @@ interface RunContext {
   readonly createId: FlowRunOptions['createId']
   readonly emit: (event: SchedulerEvent) => Effect.Effect<void, Error>
   readonly invokeTask: FlowRunOptions['invokeTask']
+  readonly admitTask: FlowRunOptions['admitTask']
   readonly prepared: PreparedFlow
   readonly projectFailure: FlowRunOptions['projectFailure']
   readonly waits: WaitHost | undefined
@@ -295,7 +303,6 @@ function runGraph(
       let measuredAt = yield* Clock.currentTimeMillis
       let nextCallCheckAt = measuredAt + (resume == null ? 1000 : 0)
       let readyWorkflowRunIds = resume?.readyWorkflowRunIds
-      let idleSince: number | undefined
       const agents: Record<string, FlowRunCheckpoint['agents'][string]> = { ...resume?.checkpoint.agents }
       const resolveInputs = (nodeId: string, node: ExecutableNode) => resolveNodeInputs(nodeId, node, dependencies, context.bindingValues, launch[nodeId])
       const commit = (
@@ -479,7 +486,7 @@ function runGraph(
       }
       if (resume != null) {
         yield* Effect.try({
-          try: () => validateCheckpoint(target, resume.checkpoint, resolveInputs),
+          try: () => validateCheckpoint(target, resume.checkpoint, dependencies, resolveInputs),
           catch: (error) => (error instanceof Error ? error : new Error(String(error))),
         })
       }
@@ -487,15 +494,11 @@ function runGraph(
         if (trigger != null) dependencies.start(trigger.nodeId, trigger.outputs)
       }
 
-      const applyResolutions = (resolutions: Readonly<Record<string, WaitResolution>>, now: number) => {
+      const applyResolutions = (resolutions: Readonly<Record<string, WaitResolution>>) => {
         for (const saved of pendingWaits.values()) {
           const resolution = resolutions[saved.waitId]
           if (resolution == null) continue
           const { action, resolvedAt, comment } = resolution
-          if (idleSince != null) {
-            idleSince = undefined
-            measuredAt = now
-          }
           pendingWaits.delete(saved.jobId)
           const node = target.graph.nodes[saved.nodeId] as ExecutableNode
           runNode(
@@ -526,7 +529,7 @@ function runGraph(
       }
       while (true) {
         const now = yield* Clock.currentTimeMillis
-        if (idleSince == null && remainingMs != null) remainingMs -= now - measuredAt
+        if (remainingMs != null) remainingMs -= now - measuredAt
         measuredAt = now
         if (remainingMs != null && remainingMs <= 0) return yield* Effect.fail(new Error('Run exceeded its execution deadline.'))
         if (firstCause != null) {
@@ -547,7 +550,6 @@ function runGraph(
               [...pendingWaits.values()].map((wait) => wait.waitId),
               false,
             ),
-            now,
           )
         if (pendingCalls.size > 0 && now >= nextCallCheckAt) {
           for (const call of pendingCalls.values()) {
@@ -572,17 +574,14 @@ function runGraph(
           if (dependencies.incomplete) return yield* Effect.fail(new Error('Execution graph contains unresolved dependencies.'))
           break
         }
-        if (running > 0 || ready.length > 0) idleSince = undefined
-        else idleSince ??= now
-        const left = idleSince == null ? remainingMs : waitRetentionMs - (now - idleSince)
-        if (idleSince != null && (left! <= 0 || pendingCalls.size > 0)) {
+        if (running == 0 && ready.length == 0) {
           const checkpoint: FlowRunCheckpoint = {
             bindingValues: context.bindingValues,
             inputs: launch,
             results: Object.fromEntries(completed),
             counts: context.counts,
-            dependencies: dependencies.state,
-            version: 6,
+            dependencies: dependencies.checkpoint(),
+            version: 7,
             agents,
             waits: [...pendingWaits.values()],
             ...(pendingCalls.size == 0 ? {} : { calls: [...pendingCalls.values()] }),
@@ -602,9 +601,9 @@ function runGraph(
         let next = Effect.raceFirst(activity, decision)
         if (pendingCalls.size > 0)
           next = Effect.raceFirst(next, Effect.sleep(Math.max(0, nextCallCheckAt - (yield* Clock.currentTimeMillis))).pipe(Effect.as({})))
-        if (left != null) next = Effect.raceFirst(next, Effect.sleep(Math.max(0, left)).pipe(Effect.as({})))
+        if (remainingMs != null) next = Effect.raceFirst(next, Effect.sleep(Math.max(0, remainingMs)).pipe(Effect.as({})))
         const resolutions = yield* next
-        applyResolutions(resolutions, yield* Clock.currentTimeMillis)
+        applyResolutions(resolutions)
       }
       yield* context.emit({ progress: 100, runId, type: 'run.progress' })
       const outputNodeId = order.find((nodeId) => target.graph.nodes[nodeId]?.kind == 'outputs')
@@ -655,18 +654,7 @@ export function runFlow(prepared: PreparedFlow, options: FlowRunOptions): Effect
             results: Object.fromEntries(Object.entries(decoded.results).map(([id, result]) => [id, { ...result, outputs: outputs(id, result.outputs) }])),
             dependencies: {
               ...decoded.dependencies,
-              nodes: Object.fromEntries(
-                Object.entries(decoded.dependencies.nodes).map(([id, state]) => [
-                  id,
-                  {
-                    ...state,
-                    ...(state.output == null ? {} : { output: outputs(id, state.output) }),
-                    input: Object.fromEntries(
-                      Object.entries(state.input).map(([source, result]) => [source, { ...result, outputs: outputs(source, result.outputs) }]),
-                    ),
-                  },
-                ]),
-              ),
+              results: decoded.dependencies.results.map((result) => ({ ...result, outputs: outputs(result.nodeId, result.outputs) })),
             },
             waits: decoded.waits.map((wait) => (wait.pending == null ? wait : Object.assign({}, wait, { pending: withWaitNotificationMessage(wait.pending) }))),
           }
@@ -691,6 +679,7 @@ export function runFlow(prepared: PreparedFlow, options: FlowRunOptions): Effect
         createId: options.createId,
         emit,
         invokeTask: options.invokeTask,
+        admitTask: options.admitTask,
         prepared,
         projectFailure: options.projectFailure,
         waits: options.waits,