@orkestrel/workflow 0.0.1 → 0.0.3

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

@@ -1,5 +1,4 @@
 import { AbortInterface } from '@orkestrel/abort';
-import { AgentInterface } from '@orkestrel/agent';
 import { ArrayShape } from '@orkestrel/contract';
 import { BudgetInterface } from '@orkestrel/budget';
 import { ContractInterface } from '@orkestrel/contract';
@@ -7,31 +6,16 @@ import { DriverInterface } from '@orkestrel/database';
 import { EmitterErrorHandler } from '@orkestrel/emitter';
 import { EmitterHooks } from '@orkestrel/emitter';
 import { EmitterInterface } from '@orkestrel/emitter';
+import { Failure } from '@orkestrel/contract';
 import { LiteralShape } from '@orkestrel/contract';
 import { NumberShape } from '@orkestrel/contract';
 import { ObjectShape } from '@orkestrel/contract';
 import { OptionalShape } from '@orkestrel/contract';
 import { Result } from '@orkestrel/contract';
 import { StringShape } from '@orkestrel/contract';
+import { Success } from '@orkestrel/contract';
 import { TableInterface } from '@orkestrel/database';
 import { TokenUsage } from '@orkestrel/budget';
-import { ToolInterface } from '@orkestrel/agent';
-import { ToolManagerInterface } from '@orkestrel/agent';
-import { UnionShape } from '@orkestrel/contract';
-
-/**
- * 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>`)
- */
-export declare function agentTag(name: string): string;
 
 /**
  * Assert that a {@link WorkflowSnapshot} carries a `boolean` `bail` — at the workflow tier AND
@@ -43,10 +27,13 @@ export declare function agentTag(name: string): string;
  * untrusted JSON, so a status (or an override) outside
  * {@link import('./constants.js').WORKFLOW_STATUSES} /
  * {@link import('./constants.js').PHASE_STATUSES} / {@link import('./constants.js').TASK_STATUSES},
- * or a non-boolean `bail` (the workflow's OR any phase's — both are REQUIRED persisted policy),
+ * a non-boolean `bail` (the workflow's OR any phase's — both are REQUIRED persisted policy), a
+ * present-but-invalid phase `concurrency` (not a positive integer), or a present-but-invalid task
+ * `run` (an empty string) / `retries` / `timeout` (not a non-negative integer),
  * is rejected loudly (naming the offending node) rather than silently producing a broken tree.
- * The `override` is optional, so it is only checked WHEN present. Structural shape beyond these
- * fields is the contract's concern; this guards exactly the fields the live state machine reads back.
+ * The `override` / `concurrency` / `run` / `retries` / `timeout` are optional, so each is only
+ * checked WHEN present. Structural shape beyond these fields is the contract's concern; this
+ * guards exactly the fields the live state machine reads back.
  *
  * @param snapshot - The snapshot to validate
  */
@@ -117,48 +104,6 @@ export declare function canTransitionTask(from: TaskStatus, to: TaskStatus): boo
  */
 export declare function collectResults(phases: readonly (readonly TaskResult[])[]): readonly TaskResult[];
 
-/**
- * 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`.
- *
- * @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
- */
-export declare function completeDraft(draft: WorkflowDraft): WorkflowDefinition;
-
-/**
- * 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).
- *
- * @param phase - The draft phase
- * @param index - The phase's positional index in the workflow
- * @returns A complete {@link PhaseDefinition}
- */
-export declare function completePhaseDraft(phase: PhaseDraft, index: number): PhaseDefinition;
-
-/**
- * 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}
- */
-export declare function completeTaskDraft(task: TaskDraft, phaseId: string, index: number): TaskDefinition;
-
 /**
  * The per-unit handle a runner handler receives — wraps the unit's identity,
  * input, cancellation, and the run controls (`wait` / `spawn` / `abort`).
@@ -441,6 +386,11 @@ export declare function createScheduler(): SchedulerInterface;
  * `options.phases[id].tasks[id]` (the AGENTS §8 nested-by-id bag). The W-b tree is the
  * state machine ONLY — it does not execute tasks (W-c drives the transitions).
  *
+ * `options.functions` is the {@link import('./types.js').WorkflowFunctions} registry each live
+ * task's `run` name resolves against ONCE at construction into its runtime
+ * {@link import('./types.js').TaskInterface.handler} — a name omitted or absent from the
+ * registry resolves to no handler (the no-handler rule).
+ *
  * @param definition - The workflow definition to bring to life
  * @param options - Runtime options (initial listeners, `bail` override, per-node options)
  * @returns The live {@link WorkflowInterface} root
@@ -485,152 +435,54 @@ export declare function createWorkflow(definition: WorkflowDefinition, options?:
  */
 export declare function createWorkflowContract(): ContractInterface<WorkflowDefinition>;
 
-/**
- * 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
- * ```
- */
-export declare function createWorkflowDraftContract(): ContractInterface<WorkflowDraft>;
-
 /**
  * Create a workflow runner — a {@link WorkflowRunnerInterface} that EXECUTES a live W-b
  * workflow tree by COMPOSING the shipped substrate: phases sequential, tasks concurrent,
- * each task dispatched BY NAME under the workflow's `bail` policy.
- *
- * @remarks
- * The runner is THIN — it re-implements no concurrency / retry / abort logic. Per-phase
- * bounded concurrency is one {@link createRunner} per phase;
- * `bail` maps onto that Runner's fail-fast (`true` — the first failure aborts the in-flight
- * siblings + skips the rest) vs settle-all (`false` — failures are recorded, the run
- * finishes); the run-level abort / timeout / budget ({@link import('./types.js').WorkflowRunOptions})
- * fold through `AbortSignal.any` (the agent runtime's pattern); pacing is the shipped
- * scheduler. `execute(definition, options?)` BUILDS the live tree from the definition itself
- * (via {@link createWorkflow} — one source of truth, returned in `WorkflowResult.workflow`),
- * drives the live entity (`start` → `complete` / `fail`), and resolves a
+ * each task dispatched through its OWN resolved handler under the workflow's `bail` policy.
+ *
+ * @remarks
+ * The runner is a PURE engine — it re-implements no concurrency / retry / abort logic, AND it
+ * carries no `functions` / `tools` / `agents` registry of its own: each live task already
+ * resolved its own {@link import('./types.js').WorkflowFunction} into
+ * {@link import('./types.js').TaskInterface.handler} ONCE at construction, from the
+ * {@link WorkflowOptions.functions} registry supplied to `execute` / {@link createWorkflow}.
+ * Per-phase bounded concurrency is one {@link createRunner} per phase; `bail` maps onto that
+ * Runner's fail-fast (`true` — the first failure aborts the in-flight siblings + skips the
+ * rest) vs settle-all (`false` — failures are recorded, the run finishes); the run-level abort
+ * / timeout / budget ({@link import('./types.js').WorkflowRunOptions}) fold through
+ * `AbortSignal.any` (the agent runtime's pattern); pacing is the shipped scheduler.
+ * `execute(definition, options?)` BUILDS the live tree from the definition itself (via
+ * {@link createWorkflow} — one source of truth, returned in `WorkflowResult.workflow`), drives
+ * the live entity (`start` → `complete` / `fail`), and resolves a
  * {@link import('./types.js').WorkflowResult}.
  *
- * A task is dispatched on its {@link import('./types.js').TaskForm}: `function` → the
- * `functions` registry, `tool` → the `tools` {@link ToolManagerInterface}, `agent` → the
- * `agents` {@link import('./types.js').WorkflowAgents} resolver (W-c2), behind a depth + cycle
- * guard. A task whose handler is NOT found (an unregistered name for ANY form) AUTO-COMPLETES
+ * 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'
  * ```
  */
 export declare function createWorkflowRunner(options?: WorkflowRunnerOptions): WorkflowRunnerInterface;
 
-/**
- * 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
- * ```
- */
-export declare function createWorkflowTool(definition: WorkflowDefinition, runner: WorkflowRunnerInterface, options?: WorkflowToolOptions): ToolInterface;
-
 /**
  * A {@link WorkflowStoreInterface} backed by one table of the `databases` layer — a
  * workflow's durable run-state IS a row, so persistence reduces to keyed point-access
@@ -702,17 +554,23 @@ export declare const DEFAULT_BAIL = false;
 /**
  * The default per-phase task concurrency the {@link import('./factories.js').createWorkflowRunner}
  * runner applies when a {@link import('./types.js').PhaseDefinition} omits its `concurrency`
- * throttle — a large cap that is effectively unbounded for any realistic phase.
+ * throttle — a cap that is effectively unbounded for any realistic phase.
  *
  * @remarks
  * The determinism principle fixes that a phase's tasks run CONCURRENTLY; `concurrency` is
  * only an optional resource throttle (max-in-flight). With none declared, the runner runs
- * all of a phase's tasks at once — modelled as this large finite cap so the value flows
- * straight into the substrate {@link import('./types.js').RunnerInterface}'s
- * `concurrency` (which expects a positive integer) without a special unbounded branch. No
- * realistic phase declares enough tasks to reach it, so it behaves as "run them all".
+ * all of a phase's tasks at once — modelled as this finite cap so the value flows straight
+ * into the substrate {@link import('./types.js').RunnerInterface}'s `concurrency` (which
+ * expects a positive integer) without a special unbounded branch. No realistic phase
+ * declares enough tasks to reach it, so it behaves as "run them all".
+ *
+ * WHY `1024` and not a huge sentinel like `1_000_000`: the backing `@orkestrel/queue` Runner
+ * EAGERLY spawns one parked worker loop per concurrency unit AT CONSTRUCTION, so this default
+ * must be a value whose eager allocation cost is negligible for every default-concurrency
+ * phase — a million-unit default meant ~1e6 promise/closure allocations per such phase. A
+ * phase may still DECLARE a larger explicit `concurrency` and pays that allocation knowingly.
  */
-export declare const DEFAULT_PHASE_CONCURRENCY = 1000000;
+export declare const DEFAULT_PHASE_CONCURRENCY = 1024;
 
 /**
  * A promise paired with its externally-callable `resolve`/`reject` — the settle path
@@ -733,10 +591,12 @@ export declare interface DeferredInterface<T> {
  *
  * @remarks
  * The structural fields (`id` / `name` / `description` + the ordered phases / tasks)
- * carry over verbatim; the W-b live tree is the DECLARATIVE state machine, so the
- * execution-only definition fields (per-phase `run` / `concurrency`, per-task `retries` /
- * `timeout`) are intentionally dropped (W-c reads them from the definition when it drives
- * transitions). The `bail` policy carries over — at the workflow tier AND, per phase, the
+ * carry over verbatim, as does each phase's `concurrency` (persisted on the
+ * {@link PhaseSnapshot} so a restore reinstates the same throttle) and each task's `run` /
+ * `retries` / `timeout` (persisted on the {@link TaskSnapshot}, like `bail` / `concurrency`,
+ * so a restore + a {@link import('./types.js').WorkflowOptions.functions} registry resumes
+ * real work). The `bail` policy carries over — at the
+ * workflow tier AND, per phase, the
  * EFFECTIVE policy (`phase.bail ?? workflowBail`) on each {@link PhaseSnapshot} — so the seeded
  * snapshot is self-contained; a fresh seed has no `override`. `created` / `updated` are stamped now.
  * {@link import('./factories.js').createWorkflow} builds from this.
@@ -754,6 +614,34 @@ export declare interface DeferredInterface<T> {
  */
 export declare function definitionToSnapshot(definition: WorkflowDefinition, bail?: boolean): WorkflowSnapshot;
 
+/**
+ * Derive the PENDING SUFFIX boundary of a positional list of {@link LifecycleStatus}es —
+ * the index of the first entry in the contiguous trailing run of `pending` entries.
+ *
+ * @remarks
+ * The native, hook-free replacement for a runner-installed cursor (AGENTS §12): a
+ * {@link import('./types.js').WorkflowInterface}'s `add` / `remove` / `move` / `update`
+ * reads this over its live phases' statuses to decide which positions are safe to edit.
+ * Because entries run SEQUENTIALLY (phases sequential, AGENTS determinism), every
+ * already-started entry forms a contiguous LEADING prefix and every still-`pending`
+ * entry forms the trailing suffix — so the boundary is simply the count of leading
+ * non-`pending` entries: the index of the first `pending` entry, or the full length when
+ * none is `pending` (nothing is safely editable). A `pending` container's entries are ALL
+ * `pending`, so the boundary is `0` and every position is naturally accepted — callers
+ * need no special case for that.
+ *
+ * @param statuses - The positional list of statuses to derive the boundary from
+ * @returns The index of the first `pending` entry, or `statuses.length` when none is `pending`
+ *
+ * @example
+ * ```ts
+ * deriveBoundary(['completed', 'running', 'pending', 'pending']) // 2
+ * deriveBoundary(['pending', 'pending']) // 0
+ * deriveBoundary(['completed', 'completed']) // 2 (nothing pending)
+ * ```
+ */
+export declare function deriveBoundary(statuses: readonly LifecycleStatus[]): number;
+
 /**
  * Derive a phase's status from its tasks' statuses (tasks are concurrent, so this
  * is an order-insensitive reduction).
@@ -808,47 +696,67 @@ export declare function derivePhaseStatus(tasks: readonly TaskStatus[]): PhaseSt
 export declare function deriveWorkflowStatus(phases: readonly PhaseDerivation[]): WorkflowStatus;
 
 /**
- * Expand a flat {@link WorkflowSteps} blob into a strict {@link WorkflowDefinition} — each
- * step becomes a one-task phase, IN ORDER.
+ * Box an error as a {@link Failure} — the graceful outcome half of a {@link Result}.
  *
- * @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.
+ * @typeParam E - The boxed error's type
+ * @param error - The error to box
+ * @returns A {@link Failure} wrapping `error`
  *
- * @param flat - The flat steps blob (`{ name?, steps: [{ name, via? }] }`)
- * @returns A complete {@link WorkflowDefinition} (one one-task phase per step)
+ * @example
+ * ```ts
+ * const result = failure(new WorkflowError('MUTATION', 'refused')) // { success: false, error }
+ * ```
  */
-export declare function expandSteps(flat: WorkflowSteps): WorkflowDefinition;
+export declare function failure<E>(error: E): Failure<E>;
 
 /**
- * Narrow a {@link TaskForm} to the `agent` form — a task that runs a registered
- * agent (a subagent).
+ * Find the first {@link TaskResult} in a positional list whose boxed outcome is a
+ * `Failure` — the pure scan shared by a phase's and a workflow's derived-`failed`
+ * `fail`-event lookup.
+ *
+ * @remarks
+ * The shared leaf behind {@link import('./phases/Phase.js').Phase} and
+ * {@link import('./Workflow.js').Workflow}'s own `#failure` — each gathers ITS tier's
+ * results (a phase's own settled tasks, a workflow's flattened `results()`) and feeds
+ * them here; the tier-local method keeps the §12 invariant throw (a derived `failed`
+ * status guarantees a failing result exists) since throwing on `undefined` is
+ * orchestration, not a leaf concern.
  *
- * @param form - The task form to test
- * @returns `true` when `form.via` is `'agent'`
+ * @param results - The results to scan, in any order
+ * @returns The first result whose `result.success` is `false`, or `undefined` if none
+ *
+ * @example
+ * ```ts
+ * findFailure([completedResult, failedResult]) // failedResult
+ * ```
  */
-export declare function isAgentTask(form: TaskForm): form is {
-    readonly via: 'agent';
-    readonly name: string;
-};
+export declare function findFailure(results: readonly TaskResult[]): TaskResult | undefined;
 
 /**
- * Narrow a {@link TaskForm} to the `function` form — a task that runs a registered
- * function.
+ * Insert one `[key, value]` entry at a positional index into a readonly entries array —
+ * the pure splice-in step behind an insertion-ordered registry's `add`.
+ *
+ * @remarks
+ * Shared by {@link import('./tasks/TaskManager.js').TaskManager} and
+ * {@link import('./phases/PhaseManager.js').PhaseManager}: both convert their
+ * insertion-ordered `Map` to `[...map.entries()]`, call this to splice the new entry
+ * in at the target index, then rebuild the `Map` from the result (a stateful step that
+ * stays a `#` private method — this helper does no `Map` construction). Does not
+ * mutate `entries`; returns a new array.
  *
- * @param form - The task form to test
- * @returns `true` when `form.via` is `'function'`
+ * @typeParam T - The entry's value type
+ * @param entries - The current positional entries, in order
+ * @param index - The index to insert at (`0` prepends, `entries.length` appends)
+ * @param key - The new entry's key
+ * @param value - The new entry's value
+ * @returns A new entries array with `[key, value]` inserted at `index`
+ *
+ * @example
+ * ```ts
+ * insertEntry([['a', 1], ['b', 2]], 1, 'c', 3) // [['a', 1], ['c', 3], ['b', 2]]
+ * ```
  */
