@orkestrel/workflow 0.0.1 → 0.0.2

package/dist/src/core/index.d.cts

@@ -7,17 +7,42 @@ import { DriverInterface } from '@orkestrel/database';
 import { EmitterErrorHandler } from '@orkestrel/emitter';
 import { EmitterHooks } from '@orkestrel/emitter';
 import { EmitterInterface } from '@orkestrel/emitter';
+import { Failure } from '@orkestrel/contract';
 import { LiteralShape } from '@orkestrel/contract';
 import { NumberShape } from '@orkestrel/contract';
 import { ObjectShape } from '@orkestrel/contract';
 import { OptionalShape } from '@orkestrel/contract';
 import { Result } from '@orkestrel/contract';
 import { StringShape } from '@orkestrel/contract';
+import { Success } from '@orkestrel/contract';
 import { TableInterface } from '@orkestrel/database';
 import { TokenUsage } from '@orkestrel/budget';
 import { ToolInterface } from '@orkestrel/agent';
 import { ToolManagerInterface } from '@orkestrel/agent';
-import { UnionShape } from '@orkestrel/contract';
+
+/**
+ * Options for {@link import('./factories.js').createAgentFunction} — the OPT-IN adapter that
+ * wraps a live `AgentInterface` (`@orkestrel/agent`) as a {@link WorkflowFunction}, folding a
+ * nested workflow-authoring depth / cycle guard into its closure.
+ *
+ * @remarks
+ * All fields are optional: omitted entirely, the adapter runs the agent with no nested
+ * workflow tool bound and no depth/cycle bound (depth `0`, empty ancestry).
+ * - `runner` — when supplied, the adapter BINDS a depth/cycle-aware
+ *   {@link import('./factories.js').createWorkflowTool} onto the agent's `context.tools` (the
+ *   propagation seam), so the agent can author + run a NESTED workflow through it. Omitted ⇒
+ *   the agent runs with no workflow tool bound.
+ * - `depth` — this invocation's nesting depth (default `0`); the bound workflow tool runs its
+ *   nested workflow at `depth + 1`, bounded by {@link import('./constants.js').MAX_WORKFLOW_DEPTH}.
+ * - `ancestry` — the workflow / agent identifiers already in this run chain (default empty); a
+ *   cycle (this agent already present) is rejected with a typed `DEPTH`
+ *   {@link import('./errors.js').WorkflowError}.
+ */
+export declare interface AgentFunctionOptions {
+    readonly runner?: WorkflowRunnerInterface;
+    readonly depth?: number;
+    readonly ancestry?: readonly string[];
+}
 
 /**
  * The ancestry identifier of an agent in a run chain — `agent:<name>`.
@@ -43,10 +68,13 @@ export declare function agentTag(name: string): string;
  * untrusted JSON, so a status (or an override) outside
  * {@link import('./constants.js').WORKFLOW_STATUSES} /
  * {@link import('./constants.js').PHASE_STATUSES} / {@link import('./constants.js').TASK_STATUSES},
- * or a non-boolean `bail` (the workflow's OR any phase's — both are REQUIRED persisted policy),
+ * a non-boolean `bail` (the workflow's OR any phase's — both are REQUIRED persisted policy), a
+ * present-but-invalid phase `concurrency` (not a positive integer), or a present-but-invalid task
+ * `run` (an empty string) / `retries` / `timeout` (not a non-negative integer),
  * is rejected loudly (naming the offending node) rather than silently producing a broken tree.
- * The `override` is optional, so it is only checked WHEN present. Structural shape beyond these
- * fields is the contract's concern; this guards exactly the fields the live state machine reads back.
+ * The `override` / `concurrency` / `run` / `retries` / `timeout` are optional, so each is only
+ * checked WHEN present. Structural shape beyond these fields is the contract's concern; this
+ * guards exactly the fields the live state machine reads back.
  *
  * @param snapshot - The snapshot to validate
  */
@@ -262,6 +290,48 @@ export declare interface ControllerInterface<TInput, TResult> {
     abort(reason?: unknown): void;
 }
 
+/**
+ * Wrap a live `AgentInterface` (`@orkestrel/agent`) as a {@link WorkflowFunction} — the OPT-IN
+ * adapter that runs the agent to a settled result, folding a nested workflow-authoring
+ * depth / cycle guard into its own closure.
+ *
+ * @remarks
+ * Composes into a caller's {@link WorkflowOptions.functions} registry like any other behavior;
+ * the PURE {@link import('./WorkflowRunner.js').WorkflowRunner} has no knowledge of agents
+ * itself. Before running the agent, the depth/cycle guard REJECTS the call (a THROWN typed
+ * `DEPTH` {@link WorkflowError}, which the leaf `fail`s) when running it would push a nested
+ * chain past {@link MAX_WORKFLOW_DEPTH}, OR when this agent is already an ancestor (a cycle) —
+ * ported from the former engine-side guard. When {@link AgentFunctionOptions.runner} is
+ * supplied, the adapter BINDS a depth/cycle-aware {@link createWorkflowTool} onto the agent's
+ * `context.tools` (the propagation seam) — closed over `depth` and the extended ancestry (the
+ * tool itself computes `depth + 1` internally) — so the agent can author + run a NESTED
+ * workflow through it; the wrapped default is the CURRENT task's own workflow id (used only on
+ * a no-args tool call). The task's cancellation folds into the agent run: an already-aborted
+ * `controller.signal` cancels the agent up front; otherwise a one-shot listener fires
+ * `agent.abort(reason)` when the task cancels, removed in `finally`. `agent.generate()` resolves
+ * a partial `AgentResult` on a cancel (never rejects), returned as the task's completed value.
+ *
+ * A bound agent is effectively SINGLE-RUN: `context.tools.add` binds one {@link ToolInterface}
+ * under the fixed {@link import('./constants.js').WORKFLOW_TOOL_NAME}, and `agent.generate()` /
+ * `agent.abort()` are per-agent state. Two CONCURRENT tasks sharing the SAME `agent` instance
+ * race on that one tool binding (last-write-wins) and on generate/abort — give each concurrent
+ * task its OWN agent instance.
+ *
+ * @param agent - The live `AgentInterface` to run
+ * @param options - The nested-workflow binding + depth/cycle bookkeeping (see {@link AgentFunctionOptions})
+ * @returns A {@link WorkflowFunction} that runs `agent` to its settled result
+ *
+ * @example
+ * ```ts
+ * import { createAgentFunction, createWorkflowRunner } from '@src/core'
+ *
+ * const runner = createWorkflowRunner()
+ * const review = createAgentFunction(myAgent, { runner })
+ * await runner.execute(definition, { functions: { review } })
+ * ```
+ */
+export declare function createAgentFunction(agent: AgentInterface, options?: AgentFunctionOptions): WorkflowFunction;
+
 /**
  * Create a {@link DatabaseWorkflowStore} over any {@link DriverInterface} — the durable,
  * driver-pluggable backing for the W-d persistence seam, the opt-in twin of
@@ -425,6 +495,38 @@ export declare function createRunner<TInput, TResult>(options: RunnerOptions<TIn
  */
 export declare function createScheduler(): SchedulerInterface;
 
+/**
+ * Wrap a registered tool as a {@link WorkflowFunction} — the OPT-IN adapter that lets a
+ * `function`-form task run a `@orkestrel/agent` tool BY NAME.
+ *
+ * @remarks
+ * Composes into a caller's {@link WorkflowOptions.functions} registry like any other behavior
+ * (`{ publish: createToolFunction(tools, 'publish') }`); the PURE
+ * {@link import('./WorkflowRunner.js').WorkflowRunner} has no knowledge of tools itself. The
+ * returned function executes `name` against `tools` with the task's `controller.input` as the
+ * call arguments, id-correlated to the task's own id. A `ToolManagerInterface.execute` NEVER
+ * throws (a handler throw is isolated into `result.error`), so a failing tool is surfaced here
+ * as a THROWN `Error` carrying the original message as `cause` — the leaf `fail`s, honouring
+ * `bail`. An UNREGISTERED tool name is a programmer error (an explicit binding to a name that
+ * doesn't exist) — unlike the engine's own silent auto-complete of an unresolved task handler,
+ * this THROWS a typed `TOOL` {@link WorkflowError}.
+ *
+ * @param tools - The {@link ToolManagerInterface} the named tool is registered on
+ * @param name - The registered tool's name
+ * @returns A {@link WorkflowFunction} that runs the named tool
+ *
+ * @example
+ * ```ts
+ * import { createToolFunction, createToolManager, createWorkflowRunner } from '@src/core'
+ *
+ * const tools = createToolManager()
+ * tools.add(myPublishTool)
+ * const runner = createWorkflowRunner()
+ * await runner.execute(definition, { functions: { publish: createToolFunction(tools, 'publish') } })
+ * ```
+ */
+export declare function createToolFunction(tools: ToolManagerInterface, name: string): WorkflowFunction;
+
 /**
  * Build the live W-b entity tree from a {@link WorkflowDefinition} — the whole
  * {@link WorkflowInterface} → {@link import('./types.js').PhaseInterface} →
@@ -441,6 +543,11 @@ export declare function createScheduler(): SchedulerInterface;
  * `options.phases[id].tasks[id]` (the AGENTS §8 nested-by-id bag). The W-b tree is the
  * state machine ONLY — it does not execute tasks (W-c drives the transitions).
  *
+ * `options.functions` is the {@link import('./types.js').WorkflowFunctions} registry each live
+ * task's `run` name resolves against ONCE at construction into its runtime
+ * {@link import('./types.js').TaskInterface.handler} — a name omitted or absent from the
+ * registry resolves to no handler (the no-handler rule).
+ *
  * @param definition - The workflow definition to bring to life
  * @param options - Runtime options (initial listeners, `bail` override, per-node options)
  * @returns The live {@link WorkflowInterface} root
@@ -516,50 +623,45 @@ export declare function createWorkflowDraftContract(): ContractInterface<Workflo
 /**
  * Create a workflow runner — a {@link WorkflowRunnerInterface} that EXECUTES a live W-b
  * workflow tree by COMPOSING the shipped substrate: phases sequential, tasks concurrent,
- * each task dispatched BY NAME under the workflow's `bail` policy.
- *
- * @remarks
- * The runner is THIN — it re-implements no concurrency / retry / abort logic. Per-phase
- * bounded concurrency is one {@link createRunner} per phase;
- * `bail` maps onto that Runner's fail-fast (`true` — the first failure aborts the in-flight
- * siblings + skips the rest) vs settle-all (`false` — failures are recorded, the run
- * finishes); the run-level abort / timeout / budget ({@link import('./types.js').WorkflowRunOptions})
- * fold through `AbortSignal.any` (the agent runtime's pattern); pacing is the shipped
- * scheduler. `execute(definition, options?)` BUILDS the live tree from the definition itself
- * (via {@link createWorkflow} — one source of truth, returned in `WorkflowResult.workflow`),
- * drives the live entity (`start` → `complete` / `fail`), and resolves a
+ * each task dispatched through its OWN resolved handler under the workflow's `bail` policy.
+ *
+ * @remarks
+ * The runner is a PURE engine — it re-implements no concurrency / retry / abort logic, AND it
+ * carries no `functions` / `tools` / `agents` registry of its own: each live task already
+ * resolved its own {@link import('./types.js').WorkflowFunction} into
+ * {@link import('./types.js').TaskInterface.handler} ONCE at construction, from the
+ * {@link WorkflowOptions.functions} registry supplied to `execute` / {@link createWorkflow}.
+ * Per-phase bounded concurrency is one {@link createRunner} per phase; `bail` maps onto that
+ * Runner's fail-fast (`true` — the first failure aborts the in-flight siblings + skips the
+ * rest) vs settle-all (`false` — failures are recorded, the run finishes); the run-level abort
+ * / timeout / budget ({@link import('./types.js').WorkflowRunOptions}) fold through
+ * `AbortSignal.any` (the agent runtime's pattern); pacing is the shipped scheduler.
+ * `execute(definition, options?)` BUILDS the live tree from the definition itself (via
+ * {@link createWorkflow} — one source of truth, returned in `WorkflowResult.workflow`), drives
+ * the live entity (`start` → `complete` / `fail`), and resolves a
  * {@link import('./types.js').WorkflowResult}.
  *
- * A task is dispatched on its {@link import('./types.js').TaskForm}: `function` → the
- * `functions` registry, `tool` → the `tools` {@link ToolManagerInterface}, `agent` → the
- * `agents` {@link import('./types.js').WorkflowAgents} resolver (W-c2), behind a depth + cycle
- * guard. A task whose handler is NOT found (an unregistered name for ANY form) AUTO-COMPLETES
- * (the ROADMAP no-handler rule).
- *
- * The runner is constructed with a reference to {@link createWorkflowTool} (the workflow-tool
- * binder) so it can BIND a depth/cycle-aware workflow tool onto a dispatched subagent's context
- * — the propagation seam — WITHOUT this module's classes importing its own `factories.ts` (the
- * factories→classes direction; the binder is injected as a value at construction).
- *
- * @param options - The behavior registries (`functions` / `tools` / `agents`) the runner
- *   dispatches a task by name through, plus an optional pacing `scheduler` (default the shipped
- *   cross-environment one). Omitting `functions` / `tools` / `agents` makes those task forms
- *   auto-complete (no handler). See {@link WorkflowRunnerOptions}.
+ * Static tool / agent calling is OPT-IN, wired through the adapter factories
+ * {@link createToolFunction} / {@link createAgentFunction} — plain
+ * {@link import('./types.js').WorkflowFunction}s a caller composes into its OWN
+ * {@link WorkflowOptions.functions} registry, same as any other behavior. A task with no
+ * resolved handler AUTO-COMPLETES (the ROADMAP no-handler rule).
+ *
+ * @param options - An optional pacing `scheduler` (default the shipped cross-environment one).
+ *   See {@link WorkflowRunnerOptions}.
  * @returns A working {@link WorkflowRunnerInterface}
  *
  * @example
  * ```ts
- * import { createWorkflowRunner, createToolManager } from '@src/core'
+ * import { createWorkflowRunner } from '@src/core'
  *
- * const tools = createToolManager()
- * const runner = createWorkflowRunner({
- * 	functions: { compile: async (controller) => `built ${controller.task.id}` },
- * 	tools,
- * })
+ * const runner = createWorkflowRunner()
  * const definition = { id: 'w', name: 'W', phases: [{ id: 'p', name: 'P', tasks: [
- * 	{ id: 't', name: 'T', run: { via: 'function', name: 'compile' } },
+ * 	{ id: 't', name: 'T', run: 'compile' },
  * ] }] }
- * const result = await runner.execute(definition) // builds + drives the tree
+ * const result = await runner.execute(definition, {
+ * 	functions: { compile: async (controller) => `built ${controller.task.id}` },
+ * })
  * result.status // 'completed'
  * result.workflow.phase('p')?.task('t')?.status // 'completed'
  * ```
@@ -568,25 +670,26 @@ export declare function createWorkflowRunner(options?: WorkflowRunnerOptions): W
 
 /**
  * Wrap a {@link WorkflowDefinition} as an LLM-callable {@link ToolInterface} — it ADVERTISES
- * the SIMPLE flat authoring shape (`{ name?, steps: [{ name, via? }] }`) as its `parameters` so
+ * the SIMPLE flat authoring shape (`{ name?, steps: [{ name }] }`) as its `parameters` so
  * even a small model can author a complete tree, and its handler EXPANDS / COMPLETES the
  * authored blob, validates it against the STRICT contract, runs it through `runner`, and
  * returns the run SUMMARY (throwing a typed {@link WorkflowError} on failure).
  *
  * @remarks
  * A plain {@link ToolManagerInterface}-compatible tool (so `createMCPServer` / `createMCPRoutes`
- * expose it for free — nothing MCP is wired here). It is ALSO the propagation carrier the
- * {@link WorkflowRunner} binds onto a dispatched subagent (W-c2): because a tool handler receives
- * ONLY the model-supplied `args` (no ambient context, no signal), the run's depth + ancestry are
- * CLOSED OVER at bind time via {@link WorkflowToolOptions}, and the handler runs the nested
- * workflow at `depth + 1` with the extended ancestry.
+ * expose it for free — nothing MCP is wired here). It is ALSO the propagation carrier
+ * {@link createAgentFunction} binds onto a wrapped agent's `context.tools`: because a tool
+ * handler receives ONLY the model-supplied `args` (no ambient context, no signal), the run's
+ * depth + ancestry are CLOSED OVER at bind time via {@link WorkflowToolOptions}, and the
+ * handler enforces the SAME depth / cycle guard itself (this function owns it now — the engine
+ * carries none) before running the nested workflow at `depth + 1` with the extended ancestry.
  *
  * **Widened authoring surface (additive — the canonical contract + runner stay STRICT and
  * unchanged).** A 2B model reliably CALLS the tool but cannot reliably emit the full four-level
- * nested {@link WorkflowDefinition} (six required `id`/`name` strings, a nested tagged union,
- * all-or-nothing). So the tool ACCEPTS three authoring forms and converges them on the SAME
- * strict {@link createWorkflowContract} gate before running (soundness preserved):
- * - the FLAT shape `{ name?, steps: [{ name, via? }] }` — the ADVERTISED `parameters` (the simplest
+ * nested {@link WorkflowDefinition} (six required `id`/`name` strings, an all-or-nothing tree).
+ * So the tool ACCEPTS three authoring forms and converges them on the SAME strict
+ * {@link createWorkflowContract} gate before running (soundness preserved):
+ * - the FLAT shape `{ name?, steps: [{ name }] }` — the ADVERTISED `parameters` (the simplest
  *   form, {@link import('./helpers.js').expandSteps}'d into one one-task phase per step);
  * - a nested DRAFT with any `id`/`name` OMITTED — {@link createWorkflowDraftContract}-parsed then
  *   {@link import('./helpers.js').completeDraft}'d (missing ids synthesized positionally);
@@ -608,9 +711,15 @@ export declare function createWorkflowRunner(options?: WorkflowRunnerOptions): W
  *   gate (e.g. an explicit empty `id`, `concurrency: 0`) ⇒ THROW a `TOOL` {@link WorkflowError} (no run).
  * - **Over-deep / cyclic** ⇒ THROW a `DEPTH` {@link WorkflowError} when the nested run would exceed
  *   {@link MAX_WORKFLOW_DEPTH}, or the target workflow id is already an ancestor (a cycle) — the
- *   same `code` the agent-task guard raises.
- * - **Otherwise** ⇒ `runner.execute(target, { depth: depth + 1, ancestry: … })`, RETURNING the
- *   plain summary of the terminal run (`{ status, count }`, via {@link workflowToolSummary}).
+ *   SAME `code` {@link createAgentFunction}'s own guard raises. Enforced HERE, INSIDE this
+ *   handler, before ever calling `runner.execute` — the engine itself performs no such check.
+ * - **Otherwise** ⇒ `runner.execute(target)`, RETURNING the plain summary of the terminal run
+ *   (`{ status, count }`, via {@link workflowToolSummary}).
+ *
+ * The tool executes AUTHORED STRUCTURE, not consumer behavior: a nested tree authored through
+ * it (flat, draft, or full form) carries no {@link WorkflowFunctions} registry, so EVERY one of
+ * its tasks auto-completes under the no-handler rule. This handler validates and synthesizes
+ * shape — it never runs a caller's handlers.
  *
  * @param definition - The workflow the tool runs when called with no authored args
  * @param runner - The {@link WorkflowRunnerInterface} that executes the (nested) workflow
@@ -702,17 +811,23 @@ export declare const DEFAULT_BAIL = false;
 /**
  * The default per-phase task concurrency the {@link import('./factories.js').createWorkflowRunner}
  * runner applies when a {@link import('./types.js').PhaseDefinition} omits its `concurrency`
- * throttle — a large cap that is effectively unbounded for any realistic phase.
+ * throttle — a cap that is effectively unbounded for any realistic phase.
  *
  * @remarks
  * The determinism principle fixes that a phase's tasks run CONCURRENTLY; `concurrency` is
  * only an optional resource throttle (max-in-flight). With none declared, the runner runs
- * all of a phase's tasks at once — modelled as this large finite cap so the value flows
- * straight into the substrate {@link import('./types.js').RunnerInterface}'s
- * `concurrency` (which expects a positive integer) without a special unbounded branch. No
- * realistic phase declares enough tasks to reach it, so it behaves as "run them all".
+ * all of a phase's tasks at once — modelled as this finite cap so the value flows straight
+ * into the substrate {@link import('./types.js').RunnerInterface}'s `concurrency` (which
+ * expects a positive integer) without a special unbounded branch. No realistic phase
+ * declares enough tasks to reach it, so it behaves as "run them all".
+ *
+ * WHY `1024` and not a huge sentinel like `1_000_000`: the backing `@orkestrel/queue` Runner
+ * EAGERLY spawns one parked worker loop per concurrency unit AT CONSTRUCTION, so this default
+ * must be a value whose eager allocation cost is negligible for every default-concurrency
+ * phase — a million-unit default meant ~1e6 promise/closure allocations per such phase. A
+ * phase may still DECLARE a larger explicit `concurrency` and pays that allocation knowingly.
  */
