@orkestrel/workflow 0.0.1 → 0.0.2

package/dist/src/core/index.cjs

@@ -2,8 +2,8 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 let _orkestrel_agent = require("@orkestrel/agent");
 let _orkestrel_contract = require("@orkestrel/contract");
 let _orkestrel_database = require("@orkestrel/database");
-let _orkestrel_emitter = require("@orkestrel/emitter");
 let _orkestrel_abort = require("@orkestrel/abort");
+let _orkestrel_emitter = require("@orkestrel/emitter");
 let _orkestrel_timeout = require("@orkestrel/timeout");
 let _orkestrel_queue = require("@orkestrel/queue");
 //#region src/core/Scheduler.ts
@@ -83,18 +83,6 @@ var Scheduler = class {
 /** The default {@link import('./types.js').WorkflowDefinition.bail} — graceful (continue on a leaf failure). */
 var DEFAULT_BAIL = false;
 /**
-* 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.
-*/
-var TASK_VIAS = Object.freeze([
-	"function",
-	"tool",
-	"agent"
-]);
-/**
 * Every {@link TaskStatus} value, frozen — the lifecycle vocabulary of a task.
 *
 * @remarks
@@ -174,63 +162,64 @@ var TASK_TRANSITIONS = Object.freeze({
 /**
 * 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.
 */
-var DEFAULT_PHASE_CONCURRENCY = 1e6;
+var DEFAULT_PHASE_CONCURRENCY = 1024;
 /**
-* 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.
 */
 var MAX_WORKFLOW_DEPTH = 8;
 /**
-* 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.
 */
 var WORKFLOW_TOOL_NAME = "workflow";
 /**
 * 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.
 */
 var WORKFLOW_TOOL_FLAT_EXAMPLE = Object.freeze({
 	name: "release",
-	steps: Object.freeze([Object.freeze({
-		name: "compile",
-		via: "function"
-	}), Object.freeze({
-		name: "publish",
-		via: "tool"
-	})])
+	steps: Object.freeze([Object.freeze({ name: "compile" }), Object.freeze({ name: "publish" })])
 });
 /**
 * A minimal NESTED authoring example — the ADVANCED escape-hatch form a model may use
@@ -250,10 +239,7 @@ var WORKFLOW_TOOL_NESTED_EXAMPLE = Object.freeze({
 		tasks: Object.freeze([Object.freeze({
 			id: "compile",
 			name: "Compile",
-			run: Object.freeze({
-				via: "function",
-				name: "compile"
-			})
+			run: "compile"
 		})])
 	})])
 });
@@ -262,27 +248,30 @@ var WORKFLOW_TOOL_NESTED_EXAMPLE = Object.freeze({
 * 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.
 */
 var WORKFLOW_TOOL_DESCRIPTION = [
 	"Author and run a workflow (phases run sequentially, the tasks within a phase run concurrently) in one call.",
 	"",
 	"SIMPLEST way — a flat list of steps. Each step runs one registered behavior; steps run one after another:",
-	"  { \"name\": \"<workflow name>\", \"steps\": [ { \"name\": \"<registered name>\", \"via\": \"function|tool|agent\" }, ... ] }",
+	"  { \"name\": \"<workflow name>\", \"steps\": [ { \"name\": \"<registered name>\" }, ... ] }",
 	"- a step's \"name\" is a REGISTERED behavior name (a registry key), NOT a human label.",
-	"- \"via\" is how to run it: \"function\" (the default if omitted), \"tool\", or \"agent\".",
 	"- the top-level \"name\" (the workflow name) is optional. Ids are filled in for you.",
 	"Example:",
 	JSON.stringify(WORKFLOW_TOOL_FLAT_EXAMPLE),
 	"",
-	"ADVANCED — the full nested form, for multi-task phases or explicit ids. A workflow has phases; a phase has tasks; a task has a \"run\" of { \"via\", \"name\" }:",
+	"ADVANCED — the full nested form, for multi-task phases or explicit ids. A workflow has phases; a phase has tasks; a task has a \"run\" (a registered behavior name):",
 	JSON.stringify(WORKFLOW_TOOL_NESTED_EXAMPLE),
 	"In the nested form you may omit any \"id\"/\"name\" and they are filled in positionally; a provided one is kept."
 ].join("\n");
@@ -333,35 +322,6 @@ function isWorkflowError(value) {
 //#endregion
 //#region src/core/helpers.ts
 /**
-* Narrow a {@link TaskForm} to the `function` form — a task that runs a registered
-* function.
-*
-* @param form - The task form to test
-* @returns `true` when `form.via` is `'function'`
-*/
-function isFunctionTask(form) {
-	return form.via === "function";
-}
-/**
-* 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'`
-*/
-function isToolTask(form) {
-	return form.via === "tool";
-}
-/**
-* Narrow a {@link TaskForm} to the `agent` form — a task that runs a registered
-* agent (a subagent).
-*
-* @param form - The task form to test
-* @returns `true` when `form.via` is `'agent'`
-*/
-function isAgentTask(form) {
-	return form.via === "agent";
-}
-/**
 * The ancestry identifier of a workflow run — `workflow:<id>`.
 *
 * @remarks
@@ -478,6 +438,36 @@ function deriveWorkflowStatus(phases) {
 	return "skipped";
 }
 /**
+* 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)
+* ```
+*/
+function deriveBoundary(statuses) {
+	const index = statuses.findIndex((status) => status === "pending");
+	return index === -1 ? statuses.length : index;
+}
+/**
 * Test whether the live W-b task state machine may move directly from one
 * {@link TaskStatus} to another — the legal-transition guard.
 *
@@ -495,6 +485,66 @@ function canTransitionTask(from, to) {
 	return TASK_TRANSITIONS[from].includes(to);
 }
 /**
+* 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`
+*
+* @example
+* ```ts
+* const result = success(task) // { success: true, value: task }
+* ```
+*/
+function success(value) {
+	return {
+		success: true,
+		value
+	};
+}
+/**
+* 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 }
+* ```
+*/
+function failure(error) {
+	return {
+		success: false,
+		error
+	};
+}
+/**
+* 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 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
+* ```
+*/
+function findFailure(results) {
+	return results.find((result) => result.result?.success === false);
+}
+/**
 * Build a {@link WorkflowContext} — the identity every level inherits — from a node's
 * `id` / `name` / optional `description`.
 *
@@ -570,10 +620,12 @@ function isWorkflowSnapshot(value) {
 *
 * @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.
@@ -611,6 +663,7 @@ function definitionToSnapshot(definition, bail) {
 * 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
@@ -623,6 +676,7 @@ function phaseDefinitionToSnapshot(phase, workflowBail) {
 		...phase.description === void 0 ? {} : { description: phase.description },
 		status: "pending",
 		bail: phase.bail ?? workflowBail,
+		...phase.concurrency === void 0 ? {} : { concurrency: phase.concurrency },
 		tasks: phase.tasks.map((task) => taskDefinitionToSnapshot(task))
 	};
 }
@@ -631,6 +685,12 @@ function phaseDefinitionToSnapshot(phase, workflowBail) {
 * {@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}
 */
@@ -640,7 +700,10 @@ function taskDefinitionToSnapshot(task) {
 		name: task.name,
 		...task.description === void 0 ? {} : { description: task.description },
 		status: "pending",
-		metadata: {}
+		metadata: {},
+		...task.run === void 0 ? {} : { run: task.run },
+		...task.retries === void 0 ? {} : { retries: task.retries },
+		...task.timeout === void 0 ? {} : { timeout: task.timeout }
 	};
 }
 /**
@@ -744,7 +807,7 @@ function completeTaskDraft(task, phaseId, index) {
 		id,
 		name: task.name ?? id,
 		...task.description === void 0 ? {} : { description: task.description },
-		run: task.run,
+		...task.run === void 0 ? {} : { run: task.run },
 		...task.retries === void 0 ? {} : { retries: task.retries },
 		...task.timeout === void 0 ? {} : { timeout: task.timeout }
 	};
@@ -756,34 +819,81 @@ function completeTaskDraft(task, phaseId, index) {
 * @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)
 */
 function expandSteps(flat) {
 	return completeDraft({
 		...flat.name === void 0 ? {} : { name: flat.name },
-		phases: flat.steps.map((step) => ({ tasks: [{ run: stepToForm(step) }] }))
+		phases: flat.steps.map((step) => ({ tasks: [{ run: step.name }] }))
 	});
 }
 /**
-* Convert one flat {@link WorkflowStep} into a {@link TaskForm} — `name` → the form's `name`,
-* `via` → the form's discriminant (defaulting to `'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`.
+*
+* @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`
 *
-* @param step - The flat step
-* @returns The {@link TaskForm} the step's task runs
+* @example
+* ```ts
+* insertEntry([['a', 1], ['b', 2]], 1, 'c', 3) // [['a', 1], ['c', 3], ['b', 2]]
+* ```
 */
-function stepToForm(step) {
-	return {
-		via: step.via ?? "function",
-		name: step.name
-	};
+function insertEntry(entries, index, key, value) {
+	const next = [...entries];
+	next.splice(index, 0, [key, value]);
+	return next;
+}
+/**
+* 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]]
+* ```
+*/
+function moveEntry(entries, key, index) {
+	const next = [...entries];
+	const at = next.findIndex(([entryKey]) => entryKey === key);
+	if (at === -1) return next;
+	const [entry] = next.splice(at, 1);
+	if (entry !== void 0) next.splice(index, 0, entry);
+	return next;
 }
 /**
 * Create a {@link DeferredInterface} — a promise whose settlement is driven
@@ -804,41 +914,39 @@ function createDeferred() {
 		reject
 	};
 }
-//#endregion
-//#region src/core/shapers.ts
 /**
-* 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).
+* Park until `signal` aborts — a promise-parked wait (AGENTS §21), never a timer or
+* busy-loop, that NEVER rejects.
 *
 * @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`.
+* 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
+* ```
 */
-var taskFormShape = (0, _orkestrel_contract.unionShape)((0, _orkestrel_contract.objectShape)({
-	via: (0, _orkestrel_contract.literalShape)(["function"], { description: "Run a registered workflow FUNCTION by name." }),
-	name: (0, _orkestrel_contract.stringShape)({
-		min: 1,
-		description: "The registered function name to invoke (a registry key, not a label)."
-	})
-}), (0, _orkestrel_contract.objectShape)({
-	via: (0, _orkestrel_contract.literalShape)(["tool"], { description: "Run a registered TOOL by name." }),
-	name: (0, _orkestrel_contract.stringShape)({
-		min: 1,
-		description: "The registered tool name to invoke (a registry key, not a label)."
-	})
-}), (0, _orkestrel_contract.objectShape)({
-	via: (0, _orkestrel_contract.literalShape)(["agent"], { description: "Run a registered AGENT (a subagent) by name." }),
-	name: (0, _orkestrel_contract.stringShape)({
-		min: 1,
-		description: "The registered agent name to invoke (a registry key, not a label)."
-	})
-}));
+function parkSignal(signal) {
+	if (signal.aborted) return Promise.resolve();
+	return new Promise((resolve) => {
+		signal.addEventListener("abort", () => resolve(), { once: true });
+	});
+}
+//#endregion
+//#region src/core/shapers.ts
 /**
-* 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.
 */
 var taskShape = (0, _orkestrel_contract.objectShape)({
 	id: (0, _orkestrel_contract.stringShape)({
@@ -850,7 +958,10 @@ var taskShape = (0, _orkestrel_contract.objectShape)({
 		description: "Human-readable task name."
 	}),
 	description: (0, _orkestrel_contract.optionalShape)((0, _orkestrel_contract.stringShape)({ description: "Optional task description." })),
-	run: taskFormShape,
+	run: (0, _orkestrel_contract.optionalShape)((0, _orkestrel_contract.stringShape)({
+		min: 1,
+		description: "The registered behavior name to invoke (a registry key, not a label); omitted has no handler."
+	})),
 	retries: (0, _orkestrel_contract.optionalShape)((0, _orkestrel_contract.integerShape)({
 		min: 0,
 		description: "Extra attempts after the first on failure; overrides the phase default. Omitted means none."
@@ -908,7 +1019,7 @@ var workflowShape = (0, _orkestrel_contract.objectShape)({
 * @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}.
 */
 var taskDraftShape = (0, _orkestrel_contract.objectShape)({
 	id: (0, _orkestrel_contract.optionalShape)((0, _orkestrel_contract.stringShape)({
@@ -920,7 +1031,10 @@ var taskDraftShape = (0, _orkestrel_contract.objectShape)({
 		description: "Task name; defaults to the id when omitted."
 	})),
 	description: (0, _orkestrel_contract.optionalShape)((0, _orkestrel_contract.stringShape)({ description: "Optional task description." })),
-	run: taskFormShape,
+	run: (0, _orkestrel_contract.optionalShape)((0, _orkestrel_contract.stringShape)({
+		min: 1,
+		description: "The registered behavior name to invoke (a registry key, not a label); omitted has no handler."
+	})),
 	retries: (0, _orkestrel_contract.optionalShape)((0, _orkestrel_contract.integerShape)({
 		min: 0,
 		description: "Extra attempts after the first on failure; overrides the phase default. Omitted means none."
@@ -978,33 +1092,25 @@ var workflowDraftShape = (0, _orkestrel_contract.objectShape)({
 	bail: (0, _orkestrel_contract.optionalShape)((0, _orkestrel_contract.literalShape)([true, false], { description: "Failure policy: false (default) continues gracefully, true halts on the first failure." }))
 });
 /**
-* 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}).
 */
-var stepShape = (0, _orkestrel_contract.objectShape)({
-	name: (0, _orkestrel_contract.stringShape)({
-		min: 1,
-		description: "The registered behavior name this step runs (becomes the task run.name)."
-	}),
-	via: (0, _orkestrel_contract.optionalShape)((0, _orkestrel_contract.literalShape)([
-		"function",
-		"tool",
-		"agent"
-	], { description: "How to run it: function (default), tool, or agent." }))
-});
+var stepShape = (0, _orkestrel_contract.objectShape)({ name: (0, _orkestrel_contract.stringShape)({
+	min: 1,
+	description: "The registered behavior name this step runs (becomes the task run)."
+}) });
 /**
 * 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
@@ -1018,6 +1124,43 @@ var workflowStepsShape = (0, _orkestrel_contract.objectShape)({
 	})),
 	steps: (0, _orkestrel_contract.arrayShape)(stepShape, { description: "The ordered steps to run, one after another (each becomes a one-task phase)." })
 });
+/**
+* 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).
+*/
+var taskUpdateShape = (0, _orkestrel_contract.objectShape)({
+	name: (0, _orkestrel_contract.optionalShape)((0, _orkestrel_contract.stringShape)({
+		min: 1,
+		description: "New task name."
+	})),
+	description: (0, _orkestrel_contract.optionalShape)((0, _orkestrel_contract.stringShape)({ description: "New task description." }))
+});
+/**
+* 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).
+*/
+var phaseUpdateShape = (0, _orkestrel_contract.objectShape)({
+	name: (0, _orkestrel_contract.optionalShape)((0, _orkestrel_contract.stringShape)({
+		min: 1,
+		description: "New phase name."
+	})),
+	description: (0, _orkestrel_contract.optionalShape)((0, _orkestrel_contract.stringShape)({ description: "New phase description." })),
+	concurrency: (0, _orkestrel_contract.optionalShape)((0, _orkestrel_contract.integerShape)({
+		min: 1,
+		description: "Max tasks in flight at once (a resource throttle); omitted leaves it unchanged."
+	})),
+	bail: (0, _orkestrel_contract.optionalShape)((0, _orkestrel_contract.literalShape)([true, false], { description: "Per-phase failure-policy override; omitted leaves it unchanged." }))
+});
 //#endregion
 //#region src/core/stores/DatabaseWorkflowStore.ts
 /**
@@ -1178,6 +1321,12 @@ var MemoryWorkflowStore = class {
 *   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).
 */
 var Task = class {
 	#context;
@@ -1188,7 +1337,13 @@ var Task = class {
 	#emitter;
 	#status;
 	#result;
-	constructor(context, phase, workflow, recompute, options, status = "pending", result) {
+	#name;
+	#description;
+	#run;
+	#retries;
+	#timeout;
+	#handler;
+	constructor(context, phase, workflow, recompute, options, status = "pending", result, run, retries, timeout, handler) {
 		this.#context = context;
 		this.#phase = phase;
 		this.#workflow = workflow;
@@ -1200,6 +1355,12 @@ var Task = class {
 		});
 		this.#status = status;
 		this.#result = result;
+		this.#name = context.name;
+		this.#description = context.description;
+		this.#run = run;
+		this.#retries = retries;
+		this.#timeout = timeout;
+		this.#handler = handler;
 	}
 	get emitter() {
 		return this.#emitter;
@@ -1208,10 +1369,10 @@ var Task = class {
 		return this.#context.id;
 	}
 	get name() {
-		return this.#context.name;
+		return this.#name;
 	}
 	get description() {
-		return this.#context.description;
+		return this.#description;
 	}
 	get context() {
 		return this.#context;
@@ -1228,6 +1389,18 @@ var Task = class {
 	get result() {
 		return this.#result;
 	}
+	get run() {
+		return this.#run;
+	}
+	get handler() {
+		return this.#handler;
+	}
+	get retries() {
+		return this.#retries;
+	}
+	get timeout() {
+		return this.#timeout;
+	}
 	start() {
 		this.#transition("running");
 		this.#emitter.emit("start", this.id);
@@ -1262,6 +1435,29 @@ var Task = class {
 		this.#emitter.emit("stop");
 		this.#escalate();
 	}
+	/**
+	* 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) {
+		if (this.#status !== "pending") throw new WorkflowError("MUTATION", `task '${this.id}' cannot be patched while '${this.#status}'`, {
+			task: this.id,
+			status: this.#status
+		});
+		if (value.name !== void 0) this.#name = value.name;
+		if (value.description !== void 0) this.#description = value.description;
+	}
 	snapshot() {
 		return {
 			id: this.id,
@@ -1269,7 +1465,10 @@ var Task = class {
 			...this.description === void 0 ? {} : { description: this.description },
 			status: this.#status,
 			...this.#result === void 0 ? {} : { result: this.#result },
-			metadata: this.#metadata
+			metadata: this.#metadata,
+			...this.#run === void 0 ? {} : { run: this.#run },
+			...this.#retries === void 0 ? {} : { retries: this.#retries },
+			...this.#timeout === void 0 ? {} : { timeout: this.#timeout }
 		};
 	}
 	#transition(to) {
@@ -1309,6 +1508,11 @@ var Task = class {
 *   `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
@@ -1324,18 +1528,51 @@ var Task = class {
 */
 var TaskManager = class {
 	#tasks = /* @__PURE__ */ new Map();
+	#isUpdate = (0, _orkestrel_contract.compileGuard)(taskUpdateShape);
 	get count() {
 		return this.#tasks.size;
 	}
 	append(task) {
+		if (this.#tasks.has(task.id)) throw new WorkflowError("MUTATION", `duplicate task id '${task.id}'`, { id: task.id });
 		this.#tasks.set(task.id, task);
 	}
+	add(task, index) {
+		if (this.#tasks.has(task.id)) return failure(new WorkflowError("MUTATION", `duplicate task id '${task.id}'`, { id: task.id }));
+		const at = index ?? this.#tasks.size;
+		if (at < 0 || at > this.#tasks.size) return failure(new WorkflowError("MUTATION", `index '${at}' out of bounds`, { index: at }));
+		this.#reorder(insertEntry([...this.#tasks.entries()], at, task.id, task));
+		return success(task);
+	}
+	remove(id) {
+		const target = this.#tasks.get(id);
+		if (target === void 0 || target.status !== "pending") return failure(new WorkflowError("MUTATION", `task '${id}' is not a pending task`, { id }));
+		this.#tasks.delete(id);
+		return success(target);
+	}
+	move(id, index) {
+		const target = this.#tasks.get(id);
+		if (target === void 0 || target.status !== "pending") return failure(new WorkflowError("MUTATION", `task '${id}' is not a pending task`, { id }));
+		if (index < 0 || index >= this.#tasks.size) return failure(new WorkflowError("MUTATION", `index '${index}' out of bounds`, { index }));
+		this.#reorder(moveEntry([...this.#tasks.entries()], id, index));
+		return success(target);
+	}
+	update(id, patch) {
+		const target = this.#tasks.get(id);
+		if (target === void 0 || target.status !== "pending") return failure(new WorkflowError("MUTATION", `task '${id}' is not a pending task`, { id }));
+		if (!this.#isUpdate(patch)) return failure(new WorkflowError("MUTATION", `invalid patch for task '${id}'`, { id }));
+		target.patch(patch);
+		return success(target);
+	}
 	task(id) {
 		return this.#tasks.get(id);
 	}
 	tasks() {
 		return [...this.#tasks.values()];
 	}
+	#reorder(entries) {
+		this.#tasks.clear();
+		for (const [key, value] of entries) this.#tasks.set(key, value);
+	}
 };
 //#endregion
 //#region src/core/phases/Phase.ts
@@ -1360,29 +1597,59 @@ var TaskManager = class {
 *   `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.
 */
 var Phase = class {
-	#context;
+	#id;
+	#name;
+	#description;
 	#workflow;
 	#escalateUp;
 	#tasks = new TaskManager();
+	#functions;
 	#bail;
+	#concurrency;
 	#emitter;
 	#status;
 	#override;
-	constructor(snapshot, workflow, escalate, options, bail) {
-		this.#context = {
-			id: snapshot.id,
-			name: snapshot.name,
-			workflow: workflow.context
-		};
-		if (snapshot.description !== void 0) this.#context = {
-			...this.#context,
-			description: snapshot.description
-		};
+	#paused;
+	#gate;
+	constructor(snapshot, workflow, escalate, options, bail, functions) {
+		this.#id = snapshot.id;
+		this.#name = snapshot.name;
+		this.#description = snapshot.description;
 		this.#workflow = workflow;
 		this.#escalateUp = escalate;
+		this.#functions = functions;
 		this.#bail = bail ?? snapshot.bail;
+		this.#concurrency = snapshot.concurrency;
 		this.#emitter = new _orkestrel_emitter.Emitter({
 			on: options?.on,
 			error: options?.error
@@ -1390,21 +1657,27 @@ var Phase = class {
 		for (const task of snapshot.tasks) this.#append(task, options);
 		this.#override = snapshot.override;
 		this.#status = this.status;
+		this.#paused = false;
+		this.#gate = void 0;
 	}
 	get emitter() {
 		return this.#emitter;
 	}
 	get id() {
-		return this.#context.id;
+		return this.#id;
 	}
 	get name() {
-		return this.#context.name;
+		return this.#name;
 	}
 	get description() {
-		return this.#context.description;
+		return this.#description;
 	}
 	get context() {
-		return this.#context;
+		return buildPhaseContext(this.#workflow.context, {
+			id: this.#id,
+			name: this.#name,
+			...this.#description === void 0 ? {} : { description: this.#description }
+		});
 	}
 	get workflow() {
 		return this.#workflow;
@@ -1412,6 +1685,12 @@ var Phase = class {
 	get bail() {
 		return this.#bail;
 	}
+	get concurrency() {
+		return this.#concurrency;
+	}
+	get paused() {
+		return this.#paused;
+	}
 	get status() {
 		return this.#override ?? derivePhaseStatus(this.#statuses());
 	}
@@ -1427,10 +1706,81 @@ var Phase = class {
 		return results;
 	}
 	skip() {
-		this.#force("skipped");
+		if (!isTerminalStatus(this.status)) this.#force("skipped");
+		this.#paused = false;
+		this.#release();
 	}
 	stop() {
-		this.#force("stopped");
+		if (!isTerminalStatus(this.status)) this.#force("stopped");
+		this.#paused = false;
+		this.#release();
+	}
+	pause() {
+		if (this.#paused || isTerminalStatus(this.status)) return;
+		this.#paused = true;
+		this.#gate = createDeferred();
+	}
+	resume() {
+		if (!this.#paused) return;
+		this.#paused = false;
+		this.#release();
+	}
+	wait() {
+		return this.#paused && this.#gate !== void 0 ? this.#gate.promise : Promise.resolve();
+	}
+	add(definition, index) {
+		const status = this.status;
+		if (isTerminalStatus(status)) return failure(new WorkflowError("MUTATION", `phase '${this.#id}' is terminal`, {
+			id: this.#id,
+			status
+		}));
+		const created = this.#mint(definition);
+		if (status === "running") {
+			const at = index ?? this.#tasks.count;
+			if (at !== this.#tasks.count) return failure(new WorkflowError("MUTATION", `phase '${this.#id}' only accepts an append while executing`, {
+				id: this.#id,
+				index: at
+			}));
+			return this.#addTo(created, index, at);
+		}
+		return this.#addTo(created, index, index ?? this.#tasks.count);
+	}
+	remove(id) {
+		if (this.status !== "pending") return failure(new WorkflowError("MUTATION", `phase '${this.#id}' is not pending`, {
+			id: this.#id,
+			status: this.status
+		}));
+		const result = this.#tasks.remove(id);
+		if (result.success) this.#emitter.emit("remove", result.value);
+		return result;
+	}
+	move(id, index) {
+		if (this.status !== "pending") return failure(new WorkflowError("MUTATION", `phase '${this.#id}' is not pending`, {
+			id: this.#id,
+			status: this.status
+		}));
+		const result = this.#tasks.move(id, index);
+		if (result.success) this.#emitter.emit("move", result.value, index);
+		return result;
+	}
+	update(id, patch) {
+		if (this.status !== "pending") return failure(new WorkflowError("MUTATION", `phase '${this.#id}' is not pending`, {
+			id: this.#id,
+			status: this.status
+		}));
+		const result = this.#tasks.update(id, patch);
+		if (result.success) this.#emitter.emit("update", result.value);
+		return result;
+	}
+	patch(value) {
+		if (this.status !== "pending") throw new WorkflowError("MUTATION", `phase '${this.#id}' can only be patched while pending`, {
+			id: this.#id,
+			status: this.status
+		});
+		if (value.name !== void 0) this.#name = value.name;
+		if (value.description !== void 0) this.#description = value.description;
+		if (value.concurrency !== void 0) this.#concurrency = value.concurrency;
+		if (value.bail !== void 0) this.#bail = value.bail;
 	}
 	snapshot() {
 		return {
@@ -1440,6 +1790,7 @@ var Phase = class {
 			status: this.status,
 			...this.#override === void 0 ? {} : { override: this.#override },
 			bail: this.#bail,
+			...this.#concurrency === void 0 ? {} : { concurrency: this.#concurrency },
 			tasks: this.#tasks.tasks().map((task) => task.snapshot())
 		};
 	}
@@ -1464,16 +1815,32 @@ var Phase = class {
 		else if (status === "stopped") this.#emitter.emit("stop");
 	}
 	#failure() {
-		for (const task of this.#tasks.tasks()) {
-			const result = task.result;
-			if (result?.result?.success === false) return result;
-		}
-		throw new Error(`phase '${this.id}' derived failed with no failing task result`);
+		const found = findFailure(this.results());
+		if (found === void 0) throw new Error(`phase '${this.id}' derived failed with no failing task result`);
+		return found;
+	}
+	#release() {
+		if (this.#gate === void 0) return;
+		this.#gate.resolve();
+		this.#gate = void 0;
+	}
+	#addTo(task, index, at) {
+		const result = this.#tasks.add(task, index);
+		if (result.success) this.#emitter.emit("add", result.value, at);
+		return result;
 	}
 	#append(task, options) {
-		const created = new Task(buildTaskContext(this.#context, task), this, this.#workflow, () => this.#recompute(), options?.tasks?.[task.id], task.status, task.result);
+		const created = this.#create(task, options?.tasks?.[task.id]);
 		this.#tasks.append(created);
 	}
+	#create(snapshot, options) {
+		const context = buildTaskContext(this.context, snapshot);
+		const handler = snapshot.run === void 0 ? void 0 : this.#functions?.[snapshot.run];
+		return new Task(context, this, this.#workflow, () => this.#recompute(), options, snapshot.status, snapshot.result, snapshot.run, snapshot.retries, snapshot.timeout, handler);
+	}
+	#mint(definition) {
+		return this.#create(taskDefinitionToSnapshot(definition), void 0);
+	}
 	#statuses() {
 		return this.#tasks.tasks().map((task) => task.status);
 	}
@@ -1490,6 +1857,11 @@ var Phase = class {
 *   `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
@@ -1505,18 +1877,51 @@ var Phase = class {
 */
 var PhaseManager = class {
 	#phases = /* @__PURE__ */ new Map();
+	#isUpdate = (0, _orkestrel_contract.compileGuard)(phaseUpdateShape);
 	get count() {
 		return this.#phases.size;
 	}
 	append(phase) {
+		if (this.#phases.has(phase.id)) throw new WorkflowError("MUTATION", `duplicate phase id '${phase.id}'`, { id: phase.id });
 		this.#phases.set(phase.id, phase);
 	}
+	add(phase, index) {
+		if (this.#phases.has(phase.id)) return failure(new WorkflowError("MUTATION", `duplicate phase id '${phase.id}'`, { id: phase.id }));
+		const at = index ?? this.#phases.size;
+		if (at < 0 || at > this.#phases.size) return failure(new WorkflowError("MUTATION", `index '${at}' out of bounds`, { index: at }));
+		this.#reorder(insertEntry([...this.#phases.entries()], at, phase.id, phase));
+		return success(phase);
+	}
+	remove(id) {
+		const target = this.#phases.get(id);
+		if (target === void 0 || target.status !== "pending") return failure(new WorkflowError("MUTATION", `phase '${id}' is not a pending phase`, { id }));
+		this.#phases.delete(id);
+		return success(target);
+	}
+	move(id, index) {
+		const target = this.#phases.get(id);
+		if (target === void 0 || target.status !== "pending") return failure(new WorkflowError("MUTATION", `phase '${id}' is not a pending phase`, { id }));
+		if (index < 0 || index >= this.#phases.size) return failure(new WorkflowError("MUTATION", `index '${index}' out of bounds`, { index }));
+		this.#reorder(moveEntry([...this.#phases.entries()], id, index));
+		return success(target);
+	}
+	update(id, patch) {
+		const target = this.#phases.get(id);
+		if (target === void 0 || target.status !== "pending") return failure(new WorkflowError("MUTATION", `phase '${id}' is not a pending phase`, { id }));
+		if (!this.#isUpdate(patch)) return failure(new WorkflowError("MUTATION", `invalid patch for phase '${id}'`, { id }));
+		target.patch(patch);
+		return success(target);
+	}
 	phase(id) {
 		return this.#phases.get(id);
 	}
 	phases() {
 		return [...this.#phases.values()];
 	}
+	#reorder(entries) {
+		this.#phases.clear();
+		for (const [key, value] of entries) this.#phases.set(key, value);
+	}
 };
 //#endregion
 //#region src/core/Workflow.ts
@@ -1547,27 +1952,52 @@ var PhaseManager = class {
 *   `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.
 */
 var Workflow = class {
 	#context;
 	#bail;
 	#bailOverride;
+	#functions;
 	#phases = new PhaseManager();
 	#emitter;
 	#created;
 	#updated;
 	#status;
 	#override;
+	#abort;
+	#paused;
+	#gate;
+	#destroyed;
 	constructor(snapshot, options) {
 		this.#context = buildWorkflowContext(snapshot);
 		this.#bail = options?.bail ?? snapshot.bail;
 		this.#bailOverride = options?.bail;
+		this.#functions = options?.functions;
 		this.#emitter = new _orkestrel_emitter.Emitter({
 			on: options?.on,
 			error: options?.error
 		});
 		this.#created = snapshot.created;
 		this.#updated = snapshot.updated;
+		this.#abort = (0, _orkestrel_abort.createAbort)();
+		this.#paused = false;
+		this.#gate = void 0;
+		this.#destroyed = false;
 		for (const phase of snapshot.phases) this.#append(phase, options);
 		this.#override = snapshot.override;
 		this.#status = this.status;
@@ -1590,6 +2020,15 @@ var Workflow = class {
 	get bail() {
 		return this.#bail;
 	}
+	get paused() {
+		return this.#paused;
+	}
+	get destroyed() {
+		return this.#destroyed;
+	}
+	get signal() {
+		return this.#abort.signal;
+	}
 	get status() {
 		return this.#override ?? deriveWorkflowStatus(this.#statuses());
 	}
@@ -1603,13 +2042,95 @@ var Workflow = class {
 		return collectResults(this.#phases.phases().map((phase) => phase.results()));
 	}
 	skip() {
-		this.#force("skipped");
+		if (!isTerminalStatus(this.status)) this.#force("skipped");
+		this.#paused = false;
+		this.#release();
 	}
 	stop() {
-		this.#force("stopped");
+		if (!isTerminalStatus(this.status)) this.#force("stopped");
+		this.#paused = false;
+		this.#release();
 	}
 	complete() {
-		this.#force("completed");
+		if (this.status === "pending") this.#force("completed");
+	}
+	pause() {
+		if (this.#paused || isTerminalStatus(this.status) || this.#destroyed) return;
+		this.#paused = true;
+		this.#gate = createDeferred();
+	}
+	resume() {
+		if (!this.#paused) return;
+		this.#paused = false;
+		this.#release();
+	}
+	destroy() {
+		if (this.#destroyed) return;
+		this.#destroyed = true;
+		this.#abort.abort();
+		for (const phase of this.#phases.phases()) if (!isTerminalStatus(phase.status)) phase.stop();
+		if (!isTerminalStatus(this.status)) this.stop();
+		this.#paused = false;
+		this.#release();
+	}
+	wait() {
+		return this.#paused && this.#gate !== void 0 ? this.#gate.promise : Promise.resolve();
+	}
+	add(definition, index) {
+		if (isTerminalStatus(this.status)) return failure(new WorkflowError("MUTATION", `workflow '${this.id}' is terminal`, {
+			id: this.id,
+			status: this.status
+		}));
+		const at = index ?? this.#phases.count;
+		if (at < this.#boundary()) return failure(new WorkflowError("MUTATION", `workflow '${this.id}' add index precedes boundary`, {
+			id: this.id,
+			index: at
+		}));
+		return this.#addTo(this.#mint(definition), index, at);
+	}
+	remove(id) {
+		if (isTerminalStatus(this.status)) return failure(new WorkflowError("MUTATION", `workflow '${this.id}' is terminal`, {
+			id: this.id,
+			status: this.status
+		}));
+		const at = this.#indexOf(id);
+		if (at === -1 || at < this.#boundary()) return failure(new WorkflowError("MUTATION", `workflow '${this.id}' cannot remove '${id}'`, {
+			id: this.id,
+			phase: id
+		}));
+		const result = this.#phases.remove(id);
+		if (result.success) this.#emitter.emit("remove", result.value);
+		return result;
+	}
+	move(id, index) {
+		if (isTerminalStatus(this.status)) return failure(new WorkflowError("MUTATION", `workflow '${this.id}' is terminal`, {
+			id: this.id,
+			status: this.status
+		}));
+		const at = this.#indexOf(id);
+		const boundary = this.#boundary();
+		if (at === -1 || at < boundary || index < boundary) return failure(new WorkflowError("MUTATION", `workflow '${this.id}' cannot move '${id}'`, {
+			id: this.id,
+			phase: id,
+			index
+		}));
+		const result = this.#phases.move(id, index);
+		if (result.success) this.#emitter.emit("move", result.value, index);
+		return result;
+	}
+	update(id, patch) {
+		if (isTerminalStatus(this.status)) return failure(new WorkflowError("MUTATION", `workflow '${this.id}' is terminal`, {
+			id: this.id,
+			status: this.status
+		}));
+		const at = this.#indexOf(id);
+		if (at === -1 || at < this.#boundary()) return failure(new WorkflowError("MUTATION", `workflow '${this.id}' cannot update '${id}'`, {
+			id: this.id,
+			phase: id
+		}));
+		const result = this.#phases.update(id, patch);
+		if (result.success) this.#emitter.emit("update", result.value);
+		return result;
 	}
 	snapshot() {
 		return {
@@ -1641,14 +2162,34 @@ var Workflow = class {
 		else if (status === "failed") this.#emitter.emit("fail", this.#failure());
 		else if (status === "stopped") this.#emitter.emit("stop");
 	}
+	#addTo(phase, index, at) {
+		const result = this.#phases.add(phase, index);
+		if (result.success) this.#emitter.emit("add", result.value, at);
+		return result;
+	}
+	#indexOf(id) {
+		return this.#phases.phases().findIndex((phase) => phase.id === id);
+	}
+	#boundary() {
+		return deriveBoundary(this.#phases.phases().map((phase) => phase.status));
+	}
 	#failure() {
-		for (const result of this.results()) if (result.result?.success === false) return result;
-		throw new Error(`workflow '${this.id}' derived failed with no failing task result`);
+		const found = findFailure(this.results());
+		if (found === void 0) throw new Error(`workflow '${this.id}' derived failed with no failing task result`);
+		return found;
 	}
 	#append(phase, options) {
-		const created = new Phase(phase, this, () => this.#recompute(), options?.phases?.[phase.id], this.#bailOverride);
+		const created = new Phase(phase, this, () => this.#recompute(), options?.phases?.[phase.id], this.#bailOverride, this.#functions);
 		this.#phases.append(created);
 	}
+	#mint(definition) {
+		return new Phase(phaseDefinitionToSnapshot(definition, this.#bail), this, () => this.#recompute(), void 0, this.#bailOverride, this.#functions);
+	}
+	#release() {
+		if (this.#gate === void 0) return;
+		this.#gate.resolve();
+		this.#gate = void 0;
+	}
 	#statuses() {
 		return this.#phases.phases().map((phase) => ({
 			status: phase.status,
@@ -1701,10 +2242,7 @@ var Controller = class {
 		return this.#abort.aborted;
 	}
 	wait() {
-		if (this.signal.aborted) return Promise.resolve();
-		return new Promise((resolve) => {
-			this.signal.addEventListener("abort", () => resolve(), { once: true });
-		});
+		return parkSignal(this.signal);
 	}
 	spawn(input) {
 		return this.#spawn(input);
@@ -1749,6 +2287,15 @@ var Controller = class {
 *   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
@@ -1766,11 +2313,13 @@ var Runner = class {
 	#aborts = /* @__PURE__ */ new Map();
 	#order = [];
 	#values = /* @__PURE__ */ new Map();
+	#dispatched = /* @__PURE__ */ new Set();
 	#count = 0;
 	#drained;
 	#started = false;
 	#running = false;
 	#stopped = false;
+	#stopping = false;
 	#failure;
 	constructor(options) {
 		this.#handler = options.handler;
@@ -1795,6 +2344,39 @@ var Runner = class {
 	get stopped() {
 		return this.#stopped;
 	}
+	get paused() {
+		return this.#queue.paused;
+	}
+	/**
+	* 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) {
+		if (this.#stopped || !this.#running) return void 0;
+		return this.#launch(input, void 0, true);
+	}
 	async execute(inputs) {
 		if (this.#started) throw new Error("runner has already executed");
 		if (this.#stopped) throw new Error("runner is stopped");
@@ -1824,6 +2406,47 @@ var Runner = class {
 		this.#stopped = true;
 		this.#emitter.emit("abort", reason);
 	}
+	/**
+	* 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() {
+		if (this.#stopped || this.#queue.paused) return;
+		this.#queue.pause();
+	}
+	/**
+	* 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() {
+		if (this.#stopped || !this.#queue.paused) return;
+		this.#queue.resume();
+	}
+	/**
+	* 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() {
+		if (this.#stopped) return;
+		this.#stopping = true;
+		this.#stopped = true;
+		this.#queue.stop();
+	}
 	destroy() {
 		if (this.#stopped) {
 			this.#queue.destroy();
@@ -1832,13 +2455,13 @@ var Runner = class {
 		this.abort();
 		this.#queue.destroy();
 	}
-	#launch(input, parent) {
+	#launch(input, parent, announce = parent !== void 0) {
 		const id = crypto.randomUUID();
 		const abort = (0, _orkestrel_abort.createAbort)();
 		this.#aborts.set(id, abort);
 		this.#order.push(id);
 		this.#count += 1;
-		if (parent !== void 0) this.#emitter.emit("spawn", id, parent);
+		if (announce) this.#emitter.emit("spawn", id, parent);
 		const promise = this.#queue.enqueue({
 			id,
 			input
@@ -1859,6 +2482,7 @@ var Runner = class {
 	#dispatch(unit, execution) {
 		const abort = this.#aborts.get(unit.id);
 		if (abort === void 0) throw new Error("unit abort missing");
+		this.#dispatched.add(unit.id);
 		const controller = new Controller(unit.id, unit.input, abort, execution.signal, (input) => this.#spawn(input, unit.id));
 		this.#emitter.emit("unit", unit.id);
 		return this.#handler(controller);
@@ -1871,7 +2495,7 @@ var Runner = class {
 		if (outcome.ok) {
 			this.#values.set(id, { value: outcome.value });
 			this.#emitter.emit("settle", id);
-		} else if (this.#failure === void 0) {
+		} else if (this.#stopping && !this.#dispatched.has(id)) {} else if (this.#failure === void 0) {
 			this.#failure = { error: outcome.error };
 			this.#emitter.emit("fail", id, outcome.error);
 			this.abort(outcome.error);
@@ -1939,35 +2563,51 @@ var TaskController = class {
 //#region src/core/WorkflowRunner.ts
 /**
 * 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;
@@ -1975,7 +2615,20 @@ var TaskController = class {
 *   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`
@@ -1983,59 +2636,69 @@ var TaskController = class {
 *   {@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.
 */
 var WorkflowRunner = class {
-	#functions;
-	#tools;
-	#agents;
 	#scheduler;
-	#workflowTool;
-	constructor(functions, tools, agents, scheduler, workflowTool) {
-		this.#functions = functions;
-		this.#tools = tools;
-		this.#agents = agents;
+	constructor(scheduler) {
 		this.#scheduler = scheduler;
-		this.#workflowTool = workflowTool;
 	}
-	execute(definition, options) {
-		const workflow = new Workflow(definitionToSnapshot(definition, options?.bail ?? definition.bail ?? false), options);
-		const depth = options?.depth ?? 0;
-		const ancestry = [...options?.ancestry ?? [], workflowTag(definition.id)];
-		return this.#execute(workflow, definition, options, depth, ancestry);
+	execute(target, options) {
+		if (this.#isWorkflow(target)) {
+			if (target.status !== "pending" || target.destroyed) throw new WorkflowError("TRANSITION", `workflow '${target.id}' is not drivable`, {
+				id: target.id,
+				status: target.status,
+				destroyed: target.destroyed
+			});
+			return this.#execute(target, options);
+		}
+		const workflow = new Workflow(definitionToSnapshot(target, options?.bail ?? target.bail ?? false), options);
+		return this.#execute(workflow, options);
 	}
-	async #execute(workflow, definition, options, depth, ancestry) {
+	async #execute(workflow, options) {
 		const ms = options?.timeout;
 		const timeout = ms !== void 0 && ms > 0 ? (0, _orkestrel_timeout.createTimeout)({ ms }) : void 0;
 		timeout?.start();
 		options?.budget?.start();
-		const runSignal = this.#fold(options, timeout);
+		const runSignal = this.#fold(workflow, options, timeout);
 		const holder = { runner: void 0 };
-		const onCancel = () => holder.runner?.abort(runSignal?.reason);
-		if (runSignal !== void 0) if (runSignal.aborted) onCancel();
+		const onCancel = () => holder.runner?.abort(runSignal.reason);
+		if (runSignal.aborted) onCancel();
 		else runSignal.addEventListener("abort", onCancel, { once: true });
 		try {
-			const phases = workflow.phases.phases();
-			for (let index = 0; index < phases.length; index += 1) {
+			let index = 0;
+			for (;;) {
+				const phases = workflow.phases.phases();
+				if (index >= phases.length) break;
 				const phase = phases[index];
-				if (phase === void 0) continue;
+				if (phase === void 0) {
+					index += 1;
+					continue;
+				}
 				if (this.#cancelled(runSignal) || this.#halted(workflow)) {
-					this.#skipFrom(phases, index);
+					this.#haltFrom(phases, index, workflow, runSignal);
 					break;
 				}
-				if (await this.#runPhase(workflow, phase, this.#phaseOf(definition, phase.id), runSignal, holder, depth, ancestry)) {
-					this.#skipFrom(phases, index + 1);
+				if (workflow.paused) await this.#raceWait(() => workflow.wait(), runSignal);
+				if (this.#cancelled(runSignal) || this.#halted(workflow)) {
+					this.#haltFrom(workflow.phases.phases(), index, workflow, runSignal);
+					break;
+				}
+				if (await this.#runPhase(workflow, phase, runSignal, holder)) {
+					this.#skipFrom(workflow.phases.phases(), index + 1);
 					break;
 				}
-				if (index < phases.length - 1 && !this.#cancelled(runSignal)) try {
-					await this.#scheduler.yield(runSignal === void 0 ? void 0 : { signal: runSignal });
-				} catch {}
+				index += 1;
+				const remaining = workflow.phases.phases();
+				if (index < remaining.length && !this.#cancelled(runSignal)) try {
+					await this.#scheduler.yield({ signal: runSignal });
+				} catch (error) {
+					if (!runSignal.aborted) throw error;
+				}
 			}
-			if (this.#cancelled(runSignal)) {
-				this.#skipFrom(workflow.phases.phases(), 0);
-				if (this.#stoppable(workflow)) workflow.stop();
-			} else if (this.#completable(workflow)) workflow.complete();
+			if (this.#cancelled(runSignal)) this.#haltFrom(workflow.phases.phases(), 0, workflow, runSignal);
+			else if (this.#completable(workflow)) workflow.complete();
 			return {
 				workflow,
 				status: workflow.status,
@@ -2043,52 +2706,71 @@ var WorkflowRunner = class {
 			};
 		} finally {
 			timeout?.clear();
-			runSignal?.removeEventListener("abort", onCancel);
+			runSignal.removeEventListener("abort", onCancel);
 		}
 	}
-	async #runPhase(workflow, phase, definition, runSignal, holder, depth, ancestry) {
-		const tasks = phase.tasks.tasks();
-		if (tasks.length === 0) return false;
-		const bail = definition?.bail ?? workflow.bail;
-		const concurrency = definition?.concurrency !== void 0 && definition.concurrency > 0 ? definition.concurrency : DEFAULT_PHASE_CONCURRENCY;
-		const attempts = /* @__PURE__ */ new Map();
-		const runner = new Runner({
-			concurrency,
-			entries: (task) => {
-				const def = this.#taskOf(definition, task.id);
-				return {
-					retries: def?.retries,
-					timeout: def?.timeout
-				};
-			},
-			handler: (controller) => this.#runTask(workflow, controller.input, this.#taskOf(definition, controller.input.id), controller, runSignal, bail, attempts, depth, ancestry)
-		});
-		holder.runner = runner;
+	async #runPhase(workflow, phase, runSignal, holder) {
+		const launched = /* @__PURE__ */ new Set();
+		let runner;
+		const onAdd = (task) => {
+			if (launched.has(task.id)) return;
+			launched.add(task.id);
+			runner?.spawn(task);
+		};
+		phase.emitter.on("add", onAdd);
 		try {
-			await runner.execute(tasks);
-			return false;
-		} catch {
-			return !this.#cancelled(runSignal);
+			const tasks = phase.tasks.tasks();
+			for (const task of tasks) launched.add(task.id);
+			if (tasks.length === 0) return false;
+			const bail = phase.bail;
+			const concurrency = phase.concurrency !== void 0 && phase.concurrency > 0 ? phase.concurrency : DEFAULT_PHASE_CONCURRENCY;
+			const attempts = /* @__PURE__ */ new Map();
+			const created = new Runner({
+				concurrency,
+				entries: (task) => ({
+					retries: task.retries,
+					timeout: task.timeout
+				}),
+				handler: (controller) => this.#runTask(workflow, controller.input, controller, runSignal, bail, attempts)
+			});
+			runner = created;
+			holder.runner = created;
+			try {
+				await created.execute(tasks);
+				return false;
+			} catch {
+				return !this.#cancelled(runSignal);
+			} finally {
+				created.destroy();
+				holder.runner = void 0;
+			}
 		} finally {
-			runner.destroy();
-			holder.runner = void 0;
+			phase.emitter.off("add", onAdd);
+			if (this.#cancelled(runSignal) && this.#stoppable(workflow)) workflow.stop();
+			for (const task of phase.tasks.tasks()) this.#skip(task);
 		}
 	}
-	async #runTask(workflow, task, definition, controller, runSignal, bail, attempts, depth, ancestry) {
+	async #runTask(workflow, task, controller, runSignal, bail, attempts) {
 		const signal = this.#taskSignal(controller.signal, runSignal);
 		const attempt = (attempts.get(task.id) ?? 0) + 1;
 		attempts.set(task.id, attempt);
-		const last = attempt > Math.max(0, definition?.retries ?? 0);
+		const last = attempt > Math.max(0, task.retries ?? 0);
+		if (workflow.paused) await this.#raceWait(() => workflow.wait(), runSignal);
+		if (task.phase.paused) await this.#raceWait(() => task.phase.wait(), runSignal);
+		if (this.#skipping(controller, runSignal) || this.#halted(workflow)) {
+			this.#skipCancelled(task, workflow, runSignal);
+			return;
+		}
 		if (task.status === "pending") task.start();
-		if (this.#skipping(controller, runSignal)) {
-			this.#skip(task);
+		if (this.#skipping(controller, runSignal) || this.#halted(workflow)) {
+			this.#skipCancelled(task, workflow, runSignal);
 			return;
 		}
 		const handle = new TaskController(signal, task.snapshot().metadata, task.context, () => workflow.results());
 		try {
-			const value = await this.#dispatch(definition, handle, depth, ancestry);
+			const value = task.handler === void 0 ? void 0 : await task.handler(handle);
 			if (task.status !== "running" || this.#skipping(controller, runSignal)) {
-				this.#skip(task);
+				this.#skipCancelled(task, workflow, runSignal);
 				return;
 			}
 			if (signal.aborted) {
@@ -2098,7 +2780,7 @@ var WorkflowRunner = class {
 			task.complete(value);
 		} catch (error) {
 			if (task.status !== "running" || this.#skipping(controller, runSignal)) {
-				this.#skip(task);
+				this.#skipCancelled(task, workflow, runSignal);
 				return;
 			}
 			if (signal.aborted) {
@@ -2114,80 +2796,32 @@ var WorkflowRunner = class {
 		if (!last) return;
 		task.fail(/* @__PURE__ */ new Error(`task '${task.id}' timed out`));
 	}
-	async #dispatch(definition, controller, depth, ancestry) {
-		const form = definition?.run;
-		if (form !== void 0 && isFunctionTask(form)) {
-			const handler = this.#functions[form.name];
-			if (handler !== void 0) return handler(controller);
-			return;
-		}
-		if (form !== void 0 && isToolTask(form)) {
-			const tools = this.#tools;
-			if (tools === void 0) return void 0;
-			if (tools.tool(form.name) === void 0) return void 0;
-			const result = await tools.execute({
-				id: controller.task.id,
-				name: form.name,
-				arguments: controller.input
-			});
-			if (result.error !== void 0) throw new Error(result.error);
-			return result.value;
-		}
-		if (form !== void 0 && isAgentTask(form)) return this.#dispatchAgent(form.name, controller, depth, ancestry);
-	}
-	async #dispatchAgent(name, controller, depth, ancestry) {
-		const resolve = this.#agents;
-		if (resolve === void 0) return void 0;
-		const agent = resolve(name);
-		if (agent === void 0) return void 0;
-		if (depth + 1 > 8) throw new WorkflowError("DEPTH", `agent '${name}' exceeds max workflow depth`, {
-			agent: name,
-			depth,
-			max: 8
-		});
-		const tag = agentTag(name);
-		if (ancestry.includes(tag)) throw new WorkflowError("DEPTH", `agent '${name}' is already an ancestor (cycle)`, {
-			agent: name,
-			ancestry: [...ancestry]
+	async #raceWait(wait, runSignal) {
+		if (runSignal.aborted) return;
+		let onAbort;
+		const cancelled = new Promise((resolve) => {
+			onAbort = () => resolve();
+			runSignal.addEventListener("abort", onAbort, { once: true });
 		});
-		this.#bindWorkflowTool(agent, depth, [...ancestry, tag], controller.task.phase.workflow.id);
-		return this.#runAgent(agent, controller.signal);
-	}
-	#bindWorkflowTool(agent, depth, ancestry, workflowId) {
-		const bind = this.#workflowTool;
-		if (bind === void 0) return;
-		const wrapped = {
-			id: workflowId,
-			name: workflowId,
-			phases: []
-		};
-		agent.context.tools.add(bind(wrapped, this, {
-			depth,
-			ancestry
-		}));
-	}
-	async #runAgent(agent, signal) {
-		const onAbort = () => agent.abort(signal.reason);
-		if (signal.aborted) agent.abort(signal.reason);
-		else signal.addEventListener("abort", onAbort, { once: true });
 		try {
-			return await agent.generate();
+			await Promise.race([wait(), cancelled]);
 		} finally {
-			signal.removeEventListener("abort", onAbort);
+			if (onAbort !== void 0) runSignal.removeEventListener("abort", onAbort);
 		}
 	}
 	#taskSignal(unitSignal, runSignal) {
-		if (runSignal === void 0) return unitSignal;
-		return (0, _orkestrel_abort.createAbort)({ signal: AbortSignal.any([unitSignal, runSignal]) }).signal;
+		return AbortSignal.any([unitSignal, runSignal]);
 	}
-	#fold(options, timeout) {
-		const signals = [];
+	#fold(workflow, options, timeout) {
+		const signals = [workflow.signal];
 		if (options?.signal !== void 0) signals.push(options.signal);
 		if (timeout !== void 0) signals.push(timeout.signal);
 		if (options?.budget !== void 0) signals.push(options.budget.signal);
-		if (signals.length === 0) return void 0;
-		if (signals.length === 1) return signals[0];
-		return AbortSignal.any(signals);
+		return signals.length === 1 ? signals[0] : AbortSignal.any(signals);
+	}
+	#haltFrom(phases, index, workflow, runSignal) {
+		if (this.#cancelled(runSignal) && this.#stoppable(workflow)) workflow.stop();
+		this.#skipFrom(phases, index);
 	}
 	#skipFrom(phases, index) {
 		for (let cursor = index; cursor < phases.length; cursor += 1) {
@@ -2196,14 +2830,18 @@ var WorkflowRunner = class {
 			for (const task of phase.tasks.tasks()) this.#skip(task);
 		}
 	}
+	#skipCancelled(task, workflow, runSignal) {
+		if (this.#cancelled(runSignal) && this.#stoppable(workflow)) workflow.stop();
+		this.#skip(task);
+	}
 	#skip(task) {
 		if (task.status === "pending" || task.status === "running") task.skip();
 	}
 	#skipping(controller, runSignal) {
-		return controller.aborted || runSignal?.aborted === true;
+		return controller.aborted || runSignal.aborted;
 	}
 	#cancelled(runSignal) {
-		return runSignal?.aborted === true;
+		return runSignal.aborted;
 	}
 	#halted(workflow) {
 		const status = workflow.status;
@@ -2216,11 +2854,8 @@ var WorkflowRunner = class {
 	#completable(workflow) {
 		return workflow.status === "pending";
 	}
-	#phaseOf(definition, id) {
-		return definition.phases.find((phase) => phase.id === id);
-	}
-	#taskOf(phase, id) {
-		return phase?.tasks.find((task) => task.id === id);
+	#isWorkflow(target) {
+		return "destroyed" in target && "snapshot" in target && typeof target.snapshot === "function";
 	}
 };
 //#endregion
@@ -2312,6 +2947,11 @@ function createWorkflowDraftContract() {
 * `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
@@ -2371,10 +3011,13 @@ function restoreWorkflow(snapshot, options) {
 * 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
 */
@@ -2404,10 +3047,28 @@ function assertSnapshot(snapshot) {
 			phase: phase.id,
 			override: phase.override
 		});
-		for (const task of phase.tasks) if (!TASK_STATUSES.includes(task.status)) throw new WorkflowError("RESTORE", `task '${task.id}' has an invalid status`, {
-			task: task.id,
-			status: task.status
+		if (phase.concurrency !== void 0 && (!Number.isInteger(phase.concurrency) || phase.concurrency < 1)) throw new WorkflowError("RESTORE", `phase '${phase.id}' has an invalid concurrency`, {
+			phase: phase.id,
+			concurrency: phase.concurrency
 		});
+		for (const task of phase.tasks) {
+			if (!TASK_STATUSES.includes(task.status)) throw new WorkflowError("RESTORE", `task '${task.id}' has an invalid status`, {
+				task: task.id,
+				status: task.status
+			});
+			if (task.run !== void 0 && task.run.length < 1) throw new WorkflowError("RESTORE", `task '${task.id}' has an invalid run`, {
+				task: task.id,
+				run: task.run
+			});
+			if (task.retries !== void 0 && (!Number.isInteger(task.retries) || task.retries < 0)) throw new WorkflowError("RESTORE", `task '${task.id}' has an invalid retries`, {
+				task: task.id,
+				retries: task.retries
+			});
+			if (task.timeout !== void 0 && (!Number.isInteger(task.timeout) || task.timeout < 0)) throw new WorkflowError("RESTORE", `task '${task.id}' has an invalid timeout`, {
+				task: task.id,
+				timeout: task.timeout
+			});
+		}
 	}
 }
 /**
@@ -2486,78 +3147,194 @@ function createDatabaseWorkflowStore(driver = (0, _orkestrel_database.createMemo
 /**
 * 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.
+* each task dispatched through its OWN resolved handler 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
+* 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'
 * ```
 */
 function createWorkflowRunner(options) {
-	return new WorkflowRunner(options?.functions ?? {}, options?.tools, options?.agents, options?.scheduler ?? createScheduler(), createWorkflowTool);
+	return new WorkflowRunner(options?.scheduler ?? createScheduler());
+}
+/**
+* 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') } })
+* ```
+*/
+function createToolFunction(tools, name) {
+	return async (controller) => {
+		if (tools.tool(name) === void 0) throw new WorkflowError("TOOL", `tool '${name}' is not registered`, { tool: name });
+		const result = await tools.execute({
+			id: controller.task.id,
+			name,
+			arguments: controller.input
+		});
+		if (result.error !== void 0) throw new Error(result.error, { cause: result.error });
+		return result.value;
+	};
+}
+/**
+* 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 } })
+* ```
+*/
+function createAgentFunction(agent, options) {
+	return async (controller) => {
+		const depth = options?.depth ?? 0;
+		const ancestry = options?.ancestry ?? [];
+		if (depth + 1 > 8) throw new WorkflowError("DEPTH", `agent '${agent.id}' exceeds max workflow depth`, {
+			agent: agent.id,
+			depth,
+			max: 8
+		});
+		const tag = agentTag(agent.id);
+		if (ancestry.includes(tag)) throw new WorkflowError("DEPTH", `agent '${agent.id}' is already an ancestor (cycle)`, {
+			agent: agent.id,
+			ancestry: [...ancestry]
+		});
+		const runner = options?.runner;
+		if (runner !== void 0) {
+			const workflowId = controller.task.phase.workflow.id;
+			const wrapped = {
+				id: workflowId,
+				name: workflowId,
+				phases: []
+			};
+			agent.context.tools.add(createWorkflowTool(wrapped, runner, {
+				depth,
+				ancestry: [...ancestry, tag]
+			}));
+		}
+		const signal = controller.signal;
+		const onAbort = () => agent.abort(signal.reason);
+		if (signal.aborted) agent.abort(signal.reason);
+		else signal.addEventListener("abort", onAbort, { once: true });
+		try {
+			return await agent.generate();
+		} finally {
+			signal.removeEventListener("abort", onAbort);
+		}
+	};
 }
 /**
 * 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);
@@ -2579,9 +3356,15 @@ function createWorkflowRunner(options) {
 *   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
@@ -2631,10 +3414,7 @@ function createWorkflowTool(definition, runner, options) {
 				workflow: target.id,
 				ancestry: [...ancestry]
 			});
-			return workflowToolSummary(await runner.execute(target, {
-				depth: depth + 1,
-				ancestry: [...ancestry, tag]
-			}));
+			return workflowToolSummary(await runner.execute(target));
 		}
 	});
 }
@@ -2743,7 +3523,6 @@ exports.Runner = Runner;
 exports.Scheduler = Scheduler;
 exports.TASK_STATUSES = TASK_STATUSES;
 exports.TASK_TRANSITIONS = TASK_TRANSITIONS;
-exports.TASK_VIAS = TASK_VIAS;
 exports.TERMINAL_TASK_STATUSES = TERMINAL_TASK_STATUSES;
 exports.Task = Task;
 exports.TaskController = TaskController;
@@ -2766,36 +3545,42 @@ exports.collectResults = collectResults;
 exports.completeDraft = completeDraft;
 exports.completePhaseDraft = completePhaseDraft;
 exports.completeTaskDraft = completeTaskDraft;
+exports.createAgentFunction = createAgentFunction;
 exports.createDatabaseWorkflowStore = createDatabaseWorkflowStore;
 exports.createDeferred = createDeferred;
 exports.createMemoryWorkflowStore = createMemoryWorkflowStore;
 exports.createRunner = createRunner;
 exports.createScheduler = createScheduler;
+exports.createToolFunction = createToolFunction;
 exports.createWorkflow = createWorkflow;
 exports.createWorkflowContract = createWorkflowContract;
 exports.createWorkflowDraftContract = createWorkflowDraftContract;
 exports.createWorkflowRunner = createWorkflowRunner;
 exports.createWorkflowTool = createWorkflowTool;
 exports.definitionToSnapshot = definitionToSnapshot;
+exports.deriveBoundary = deriveBoundary;
 exports.derivePhaseStatus = derivePhaseStatus;
 exports.deriveWorkflowStatus = deriveWorkflowStatus;
 exports.expandSteps = expandSteps;
-exports.isAgentTask = isAgentTask;
-exports.isFunctionTask = isFunctionTask;
+exports.failure = failure;
+exports.findFailure = findFailure;
+exports.insertEntry = insertEntry;
 exports.isTerminalStatus = isTerminalStatus;
-exports.isToolTask = isToolTask;
 exports.isWorkflowError = isWorkflowError;
 exports.isWorkflowSnapshot = isWorkflowSnapshot;
+exports.moveEntry = moveEntry;
+exports.parkSignal = parkSignal;
 exports.phaseDefinitionToSnapshot = phaseDefinitionToSnapshot;
 exports.phaseDraftShape = phaseDraftShape;
 exports.phaseShape = phaseShape;
+exports.phaseUpdateShape = phaseUpdateShape;
 exports.restoreWorkflow = restoreWorkflow;
 exports.stepShape = stepShape;
-exports.stepToForm = stepToForm;
+exports.success = success;
 exports.taskDefinitionToSnapshot = taskDefinitionToSnapshot;
 exports.taskDraftShape = taskDraftShape;
-exports.taskFormShape = taskFormShape;
 exports.taskShape = taskShape;
+exports.taskUpdateShape = taskUpdateShape;
 exports.workflowDraftShape = workflowDraftShape;
 exports.workflowShape = workflowShape;
 exports.workflowStepsShape = workflowStepsShape;