@orkestrel/workflow 0.0.1 → 0.0.3

package/dist/src/core/index.js

@@ -1,8 +1,7 @@
-import { createTool } from "@orkestrel/agent";
-import { arrayShape, createContract, integerShape, isArray, isBoolean, isNumber, isRecord, isString, literalShape, objectShape, optionalShape, rawShape, schemaToParameters, stringShape, unionShape } from "@orkestrel/contract";
+import { arrayShape, compileGuard, createContract, integerShape, isArray, isBoolean, isNumber, isRecord, isString, literalShape, objectShape, optionalShape, rawShape, stringShape } from "@orkestrel/contract";
 import { createDatabase, createMemoryDriver } from "@orkestrel/database";
-import { Emitter } from "@orkestrel/emitter";
 import { createAbort } from "@orkestrel/abort";
+import { Emitter } from "@orkestrel/emitter";
 import { createTimeout } from "@orkestrel/timeout";
 import { createQueue } from "@orkestrel/queue";
 //#region src/core/Scheduler.ts
@@ -82,18 +81,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
@@ -173,118 +160,23 @@ 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".
-*/
-var DEFAULT_PHASE_CONCURRENCY = 1e6;
-/**
-* The maximum nesting depth a workflow's `agent` task may spawn into (W-c) — the
-* bound the runner's depth/cycle guard enforces.
-*
-* @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.
-*/
-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).
-*
-* @remarks
-* The propagation seam's well-known key: before running an `agent` task, the runner 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.
-*/
-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 }] }`.
-*
-* @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
-* ({@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"
-	})])
-});
-/**
-* A minimal NESTED authoring example — the ADVANCED escape-hatch form a model may use
-* instead of the flat shape: a full {@link WorkflowDefinition}.
-*
-* @remarks
-* The full four-level form, documented in {@link WORKFLOW_TOOL_DESCRIPTION} as the advanced
-* alternative. It is embedded VERBATIM and guarded by a parity test (`createWorkflowContract().is`
-* must accept it), so the doc example can never drift from a valid definition.
-*/
-var WORKFLOW_TOOL_NESTED_EXAMPLE = Object.freeze({
-	id: "release",
-	name: "Release",
-	phases: Object.freeze([Object.freeze({
-		id: "build",
-		name: "Build",
-		tasks: Object.freeze([Object.freeze({
-			id: "compile",
-			name: "Compile",
-			run: Object.freeze({
-				via: "function",
-				name: "compile"
-			})
-		})])
-	})])
-});
-/**
-* The DESCRIPTION {@link import('./factories.js').createWorkflowTool} advertises — a
-* 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
-* {@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).
-*/
-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\" }, ... ] }",
-	"- 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\" }:",
-	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");
+* 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 = 1024;
 //#endregion
 //#region src/core/errors.ts
 /**
@@ -295,11 +187,11 @@ var WORKFLOW_TOOL_DESCRIPTION = [
 * offending node id / status. Thrown for an illegal lifecycle transition
 * (`TRANSITION`), a structurally invalid {@link import('./types.js').WorkflowSnapshot}
 * passed to {@link import('./factories.js').restoreWorkflow} (`RESTORE`), an over-deep /
-* cyclic nested-workflow dispatch (`DEPTH`), and a malformed
-* {@link import('./factories.js').createWorkflowTool} args blob (`TOOL`). On the
-* workflow-tool seam the `DEPTH` / `TOOL` throw is ISOLATED by the
-* `@orkestrel/agent` package's `ToolManager` into the tool result's
-* top-level `error` (AGENTS §14 — the universal tool-handler contract).
+* cyclic nested-workflow dispatch (`DEPTH`), and a malformed workflow-authoring-tool args
+* blob (`TOOL`). `DEPTH` and `TOOL` are public type surface constructed by the
+* `@orkestrel/tool` package's workflow-tool / agent-function adapters; on that seam the
+* throw is ISOLATED by its `ToolManager` into the tool result's top-level `error`
+* (AGENTS §14 — the universal tool-handler contract).
 */
 var WorkflowError = class extends Error {
 	code;
@@ -332,66 +224,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
-* The {@link import('./WorkflowRunner.js').WorkflowRunner}'s cycle guard records one of
-* these per workflow in the current nested run chain (carried on
-* {@link import('./types.js').WorkflowRunOptions.ancestry}). Tagging the bare id keeps a
-* workflow id and an {@link agentTag} agent name in ONE namespaced set without collision,
-* so re-entering a workflow OR an agent already in the chain is a single `includes` check.
-*
-* @param id - The workflow definition's `id`
-* @returns The namespaced ancestry tag (`workflow:<id>`)
-*/
-function workflowTag(id) {
-	return `workflow:${id}`;
-}
-/**
-* The ancestry identifier of an agent in a run chain — `agent:<name>`.
-*
-* @remarks
-* The agent counterpart of {@link workflowTag}: the runner adds one when it dispatches an
-* `agent` task, and rejects the task (a typed `DEPTH` `task.fail`) when the same tag is
-* already in the ancestry (a re-entry cycle). The `agent:` namespace keeps it distinct
-* from a same-string workflow id.
-*
-* @param name - The agent's registry name (the `agent`-form's `name`)
-* @returns The namespaced ancestry tag (`agent:<name>`)
-*/
-function agentTag(name) {
-	return `agent:${name}`;
-}
-/**
 * Test whether a {@link LifecycleStatus} is TERMINAL — a node in this state will not
 * transition further.
 *
@@ -477,6 +309,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.
 *
@@ -494,6 +356,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`.
 *