-export declare const DEFAULT_PHASE_CONCURRENCY = 1000000;
+export declare const DEFAULT_PHASE_CONCURRENCY = 1024;
 
 /**
  * A promise paired with its externally-callable `resolve`/`reject` — the settle path
@@ -733,10 +848,12 @@ export declare interface DeferredInterface<T> {
  *
  * @remarks
  * The structural fields (`id` / `name` / `description` + the ordered phases / tasks)
- * carry over verbatim; the W-b live tree is the DECLARATIVE state machine, so the
- * execution-only definition fields (per-phase `run` / `concurrency`, per-task `retries` /
- * `timeout`) are intentionally dropped (W-c reads them from the definition when it drives
- * transitions). The `bail` policy carries over — at the workflow tier AND, per phase, the
+ * carry over verbatim, as does each phase's `concurrency` (persisted on the
+ * {@link PhaseSnapshot} so a restore reinstates the same throttle) and each task's `run` /
+ * `retries` / `timeout` (persisted on the {@link TaskSnapshot}, like `bail` / `concurrency`,
+ * so a restore + a {@link import('./types.js').WorkflowOptions.functions} registry resumes
+ * real work). The `bail` policy carries over — at the
+ * workflow tier AND, per phase, the
  * EFFECTIVE policy (`phase.bail ?? workflowBail`) on each {@link PhaseSnapshot} — so the seeded
  * snapshot is self-contained; a fresh seed has no `override`. `created` / `updated` are stamped now.
  * {@link import('./factories.js').createWorkflow} builds from this.
@@ -754,6 +871,34 @@ export declare interface DeferredInterface<T> {
  */
 export declare function definitionToSnapshot(definition: WorkflowDefinition, bail?: boolean): WorkflowSnapshot;
 
+/**
+ * Derive the PENDING SUFFIX boundary of a positional list of {@link LifecycleStatus}es —
+ * the index of the first entry in the contiguous trailing run of `pending` entries.
+ *
+ * @remarks
+ * The native, hook-free replacement for a runner-installed cursor (AGENTS §12): a
+ * {@link import('./types.js').WorkflowInterface}'s `add` / `remove` / `move` / `update`
+ * reads this over its live phases' statuses to decide which positions are safe to edit.
+ * Because entries run SEQUENTIALLY (phases sequential, AGENTS determinism), every
+ * already-started entry forms a contiguous LEADING prefix and every still-`pending`
+ * entry forms the trailing suffix — so the boundary is simply the count of leading
+ * non-`pending` entries: the index of the first `pending` entry, or the full length when
+ * none is `pending` (nothing is safely editable). A `pending` container's entries are ALL
+ * `pending`, so the boundary is `0` and every position is naturally accepted — callers
+ * need no special case for that.
+ *
+ * @param statuses - The positional list of statuses to derive the boundary from
+ * @returns The index of the first `pending` entry, or `statuses.length` when none is `pending`
+ *
+ * @example
+ * ```ts
+ * deriveBoundary(['completed', 'running', 'pending', 'pending']) // 2
+ * deriveBoundary(['pending', 'pending']) // 0
+ * deriveBoundary(['completed', 'completed']) // 2 (nothing pending)
+ * ```
+ */
+export declare function deriveBoundary(statuses: readonly LifecycleStatus[]): number;
+
 /**
  * Derive a phase's status from its tasks' statuses (tasks are concurrent, so this
  * is an order-insensitive reduction).
@@ -814,41 +959,80 @@ export declare function deriveWorkflowStatus(phases: readonly PhaseDerivation[])
  * @remarks
  * The expansion of the tool's ADVERTISED surface (AGENTS §21 — the simplest form a small
  * model can author). Each {@link WorkflowStep} maps to a phase holding exactly one task:
- * the step's `name` becomes the task's `run.name`, and its `via` becomes the task's `run.via`
- * (defaulting to `'function'` when omitted). Ids/names are auto-filled positionally — it
- * builds an ids-omitted {@link WorkflowDraft} and delegates to {@link completeDraft}, so the
- * two lenient surfaces share ONE synthesis path (step `i` → phase `phase-<i>`, its task
- * `phase-<i>-task-0`). The optional `name` becomes the workflow's `name`. The result is a
- * complete definition the caller validates against the STRICT contract before running.
- *
- * @param flat - The flat steps blob (`{ name?, steps: [{ name, via? }] }`)
+ * the step's `name` becomes the task's `run` (the behavior-registry key). Ids/names are
+ * auto-filled positionally — it builds an ids-omitted {@link WorkflowDraft} and delegates
+ * to {@link completeDraft}, so the two lenient surfaces share ONE synthesis path (step `i`
+ * → phase `phase-<i>`, its task `phase-<i>-task-0`). The optional `name` becomes the
+ * workflow's `name`. The result is a complete definition the caller validates against the
+ * STRICT contract before running.
+ *
+ * @param flat - The flat steps blob (`{ name?, steps: [{ name }] }`)
  * @returns A complete {@link WorkflowDefinition} (one one-task phase per step)
  */
 export declare function expandSteps(flat: WorkflowSteps): WorkflowDefinition;
 
 /**
- * Narrow a {@link TaskForm} to the `agent` form — a task that runs a registered
- * agent (a subagent).
+ * Box an error as a {@link Failure} — the graceful outcome half of a {@link Result}.
+ *
+ * @typeParam E - The boxed error's type
+ * @param error - The error to box
+ * @returns A {@link Failure} wrapping `error`
+ *
+ * @example
+ * ```ts
+ * const result = failure(new WorkflowError('MUTATION', 'refused')) // { success: false, error }
+ * ```
+ */
+export declare function failure<E>(error: E): Failure<E>;
+
+/**
+ * Find the first {@link TaskResult} in a positional list whose boxed outcome is a
+ * `Failure` — the pure scan shared by a phase's and a workflow's derived-`failed`
+ * `fail`-event lookup.
+ *
+ * @remarks
+ * The shared leaf behind {@link import('./phases/Phase.js').Phase} and
+ * {@link import('./Workflow.js').Workflow}'s own `#failure` — each gathers ITS tier's
+ * results (a phase's own settled tasks, a workflow's flattened `results()`) and feeds
+ * them here; the tier-local method keeps the §12 invariant throw (a derived `failed`
+ * status guarantees a failing result exists) since throwing on `undefined` is
+ * orchestration, not a leaf concern.
  *
- * @param form - The task form to test
- * @returns `true` when `form.via` is `'agent'`
+ * @param results - The results to scan, in any order
+ * @returns The first result whose `result.success` is `false`, or `undefined` if none
+ *
+ * @example
+ * ```ts
+ * findFailure([completedResult, failedResult]) // failedResult
+ * ```
  */
-export declare function isAgentTask(form: TaskForm): form is {
-    readonly via: 'agent';
-    readonly name: string;
-};
+export declare function findFailure(results: readonly TaskResult[]): TaskResult | undefined;
 
 /**
- * Narrow a {@link TaskForm} to the `function` form — a task that runs a registered
- * function.
+ * Insert one `[key, value]` entry at a positional index into a readonly entries array —
+ * the pure splice-in step behind an insertion-ordered registry's `add`.
  *
- * @param form - The task form to test
- * @returns `true` when `form.via` is `'function'`
+ * @remarks
+ * Shared by {@link import('./tasks/TaskManager.js').TaskManager} and
+ * {@link import('./phases/PhaseManager.js').PhaseManager}: both convert their
+ * insertion-ordered `Map` to `[...map.entries()]`, call this to splice the new entry
+ * in at the target index, then rebuild the `Map` from the result (a stateful step that
+ * stays a `#` private method — this helper does no `Map` construction). Does not
+ * mutate `entries`; returns a new array.
+ *
+ * @typeParam T - The entry's value type
+ * @param entries - The current positional entries, in order
+ * @param index - The index to insert at (`0` prepends, `entries.length` appends)
+ * @param key - The new entry's key
+ * @param value - The new entry's value
+ * @returns A new entries array with `[key, value]` inserted at `index`
+ *
+ * @example
+ * ```ts
+ * insertEntry([['a', 1], ['b', 2]], 1, 'c', 3) // [['a', 1], ['c', 3], ['b', 2]]
+ * ```
  */
-export declare function isFunctionTask(form: TaskForm): form is {
-    readonly via: 'function';
-    readonly name: string;
-};
+export declare function insertEntry<T>(entries: readonly (readonly [string, T])[], index: number, key: string, value: T): readonly (readonly [string, T])[];
 
 /**
  * Test whether a {@link LifecycleStatus} is TERMINAL — a node in this state will not
@@ -867,17 +1051,6 @@ export declare function isFunctionTask(form: TaskForm): form is {
  */
 export declare function isTerminalStatus(status: LifecycleStatus): boolean;
 
-/**
- * Narrow a {@link TaskForm} to the `tool` form — a task that runs a registered tool.
- *
- * @param form - The task form to test
- * @returns `true` when `form.via` is `'tool'`
- */
-export declare function isToolTask(form: TaskForm): form is {
-    readonly via: 'tool';
-    readonly name: string;
-};
-
 /**
  * Narrow an unknown caught value to a {@link WorkflowError}.
  *
@@ -932,16 +1105,17 @@ export declare function isWorkflowSnapshot(value: unknown): value is WorkflowSna
 export declare type LifecycleStatus = 'pending' | 'running' | 'completed' | 'failed' | 'skipped' | 'stopped';
 
 /**
- * The maximum nesting depth a workflow's `agent` task may spawn into (W-c) — the
- * bound the runner's depth/cycle guard enforces.
+ * The maximum nesting depth a workflow → agent → workflow chain may reach — the bound
+ * the {@link import('./factories.js').createAgentFunction} and
+ * {@link import('./factories.js').createWorkflowTool} adapters' depth/cycle guards enforce.
  *
  * @remarks
- * The limit lives in ONE place. The `agent` {@link import('./types.js').TaskForm} is
- * bounded by it when the {@link import('./WorkflowRunner.js').WorkflowRunner} resolves a
- * subagent: an agent running at this depth can no longer author + run a nested workflow
- * (that would be depth `MAX_WORKFLOW_DEPTH + 1`), so the over-deep `agent` task is
- * rejected (a typed `DEPTH` `task.fail`). The chain therefore nests workflows down to
- * this depth, and the `agent` task in the depth-`MAX_WORKFLOW_DEPTH` workflow fails.
+ * The limit lives in ONE place. An {@link import('./factories.js').createAgentFunction}-wrapped
+ * agent running at this depth can no longer author + run a NESTED workflow through its bound
+ * workflow tool (that would be depth `MAX_WORKFLOW_DEPTH + 1`), so the over-deep invocation is
+ * REJECTED (a typed `DEPTH` {@link import('./errors.js').WorkflowError} throw). The chain
+ * therefore nests workflows down to this depth, and the nested run at
+ * depth `MAX_WORKFLOW_DEPTH` fails.
  */
 export declare const MAX_WORKFLOW_DEPTH = 8;
 
@@ -990,6 +1164,54 @@ export declare class MemoryWorkflowStore implements WorkflowStoreInterface {
     delete(id: string): Promise<void>;
 }
 
