@orkestrel/workflow 0.0.17 → 0.0.18

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

@@ -1,30 +1,30 @@
 import { ArrayShape } from '@orkestrel/contract';
-import { BudgetInterface } from '@orkestrel/budget';
-import { ContractInterface } from '@orkestrel/contract';
-import { DriverInterface } from '@orkestrel/database';
-import { EmitterErrorHandler } from '@orkestrel/emitter';
-import { EmitterHooks } from '@orkestrel/emitter';
-import { EmitterInterface } from '@orkestrel/emitter';
-import { Failure } from '@orkestrel/contract';
-import { Guard } from '@orkestrel/contract';
-import { JSONRecord } from '@orkestrel/contract';
-import { JSONValue } from '@orkestrel/contract';
+import type { BudgetInterface } from '@orkestrel/budget';
+import type { ContractInterface } from '@orkestrel/contract';
+import type { DriverInterface } from '@orkestrel/database';
+import type { EmitterErrorHandler } from '@orkestrel/emitter';
+import type { EmitterHooks } from '@orkestrel/emitter';
+import type { EmitterInterface } from '@orkestrel/emitter';
+import type { Failure } from '@orkestrel/contract';
+import type { Guard } from '@orkestrel/contract';
+import type { JSONRecord } from '@orkestrel/contract';
+import type { JSONValue } from '@orkestrel/contract';
 import { LiteralShape } from '@orkestrel/contract';
 import { NumberShape } from '@orkestrel/contract';
 import { ObjectShape } from '@orkestrel/contract';
 import { OptionalShape } from '@orkestrel/contract';
-import { Result } from '@orkestrel/contract';
+import type { Result } from '@orkestrel/contract';
 import { StringShape } from '@orkestrel/contract';
-import { Success } from '@orkestrel/contract';
-import { TableInterface } from '@orkestrel/database';
-import { TokenUsage } from '@orkestrel/budget';
+import type { Success } from '@orkestrel/contract';
+import type { TableInterface } from '@orkestrel/database';
+import type { TokenUsage } from '@orkestrel/budget';
 
 /**
  * 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
+ * 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),
@@ -38,7 +38,7 @@ export declare type AttemptOutcome = readonly [settled: true, value: JSONValue]
  * 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)
+ * @param workflow - The parent workflow context (the lineage pointer up the tree)
  * @param node - The phase's identity (`id` / `name` / optional `description`)
  * @returns The {@link PhaseContext}
  */
