@orkestrel/workflow 0.0.15 → 0.0.17

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

@@ -1,4 +1,3 @@
-import { AbortInterface } from '@orkestrel/abort';
 import { ArrayShape } from '@orkestrel/contract';
 import { BudgetInterface } from '@orkestrel/budget';
 import { ContractInterface } from '@orkestrel/contract';
@@ -7,6 +6,7 @@ import { EmitterErrorHandler } from '@orkestrel/emitter';
 import { EmitterHooks } from '@orkestrel/emitter';
 import { EmitterInterface } from '@orkestrel/emitter';
 import { Failure } from '@orkestrel/contract';
+import { Guard } from '@orkestrel/contract';
 import { JSONRecord } from '@orkestrel/contract';
 import { JSONValue } from '@orkestrel/contract';
 import { LiteralShape } from '@orkestrel/contract';
@@ -20,7 +20,22 @@ import { TableInterface } from '@orkestrel/database';
 import { TokenUsage } from '@orkestrel/budget';
 
 /**
- * Build a {@link PhaseContext} — a phase's own identity plus a back-reference to its
+ * Names how one task attempt left the race between its handler and its cancellation.
+ *
+ * @remarks
+ * The engine races a dispatched {@link WorkflowFunction} against the attempt's folded signal, so
+ * the attempt either SETTLED with the handler's JSON value or did not settle at all. A tuple, not
+ * a {@link Result}: the unsettled branch is a cancellation rather than an error, so there is no
+ * error to carry, and `genuine` records what the cancellation was — `true` for a genuine cancel
+ * (a run-level bound, a task `stop` / `skip`, or a sibling fail-fast, all of which skip the leaf),
+ * `false` for a bare per-attempt timeout (a retryable failure of this attempt), and `undefined`
+ * when the caller must re-read the discriminator itself. The engine reads the tuple positionally
+ * at each of its own settlement points; it never crosses the published surface.
+ */
+export declare type AttemptOutcome = readonly [settled: true, value: JSONValue] | readonly [settled: false, value: undefined, genuine?: boolean];
+
+/**
+ * Builds a {@link PhaseContext} — a phase's own identity plus a back-reference to its
  * workflow — from the parent {@link WorkflowContext} and the phase node's identity.
  *
  * @param workflow - The parent workflow context (the lineage pointer UP the tree)
@@ -30,7 +45,7 @@ import { TokenUsage } from '@orkestrel/budget';
 export declare function buildPhaseContext(workflow: WorkflowContext, node: WorkflowContext): PhaseContext;
 
 /**
- * Build a {@link TaskContext} — a task's own identity plus a back-reference to its phase
+ * Builds a {@link TaskContext} — a task's own identity plus a back-reference to its phase
  * (and, transitively, its workflow) — from the parent {@link PhaseContext} and the task
  * node's identity.
  *
@@ -41,7 +56,7 @@ export declare function buildPhaseContext(workflow: WorkflowContext, node: Workf
 export declare function buildTaskContext(phase: PhaseContext, node: WorkflowContext): TaskContext;
 
 /**
- * Build a {@link WorkflowContext} — the identity every level inherits — from a node's
+ * Builds a {@link WorkflowContext} — the identity every level inherits — from a node's
  * `id` / `name` / optional `description`.
  *
  * @remarks
@@ -55,8 +70,8 @@ export declare function buildTaskContext(phase: PhaseContext, node: WorkflowCont
 export declare function buildWorkflowContext(node: WorkflowContext): WorkflowContext;
 
 /**
- * Test whether the live W-b task state machine may move directly from one
- * {@link TaskStatus} to another — the legal-transition guard.
+ * Tests whether the live W-b task state machine may move directly from one
+ * {@link LifecycleStatus} to another — the legal-transition guard.
  *
  * @remarks
  * Reads the {@link import('./constants.js').TASK_TRANSITIONS} graph: `true` only when
@@ -66,12 +81,12 @@ export declare function buildWorkflowContext(node: WorkflowContext): WorkflowCon
  *
  * @param from - The task's current status
  * @param to - The status the transition would move it to
- * @returns `true` when the move is legal
+ * @returns True if the move is legal; false otherwise
  */
-export declare function canTransitionTask(from: TaskStatus, to: TaskStatus): boolean;
+export declare function canTransitionTask(from: LifecycleStatus, to: LifecycleStatus): boolean;
 
 /**
- * Capture every top-level {@link WorkflowOptions} value exactly once into an owned plain bag.
+ * Captures every top-level {@link WorkflowOptions} value exactly once into an owned plain bag.
  *
  * @remarks
  * Direct property reads preserve inherited and non-enumerable option values while preventing
@@ -92,7 +107,7 @@ export declare function canTransitionTask(from: TaskStatus, to: TaskStatus): boo
 export declare function captureWorkflowOptions(options?: WorkflowOptions): WorkflowOptions;
 
 /**
- * Validate and clone one complete task activity frame.
+ * Validates and clones one complete task activity frame.
  *
  * @remarks
  * This is the hostile boundary behind task reports and snapshot hydration. Supplying
@@ -109,7 +124,32 @@ export declare function captureWorkflowOptions(options?: WorkflowOptions): Workf
 export declare function cloneTaskActivity(input: unknown, updated?: number): TaskActivity;
 
 /**
- * Validate and own a workflow snapshot before live construction.
+ * Validates and owns one list of task activity claims.
+ *
+ * @remarks
+ * The one cloner behind both claim lists of a task activity frame — its `operations` and its
+ * `constraints` — because {@link import('./types.js').TaskOperation} and
+ * {@link import('./types.js').TaskConstraint} are the same {@link import('./types.js').TaskClaim}
+ * shape. An omitted
+ * list is an empty one. Each member is read exactly once inside the caller's protected boundary
+ * and returned frozen; the semantic pass over the copied values is
+ * {@link import('./validators.js').isTaskClaimList}, so this cloner refuses only what it cannot
+ * read: a non-array list, a non-record member, a hostile prototype, or an unexpected key.
+ *
+ * @param input - The untrusted claim list
+ * @param noun - The singular claim noun the refusal message names, pluralized by adding `s`
+ * @returns The owned frozen claims, in input order
+ * @throws {WorkflowError} With `MUTATION` when the list or one of its members cannot be read
+ *
+ * @example
+ * ```ts
+ * cloneTaskClaims([{ id: 'fetch', name: 'Fetch', started: 1 }], 'operation')
+ * ```
+ */
+export declare function cloneTaskClaims(input: unknown, noun: string): readonly unknown[];
+
+/**
+ * Validates and owns a workflow snapshot before live construction.
  *
  * @param input - The hostile snapshot boundary
  * @param id - The optional storage key the owned snapshot must match
@@ -119,7 +159,156 @@ export declare function cloneTaskActivity(input: unknown, updated?: number): Tas
 export declare function cloneWorkflowSnapshot(input: unknown, id?: string): WorkflowSnapshot;
 
 /**
- * Flatten a nested list of per-phase {@link TaskResult} lists into one positional list
+ * Implements the insertion-ordered gated store both lean managers hold — entities keyed by `id`,
+ * positional order preserved across an interior `skip` or `remove`.
+ *
+ * @remarks
+ * - **One engine, two managers.** {@link import('./tasks/TaskManager.js').TaskManager} and
+ *   {@link import('./phases/PhaseManager.js').PhaseManager} differ only in the entity noun and the
+ *   patch shape they validate, so both hold one of these and add only their domain accessors
+ *   (`task` / `tasks`, `phase` / `phases`). The `Map`'s insertion order is the single source of
+ *   positional truth; `add` and `move` rebuild it through the pure
+ *   {@link import('./helpers.js').insertEntry} / {@link import('./helpers.js').moveEntry} leaves.
+ * - **Gated mutation API.** `append` is the build-time wiring path and THROWS on a
+ *   duplicate id; `add` / `remove` / `move` / `update` return a graceful `MUTATION`
+ *   {@link WorkflowError} failure instead. Gating reads ONLY the target's own existence, `pending`
+ *   status, id, and bounds — a container's own status is the owning entity's gate, applied before
+ *   it delegates here.
+ * - **Event-free.** A purely structural container; the entity that owns it emits on success.
+ *
+ * @typeParam TEntry - The stored entity
+ * @typeParam TPatch - The declarative partial update `update` validates and applies
+ *
+ * @example
+ * ```ts
+ * import { compileGuard } from '@orkestrel/contract'
+ * import { Collection, taskUpdateShape } from '@orkestrel/workflow'
+ * import type { TaskInterface, TaskUpdate } from '@orkestrel/workflow'
+ *
+ * const tasks = new Collection<TaskInterface, TaskUpdate>('task', compileGuard(taskUpdateShape))
+ * tasks.append(task) // a live Task
+ * tasks.entry(task.id) // the same task
+ * tasks.entries() // [task]
+ * tasks.count // 1
+ * tasks.add(other, 0) // Result — inserted first
+ * tasks.move(other.id, 1) // Result — repositioned
+ * tasks.update(task.id, { name: 'Renamed task' }) // Result — patched
+ * tasks.remove(other.id) // Result — dropped
+ * ```
+ */
+export declare class Collection<TEntry extends CollectionEntry<TPatch>, TPatch> implements CollectionInterface<TEntry, TPatch> {
+    #private;
+    constructor(noun: string, patch: Guard<TPatch>);
+    get count(): number;
+    append(entry: TEntry): void;
+    add(entry: TEntry, index?: number): Result<TEntry, WorkflowError>;
+    remove(id: string): Result<TEntry, WorkflowError>;
+    move(id: string, index: number): Result<TEntry, WorkflowError>;
+    update(id: string, patch: TPatch): Result<TEntry, WorkflowError>;
+    entry(id: string): TEntry | undefined;
+    entries(): readonly TEntry[];
+}
+
+/**
+ * Declares what the {@link CollectionInterface} store requires of the entities it holds — a stable `id`, a
+ * gating {@link LifecycleStatus}, and a `patch` the store applies after validation.
+ *
+ * @remarks
+ * Both {@link TaskInterface} and {@link PhaseInterface} satisfy it, which is what lets one engine
+ * serve {@link TaskManagerInterface} and {@link PhaseManagerInterface}. The store reads `status`
+ * only to gate a `remove` / `move` / `update` on the target being `pending`; it never derives,
+ * writes, or interprets it further.
+ *
+ * @typeParam TPatch - The declarative partial update the entity's `patch` accepts
+ */
+export declare interface CollectionEntry<TPatch> {
+    readonly id: string;
+    readonly status: LifecycleStatus;
+    patch(value: TPatch): void;
+}
+
+/**
+ * Declares an insertion-ordered store of {@link CollectionEntry} entities keyed by `id`, with the gated
+ * mutation quartet a lean manager delegates to.
+ *
+ * @remarks
+ * The ONE engine behind {@link TaskManagerInterface} and {@link PhaseManagerInterface}: positional
+ * order is the backing `Map`'s insertion order, so it survives an interior `skip` (a status
+ * change, never a removal) and a snapshot restore reproduces it by re-`append`ing in order.
+ * `append` is the build-time wiring path and THROWS a `MUTATION`
+ * {@link import('./errors.js').WorkflowError} on a duplicate id (a genuine programmer error);
+ * `add` / `remove` / `move` / `update` are its graceful `Result` counterparts, gating ONLY on the
+ * target's own existence, `pending` status, id, and bounds. The store is event-free — the entity
+ * that owns it emits on success. Each refusal names the entity noun the store was built with, so
+ * a task store and a phase store report in their own vocabulary.
+ *
+ * @typeParam TEntry - The stored entity
+ * @typeParam TPatch - The declarative partial update `update` validates and applies
+ */
+export declare interface CollectionInterface<TEntry, TPatch> {
+    readonly count: number;
+    /**
+     * Adds `entry` at the end — the build-time wiring path.
+     *
+     * @remarks
+     * THROWS a `MUTATION` {@link import('./errors.js').WorkflowError} on a duplicate `id` instead
+     * of silently overwriting the existing entry.
+     *
+     * @param entry - The entity to append
+     */
+    append(entry: TEntry): void;
+    /**
+     * Inserts `entry` at `index` (default the end) — the gated counterpart to {@link append}.
+     *
+     * @param entry - The entity to insert
+     * @param index - The insertion position (`[0, count]`); omitted inserts at the end
+     * @returns A {@link Result} boxing the inserted entity, or a `MUTATION` failure on a duplicate
+     *   id or an out-of-bounds `index`
+     */
+    add(entry: TEntry, index?: number): Result<TEntry, WorkflowError>;
+    /**
+     * Removes the `pending` entity `id`.
+     *
+     * @param id - The entity id to remove
+     * @returns A {@link Result} boxing the removed entity, or a `MUTATION` failure when `id` is
+     *   absent or not `pending`
+     */
+    remove(id: string): Result<TEntry, WorkflowError>;
+    /**
+     * Repositions the `pending` entity `id` to `index`.
+     *
+     * @param id - The entity id to move
+     * @param index - The destination position (`[0, count)`)
+     * @returns A {@link Result} boxing the moved entity, or a `MUTATION` failure when `id` is
+     *   absent, not `pending`, or `index` is out of bounds
+     */
+    move(id: string, index: number): Result<TEntry, WorkflowError>;
+    /**
+     * Applies a validated patch to the `pending` entity `id`.
+     *
+     * @param id - The entity id to patch
+     * @param patch - The fields to update
+     * @returns A {@link Result} boxing the patched entity, or a `MUTATION` failure when `id` is
+     *   absent, not `pending`, or `patch` fails validation
+     */
+    update(id: string, patch: TPatch): Result<TEntry, WorkflowError>;
+    /**
+     * Looks up one stored entity by its `id`.
+     *
+     * @param id - The entity id to resolve
+     * @returns The stored entity, or `undefined` when none is stored under `id`
+     */
+    entry(id: string): TEntry | undefined;
+    /**
+     * Lists every stored entity in positional order.
+     *
+     * @returns The stored entities, in insertion order
+     */
+    entries(): readonly TEntry[];
+}
+
+/**
+ * Flattens a nested list of per-phase {@link TaskResult} lists into one positional list
  * — the workflow tier of the result tree, built from each phase's `results()`.
  *
  * @remarks
@@ -133,45 +322,7 @@ export declare function cloneWorkflowSnapshot(input: unknown, id?: string): Work
 export declare function collectResults(phases: ReadonlyArray<readonly TaskResult[]>): readonly TaskResult[];
 
 /**
- * The per-unit handle a runner handler receives — wraps the unit's identity,
- * input, cancellation, and the run controls (`wait` / `spawn` / `abort`).
- *
- * @remarks
- * - **Built by the Runner per unit.** The runner constructs one `Controller` per
- *   unit it dispatches, handing it the unit's `id`, `input`, the unit's `Abort`
- *   handle, the queue attempt's `signal`, and a `spawn` callback that launches a
- *   sibling through the same queue.
- * - **Signal.** `signal` is the queue attempt's signal, which ANY-combines the
- *   unit's own abort, the runner-level abort (the runner aborts every unit), and
- *   the per-attempt timeout — so it fires on any of the three. `aborted` and
- *   `abort(reason)` delegate to the unit's `Abort` (the cancellation source of
- *   truth); since the attempt signal ANY-includes that abort, `abort()` fires
- *   `signal` too.
- * - **`wait` promise-parks (never a timer).** It resolves the instant the unit's
- *   `signal` fires (immediately if already aborted) via a one-shot listener — no
- *   `setTimeout`, no polling, no busy-yield — so a parked unit costs no CPU.
- * - **`spawn` is fire-and-track.** It delegates to the runner's launch-a-sibling
- *   callback, which routes the sibling through the queue; the runner's `execute`
- *   awaits the spawn closure, so the sibling runs whether or not its promise is
- *   awaited. (Inline-awaiting a spawn from a slot-holding handler on a bounded
- *   runner can deadlock — fan out instead; see {@link ControllerInterface.spawn}.)
- * - **Event-free by design.** The per-unit handle carries no Emitter; observe the
- *   {@link RunnerInterface.emitter} instead (`unit` / `spawn` / `settle` / `fail` carry the id).
- */
-export declare class Controller<TInput, TResult> implements ControllerInterface<TInput, TResult> {
-    #private;
-    readonly id: string;
-    readonly input: TInput;
-    readonly signal: AbortSignal;
-    constructor(id: string, input: TInput, abort: AbortInterface, signal: AbortSignal, spawn: (input: TInput) => Promise<TResult>);
-    get aborted(): boolean;
-    wait(): Promise<void>;
-    spawn(input: TInput): Promise<TResult>;
-    abort(reason?: unknown): void;
-}
-
-/**
- * The per-unit handle a {@link RunnerHandler} receives — the running unit's
+ * Declares the per-unit handle a {@link RunnerHandler} receives — the running unit's
  * identity, input, cancellation, and the controls to cooperate with the run.
  *
  * @remarks
@@ -195,7 +346,7 @@ export declare interface ControllerInterface<TInput, TResult> {
     readonly signal: AbortSignal;
     readonly aborted: boolean;
     /**
-     * Park until this unit's `signal` aborts — **promise-parked**, never a timer.
+     * Parks until this unit's `signal` aborts — **promise-parked**, never a timer.
      *
      * @remarks
      * Resolves the moment the unit's `signal` fires (unit abort, runner abort, or
@@ -203,11 +354,11 @@ export declare interface ControllerInterface<TInput, TResult> {
      * one-shot `'abort'` listener and never polls — no `setTimeout`, no `delay`, no
      * busy-yield — so a parked unit consumes no CPU until it is actually cancelled.
      *
-     * @returns A promise that resolves once the unit's `signal` aborts
+     * @returns A promise that resolves after the unit's `signal` aborts
      */
     wait(): Promise<void>;
     /**
-     * Add a sibling unit to the run; returns its result promise.
+     * Adds a sibling unit to the run; returns its result promise.
      *
      * @remarks
      * **Fire-and-track.** The spawned unit is routed through the same backing queue
@@ -228,7 +379,7 @@ export declare interface ControllerInterface<TInput, TResult> {
      */
     spawn(input: TInput): Promise<TResult>;
     /**
-     * Cancel this unit — fires its `signal` with the optional reason.
+     * Cancels this unit — fires its `signal` with the optional reason.
      *
      * @param reason - An optional cancellation reason carried on the signal
      */