+/**
+ * Reposition the entry keyed `key` to a new positional index in a readonly entries
+ * array — the pure remove-then-reinsert step behind an insertion-ordered registry's
+ * `move`.
+ *
+ * @remarks
+ * The move counterpart of {@link insertEntry}: finds the entry by `key`, splices it
+ * out, then splices it back in at `index`. An absent `key` is a no-op (returns a copy
+ * of `entries` unchanged) — the caller (`TaskManager.move` / `PhaseManager.move`)
+ * already gates on the target's existence before calling this, so the no-op branch is
+ * defensive, never reached in practice. Does not mutate `entries`; returns a new array.
+ *
+ * @typeParam T - The entry's value type
+ * @param entries - The current positional entries, in order
+ * @param key - The key of the entry to reposition
+ * @param index - The new index for the entry
+ * @returns A new entries array with the `key` entry repositioned to `index`
+ *
+ * @example
+ * ```ts
+ * moveEntry([['a', 1], ['b', 2], ['c', 3]], 'a', 2) // [['b', 2], ['c', 3], ['a', 1]]
+ * ```
+ */
+export declare function moveEntry<T>(entries: readonly (readonly [string, T])[], key: string, index: number): readonly (readonly [string, T])[];
+
+/**
+ * Park until `signal` aborts — a promise-parked wait (AGENTS §21), never a timer or
+ * busy-loop, that NEVER rejects.
+ *
+ * @remarks
+ * Resolves IMMEDIATELY when `signal` is already aborted; otherwise attaches a one-shot
+ * `abort` listener and resolves when it fires, removing the listener either way. The
+ * shared leaf behind the duplicate abort-wiring an execution engine otherwise hand-rolls
+ * at every fold point.
+ *
+ * @param signal - The signal to park on
+ * @returns A promise that resolves once `signal` has aborted
+ *
+ * @example
+ * ```ts
+ * const controller = new AbortController()
+ * const parked = parkSignal(controller.signal)
+ * controller.abort()
+ * await parked // resolves
+ * ```
+ */
+export declare function parkSignal(signal: AbortSignal): Promise<void>;
+
 /**
  * The live DERIVED state machine (W-b) for one phase — an observable (AGENTS §13) whose
  * {@link PhaseStatus} is computed from its tasks (never set directly) and recomputed
@@ -1011,10 +1233,38 @@ export declare class MemoryWorkflowStore implements WorkflowStoreInterface {
  *   `start` / `complete` / `fail` / `stop` on a derived-status CHANGE, strictly AFTER the
  *   recompute + escalate; the emitter isolates a listener throw and routes it to its `error`
  *   handler (the `error` option); `fail` carries the failing task's {@link TaskResult}.
+ * - **Structural API (AGENTS §7).** `add` / `remove` / `move` / `update` gate BEFORE
+ *   delegating to {@link tasks} (the manager gates the target's own existence/status/id/
+ *   bounds), then emit the matching {@link PhaseEventMap} event on success only. NATIVE
+ *   gating, purely from this phase's own derived `status` (no runner-installed hook): while
+ *   `pending`, any valid `index` is accepted; while `running`, `add` accepts ONLY a pure
+ *   append (a live runner subscribed to the `add` event picks it up), and `remove` / `move` /
+ *   `update` always fail gracefully (the tasks are already handed to the execution
+ *   substrate); while terminal, everything is refused.
+ * - **Patch (AGENTS §12).** `patch` applies a validated {@link PhaseUpdate} to SELF
+ *   (`name` / `description` / `concurrency` / `bail`) — defense-in-depth: it throws a
+ *   `MUTATION` {@link WorkflowError} unless this phase's own `status` is `pending`, mirroring
+ *   the owning {@link WorkflowInterface.update}'s gate.
+ * - **Minting (AGENTS §7).** {@link add} MINTS a live {@link Task} from a {@link TaskDefinition}
+ *   (converts it to a {@link TaskSnapshot}, builds the task wired to THIS phase) — the same
+ *   construction path {@link #append} uses at build time, so a live mint and a restored/built
+ *   task are wired IDENTICALLY. At construction, the workflow-level
+ *   {@link import('../types.js').WorkflowFunctions} registry (threaded from
+ *   {@link import('../types.js').WorkflowOptions.functions}) resolves each task's `run` name into
+ *   its runtime {@link import('../types.js').TaskInterface.handler} ONCE; a `run` that is omitted
+ *   or unregistered resolves to no handler (the no-handler rule).
+ * - **Runtime lifecycle (AGENTS §10).** `pause` / `resume` / `wait` mirror the workflow's own
+ *   quartet, scoped to this phase — a driving
+ *   {@link import('../types.js').WorkflowRunnerInterface.execute} gates a task's own
+ *   pre-dispatch on the workflow's gate FIRST, then this phase's gate, WITHOUT touching
+ *   {@link status} — `paused` is runtime-only, never persisted. `skip` / `stop` (this phase's
+ *   own terminal forcing) always release a parked {@link wait} waiter, mirroring
+ *   {@link import('../Workflow.js').Workflow.destroy}'s cascade — a permanently-ended phase
+ *   has nothing left to pause for.
  */
 export declare class Phase implements PhaseInterface {
     #private;
-    constructor(snapshot: PhaseSnapshot, workflow: WorkflowInterface, escalate: () => void, options?: PhaseOptions, bail?: boolean);
+    constructor(snapshot: PhaseSnapshot, workflow: WorkflowInterface, escalate: () => void, options?: PhaseOptions, bail?: boolean, functions?: WorkflowFunctions);
     get emitter(): EmitterInterface<PhaseEventMap>;
     get id(): string;
     get name(): string;
@@ -1022,12 +1272,22 @@ export declare class Phase implements PhaseInterface {
     get context(): PhaseContext;
     get workflow(): WorkflowInterface;
     get bail(): boolean;
+    get concurrency(): number | undefined;
+    get paused(): boolean;
     get status(): PhaseStatus;
     get tasks(): TaskManagerInterface;
     task(id: string): TaskInterface | undefined;
     results(): readonly TaskResult[];
     skip(): void;
     stop(): void;
+    pause(): void;
+    resume(): void;
+    wait(): Promise<void>;
+    add(definition: TaskDefinition, index?: number): Result<TaskInterface, WorkflowError>;
+    remove(id: string): Result<TaskInterface, WorkflowError>;
+    move(id: string, index: number): Result<TaskInterface, WorkflowError>;
+    update(id: string, patch: TaskUpdate): Result<TaskInterface, WorkflowError>;
+    patch(value: PhaseUpdate): void;
     snapshot(): PhaseSnapshot;
 }
 
@@ -1082,6 +1342,7 @@ export declare interface PhaseDefinition {
  * The snapshot persists the EFFECTIVE failure policy this phase runs under: the phase's own
  * `bail` when it declares one, else the `workflowBail` it inherits — so a restore reinstates
  * the same per-phase policy without a silent default (`effectiveBail = phase.bail ?? workflowBail`).
+ * `concurrency` (the resource throttle) carries over verbatim, omitted when undefined.
  *
  * @param phase - The phase definition to seed from
  * @param workflowBail - The workflow-level `bail` default the phase inherits when it declares none
@@ -1130,16 +1391,7 @@ export declare const phaseDraftShape: ObjectShape<{
         id: OptionalShape<StringShape>;
         name: OptionalShape<StringShape>;
         description: OptionalShape<StringShape>;
-        run: UnionShape<[ ObjectShape<{
-            via: LiteralShape<readonly ["function"]>;
-            name: StringShape;
-        }>, ObjectShape<{
-            via: LiteralShape<readonly ["tool"]>;
-            name: StringShape;
-        }>, ObjectShape<{
-            via: LiteralShape<readonly ["agent"]>;
-            name: StringShape;
-        }>]>;
+        run: OptionalShape<StringShape>;
         retries: OptionalShape<NumberShape>;
         timeout: OptionalShape<NumberShape>;
     }>>;
@@ -1154,9 +1406,12 @@ export declare const phaseDraftShape: ObjectShape<{
  * @remarks
  * `start` fires when the phase begins; `complete` when all its tasks settled
  * successfully; `fail` when a task failed under `bail` (carrying the
- * {@link TaskResult}); `stop` when the phase was ended. A throwing listener is
- * isolated by the emitter and routed to its `error` handler, not the domain surface
- * (AGENTS §13). A `type` alias (AGENTS §4.5) so it satisfies `EventMap`.
+ * {@link TaskResult}); `stop` when the phase was ended. `add` / `remove` / `move` /
+ * `update` fire on a successful structural or patch edit through
+ * {@link PhaseInterface.add} / `remove` / `move` / `update` (AGENTS §7) — never on a
+ * refused/gated one. A throwing listener is isolated by the emitter and routed to its
+ * `error` handler, not the domain surface (AGENTS §13). A `type` alias (AGENTS §4.5)
+ * so it satisfies `EventMap`.
  */
 export declare type PhaseEventMap = {
     /** The phase began — its `id`. */
@@ -1167,6 +1422,14 @@ export declare type PhaseEventMap = {
     readonly fail: readonly [result: TaskResult];
     /** The phase was permanently stopped. */
     readonly stop: readonly [];
+    /** A task was inserted — the inserted task + its final index. */
+    readonly add: readonly [task: TaskInterface, index: number];
+    /** A task was removed — the removed task. */
+    readonly remove: readonly [task: TaskInterface];
+    /** A task was repositioned — the moved task + its new index. */
+    readonly move: readonly [task: TaskInterface, index: number];
+    /** A task was patched — the patched task. */
+    readonly update: readonly [task: TaskInterface];
 };
 
 /** Initial {@link PhaseEventMap} listeners — the reserved `on` option (AGENTS §8). */
@@ -1194,6 +1457,12 @@ export declare type PhaseInput = Partial<PhaseContext>;
  * - **Observable (AGENTS §13).** The owned {@link emitter} ({@link PhaseEventMap}) fires
  *   `start` / `complete` / `fail` / `stop` on a derived-status change; the emitter isolates a
  *   listener throw and routes it to its `error` handler (the `error` option).
+ * - **Runtime lifecycle (AGENTS §10).** `pause` / `resume` / `wait` mirror
+ *   {@link WorkflowInterface.pause} / `resume` / `wait`, scoped to this phase — a driving
+ *   {@link WorkflowRunnerInterface.execute} gates a task's own pre-dispatch on BOTH the
+ *   workflow's and its phase's gate. `paused` is RUNTIME-ONLY, never persisted; idempotent;
+ *   released by `resume` and by this phase's own `stop` / `skip` forcing a terminal status
+ *   (a permanently-ended phase has nothing left to pause for).
  */
 export declare interface PhaseInterface {
     readonly emitter: EmitterInterface<PhaseEventMap>;
@@ -1205,13 +1474,167 @@ export declare interface PhaseInterface {
     readonly status: PhaseStatus;
     /** The RESOLVED effective failure policy this phase runs under (`phase.bail ?? workflow.bail`); mirrors {@link WorkflowInterface.bail}. */
     readonly bail: boolean;
+    /** Max tasks in flight at once (a resource throttle); mirrors {@link PhaseSnapshot.concurrency}. `undefined` ⇒ unbounded. */
+    readonly concurrency: number | undefined;
+    /**
+     * Whether the phase is currently paused (AGENTS §10 — resumable); RUNTIME-ONLY — never a
+     * {@link PhaseStatus}, never persisted in a {@link PhaseSnapshot} (a paused phase's
+     * `status` still reports its ordinary derived value).
+     */
+    readonly paused: boolean;
     readonly tasks: TaskManagerInterface;
     /** Look up one live task by its `id`. */
     task(id: string): TaskInterface | undefined;
     /** The settled tasks' results, in positional order — the phase tier of the result tree. */
     results(): readonly TaskResult[];
+    /**
+     * FORCE this phase to `skipped` (AGENTS §10), overriding the derived value; idempotent.
+     *
+     * @remarks
+     * A NO-OP once `status` is already terminal — a settled phase cannot be re-forced. Always
+     * releases a parked {@link wait} waiter regardless (a terminal phase has nothing left to
+     * pause for).
+     */
     skip(): void;
+    /**
+     * FORCE this phase to `stopped` (AGENTS §10), overriding the derived value; idempotent.
+     *
+     * @remarks
+     * A NO-OP once `status` is already terminal (a settled phase cannot be re-forced). Always
+     * releases a parked {@link wait} waiter regardless (a terminal phase has nothing left to
+     * pause for).
+     */
     stop(): void;
+    /**
+     * Suspend the phase (AGENTS §10 — resumable); idempotent.
+     *
+     * @remarks
+     * A no-op when already `paused` or when `status` is terminal. RUNTIME-ONLY (AGENTS §10) —
+     * never a {@link PhaseStatus}, never persisted in a {@link PhaseSnapshot}. A driving
+     * {@link WorkflowRunnerInterface.execute} gates a task's own pre-dispatch on this phase's
+     * gate (after the workflow's own gate). **Pausing does NOT suspend a driving run's
+     * timeout / budget / abort clocks** — those bounds keep ticking while paused, so a long
+     * pause can still fire a run-level cancel and stop the workflow while parked.
+     *
+     * @example
+     * ```ts
+     * phase.pause()
+     * phase.paused // true
+     * ```
+     */
+    pause(): void;
+    /**
+     * Continue a paused phase (AGENTS §10); idempotent — a no-op unless {@link paused}.
+     *
+     * @example
+     * ```ts
+     * phase.resume()
+     * phase.paused // false
+     * ```
+     */
+    resume(): void;
+    /**
+     * Park until this phase is not paused — **promise-parked**, never a timer or busy-loop
+     * (AGENTS §21; mirrors {@link WorkflowInterface.wait}).
+     *
+     * @remarks
+     * Resolves IMMEDIATELY when not {@link paused}. While paused, parks until `resume` or
+     * this phase's own `stop` / `skip` forcing a terminal status — all release a parked
+     * waiter. NEVER rejects.
+     *
+     * @returns A promise that resolves once the phase is no longer paused
+     */
+    wait(): Promise<void>;
+    /**
+     * MINT a live {@link TaskInterface} from `definition` and insert it into this phase
+     * (AGENTS §7 the entity structural API) — gated BEFORE delegating to {@link tasks}'
+     * manager.
+     *
+     * @remarks
+     * Converts `definition` → {@link TaskSnapshot} and constructs the live task (wired to
+     * THIS phase, its recompute cascade, and its emitter hooks), carrying its `run` /
+     * `retries` / `timeout` from `definition` and resolving its {@link TaskInterface.handler}
+     * against the workflow-level {@link WorkflowOptions.functions} registry — the SAME
+     * resolution {@link import('./factories.js').createWorkflow} performs at build time.
+     * Requires `definition.id` to be UNIQUE among this phase's existing
+     * task ids — a duplicate is a `MUTATION` failure (mirrors
+     * {@link TaskManagerInterface.add}'s own duplicate-id gate).
+     *
+     * NATIVE gating, purely from this phase's own derived `status` (AGENTS §12 — no
+     * runner-installed hook), UNCHANGED from the entity-taking predecessor. While
+     * `pending`: any valid `index` is accepted (delegates the minted task to
+     * {@link TaskManagerInterface.add} then emits `add`). While `running`: accepted ONLY as
+     * a pure append (`index` omitted or `=== tasks.count`) — a live runner subscribed to
+     * the `add` event picks the new task up for same-run execution; the derived-status
+     * model guarantees this phase cannot reach a terminal status while the accepted task is
+     * still `pending` (its status feeds `status` via {@link import('./helpers.js').derivePhaseStatus}).
+     * While terminal: always refused.
+     *
+     * **Abort edge.** An append ACCEPTED while `running` can still settle `skipped` rather
+     * than run — if the driving run is cancelled (abort / timeout / budget / `workflow.destroy()`)
+     * before the substrate actually dispatches the newly-minted task, the runner's halt sweep
+     * `skip`s it like any other not-yet-started task. Acceptance here only guarantees the task
+     * is WIRED into the live tree, not that it will execute.
+     *
+     * @param definition - The {@link TaskDefinition} to mint a live task from
+     * @param index - The insertion position; omitted inserts at the end
+     * @returns A {@link Result} boxing the minted, inserted task, or a `MUTATION` failure
+     */
+    add(definition: TaskDefinition, index?: number): Result<TaskInterface, WorkflowError>;
+    /**
+     * Remove the `pending` task `id` from this phase.
+     *
+     * @remarks
+     * NATIVE gating: allowed only while this phase's own `status` is `pending`. While
+     * `running` or terminal, always a `MUTATION` failure — a running phase's tasks are
+     * already handed to the execution substrate and only a pure {@link add} append remains
+     * possible.
+     *
+     * @param id - The task id to remove
+     * @returns A {@link Result} boxing the removed task, or a `MUTATION` failure
+     */
+    remove(id: string): Result<TaskInterface, WorkflowError>;
+    /**
+     * Reposition the `pending` task `id` to `index` within this phase.
+     *
+     * @remarks
+     * NATIVE gating: allowed only while this phase's own `status` is `pending`; `running` /
+     * terminal always fail (see {@link remove}).
+     *
+     * @param id - The task id to move
+     * @param index - The destination position
+     * @returns A {@link Result} boxing the moved task, or a `MUTATION` failure
+     */
+    move(id: string, index: number): Result<TaskInterface, WorkflowError>;
+    /**
+     * Apply a validated {@link TaskUpdate} patch to the `pending` task `id` in this phase.
+     *
+     * @remarks
+     * NATIVE gating: allowed only while this phase's own `status` is `pending`; `running` /
+     * terminal always fail (see {@link remove}).
+     *
+     * @param id - The task id to patch
+     * @param patch - The fields to update
+     * @returns A {@link Result} boxing the patched task, or a `MUTATION` failure
+     */
+    update(id: string, patch: TaskUpdate): Result<TaskInterface, WorkflowError>;
+    /**
+     * Apply a validated declarative patch to SELF (`name` / `description` /
+     * `concurrency` / `bail`).
+     *
+     * @remarks
+     * Defense-in-depth (AGENTS §12): the owning {@link WorkflowInterface.update} gates
+     * FIRST, so a direct call here THROWS a `MUTATION`
+     * {@link import('./errors.js').WorkflowError} unless this phase's own `status` is
+     * `pending`.
+     *
+     * @param value - The {@link PhaseUpdate} fields to apply
+     * @example
+     * ```ts
+     * phase.patch({ concurrency: 4 })
+     * ```
+     */
+    patch(value: PhaseUpdate): void;
     snapshot(): PhaseSnapshot;
 }
 
@@ -1225,6 +1648,11 @@ export declare interface PhaseInterface {
  *   `append` adds one at the end, `phase(id)` looks one up, `phases()` lists them in
  *   positional order, `count` is the size. A snapshot RESTORE re-`append`s in the
  *   snapshot's order, reproducing it exactly.
+ * - **Gated mutation API (AGENTS §12).** `add` / `remove` / `move` / `update` are the
+ *   graceful `Result` counterparts to `append`, gating ONLY on the target's OWN
+ *   existence/status/id/bounds — a duplicate id, an absent/non-`pending` target, an
+ *   out-of-bounds `index`, or a patch that fails {@link phaseUpdateShape} validation
+ *   all fail gracefully with a `MUTATION` {@link WorkflowError} instead of throwing.
  * - **No batch matrix.** A workflow's phases are a fixed positional set, so AGENTS §9.2
  *   is deliberately omitted.
  * - **Event-free.** A purely structural container — the live {@link PhaseInterface}s own
@@ -1242,6 +1670,10 @@ export declare class PhaseManager implements PhaseManagerInterface {
     #private;
     get count(): number;
     append(phase: PhaseInterface): void;
+    add(phase: PhaseInterface, index?: number): Result<PhaseInterface, WorkflowError>;
+    remove(id: string): Result<PhaseInterface, WorkflowError>;
+    move(id: string, index: number): Result<PhaseInterface, WorkflowError>;
+    update(id: string, patch: PhaseUpdate): Result<PhaseInterface, WorkflowError>;
     phase(id: string): PhaseInterface | undefined;
     phases(): readonly PhaseInterface[];
 }
@@ -1253,10 +1685,61 @@ export declare class PhaseManager implements PhaseManagerInterface {
  * @remarks
  * `append` adds one live {@link PhaseInterface} at the end; `phase(id)` looks one up;
  * `phases()` lists them in positional order; `count` is the tally. No batch matrix.
+ * `add` / `remove` / `move` / `update` (AGENTS §12) are the GATED mutation
+ * counterparts a {@link WorkflowInterface.add} / `remove` / `move` / `update`
+ * delegates to AFTER its own container-status/hook gating — the manager gates ONLY
+ * on the target's OWN existence/status/id/bounds and stays event-free (the entity
+ * emits on success).
  */
 export declare interface PhaseManagerInterface {
     readonly count: number;
+    /**
+     * Add `phase` at the end (the build-time wiring path).
+     *
+     * @remarks
+     * THROWS a `MUTATION` {@link import('./errors.js').WorkflowError} on a duplicate
+     * `id` (a genuine programmer error — a build-time wiring bug, AGENTS §12) instead of
+     * silently overwriting the existing entry.
+     *
+     * @param phase - The live phase to append
+     */
     append(phase: PhaseInterface): void;
+    /**
+     * Insert `phase` at `index` (default the end) — the GATED mutation counterpart to
+     * {@link append}: a duplicate `id` or an out-of-bounds `index` fails gracefully
+     * instead of throwing.
+     *
+     * @param phase - The live phase to insert
+     * @param index - The insertion position (`[0, count]`); omitted inserts at the end
+     * @returns A {@link Result} boxing the inserted phase, or a `MUTATION` failure
+     */
+    add(phase: PhaseInterface, index?: number): Result<PhaseInterface, WorkflowError>;
+    /**
+     * Remove the `pending` phase `id`.
+     *
+     * @param id - The phase id to remove
+     * @returns A {@link Result} boxing the removed phase, or a `MUTATION` failure when
+     *   `id` is absent or not `pending`
+     */
+    remove(id: string): Result<PhaseInterface, WorkflowError>;
+    /**
+     * Reposition the `pending` phase `id` to `index`.
+     *
+     * @param id - The phase id to move
+     * @param index - The destination position (`[0, count)`)
+     * @returns A {@link Result} boxing the moved phase, or a `MUTATION` failure when
+     *   `id` is absent, not `pending`, or `index` is out of bounds
+     */
+    move(id: string, index: number): Result<PhaseInterface, WorkflowError>;
+    /**
+     * Apply a validated {@link PhaseUpdate} patch to the `pending` phase `id`.
+     *
+     * @param id - The phase id to patch
+     * @param patch - The fields to update
+     * @returns A {@link Result} boxing the patched phase, or a `MUTATION` failure when
+     *   `id` is absent, not `pending`, or `patch` fails validation
+     */
+    update(id: string, patch: PhaseUpdate): Result<PhaseInterface, WorkflowError>;
     phase(id: string): PhaseInterface | undefined;
     phases(): readonly PhaseInterface[];
 }
@@ -1292,16 +1775,7 @@ export declare const phaseShape: ObjectShape<{
         id: StringShape;
         name: StringShape;
         description: OptionalShape<StringShape>;
-        run: UnionShape<[ ObjectShape<{
-            via: LiteralShape<readonly ["function"]>;
-            name: StringShape;
-        }>, ObjectShape<{
-            via: LiteralShape<readonly ["tool"]>;
-            name: StringShape;
-        }>, ObjectShape<{
-            via: LiteralShape<readonly ["agent"]>;
-            name: StringShape;
-        }>]>;
+        run: OptionalShape<StringShape>;
         retries: OptionalShape<NumberShape>;
         timeout: OptionalShape<NumberShape>;
     }>>;
@@ -1334,6 +1808,12 @@ export declare interface PhaseSnapshot {
      * per-phase policy identically without a silent default.
      */
     readonly bail: boolean;
+    /**
+     * Max tasks in flight at once (a resource throttle), persisted so a restore reinstates the
+     * same per-phase throttle — mirrors {@link import('./types.js').PhaseDefinition.concurrency}.
+     * Omitted ⇒ unbounded.
+     */
+    readonly concurrency?: number;
     readonly tasks: readonly TaskSnapshot[];
 }
 
@@ -1349,6 +1829,45 @@ export declare interface PhaseSnapshot {
  */
 export declare type PhaseStatus = LifecycleStatus;
 
+/**
+ * A declarative partial update to a {@link PhaseInterface} — the fields a `pending`
+ * phase's {@link PhaseInterface.patch} (and the owning {@link PhaseManagerInterface.update})
+ * accept, runtime-validated via {@link import('./shapers.js').phaseUpdateShape}.
+ *
+ * @remarks
+ * Mirrors the identity + throttle/policy fields of {@link PhaseDefinition} (`name` /
+ * `description` / `concurrency` / `bail`) — never `id` / `tasks` (structural children
+ * change through {@link PhaseInterface.add} / `remove` / `move`, not a patch). Every
+ * field is optional; an omitted field is left unchanged.
+ *
+ * @example
+ * ```ts
+ * const result = workflow.phases.update(phase.id, { concurrency: 4, bail: true })
+ * ```
+ */
+export declare interface PhaseUpdate {
+    readonly name?: string;
+    readonly description?: string;
+    readonly concurrency?: number;
+    readonly bail?: boolean;
+}
+
+/**
+ * The shape of a {@link import('./types.js').PhaseUpdate} — a partial edit to a
+ * `pending` phase's `name` / `description` / `concurrency` / `bail`, all optional.
+ *
+ * @remarks
+ * Mirrors {@link phaseShape}'s corresponding field constraints exactly; never `id` /
+ * `tasks` (structural children change through the phase's own `add` / `remove` /
+ * `move`, not a patch, AGENTS §12).
+ */
+export declare const phaseUpdateShape: ObjectShape<{
+    name: OptionalShape<StringShape>;
+    description: OptionalShape<StringShape>;
+    concurrency: OptionalShape<NumberShape>;
+    bail: OptionalShape<LiteralShape<readonly [true, false]>>;
+}>;
+
 /**
  * Rebuild an equivalent live W-b entity tree from a {@link WorkflowSnapshot} — the
  * inverse of {@link WorkflowInterface.snapshot}, restoring structure + each node's status
@@ -1414,6 +1933,15 @@ export declare function restoreWorkflow(snapshot: WorkflowSnapshot, options?: Wo
  *   unit failure (after its retries) records the error and `abort()`s the run, so every
  *   sibling's signal fires; later failures are ignored and `execute` rejects with the
  *   first error. A user `abort(reason)` likewise rejects a running `execute`.
+ * - **`pause` / `resume` / `stop` (§10) ride the backing Queue.** `pause` / `resume`
+ *   delegate straight to the Queue's own pause/resume (holding/releasing the NEXT
+ *   dispatch while an in-flight unit finishes); `paused` mirrors the Queue's. `stop` is a
+ *   GRACEFUL permanent end, distinct from `abort`: still-pending (never-dispatched)
+ *   units are rejected by the Queue's own stop WITHOUT their handler ever running, and
+ *   `#settle` reads that fact (`#dispatched`) to treat the rejection as a stop artifact —
+ *   not a failure, never tripping fail-fast — while an in-flight unit still runs to
+ *   completion and settles normally. `execute` RESOLVES (never rejects) once every unit
+ *   has settled, with whatever results actually completed.
  * - **Observable (§13).** The owned {@link emitter} ({@link RunnerEventMap}) carries the run
  *   lifecycle — `start` / `unit` / `spawn` / `settle` / `fail` / `finish` / `abort` — for
  *   fire-and-forget observers. Every event is emitted directly, strictly AFTER the relevant
@@ -1429,8 +1957,66 @@ export declare class Runner<TInput, TResult> implements RunnerInterface<TInput,
     get emitter(): EmitterInterface<RunnerEventMap<TResult>>;
     get active(): number;
     get stopped(): boolean;
+    get paused(): boolean;
+    /**
+     * Inject one more unit into an IN-FLIGHT `execute` run — a LIVE counterpart to a
+     * `Controller.spawn`, called from OUTSIDE any unit's handler.
+     *
+     * @remarks
+     * Returns `undefined` synchronously (graceful, non-throwing — AGENTS §12) unless the
+     * runner is currently mid-`execute` and not yet stopped — covering "never started",
+     * "already drained", "aborted", and "destroyed". Otherwise the unit is routed through
+     * the SAME backing queue as a declared/`spawn`ed unit via `#launch` — the outstanding-
+     * unit count gate increments BEFORE this call returns, so an in-flight `execute`
+     * keeps awaiting it (the drain race: `#running` flips to `false` as the very first
+     * step after `execute`'s `await drained.promise` settles, so a `spawn` reaching this
+     * method after the run has fully drained is cleanly rejected with `undefined` —
+     * never silently dropped, never hangs `execute`). Emits {@link RunnerEventMap.spawn}
+     * with a `parent` of `undefined` (this call has no spawning unit) once accepted.
+     *
+     * @param input - The unit's work payload
+     * @returns The unit's result promise, or `undefined` when no in-flight run can accept it
+     * @example
+     * ```ts
+     * const runner = createRunner({ handler: (c) => c.input })
+     * const result = runner.execute([1, 2])
+     * const extra = runner.spawn(3) // Promise<number> | undefined
+     * await result
+     * ```
+     */
+    spawn(input: TInput): Promise<TResult> | undefined;
     execute(inputs: readonly TInput[]): Promise<readonly TResult[]>;
     abort(reason?: unknown): void;
+    /**
+     * Suspend dispatch (AGENTS §10 — resumable): delegates to the backing queue's own
+     * `pause`, which holds the NEXT dispatch while any in-flight unit finishes.
+     *
+     * @remarks
+     * A no-op once the runner is `stopped` — a stopped runner has no dispatch left to
+     * suspend, mirroring the guard `stop()` itself applies. Also a no-op when already
+     * `paused` (the queue's own `pause` is idempotent), so calling it repeatedly is safe.
+     */
+    pause(): void;
+    /**
+     * Continue a paused runner (AGENTS §10); delegates to the backing queue's `resume`.
+     *
+     * @remarks
+     * A no-op once the runner is `stopped` (nothing left to resume) and a no-op when the
+     * runner is not currently `paused`, so calling it repeatedly or on a never-paused
+     * runner is safe.
+     */
+    resume(): void;
+    /**
+     * Permanently end the runner (AGENTS §10) — a GRACEFUL stop, distinct from `abort`.
+     * Marks the runner `stopping` + `stopped`, then stops the backing queue: every
+     * still-PENDING (never-dispatched) unit is rejected by the queue with its own
+     * "queue is stopped" error, WITHOUT running its handler; every already-in-flight unit
+     * keeps running to completion and settles normally. `#settle` reads `#stopping` to
+     * classify a never-dispatched unit's rejection as a stop artifact (decrement the count
+     * gate, no recorded failure, no fail-fast trip) rather than a genuine failure — a
+     * dispatched unit's rejection while stopping is still a real failure. Idempotent.
+     */
+    stop(): void;
     destroy(): void;
 }
 
@@ -1523,6 +2109,8 @@ export declare interface RunnerInterface<TInput, TResult> {
     readonly emitter: EmitterInterface<RunnerEventMap<TResult>>;
     readonly active: number;
     readonly stopped: boolean;
+    /** Whether the runner is currently paused (AGENTS §10 — resumable, no new dispatch); rides the backing queue's own `paused`. */
+    readonly paused: boolean;
     /**
      * Run all `inputs` — and anything they `spawn` — to completion; resolve their
      * results in order: the declared inputs first (in input order), then the spawned
@@ -1537,6 +2125,25 @@ export declare interface RunnerInterface<TInput, TResult> {
      * @returns The units' results, in order (declared first, then spawns)
      */
     execute(inputs: readonly TInput[]): Promise<readonly TResult[]>;
+    /**
+     * Inject one more unit into an IN-FLIGHT `execute` run — a LIVE counterpart to a
+     * `Controller.spawn`, called from OUTSIDE any unit's handler (the seam a live
+     * `running` {@link PhaseInterface}'s `add` event lets a subscribed run offer a newly
+     * added task to the SAME execution substrate).
+     *
+     * @remarks
+     * Returns `undefined` synchronously (graceful, non-throwing — AGENTS §12) when the
+     * runner is not currently mid-`execute`, or the run has already fully drained — the
+     * caller reads `undefined` as "not accepted". Otherwise the unit is routed through
+     * the SAME backing queue as a declared/`spawn`ed unit (the runner's
+     * outstanding-unit count gate keeps the in-flight `execute` awaiting it) and emits
+     * the {@link RunnerEventMap.spawn} event; its result promise resolves once the unit
+     * settles.
+     *
+     * @param input - The unit's work payload
+     * @returns The unit's result promise, or `undefined` when no in-flight run can accept it
+     */
+    spawn(input: TInput): Promise<TResult> | undefined;
     /**
      * Cancel every in-flight + pending unit (and the backing queue), making a running
      * `execute` reject.
@@ -1544,6 +2151,44 @@ export declare interface RunnerInterface<TInput, TResult> {
      * @param reason - An optional cancellation reason propagated to every unit's signal
      */
     abort(reason?: unknown): void;
+    /**
+     * Suspend dispatch (AGENTS §10 — resumable): the backing queue holds the NEXT dispatch
+     * while any in-flight unit finishes; idempotent.
+     *
+     * @example
+     * ```ts
+     * runner.pause()
+     * runner.paused // true
+     * ```
+     */
+    pause(): void;
+    /**
+     * Continue a paused runner (AGENTS §10); idempotent.
+     *
+     * @example
+     * ```ts
+     * runner.resume()
+     * runner.paused // false
+     * ```
+     */
+    resume(): void;
+    /**
+     * Permanently end the runner (AGENTS §10) — a GRACEFUL stop: no further unit is
+     * dispatched, but every already-in-flight unit runs to completion and settles
+     * normally. A never-dispatched (still-pending) unit is rejected by the backing queue
+     * and is NOT recorded as a failure (it never trips fail-fast); a genuine in-flight
+     * failure still is. `execute`'s promise RESOLVES (never rejects) once every unit has
+     * settled, with whatever results actually completed. Idempotent.
+     *
+     * @example
+     * ```ts
+     * const runner = createRunner({ handler: (c) => c.input, concurrency: 1 })
+     * const results = runner.execute([1, 2, 3])
+     * runner.stop() // the in-flight unit finishes; the rest are gracefully dropped
+     * await results // resolves with whatever settled — never rejects
+     * ```
+     */
+    stop(): void;
     /** Tear the runner down — `abort` plus stop the backing queue; idempotent. */
     destroy(): void;
 }
@@ -1683,28 +2328,31 @@ export declare interface SchedulerOptions {
 export declare type SchedulerPriority = 'user' | 'normal' | 'background';
 
 /**
- * The shape of ONE flat step — `{ name, via? }` — the building block of
+ * The shape of ONE flat step — `{ name }` — the building block of
  * {@link workflowStepsShape}.
  *
  * @remarks
- * `name` is the REGISTERED behavior name the step runs (it becomes the task's `run.name`);
- * `via` is the optional execution mechanism (defaults to `'function'` when omitted). The
+ * `name` is the REGISTERED behavior name the step runs (it becomes the task's `run`). The
  * tool expands each step into a one-task phase, in order
  * ({@link import('./helpers.js').expandSteps}).
  */
 export declare const stepShape: ObjectShape<{
     name: StringShape;
-    via: OptionalShape<LiteralShape<readonly ["function", "tool", "agent"]>>;
 }>;
 
 /**
- * Convert one flat {@link WorkflowStep} into a {@link TaskForm} — `name` → the form's `name`,
- * `via` → the form's discriminant (defaulting to `'function'`).
+ * Box a value as a {@link Success} — the graceful outcome half of a {@link Result}.
+ *
+ * @typeParam T - The boxed value's type
+ * @param value - The value to box
+ * @returns A {@link Success} wrapping `value`
  *
- * @param step - The flat step
- * @returns The {@link TaskForm} the step's task runs
+ * @example
+ * ```ts
+ * const result = success(task) // { success: true, value: task }
+ * ```
  */
-export declare function stepToForm(step: WorkflowStep): TaskForm;
+export declare function success<T>(value: T): Success<T>;
 
 /**
  * The live leaf state machine (W-b) for one task — an observable (AGENTS §13), guarded
@@ -1731,10 +2379,16 @@ export declare function stepToForm(step: WorkflowStep): TaskForm;
  *   matching event strictly AFTER the state change, BEFORE the cascade; the emitter isolates
  *   a listener throw and routes it to its `error` handler (the `error` option), so a buggy
  *   observer can never corrupt a transition.
+ * - **Declarative config (AGENTS §12).** `run` / `retries` / `timeout` PERSIST in a
+ *   {@link TaskSnapshot} (like a phase's `bail` / `concurrency`), carried verbatim from the
+ *   matching {@link import('../types.js').TaskDefinition} / {@link TaskSnapshot} field. `handler`
+ *   is the RUNTIME-ONLY counterpart — `run` resolved ONCE at construction against the
+ *   workflow-level {@link import('../types.js').WorkflowOptions.functions} registry — and is
+ *   NEVER persisted; `undefined` when `run` is omitted or unregistered (the no-handler rule).
  */
 export declare class Task implements TaskInterface {
     #private;
-    constructor(context: TaskContext, phase: PhaseInterface, workflow: WorkflowInterface, recompute: () => void, options?: TaskOptions, status?: TaskStatus, result?: TaskResult);
+    constructor(context: TaskContext, phase: PhaseInterface, workflow: WorkflowInterface, recompute: () => void, options?: TaskOptions, status?: TaskStatus, result?: TaskResult, run?: string, retries?: number, timeout?: number, handler?: WorkflowFunction);
     get emitter(): EmitterInterface<TaskEventMap>;
     get id(): string;
     get name(): string;
@@ -1744,11 +2398,31 @@ export declare class Task implements TaskInterface {
     get workflow(): WorkflowInterface;
     get status(): TaskStatus;
     get result(): TaskResult | undefined;
+    get run(): string | undefined;
+    get handler(): WorkflowFunction | undefined;
+    get retries(): number | undefined;
+    get timeout(): number | undefined;
     start(): void;
     complete(value: unknown): void;
     fail(error: unknown): void;
     skip(): void;
     stop(): void;
+    /**
+     * Apply a validated declarative patch to SELF (`name` / `description`).
+     *
+     * @remarks
+     * Defense-in-depth (AGENTS §12): the owning
+     * {@link import('../types.js').TaskManagerInterface.update} gates FIRST (target
+     * exists + `pending`), so this is the second, redundant check — it THROWS a
+     * `MUTATION` {@link WorkflowError} unless this task's own `status` is `pending`.
+     *
+     * @param value - The {@link TaskUpdate} fields to apply
+     * @example
+     * ```ts
+     * task.patch({ name: 'Renamed task' })
+     * ```
+     */
+    patch(value: TaskUpdate): void;
     snapshot(): TaskSnapshot;
 }
 
@@ -1776,15 +2450,6 @@ export declare const TASK_STATUSES: readonly TaskStatus[];
  */
 export declare const TASK_TRANSITIONS: Readonly<Record<TaskStatus, readonly TaskStatus[]>>;
 
-/**
- * The three task-form mechanisms (the {@link TaskVia} discriminant), frozen.
- *
- * @remarks
- * The runtime source of truth for the `via` axis — drive the contract's literal
- * shape and any guard from this array rather than repeating the literals.
- */
-export declare const TASK_VIAS: readonly TaskVia[];
-
 /**
  * The ambient context of a task — its own identity plus a back-reference to the
  * phase (and, transitively, the workflow) it belongs to.
@@ -1862,32 +2527,39 @@ export declare interface TaskControllerInterface {
 }
 
 /**
- * The serializable definition of one task — its identity plus the behavior it runs
- * (a {@link TaskForm}, referenced by name).
+ * The serializable definition of one task — its identity plus an optional reference to
+ * the behavior it runs.
  *
  * @remarks
  * Pure JSON DATA: a UI or an LLM authors it, it round-trips through the contract
- * (factories.ts), and it carries NO functions. `id` is the positional identity
- * within its phase; `name` is the human label; `description` is optional prose;
- * `run` is the {@link TaskForm} naming the registered behavior.
+ * (factories.ts), and it carries NO functions. `id` is the positional identity within
+ * its phase; `name` is the human label; `description` is optional prose. `run` is a
+ * PLAIN NAME — a key resolved ONCE at construction against a workflow-level
+ * {@link WorkflowFunctions} registry into a runtime {@link TaskInterface.handler}
+ * carried on the live task. A task whose `run` is omitted, or whose name is unregistered,
+ * has no handler and AUTO-COMPLETES (the no-handler rule).
  */
 export declare interface TaskDefinition {
     readonly id: string;
     readonly name: string;
     readonly description?: string;
-    readonly run: TaskForm;
+    readonly run?: string;
     /**
      * @remarks
      * Extra attempts after the first on failure (a non-negative integer); the runner threads it
      * to this task's substrate unit, OVERRIDING the phase Runner's `retries` default. Omitted ⇒
-     * the default (no extra attempts). Execution-only: it is NOT persisted in a snapshot.
+     * the default (no extra attempts). PERSISTED in a {@link TaskSnapshot} (like `bail` and
+     * `concurrency`), so `restoreWorkflow(snapshot, { functions })` resumes with the same
+     * reliability config; only the resolved handler itself is runtime-only.
      */
     readonly retries?: number;
     /**
      * @remarks
      * The per-attempt deadline in milliseconds (a non-negative integer); the runner threads it to
      * this task's substrate unit, OVERRIDING the phase Runner's `timeout` default. Omitted (or a
-     * non-positive value) ⇒ no deadline. Execution-only: it is NOT persisted in a snapshot.
+     * non-positive value) ⇒ no deadline. PERSISTED in a {@link TaskSnapshot} (like `bail` and
+     * `concurrency`), so `restoreWorkflow(snapshot, { functions })` resumes with the same
+     * reliability config; only the resolved handler itself is runtime-only.
      */
     readonly timeout?: number;
 }
@@ -1897,6 +2569,12 @@ export declare interface TaskDefinition {
  * {@link TaskSnapshot} — the per-task leaf step of {@link definitionToSnapshot} (no
  * result yet, empty metadata).
  *
+ * @remarks
+ * `run` / `retries` / `timeout` carry over verbatim (persisted declarative config, like a
+ * phase's `bail` / `concurrency`) — a restore reinstates the same behavior reference and
+ * reliability overrides once paired with a {@link import('./types.js').WorkflowOptions.functions}
+ * registry.
+ *
  * @param task - The task definition to seed from
  * @returns An initial {@link TaskSnapshot}
  */
@@ -1914,7 +2592,8 @@ export declare interface TaskDraft {
     readonly id?: string;
     readonly name?: string;
     readonly description?: string;
-    readonly run: TaskForm;
+    /** The behavior reference — a registry key resolved against {@link WorkflowFunctions} at construction; omitted ⇒ no handler. */
+    readonly run?: string;
     /** Extra attempts after the first on failure (a non-negative integer); overrides the phase Runner default. Execution-only. */
     readonly retries?: number;
     /** The per-attempt deadline in milliseconds (a non-negative integer); overrides the phase Runner default. Execution-only. */
@@ -1928,22 +2607,13 @@ export declare interface TaskDraft {
  * @remarks
  * A PROVIDED `id` / `name` still carries `minLength: 1`, so an explicitly-empty `id: ''`
  * is INVALID (rejected by the draft contract), never auto-filled — keeping "garbage"
- * distinct from "omitted". `run` stays required.
+ * distinct from "omitted". `run` stays optional, mirroring {@link taskShape}.
  */
 export declare const taskDraftShape: ObjectShape<{
     id: OptionalShape<StringShape>;
     name: OptionalShape<StringShape>;
     description: OptionalShape<StringShape>;
-    run: UnionShape<[ ObjectShape<{
-        via: LiteralShape<readonly ["function"]>;
-        name: StringShape;
-    }>, ObjectShape<{
-        via: LiteralShape<readonly ["tool"]>;
-        name: StringShape;
-    }>, ObjectShape<{
-        via: LiteralShape<readonly ["agent"]>;
-        name: StringShape;
-    }>]>;
+    run: OptionalShape<StringShape>;
     retries: OptionalShape<NumberShape>;
     timeout: OptionalShape<NumberShape>;
 }>;
@@ -1973,58 +2643,6 @@ export declare type TaskEventMap = {
     readonly stop: readonly [];
 };
 
-/**
- * A {@link TaskDefinition}'s behavior reference — a descriptive tagged union over
- * the three execution forms a task can take, discriminated by `via` (the axis is
- * the execution MECHANISM, never a bare `kind`; AGENTS §4.4). Each form references
- * its behavior BY NAME through a registry (the runner resolves the name at W-b);
- * a definition NEVER inlines a function, so the whole tree stays JSON-serializable.
- *
- * @remarks
- * - `function` — a registered function the runner invokes directly.
- * - `tool` — a registered {@link ToolInterface} the
- *   runner executes as a tool call.
- * - `agent` — a registered agent (a subagent). It will later carry a depth/cycle
- *   guard (W-c, bounded by {@link import('./constants.js').MAX_WORKFLOW_DEPTH}); in
- *   W-a it is purely the typed reference.
- *
- * `name` is the registry key (it identifies the behavior the form runs). A
- * descriptive `via` literal (not `kind`) names the axis that varies, and the
- * `is*` guards narrow on `run.via` cleanly.
- */
-export declare type TaskForm = {
-    readonly via: 'function';
-    readonly name: string;
-} | {
-    readonly via: 'tool';
-    readonly name: string;
-} | {
-    readonly via: 'agent';
-    readonly name: string;
-};
-
-/**
- * The shape of a {@link import('./types.js').TaskForm} — a descriptive tagged union
- * over the three execution mechanisms, discriminated by the `via` literal (never a
- * bare `kind`; AGENTS §4.4). Each variant pairs the `via` discriminant with a `name`
- * (the registry key for the behavior).
- *
- * @remarks
- * The union and each `via` literal + `name` carry a `description` so the emitted JSON
- * Schema spells out what the discriminant means and that `name` is a REGISTERED key
- * (not a human label) — the field-level guidance a small model needs to fill `run`.
- */
-export declare const taskFormShape: UnionShape<[ ObjectShape<{
-    via: LiteralShape<readonly ["function"]>;
-    name: StringShape;
-}>, ObjectShape<{
-    via: LiteralShape<readonly ["tool"]>;
-    name: StringShape;
-}>, ObjectShape<{
-    via: LiteralShape<readonly ["agent"]>;
-    name: StringShape;
-}>]>;
-
 /** Initial {@link TaskEventMap} listeners — the reserved `on` option (AGENTS §8). */
 export declare type TaskHooks = EmitterHooks<TaskEventMap>;
 
@@ -2077,11 +2695,52 @@ export declare interface TaskInterface {
     readonly status: TaskStatus;
     /** The recorded outcome once the task settled with one (`completed` / `failed`), else `undefined`. */
     readonly result: TaskResult | undefined;
+    /**
+     * The behavior reference — a plain registry key name, PERSISTED (mirrors
+     * {@link TaskDefinition.run} / {@link TaskSnapshot.run}), like {@link PhaseInterface.bail}.
+     * `undefined` when this task has no behavior reference.
+     */
+    readonly run: string | undefined;
+    /**
+     * The RESOLVED runtime handler — RUNTIME-ONLY, NEVER persisted in a {@link TaskSnapshot}.
+     * Resolved ONCE at construction (build, restore, or a live mint) by looking `run` up in the
+     * workflow-level {@link WorkflowOptions.functions} registry: `functions?.[run]` when `run`
+     * is defined, else `undefined`. A task with no `handler` (an omitted `run`, or a `run` name
+     * absent from the registry) AUTO-COMPLETES (the no-handler rule) — its phase/workflow still
+     * reaches a terminal status, just with no dispatched behavior.
+     */
+    readonly handler: WorkflowFunction | undefined;
+    /**
+     * Extra attempts after the first on failure — PERSISTED (mirrors {@link TaskDefinition.retries}
+     * / {@link TaskSnapshot.retries}), like {@link PhaseInterface.concurrency}. `undefined` ⇒ none.
+     */
+    readonly retries: number | undefined;
+    /**
+     * The per-attempt deadline in milliseconds — PERSISTED (mirrors {@link TaskDefinition.timeout}
+     * / {@link TaskSnapshot.timeout}). `undefined` ⇒ no deadline.
+     */
+    readonly timeout: number | undefined;
     start(): void;
     complete(value: unknown): void;
     fail(error: unknown): void;
     skip(): void;
     stop(): void;
+    /**
+     * Apply a validated declarative patch to SELF (`name` / `description`).
+     *
+     * @remarks
+     * Defense-in-depth (AGENTS §12): the owning {@link TaskManagerInterface.update} gates
+     * FIRST (target exists + `pending`), so a direct call here is the second, redundant
+     * check — it THROWS a `MUTATION` {@link import('./errors.js').WorkflowError} unless
+     * this task's own `status` is `pending`.
+     *
+     * @param value - The {@link TaskUpdate} fields to apply
+     * @example
+     * ```ts
+     * task.patch({ name: 'Renamed task' })
+     * ```
+     */
+    patch(value: TaskUpdate): void;
     snapshot(): TaskSnapshot;
 }
 
@@ -2096,6 +2755,11 @@ export declare interface TaskInterface {
  *   `tasks()` lists them in positional order, `count` is the size. A `skip` is a STATUS
  *   change on a stored task (never a removal), so order survives it; a snapshot RESTORE
  *   re-`append`s in the snapshot's order, reproducing it exactly.
+ * - **Gated mutation API (AGENTS §12).** `add` / `remove` / `move` / `update` are the
+ *   graceful `Result` counterparts to `append`, gating ONLY on the target's OWN
+ *   existence/status/id/bounds — a duplicate id, an absent/non-`pending` target, an
+ *   out-of-bounds `index`, or a patch that fails {@link taskUpdateShape} validation all
+ *   fail gracefully with a `MUTATION` {@link WorkflowError} instead of throwing.
  * - **No batch matrix.** A phase's tasks are a fixed positional set, so AGENTS §9.2 (the
  *   bulk verb overloads) is deliberately omitted — there is no `remove` family here.
  * - **Event-free.** A purely structural container — the live {@link TaskInterface}s own
@@ -2113,6 +2777,10 @@ export declare class TaskManager implements TaskManagerInterface {
     #private;
     get count(): number;
     append(task: TaskInterface): void;
+    add(task: TaskInterface, index?: number): Result<TaskInterface, WorkflowError>;
+    remove(id: string): Result<TaskInterface, WorkflowError>;
+    move(id: string, index: number): Result<TaskInterface, WorkflowError>;
+    update(id: string, patch: TaskUpdate): Result<TaskInterface, WorkflowError>;
     task(id: string): TaskInterface | undefined;
     tasks(): readonly TaskInterface[];
 }
@@ -2126,11 +2794,61 @@ export declare class TaskManager implements TaskManagerInterface {
  * `append` adds one live {@link TaskInterface} at the end (the build-time wiring path);
  * `task(id)` looks one up; `tasks()` lists them in positional order; `count` is the
  * tally. No batch matrix (AGENTS §9.2 is deliberately omitted — a phase's tasks are a
- * fixed positional set, not a bulk-mutated collection).
+ * fixed positional set, not a bulk-mutated collection). `add` / `remove` / `move` /
+ * `update` (AGENTS §12) are the GATED mutation counterparts a
+ * {@link PhaseInterface.add} / `remove` / `move` / `update` delegates to AFTER its own
+ * container-status/hook gating — the manager gates ONLY on the target's OWN
+ * existence/status/id/bounds and stays event-free (the entity emits on success).
  */
 export declare interface TaskManagerInterface {
     readonly count: number;
+    /**
+     * Add `task` at the end (the build-time wiring path).
+     *
+     * @remarks
+     * THROWS a `MUTATION` {@link import('./errors.js').WorkflowError} on a duplicate
+     * `id` (a genuine programmer error — a build-time wiring bug, AGENTS §12) instead of
+     * silently overwriting the existing entry.
+     *
+     * @param task - The live task to append
+     */
     append(task: TaskInterface): void;
+    /**
+     * Insert `task` at `index` (default the end) — the GATED mutation counterpart to
+     * {@link append}: a duplicate `id` or an out-of-bounds `index` fails gracefully
+     * instead of throwing.
+     *
+     * @param task - The live task to insert
+     * @param index - The insertion position (`[0, count]`); omitted inserts at the end
+     * @returns A {@link Result} boxing the inserted task, or a `MUTATION` failure
+     */
+    add(task: TaskInterface, index?: number): Result<TaskInterface, WorkflowError>;
+    /**
+     * Remove the `pending` task `id`.
+     *
+     * @param id - The task id to remove
+     * @returns A {@link Result} boxing the removed task, or a `MUTATION` failure when
+     *   `id` is absent or not `pending`
+     */
+    remove(id: string): Result<TaskInterface, WorkflowError>;
+    /**
+     * Reposition the `pending` task `id` to `index`.
+     *
+     * @param id - The task id to move
+     * @param index - The destination position (`[0, count)`)
+     * @returns A {@link Result} boxing the moved task, or a `MUTATION` failure when `id`
+     *   is absent, not `pending`, or `index` is out of bounds
+     */
+    move(id: string, index: number): Result<TaskInterface, WorkflowError>;
+    /**
+     * Apply a validated {@link TaskUpdate} patch to the `pending` task `id`.
+     *
+     * @param id - The task id to patch
+     * @param patch - The fields to update
+     * @returns A {@link Result} boxing the patched task, or a `MUTATION` failure when
+     *   `id` is absent, not `pending`, or `patch` fails validation
+     */
+    update(id: string, patch: TaskUpdate): Result<TaskInterface, WorkflowError>;
     task(id: string): TaskInterface | undefined;
     tasks(): readonly TaskInterface[];
 }
@@ -2141,9 +2859,11 @@ export declare interface TaskManagerInterface {
  *
  * @remarks
  * The reserved `on` (AGENTS §8) wires initial {@link TaskEventMap} listeners; a
- * {@link createTask}-built tree threads each level's `on` from its parent options.
- * `metadata` is the open consumer bag carried verbatim into a {@link TaskSnapshot}
- * (mirrors {@link TaskInput.metadata}), never interpreted by the workflow.
+ * {@link import('./factories.js').createWorkflow}-built tree threads each level's `on`
+ * from its parent options, the same way a {@link WorkflowInterface.add} /
+ * {@link PhaseInterface.add} mint threads a leaf's `on` from ITS options. `metadata` is
+ * the open consumer bag carried verbatim into a {@link TaskSnapshot} (mirrors
+ * {@link TaskInput.metadata}), never interpreted by the workflow.
  */
 export declare interface TaskOptions {
     readonly on?: TaskHooks;
@@ -2180,23 +2900,15 @@ export declare interface TaskResult {
 }
 
 /**
- * The shape of a {@link import('./types.js').TaskDefinition} — identity plus the
- * behavior reference ({@link taskFormShape}). `description` is optional prose.
+ * The shape of a {@link import('./types.js').TaskDefinition} — identity plus an optional
+ * `run` behavior reference (a plain registry-key string, min length 1). `description` is
+ * optional prose.
  */
 export declare const taskShape: ObjectShape<{
     id: StringShape;
     name: StringShape;
     description: OptionalShape<StringShape>;
-    run: UnionShape<[ ObjectShape<{
-        via: LiteralShape<readonly ["function"]>;
-        name: StringShape;
-    }>, ObjectShape<{
-        via: LiteralShape<readonly ["tool"]>;
-        name: StringShape;
-    }>, ObjectShape<{
-        via: LiteralShape<readonly ["agent"]>;
-        name: StringShape;
-    }>]>;
+    run: OptionalShape<StringShape>;
     retries: OptionalShape<NumberShape>;
     timeout: OptionalShape<NumberShape>;
 }>;
@@ -2209,6 +2921,12 @@ export declare const taskShape: ObjectShape<{
  * Pure JSON DATA (no class instances, no functions). `result` is the task's
  * {@link TaskResult} when it has settled with an outcome, else `undefined`.
  * `metadata` is the open consumer bag carried from the task's {@link TaskInput}.
+ * `run` / `retries` / `timeout` are the DECLARATIVE config the task carries — persisted
+ * like a {@link PhaseSnapshot}'s `bail` / `concurrency`, so a restore reinstates the same
+ * behavior reference and reliability overrides (`run` re-resolves against the
+ * {@link WorkflowOptions.functions} registry supplied to
+ * {@link import('./factories.js').restoreWorkflow}); each omitted ⇒ the corresponding
+ * unset default.
  */
 export declare interface TaskSnapshot {
     readonly id: string;
@@ -2217,6 +2935,12 @@ export declare interface TaskSnapshot {
     readonly status: TaskStatus;
     readonly result?: TaskResult;
     readonly metadata: Readonly<Record<string, unknown>>;
+    /** The behavior reference — a registry key resolved against {@link WorkflowFunctions} on restore/build. */
+    readonly run?: string;
+    /** Extra attempts after the first on failure (a non-negative integer); overrides the phase Runner default. */
+    readonly retries?: number;
+    /** The per-attempt deadline in milliseconds (a non-negative integer); overrides the phase Runner default. */
+    readonly timeout?: number;
 }
 
 /**
@@ -2235,8 +2959,40 @@ export declare interface TaskSnapshot {
  */
 export declare type TaskStatus = LifecycleStatus;
 
-/** The discriminant literal of a {@link TaskForm} — the execution mechanism axis. */
-export declare type TaskVia = TaskForm['via'];
+/**
+ * A declarative partial update to a {@link TaskInterface} — the fields a `pending`
+ * task's {@link TaskInterface.patch} (and the owning {@link TaskManagerInterface.update})
+ * accept, runtime-validated via {@link import('./shapers.js').taskUpdateShape}.
+ *
+ * @remarks
+ * Mirrors the identity fields of {@link TaskDefinition} (`name` / `description`) —
+ * never `run` / `retries` / `timeout` (a form/reliability change is a structural
+ * replace, not a patch) and never `id` (identity is immutable once created). Every
+ * field is optional; an omitted field is left unchanged.
+ *
+ * @example
+ * ```ts
+ * const result = task.phase.tasks.update(task.id, { name: 'Renamed task' })
+ * ```
+ */
+export declare interface TaskUpdate {
+    readonly name?: string;
+    readonly description?: string;
+}
+
+/**
+ * The shape of a {@link import('./types.js').TaskUpdate} — a partial edit to a
+ * `pending` task's `name` / `description`, both optional.
+ *
+ * @remarks
+ * Mirrors {@link taskShape}'s `name` / `description` constraints exactly (a provided
+ * `name` still has `minLength: 1`); never `id` / `run` / `retries` / `timeout` (those
+ * are not patchable fields, AGENTS §12).
+ */
+export declare const taskUpdateShape: ObjectShape<{
+    name: OptionalShape<StringShape>;
+    description: OptionalShape<StringShape>;
+}>;
 
 /**
  * The {@link TaskStatus} values that are TERMINAL — a task in one of these will
@@ -2295,6 +3051,21 @@ export declare type UnitOutcome<TResult> = {
  *   `start` / `complete` / `fail` / `stop` on a derived-status CHANGE; the emitter isolates a
  *   listener throw and routes it to its `error` handler (the `error` option); `fail` carries
  *   the failing task's {@link TaskResult}.
+ * - **Structural API (AGENTS §7).** `add` / `remove` / `move` / `update` gate BEFORE
+ *   delegating to {@link phases} (the manager gates the target's own existence/status/id/
+ *   bounds), then emit the matching {@link WorkflowEventMap} event on success only. NATIVE,
+ *   bottom-up gating (no runner-installed hook): refused outright while this workflow's own
+ *   `status` is terminal; otherwise a target position must fall within the PENDING SUFFIX —
+ *   the contiguous trailing run of `pending` phases — whose boundary is
+ *   {@link import('./helpers.js').deriveBoundary} over the live phases' statuses. A `pending`
+ *   workflow's phases are all `pending`, so the boundary is `0` and every position is
+ *   naturally accepted.
+ * - **Runtime lifecycle (AGENTS §10).** `pause` / `resume` / `wait` gate execution at the runner's
+ *   phase/task boundaries WITHOUT touching {@link status} — `paused` is runtime-only, never
+ *   persisted. `destroy` is a terminal teardown: it aborts {@link signal}, `stop`s every
+ *   non-terminal live phase (so an engine parked on a phase's own gate unparks and the tree
+ *   lands coherent), forces the `stop` override on THIS workflow when not already terminal,
+ *   releases any parked {@link wait} waiter, and marks {@link destroyed} — all four idempotent.
  */
 export declare class Workflow implements WorkflowInterface {
     #private;
@@ -2305,6 +3076,9 @@ export declare class Workflow implements WorkflowInterface {
     get description(): string | undefined;
     get context(): WorkflowContext;
     get bail(): boolean;
+    get paused(): boolean;
+    get destroyed(): boolean;
+    get signal(): AbortSignal;
     get status(): WorkflowStatus;
     get phases(): PhaseManagerInterface;
     phase(id: string): PhaseInterface | undefined;
@@ -2312,6 +3086,14 @@ export declare class Workflow implements WorkflowInterface {
     skip(): void;
     stop(): void;
     complete(): void;
+    pause(): void;
+    resume(): void;
+    destroy(): void;
+    wait(): Promise<void>;
+    add(definition: PhaseDefinition, index?: number): Result<PhaseInterface, WorkflowError>;
+    remove(id: string): Result<PhaseInterface, WorkflowError>;
+    move(id: string, index: number): Result<PhaseInterface, WorkflowError>;
+    update(id: string, patch: PhaseUpdate): Result<PhaseInterface, WorkflowError>;
     snapshot(): WorkflowSnapshot;
 }
 
@@ -2323,24 +3105,28 @@ export declare const WORKFLOW_STATUSES: readonly WorkflowStatus[];
  * multi-line guide that teaches a small model how to author a complete workflow tree.
  *
  * @remarks
- * Presents the SIMPLE flat shape (`{ name, steps: [{ name, via }] }`) as the PRIMARY way with
- * one complete worked example ({@link WORKFLOW_TOOL_FLAT_EXAMPLE}), names the three `via`
- * values + that a step's `name` is a REGISTERED name (not a human label), and documents the full nested
+ * Presents the SIMPLE flat shape (`{ name, steps: [{ name }] }`) as the PRIMARY way with
+ * one complete worked example ({@link WORKFLOW_TOOL_FLAT_EXAMPLE}), names that a step's
+ * `name` is a REGISTERED name (not a human label), and documents the full nested
  * {@link WorkflowDefinition} as the ADVANCED form with a minimal example
  * ({@link WORKFLOW_TOOL_NESTED_EXAMPLE}). Both examples are interpolated VERBATIM from the
  * validated constants, so a parity test pins them — the description can never drift from a
  * real, contract-valid example. The `parameters` the tool advertises are the FLAT shape's
- * schema; the nested form is the documented escape-hatch (the tool accepts both).
+ * schema; the nested form is the documented escape-hatch (the tool accepts both). NOTE: a step's
+ * "registered behavior name" is authored STRUCTURE only —
+ * {@link import('./factories.js').createWorkflowTool} runs the authored tree with no
+ * {@link WorkflowFunctions} registry of its own, so every one of its tasks auto-completes under
+ * the no-handler rule; the tool validates/synthesizes shape, it does not dispatch behavior.
  */
 export declare const WORKFLOW_TOOL_DESCRIPTION: string;
 
 /**
  * A complete FLAT authoring example — the PRIMARY way a small model authors a workflow
- * through {@link import('./factories.js').createWorkflowTool}: `{ name, steps: [{ name, via }] }`.
+ * through {@link import('./factories.js').createWorkflowTool}: `{ name, steps: [{ name }] }`.
  *
  * @remarks
  * Each step becomes a one-task phase, in order; a step's `name` is a REGISTERED behavior name
- * (not a label) and `via` is the execution mechanism. The tool expands this
+ * (not a label) — the registry key its task's `run` resolves against. The tool expands this
  * ({@link import('./helpers.js').expandSteps}) into a valid {@link WorkflowDefinition}. It
  * is embedded VERBATIM in {@link WORKFLOW_TOOL_DESCRIPTION} and guarded by a parity test
  * (it must expand to a tree the STRICT contract accepts), so the doc example can never drift.
@@ -2348,16 +3134,16 @@ export declare const WORKFLOW_TOOL_DESCRIPTION: string;
 export declare const WORKFLOW_TOOL_FLAT_EXAMPLE: WorkflowSteps;
 
 /**
- * The name under which the {@link import('./WorkflowRunner.js').WorkflowRunner} BINDS the
- * depth/cycle-aware workflow tool onto a dispatched `agent` task's
- * `AgentContextInterface` (the future `@orkestrel/agent` package, W-c2).
+ * The name under which {@link import('./factories.js').createAgentFunction} BINDS the
+ * depth/cycle-aware workflow tool onto a wrapped agent's `context.tools` (`AgentContextInterface`,
+ * `@orkestrel/agent`).
  *
  * @remarks
- * The propagation seam's well-known key: before running an `agent` task, the runner adds a
+ * The propagation seam's well-known key: when its `runner` option is supplied, the adapter adds a
  * {@link import('./factories.js').createWorkflowTool}-built tool under this name to the
- * resolved agent's `context.tools`, so the subagent can author + run a NESTED workflow
- * (bounded by {@link MAX_WORKFLOW_DEPTH}). A subagent that wants to fan out into a workflow
- * calls this tool by this name; the bound handler runs the nested workflow at depth + 1.
+ * agent's `context.tools`, so it can author + run a NESTED workflow (bounded by
+ * {@link MAX_WORKFLOW_DEPTH}). An agent that wants to fan out into a workflow calls this tool by
+ * this name; the bound handler runs the nested workflow at depth + 1.
  */
 export declare const WORKFLOW_TOOL_NAME = "workflow";
 
@@ -2372,32 +3158,6 @@ export declare const WORKFLOW_TOOL_NAME = "workflow";
  */
 export declare const WORKFLOW_TOOL_NESTED_EXAMPLE: WorkflowDefinition;
 
-/**
- * The `agent`-task behavior resolver (W-c2) — resolves a registered agent BY NAME to a
- * live {@link AgentInterface} the runner runs as a subagent.
- *
- * @remarks
- * The `agent` analogue of the {@link WorkflowFunctions} registry / the
- * {@link ToolManagerInterface} the other two forms dispatch through: the runner resolves
- * an `agent`-form {@link TaskForm}'s `name` here. A name absent from the resolver is the
- * no-handler case — the task AUTO-COMPLETES (the ROADMAP rule), exactly like an
- * unregistered `function` / `tool`.
- *
- * **Resolve a FRESH agent per call.** A phase's tasks run CONCURRENTLY, so two `agent`
- * tasks naming the same agent are resolved concurrently — and the runner BINDS a
- * depth/cycle-aware workflow tool onto each resolved agent's `context.tools` (the
- * propagation seam — see {@link WorkflowToolOptions}). An implementation that returns the
- * SAME instance for both would have them race on that mutation, so it must mint a fresh
- * agent each call (exactly as `AgentRegistry.build` does). A function resolver
- * (`(name) => …`) is the minimal shape; the agents module's `AgentRegistry` is not a
- * direct fit (its `build` rehydrates from a serializable `AgentJobInput`, not a bare
- * name), so a small adapter `(name) => registry.build({ provider, ... })` bridges it.
- *
- * @param name - The agent's registry key (the `agent`-form's `name`)
- * @returns The resolved live agent, or `undefined` when the name is unregistered
- */
-export declare type WorkflowAgents = (name: string) => AgentInterface | undefined;
-
 /**
  * The ambient context of a workflow — the identity every level inherits.
  *
@@ -2440,7 +3200,8 @@ export declare interface WorkflowDefinition {
  * @remarks
  * The lenient authoring form `createWorkflowDraftContract` validates and
  * {@link import('./helpers.js').completeDraft} completes into a strict
- * {@link WorkflowDefinition}. `run` stays required; the `bail` policy carries over.
+ * {@link WorkflowDefinition}. `run` stays optional (a plain name string); the `bail`
+ * policy carries over.
  */
 export declare interface WorkflowDraft {
     readonly id?: string;
@@ -2476,16 +3237,7 @@ export declare const workflowDraftShape: ObjectShape<{
             id: OptionalShape<StringShape>;
             name: OptionalShape<StringShape>;
             description: OptionalShape<StringShape>;
-            run: UnionShape<[ ObjectShape<{
-                via: LiteralShape<readonly ["function"]>;
-                name: StringShape;
-            }>, ObjectShape<{
-                via: LiteralShape<readonly ["tool"]>;
-                name: StringShape;
-            }>, ObjectShape<{
-                via: LiteralShape<readonly ["agent"]>;
-                name: StringShape;
-            }>]>;
+            run: OptionalShape<StringShape>;
             retries: OptionalShape<NumberShape>;
             timeout: OptionalShape<NumberShape>;
         }>>;
@@ -2540,8 +3292,20 @@ export declare class WorkflowError extends Error {
  *   returning a failure result), and the `@orkestrel/agent` package's `ToolManager`
  *   ISOLATES the throw into the canonical tool result's top-level `error` (AGENTS §14 — the
  *   universal tool-handler contract); the error `context` names the wrapped workflow id.
+ * - `MUTATION` — a GATED structural or patch edit was refused: a duplicate id on
+ *   `append`/`add`, a target that does not exist or is not `pending`, an out-of-bounds
+ *   `index`, a patch that failed shaper validation, or a live structural edit refused by
+ *   the NATIVE bottom-up gate — a terminal container, an edit targeting (or destined for)
+ *   a position BEFORE the container's own pending-suffix boundary, or (a running phase)
+ *   anything other than a pure append. The manager /
+ *   entity structural API (AGENTS §12) returns it as a graceful `Result` `failure` —
+ *   it NEVER throws for this code except {@link TaskInterface.patch} /
+ *   {@link PhaseInterface.patch}'s defense-in-depth self-check and the build-time
+ *   {@link TaskManagerInterface.append} / {@link PhaseManagerInterface.append} duplicate-id
+ *   guard (both genuine programmer-error paths, AGENTS §12). The error `context` names
+ *   the offending id / index / status.
  */
-export declare type WorkflowErrorCode = 'TRANSITION' | 'RESTORE' | 'DEPTH' | 'TOOL';
+export declare type WorkflowErrorCode = 'TRANSITION' | 'RESTORE' | 'DEPTH' | 'TOOL' | 'MUTATION';
 
 /**
  * The push observation surface (AGENTS §13) of the workflow entity (W-b) — the
@@ -2552,10 +3316,13 @@ export declare type WorkflowErrorCode = 'TRANSITION' | 'RESTORE' | 'DEPTH' | 'TO
  * Present-tense events with arg tuples. `start` fires when the workflow begins;
  * `complete` when every phase settled successfully; `fail` when a phase failed
  * under `bail` (carrying the failing {@link TaskResult}); `stop` when the workflow
- * was permanently ended. A throwing listener never reaches the domain surface — the
- * emitter isolates it and routes it to its OWN `error` handler (the `error` option,
- * AGENTS §13). Declared as a `type` alias (not `interface extends EventMap`, AGENTS
- * §4.5) so the type-literal satisfies `EventMap` structurally.
+ * was permanently ended. `add` / `remove` / `move` / `update` fire on a successful
+ * structural or patch edit through {@link WorkflowInterface.add} / `remove` / `move` /
+ * `update` (AGENTS §7) — never on a refused/gated one. A throwing listener never
+ * reaches the domain surface — the emitter isolates it and routes it to its OWN
+ * `error` handler (the `error` option, AGENTS §13). Declared as a `type` alias (not
+ * `interface extends EventMap`, AGENTS §4.5) so the type-literal satisfies `EventMap`
+ * structurally.
  */
 export declare type WorkflowEventMap = {
     /** The workflow began — its `id`. */
@@ -2566,6 +3333,14 @@ export declare type WorkflowEventMap = {
     readonly fail: readonly [result: TaskResult];
     /** The workflow was permanently stopped. */
     readonly stop: readonly [];
+    /** A phase was inserted — the inserted phase + its final index. */
+    readonly add: readonly [phase: PhaseInterface, index: number];
+    /** A phase was removed — the removed phase. */
+    readonly remove: readonly [phase: PhaseInterface];
+    /** A phase was repositioned — the moved phase + its new index. */
+    readonly move: readonly [phase: PhaseInterface, index: number];
+    /** A phase was patched — the patched phase. */
+    readonly update: readonly [phase: PhaseInterface];
 };
 
 /**
@@ -2589,10 +3364,10 @@ export declare type WorkflowFunction = (controller: TaskControllerInterface) =>
  * {@link WorkflowFunction} handlers.
  *
  * @remarks
- * The runner resolves a `function`-form {@link TaskForm}'s `name` here. A name absent
- * from the registry is the no-handler case — the task AUTO-COMPLETES (the ROADMAP rule),
- * exactly like an unsupported form. A plain record (not a manager) — the registry is a
- * lookup, with no lifecycle of its own.
+ * A live {@link TaskInterface} resolves its `run` name against this registry ONCE at
+ * construction into its {@link TaskInterface.handler}. A name absent from the registry (or
+ * an omitted `run`) is the no-handler case — the task AUTO-COMPLETES (the ROADMAP rule). A
+ * plain record (not a manager) — the registry is a lookup, with no lifecycle of its own.
  */
 export declare type WorkflowFunctions = Readonly<Record<string, WorkflowFunction>>;
 
@@ -2634,13 +3409,182 @@ export declare interface WorkflowInterface {
     readonly bail: boolean;
     readonly status: WorkflowStatus;
     readonly phases: PhaseManagerInterface;
+    /**
+     * Whether the workflow is currently paused (AGENTS §10 — resumable); RUNTIME-ONLY —
+     * never a {@link WorkflowStatus}, never persisted in a {@link WorkflowSnapshot} (a
+     * paused workflow's `status` still reports its ordinary `pending` / `running` value).
+     */
+    readonly paused: boolean;
+    /** Whether {@link destroy} has torn this workflow down; RUNTIME-ONLY, never persisted. */
+    readonly destroyed: boolean;
+    /**
+     * This workflow's own cancellation signal — fires on {@link destroy}. RUNTIME-ONLY
+     * (implemented over `@orkestrel/abort`, AGENTS core precedent), never persisted.
+     */
+    readonly signal: AbortSignal;
     /** Look up one live phase by its `id`. */
     phase(id: string): PhaseInterface | undefined;
     /** Every settled task's result across all phases, in positional order — the workflow tier of the result tree. */
     results(): readonly TaskResult[];
+    /**
+     * FORCE this workflow to `skipped` (AGENTS §10), overriding the derived value; idempotent.
+     *
+     * @remarks
+     * A NO-OP once `status` is already terminal — a settled workflow cannot be re-forced.
+     * Always releases a parked {@link wait} waiter regardless (a terminal workflow has nothing
+     * left to pause for).
+     */
     skip(): void;
+    /**
+     * FORCE this workflow to `stopped` (AGENTS §10), overriding the derived value; idempotent.
+     *
+     * @remarks
+     * A NO-OP once `status` is already terminal — a settled workflow cannot be re-forced. Always
+     * releases a parked {@link wait} waiter regardless (a terminal workflow has nothing left to
+     * pause for).
+     */
     stop(): void;
+    /**
+     * FORCE this workflow to `completed` (AGENTS §10), overriding the derived value.
+     *
+     * @remarks
+     * A NO-OP unless `status` is `pending` — its ONLY legitimate use is settling a vacuously
+     * DONE tree (no work happened), mirroring the runner's own gate. Never overrides a real
+     * `completed` / a bail-true `failed` / a `stopped` / a derived `skipped`.
+     */
     complete(): void;
+    /**
+     * Suspend the workflow (AGENTS §10 — resumable); idempotent.
+     *
+     * @remarks
+     * A no-op when already `paused`, when `status` is terminal, or once {@link destroyed}.
+     * RUNTIME-ONLY (AGENTS §10) — never a {@link WorkflowStatus}, never persisted in a
+     * {@link WorkflowSnapshot}. A driving {@link WorkflowRunnerInterface.execute} gates at the
+     * next phase boundary and before each task's own dispatch; an in-flight task body is
+     * never suspended mid-flight. **Pausing does NOT suspend the run's timeout / budget /
+     * abort clocks** — those bounds keep ticking while paused, so a run parked on
+     * `pause()` can still be cancelled (and settle `stopped`) by its own deadline / budget /
+     * abort while parked.
+     *
+     * @example
+     * ```ts
+     * workflow.pause()
+     * workflow.paused // true
+     * ```
+     */
+    pause(): void;
+    /**
+     * Continue a paused workflow (AGENTS §10); idempotent — a no-op unless {@link paused}.
+     *
+     * @example
+     * ```ts
+     * workflow.resume()
+     * workflow.paused // false
+     * ```
+     */
+    resume(): void;
+    /**
+     * Tear this workflow down (AGENTS §10) — a TERMINAL teardown: aborts {@link signal},
+     * `stop`s every non-terminal live phase (so any engine parked on a phase's own gate
+     * unparks and the tree lands coherent), forces the `stop` override on THIS workflow if
+     * it is not already terminal, resolves any parked {@link wait} waiter, and marks
+     * {@link destroyed}; idempotent.
+     *
+     * @remarks
+     * After `destroy`, every structural mutator (`add` / `remove` / `move` / `update` /
+     * `patch`) and `pause` / `resume` reject (a `Result` failure) or no-op — never throws
+     * for calling `destroy` itself twice.
+     *
+     * @example
+     * ```ts
+     * workflow.destroy()
+     * workflow.destroyed // true
+     * ```
+     */
+    destroy(): void;
+    /**
+     * Park until this workflow is not paused — **promise-parked**, never a timer or
+     * busy-loop (AGENTS §21; mirrors {@link ControllerInterface.wait}'s doc style).
+     *
+     * @remarks
+     * Resolves IMMEDIATELY when not {@link paused}. While paused, parks until `resume` /
+     * `skip` / `stop` / `destroy` — each always releases a parked waiter (a permanently
+     * ended workflow has nothing left to pause for). NEVER rejects.
+     *
+     * @returns A promise that resolves once the workflow is no longer paused
+     */
+    wait(): Promise<void>;
+    /**
+     * MINT a live {@link PhaseInterface} (and its tasks) from `definition` and insert it
+     * into this workflow (AGENTS §7 the entity structural API) — gated BEFORE delegating
+     * to {@link phases}' manager.
+     *
+     * @remarks
+     * Converts `definition` → {@link PhaseSnapshot} and constructs the live phase (wired to
+     * THIS workflow, its recompute cascade, and its emitter hooks) plus each of its live
+     * tasks — each task's `run` / `retries` / `timeout` carried from its {@link TaskDefinition}
+     * and its {@link TaskInterface.handler} resolved against the workflow-level
+     * {@link WorkflowOptions.functions} registry (mirrors
+     * {@link import('./factories.js').createWorkflow}'s build-time resolution). The
+     * phase's effective `bail` resolves exactly as the build path does
+     * (`definition.bail ?? this.bail`). Requires `definition.id` to be UNIQUE among this
+     * workflow's existing phase ids — a duplicate is a `MUTATION` failure (mirrors
+     * {@link PhaseManagerInterface.add}'s own duplicate-id gate).
+     *
+     * NATIVE gating, purely from this workflow's own derived `status` and the phase list's
+     * positions (AGENTS §12 — no runner-installed hook), UNCHANGED from the entity-taking
+     * predecessor: refused outright while this workflow's own `status` is terminal or once
+     * {@link destroyed}. Otherwise the effective target position (`index ?? phases.count`)
+     * must fall within the PENDING SUFFIX — the contiguous trailing run of `pending` phases
+     * (phases run sequentially, so every already-started phase forms a contiguous leading
+     * prefix); its boundary is {@link import('./helpers.js').deriveBoundary}. A `pending`
+     * workflow's phases are ALL `pending`, so the boundary is `0` and every index is
+     * naturally accepted — no special case needed. Delegates the minted phase to
+     * {@link PhaseManagerInterface.add} then emits `add` on success.
+     *
+     * @param definition - The {@link PhaseDefinition} to mint a live phase (and tasks) from
+     * @param index - The insertion position; omitted inserts at the end
+     * @returns A {@link Result} boxing the minted, inserted phase, or a `MUTATION` failure
+     */
+    add(definition: PhaseDefinition, index?: number): Result<PhaseInterface, WorkflowError>;
+    /**
+     * Remove the `pending` phase `id` from this workflow.
+     *
+     * @remarks
+     * NATIVE gating: refused while this workflow's own `status` is terminal. Otherwise the
+     * target must exist at an index within the pending suffix (at or past
+     * {@link import('./helpers.js').deriveBoundary}) — the manager separately gates the
+     * target's own `pending` status (AGENTS §9).
+     *
+     * @param id - The phase id to remove
+     * @returns A {@link Result} boxing the removed phase, or a `MUTATION` failure
+     */
+    remove(id: string): Result<PhaseInterface, WorkflowError>;
+    /**
+     * Reposition the `pending` phase `id` to `index` within this workflow.
+     *
+     * @remarks
+     * NATIVE gating: refused while this workflow's own `status` is terminal. Otherwise BOTH
+     * the target's current index and the destination `index` must fall within the pending
+     * suffix (see {@link remove}).
+     *
+     * @param id - The phase id to move
+     * @param index - The destination position
+     * @returns A {@link Result} boxing the moved phase, or a `MUTATION` failure
+     */
+    move(id: string, index: number): Result<PhaseInterface, WorkflowError>;
+    /**
+     * Apply a validated {@link PhaseUpdate} patch to the `pending` phase `id` in this workflow.
+     *
+     * @remarks
+     * NATIVE gating: refused while this workflow's own `status` is terminal. Otherwise the
+     * target must exist at an index within the pending suffix (see {@link remove}).
+     *
+     * @param id - The phase id to patch
+     * @param patch - The fields to update
+     * @returns A {@link Result} boxing the patched phase, or a `MUTATION` failure
+     */
+    update(id: string, patch: PhaseUpdate): Result<PhaseInterface, WorkflowError>;
     snapshot(): WorkflowSnapshot;
 }
 
@@ -2670,6 +3614,19 @@ export declare interface WorkflowOptions {
     readonly error?: EmitterErrorHandler;
     /** Per-phase {@link PhaseOptions}, keyed by the phase's `id`. */
     readonly phases?: Readonly<Record<string, PhaseOptions>>;
+    /**
+     * The `function`-task behavior registry ({@link WorkflowFunctions}) each live task's
+     * {@link TaskDefinition.run} / {@link TaskSnapshot.run} name resolves against ONCE at
+     * construction into its runtime {@link TaskInterface.handler} — the SAME registry a
+     * fresh build ({@link import('./factories.js').createWorkflow}) and a restore
+     * ({@link import('./factories.js').restoreWorkflow}) both consume, and the same shape a
+     * live {@link WorkflowInterface.add} / {@link PhaseInterface.add} mint resolves a newly
+     * minted task against. A `run` name absent from `functions` (or omitted entirely)
+     * resolves to no handler — that task AUTO-COMPLETES (the no-handler rule): its
+     * phase/workflow still reaches a terminal status, just with no dispatched behavior.
+     * Omitted ⇒ an empty registry (every task auto-completes).
+     */
+    readonly functions?: WorkflowFunctions;
 }
 
 /**
@@ -2695,35 +3652,51 @@ export declare interface WorkflowResult {
 
 /**
  * The thin orchestrator that EXECUTES a live W-b workflow tree by COMPOSING the shipped
- * substrate — phases sequential, tasks concurrent — dispatching each task BY NAME under the
- * `bail` policy, including the W-c2 `agent` form behind a depth + cycle guard.
+ * substrate — phases sequential, tasks concurrent — dispatching each task through its OWN
+ * resolved handler under the `bail` policy.
  *
  * @remarks
  * - **Composes, never re-implements.** Per-phase bounded concurrency is one
  *   {@link createRunner} per phase (the substrate {@link RunnerInterface} over the workers
  *   `Queue`); `bail` maps onto that Runner's fail-fast vs settle-all; the run-level abort /
- *   timeout / budget fold through {@link createAbort} / {@link createTimeout} +
+ *   timeout / budget / entity `signal` fold through {@link createAbort} / {@link createTimeout} +
  *   `AbortSignal.any` (exactly as the agent runtime folds its bounds); pacing is the shipped
  *   {@link SchedulerInterface}. The runner writes ZERO concurrency / retry / abort logic of
- *   its own — it only sequences phases, dispatches a task, and drives the live entity.
- * - **Phases sequential, tasks concurrent.** `#execute` awaits the phases in order (phase
- *   N+1 starts only once phase N has fully settled). Within a phase, ALL its tasks are the
- *   one Runner's `inputs`, run at `concurrency` = the phase's
- *   {@link PhaseDefinition.concurrency} (default {@link DEFAULT_PHASE_CONCURRENCY}).
- * - **Dispatch by name.** `#dispatch` branches on the task's
- *   {@link import('./types.js').TaskForm} (read from the `definition`, correlated by `id`):
- *   `function` → the {@link WorkflowFunctions} registry, `tool` → the
- *   {@link ToolManagerInterface}, `agent` → the {@link WorkflowAgents} resolver (W-c2). A
- *   handler that is NOT found (an unregistered name for ANY form) AUTO-COMPLETES — the
- *   ROADMAP no-handler rule.
- * - **`agent` form + depth/cycle guard (W-c2).** An `agent` task resolves its subagent via
- *   `agents`, BINDS a depth/cycle-aware workflow tool onto the subagent's `context.tools`
- *   (the propagation seam), folds the task's cancellation into the agent run (a workflow
- *   cancel `abort`s the subagent), and drives it: success → `complete(result)`, throw →
- *   `fail(error)`. Before running, the guard REJECTS the task into a typed `DEPTH`
- *   {@link WorkflowError} (`fail`) when running it would push the nested chain past
- *   {@link MAX_WORKFLOW_DEPTH}, OR when its target agent is already an ancestor (a cycle).
- *   The rejected task never runs the agent.
+ *   its own — it only sequences phases, dispatches a task's own handler, and drives the live
+ *   entity.
+ * - **Pure engine — no registries, no tool/agent knowledge.** The runner carries no
+ *   `functions` / `tools` / `agents` registry: each live {@link TaskInterface} already
+ *   resolved its own {@link import('./types.js').WorkflowFunction} into
+ *   {@link import('./types.js').TaskInterface.handler} ONCE at construction (build, restore,
+ *   or a live mint all resolve it identically, from {@link WorkflowOptions.functions}), so
+ *   dispatch is simply "invoke the task's own handler". Static tool / agent calling is an
+ *   OPT-IN concern of `factories.ts`'s adapter factories ({@link import('./factories.js').createToolFunction},
+ *   {@link import('./factories.js').createAgentFunction}) — plain {@link import('./types.js').WorkflowFunction}s a
+ *   caller wires into {@link WorkflowOptions.functions} like any other behavior. This module
+ *   never imports `@orkestrel/agent`.
+ * - **Two `execute` forms, one engine.** `execute(definition, options)` BUILDS the live tree
+ *   from a {@link WorkflowDefinition} (single source of truth for the `run` / `concurrency`
+ *   metadata); `execute(workflow, options)` DRIVES a caller-owned, ALREADY-BUILT
+ *   {@link WorkflowInterface} instead — the entity-native control surface (AGENTS §10:
+ *   `pause` / `resume` / `add` / `stop` / `destroy` live on the entity itself). Both forms
+ *   converge on the SAME `#execute` engine: neither reads a `WorkflowDefinition` once the tree
+ *   exists — `#runTask` reads each task's OWN {@link import('./types.js').TaskInterface.handler}
+ *   / `retries` / `timeout`, and `#runPhase` reads each phase's OWN
+ *   {@link PhaseInterface.concurrency} / `bail`, so a live `add`-minted phase or task (V5)
+ *   runs under EXACTLY the same rules as one built from the original definition.
+ * - **Phases sequential, tasks concurrent — LIVE continuity.** `#execute` drives the phases in
+ *   order, RE-READING `workflow.phases.phases()` every iteration (a cursor over the live
+ *   manager, not a one-time snapshot) so a caller's `workflow.add(phaseDefinition)` mid-run is
+ *   picked up. Within a phase, `#runPhase` subscribes to that phase's `add` event BEFORE
+ *   capturing its task list, then `spawn`s any task added mid-phase onto the SAME substrate
+ *   Runner (so it is actually dispatched, under the same `concurrency`); a task added too late
+ *   for `spawn` to accept (the runner already drained) is swept `skip`ped afterward so the
+ *   phase always reaches a coherent terminal state.
+ * - **Dispatch by handler.** `#runTask` invokes the live task's own
+ *   {@link import('./types.js').TaskInterface.handler} directly: `undefined` (an omitted `run`,
+ *   or a `run` name absent from the {@link WorkflowOptions.functions} registry it was resolved
+ *   against) AUTO-COMPLETES — the ROADMAP no-handler rule; otherwise the handler runs with the
+ *   task's {@link import('./types.js').TaskControllerInterface} handle.
  * - **`bail` → substrate.** Under `bail: true` (halt) a genuine task failure `fail`s the leaf
  *   THEN re-throws, so the substrate Runner fail-fasts — it aborts the in-flight siblings
  *   (their `controller.signal` fires; a mid-flight sibling `skip`s) and rejects the phase run;
@@ -2731,7 +3704,20 @@ export declare interface WorkflowResult {
  *   Under `bail: false` (graceful) a failure `fail`s the leaf and RESOLVES (never throws), so
  *   the Runner settles every unit (allSettled) and the run finishes (the workflow derives
  *   `completed`, the failure recorded in the result tree).
- * - **Abort / Timeout / Budget fold.** `#execute` folds the run's external `signal`, a
+ * - **Pause / stop / destroy gates.** `workflow.pause()` is honoured at exactly two points —
+ *   the next phase boundary (workflow-only) and each task's own pre-dispatch (before
+ *   `task.start()`, workflow gate FIRST then this task's own `phase.pause()`) — by parking on
+ *   {@link WorkflowInterface.wait} / {@link PhaseInterface.wait}; an in-flight task body is
+ *   NEVER suspended mid-flight. A GRACEFUL `workflow.stop()` (no signal involved) is caught at
+ *   those same gates: not-yet-started work is `skip`ped, in-flight work finishes naturally. A
+ *   HARD `workflow.destroy()` aborts {@link WorkflowInterface.signal}, which `#fold` has folded
+ *   into the run's composed signal — so it cancels the active phase Runner (and every
+ *   in-flight task) exactly like an external abort / timeout / budget fire. EVERY park on a
+ *   `wait()` gate is RACED against that same run signal (`#raceWait`, S2) — so a cancel firing
+ *   WHILE parked unparks the engine promptly instead of hanging until `resume`; the existing
+ *   halt / abort re-checks after the gate then decide the outcome.
+ * - **Abort / Timeout / Budget / entity-signal fold.** `#execute` folds the live workflow's
+ *   own {@link WorkflowInterface.signal}, the run's external `signal`, a
  *   {@link TimeoutInterface}, and the `@orkestrel/budget` package's `BudgetInterface`'s
  *   `signal` into one `runSignal` (`AbortSignal.any`); a fire aborts the active phase's Runner
  *   (cancelling every in-flight task) and HALTS the run — the remaining tasks / phases `skip`
@@ -2739,19 +3725,77 @@ export declare interface WorkflowResult {
  *   {@link TaskController} signal `AbortSignal.any`-combines the substrate per-unit signal with
  *   `runSignal`, so a handler observes either cause directly.
  * - **Re-entrant-safe.** No shared per-run mutable field: the active-Runner holder is LOCAL to
- *   each `#execute`, so a nested `execute` (the bound workflow tool re-entering this instance
- *   while the outer run is suspended on an `agent` task) cannot clobber the outer run's state.
+ *   each `#execute`, so a nested `execute` (a bound workflow-tool handler re-entering this
+ *   instance while the outer run is suspended awaiting it) cannot clobber the outer run's state.
  */
 export declare class WorkflowRunner implements WorkflowRunnerInterface {
     #private;
-    constructor(functions: WorkflowFunctions, tools: ToolManagerInterface | undefined, agents: WorkflowAgents | undefined, scheduler: SchedulerInterface, workflowTool: WorkflowToolBinder | undefined);
+    constructor(scheduler: SchedulerInterface);
+    /**
+     * Execute a workflow definition to completion — BUILD its live tree, run the phases
+     * sequentially with each phase's tasks concurrent — resolving its terminal
+     * {@link WorkflowResult} (whose `workflow` is the freshly-built live tree).
+     *
+     * @remarks
+     * One-shot. The runner BUILDS the live tree from `definition` internally (one source of
+     * truth — the per-task `run` and per-phase `concurrency` come from the same definition
+     * the tree is constructed from, so the executed tree can never drift from the metadata).
+     * The {@link WorkflowOptions} part of `options` (initial `on` listeners, a `bail` override,
+     * the per-node `phases` bag, the {@link WorkflowOptions.functions} registry each task's
+     * `run` resolves against) is forwarded to the build. Under `bail: false` (graceful) every
+     * task settles (a failure is recorded on its {@link TaskInterface}) and the workflow
+     * reaches `completed`; under `bail: true` (halt) the first failure aborts the in-flight
+     * sibling tasks AND `skip`s the remaining tasks / phases, settling the workflow `failed`. A
+     * {@link WorkflowRunOptions} abort / timeout / budget fires every in-flight task's signal
+     * and `stop`s the run. `execute` resolves (never rejects) on a cancel — the partial outcome
+     * is read from the returned {@link WorkflowResult} (its `workflow` / `status` / `results`).
+     *
+     * @param definition - The {@link WorkflowDefinition} to build the live tree from and drive
+     * @param options - The construction options ({@link WorkflowOptions}: `on` / `bail` /
+     *   `phases` / `functions`) PLUS the per-run bounds (`signal` / `timeout` / `budget`)
+     * @returns The run's terminal {@link WorkflowResult} (its `workflow` is the built tree)
+     * @example
+     * ```ts
+     * const result = await runner.execute(definition, { timeout: 5_000 })
+     * result.status // 'completed' | 'failed' | 'stopped'
+     * ```
+     */
     execute(definition: WorkflowDefinition, options?: WorkflowRunOptions): Promise<WorkflowResult>;
+    /**
+     * Drive an ALREADY-BUILT, CALLER-OWNED live {@link WorkflowInterface} — the entity-native
+     * counterpart to the definition-building {@link execute} overload.
+     *
+     * @remarks
+     * `createWorkflow` mints the live tree, this overload drives it, and the caller controls
+     * the SAME entity mid-run via its own `pause` / `resume` / `add` / `stop` / `destroy`
+     * (AGENTS §10). Requires `workflow.status === 'pending'` and `!workflow.destroyed` —
+     * otherwise this is a programmer-timing error and it THROWS a `TRANSITION`
+     * {@link WorkflowError} (AGENTS §12) rather than silently no-opping or building a second
+     * tree. Once accepted, observable semantics are byte-identical to the `definition` form —
+     * except the phase loop RE-READS the live tree every iteration, so a caller's live `add`
+     * mid-run is picked up and actually dispatched. `options` carries only the per-run bounds
+     * (`signal` / `timeout` / `budget`) — the construction half of {@link WorkflowRunOptions}
+     * does not apply, since the tree already exists.
+     *
+     * @param workflow - The live {@link WorkflowInterface} to drive
+     * @param options - The per-run bounds (`signal` / `timeout` / `budget`)
+     * @returns The run's terminal {@link WorkflowResult} (its `workflow` is the SAME entity passed in)
+     * @example
+     * ```ts
+     * const workflow = createWorkflow(definition)
+     * const run = runner.execute(workflow)
+     * workflow.pause()
+     * workflow.resume()
+     * await run
+     * ```
+     */
+    execute(workflow: WorkflowInterface, options?: Omit<WorkflowRunOptions, keyof WorkflowOptions>): Promise<WorkflowResult>;
 }
 
 /**
  * A thin orchestrator that EXECUTES a live {@link WorkflowInterface} tree by composing the
- * shipped substrate — phases sequential, tasks concurrent, dispatched by name under the
- * `bail` policy.
+ * shipped substrate — phases sequential, tasks concurrent, each task dispatched through its
+ * OWN resolved handler under the `bail` policy.
  *
  * @remarks
  * `execute(definition, options?)` BUILDS the live W-b entity tree from the definition itself
@@ -2760,18 +3804,22 @@ export declare class WorkflowRunner implements WorkflowRunnerInterface {
  * through ONE substrate {@link RunnerInterface} (concurrency =
  * the phase's {@link PhaseDefinition.concurrency}). The definition is the SINGLE source of
  * truth: the runner owns both the declarative state (the live tree it constructs) and the
- * EXECUTION-ONLY fields the snapshot deliberately dropped — each task's {@link TaskForm}
- * (`run`) and each phase's `concurrency` (so there is no separately-supplied workflow to drift
- * from the definition). The freshly-built live tree is returned in {@link WorkflowResult.workflow}.
- * Each task is dispatched by its {@link TaskForm} — a `function` through the
- * {@link WorkflowFunctions} registry, a `tool` through the {@link ToolManagerInterface}; a
- * task whose handler is not found AUTO-COMPLETES. The runner DRIVES the live entity (`start`
- * → `complete` / `fail`), never re-implementing status. The `bail` policy maps onto the
- * substrate's fail-fast (`bail: true` — the first failure aborts in-flight siblings and skips
- * the rest) vs settle-all (`bail: false` — failures are recorded and the run finishes). The
- * {@link WorkflowOptions} half of the options is forwarded to `createWorkflow` (initial
- * listeners, a `bail` override, per-node options); the Abort / Timeout / Budget bounds fold
- * per run via `AbortSignal.any`, halting the run and `stop`ping the workflow.
+ * EXECUTION-ONLY field the snapshot deliberately dropped — each task's `run` (resolved into
+ * its {@link TaskInterface.handler} once at construction, against
+ * {@link WorkflowOptions.functions}) and each phase's `concurrency` (so there is no
+ * separately-supplied workflow to drift from the definition). The freshly-built live tree is
+ * returned in {@link WorkflowResult.workflow}. The runner carries NO registry of its own — it
+ * simply invokes each task's OWN {@link TaskInterface.handler}; a task with no handler
+ * AUTO-COMPLETES. The runner DRIVES the live entity (`start` → `complete` / `fail`), never
+ * re-implementing status. The `bail` policy maps onto the substrate's fail-fast (`bail: true`
+ * — the first failure aborts in-flight siblings and skips the rest) vs settle-all (`bail:
+ * false` — failures are recorded and the run finishes). The {@link WorkflowOptions} half of
+ * the options is forwarded to `createWorkflow` (initial listeners, a `bail` override,
+ * per-node options, the `functions` registry); the Abort / Timeout / Budget bounds fold per
+ * run via `AbortSignal.any`, halting the run and `stop`ping the workflow. A second
+ * `execute(workflow, options?)` overload drives a CALLER-BUILT live tree instead — the
+ * entity-native control surface (AGENTS §10: `pause` / `resume` / `add` / `stop` /
+ * `destroy` live on {@link WorkflowInterface} itself); see its own doc for details.
  */
 export declare interface WorkflowRunnerInterface {
     /**
@@ -2781,10 +3829,11 @@ export declare interface WorkflowRunnerInterface {
      *
      * @remarks
      * One-shot. The runner BUILDS the live tree from `definition` internally (one source of
-     * truth — the per-task {@link TaskForm} (`run`) and per-phase `concurrency` come from the
-     * same definition the tree is constructed from, so the executed tree can never drift from
-     * the form/throttle metadata). The {@link WorkflowOptions} part of `options` (initial `on`
-     * listeners, a `bail` override, the per-node `phases` bag) is forwarded to the build.
+     * truth — the per-task `run` (resolved into its {@link TaskInterface.handler}) and per-phase
+     * `concurrency` come from the same definition the tree is constructed from, so the executed
+     * tree can never drift from the metadata). The {@link WorkflowOptions} part of `options`
+     * (initial `on` listeners, a `bail` override, the per-node `phases` bag, the `functions`
+     * registry) is forwarded to the build.
      * Under `bail: false` (graceful) every task settles (a failure is recorded on its
      * {@link TaskInterface}) and the workflow reaches `completed`; under `bail: true` (halt)
      * the first failure aborts the in-flight sibling tasks AND `skip`s the remaining tasks /
@@ -2796,33 +3845,74 @@ export declare interface WorkflowRunnerInterface {
      * the run as `stopped` — the cancel supersedes the same-tick failure, and that task's error
      * is not recorded.
      *
+     * **Programmer-error exception (AGENTS §12).** A PATHOLOGICAL `definition` (e.g. a
+     * duplicate phase or task `id`) THROWS SYNCHRONOUSLY at construction — before any phase
+     * runs, and before the returned `Promise` is even created — rather than resolving a
+     * failed/partial {@link WorkflowResult}. This is the one exception to the "resolves,
+     * never rejects" contract above: a malformed definition is a programmer-timing error, not
+     * a runtime outcome to report through the result tree.
+     *
      * @param definition - The {@link WorkflowDefinition} to build the live tree from and drive
      * @param options - The construction options ({@link WorkflowOptions}: `on` / `bail` /
      *   `phases`) PLUS the per-run bounds (`signal` / `timeout` / `budget`)
      * @returns The run's terminal {@link WorkflowResult} (its `workflow` is the built tree)
      */
     execute(definition: WorkflowDefinition, options?: WorkflowRunOptions): Promise<WorkflowResult>;
+    /**
+     * Drive an ALREADY-BUILT, CALLER-OWNED live {@link WorkflowInterface} — the
+     * ENTITY-NATIVE counterpart to the definition-building {@link execute} overload.
+     *
+     * @remarks
+     * The entity itself is now the single control surface (no separate run handle):
+     * `createWorkflow` mints the live tree, this overload drives it, and the caller
+     * controls the SAME entity mid-run via its own `pause` / `resume` / `add` / `stop` /
+     * `destroy` (AGENTS §10). Requires `workflow.status === 'pending'` and
+     * `!workflow.destroyed` — otherwise this is a programmer-timing error and it THROWS a
+     * `TRANSITION` {@link import('./errors.js').WorkflowError} (AGENTS §12) rather than
+     * silently no-opping or building a second tree. Once accepted, phases run
+     * SEQUENTIALLY and, within each phase, tasks CONCURRENTLY — byte-identical observable
+     * semantics to the `definition`-form `execute` — except the phase loop RE-READS the
+     * live `workflow.phases` / each phase's live `tasks` every iteration (a cursor over
+     * the live managers, not a one-time snapshot), so a caller's live `add` mid-run is
+     * picked up and actually dispatched. `workflow.pause()` gates the run at the next
+     * phase boundary AND before each task's dispatch (an in-flight task body is never
+     * suspended); `workflow.stop()` skips not-yet-started work gracefully; `workflow.destroy()`
+     * folds `workflow.signal` into the run's cancellation, aborting in-flight work
+     * immediately. `options` carries only the per-run BOUNDS (`signal` / `timeout` /
+     * `budget`) — the construction half of {@link WorkflowRunOptions}
+     * does not apply, since the tree already exists.
+     *
+     * **Run round-trips through the snapshot.** Driving a tree rebuilt by
+     * {@link import('./factories.js').restoreWorkflow} behaves according to whether a
+     * {@link WorkflowFunctions} registry was supplied at that build: WITH a registry,
+     * each task's `run` name is re-resolved against it, so a matched task carries a real
+     * handler and this overload actually DISPATCHES it, resuming real work. WITHOUT a
+     * registry (or when a task's `run` name has no match in it), the task's
+     * {@link TaskInterface.run} is `undefined` — the no-handler rule then AUTO-COMPLETES
+     * that task (no dispatch occurs). A PARTIALLY-run restored tree (any live phase/task
+     * not `pending`) is rejected outright by the `workflow.status === 'pending'` guard
+     * above — only a wholly `pending` restored tree is drivable.
+     *
+     * @param workflow - The live {@link WorkflowInterface} to drive (its own entity surface —
+     *   `pause` / `resume` / `add` / `stop` / `destroy` — is the caller's control seam)
+     * @param options - The per-run bounds (`signal` / `timeout` / `budget`); the construction
+     *   half of {@link WorkflowRunOptions} does not apply (the tree already exists)
+     * @returns The run's terminal {@link WorkflowResult} (its `workflow` is the SAME entity passed in)
+     */
+    execute(workflow: WorkflowInterface, options?: Omit<WorkflowRunOptions, keyof WorkflowOptions>): Promise<WorkflowResult>;
 }
 
 /**
- * The options for `createWorkflowRunner` — the behavior registries the runner dispatches
- * a task BY NAME through, plus the optional pacing scheduler.
- *
- * @remarks
- * - `functions` — the {@link WorkflowFunctions} registry for `function`-form tasks. A name
- *   absent here is the no-handler case (the task auto-completes). Omitted ⇒ an empty
- *   registry (every `function` task auto-completes).
- * - `tools` — the {@link ToolManagerInterface} (the shipped tool registry) a `tool`-form
- *   task is dispatched through: the runner resolves `run.name` via `tools.tool(name)` and
- *   invokes it with the task's input. An unregistered tool name is the no-handler case
- *   (auto-completes). Omitted ⇒ every `tool` task auto-completes.
- * - `agents` — the {@link WorkflowAgents} resolver (W-c2) an `agent`-form task is dispatched
- *   through: the runner resolves `run.name` to a live
- *   {@link AgentInterface}, BINDS a depth/cycle-aware workflow
- *   tool onto its `context.tools` (the propagation seam), folds the task's cancellation into
- *   the agent run, and drives it (success → `complete`, throw → `fail`), all behind the
- *   depth + cycle guard. An unregistered agent name is the no-handler case (auto-completes).
- *   Omitted ⇒ every `agent` task auto-completes.
+ * The options for `createWorkflowRunner` — the optional pacing scheduler the runner
+ * paces phase boundaries with.
+ *
+ * @remarks
+ * The runner is a PURE engine — it carries no `functions` / `tools` / `agents` registry
+ * (each live task already resolved its own handler at construction from
+ * {@link WorkflowOptions.functions}); wiring a `function`-form task to a tool or an agent is
+ * an OPT-IN concern of `factories.ts`'s adapter factories
+ * ({@link import('./factories.js').createToolFunction}, {@link import('./factories.js').createAgentFunction}),
+ * which a caller composes into its OWN `functions` registry.
  * - `scheduler` — the {@link SchedulerInterface} that paces the tree (a cooperative
  *   `yield` between phases). Omitted ⇒ the shipped cross-environment default
  *   ({@link createScheduler}).
@@ -2833,10 +3923,6 @@ export declare interface WorkflowRunnerInterface {
  * wire. A future runner-level emitter would introduce its own `EmitterHooks` here.
  */
 export declare interface WorkflowRunnerOptions {
-    readonly functions?: WorkflowFunctions;
-    readonly tools?: ToolManagerInterface;
-    /** The {@link WorkflowAgents} resolver for `agent`-form tasks (W-c2); omitted ⇒ every `agent` task auto-completes. */
-    readonly agents?: WorkflowAgents;
     readonly scheduler?: SchedulerInterface;
 }
 
@@ -2869,28 +3955,15 @@ export declare interface WorkflowRunnerOptions {
  *   `signal` and `start`s it. (A `max: 0` budget is exhausted from its first `start`, so it
  *   cancels the run at entry — a DIFFERENT primitive from the `timeout: 0` "no deadline" case.)
  *
- * The last two are the W-c2 DEPTH / CYCLE bookkeeping — the run's position in a nested
- * workflow→agent→workflow chain, threaded across the
- * `execute → agent-task → createWorkflowTool → nested execute` boundary so the guard can
- * bound recursion. A TOP-LEVEL `execute` omits both (depth `0`, empty ancestry); only the
- * runner-bound workflow tool ({@link import('./factories.js').createWorkflowTool}) supplies
- * them, incrementing the depth and extending the ancestry for each nested run.
- * - `depth` — the run's nesting depth (default `0`). An `agent` task is REJECTED (a typed
- *   `DEPTH` `task.fail`) when running it would push the chain past
- *   {@link import('./constants.js').MAX_WORKFLOW_DEPTH}.
- * - `ancestry` — the identifiers of the workflows + agents already in this run chain
- *   (e.g. `workflow:<id>` / `agent:<name>`). An `agent` task whose target agent — or the
- *   workflow it would author — is already present is a CYCLE and is likewise rejected.
- *   Default empty.
+ * The engine itself carries NO nesting bookkeeping — the depth / cycle guard for a nested
+ * `agent` → workflow-tool → workflow chain lives entirely in the OPT-IN adapter factories
+ * ({@link import('./factories.js').createAgentFunction}, {@link import('./factories.js').createWorkflowTool}),
+ * closed over their own `depth` / `ancestry`, never threaded through `execute`'s options.
  */
 export declare type WorkflowRunOptions = WorkflowOptions & {
     readonly signal?: AbortSignal;
     readonly timeout?: number;
     readonly budget?: BudgetInterface<TokenUsage>;
-    /** The run's nesting depth (W-c2); default `0`. Threaded by the bound workflow tool, never by a top-level caller. */
-    readonly depth?: number;
-    /** The workflow / agent identifiers already in this run chain (W-c2 cycle guard); default empty. */
-    readonly ancestry?: readonly string[];
 };
 
 /**
@@ -2911,16 +3984,7 @@ export declare const workflowShape: ObjectShape<{
             id: StringShape;
             name: StringShape;
             description: OptionalShape<StringShape>;
-            run: UnionShape<[ ObjectShape<{
-                via: LiteralShape<readonly ["function"]>;
-                name: StringShape;
-            }>, ObjectShape<{
-                via: LiteralShape<readonly ["tool"]>;
-                name: StringShape;
-            }>, ObjectShape<{
-                via: LiteralShape<readonly ["agent"]>;
-                name: StringShape;
-            }>]>;
+            run: OptionalShape<StringShape>;
             retries: OptionalShape<NumberShape>;
             timeout: OptionalShape<NumberShape>;
         }>>;
@@ -2994,18 +4058,16 @@ export declare interface WorkflowSnapshotRow {
 export declare type WorkflowStatus = LifecycleStatus;
 
 /**
- * One flat step — `{ name, via? }` — the building block of a {@link WorkflowSteps} blob.
+ * One flat step — `{ name }` — the building block of a {@link WorkflowSteps} blob.
  *
  * @remarks
- * `name` is the REGISTERED behavior name the step runs (it becomes the task's `run.name`,
- * NOT a human label). `via` is the optional execution mechanism — `'function'` (the
- * default when omitted), `'tool'`, or `'agent'`.
+ * `name` is the REGISTERED behavior name the step runs (it becomes the task's `run`,
+ * NOT a human label) — resolved against a workflow-level {@link WorkflowFunctions}
+ * registry at construction.
  */
 export declare interface WorkflowStep {
-    /** The registered behavior name this step runs (becomes the task's `run.name`). */
+    /** The registered behavior name this step runs (becomes the task's `run`). */
     readonly name: string;
-    /** How to run it — `'function'` (default), `'tool'`, or `'agent'`. */
-    readonly via?: TaskVia;
 }
 
 /**
@@ -3025,11 +4087,11 @@ export declare interface WorkflowSteps {
 
 /**
  * The FLAT authoring shape `createWorkflowTool` advertises as its `parameters` — the
- * simplest surface a small model can fill: `{ name?, steps: [{ name, via? }] }`.
+ * simplest surface a small model can fill: `{ name?, steps: [{ name }] }`.
  *
  * @remarks
  * The deliberately-reduced surface (AGENTS §21): a flat ordered list of steps, each a
- * `{ name, via? }`. The tool EXPANDS it ({@link import('./helpers.js').expandSteps}) into a
+ * `{ name }`. The tool EXPANDS it ({@link import('./helpers.js').expandSteps}) into a
  * full {@link import('./types.js').WorkflowDefinition} — one one-task phase per step, in
  * order — then validates against the STRICT
  * {@link import('./factories.js').createWorkflowContract} gate. The full nested form is
@@ -3040,7 +4102,6 @@ export declare const workflowStepsShape: ObjectShape<{
     name: OptionalShape<StringShape>;
     steps: ArrayShape<ObjectShape<{
         name: StringShape;
-        via: OptionalShape<LiteralShape<readonly ["function", "tool", "agent"]>>;
     }>>;
 }>;
 
@@ -3106,26 +4167,6 @@ export declare interface WorkflowStoreInterface {
  */
 export declare function workflowTag(id: string): string;
 
-/**
- * The workflow-tool binder — the signature of {@link import('./factories.js').createWorkflowTool},
- * threaded into the {@link WorkflowRunnerInterface} at construction (W-c2) so the runner can BIND a
- * depth/cycle-aware workflow tool onto a dispatched subagent.
- *
- * @remarks
- * The runner receives a REFERENCE to `createWorkflowTool` rather than importing it, because
- * `createWorkflowTool` lives in `factories.ts` which imports the runner CLASS (the
- * factories→classes direction); importing the factory back into the class would be a cycle. The
- * factory (which legitimately owns `createWorkflowContract`) is passed as a value at construction,
- * and the runner invokes it with `this` as the `runner` argument — keeping the cycle-free seam an
- * explicit, typed contract rather than a hidden dependency.
- *
- * @param definition - The workflow the bound tool runs when called with no authored args
- * @param runner - The runner that executes the (nested) workflow (the runner passes `this`)
- * @param options - The depth + ancestry the nested workflow runs under (see {@link WorkflowToolOptions})
- * @returns The bound {@link ToolInterface}
- */
-export declare type WorkflowToolBinder = (definition: WorkflowDefinition, runner: WorkflowRunnerInterface, options?: WorkflowToolOptions) => ToolInterface;
-
 /**
  * Options for {@link import('./factories.js').createWorkflowTool} — the depth + ancestry the
  * wrapped {@link WorkflowDefinition} runs the NESTED workflow at when an LLM invokes the tool.