@@ -49,7 +49,7 @@ export declare function buildPhaseContext(workflow: WorkflowContext, node: Workf
  * (and, transitively, its workflow) — from the parent {@link PhaseContext} and the task
  * node's identity.
  *
- * @param phase - The parent phase context (carrying the full lineage UP the tree)
+ * @param phase - The parent phase context (carrying the full lineage up the tree)
  * @param node - The task's identity (`id` / `name` / optional `description`)
  * @returns The {@link TaskContext}
  */
@@ -169,9 +169,9 @@ export declare function cloneWorkflowSnapshot(input: unknown, id?: string): Work
  *   (`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
+ * - **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`
+ *   {@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.
@@ -232,12 +232,12 @@ export declare interface CollectionEntry<TPatch> {
  * mutation quartet a lean manager delegates to.
  *
  * @remarks
- * The ONE engine behind {@link TaskManagerInterface} and {@link PhaseManagerInterface}: positional
+ * 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`
+ * `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
+ * `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.
@@ -251,7 +251,7 @@ export declare interface CollectionInterface<TEntry, TPatch> {
      * Adds `entry` at the end — the build-time wiring path.
      *
      * @remarks
-     * THROWS a `MUTATION` {@link import('./errors.js').WorkflowError} on a duplicate `id` instead
+     * 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
@@ -332,7 +332,7 @@ export declare function collectResults(phases: ReadonlyArray<readonly TaskResult
  * - `input` — the unit's work payload.
  * - `signal` — the unit's cancellation: fires on the unit's own `abort()`, a
  *   runner-level `abort` (the runner aborts every unit), or this attempt's timeout
- *   expiring (it reflects the underlying queue attempt's signal, which ANY-combines
+ *   expiring (it reflects the underlying queue attempt's signal, which any-combines
  *   all three).
  * - `aborted` — whether the unit's cancellation has fired.
  *
@@ -346,7 +346,7 @@ export declare interface ControllerInterface<TInput, TResult> {
     readonly signal: AbortSignal;
     readonly aborted: boolean;
     /**
-     * Parks until this unit's `signal` aborts — **promise-parked**, never a timer.
+     * Parks until this unit's `signal` aborts — a promise-parked wait, never a timer.
      *
      * @remarks
      * Resolves the moment the unit's `signal` fires (unit abort, runner abort, or
@@ -365,10 +365,10 @@ export declare interface ControllerInterface<TInput, TResult> {
      * as every declared unit, so it actually runs (in FIFO wake order) and its result
      * joins the run's ordered output after the declared units, in spawn order. The
      * runner's `execute` awaits the full transitive spawn closure (it tracks an
-     * outstanding-unit count, not a one-time snapshot), so a caller does NOT need to
+     * outstanding-unit count, not a one-time snapshot), so a caller does not need to
      * await the returned promise to make the sibling run.
      *
-     * **Deadlock caveat.** On a bounded-`concurrency` runner, do NOT `await` a
+     * **Deadlock caveat.** On a bounded-`concurrency` runner, do not `await` a
      * `spawn`ed promise *inline* from within a handler — the handler holds a queue
      * slot while it awaits, and if every slot is held by a handler awaiting its own
      * spawn, no slot is free to run the spawns and the run deadlocks. The intended
@@ -389,22 +389,22 @@ export declare interface ControllerInterface<TInput, TResult> {
 /**
  * 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}.
+ * {@link createMemoryWorkflowStore}. It holds the snapshot as one opaque JSON column, and its
+ * `driver` defaults to memory, so it works before any durable driver is passed.
  *
  * @remarks
- * Builds a one-table database (`snapshots`, keyed by `id`) over the supplied driver, the snapshot
- * held as ONE OPAQUE JSON COLUMN — the column map is `{ id; snapshot }` where `snapshot` is a
+ * Builds a one-table database (`snapshots`, keyed by `id`) over the supplied driver. The column map
+ * is `{ id; snapshot }` where `snapshot` is a
  * `rawShape` (a JSON blob), exactly as `createDatabaseQueueStore` stores its `input`. The
- * 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
+ * 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`, 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 —
+ * {@link import('./validators.js').isOwnedWorkflowSnapshot}). 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
- * {@link WorkflowStoreInterface} WITHOUT touching the runner or the entity tree.
+ * {@link WorkflowStoreInterface} without touching the runner or the entity tree.
  *
  * @param driver - The storage backend the snapshots persist to (defaults to {@link createMemoryDriver})
  * @returns A {@link WorkflowStoreInterface} over the driver
@@ -425,18 +425,17 @@ export declare function createDatabaseWorkflowStore(driver?: DriverInterface): W
 
 /**
  * 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.
+ * {@link MemoryWorkflowStore} persisting {@link WorkflowSnapshot}s by workflow id, the default
+ * backend behind the W-d persistence seam. It takes no options and expires nothing: a
+ * persisted run state lives until an explicit `delete`.
  *
  * @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 (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
+ * (and the `createMemoryQueueStore` family) 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
- * driver, and it swaps in WITHOUT touching the runner or the entity tree. Restore stays a caller
+ * table) — for a durable store (run-state surviving a restart) pass it a JSON / SQLite / IndexedDB
+ * driver, and it swaps in without touching the runner or the entity tree. Restore stays a caller
  * concern: read a snapshot back and rebuild the live tree with {@link createRestoredWorkflow}.
  *
  * @returns A memory-backed {@link WorkflowStoreInterface}
@@ -455,7 +454,8 @@ export declare function createDatabaseWorkflowStore(driver?: DriverInterface): W
 export declare function createMemoryWorkflowStore(): WorkflowStoreInterface;
 
 /**
- * Builds an interrupted workflow back to life at its remaining retry budget.
+ * Builds an interrupted workflow back to life at its remaining retry budget, normalizing a
+ * leaf whose attempts are exhausted into a recovery failure.
  *
  * @remarks
  * Each phase captures every unique initial `behavior` binding once before constructing tasks. Recovery
@@ -483,11 +483,11 @@ export declare function createRecoveredWorkflow(snapshot: unknown, options?: Wor
  *
  * @remarks
  * Round-trip fidelity is paramount: a `snapshot()` → `createRestoredWorkflow()` reproduces the
- * same status at every node (each `#override` restored DIRECTLY from the snapshot's own
+ * same status at every node (each `#override` restored directly from the snapshot's own
  * `override` field, not guessed from a status divergence), the same recorded
  * {@link import('./types.js').TaskResult}s, and the same positional order (an interior
- * `skip` / `remove` survives). The snapshot is SELF-CONTAINED — it persists the `bail`
- * policy it ran under, so the restore re-derives status IDENTICALLY without a silent
+ * `skip` / `remove` survives). The snapshot is self-contained — it persists the `bail`
+ * policy it ran under, so the restore re-derives status identically without a silent
  * default; the snapshot's `bail` is the source of truth, while an explicit `options.bail`
  * 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
@@ -512,12 +512,13 @@ export declare function createRestoredWorkflow(snapshot: unknown, options?: Work
 
 /**
  * Creates a thin generic orchestrator that drives declared units — and any they
- * `spawn` — through a bounded-concurrency queue, collecting their results in order.
+ * `spawn` — through a bounded-concurrency queue, collecting their results in order and
+ * failing the run fast on the first genuine unit failure.
  *
  * @remarks
  * The Runner composes the workers `Queue` for backpressure, FIFO ordering, bounded
  * concurrency, retries, and the per-attempt timeout — it adds only orchestration, not
- * a second concurrency engine. `execute(inputs)` runs the unit set ONCE (a second call
+ * a second concurrency engine. `execute(inputs)` runs the unit set once (a second call
  * throws) and resolves the units' results in order: the declared inputs first, then
  * any `spawn`ed siblings in spawn order. Each unit's handler gets a `Controller` — its
  * `id` / `input`, a `signal` that fires on the unit's `abort`, a runner-level `abort`,
@@ -527,8 +528,8 @@ export declare function createRestoredWorkflow(snapshot: unknown, options?: Work
  * typed `emitter` surfaces `start` / `unit` / `spawn` / `settle` / `fail` / `finish` / `abort`.
  *
  * 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 do NOT `await` a spawn inline (a slot-holding
+ * outstanding-unit count, not a one-time snapshot), a handler need not await its spawns
+ * 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
@@ -605,20 +606,20 @@ export declare function createScheduler(): SchedulerInterface;
  * 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.
+ * context, its emitter, and the cascade, and every node born `pending`.
  *
  * @remarks
- * The definition is the DECLARATIVE blueprint; this seeds an initial all-`pending`
+ * The definition is the declarative blueprint; this seeds an initial all-`pending`
  * {@link WorkflowSnapshot} from it ({@link definitionToSnapshot}) and constructs the live
  * tree over that one path. The `bail` failure policy resolves to `options.bail`, else the
  * 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 nested-by-id bag). The W-b tree is the
- * state machine ONLY — it does not execute tasks (W-c drives the transitions).
+ * state machine only — it does not execute tasks (W-c drives the transitions).
  *
  * `options.functions` is the {@link import('./types.js').WorkflowRegistry} registry each live
- * task's `behavior` name resolves against ONCE at construction into its runtime
+ * 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.
  *
@@ -669,15 +670,17 @@ export declare function createWorkflowContract(): ContractInterface<WorkflowDefi
 /**
  * Creates a {@link WorkflowManagerInterface} — the store-backed registry of
  * {@link WorkflowInterface}s, the additive manager tier mirroring the `@orkestrel/agent`
- * line's `createConversationManager` / `createWorkspaceManager`.
+ * line's `createConversationManager` / `createWorkspaceManager`. The returned registry makes
+ * hydrated named work runnable when `options.functions` is supplied, and leaves it
+ * inspectable when it is not.
  *
  * @remarks
  * `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
+ * {@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
- * is PURELY ADDITIVE: direct {@link WorkflowStoreInterface} use and
+ * is purely additive: direct {@link WorkflowStoreInterface} use and
  * {@link createRestoredWorkflow} remain valid — the manager is one more caller-driven persistence
  * seam, not a replacement.
  *
@@ -692,7 +695,7 @@ export declare function createWorkflowContract(): ContractInterface<WorkflowDefi
  * 	store: createMemoryWorkflowStore(),
  * 	functions: { compile: async (controller) => `built ${controller.task.id}` },
  * })
- * const workflow = manager.add(definition) // minted, registered, RUNNABLE
+ * const workflow = manager.add(definition) // minted, registered, runnable
  * await manager.save(workflow.id)          // persisted to the store
  * const reopened = await manager.open(workflow.id) // already registered — no store hit
  * ```
@@ -700,22 +703,22 @@ export declare function createWorkflowContract(): ContractInterface<WorkflowDefi
 export declare function createWorkflowManager(options?: WorkflowManagerOptions): WorkflowManagerInterface;
 
 /**
- * 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.
+ * 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. The
+ * engine is pure — it carries no behavior or provider registry, and its only option is the
+ * scheduler it paces phase boundaries with.
  *
  * @remarks
- * The runner is a PURE engine — it re-implements no concurrency / retry / abort logic, AND it
- * carries no behavior or provider registry of its own: each live task already
- * resolved its own {@link import('./types.js').WorkflowFunction} into
- * {@link import('./types.js').TaskInterface.handler} ONCE at construction, from the
+ * Each live task already resolved its own {@link import('./types.js').WorkflowFunction} into
+ * {@link import('./types.js').TaskInterface.handler} once at construction, from the
  * {@link WorkflowOptions.functions} registry supplied to `execute` / {@link createWorkflow}.
  * Per-phase bounded concurrency is one {@link createRunner} per phase; `bail` maps onto that
  * Runner's fail-fast (`true` — the first failure aborts the in-flight siblings + skips the
  * rest) vs settle-all (`false` — failures are recorded, the run finishes); the run-level abort
  * / timeout / budget ({@link import('./types.js').WorkflowRunOptions}) fold through
  * `AbortSignal.any` (the agent runtime's pattern); pacing is the shipped scheduler.
- * `execute(definition, options?)` BUILDS the live tree from the definition itself (through
+ * `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}.
@@ -729,19 +732,43 @@ export declare function createWorkflowManager(options?: WorkflowManagerOptions):
  *   See {@link WorkflowRunnerOptions}.
  * @returns A working {@link WorkflowRunnerInterface}
  *
- * @example
+ * @example Author a definition and run it
  * ```ts
  * import { createWorkflowRunner } from '@orkestrel/workflow'
+ * import type { WorkflowDefinition } from '@orkestrel/workflow'
+ *
+ * const definition: WorkflowDefinition = {
+ * 	id: 'release',
+ * 	name: 'Release',
+ * 	phases: [
+ * 		{
+ * 			id: 'build',
+ * 			name: 'Build',
+ * 			tasks: [
+ * 				{ id: 'compile', name: 'Compile', behavior: 'compile' },
+ * 				{ id: 'lint', name: 'Lint', behavior: 'lint' },
+ * 			],
+ * 		},
+ * 		{
+ * 			id: 'ship',
+ * 			name: 'Ship',
+ * 			tasks: [{ id: 'publish', name: 'Publish', behavior: 'publish' }],
+ * 		},
+ * 	],
+ * }
+ *
+ * const runner = createWorkflowRunner() // a pure engine — no registries
  *
- * const runner = createWorkflowRunner()
- * const definition = { id: 'w', name: 'W', phases: [{ id: 'p', name: 'P', tasks: [
- * 	{ id: 't', name: 'T', behavior: 'compile' },
- * ] }] }
  * const result = await runner.execute(definition, {
- * 	functions: { compile: async (controller) => `built ${controller.task.id}` },
+ * 	functions: {
+ * 		compile: async (controller) => `built ${controller.task.id}`,
+ * 		lint: async () => 'clean',
+ * 		publish: async () => 'published',
+ * 	},
  * })
  * result.status // 'completed'
- * result.workflow.phase('p')?.task('t')?.status // 'completed'
+ * result.workflow.phase('build')?.task('compile')?.status // 'completed'
+ * result.results // every settled task's TaskResult, in positional order
  * ```
  */
 export declare function createWorkflowRunner(options?: WorkflowRunnerOptions): WorkflowRunnerInterface;
@@ -753,14 +780,14 @@ export declare function createWorkflowRunner(options?: WorkflowRunnerOptions): W
  * @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
+ * {@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
+ * `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
+ * 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
@@ -784,28 +811,28 @@ export declare function createWorkflowTree(definition: WorkflowDefinition, captu
 
 /**
  * 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
+ * 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}.
  *
  * @remarks
  * The store is driver-agnostic: it holds a single {@link TableInterface} whose backend
  * (memory, JSON, SQLite, IndexedDB) is chosen by whoever builds it (the factories), so a
- * JSON / SQLite / IndexedDB backend swaps in WITHOUT touching the runner or the entity tree
+ * JSON / SQLite / IndexedDB backend swaps in without touching the runner or the entity tree
  * — the same seam as `@orkestrel/queue`'s `DatabaseQueueStore`.
  * The driver defaults to memory ({@link import('../factories.js').createDatabaseWorkflowStore}
- * passes `createMemoryDriver()`), so it ALSO works in memory out of the box; you opt into the
+ * passes `createMemoryDriver()`), so it also works in memory out of the box; you opt into the
  * durable plumbing by passing a JSON / SQLite / IndexedDB driver.
  *
- * The {@link WorkflowSnapshot} is stored as ONE OPAQUE JSON COLUMN — the table is a row of
+ * The {@link WorkflowSnapshot} is stored as one opaque JSON column — the table is a row of
  * `{ id; snapshot }` ({@link WorkflowSnapshotRow}), the snapshot the whole JSON blob (a `rawShape`
  * column the factory builds) — exactly as `DatabaseQueueStore` stores its `input`. The snapshot is
- * already a COMPLETE, self-contained, pure-JSON payload, so storing it whole is lossless AND
+ * already a complete, self-contained, pure-JSON payload, so storing it whole is lossless and
  * sidesteps a TS2589 instantiation-depth blow-up: a structured multi-column table would force the
  * contract to `Infer` the deeply-nested snapshot shape (workflow → phases → tasks → results),
  * tripping the compiler — one JSON column keeps the row type flat (`snapshot` reads back as `unknown`).
  *
- * - **`set(snapshot)` upserts under the snapshot's OWN `id`** (no separate id param) — it writes
+ * - **`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**, owning and narrowing the opaque JSON
  *   column back to a {@link WorkflowSnapshot} through
@@ -815,9 +842,9 @@ export declare function createWorkflowTree(definition: WorkflowDefinition, captu
  *   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
+ * 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
+ * explicit `delete`. The public surface is exactly `get` / `set` / `delete` — no extra members (the
  * 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}.
  *
@@ -845,40 +872,43 @@ export declare class DatabaseWorkflowStore implements WorkflowStoreInterface {
     constructor(table: TableInterface<WorkflowSnapshotRow>);
     /** Resolves and key-checks the snapshot for `id`, narrowing the opaque column to `WorkflowSnapshot`. */
     get(id: string): Promise<WorkflowSnapshot | undefined>;
-    /** Inserts or replaces 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>;
     /** Drops a snapshot by id; an absent id is a no-op (no throw). */
     delete(id: string): Promise<void>;
 }
 
-/** Names the default {@link import('./types.js').WorkflowDefinition.bail} — graceful (continue on a leaf failure). */
+/**
+ * Names the default {@link import('./types.js').WorkflowDefinition.bail}, `false` — the graceful
+ * policy that records a leaf failure and finishes every phase.
+ */
 export declare const DEFAULT_BAIL = false;
 
 /**
  * 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.
+ * throttle — `1024`, a cap that is effectively unbounded for any realistic phase.
  *
  * @remarks
- * The determinism principle fixes that a phase's tasks run CONCURRENTLY; `concurrency` is
+ * The determinism principle fixes that a phase's tasks run concurrently; `concurrency` is
  * only an optional resource throttle (max-in-flight). With none declared, the runner runs
  * all of a phase's tasks at once — modelled as this finite cap so the value flows straight
  * into the substrate {@link import('./types.js').RunnerInterface}'s `concurrency` (which
  * expects a positive integer) without a special unbounded branch. No realistic phase
  * declares enough tasks to reach it, so it behaves as "run them all".
  *
- * WHY `1024` and not a huge sentinel like `1_000_000`: the backing `@orkestrel/queue` Runner
- * EAGERLY spawns one parked worker loop per concurrency unit AT CONSTRUCTION, so this default
+ * why `1024` and not a huge sentinel like `1_000_000`: the backing `@orkestrel/queue` Runner
+ * eagerly spawns one parked worker loop per concurrency unit at construction, so this default
  * must be a value whose eager allocation cost is negligible for every default-concurrency
  * phase — a million-unit default meant ~1e6 promise/closure allocations per such phase. A
- * phase may still DECLARE a larger explicit `concurrency` and pays that allocation knowingly.
+ * phase may still declare a larger explicit `concurrency` and pays that allocation knowingly.
  */
 export declare const DEFAULT_PHASE_CONCURRENCY = 1024;
 
 /**
- * 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.
+ * 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 a fresh build and for a restore alike.
  *
  * @remarks
  * The structural fields (`id` / `name` / `description` + the ordered phases / tasks)
@@ -887,20 +917,20 @@ export declare const DEFAULT_PHASE_CONCURRENCY = 1024;
  * `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
+ * 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 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
+ * The optional `bail` override is the effective workflow policy the tree will run under
  * (`createWorkflow` / the runner resolve `options.bail ?? definition.bail ?? DEFAULT_BAIL` and
- * pass it here), so an `options.bail` override reaches BOTH the workflow tier AND the
+ * pass it here), so an `options.bail` override reaches both the workflow tier and the
  * inheritance default of every phase that declares no `bail` of its own — otherwise the
  * per-phase seeds would silently ignore the override. Omitted ⇒ the definition's own `bail`
  * (defaulting to the graceful {@link import('./constants.js').DEFAULT_BAIL}).
  *
  * @param definition - The workflow definition to seed from
- * @param bail - The EFFECTIVE workflow bail to seed both tiers with (defaults to the definition's)
+ * @param bail - The effective workflow bail to seed both tiers with (defaults to the definition's)
  * @returns An initial, all-`pending` {@link WorkflowSnapshot}
  */
 export declare function definitionToSnapshot(definition: WorkflowDefinition, bail?: boolean): WorkflowSnapshot;
@@ -913,7 +943,7 @@ export declare function definitionToSnapshot(definition: WorkflowDefinition, bai
  * {@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
+ * 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`.
@@ -931,18 +961,19 @@ export declare function definitionToSnapshot(definition: WorkflowDefinition, bai
 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.
+ * 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, or the
+ * list's length where it has none.
  *
  * @remarks
  * 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`
+ * 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 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
+ * none is `pending` (nothing is safely editable). A `pending` container's entries are all
  * `pending`, so the boundary is `0` and every position is naturally accepted — callers
  * need no special case for that.
  *
@@ -959,14 +990,14 @@ export declare function delayHost(ms: number, signal?: AbortSignal): Promise<voi
 export declare function deriveBoundary(statuses: readonly LifecycleStatus[]): number;
 
 /**
- * Derives a phase's status from its tasks' statuses (tasks are concurrent, so this
- * is an order-insensitive reduction).
+ * Derives a phase's status from its tasks' statuses, the most severe terminal status winning
+ * (tasks are concurrent, so this is an order-insensitive reduction).
  *
  * @remarks
  * The truth table (most-severe terminal wins; `bail`-agnostic — a phase surfaces a
  * task failure as `failed` so the workflow's `bail` policy can decide):
  * - no tasks ⇒ `pending`.
- * - any task `running`, OR a mix of started-and-unsettled tasks (some non-`pending`
+ * - any task `running`, or a mix of started-and-unsettled tasks (some non-`pending`
  *   but not all terminal) ⇒ `running`.
  * - every task `pending` ⇒ `pending`.
  * - all terminal: any `failed` ⇒ `failed`; else any `stopped` ⇒ `stopped`; else any
@@ -983,23 +1014,24 @@ export declare function derivePhaseStatus(tasks: readonly LifecycleStatus[]): Li
 
 /**
  * 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).
+ * paired with the effective `bail` it ran under (`phase.bail ?? workflow.bail`) — so the
+ * failure outcome is aware of each phase's own policy, and `failed` is reachable only where
+ * that policy is `true` (phases are sequential, but the derivation is an order-insensitive
+ * reduction over the settled set).
  *
  * @remarks
  * `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
+ * {@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
  *   `failed` (the database-transaction halt) — even when the workflow default is graceful.
- * - **A `failed` phase whose effective `bail` is `false` (graceful)** is DATA, not a workflow
- *   failure — it folds into completion like a settled phase. A graceful failed phase NEVER
+ * - **A `failed` phase whose effective `bail` is `false` (graceful)** is data, not a workflow
+ *   failure — it folds into completion like a settled phase. A graceful failed phase never
  *   makes the workflow `failed` — even when the workflow default is strict.
  *
  * The rest of the table is shared:
  * - no phases ⇒ `pending`.
- * - any phase `running`, OR a mix of started-and-unsettled phases (some non-`pending`
+ * - any phase `running`, or a mix of started-and-unsettled phases (some non-`pending`
  *   but not all terminal) ⇒ `running`.
  * - every phase `pending` ⇒ `pending`.
  * - all terminal (a `failed` phase counts as terminal here): any `stopped` ⇒ `stopped`; else
@@ -1040,7 +1072,7 @@ export declare function failure<E>(error: E): Failure<E>;
  *
  * @remarks
  * The shared leaf behind {@link import('./phases/Phase.js').Phase} and
- * {@link import('./Workflow.js').Workflow}'s own `#failure` — each gathers ITS tier's
+ * {@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 invariant throw (a derived `failed`
  * status means a failing result exists) because throwing on `undefined` is
@@ -1105,7 +1137,7 @@ export declare function insertEntry<T>(entries: ReadonlyArray<readonly [string,
  * @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
+ * 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.
@@ -1121,12 +1153,13 @@ export declare function insertEntry<T>(entries: ReadonlyArray<readonly [string,
 export declare function isCompletable(workflow: WorkflowInterface): boolean;
 
 /**
- * Tests whether a driving run must stop giving a workflow more work.
+ * Tests whether a driving run must stop giving a workflow — or one forced phase of it —
+ * 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
+ * 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
@@ -1189,7 +1222,7 @@ export declare function isOwnedWorkflowSnapshot(value: unknown): value is Workfl
  * 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
+ * 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.
  *
@@ -1206,11 +1239,11 @@ export declare function isOwnedWorkflowSnapshot(value: unknown): value is Workfl
 export declare function isSkipping(task: TaskInterface, controller: ControllerInterface<TaskInterface, void>, runSignal: AbortSignal): boolean;
 
 /**
- * Tests whether forcing a workflow `stopped` would still record something.
+ * Tests whether forcing a workflow `stopped` would still record the cancellation.
  *
  * @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
+ * 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
@@ -1232,7 +1265,7 @@ 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
+ * 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.
@@ -1313,7 +1346,7 @@ export declare function isTaskFailure(value: unknown): value is TaskFailure;
  *
  * @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
+ * 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`,
@@ -1340,11 +1373,11 @@ export declare function isTaskFailure(value: unknown): value is TaskFailure;
 export declare function isTaskResult(value: unknown, workflow: unknown, phase: unknown, task: unknown): value is TaskResult;
 
 /**
- * Tests whether a {@link LifecycleStatus} is TERMINAL — a node in this state will not
- * transition further.
+ * Tests whether a {@link LifecycleStatus} is terminal — `completed`, `failed`, `skipped`, or
+ * `stopped`, the states a node never transitions out of.
  *
  * @remarks
- * The ONE terminal check across every tier (AGENTS.md § Design laws, "one concept, one term"):
+ * 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. It reads the terminal set from
@@ -1381,8 +1414,8 @@ export declare function isWorkflowError(value: unknown): value is WorkflowError;
  * 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
+ * (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
@@ -1419,7 +1452,8 @@ export declare function isWorkflowInterface(value: unknown): value is WorkflowIn
 export declare function isWorkflowSnapshot(value: unknown): value is WorkflowSnapshot;
 
 /**
- * Lists every {@link LifecycleStatus} value, frozen — the vocabulary every tier draws from.
+ * Lists every {@link LifecycleStatus} value, frozen — the vocabulary every tier draws from,
+ * in the order `pending`, `running`, `completed`, `failed`, `skipped`, `stopped`.
  *
  * @remarks
  * Ordered pending → running → terminal (`completed` / `failed` / `skipped` /
@@ -1434,7 +1468,7 @@ export declare const LIFECYCLE_STATUSES: readonly LifecycleStatus[];
  * `skipped` / `stopped`.
  *
  * @remarks
- * The ONE literal set the workflow, phase, and task tiers all draw from, so the vocabulary
+ * 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
@@ -1451,7 +1485,7 @@ export declare type LifecycleStatus = 'pending' | 'running' | 'completed' | 'fai
  *
  * @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
+ * 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.
  *
@@ -1469,33 +1503,31 @@ export declare type LifecycleStatus = 'pending' | 'running' | 'completed' | 'fai
 export declare function matchesDescription(left: unknown, right: unknown): boolean;
 
 /**
- * Names 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,
+ * `2_147_483_647` milliseconds.
  */
 export declare const MAX_TIMER_MS = 2147483647;
 
 /**
  * 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.
+ * {@link WorkflowSnapshot}s keyed by workflow id, the default store
+ * {@link import('../factories.js').createMemoryWorkflowStore} builds. It expires nothing: a
+ * persisted snapshot lives until an explicit `delete`.
  *
  * @remarks
  * 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
- * that lives until an explicit `delete`, never silently aging out (a run that vanished
- * mid-flight would be a silent data loss, not a freed session). A durable backend (JSON /
- * SQLite / IndexedDB) swaps in through the SAME interface without touching the runner or the
+ * self-contained JSON, so no encoding is needed for the memory tier). A durable backend (JSON /
+ * SQLite / IndexedDB) swaps in through the same interface without touching the runner or the
  * entity tree — its driver-pluggable twin is
  * {@link import('./DatabaseWorkflowStore.js').DatabaseWorkflowStore} (the snapshot as one opaque
  * JSON column), exactly as `@orkestrel/queue`'s `MemoryQueueStore`
  * twins `DatabaseQueueStore`.
  *
  * - **`get` resolves the persisted snapshot for an id**, or `undefined` if none is stored.
- * - **`set` inserts / replaces under the snapshot's OWN `id`** (no separate id param).
+ * - **`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 guide's 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}.
  *
@@ -1549,7 +1581,7 @@ export declare function moveEntry<T>(entries: ReadonlyArray<readonly [string, T]
  *
  * @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
+ * 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.
@@ -1570,10 +1602,10 @@ export declare function ownsAttempt(owners: Map<string, number>, task: TaskInter
 
 /**
  * Parks until `signal` aborts — a promise-parked wait, never a timer or
- * busy-loop, that NEVER rejects.
+ * busy-loop, that resolves on the abort event and never rejects.
  *
  * @remarks
- * Resolves IMMEDIATELY when `signal` is already aborted; otherwise attaches a one-shot
+ * Resolves immediately when `signal` is already aborted; otherwise attaches a one-shot
  * `abort` listener and resolves when it fires, removing the listener either way. The
  * shared leaf behind the duplicate abort-wiring an execution engine otherwise hand-rolls
  * at every fold point.
@@ -1593,7 +1625,8 @@ export declare function parkSignal(signal: AbortSignal): Promise<void>;
 
 /**
  * Lists the {@link WorkflowEventMap} / {@link PhaseEventMap} events that make a durable observer
- * re-persist the live tree, frozen.
+ * re-persist the live tree, frozen — `start`, `complete`, `fail`, `skip`, `stop`, `move`, and
+ * `update`.
  *
  * @remarks
  * The two maps carry the same event names, so one list serves both tiers. It is the source of
@@ -1605,7 +1638,8 @@ export declare function parkSignal(signal: AbortSignal): Promise<void>;
 export declare const PERSISTED_NODE_EVENTS: ReadonlyArray<keyof WorkflowEventMap & keyof PhaseEventMap>;
 
 /**
- * Lists the {@link TaskEventMap} events that make a durable observer re-persist the live tree, frozen.
+ * Lists the {@link TaskEventMap} events that make a durable observer re-persist the live tree,
+ * frozen — `start`, `complete`, `fail`, `skip`, `stop`, `report`, and `pulse`.
  *
  * @remarks
  * The leaf counterpart of {@link PERSISTED_NODE_EVENTS}, and the source of truth behind the task
@@ -1622,21 +1656,21 @@ export declare const PERSISTED_TASK_EVENTS: ReadonlyArray<keyof TaskEventMap>;
  *
  * @remarks
  * Extends {@link WorkflowContext} (so the phase carries its own `id` / `name`) and
- * adds `workflow`, the parent's context — the lineage pointer back UP the tree.
+ * adds `workflow`, the parent's context — the lineage pointer back up the tree.
  */
 export declare interface PhaseContext extends WorkflowContext {
     readonly workflow: WorkflowContext;
 }
 
 /**
- * Represents the serializable definition of one phase — its identity, its ordered tasks, and
- * an optional resource throttle.
+ * Represents the serializable definition of one phase — its identity, its ordered tasks, an
+ * optional resource throttle, and an optional `bail` override of the workflow policy.
  *
  * @remarks
- * Pure JSON DATA. `tasks` are the phase's tasks, which run CONCURRENTLY (the fixed
+ * Pure JSON data. `tasks` are the phase's tasks, which run concurrently (the fixed
  * determinism principle). `concurrency` is the optional per-phase resource throttle
  * — the maximum number of tasks in flight at once (a positive integer); omitted ⇒
- * unbounded. It is a throttle, NOT a sequencing control: phases are always
+ * unbounded. It is a throttle, not a sequencing control: phases are always
  * sequential, tasks within a phase always concurrent.
  */
 export declare interface PhaseDefinition {
@@ -1650,10 +1684,10 @@ export declare interface PhaseDefinition {
      * Sets the phase's failure policy.
      *
      * @remarks
-     * The per-phase failure-policy OVERRIDE. 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.
+     * `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.
      */
     readonly bail?: boolean;
 }
@@ -1663,7 +1697,7 @@ export declare interface PhaseDefinition {
  * {@link PhaseSnapshot} — the per-phase step of {@link definitionToSnapshot}.
  *
  * @remarks
- * The snapshot persists the EFFECTIVE failure policy this phase runs under: the phase's own
+ * The snapshot persists the effective failure policy this phase runs under: the phase's own
  * `bail` when it declares one, else the `workflowBail` it inherits — so a restore reinstates
  * the same per-phase policy without a silent default (`effectiveBail = phase.bail ?? workflowBail`).
  * `concurrency` (the resource throttle) carries over verbatim, omitted when undefined.
@@ -1676,14 +1710,14 @@ export declare function phaseDefinitionToSnapshot(phase: WorkflowDefinition['pha
 
 /**
  * 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`).
+ * {@link LifecycleStatus} paired with the effective `bail` policy it ran under
+ * (`phase.bail ?? workflow.bail`) — the input shape {@link deriveWorkflowStatus} reduces.
  *
  * @remarks
- * 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`
+ * 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`
  * phase whose `bail` is `false` folds into completion. {@link import('./Workflow.js').Workflow}
  * builds one per live phase (`{ status: phase.status, bail: phase.bail }`).
  */
@@ -1738,19 +1772,19 @@ export declare type PhaseInput = Partial<PhaseContext>;
 
 /**
  * Declares the live derived state machine (W-b) for one {@link PhaseDefinition} — an
- * observable phase whose {@link LifecycleStatus} is DERIVED from its tasks
+ * 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 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.
+ *   unless an override is in force. It recomputes whenever a child task transitions; a
+ *   change emits.
  * - **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` FORCE the phase's status, overriding the
+ *   result tree); `workflow` navigates up to the live parent.
+ * - **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
@@ -1758,8 +1792,8 @@ export declare type PhaseInput = Partial<PhaseContext>;
  *   its `error` handler (the `error` option).
  * - **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;
+ *   {@link WorkflowRunnerInterface.execute} gates a task's own pre-dispatch on both the
+ *   workflow's and its phase's gate. `paused` is runtime-only, never persisted; idempotent;
  *   released by `resume` and by this phase's own `stop` / `skip` forcing a terminal status
  *   (a permanently-ended phase has nothing left to pause for).
  */
@@ -1773,12 +1807,12 @@ export declare interface PhaseInterface {
     readonly workflow: WorkflowInterface;
     /** 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}. */
+    /** Reports the resolved effective failure policy this phase runs under (`phase.bail ?? workflow.bail`); mirrors {@link WorkflowInterface.bail}. */
     readonly bail: boolean;
     /** Caps the tasks in flight at once (a resource throttle); mirrors {@link PhaseSnapshot.concurrency}. `undefined` ⇒ unbounded. */
     readonly concurrency: number | undefined;
     /**
-     * Reports whether the phase is paused (resumable); RUNTIME-ONLY — never a
+     * 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).
      */
@@ -1792,7 +1826,7 @@ export declare interface PhaseInterface {
      * Forces this phase to `skipped`, overriding the derived value; idempotent.
      *
      * @remarks
-     * A NO-OP after `status` becomes 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).
      */
@@ -1801,7 +1835,7 @@ export declare interface PhaseInterface {
      * Forces this phase to `stopped`, overriding the derived value; idempotent.
      *
      * @remarks
-     * A NO-OP after `status` becomes 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).
      */
@@ -1810,10 +1844,10 @@ export declare interface PhaseInterface {
      * Suspends the phase (resumable); idempotent.
      *
      * @remarks
-     * A no-op when already `paused` or when `status` is terminal. RUNTIME-ONLY —
+     * 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
+     * gate (after the workflow's own gate). **Pausing does not suspend a driving run's
      * timeout / budget / abort clocks** — those bounds keep ticking while paused, so a long
      * pause can still fire a run-level cancel and stop the workflow while parked.
      *
@@ -1835,47 +1869,45 @@ export declare interface PhaseInterface {
      */
     resume(): void;
     /**
-     * Parks until this phase is not paused — **promise-parked**, never a timer or busy-loop
-     * (mirrors {@link WorkflowInterface.wait}).
+     * Parks until this phase is not paused — a promise-parked wait, never a timer or busy-loop.
      *
      * @remarks
-     * Resolves IMMEDIATELY when not {@link paused}. While paused, parks until `resume` or
+     * 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.
+     * waiter. Never rejects.
      *
      * @returns A promise that resolves after the phase is no longer paused
      */
     wait(): Promise<void>;
     /**
      * Mints a live {@link TaskInterface} from `definition` and inserts it into this phase
-     * (the entity structural API) — gated BEFORE delegating to {@link tasks}'
-     * manager.
+     * (the entity structural API) — gated before it delegates to the {@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 `behavior` /
+     * 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
+     * against the workflow-level {@link WorkflowOptions.functions} registry — the same
      * resolution {@link import('./factories.js').createWorkflow} performs at build time.
-     * Requires `definition.id` to be UNIQUE among this phase's existing
+     * Requires `definition.id` to be unique among this phase's existing
      * task ids — a duplicate is a `MUTATION` failure (mirrors
      * {@link TaskManagerInterface.add}'s own duplicate-id gate).
      *
-     * NATIVE gating, purely from this phase's own derived `status` (no
-     * runner-installed hook), UNCHANGED from the entity-taking predecessor. While
+     * 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
+     * {@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 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
+     * **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 means only that the task
-     * is WIRED into the live tree, not that it will execute.
+     * is wired into the live tree, not that it will execute.
      *
      * @param definition - The {@link TaskDefinition} to mint a live task from
      * @param index - The insertion position; omitted inserts at the end
@@ -1886,7 +1918,7 @@ export declare interface PhaseInterface {
      * Removes the `pending` task `id` from this phase.
      *
      * @remarks
-     * NATIVE gating: allowed only while this phase's own `status` is `pending`. While
+     * native gating: allowed only while this phase's own `status` is `pending`. While
      * `running` or terminal, always a `MUTATION` failure — a running phase's tasks are
      * already handed to the execution substrate and only a pure {@link add} append remains
      * possible.
@@ -1899,7 +1931,7 @@ export declare interface PhaseInterface {
      * Repositions the `pending` task `id` to `index` within this phase.
      *
      * @remarks
-     * NATIVE gating: allowed only while this phase's own `status` is `pending`; `running` /
+     * native gating: allowed only while this phase's own `status` is `pending`; `running` /
      * terminal always fail (see {@link remove}).
      *
      * @param id - The task id to move
@@ -1911,7 +1943,7 @@ export declare interface PhaseInterface {
      * 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` /
+     * native gating: allowed only while this phase's own `status` is `pending`; `running` /
      * terminal always fail (see {@link remove}).
      *
      * @param id - The task id to patch
@@ -1920,12 +1952,12 @@ export declare interface PhaseInterface {
      */
     update(id: string, patch: TaskUpdate): Result<TaskInterface, WorkflowError>;
     /**
-     * Applies a validated declarative patch to SELF (`name` / `description` /
+     * Applies a validated declarative patch to this phase itself (`name` / `description` /
      * `concurrency` / `bail`).
      *
      * @remarks
      * Defense-in-depth: the owning {@link WorkflowInterface.update} gates
-     * FIRST, so a direct call here THROWS a `MUTATION`
+     * first, so a direct call here throws a `MUTATION`
      * {@link import('./errors.js').WorkflowError} unless this phase's own `status` is
      * `pending`.
      *
@@ -1936,6 +1968,11 @@ export declare interface PhaseInterface {
      * ```
      */
     patch(value: PhaseUpdate): void;
+    /**
+     * Serializes this phase and its tasks.
+     *
+     * @returns The pure-JSON {@link PhaseSnapshot} of this phase
+     */
     snapshot(): PhaseSnapshot;
 }
 
@@ -1953,7 +1990,7 @@ export declare interface PhaseInterface {
  *   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
+ *   `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.
@@ -1990,10 +2027,10 @@ export declare class PhaseManager implements PhaseManagerInterface {
  * @remarks
  * `append` adds one live {@link PhaseInterface} at the end; `phase(id)` looks one up;
  * `phases()` lists them in positional order; `count` is the tally. No batch matrix.
- * `add` / `remove` / `move` / `update` 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
+ * delegates to after its own container-status/hook gating — the manager gates only
+ * on the target's own existence/status/id/bounds and stays event-free (the entity
  * emits on success).
  */
 export declare interface PhaseManagerInterface {
@@ -2002,7 +2039,7 @@ export declare interface PhaseManagerInterface {
      * Adds `phase` at the end (the build-time wiring path).
      *
      * @remarks
-     * THROWS a `MUTATION` {@link import('./errors.js').WorkflowError} on a duplicate
+     * throws a `MUTATION` {@link import('./errors.js').WorkflowError} on a duplicate
      * `id` (a genuine programmer error — a build-time wiring bug) instead of
      * silently overwriting the existing entry.
      *
@@ -2010,7 +2047,7 @@ export declare interface PhaseManagerInterface {
      */
     append(phase: PhaseInterface): void;
     /**
-     * Inserts `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.
      *
@@ -2045,7 +2082,18 @@ export declare interface PhaseManagerInterface {
      *   `id` is absent, not `pending`, or `patch` fails validation
      */
     update(id: string, patch: PhaseUpdate): Result<PhaseInterface, WorkflowError>;
+    /**
+     * Looks up one held phase by its `id`.
+     *
+     * @param id - The phase id to resolve
+     * @returns The live phase, or `undefined` when none is held under that id
+     */
     phase(id: string): PhaseInterface | undefined;
+    /**
+     * Lists the held phases in positional order.
+     *
+     * @returns Every live phase, in the order the store holds them
+     */
     phases(): readonly PhaseInterface[];
 }
 
@@ -2072,32 +2120,33 @@ export declare interface PhaseOptions {
  * {@link taskShape} tasks, and an optional positive-integer `concurrency` throttle
  * (max tasks in flight; omitted ⇒ unbounded).
  */
-export declare const phaseShape: ObjectShape<{
-    id: StringShape;
-    name: StringShape;
-    description: OptionalShape<StringShape>;
-    tasks: ArrayShape<ObjectShape<{
-        id: StringShape;
-        name: StringShape;
-        description: OptionalShape<StringShape>;
-        behavior: OptionalShape<StringShape>;
-        retries: OptionalShape<NumberShape>;
-        timeout: OptionalShape<NumberShape>;
-    }, false>>;
-    concurrency: OptionalShape<NumberShape>;
-    bail: OptionalShape<LiteralShape<readonly [true, false]>>;
+export declare const phaseShape: ObjectShape<    {
+id: StringShape;
+name: StringShape;
+description: OptionalShape<StringShape>;
+tasks: ArrayShape<ObjectShape<    {
+id: StringShape;
+name: StringShape;
+description: OptionalShape<StringShape>;
+behavior: OptionalShape<StringShape>;
+retries: OptionalShape<NumberShape>;
+timeout: OptionalShape<NumberShape>;
+}, false>>;
+concurrency: OptionalShape<NumberShape>;
+bail: OptionalShape<LiteralShape<readonly [true, false]>>;
 }, false>;
 
 /**
- * Represents a JSON-serializable snapshot of one phase's state — its identity, status, its forced
- * override (if any), and its nested task snapshots.
+ * Represents a JSON-serializable snapshot of one phase's state — its identity, status, the
+ * forced override a whole-phase `skip` or `stop` left, the effective `bail` and `concurrency`
+ * it ran under, 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` — PRESENT only
- * when one is in force, so a restore reinstates it DIRECTLY (no fragile derivation comparison)
+ * 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` — 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
+ * field — a task's terminal status is its forced marker. `tasks` are the phase's
  * {@link TaskSnapshot}s in order.
  */
 export declare interface PhaseSnapshot {
@@ -2109,8 +2158,8 @@ export declare interface PhaseSnapshot {
     /** Records the forced status of a whole-phase `skip` / `stop`; present only when an override is in force. */
     readonly override?: LifecycleStatus;
     /**
-     * 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
+     * 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;
@@ -2155,11 +2204,11 @@ export declare interface PhaseUpdate {
  * `tasks` (structural children change through the phase's own `add` / `remove` /
  * `move`, not a patch).
  */
-export declare const phaseUpdateShape: ObjectShape<{
-    name: OptionalShape<StringShape>;
-    description: OptionalShape<StringShape>;
-    concurrency: OptionalShape<NumberShape>;
-    bail: OptionalShape<LiteralShape<readonly [true, false]>>;
+export declare const phaseUpdateShape: ObjectShape<    {
+name: OptionalShape<StringShape>;
+description: OptionalShape<StringShape>;
+concurrency: OptionalShape<NumberShape>;
+bail: OptionalShape<LiteralShape<readonly [true, false]>>;
 }, false>;
 
 /**
@@ -2172,7 +2221,8 @@ export declare const phaseUpdateShape: ObjectShape<{
 export declare function recoverWorkflowSnapshot(snapshot: WorkflowSnapshot): WorkflowSnapshot;
 
 /**
- * Resolves a task's runtime silence window against its workflow default.
+ * Resolves a task's runtime silence window against its workflow default, to a host-safe
+ * `1..MAX_TIMER_MS` window or to `undefined` where the task disables it.
  *
  * @param value - The task-level override; any present non-positive or non-finite value disables
  * @param fallback - The workflow-level default
@@ -2250,13 +2300,13 @@ export declare interface RunHolderInterface {
  *   bounded concurrency, retries, and the per-attempt timeout are all the Queue's —
  *   the Runner adds only orchestration (launching, ordering, draining, fail-fast).
  * - **Spawns actually run, results stay ordered (the B2 fix).** Declared inputs and
- *   `spawn`ed siblings flow through the SAME `#launch`, which appends the unit's `id`
+ *   `spawn`ed siblings flow through the same `#launch`, which appends the unit's `id`
  *   to an ordered `#order` list and records its settled value into `#values` by `id`.
  *   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 through a count gate.** `#launch` increments
- *   an outstanding-unit `#count` BEFORE enqueuing and every settle decrements it,
+ *   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
@@ -2268,26 +2318,26 @@ export declare interface RunHolderInterface {
  *   spawn by a bounded handler can still deadlock — that caveat is the caller's.)
  * - **Per-unit Controller + signal.** Each unit gets a `Controller` carrying its `id`,
  *   `input`, the unit's `Abort` (so `aborted` / `abort` delegate to it), and the queue
- *   attempt's `signal` (which ANY-combines the unit abort + runner abort + timeout). A
+ *   attempt's `signal` (which any-combines the unit abort + runner abort + timeout). A
  *   `spawn` callback is injected so `controller.spawn(input)` delegates to `#launch`.
  * - **One-shot + fail-fast.** `execute` runs once (a second call throws). The first
  *   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` ride the backing Queue.** `pause` / `resume`
- *   delegate straight to the Queue's own pause/resume (holding/releasing the NEXT
+ *   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
+ *   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) after every unit
+ *   completion and settles normally. `execute` resolves (never rejects) after every unit
  *   has settled, with whatever results actually completed.
  * - **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
+ *   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
- *   to its `error` handler (the `error` option), so a buggy observer can NEVER reorder, throw
+ *   to its `error` handler (the `error` option), so a buggy observer can never reorder, throw
  *   into, or corrupt the one-shot / fail-fast / spawn-tracking engine: the outstanding-unit
  *   count gate stays balanced and fail-fast still fires regardless of what a listener does.
  *   Observation is purely a side-channel.
@@ -2300,15 +2350,15 @@ export declare class Runner<TInput, TResult> implements RunnerInterface<TInput,
     get stopped(): boolean;
     get paused(): boolean;
     /**
-     * Injects one more unit into an IN-FLIGHT `execute` run — a LIVE counterpart to a
-     * `Controller.spawn`, called from OUTSIDE any unit's handler.
+     * 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) 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 through `#launch` — the outstanding-
-     * unit count gate increments BEFORE this call returns, so an in-flight `execute`
+     * 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` —
@@ -2330,7 +2380,7 @@ export declare class Runner<TInput, TResult> implements RunnerInterface<TInput,
     abort(reason?: unknown): Promise<void>;
     /**
      * Suspends dispatch (resumable): delegates to the backing queue's own
-     * `pause`, which holds the NEXT dispatch while any in-flight unit finishes.
+     * `pause`, which holds the next dispatch while any in-flight unit finishes.
      *
      * @remarks
      * A no-op after the runner is `stopped` — a stopped runner has no dispatch left to
@@ -2348,10 +2398,10 @@ export declare class Runner<TInput, TResult> implements RunnerInterface<TInput,
      */
     resume(): void;
     /**
-     * Ends the runner permanently — 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
+     * still-pending (never-dispatched) unit is rejected by the queue with its own
+     * "queue is stopped" error, without running its handler; every already-in-flight unit
      * keeps running to completion and settles normally. `#settle` reads `#stopping` to
      * classify a never-dispatched unit's rejection as a stop artifact (decrement the count
      * gate, no recorded failure, no fail-fast trip) rather than a genuine failure — a
@@ -2362,12 +2412,13 @@ export declare class Runner<TInput, TResult> implements RunnerInterface<TInput,
 }
 
 /**
- * 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}.
+ * 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
- * abort), so only the two reliability knobs are exposed here. Each field OVERRIDES the
+ * abort), so only the two reliability knobs are exposed here. Each field overrides the
  * runner-level `retries` / `timeout` default for that one unit; an omitted field falls back
  * to the default. This is the per-unit slice of the backing Queue's
  * `@orkestrel/queue` `QueueEntryOptions` surfaced cleanly — the Queue already
@@ -2380,8 +2431,8 @@ export declare interface RunnerEntryOptions {
 
 /**
  * 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.
+ * lifecycle a fire-and-forget observer (logging, metrics, tracing) subscribes to, beside
+ * the eventual `execute` result.
  *
  * @typeParam TResult - The value a unit resolves; the `finish` payload is the run's ordered
  *   `readonly TResult[]`, so the map is `RunnerEventMap<TResult>` — mirroring how the
@@ -2389,9 +2440,9 @@ export declare interface RunnerEntryOptions {
  *
  * @remarks
  * 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
+ * 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
+ * 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 through `runner.emitter.on(...)`.
  *
@@ -2436,8 +2487,8 @@ export declare type RunnerHandler<TInput, TResult> = (controller: ControllerInte
  * spawned) through it so spawned work actually runs.
  *
  * 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 /
+ * ({@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 through
@@ -2467,16 +2518,16 @@ export declare interface RunnerInterface<TInput, TResult> {
      */
     execute(inputs: readonly TInput[]): Promise<readonly TResult[]>;
     /**
-     * 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).
+     * Injects one more unit into a run already in flight — the live counterpart to a
+     * `Controller.spawn`, called from outside any unit's handler (the seam through which a
+     * subscribed run offers a newly added task of a `running` {@link PhaseInterface} to the same
+     * execution substrate).
      *
      * @remarks
      * 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
+     * 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 after the unit
      * settles.
@@ -2494,7 +2545,7 @@ export declare interface RunnerInterface<TInput, TResult> {
      */
     abort(reason?: unknown): Promise<void>;
     /**
-     * Suspends dispatch (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
@@ -2515,12 +2566,12 @@ export declare interface RunnerInterface<TInput, TResult> {
      */
     resume(): void;
     /**
-     * Ends the runner permanently — 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) after every unit has
-     * settled, with whatever results actually completed. Idempotent.
+     * and is not recorded as a failure, so it never trips fail-fast, while a genuine in-flight
+     * failure still does. `execute`'s promise resolves rather than rejects after every unit has
+     * settled, with whatever results completed. Idempotent.
      *
      * @example
      * ```ts
@@ -2541,7 +2592,9 @@ export declare interface RunnerInterface<TInput, TResult> {
 }
 
 /**
- * Declares the options for `createRunner`.
+ * Declares the options for `createRunner` — the `handler` every unit runs, the queue bounds
+ * `concurrency`, `retries`, and `timeout`, the per-entry `entries` resolver, and the emitter
+ * `on` hooks and `error` handler.
  *
  * @remarks
  * - `handler` — runs each unit's work against its {@link ControllerInterface};
@@ -2638,13 +2691,13 @@ export declare function scheduleHost(start: (complete: () => void, failure: (err
  * browser and Node.
  *
  * @remarks
- * - **Cross-environment.** Uses ONLY `setTimeout` / `clearTimeout` — universally
+ * - **Cross-environment.** Uses only `setTimeout` / `clearTimeout` — universally
  *   available. It deliberately avoids env-specific fast paths (`setImmediate`,
  *   `scheduler.yield`, `requestAnimationFrame`, `node:timers/promises`,
  *   `MessageChannel`); those belong to the environment backends, built with the
  *   agent loop that consumes them.
  * - **`yield` is a macrotask host-turn, not a microtask.** `yield()` waits on a
- *   `setTimeout(0)`, NOT `queueMicrotask`. A microtask drains before the host
+ *   `setTimeout(0)`, not `queueMicrotask`. A microtask drains before the host
  *   regains control, so it would not actually let pending I/O, timers, or
  *   rendering run — it only defers within the current task. A zero-delay timer is
  *   the correct cross-environment "give the host a turn".
@@ -2666,10 +2719,10 @@ export declare function scheduleHost(start: (complete: () => void, failure: (err
  * }
  * ```
  */
-declare class Scheduler_2 implements SchedulerInterface {
+export declare class Scheduler implements SchedulerInterface {
     /**
      * 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,
+     * 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>;
@@ -2684,11 +2737,10 @@ declare class Scheduler_2 implements SchedulerInterface {
      */
     delay(ms: number, options?: SchedulerOptions): Promise<void>;
 }
-export { Scheduler_2 as 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
+ * Declares a cooperative host-yield primitive: a loop decides what to do; the scheduler
+ * decides when the host regains control. It is abort-aware — a pending yield or delay
  * rejects with the signal's reason when aborted.
  */
 export declare interface SchedulerInterface {
@@ -2759,12 +2811,13 @@ export declare interface TaskActivity {
 }
 
 /**
- * Represents one complete replacement of a running task's observable activity.
+ * Represents one complete replacement of a running task's observable activity, an omitted
+ * collection meaning an empty one.
  *
  * @remarks
  * `note` describes the frame while `progress.message` describes the progress value.
- * Omitted `operations` or `constraints` mean an empty list. Omitted `progress` clears the
- * previous aggregate progress. Use {@link TaskInterface.report} to commit the replacement.
+ * Omitted `progress` clears the previous aggregate progress. Use {@link TaskInterface.report} to
+ * commit the replacement.
  */
 export declare interface TaskActivityInput {
     readonly note?: string;
@@ -2774,11 +2827,12 @@ export declare interface TaskActivityInput {
 }
 
 /**
- * Represents one identified thing a running task claims active, with the moment the claim began.
+ * Represents one identified thing a running task claims active, with the moment the claim
+ * began — the shape {@link TaskOperation} and {@link TaskConstraint} share.
  *
  * @remarks
- * 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
+ * `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
@@ -2807,7 +2861,7 @@ export declare interface TaskConstraint extends TaskClaim {
  *
  * @remarks
  * Extends {@link WorkflowContext} and adds `phase`, the parent {@link PhaseContext}
- * — so a task carries its FULL lineage (workflow → phase → task) for a
+ * — so a task carries its full lineage (workflow → phase → task) for a
  * {@link TaskResult} or a runner.
  */
 export declare interface TaskContext extends WorkflowContext {
@@ -2816,10 +2870,11 @@ export declare interface TaskContext extends WorkflowContext {
 
 /**
  * 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.
+ * cancellation, its input, its lineage, and read access up the tree to the results already
+ * settled.
  *
  * @remarks
- * A 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.
@@ -2827,7 +2882,7 @@ export declare interface TaskContext extends WorkflowContext {
  * - `input` — the task's `metadata` bag (the open consumer payload from its
  *   {@link TaskInput}); `{}` when none.
  * - `task` — the task's full {@link TaskContext} (so `task.phase` / `task.phase.workflow`
- *   navigate UP the lineage).
+ *   navigate up the lineage).
  * - `wait()` — a cooperative checkpoint for the workflow, phase, and task pause gates.
  * - `results()` — every settled task's {@link TaskResult} across already-finished phases,
  *   so a `function` task can read an earlier phase's output (the W-b result tree, read-only).
@@ -2867,14 +2922,14 @@ export declare interface TaskControllerInterface {
 }
 
 /**
- * Represents the serializable definition of one task — its identity plus an optional reference to
- * the behavior it runs.
+ * Represents the serializable definition of one task — its identity, an optional reference to
+ * the behavior it runs, and its optional per-task `retries` and `timeout` overrides.
  *
  * @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
+ * 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. `behavior` is a
- * PLAIN NAME — a key resolved ONCE at construction against a workflow-level
+ * plain name — a key resolved once at construction against a workflow-level
  * {@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.
@@ -2889,8 +2944,8 @@ export declare interface TaskDefinition {
      *
      * @remarks
      * Extra attempts after the first on failure (a non-negative integer); the runner threads it
-     * to this task's substrate unit, OVERRIDING the phase Runner's `retries` default. Omitted ⇒
-     * the default (no extra attempts). PERSISTED in a {@link TaskSnapshot} (like `bail` and
+     * to this task's substrate unit, overriding the phase Runner's `retries` default. Omitted ⇒
+     * the default (no extra attempts). Persisted in a {@link TaskSnapshot} (like `bail` and
      * `concurrency`), so `createRestoredWorkflow(snapshot, { functions })` resumes with the same
      * reliability config; only the resolved handler itself is runtime-only.
      */
@@ -2900,7 +2955,7 @@ export declare interface TaskDefinition {
      *
      * @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},
+     * `MAX_TIMER_MS`. Zero or omission means no deadline. Persisted in a {@link TaskSnapshot},
      * so `createRestoredWorkflow(snapshot, { functions })` resumes with the same reliability config;
      * only the resolved handler itself is runtime-only.
      */
@@ -2980,12 +3035,10 @@ export declare type TaskFailureOrigin = 'handler' | 'timeout' | 'recovery';
 
 /**
  * Represents the minimal data to create a task context — a partial {@link TaskContext} plus
- * any creation-only fields.
+ * the open `metadata` bag the task stores and snapshots without interpreting it.
  *
  * @remarks
- * `metadata` is an open consumer bag the workflow system stores and carries into a
- * {@link TaskSnapshot} but never interprets. All members are optional (the storing
- * layer fills identity / lineage).
+ * All members are optional (the storing layer fills identity / lineage).
  */
 export declare interface TaskInput extends Partial<TaskContext> {
     /** Holds an open consumer bag — stored and snapshotted, never interpreted by the workflow. */
@@ -3000,13 +3053,13 @@ export declare interface TaskInput extends Partial<TaskContext> {
  * @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
+ *   `context.phase.workflow` navigate up the tree), and `phase` / `workflow` are the
  *   live parent entities for direct lineage navigation.
  * - **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` (intentionally not run),
- *   and `stop` (ended early). Each is GUARDED: an illegal transition (for example,
+ *   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}.
@@ -3014,7 +3067,7 @@ export declare interface TaskInput extends Partial<TaskContext> {
  *   outcome (`completed` / `failed`), else `undefined` — the lineage-navigable leaf of the
  *   result tree.
  * - **Observable.** The owned {@link emitter} ({@link TaskEventMap}) fires
- *   `start` / `complete` / `fail` / `pause` / `resume` / `skip` / `stop` strictly AFTER
+ *   `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).
  */
@@ -3034,14 +3087,14 @@ export declare interface TaskInterface {
     /** Holds the recorded outcome after the task settled with one (`completed` / `failed`), else `undefined`. */
     readonly result: TaskResult | undefined;
     /**
-     * Names the behavior reference — a plain registry key name, PERSISTED (mirrors
+     * 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 behavior: string | undefined;
     /**
-     * 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
+     * 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
@@ -3049,12 +3102,12 @@ export declare interface TaskInterface {
      */
     readonly handler: WorkflowFunction | undefined;
     /**
-     * Holds the 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;
     /**
-     * Holds 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.
      */
@@ -3069,10 +3122,28 @@ export declare interface TaskInterface {
     readonly paused: boolean;
     /** Holds this task's own cancellation signal; running/pending {@link stop} or {@link skip} fires it. */
     readonly signal: AbortSignal;
+    /**
+     * Launches the next persisted attempt of this task, from `pending` or from a retrying
+     * `running`, clearing the activity frame and emitting `start` before the cascade.
+     */
     start(): void;
+    /**
+     * Settles this running task as `completed`, boxing its produced value as a `Success`.
+     *
+     * @param value - The JSON result the handler produced
+     */
     complete(value: JSONValue): void;
+    /**
+     * Settles this running task as `failed`, boxing a normalized failure as a `Failure`.
+     *
+     * @param error - The normalized {@link TaskFailure} to persist
+     */
     fail(error: TaskFailure): void;
+    /** Moves this task to `skipped` — work intentionally not run — and emits `skip`. */
     skip(): void;
+    /**
+     * Moves this task to `stopped`, fires its own signal, releases its gate, and emits `stop`.
+     */
     stop(): void;
     /**
      * Replaces the complete observable activity of this running task.
@@ -3098,12 +3169,12 @@ export declare interface TaskInterface {
      */
     wait(): Promise<void>;
     /**
-     * Applies a validated declarative patch to SELF (`name` / `description`).
+     * Applies a validated declarative patch to this task itself (`name` / `description`).
      *
      * @remarks
      * 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
+     * first (target exists + `pending`), so a direct call here is the second, redundant
+     * check — it throws a `MUTATION` {@link import('./errors.js').WorkflowError} unless
      * this task's own `status` is `pending`.
      *
      * @param value - The {@link TaskUpdate} fields to apply
@@ -3113,6 +3184,12 @@ export declare interface TaskInterface {
      * ```
      */
     patch(value: TaskUpdate): void;
+    /**
+     * Serializes this task's identity, status, result, owned metadata, consumed `attempts`,
+     * reliability settings, and activity.
+     *
+     * @returns The pure-JSON {@link TaskSnapshot} of this leaf
+     */
     snapshot(): TaskSnapshot;
 }
 
@@ -3129,10 +3206,10 @@ export declare interface TaskInterface {
  *   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
+ *   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
+ *   `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.
@@ -3172,9 +3249,9 @@ export declare class TaskManager implements TaskManagerInterface {
  * `task(id)` looks one up; `tasks()` lists them in positional order; `count` is the
  * 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
+ * `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).
  */
 export declare interface TaskManagerInterface {
@@ -3183,7 +3260,7 @@ export declare interface TaskManagerInterface {
      * Adds `task` at the end (the build-time wiring path).
      *
      * @remarks
-     * THROWS a `MUTATION` {@link import('./errors.js').WorkflowError} on a duplicate
+     * throws a `MUTATION` {@link import('./errors.js').WorkflowError} on a duplicate
      * `id` (a genuine programmer error — a build-time wiring bug) instead of
      * silently overwriting the existing entry.
      *
@@ -3191,7 +3268,7 @@ export declare interface TaskManagerInterface {
      */
     append(task: TaskInterface): void;
     /**
-     * Inserts `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.
      *
@@ -3226,7 +3303,18 @@ export declare interface TaskManagerInterface {
      *   `id` is absent, not `pending`, or `patch` fails validation
      */
     update(id: string, patch: TaskUpdate): Result<TaskInterface, WorkflowError>;
+    /**
+     * Looks up one held task by its `id`.
+     *
+     * @param id - The task id to resolve
+     * @returns The live task, or `undefined` when none is held under that id
+     */
     task(id: string): TaskInterface | undefined;
+    /**
+     * Lists the held tasks in positional order.
+     *
+     * @returns Every live task, in the order the store holds them
+     */
     tasks(): readonly TaskInterface[];
 }
 
@@ -3248,7 +3336,7 @@ export declare interface TaskOperation extends TaskClaim {
  * 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
+ * {@link PhaseInterface.add} mint threads a leaf's `on` from its options. `metadata` is
  * the open consumer bag carried verbatim into a {@link TaskSnapshot} (mirrors
  * {@link TaskInput.metadata}), never interpreted by the workflow.
  */
@@ -3283,12 +3371,12 @@ export declare interface TaskProgress {
  * @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
+ * 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
+ * {@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).
  */
@@ -3308,13 +3396,13 @@ export declare interface TaskResult {
  * `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>;
-    behavior: OptionalShape<StringShape>;
-    retries: OptionalShape<NumberShape>;
-    timeout: OptionalShape<NumberShape>;
+export declare const taskShape: ObjectShape<    {
+id: StringShape;
+name: StringShape;
+description: OptionalShape<StringShape>;
+behavior: OptionalShape<StringShape>;
+retries: OptionalShape<NumberShape>;
+timeout: OptionalShape<NumberShape>;
 }, false>;
 
 /**
@@ -3322,10 +3410,10 @@ export declare const taskShape: ObjectShape<{
  * the durable store (W-d) persists.
  *
  * @remarks
- * Pure JSON DATA (no class instances, no functions). `result` is the task's
+ * 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}.
- * `behavior` / `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 (`behavior` re-resolves against the
  * {@link WorkflowOptions.functions} registry supplied to
@@ -3382,14 +3470,14 @@ export declare interface TaskUpdate {
  * `name` still has `minLength: 1`); never `id` / `behavior` / `retries` / `timeout` (those
  * are not patchable fields).
  */
-export declare const taskUpdateShape: ObjectShape<{
-    name: OptionalShape<StringShape>;
-    description: OptionalShape<StringShape>;
+export declare const taskUpdateShape: ObjectShape<    {
+name: OptionalShape<StringShape>;
+description: OptionalShape<StringShape>;
 }, false>;
 
 /**
- * Lists the {@link LifecycleStatus} values that are TERMINAL — a node in one of these will
- * not transition further, frozen.
+ * Lists the terminal {@link LifecycleStatus} values, frozen — `completed`, `failed`, `skipped`,
+ * and `stopped`, each a state a node never transitions out of.
  *
  * @remarks
  * The source of truth behind {@link import('./helpers.js').isTerminalStatus}.
@@ -3398,7 +3486,7 @@ export declare const taskUpdateShape: ObjectShape<{
 export declare const TERMINAL_STATUSES: readonly LifecycleStatus[];
 
 /**
- * Implements the live DERIVED state machine (W-b) for a whole workflow — the observable ROOT
+ * 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.
  *
@@ -3409,16 +3497,16 @@ export declare const TERMINAL_STATUSES: readonly LifecycleStatus[];
  *   passes a persisted one). Each child {@link Phase} is wired to escalate to `#recompute`.
  * - **Derived status.** `status` is `#override` when forced, else
  *   {@link deriveWorkflowStatus} over the live phases' statuses feeding `bail`. `failed` is
- *   reachable ONLY under `bail: true` (a single failed task halts the workflow); under
+ *   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.** `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
+ *   change; a change emits.
+ * - **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.
  * - **Result tree.** `results()` flattens every phase's `results()` ({@link collectResults}) — the
- *   workflow tier; `phase(id)` + each `phase.task(id)` navigate DOWN, a task's `phase` / `workflow`
- *   navigate UP.
+ *   workflow tier; `phase(id)` + each `phase.task(id)` navigate down, a task's `phase` / `workflow`
+ *   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.** The owned {@link emitter} ({@link WorkflowEventMap}) fires
@@ -3426,17 +3514,17 @@ export declare const TERMINAL_STATUSES: readonly LifecycleStatus[];
  *   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.** `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,
+ *   bounds), then emit the matching {@link WorkflowEventMap} event on success only. Native,
  *   bottom-up gating (no runner-installed hook): refused outright while this workflow's own
- *   `status` is terminal; otherwise a target position must fall within the PENDING SUFFIX —
+ *   `status` is terminal; otherwise a target position must fall within the pending suffix —
  *   the contiguous trailing run of `pending` phases — whose boundary is
  *   {@link import('./helpers.js').deriveBoundary} over the live phases' statuses. A `pending`
  *   workflow's phases are all `pending`, so the boundary is `0` and every position is
  *   naturally accepted.
  * - **Runtime lifecycle.** `pause` / `resume` / `wait` gate execution at the runner's
- *   phase/task boundaries WITHOUT touching {@link status} — `paused` is runtime-only, never
+ *   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
@@ -3509,11 +3597,11 @@ export declare interface WorkflowContext {
  * 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): `false` (the default) is GRACEFUL —
+ * 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): `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
+ * is a database-transaction halt — a single failed task propagates `failed` to the
  * whole workflow. See {@link import('./helpers.js').deriveWorkflowStatus}.
  */
 export declare interface WorkflowDefinition {
@@ -3526,11 +3614,12 @@ export declare interface WorkflowDefinition {
 }
 
 /**
- * Represents an error raised by the workflow runtime.
+ * Represents an error the workflow runtime raises for an operation it refuses — a
+ * {@link WorkflowErrorCode} (`TRANSITION`, `RESTORE`, `MUTATION`, `SCHEDULE`, or `INVARIANT`)
+ * beside an optional `context` naming the node or the parameter at fault.
  *
  * @remarks
- * Carries a {@link WorkflowErrorCode} and an optional `context` bag naming the
- * offending node id / status / parameter. Raised for an illegal lifecycle transition
+ * Raised for an illegal lifecycle transition
  * (`TRANSITION`), a structurally invalid {@link import('./types.js').WorkflowSnapshot}
  * boundary (`RESTORE`), a refused structural/activity edit (`MUTATION`), a host
  * schedule refused before arming because the caller's `signal` is not a native
@@ -3553,21 +3642,21 @@ export declare class WorkflowError extends Error {
  *   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).
- * - `MUTATION` — a GATED structural or patch edit was refused: a duplicate id on
+ * - `MUTATION` — a gated structural or patch edit was refused: a duplicate id on
  *   `append`/`add`, a target that does not exist or is not `pending`, an out-of-bounds
  *   `index`, a patch that failed shaper validation, or a live structural edit refused by
- *   the NATIVE bottom-up gate — a terminal container, an edit targeting (or destined for)
- *   a position BEFORE the container's own pending-suffix boundary, or (a running phase)
+ *   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 returns it as a graceful `Result` `failure` —
- *   it NEVER throws for this code except {@link TaskInterface.patch} /
+ *   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). 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
+ *   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
@@ -3592,7 +3681,7 @@ export declare type WorkflowErrorCode = 'TRANSITION' | 'RESTORE' | 'MUTATION' |
  * / `move` / `update` fire on a successful
  * structural or patch edit through {@link WorkflowInterface.add} / `remove` / `move` /
  * `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
+ * reaches the domain surface — the emitter isolates it and routes it to its own
  * `error` handler (the `error` option). Declared as a `type` alias (not
  * `interface extends EventMap`) so the type-literal satisfies `EventMap`
  * structurally.
@@ -3632,12 +3721,12 @@ export declare interface WorkflowFault {
 
 /**
  * Declares the registered behavior a `function`-form
- * {@link TaskDefinition} runs, resolved BY NAME through the {@link WorkflowRegistry}
+ * {@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
- * `input` (the task's `metadata` bag), its lineage {@link TaskContext}, and read-UP access
+ * `input` (the task's `metadata` bag), its lineage {@link TaskContext}, and read-up access
  * 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
@@ -3651,19 +3740,19 @@ export declare type WorkflowInput = Partial<WorkflowContext>;
 
 /**
  * Declares the live derived state machine (W-b) for a whole {@link WorkflowDefinition} — the
- * observable root whose {@link LifecycleStatus} is DERIVED from its phases
+ * 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 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
+ *   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};
- *   `phase(id)` / `phases().phases()` read in positional order. `results` collects ALL
+ *   `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` 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);
@@ -3685,15 +3774,15 @@ export declare interface WorkflowInterface {
     readonly status: LifecycleStatus;
     readonly phases: PhaseManagerInterface;
     /**
-     * Reports whether the workflow is paused (resumable); RUNTIME-ONLY —
+     * 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;
-    /** Reports 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;
     /**
-     * Holds 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;
@@ -3705,7 +3794,7 @@ export declare interface WorkflowInterface {
      * Forces this workflow to `skipped`, overriding the derived value; idempotent.
      *
      * @remarks
-     * A NO-OP after `status` becomes 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).
      */
@@ -3714,7 +3803,7 @@ export declare interface WorkflowInterface {
      * Forces this workflow to `stopped`, overriding the derived value; idempotent.
      *
      * @remarks
-     * A NO-OP after `status` becomes 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).
      */
@@ -3723,8 +3812,8 @@ export declare interface WorkflowInterface {
      * 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
-     * every phase contains zero tasks. Its ONLY legitimate use is settling an executed no-op
+     * A no-op unless `status` is `pending` and the tree is genuinely vacuous: zero phases or
+     * every phase contains zero tasks. Its only legitimate use is settling an executed no-op
      * tree. It never overrides pending work or any started/terminal state.
      */
     complete(): void;
@@ -3733,10 +3822,10 @@ export declare interface WorkflowInterface {
      *
      * @remarks
      * 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
+     * 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 /
+     * never suspended mid-flight. **Pausing does not suspend the run's timeout / budget /
      * abort clocks** — those bounds keep ticking while paused, so a run parked on
      * `pause()` can still be cancelled (and settle `stopped`) by its own deadline / budget /
      * abort while parked.
@@ -3759,7 +3848,7 @@ export declare interface WorkflowInterface {
      */
     resume(): void;
     /**
-     * Tears this workflow down — an atomic TERMINAL teardown: mark
+     * Tears this workflow down — one 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.
@@ -3777,42 +3866,42 @@ export declare interface WorkflowInterface {
      */
     destroy(): void;
     /**
-     * Parks until this workflow is not paused — **promise-parked**, never a timer or
-     * busy-loop (mirrors {@link ControllerInterface.wait}'s doc style).
+     * Parks until this workflow is not paused — a promise-parked wait, never a timer or
+     * busy-loop.
      *
      * @remarks
-     * Resolves IMMEDIATELY when not {@link paused}. While paused, parks until `resume` /
+     * 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.
+     * ended workflow has nothing left to pause for). Never rejects.
      *
      * @returns A promise that resolves after the workflow is no longer paused
      */
     wait(): Promise<void>;
     /**
      * 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.
+     * into this workflow (the entity structural API) — gated before it delegates to the
+     * {@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
+     * this workflow, its recompute cascade, and its emitter hooks) plus each of its live
      * 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
      * phase's effective `bail` resolves exactly as the build path does
-     * (`definition.bail ?? this.bail`). Requires `definition.id` to be UNIQUE among this
+     * (`definition.bail ?? this.bail`). Requires `definition.id` to be unique among this
      * workflow's existing phase ids — a duplicate is a `MUTATION` failure (mirrors
      * {@link PhaseManagerInterface.add}'s own duplicate-id gate).
      *
-     * NATIVE gating, purely from this workflow's own derived `status` and the phase list's
-     * positions (no runner-installed hook), UNCHANGED from the entity-taking
+     * native gating, purely from this workflow's own derived `status` and the phase list's
+     * 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
+     * must fall within the pending suffix — the contiguous trailing run of `pending` phases
      * (phases run sequentially, so every already-started phase forms a contiguous leading
      * prefix); its boundary is {@link import('./helpers.js').deriveBoundary}. A `pending`
-     * workflow's phases are ALL `pending`, so the boundary is `0` and every index is
+     * workflow's phases are all `pending`, so the boundary is `0` and every index is
      * naturally accepted — no special case needed. Delegates the minted phase to
      * {@link PhaseManagerInterface.add} then emits `add` on success.
      *
@@ -3825,7 +3914,7 @@ export declare interface WorkflowInterface {
      * Removes the `pending` phase `id` from this workflow.
      *
      * @remarks
-     * NATIVE gating: refused while this workflow's own `status` is terminal. Otherwise the
+     * 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.
@@ -3838,7 +3927,7 @@ export declare interface WorkflowInterface {
      * Repositions the `pending` phase `id` to `index` within this workflow.
      *
      * @remarks
-     * NATIVE gating: refused while this workflow's own `status` is terminal. Otherwise BOTH
+     * native gating: refused while this workflow's own `status` is terminal. Otherwise both
      * the target's current index and the destination `index` must fall within the pending
      * suffix (see {@link remove}).
      *
@@ -3851,7 +3940,7 @@ export declare interface WorkflowInterface {
      * 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
+     * native gating: refused while this workflow's own `status` is terminal. Otherwise the
      * target must exist at an index within the pending suffix (see {@link remove}).
      *
      * @param id - The phase id to patch
@@ -3859,6 +3948,11 @@ export declare interface WorkflowInterface {
      * @returns A {@link Result} boxing the patched phase, or a `MUTATION` failure
      */
     update(id: string, patch: PhaseUpdate): Result<PhaseInterface, WorkflowError>;
+    /**
+     * Serializes the whole live tree — this workflow, its phases, and their tasks.
+     *
+     * @returns The pure-JSON {@link WorkflowSnapshot} a durable store persists
+     */
     snapshot(): WorkflowSnapshot;
 }
 
@@ -3873,14 +3967,14 @@ export declare interface WorkflowInterface {
  *   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,
+ *   overwrites (last write wins). `count` is the map size, `workflow(id)` looks one up,
  *   `workflows()` lists them in insertion order.
  * - **Durable open / save.** `open(id)` returns an already-registered workflow directly; same-id
  *   misses share one hydration. A concurrent `add` wins, while `remove` / `clear` invalidate
  *   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 (array overload FIRST) — `true` only when
+ * - **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".
@@ -3890,7 +3984,7 @@ export declare interface WorkflowInterface {
  * const manager = new WorkflowManager({
  * 	functions: { compile: async (controller) => `built ${controller.task.id}` },
  * })
- * const workflow = manager.add(definition) // minted, registered, RUNNABLE
+ * const workflow = manager.add(definition) // minted, registered, runnable
  * manager.workflow(workflow.id) // the same workflow
  * manager.count // 1
  * ```
@@ -3913,43 +4007,44 @@ export declare class WorkflowManager implements WorkflowManagerInterface {
  * 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`, because a
- * workflow only exists relative to a definition), and the optional `store` seam's `open`
- * threads the manager's {@link WorkflowRegistry} registry so a HYDRATED workflow is
- * immediately RUNNABLE, not merely a restored state mirror. NO `active` / `switch` pointer
- * — the workflow domain has no consumer that renders "the current workflow" the
- * way an agent context renders the active conversation/workspace.
+ * domain: `add` mints from a {@link WorkflowDefinition}, and the optional `store` seam's
+ * `open` threads the manager's {@link WorkflowRegistry} registry, so a hydrated workflow is
+ * immediately runnable rather than a restored state mirror.
  *
  * @remarks
  * - **Registry.** `count` is how many are stored. `add(definition)` mints a live
  *   {@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, because `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}
  *   is supplied (the `store` option), `open(id)` resolves an already-registered workflow
- *   directly (no store hit); same-id registry misses share one in-flight hydration. On a MISS
- *   it HYDRATES one from `store.get(id)` through
+ *   directly (no store hit); same-id registry misses share one in-flight hydration. On a miss
+ *   it hydrates one from `store.get(id)` through
  *   {@link import('./factories.js').createRestoredWorkflow} — flowing this manager's `functions`
- *   registry in so the rehydrated tree is RUNNABLE — registers it, and returns it. Registry
+ *   registry in so the rehydrated tree is runnable — registers it, and returns it. Registry
  *   mutation wins over an earlier pending hydration: `add` supplies the live result, while
  *   `remove` (even for an absent id) and `clear` invalidate the earlier read. Missed and failed
  *   reads leave no stale in-flight entry, and a payload whose own id differs from the requested
  *   key rejects with `RESTORE` instead of registering under either id. `save(id)` captures a
- *   registered workflow's {@link WorkflowInterface.snapshot} at invocation, then PERSISTS it.
+ *   registered workflow's {@link WorkflowInterface.snapshot} at invocation, then persists it.
  *   Same-id writes run serially in invocation order; different ids remain independent, and an
  *   earlier rejection reaches its caller without preventing a later queued write. Both are
- *   LENIENT without a store — `open` resolves only registered ids, `save` is a no-op
- *   (`false`) — never a throw. The EXACT analogue of
+ *   lenient without a store — `open` resolves only registered ids, `save` is a no-op
+ *   (`false`) — never a throw. The exact analogue of
  *   `ConversationManagerInterface.open` / `.save` and `WorkspaceManagerInterface.open` /
  *   `.save` — this is the workflow line's caller-driven persistence gaining the standard
- *   open/save seam, ADDITIVE alongside direct {@link WorkflowStoreInterface} use and
+ *   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 (array overload FIRST) — `true` only
+ * - **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).
+ * - **No pointer.** There is no `active` / `switch` pointer: no consumer of this domain renders
+ *   "the current workflow" the way an agent context renders the active conversation or
+ *   workspace. `add` mints from a {@link WorkflowDefinition} rather than from an empty `Input`,
+ *   because a workflow exists only relative to a definition.
  *
  * @example
  * ```ts
@@ -3958,21 +4053,32 @@ export declare class WorkflowManager implements WorkflowManagerInterface {
  * const manager = createWorkflowManager({
  * 	functions: { compile: async (controller) => `built ${controller.task.id}` },
  * })
- * const workflow = manager.add(definition) // minted, registered, RUNNABLE (functions flow in)
+ * const workflow = manager.add(definition) // minted, registered, runnable (functions flow in)
  * manager.count // 1
  * ```
  */
 export declare interface WorkflowManagerInterface {
     readonly count: number;
+    /**
+     * Looks up one registered workflow by its `id`.
+     *
+     * @param id - The workflow id to resolve
+     * @returns The registered workflow, or `undefined` when none is registered under that id
+     */
     workflow(id: string): WorkflowInterface | undefined;
+    /**
+     * Lists the registered workflows in insertion order.
+     *
+     * @returns Every registered workflow, in the order it was added
+     */
     workflows(): readonly WorkflowInterface[];
     /**
      * 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`.
+     * registry in) and registers it under `definition.id`, overwriting an already-registered id.
      *
      * @remarks
-     * An already-registered `definition.id` OVERWRITES (last write wins) — `createWorkflow`
+     * An already-registered `definition.id` overwrites (last write wins) — `createWorkflow`
      * keys the live tree by the definition's own id, so a re-`add` under the same id is
      * indistinguishable from a fresh mint at the registry level.
      *
@@ -3981,38 +4087,38 @@ export declare interface WorkflowManagerInterface {
      */
     add(definition: WorkflowDefinition): WorkflowInterface;
     /**
-     * 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).
+     * Resolves a workflow by id — from the registry when it holds one, otherwise hydrated from
+     * the optional {@link WorkflowStoreInterface} (`store`) and runnable, because this manager's
+     * `functions` registry is threaded into the rehydration.
      *
      * @remarks
-     * - If `id` is ALREADY registered, it is returned directly — no store hit.
+     * - 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
+     *   object. On a hit the snapshot is
      *   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
+     *   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
      *   with a normalized `RESTORE` error carrying the requested and payload ids.
      * - Registry mutation after the store read starts has precedence: `add(definition)` for the
      *   same id wins and becomes every pending caller's result; `remove(id)` invalidates that read
      *   even when the id was absent; `clear()` invalidates every earlier read. A miss or rejection
      *   clears the in-flight entry so a later call retries.
-     * - Else (no store, or a store MISS) ⇒ `undefined` (lenient — no throw).
+     * - Else (no store, or a store miss) ⇒ `undefined` (lenient — no throw).
      *
      * @param id - The workflow id to open
-     * @returns The resolved, RUNNABLE {@link WorkflowInterface}, or `undefined` when neither registered nor stored
+     * @returns The resolved, runnable {@link WorkflowInterface}, or `undefined` when neither registered nor stored
      */
     open(id: string): Promise<WorkflowInterface | undefined>;
     /**
-     * Persists 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
-     * When a `store` is set AND `id` is registered, the snapshot is captured synchronously at
+     * When a `store` is set and `id` is registered, the snapshot is captured synchronously at
      * invocation. Same-id `store.set` calls are serialized in invocation order; different ids are
      * independent. A rejected write reaches that caller unchanged but does not poison a later
-     * queued write. Otherwise (no store, OR an unknown id) it is a NO-OP returning `false`.
+     * 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 if the snapshot was persisted; false otherwise (no store, or an unknown id)
@@ -4022,7 +4128,7 @@ export declare interface WorkflowManagerInterface {
      * 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
+     * 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.
      *
@@ -4037,6 +4143,7 @@ export declare interface WorkflowManagerInterface {
      * @returns True if the id was registered and removed; false otherwise
      */
     remove(id: string): boolean;
+    /** Empties the registry, dropping every registered workflow. */
     clear(): void;
 }
 
@@ -4046,23 +4153,23 @@ export declare interface WorkflowManagerInterface {
  * hydrates resolves its tasks' handlers against.
  *
  * @remarks
- * `store` is the EXACT analogue of `ConversationManagerOptions.store` /
+ * `store` is the exact analogue of `ConversationManagerOptions.store` /
  * `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 WorkflowRegistry} 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
+ * hydrated workflow carries real resolved `handler`s and is runnable. Omitted ⇒ named work
  * remains inspectable but cannot be driven; omitted-`behavior` tasks remain deliberate no-ops.
  */
 export declare interface WorkflowManagerOptions {
     /**
      * 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
+     * / 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
      * what is already registered, and `save` is a no-op (`false`).
      */
     readonly store?: WorkflowStoreInterface;
@@ -4070,7 +4177,7 @@ export declare interface WorkflowManagerOptions {
      * 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 ⇒
+     * hydrated workflow is runnable, its tasks carrying real resolved `handler`s. Omitted ⇒
      * named tasks remain inspectable but execution rejects them.
      */
     readonly functions?: WorkflowRegistry;
@@ -4094,7 +4201,7 @@ export declare interface WorkflowOptions {
      * 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}
+     * {@link WorkflowSnapshot} persists the policy, so {@link import('./factories.js').createRestoredWorkflow}
      * takes it from the snapshot (the source of truth); an explicit `options.bail` on restore still
      * wins when supplied. Omitted on a fresh build ⇒ the graceful {@link import('./constants.js').DEFAULT_BAIL}.
      */
@@ -4105,8 +4212,8 @@ export declare interface WorkflowOptions {
     readonly phases?: Readonly<Record<string, PhaseOptions>>;
     /**
      * 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
+     * {@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
@@ -4121,11 +4228,12 @@ export declare interface WorkflowOptions {
 }
 
 /**
- * Coordinates advanced run-local snapshot persistence with one writer and one coalesced most recent obligation.
+ * Coordinates advanced run-local snapshot persistence with one writer and one coalesced most
+ * recent obligation, normally composed through `execute({ store })` rather than built directly.
  *
  * @remarks
- * Normally composed by `WorkflowRunner.execute({ store })`; exported for hosts that need to
- * coordinate the same required boundaries around their own runner integration.
+ * Exported for hosts that need to coordinate the same required boundaries around their own runner
+ * integration.
  *
  * @example
  * ```ts
@@ -4188,7 +4296,7 @@ export declare interface WorkflowPersistenceInterface {
  * {@link WorkflowFunction} handlers.
  *
  * @remarks
- * A live {@link TaskInterface} resolves its `behavior` name against this registry ONCE at
+ * 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
@@ -4198,12 +4306,13 @@ 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.
+ * live workflow, its final status, the flattened result tree, and the persistence outcome a
+ * supplied store produced.
  *
  * @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
+ * lineage) alongside the two read-throughs the run produced: `status` is the workflow's
  * 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
@@ -4225,8 +4334,8 @@ export declare interface WorkflowResult {
 }
 
 /**
- * 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
+ * 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
@@ -4237,33 +4346,33 @@ export declare interface WorkflowResult {
  *   timeout / budget / entity `signal` fold through the `@orkestrel/abort` signal contract,
  *   {@link createTimeout}, and `AbortSignal.any` (exactly as the agent runtime folds its bounds);
  *   pacing is the shipped
- *   {@link SchedulerInterface}. The runner writes ZERO concurrency / retry / abort logic of
+ *   {@link SchedulerInterface}. The runner writes zero concurrency / retry / abort logic of
  *   its own — it only sequences phases, dispatches a task's own handler, and drives the live
  *   entity. The workflow layer owns per-task deadlines because timeout settlement must
  *   update the live leaf under the phase's `bail` policy before the substrate unit settles.
  * - **Pure engine — no integration registry.** The runner carries no behavior or provider
  *   registry: each live {@link TaskInterface} already
  *   resolved its own {@link import('./types.js').WorkflowFunction} into
- *   {@link import('./types.js').TaskInterface.handler} ONCE at construction (build, restore,
+ *   {@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 "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
+ * - **Two `execute` forms, one engine.** `execute(definition, options)` builds the live tree
  *   from a {@link WorkflowDefinition} (single source of truth for the `behavior` / `concurrency`
- *   metadata); `execute(workflow, options)` DRIVES a caller-owned, ALREADY-BUILT
+ *   metadata); `execute(workflow, options)` drives a caller-owned, already-built
  *   {@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
+ *   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)
- *   runs under EXACTLY the same rules as one built from the original definition.
- * - **Phases sequential, tasks concurrent — LIVE continuity.** `#execute` drives the phases in
- *   order, RE-READING `workflow.phases.phases()` every iteration (a cursor over the live
+ *   runs under exactly the same rules as one built from the original definition.
+ * - **Phases sequential, tasks concurrent — live continuity.** `#execute` drives the phases in
+ *   order, re-reading `workflow.phases.phases()` every iteration (a cursor over the live
  *   manager, not a one-time snapshot) so a caller's `workflow.add(phaseDefinition)` mid-run is
- *   picked up. Within a phase, `#runPhase` subscribes to that phase's `add` event BEFORE
- *   capturing its task list, then `spawn`s any task added mid-phase onto the SAME substrate
+ *   picked up. Within a phase, `#runPhase` subscribes to that phase's `add` event before
+ *   capturing its task list, then `spawn`s any task added mid-phase onto the same substrate
  *   Runner (so it is actually dispatched, under the same `concurrency`); a task added too late
  *   for `spawn` to accept (the runner already drained) is swept `skip`ped afterward so the
  *   phase always reaches a coherent terminal state.
@@ -4272,30 +4381,30 @@ export declare interface WorkflowResult {
  *   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
- *   THEN re-throws, so the substrate Runner fail-fasts — it aborts the in-flight siblings
+ *   then re-throws, so the substrate Runner fail-fasts — it aborts the in-flight siblings
  *   (their `controller.signal` fires; a mid-flight sibling `skip`s) and rejects the phase run;
  *   `#execute` then `skip`s the remaining tasks / phases (the workflow derives `failed`).
- *   Under `bail: false` (graceful) a failure `fail`s the leaf and RESOLVES (never throws), so
+ *   Under `bail: false` (graceful) a failure `fail`s the leaf and resolves (never throws), so
  *   the Runner settles every unit (allSettled) and the run finishes (the workflow derives
  *   `completed`, the failure recorded in the result tree).
  * - **Pause / stop / destroy gates.** Workflow, phase, and task gates are checked before
  *   dispatch, and a running handler can checkpoint their folded state through
  *   {@link import('./types.js').TaskControllerInterface.wait}. Because the substrate acquires
  *   concurrency before this handler gate, a paused task occupies one phase slot until resume;
- *   already-running siblings continue and its per-attempt timeout keeps counting. A GRACEFUL
+ *   already-running siblings continue and its per-attempt timeout keeps counting. A graceful
  *   `workflow.stop()` (no signal involved) is caught at
  *   those same gates: not-yet-started work is `skip`ped, in-flight work finishes naturally. A
- *   HARD `workflow.destroy()` aborts {@link WorkflowInterface.signal}, which `#fold` has folded
+ *   hard `workflow.destroy()` aborts {@link WorkflowInterface.signal}, which `#fold` has folded
  *   into the run's composed signal — so it cancels the active phase Runner (and every
- *   in-flight task) exactly like an external abort / timeout / budget fire. EVERY park on a
- *   `wait()` gate is RACED against that same run signal (`#raceWait`, S2) — so a cancel firing
- *   WHILE parked unparks the engine promptly instead of hanging until `resume`; the existing
+ *   in-flight task) exactly like an external abort / timeout / budget fire. Every park on a
+ *   `wait()` gate is raced against that same run signal (`#raceWait`, S2) — so a cancel firing
+ *   while parked unparks the engine promptly instead of hanging until `resume`; the existing
  *   halt / abort re-checks after the gate then decide the outcome.
  * - **Abort / Timeout / Budget / entity-signal fold.** `#execute` folds the live workflow's
  *   own {@link WorkflowInterface.signal}, the run's external `signal`, a
  *   {@link TimeoutInterface}, and the `@orkestrel/budget` package's `BudgetInterface`'s
  *   `signal` into one `runSignal` (`AbortSignal.any`); a fire aborts the active phase's Runner
- *   (cancelling every in-flight task) and HALTS the run — the remaining tasks / phases `skip`
+ *   (cancelling every in-flight task) and halts the run — the remaining tasks / phases `skip`
  *   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.
@@ -4307,12 +4416,12 @@ export declare class WorkflowRunner implements WorkflowRunnerInterface {
     #private;
     constructor(scheduler: SchedulerInterface);
     /**
-     * Executes a workflow definition to completion — BUILDS its live tree, runs 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
+     * One-shot. The runner builds the live tree from `definition` internally (one source of
      * 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,
@@ -4320,7 +4429,7 @@ export declare class WorkflowRunner implements WorkflowRunnerInterface {
      * `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
+     * sibling tasks and `skip`s the remaining tasks / phases, settling the workflow `failed`. A
      * {@link WorkflowRunOptions} abort / timeout / budget fires every in-flight task's signal
      * and `stop`s the run. `execute` resolves (never rejects) on a cancel — the partial outcome
      * is read from the returned {@link WorkflowResult} (its `workflow` / `status` / `results`).
@@ -4329,7 +4438,7 @@ 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`) and the
+     *   `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
@@ -4340,25 +4449,25 @@ export declare class WorkflowRunner implements WorkflowRunnerInterface {
      */
     execute(definition: WorkflowDefinition, options?: WorkflowRunOptions): Promise<WorkflowResult>;
     /**
-     * Drives 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 through its own `pause` / `resume` / `add` / `stop` / `destroy`.
+     * 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. 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`
+     * 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 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`) and the durable `store`
-     * @returns The run's terminal {@link WorkflowResult} (its `workflow` is the SAME entity passed in)
+     * @returns The run's terminal {@link WorkflowResult} (its `workflow` is the same entity passed in)
      * @example
      * ```ts
      * const workflow = createWorkflow(definition)
@@ -4372,42 +4481,42 @@ export declare class WorkflowRunner implements WorkflowRunnerInterface {
 }
 
 /**
- * Declares 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.
+ * own resolved handler under the `bail` policy.
  *
  * @remarks
- * `execute(definition, options?)` BUILDS the live W-b entity tree from the definition itself
+ * `execute(definition, options?)` builds the live W-b entity tree from the definition itself
  * (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
+ * {@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 `behavior` (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
- * 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
+ * returned in {@link WorkflowResult.workflow}. The runner carries no registry of its own — it
+ * 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 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
+ * `execute(workflow, options?)` overload drives a caller-built live tree instead — the
  * entity-native control surface (`pause` / `resume` / `add` / `stop` /
  * `destroy` live on {@link WorkflowInterface} itself); see its own doc for details.
  */
 export declare interface WorkflowRunnerInterface {
     /**
-     * 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).
+     * Executes a workflow to completion — building the live tree from a definition, or driving
+     * an already-built caller-owned tree — running the phases sequentially with each phase's
+     * tasks concurrent, and resolving its terminal {@link WorkflowResult}.
      *
      * @remarks
-     * One-shot. The runner BUILDS the live tree from `definition` internally (one source of
+     * One-shot. The runner builds the live tree from `definition` internally (one source of
      * 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`
@@ -4415,17 +4524,17 @@ export declare interface WorkflowRunnerInterface {
      * registry) is forwarded to the build.
      * Under `bail: false` (graceful) every task settles (a failure is recorded on its
      * {@link TaskInterface}) and the workflow reaches `completed`; under `bail: true` (halt)
-     * the first failure aborts the in-flight sibling tasks AND `skip`s the remaining tasks /
+     * the first failure aborts the in-flight sibling tasks and `skip`s the remaining tasks /
      * phases, settling the workflow `failed`. A {@link WorkflowRunOptions} abort / timeout /
      * budget fires every in-flight task's signal and `stop`s the run. `execute` resolves
      * (never rejects) on a cancel — the partial outcome is read from the returned
      * {@link WorkflowResult} (its `workflow` / `status` / `results`). A run-level cancel
-     * (abort / timeout / budget) that fires on the SAME tick as a genuine task failure resolves
+     * (abort / timeout / budget) that fires on the same tick as a genuine task failure resolves
      * the run as `stopped` — the cancel supersedes the same-tick failure, and that task's error
      * is not recorded.
      *
-     * **Programmer-error exception.** A PATHOLOGICAL `definition` (for example, a
-     * duplicate phase or task `id`) THROWS SYNCHRONOUSLY at construction — before any phase
+     * **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
      * failures may reject asynchronously after remaining work is stopped, swept, and final
@@ -4433,40 +4542,40 @@ 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`) and the durable `store`
+     *   `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>;
     /**
-     * Drives an ALREADY-BUILT, CALLER-OWNED live {@link WorkflowInterface} — the
-     * ENTITY-NATIVE counterpart to the definition-building {@link execute} overload.
+     * 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 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 through its own `pause` / `resume` / `add` / `stop` /
+     * 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. 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
+     * sequentially and, within each phase, tasks concurrently — byte-identical observable
+     * semantics to the `definition`-form `execute` — except the phase loop re-reads the
      * live `workflow.phases` / each phase's live `tasks` every iteration (a cursor over
      * the live managers, not a one-time snapshot), so a caller's live `add` mid-run is
      * picked up and actually dispatched. `workflow.pause()` gates the run at the next
-     * phase boundary AND before each task's dispatch (an in-flight task body is never
+     * 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 RUN CONTROLS — the bounds (`signal` /
+     * 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 WorkflowRegistry} registry was supplied at that build: WITH a registry,
+     * {@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,
+     * handler and this overload actually dispatches it, resuming real work. Without a registry,
      * 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.
@@ -4476,7 +4585,7 @@ export declare interface WorkflowRunnerInterface {
      * @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)
+     * @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>;
 }
@@ -4486,15 +4595,15 @@ export declare interface WorkflowRunnerInterface {
  * paces phase boundaries with.
  *
  * @remarks
- * The runner is a PURE engine — it carries no `functions` / `tools` / `agents` registry
+ * The runner is a pure engine — it carries no `functions` / `tools` / `agents` registry
  * (each live task already resolved its own handler at construction from
  * {@link WorkflowOptions.functions}).
  * - `scheduler` — the {@link SchedulerInterface} that paces the tree (a cooperative
  *   `yield` between phases). Omitted ⇒ the shipped cross-environment default
  *   ({@link createScheduler}).
  *
- * 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` /
+ * 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.
  */
@@ -4504,13 +4613,13 @@ export declare interface WorkflowRunnerOptions {
 
 /**
  * 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
+ * construction options ({@link WorkflowOptions}) beside the per-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 (through
- * {@link import('./factories.js').createWorkflow}), so these options carry BOTH halves of
+ * `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`
  *   override, the per-node `phases` bag); `execute` forwards it straight to `createWorkflow`,
@@ -4521,8 +4630,8 @@ export declare interface WorkflowRunnerOptions {
  *   fold and the store makes the run durable.
  *
  * 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
+ * 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`.
  * - `signal` — an external cancellation (a caller `AbortController`).
  * - `timeout` — a whole-run deadline in milliseconds. A non-positive, non-finite, or
@@ -4530,19 +4639,19 @@ export declare interface WorkflowRunnerOptions {
  * - `budget` — a whole-run cost ceiling (a {@link BudgetInterface} over {@link TokenUsage}
  *   — its `signal` fires when a task-reported usage crosses `max`); the runner folds its
  *   `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.)
+ *   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
+ * `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
+ * 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
+ * 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.
+ * whose state is no longer recoverable. This half applies to both `execute` overloads.
  */
 export declare type WorkflowRunOptions = WorkflowOptions & {
     readonly signal?: AbortSignal;
@@ -4557,26 +4666,26 @@ export declare type WorkflowRunOptions = WorkflowOptions & {
  * failure policy (the literal pair `true`/`false`, the runtime mirror of the boolean
  * toggle; omitted ⇒ the graceful default).
  */
-export declare const workflowShape: ObjectShape<{
-    id: StringShape;
-    name: StringShape;
-    description: OptionalShape<StringShape>;
-    phases: ArrayShape<ObjectShape<{
-        id: StringShape;
-        name: StringShape;
-        description: OptionalShape<StringShape>;
-        tasks: ArrayShape<ObjectShape<{
-            id: StringShape;
-            name: StringShape;
-            description: OptionalShape<StringShape>;
-            behavior: OptionalShape<StringShape>;
-            retries: OptionalShape<NumberShape>;
-            timeout: OptionalShape<NumberShape>;
-        }, false>>;
-        concurrency: OptionalShape<NumberShape>;
-        bail: OptionalShape<LiteralShape<readonly [true, false]>>;
-    }, false>>;
-    bail: OptionalShape<LiteralShape<readonly [true, false]>>;
+export declare const workflowShape: ObjectShape<    {
+id: StringShape;
+name: StringShape;
+description: OptionalShape<StringShape>;
+phases: ArrayShape<ObjectShape<    {
+id: StringShape;
+name: StringShape;
+description: OptionalShape<StringShape>;
+tasks: ArrayShape<ObjectShape<    {
+id: StringShape;
+name: StringShape;
+description: OptionalShape<StringShape>;
+behavior: OptionalShape<StringShape>;
+retries: OptionalShape<NumberShape>;
+timeout: OptionalShape<NumberShape>;
+}, false>>;
+concurrency: OptionalShape<NumberShape>;
+bail: OptionalShape<LiteralShape<readonly [true, false]>>;
+}, false>>;
+bail: OptionalShape<LiteralShape<readonly [true, false]>>;
 }, false>;
 
 /**
@@ -4585,16 +4694,16 @@ export declare const workflowShape: ObjectShape<{
  * and creation / update timestamps.
  *
  * @remarks
- * Pure JSON DATA — the COMPLETE, SELF-CONTAINED payload the durable store (W-d) persists,
+ * 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` 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)
+ * 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
  * vacuous `completed`. The completed override is valid only for an otherwise-derived pending
- * tree containing no tasks. An override is PRESENT only when one is in force (so a restore
- * reinstates it DIRECTLY rather than guessing from a status divergence). `phases` are the
+ * tree containing no tasks. An override is present only when one is in force (so a restore
+ * reinstates it directly rather than guessing from a status divergence). `phases` are the
  * workflow's {@link PhaseSnapshot}s in order; `created` / `updated` are ms since epoch.
  */
 export declare interface WorkflowSnapshot {
@@ -4614,13 +4723,14 @@ export declare interface WorkflowSnapshot {
 
 /**
  * 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.
+ * persists — a workflow `id` plus its {@link WorkflowSnapshot} held as one opaque JSON column,
+ * read back as `unknown` and narrowed on `get`.
  *
  * @remarks
  * The Database twin of {@link WorkflowStoreInterface} stores the snapshot whole (the `snapshot`
  * column is a `rawShape`, an opaque JSON blob — exactly as
  * `@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
+ * 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 owns and narrows it to a
  * {@link WorkflowSnapshot} on `get` through {@link import('./cloners.js').cloneWorkflowSnapshot},
@@ -4637,28 +4747,28 @@ export declare interface WorkflowSnapshotRow {
 }
 
 /**
- * Declares the durable persistence seam for a {@link WorkflowSnapshot} — three async primitives
- * (`get` / `set` / `delete`) keyed by a workflow id, the snapshot analogue of
+ * Declares the durable persistence seam for a {@link WorkflowSnapshot} — the async `get` / `set` /
+ * `delete` primitives keyed by a workflow id, the snapshot analogue of
  * the server package's `SessionStoreInterface` (and the `@orkestrel/queue`
  * `QueueStoreInterface` driver-swap pattern).
  *
  * @remarks
- * The store persists the W-a {@link WorkflowSnapshot} — the COMPLETE, self-contained,
- * pure-JSON run state — so a JSON / SQLite / IndexedDB backend swaps in WITHOUT touching the
+ * The store persists the W-a {@link WorkflowSnapshot} — the complete, self-contained,
+ * pure-JSON run state — so a JSON / SQLite / IndexedDB backend swaps in without touching the
  * runner or the entity tree: the in-memory default
  * {@link import('./stores/MemoryWorkflowStore.js').MemoryWorkflowStore} and its driver-pluggable
  * twin {@link import('./stores/DatabaseWorkflowStore.js').DatabaseWorkflowStore} (the snapshot as
- * one opaque JSON column) share THIS one interface. Restore is NOT a store concern — a caller reads
+ * one opaque JSON column) share this one interface. Restore is not a store concern — a caller reads
  * a snapshot back and rebuilds the live tree with the shipped {@link import('./factories.js').createRestoredWorkflow}.
  *
  * Every primitive is async (a `Promise`), so a durable backend (a database round-trip) fits the
- * same shape as the memory one. The snapshot carries its OWN id, so `set` takes no separate id
+ * same shape as the memory one. The snapshot carries its own id, so `set` takes no separate id
  * param (mirroring `QueueStoreInterface.save` from `@orkestrel/queue` / the server package's
  * `SessionStoreInterface.set`, which key off the value's own
- * `id`). UNLIKE a session store there is NO idle-TTL / eviction — a persisted workflow run-state
+ * `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
- * (the smallest interface the capability requires), because the snapshot is the ONE payload a
+ * (the smallest interface the capability requires), because the snapshot is the one payload a
  * workflow store persists.
  */
 export declare interface WorkflowStoreInterface {