@@ -236,7 +387,7 @@ export declare interface ControllerInterface<TInput, TResult> {
 }
 
 /**
- * Create a {@link DatabaseWorkflowStore} over any {@link DriverInterface} — the durable,
+ * Creates a {@link DatabaseWorkflowStore} over any {@link DriverInterface} — the durable,
  * driver-pluggable backing for the W-d persistence seam, the opt-in twin of
  * {@link createMemoryWorkflowStore}.
  *
@@ -247,8 +398,9 @@ export declare interface ControllerInterface<TInput, TResult> {
  * snapshot is already a COMPLETE, self-contained, pure-JSON payload, so storing it whole is lossless
  * AND keeps the row type FLAT — a structured multi-column snapshot table would force the contract to
  * `Infer` the deeply-nested snapshot shape (workflow → phases → tasks → results) and trip TS2589;
- * the opaque column sidesteps it (the column reads back as `unknown`, narrowed on `get` by
- * {@link import('./helpers.js').isWorkflowSnapshot}). The `driver` DEFAULTS to
+ * the opaque column sidesteps it (the column reads back as `unknown`, owned and narrowed on `get` by
+ * {@link cloneWorkflowSnapshot}, whose semantic pass is
+ * {@link import('./validators.js').isOwnedWorkflowSnapshot}). The `driver` DEFAULTS to
  * {@link createMemoryDriver}, so the store ALSO works in memory out of the box; pass a server
  * `createJSONDriver` / `createSQLiteDriver` (or a browser IndexedDB driver) for a persistent one —
  * the durability is the driver's job, the store engine is shared. It swaps in behind
@@ -272,23 +424,15 @@ export declare interface ControllerInterface<TInput, TResult> {
 export declare function createDatabaseWorkflowStore(driver?: DriverInterface): WorkflowStoreInterface;
 
 /**
- * Create a {@link DeferredInterface} — a promise whose settlement is driven
- * externally, so a caller can resolve/reject it from outside the executor.
- *
- * @typeParam T - The value the deferred promise resolves
- * @returns A deferred `promise` plus its `resolve` / `reject`
- */
-export declare function createDeferred<T>(): DeferredInterface<T>;
-
-/**
- * Create the in-memory durable {@link WorkflowStoreInterface} — a process-lifetime
+ * Creates the in-memory durable {@link WorkflowStoreInterface} — a process-lifetime
  * {@link MemoryWorkflowStore} persisting {@link WorkflowSnapshot}s by workflow id, the DEFAULT
  * backend behind the W-d persistence seam.
  *
  * @remarks
  * The snapshot analogue of the server package's `createMemorySessionStore`
  * (and the `createMemoryQueueStore` family), but LEANER — there is no idle-TTL, so no
- * options bag (AGENTS §21 minimal): a persisted run-state lives until an explicit `delete`. This is
+ * options bag (the smallest interface the capability requires): a persisted run-state lives until
+ * an explicit `delete`. This is
  * the zero-plumbing DEFAULT (a plain `Map`); its driver-pluggable twin is
  * {@link createDatabaseWorkflowStore} (the snapshot as one opaque JSON column over a `databases`
  * table) — for a DURABLE store (run-state surviving a restart) pass it a JSON / SQLite / IndexedDB
@@ -311,10 +455,10 @@ export declare function createDeferred<T>(): DeferredInterface<T>;
 export declare function createMemoryWorkflowStore(): WorkflowStoreInterface;
 
 /**
- * Build an interrupted workflow back to life at its remaining retry budget.
+ * Builds an interrupted workflow back to life at its remaining retry budget.
  *
  * @remarks
- * Each phase captures every unique initial `run` binding once before constructing tasks. Recovery
+ * Each phase captures every unique initial `behavior` binding once before constructing tasks. Recovery
  * validates those live tasks' captured callable handlers without rereading the registry, while the
  * retained registry identity remains available to resolve future live additions at their mint time.
  *
@@ -333,7 +477,7 @@ export declare function createMemoryWorkflowStore(): WorkflowStoreInterface;
 export declare function createRecoveredWorkflow(snapshot: unknown, options?: WorkflowOptions): WorkflowInterface;
 
 /**
- * Build an equivalent live W-b entity tree from a {@link WorkflowSnapshot} — the
+ * Builds an equivalent live W-b entity tree from a {@link WorkflowSnapshot} — the
  * inverse of {@link WorkflowInterface.snapshot}, restoring structure + each node's status
  * + recorded results + positional order + the persisted `#override`.
  *
@@ -348,7 +492,7 @@ export declare function createRecoveredWorkflow(snapshot: unknown, options?: Wor
  * still wins when supplied (to deliberately re-run under a different policy). A structurally
  * invalid snapshot (a status — or override — outside the lifecycle vocabulary, or a
  * non-boolean `bail`) throws a `RESTORE` {@link WorkflowError}.
- * Runtime handlers are optional: without a matching `functions` entry, a persisted `run`
+ * Runtime handlers are optional: without a matching `functions` entry, a persisted `behavior`
  * remains visible with an undefined `handler` so the exact state is inspectable. The runner
  * rejects that unresolved tree if execution is attempted.
  *
@@ -367,7 +511,7 @@ export declare function createRecoveredWorkflow(snapshot: unknown, options?: Wor
 export declare function createRestoredWorkflow(snapshot: unknown, options?: WorkflowOptions): WorkflowInterface;
 
 /**
- * Create a thin generic orchestrator that drives declared units — and any they
+ * Creates a thin generic orchestrator that drives declared units — and any they
  * `spawn` — through a bounded-concurrency queue, collecting their results in order.
  *
  * @remarks
@@ -379,13 +523,13 @@ export declare function createRestoredWorkflow(snapshot: unknown, options?: Work
  * `id` / `input`, a `signal` that fires on the unit's `abort`, a runner-level `abort`,
  * or the attempt's timeout, a promise-parked `wait()`, and `spawn(input)` to fan out
  * sibling units. The run is **fail-fast**: the first unit failure (after retries)
- * aborts every other unit and rejects `execute` with that error. **Observable (§13):** a
+ * aborts every other unit and rejects `execute` with that error. **Observable:** a
  * typed `emitter` surfaces `start` / `unit` / `spawn` / `settle` / `fail` / `finish` / `abort`.
  *
- * Because `spawn` is fire-and-track (the runner awaits the whole spawn closure via an
+ * Because `spawn` is fire-and-track (the runner awaits the whole spawn closure through an
  * outstanding-unit count, not a one-time snapshot), a handler need NOT await its spawns
- * for them to run — and on a bounded runner it should NOT `await` a spawn inline (a
- * slot-holding handler awaiting its own spawn can deadlock); fan out and return instead.
+ * for them to run — and on a bounded runner do NOT `await` a spawn inline (a slot-holding
+ * handler awaiting its own spawn can deadlock); fan out and return instead.
  *
  * @typeParam TInput - The work input each unit carries
  * @typeParam TResult - The value a unit's handler resolves
@@ -413,12 +557,12 @@ export declare function createRestoredWorkflow(snapshot: unknown, options?: Work
 export declare function createRunner<TInput, TResult>(options: RunnerOptions<TInput, TResult>): RunnerInterface<TInput, TResult>;
 
 /**
- * Create the safe cross-environment cooperative-yield default — a
+ * Creates the safe cross-environment cooperative-yield default — a
  * {@link SchedulerInterface} built on `setTimeout` / `clearTimeout` alone, so it
  * runs unchanged in both the browser and Node.
  *
  * @remarks
- * `yield()` gives the host a turn via a zero-delay macrotask (so pending I/O,
+ * `yield()` gives the host a turn through a zero-delay macrotask (so pending I/O,
  * timers, and rendering actually run — a microtask would not); `delay(ms)` resumes
  * after at least `ms`. Pass `options.signal` to make a pending yield/delay reject
  * with the signal's exact `reason`; the shared owned-signal lifecycle clears the timer
@@ -458,7 +602,7 @@ export declare function createRunner<TInput, TResult>(options: RunnerOptions<TIn
 export declare function createScheduler(): SchedulerInterface;
 
 /**
- * Build the live W-b entity tree from a {@link WorkflowDefinition} — the whole
+ * Builds the live W-b entity tree from a {@link WorkflowDefinition} — the whole
  * {@link WorkflowInterface} → {@link import('./types.js').PhaseInterface} →
  * {@link import('./types.js').TaskInterface} tree, each level wired with its lineage
  * context, its emitter, and the cascade.
@@ -470,11 +614,11 @@ export declare function createScheduler(): SchedulerInterface;
  * definition's `bail`, else the graceful {@link import('./constants.js').DEFAULT_BAIL}; it
  * feeds {@link import('./helpers.js').deriveWorkflowStatus}. Per-phase / per-task initial
  * listeners + metadata travel through `options.phases[id].on` /
- * `options.phases[id].tasks[id]` (the AGENTS §8 nested-by-id bag). The W-b tree is the
+ * `options.phases[id].tasks[id]` (the 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
+ * `options.functions` is the {@link import('./types.js').WorkflowRegistry} registry each live
+ * task's `behavior` name resolves against ONCE at construction into its runtime
  * {@link import('./types.js').TaskInterface.handler}. An omitted name is the deliberate no-op;
  * an unresolved present name remains inspectable but is rejected if execution is attempted.
  *
@@ -494,7 +638,7 @@ export declare function createScheduler(): SchedulerInterface;
 export declare function createWorkflow(definition: WorkflowDefinition, options?: WorkflowOptions): WorkflowInterface;
 
 /**
- * Compile the workflow definition contract — the JSON Schema, guard, parser, and
+ * Compiles the workflow definition contract — the JSON Schema, guard, parser, and
  * seeded generator for a {@link WorkflowDefinition}, all derived from one shape and
  * kept in lockstep.
  *
@@ -523,13 +667,13 @@ export declare function createWorkflow(definition: WorkflowDefinition, options?:
 export declare function createWorkflowContract(): ContractInterface<WorkflowDefinition>;
 
 /**
- * Create a {@link WorkflowManagerInterface} — the store-backed registry of
+ * Creates a {@link WorkflowManagerInterface} — the store-backed registry of
  * {@link WorkflowInterface}s, the additive manager tier mirroring the `@orkestrel/agent`
  * line's `createConversationManager` / `createWorkspaceManager`.
  *
  * @remarks
- * `options.functions` flows into every workflow the manager mints (`add`, via
- * {@link createWorkflow}) or hydrates (`open`'s registry-miss path, via
+ * `options.functions` flows into every workflow the manager mints (`add`, through
+ * {@link createWorkflow}) or hydrates (`open`'s registry-miss path, through
  * {@link createRestoredWorkflow}), so a hydrated workflow is RUNNABLE rather than a dead snapshot
  * mirror. `options.store` is the EXACT analogue of the twins' `store` seam — omitted ⇒ the
  * manager is registry-only (`open` resolves only what is registered, `save` is a no-op). This
@@ -556,9 +700,9 @@ export declare function createWorkflowContract(): ContractInterface<WorkflowDefi
 export declare function createWorkflowManager(options?: WorkflowManagerOptions): WorkflowManagerInterface;
 
 /**
- * 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 through its OWN resolved handler under the workflow's `bail` policy.
+ * Creates the thin orchestrator — a {@link WorkflowRunnerInterface} — that EXECUTES a live W-b
+ * workflow tree by COMPOSING the shipped substrate: phases sequential, tasks concurrent, 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
@@ -571,14 +715,14 @@ export declare function createWorkflowManager(options?: WorkflowManagerOptions):
  * 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
+ * `execute(definition, options?)` BUILDS the live tree from the definition itself (through
  * {@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}.
  *
  * External integrations remain application-owned: a caller wires an ordinary
  * {@link import('./types.js').WorkflowFunction} into its own {@link WorkflowOptions.functions}
- * registry. Only a task that omits `run` auto-completes; unresolved named work is rejected
+ * registry. Only a task that omits `behavior` auto-completes; unresolved named work is rejected
  * before dispatch.
  *
  * @param options - An optional pacing `scheduler` (default the shipped cross-environment one).
@@ -591,7 +735,7 @@ export declare function createWorkflowManager(options?: WorkflowManagerOptions):
  *
  * const runner = createWorkflowRunner()
  * const definition = { id: 'w', name: 'W', phases: [{ id: 'p', name: 'P', tasks: [
- * 	{ id: 't', name: 'T', run: 'compile' },
+ * 	{ id: 't', name: 'T', behavior: 'compile' },
  * ] }] }
  * const result = await runner.execute(definition, {
  * 	functions: { compile: async (controller) => `built ${controller.task.id}` },
@@ -603,7 +747,43 @@ export declare function createWorkflowManager(options?: WorkflowManagerOptions):
 export declare function createWorkflowRunner(options?: WorkflowRunnerOptions): WorkflowRunnerInterface;
 
 /**
- * A {@link WorkflowStoreInterface} backed by one table of the `databases` layer — a
+ * Builds the live entity tree one definition and one owned options bag describe — the shared
+ * construction path behind every definition-driven mint.
+ *
+ * @remarks
+ * Seeds an initial all-`pending` {@link WorkflowSnapshot} from the definition and constructs the
+ * live {@link WorkflowInterface} over it. `bail` is the caller's own override, forwarded to
+ * {@link definitionToSnapshot} so it reaches BOTH tiers: the workflow snapshot AND the inheritance
+ * default of every phase that declares no `bail` of its own, while a phase declaring one still
+ * wins. Omitted, the definition's own `bail` governs, defaulting to the graceful
+ * {@link import('./constants.js').DEFAULT_BAIL}.
+ *
+ * `captured` is forwarded to the entity UNCHANGED — its own `bail` is deliberately not replaced
+ * with the resolved policy, because the snapshot already carries the resolved value at both tiers
+ * and an injected one would make `Workflow` read it as an EXPLICIT uniform override and clobber
+ * the per-phase overrides. Each task's `behavior` / `retries` / `timeout` travel onto the snapshot
+ * too, so `captured.functions` resolves every handler identically whether the tree is built fresh
+ * or restored. Pass a bag {@link captureWorkflowOptions} already owns: this constructs over it
+ * without re-capturing.
+ *
+ * @param definition - The workflow definition to bring to life
+ * @param captured - The already-owned {@link WorkflowOptions} bag the entity is constructed with,
+ * whose `bail` is the caller's failure-policy override, or `undefined` to take the definition's
+ * @returns The live {@link WorkflowInterface} root
+ *
+ * @example
+ * ```ts
+ * import { captureWorkflowOptions, createWorkflowTree } from '@orkestrel/workflow'
+ *
+ * const captured = captureWorkflowOptions({ bail: true })
+ * const workflow = createWorkflowTree(definition, captured)
+ * workflow.bail // true — the override reached the workflow and every inheriting phase
+ * ```
+ */
+export declare function createWorkflowTree(definition: WorkflowDefinition, captured: WorkflowOptions): WorkflowInterface;
+
+/**
+ * Implements 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
  * (`get` / `set` / `delete`) over a `TableInterface`, the driver-pluggable twin of the
  * plain-`Map` {@link import('./MemoryWorkflowStore.js').MemoryWorkflowStore}.
@@ -627,16 +807,18 @@ export declare function createWorkflowRunner(options?: WorkflowRunnerOptions): W
  *
  * - **`set(snapshot)` upserts under the snapshot's OWN `id`** (no separate id param) — it writes
  *   the row `{ id: snapshot.id, snapshot }`.
- * - **`get(id)` resolves the stored snapshot for an id**, narrowing the opaque JSON column back to
- *   a {@link WorkflowSnapshot} ({@link import('../helpers.js').isWorkflowSnapshot} — the AGENTS §14
- *   boundary narrow for an untrusted storage read), or `undefined` if none is stored. A present
- *   snapshot whose own id differs from the requested key rejects with normalized `RESTORE` evidence.
+ * - **`get(id)` resolves the stored snapshot for an id**, owning and narrowing the opaque JSON
+ *   column back to a {@link WorkflowSnapshot} through
+ *   {@link import('../cloners.js').cloneWorkflowSnapshot}, whose semantic pass is
+ *   {@link import('../validators.js').isOwnedWorkflowSnapshot} — the boundary narrow for
+ *   an untrusted storage read — or `undefined` if none is stored. A present snapshot whose own id
+ *   differs from the requested key rejects with normalized `RESTORE` evidence.
  * - **`delete(id)` drops a snapshot by id**; an absent id is a no-op (no throw).
  *
  * UNLIKE the server package's `SessionStoreInterface` there is NO
  * idle-TTL / eviction — a persisted run-state is durable orchestration state that lives until an
  * explicit `delete`. The public surface is EXACTLY `get` / `set` / `delete` — no extra members (the
- * §22 method bijection with {@link WorkflowStoreInterface}). Restore stays a caller concern: read a
+ * guide's method bijection with {@link WorkflowStoreInterface}). Restore stays a caller concern: read a
  * snapshot back and rebuild the live tree with {@link import('../factories.js').createRestoredWorkflow}.
  *
  * @example
@@ -655,25 +837,25 @@ export declare function createWorkflowRunner(options?: WorkflowRunnerOptions): W
 export declare class DatabaseWorkflowStore implements WorkflowStoreInterface {
     #private;
     /**
-     * Wrap a table as a workflow store.
+     * Wraps a table as a workflow store.
      *
      * @param table - The {@link TableInterface} holding the snapshots — its row is the
      *   {@link WorkflowSnapshotRow} `{ id; snapshot }` shape (the snapshot one opaque JSON column)
      */
     constructor(table: TableInterface<WorkflowSnapshotRow>);
-    /** Resolve and key-check the snapshot for `id`, narrowing the opaque column to `WorkflowSnapshot`. */
+    /** Resolves and key-checks the snapshot for `id`, narrowing the opaque column to `WorkflowSnapshot`. */
     get(id: string): Promise<WorkflowSnapshot | undefined>;
-    /** Insert or replace under the snapshot's OWN `id` (no separate id param) — the row is `{ id, snapshot }`. */
+    /** Inserts or replaces under the snapshot's OWN `id` (no separate id param) — the row is `{ id, snapshot }`. */
     set(snapshot: WorkflowSnapshot): Promise<void>;
-    /** Drop a snapshot by id; an absent id is a no-op (no throw). */
+    /** Drops a snapshot by id; an absent id is a no-op (no throw). */
     delete(id: string): Promise<void>;
 }
 
-/** The default {@link import('./types.js').WorkflowDefinition.bail} — graceful (continue on a leaf failure). */
+/** Names the default {@link import('./types.js').WorkflowDefinition.bail} — graceful (continue on a leaf failure). */
 export declare const DEFAULT_BAIL = false;
 
 /**
- * The default per-phase task concurrency the {@link import('./factories.js').createWorkflowRunner}
+ * Names 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 cap that is effectively unbounded for any realistic phase.
  *
@@ -694,32 +876,20 @@ export declare const DEFAULT_BAIL = false;
 export declare const DEFAULT_PHASE_CONCURRENCY = 1024;
 
 /**
- * A promise paired with its externally-callable `resolve`/`reject` — the settle path
- * is exposed to the caller instead of being buried in an executor closure.
- *
- * @typeParam T - The value the deferred's `promise` resolves
- */
-export declare interface DeferredInterface<T> {
-    readonly promise: Promise<T>;
-    resolve(value: T): void;
-    reject(reason: unknown): void;
-}
-
-/**
- * Convert a {@link WorkflowDefinition} into an INITIAL {@link WorkflowSnapshot} — every
+ * Converts a {@link WorkflowDefinition} into an INITIAL {@link WorkflowSnapshot} — every
  * node `pending`, no results, empty metadata — so the live W-b tree has ONE construction
  * path (snapshot-driven) for both a fresh build and a restore.
  *
  * @remarks
  * The structural fields (`id` / `name` / `description` + the ordered phases / tasks)
  * 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` /
+ * {@link PhaseSnapshot} so a restore reinstates the same throttle) and each task's `behavior` /
  * `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.
+ * snapshot is self-contained; a fresh seed has no `override`. `created` / `updated` are stamped at that point.
  * {@link import('./factories.js').createWorkflow} builds from this.
  *
  * The optional `bail` override is the EFFECTIVE workflow policy the tree will run under
@@ -736,16 +906,41 @@ 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 —
+ * Schedules the shared host timer boundary every scheduler backend resumes from.
+ *
+ * @remarks
+ * The one `setTimeout` / `clearTimeout` boundary in the package: the cross-environment
+ * {@link import('./Scheduler.js').Scheduler}, both Node primitives, and every browser backend's
+ * `delay` and macrotask fallback route here, so the timer is armed and cleared in one place. It
+ * composes {@link scheduleHost}, which owns listener safety, the cancellation race, the exact
+ * caller reason, and once-only settlement. It does NOT validate `ms`: the value passes straight to
+ * the host `setTimeout`, which clamps a negative value or `NaN` to about zero, so an
+ * out-of-domain `ms` resumes on the next host turn rather than throwing. Pass a non-negative
+ * finite `ms`.
+ *
+ * @param ms - The milliseconds to wait before resuming
+ * @param signal - Optional caller cancellation signal
+ * @returns A promise that resolves after `ms`, or rejects with the caller's exact abort reason
+ *
+ * @example
+ * ```ts
+ * const controller = new AbortController()
+ * await delayHost(0, controller.signal) // a real macrotask host turn
+ * ```
+ */
+export declare function delayHost(ms: number, signal?: AbortSignal): Promise<void>;
+
+/**
+ * Derives 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
+ * The native, hook-free replacement for a runner-installed cursor: 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
+ * entry forms the trailing suffix — so the boundary is 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
@@ -764,7 +959,7 @@ export declare function definitionToSnapshot(definition: WorkflowDefinition, bai
 export declare function deriveBoundary(statuses: readonly LifecycleStatus[]): number;
 
 /**
- * Derive a phase's status from its tasks' statuses (tasks are concurrent, so this
+ * Derives a phase's status from its tasks' statuses (tasks are concurrent, so this
  * is an order-insensitive reduction).
  *
  * @remarks
@@ -782,18 +977,18 @@ export declare function deriveBoundary(statuses: readonly LifecycleStatus[]): nu
  * task makes the phase `failed`.
  *
  * @param tasks - The phase's task statuses, in any order
- * @returns The derived {@link PhaseStatus}
+ * @returns The derived phase {@link LifecycleStatus}
  */
-export declare function derivePhaseStatus(tasks: readonly TaskStatus[]): PhaseStatus;
+export declare function derivePhaseStatus(tasks: readonly LifecycleStatus[]): LifecycleStatus;
 
 /**
- * Derive a workflow's status from its phases' {@link PhaseDerivation}s — each phase's status
+ * Derives a workflow's status from its phases' {@link PhaseDerivation}s — each phase's status
  * paired with the EFFECTIVE `bail` it ran under (`phase.bail ?? workflow.bail`) — so the
  * failure outcome is PER-PHASE-bail-aware (phases are sequential, but the derivation is an
  * order-insensitive reduction over the settled set).
  *
  * @remarks
- * `bail` is now a per-phase override (AGENTS §4.4), so it is carried on each
+ * `bail` is a per-phase override, so it is carried on each
  * {@link PhaseDerivation} rather than passed as one scalar. It is the ONLY axis that changes
  * the failure outcome, decided per phase:
  * - **A `failed` phase whose effective `bail` is `true` (halt)** propagates ⇒ the workflow is
@@ -812,12 +1007,12 @@ export declare function derivePhaseStatus(tasks: readonly TaskStatus[]): PhaseSt
  *   else (all `skipped`) ⇒ `skipped`.
  *
  * @param phases - The workflow's per-phase {@link PhaseDerivation}s (status + effective bail), in any order
- * @returns The derived {@link WorkflowStatus}
+ * @returns The derived workflow {@link LifecycleStatus}
  */
-export declare function deriveWorkflowStatus(phases: readonly PhaseDerivation[]): WorkflowStatus;
+export declare function deriveWorkflowStatus(phases: readonly PhaseDerivation[]): LifecycleStatus;
 
 /**
- * Normalize an unknown thrown value to a non-empty persistence-safe message.
+ * Normalizes an unknown thrown value to a non-empty persistence-safe message.
  *
  * @param error - The caught value
  * @returns A non-empty message without stack or cause data
@@ -825,7 +1020,7 @@ export declare function deriveWorkflowStatus(phases: readonly PhaseDerivation[])
 export declare function errorToMessage(error: unknown): string;
 
 /**
- * Box an error as a {@link Failure} — the graceful outcome half of a {@link Result}.
+ * Boxes an error as a {@link Failure} — the graceful outcome half of a {@link Result}.
  *
  * @typeParam E - The boxed error's type
  * @param error - The error to box
@@ -839,7 +1034,7 @@ export declare function errorToMessage(error: unknown): string;
 export declare function failure<E>(error: E): Failure<E>;
 
 /**
- * Find the first {@link TaskResult} in a positional list whose boxed outcome is a
+ * Finds 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.
  *
@@ -847,8 +1042,8 @@ export declare function failure<E>(error: E): Failure<E>;
  * 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
+ * them here; the tier-local method keeps the invariant throw (a derived `failed`
+ * status means a failing result exists) because throwing on `undefined` is
  * orchestration, not a leaf concern.
  *
  * @param results - The results to scan, in any order
@@ -862,30 +1057,33 @@ export declare function failure<E>(error: E): Failure<E>;
 export declare function findFailure(results: readonly TaskResult[]): TaskResult | undefined;
 
 /**
- * Test that every named task has a callable runtime handler before dispatch.
+ * Tests that every named task has a callable runtime handler before dispatch.
  *
  * @remarks
- * A snapshot lookup reads each unique `run` binding at most once from `functions`. A live workflow
+ * A snapshot lookup reads each unique `behavior` binding at most once from `functions`. A live workflow
  * validates its tasks' already-resolved handlers without consulting the retained registry again.
+ * `functions` belongs to the snapshot overload alone; the live-workflow overload takes no registry
+ * and reads each task's already-resolved `handler`.
  *
  * @param workflow - The persisted snapshot or constructed live workflow to validate
- * @returns Whether every named task resolves to a callable handler
+ * @param functions - The behavior registry the snapshot overload resolves each unique `behavior`
+ * name against; omitted or `undefined` leaves every named task unresolved
+ * @returns True if every named task resolves to a callable handler; false otherwise
  */
 export declare function hasWorkflowHandlers(workflow: WorkflowInterface): boolean;
 
-export declare function hasWorkflowHandlers(workflow: WorkflowSnapshot, functions: WorkflowFunctions | undefined): boolean;
+export declare function hasWorkflowHandlers(workflow: WorkflowSnapshot, functions: WorkflowRegistry | undefined): boolean;
 
 /**
- * Insert one `[key, value]` entry at a positional index into a readonly entries array —
+ * Inserts 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.
+ * Used by the shared {@link import('./Collection.js').Collection} store both managers hold: it
+ * converts its insertion-ordered `Map` to `[...map.entries()]`, calls this to splice the new entry
+ * in at the target index, then rebuilds the `Map` from the result (a stateful step that stays a
+ * `#` private method — this helper does no `Map` construction). Does not mutate `entries`;
+ * returns a new array.
  *
  * @typeParam T - The entry's value type
  * @param entries - The current positional entries, in order
@@ -901,56 +1099,269 @@ export declare function hasWorkflowHandlers(workflow: WorkflowSnapshot, function
  */
 export declare function insertEntry<T>(entries: ReadonlyArray<readonly [string, T]>, index: number, key: string, value: T): ReadonlyArray<readonly [string, T]>;
 
-/** Test the workflow lifecycle vocabulary. */
+/**
+ * Tests whether a naturally-finished run may force its workflow `completed`.
+ *
+ * @remarks
+ * A run that walked every phase and still derives `pending` executed nothing — zero phases, or
+ * every phase empty — so it is vacuously done and the run settles it `completed`. Gated on
+ * EXACTLY `pending` so a real `completed`, a `bail: true` `failed`, a `stopped`, or a derived
+ * `skipped` is never overridden. The tree-is-empty half of the rule is
+ * {@link WorkflowInterface.complete}'s own guard, which refuses a pending tree that still holds
+ * tasks.
+ *
+ * @param workflow - The live workflow the run has finished walking
+ * @returns True if the run may force the vacuous completion; false otherwise
+ *
+ * @example
+ * ```ts
+ * isCompletable(createWorkflow({ id: 'w', name: 'W', phases: [] })) // true
+ * ```
+ */
+export declare function isCompletable(workflow: WorkflowInterface): boolean;
+
+/**
+ * Tests whether a driving run must stop giving a workflow more work.
+ *
+ * @remarks
+ * The halt gate a {@link import('./WorkflowRunner.js').WorkflowRunner} consults before starting a
+ * phase, before dispatching a task, and after every cooperative gate. A workflow is halted after
+ * its derived status is terminal but NOT `completed` — a `bail: true` failure, a caller's own
+ * graceful `stop()`, or a forced `skip`. `completed` is excluded deliberately: a workflow that
+ * completed vacuously is settled, not halted, and the distinction is what keeps the run from
+ * sweeping a finished tree. When a `phase` is supplied, its own forced `skipped` / `stopped` halts
+ * that phase's work too; a `failed` phase does not, because the workflow's own `bail` policy
+ * decides whether a failed phase ends the run.
+ *
+ * @param workflow - The live workflow the run is driving
+ * @param phase - The phase whose own forced terminal status also halts its tasks
+ * @returns True if the run must stop giving this workflow (or phase) more work; false otherwise
+ *
+ * @example
+ * ```ts
+ * isHalted(workflow) // false while pending or running
+ * workflow.stop()
+ * isHalted(workflow) // true
+ * ```
+ */
+export declare function isHalted(workflow: WorkflowInterface, phase?: PhaseInterface): boolean;
+
+/**
+ * Checks whether an unknown value belongs to the workflow lifecycle vocabulary.
+ *
+ * @remarks
+ * Reads {@link import('./constants.js').LIFECYCLE_STATUSES}, the runtime array every tier draws
+ * from, so the vocabulary has one definition rather than a hard-coded copy per guard.
+ *
+ * @param value - The value to test
+ * @returns True if `value` is a {@link LifecycleStatus}; false otherwise
+ *
+ * @example
+ * ```ts
+ * isLifecycleStatus('running') // true
+ * isLifecycleStatus('paused') // false
+ * ```
+ */
 export declare function isLifecycleStatus(value: unknown): value is LifecycleStatus;
 
 /**
- * Validate a safe owned JSON graph as a coherent workflow snapshot.
+ * Validates a safe owned JSON graph as a coherent workflow snapshot.
  *
  * @remarks
  * Callers at hostile boundaries use {@link isWorkflowSnapshot}, which owns the
  * graph first so this semantic pass never observes accessors or prototypes.
+ *
+ * @param value - The already-owned JSON graph to validate
+ * @returns True if `value` is a coherent {@link WorkflowSnapshot}; false otherwise
+ *
+ * @example
+ * ```ts
+ * isOwnedWorkflowSnapshot(workflow.snapshot()) // true
+ * ```
  */
 export declare function isOwnedWorkflowSnapshot(value: unknown): value is WorkflowSnapshot;
 
 /**
- * Test whether an unknown value is valid persisted task activity.
+ * Tests whether a task attempt is being genuinely cancelled rather than merely timed out.
+ *
+ * @remarks
+ * The discriminator that keeps a per-attempt deadline off the skip path. Three causes fire a
+ * running task's folded signal, and only two of them mean "skip this task": the task's own
+ * `signal` (its `stop` / `skip`), and the unit or run signal (a sibling fail-fast under
+ * `bail: true`, or a run-level abort / timeout / budget / `destroy`). A bare per-attempt timeout
+ * fires NEITHER — it aborts only the deadline portion of the attempt signal — so it stays a
+ * retryable failure of that attempt instead of skipping the leaf and losing the recorded fault.
+ * Read fresh at each call so a cancel that lands mid-dispatch is seen.
+ *
+ * @param task - The live task the attempt is driving
+ * @param controller - The substrate unit handle carrying the unit-level abort
+ * @param runSignal - The run's folded cancellation signal
+ * @returns True if the attempt is being genuinely cancelled; false otherwise
+ *
+ * @example
+ * ```ts
+ * isSkipping(task, controller, runSignal) // false until a cancel fires
+ * ```
+ */
+export declare function isSkipping(task: TaskInterface, controller: ControllerInterface<TaskInterface, void>, runSignal: AbortSignal): boolean;
+
+/**
+ * Tests whether forcing a workflow `stopped` would still record something.
+ *
+ * @remarks
+ * `stop()` is a no-op after a workflow's status becomes terminal, so a run that must record a
+ * cancellation forces it only while this holds. It is NOT the negation of
+ * {@link isTerminalStatus}: `completed` and `skipped` both pass, because a run-level cancel that
+ * lands on a vacuously-completed or fully-skipped tree still records `stopped` as the outcome the
+ * caller asked for. Only an already-`failed` or already-`stopped` workflow has a terminal state
+ * worth keeping.
+ *
+ * @param workflow - The live workflow a run-level cancel would force
+ * @returns True if forcing `stopped` would change the recorded outcome; false otherwise
+ *
+ * @example
+ * ```ts
+ * isStoppable(workflow) // true while pending, running, completed, or skipped
+ * workflow.stop()
+ * isStoppable(workflow) // false
+ * ```
+ */
+export declare function isStoppable(workflow: WorkflowInterface): boolean;
+
+/**
+ * Tests whether an unknown value is valid persisted task activity.
+ *
+ * @remarks
+ * The persisted counterpart of {@link isTaskActivityInput}: the same frame plus the REQUIRED
+ * `operations`, `constraints`, and a finite non-negative `updated` stamp, because a stored frame
+ * has already been accepted and normalized. Total — a hostile prototype or accessor answers
+ * `false` rather than throwing.
+ *
+ * @param value - The value to test
+ * @returns True if `value` is a persisted {@link TaskActivity}; false otherwise
+ *
+ * @example
+ * ```ts
+ * isTaskActivity({ operations: [], constraints: [], updated: 1 }) // true
+ * ```
  */
 export declare function isTaskActivity(value: unknown): value is TaskActivity;
 
 /**
- * Test whether an unknown value is a valid whole-frame activity report.
+ * Tests whether an unknown value is a valid whole-frame activity report.
+ *
+ * @remarks
+ * The guard behind {@link import('./types.js').TaskInterface.report}: exactly the optional `note`,
+ * `progress`, `operations`, and `constraints` keys, with the two claim lists checked by
+ * {@link isTaskClaimList} and `progress` a finite non-negative value under an optional `total` at
+ * least as large. Total — a hostile prototype or accessor answers `false` rather than throwing.
+ *
+ * @param value - The value to test
+ * @returns True if `value` is a valid {@link TaskActivityInput}; false otherwise
+ *
+ * @example
+ * ```ts
+ * isTaskActivityInput({ note: 'compiling', progress: { progress: 2, total: 5 } }) // true
+ * ```
  */
 export declare function isTaskActivityInput(value: unknown): value is TaskActivityInput;
 