@@ -569,10 +491,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.
@@ -610,6 +534,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
@@ -622,6 +547,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))
 	};
 }
@@ -630,6 +556,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}
 */
@@ -639,7 +571,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 }
 	};
 }
 /**
@@ -658,131 +593,64 @@ function collectResults(phases) {
 	return phases.flat();
 }
 /**
-* Summarize a terminal {@link WorkflowResult} into the PLAIN value a
-* {@link import('./factories.js').createWorkflowTool} handler returns on success.
-*
-* @remarks
-* This is the run summary the handler returns DIRECTLY — NOT a `ToolResult` (the future `@orkestrel/agent` package).
-* The handler conforms to the universal tool-handler contract (AGENTS §14): it returns the plain value
-* (and throws on failure), so the `@orkestrel/agent` package's `ToolManager` performs
-* the ONE canonical wrap (`{ id, name, value }`) and the model reads exactly this summary — once,
-* identically — over BOTH the agent loop and MCP. The summary is LEAN: the workflow's terminal `status`
-* and the COUNT of settled task results — enough for a caller / model to react without serializing the
-* whole live tree. (It carries no synthetic `id` / `name`: a tool handler has no call id; the manager
-* supplies the canonical envelope's identity.)
-*
-* @param result - The terminal {@link WorkflowResult} the run produced
-* @returns The plain success summary — `{ status, count }`
-*/
-function workflowToolSummary(result) {
-	return {
-		status: result.status,
-		count: result.results.length
-	};
-}
-/**
-* Complete a {@link WorkflowDraft} into a strict {@link WorkflowDefinition} — synthesize
-* any MISSING `id` deterministically + positionally, and default any MISSING `name` to
-* its (now-resolved) `id`.
+* 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
-* The positional id scheme is stable and human-legible: the workflow is `wf`, phase `i`
-* is `phase-<i>`, and task `j` of that phase is `<phaseId>-task-<j>` (so a provided phase
-* id flows into its tasks' synthesized ids). A PROVIDED `id` / `name` at any level is kept
-* VERBATIM — synthesis touches only the omitted ones. A missing `name` defaults to the
-* resolved `id` (never the other way round), so the result always has both. `run`,
-* `description`, the per-phase `concurrency` / `bail`, the per-task `retries` / `timeout`, and
-* the workflow `bail` carry over unchanged. The result is a complete
-* {@link WorkflowDefinition}; the caller still validates it against the STRICT contract.
-*
-* @param draft - The draft workflow (id/name optional at all three levels)
-* @returns A complete {@link WorkflowDefinition} with every id/name filled
-*/
-function completeDraft(draft) {
-	const id = draft.id ?? "wf";
-	return {
-		id,
-		name: draft.name ?? id,
-		...draft.description === void 0 ? {} : { description: draft.description },
-		phases: draft.phases.map((phase, index) => completePhaseDraft(phase, index)),
-		...draft.bail === void 0 ? {} : { bail: draft.bail }
-	};
-}
-/**
-* Complete one {@link PhaseDraft} into a strict {@link PhaseDefinition} — the per-phase
-* step of {@link completeDraft} (phase `index` → `phase-<index>` when its id is omitted).
+* 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 phase - The draft phase
-* @param index - The phase's positional index in the workflow
-* @returns A complete {@link PhaseDefinition}
-*/
-function completePhaseDraft(phase, index) {
-	const id = phase.id ?? `phase-${index}`;
-	return {
-		id,
-		name: phase.name ?? id,
-		...phase.description === void 0 ? {} : { description: phase.description },
-		tasks: phase.tasks.map((task, taskIndex) => completeTaskDraft(task, id, taskIndex)),
-		...phase.concurrency === void 0 ? {} : { concurrency: phase.concurrency },
-		...phase.bail === void 0 ? {} : { bail: phase.bail }
-	};
-}
-/**
-* Complete one {@link TaskDraft} into a strict {@link TaskDefinition} — the per-task leaf
-* step of {@link completeDraft} (task `index` of phase `<phaseId>` → `<phaseId>-task-<index>`
-* when its id is omitted).
-*
-* @param task - The draft task
-* @param phaseId - The (resolved) parent phase id, so the synthesized task id nests under it
-* @param index - The task's positional index within its phase
-* @returns A complete {@link TaskDefinition}
+* @example
+* ```ts
+* insertEntry([['a', 1], ['b', 2]], 1, 'c', 3) // [['a', 1], ['c', 3], ['b', 2]]
+* ```
 */