-export declare function isFunctionTask(form: TaskForm): form is {
-    readonly via: 'function';
-    readonly name: string;
-};
+export declare function insertEntry<T>(entries: readonly (readonly [string, T])[], index: number, key: string, value: T): readonly (readonly [string, T])[];
 
 /**
  * Test whether a {@link LifecycleStatus} is TERMINAL — a node in this state will not
@@ -867,17 +775,6 @@ export declare function isFunctionTask(form: TaskForm): form is {
  */
 export declare function isTerminalStatus(status: LifecycleStatus): boolean;
 
-/**
- * Narrow a {@link TaskForm} to the `tool` form — a task that runs a registered tool.
- *
- * @param form - The task form to test
- * @returns `true` when `form.via` is `'tool'`
- */
-export declare function isToolTask(form: TaskForm): form is {
-    readonly via: 'tool';
-    readonly name: string;
-};
-
 /**
  * Narrow an unknown caught value to a {@link WorkflowError}.
  *
@@ -931,20 +828,6 @@ export declare function isWorkflowSnapshot(value: unknown): value is WorkflowSna
  */
 export declare type LifecycleStatus = 'pending' | 'running' | 'completed' | 'failed' | 'skipped' | 'stopped';
 
-/**
- * The maximum nesting depth a workflow's `agent` task may spawn into (W-c) — the
- * bound the runner's depth/cycle guard enforces.
- *
- * @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.
- */
-export declare const MAX_WORKFLOW_DEPTH = 8;
-
 /**
  * The in-memory {@link WorkflowStoreInterface} — a process-lifetime `Map` of
  * {@link WorkflowSnapshot}s keyed by workflow id, the DEFAULT store
@@ -990,6 +873,54 @@ export declare class MemoryWorkflowStore implements WorkflowStoreInterface {
     delete(id: string): Promise<void>;
 }
 
+/**
+ * Reposition the entry keyed `key` to a new positional index in a readonly entries
+ * array — the pure remove-then-reinsert step behind an insertion-ordered registry's
+ * `move`.
+ *
+ * @remarks
+ * The move counterpart of {@link insertEntry}: finds the entry by `key`, splices it
+ * out, then splices it back in at `index`. An absent `key` is a no-op (returns a copy
+ * of `entries` unchanged) — the caller (`TaskManager.move` / `PhaseManager.move`)
+ * already gates on the target's existence before calling this, so the no-op branch is
+ * defensive, never reached in practice. Does not mutate `entries`; returns a new array.
+ *
+ * @typeParam T - The entry's value type
+ * @param entries - The current positional entries, in order
+ * @param key - The key of the entry to reposition
+ * @param index - The new index for the entry
+ * @returns A new entries array with the `key` entry repositioned to `index`
+ *
+ * @example
+ * ```ts
+ * moveEntry([['a', 1], ['b', 2], ['c', 3]], 'a', 2) // [['b', 2], ['c', 3], ['a', 1]]
+ * ```
+ */
+export declare function moveEntry<T>(entries: readonly (readonly [string, T])[], key: string, index: number): readonly (readonly [string, T])[];
+
+/**
+ * Park until `signal` aborts — a promise-parked wait (AGENTS §21), never a timer or
+ * busy-loop, that NEVER rejects.
+ *
+ * @remarks
+ * Resolves IMMEDIATELY when `signal` is already aborted; otherwise attaches a one-shot
+ * `abort` listener and resolves when it fires, removing the listener either way. The
+ * shared leaf behind the duplicate abort-wiring an execution engine otherwise hand-rolls
+ * at every fold point.
+ *
+ * @param signal - The signal to park on
+ * @returns A promise that resolves once `signal` has aborted
+ *
+ * @example
+ * ```ts
+ * const controller = new AbortController()
+ * const parked = parkSignal(controller.signal)
+ * controller.abort()
+ * await parked // resolves
+ * ```
+ */
+export declare function parkSignal(signal: AbortSignal): Promise<void>;
+
 /**
  * The live DERIVED state machine (W-b) for one phase — an observable (AGENTS §13) whose
  * {@link PhaseStatus} is computed from its tasks (never set directly) and recomputed
@@ -1011,10 +942,38 @@ export declare class MemoryWorkflowStore implements WorkflowStoreInterface {
  *   `start` / `complete` / `fail` / `stop` on a derived-status CHANGE, strictly AFTER the
  *   recompute + escalate; the emitter isolates a listener throw and routes it to its `error`
  *   handler (the `error` option); `fail` carries the failing task's {@link TaskResult}.
+ * - **Structural API (AGENTS §7).** `add` / `remove` / `move` / `update` gate BEFORE
+ *   delegating to {@link tasks} (the manager gates the target's own existence/status/id/
+ *   bounds), then emit the matching {@link PhaseEventMap} event on success only. NATIVE
+ *   gating, purely from this phase's own derived `status` (no runner-installed hook): while
+ *   `pending`, any valid `index` is accepted; while `running`, `add` accepts ONLY a pure
+ *   append (a live runner subscribed to the `add` event picks it up), and `remove` / `move` /
+ *   `update` always fail gracefully (the tasks are already handed to the execution
+ *   substrate); while terminal, everything is refused.
+ * - **Patch (AGENTS §12).** `patch` applies a validated {@link PhaseUpdate} to SELF
+ *   (`name` / `description` / `concurrency` / `bail`) — defense-in-depth: it throws a
+ *   `MUTATION` {@link WorkflowError} unless this phase's own `status` is `pending`, mirroring
+ *   the owning {@link WorkflowInterface.update}'s gate.
+ * - **Minting (AGENTS §7).** {@link add} MINTS a live {@link Task} from a {@link TaskDefinition}
+ *   (converts it to a {@link TaskSnapshot}, builds the task wired to THIS phase) — the same
+ *   construction path {@link #append} uses at build time, so a live mint and a restored/built
+ *   task are wired IDENTICALLY. At construction, the workflow-level
+ *   {@link import('../types.js').WorkflowFunctions} registry (threaded from
+ *   {@link import('../types.js').WorkflowOptions.functions}) resolves each task's `run` name into
+ *   its runtime {@link import('../types.js').TaskInterface.handler} ONCE; a `run` that is omitted
+ *   or unregistered resolves to no handler (the no-handler rule).
+ * - **Runtime lifecycle (AGENTS §10).** `pause` / `resume` / `wait` mirror the workflow's own
+ *   quartet, scoped to this phase — a driving
+ *   {@link import('../types.js').WorkflowRunnerInterface.execute} gates a task's own
+ *   pre-dispatch on the workflow's gate FIRST, then this phase's gate, WITHOUT touching
+ *   {@link status} — `paused` is runtime-only, never persisted. `skip` / `stop` (this phase's
+ *   own terminal forcing) always release a parked {@link wait} waiter, mirroring
+ *   {@link import('../Workflow.js').Workflow.destroy}'s cascade — a permanently-ended phase
+ *   has nothing left to pause for.
  */
 export declare class Phase implements PhaseInterface {
     #private;
-    constructor(snapshot: PhaseSnapshot, workflow: WorkflowInterface, escalate: () => void, options?: PhaseOptions, bail?: boolean);
+    constructor(snapshot: PhaseSnapshot, workflow: WorkflowInterface, escalate: () => void, options?: PhaseOptions, bail?: boolean, functions?: WorkflowFunctions);
     get emitter(): EmitterInterface<PhaseEventMap>;
     get id(): string;
     get name(): string;
@@ -1022,12 +981,22 @@ export declare class Phase implements PhaseInterface {
     get context(): PhaseContext;
     get workflow(): WorkflowInterface;
     get bail(): boolean;
+    get concurrency(): number | undefined;
+    get paused(): boolean;
     get status(): PhaseStatus;
     get tasks(): TaskManagerInterface;
     task(id: string): TaskInterface | undefined;
     results(): readonly TaskResult[];
     skip(): void;
     stop(): void;
+    pause(): void;
+    resume(): void;
+    wait(): Promise<void>;
+    add(definition: TaskDefinition, index?: number): Result<TaskInterface, WorkflowError>;
+    remove(id: string): Result<TaskInterface, WorkflowError>;
+    move(id: string, index: number): Result<TaskInterface, WorkflowError>;
+    update(id: string, patch: TaskUpdate): Result<TaskInterface, WorkflowError>;
+    patch(value: PhaseUpdate): void;
     snapshot(): PhaseSnapshot;
 }
 
@@ -1082,6 +1051,7 @@ export declare interface PhaseDefinition {
  * The snapshot persists the EFFECTIVE failure policy this phase runs under: the phase's own
  * `bail` when it declares one, else the `workflowBail` it inherits — so a restore reinstates
  * the same per-phase policy without a silent default (`effectiveBail = phase.bail ?? workflowBail`).
+ * `concurrency` (the resource throttle) carries over verbatim, omitted when undefined.
  *
  * @param phase - The phase definition to seed from
  * @param workflowBail - The workflow-level `bail` default the phase inherits when it declares none
@@ -1106,47 +1076,6 @@ export declare interface PhaseDerivation {
     readonly bail: boolean;
 }
 
-/** A draft phase — a {@link PhaseDefinition} with OPTIONAL `id` / `name` and {@link TaskDraft} tasks. */
-export declare interface PhaseDraft {
-    readonly id?: string;
-    readonly name?: string;
-    readonly description?: string;
-    readonly tasks: readonly TaskDraft[];
-    /** Max tasks in flight at once (a resource throttle); omitted ⇒ unbounded. */
-    readonly concurrency?: number;
-    /** The per-phase failure-policy OVERRIDE; omitted ⇒ inherits the workflow `bail` (`effectiveBail = phase.bail ?? workflow.bail`). */
-    readonly bail?: boolean;
-}
-
-/**
- * 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.
- */
-export declare const phaseDraftShape: ObjectShape<{
-    id: OptionalShape<StringShape>;
-    name: OptionalShape<StringShape>;
-    description: OptionalShape<StringShape>;
-    tasks: ArrayShape<ObjectShape<{
-        id: OptionalShape<StringShape>;
-        name: OptionalShape<StringShape>;
-        description: OptionalShape<StringShape>;
-        run: UnionShape<[ ObjectShape<{
-            via: LiteralShape<readonly ["function"]>;
-            name: StringShape;
-        }>, ObjectShape<{
-            via: LiteralShape<readonly ["tool"]>;
-            name: StringShape;
-        }>, ObjectShape<{
-            via: LiteralShape<readonly ["agent"]>;
-            name: StringShape;
-        }>]>;
-        retries: OptionalShape<NumberShape>;
-        timeout: OptionalShape<NumberShape>;
-    }>>;
-    concurrency: OptionalShape<NumberShape>;
-    bail: OptionalShape<LiteralShape<readonly [true, false]>>;
-}>;
-
 /**
  * The push observation surface (AGENTS §13) of the phase entity (W-b) — analogous
  * to {@link WorkflowEventMap}, scoped to one phase.
@@ -1154,9 +1083,12 @@ export declare const phaseDraftShape: ObjectShape<{
  * @remarks
  * `start` fires when the phase begins; `complete` when all its tasks settled
  * successfully; `fail` when a task failed under `bail` (carrying the
- * {@link TaskResult}); `stop` when the phase was ended. A throwing listener is
- * isolated by the emitter and routed to its `error` handler, not the domain surface
- * (AGENTS §13). A `type` alias (AGENTS §4.5) so it satisfies `EventMap`.
+ * {@link TaskResult}); `stop` when the phase was ended. `add` / `remove` / `move` /
+ * `update` fire on a successful structural or patch edit through
+ * {@link PhaseInterface.add} / `remove` / `move` / `update` (AGENTS §7) — never on a
+ * refused/gated one. A throwing listener is isolated by the emitter and routed to its
+ * `error` handler, not the domain surface (AGENTS §13). A `type` alias (AGENTS §4.5)
+ * so it satisfies `EventMap`.
  */
 export declare type PhaseEventMap = {
     /** The phase began — its `id`. */
@@ -1167,6 +1099,14 @@ export declare type PhaseEventMap = {
     readonly fail: readonly [result: TaskResult];
     /** The phase was permanently stopped. */
     readonly stop: readonly [];
+    /** A task was inserted — the inserted task + its final index. */
+    readonly add: readonly [task: TaskInterface, index: number];
+    /** A task was removed — the removed task. */
+    readonly remove: readonly [task: TaskInterface];
+    /** A task was repositioned — the moved task + its new index. */
+    readonly move: readonly [task: TaskInterface, index: number];
+    /** A task was patched — the patched task. */
+    readonly update: readonly [task: TaskInterface];
 };
 
 /** Initial {@link PhaseEventMap} listeners — the reserved `on` option (AGENTS §8). */
@@ -1194,6 +1134,12 @@ export declare type PhaseInput = Partial<PhaseContext>;
  * - **Observable (AGENTS §13).** The owned {@link emitter} ({@link PhaseEventMap}) fires
  *   `start` / `complete` / `fail` / `stop` on a derived-status change; the emitter isolates a
  *   listener throw and routes it to its `error` handler (the `error` option).
+ * - **Runtime lifecycle (AGENTS §10).** `pause` / `resume` / `wait` mirror
+ *   {@link WorkflowInterface.pause} / `resume` / `wait`, scoped to this phase — a driving
+ *   {@link WorkflowRunnerInterface.execute} gates a task's own pre-dispatch on BOTH the
+ *   workflow's and its phase's gate. `paused` is RUNTIME-ONLY, never persisted; idempotent;
+ *   released by `resume` and by this phase's own `stop` / `skip` forcing a terminal status
+ *   (a permanently-ended phase has nothing left to pause for).
  */
 export declare interface PhaseInterface {
     readonly emitter: EmitterInterface<PhaseEventMap>;
@@ -1205,13 +1151,167 @@ export declare interface PhaseInterface {
     readonly status: PhaseStatus;
     /** The RESOLVED effective failure policy this phase runs under (`phase.bail ?? workflow.bail`); mirrors {@link WorkflowInterface.bail}. */
     readonly bail: boolean;
+    /** Max tasks in flight at once (a resource throttle); mirrors {@link PhaseSnapshot.concurrency}. `undefined` ⇒ unbounded. */
+    readonly concurrency: number | undefined;
+    /**
+     * Whether the phase is currently paused (AGENTS §10 — resumable); RUNTIME-ONLY — never a
+     * {@link PhaseStatus}, never persisted in a {@link PhaseSnapshot} (a paused phase's
+     * `status` still reports its ordinary derived value).
+     */
+    readonly paused: boolean;
     readonly tasks: TaskManagerInterface;
     /** Look up one live task by its `id`. */
     task(id: string): TaskInterface | undefined;
     /** The settled tasks' results, in positional order — the phase tier of the result tree. */
     results(): readonly TaskResult[];
+    /**
+     * FORCE this phase to `skipped` (AGENTS §10), overriding the derived value; idempotent.
+     *
+     * @remarks
+     * A NO-OP once `status` is already terminal — a settled phase cannot be re-forced. Always
+     * releases a parked {@link wait} waiter regardless (a terminal phase has nothing left to
+     * pause for).
+     */
     skip(): void;
+    /**
+     * FORCE this phase to `stopped` (AGENTS §10), overriding the derived value; idempotent.
+     *
+     * @remarks
+     * A NO-OP once `status` is already terminal (a settled phase cannot be re-forced). Always
+     * releases a parked {@link wait} waiter regardless (a terminal phase has nothing left to
+     * pause for).
+     */
     stop(): void;
+    /**
+     * Suspend the phase (AGENTS §10 — resumable); idempotent.
+     *
+     * @remarks
+     * A no-op when already `paused` or when `status` is terminal. RUNTIME-ONLY (AGENTS §10) —
+     * never a {@link PhaseStatus}, never persisted in a {@link PhaseSnapshot}. A driving
+     * {@link WorkflowRunnerInterface.execute} gates a task's own pre-dispatch on this phase's
+     * gate (after the workflow's own gate). **Pausing does NOT suspend a driving run's
+     * timeout / budget / abort clocks** — those bounds keep ticking while paused, so a long
+     * pause can still fire a run-level cancel and stop the workflow while parked.
+     *
+     * @example
+     * ```ts
+     * phase.pause()
+     * phase.paused // true
+     * ```
+     */
+    pause(): void;
+    /**
+     * Continue a paused phase (AGENTS §10); idempotent — a no-op unless {@link paused}.
+     *
+     * @example
+     * ```ts
+     * phase.resume()
+     * phase.paused // false
+     * ```
+     */
+    resume(): void;
+    /**
+     * Park until this phase is not paused — **promise-parked**, never a timer or busy-loop
+     * (AGENTS §21; mirrors {@link WorkflowInterface.wait}).
+     *
+     * @remarks
+     * Resolves IMMEDIATELY when not {@link paused}. While paused, parks until `resume` or
+     * this phase's own `stop` / `skip` forcing a terminal status — all release a parked
+     * waiter. NEVER rejects.
+     *
+     * @returns A promise that resolves once the phase is no longer paused
+     */
+    wait(): Promise<void>;
+    /**
+     * MINT a live {@link TaskInterface} from `definition` and insert it into this phase
+     * (AGENTS §7 the entity structural API) — gated BEFORE delegating to {@link tasks}'
+     * manager.
+     *
+     * @remarks
+     * Converts `definition` → {@link TaskSnapshot} and constructs the live task (wired to
+     * THIS phase, its recompute cascade, and its emitter hooks), carrying its `run` /
+     * `retries` / `timeout` from `definition` and resolving its {@link TaskInterface.handler}
+     * against the workflow-level {@link WorkflowOptions.functions} registry — the SAME
+     * resolution {@link import('./factories.js').createWorkflow} performs at build time.
+     * Requires `definition.id` to be UNIQUE among this phase's existing
+     * task ids — a duplicate is a `MUTATION` failure (mirrors
+     * {@link TaskManagerInterface.add}'s own duplicate-id gate).
+     *
+     * NATIVE gating, purely from this phase's own derived `status` (AGENTS §12 — no
+     * runner-installed hook), UNCHANGED from the entity-taking predecessor. While
+     * `pending`: any valid `index` is accepted (delegates the minted task to
+     * {@link TaskManagerInterface.add} then emits `add`). While `running`: accepted ONLY as
+     * a pure append (`index` omitted or `=== tasks.count`) — a live runner subscribed to
+     * the `add` event picks the new task up for same-run execution; the derived-status
+     * model guarantees this phase cannot reach a terminal status while the accepted task is
+     * still `pending` (its status feeds `status` via {@link import('./helpers.js').derivePhaseStatus}).
+     * While terminal: always refused.
+     *
+     * **Abort edge.** An append ACCEPTED while `running` can still settle `skipped` rather
+     * than run — if the driving run is cancelled (abort / timeout / budget / `workflow.destroy()`)
+     * before the substrate actually dispatches the newly-minted task, the runner's halt sweep
+     * `skip`s it like any other not-yet-started task. Acceptance here only guarantees the task
+     * is WIRED into the live tree, not that it will execute.
+     *
+     * @param definition - The {@link TaskDefinition} to mint a live task from
+     * @param index - The insertion position; omitted inserts at the end
+     * @returns A {@link Result} boxing the minted, inserted task, or a `MUTATION` failure
+     */
+    add(definition: TaskDefinition, index?: number): Result<TaskInterface, WorkflowError>;
+    /**
+     * Remove the `pending` task `id` from this phase.
+     *
+     * @remarks
+     * NATIVE gating: allowed only while this phase's own `status` is `pending`. While
+     * `running` or terminal, always a `MUTATION` failure — a running phase's tasks are
+     * already handed to the execution substrate and only a pure {@link add} append remains
+     * possible.
+     *
+     * @param id - The task id to remove
+     * @returns A {@link Result} boxing the removed task, or a `MUTATION` failure
+     */
+    remove(id: string): Result<TaskInterface, WorkflowError>;
+    /**
+     * Reposition the `pending` task `id` to `index` within this phase.
+     *
+     * @remarks
+     * NATIVE gating: allowed only while this phase's own `status` is `pending`; `running` /
+     * terminal always fail (see {@link remove}).
+     *
+     * @param id - The task id to move
+     * @param index - The destination position
+     * @returns A {@link Result} boxing the moved task, or a `MUTATION` failure
+     */
+    move(id: string, index: number): Result<TaskInterface, WorkflowError>;
+    /**
+     * Apply a validated {@link TaskUpdate} patch to the `pending` task `id` in this phase.
+     *
+     * @remarks
+     * NATIVE gating: allowed only while this phase's own `status` is `pending`; `running` /
+     * terminal always fail (see {@link remove}).
+     *
+     * @param id - The task id to patch
+     * @param patch - The fields to update
+     * @returns A {@link Result} boxing the patched task, or a `MUTATION` failure
+     */
+    update(id: string, patch: TaskUpdate): Result<TaskInterface, WorkflowError>;
+    /**
+     * Apply a validated declarative patch to SELF (`name` / `description` /
+     * `concurrency` / `bail`).
+     *
+     * @remarks
+     * Defense-in-depth (AGENTS §12): the owning {@link WorkflowInterface.update} gates
+     * FIRST, so a direct call here THROWS a `MUTATION`
+     * {@link import('./errors.js').WorkflowError} unless this phase's own `status` is
+     * `pending`.
+     *
+     * @param value - The {@link PhaseUpdate} fields to apply
+     * @example
+     * ```ts
+     * phase.patch({ concurrency: 4 })
+     * ```
+     */
+    patch(value: PhaseUpdate): void;
     snapshot(): PhaseSnapshot;
 }
 
@@ -1225,6 +1325,11 @@ export declare interface PhaseInterface {
  *   `append` adds one at the end, `phase(id)` looks one up, `phases()` lists them in
  *   positional order, `count` is the size. A snapshot RESTORE re-`append`s in the
  *   snapshot's order, reproducing it exactly.
+ * - **Gated mutation API (AGENTS §12).** `add` / `remove` / `move` / `update` are the
+ *   graceful `Result` counterparts to `append`, gating ONLY on the target's OWN
+ *   existence/status/id/bounds — a duplicate id, an absent/non-`pending` target, an
+ *   out-of-bounds `index`, or a patch that fails {@link phaseUpdateShape} validation
+ *   all fail gracefully with a `MUTATION` {@link WorkflowError} instead of throwing.
  * - **No batch matrix.** A workflow's phases are a fixed positional set, so AGENTS §9.2
  *   is deliberately omitted.
  * - **Event-free.** A purely structural container — the live {@link PhaseInterface}s own
@@ -1242,6 +1347,10 @@ export declare class PhaseManager implements PhaseManagerInterface {
     #private;
     get count(): number;
     append(phase: PhaseInterface): void;
+    add(phase: PhaseInterface, index?: number): Result<PhaseInterface, WorkflowError>;
+    remove(id: string): Result<PhaseInterface, WorkflowError>;
+    move(id: string, index: number): Result<PhaseInterface, WorkflowError>;
+    update(id: string, patch: PhaseUpdate): Result<PhaseInterface, WorkflowError>;
     phase(id: string): PhaseInterface | undefined;
     phases(): readonly PhaseInterface[];
 }
@@ -1253,10 +1362,61 @@ export declare class PhaseManager implements PhaseManagerInterface {
  * @remarks
  * `append` adds one live {@link PhaseInterface} at the end; `phase(id)` looks one up;
  * `phases()` lists them in positional order; `count` is the tally. No batch matrix.
+ * `add` / `remove` / `move` / `update` (AGENTS §12) are the GATED mutation
+ * counterparts a {@link WorkflowInterface.add} / `remove` / `move` / `update`
+ * delegates to AFTER its own container-status/hook gating — the manager gates ONLY
+ * on the target's OWN existence/status/id/bounds and stays event-free (the entity
+ * emits on success).
  */
 export declare interface PhaseManagerInterface {
     readonly count: number;
+    /**
+     * Add `phase` at the end (the build-time wiring path).
+     *
+     * @remarks
+     * THROWS a `MUTATION` {@link import('./errors.js').WorkflowError} on a duplicate
+     * `id` (a genuine programmer error — a build-time wiring bug, AGENTS §12) instead of
+     * silently overwriting the existing entry.
+     *
+     * @param phase - The live phase to append
+     */
     append(phase: PhaseInterface): void;
+    /**
+     * Insert `phase` at `index` (default the end) — the GATED mutation counterpart to
+     * {@link append}: a duplicate `id` or an out-of-bounds `index` fails gracefully
+     * instead of throwing.
+     *
+     * @param phase - The live phase to insert
+     * @param index - The insertion position (`[0, count]`); omitted inserts at the end
+     * @returns A {@link Result} boxing the inserted phase, or a `MUTATION` failure
+     */
+    add(phase: PhaseInterface, index?: number): Result<PhaseInterface, WorkflowError>;
+    /**
+     * Remove the `pending` phase `id`.
+     *
+     * @param id - The phase id to remove
+     * @returns A {@link Result} boxing the removed phase, or a `MUTATION` failure when
+     *   `id` is absent or not `pending`
+     */
+    remove(id: string): Result<PhaseInterface, WorkflowError>;
+    /**
+     * Reposition the `pending` phase `id` to `index`.
+     *
+     * @param id - The phase id to move
+     * @param index - The destination position (`[0, count)`)
+     * @returns A {@link Result} boxing the moved phase, or a `MUTATION` failure when
+     *   `id` is absent, not `pending`, or `index` is out of bounds
+     */
+    move(id: string, index: number): Result<PhaseInterface, WorkflowError>;
+    /**
+     * Apply a validated {@link PhaseUpdate} patch to the `pending` phase `id`.
+     *
+     * @param id - The phase id to patch
+     * @param patch - The fields to update
+     * @returns A {@link Result} boxing the patched phase, or a `MUTATION` failure when
+     *   `id` is absent, not `pending`, or `patch` fails validation
+     */
+    update(id: string, patch: PhaseUpdate): Result<PhaseInterface, WorkflowError>;
     phase(id: string): PhaseInterface | undefined;
     phases(): readonly PhaseInterface[];
 }
@@ -1292,16 +1452,7 @@ export declare const phaseShape: ObjectShape<{
         id: StringShape;
         name: StringShape;
         description: OptionalShape<StringShape>;
-        run: UnionShape<[ ObjectShape<{
-            via: LiteralShape<readonly ["function"]>;
-            name: StringShape;
-        }>, ObjectShape<{
-            via: LiteralShape<readonly ["tool"]>;
-            name: StringShape;
-        }>, ObjectShape<{
-            via: LiteralShape<readonly ["agent"]>;
-            name: StringShape;
-        }>]>;
+        run: OptionalShape<StringShape>;
         retries: OptionalShape<NumberShape>;
         timeout: OptionalShape<NumberShape>;
     }>>;
@@ -1334,6 +1485,12 @@ export declare interface PhaseSnapshot {
      * per-phase policy identically without a silent default.
      */
     readonly bail: boolean;
+    /**
+     * Max tasks in flight at once (a resource throttle), persisted so a restore reinstates the
+     * same per-phase throttle — mirrors {@link import('./types.js').PhaseDefinition.concurrency}.
+     * Omitted ⇒ unbounded.
+     */
+    readonly concurrency?: number;
     readonly tasks: readonly TaskSnapshot[];
 }
 
@@ -1349,6 +1506,45 @@ export declare interface PhaseSnapshot {
  */
 export declare type PhaseStatus = LifecycleStatus;
 
+/**
+ * A declarative partial update to a {@link PhaseInterface} — the fields a `pending`
+ * phase's {@link PhaseInterface.patch} (and the owning {@link PhaseManagerInterface.update})
+ * accept, runtime-validated via {@link import('./shapers.js').phaseUpdateShape}.
+ *
+ * @remarks
+ * Mirrors the identity + throttle/policy fields of {@link PhaseDefinition} (`name` /
+ * `description` / `concurrency` / `bail`) — never `id` / `tasks` (structural children
+ * change through {@link PhaseInterface.add} / `remove` / `move`, not a patch). Every
+ * field is optional; an omitted field is left unchanged.
+ *
+ * @example
+ * ```ts
+ * const result = workflow.phases.update(phase.id, { concurrency: 4, bail: true })
+ * ```
+ */
+export declare interface PhaseUpdate {
+    readonly name?: string;
+    readonly description?: string;
+    readonly concurrency?: number;
+    readonly bail?: boolean;
+}
+
+/**
+ * The shape of a {@link import('./types.js').PhaseUpdate} — a partial edit to a
+ * `pending` phase's `name` / `description` / `concurrency` / `bail`, all optional.
+ *
+ * @remarks
+ * Mirrors {@link phaseShape}'s corresponding field constraints exactly; never `id` /
+ * `tasks` (structural children change through the phase's own `add` / `remove` /
+ * `move`, not a patch, AGENTS §12).
+ */
+export declare const phaseUpdateShape: ObjectShape<{
+    name: OptionalShape<StringShape>;
+    description: OptionalShape<StringShape>;
+    concurrency: OptionalShape<NumberShape>;
+    bail: OptionalShape<LiteralShape<readonly [true, false]>>;
+}>;
+
 /**
  * Rebuild an equivalent live W-b entity tree from a {@link WorkflowSnapshot} — the
  * inverse of {@link WorkflowInterface.snapshot}, restoring structure + each node's status
@@ -1414,6 +1610,15 @@ export declare function restoreWorkflow(snapshot: WorkflowSnapshot, options?: Wo
  *   unit failure (after its retries) records the error and `abort()`s the run, so every
  *   sibling's signal fires; later failures are ignored and `execute` rejects with the
  *   first error. A user `abort(reason)` likewise rejects a running `execute`.
+ * - **`pause` / `resume` / `stop` (§10) ride the backing Queue.** `pause` / `resume`
+ *   delegate straight to the Queue's own pause/resume (holding/releasing the NEXT
+ *   dispatch while an in-flight unit finishes); `paused` mirrors the Queue's. `stop` is a
+ *   GRACEFUL permanent end, distinct from `abort`: still-pending (never-dispatched)
+ *   units are rejected by the Queue's own stop WITHOUT their handler ever running, and
+ *   `#settle` reads that fact (`#dispatched`) to treat the rejection as a stop artifact —
+ *   not a failure, never tripping fail-fast — while an in-flight unit still runs to
+ *   completion and settles normally. `execute` RESOLVES (never rejects) once every unit
+ *   has settled, with whatever results actually completed.
  * - **Observable (§13).** The owned {@link emitter} ({@link RunnerEventMap}) carries the run
  *   lifecycle — `start` / `unit` / `spawn` / `settle` / `fail` / `finish` / `abort` — for
  *   fire-and-forget observers. Every event is emitted directly, strictly AFTER the relevant
@@ -1429,8 +1634,66 @@ export declare class Runner<TInput, TResult> implements RunnerInterface<TInput,
     get emitter(): EmitterInterface<RunnerEventMap<TResult>>;
     get active(): number;
     get stopped(): boolean;
+    get paused(): boolean;
+    /**
+     * Inject one more unit into an IN-FLIGHT `execute` run — a LIVE counterpart to a
+     * `Controller.spawn`, called from OUTSIDE any unit's handler.
+     *
+     * @remarks
+     * Returns `undefined` synchronously (graceful, non-throwing — AGENTS §12) unless the
+     * runner is currently mid-`execute` and not yet stopped — covering "never started",
+     * "already drained", "aborted", and "destroyed". Otherwise the unit is routed through
+     * the SAME backing queue as a declared/`spawn`ed unit via `#launch` — the outstanding-
+     * unit count gate increments BEFORE this call returns, so an in-flight `execute`
+     * keeps awaiting it (the drain race: `#running` flips to `false` as the very first
+     * step after `execute`'s `await drained.promise` settles, so a `spawn` reaching this
+     * method after the run has fully drained is cleanly rejected with `undefined` —
+     * never silently dropped, never hangs `execute`). Emits {@link RunnerEventMap.spawn}
+     * with a `parent` of `undefined` (this call has no spawning unit) once accepted.
+     *
+     * @param input - The unit's work payload
+     * @returns The unit's result promise, or `undefined` when no in-flight run can accept it
+     * @example
+     * ```ts
+     * const runner = createRunner({ handler: (c) => c.input })
+     * const result = runner.execute([1, 2])
+     * const extra = runner.spawn(3) // Promise<number> | undefined
+     * await result
+     * ```
+     */
+    spawn(input: TInput): Promise<TResult> | undefined;
     execute(inputs: readonly TInput[]): Promise<readonly TResult[]>;
     abort(reason?: unknown): void;
+    /**
+     * Suspend dispatch (AGENTS §10 — resumable): delegates to the backing queue's own
+     * `pause`, which holds the NEXT dispatch while any in-flight unit finishes.
+     *
+     * @remarks
+     * A no-op once the runner is `stopped` — a stopped runner has no dispatch left to
+     * suspend, mirroring the guard `stop()` itself applies. Also a no-op when already
+     * `paused` (the queue's own `pause` is idempotent), so calling it repeatedly is safe.
+     */
+    pause(): void;
+    /**
+     * Continue a paused runner (AGENTS §10); delegates to the backing queue's `resume`.
+     *
+     * @remarks
+     * A no-op once the runner is `stopped` (nothing left to resume) and a no-op when the
+     * runner is not currently `paused`, so calling it repeatedly or on a never-paused
+     * runner is safe.
+     */
+    resume(): void;
+    /**
+     * Permanently end the runner (AGENTS §10) — a GRACEFUL stop, distinct from `abort`.
+     * Marks the runner `stopping` + `stopped`, then stops the backing queue: every
+     * still-PENDING (never-dispatched) unit is rejected by the queue with its own
+     * "queue is stopped" error, WITHOUT running its handler; every already-in-flight unit
+     * keeps running to completion and settles normally. `#settle` reads `#stopping` to
+     * classify a never-dispatched unit's rejection as a stop artifact (decrement the count
+     * gate, no recorded failure, no fail-fast trip) rather than a genuine failure — a
+     * dispatched unit's rejection while stopping is still a real failure. Idempotent.
+     */
+    stop(): void;
     destroy(): void;
 }
 
@@ -1523,6 +1786,8 @@ export declare interface RunnerInterface<TInput, TResult> {
     readonly emitter: EmitterInterface<RunnerEventMap<TResult>>;
     readonly active: number;
     readonly stopped: boolean;
+    /** Whether the runner is currently paused (AGENTS §10 — resumable, no new dispatch); rides the backing queue's own `paused`. */
+    readonly paused: boolean;
     /**
      * Run all `inputs` — and anything they `spawn` — to completion; resolve their
      * results in order: the declared inputs first (in input order), then the spawned
@@ -1537,6 +1802,25 @@ export declare interface RunnerInterface<TInput, TResult> {
      * @returns The units' results, in order (declared first, then spawns)
      */
     execute(inputs: readonly TInput[]): Promise<readonly TResult[]>;
+    /**
+     * Inject one more unit into an IN-FLIGHT `execute` run — a LIVE counterpart to a
+     * `Controller.spawn`, called from OUTSIDE any unit's handler (the seam a live
+     * `running` {@link PhaseInterface}'s `add` event lets a subscribed run offer a newly
+     * added task to the SAME execution substrate).
+     *
+     * @remarks
+     * Returns `undefined` synchronously (graceful, non-throwing — AGENTS §12) when the
+     * runner is not currently mid-`execute`, or the run has already fully drained — the
+     * caller reads `undefined` as "not accepted". Otherwise the unit is routed through
+     * the SAME backing queue as a declared/`spawn`ed unit (the runner's
+     * outstanding-unit count gate keeps the in-flight `execute` awaiting it) and emits
+     * the {@link RunnerEventMap.spawn} event; its result promise resolves once the unit
+     * settles.
+     *
+     * @param input - The unit's work payload
+     * @returns The unit's result promise, or `undefined` when no in-flight run can accept it
+     */
+    spawn(input: TInput): Promise<TResult> | undefined;
     /**
      * Cancel every in-flight + pending unit (and the backing queue), making a running
      * `execute` reject.
@@ -1544,10 +1828,48 @@ export declare interface RunnerInterface<TInput, TResult> {
      * @param reason - An optional cancellation reason propagated to every unit's signal
      */
     abort(reason?: unknown): void;
-    /** Tear the runner down — `abort` plus stop the backing queue; idempotent. */
-    destroy(): void;
-}
-
+    /**
+     * Suspend dispatch (AGENTS §10 — resumable): the backing queue holds the NEXT dispatch
+     * while any in-flight unit finishes; idempotent.
+     *
+     * @example
+     * ```ts
+     * runner.pause()
+     * runner.paused // true
+     * ```
+     */
+    pause(): void;
+    /**
+     * Continue a paused runner (AGENTS §10); idempotent.
+     *
+     * @example
+     * ```ts
+     * runner.resume()
+     * runner.paused // false
+     * ```
+     */
+    resume(): void;
+    /**
+     * Permanently end the runner (AGENTS §10) — a GRACEFUL stop: no further unit is
+     * dispatched, but every already-in-flight unit runs to completion and settles
+     * normally. A never-dispatched (still-pending) unit is rejected by the backing queue
+     * and is NOT recorded as a failure (it never trips fail-fast); a genuine in-flight
+     * failure still is. `execute`'s promise RESOLVES (never rejects) once every unit has
+     * settled, with whatever results actually completed. Idempotent.
+     *
+     * @example
+     * ```ts
+     * const runner = createRunner({ handler: (c) => c.input, concurrency: 1 })
+     * const results = runner.execute([1, 2, 3])
+     * runner.stop() // the in-flight unit finishes; the rest are gracefully dropped
+     * await results // resolves with whatever settled — never rejects
+     * ```
+     */
+    stop(): void;
+    /** Tear the runner down — `abort` plus stop the backing queue; idempotent. */
+    destroy(): void;
+}
+
 /**
  * Options for `createRunner`.
  *
@@ -1683,28 +2005,18 @@ export declare interface SchedulerOptions {
 export declare type SchedulerPriority = 'user' | 'normal' | 'background';
 
 /**
- * The shape of ONE flat step — `{ name, via? }` — the building block of
- * {@link workflowStepsShape}.
+ * Box a value as a {@link Success} — the graceful outcome half of a {@link Result}.
  *
- * @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}).
- */
-export declare const stepShape: ObjectShape<{
-    name: StringShape;
-    via: OptionalShape<LiteralShape<readonly ["function", "tool", "agent"]>>;
-}>;
-
-/**
- * Convert one flat {@link WorkflowStep} into a {@link TaskForm} — `name` → the form's `name`,
- * `via` → the form's discriminant (defaulting to `'function'`).
+ * @typeParam T - The boxed value's type
+ * @param value - The value to box
+ * @returns A {@link Success} wrapping `value`
  *
- * @param step - The flat step
- * @returns The {@link TaskForm} the step's task runs
+ * @example
+ * ```ts
+ * const result = success(task) // { success: true, value: task }
+ * ```
  */
-export declare function stepToForm(step: WorkflowStep): TaskForm;
+export declare function success<T>(value: T): Success<T>;
 
 /**
  * The live leaf state machine (W-b) for one task — an observable (AGENTS §13), guarded
@@ -1731,10 +2043,16 @@ export declare function stepToForm(step: WorkflowStep): TaskForm;
  *   matching event strictly AFTER the state change, BEFORE the cascade; the emitter isolates
  *   a listener throw and routes it to its `error` handler (the `error` option), so a buggy
  *   observer can never corrupt a transition.
+ * - **Declarative config (AGENTS §12).** `run` / `retries` / `timeout` PERSIST in a
+ *   {@link TaskSnapshot} (like a phase's `bail` / `concurrency`), carried verbatim from the
+ *   matching {@link import('../types.js').TaskDefinition} / {@link TaskSnapshot} field. `handler`
+ *   is the RUNTIME-ONLY counterpart — `run` resolved ONCE at construction against the
+ *   workflow-level {@link import('../types.js').WorkflowOptions.functions} registry — and is
+ *   NEVER persisted; `undefined` when `run` is omitted or unregistered (the no-handler rule).
  */
 export declare class Task implements TaskInterface {
     #private;
-    constructor(context: TaskContext, phase: PhaseInterface, workflow: WorkflowInterface, recompute: () => void, options?: TaskOptions, status?: TaskStatus, result?: TaskResult);
+    constructor(context: TaskContext, phase: PhaseInterface, workflow: WorkflowInterface, recompute: () => void, options?: TaskOptions, status?: TaskStatus, result?: TaskResult, run?: string, retries?: number, timeout?: number, handler?: WorkflowFunction);
     get emitter(): EmitterInterface<TaskEventMap>;
     get id(): string;
     get name(): string;
@@ -1744,11 +2062,31 @@ export declare class Task implements TaskInterface {
     get workflow(): WorkflowInterface;
     get status(): TaskStatus;
     get result(): TaskResult | undefined;
+    get run(): string | undefined;
+    get handler(): WorkflowFunction | undefined;
+    get retries(): number | undefined;
+    get timeout(): number | undefined;
     start(): void;
     complete(value: unknown): void;
     fail(error: unknown): void;
     skip(): void;
     stop(): void;
+    /**
+     * Apply a validated declarative patch to SELF (`name` / `description`).
+     *
+     * @remarks
+     * Defense-in-depth (AGENTS §12): the owning
+     * {@link import('../types.js').TaskManagerInterface.update} gates FIRST (target
+     * exists + `pending`), so this is the second, redundant check — it THROWS a
+     * `MUTATION` {@link WorkflowError} unless this task's own `status` is `pending`.
+     *
+     * @param value - The {@link TaskUpdate} fields to apply
+     * @example
+     * ```ts
+     * task.patch({ name: 'Renamed task' })
+     * ```
+     */
+    patch(value: TaskUpdate): void;
     snapshot(): TaskSnapshot;
 }
 
@@ -1776,15 +2114,6 @@ export declare const TASK_STATUSES: readonly TaskStatus[];
  */
 export declare const TASK_TRANSITIONS: Readonly<Record<TaskStatus, readonly TaskStatus[]>>;
 
-/**
- * The three task-form mechanisms (the {@link TaskVia} discriminant), frozen.
- *
- * @remarks
- * The runtime source of truth for the `via` axis — drive the contract's literal
- * shape and any guard from this array rather than repeating the literals.
- */
-export declare const TASK_VIAS: readonly TaskVia[];
-
 /**
  * The ambient context of a task — its own identity plus a back-reference to the
  * phase (and, transitively, the workflow) it belongs to.
@@ -1862,32 +2191,39 @@ export declare interface TaskControllerInterface {
 }
 
 /**
- * The serializable definition of one task — its identity plus the behavior it runs
- * (a {@link TaskForm}, referenced by name).
+ * The serializable definition of one task — its identity plus an optional reference to
+ * the behavior it runs.
  *
  * @remarks
  * Pure JSON DATA: a UI or an LLM authors it, it round-trips through the contract
- * (factories.ts), and it carries NO functions. `id` is the positional identity
- * within its phase; `name` is the human label; `description` is optional prose;
- * `run` is the {@link TaskForm} naming the registered behavior.
+ * (factories.ts), and it carries NO functions. `id` is the positional identity within
+ * its phase; `name` is the human label; `description` is optional prose. `run` is a
+ * PLAIN NAME — a key resolved ONCE at construction against a workflow-level
+ * {@link WorkflowFunctions} registry into a runtime {@link TaskInterface.handler}
+ * carried on the live task. A task whose `run` is omitted, or whose name is unregistered,
+ * has no handler and AUTO-COMPLETES (the no-handler rule).
  */
 export declare interface TaskDefinition {
     readonly id: string;
     readonly name: string;
     readonly description?: string;
-    readonly run: TaskForm;
+    readonly run?: string;
     /**
      * @remarks
      * Extra attempts after the first on failure (a non-negative integer); the runner threads it
      * to this task's substrate unit, OVERRIDING the phase Runner's `retries` default. Omitted ⇒
-     * the default (no extra attempts). Execution-only: it is NOT persisted in a snapshot.
+     * the default (no extra attempts). PERSISTED in a {@link TaskSnapshot} (like `bail` and
+     * `concurrency`), so `restoreWorkflow(snapshot, { functions })` resumes with the same
+     * reliability config; only the resolved handler itself is runtime-only.
      */
     readonly retries?: number;
     /**
      * @remarks
      * The per-attempt deadline in milliseconds (a non-negative integer); the runner threads it to
      * this task's substrate unit, OVERRIDING the phase Runner's `timeout` default. Omitted (or a
-     * non-positive value) ⇒ no deadline. Execution-only: it is NOT persisted in a snapshot.
+     * non-positive value) ⇒ no deadline. PERSISTED in a {@link TaskSnapshot} (like `bail` and
+     * `concurrency`), so `restoreWorkflow(snapshot, { functions })` resumes with the same
+     * reliability config; only the resolved handler itself is runtime-only.
      */
     readonly timeout?: number;
 }
@@ -1897,57 +2233,17 @@ export declare interface TaskDefinition {
  * {@link TaskSnapshot} — the per-task leaf step of {@link definitionToSnapshot} (no
  * result yet, empty metadata).
  *
+ * @remarks
+ * `run` / `retries` / `timeout` carry over verbatim (persisted declarative config, like a
+ * phase's `bail` / `concurrency`) — a restore reinstates the same behavior reference and
+ * reliability overrides once paired with a {@link import('./types.js').WorkflowOptions.functions}
+ * registry.
+ *
  * @param task - The task definition to seed from
  * @returns An initial {@link TaskSnapshot}
  */
 export declare function taskDefinitionToSnapshot(task: WorkflowDefinition['phases'][number]['tasks'][number]): TaskSnapshot;
 
-/**
- * A draft task — a {@link TaskDefinition} with OPTIONAL `id` / `name`.
- *
- * @remarks
- * The tool synthesizes a missing `id` positionally and defaults a missing `name` to
- * its `id` ({@link import('./helpers.js').completeDraft}). A PROVIDED `id` / `name` is
- * preserved verbatim (and must be non-empty — the draft contract's `minLength: 1`).
- */
-export declare interface TaskDraft {
-    readonly id?: string;
-    readonly name?: string;
-    readonly description?: string;
-    readonly run: TaskForm;
-    /** Extra attempts after the first on failure (a non-negative integer); overrides the phase Runner default. Execution-only. */
-    readonly retries?: number;
-    /** The per-attempt deadline in milliseconds (a non-negative integer); overrides the phase Runner default. Execution-only. */
-    readonly timeout?: number;
-}
-
-/**
- * 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).
- *
- * @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.
- */
-export declare const taskDraftShape: ObjectShape<{
-    id: OptionalShape<StringShape>;
-    name: OptionalShape<StringShape>;
-    description: OptionalShape<StringShape>;
-    run: UnionShape<[ ObjectShape<{
-        via: LiteralShape<readonly ["function"]>;
-        name: StringShape;
-    }>, ObjectShape<{
-        via: LiteralShape<readonly ["tool"]>;
-        name: StringShape;
-    }>, ObjectShape<{
-        via: LiteralShape<readonly ["agent"]>;
-        name: StringShape;
-    }>]>;
-    retries: OptionalShape<NumberShape>;
-    timeout: OptionalShape<NumberShape>;
-}>;
-
 /**
  * The push observation surface (AGENTS §13) of the task entity (W-b) — the
  * lifecycle moments of one task.
@@ -1973,58 +2269,6 @@ export declare type TaskEventMap = {
     readonly stop: readonly [];
 };
 
-/**
- * A {@link TaskDefinition}'s behavior reference — a descriptive tagged union over
- * the three execution forms a task can take, discriminated by `via` (the axis is
- * the execution MECHANISM, never a bare `kind`; AGENTS §4.4). Each form references
- * its behavior BY NAME through a registry (the runner resolves the name at W-b);
- * a definition NEVER inlines a function, so the whole tree stays JSON-serializable.
- *
- * @remarks
- * - `function` — a registered function the runner invokes directly.
- * - `tool` — a registered {@link ToolInterface} the
- *   runner executes as a tool call.
- * - `agent` — a registered agent (a subagent). It will later carry a depth/cycle
- *   guard (W-c, bounded by {@link import('./constants.js').MAX_WORKFLOW_DEPTH}); in
- *   W-a it is purely the typed reference.
- *
- * `name` is the registry key (it identifies the behavior the form runs). A
- * descriptive `via` literal (not `kind`) names the axis that varies, and the
- * `is*` guards narrow on `run.via` cleanly.
- */
-export declare type TaskForm = {
-    readonly via: 'function';
-    readonly name: string;
-} | {
-    readonly via: 'tool';
-    readonly name: string;
-} | {
-    readonly via: 'agent';
-    readonly name: string;
-};
-
-/**
- * The shape of a {@link import('./types.js').TaskForm} — a descriptive tagged union
- * over the three execution mechanisms, discriminated by the `via` literal (never a
- * bare `kind`; AGENTS §4.4). Each variant pairs the `via` discriminant with a `name`
- * (the registry key for the behavior).
- *
- * @remarks
- * The union and each `via` literal + `name` carry a `description` so the emitted JSON
- * Schema spells out what the discriminant means and that `name` is a REGISTERED key
- * (not a human label) — the field-level guidance a small model needs to fill `run`.
- */
-export declare const taskFormShape: UnionShape<[ ObjectShape<{
-    via: LiteralShape<readonly ["function"]>;
-    name: StringShape;
-}>, ObjectShape<{
-    via: LiteralShape<readonly ["tool"]>;
-    name: StringShape;
-}>, ObjectShape<{
-    via: LiteralShape<readonly ["agent"]>;
-    name: StringShape;
-}>]>;
-
 /** Initial {@link TaskEventMap} listeners — the reserved `on` option (AGENTS §8). */
 export declare type TaskHooks = EmitterHooks<TaskEventMap>;
 
@@ -2077,11 +2321,52 @@ export declare interface TaskInterface {
     readonly status: TaskStatus;
     /** The recorded outcome once the task settled with one (`completed` / `failed`), else `undefined`. */
     readonly result: TaskResult | undefined;
+    /**
+     * The behavior reference — a plain registry key name, PERSISTED (mirrors
+     * {@link TaskDefinition.run} / {@link TaskSnapshot.run}), like {@link PhaseInterface.bail}.
+     * `undefined` when this task has no behavior reference.
+     */
+    readonly run: string | undefined;
+    /**
+     * The RESOLVED runtime handler — RUNTIME-ONLY, NEVER persisted in a {@link TaskSnapshot}.
+     * Resolved ONCE at construction (build, restore, or a live mint) by looking `run` up in the
+     * workflow-level {@link WorkflowOptions.functions} registry: `functions?.[run]` when `run`
+     * is defined, else `undefined`. A task with no `handler` (an omitted `run`, or a `run` name
+     * absent from the registry) AUTO-COMPLETES (the no-handler rule) — its phase/workflow still
+     * reaches a terminal status, just with no dispatched behavior.
+     */
+    readonly handler: WorkflowFunction | undefined;
+    /**
+     * Extra attempts after the first on failure — PERSISTED (mirrors {@link TaskDefinition.retries}
+     * / {@link TaskSnapshot.retries}), like {@link PhaseInterface.concurrency}. `undefined` ⇒ none.
+     */
+    readonly retries: number | undefined;
+    /**
+     * The per-attempt deadline in milliseconds — PERSISTED (mirrors {@link TaskDefinition.timeout}
+     * / {@link TaskSnapshot.timeout}). `undefined` ⇒ no deadline.
+     */
+    readonly timeout: number | undefined;
     start(): void;
     complete(value: unknown): void;
     fail(error: unknown): void;
     skip(): void;
     stop(): void;
+    /**
+     * Apply a validated declarative patch to SELF (`name` / `description`).
+     *
+     * @remarks
+     * Defense-in-depth (AGENTS §12): the owning {@link TaskManagerInterface.update} gates
+     * FIRST (target exists + `pending`), so a direct call here is the second, redundant
+     * check — it THROWS a `MUTATION` {@link import('./errors.js').WorkflowError} unless
+     * this task's own `status` is `pending`.
+     *
+     * @param value - The {@link TaskUpdate} fields to apply
+     * @example
+     * ```ts
+     * task.patch({ name: 'Renamed task' })
+     * ```
+     */
+    patch(value: TaskUpdate): void;
     snapshot(): TaskSnapshot;
 }
 
@@ -2096,6 +2381,11 @@ export declare interface TaskInterface {
  *   `tasks()` lists them in positional order, `count` is the size. A `skip` is a STATUS
  *   change on a stored task (never a removal), so order survives it; a snapshot RESTORE
  *   re-`append`s in the snapshot's order, reproducing it exactly.
+ * - **Gated mutation API (AGENTS §12).** `add` / `remove` / `move` / `update` are the
+ *   graceful `Result` counterparts to `append`, gating ONLY on the target's OWN
+ *   existence/status/id/bounds — a duplicate id, an absent/non-`pending` target, an
+ *   out-of-bounds `index`, or a patch that fails {@link taskUpdateShape} validation all
+ *   fail gracefully with a `MUTATION` {@link WorkflowError} instead of throwing.
  * - **No batch matrix.** A phase's tasks are a fixed positional set, so AGENTS §9.2 (the
  *   bulk verb overloads) is deliberately omitted — there is no `remove` family here.
  * - **Event-free.** A purely structural container — the live {@link TaskInterface}s own
@@ -2113,6 +2403,10 @@ export declare class TaskManager implements TaskManagerInterface {
     #private;
     get count(): number;
     append(task: TaskInterface): void;
+    add(task: TaskInterface, index?: number): Result<TaskInterface, WorkflowError>;
+    remove(id: string): Result<TaskInterface, WorkflowError>;
+    move(id: string, index: number): Result<TaskInterface, WorkflowError>;
+    update(id: string, patch: TaskUpdate): Result<TaskInterface, WorkflowError>;
     task(id: string): TaskInterface | undefined;
     tasks(): readonly TaskInterface[];
 }
@@ -2126,11 +2420,61 @@ export declare class TaskManager implements TaskManagerInterface {
  * `append` adds one live {@link TaskInterface} at the end (the build-time wiring path);
  * `task(id)` looks one up; `tasks()` lists them in positional order; `count` is the
  * tally. No batch matrix (AGENTS §9.2 is deliberately omitted — a phase's tasks are a
- * fixed positional set, not a bulk-mutated collection).
+ * fixed positional set, not a bulk-mutated collection). `add` / `remove` / `move` /
+ * `update` (AGENTS §12) are the GATED mutation counterparts a
+ * {@link PhaseInterface.add} / `remove` / `move` / `update` delegates to AFTER its own
+ * container-status/hook gating — the manager gates ONLY on the target's OWN
+ * existence/status/id/bounds and stays event-free (the entity emits on success).
  */
 export declare interface TaskManagerInterface {
     readonly count: number;
+    /**
+     * Add `task` at the end (the build-time wiring path).
+     *
+     * @remarks
+     * THROWS a `MUTATION` {@link import('./errors.js').WorkflowError} on a duplicate
+     * `id` (a genuine programmer error — a build-time wiring bug, AGENTS §12) instead of
+     * silently overwriting the existing entry.
+     *
+     * @param task - The live task to append
+     */
     append(task: TaskInterface): void;
+    /**
+     * Insert `task` at `index` (default the end) — the GATED mutation counterpart to
+     * {@link append}: a duplicate `id` or an out-of-bounds `index` fails gracefully
+     * instead of throwing.
+     *
+     * @param task - The live task to insert
+     * @param index - The insertion position (`[0, count]`); omitted inserts at the end
+     * @returns A {@link Result} boxing the inserted task, or a `MUTATION` failure
+     */
+    add(task: TaskInterface, index?: number): Result<TaskInterface, WorkflowError>;
+    /**
+     * Remove the `pending` task `id`.
+     *
+     * @param id - The task id to remove
+     * @returns A {@link Result} boxing the removed task, or a `MUTATION` failure when
+     *   `id` is absent or not `pending`
+     */
+    remove(id: string): Result<TaskInterface, WorkflowError>;
+    /**
+     * Reposition the `pending` task `id` to `index`.
+     *
+     * @param id - The task id to move
+     * @param index - The destination position (`[0, count)`)
+     * @returns A {@link Result} boxing the moved task, or a `MUTATION` failure when `id`
+     *   is absent, not `pending`, or `index` is out of bounds
+     */
+    move(id: string, index: number): Result<TaskInterface, WorkflowError>;
+    /**
+     * Apply a validated {@link TaskUpdate} patch to the `pending` task `id`.
+     *
+     * @param id - The task id to patch
+     * @param patch - The fields to update
+     * @returns A {@link Result} boxing the patched task, or a `MUTATION` failure when
+     *   `id` is absent, not `pending`, or `patch` fails validation
+     */
+    update(id: string, patch: TaskUpdate): Result<TaskInterface, WorkflowError>;
     task(id: string): TaskInterface | undefined;
     tasks(): readonly TaskInterface[];
 }
@@ -2141,9 +2485,11 @@ export declare interface TaskManagerInterface {
  *
  * @remarks
  * The reserved `on` (AGENTS §8) wires initial {@link TaskEventMap} listeners; a
- * {@link createTask}-built tree threads each level's `on` from its parent options.
- * `metadata` is the open consumer bag carried verbatim into a {@link TaskSnapshot}
- * (mirrors {@link TaskInput.metadata}), never interpreted by the workflow.
+ * {@link import('./factories.js').createWorkflow}-built tree threads each level's `on`
+ * from its parent options, the same way a {@link WorkflowInterface.add} /
+ * {@link PhaseInterface.add} mint threads a leaf's `on` from ITS options. `metadata` is
+ * the open consumer bag carried verbatim into a {@link TaskSnapshot} (mirrors
+ * {@link TaskInput.metadata}), never interpreted by the workflow.
  */
 export declare interface TaskOptions {
     readonly on?: TaskHooks;
@@ -2180,23 +2526,15 @@ export declare interface TaskResult {
 }
 
 /**
- * The shape of a {@link import('./types.js').TaskDefinition} — identity plus the
- * behavior reference ({@link taskFormShape}). `description` is optional prose.
+ * The shape of a {@link import('./types.js').TaskDefinition} — identity plus an optional
+ * `run` behavior reference (a plain registry-key string, min length 1). `description` is
+ * optional prose.
  */
 export declare const taskShape: ObjectShape<{
     id: StringShape;
     name: StringShape;
     description: OptionalShape<StringShape>;
-    run: UnionShape<[ ObjectShape<{
-        via: LiteralShape<readonly ["function"]>;
-        name: StringShape;
-    }>, ObjectShape<{
-        via: LiteralShape<readonly ["tool"]>;
-        name: StringShape;
-    }>, ObjectShape<{
-        via: LiteralShape<readonly ["agent"]>;
-        name: StringShape;
-    }>]>;
+    run: OptionalShape<StringShape>;
     retries: OptionalShape<NumberShape>;
     timeout: OptionalShape<NumberShape>;
 }>;
@@ -2209,6 +2547,12 @@ export declare const taskShape: ObjectShape<{
  * Pure JSON DATA (no class instances, no functions). `result` is the task's
  * {@link TaskResult} when it has settled with an outcome, else `undefined`.
  * `metadata` is the open consumer bag carried from the task's {@link TaskInput}.
+ * `run` / `retries` / `timeout` are the DECLARATIVE config the task carries — persisted
+ * like a {@link PhaseSnapshot}'s `bail` / `concurrency`, so a restore reinstates the same
+ * behavior reference and reliability overrides (`run` re-resolves against the
+ * {@link WorkflowOptions.functions} registry supplied to
+ * {@link import('./factories.js').restoreWorkflow}); each omitted ⇒ the corresponding
+ * unset default.
  */
 export declare interface TaskSnapshot {
     readonly id: string;
@@ -2217,6 +2561,12 @@ export declare interface TaskSnapshot {
     readonly status: TaskStatus;
     readonly result?: TaskResult;
     readonly metadata: Readonly<Record<string, unknown>>;
+    /** The behavior reference — a registry key resolved against {@link WorkflowFunctions} on restore/build. */
+    readonly run?: string;
+    /** Extra attempts after the first on failure (a non-negative integer); overrides the phase Runner default. */
+    readonly retries?: number;
+    /** The per-attempt deadline in milliseconds (a non-negative integer); overrides the phase Runner default. */
+    readonly timeout?: number;
 }
 
 /**
@@ -2235,8 +2585,40 @@ export declare interface TaskSnapshot {
  */
 export declare type TaskStatus = LifecycleStatus;
 
-/** The discriminant literal of a {@link TaskForm} — the execution mechanism axis. */
-export declare type TaskVia = TaskForm['via'];
+/**
+ * A declarative partial update to a {@link TaskInterface} — the fields a `pending`
+ * task's {@link TaskInterface.patch} (and the owning {@link TaskManagerInterface.update})
+ * accept, runtime-validated via {@link import('./shapers.js').taskUpdateShape}.
+ *
+ * @remarks
+ * Mirrors the identity fields of {@link TaskDefinition} (`name` / `description`) —
+ * never `run` / `retries` / `timeout` (a form/reliability change is a structural
+ * replace, not a patch) and never `id` (identity is immutable once created). Every
+ * field is optional; an omitted field is left unchanged.
+ *
+ * @example
+ * ```ts
+ * const result = task.phase.tasks.update(task.id, { name: 'Renamed task' })
+ * ```
+ */
+export declare interface TaskUpdate {
+    readonly name?: string;
+    readonly description?: string;
+}
+
+/**
+ * The shape of a {@link import('./types.js').TaskUpdate} — a partial edit to a
+ * `pending` task's `name` / `description`, both optional.
+ *
+ * @remarks
+ * Mirrors {@link taskShape}'s `name` / `description` constraints exactly (a provided
+ * `name` still has `minLength: 1`); never `id` / `run` / `retries` / `timeout` (those
+ * are not patchable fields, AGENTS §12).
+ */
+export declare const taskUpdateShape: ObjectShape<{
+    name: OptionalShape<StringShape>;
+    description: OptionalShape<StringShape>;
+}>;
 
 /**
  * The {@link TaskStatus} values that are TERMINAL — a task in one of these will
@@ -2295,6 +2677,21 @@ export declare type UnitOutcome<TResult> = {
  *   `start` / `complete` / `fail` / `stop` on a derived-status CHANGE; the emitter isolates a
  *   listener throw and routes it to its `error` handler (the `error` option); `fail` carries
  *   the failing task's {@link TaskResult}.
+ * - **Structural API (AGENTS §7).** `add` / `remove` / `move` / `update` gate BEFORE
+ *   delegating to {@link phases} (the manager gates the target's own existence/status/id/
+ *   bounds), then emit the matching {@link WorkflowEventMap} event on success only. NATIVE,
+ *   bottom-up gating (no runner-installed hook): refused outright while this workflow's own
+ *   `status` is terminal; otherwise a target position must fall within the PENDING SUFFIX —
+ *   the contiguous trailing run of `pending` phases — whose boundary is
+ *   {@link import('./helpers.js').deriveBoundary} over the live phases' statuses. A `pending`
+ *   workflow's phases are all `pending`, so the boundary is `0` and every position is
+ *   naturally accepted.
+ * - **Runtime lifecycle (AGENTS §10).** `pause` / `resume` / `wait` gate execution at the runner's
+ *   phase/task boundaries WITHOUT touching {@link status} — `paused` is runtime-only, never
+ *   persisted. `destroy` is a terminal teardown: it aborts {@link signal}, `stop`s every
+ *   non-terminal live phase (so an engine parked on a phase's own gate unparks and the tree
+ *   lands coherent), forces the `stop` override on THIS workflow when not already terminal,
+ *   releases any parked {@link wait} waiter, and marks {@link destroyed} — all four idempotent.
  */
 export declare class Workflow implements WorkflowInterface {
     #private;
@@ -2305,6 +2702,9 @@ export declare class Workflow implements WorkflowInterface {
     get description(): string | undefined;
     get context(): WorkflowContext;
     get bail(): boolean;
+    get paused(): boolean;
+    get destroyed(): boolean;
+    get signal(): AbortSignal;
     get status(): WorkflowStatus;
     get phases(): PhaseManagerInterface;
     phase(id: string): PhaseInterface | undefined;
@@ -2312,92 +2712,20 @@ export declare class Workflow implements WorkflowInterface {
     skip(): void;
     stop(): void;
     complete(): void;
+    pause(): void;
+    resume(): void;
+    destroy(): void;
+    wait(): Promise<void>;
+    add(definition: PhaseDefinition, index?: number): Result<PhaseInterface, WorkflowError>;
+    remove(id: string): Result<PhaseInterface, WorkflowError>;
+    move(id: string, index: number): Result<PhaseInterface, WorkflowError>;
+    update(id: string, patch: PhaseUpdate): Result<PhaseInterface, WorkflowError>;
     snapshot(): WorkflowSnapshot;
 }
 
 /** Every {@link WorkflowStatus} value, frozen — the lifecycle vocabulary of a workflow. */
 export declare const WORKFLOW_STATUSES: readonly WorkflowStatus[];
 
-/**
- * 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).
- */
-export declare const WORKFLOW_TOOL_DESCRIPTION: string;
-
-/**
- * A complete FLAT authoring example — the PRIMARY way a small model authors a workflow
- * through {@link import('./factories.js').createWorkflowTool}: `{ name, steps: [{ name, via }] }`.
- *
- * @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.
- */
-export declare const WORKFLOW_TOOL_FLAT_EXAMPLE: WorkflowSteps;
-
-/**
- * The name under which the {@link import('./WorkflowRunner.js').WorkflowRunner} BINDS the
- * depth/cycle-aware workflow tool onto a dispatched `agent` task's
- * `AgentContextInterface` (the future `@orkestrel/agent` package, W-c2).
- *
- * @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.
- */
-export declare const WORKFLOW_TOOL_NAME = "workflow";
-
-/**
- * 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.
- */
-export declare const WORKFLOW_TOOL_NESTED_EXAMPLE: WorkflowDefinition;
-
-/**
- * The `agent`-task behavior resolver (W-c2) — resolves a registered agent BY NAME to a
- * live {@link AgentInterface} the runner runs as a subagent.
- *
- * @remarks
- * The `agent` analogue of the {@link WorkflowFunctions} registry / the
- * {@link ToolManagerInterface} the other two forms dispatch through: the runner resolves
- * an `agent`-form {@link TaskForm}'s `name` here. A name absent from the resolver is the
- * no-handler case — the task AUTO-COMPLETES (the ROADMAP rule), exactly like an
- * unregistered `function` / `tool`.
- *
- * **Resolve a FRESH agent per call.** A phase's tasks run CONCURRENTLY, so two `agent`
- * tasks naming the same agent are resolved concurrently — and the runner BINDS a
- * depth/cycle-aware workflow tool onto each resolved agent's `context.tools` (the
- * propagation seam — see {@link WorkflowToolOptions}). An implementation that returns the
- * SAME instance for both would have them race on that mutation, so it must mint a fresh
- * agent each call (exactly as `AgentRegistry.build` does). A function resolver
- * (`(name) => …`) is the minimal shape; the agents module's `AgentRegistry` is not a
- * direct fit (its `build` rehydrates from a serializable `AgentJobInput`, not a bare
- * name), so a small adapter `(name) => registry.build({ provider, ... })` bridges it.
- *
- * @param name - The agent's registry key (the `agent`-form's `name`)
- * @returns The resolved live agent, or `undefined` when the name is unregistered
- */
-export declare type WorkflowAgents = (name: string) => AgentInterface | undefined;
-
 /**
  * The ambient context of a workflow — the identity every level inherits.
  *
@@ -2433,68 +2761,6 @@ export declare interface WorkflowDefinition {
     readonly bail?: boolean;
 }
 
-/**
- * A draft workflow — a {@link WorkflowDefinition} with OPTIONAL `id` / `name` at all
- * three levels (workflow / phase / task).
- *
- * @remarks
- * The lenient authoring form `createWorkflowDraftContract` validates and
- * {@link import('./helpers.js').completeDraft} completes into a strict
- * {@link WorkflowDefinition}. `run` stays required; the `bail` policy carries over.
- */
-export declare interface WorkflowDraft {
-    readonly id?: string;
-    readonly name?: string;
-    readonly description?: string;
-    readonly phases: readonly PhaseDraft[];
-    /** Failure policy: `false` (default) continues gracefully, `true` halts on the first failure. */
-    readonly bail?: boolean;
-}
-
-/**
- * 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.
- *
- * @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.
- */
-export declare const workflowDraftShape: ObjectShape<{
-    id: OptionalShape<StringShape>;
-    name: OptionalShape<StringShape>;
-    description: OptionalShape<StringShape>;
-    phases: ArrayShape<ObjectShape<{
-        id: OptionalShape<StringShape>;
-        name: OptionalShape<StringShape>;
-        description: OptionalShape<StringShape>;
-        tasks: ArrayShape<ObjectShape<{
-            id: OptionalShape<StringShape>;
-            name: OptionalShape<StringShape>;
-            description: OptionalShape<StringShape>;
-            run: UnionShape<[ ObjectShape<{
-                via: LiteralShape<readonly ["function"]>;
-                name: StringShape;
-            }>, ObjectShape<{
-                via: LiteralShape<readonly ["tool"]>;
-                name: StringShape;
-            }>, ObjectShape<{
-                via: LiteralShape<readonly ["agent"]>;
-                name: StringShape;
-            }>]>;
-            retries: OptionalShape<NumberShape>;
-            timeout: OptionalShape<NumberShape>;
-        }>>;
-        concurrency: OptionalShape<NumberShape>;
-        bail: OptionalShape<LiteralShape<readonly [true, false]>>;
-    }>>;
-    bail: OptionalShape<LiteralShape<readonly [true, false]>>;
-}>;
-
 /**
  * An error thrown by the workflow entity + W-c2 recursion layer.
  *
@@ -2503,11 +2769,11 @@ export declare const workflowDraftShape: ObjectShape<{
  * 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).
  */
 export declare class WorkflowError extends Error {
     readonly code: WorkflowErrorCode;
@@ -2525,23 +2791,35 @@ export declare class WorkflowError extends Error {
  *   the offending current status + requested transition in the error `context`.
  * - `RESTORE` — a {@link import('./factories.js').restoreWorkflow} given a structurally
  *   invalid {@link WorkflowSnapshot} (a status outside the lifecycle vocabulary).
- * - `DEPTH` — a nested-workflow dispatch (W-c2) that the runner's depth / cycle guard
- *   rejected: running it would push the nested-workflow chain past
- *   {@link import('./constants.js').MAX_WORKFLOW_DEPTH}, OR its target agent (or a
- *   workflow it would author) is already an ancestor of the current run (a re-entry
- *   cycle). Raised on BOTH seams of the W-c2 recursion — an `agent`-task dispatch
- *   (`fail`ed with this code; it never runs) AND the
- *   {@link import('./factories.js').createWorkflowTool} handler (thrown, then ISOLATED
- *   by the `@orkestrel/agent` package's `ToolManager` into the tool
- *   result's `error`). The error `context` names the offending agent / workflow id + the depth.
- * - `TOOL` — the {@link import('./factories.js').createWorkflowTool} handler was handed
- *   a MALFORMED / over-constraint authored args blob (e.g. an empty `id`, `concurrency: 0`)
- *   that the contract rejected, so no workflow ran. The handler THROWS it (rather than
- *   returning a failure result), and the `@orkestrel/agent` package's `ToolManager`
- *   ISOLATES the throw into the canonical tool result's top-level `error` (AGENTS §14 — the
- *   universal tool-handler contract); the error `context` names the wrapped workflow id.
- */
-export declare type WorkflowErrorCode = 'TRANSITION' | 'RESTORE' | 'DEPTH' | 'TOOL';
+ * - `DEPTH` — a nested-workflow dispatch (W-c2) that a depth / cycle guard rejected:
+ *   running it would push the nested-workflow chain past a bounded max depth, OR its
+ *   target agent (or a workflow it would author) is already an ancestor of the current
+ *   run (a re-entry cycle). Public type surface consumed by the `@orkestrel/tool`
+ *   package's workflow-tool / agent-function adapters, which construct
+ *   {@link import('./errors.js').WorkflowError}s with this code (thrown, then ISOLATED
+ *   by that package's `ToolManager` into the tool result's `error`). The error `context`
+ *   names the offending agent / workflow id + the depth.
+ * - `TOOL` — a workflow-authoring tool handler (in `@orkestrel/tool`) was handed a
+ *   MALFORMED / over-constraint authored args blob (e.g. an empty `id`, `concurrency: 0`)
+ *   that {@link import('./factories.js').createWorkflowContract} rejected, so no workflow
+ *   ran. Public type surface: `@orkestrel/tool` constructs this code and THROWS it
+ *   (rather than returning a failure result); its `ToolManager` ISOLATES the throw into
+ *   the canonical tool result's top-level `error` (AGENTS §14 — the universal
+ *   tool-handler contract); the error `context` names the wrapped workflow id.
+ * - `MUTATION` — a GATED structural or patch edit was refused: a duplicate id on
+ *   `append`/`add`, a target that does not exist or is not `pending`, an out-of-bounds
+ *   `index`, a patch that failed shaper validation, or a live structural edit refused by
+ *   the NATIVE bottom-up gate — a terminal container, an edit targeting (or destined for)
+ *   a position BEFORE the container's own pending-suffix boundary, or (a running phase)
+ *   anything other than a pure append. The manager /
+ *   entity structural API (AGENTS §12) returns it as a graceful `Result` `failure` —
+ *   it NEVER throws for this code except {@link TaskInterface.patch} /
+ *   {@link PhaseInterface.patch}'s defense-in-depth self-check and the build-time
+ *   {@link TaskManagerInterface.append} / {@link PhaseManagerInterface.append} duplicate-id
+ *   guard (both genuine programmer-error paths, AGENTS §12). The error `context` names
+ *   the offending id / index / status.
+ */
+export declare type WorkflowErrorCode = 'TRANSITION' | 'RESTORE' | 'DEPTH' | 'TOOL' | 'MUTATION';
 
 /**
  * The push observation surface (AGENTS §13) of the workflow entity (W-b) — the
@@ -2552,10 +2830,13 @@ export declare type WorkflowErrorCode = 'TRANSITION' | 'RESTORE' | 'DEPTH' | 'TO
  * Present-tense events with arg tuples. `start` fires when the workflow begins;
  * `complete` when every phase settled successfully; `fail` when a phase failed
  * under `bail` (carrying the failing {@link TaskResult}); `stop` when the workflow
- * was permanently ended. A throwing listener never reaches the domain surface — the
- * emitter isolates it and routes it to its OWN `error` handler (the `error` option,
- * AGENTS §13). Declared as a `type` alias (not `interface extends EventMap`, AGENTS
- * §4.5) so the type-literal satisfies `EventMap` structurally.
+ * was permanently ended. `add` / `remove` / `move` / `update` fire on a successful
+ * structural or patch edit through {@link WorkflowInterface.add} / `remove` / `move` /
+ * `update` (AGENTS §7) — never on a refused/gated one. A throwing listener never
+ * reaches the domain surface — the emitter isolates it and routes it to its OWN
+ * `error` handler (the `error` option, AGENTS §13). Declared as a `type` alias (not
+ * `interface extends EventMap`, AGENTS §4.5) so the type-literal satisfies `EventMap`
+ * structurally.
  */
 export declare type WorkflowEventMap = {
     /** The workflow began — its `id`. */
@@ -2566,6 +2847,14 @@ export declare type WorkflowEventMap = {
     readonly fail: readonly [result: TaskResult];
     /** The workflow was permanently stopped. */
     readonly stop: readonly [];
+    /** A phase was inserted — the inserted phase + its final index. */
+    readonly add: readonly [phase: PhaseInterface, index: number];
+    /** A phase was removed — the removed phase. */
+    readonly remove: readonly [phase: PhaseInterface];
+    /** A phase was repositioned — the moved phase + its new index. */
+    readonly move: readonly [phase: PhaseInterface, index: number];
+    /** A phase was patched — the patched phase. */
+    readonly update: readonly [phase: PhaseInterface];
 };
 
 /**
@@ -2589,10 +2878,10 @@ export declare type WorkflowFunction = (controller: TaskControllerInterface) =>
  * {@link WorkflowFunction} handlers.
  *
  * @remarks
- * The runner resolves a `function`-form {@link TaskForm}'s `name` here. A name absent
- * from the registry is the no-handler case — the task AUTO-COMPLETES (the ROADMAP rule),
- * exactly like an unsupported form. A plain record (not a manager) — the registry is a
- * lookup, with no lifecycle of its own.
+ * A live {@link TaskInterface} resolves its `run` name against this registry ONCE at
+ * construction into its {@link TaskInterface.handler}. A name absent from the registry (or
+ * an omitted `run`) is the no-handler case — the task AUTO-COMPLETES (the ROADMAP rule). A
+ * plain record (not a manager) — the registry is a lookup, with no lifecycle of its own.
  */
 export declare type WorkflowFunctions = Readonly<Record<string, WorkflowFunction>>;
 
@@ -2634,13 +2923,182 @@ export declare interface WorkflowInterface {
     readonly bail: boolean;
     readonly status: WorkflowStatus;
     readonly phases: PhaseManagerInterface;
+    /**
+     * Whether the workflow is currently paused (AGENTS §10 — resumable); RUNTIME-ONLY —
+     * never a {@link WorkflowStatus}, never persisted in a {@link WorkflowSnapshot} (a
+     * paused workflow's `status` still reports its ordinary `pending` / `running` value).
+     */
+    readonly paused: boolean;
+    /** Whether {@link destroy} has torn this workflow down; RUNTIME-ONLY, never persisted. */
+    readonly destroyed: boolean;
+    /**
+     * This workflow's own cancellation signal — fires on {@link destroy}. RUNTIME-ONLY
+     * (implemented over `@orkestrel/abort`, AGENTS core precedent), never persisted.
+     */
+    readonly signal: AbortSignal;
     /** Look up one live phase by its `id`. */
     phase(id: string): PhaseInterface | undefined;
     /** Every settled task's result across all phases, in positional order — the workflow tier of the result tree. */
     results(): readonly TaskResult[];
+    /**
+     * FORCE this workflow to `skipped` (AGENTS §10), overriding the derived value; idempotent.
+     *
+     * @remarks
+     * A NO-OP once `status` is already terminal — a settled workflow cannot be re-forced.
+     * Always releases a parked {@link wait} waiter regardless (a terminal workflow has nothing
+     * left to pause for).
+     */
     skip(): void;
+    /**
+     * FORCE this workflow to `stopped` (AGENTS §10), overriding the derived value; idempotent.
+     *
+     * @remarks
+     * A NO-OP once `status` is already terminal — a settled workflow cannot be re-forced. Always
+     * releases a parked {@link wait} waiter regardless (a terminal workflow has nothing left to
+     * pause for).
+     */
     stop(): void;
+    /**
+     * FORCE this workflow to `completed` (AGENTS §10), overriding the derived value.
+     *
+     * @remarks
+     * A NO-OP unless `status` is `pending` — its ONLY legitimate use is settling a vacuously
+     * DONE tree (no work happened), mirroring the runner's own gate. Never overrides a real
+     * `completed` / a bail-true `failed` / a `stopped` / a derived `skipped`.
+     */
     complete(): void;
+    /**
+     * Suspend the workflow (AGENTS §10 — resumable); idempotent.
+     *
+     * @remarks
+     * A no-op when already `paused`, when `status` is terminal, or once {@link destroyed}.
+     * RUNTIME-ONLY (AGENTS §10) — never a {@link WorkflowStatus}, never persisted in a
+     * {@link WorkflowSnapshot}. A driving {@link WorkflowRunnerInterface.execute} gates at the
+     * next phase boundary and before each task's own dispatch; an in-flight task body is
+     * never suspended mid-flight. **Pausing does NOT suspend the run's timeout / budget /
+     * abort clocks** — those bounds keep ticking while paused, so a run parked on
+     * `pause()` can still be cancelled (and settle `stopped`) by its own deadline / budget /
+     * abort while parked.
+     *
+     * @example
+     * ```ts
+     * workflow.pause()
+     * workflow.paused // true
+     * ```
+     */
+    pause(): void;
+    /**
+     * Continue a paused workflow (AGENTS §10); idempotent — a no-op unless {@link paused}.
+     *
+     * @example
+     * ```ts
+     * workflow.resume()
+     * workflow.paused // false
+     * ```
+     */
+    resume(): void;
+    /**
+     * Tear this workflow down (AGENTS §10) — a TERMINAL teardown: aborts {@link signal},
+     * `stop`s every non-terminal live phase (so any engine parked on a phase's own gate
+     * unparks and the tree lands coherent), forces the `stop` override on THIS workflow if
+     * it is not already terminal, resolves any parked {@link wait} waiter, and marks
+     * {@link destroyed}; idempotent.
+     *
+     * @remarks
+     * After `destroy`, every structural mutator (`add` / `remove` / `move` / `update` /
+     * `patch`) and `pause` / `resume` reject (a `Result` failure) or no-op — never throws
+     * for calling `destroy` itself twice.
+     *
+     * @example
+     * ```ts
+     * workflow.destroy()
+     * workflow.destroyed // true
+     * ```
+     */
+    destroy(): void;
+    /**
+     * Park until this workflow is not paused — **promise-parked**, never a timer or
+     * busy-loop (AGENTS §21; mirrors {@link ControllerInterface.wait}'s doc style).
+     *
+     * @remarks
+     * Resolves IMMEDIATELY when not {@link paused}. While paused, parks until `resume` /
+     * `skip` / `stop` / `destroy` — each always releases a parked waiter (a permanently
+     * ended workflow has nothing left to pause for). NEVER rejects.
+     *
+     * @returns A promise that resolves once the workflow is no longer paused
+     */
+    wait(): Promise<void>;
+    /**
+     * MINT a live {@link PhaseInterface} (and its tasks) from `definition` and insert it
+     * into this workflow (AGENTS §7 the entity structural API) — gated BEFORE delegating
+     * to {@link phases}' manager.
+     *
+     * @remarks
+     * Converts `definition` → {@link PhaseSnapshot} and constructs the live phase (wired to
+     * THIS workflow, its recompute cascade, and its emitter hooks) plus each of its live
+     * tasks — each task's `run` / `retries` / `timeout` carried from its {@link TaskDefinition}
+     * and its {@link TaskInterface.handler} resolved against the workflow-level
+     * {@link WorkflowOptions.functions} registry (mirrors
+     * {@link import('./factories.js').createWorkflow}'s build-time resolution). The
+     * phase's effective `bail` resolves exactly as the build path does
+     * (`definition.bail ?? this.bail`). Requires `definition.id` to be UNIQUE among this
+     * workflow's existing phase ids — a duplicate is a `MUTATION` failure (mirrors
+     * {@link PhaseManagerInterface.add}'s own duplicate-id gate).
+     *
+     * NATIVE gating, purely from this workflow's own derived `status` and the phase list's
+     * positions (AGENTS §12 — no runner-installed hook), UNCHANGED from the entity-taking
+     * predecessor: refused outright while this workflow's own `status` is terminal or once
+     * {@link destroyed}. Otherwise the effective target position (`index ?? phases.count`)
+     * must fall within the PENDING SUFFIX — the contiguous trailing run of `pending` phases
+     * (phases run sequentially, so every already-started phase forms a contiguous leading
+     * prefix); its boundary is {@link import('./helpers.js').deriveBoundary}. A `pending`
+     * workflow's phases are ALL `pending`, so the boundary is `0` and every index is
+     * naturally accepted — no special case needed. Delegates the minted phase to
+     * {@link PhaseManagerInterface.add} then emits `add` on success.
+     *
+     * @param definition - The {@link PhaseDefinition} to mint a live phase (and tasks) from
+     * @param index - The insertion position; omitted inserts at the end
+     * @returns A {@link Result} boxing the minted, inserted phase, or a `MUTATION` failure
+     */
+    add(definition: PhaseDefinition, index?: number): Result<PhaseInterface, WorkflowError>;
+    /**
+     * Remove the `pending` phase `id` from this workflow.
+     *
+     * @remarks
+     * NATIVE gating: refused while this workflow's own `status` is terminal. Otherwise the
+     * target must exist at an index within the pending suffix (at or past
+     * {@link import('./helpers.js').deriveBoundary}) — the manager separately gates the
+     * target's own `pending` status (AGENTS §9).
+     *
+     * @param id - The phase id to remove
+     * @returns A {@link Result} boxing the removed phase, or a `MUTATION` failure
+     */
+    remove(id: string): Result<PhaseInterface, WorkflowError>;
+    /**
+     * Reposition the `pending` phase `id` to `index` within this workflow.
+     *
+     * @remarks
+     * NATIVE gating: refused while this workflow's own `status` is terminal. Otherwise BOTH
+     * the target's current index and the destination `index` must fall within the pending
+     * suffix (see {@link remove}).
+     *
+     * @param id - The phase id to move
+     * @param index - The destination position
+     * @returns A {@link Result} boxing the moved phase, or a `MUTATION` failure
+     */
+    move(id: string, index: number): Result<PhaseInterface, WorkflowError>;
+    /**
+     * Apply a validated {@link PhaseUpdate} patch to the `pending` phase `id` in this workflow.
+     *
+     * @remarks
+     * NATIVE gating: refused while this workflow's own `status` is terminal. Otherwise the
+     * target must exist at an index within the pending suffix (see {@link remove}).
+     *
+     * @param id - The phase id to patch
+     * @param patch - The fields to update
+     * @returns A {@link Result} boxing the patched phase, or a `MUTATION` failure
+     */
+    update(id: string, patch: PhaseUpdate): Result<PhaseInterface, WorkflowError>;
     snapshot(): WorkflowSnapshot;
 }
 
@@ -2670,6 +3128,19 @@ export declare interface WorkflowOptions {
     readonly error?: EmitterErrorHandler;
     /** Per-phase {@link PhaseOptions}, keyed by the phase's `id`. */
     readonly phases?: Readonly<Record<string, PhaseOptions>>;
+    /**
+     * The `function`-task behavior registry ({@link WorkflowFunctions}) each live task's
+     * {@link TaskDefinition.run} / {@link TaskSnapshot.run} name resolves against ONCE at
+     * construction into its runtime {@link TaskInterface.handler} — the SAME registry a
+     * fresh build ({@link import('./factories.js').createWorkflow}) and a restore
+     * ({@link import('./factories.js').restoreWorkflow}) both consume, and the same shape a
+     * live {@link WorkflowInterface.add} / {@link PhaseInterface.add} mint resolves a newly
+     * minted task against. A `run` name absent from `functions` (or omitted entirely)
+     * resolves to no handler — that task AUTO-COMPLETES (the no-handler rule): its
+     * phase/workflow still reaches a terminal status, just with no dispatched behavior.
+     * Omitted ⇒ an empty registry (every task auto-completes).
+     */
+    readonly functions?: WorkflowFunctions;
 }
 
 /**
@@ -2695,35 +3166,51 @@ export declare interface WorkflowResult {
 
 /**
  * The thin orchestrator that EXECUTES a live W-b workflow tree by COMPOSING the shipped
- * substrate — phases sequential, tasks concurrent — dispatching each task BY NAME under the
- * `bail` policy, including the W-c2 `agent` form behind a depth + cycle guard.
+ * substrate — phases sequential, tasks concurrent — dispatching each task through its OWN
+ * resolved handler under the `bail` policy.
  *
  * @remarks
  * - **Composes, never re-implements.** Per-phase bounded concurrency is one
  *   {@link createRunner} per phase (the substrate {@link RunnerInterface} over the workers
  *   `Queue`); `bail` maps onto that Runner's fail-fast vs settle-all; the run-level abort /
- *   timeout / budget fold through {@link createAbort} / {@link createTimeout} +
+ *   timeout / budget / entity `signal` fold through {@link createAbort} / {@link createTimeout} +
  *   `AbortSignal.any` (exactly as the agent runtime folds its bounds); pacing is the shipped
  *   {@link SchedulerInterface}. The runner writes ZERO concurrency / retry / abort logic of
- *   its own — it only sequences phases, dispatches a task, and drives the live entity.
- * - **Phases sequential, tasks concurrent.** `#execute` awaits the phases in order (phase
- *   N+1 starts only once phase N has fully settled). Within a phase, ALL its tasks are the
- *   one Runner's `inputs`, run at `concurrency` = the phase's
- *   {@link PhaseDefinition.concurrency} (default {@link DEFAULT_PHASE_CONCURRENCY}).
- * - **Dispatch by name.** `#dispatch` branches on the task's
- *   {@link import('./types.js').TaskForm} (read from the `definition`, correlated by `id`):
- *   `function` → the {@link WorkflowFunctions} registry, `tool` → the
- *   {@link ToolManagerInterface}, `agent` → the {@link WorkflowAgents} resolver (W-c2). A
- *   handler that is NOT found (an unregistered name for ANY form) AUTO-COMPLETES — the
- *   ROADMAP no-handler rule.
- * - **`agent` form + depth/cycle guard (W-c2).** An `agent` task resolves its subagent via
- *   `agents`, BINDS a depth/cycle-aware workflow tool onto the subagent's `context.tools`
- *   (the propagation seam), folds the task's cancellation into the agent run (a workflow
- *   cancel `abort`s the subagent), and drives it: success → `complete(result)`, throw →
- *   `fail(error)`. Before running, the guard REJECTS the task into a typed `DEPTH`
- *   {@link WorkflowError} (`fail`) when running it would push the nested chain past
- *   {@link MAX_WORKFLOW_DEPTH}, OR when its target agent is already an ancestor (a cycle).
- *   The rejected task never runs the agent.
+ *   its own — it only sequences phases, dispatches a task's own handler, and drives the live
+ *   entity.
+ * - **Pure engine — no registries, no tool/agent knowledge.** The runner carries no
+ *   `functions` / `tools` / `agents` registry: each live {@link TaskInterface} already
+ *   resolved its own {@link import('./types.js').WorkflowFunction} into
+ *   {@link import('./types.js').TaskInterface.handler} ONCE at construction (build, restore,
+ *   or a live mint all resolve it identically, from {@link WorkflowOptions.functions}), so
+ *   dispatch is simply "invoke the task's own handler". Static tool / agent calling is an
+ *   OPT-IN concern of 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;
@@ -2731,7 +3218,20 @@ export declare interface WorkflowResult {
  *   Under `bail: false` (graceful) a failure `fail`s the leaf and RESOLVES (never throws), so
  *   the Runner settles every unit (allSettled) and the run finishes (the workflow derives
  *   `completed`, the failure recorded in the result tree).
- * - **Abort / Timeout / Budget fold.** `#execute` folds the run's external `signal`, a
+ * - **Pause / stop / destroy gates.** `workflow.pause()` is honoured at exactly two points —
+ *   the next phase boundary (workflow-only) and each task's own pre-dispatch (before
+ *   `task.start()`, workflow gate FIRST then this task's own `phase.pause()`) — by parking on
+ *   {@link WorkflowInterface.wait} / {@link PhaseInterface.wait}; an in-flight task body is
+ *   NEVER suspended mid-flight. A GRACEFUL `workflow.stop()` (no signal involved) is caught at
+ *   those same gates: not-yet-started work is `skip`ped, in-flight work finishes naturally. A
+ *   HARD `workflow.destroy()` aborts {@link WorkflowInterface.signal}, which `#fold` has folded
+ *   into the run's composed signal — so it cancels the active phase Runner (and every
+ *   in-flight task) exactly like an external abort / timeout / budget fire. EVERY park on a
+ *   `wait()` gate is RACED against that same run signal (`#raceWait`, S2) — so a cancel firing
+ *   WHILE parked unparks the engine promptly instead of hanging until `resume`; the existing
+ *   halt / abort re-checks after the gate then decide the outcome.
+ * - **Abort / Timeout / Budget / entity-signal fold.** `#execute` folds the live workflow's
+ *   own {@link WorkflowInterface.signal}, the run's external `signal`, a
  *   {@link TimeoutInterface}, and the `@orkestrel/budget` package's `BudgetInterface`'s
  *   `signal` into one `runSignal` (`AbortSignal.any`); a fire aborts the active phase's Runner
  *   (cancelling every in-flight task) and HALTS the run — the remaining tasks / phases `skip`
@@ -2739,19 +3239,77 @@ export declare interface WorkflowResult {
  *   {@link TaskController} signal `AbortSignal.any`-combines the substrate per-unit signal with
  *   `runSignal`, so a handler observes either cause directly.
  * - **Re-entrant-safe.** No shared per-run mutable field: the active-Runner holder is LOCAL to
- *   each `#execute`, so a nested `execute` (the bound workflow tool re-entering this instance
- *   while the outer run is suspended on an `agent` task) cannot clobber the outer run's state.
+ *   each `#execute`, so a nested `execute` (a bound workflow-tool handler re-entering this
+ *   instance while the outer run is suspended awaiting it) cannot clobber the outer run's state.
  */
 export declare class WorkflowRunner implements WorkflowRunnerInterface {
     #private;
-    constructor(functions: WorkflowFunctions, tools: ToolManagerInterface | undefined, agents: WorkflowAgents | undefined, scheduler: SchedulerInterface, workflowTool: WorkflowToolBinder | undefined);
+    constructor(scheduler: SchedulerInterface);
+    /**
+     * Execute a workflow definition to completion — BUILD its live tree, run the phases
+     * sequentially with each phase's tasks concurrent — resolving its terminal
+     * {@link WorkflowResult} (whose `workflow` is the freshly-built live tree).
+     *
+     * @remarks
+     * One-shot. The runner BUILDS the live tree from `definition` internally (one source of
+     * truth — the per-task `run` and per-phase `concurrency` come from the same definition
+     * the tree is constructed from, so the executed tree can never drift from the metadata).
+     * The {@link WorkflowOptions} part of `options` (initial `on` listeners, a `bail` override,
+     * the per-node `phases` bag, the {@link WorkflowOptions.functions} registry each task's
+     * `run` resolves against) is forwarded to the build. Under `bail: false` (graceful) every
+     * task settles (a failure is recorded on its {@link TaskInterface}) and the workflow
+     * reaches `completed`; under `bail: true` (halt) the first failure aborts the in-flight
+     * sibling tasks AND `skip`s the remaining tasks / phases, settling the workflow `failed`. A
+     * {@link WorkflowRunOptions} abort / timeout / budget fires every in-flight task's signal
+     * and `stop`s the run. `execute` resolves (never rejects) on a cancel — the partial outcome
+     * is read from the returned {@link WorkflowResult} (its `workflow` / `status` / `results`).
+     *
+     * @param definition - The {@link WorkflowDefinition} to build the live tree from and drive
+     * @param options - The construction options ({@link WorkflowOptions}: `on` / `bail` /
+     *   `phases` / `functions`) PLUS the per-run bounds (`signal` / `timeout` / `budget`)
+     * @returns The run's terminal {@link WorkflowResult} (its `workflow` is the built tree)
+     * @example
+     * ```ts
+     * const result = await runner.execute(definition, { timeout: 5_000 })
+     * result.status // 'completed' | 'failed' | 'stopped'
+     * ```
+     */
     execute(definition: WorkflowDefinition, options?: WorkflowRunOptions): Promise<WorkflowResult>;
+    /**
+     * Drive an ALREADY-BUILT, CALLER-OWNED live {@link WorkflowInterface} — the entity-native
+     * counterpart to the definition-building {@link execute} overload.
+     *
+     * @remarks
+     * `createWorkflow` mints the live tree, this overload drives it, and the caller controls
+     * the SAME entity mid-run via its own `pause` / `resume` / `add` / `stop` / `destroy`
+     * (AGENTS §10). Requires `workflow.status === 'pending'` and `!workflow.destroyed` —
+     * otherwise this is a programmer-timing error and it THROWS a `TRANSITION`
+     * {@link WorkflowError} (AGENTS §12) rather than silently no-opping or building a second
+     * tree. Once accepted, observable semantics are byte-identical to the `definition` form —
+     * except the phase loop RE-READS the live tree every iteration, so a caller's live `add`
+     * mid-run is picked up and actually dispatched. `options` carries only the per-run bounds
+     * (`signal` / `timeout` / `budget`) — the construction half of {@link WorkflowRunOptions}
+     * does not apply, since the tree already exists.
+     *
+     * @param workflow - The live {@link WorkflowInterface} to drive
+     * @param options - The per-run bounds (`signal` / `timeout` / `budget`)
+     * @returns The run's terminal {@link WorkflowResult} (its `workflow` is the SAME entity passed in)
+     * @example
+     * ```ts
+     * const workflow = createWorkflow(definition)
+     * const run = runner.execute(workflow)
+     * workflow.pause()
+     * workflow.resume()
+     * await run
+     * ```
+     */
+    execute(workflow: WorkflowInterface, options?: Omit<WorkflowRunOptions, keyof WorkflowOptions>): Promise<WorkflowResult>;
 }
 
 /**
  * A thin orchestrator that EXECUTES a live {@link WorkflowInterface} tree by composing the
- * shipped substrate — phases sequential, tasks concurrent, dispatched by name under the
- * `bail` policy.
+ * shipped substrate — phases sequential, tasks concurrent, each task dispatched through its
+ * OWN resolved handler under the `bail` policy.
  *
  * @remarks
  * `execute(definition, options?)` BUILDS the live W-b entity tree from the definition itself
@@ -2760,18 +3318,22 @@ export declare class WorkflowRunner implements WorkflowRunnerInterface {
  * through ONE substrate {@link RunnerInterface} (concurrency =
  * the phase's {@link PhaseDefinition.concurrency}). The definition is the SINGLE source of
  * truth: the runner owns both the declarative state (the live tree it constructs) and the
- * EXECUTION-ONLY fields the snapshot deliberately dropped — each task's {@link TaskForm}
- * (`run`) and each phase's `concurrency` (so there is no separately-supplied workflow to drift
- * from the definition). The freshly-built live tree is returned in {@link WorkflowResult.workflow}.
- * Each task is dispatched by its {@link TaskForm} — a `function` through the
- * {@link WorkflowFunctions} registry, a `tool` through the {@link ToolManagerInterface}; a
- * task whose handler is not found AUTO-COMPLETES. The runner DRIVES the live entity (`start`
- * → `complete` / `fail`), never re-implementing status. The `bail` policy maps onto the
- * substrate's fail-fast (`bail: true` — the first failure aborts in-flight siblings and skips
- * the rest) vs settle-all (`bail: false` — failures are recorded and the run finishes). The
- * {@link WorkflowOptions} half of the options is forwarded to `createWorkflow` (initial
- * listeners, a `bail` override, per-node options); the Abort / Timeout / Budget bounds fold
- * per run via `AbortSignal.any`, halting the run and `stop`ping the workflow.
+ * EXECUTION-ONLY field the snapshot deliberately dropped — each task's `run` (resolved into
+ * its {@link TaskInterface.handler} once at construction, against
+ * {@link WorkflowOptions.functions}) and each phase's `concurrency` (so there is no
+ * separately-supplied workflow to drift from the definition). The freshly-built live tree is
+ * returned in {@link WorkflowResult.workflow}. The runner carries NO registry of its own — it
+ * simply invokes each task's OWN {@link TaskInterface.handler}; a task with no handler
+ * AUTO-COMPLETES. The runner DRIVES the live entity (`start` → `complete` / `fail`), never
+ * re-implementing status. The `bail` policy maps onto the substrate's fail-fast (`bail: true`
+ * — the first failure aborts in-flight siblings and skips the rest) vs settle-all (`bail:
+ * false` — failures are recorded and the run finishes). The {@link WorkflowOptions} half of
+ * the options is forwarded to `createWorkflow` (initial listeners, a `bail` override,
+ * per-node options, the `functions` registry); the Abort / Timeout / Budget bounds fold per
+ * run via `AbortSignal.any`, halting the run and `stop`ping the workflow. A second
+ * `execute(workflow, options?)` overload drives a CALLER-BUILT live tree instead — the
+ * entity-native control surface (AGENTS §10: `pause` / `resume` / `add` / `stop` /
+ * `destroy` live on {@link WorkflowInterface} itself); see its own doc for details.
  */
 export declare interface WorkflowRunnerInterface {
     /**
@@ -2781,10 +3343,11 @@ export declare interface WorkflowRunnerInterface {
      *
      * @remarks
      * One-shot. The runner BUILDS the live tree from `definition` internally (one source of
-     * truth — the per-task {@link TaskForm} (`run`) and per-phase `concurrency` come from the
-     * same definition the tree is constructed from, so the executed tree can never drift from
-     * the form/throttle metadata). The {@link WorkflowOptions} part of `options` (initial `on`
-     * listeners, a `bail` override, the per-node `phases` bag) is forwarded to the build.
+     * truth — the per-task `run` (resolved into its {@link TaskInterface.handler}) and per-phase
+     * `concurrency` come from the same definition the tree is constructed from, so the executed
+     * tree can never drift from the metadata). The {@link WorkflowOptions} part of `options`
+     * (initial `on` listeners, a `bail` override, the per-node `phases` bag, the `functions`
+     * registry) is forwarded to the build.
      * Under `bail: false` (graceful) every task settles (a failure is recorded on its
      * {@link TaskInterface}) and the workflow reaches `completed`; under `bail: true` (halt)
      * the first failure aborts the in-flight sibling tasks AND `skip`s the remaining tasks /
@@ -2796,33 +3359,73 @@ export declare interface WorkflowRunnerInterface {
      * the run as `stopped` — the cancel supersedes the same-tick failure, and that task's error
      * is not recorded.
      *
+     * **Programmer-error exception (AGENTS §12).** A PATHOLOGICAL `definition` (e.g. a
+     * duplicate phase or task `id`) THROWS SYNCHRONOUSLY at construction — before any phase
+     * runs, and before the returned `Promise` is even created — rather than resolving a
+     * failed/partial {@link WorkflowResult}. This is the one exception to the "resolves,
+     * never rejects" contract above: a malformed definition is a programmer-timing error, not
+     * a runtime outcome to report through the result tree.
+     *
      * @param definition - The {@link WorkflowDefinition} to build the live tree from and drive
      * @param options - The construction options ({@link WorkflowOptions}: `on` / `bail` /
      *   `phases`) PLUS the per-run bounds (`signal` / `timeout` / `budget`)
      * @returns The run's terminal {@link WorkflowResult} (its `workflow` is the built tree)
      */
     execute(definition: WorkflowDefinition, options?: WorkflowRunOptions): Promise<WorkflowResult>;
+    /**
+     * Drive an ALREADY-BUILT, CALLER-OWNED live {@link WorkflowInterface} — the
+     * ENTITY-NATIVE counterpart to the definition-building {@link execute} overload.
+     *
+     * @remarks
+     * The entity itself is now the single control surface (no separate run handle):
+     * `createWorkflow` mints the live tree, this overload drives it, and the caller
+     * controls the SAME entity mid-run via its own `pause` / `resume` / `add` / `stop` /
+     * `destroy` (AGENTS §10). Requires `workflow.status === 'pending'` and
+     * `!workflow.destroyed` — otherwise this is a programmer-timing error and it THROWS a
+     * `TRANSITION` {@link import('./errors.js').WorkflowError} (AGENTS §12) rather than
+     * silently no-opping or building a second tree. Once accepted, phases run
+     * SEQUENTIALLY and, within each phase, tasks CONCURRENTLY — byte-identical observable
+     * semantics to the `definition`-form `execute` — except the phase loop RE-READS the
+     * live `workflow.phases` / each phase's live `tasks` every iteration (a cursor over
+     * the live managers, not a one-time snapshot), so a caller's live `add` mid-run is
+     * picked up and actually dispatched. `workflow.pause()` gates the run at the next
+     * phase boundary AND before each task's dispatch (an in-flight task body is never
+     * suspended); `workflow.stop()` skips not-yet-started work gracefully; `workflow.destroy()`
+     * folds `workflow.signal` into the run's cancellation, aborting in-flight work
+     * immediately. `options` carries only the per-run BOUNDS (`signal` / `timeout` /
+     * `budget`) — the construction half of {@link WorkflowRunOptions}
+     * does not apply, since the tree already exists.
+     *
+     * **Run round-trips through the snapshot.** Driving a tree rebuilt by
+     * {@link import('./factories.js').restoreWorkflow} behaves according to whether a
+     * {@link WorkflowFunctions} registry was supplied at that build: WITH a registry,
+     * each task's `run` name is re-resolved against it, so a matched task carries a real
+     * handler and this overload actually DISPATCHES it, resuming real work. WITHOUT a
+     * registry (or when a task's `run` name has no match in it), the task's
+     * {@link TaskInterface.run} is `undefined` — the no-handler rule then AUTO-COMPLETES
+     * that task (no dispatch occurs). A PARTIALLY-run restored tree (any live phase/task
+     * not `pending`) is rejected outright by the `workflow.status === 'pending'` guard
+     * above — only a wholly `pending` restored tree is drivable.
+     *
+     * @param workflow - The live {@link WorkflowInterface} to drive (its own entity surface —
+     *   `pause` / `resume` / `add` / `stop` / `destroy` — is the caller's control seam)
+     * @param options - The per-run bounds (`signal` / `timeout` / `budget`); the construction
+     *   half of {@link WorkflowRunOptions} does not apply (the tree already exists)
+     * @returns The run's terminal {@link WorkflowResult} (its `workflow` is the SAME entity passed in)
+     */
+    execute(workflow: WorkflowInterface, options?: Omit<WorkflowRunOptions, keyof WorkflowOptions>): Promise<WorkflowResult>;
 }
 
 /**
- * The options for `createWorkflowRunner` — the behavior registries the runner dispatches
- * a task BY NAME through, plus the optional pacing scheduler.
- *
- * @remarks
- * - `functions` — the {@link WorkflowFunctions} registry for `function`-form tasks. A name
- *   absent here is the no-handler case (the task auto-completes). Omitted ⇒ an empty
- *   registry (every `function` task auto-completes).
- * - `tools` — the {@link ToolManagerInterface} (the shipped tool registry) a `tool`-form
- *   task is dispatched through: the runner resolves `run.name` via `tools.tool(name)` and
- *   invokes it with the task's input. An unregistered tool name is the no-handler case
- *   (auto-completes). Omitted ⇒ every `tool` task auto-completes.
- * - `agents` — the {@link WorkflowAgents} resolver (W-c2) an `agent`-form task is dispatched
- *   through: the runner resolves `run.name` to a live
- *   {@link AgentInterface}, BINDS a depth/cycle-aware workflow
- *   tool onto its `context.tools` (the propagation seam), folds the task's cancellation into
- *   the agent run, and drives it (success → `complete`, throw → `fail`), all behind the
- *   depth + cycle guard. An unregistered agent name is the no-handler case (auto-completes).
- *   Omitted ⇒ every `agent` task auto-completes.
+ * The options for `createWorkflowRunner` — the optional pacing scheduler the runner
+ * paces phase boundaries with.
+ *
+ * @remarks
+ * The runner is a PURE engine — it carries no `functions` / `tools` / `agents` registry
+ * (each live task already resolved its own handler at construction from
+ * {@link WorkflowOptions.functions}); wiring a `function`-form task to a tool or an agent is
+ * an OPT-IN concern of the `@orkestrel/tool` package's adapter factories, which a caller
+ * composes into its OWN `functions` registry.
  * - `scheduler` — the {@link SchedulerInterface} that paces the tree (a cooperative
  *   `yield` between phases). Omitted ⇒ the shipped cross-environment default
  *   ({@link createScheduler}).
@@ -2833,10 +3436,6 @@ export declare interface WorkflowRunnerInterface {
  * wire. A future runner-level emitter would introduce its own `EmitterHooks` here.
  */
 export declare interface WorkflowRunnerOptions {
-    readonly functions?: WorkflowFunctions;
-    readonly tools?: ToolManagerInterface;
-    /** The {@link WorkflowAgents} resolver for `agent`-form tasks (W-c2); omitted ⇒ every `agent` task auto-completes. */
-    readonly agents?: WorkflowAgents;
     readonly scheduler?: SchedulerInterface;
 }
 
@@ -2869,28 +3468,15 @@ export declare interface WorkflowRunnerOptions {
  *   `signal` and `start`s it. (A `max: 0` budget is exhausted from its first `start`, so it
  *   cancels the run at entry — a DIFFERENT primitive from the `timeout: 0` "no deadline" case.)
  *
- * The last two are the W-c2 DEPTH / CYCLE bookkeeping — the run's position in a nested
- * workflow→agent→workflow chain, threaded across the
- * `execute → agent-task → createWorkflowTool → nested execute` boundary so the guard can
- * bound recursion. A TOP-LEVEL `execute` omits both (depth `0`, empty ancestry); only the
- * runner-bound workflow tool ({@link import('./factories.js').createWorkflowTool}) supplies
- * them, incrementing the depth and extending the ancestry for each nested run.
- * - `depth` — the run's nesting depth (default `0`). An `agent` task is REJECTED (a typed
- *   `DEPTH` `task.fail`) when running it would push the chain past
- *   {@link import('./constants.js').MAX_WORKFLOW_DEPTH}.
- * - `ancestry` — the identifiers of the workflows + agents already in this run chain
- *   (e.g. `workflow:<id>` / `agent:<name>`). An `agent` task whose target agent — or the
- *   workflow it would author — is already present is a CYCLE and is likewise rejected.
- *   Default empty.
+ * The engine itself carries NO nesting bookkeeping — the depth / cycle guard for a nested
+ * `agent` → workflow-tool → workflow chain lives entirely in the OPT-IN adapter factories
+ * shipped by `@orkestrel/tool`, closed over their own `depth` / `ancestry`, never threaded
+ * through `execute`'s options.
  */
 export declare type WorkflowRunOptions = WorkflowOptions & {
     readonly signal?: AbortSignal;
     readonly timeout?: number;
     readonly budget?: BudgetInterface<TokenUsage>;
-    /** The run's nesting depth (W-c2); default `0`. Threaded by the bound workflow tool, never by a top-level caller. */
-    readonly depth?: number;
-    /** The workflow / agent identifiers already in this run chain (W-c2 cycle guard); default empty. */
-    readonly ancestry?: readonly string[];
 };
 
 /**
@@ -2911,16 +3497,7 @@ export declare const workflowShape: ObjectShape<{
             id: StringShape;
             name: StringShape;
             description: OptionalShape<StringShape>;
-            run: UnionShape<[ ObjectShape<{
-                via: LiteralShape<readonly ["function"]>;
-                name: StringShape;
-            }>, ObjectShape<{
-                via: LiteralShape<readonly ["tool"]>;
-                name: StringShape;
-            }>, ObjectShape<{
-                via: LiteralShape<readonly ["agent"]>;
-                name: StringShape;
-            }>]>;
+            run: OptionalShape<StringShape>;
             retries: OptionalShape<NumberShape>;
             timeout: OptionalShape<NumberShape>;
         }>>;
@@ -2993,57 +3570,6 @@ export declare interface WorkflowSnapshotRow {
  */
 export declare type WorkflowStatus = LifecycleStatus;
 
-/**
- * One flat step — `{ name, via? }` — the building block of a {@link WorkflowSteps} blob.
- *
- * @remarks
- * `name` is the REGISTERED behavior name the step runs (it becomes the task's `run.name`,
- * NOT a human label). `via` is the optional execution mechanism — `'function'` (the
- * default when omitted), `'tool'`, or `'agent'`.
- */
-export declare interface WorkflowStep {
-    /** The registered behavior name this step runs (becomes the task's `run.name`). */
-    readonly name: string;
-    /** How to run it — `'function'` (default), `'tool'`, or `'agent'`. */
-    readonly via?: TaskVia;
-}
-
-/**
- * The FLAT authoring blob `createWorkflowTool` advertises — `{ name?, steps }` — the
- * simplest surface a small model can fill.
- *
- * @remarks
- * Each {@link WorkflowStep} becomes a one-task phase, in order
- * ({@link import('./helpers.js').expandSteps}); `name` is the optional workflow name
- * (defaulted when omitted). The expanded tree is validated against the STRICT
- * {@link import('./factories.js').createWorkflowContract} gate before running.
- */
-export declare interface WorkflowSteps {
-    readonly name?: string;
-    readonly steps: readonly WorkflowStep[];
-}
-
-/**
- * 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.
- */
-export declare const workflowStepsShape: ObjectShape<{
-    name: OptionalShape<StringShape>;
-    steps: ArrayShape<ObjectShape<{
-        name: StringShape;
-        via: OptionalShape<LiteralShape<readonly ["function", "tool", "agent"]>>;
-    }>>;
-}>;
-
 /**
  * The durable persistence seam for a {@link WorkflowSnapshot} — three async primitives
  * (`get` / `set` / `delete`) keyed by a workflow id, the snapshot analogue of
@@ -3091,89 +3617,4 @@ export declare interface WorkflowStoreInterface {
     delete(id: string): Promise<void>;
 }
 
-/**
- * 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>`)
- */
-export declare function workflowTag(id: string): string;
-
-/**
- * The workflow-tool binder — the signature of {@link import('./factories.js').createWorkflowTool},
- * threaded into the {@link WorkflowRunnerInterface} at construction (W-c2) so the runner can BIND a
- * depth/cycle-aware workflow tool onto a dispatched subagent.
- *
- * @remarks
- * The runner receives a REFERENCE to `createWorkflowTool` rather than importing it, because
- * `createWorkflowTool` lives in `factories.ts` which imports the runner CLASS (the
- * factories→classes direction); importing the factory back into the class would be a cycle. The
- * factory (which legitimately owns `createWorkflowContract`) is passed as a value at construction,
- * and the runner invokes it with `this` as the `runner` argument — keeping the cycle-free seam an
- * explicit, typed contract rather than a hidden dependency.
- *
- * @param definition - The workflow the bound tool runs when called with no authored args
- * @param runner - The runner that executes the (nested) workflow (the runner passes `this`)
- * @param options - The depth + ancestry the nested workflow runs under (see {@link WorkflowToolOptions})
- * @returns The bound {@link ToolInterface}
- */
-export declare type WorkflowToolBinder = (definition: WorkflowDefinition, runner: WorkflowRunnerInterface, options?: WorkflowToolOptions) => ToolInterface;
-
-/**
- * Options for {@link import('./factories.js').createWorkflowTool} — the depth + ancestry the
- * wrapped {@link WorkflowDefinition} runs the NESTED workflow at when an LLM invokes the tool.
- *
- * @remarks
- * This is the PROPAGATION carrier across the agent/tool boundary. A `Tool`'s handler receives
- * ONLY the model-supplied `args` (no ambient context, no signal — see
- * the `@orkestrel/agent` package's `ToolOptions`), so the run's position in the
- * workflow→agent→workflow chain CANNOT be threaded through a tool call at runtime. Instead the
- * runner CLOSES it over the tool at BIND time: when it dispatches an `agent` task at depth `D`
- * with ancestry `A`, it builds the agent's workflow tool with `{ depth: D, ancestry: A }`, so
- * the handler's closure carries them. On invocation the handler runs the nested workflow at
- * `depth: D + 1` with `ancestry: A ∪ { workflow:<id> }` — bounded by
- * {@link import('./constants.js').MAX_WORKFLOW_DEPTH} (an over-deep / cyclic nested run THROWS a
- * typed `DEPTH` {@link import('./errors.js').WorkflowError}, which the `ToolManager` isolates into
- * the tool result's top-level `error`, AGENTS §14).
- *
- * Both fields are OPTIONAL: a workflow tool built for a TOP-LEVEL caller (not by the runner's
- * agent-task binding) omits them — its nested run starts the chain at depth `1` with the bare
- * `workflow:<id>` ancestry.
- */
-export declare interface WorkflowToolOptions {
-    /** The depth the INVOKING agent runs at; the nested workflow runs at `depth + 1`. Default `0`. */
-    readonly depth?: number;
-    /** The ancestry of the invoking run; the nested run extends it with its own `workflow:<id>`. Default empty. */
-    readonly ancestry?: readonly string[];
-}
-
-/**
- * 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 }`
- */
-export declare function workflowToolSummary(result: WorkflowResult): Readonly<{
-    status: WorkflowStatus;
-    count: number;
-}>;
-
 export { }