-/** Test a normalized persisted task failure. */
+/**
+ * Checks whether an unknown value is a valid list of task activity claims.
+ *
+ * @remarks
+ * The one guard behind both claim lists of a {@link TaskActivityInput} — its `operations` and its
+ * `constraints` — because {@link import('./types.js').TaskOperation} and
+ * {@link import('./types.js').TaskConstraint} are the same {@link TaskClaim} shape. Every member must be a plain record carrying exactly `id`, `name`, and
+ * `started`, with non-empty string `id` and `name`, a finite non-negative `started`, and an `id`
+ * unique within the list. Total: a hostile prototype, an accessor, or a cycle returns `false`
+ * rather than throwing.
+ *
+ * @param value - The value to test
+ * @returns True if `value` is a list of valid, uniquely identified claims; false otherwise
+ *
+ * @example
+ * ```ts
+ * isTaskClaimList([{ id: 'fetch', name: 'Fetch', started: 1 }]) // true
+ * isTaskClaimList([{ id: 'fetch', name: 'Fetch' }]) // false
+ * ```
+ */
+export declare function isTaskClaimList(value: unknown): value is readonly TaskClaim[];
+
+/**
+ * Tests a normalized persisted task failure.
+ *
+ * @remarks
+ * The exact-record guard behind a persisted {@link TaskFailure}: exactly `origin` and `message`,
+ * an `origin` drawn from the {@link import('./types.js').TaskFailureOrigin} vocabulary, and a
+ * non-empty `message`. Total — a hostile prototype or accessor answers `false` rather than
+ * throwing.
+ *
+ * @param value - The value to test
+ * @returns True if `value` is a persisted {@link TaskFailure}; false otherwise
+ *
+ * @example
+ * ```ts
+ * isTaskFailure({ origin: 'handler', message: 'boom' }) // true
+ * isTaskFailure({ origin: 'handler' }) // false
+ * ```
+ */
 export declare function isTaskFailure(value: unknown): value is TaskFailure;
 
-/** Test a result's lineage against its containing snapshot nodes. */
+/**
+ * Tests a result's lineage against its containing snapshot nodes.
+ *
+ * @remarks
+ * The four arguments are the result and the three snapshot nodes it claims to belong to, read
+ * from the OUTSIDE in: a {@link TaskResult} is self-describing, so restoring one is only safe
+ * when every identity it carries agrees with the tree it was found in. It checks the exact key
+ * set at each level, that `status` equals the owning task's, and that the `task` / `phase` /
+ * `workflow` contexts — including the nested `task.phase.workflow` lineage — carry the same `id`,
+ * `name`, and `description` as the nodes containing them. It then requires the boxed outcome to
+ * match the status: a `Success` holding JSON for `completed`, a `Failure` holding a
+ * {@link TaskFailure} for `failed`, and nothing for any other status. Total — a hostile
+ * prototype, accessor, or cycle answers `false` rather than throwing.
+ *
+ * @param value - The candidate {@link TaskResult}
+ * @param workflow - The workflow snapshot node containing it
+ * @param phase - The phase snapshot node containing it
+ * @param task - The task snapshot node the result belongs to
+ * @returns True if `value` is a {@link TaskResult} whose lineage and outcome match
+ *   those nodes; false otherwise
+ *
+ * @example
+ * ```ts
+ * const snapshot = workflow.snapshot()
+ * const phase = snapshot.phases[0]
+ * const task = phase?.tasks[0]
+ * isTaskResult(task?.result, snapshot, phase, task) // true for a settled task
+ * ```
+ */
 export declare function isTaskResult(value: unknown, workflow: unknown, phase: unknown, task: unknown): value is TaskResult;
 
 /**
- * Test whether a {@link LifecycleStatus} is TERMINAL — a node in this state will not
+ * Tests whether a {@link LifecycleStatus} is TERMINAL — a node in this state will not
  * transition further.
  *
  * @remarks
- * The ONE terminal check across all three tiers (AGENTS §4.4 "one concept = one word"):
+ * The ONE terminal check across every tier (AGENTS.md § Design laws, "one concept, one term"):
  * a task, a phase, and a workflow share the same {@link LifecycleStatus} vocabulary, so a
  * single predicate covers them — {@link derivePhaseStatus} and {@link deriveWorkflowStatus}
- * both consult it to tell a settled node from an in-flight one. Terminal: `completed` /
- * `failed` / `skipped` / `stopped`; the only non-terminal states are `pending` and
- * `running`.
+ * both consult it to tell a settled node from an in-flight one. It reads the terminal set from
+ * {@link import('./constants.js').TERMINAL_STATUSES} (`completed` / `failed` / `skipped` /
+ * `stopped`), so that constant is the one definition; the only non-terminal states are `pending`
+ * and `running`.
  *
  * @param status - The lifecycle status to test (a task / phase / workflow status)
- * @returns `true` when the status is terminal
+ * @returns True if the status is terminal; false otherwise
  */
 export declare function isTerminalStatus(status: LifecycleStatus): boolean;
 
 /**
- * Narrow an unknown caught value to a {@link WorkflowError}.
+ * Narrows an unknown caught value to a {@link WorkflowError}.
  *
  * @param value - The value to test (typically a `catch` binding)
- * @returns `true` when `value` is a {@link WorkflowError}
+ * @returns True if `value` is a {@link WorkflowError}; false otherwise
  *
  * @example
  * ```ts
@@ -963,41 +1374,112 @@ export declare function isTerminalStatus(status: LifecycleStatus): boolean;
  */
 export declare function isWorkflowError(value: unknown): value is WorkflowError;
 
-/** Total hostile-boundary workflow snapshot guard. */
+/**
+ * Checks whether an unknown value is a live workflow entity rather than a definition.
+ *
+ * @remarks
+ * The discriminator behind the overloaded
+ * {@link import('./types.js').WorkflowRunnerInterface.execute}: a
+ * {@link import('./types.js').WorkflowInterface} is the only one of the two carrying `destroyed`
+ * (RUNTIME-ONLY, never a field on the pure-JSON
+ * {@link import('./types.js').WorkflowDefinition}) AND a callable `snapshot`. Requiring both is
+ * sturdier than `destroyed` alone — a definition could coincidentally carry a `destroyed` field as
+ * arbitrary data, and pairing it with a function-typed `snapshot` narrows to the actual entity
+ * shape without an `as`. It reads a live class instance, so it tests object identity rather than a
+ * plain-record brand, and it is total: any other value answers `false`.
+ *
+ * @param value - The value to test
+ * @returns True if `value` is a live {@link WorkflowInterface}; false otherwise
+ *
+ * @example
+ * ```ts
+ * isWorkflowInterface(createWorkflow(definition)) // true
+ * isWorkflowInterface(definition) // false
+ * ```
+ */
+export declare function isWorkflowInterface(value: unknown): value is WorkflowInterface;
+
+/**
+ * Guards the hostile boundary totally for a workflow snapshot.
+ *
+ * @remarks
+ * Owns the value first through the exact-JSON clone of `@orkestrel/contract`, then runs the
+ * semantic pass {@link isOwnedWorkflowSnapshot} over the owned copy — so no accessor, prototype,
+ * or cycle in the caller's graph is ever observed by the semantic pass. Total: an unclonable
+ * value answers `false` rather than throwing.
+ *
+ * @param value - The untrusted value to test
+ * @returns True if `value` is a coherent {@link WorkflowSnapshot}; false otherwise
+ *
+ * @example
+ * ```ts
+ * isWorkflowSnapshot(JSON.parse(payload)) // true only for a coherent snapshot
+ * ```
+ */
 export declare function isWorkflowSnapshot(value: unknown): value is WorkflowSnapshot;
 
 /**
- * The shared lifecycle vocabulary every tier draws from — `pending` before it runs,
+ * Lists every {@link LifecycleStatus} value, frozen — the vocabulary every tier draws from.
+ *
+ * @remarks
+ * Ordered pending → running → terminal (`completed` / `failed` / `skipped` /
+ * `stopped`). The runtime source of truth for the union:
+ * {@link import('./validators.js').isLifecycleStatus} reads this array.
+ */
+export declare const LIFECYCLE_STATUSES: readonly LifecycleStatus[];
+
+/**
+ * Names the shared lifecycle vocabulary every tier draws from — `pending` before it runs,
  * `running` while in flight, then one of the terminal states `completed` / `failed` /
  * `skipped` / `stopped`.
  *
  * @remarks
- * The ONE literal set behind the three semantic tiers ({@link TaskStatus} /
- * {@link PhaseStatus} / {@link WorkflowStatus}), which alias it so each keeps its own
- * name + doc while the vocabulary lives in one place (AGENTS §4.4 "one concept = one
- * word"). It also types the single runtime terminal check
- * {@link import('./helpers.js').isTerminalStatus} — every tier's value is a
- * `LifecycleStatus`, so the one predicate accepts them all. The three tiers are direct
- * aliases, not branded types, so TypeScript accepts any one of them wherever another is
- * expected. Each name documents which tier a value came from; it does not enforce it.
+ * The ONE literal set the workflow, phase, and task tiers all draw from, so the vocabulary
+ * lives in one place and a signature reading `LifecycleStatus` means the same thing at
+ * every tier. Each member's tier-specific meaning belongs to the member that declares it:
+ * `skipped` is "deliberately not run" and `stopped` is "ended early", and the terminal
+ * members for which a {@link TaskResult} is meaningful are exactly `completed` and
+ * `failed`, which box a {@link Result}, while `skipped` and `stopped` settle without a
+ * boxed outcome. It also types the single runtime terminal check
+ * {@link import('./helpers.js').isTerminalStatus}, which therefore accepts a value from
+ * any tier.
  */
 export declare type LifecycleStatus = 'pending' | 'running' | 'completed' | 'failed' | 'skipped' | 'stopped';
 
-/** Compare two optional description values. */
+/**
+ * Compares two optional description values.
+ *
+ * @remarks
+ * The equality rule a lineage check needs: two descriptions match when they are the same value
+ * AND that value is either a string or genuine absence. Anything else — a number, an object, a
+ * `null` — never matches, even against itself, so a lineage stamped with a non-string description
+ * is rejected rather than silently accepted.
+ *
+ * @param left - The first description value
+ * @param right - The second description value
+ * @returns True if both are the same string or both absent; false otherwise
+ *
+ * @example
+ * ```ts
+ * matchesDescription('build', 'build') // true
+ * matchesDescription(undefined, undefined) // true
+ * matchesDescription('build', undefined) // false
+ * ```
+ */
 export declare function matchesDescription(left: unknown, right: unknown): boolean;
 
 /**
- * The largest delay representable by the host timer APIs without overflow or clamping.
+ * Names the largest delay representable by the host timer APIs without overflow or clamping.
  */
 export declare const MAX_TIMER_MS = 2147483647;
 
 /**
- * The in-memory {@link WorkflowStoreInterface} — a process-lifetime `Map` of
+ * Implements the in-memory {@link WorkflowStoreInterface} — a process-lifetime `Map` of
  * {@link WorkflowSnapshot}s keyed by workflow id, the DEFAULT store
  * {@link import('../factories.js').createMemoryWorkflowStore} builds.
  *
  * @remarks
- * A plain `Map<string, WorkflowSnapshot>` (AGENTS §21 — the snapshot is already pure,
+ * A plain `Map<string, WorkflowSnapshot>` (the snapshot is already pure,
  * self-contained JSON, so no encoding is needed for the memory tier). UNLIKE the server
  * package's `SessionStoreInterface`'s memory store there is
  * NO idle-TTL and NO eviction: a persisted workflow run-state is durable orchestration state
@@ -1013,7 +1495,7 @@ export declare const MAX_TIMER_MS = 2147483647;
  * - **`set` inserts / replaces under the snapshot's OWN `id`** (no separate id param).
  * - **`delete` drops a snapshot by id**; an absent id is a no-op (no throw).
  *
- * The public surface is EXACTLY `get` / `set` / `delete` — no extra members (the §22 method
+ * The public surface is EXACTLY `get` / `set` / `delete` — no extra members (the guide's method
  * bijection with {@link WorkflowStoreInterface}). Restore is a caller concern: read a snapshot
  * back and rebuild the live tree with {@link import('../factories.js').createRestoredWorkflow}.
  *
@@ -1037,16 +1519,17 @@ export declare class MemoryWorkflowStore implements WorkflowStoreInterface {
 }
 
 /**
- * Reposition the entry keyed `key` to a new positional index in a readonly entries
+ * Repositions 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.
+ * of `entries` unchanged) — the caller, the shared
+ * {@link import('./Collection.js').Collection} store's `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
@@ -1062,7 +1545,31 @@ export declare class MemoryWorkflowStore implements WorkflowStoreInterface {
 export declare function moveEntry<T>(entries: ReadonlyArray<readonly [string, T]>, key: string, index: number): ReadonlyArray<readonly [string, T]>;
 
 /**
- * Park until `signal` aborts — a promise-parked wait (AGENTS §21), never a timer or
+ * Tests whether one attempt still owns the task it launched.
+ *
+ * @remarks
+ * A retried task is re-dispatched while an earlier attempt's handler may still be resolving, so
+ * every settlement path re-checks ownership before touching the leaf. Ownership needs BOTH
+ * halves: the run-local `owners` ledger must still name this attempt, and the live task's own
+ * `attempts` tally must still match it. A superseded attempt reads `false` and returns without
+ * recording anything, so a late resolution can never overwrite the newer attempt's outcome.
+ *
+ * @param owners - The run-local ledger of the attempt owning each task id
+ * @param task - The live task the attempt launched
+ * @param attempt - The one-based attempt number to test
+ * @returns True if `attempt` still owns `task`; false otherwise
+ *
+ * @example
+ * ```ts
+ * const owners = new Map([[task.id, 1]])
+ * ownsAttempt(owners, task, 1) // true while the task's own `attempts` is 1
+ * ownsAttempt(owners, task, 2) // false
+ * ```
+ */
+export declare function ownsAttempt(owners: Map<string, number>, task: TaskInterface, attempt: number): boolean;
+
+/**
+ * Parks until `signal` aborts — a promise-parked wait, never a timer or
  * busy-loop, that NEVER rejects.
  *
  * @remarks
@@ -1072,7 +1579,7 @@ export declare function moveEntry<T>(entries: ReadonlyArray<readonly [string, T]
  * at every fold point.
  *
  * @param signal - The signal to park on
- * @returns A promise that resolves once `signal` has aborted
+ * @returns A promise that resolves after `signal` has aborted
  *
  * @example
  * ```ts
@@ -1085,94 +1592,32 @@ export declare function moveEntry<T>(entries: ReadonlyArray<readonly [string, T]
 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
- * reactively as a task transitions (the middle tier of the cascade).
+ * Lists the {@link WorkflowEventMap} / {@link PhaseEventMap} events that make a durable observer
+ * re-persist the live tree, frozen.
  *
  * @remarks
- * - **Derived status.** `status` is `#override` when one is in force, else
- *   {@link derivePhaseStatus} over the live tasks' statuses. `#recompute` (passed to
- *   each child {@link Task}) re-derives on every child transition; a CHANGE emits the matching
- *   event AND escalates to the workflow (`#escalate`, the upward step of the cascade).
- * - **Override (AGENTS §10).** `skip` / `stop` FORCE the phase's status (e.g. skipping a whole
- *   phase), overriding the derived value; the override is PERSISTED in the snapshot's own
- *   `override` field and restored DIRECTLY (no divergence guess), so a forced phase round-trips.
- * - **Children (AGENTS §9).** `tasks` is the lean {@link TaskManager} (an accessor + `count`,
- *   no batch matrix); built positionally from the snapshot so order survives an interior `skip`.
- *   `results()` collects the settled tasks' {@link TaskResult}s (the phase tier of the result
- *   tree); `workflow` navigates UP to the live parent.
- * - **Observable (AGENTS §13).** The owned {@link emitter} ({@link PhaseEventMap}) fires
- *   `start` / `complete` / `fail` / `pause` / `resume` / `skip` / `stop` after the
- *   corresponding status or runtime-gate change. Status events fire after the phase recomputes
- *   and before it escalates to the workflow, preserving child/phase cause before parent effect.
- *   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 every unique initial `run`
- *   name ONCE before any task is built; siblings sharing a name receive the exact same captured
- *   runtime {@link import('../types.js').TaskInterface.handler}. A later live {@link add} reads
- *   that name once from the retained registry at its own mint moment. An omitted or unregistered
- *   `run` resolves to no handler; only omission is a no-op, while an unresolved present name makes
- *   the containing tree non-drivable.
- * - **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;
-    readonly description?: string;
-    constructor(snapshot: PhaseSnapshot, workflow: WorkflowInterface, escalate: () => void, options?: PhaseOptions, bail?: boolean, functions?: WorkflowFunctions, silence?: number);
-    get emitter(): EmitterInterface<PhaseEventMap>;
-    get id(): string;
-    get name(): string;
-    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;
-}
+ * The two maps carry the same event names, so one list serves both tiers. It is the source of
+ * truth behind {@link import('./WorkflowPersistence.js').WorkflowPersistence}'s attach and detach
+ * passes: subscribing and unsubscribing loop over these names, so an added event reaches both
+ * passes from one edit. `add` and `remove` are deliberately absent — they carry the new or dropped
+ * child, so the persistence layer binds its own attaching handler to them instead.
+ */
+export declare const PERSISTED_NODE_EVENTS: ReadonlyArray<keyof WorkflowEventMap & keyof PhaseEventMap>;
 
-/** Every {@link PhaseStatus} value, frozen — the lifecycle vocabulary of a phase. */
-export declare const PHASE_STATUSES: readonly PhaseStatus[];
+/**
+ * Lists the {@link TaskEventMap} events that make a durable observer re-persist the live tree, frozen.
+ *
+ * @remarks
+ * The leaf counterpart of {@link PERSISTED_NODE_EVENTS}, and the source of truth behind the task
+ * attach and detach passes of
+ * {@link import('./WorkflowPersistence.js').WorkflowPersistence}. `report` and `pulse` join the
+ * lifecycle events because an accepted activity frame changes the persisted snapshot; a leaf has
+ * no children, so there is no structural event to bind separately.
+ */
+export declare const PERSISTED_TASK_EVENTS: ReadonlyArray<keyof TaskEventMap>;
 
 /**
- * The ambient context of a phase — its own identity plus a back-reference to the
+ * Represents the ambient context of a phase — its own identity plus a back-reference to the
  * workflow it belongs to.
  *
  * @remarks
@@ -1184,7 +1629,7 @@ export declare interface PhaseContext extends WorkflowContext {
 }
 
 /**
- * The serializable definition of one phase — its identity, its ordered tasks, and
+ * Represents the serializable definition of one phase — its identity, its ordered tasks, and
  * an optional resource throttle.
  *
  * @remarks
@@ -1199,11 +1644,13 @@ export declare interface PhaseDefinition {
     readonly name: string;
     readonly description?: string;
     readonly tasks: readonly TaskDefinition[];
-    /** Max tasks in flight at once (a resource throttle); omitted ⇒ unbounded. */
+    /** Caps the tasks in flight at once (a resource throttle); omitted ⇒ unbounded. */
     readonly concurrency?: number;
     /**
+     * Sets the phase's failure policy.
+     *
      * @remarks
-     * The per-phase failure-policy OVERRIDE (AGENTS §4.4). Omitted ⇒ the phase INHERITS the
+     * The per-phase failure-policy OVERRIDE. Omitted ⇒ the phase INHERITS the
      * workflow `bail`; supplied, it wins (`effectiveBail = phase.bail ?? workflow.bail`). A
      * `bail: true` phase HALTS the run on its first task failure even under a graceful workflow
      * default; a `bail: false` phase does NOT halt even under a strict workflow default.
@@ -1212,7 +1659,7 @@ export declare interface PhaseDefinition {
 }
 
 /**
- * Convert one {@link import('./types.js').PhaseDefinition} into an initial, all-`pending`
+ * Converts one {@link import('./types.js').PhaseDefinition} into an initial, all-`pending`
  * {@link PhaseSnapshot} — the per-phase step of {@link definitionToSnapshot}.
  *
  * @remarks
@@ -1228,11 +1675,12 @@ export declare interface PhaseDefinition {
 export declare function phaseDefinitionToSnapshot(phase: WorkflowDefinition['phases'][number], workflowBail: boolean): PhaseSnapshot;
 
 /**
- * One phase's contribution to the workflow-status derivation — its {@link PhaseStatus} paired
- * with the EFFECTIVE `bail` policy it ran under (`phase.bail ?? workflow.bail`, AGENTS §4.4).
+ * Represents one phase's contribution to the workflow-status derivation — its
+ * {@link LifecycleStatus} paired with the EFFECTIVE `bail` policy it ran under
+ * (`phase.bail ?? workflow.bail`).
  *
  * @remarks
- * The input shape of {@link import('./helpers.js').deriveWorkflowStatus}: since `bail` is now a
+ * The input shape of {@link import('./helpers.js').deriveWorkflowStatus}: because `bail` is a
  * per-phase override, the workflow `failed` derivation is per-phase-bail-aware, so each phase
  * must carry its OWN effective policy rather than the derivation taking one scalar `bail`. A
  * `failed` phase propagates `failed` to the workflow only when ITS `bail` is `true`; a `failed`
@@ -1240,12 +1688,13 @@ export declare function phaseDefinitionToSnapshot(phase: WorkflowDefinition['pha
  * builds one per live phase (`{ status: phase.status, bail: phase.bail }`).
  */
 export declare interface PhaseDerivation {
-    readonly status: PhaseStatus;
+    /** Holds the phase's derived lifecycle status. */
+    readonly status: LifecycleStatus;
     readonly bail: boolean;
 }
 
 /**
- * The push observation surface (AGENTS §13) of the phase entity (W-b) — analogous
+ * Declares the push observation surface of the phase entity (W-b) — analogous
  * to {@link WorkflowEventMap}, scoped to one phase.
  *
  * @remarks
@@ -1255,63 +1704,59 @@ export declare interface PhaseDerivation {
  * `skip` when the phase was intentionally skipped; `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
+ * {@link PhaseInterface.add} / `remove` / `move` / `update` — 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`.
+ * `error` handler, not the domain surface. A `type` alias so it satisfies `EventMap`.
  */
 export declare type PhaseEventMap = {
-    /** The phase began — its `id`. */
+    /** Signals that the phase began — its `id`. */
     readonly start: readonly [id: string];
-    /** Every task in the phase settled successfully. */
+    /** Signals that every task in the phase settled successfully. */
     readonly complete: readonly [];
-    /** A task failed under `bail` — the failing task's result. */
+    /** Signals that a task failed under `bail` — the failing task's result. */
     readonly fail: readonly [result: TaskResult];
-    /** The phase's runtime gate closed. */
+    /** Signals that the phase's runtime gate closed. */
     readonly pause: readonly [];
-    /** The phase's runtime gate opened. */
+    /** Signals that the phase's runtime gate opened. */
     readonly resume: readonly [];
-    /** The phase was intentionally skipped. */
+    /** Signals that the phase was intentionally skipped. */
     readonly skip: readonly [];
-    /** The phase was permanently stopped. */
+    /** Signals that the phase was permanently stopped. */
     readonly stop: readonly [];
-    /** A task was inserted — the inserted task + its final index. */
+    /** Signals that a task was inserted — the inserted task + its final index. */
     readonly add: readonly [task: TaskInterface, index: number];
-    /** A task was removed — the removed task. */
+    /** Signals that a task was removed — the removed task. */
     readonly remove: readonly [task: TaskInterface];
-    /** A task was repositioned — the moved task + its new index. */
+    /** Signals that a task was repositioned — the moved task + its new index. */
     readonly move: readonly [task: TaskInterface, index: number];
-    /** A task was patched — the patched task. */
+    /** Signals that a task was patched — the patched task. */
     readonly update: readonly [task: TaskInterface];
 };
 
-/** Initial {@link PhaseEventMap} listeners — the reserved `on` option (AGENTS §8). */
-export declare type PhaseHooks = EmitterHooks<PhaseEventMap>;
-
-/** The minimal data to create a phase context — a partial {@link PhaseContext}. */
+/** Represents the minimal data to create a phase context — a partial {@link PhaseContext}. */
 export declare type PhaseInput = Partial<PhaseContext>;
 
 /**
- * The live derived state machine (W-b) for one {@link PhaseDefinition} — an
- * observable (AGENTS §13) phase whose {@link PhaseStatus} is DERIVED from its tasks
+ * Declares the live derived state machine (W-b) for one {@link PhaseDefinition} — an
+ * observable phase whose {@link LifecycleStatus} is DERIVED from its tasks
  * (never set directly) and recomputed reactively as a task transitions (the cascade).
  *
  * @remarks
- * - **Derived status.** `status` is computed via
+ * - **Derived status.** `status` is computed through
  *   {@link import('./helpers.js').derivePhaseStatus} over the live tasks' statuses,
  *   UNLESS an override is in force. It recomputes whenever a child task transitions; a
  *   CHANGE emits.
- * - **Children.** `tasks` is the lean {@link TaskManagerInterface} (AGENTS §9 — an
+ * - **Children.** `tasks` is the lean {@link TaskManagerInterface} (an
  *   accessor + `count`, no batch matrix); `task(id)` / `tasks().tasks()` read in positional
  *   order. `results` collects the settled tasks' {@link TaskResult}s (the phase tier of the
  *   result tree); `workflow` navigates UP to the live parent.
- * - **Override.** `skip` / `stop` (AGENTS §10) FORCE the phase's status, overriding the
- *   derived value (e.g. skipping a whole phase); the override survives a snapshot.
- * - **Observable (AGENTS §13).** The owned {@link emitter} ({@link PhaseEventMap}) fires
+ * - **Override.** `skip` / `stop` FORCE the phase's status, overriding the
+ *   derived value (for example, skipping a whole phase); the override survives a snapshot.
+ * - **Observable.** The owned {@link emitter} ({@link PhaseEventMap}) fires
  *   `start` / `complete` / `fail` / `pause` / `resume` / `stop` after the corresponding
  *   status or runtime-gate 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
+ * - **Runtime lifecycle.** `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;
@@ -1322,49 +1767,51 @@ export declare interface PhaseInterface {
     readonly emitter: EmitterInterface<PhaseEventMap>;
     readonly id: string;
     readonly name: string;
-    readonly description?: string;
+    /** Holds this phase's prose, or `undefined` when the definition or snapshot declared none. */
+    readonly description: string | undefined;
     readonly context: PhaseContext;
     readonly workflow: WorkflowInterface;