-function completeTaskDraft(task, phaseId, index) {
-	const id = task.id ?? `${phaseId}-task-${index}`;
-	return {
-		id,
-		name: task.name ?? id,
-		...task.description === void 0 ? {} : { description: task.description },
-		run: task.run,
-		...task.retries === void 0 ? {} : { retries: task.retries },
-		...task.timeout === void 0 ? {} : { timeout: task.timeout }
-	};
+function insertEntry(entries, index, key, value) {
+	const next = [...entries];
+	next.splice(index, 0, [key, value]);
+	return next;
 }
 /**
-* Expand a flat {@link WorkflowSteps} blob into a strict {@link WorkflowDefinition} — each
-* step becomes a one-task phase, IN ORDER.
+* 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 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? }] }`)
-* @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) }] }))
-	});
-}
-/**
-* Convert one flat {@link WorkflowStep} into a {@link TaskForm} — `name` → the form's `name`,
-* `via` → the form's discriminant (defaulting to `'function'`).
+* 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`
 *
-* @param step - The flat step
-* @returns The {@link TaskForm} the step's task runs
+* @example
+* ```ts
+* moveEntry([['a', 1], ['b', 2], ['c', 3]], 'a', 2) // [['b', 2], ['c', 3], ['a', 1]]
+* ```
 */
-function stepToForm(step) {
-	return {
-		via: step.via ?? "function",
-		name: step.name
-	};
+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
@@ -803,41 +671,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 = unionShape(objectShape({
-	via: literalShape(["function"], { description: "Run a registered workflow FUNCTION by name." }),
-	name: stringShape({
-		min: 1,
-		description: "The registered function name to invoke (a registry key, not a label)."
-	})
-}), objectShape({
-	via: literalShape(["tool"], { description: "Run a registered TOOL by name." }),
-	name: stringShape({
-		min: 1,
-		description: "The registered tool name to invoke (a registry key, not a label)."
-	})
-}), objectShape({
-	via: literalShape(["agent"], { description: "Run a registered AGENT (a subagent) by name." }),
-	name: 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 = objectShape({
 	id: stringShape({
@@ -849,7 +715,10 @@ var taskShape = objectShape({
 		description: "Human-readable task name."
 	}),
 	description: optionalShape(stringShape({ description: "Optional task description." })),
-	run: taskFormShape,
+	run: optionalShape(stringShape({
+		min: 1,
+		description: "The registered behavior name to invoke (a registry key, not a label); omitted has no handler."
+	})),
 	retries: optionalShape(integerShape({
 		min: 0,
 		description: "Extra attempts after the first on failure; overrides the phase default. Omitted means none."
@@ -901,121 +770,41 @@ var workflowShape = objectShape({
 	bail: optionalShape(literalShape([true, false], { description: "Failure policy: false (default) continues gracefully, true halts on the first failure." }))
 });
 /**
-* The shape of a TASK in a draft workflow — identical to {@link taskShape} EXCEPT `id`
-* and `name` are OPTIONAL (the tool synthesizes any missing one positionally).
+* The shape of a {@link import('./types.js').TaskUpdate} — a partial edit to a
+* `pending` task's `name` / `description`, both optional.
 *
 * @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.
+* 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 taskDraftShape = objectShape({
-	id: optionalShape(stringShape({
-		min: 1,
-		description: "Task id; auto-filled when omitted."
-	})),
+var taskUpdateShape = objectShape({
 	name: optionalShape(stringShape({
 		min: 1,
-		description: "Task name; defaults to the id when omitted."
-	})),
-	description: optionalShape(stringShape({ description: "Optional task description." })),
-	run: taskFormShape,
-	retries: optionalShape(integerShape({
-		min: 0,
-		description: "Extra attempts after the first on failure; overrides the phase default. Omitted means none."
+		description: "New task name."
 	})),
-	timeout: optionalShape(integerShape({
-		min: 0,
-		description: "Per-attempt deadline in milliseconds; overrides the phase default. Omitted means no deadline."
-	}))
+	description: optionalShape(stringShape({ description: "New task description." }))
 });
 /**
-* The shape of a PHASE in a draft workflow — identical to {@link phaseShape} EXCEPT
-* `id` and `name` are OPTIONAL, and its tasks are {@link taskDraftShape}s.
-*/
-var phaseDraftShape = objectShape({
-	id: optionalShape(stringShape({
-		min: 1,
-		description: "Phase id; auto-filled when omitted."
-	})),
-	name: optionalShape(stringShape({
-		min: 1,
-		description: "Phase name; defaults to the id when omitted."
-	})),
-	description: optionalShape(stringShape({ description: "Optional phase description." })),
-	tasks: arrayShape(taskDraftShape, { description: "The phase tasks; they run CONCURRENTLY." }),
-	concurrency: optionalShape(integerShape({
-		min: 1,
-		description: "Max tasks in flight at once (a resource throttle); omitted means unbounded."
-	})),
-	bail: optionalShape(literalShape([true, false], { description: "Per-phase failure-policy override; omitted inherits the workflow bail." }))
-});
-/**
-* The shape of a DRAFT workflow — identical to {@link workflowShape} EXCEPT `id` and
-* `name` are OPTIONAL at all three levels (workflow / phase / task), so a small model
-* can omit the six identity strings and let the tool synthesize them positionally.
+* The shape of a {@link import('./types.js').PhaseUpdate} — a partial edit to a
+* `pending` phase's `name` / `description` / `concurrency` / `bail`, all optional.
 *
 * @remarks
-* The lenient counterpart {@link import('./factories.js').createWorkflowDraftContract}
-* compiles. `run` stays required; a provided `id` / `name` still has `minLength: 1` (so an
-* explicitly-empty `id: ''` is REJECTED, not auto-filled). After
-* {@link import('./helpers.js').completeDraft} fills the missing ids/names, the result is
-* validated against the STRICT {@link import('./factories.js').createWorkflowContract} gate
-* before running.
+* 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 workflowDraftShape = objectShape({
-	id: optionalShape(stringShape({
-		min: 1,
-		description: "Workflow id; auto-filled when omitted."
-	})),
+var phaseUpdateShape = objectShape({
 	name: optionalShape(stringShape({
 		min: 1,
-		description: "Workflow name; defaults to the id when omitted."
+		description: "New phase name."
 	})),
-	description: optionalShape(stringShape({ description: "Optional workflow description." })),
-	phases: arrayShape(phaseDraftShape, { description: "The workflow phases; they run SEQUENTIALLY, in order." }),
-	bail: optionalShape(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
-* {@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
-* tool expands each step into a one-task phase, in order
-* ({@link import('./helpers.js').expandSteps}).
-*/
-var stepShape = objectShape({
-	name: stringShape({
-		min: 1,
-		description: "The registered behavior name this step runs (becomes the task run.name)."
-	}),
-	via: optionalShape(literalShape([
-		"function",
-		"tool",
-		"agent"
-	], { description: "How to run it: function (default), tool, or agent." }))
-});
-/**
-* The FLAT authoring shape `createWorkflowTool` advertises as its `parameters` — the
-* simplest surface a small model can fill: `{ name?, steps: [{ name, via? }] }`.
-*
-* @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
-* 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
-* STILL accepted by the tool (it branches on the args' shape) and is documented as the
-* advanced escape-hatch in the tool's description — but THIS is what `parameters` advertises.
-*/
-var workflowStepsShape = objectShape({
-	name: optionalShape(stringShape({
+	description: optionalShape(stringShape({ description: "New phase description." })),
+	concurrency: optionalShape(integerShape({
 		min: 1,
-		description: "Optional workflow name."
+		description: "Max tasks in flight at once (a resource throttle); omitted leaves it unchanged."
 	})),
-	steps: arrayShape(stepShape, { description: "The ordered steps to run, one after another (each becomes a one-task phase)." })
+	bail: optionalShape(literalShape([true, false], { description: "Per-phase failure-policy override; omitted leaves it unchanged." }))
 });
 //#endregion
 //#region src/core/stores/DatabaseWorkflowStore.ts
@@ -1177,6 +966,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;
@@ -1187,7 +982,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;
@@ -1199,6 +1000,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;
@@ -1207,10 +1014,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;
@@ -1227,6 +1034,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);
@@ -1261,6 +1080,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,
@@ -1268,7 +1110,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) {
@@ -1308,6 +1153,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
@@ -1323,18 +1173,51 @@ var Task = class {
 */
 var TaskManager = class {
 	#tasks = /* @__PURE__ */ new Map();
+	#isUpdate = 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
@@ -1359,29 +1242,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 Emitter({
 			on: options?.on,
 			error: options?.error
@@ -1389,21 +1302,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;
@@ -1411,6 +1330,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());
 	}
@@ -1426,10 +1351,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 {
@@ -1439,6 +1435,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())
 		};
 	}
@@ -1463,16 +1460,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);
 	}
@@ -1489,6 +1502,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
@@ -1504,18 +1522,51 @@ var Phase = class {
 */
 var PhaseManager = class {
 	#phases = /* @__PURE__ */ new Map();
+	#isUpdate = 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
@@ -1546,27 +1597,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 Emitter({
 			on: options?.on,
 			error: options?.error
 		});
 		this.#created = snapshot.created;
 		this.#updated = snapshot.updated;
+		this.#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;
@@ -1589,6 +1665,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());
 	}
@@ -1602,13 +1687,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 {
@@ -1640,14 +1807,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,
@@ -1700,10 +1887,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);
@@ -1748,6 +1932,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
@@ -1765,11 +1958,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;
@@ -1794,6 +1989,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");
@@ -1823,6 +2051,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();
@@ -1831,13 +2100,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 = 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
@@ -1858,6 +2127,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);
@@ -1870,7 +2140,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);
@@ -1938,35 +2208,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 the `@orkestrel/tool` package's adapter factories — plain
+*   {@link import('./types.js').WorkflowFunction}s a caller wires into
+*   {@link WorkflowOptions.functions} like any other behavior. This module never imports
+*   any tool/agent package.
+* - **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;
@@ -1974,7 +2260,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`
@@ -1982,59 +2281,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 ? 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.#haltFrom(phases, index, workflow, runSignal);
+					break;
+				}
+				if (workflow.paused) await this.#raceWait(() => workflow.wait(), runSignal);
 				if (this.#cancelled(runSignal) || this.#halted(workflow)) {
-					this.#skipFrom(phases, index);
+					this.#haltFrom(workflow.phases.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 (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,
@@ -2042,52 +2351,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) {
@@ -2097,7 +2425,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) {
@@ -2113,80 +2441,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 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) {
@@ -2195,14 +2475,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;
@@ -2215,11 +2499,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
@@ -2261,41 +2542,6 @@ function createWorkflowContract() {
 	};
 }
 /**
-* Compile the LENIENT workflow DRAFT contract — identical to
-* {@link createWorkflowContract} EXCEPT `id` and `name` are OPTIONAL at all three levels
-* (workflow / phase / task), so a small model can omit the six identity strings.
-*
-* @remarks
-* The widened authoring surface {@link createWorkflowTool} parses an authored blob through
-* before {@link import('./helpers.js').completeDraft} fills the missing ids/names. It does
-* NOT relax the canonical contract — {@link createWorkflowContract} stays byte-for-byte
-* unchanged and STRICT, and the completed draft is re-validated against THAT strict gate
-* before running (soundness preserved). A PROVIDED `id` / `name` still carries `minLength: 1`,
-* so an explicitly-empty `id: ''` is REJECTED (parses to `undefined`), never auto-filled —
-* keeping "garbage" distinct from "omitted". `run` stays required.
-*
-* @returns The compiled {@link WorkflowDraft} contract
-*
-* @example
-* ```ts
-* import { createWorkflowDraftContract, completeDraft } from '@src/core'
-*
-* const draft = createWorkflowDraftContract()
-* const parsed = draft.parse({ phases: [{ tasks: [{ run: { via: 'function', name: 'f' } }] }] })
-* const definition = parsed && completeDraft(parsed) // ids/names filled positionally
-* draft.parse({ id: '', phases: [] })                // undefined — an explicit empty id is rejected
-* ```
-*/
-function createWorkflowDraftContract() {
-	const contract = createContract(workflowDraftShape);
-	return {
-		schema: contract.schema,
-		is: contract.is,
-		generate: (random) => contract.generate(random),
-		parse: (value) => contract.parse(value)
-	};
-}
-/**
 * Build the live W-b entity tree from a {@link WorkflowDefinition} — the whole
 * {@link WorkflowInterface} → {@link import('./types.js').PhaseInterface} →
 * {@link import('./types.js').TaskInterface} tree, each level wired with its lineage
@@ -2311,6 +2557,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
@@ -2370,10 +2621,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
 */
@@ -2403,10 +2657,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
+			});
+		}
 	}
 }
 /**
@@ -2485,157 +2757,51 @@ function createDatabaseWorkflowStore(driver = createMemoryDriver()) {
 /**
 * 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
+* Static tool / agent calling is OPT-IN: a caller wires a plain
+* {@link import('./types.js').WorkflowFunction} into its OWN {@link WorkflowOptions.functions}
+* registry, same as any other behavior — the `@orkestrel/tool` package ships the
+* tool/agent adapter factories for that. A task with no resolved handler 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}.
+* @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);
-}
-/**
-* 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
-* 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.
-*
-* **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
-*   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);
-* - the full nested {@link WorkflowDefinition} — the advanced escape-hatch (documented in the
-*   description), accepted as the draft super-set.
-*
-* The handler conforms to the universal tool-handler contract (AGENTS §14): it returns the PLAIN
-* run-summary VALUE on success and THROWS a typed {@link WorkflowError} on every failure path. It
-* does NOT build a {@link ToolResult} itself — the `@orkestrel/agent` package's `ToolManager`
-* performs the ONE canonical wrap (`{ id, name, value }` on a return; `{ id, name, error }` on a
-* throw, ISOLATED so nothing escapes the run), so the outcome appears EXACTLY ONCE, identically,
-* over BOTH the agent loop and MCP (a throw → MCP `isError: true`):
-* - **No authored args** (an empty `arguments`) ⇒ runs the WRAPPED `definition`.
-* - **A `steps` array** ⇒ the FLAT form: parse it, {@link import('./helpers.js').expandSteps} it.
-* - **Otherwise** ⇒ the nested form: {@link createWorkflowDraftContract}-parse it,
-*   {@link import('./helpers.js').completeDraft} it.
-* - **Strict gate** ⇒ the expanded / completed result is validated against
-*   {@link createWorkflowContract}.`is`; a blob that can't expand, or whose result fails the strict
-*   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}).
-*
-* @param definition - The workflow the tool runs when called with no authored args
-* @param runner - The {@link WorkflowRunnerInterface} that executes the (nested) workflow
-* @param options - The depth + ancestry to run the nested workflow under (see
-*   {@link WorkflowToolOptions}); omitted ⇒ depth `0` / empty ancestry (a top-level wrap)
-* @returns A {@link ToolInterface} (named {@link import('./constants.js').WORKFLOW_TOOL_NAME})
-*   whose `parameters` advertise the FLAT authoring schema (the nested form stays accepted)
-*
-* @example
-* ```ts
-* import { createWorkflowRunner, createWorkflowTool, createToolManager } from '@src/core'
-*
-* const runner = createWorkflowRunner()
-* const tool = createWorkflowTool(definition, runner)
-* const tools = createToolManager()
-* tools.add(tool) // a model can now author + run a workflow in one call
-* ```
-*/
-function createWorkflowTool(definition, runner, options) {
-	const strict = createWorkflowContract();
-	const draft = createWorkflowDraftContract();
-	const steps = createContract(workflowStepsShape);
-	const depth = options?.depth ?? 0;
-	const ancestry = options?.ancestry ?? [];
-	return createTool({
-		name: WORKFLOW_TOOL_NAME,
-		description: WORKFLOW_TOOL_DESCRIPTION,
-		parameters: schemaToParameters(steps.schema),
-		execute: async (args) => {
-			let target;
-			if (Object.keys(args).length === 0) target = definition;
-			else if (Array.isArray(args.steps)) {
-				const flat = steps.parse(args);
-				target = flat === void 0 ? void 0 : expandSteps(flat);
-			} else {
-				const parsed = draft.parse(args);
-				target = parsed === void 0 ? void 0 : completeDraft(parsed);
-			}
-			if (target === void 0 || !strict.is(target)) throw new WorkflowError("TOOL", "malformed workflow definition", { workflow: definition.id });
-			if (depth + 1 > 8) throw new WorkflowError("DEPTH", `nested workflow exceeds max depth 8`, {
-				workflow: target.id,
-				depth,
-				max: 8
-			});
-			const tag = workflowTag(target.id);
-			if (ancestry.includes(tag)) throw new WorkflowError("DEPTH", `workflow '${target.id}' is already an ancestor (cycle)`, {
-				workflow: target.id,
-				ancestry: [...ancestry]
-			});
-			return workflowToolSummary(await runner.execute(target, {
-				depth: depth + 1,
-				ancestry: [...ancestry, tag]
-			}));
-		}
-	});
+	return new WorkflowRunner(options?.scheduler ?? createScheduler());
 }
 /**
 * Create the safe cross-environment cooperative-yield default — a
@@ -2729,6 +2895,6 @@ function createRunner(options) {
 	return new Runner(options);
 }
 //#endregion
-export { Controller, DEFAULT_BAIL, DEFAULT_PHASE_CONCURRENCY, DatabaseWorkflowStore, MAX_WORKFLOW_DEPTH, MemoryWorkflowStore, PHASE_STATUSES, Phase, PhaseManager, Runner, Scheduler, TASK_STATUSES, TASK_TRANSITIONS, TASK_VIAS, TERMINAL_TASK_STATUSES, Task, TaskController, TaskManager, WORKFLOW_STATUSES, WORKFLOW_TOOL_DESCRIPTION, WORKFLOW_TOOL_FLAT_EXAMPLE, WORKFLOW_TOOL_NAME, WORKFLOW_TOOL_NESTED_EXAMPLE, Workflow, WorkflowError, WorkflowRunner, agentTag, assertSnapshot, buildPhaseContext, buildTaskContext, buildWorkflowContext, canTransitionTask, collectResults, completeDraft, completePhaseDraft, completeTaskDraft, createDatabaseWorkflowStore, createDeferred, createMemoryWorkflowStore, createRunner, createScheduler, createWorkflow, createWorkflowContract, createWorkflowDraftContract, createWorkflowRunner, createWorkflowTool, definitionToSnapshot, derivePhaseStatus, deriveWorkflowStatus, expandSteps, isAgentTask, isFunctionTask, isTerminalStatus, isToolTask, isWorkflowError, isWorkflowSnapshot, phaseDefinitionToSnapshot, phaseDraftShape, phaseShape, restoreWorkflow, stepShape, stepToForm, taskDefinitionToSnapshot, taskDraftShape, taskFormShape, taskShape, workflowDraftShape, workflowShape, workflowStepsShape, workflowTag, workflowToolSummary };
+export { Controller, DEFAULT_BAIL, DEFAULT_PHASE_CONCURRENCY, DatabaseWorkflowStore, MemoryWorkflowStore, PHASE_STATUSES, Phase, PhaseManager, Runner, Scheduler, TASK_STATUSES, TASK_TRANSITIONS, TERMINAL_TASK_STATUSES, Task, TaskController, TaskManager, WORKFLOW_STATUSES, Workflow, WorkflowError, WorkflowRunner, assertSnapshot, buildPhaseContext, buildTaskContext, buildWorkflowContext, canTransitionTask, collectResults, createDatabaseWorkflowStore, createDeferred, createMemoryWorkflowStore, createRunner, createScheduler, createWorkflow, createWorkflowContract, createWorkflowRunner, definitionToSnapshot, deriveBoundary, derivePhaseStatus, deriveWorkflowStatus, failure, findFailure, insertEntry, isTerminalStatus, isWorkflowError, isWorkflowSnapshot, moveEntry, parkSignal, phaseDefinitionToSnapshot, phaseShape, phaseUpdateShape, restoreWorkflow, success, taskDefinitionToSnapshot, taskShape, taskUpdateShape, workflowShape };
 
 //# sourceMappingURL=index.js.map