-    readonly status: PhaseStatus;
-    /** The RESOLVED effective failure policy this phase runs under (`phase.bail ?? workflow.bail`); mirrors {@link WorkflowInterface.bail}. */
+    /** Holds this phase's effective lifecycle status, derived from its tasks unless an override is in force. */
+    readonly status: LifecycleStatus;
+    /** Reports 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. */
+    /** Caps the 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
+     * Reports whether the phase is paused (resumable); RUNTIME-ONLY — never a
+     * {@link LifecycleStatus}, 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`. */
+    /** Looks 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. */
+    /** Lists 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.
+     * Forces this phase to `skipped`, overriding the derived value; idempotent.
      *
      * @remarks
-     * A NO-OP once `status` is already terminal — a settled phase cannot be re-forced. Always
+     * A NO-OP after `status` becomes 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.
+     * Forces this phase to `stopped`, overriding the derived value; idempotent.
      *
      * @remarks
-     * A NO-OP once `status` is already terminal (a settled phase cannot be re-forced). Always
+     * A NO-OP after `status` becomes 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.
+     * Suspends the phase (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
+     * A no-op when already `paused` or when `status` is terminal. RUNTIME-ONLY —
+     * never a {@link LifecycleStatus}, 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
@@ -1378,7 +1825,7 @@ export declare interface PhaseInterface {
      */
     pause(): void;
     /**
-     * Continue a paused phase (AGENTS §10); idempotent — a no-op unless {@link paused}.
+     * Continues a paused phase; idempotent — a no-op unless {@link paused}.
      *
      * @example
      * ```ts
@@ -1388,25 +1835,25 @@ export declare interface PhaseInterface {
      */
     resume(): void;
     /**
-     * Park until this phase is not paused — **promise-parked**, never a timer or busy-loop
-     * (AGENTS §21; mirrors {@link WorkflowInterface.wait}).
+     * Parks until this phase is not paused — **promise-parked**, never a timer or busy-loop
+     * (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
+     * @returns A promise that resolves after 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}'
+     * Mints a live {@link TaskInterface} from `definition` and inserts it into this phase
+     * (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` /
+     * THIS phase, its recompute cascade, and its emitter hooks), carrying its `behavior` /
      * `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.
@@ -1414,20 +1861,20 @@ export declare interface PhaseInterface {
      * 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
+     * NATIVE gating, purely from this phase's own derived `status` (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}).
+     * model keeps this phase from reaching a terminal status while the accepted task is
+     * still `pending` (its status feeds `status` through {@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
+     * `skip`s it like any other not-yet-started task. Acceptance here means only that the task
      * is WIRED into the live tree, not that it will execute.
      *
      * @param definition - The {@link TaskDefinition} to mint a live task from
@@ -1436,7 +1883,7 @@ export declare interface PhaseInterface {
      */
     add(definition: TaskDefinition, index?: number): Result<TaskInterface, WorkflowError>;
     /**
-     * Remove the `pending` task `id` from this phase.
+     * Removes the `pending` task `id` from this phase.
      *
      * @remarks
      * NATIVE gating: allowed only while this phase's own `status` is `pending`. While
@@ -1449,7 +1896,7 @@ export declare interface PhaseInterface {
      */
     remove(id: string): Result<TaskInterface, WorkflowError>;
     /**
-     * Reposition the `pending` task `id` to `index` within this phase.
+     * Repositions the `pending` task `id` to `index` within this phase.
      *
      * @remarks
      * NATIVE gating: allowed only while this phase's own `status` is `pending`; `running` /
@@ -1461,7 +1908,7 @@ export declare interface PhaseInterface {
      */
     move(id: string, index: number): Result<TaskInterface, WorkflowError>;
     /**
-     * Apply a validated {@link TaskUpdate} patch to the `pending` task `id` in this phase.
+     * Applies 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` /
@@ -1473,11 +1920,11 @@ export declare interface PhaseInterface {
      */
     update(id: string, patch: TaskUpdate): Result<TaskInterface, WorkflowError>;
     /**
-     * Apply a validated declarative patch to SELF (`name` / `description` /
+     * Applies a validated declarative patch to SELF (`name` / `description` /
      * `concurrency` / `bail`).
      *
      * @remarks
-     * Defense-in-depth (AGENTS §12): the owning {@link WorkflowInterface.update} gates
+     * Defense-in-depth: 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`.
@@ -1493,24 +1940,28 @@ export declare interface PhaseInterface {
 }
 
 /**
- * The lean child manager (AGENTS §9) of a {@link import('../Workflow.js').Workflow}'s
- * live phases — an insertion-ordered registry keyed by phase `id`, the phase analogue
+ * Implements the lean child manager of a {@link import('../Workflow.js').Workflow}'s live
+ * phases — the phase vocabulary over one insertion-ordered {@link Collection}, the phase analogue
  * of {@link import('../tasks/TaskManager.js').TaskManager}.
  *
  * @remarks
- * - **Positional store.** Phases live in an insertion-ordered `Map` keyed by `id`;
- *   `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
- *   their own emitters.
+ * - **One shared store.** The insertion-ordered `Map`, the reorder step, the bounds checks, and
+ *   the gated `add` / `remove` / `move` / `update` all live in {@link Collection}, built with the
+ *   `phase` noun its refusals name and the compiled {@link phaseUpdateShape} guard. This class
+ *   adds the domain accessors `phase` / `phases` and nothing else.
+ * - **Positional store.** `append` adds one live {@link PhaseInterface} at the end, `phase(id)`
+ *   looks one up, `phases()` lists them in positional order, `count` is the tally. A snapshot
+ *   RESTORE re-`append`s in the snapshot's order, reproducing it exactly.
+ * - **Gated mutation API.** `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 the batch verbs of
+ *   `.claude/rules/patterns.md` § Batch operations are
+ *   deliberately omitted.
+ * - **Event-free.** A purely structural container — the live {@link PhaseInterface}s own their own
+ *   emitters.
  *
  * @example
  * ```ts
@@ -1533,13 +1984,13 @@ export declare class PhaseManager implements PhaseManagerInterface {
 }
 
 /**
- * The lean child manager (AGENTS §9) of a {@link WorkflowInterface}'s live phases —
+ * Declares the lean child manager of a {@link WorkflowInterface}'s live phases —
  * positional accessors plus `count`, the phase analogue of {@link TaskManagerInterface}.
  *
  * @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
+ * `add` / `remove` / `move` / `update` 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
@@ -1548,18 +1999,18 @@ export declare class PhaseManager implements PhaseManagerInterface {
 export declare interface PhaseManagerInterface {
     readonly count: number;
     /**
-     * Add `phase` at the end (the build-time wiring path).
+     * Adds `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
+     * `id` (a genuine programmer error — a build-time wiring bug) 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
+     * Inserts `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.
      *
@@ -1569,7 +2020,7 @@ export declare interface PhaseManagerInterface {
      */
     add(phase: PhaseInterface, index?: number): Result<PhaseInterface, WorkflowError>;
     /**
-     * Remove the `pending` phase `id`.
+     * Removes the `pending` phase `id`.
      *
      * @param id - The phase id to remove
      * @returns A {@link Result} boxing the removed phase, or a `MUTATION` failure when
@@ -1577,7 +2028,7 @@ export declare interface PhaseManagerInterface {
      */
     remove(id: string): Result<PhaseInterface, WorkflowError>;
     /**
-     * Reposition the `pending` phase `id` to `index`.
+     * Repositions the `pending` phase `id` to `index`.
      *
      * @param id - The phase id to move
      * @param index - The destination position (`[0, count)`)
@@ -1586,7 +2037,7 @@ export declare interface PhaseManagerInterface {
      */
     move(id: string, index: number): Result<PhaseInterface, WorkflowError>;
     /**
-     * Apply a validated {@link PhaseUpdate} patch to the `pending` phase `id`.
+     * Applies a validated {@link PhaseUpdate} patch to the `pending` phase `id`.
      *
      * @param id - The phase id to patch
      * @param patch - The fields to update
@@ -1599,25 +2050,25 @@ export declare interface PhaseManagerInterface {
 }
 
 /**
- * The runtime options for a {@link PhaseInterface} — the construction bag the live
+ * Declares the runtime options for a {@link PhaseInterface} — the construction bag the live
  * derived phase state machine (W-b) carries.
  *
  * @remarks
- * The reserved `on` (AGENTS §8) wires initial {@link PhaseEventMap} listeners.
+ * The reserved `on` wires initial {@link PhaseEventMap} listeners.
  * `tasks` keys per-task {@link TaskOptions} by task `id`, so {@link createWorkflow}
  * can thread a leaf's options (its `on` / `metadata`) down through the phase when it
  * builds the whole tree.
  */
 export declare interface PhaseOptions {
-    readonly on?: PhaseHooks;
-    /** The emitter's listener-error handler (AGENTS §13) — a listener throw routes here, not to a domain event. */
+    readonly on?: EmitterHooks<PhaseEventMap>;
+    /** Holds the emitter's listener-error handler — a listener throw routes here, not to a domain event. */
     readonly error?: EmitterErrorHandler;
-    /** Per-task {@link TaskOptions}, keyed by the task's `id`. */
+    /** Holds the per-task {@link TaskOptions}, keyed by the task's `id`. */
     readonly tasks?: Readonly<Record<string, TaskOptions>>;
 }
 
 /**
- * The shape of a {@link import('./types.js').PhaseDefinition} — identity, its ordered
+ * Describes the shape of a {@link import('./types.js').PhaseDefinition} — identity, its ordered
  * {@link taskShape} tasks, and an optional positive-integer `concurrency` throttle
  * (max tasks in flight; omitted ⇒ unbounded).
  */
@@ -1629,7 +2080,7 @@ export declare const phaseShape: ObjectShape<{
         id: StringShape;
         name: StringShape;
         description: OptionalShape<StringShape>;
-        run: OptionalShape<StringShape>;
+        behavior: OptionalShape<StringShape>;
         retries: OptionalShape<NumberShape>;
         timeout: OptionalShape<NumberShape>;
     }, false>>;
@@ -1638,12 +2089,12 @@ export declare const phaseShape: ObjectShape<{
 }, false>;
 
 /**
- * A JSON-serializable snapshot of one phase's state — its identity, status, its forced
+ * Represents a JSON-serializable snapshot of one phase's state — its identity, status, its forced
  * override (if any), and its nested task snapshots.
  *
  * @remarks
  * Pure JSON DATA. `status` is the EFFECTIVE status (override-or-derived) at snapshot time.
- * `override` is the forced status of a whole-phase `skip` / `stop` (AGENTS §10) — PRESENT only
+ * `override` is the forced status of a whole-phase `skip` / `stop` — PRESENT only
  * when one is in force, so a restore reinstates it DIRECTLY (no fragile derivation comparison)
  * and a genuinely-derived phase carries none. A leaf {@link TaskSnapshot} needs no `override`
  * field — a task's terminal status IS its forced marker. `tasks` are the phase's
@@ -1653,17 +2104,18 @@ export declare interface PhaseSnapshot {
     readonly id: string;
     readonly name: string;
     readonly description?: string;
-    readonly status: PhaseStatus;
-    /** The forced status of a whole-phase `skip` / `stop`; present only when an override is in force. */
-    readonly override?: PhaseStatus;
+    /** Holds the phase's persisted effective lifecycle status (override-or-derived). */
+    readonly status: LifecycleStatus;
+    /** Records the forced status of a whole-phase `skip` / `stop`; present only when an override is in force. */
+    readonly override?: LifecycleStatus;
     /**
-     * The EFFECTIVE failure policy this phase ran under (`phase.bail ?? workflow.bail`, AGENTS §4.4)
+     * Records the EFFECTIVE failure policy this phase ran under (`phase.bail ?? workflow.bail`)
      * — persisted (REQUIRED, like {@link WorkflowSnapshot.bail}) so a restore reinstates the same
      * 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
+     * Caps the 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.
      */
@@ -1672,21 +2124,9 @@ export declare interface PhaseSnapshot {
 }
 
 /**
- * The lifecycle status of a phase — the same vocabulary as {@link TaskStatus},
- * derived from its tasks' statuses.
- *
- * @remarks
- * A semantic tier of the shared {@link LifecycleStatus} vocabulary. A failed task makes
- * its phase `failed` regardless of policy; the phase's effective `bail` determines whether
- * that failure propagates to the workflow or is retained as graceful result data. `stopped`
- * propagates when every task was stopped. See {@link import('./helpers.js').derivePhaseStatus}.
- */
-export declare type PhaseStatus = LifecycleStatus;
-
-/**
- * A declarative partial update to a {@link PhaseInterface} — the fields a `pending`
+ * Represents 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}.
+ * accept, runtime-validated through {@link import('./shapers.js').phaseUpdateShape}.
  *
  * @remarks
  * Mirrors the identity + throttle/policy fields of {@link PhaseDefinition} (`name` /
@@ -1707,13 +2147,13 @@ export declare interface PhaseUpdate {
 }
 
 /**
- * The shape of a {@link import('./types.js').PhaseUpdate} — a partial edit to a
+ * Describes 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).
+ * `move`, not a patch).
  */
 export declare const phaseUpdateShape: ObjectShape<{
     name: OptionalShape<StringShape>;
@@ -1723,7 +2163,7 @@ export declare const phaseUpdateShape: ObjectShape<{
 }, false>;
 
 /**
- * Convert interrupted running work into a recoverable pending suffix or an
+ * Converts interrupted running work into a recoverable pending suffix or an
  * exhausted recovery failure without replenishing attempts.
  *
  * @param snapshot - A fully validated owned snapshot with no terminal overrides
@@ -1732,7 +2172,7 @@ export declare const phaseUpdateShape: ObjectShape<{
 export declare function recoverWorkflowSnapshot(snapshot: WorkflowSnapshot): WorkflowSnapshot;
 
 /**
- * Resolve a task's runtime silence window against its workflow default.
+ * Resolves a task's runtime silence window against its workflow default.
  *
  * @param value - The task-level override; any present non-positive or non-finite value disables
  * @param fallback - The workflow-level default
@@ -1741,7 +2181,67 @@ export declare function recoverWorkflowSnapshot(snapshot: WorkflowSnapshot): Wor
 export declare function resolveTaskSilence(value: number | undefined, fallback: number | undefined): number | undefined;
 
 /**
- * A thin generic orchestrator that drives declared units — and any they `spawn` —
+ * Holds the active phase {@link RunnerInterface} for one
+ * {@link import('./types.js').WorkflowRunnerInterface.execute} call, for the lifetime of that run.
+ *
+ * @remarks
+ * - **One holder per run.** The engine mints a holder as a run begins and threads that one
+ *   instance through every phase of the run, so a nested `execute` reached through application
+ *   composition gets its own holder and can never clobber the suspended outer run's.
+ * - **`hold` is the only mutation.** A phase takes the substrate runner with `hold(runner)` as it
+ *   starts and releases it with `hold()` as it settles; `runner` reads the held value back and is
+ *   `undefined` between phases and after the last one.
+ * - **A cancel closes over the holder.** The run-level abort listener reads `runner` when it
+ *   fires, so it reaches whichever phase runner is live at that moment rather than the one that
+ *   was live when the listener was armed.
+ * - **Event-free.** A plain cell — no emitter, no lifecycle of its own.
+ */
+export declare class RunHolder implements RunHolderInterface {
+    #private;
+    get runner(): RunnerInterface<TaskInterface, void> | undefined;
+    /**
+     * Takes the phase runner a starting phase hands this run, or releases the held one.
+     *
+     * @param runner - The phase runner to hold; omitted releases the held runner
+     * @example
+     * ```ts
+     * import type { TaskInterface } from '@orkestrel/workflow'
+     * import { createRunner, RunHolder } from '@orkestrel/workflow'
+     *
+     * const holder = new RunHolder()
+     * holder.hold(createRunner<TaskInterface, void>({ handler: () => undefined }))
+     * holder.hold() // released — `runner` reads `undefined` again
+     * ```
+     */
+    hold(runner?: RunnerInterface<TaskInterface, void>): void;
+}
+
+/**
+ * Holds the phase {@link RunnerInterface} one {@link WorkflowRunnerInterface.execute} call is
+ * driving, for the lifetime of that run.
+ *
+ * @remarks
+ * Phases run sequentially, so one run drives at most one phase runner at a time: `hold(runner)`
+ * takes the runner as a phase starts and `hold()` releases it as that phase settles, leaving
+ * `runner` `undefined` between phases and after the last one. `runner` is a readonly projection
+ * of the held state, so the swap goes through `hold` alone. A run-level cancel closes over the
+ * holder rather than over a runner, so it aborts whichever phase runner is live when the cancel
+ * fires rather than the one that was live when the listener was armed, and a fresh holder per
+ * `execute` keeps a nested run from clobbering the suspended outer run's.
+ */
+export declare interface RunHolderInterface {
+    /** Reports the phase runner this cell holds, or `undefined` between phases. */
+    readonly runner: RunnerInterface<TaskInterface, void> | undefined;
+    /**
+     * Takes a phase runner for the phase that is starting, or releases the held one.
+     *
+     * @param runner - The phase runner to hold; omitted releases the held runner
+     */
+    hold(runner?: RunnerInterface<TaskInterface, void>): void;
+}
+
+/**
+ * Implements a thin generic orchestrator that drives declared units — and any they `spawn` —
  * through a bounded-concurrency {@link createQueue}, collecting ordered results.
  *
  * @remarks
@@ -1755,12 +2255,12 @@ export declare function resolveTaskSilence(value: number | undefined, fallback:
  *   Results are read back as `#order.map(id => #values.get(id))` — declared first (in
  *   input order), then spawns (in spawn order). There is no one-time task snapshot,
  *   so a unit spawned mid-handler is run and ordered like any other.
- * - **`execute` awaits the full spawn closure via a count gate.** `#launch` increments
+ * - **`execute` awaits the full spawn closure through a count gate.** `#launch` increments
  *   an outstanding-unit `#count` BEFORE enqueuing and every settle decrements it,
  *   resolving the `#drained` deferred at zero. Because `spawn` calls `#launch` (so
  *   `#count += 1`) before the parent handler returns, the count never reaches zero
  *   mid-run — `execute` parks on `#drained` and so awaits the entire transitive
- *   closure, not just the declared units.
+ *   closure, not only the declared units.
  * - **`spawn` is fire-and-track.** A spawned unit runs through the queue regardless of
  *   whether its promise is awaited; the Runner never awaits a spawned promise from
  *   within a handler's slot (it awaits the count gate instead), so a slot-holding
@@ -1774,16 +2274,16 @@ export declare function resolveTaskSilence(value: number | undefined, fallback:
  *   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`
+ * - **`pause` / `resume` / `stop` 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
+ *   completion and settles normally. `execute` RESOLVES (never rejects) after every unit
  *   has settled, with whatever results actually completed.
- * - **Observable (§13).** The owned {@link emitter} ({@link RunnerEventMap}) carries the run
+ * - **Observable.** 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
  *   launch / settle / drain transition; the emitter isolates a listener throw and routes it
@@ -1800,20 +2300,20 @@ export declare class Runner<TInput, TResult> implements RunnerInterface<TInput,
     get stopped(): boolean;
     get paused(): boolean;
     /**
-     * Inject one more unit into an IN-FLIGHT `execute` run — a LIVE counterpart to a
+     * Injects 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",
+     * Returns `undefined` synchronously (graceful, non-throwing) unless the
+     * runner is 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-
+     * the SAME backing queue as a declared/`spawn`ed unit through `#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.
+     * with a `parent` of `undefined` (this call has no spawning unit) after acceptance.
      *
      * @param input - The unit's work payload
      * @returns The unit's result promise, or `undefined` when no in-flight run can accept it
@@ -1829,26 +2329,26 @@ export declare class Runner<TInput, TResult> implements RunnerInterface<TInput,
     execute(inputs: readonly TInput[]): Promise<readonly TResult[]>;
     abort(reason?: unknown): Promise<void>;
     /**
-     * Suspend dispatch (AGENTS §10 — resumable): delegates to the backing queue's own
+     * Suspends dispatch (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
+     * A no-op after 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`.
+     * Continues a paused runner; 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
+     * A no-op after the runner is `stopped` (nothing left to resume) and a no-op when the
+     * runner is not `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`.
+     * Ends the runner permanently — 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
@@ -1862,8 +2362,8 @@ export declare class Runner<TInput, TResult> implements RunnerInterface<TInput,
 }
 
 /**
- * The per-entry reliability OVERRIDES for one unit — its extra attempts on failure and its
- * per-attempt deadline, resolved from the unit's input via {@link RunnerOptions.entries}.
+ * Declares the per-entry reliability OVERRIDES for one unit — its extra attempts on failure and its
+ * per-attempt deadline, resolved from the unit's input through {@link RunnerOptions.entries}.
  *
  * @remarks
  * The unit's `id` and `signal` stay Runner-managed (it mints the id and owns the per-unit
@@ -1879,7 +2379,7 @@ export declare interface RunnerEntryOptions {
 }
 
 /**
- * The push observation surface of a {@link RunnerInterface} (AGENTS §13) — the run
+ * Declares the push observation surface of a {@link RunnerInterface} — the run
  * lifecycle a fire-and-forget observer (logging, metrics, tracing) subscribes to,
  * ALONGSIDE the eventual `execute` result.
  *
@@ -1888,32 +2388,32 @@ export declare interface RunnerEntryOptions {
  *   {@link RunnerInterface} is generic.
  *
  * @remarks
- * Listener isolation is the emitter's (AGENTS §13): every event is emitted directly and a
+ * Listener isolation is the emitter's: every event is emitted directly and a
  * listener throw is routed to the emitter's OWN `error` handler (the `error` option), never
  * onto this domain map and never into the one-shot / fail-fast / spawn-tracking engine — so a
  * buggy observer can never reorder, throw into, or corrupt the run. Every emit sits AFTER the
  * relevant unit-launch / settle / drain transition, so a throwing observer cannot unbalance
- * the outstanding-unit count gate or break fail-fast. Subscribe via `runner.emitter.on(...)`.
+ * the outstanding-unit count gate or break fail-fast. Subscribe through `runner.emitter.on(...)`.
  *
- * Declared as a `type` alias (not `interface extends EventMap`, §4.5 — `EventMap` is a
+ * Declared as a `type` alias (not `interface extends EventMap` — `EventMap` is a
  * `type` kind): a type-literal satisfies the `EventMap` constraint
  * (`Record<string, readonly unknown[]>`) structurally, whereas an interface lacks the
  * required index signature.
  */
 export declare type RunnerEventMap<TResult> = {
-    /** `execute` began — emitted once at the top of a non-empty run. */
+    /** Signals that `execute` began — emitted once at the top of a non-empty run. */
     readonly start: readonly [];
-    /** A unit's handler began running — the unit's id (declared or spawned). */
+    /** Signals that a unit's handler began running — the unit's id (declared or spawned). */
     readonly unit: readonly [id: string];
-    /** A sub-unit was spawned — its id + the spawning parent's id (when known). */
+    /** Signals that a sub-unit was spawned — its id + the spawning parent's id (when known). */
     readonly spawn: readonly [id: string, parent: string | undefined];
-    /** A unit completed successfully — its id (after its outcome was recorded). */
+    /** Signals that a unit completed successfully — its id (after its outcome was recorded). */
     readonly settle: readonly [id: string];
-    /** A unit failed — its id + the error (always `unknown`). */
+    /** Signals that a unit failed — its id + the error (always `unknown`). */
     readonly fail: readonly [id: string, error: unknown];
-    /** The batch settled — the run's ordered results (the same array `execute` resolves). */
+    /** Signals that the batch settled — the run's ordered results (the same array `execute` resolves). */
     readonly finish: readonly [results: readonly TResult[]];
-    /** The run was aborted (fail-fast, a user `abort`, or `destroy`) — the cancel reason. */
+    /** Signals that the run was aborted (fail-fast, a user `abort`, or `destroy`) — the cancel reason. */
     readonly abort: readonly [reason: unknown];
 };
 
@@ -1926,7 +2426,7 @@ export declare type RunnerEventMap<TResult> = {
 export declare type RunnerHandler<TInput, TResult> = (controller: ControllerInterface<TInput, TResult>) => Promise<TResult> | TResult;
 
 /**
- * A thin generic orchestrator that drives declared units — plus any they `spawn` —
+ * Declares a thin generic orchestrator that drives declared units — plus any they `spawn` —
  * through a bounded-concurrency queue, collecting their results in order.
  *
  * @remarks
@@ -1935,12 +2435,12 @@ export declare type RunnerHandler<TInput, TResult> = (controller: ControllerInte
  * (the backpressure + retry + timeout engine), routing every unit (declared and
  * spawned) through it so spawned work actually runs.
  *
- * Exposes a typed {@link emitter} (AGENTS §13) carrying its run lifecycle moments
+ * Exposes a typed {@link emitter} carrying its run lifecycle moments
  * ({@link RunnerEventMap}) for fire-and-forget observers, ALONGSIDE the eventual `execute`
  * result. Emitting is observation-only — every event fires AFTER the relevant unit-launch /
  * settle / drain transition, so a buggy observer can never reorder or corrupt the one-shot /
  * fail-fast / spawn-tracking engine: the emitter isolates a listener throw and routes it to
- * its `error` handler (the `error` option), never the run. Subscribe via
+ * its `error` handler (the `error` option), never the run. Subscribe through
  * `runner.emitter.on(...)`.
  *
  * @typeParam TInput - The unit's work input
@@ -1950,10 +2450,10 @@ 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`. */
+    /** Reports whether the runner is paused (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
+     * Runs all `inputs` — and anything they `spawn` — to completion; resolves their
      * results in order: the declared inputs first (in input order), then the spawned
      * units (in spawn order).
      *
@@ -1967,18 +2467,18 @@ export declare interface RunnerInterface<TInput, TResult> {
      */
     execute(inputs: readonly TInput[]): Promise<readonly TResult[]>;
     /**
-     * Inject one more unit into an IN-FLIGHT `execute` run — a LIVE counterpart to a
+     * Injects 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
+     * Returns `undefined` synchronously (graceful, non-throwing) when the
+     * runner is not 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
+     * the {@link RunnerEventMap.spawn} event; its result promise resolves after the unit
      * settles.
      *
      * @param input - The unit's work payload
@@ -1986,7 +2486,7 @@ export declare interface RunnerInterface<TInput, TResult> {
      */
     spawn(input: TInput): Promise<TResult> | undefined;
     /**
-     * Cancel every in-flight + pending unit (and the backing queue), making a running
+     * Cancels every in-flight + pending unit (and the backing queue), making a running
      * `execute` reject.
      *
      * @param reason - An optional cancellation reason propagated to every unit's signal
@@ -1994,7 +2494,7 @@ export declare interface RunnerInterface<TInput, TResult> {
      */
     abort(reason?: unknown): Promise<void>;
     /**
-     * Suspend dispatch (AGENTS §10 — resumable): the backing queue holds the NEXT dispatch
+     * Suspends dispatch (resumable): the backing queue holds the NEXT dispatch
      * while any in-flight unit finishes; idempotent.
      *
      * @example
@@ -2005,7 +2505,7 @@ export declare interface RunnerInterface<TInput, TResult> {
      */
     pause(): void;
     /**
-     * Continue a paused runner (AGENTS §10); idempotent.
+     * Continues a paused runner; idempotent.
      *
      * @example
      * ```ts
@@ -2015,11 +2515,11 @@ export declare interface RunnerInterface<TInput, TResult> {
      */
     resume(): void;
     /**
-     * Permanently end the runner (AGENTS §10) — a GRACEFUL stop: no further unit is
+     * Ends the runner permanently — 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
+     * failure still is. `execute`'s promise RESOLVES (never rejects) after every unit has
      * settled, with whatever results actually completed. Idempotent.
      *
      * @example
@@ -2033,7 +2533,7 @@ export declare interface RunnerInterface<TInput, TResult> {
      */
     stop(): Promise<void>;
     /**
-     * Tear the runner down, awaiting backing-queue cleanup before destroying the emitter last.
+     * Tears the runner down, awaiting backing-queue cleanup before destroying the emitter last.
      *
      * @returns The stable teardown barrier
      */
@@ -2041,7 +2541,7 @@ export declare interface RunnerInterface<TInput, TResult> {
 }
 
 /**
- * Options for `createRunner`.
+ * Declares the options for `createRunner`.
  *
  * @remarks
  * - `handler` — runs each unit's work against its {@link ControllerInterface};
@@ -2054,29 +2554,30 @@ export declare interface RunnerInterface<TInput, TResult> {
  *   an integer in `0..2_147_483_647`, and `0` disables the deadline.
  * - `entries` — per-entry `retries` / `timeout` overrides, resolved from each
  *   input; falls back to the runner-level `retries` / `timeout` defaults.
- * - `on` — the reserved {@link EmitterHooks} key (§8): initial listeners for the runner's
- *   {@link RunnerEventMap}, wired at construction (e.g. `{ finish: (r) => log(r) }`).
+ * - `on` — the reserved {@link EmitterHooks} key: initial listeners for the runner's
+ *   {@link RunnerEventMap}, wired at construction (for example, `{ finish: (r) => log(r) }`).
  */
 export declare interface RunnerOptions<TInput, TResult> {
     readonly on?: EmitterHooks<RunnerEventMap<TResult>>;
-    /** The emitter's listener-error handler (AGENTS §13) — a listener throw routes here, not to a domain event. */
+    /** Holds the emitter's listener-error handler — a listener throw routes here, not to a domain event. */
     readonly error?: EmitterErrorHandler;
     readonly handler: RunnerHandler<TInput, TResult>;
     readonly concurrency?: number;
     readonly retries?: number;
     readonly timeout?: number;
-    /** Per-entry `retries` / `timeout` overrides, resolved from each input; falls back to the runner-level defaults. */
+    /** Resolves per-entry `retries` / `timeout` overrides from each input; falls back to the runner-level defaults. */
     readonly entries?: (input: TInput) => RunnerEntryOptions;
 }
 
 /**
- * One unit the {@link RunnerInterface} is tracking: the queue payload it was enqueued
+ * Represents one unit the {@link RunnerInterface} is tracking: the queue payload it was enqueued
  * with — its `id` (a random UUID) keys it in the runner's ordered launch list and value
  * map, and `input` is the unit's work payload handed to the handler's `Controller`.
  *
  * @remarks
- * The runner's internal bookkeeping shape, published through the barrel because §5
- * centralizes every file-local type — declared or spawned, every unit flows through the
+ * The runner's internal bookkeeping shape, published through the barrel because
+ * `.claude/rules/architecture.md` § Centralized-file pattern centralizes every file-local type —
+ * declared or spawned, every unit flows through the
  * one queue as a `RunnerUnit`, so backpressure / ordering / retries / timeout stay the
  * Queue's behavior and the runner adds only orchestration.
  *
@@ -2088,7 +2589,21 @@ export declare interface RunnerUnit<TInput> {
 }
 
 /**
- * Schedule one cancellable host operation behind an owned settlement signal.
+ * Locates the nearest identifiable node for an inconsistent owned snapshot.
+ *
+ * @remarks
+ * The walk stops at the first phase or task whose persisted fields are inconsistent and returns
+ * the identifiers it could read there, so a diagnostic can name the offending node even when part
+ * of its identity is unreadable.
+ *
+ * @param value - The candidate snapshot, which may be any unknown value
+ * @returns The nearest identifying record naming the offending `phase` and `task`, or `undefined`
+ * when no inconsistent node is identifiable
+ */
+export declare function scanSnapshotContext(value: unknown): Readonly<Record<string, unknown>> | undefined;
+
+/**
+ * Schedules one cancellable host operation behind an owned settlement signal.
  *
  * @remarks
  * A defined `signal` that is not a native `AbortSignal` is refused before anything is armed, as a
@@ -2118,7 +2633,7 @@ export declare interface RunnerUnit<TInput> {
 export declare function scheduleHost(start: (complete: () => void, failure: (error: unknown) => void) => () => void, signal?: AbortSignal): Promise<void>;
 
 /**
- * The safe cross-environment cooperative-yield default — a {@link SchedulerInterface}
+ * Implements the safe cross-environment cooperative-yield default — a {@link SchedulerInterface}
  * built on `setTimeout` / `clearTimeout` alone, so it runs unchanged in both the
  * browser and Node.
  *
@@ -2134,7 +2649,7 @@ export declare function scheduleHost(start: (complete: () => void, failure: (err
  *   rendering run — it only defers within the current task. A zero-delay timer is
  *   the correct cross-environment "give the host a turn".
  * - **Abort-aware.** A pending `yield` / `delay` rejects with `signal.reason` exactly.
- *   {@link scheduleHost} links an owned settlement composite to the caller before arming
+ *   {@link delayHost} links an owned settlement composite to the caller before arming
  *   the timer, so pre-abort schedules nothing, caller signal method mutation is harmless,
  *   cancellation clears the handle, and native first-settlement wins exactly once.
  * - **Priority is accepted but uniform.** `options.priority` is part of the
@@ -2152,60 +2667,59 @@ export declare function scheduleHost(start: (complete: () => void, failure: (err
  * ```
  */
 declare class Scheduler_2 implements SchedulerInterface {
-    #private;
     /**
-     * Yield control back to the host so other tasks (I/O, timers, rendering) can
-     * run, then resume — a macrotask turn via `setTimeout(0)` (NOT a microtask,
+     * Yields control back to the host so other tasks (I/O, timers, rendering) can
+     * run, then resumes — a macrotask turn through `setTimeout(0)` (NOT a microtask,
      * which would resume before the host regains control).
      */
     yield(options?: SchedulerOptions): Promise<void>;
     /**
-     * Resume after at least `ms` milliseconds; abort rejects with `signal.reason`.
+     * Resumes after at least `ms` milliseconds; abort rejects with `signal.reason`.
      *
      * @remarks
-     * `ms` should be a non-negative finite number. The primitive stays minimal and
-     * does no validation: it passes `ms` straight to the host `setTimeout`, which
-     * clamps a negative value or `NaN` to ~0 — so an out-of-domain `ms` resolves on
-     * the next host turn rather than throwing.
+     * Pass a non-negative finite `ms`. The primitive stays minimal and does no
+     * validation: it passes `ms` straight to the host `setTimeout`, which clamps a
+     * negative value or `NaN` to ~0 — so an out-of-domain `ms` resolves on the next
+     * host turn rather than throwing.
      */
     delay(ms: number, options?: SchedulerOptions): Promise<void>;
 }
 export { Scheduler_2 as Scheduler }
 
 /**
- * A cooperative host-yield primitive: a loop decides WHAT to do; the scheduler
+ * Declares a cooperative host-yield primitive: a loop decides WHAT to do; the scheduler
  * decides WHEN the host regains control. Abort-aware — a pending yield/delay
  * rejects with the signal's reason when aborted.
  */
 export declare interface SchedulerInterface {
     /**
-     * Yield control back to the host so other tasks (I/O, timers, rendering) can
-     * run, then resume.
+     * Yields control back to the host so other tasks (I/O, timers, rendering) can
+     * run, then resumes.
      */
     yield(options?: SchedulerOptions): Promise<void>;
-    /** Resume after at least `ms` milliseconds. */
+    /** Resumes after at least `ms` milliseconds. */
     delay(ms: number, options?: SchedulerOptions): Promise<void>;
 }
 
-/** Options for a single cooperative yield/delay. */
+/** Declares the options for a single cooperative yield/delay. */
 export declare interface SchedulerOptions {
     /**
-     * A relative urgency hint. Honoured by environment backends; the
+     * Carries a relative urgency hint. Honoured by environment backends; the
      * cross-environment default treats all priorities the same.
      */
     readonly priority?: SchedulerPriority;
-    /** A signal whose abort rejects a pending yield/delay with its `reason`. */
+    /** Carries a signal whose abort rejects a pending yield/delay with its `reason`. */
     readonly signal?: AbortSignal;
 }
 
 /**
- * Relative urgency hint for cooperative scheduling. Honoured by environment
+ * Names the relative urgency hint for cooperative scheduling. Honoured by environment
  * backends; the cross-environment default treats all priorities uniformly.
  */
 export declare type SchedulerPriority = 'user' | 'normal' | 'background';
 
 /**
- * Box a value as a {@link Success} — the graceful outcome half of a {@link Result}.
+ * Boxes a value as a {@link Success} — the graceful outcome half of a {@link Result}.
  *
  * @typeParam T - The boxed value's type
  * @param value - The value to box
@@ -2219,99 +2733,7 @@ export declare type SchedulerPriority = 'user' | 'normal' | 'background';
 export declare function success<T>(value: T): Success<T>;
 
 /**
- * The live leaf state machine (W-b) for one task — an observable (AGENTS §13), guarded
- * synchronous task whose explicit {@link TaskStatus} advances through the AGENTS §10
- * transitions, recording a {@link TaskResult} on a terminal outcome.
- *
- * @remarks
- * - **Guarded transitions (AGENTS §10).** `start` (→ `running`), then `complete(value)`
- *   (→ `completed`, records a {@link import('@orkestrel/contract').Success}), `fail(error)`
- *   (→ `failed`, records a {@link import('@orkestrel/contract').Failure}), `skip` (→ `skipped`),
- *   `stop` (→ `stopped`). Each consults {@link canTransitionTask} FIRST and throws a
- *   `TRANSITION` {@link WorkflowError} on an illegal move (e.g. completing a non-`running`
- *   task) — the legal graph is the single source of truth, so the leaf can never reach an
- *   impossible state.
- * - **Snapshot fidelity.** A leaf needs no override: `skipped` / `stopped` are explicit terminal
- *   statuses, and restore reinstates the leaf directly from {@link TaskSnapshot.status}.
- * - **The cascade.** Every status change records its boxed result (when any), fires the leaf's
- *   OWN event, THEN calls the parent phase's `#recompute` (injected at construction) so the
- *   transition propagates UP (Task → Phase → Workflow re-derive). The own-event-before-cascade
- *   order means an observer sees the CAUSE (this leaf changed) before the EFFECT (the parents
- *   re-derive) — the project precedent (`Runner.#settle` emits its own `fail` before propagating).
- * - **Observable (AGENTS §13).** The owned {@link emitter} ({@link TaskEventMap}) fires the
- *   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. Only omission is a
- *   deliberate no-op; unresolved named work is rejected before dispatch.
- */
-export declare class Task implements TaskInterface {
-    #private;
-    readonly description?: string;
-    constructor(context: TaskContext, phase: PhaseInterface, workflow: WorkflowInterface, recompute: () => void, options?: TaskOptions, status?: TaskStatus, result?: TaskResult, run?: string, retries?: number, timeout?: number, metadata?: JSONRecord, attempts?: number, activity?: TaskActivity, handler?: WorkflowFunction, silence?: number);
-    get emitter(): EmitterInterface<TaskEventMap>;
-    get id(): string;
-    get name(): string;
-    get context(): TaskContext;
-    get phase(): PhaseInterface;
-    get workflow(): WorkflowInterface;
-    get status(): TaskStatus;
-    get result(): TaskResult | undefined;
-    get attempts(): number;
-    get run(): string | undefined;
-    get handler(): WorkflowFunction | undefined;
-    get retries(): number | undefined;
-    get timeout(): number | undefined;
-    get activity(): TaskActivity | undefined;
-    get silence(): number | undefined;
-    get silent(): boolean;
-    get paused(): boolean;
-    get signal(): AbortSignal;
-    start(): void;
-    complete(value: JSONValue): void;
-    fail(error: TaskFailure): void;
-    skip(): void;
-    stop(): void;
-    report(input: TaskActivityInput): Result<TaskActivity, WorkflowError>;
-    pulse(): boolean;
-    pause(): void;
-    resume(): void;
-    wait(): Promise<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;
-}
-
-/**
- * Every {@link TaskStatus} value, frozen — the lifecycle vocabulary of a task.
- *
- * @remarks
- * Ordered pending → running → terminal (`completed` / `failed` / `skipped` /
- * `stopped`). The source of truth for the union; compose guards / shapes from it.
- */
-export declare const TASK_STATUSES: readonly TaskStatus[];
-
-/**
- * The legal {@link TaskStatus} transition graph of the live W-b task state machine —
+ * Declares the legal {@link LifecycleStatus} transition graph of the live W-b task state machine —
  * each current status mapped to the statuses it may move to directly, frozen.
  *
  * @remarks
@@ -2323,10 +2745,10 @@ export declare const TASK_STATUSES: readonly TaskStatus[];
  * transitions again. So completing a non-`running` task, or starting a settled one, is
  * rejected.
  */
-export declare const TASK_TRANSITIONS: Readonly<Record<TaskStatus, readonly TaskStatus[]>>;
+export declare const TASK_TRANSITIONS: Readonly<Record<LifecycleStatus, readonly LifecycleStatus[]>>;
 
 /**
- * The bounded, JSON-serializable activity most recently accepted from a task reporter.
+ * Represents the bounded, JSON-serializable activity most recently accepted from a task reporter.
  */
 export declare interface TaskActivity {
     readonly note?: string;
@@ -2337,7 +2759,7 @@ export declare interface TaskActivity {
 }
 
 /**
- * One complete replacement of a running task's observable activity.
+ * Represents one complete replacement of a running task's observable activity.
  *
  * @remarks
  * `note` describes the frame while `progress.message` describes the progress value.
@@ -2352,20 +2774,35 @@ export declare interface TaskActivityInput {
 }
 
 /**
- * One constraint claimed active when a running task's complete frame was accepted.
+ * Represents one identified thing a running task claims active, with the moment the claim began.
  *
  * @remarks
- * Constraints describe active limits or requirements without embedding provider policy in
- * core. `id` is unique within one complete report and `started` is finite and non-negative.
+ * The shape {@link TaskOperation} and {@link TaskConstraint} share: `id` is unique within one
+ * complete activity report, `name` is the human-readable label, and `started` is a finite
+ * non-negative reporter timestamp. The two claim lists are validated by one guard
+ * ({@link import('./validators.js').isTaskClaimList}) and owned by one cloner
+ * ({@link import('./cloners.js').cloneTaskClaims}) over this type, while each list keeps its own
+ * published member name so a later member can distinguish them.
  */
-export declare interface TaskConstraint {
+export declare interface TaskClaim {
     readonly id: string;
     readonly name: string;
     readonly started: number;
 }
 
 /**
- * The ambient context of a task — its own identity plus a back-reference to the
+ * Represents one constraint claimed active when a running task's complete frame was accepted.
+ *
+ * @remarks
+ * A {@link TaskClaim}. Constraints describe active limits or requirements without embedding
+ * provider policy in core. `id` is unique within one complete report and `started` is finite and
+ * non-negative.
+ */
+export declare interface TaskConstraint extends TaskClaim {
+}
+
+/**
+ * Represents the ambient context of a task — its own identity plus a back-reference to the
  * phase (and, transitively, the workflow) it belongs to.
  *
  * @remarks
@@ -2378,50 +2815,11 @@ export declare interface TaskContext extends WorkflowContext {
 }
 
 /**
- * The attempt-scoped handle a {@link import('./types.js').WorkflowFunction} receives.
- *
- * @remarks
- * - **A leaf handle, NOT the runner `Controller`.** A workflow task is a leaf of the
- *   declarative W-b tree, not a fan-out unit, so it has no `spawn`; its `wait` instead
- *   checkpoints the workflow, phase, and task cooperative gates.
- * - **Folded signal.** `signal` is the cancellation folded for THIS attempt: its per-attempt
- *   deadline, task stop/skip, workflow abort/timeout/budget/destroy, or a sibling fail-fast.
- *   A handler races its work against it; `aborted` reads it.
- * - **Attempt ownership.** `report` / `pulse` are closures supplied by the runner and refuse
- *   after this signal aborts or a retry token supersedes this handle.
- * - **Input + lineage.** `input` is the task's open `metadata` bag (its
- *   {@link import('./types.js').TaskInput} payload, `{}` when none); `task` is the full
- *   {@link TaskContext}, so `task.phase` / `task.phase.workflow` navigate UP the lineage.
- * - **Read-up results.** `results()` returns every settled task's {@link TaskResult} across
- *   the phases that have already finished (a closure over the live
- *   {@link import('./types.js').WorkflowInterface}), so a `function` task can read an earlier
- *   phase's output. Read-only — a task records its OWN outcome by returning / throwing, not
- *   by mutating the tree.
- * - **Event-free.** Like the runner `Controller`, the per-task handle carries no Emitter;
- *   observe the W-b entities' own emitters (`task.emitter` / `phase.emitter`) instead.
- */
-declare class TaskController_2 implements TaskControllerInterface {
-    #private;
-    readonly signal: AbortSignal;
-    readonly input: JSONRecord;
-    readonly task: TaskContext;
-    readonly attempt: number;
-    constructor(signal: AbortSignal, input: JSONRecord, task: TaskInterface, attempt: number, results: () => readonly TaskResult[], report: (input: TaskActivityInput) => Result<TaskActivity, WorkflowError>, pulse: () => boolean);
-    get aborted(): boolean;
-    get paused(): boolean;
-    report(input: TaskActivityInput): Result<TaskActivity, WorkflowError>;
-    pulse(): boolean;
-    wait(): Promise<void>;
-    results(): readonly TaskResult[];
-}
-export { TaskController_2 as TaskController }
-
-/**
- * The per-task handle a {@link WorkflowFunction} receives — the running task's
+ * Declares the per-task handle a {@link WorkflowFunction} receives — the running task's
  * cancellation, its input, its lineage, and read-UP access to the result tree.
  *
  * @remarks
- * A NEW, lean handle (NOT the runner `Controller` — it carries no `spawn`; a workflow task
+ * A lean handle (NOT the runner `Controller` — it carries no `spawn`; a workflow task
  * is a leaf of the declarative tree, not a fan-out unit). It exposes:
  * - `signal` — this attempt's folded cancellation: its per-attempt deadline, task
  *   stop/skip, workflow abort/timeout/budget/destroy, or a sibling fail-fast.
@@ -2438,55 +2836,57 @@ export declare interface TaskControllerInterface {
     /** Fires on this attempt's deadline, task stop/skip, run cancellation, or sibling fail-fast. */
     readonly signal: AbortSignal;
     readonly aborted: boolean;
-    /** The task's open `metadata` bag (its {@link TaskInput} payload); `{}` when none. */
+    /** Holds the task's open `metadata` bag (its {@link TaskInput} payload); `{}` when none. */
     readonly input: JSONRecord;
     readonly task: TaskContext;
-    /** The one-based persisted launch represented by this handle. */
+    /** Reports the one-based persisted launch represented by this handle. */
     readonly attempt: number;
-    /** Whether the workflow, phase, or task cooperative gate is currently paused. */
+    /** Reports whether the workflow, phase, or task cooperative gate is paused. */
     readonly paused: boolean;
     /**
-     * Replace this running task's complete observable activity.
+     * Replaces this running task's complete observable activity.
      *
      * @param input - The complete operations, progress, and constraints replacement
      * @returns The accepted frame, or a `TRANSITION` failure after ownership is lost or this attempt aborts
      */
     report(input: TaskActivityInput): Result<TaskActivity, WorkflowError>;
     /**
-     * Confirm liveness without replacing current activity.
+     * Confirms liveness without replacing current activity.
      *
-     * @returns `true` when committed, or `false` after ownership is lost or this attempt aborts
+     * @returns True if the pulse was committed before ownership is lost or this attempt aborts; false otherwise
      */
     pulse(): boolean;
     /**
-     * Cooperatively park while any workflow, phase, or task gate is paused, or until cancelled.
+     * Parks cooperatively while any workflow, phase, or task gate is paused, or until cancelled.
      *
      * @returns A promise that resolves when every applicable gate is open or the signal aborts
      */
     wait(): Promise<void>;
-    /** Every settled task's result across already-finished phases — the result tree, read-only. */
+    /** Lists every settled task's result across already-finished phases — the result tree, read-only. */
     results(): readonly TaskResult[];
 }
 
 /**
- * The serializable definition of one task — its identity plus an optional reference to
+ * Represents 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 a
+ * its phase; `name` is the human label; `description` is optional prose. `behavior` 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. An omitted `run` is the deliberate no-op form and completes
+ * {@link WorkflowRegistry} registry into a runtime {@link TaskInterface.handler}
+ * carried on the live task. An omitted `behavior` is the deliberate no-op form and completes
  * with JSON `null`; an unresolved present name remains inspectable but is not executable.
  */
 export declare interface TaskDefinition {
     readonly id: string;
     readonly name: string;
     readonly description?: string;
-    readonly run?: string;
+    readonly behavior?: string;
     /**
+     * Sets the extra attempts after the first on failure.
+     *
      * @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 ⇒
@@ -2496,6 +2896,8 @@ export declare interface TaskDefinition {
      */
     readonly retries?: number;
     /**
+     * Sets the per-attempt deadline in milliseconds.
+     *
      * @remarks
      * The workflow-owned per-attempt deadline in milliseconds, an integer from `0` through
      * `MAX_TIMER_MS`. Zero or omission means no deadline. PERSISTED in a {@link TaskSnapshot},
@@ -2506,14 +2908,14 @@ export declare interface TaskDefinition {
 }
 
 /**
- * Convert one {@link import('./types.js').TaskDefinition} into an initial, `pending`
+ * Converts one {@link import('./types.js').TaskDefinition} into an initial, `pending`
  * {@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
+ * `behavior` / `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}
+ * reliability overrides after pairing with a {@link import('./types.js').WorkflowOptions.functions}
  * registry.
  *
  * @param task - The task definition to seed from
@@ -2522,7 +2924,7 @@ export declare interface TaskDefinition {
 export declare function taskDefinitionToSnapshot(task: WorkflowDefinition['phases'][number]['tasks'][number]): TaskSnapshot;
 
 /**
- * The push observation surface (AGENTS §13) of the task entity (W-b) — the
+ * Declares the push observation surface of the task entity (W-b) — the
  * lifecycle moments of one task.
  *
  * @remarks
@@ -2531,61 +2933,53 @@ export declare function taskDefinitionToSnapshot(task: WorkflowDefinition['phase
  * `pause` / `resume` when its runtime gate closes / opens; `skip` when it is
  * intentionally not executed; `stop` when it is ended early. 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
+ * not the domain surface. A `type` alias so it satisfies
  * `EventMap`.
  */
 export declare type TaskEventMap = {
-    /** The task began — its `id`. */
+    /** Signals that the task began — its `id`. */
     readonly start: readonly [id: string];
-    /** The task finished successfully — its result. */
+    /** Signals that the task finished successfully — its result. */
     readonly complete: readonly [result: TaskResult];
-    /** The task failed — its result. */
+    /** Signals that the task failed — its result. */
     readonly fail: readonly [result: TaskResult];
-    /** The task's runtime gate closed. */
+    /** Signals that the task's runtime gate closed. */
     readonly pause: readonly [];
-    /** The task's runtime gate opened. */
+    /** Signals that the task's runtime gate opened. */
     readonly resume: readonly [];
-    /** The task was intentionally skipped. */
+    /** Signals that the task was intentionally skipped. */
     readonly skip: readonly [];
-    /** The task was permanently stopped. */
+    /** Signals that the task was permanently stopped. */
     readonly stop: readonly [];
-    /** A complete activity replacement was committed. */
+    /** Signals that a complete activity replacement was committed. */
     readonly report: readonly [activity: TaskActivity];
-    /** The task confirmed liveness without replacing its current activity. */
+    /** Signals that the task confirmed liveness without replacing its current activity. */
     readonly pulse: readonly [activity: TaskActivity];
-    /** No report or pulse was accepted during the effective silence window. */
+    /** Signals that no report or pulse was accepted during the effective silence window. */
     readonly silence: readonly [];
 };
 
-/** A normalized JSON-safe task failure persisted without a stack or cause. */
+/** Represents a normalized JSON-safe task failure persisted without a stack or cause. */
 export declare interface TaskFailure {
     readonly origin: TaskFailureOrigin;
     readonly message: string;
 }
 
 /**
- * The structured outcome of a task execution — its full lineage, its terminal
- * status, the moment it settled, and its boxed produced outcome.
+ * Names where a task failure arose — the axis a persisted {@link TaskFailure} records.
  *
  * @remarks
- * Carries the complete lineage (`task` / `phase` / `workflow` contexts) so a result
- * is self-describing wherever it travels. `status` is the terminal state this
- * result records. `result` BOXES the produced outcome in a {@link Result}: it is
- * PRESENT exactly when `status` is `completed` (a {@link import('@orkestrel/contract').Success})
- * or `failed` (a {@link import('@orkestrel/contract').Failure}), and ABSENT when `status` is
- * `skipped` or `stopped` (terminal, but produced no outcome) — a pending/running
- * task has no result at all (a non-terminal status, per
- * {@link import('./helpers.js').isTerminalStatus}). This boxed `result` REPLACES separate
- * `value?` / `error?` fields: a success's payload is `result.value`, a failure's reason is `result.error`.
- * `timestamp` is when the result was created (ms since epoch).
+ * - `handler` — the task's own {@link WorkflowFunction} threw or rejected, or its `behavior` name had
+ *   no registered handler to dispatch.
+ * - `timeout` — the task's per-attempt deadline expired on its final attempt.
+ * - `recovery` — an interrupted `running` task was rebuilt by
+ *   {@link import('./factories.js').createRecoveredWorkflow} with no attempts left in its retry
+ *   budget, so the recovery settled it rather than replenishing it.
  */
 export declare type TaskFailureOrigin = 'handler' | 'timeout' | 'recovery';
 
-/** Initial {@link TaskEventMap} listeners — the reserved `on` option (AGENTS §8). */
-export declare type TaskHooks = EmitterHooks<TaskEventMap>;
-
 /**
- * The minimal data to create a task context — a partial {@link TaskContext} plus
+ * Represents the minimal data to create a task context — a partial {@link TaskContext} plus
  * any creation-only fields.
  *
  * @remarks
@@ -2594,32 +2988,32 @@ export declare type TaskHooks = EmitterHooks<TaskEventMap>;
  * layer fills identity / lineage).
  */
 export declare interface TaskInput extends Partial<TaskContext> {
-    /** An open consumer bag — stored and snapshotted, never interpreted by the workflow. */
+    /** Holds an open consumer bag — stored and snapshotted, never interpreted by the workflow. */
     readonly metadata?: JSONRecord;
 }
 
 /**
- * The live leaf state machine (W-b) for one {@link TaskDefinition} — an observable
- * (AGENTS §13), guarded synchronous task whose explicit {@link TaskStatus} advances
- * through the AGENTS §10 transitions.
+ * Declares the live leaf state machine (W-b) for one {@link TaskDefinition} — an observable,
+ * guarded synchronous task whose explicit {@link LifecycleStatus} advances through the
+ * declared transitions.
  *
  * @remarks
  * - **Identity + lineage.** `id` / `name` / `description` mirror the definition;
  *   `context` is the task's full {@link TaskContext} (so `context.phase` /
  *   `context.phase.workflow` navigate UP the tree), and `phase` / `workflow` are the
  *   live parent entities for direct lineage navigation.
- * - **State machine (AGENTS §10).** `status` is the explicit current state. `start`
+ * - **State machine.** `status` is the explicit current state. `start`
  *   moves `pending → running`; the terminal transitions are `complete(value)` (records
  *   a {@link import('@orkestrel/contract').Success}), `fail(error)` (records a
- *   {@link import('@orkestrel/contract').Failure}), `skip` (AGENTS §10 — intentionally not run),
- *   and `stop` (AGENTS §10 — ended early). Each is GUARDED: an illegal transition (e.g.
+ *   {@link import('@orkestrel/contract').Failure}), `skip` (intentionally not run),
+ *   and `stop` (ended early). Each is GUARDED: an illegal transition (for example,
  *   completing a non-`running` task) throws a {@link import('./errors.js').WorkflowError}.
  *   A leaf needs no override: `skipped` / `stopped` are explicit terminal statuses and
  *   restore directly from {@link TaskSnapshot.status}.
- * - **Result.** `result` is the recorded {@link TaskResult} once the task settled with an
+ * - **Result.** `result` is the recorded {@link TaskResult} after the task settled with an
  *   outcome (`completed` / `failed`), else `undefined` — the lineage-navigable leaf of the
  *   result tree.
- * - **Observable (AGENTS §13).** The owned {@link emitter} ({@link TaskEventMap}) fires
+ * - **Observable.** The owned {@link emitter} ({@link TaskEventMap}) fires
  *   `start` / `complete` / `fail` / `pause` / `resume` / `skip` / `stop` strictly AFTER
  *   each state change; the emitter isolates a listener throw and routes it to its `error`
  *   handler (the `error` option).
@@ -2628,50 +3022,52 @@ export declare interface TaskInterface {
     readonly emitter: EmitterInterface<TaskEventMap>;
     readonly id: string;
     readonly name: string;
-    readonly description?: string;
+    /** Holds this task's prose, or `undefined` when the definition or snapshot declared none. */
+    readonly description: string | undefined;
     readonly context: TaskContext;
     readonly phase: PhaseInterface;
     readonly workflow: WorkflowInterface;
-    readonly status: TaskStatus;
-    /** Total launches already consumed; zero while fresh and one-based after launch. */
+    /** Holds this task's explicit lifecycle status, set by its own transitions. */
+    readonly status: LifecycleStatus;
+    /** Counts total launches already consumed; zero while fresh and one-based after launch. */
     readonly attempts: number;
-    /** The recorded outcome once the task settled with one (`completed` / `failed`), else `undefined`. */
+    /** Holds the recorded outcome after 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}.
+     * Names the behavior reference — a plain registry key name, PERSISTED (mirrors
+     * {@link TaskDefinition.behavior} / {@link TaskSnapshot.behavior}), like {@link PhaseInterface.bail}.
      * `undefined` when this task has no behavior reference.
      */
-    readonly run: string | undefined;
+    readonly behavior: 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`. An omitted `run` is the deliberate no-op form. A present,
-     * unresolved `run` remains visible on exact restore, but the runner rejects it before
+     * Holds the RESOLVED runtime handler — RUNTIME-ONLY, NEVER persisted in a {@link TaskSnapshot}.
+     * Resolved ONCE at construction (build, restore, or a live mint) by looking `behavior` up in the
+     * workflow-level {@link WorkflowOptions.functions} registry: `functions?.[behavior]` when `behavior`
+     * is defined, else `undefined`. An omitted `behavior` is the deliberate no-op form. A present,
+     * unresolved `behavior` remains visible on exact restore, but the runner rejects it before
      * dispatch instead of falsely completing named work.
      */
     readonly handler: WorkflowFunction | undefined;
     /**
-     * Extra attempts after the first on failure — PERSISTED (mirrors {@link TaskDefinition.retries}
+     * Holds the 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 workflow-owned per-attempt deadline in milliseconds (`0..MAX_TIMER_MS`) — PERSISTED
+     * Holds the workflow-owned per-attempt deadline in milliseconds (`0..MAX_TIMER_MS`) — PERSISTED
      * (mirrors {@link TaskDefinition.timeout} / {@link TaskSnapshot.timeout}). Zero or
      * `undefined` means no deadline.
      */
     readonly timeout: number | undefined;
-    /** The last accepted reporter claim, absent while pending. */
+    /** Holds the last accepted reporter claim, absent while pending. */
     readonly activity: TaskActivity | undefined;
-    /** The effective host-safe silence window (`1..MAX_TIMER_MS`), or `undefined` when disabled. */
+    /** Holds the effective host-safe silence window (`1..MAX_TIMER_MS`), or `undefined` when disabled. */
     readonly silence: number | undefined;
-    /** Whether no report or pulse was accepted during the current silence window. */
+    /** Reports whether no report or pulse was accepted during the current silence window. */
     readonly silent: boolean;
-    /** Whether this task's cooperative execution gate is paused. */
+    /** Reports whether this task's cooperative execution gate is paused. */
     readonly paused: boolean;
-    /** This task's own cancellation signal; running/pending {@link stop} or {@link skip} fires it. */
+    /** Holds this task's own cancellation signal; running/pending {@link stop} or {@link skip} fires it. */
     readonly signal: AbortSignal;
     start(): void;
     complete(value: JSONValue): void;
@@ -2679,33 +3075,33 @@ export declare interface TaskInterface {
     skip(): void;
     stop(): void;
     /**
-     * Replace the complete observable activity of this running task.
+     * Replaces the complete observable activity of this running task.
      *
      * @param input - The complete operations, progress, and constraints replacement
      * @returns The accepted immutable frame; `MUTATION` for invalid input or `TRANSITION` when not running
      */
     report(input: TaskActivityInput): Result<TaskActivity, WorkflowError>;
     /**
-     * Confirm liveness without replacing the current operations, progress, or constraints.
+     * Confirms liveness without replacing the current operations, progress, or constraints.
      *
-     * @returns `true` when committed, or `false` when the task is not running
+     * @returns True if the pulse was committed while the task is running; false otherwise
      */
     pulse(): boolean;
-    /** Suspend this task's cooperative gate while pending or running; idempotent. */
+    /** Suspends this task's cooperative gate while pending or running; idempotent. */
     pause(): void;
-    /** Continue this task's cooperative gate; idempotent. */
+    /** Continues this task's cooperative gate; idempotent. */
     resume(): void;
     /**
-     * Park until this task is not paused.
+     * Parks until this task is not paused.
      *
-     * @returns A promise that resolves once the task gate is released
+     * @returns A promise that resolves after the task gate is released
      */
     wait(): Promise<void>;
     /**
-     * Apply a validated declarative patch to SELF (`name` / `description`).
+     * Applies a validated declarative patch to SELF (`name` / `description`).
      *
      * @remarks
-     * Defense-in-depth (AGENTS §12): the owning {@link TaskManagerInterface.update} gates
+     * Defense-in-depth: 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`.
@@ -2721,25 +3117,30 @@ export declare interface TaskInterface {
 }
 
 /**
- * The lean child manager (AGENTS §9) of a {@link import('../phases/Phase.js').Phase}'s live
- * tasks — an insertion-ordered registry keyed by task `id`, so positional order is
- * preserved across an interior `skip` / `remove`.
+ * Implements the lean child manager of a {@link import('../phases/Phase.js').Phase}'s live
+ * tasks — the task vocabulary over one insertion-ordered {@link Collection}, so positional order
+ * is preserved across an interior `skip` / `remove`.
  *
  * @remarks
- * - **Positional store.** Tasks live in an insertion-ordered `Map` keyed by `id`;
- *   `append` adds one at the end (the build-time wiring path), `task(id)` looks one up,
- *   `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
- *   their own emitters; the manager observes nothing.
+ * - **One shared store.** The insertion-ordered `Map`, the reorder step, the bounds checks, and
+ *   the gated `add` / `remove` / `move` / `update` all live in {@link Collection}, built with the
+ *   `task` noun its refusals name and the compiled {@link taskUpdateShape} guard. This class adds
+ *   the domain accessors `task` / `tasks` and nothing else, so the task and phase managers cannot
+ *   drift apart.
+ * - **Positional store.** `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. 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.** `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
+ *   `.claude/rules/patterns.md` § Batch operations (the bulk verb
+ *   overloads) is deliberately omitted — no `remove` family lives here.
+ * - **Event-free.** A purely structural container — the live {@link TaskInterface}s own their own
+ *   emitters; the manager observes nothing.
  *
  * @example
  * ```ts
@@ -2762,16 +3163,16 @@ export declare class TaskManager implements TaskManagerInterface {
 }
 
 /**
- * The lean child manager (AGENTS §9) of a {@link PhaseInterface}'s live tasks —
+ * Declares the lean child manager of a {@link PhaseInterface}'s live tasks —
  * positional accessors plus `count`, backed by an insertion-ordered store so order
  * is preserved across an interior `skip` / `remove`.
  *
  * @remarks
  * `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). `add` / `remove` / `move` /
- * `update` (AGENTS §12) are the GATED mutation counterparts a
+ * tally. No batch matrix (`.claude/rules/patterns.md` § Batch operations is deliberately omitted —
+ * a phase's tasks are a fixed positional set, not a bulk-mutated collection). `add` / `remove` / `move` /
+ * `update` 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).
@@ -2779,18 +3180,18 @@ export declare class TaskManager implements TaskManagerInterface {
 export declare interface TaskManagerInterface {
     readonly count: number;
     /**
-     * Add `task` at the end (the build-time wiring path).
+     * Adds `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
+     * `id` (a genuine programmer error — a build-time wiring bug) 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
+     * Inserts `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.
      *
@@ -2800,7 +3201,7 @@ export declare interface TaskManagerInterface {
      */
     add(task: TaskInterface, index?: number): Result<TaskInterface, WorkflowError>;
     /**
-     * Remove the `pending` task `id`.
+     * Removes the `pending` task `id`.
      *
      * @param id - The task id to remove
      * @returns A {@link Result} boxing the removed task, or a `MUTATION` failure when
@@ -2808,7 +3209,7 @@ export declare interface TaskManagerInterface {
      */
     remove(id: string): Result<TaskInterface, WorkflowError>;
     /**
-     * Reposition the `pending` task `id` to `index`.
+     * Repositions the `pending` task `id` to `index`.
      *
      * @param id - The task id to move
      * @param index - The destination position (`[0, count)`)
@@ -2817,7 +3218,7 @@ export declare interface TaskManagerInterface {
      */
     move(id: string, index: number): Result<TaskInterface, WorkflowError>;
     /**
-     * Apply a validated {@link TaskUpdate} patch to the `pending` task `id`.
+     * Applies a validated {@link TaskUpdate} patch to the `pending` task `id`.
      *
      * @param id - The task id to patch
      * @param patch - The fields to update
@@ -2830,24 +3231,21 @@ export declare interface TaskManagerInterface {
 }
 
 /**
- * One operation claimed active when a running task's complete frame was accepted.
+ * Represents one operation claimed active when a running task's complete frame was accepted.
  *
  * @remarks
- * `id` is stable within one complete activity report, `name` is the human-readable label,
- * and `started` is a finite non-negative reporter timestamp.
+ * A {@link TaskClaim}: `id` is stable within one complete activity report, `name` is the
+ * human-readable label, and `started` is a finite non-negative reporter timestamp.
  */
-export declare interface TaskOperation {
-    readonly id: string;
-    readonly name: string;
-    readonly started: number;
+export declare interface TaskOperation extends TaskClaim {
 }
 
 /**
- * The runtime options for a {@link TaskInterface} — the construction bag the live
+ * Declares the runtime options for a {@link TaskInterface} — the construction bag the live
  * leaf state machine (W-b) carries that the W-a {@link TaskDefinition} did not.
  *
  * @remarks
- * The reserved `on` (AGENTS §8) wires initial {@link TaskEventMap} listeners; a
+ * The reserved `on` wires initial {@link TaskEventMap} listeners; a
  * {@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
@@ -2855,17 +3253,17 @@ export declare interface TaskOperation {
  * {@link TaskInput.metadata}), never interpreted by the workflow.
  */
 export declare interface TaskOptions {
-    readonly on?: TaskHooks;
-    /** The emitter's listener-error handler (AGENTS §13) — a listener throw routes here, not to a domain event. */
+    readonly on?: EmitterHooks<TaskEventMap>;
+    /** Holds the emitter's listener-error handler — a listener throw routes here, not to a domain event. */
     readonly error?: EmitterErrorHandler;
-    /** An open consumer bag — stored and snapshotted, never interpreted by the workflow. */
+    /** Holds an open consumer bag — stored and snapshotted, never interpreted by the workflow. */
     readonly metadata?: JSONRecord;
-    /** Runtime-only silence window; non-positive, non-finite, or over-`MAX_TIMER_MS` disables inheritance. */
+    /** Sets the runtime-only silence window; non-positive, non-finite, or over-`MAX_TIMER_MS` disables inheritance. */
     readonly silence?: number;
 }
 
 /**
- * The aggregate progress most recently reported by a running task.
+ * Represents the aggregate progress most recently reported by a running task.
  *
  * @remarks
  * `progress` and an optional `total` are finite non-negative numbers; when `total` is present
@@ -2878,41 +3276,58 @@ export declare interface TaskProgress {
     readonly message?: string;
 }
 
+/**
+ * Represents the structured outcome of a task execution — its full lineage, its terminal
+ * status, the moment it settled, and its boxed produced outcome.
+ *
+ * @remarks
+ * Carries the complete lineage (`task` / `phase` / `workflow` contexts) so a result
+ * is self-describing wherever it travels. `status` is the terminal state this
+ * result records. `result` BOXES the produced outcome in a {@link Result}: it is
+ * PRESENT exactly when `status` is `completed` (a {@link import('@orkestrel/contract').Success})
+ * or `failed` (a {@link import('@orkestrel/contract').Failure}), and ABSENT when `status` is
+ * `skipped` or `stopped` (terminal, but produced no outcome) — a pending/running
+ * task has no result at all (a non-terminal status, per
+ * {@link import('./helpers.js').isTerminalStatus}). This boxed `result` REPLACES separate
+ * `value?` / `error?` fields: a success's payload is `result.value`, a failure's reason is `result.error`.
+ * `timestamp` is when the result was created (ms since epoch).
+ */
 export declare interface TaskResult {
     readonly task: TaskContext;
     readonly phase: PhaseContext;
     readonly workflow: WorkflowContext;
-    readonly status: TaskStatus;
-    /** The boxed outcome — present for `completed` (Success) / `failed` (Failure), absent otherwise. */
+    /** Holds the task's lifecycle status at the moment the result was recorded. */
+    readonly status: LifecycleStatus;
+    /** Holds the boxed outcome — present for `completed` (Success) / `failed` (Failure), absent otherwise. */
     readonly result?: Result<JSONValue, TaskFailure>;
     readonly timestamp: number;
 }
 
 /**
- * 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
+ * Describes the shape of a {@link import('./types.js').TaskDefinition} — identity plus an optional
+ * `behavior` 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: OptionalShape<StringShape>;
+    behavior: OptionalShape<StringShape>;
     retries: OptionalShape<NumberShape>;
     timeout: OptionalShape<NumberShape>;
 }, false>;
 
 /**
- * A JSON-serializable snapshot of one task's state — the leaf of the snapshot tree
+ * Represents a JSON-serializable snapshot of one task's state — the leaf of the snapshot tree
  * the durable store (W-d) persists.
  *
  * @remarks
  * 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
+ * `behavior` / `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
+ * behavior reference and reliability overrides (`behavior` re-resolves against the
  * {@link WorkflowOptions.functions} registry supplied to
  * {@link import('./factories.js').createRestoredWorkflow}); each omitted ⇒ the corresponding
  * unset default.
@@ -2921,46 +3336,31 @@ export declare interface TaskSnapshot {
     readonly id: string;
     readonly name: string;
     readonly description?: string;
-    readonly status: TaskStatus;
+    /** Holds the task's persisted lifecycle status. */
+    readonly status: LifecycleStatus;
     readonly result?: TaskResult;
     readonly metadata: JSONRecord;
-    /** Total launches already consumed; zero while fresh and never reset by recovery. */
+    /** Counts total launches already consumed; zero while fresh and never reset by recovery. */
     readonly attempts: number;
-    /** 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. */
+    /** Names the behavior reference — a registry key resolved against {@link WorkflowRegistry} on restore/build. */
+    readonly behavior?: string;
+    /** Records the extra attempts after the first on failure (a non-negative integer); overrides the phase Runner default. */
     readonly retries?: number;
-    /** Workflow-owned per-attempt deadline (`0..MAX_TIMER_MS`); zero or omission means disabled. */
+    /** Records the workflow-owned per-attempt deadline (`0..MAX_TIMER_MS`); zero or omission means disabled. */
     readonly timeout?: number;
-    /** Pending omits activity; running/completed/failed require it; skipped/stopped may retain it. */
+    /** Holds the task's activity: pending omits it; running/completed/failed require it; skipped/stopped may retain it. */
     readonly activity?: TaskActivity;
 }
 
 /**
- * The lifecycle status of a task — `pending` before it runs, `running` while in
- * flight, then one of the terminal states: `completed` (a success), `failed` (a
- * genuine error), `skipped` (intentionally not executed, AGENTS §10 `skip`), or
- * `stopped` (permanently ended, AGENTS §10 `stop`).
- *
- * @remarks
- * A semantic tier of the shared {@link LifecycleStatus} vocabulary. Uses `running` /
- * `failed` (the project vocabulary), and keeps `skipped` and `stopped` DISTINCT — a
- * skip is "deliberately not run", a stop is "ended early". The terminal members are
- * exactly those for which a {@link TaskResult} is meaningful: `completed` / `failed`
- * box a {@link Result}, while `skipped` / `stopped` are terminal WITHOUT a boxed
- * outcome. See {@link import('./helpers.js').isTerminalStatus}.
- */
-export declare type TaskStatus = LifecycleStatus;
-
-/**
- * A declarative partial update to a {@link TaskInterface} — the fields a `pending`
+ * Represents 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}.
+ * accept, runtime-validated through {@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
+ * never `behavior` / `retries` / `timeout` (a form/reliability change is a structural
+ * replace, not a patch) and never `id` (identity is immutable after creation). Every
  * field is optional; an omitted field is left unchanged.
  *
  * @example
@@ -2974,13 +3374,13 @@ export declare interface TaskUpdate {
 }
 
 /**
- * The shape of a {@link import('./types.js').TaskUpdate} — a partial edit to a
+ * Describes 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).
+ * `name` still has `minLength: 1`); never `id` / `behavior` / `retries` / `timeout` (those
+ * are not patchable fields).
  */
 export declare const taskUpdateShape: ObjectShape<{
     name: OptionalShape<StringShape>;
@@ -2988,38 +3388,18 @@ export declare const taskUpdateShape: ObjectShape<{
 }, false>;
 
 /**
- * The {@link TaskStatus} values that are TERMINAL — a task in one of these will
+ * Lists the {@link LifecycleStatus} values that are TERMINAL — a node in one of these will
  * not transition further, frozen.
  *
  * @remarks
  * The source of truth behind {@link import('./helpers.js').isTerminalStatus}.
  * `pending` and `running` are the only non-terminal members.
  */
-export declare const TERMINAL_TASK_STATUSES: readonly TaskStatus[];
+export declare const TERMINAL_STATUSES: readonly LifecycleStatus[];
 
 /**
- * One unit's settled outcome — a discriminated union so a value of `undefined` is still
- * a success (`{ ok: true, value: undefined }`), never mistaken for a failure or an
- * absent result.
- *
- * @remarks
- * The runner records each settled unit's outcome through this shape: a success boxes the
- * resolved `value` (presence tracked by the union tag, so `undefined` is a valid result),
- * a failure carries the `error` (always `unknown`). The FIRST failure is fail-fast.
- *
- * @typeParam TResult - The value a unit resolves
- */
-export declare type UnitOutcome<TResult> = {
-    readonly ok: true;
-    readonly value: TResult;
-} | {
-    readonly ok: false;
-    readonly error: unknown;
-};
-
-/**
- * The live DERIVED state machine (W-b) for a whole workflow — the observable (AGENTS §13)
- * ROOT whose {@link WorkflowStatus} is computed from its phases under the `bail` policy and
+ * Implements the live DERIVED state machine (W-b) for a whole workflow — the observable ROOT
+ * whose {@link LifecycleStatus} is computed from its phases under the `bail` policy and
  * recomputed reactively as the cascade propagates up from a task transition.
  *
  * @remarks
@@ -3032,7 +3412,7 @@ export declare type UnitOutcome<TResult> = {
  *   reachable ONLY under `bail: true` (a single failed task halts the workflow); under
  *   `bail: false` a failed phase folds into `completed`. `#recompute` diffs on each phase
  *   change; a CHANGE emits.
- * - **Override (AGENTS §10).** `skip` / `stop` FORCE the status; an executed task-free pending tree
+ * - **Override.** `skip` / `stop` FORCE the status; an executed task-free pending tree
  *   may also be force-completed vacuously. The override is PERSISTED in the snapshot's own
  *   `override` field and restored DIRECTLY (no divergence guess). The snapshot also persists
  *   `bail`, so a restore re-derives status identically without a silent policy default.
@@ -3041,12 +3421,12 @@ export declare type UnitOutcome<TResult> = {
  *   navigate UP.
  * - **Snapshot.** `snapshot()` serializes the whole live tree to a {@link WorkflowSnapshot} (pure
  *   JSON); {@link import('./factories.js').createRestoredWorkflow} rebuilds an equivalent live tree.
- * - **Observable (AGENTS §13).** The owned {@link emitter} ({@link WorkflowEventMap}) fires
+ * - **Observable.** The owned {@link emitter} ({@link WorkflowEventMap}) fires
  *   `start` / `complete` / `fail` / `pause` / `resume` / `skip` / `stop` after the
  *   corresponding status or runtime-gate 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
+ * - **Structural API.** `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
@@ -3055,26 +3435,41 @@ export declare type UnitOutcome<TResult> = {
  *   {@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
+ * - **Runtime lifecycle.** `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 `stop`s every non-terminal task and
  *   phase (releasing their gates and liveness resources), aborts {@link signal}, forces the
  *   workflow `stop` override when needed, releases its parked waiter, and marks
  *   {@link destroyed} — all idempotent.
+ *
+ * @example
+ * ```ts
+ * import { definitionToSnapshot, Workflow } from '@orkestrel/workflow'
+ *
+ * const definition = {
+ * 	id: 'release',
+ * 	name: 'Release',
+ * 	phases: [{ id: 'build', name: 'Build', tasks: [{ id: 'compile', name: 'Compile' }] }],
+ * }
+ * const workflow = new Workflow(definitionToSnapshot(definition))
+ * workflow.status // 'pending'
+ * workflow.phase('build')?.task('compile')?.status // 'pending'
+ * workflow.snapshot().id // 'release'
+ * ```
  */
 export declare class Workflow implements WorkflowInterface {
     #private;
-    readonly description?: string;
     constructor(snapshot: WorkflowSnapshot, options?: WorkflowOptions);
     get emitter(): EmitterInterface<WorkflowEventMap>;
     get id(): string;
     get name(): string;
+    get description(): string | undefined;
     get context(): WorkflowContext;
     get bail(): boolean;
     get paused(): boolean;
     get destroyed(): boolean;
     get signal(): AbortSignal;
-    get status(): WorkflowStatus;
+    get status(): LifecycleStatus;
     get phases(): PhaseManagerInterface;
     phase(id: string): PhaseInterface | undefined;
     results(): readonly TaskResult[];
@@ -3092,14 +3487,11 @@ export declare class Workflow implements WorkflowInterface {
     snapshot(): WorkflowSnapshot;
 }
 
-/** Every {@link WorkflowStatus} value, frozen — the lifecycle vocabulary of a workflow. */
-export declare const WORKFLOW_STATUSES: readonly WorkflowStatus[];
-
-/** A runner-owned durability boundary. */
+/** Names a runner-owned durability boundary. */
 export declare type WorkflowCheckpoint = 'initial' | 'attempt' | 'settlement' | 'final';
 
 /**
- * The ambient context of a workflow — the identity every level inherits.
+ * Represents the ambient context of a workflow — the identity every level inherits.
  *
  * @remarks
  * The root of the context chain: a {@link PhaseContext} and {@link TaskContext}
@@ -3113,13 +3505,13 @@ export declare interface WorkflowContext {
 }
 
 /**
- * The serializable definition of a whole workflow — its identity, its ordered
+ * Represents the serializable definition of a whole workflow — its identity, its ordered
  * phases, and the `bail` failure policy.
  *
  * @remarks
  * Pure JSON DATA — the root a UI/LLM authors and the contract validates. `phases`
  * are the workflow's phases, which run SEQUENTIALLY. `bail` is the failure policy
- * (a boolean behavioral toggle, AGENTS §4.4): `false` (the default) is GRACEFUL —
+ * (a boolean behavioral toggle): `false` (the default) is GRACEFUL —
  * a failed leaf task is recorded as data and the workflow still completes; `true`
  * is a database-transaction HALT — a single failed task propagates `failed` to the
  * whole workflow. See {@link import('./helpers.js').deriveWorkflowStatus}.
@@ -3129,20 +3521,21 @@ export declare interface WorkflowDefinition {
     readonly name: string;
     readonly description?: string;
     readonly phases: readonly PhaseDefinition[];
-    /** Failure policy: `false` (default) continues gracefully, `true` halts on the first failure. */
+    /** Sets the failure policy: `false` (default) continues gracefully, `true` halts on the first failure. */
     readonly bail?: boolean;
 }
 
 /**
- * An error raised by the workflow runtime.
+ * Represents an error raised by the workflow runtime.
  *
  * @remarks
  * Carries a {@link WorkflowErrorCode} and an optional `context` bag naming the
  * offending node id / status / parameter. Raised for an illegal lifecycle transition
  * (`TRANSITION`), a structurally invalid {@link import('./types.js').WorkflowSnapshot}
- * boundary (`RESTORE`), a refused structural/activity edit (`MUTATION`), or a host
+ * boundary (`RESTORE`), a refused structural/activity edit (`MUTATION`), a host
  * schedule refused before arming because the caller's `signal` is not a native
- * `AbortSignal` (`SCHEDULE`, delivered as a rejected promise).
+ * `AbortSignal` (`SCHEDULE`, delivered as a rejected promise), or a broken internal
+ * invariant (`INVARIANT`).
  */
 export declare class WorkflowError extends Error {
     readonly code: WorkflowErrorCode;
@@ -3151,12 +3544,12 @@ export declare class WorkflowError extends Error {
 }
 
 /**
- * The machine-readable code of a {@link import('./errors.js').WorkflowError} — the
- * fault the live W-b state machine raises (AGENTS §12).
+ * Names the machine-readable code of a {@link import('./errors.js').WorkflowError} — the
+ * fault the live W-b state machine raises.
  *
  * @remarks
- * - `TRANSITION` — an illegal state-machine transition (e.g. `start`ing a task that is
- *   not `pending`, or `complete`/`fail`ing one that is not `running`); the guard names
+ * - `TRANSITION` — an illegal state-machine transition (for example, `start`ing a task
+ *   that is not `pending`, or `complete`/`fail`ing one that is not `running`); the guard names
  *   the offending current status + requested transition in the error `context`.
  * - `RESTORE` — a {@link import('./factories.js').createRestoredWorkflow} given a structurally
  *   invalid {@link WorkflowSnapshot} (a status outside the lifecycle vocabulary).
@@ -3166,23 +3559,28 @@ export declare class WorkflowError extends Error {
  *   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` —
+ *   entity structural API 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
+ *   guard (both genuine programmer-error paths). The error `context` names
  *   the offending id / index / status.
  * - `SCHEDULE` — {@link import('./helpers.js').scheduleHost} refused to arm host work
  *   because the caller passed a `signal` that is not a native `AbortSignal`. The refusal
  *   is a REJECTED promise, never a synchronous throw, so every scheduler backend settles
  *   the same way whatever the caller passed. The error `context` names the offending
  *   parameter (`signal`) and the `typeof` the caller supplied.
+ * - `INVARIANT` — an internal invariant did not hold: a derived
+ *   `failed` node whose failing {@link TaskResult} is missing, or a tracked
+ *   {@link RunnerInterface} unit whose cancellation handle is absent. It is a programmer-error
+ *   guard on a path no input reaches, raised instead of fabricating a substitute value that
+ *   would type-check while masking the true cause. The error `context` names the offending node.
  */
-export declare type WorkflowErrorCode = 'TRANSITION' | 'RESTORE' | 'MUTATION' | 'SCHEDULE';
+export declare type WorkflowErrorCode = 'TRANSITION' | 'RESTORE' | 'MUTATION' | 'SCHEDULE' | 'INVARIANT';
 
 /**
- * The push observation surface (AGENTS §13) of the workflow entity (W-b) — the
- * lifecycle moments a fire-and-forget observer subscribes to via
+ * Declares the push observation surface of the workflow entity (W-b) — the
+ * lifecycle moments a fire-and-forget observer subscribes to through
  * `workflow.emitter.on`.
  *
  * @remarks
@@ -3193,40 +3591,39 @@ export declare type WorkflowErrorCode = 'TRANSITION' | 'RESTORE' | 'MUTATION' |
  * `stop` when it 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
+ * `update` — 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`
+ * `error` handler (the `error` option). Declared as a `type` alias (not
+ * `interface extends EventMap`) so the type-literal satisfies `EventMap`
  * structurally.
  */
 export declare type WorkflowEventMap = {
-    /** The workflow began — its `id`. */
+    /** Signals that the workflow began — its `id`. */
     readonly start: readonly [id: string];
-    /** Every phase settled successfully. */
+    /** Signals that every phase settled successfully. */
     readonly complete: readonly [];
-    /** A phase failed under `bail` — the failing task's result. */
+    /** Signals that a phase failed under `bail` — the failing task's result. */
     readonly fail: readonly [result: TaskResult];
-    /** The workflow's runtime gate closed. */
+    /** Signals that the workflow's runtime gate closed. */
     readonly pause: readonly [];
-    /** The workflow's runtime gate opened. */
+    /** Signals that the workflow's runtime gate opened. */
     readonly resume: readonly [];
-    /** The workflow was intentionally skipped. */
+    /** Signals that the workflow was intentionally skipped. */
     readonly skip: readonly [];
-    /** The workflow was permanently stopped. */
+    /** Signals that the workflow was permanently stopped. */
     readonly stop: readonly [];
-    /** A phase was inserted — the inserted phase + its final index. */
+    /** Signals that a phase was inserted — the inserted phase + its final index. */
     readonly add: readonly [phase: PhaseInterface, index: number];
-    /** A phase was removed — the removed phase. */
+    /** Signals that a phase was removed — the removed phase. */
     readonly remove: readonly [phase: PhaseInterface];
-    /** A phase was repositioned — the moved phase + its new index. */
+    /** Signals that a phase was repositioned — the moved phase + its new index. */
     readonly move: readonly [phase: PhaseInterface, index: number];
-    /** A phase was patched — the patched phase. */
+    /** Signals that a phase was patched — the patched phase. */
     readonly update: readonly [phase: PhaseInterface];
 };
 
-/** A normalized persistence failure surfaced as workflow result data. */
+/** Represents a normalized persistence failure surfaced as workflow result data. */
 export declare interface WorkflowFault {
-    readonly origin: 'persistence';
     readonly checkpoint: WorkflowCheckpoint;
     readonly message: string;
     readonly task?: string;
@@ -3234,9 +3631,9 @@ export declare interface WorkflowFault {
 }
 
 /**
- * A registered workflow function — the behavior a `function`-form
- * {@link TaskDefinition} runs, resolved BY NAME through the {@link WorkflowFunctions}
- * registry (AGENTS §4.5 — a `Handler` function type the framework invokes).
+ * Declares the registered behavior a `function`-form
+ * {@link TaskDefinition} runs, resolved BY NAME through the {@link WorkflowRegistry}
+ * registry — a function type the framework invokes.
  *
  * @remarks
  * Receives a {@link TaskControllerInterface} — the running task's folded `signal`, its
@@ -3244,50 +3641,34 @@ export declare interface WorkflowFault {
  * to earlier phases' {@link TaskResult}s. A returned value becomes the task's
  * {@link import('@orkestrel/contract').Success} ({@link TaskInterface.complete}); a throw / rejection
  * becomes its {@link import('@orkestrel/contract').Failure} ({@link TaskInterface.fail}). Long work
- * should honour `controller.signal` (a workflow-level abort / timeout / budget, or — under
+ * must honour `controller.signal` (a workflow-level abort / timeout / budget, or — under
  * `bail: true` — a sibling's failure, fires it) so a cancel stops it promptly.
  */
 export declare type WorkflowFunction = (controller: TaskControllerInterface) => Promise<JSONValue> | JSONValue;
 
-/**
- * The `function`-task behavior registry — workflow function names mapped to their
- * {@link WorkflowFunction} handlers.
- *
- * @remarks
- * A live {@link TaskInterface} resolves its `run` name against this registry ONCE at
- * construction into its {@link TaskInterface.handler}. An omitted `run` is the deliberate
- * no-op case. A present name absent from the registry remains inspectable but makes the tree
- * non-drivable until restored with a matching handler. 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>>;
-
-/** Initial {@link WorkflowEventMap} listeners — the reserved `on` option (AGENTS §8). */
-export declare type WorkflowHooks = EmitterHooks<WorkflowEventMap>;
-
-/** The minimal data to create a workflow context — a partial {@link WorkflowContext}. */
+/** Represents the minimal data to create a workflow context — a partial {@link WorkflowContext}. */
 export declare type WorkflowInput = Partial<WorkflowContext>;
 
 /**
- * The live derived state machine (W-b) for a whole {@link WorkflowDefinition} — the
- * observable (AGENTS §13) root whose {@link WorkflowStatus} is DERIVED from its phases
+ * Declares the live derived state machine (W-b) for a whole {@link WorkflowDefinition} — the
+ * observable root whose {@link LifecycleStatus} is DERIVED from its phases
  * under the `bail` policy and recomputed reactively as the cascade propagates up.
  *
  * @remarks
- * - **Derived status.** `status` is computed via
+ * - **Derived status.** `status` is computed through
  *   {@link import('./helpers.js').deriveWorkflowStatus} over the live phases' statuses,
  *   feeding the definition's `bail`, UNLESS an override is in force. It recomputes when a
  *   phase's status changes (the top of the cascade); a CHANGE emits — `fail` carries the
  *   failing {@link TaskResult} (under `bail: true`).
- * - **Children.** `phases` is the lean {@link PhaseManagerInterface} (AGENTS §9);
+ * - **Children.** `phases` is the lean {@link PhaseManagerInterface};
  *   `phase(id)` / `phases().phases()` read in positional order. `results` collects ALL
  *   tasks' results across every phase (the workflow tier of the result tree).
- * - **Override.** `skip` / `stop` (AGENTS §10) FORCE the workflow's status; `complete`
+ * - **Override.** `skip` / `stop` FORCE the workflow's status; `complete`
  *   may force only a task-free, otherwise-pending tree. The override survives a snapshot.
  * - **Snapshot.** `snapshot()` serializes the whole live tree to a {@link WorkflowSnapshot}
  *   (pure JSON — structure + each node's status + recorded results + positional order);
  *   {@link createRestoredWorkflow} rebuilds an equivalent live tree.
- * - **Observable (AGENTS §13).** The owned {@link emitter} ({@link WorkflowEventMap}) fires
+ * - **Observable.** The owned {@link emitter} ({@link WorkflowEventMap}) fires
  *   `start` / `complete` / `fail` / `pause` / `resume` / `stop` after the corresponding
  *   status or runtime-gate change; the emitter isolates a listener throw and routes it to
  *   its `error` handler (the `error` option).
@@ -3296,48 +3677,50 @@ export declare interface WorkflowInterface {
     readonly emitter: EmitterInterface<WorkflowEventMap>;
     readonly id: string;
     readonly name: string;
-    readonly description?: string;
+    /** Holds this workflow's prose, or `undefined` when the definition or snapshot declared none. */
+    readonly description: string | undefined;
     readonly context: WorkflowContext;
     readonly bail: boolean;
-    readonly status: WorkflowStatus;
+    /** Holds this workflow's effective lifecycle status, derived from its phases unless an override is in force. */
+    readonly status: LifecycleStatus;
     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
+     * Reports whether the workflow is paused (resumable); RUNTIME-ONLY —
+     * never a {@link LifecycleStatus}, 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. */
+    /** Reports 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
+     * Holds 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`. */
+    /** Looks 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. */
+    /** Lists 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.
+     * Forces this workflow to `skipped`, overriding the derived value; idempotent.
      *
      * @remarks
-     * A NO-OP once `status` is already terminal — a settled workflow cannot be re-forced.
+     * A NO-OP after `status` becomes 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.
+     * Forces this workflow to `stopped`, overriding the derived value; idempotent.
      *
      * @remarks
-     * A NO-OP once `status` is already terminal — a settled workflow cannot be re-forced. Always
+     * A NO-OP after `status` becomes 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.
+     * Forces this workflow to `completed`, overriding the derived value.
      *
      * @remarks
      * A NO-OP unless `status` is `pending` and the tree is genuinely vacuous: zero phases or
@@ -3346,11 +3729,11 @@ export declare interface WorkflowInterface {
      */
     complete(): void;
     /**
-     * Suspend the workflow (AGENTS §10 — resumable); idempotent.
+     * Suspends the workflow (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
+     * A no-op when already `paused`, when `status` is terminal, or after {@link destroyed} becomes true.
+     * RUNTIME-ONLY — never a {@link LifecycleStatus}, 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 /
@@ -3366,7 +3749,7 @@ export declare interface WorkflowInterface {
      */
     pause(): void;
     /**
-     * Continue a paused workflow (AGENTS §10); idempotent — a no-op unless {@link paused}.
+     * Continues a paused workflow; idempotent — a no-op unless {@link paused}.
      *
      * @example
      * ```ts
@@ -3376,7 +3759,7 @@ export declare interface WorkflowInterface {
      */
     resume(): void;
     /**
-     * Tear this workflow down (AGENTS §10) — an atomic TERMINAL teardown: mark
+     * Tears this workflow down — an atomic TERMINAL teardown: mark
      * {@link destroyed}, pin non-terminal workflow/phase overrides to `stopped`, stop every
      * non-terminal task, release gates and liveness resources, abort {@link signal}, then
      * destroy task, phase, and workflow emitters in ownership order; idempotent.
@@ -3394,26 +3777,26 @@ export declare interface WorkflowInterface {
      */
     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).
+     * Parks until this workflow is not paused — **promise-parked**, never a timer or
+     * busy-loop (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
+     * @returns A promise that resolves after 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
+     * Mints a live {@link PhaseInterface} (and its tasks) from `definition` and inserts it
+     * into this workflow (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}
+     * tasks — each task's `behavior` / `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
@@ -3423,9 +3806,9 @@ export declare interface WorkflowInterface {
      * {@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`)
+     * positions (no runner-installed hook), UNCHANGED from the entity-taking
+     * predecessor: refused outright while this workflow's own `status` is terminal or after
+     * {@link destroyed} becomes true. 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`
@@ -3439,20 +3822,20 @@ export declare interface WorkflowInterface {
      */
     add(definition: PhaseDefinition, index?: number): Result<PhaseInterface, WorkflowError>;
     /**
-     * Remove the `pending` phase `id` from this workflow.
+     * Removes 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).
+     * target's own `pending` status.
      *
      * @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.
+     * Repositions the `pending` phase `id` to `index` within this workflow.
      *
      * @remarks
      * NATIVE gating: refused while this workflow's own `status` is terminal. Otherwise BOTH
@@ -3465,7 +3848,7 @@ export declare interface WorkflowInterface {
      */
     move(id: string, index: number): Result<PhaseInterface, WorkflowError>;
     /**
-     * Apply a validated {@link PhaseUpdate} patch to the `pending` phase `id` in this workflow.
+     * Applies 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
@@ -3480,14 +3863,15 @@ export declare interface WorkflowInterface {
 }
 
 /**
- * The store-backed registry of {@link WorkflowInterface}s keyed by `id`, in insertion order —
+ * Implements the store-backed registry of {@link WorkflowInterface}s keyed by `id`, in insertion order —
  * the additive manager tier mirroring the `@orkestrel/agent` line's `ConversationManager` /
  * `WorkspaceManager`. Event-free (a registry, like its twins); the observability lives on each
  * {@link WorkflowInterface}.
  *
  * @remarks
  * - **Registry.** Workflows live in an insertion-ordered `Map` keyed by `id`. `add(definition)`
- *   mints a live {@link WorkflowInterface} through {@link createWorkflow} (flowing the manager's
+ *   mints a live {@link WorkflowInterface} through the same construction path
+ *   {@link import('./factories.js').createWorkflow} takes (flowing the manager's
  *   `functions` registry in) and stores it under `definition.id` — an already-present id
  *   OVERWRITES (last write wins). `count` is the map size, `workflow(id)` looks one up,
  *   `workflows()` lists them in insertion order.
@@ -3496,8 +3880,8 @@ export declare interface WorkflowInterface {
  *   earlier reads; wrong-key payloads reject with `RESTORE`. `save(id)` captures a registered
  *   workflow's snapshot at invocation and serializes same-id writes without coupling other ids.
  *   Both remain lenient without a store or registered id.
- * - **Removal.** `remove` drops one by id, or a batch (§9.2, array overload FIRST) — `true` when
- *   any was removed. `clear` empties the registry.
+ * - **Removal.** `remove` drops one by id, or a batch (array overload FIRST) — `true` only when
+ *   every id was removed. `clear` empties the registry.
  * - **No active pointer.** Unlike its `ConversationManager` / `WorkspaceManager` twins, there is
  *   no `active` / `switch` — nothing in the workflow domain renders "the current workflow".
  *
@@ -3526,21 +3910,21 @@ export declare class WorkflowManager implements WorkflowManagerInterface {
 }
 
 /**
- * A store-backed registry of {@link WorkflowInterface}s keyed by their `id`, in insertion
+ * Declares a store-backed registry of {@link WorkflowInterface}s keyed by their `id`, in insertion
  * order — the additive manager tier mirroring `ConversationManagerInterface` /
  * `WorkspaceManagerInterface` from the `@orkestrel/agent` line, adapted for the workflow
- * domain: `add` mints from a {@link WorkflowDefinition} (not an empty `Input`, since a
+ * domain: `add` mints from a {@link WorkflowDefinition} (not an empty `Input`, because a
  * workflow only exists relative to a definition), and the optional `store` seam's `open`
- * threads the manager's {@link WorkflowFunctions} registry so a HYDRATED workflow is
+ * threads the manager's {@link WorkflowRegistry} registry so a HYDRATED workflow is
  * immediately RUNNABLE, not merely a restored state mirror. NO `active` / `switch` pointer
- * (AGENTS §21) — the workflow domain has no consumer that renders "the current workflow" the
+ * — the workflow domain has no consumer that renders "the current workflow" the
  * way an agent context renders the active conversation/workspace.
  *
  * @remarks
  * - **Registry.** `count` is how many are stored. `add(definition)` mints a live
- *   {@link WorkflowInterface} via {@link import('./factories.js').createWorkflow} (flowing
+ *   {@link WorkflowInterface} through {@link import('./factories.js').createWorkflow} (flowing
  *   this manager's `functions` registry in) and registers it under `definition.id` — an
- *   already-present id OVERWRITES (last write wins, since `createWorkflow` keys the tree by
+ *   already-present id OVERWRITES (last write wins, because `createWorkflow` keys the tree by
  *   the definition's own id). `workflow(id)` looks one up (`undefined` when absent);
  *   `workflows()` lists them in insertion order.
  * - **Durable open / save (the optional `store` seam).** When a {@link WorkflowStoreInterface}
@@ -3562,8 +3946,8 @@ export declare class WorkflowManager implements WorkflowManagerInterface {
  *   `.save` — this is the workflow line's caller-driven persistence gaining the standard
  *   open/save seam, ADDITIVE alongside direct {@link WorkflowStoreInterface} use and
  *   {@link import('./factories.js').createRestoredWorkflow} (both remain valid).
- * - **Removal.** `remove` drops one by id, or a batch (§9.2, array overload FIRST) — `true`
- *   when any was removed. `clear` empties the registry.
+ * - **Removal.** `remove` drops one by id, or a batch (array overload FIRST) — `true` only
+ *   when every id was removed. `clear` empties the registry.
  * - **Event-free.** A purely registry store — no `Emitter`, no events (each
  *   {@link WorkflowInterface} owns its own {@link WorkflowEventMap} emitter).
  *
@@ -3583,7 +3967,7 @@ export declare interface WorkflowManagerInterface {
     workflow(id: string): WorkflowInterface | undefined;
     workflows(): readonly WorkflowInterface[];
     /**
-     * MINT a live {@link WorkflowInterface} from `definition` (via
+     * Mints a live {@link WorkflowInterface} from `definition` (through
      * {@link import('./factories.js').createWorkflow}, flowing this manager's `functions`
      * registry in) and register it under `definition.id`.
      *
@@ -3597,7 +3981,7 @@ export declare interface WorkflowManagerInterface {
      */
     add(definition: WorkflowDefinition): WorkflowInterface;
     /**
-     * Resolve a workflow by id — from the registry if present, else HYDRATED from the
+     * Resolves a workflow by id — from the registry if present, else HYDRATED from the
      * optional {@link WorkflowStoreInterface} (`store`), RUNNABLE (this manager's `functions`
      * registry is threaded into the rehydration).
      *
@@ -3605,7 +3989,7 @@ export declare interface WorkflowManagerInterface {
      * - If `id` is ALREADY registered, it is returned directly — no store hit.
      * - Same-id registry misses share one in-flight `store.get(id)` and resolve to the same live
      *   object. On a HIT the snapshot is
-     *   rehydrated into a fresh {@link WorkflowInterface} via
+     *   rehydrated into a fresh {@link WorkflowInterface} through
      *   {@link import('./factories.js').createRestoredWorkflow}, flowing this manager's `functions`
      *   registry in (so the rehydrated tree carries real resolved `handler`s and can RESUME
      *   real work), registers it, and returns it. A payload whose own id differs from `id` rejects
@@ -3621,7 +4005,7 @@ export declare interface WorkflowManagerInterface {
      */
     open(id: string): Promise<WorkflowInterface | undefined>;
     /**
-     * Persist a REGISTERED workflow's {@link WorkflowInterface.snapshot} to the optional
+     * Persists a REGISTERED workflow's {@link WorkflowInterface.snapshot} to the optional
      * {@link WorkflowStoreInterface} (`store`).
      *
      * @remarks
@@ -3631,17 +4015,34 @@ export declare interface WorkflowManagerInterface {
      * queued write. Otherwise (no store, OR an unknown id) it is a NO-OP returning `false`.
      *
      * @param id - The id of the registered workflow to persist
-     * @returns `true` when the snapshot was persisted; `false` when no store / unknown id
+     * @returns True if the snapshot was persisted; false otherwise (no store, or an unknown id)
      */
     save(id: string): Promise<boolean>;
+    /**
+     * Drops a batch of registered workflows, one per id.
+     *
+     * @remarks
+     * The array overload is declared FIRST, so a list resolves to the batch form. Every id is
+     * invalidated whether or not it was registered, so an absent id changes nothing else. An
+     * empty list returns `true` vacuously — no id failed to be removed.
+     *
+     * @param ids - The workflow ids to drop
+     * @returns True if every id was removed; false if any id was not registered
+     */
     remove(ids: readonly string[]): boolean;
+    /**
+     * Drops one registered workflow by id.
+     *
+     * @param id - The workflow id to drop
+     * @returns True if the id was registered and removed; false otherwise
+     */
     remove(id: string): boolean;
     clear(): void;
 }
 
 /**
- * Options for `createWorkflowManager` — the optional durable {@link WorkflowStoreInterface}
- * seam plus the {@link WorkflowFunctions} registry every workflow the manager mints or
+ * Declares the options for `createWorkflowManager` — the optional durable {@link WorkflowStoreInterface}
+ * seam plus the {@link WorkflowRegistry} registry every workflow the manager mints or
  * hydrates resolves its tasks' handlers against.
  *
  * @remarks
@@ -3649,16 +4050,16 @@ export declare interface WorkflowManagerInterface {
  * `WorkspaceManagerOptions.store` (the `@orkestrel/agent` line's store standard) — omitted ⇒
  * the manager is registry-only: {@link WorkflowManagerInterface.open} resolves only what is
  * already registered, and {@link WorkflowManagerInterface.save} is a no-op (`false`). `functions`
- * is the workflow-specific addition: the SAME {@link WorkflowFunctions} registry threaded into
+ * is the workflow-specific addition: the SAME {@link WorkflowRegistry} registry threaded into
  * every {@link import('./factories.js').createWorkflow} ({@link WorkflowManagerInterface.add})
  * and every {@link import('./factories.js').createRestoredWorkflow}
  * ({@link WorkflowManagerInterface.open}'s hydration path) the manager performs — so a
  * hydrated workflow carries real resolved `handler`s and is RUNNABLE. Omitted ⇒ named work
- * remains inspectable but cannot be driven; omitted-`run` tasks remain deliberate no-ops.
+ * remains inspectable but cannot be driven; omitted-`behavior` tasks remain deliberate no-ops.
  */
 export declare interface WorkflowManagerOptions {
     /**
-     * The optional durable {@link WorkflowStoreInterface} backing
+     * Holds the optional durable {@link WorkflowStoreInterface} backing
      * {@link WorkflowManagerInterface.open} / {@link WorkflowManagerInterface.save} — a memory
      * / JSON / SQLite / IndexedDB store a workflow is HYDRATED from (`open` a registry miss)
      * and PERSISTED to (`save`). Omitted ⇒ the manager is registry-only: `open` resolves only
@@ -3666,30 +4067,31 @@ export declare interface WorkflowManagerOptions {
      */
     readonly store?: WorkflowStoreInterface;
     /**
-     * The {@link WorkflowFunctions} registry threaded into every workflow this manager mints
-     * (`add`, via {@link import('./factories.js').createWorkflow}) or hydrates (`open`'s
-     * registry-miss path, via {@link import('./factories.js').createRestoredWorkflow}) — so a
+     * Holds the {@link WorkflowRegistry} registry threaded into every workflow this manager mints
+     * (`add`, through {@link import('./factories.js').createWorkflow}) or hydrates (`open`'s
+     * registry-miss path, through {@link import('./factories.js').createRestoredWorkflow}) — so a
      * hydrated workflow is RUNNABLE, its tasks carrying real resolved `handler`s. Omitted ⇒
      * named tasks remain inspectable but execution rejects them.
      */
-    readonly functions?: WorkflowFunctions;
+    readonly functions?: WorkflowRegistry;
 }
 
 /**
- * The runtime options for a {@link WorkflowInterface} — the construction bag the
+ * Declares the runtime options for a {@link WorkflowInterface} — the construction bag the
  * live derived workflow state machine (W-b) carries, the root {@link createWorkflow}
  * accepts.
  *
  * @remarks
- * The reserved `on` (AGENTS §8) wires initial {@link WorkflowEventMap} listeners.
+ * The reserved `on` wires initial {@link WorkflowEventMap} listeners.
  * `phases` keys per-phase {@link PhaseOptions} by phase `id`, so the whole tree's
  * initial listeners + per-task metadata can be supplied in one nested bag (the
- * AGENTS §8 "entity is the key" grouping), each leaf reachable by its lineage of ids.
+ * "entity is the key" grouping of `.claude/rules/names.md` § Group options by entity), each leaf
+ * reachable by its lineage of ids.
  */
 export declare interface WorkflowOptions {
-    readonly on?: WorkflowHooks;
+    readonly on?: EmitterHooks<WorkflowEventMap>;
     /**
-     * The failure policy (AGENTS §4.4) the live tree applies — the same boolean toggle as
+     * Sets the failure policy the live tree applies — the same boolean toggle as
      * {@link WorkflowDefinition.bail}, fed to {@link import('./helpers.js').deriveWorkflowStatus}.
      * {@link import('./factories.js').createWorkflow} defaults it to the definition's `bail`. A
      * {@link WorkflowSnapshot} PERSISTS the policy, so {@link import('./factories.js').createRestoredWorkflow}
@@ -3697,114 +4099,140 @@ export declare interface WorkflowOptions {
      * wins when supplied. Omitted on a fresh build ⇒ the graceful {@link import('./constants.js').DEFAULT_BAIL}.
      */
     readonly bail?: boolean;
-    /** The emitter's listener-error handler (AGENTS §13) — a listener throw routes here, not to a domain event. */
+    /** Holds the emitter's listener-error handler — a listener throw routes here, not to a domain event. */
     readonly error?: EmitterErrorHandler;
-    /** Per-phase {@link PhaseOptions}, keyed by the phase's `id`. */
+    /** Holds the 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
+     * Holds the `function`-task behavior registry ({@link WorkflowRegistry}) each live task's
+     * {@link TaskDefinition.behavior} / {@link TaskSnapshot.behavior} 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').createRestoredWorkflow}) both consume, and the same shape a
      * live {@link WorkflowInterface.add} / {@link PhaseInterface.add} mint resolves a newly
-     * minted task against. An omitted `run` resolves to no handler and is the deliberate
+     * minted task against. An omitted `behavior` resolves to no handler and is the deliberate
      * no-op form. A present name absent from `functions` also has no handler so exact restore
      * remains inspectable, but {@link WorkflowRunnerInterface.execute} rejects that tree.
-     * Omitted ⇒ an empty registry; only tasks that also omit `run` are executable no-ops.
+     * Omitted ⇒ an empty registry; only tasks that also omit `behavior` are executable no-ops.
      */
-    readonly functions?: WorkflowFunctions;
-    /** Runtime-only default silence; non-positive, non-finite, or over-`MAX_TIMER_MS` disables it. */
+    readonly functions?: WorkflowRegistry;
+    /** Sets the runtime-only default silence; non-positive, non-finite, or over-`MAX_TIMER_MS` disables it. */
     readonly silence?: number;
 }
 
 /**
- * Advanced run-local snapshot persistence with one writer and one coalesced latest obligation.
+ * Coordinates advanced run-local snapshot persistence with one writer and one coalesced most recent obligation.
  *
  * @remarks
  * Normally composed by `WorkflowRunner.execute({ store })`; exported for hosts that need to
  * coordinate the same required boundaries around their own runner integration.
+ *
+ * @example
+ * ```ts
+ * import { WorkflowPersistence, createMemoryWorkflowStore, createWorkflow } from '@orkestrel/workflow'
+ *
+ * const workflow = createWorkflow({ id: 'durable', name: 'Durable', phases: [] })
+ * const persistence = new WorkflowPersistence(workflow, createMemoryWorkflowStore())
+ * await persistence.checkpoint('initial')
+ * const durable = await persistence.finalize()
+ * persistence.detach() // idempotent after finalize
+ * ```
  */
 export declare class WorkflowPersistence implements WorkflowPersistenceInterface {
     #private;
     constructor(workflow: WorkflowInterface, store: WorkflowStoreInterface);
     get fault(): WorkflowFault | undefined;
     /**
-     * Persist every change through this required boundary.
+     * Persists every change through this required boundary.
      *
      * @param checkpoint - The boundary being made durable
      * @param task - The task owning an attempt or settlement
      * @param attempt - The persisted attempt number
-     * @returns Whether the latest state reached the store
+     * @returns True if the most recent state reached the store; false otherwise
      */
     checkpoint(checkpoint: WorkflowCheckpoint, task?: TaskInterface, attempt?: number): Promise<boolean>;
     /**
-     * Stop observing the live tree and persist its final state.
+     * Stops observing the live tree and persists its final state.
      *
-     * @returns Whether the final snapshot reached the store
+     * @returns True if the final snapshot reached the store; false otherwise
      */
     finalize(): Promise<boolean>;
-    /** Stop observing the live tree. */
+    /** Stops observing the live tree. */
     detach(): void;
 }
 
 /**
- * The advanced run-local durability coordinator normally composed by
+ * Declares the advanced run-local durability coordinator normally composed by
  * {@link WorkflowRunnerInterface.execute} when `store` is supplied.
  */
 export declare interface WorkflowPersistenceInterface {
-    /** The first required checkpoint failure, if one occurred. */
+    /** Records the first required checkpoint failure, if one occurred. */
     readonly fault: WorkflowFault | undefined;
     /**
-     * Make the latest state durable at one required boundary.
+     * Makes the most recent state durable at one required boundary.
      *
      * @param checkpoint - The required durability boundary
      * @param task - The task owning an attempt or settlement
      * @param attempt - The persisted one-based attempt number
-     * @returns Whether the latest live state reached the store
+     * @returns True if the most recent live state reached the store; false otherwise
      */
     checkpoint(checkpoint: WorkflowCheckpoint, task?: TaskInterface, attempt?: number): Promise<boolean>;
-    /** Detach observers and make the final live state durable. */
+    /** Detaches observers and makes the final live state durable. */
     finalize(): Promise<boolean>;
-    /** Stop observing the live workflow tree; idempotent. */
+    /** Stops observing the live workflow tree; idempotent. */
     detach(): void;
 }
 
 /**
- * The structured outcome of a {@link WorkflowRunnerInterface.execute} run — the settled
+ * Declares the `function`-task behavior registry — workflow function names mapped to their
+ * {@link WorkflowFunction} handlers.
+ *
+ * @remarks
+ * A live {@link TaskInterface} resolves its `behavior` name against this registry ONCE at
+ * construction into its {@link TaskInterface.handler}. An omitted `behavior` is the deliberate
+ * no-op case. A present name absent from the registry remains inspectable but makes the tree
+ * non-drivable until restored with a matching handler. A plain record (not a manager) — the
+ * registry is a lookup, with no lifecycle of its own.
+ */
+export declare type WorkflowRegistry = Readonly<Record<string, WorkflowFunction>>;
+
+/**
+ * Represents the structured outcome of a {@link WorkflowRunnerInterface.execute} run — the settled
  * live workflow, its final status, and the flattened result tree.
  *
  * @remarks
  * Boxes the settled {@link WorkflowInterface} itself (so a caller can navigate the whole
  * live tree — every phase / task's final `status`, its recorded {@link TaskResult}, its
  * lineage) ALONGSIDE the two read-throughs the run produced: `status` is the workflow's
- * derived {@link WorkflowStatus} at settle (`completed` under graceful mode even with
+ * derived {@link LifecycleStatus} at settle (`completed` under graceful mode even with
  * failed leaves; `failed` under `bail: true`; `stopped` on a workflow-level abort /
  * timeout / budget), and `results` is the workflow-tier {@link TaskResult} list (every
  * settled task across all phases, in positional order — the same array `workflow.results()`
- * yields). Returning the live `workflow` (not just a snapshot) keeps the entity tree the
+ * yields). Returning the live `workflow` (not only a snapshot) keeps the entity tree the
  * source of truth — the runner adds only the convenience `status` / `results` projections.
  * A scheduler or other engine-infrastructure failure rejects after the runner coherently
  * stops remaining work and attempts final persistence.
  */
 export declare interface WorkflowResult {
     readonly workflow: WorkflowInterface;
-    readonly status: WorkflowStatus;
+    /** Holds the workflow's derived lifecycle status at settle. */
+    readonly status: LifecycleStatus;
     readonly results: readonly TaskResult[];
-    /** Whether the returned final state is stored; omitted when no store was supplied. */
+    /** Reports whether the returned final state is stored; omitted when no store was supplied. */
     readonly durable?: boolean;
-    /** The first required persistence failure; omitted when none occurred. */
+    /** Records the first required persistence failure; omitted when none occurred. */
     readonly fault?: WorkflowFault;
 }
 
 /**
- * The thin orchestrator that EXECUTES a live W-b workflow tree by COMPOSING the shipped
+ * Implements the thin orchestrator that EXECUTES a live W-b workflow tree by COMPOSING the shipped
  * 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
+ *   {@link createRunner} per phase (the substrate {@link import('./types.js').RunnerInterface}
+ *   over the workers
  *   `Queue`); `bail` maps onto that Runner's fail-fast vs settle-all; the run-level abort /
  *   timeout / budget / entity `signal` fold through the `@orkestrel/abort` signal contract,
  *   {@link createTimeout}, and `AbortSignal.any` (exactly as the agent runtime folds its bounds);
@@ -3818,15 +4246,15 @@ export declare interface WorkflowResult {
  *   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". Provider, protocol, and tool
+ *   dispatch is "invoke the task's own handler". Provider, protocol, and tool
  *   integrations remain application-owned {@link import('./types.js').WorkflowFunction}s
  *   composed into {@link WorkflowOptions.functions}. This module imports none of them.
  * - **Two `execute` forms, one engine.** `execute(definition, options)` BUILDS the live tree
- *   from a {@link WorkflowDefinition} (single source of truth for the `run` / `concurrency`
+ *   from a {@link WorkflowDefinition} (single source of truth for the `behavior` / `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
+ *   {@link WorkflowInterface} instead — the entity-native control surface
+ *   (`pause` / `resume` / `add` / `stop` / `destroy` live on the entity itself). Both forms
+ *   converge on the SAME `#execute` engine: neither reads a `WorkflowDefinition` after 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)
@@ -3840,7 +4268,7 @@ export declare interface WorkflowResult {
  *   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. An omitted `run` deliberately
+ *   {@link import('./types.js').TaskInterface.handler} directly. An omitted `behavior` deliberately
  *   auto-completes with JSON `null`; a present unresolved name is rejected by the synchronous
  *   execution claim and never false-completes.
  * - **`bail` → substrate.** Under `bail: true` (halt) a genuine task failure `fail`s the leaf
@@ -3871,25 +4299,25 @@ export declare interface WorkflowResult {
  *   and the workflow is force-`stop`ped (settles `stopped`). Each task's
  *   {@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 application-level `execute` cannot clobber the outer run's
- *   state.
+ * - **Re-entrant-safe.** No shared per-run mutable field: each `#execute` mints its own
+ *   {@link import('./RunHolder.js').RunHolder}, so a nested application-level `execute` cannot
+ *   clobber the outer run's state.
  */
 export declare class WorkflowRunner implements WorkflowRunnerInterface {
     #private;
     constructor(scheduler: SchedulerInterface);
     /**
-     * Execute a workflow definition to completion — BUILD its live tree, run the phases
+     * Executes a workflow definition to completion — BUILDS its live tree, runs 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
+     * truth — the per-task `behavior` 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
+     * `behavior` 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
@@ -3901,7 +4329,8 @@ export declare class WorkflowRunner implements WorkflowRunnerInterface {
      *
      * @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`)
+     *   `phases` / `functions`) PLUS the per-run bounds (`signal` / `timeout` / `budget`) and the
+     *   durable `store`
      * @returns The run's terminal {@link WorkflowResult} (its `workflow` is the built tree)
      * @example
      * ```ts
@@ -3911,24 +4340,24 @@ export declare class WorkflowRunner implements WorkflowRunnerInterface {
      */
     execute(definition: WorkflowDefinition, options?: WorkflowRunOptions): Promise<WorkflowResult>;
     /**
-     * Drive an ALREADY-BUILT, CALLER-OWNED live {@link WorkflowInterface} — the entity-native
+     * Drives 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'`, `!workflow.destroyed`, and no
+     * the SAME entity mid-run through its own `pause` / `resume` / `add` / `stop` / `destroy`.
+     * Requires `workflow.status === 'pending'`, `!workflow.destroyed`, and no
      * prior execution claim. A process-local object-identity claim shared by all runner instances
      * is acquired synchronously and never released, so a same-object second call throws a `TRANSITION`
-     * {@link WorkflowError} before any asynchronous status change. Once accepted, observable
+     * {@link WorkflowError} before any asynchronous status change. After acceptance, 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.
+     * mid-run is picked up and actually dispatched. `options` carries only the per-run run
+     * controls — the bounds (`signal` / `timeout` / `budget`) and the durable `store` — because the
+     * construction half of {@link WorkflowRunOptions} does not apply to a tree that already exists.
      *
      * @param workflow - The live {@link WorkflowInterface} to drive
-     * @param options - The per-run bounds (`signal` / `timeout` / `budget`)
+     * @param options - The per-run bounds (`signal` / `timeout` / `budget`) and the durable `store`
      * @returns The run's terminal {@link WorkflowResult} (its `workflow` is the SAME entity passed in)
      * @example
      * ```ts
@@ -3943,43 +4372,43 @@ export declare class WorkflowRunner implements WorkflowRunnerInterface {
 }
 
 /**
- * A thin orchestrator that EXECUTES a live {@link WorkflowInterface} tree by composing the
+ * Declares a thin orchestrator that EXECUTES a live {@link WorkflowInterface} tree by composing the
  * 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
- * (via {@link import('./factories.js').createWorkflow}) and drives it to a terminal
+ * (through {@link import('./factories.js').createWorkflow}) and drives it to a terminal
  * {@link WorkflowResult} — phases SEQUENTIALLY and, within each phase, the tasks CONCURRENTLY
  * 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 field the snapshot deliberately dropped — each task's `run` (resolved into
+ * EXECUTION-ONLY field the snapshot deliberately dropped — each task's `behavior` (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}; an omitted `run` is the only
+ * invokes each task's OWN {@link TaskInterface.handler}; an omitted `behavior` is the only
  * auto-completing no-op. 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
+ * run through `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` /
+ * entity-native control surface (`pause` / `resume` / `add` / `stop` /
  * `destroy` live on {@link WorkflowInterface} itself); see its own doc for details.
  */
 export declare interface WorkflowRunnerInterface {
     /**
-     * Execute a workflow definition to completion — BUILD its live tree, run the phases
+     * Executes a workflow definition to completion — BUILDS its live tree, runs 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` (resolved into its {@link TaskInterface.handler}) and per-phase
+     * truth — the per-task `behavior` (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`
@@ -3995,7 +4424,7 @@ 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
+     * **Programmer-error exception.** A PATHOLOGICAL `definition` (for example, 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}. Unexpected scheduler or engine-infrastructure
@@ -4004,23 +4433,23 @@ export declare interface WorkflowRunnerInterface {
      *
      * @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`)
+     *   `phases`) PLUS the per-run bounds (`signal` / `timeout` / `budget`) and the durable `store`
      * @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
+     * Drives 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):
+     * The entity itself is 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'`,
+     * controls the SAME entity mid-run through its own `pause` / `resume` / `add` / `stop` /
+     * `destroy`. Requires `workflow.status === 'pending'`,
      * `!workflow.destroyed`, and no prior execution claim. A process-local object-identity claim
      * shared by every runner instance is acquired synchronously and never released, so a same-object
      * call throws a `TRANSITION` {@link import('./errors.js').WorkflowError} even before an
-     * asynchronous status change. Once accepted, phases run
+     * asynchronous status change. After acceptance, 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
@@ -4029,30 +4458,31 @@ export declare interface WorkflowRunnerInterface {
      * 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.
+     * immediately. `options` carries only the per-run RUN CONTROLS — the bounds (`signal` /
+     * `timeout` / `budget`) and the durable `store` — because the construction half of
+     * {@link WorkflowRunOptions} does not apply to a tree that already exists.
      *
      * **Run round-trips through the snapshot.** Driving a tree rebuilt by
      * {@link import('./factories.js').createRestoredWorkflow} 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
+     * {@link WorkflowRegistry} registry was supplied at that build: WITH a registry,
+     * each task's `behavior` 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,
-     * the persisted {@link TaskInterface.run} remains visible for inspection while `handler` is
+     * the persisted {@link TaskInterface.behavior} remains visible for inspection while `handler` is
      * `undefined`, and this overload rejects the tree before dispatch. A quiescent recovered tree may contain
      * terminal work plus pending work; a tree with any `running` leaf is not 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)
+     * @param options - The per-run bounds (`signal` / `timeout` / `budget`) and the durable
+     *   `store`; 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 optional pacing scheduler the runner
+ * Declares the options for `createWorkflowRunner` — the optional pacing scheduler the runner
  * paces phase boundaries with.
  *
  * @remarks
@@ -4063,8 +4493,8 @@ export declare interface WorkflowRunnerInterface {
  *   `yield` between phases). Omitted ⇒ the shipped cross-environment default
  *   ({@link createScheduler}).
  *
- * The reserved `on` key (AGENTS §8) is intentionally ABSENT: the runner is THIN and drives
- * the W-b entities' OWN emitters (subscribe via `workflow.emitter` / `phase.emitter` /
+ * The reserved `on` key is intentionally ABSENT: the runner is THIN and drives
+ * the W-b entities' OWN emitters (subscribe through `workflow.emitter` / `phase.emitter` /
  * `task.emitter`), so it owns no event map of its own — there is nothing for an `on` to
  * wire. A future runner-level emitter would introduce its own `EmitterHooks` here.
  */
@@ -4073,12 +4503,13 @@ export declare interface WorkflowRunnerOptions {
 }
 
 /**
- * The options for one {@link WorkflowRunnerInterface.execute} call — the live tree's
- * CONSTRUCTION options ({@link WorkflowOptions}) PLUS the per-run BOUNDS (an external abort,
- * a deadline, and a cost ceiling), each bound folded into every task's cancellation.
+ * Declares the options for one {@link WorkflowRunnerInterface.execute} call — the live tree's
+ * CONSTRUCTION options ({@link WorkflowOptions}) PLUS the per-run RUN CONTROLS: the bounds
+ * (an external abort, a deadline, and a cost ceiling), each folded into every task's
+ * cancellation, and the optional durable `store`.
  *
  * @remarks
- * `execute` is single-source: it BUILDS the live tree from the definition internally (via
+ * `execute` is single-source: it BUILDS the live tree from the definition internally (through
  * {@link import('./factories.js').createWorkflow}), so these options carry BOTH halves of
  * that one call —
  * - the **construction** half is {@link WorkflowOptions} (`on` initial listeners, the `bail`
@@ -4086,9 +4517,10 @@ export declare interface WorkflowRunnerOptions {
  *   so construction-time emitter listeners, a `bail` override, and per-node options all apply
  *   to the tree it builds (`createWorkflow` resolves `bail` as `options.bail ?? definition.bail
  *   ?? DEFAULT_BAIL`); and
- * - the **run-control** half is the three bounds below, used only for the run-level fold.
+ * - the **run-control** half is the bounds and the `store` below; the bounds feed the run-level
+ *   fold and the store makes the run durable.
  *
- * The three bounds compose via `AbortSignal.any` (exactly as the agent runtime folds its
+ * The three bounds compose through `AbortSignal.any` (exactly as the agent runtime folds its
  * own): a fire of ANY of them cancels every in-flight task (its
  * {@link TaskControllerInterface.signal} fires) and HALTS the run — the remaining tasks
  * and phases are `skip`ped and the workflow settles `stopped`.
@@ -4100,6 +4532,17 @@ 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.)
  *
+ * `store` is not a bound. Supplying a {@link WorkflowStoreInterface} makes the run DURABLE: the
+ * runner composes a {@link WorkflowPersistenceInterface} over it and writes the live
+ * {@link WorkflowSnapshot} at each required checkpoint — before the first phase, around every
+ * attempt and settlement, and once more when the run finishes — so an interrupted run is
+ * recoverable from the store through
+ * {@link import('./factories.js').createRecoveredWorkflow}. It also adds the two durability
+ * read-throughs to the result: {@link WorkflowResult.durable} reports whether the FINAL state
+ * reached the store, and {@link WorkflowResult.fault} carries the first required write that
+ * failed. Both are OMITTED without a store, because a run that was never asked to persist has
+ * nothing to report. A required checkpoint that fails stops the run rather than continuing work
+ * whose state is no longer recoverable. This half applies to BOTH `execute` overloads.
  */
 export declare type WorkflowRunOptions = WorkflowOptions & {
     readonly signal?: AbortSignal;
@@ -4109,7 +4552,7 @@ export declare type WorkflowRunOptions = WorkflowOptions & {
 };
 
 /**
- * The shape of a {@link import('./types.js').WorkflowDefinition} — the contract root:
+ * Describes the shape of a {@link import('./types.js').WorkflowDefinition} — the contract root:
  * identity, its ordered {@link phaseShape} phases, and the optional `bail` boolean
  * failure policy (the literal pair `true`/`false`, the runtime mirror of the boolean
  * toggle; omitted ⇒ the graceful default).
@@ -4126,7 +4569,7 @@ export declare const workflowShape: ObjectShape<{
             id: StringShape;
             name: StringShape;
             description: OptionalShape<StringShape>;
-            run: OptionalShape<StringShape>;
+            behavior: OptionalShape<StringShape>;
             retries: OptionalShape<NumberShape>;
             timeout: OptionalShape<NumberShape>;
         }, false>>;
@@ -4137,7 +4580,7 @@ export declare const workflowShape: ObjectShape<{
 }, false>;
 
 /**
- * A JSON-serializable snapshot of a whole workflow's state — its identity, status, its
+ * Represents a JSON-serializable snapshot of a whole workflow's state — its identity, status, its
  * forced override (if any), the `bail` policy it ran under, its nested phase snapshots,
  * and creation / update timestamps.
  *
@@ -4145,7 +4588,7 @@ export declare const workflowShape: ObjectShape<{
  * Pure JSON DATA — the COMPLETE, SELF-CONTAINED payload the durable store (W-d) persists,
  * designed in full at W-a so its shape is fixed from the start. It can be written to disk,
  * sent to a prompt companion, loaded across conversations, or reviewed by an agent. Because
- * it is self-contained, it carries the policy it ran under: `bail` (AGENTS §4.4) is the
+ * it is self-contained, it carries the policy it ran under: `bail` is the
  * failure policy, so {@link import('./factories.js').createRestoredWorkflow} re-derives status
  * IDENTICALLY without a silent default. `status` is the EFFECTIVE status (override-or-derived)
  * at snapshot time; `override` is the forced status of a whole-workflow `skip` / `stop` or
@@ -4158,21 +4601,19 @@ export declare interface WorkflowSnapshot {
     readonly id: string;
     readonly name: string;
     readonly description?: string;
-    readonly status: WorkflowStatus;
-    /** Whole-workflow `skip` / `stop` or valid task-free vacuous `completed`; omitted when derived. */
-    readonly override?: WorkflowStatus;
-    /** The failure policy the workflow ran under (AGENTS §4.4) — persisted so a restore re-derives identically. */
+    /** Holds the workflow's persisted effective lifecycle status (override-or-derived). */
+    readonly status: LifecycleStatus;
+    /** Records a whole-workflow `skip` / `stop` or a valid task-free vacuous `completed`; omitted when derived. */
+    readonly override?: LifecycleStatus;
+    /** Records the failure policy the workflow ran under — persisted so a restore re-derives identically. */
     readonly bail: boolean;
     readonly phases: readonly PhaseSnapshot[];
     readonly created: number;
     readonly updated: number;
 }
 
-/** Locate the nearest identifiable node for an inconsistent owned snapshot. */
-export declare function workflowSnapshotContext(value: unknown): Readonly<Record<string, unknown>> | undefined;
-
 /**
- * One row of the table a {@link import('./stores/DatabaseWorkflowStore.js').DatabaseWorkflowStore}
+ * Represents one row of the table a {@link import('./stores/DatabaseWorkflowStore.js').DatabaseWorkflowStore}
  * persists — a workflow `id` plus its {@link WorkflowSnapshot} held as ONE OPAQUE JSON column.
  *
  * @remarks
@@ -4181,30 +4622,22 @@ export declare function workflowSnapshotContext(value: unknown): Readonly<Record
  * `@orkestrel/queue`'s `StoredEntry` stores a queue entry's `input`), so the row
  * type stays FLAT and the deeply-nested snapshot shape (workflow → phases → tasks → results) never
  * forces the contract to `Infer` it — sidestepping a TS2589 instantiation-depth blow-up. The column
- * therefore reads back as the broad `unknown`; the store narrows it to a {@link WorkflowSnapshot} on
- * `get` ({@link import('./helpers.js').isWorkflowSnapshot}, the AGENTS §14 boundary narrow). `id`
+ * therefore reads back as the broad `unknown`; the store owns and narrows it to a
+ * {@link WorkflowSnapshot} on `get` through {@link import('./cloners.js').cloneWorkflowSnapshot},
+ * whose semantic pass is {@link import('./validators.js').isOwnedWorkflowSnapshot} — the
+ * boundary narrow, which also key-checks the row and refuses a mismatch. The total guard
+ * {@link import('./validators.js').isWorkflowSnapshot} is the same boundary narrow for a caller
+ * holding an untrusted payload of its own. `id`
  * mirrors {@link WorkflowSnapshot.id} (the primary key), so a `set` writes `{ id: snapshot.id, snapshot }`.
  */
 export declare interface WorkflowSnapshotRow {
     readonly id: string;
-    /** The whole {@link WorkflowSnapshot} as one opaque JSON blob — read back as `unknown`, narrowed on `get`. */
+    /** Holds the whole {@link WorkflowSnapshot} as one opaque JSON blob — read back as `unknown`, narrowed on `get`. */
     readonly snapshot: unknown;
 }
 
 /**
- * The lifecycle status of a workflow — the same vocabulary as {@link TaskStatus},
- * derived from its phases' statuses under the `bail` policy.
- *
- * @remarks
- * A semantic tier of the shared {@link LifecycleStatus} vocabulary. `failed` is
- * reachable ONLY under `bail: true` (a single failed task halts the whole workflow);
- * under `bail: false` a workflow `completed`s even with failed leaf tasks. See
- * {@link import('./helpers.js').deriveWorkflowStatus}.
- */
-export declare type WorkflowStatus = LifecycleStatus;
-
-/**
- * The durable persistence seam for a {@link WorkflowSnapshot} — three async primitives
+ * Declares the durable persistence seam for a {@link WorkflowSnapshot} — three async primitives
  * (`get` / `set` / `delete`) keyed by a workflow id, the snapshot analogue of
  * the server package's `SessionStoreInterface` (and the `@orkestrel/queue`
  * `QueueStoreInterface` driver-swap pattern).
@@ -4225,11 +4658,12 @@ export declare type WorkflowStatus = LifecycleStatus;
  * `id`). UNLIKE a session store there is NO idle-TTL / eviction — a persisted workflow run-state
  * lives until an explicit `delete`, never silently expiring (it is durable orchestration state,
  * not an ephemeral session). It is concrete over {@link WorkflowSnapshot} — no generic parameter
- * (AGENTS §21 minimal-interface), since the snapshot is the ONE payload a workflow store persists.
+ * (the smallest interface the capability requires), because the snapshot is the ONE payload a
+ * workflow store persists.
  */
 export declare interface WorkflowStoreInterface {
     /**
-     * Resolve the persisted snapshot for `id`, or `undefined` if none is stored.
+     * Resolves the persisted snapshot for `id`, or `undefined` if none is stored.
      * A present payload whose own `id` differs from the requested storage key is corrupt and
      * rejects with a normalized `RESTORE` error carrying both ids.
      *
@@ -4238,14 +4672,14 @@ export declare interface WorkflowStoreInterface {
      */
     get(id: string): Promise<WorkflowSnapshot | undefined>;
     /**
-     * Insert or replace a snapshot under its own `snapshot.id` (no separate id param —
+     * Inserts or replaces a snapshot under its own `snapshot.id` (no separate id param —
      * mirroring `QueueStoreInterface.save` from `@orkestrel/queue`).
      *
      * @param snapshot - The snapshot to store (keyed by its `id`)
      */
     set(snapshot: WorkflowSnapshot): Promise<void>;
     /**
-     * Drop a snapshot by id; an absent id is a no-op (no throw).
+     * Drops a snapshot by id; an absent id is a no-op (no throw).
      *
      * @param id - The workflow id to drop
      */