@orkestrel/workflow 0.0.17 → 0.0.19

package/dist/src/core/index.js

@@ -1,16 +1,17 @@
+import { arrayShape, attempt, cloneJSONRecord, cloneJSONValue, compileGuard, createContract, integerShape, isArray, isBoolean, isContractError, isError, isFiniteNumber, isFunction, isInstance, isInteger, isJSONValue, isNonEmptyString, isObject, isRecord, isString, literalShape, objectShape, optionalShape, rawShape, stringShape } from "@orkestrel/contract";
 import { createAbort, isAbortSignal, linkSignal } from "@orkestrel/abort";
-import { arrayShape, attempt, cloneJSONRecord, cloneJSONValue, compileGuard, createContract, integerShape, isArray, isBoolean, isContractError, isFiniteNumber, isFunction, isInteger, isJSONValue, isNonEmptyString, isObject, isRecord, literalShape, objectShape, optionalShape, rawShape, stringShape } from "@orkestrel/contract";
 import { createDatabase, createMemoryDriver } from "@orkestrel/database";
 import { Emitter } from "@orkestrel/emitter";
 import { createTimeout } from "@orkestrel/timeout";
 import { createQueue } from "@orkestrel/queue";
 //#region src/core/errors.ts
 /**
-* 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
@@ -43,18 +44,18 @@ var WorkflowError = class extends Error {
 * ```
 */
 function isWorkflowError(value) {
-	try {
-		return value instanceof WorkflowError;
-	} catch {
-		return false;
-	}
+	return isInstance(value, WorkflowError);
 }
 //#endregion
 //#region src/core/constants.ts
-/** 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.
+*/
 var DEFAULT_BAIL = false;
 /**
-* 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` /
@@ -70,8 +71,8 @@ var LIFECYCLE_STATUSES = Object.freeze([
 	"stopped"
 ]);
 /**
-* 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}.
@@ -116,30 +117,32 @@ var TASK_TRANSITIONS = Object.freeze({
 /**
 * 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.
 */
 var DEFAULT_PHASE_CONCURRENCY = 1024;
 /**
-* 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.
 */
 var MAX_TIMER_MS = 2147483647;
 /**
 * 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
@@ -158,7 +161,8 @@ var PERSISTED_NODE_EVENTS = Object.freeze([
 	"update"
 ]);
 /**
-* 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
@@ -229,8 +233,8 @@ function isTaskFailure(value) {
 * 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
@@ -269,14 +273,14 @@ function isWorkflowInterface(value) {
 */
 function isOwnedWorkflowSnapshot(value) {
 	try {
-		if (!isRecord(value) || !Object.keys(value).every((key) => key === "id" || key === "name" || key === "description" || key === "status" || key === "override" || key === "bail" || key === "phases" || key === "created" || key === "updated") || !isNonEmptyString(value.id) || !isNonEmptyString(value.name) || value.description !== void 0 && typeof value.description !== "string" || !isLifecycleStatus(value.status) || value.override !== void 0 && value.override !== "completed" && value.override !== "skipped" && value.override !== "stopped" || !isBoolean(value.bail) || !isArray(value.phases) || !isFiniteNumber(value.created) || value.created < 0 || !isFiniteNumber(value.updated) || value.updated < value.created) return false;
+		if (!isRecord(value) || !Object.keys(value).every((key) => key === "id" || key === "name" || key === "description" || key === "status" || key === "override" || key === "bail" || key === "phases" || key === "created" || key === "updated") || !isNonEmptyString(value.id) || !isNonEmptyString(value.name) || value.description !== void 0 && !isString(value.description) || !isLifecycleStatus(value.status) || value.override !== void 0 && value.override !== "completed" && value.override !== "skipped" && value.override !== "stopped" || !isBoolean(value.bail) || !isArray(value.phases) || !isFiniteNumber(value.created) || value.created < 0 || !isFiniteNumber(value.updated) || value.updated < value.created) return false;
 		const phaseIds = /* @__PURE__ */ new Set();
 		const derivations = [];
 		let frontier = false;
 		let running = false;
 		let vacuous = true;
 		for (const phase of value.phases) {
-			if (!isRecord(phase) || !Object.keys(phase).every((key) => key === "id" || key === "name" || key === "description" || key === "status" || key === "override" || key === "bail" || key === "concurrency" || key === "tasks") || !isNonEmptyString(phase.id) || phaseIds.has(phase.id) || !isNonEmptyString(phase.name) || phase.description !== void 0 && typeof phase.description !== "string" || !isLifecycleStatus(phase.status) || phase.override !== void 0 && phase.override !== "skipped" && phase.override !== "stopped" || !isBoolean(phase.bail) || phase.concurrency !== void 0 && (!isInteger(phase.concurrency) || phase.concurrency < 1) || !isArray(phase.tasks)) return false;
+			if (!isRecord(phase) || !Object.keys(phase).every((key) => key === "id" || key === "name" || key === "description" || key === "status" || key === "override" || key === "bail" || key === "concurrency" || key === "tasks") || !isNonEmptyString(phase.id) || phaseIds.has(phase.id) || !isNonEmptyString(phase.name) || phase.description !== void 0 && !isString(phase.description) || !isLifecycleStatus(phase.status) || phase.override !== void 0 && phase.override !== "skipped" && phase.override !== "stopped" || !isBoolean(phase.bail) || phase.concurrency !== void 0 && (!isInteger(phase.concurrency) || phase.concurrency < 1) || !isArray(phase.tasks)) return false;
 			const forced = phase.override === "skipped" || phase.override === "stopped";
 			const started = phase.status === "running" || phase.status === "completed" || phase.status === "failed";
 			if (!forced && frontier && started || phase.status === "running" && running) return false;
@@ -287,7 +291,7 @@ function isOwnedWorkflowSnapshot(value) {
 			const statuses = [];
 			if (phase.tasks.length > 0) vacuous = false;
 			for (const task of phase.tasks) {
-				if (!isRecord(task) || !Object.keys(task).every((key) => key === "id" || key === "name" || key === "description" || key === "status" || key === "result" || key === "metadata" || key === "attempts" || key === "behavior" || key === "retries" || key === "timeout" || key === "activity") || !isNonEmptyString(task.id) || taskIds.has(task.id) || !isNonEmptyString(task.name) || task.description !== void 0 && typeof task.description !== "string" || !isLifecycleStatus(task.status) || !isRecord(task.metadata) || !isJSONValue(task.metadata) || !isInteger(task.attempts) || task.attempts < 0 || task.behavior !== void 0 && !isNonEmptyString(task.behavior) || task.retries !== void 0 && (!isInteger(task.retries) || task.retries < 0) || task.timeout !== void 0 && (!isInteger(task.timeout) || task.timeout < 0 || task.timeout > 2147483647)) return false;
+				if (!isRecord(task) || !Object.keys(task).every((key) => key === "id" || key === "name" || key === "description" || key === "status" || key === "result" || key === "metadata" || key === "attempts" || key === "behavior" || key === "retries" || key === "timeout" || key === "activity") || !isNonEmptyString(task.id) || taskIds.has(task.id) || !isNonEmptyString(task.name) || task.description !== void 0 && !isString(task.description) || !isLifecycleStatus(task.status) || !isRecord(task.metadata) || !isJSONValue(task.metadata) || !isInteger(task.attempts) || task.attempts < 0 || task.behavior !== void 0 && !isNonEmptyString(task.behavior) || task.retries !== void 0 && (!isInteger(task.retries) || task.retries < 0) || task.timeout !== void 0 && (!isInteger(task.timeout) || task.timeout < 0 || task.timeout > 2147483647)) return false;
 				const budget = (task.retries ?? 0) + 1;
 				if (task.attempts > budget || task.status === "pending" && task.attempts >= budget) return false;
 				if (!(task.activity === void 0 || isTaskActivity(task.activity))) return false;
@@ -422,7 +426,7 @@ function isTaskActivityInput(value) {
 * 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.
@@ -494,11 +498,11 @@ function captureWorkflowOptions(options) {
 	});
 }
 /**
-* 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
@@ -513,12 +517,13 @@ function isTerminalStatus(status) {
 	return TERMINAL_STATUSES.includes(status);
 }
 /**
-* 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
@@ -541,11 +546,11 @@ function isHalted(workflow, phase) {
 	return isTerminalStatus(status) && status !== "completed" || phase?.status === "skipped" || phase?.status === "stopped";
 }
 /**
-* 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
@@ -571,7 +576,7 @@ function isStoppable(workflow) {
 * @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.
@@ -595,7 +600,7 @@ function isCompletable(workflow) {
 * 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.
 *
@@ -617,7 +622,7 @@ function isSkipping(task, controller, runSignal) {
 *
 * @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.
@@ -638,14 +643,14 @@ function ownsAttempt(owners, task, attempt) {
 	return owners.get(task.id) === attempt && task.attempts === attempt;
 }
 /**
-* 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
@@ -669,23 +674,24 @@ function derivePhaseStatus(tasks) {
 }
 /**
 * 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
@@ -705,18 +711,19 @@ function deriveWorkflowStatus(phases) {
 	return "skipped";
 }
 /**
-* 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.
 *
@@ -752,15 +759,16 @@ function canTransitionTask(from, to) {
 	return TASK_TRANSITIONS[from].includes(to);
 }
 /**
-* 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
 * @returns A host-safe effective window (`1..MAX_TIMER_MS`), or `undefined`
 */
 function resolveTaskSilence(value, fallback) {
-	if (value !== void 0) return Number.isFinite(value) && value > 0 && value <= 2147483647 ? value : void 0;
-	return fallback !== void 0 && Number.isFinite(fallback) && fallback > 0 && fallback <= 2147483647 ? fallback : void 0;
+	if (value !== void 0) return isFiniteNumber(value) && value > 0 && value <= 2147483647 ? value : void 0;
+	return fallback !== void 0 && isFiniteNumber(fallback) && fallback > 0 && fallback <= 2147483647 ? fallback : void 0;
 }
 /**
 * Boxes a value as a {@link Success} — the graceful outcome half of a {@link Result}.
@@ -806,8 +814,8 @@ function failure(error) {
 */
 function errorToMessage(error) {
 	try {
-		const message = error instanceof Error ? error.message : String(error);
-		return typeof message === "string" && message.length > 0 ? message : "unknown failure";
+		const message = isError(error) ? error.message : String(error);
+		return isString(message) && message.length > 0 ? message : "unknown failure";
 	} catch {
 		return "unknown failure";
 	}
@@ -819,7 +827,7 @@ function errorToMessage(error) {
 *
 * @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
@@ -859,7 +867,7 @@ function buildWorkflowContext(node) {
 * 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}
 */
@@ -874,7 +882,7 @@ function buildPhaseContext(workflow, node) {
 * (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}
 */
@@ -885,9 +893,9 @@ function buildTaskContext(phase, node) {
 	});
 }
 /**
-* 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)
@@ -896,20 +904,20 @@ function buildTaskContext(phase, node) {
 * `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}
 */
 function definitionToSnapshot(definition, bail) {
@@ -931,7 +939,7 @@ function definitionToSnapshot(definition, bail) {
 * {@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.
@@ -1061,7 +1069,7 @@ function recoverWorkflowSnapshot(snapshot) {
 *
 * @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.
 *
@@ -1077,14 +1085,14 @@ function recoverWorkflowSnapshot(snapshot) {
 * ```
 */
 function matchesDescription(left, right) {
-	return left === right && (left === void 0 || typeof left === "string");
+	return left === right && (left === void 0 || isString(left));
 }
 /**
 * Tests a result's lineage against its containing snapshot nodes.
 *
 * @remarks
 * The four arguments are the result and the three snapshot nodes it claims to belong to, read
-* from the OUTSIDE in: a {@link TaskResult} is self-describing, so restoring one is only safe
+* 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`,
@@ -1311,7 +1319,7 @@ function scheduleHost(start, signal) {
 * {@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`.
@@ -1334,10 +1342,10 @@ function delayHost(ms, signal) {
 }
 /**
 * 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.
@@ -1372,9 +1380,9 @@ function parkSignal(signal) {
 *   (`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.
@@ -1467,13 +1475,13 @@ var Collection = class {
 * 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".
@@ -1498,7 +1506,7 @@ var Collection = class {
 var Scheduler = class {
 	/**
 	* 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) {
@@ -1753,28 +1761,28 @@ var phaseUpdateShape = objectShape({
 //#region src/core/stores/DatabaseWorkflowStore.ts
 /**
 * 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
@@ -1784,9 +1792,9 @@ var phaseUpdateShape = objectShape({
 *   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}.
 *
@@ -1820,7 +1828,7 @@ var DatabaseWorkflowStore = class {
 		if (row === void 0) return void 0;
 		return cloneWorkflowSnapshot(row.snapshot, id);
 	}
-	/** 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 }`. */
 	async set(snapshot) {
 		const owned = cloneWorkflowSnapshot(snapshot);
 		await this.#table.set({
@@ -1837,27 +1845,24 @@ var DatabaseWorkflowStore = class {
 //#region src/core/stores/MemoryWorkflowStore.ts
 /**
 * 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}.
 *
@@ -1900,27 +1905,27 @@ var MemoryWorkflowStore = class {
 * - **Guarded transitions.** `start` (→ `running`), then `complete(value)`
 *   (→ `completed`, records a {@link import('@orkestrel/contract').Success}), `fail(error)`
 *   (→ `failed`, records a {@link import('@orkestrel/contract').Failure}), `skip` (→ `skipped`),
-*   `stop` (→ `stopped`). Each consults {@link canTransitionTask} FIRST and throws a
+*   `stop` (→ `stopped`). Each consults {@link canTransitionTask} first and throws a
 *   `TRANSITION` {@link WorkflowError} on an illegal move (for example, completing a
 *   non-`running` task) — the legal graph is the single source of truth, so the leaf can never
 *   reach an impossible state.
 * - **Snapshot fidelity.** A leaf needs no override: `skipped` / `stopped` are explicit terminal
 *   statuses, and restore reinstates the leaf directly from {@link TaskSnapshot.status}.
 * - **The cascade.** Every status change records its boxed result (when any), fires the leaf's
-*   OWN event, THEN calls the parent phase's `#recompute` (injected at construction) so the
-*   transition propagates UP (Task → Phase → Workflow re-derive). The own-event-before-cascade
-*   order means an observer sees the CAUSE (this leaf changed) before the EFFECT (the parents
+*   own event, then calls the parent phase's `#recompute` (injected at construction) so the
+*   transition propagates up (Task → Phase → Workflow re-derive). The own-event-before-cascade
+*   order means an observer sees the cause (this leaf changed) before the effect (the parents
 *   re-derive) — the project precedent (`Runner.#settle` emits its own `fail` before propagating).
 * - **Observable.** The owned {@link emitter} ({@link TaskEventMap}) fires the
-*   matching event strictly AFTER the state change, BEFORE the cascade; the emitter isolates
+*   matching event strictly after the state change, before the cascade; the emitter isolates
 *   a listener throw and routes it to its `error` handler (the `error` option), so a buggy
 *   observer can never corrupt a transition.
-* - **Declarative config.** `behavior` / `retries` / `timeout` PERSIST in a
+* - **Declarative config.** `behavior` / `retries` / `timeout` persist in a
 *   {@link TaskSnapshot} (like a phase's `bail` / `concurrency`), carried verbatim from the
 *   matching {@link import('../types.js').TaskDefinition} / {@link TaskSnapshot} field. `handler`
-*   is the RUNTIME-ONLY counterpart — `behavior` resolved ONCE at construction against the
+*   is the runtime-only counterpart — `behavior` resolved once at construction against the
 *   workflow-level {@link import('../types.js').WorkflowOptions.functions} registry — and is
-*   NEVER persisted; `undefined` when `behavior` is omitted or unregistered. Only omission is a
+*   never persisted; `undefined` when `behavior` is omitted or unregistered. Only omission is a
 *   deliberate no-op; unresolved named work is rejected before dispatch.
 */
 var Task = class {
@@ -2078,7 +2083,7 @@ var Task = class {
 	}
 	fail(error) {
 		const origin = error.origin === "handler" || error.origin === "timeout" || error.origin === "recovery" ? error.origin : "handler";
-		const message = typeof error.message === "string" && error.message.length > 0 ? error.message : "unknown failure";
+		const message = isString(error.message) && error.message.length > 0 ? error.message : "unknown failure";
 		this.#transition("failed");
 		this.#finish();
 		const result = this.#record("failed", Object.freeze({
@@ -2117,7 +2122,7 @@ var Task = class {
 			this.#emitter.emit("report", activity);
 			return success(activity);
 		} catch (error) {
-			return failure(error instanceof WorkflowError ? error : new WorkflowError("MUTATION", "task activity report was refused", { task: this.id }));
+			return failure(isWorkflowError(error) ? error : new WorkflowError("MUTATION", "task activity report was refused", { task: this.id }));
 		}
 	}
 	pulse() {
@@ -2144,12 +2149,12 @@ var Task = class {
 		return this.#paused && this.#gate !== void 0 ? this.#gate.promise : Promise.resolve();
 	}
 	/**
-	* Applies a validated declarative patch to SELF (`name` / `description`).
+	* Applies a validated declarative patch to self (`name` / `description`).
 	*
 	* @remarks
 	* Defense-in-depth: the owning
-	* {@link import('../types.js').TaskManagerInterface.update} gates FIRST (target
-	* exists + `pending`), so this is the second, redundant check — it THROWS a
+	* {@link import('../types.js').TaskManagerInterface.update} gates first (target
+	* exists + `pending`), so this is the second, redundant check — it throws a
 	* `MUTATION` {@link WorkflowError} unless this task's own `status` is `pending`.
 	*
 	* @param value - The {@link TaskUpdate} fields to apply
@@ -2258,10 +2263,10 @@ var Task = class {
 *   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.
@@ -2309,47 +2314,47 @@ var TaskManager = class {
 //#endregion
 //#region src/core/phases/Phase.ts
 /**
-* Implements the live DERIVED state machine (W-b) for one phase — an observable whose
+* Implements the live derived state machine (W-b) for one phase — an observable whose
 * {@link LifecycleStatus} is computed from its tasks (never set directly) and recomputed
 * reactively as a task transitions (the middle tier of the cascade).
 *
 * @remarks
 * - **Derived status.** `status` is `#override` when one is in force, else
 *   {@link derivePhaseStatus} over the live tasks' statuses. `#recompute` (passed to
-*   each child {@link Task}) re-derives on every child transition; a CHANGE emits the matching
-*   event AND escalates to the workflow (`#escalate`, the upward step of the cascade).
-* - **Override.** `skip` / `stop` FORCE the phase's status (for example, skipping a whole
-*   phase), overriding the derived value; the override is PERSISTED in the snapshot's own
-*   `override` field and restored DIRECTLY (no divergence guess), so a forced phase round-trips.
+*   each child {@link Task}) re-derives on every child transition; a change emits the matching
+*   event and escalates to the workflow (`#escalate`, the upward step of the cascade).
+* - **Override.** `skip` / `stop` force the phase's status (for example, skipping a whole
+*   phase), overriding the derived value; the override is persisted in the snapshot's own
+*   `override` field and restored directly (no divergence guess), so a forced phase round-trips.
 * - **Children.** `tasks` is the lean {@link TaskManager} (an accessor + `count`,
 *   no batch matrix); built positionally from the snapshot so order survives an interior `skip`.
 *   `results()` collects the settled tasks' {@link TaskResult}s (the phase tier of the result
-*   tree); `workflow` navigates UP to the live parent.
+*   tree); `workflow` navigates up to the live parent.
 * - **Observable.** The owned {@link emitter} ({@link PhaseEventMap}) fires
 *   `start` / `complete` / `fail` / `pause` / `resume` / `skip` / `stop` after the
 *   corresponding status or runtime-gate change. Status events fire after the phase recomputes
 *   and before it escalates to the workflow, preserving child/phase cause before parent effect.
 *   The emitter isolates a listener throw and routes it to its `error` handler (the `error`
 *   option); `fail` carries the failing task's {@link TaskResult}.
-* - **Structural API.** `add` / `remove` / `move` / `update` gate BEFORE
+* - **Structural API.** `add` / `remove` / `move` / `update` gate before
 *   delegating to {@link tasks} (the manager gates the target's own existence/status/id/
-*   bounds), then emit the matching {@link PhaseEventMap} event on success only. NATIVE
+*   bounds), then emit the matching {@link PhaseEventMap} event on success only. Native
 *   gating, purely from this phase's own derived `status` (no runner-installed hook): while
-*   `pending`, any valid `index` is accepted; while `running`, `add` accepts ONLY a pure
+*   `pending`, any valid `index` is accepted; while `running`, `add` accepts only a pure
 *   append (a live runner subscribed to the `add` event picks it up), and `remove` / `move` /
 *   `update` always fail gracefully (the tasks are already handed to the execution
 *   substrate); while terminal, everything is refused.
-* - **Patch.** `patch` applies a validated {@link PhaseUpdate} to SELF
+* - **Patch.** `patch` applies a validated {@link PhaseUpdate} to self
 *   (`name` / `description` / `concurrency` / `bail`) — defense-in-depth: it throws a
 *   `MUTATION` {@link WorkflowError} unless this phase's own `status` is `pending`, mirroring
 *   the owning {@link WorkflowInterface.update}'s gate.
-* - **Minting.** {@link add} MINTS a live {@link Task} from a {@link TaskDefinition}
-*   (converts it to a {@link TaskSnapshot}, builds the task wired to THIS phase) — the same
+* - **Minting.** {@link add} mints a live {@link Task} from a {@link TaskDefinition}
+*   (converts it to a {@link TaskSnapshot}, builds the task wired to this phase) — the same
 *   construction path {@link #append} uses at build time, so a live mint and a restored/built
-*   task are wired IDENTICALLY. At construction, the workflow-level
+*   task are wired identically. At construction, the workflow-level
 *   {@link import('../types.js').WorkflowRegistry} registry (threaded from
 *   {@link import('../types.js').WorkflowOptions.functions}) resolves every unique initial `behavior`
-*   name ONCE before any task is built; siblings sharing a name receive the exact same captured
+*   name once before any task is built; siblings sharing a name receive the exact same captured
 *   runtime {@link import('../types.js').TaskInterface.handler}. A later live {@link add} reads
 *   that name once from the retained registry at its own mint moment. An omitted or unregistered
 *   `behavior` resolves to no handler; only omission is a no-op, while an unresolved present name makes
@@ -2357,7 +2362,7 @@ var TaskManager = class {
 * - **Runtime lifecycle.** `pause` / `resume` / `wait` mirror the workflow's own
 *   quartet, scoped to this phase — a driving
 *   {@link import('../types.js').WorkflowRunnerInterface.execute} gates a task's own
-*   pre-dispatch on the workflow's gate FIRST, then this phase's gate, WITHOUT touching
+*   pre-dispatch on the workflow's gate first, then this phase's gate, without touching
 *   {@link status} — `paused` is runtime-only, never persisted. `skip` / `stop` (this phase's
 *   own terminal forcing) always release a parked {@link wait} waiter, mirroring
 *   {@link import('../Workflow.js').Workflow.destroy}'s cascade — a permanently-ended phase
@@ -2616,7 +2621,7 @@ var Phase = class {
 *   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.
@@ -2664,7 +2669,7 @@ var PhaseManager = class {
 //#endregion
 //#region src/core/Workflow.ts
 /**
-* 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.
 *
@@ -2675,16 +2680,16 @@ var PhaseManager = class {
 *   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
@@ -2692,17 +2697,17 @@ var PhaseManager = class {
 *   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
@@ -2991,14 +2996,14 @@ var Workflow = class {
 *   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".
@@ -3008,7 +3013,7 @@ var Workflow = class {
 * 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
 * ```
@@ -3234,11 +3239,11 @@ var RunHolder = class {
 *   unit it dispatches, handing it the unit's `id`, `input`, the unit's `Abort`
 *   handle, the queue attempt's `signal`, and a `spawn` callback that launches a
 *   sibling through the same queue.
-* - **Signal.** `signal` is the queue attempt's signal, which ANY-combines the
+* - **Signal.** `signal` is the queue attempt's signal, which any-combines the
 *   unit's own abort, the runner-level abort (the runner aborts every unit), and
 *   the per-attempt timeout — so it fires on any of the three. `aborted` and
 *   `abort(reason)` delegate to the unit's `Abort` (the cancellation source of
-*   truth); because the attempt signal ANY-includes that abort, `abort()` fires
+*   truth); because the attempt signal any-includes that abort, `abort()` fires
 *   `signal` too.
 * - **`wait` promise-parks (never a timer).** It resolves the instant the unit's
 *   `signal` fires (immediately if already aborted) through a one-shot listener — no
@@ -3298,13 +3303,13 @@ var Controller = class {
 *   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
@@ -3316,26 +3321,26 @@ var Controller = class {
 *   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.
@@ -3394,15 +3399,15 @@ var Runner = class {
 		return this.#queue.paused;
 	}
 	/**
-	* 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` —
@@ -3462,7 +3467,7 @@ var Runner = class {
 	}
 	/**
 	* 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
@@ -3486,10 +3491,10 @@ var Runner = class {
 		this.#queue.resume();
 	}
 	/**
-	* 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
@@ -3618,21 +3623,21 @@ var Runner = class {
 * Implements the attempt-scoped handle a {@link import('./types.js').WorkflowFunction} receives.
 *
 * @remarks
-* - **A leaf handle, NOT the runner `Controller`.** A workflow task is a leaf of the
+* - **A leaf handle, not the runner `Controller`.** A workflow task is a leaf of the
 *   declarative W-b tree, not a fan-out unit, so it has no `spawn`; its `wait` instead
 *   checkpoints the workflow, phase, and task cooperative gates.
-* - **Folded signal.** `signal` is the cancellation folded for THIS attempt: its per-attempt
+* - **Folded signal.** `signal` is the cancellation folded for this attempt: its per-attempt
 *   deadline, task stop/skip, workflow abort/timeout/budget/destroy, or a sibling fail-fast.
 *   A handler races its work against it; `aborted` reads it.
 * - **Attempt ownership.** `report` / `pulse` are closures supplied by the runner and refuse
 *   after this signal aborts or a retry token supersedes this handle.
 * - **Input + lineage.** `input` is the task's open `metadata` bag (its
 *   {@link import('./types.js').TaskInput} payload, `{}` when none); `task` is the full
-*   {@link TaskContext}, so `task.phase` / `task.phase.workflow` navigate UP the lineage.
+*   {@link TaskContext}, so `task.phase` / `task.phase.workflow` navigate up the lineage.
 * - **Read-up results.** `results()` returns every settled task's {@link TaskResult} across
 *   the phases that have already finished (a closure over the live
 *   {@link import('./types.js').WorkflowInterface}), so a `function` task can read an earlier
-*   phase's output. Read-only — a task records its OWN outcome by returning / throwing, not
+*   phase's output. Read-only — a task records its own outcome by returning / throwing, not
 *   by mutating the tree.
 * - **Event-free.** Like the runner `Controller`, the per-task handle carries no Emitter;
 *   observe the W-b entities' own emitters (`task.emitter` / `phase.emitter`) instead.
@@ -3726,11 +3731,12 @@ var TaskController = class {
 //#endregion
 //#region src/core/WorkflowPersistence.ts
 /**
-* 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
@@ -3896,8 +3902,8 @@ var WorkflowPersistence = class {
 //#endregion
 //#region src/core/WorkflowRunner.ts
 /**
-* 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
@@ -3908,33 +3914,33 @@ var WorkflowPersistence = class {
 *   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.
@@ -3943,30 +3949,30 @@ var WorkflowPersistence = class {
 *   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.
@@ -4014,7 +4020,7 @@ var WorkflowRunner = class WorkflowRunner {
 		let runSignal;
 		let onCancel;
 		try {
-			timeout = ms !== void 0 && Number.isFinite(ms) && ms > 0 && ms <= 2147483647 ? createTimeout({ ms }) : void 0;
+			timeout = ms !== void 0 && isFiniteNumber(ms) && ms > 0 && ms <= 2147483647 ? createTimeout({ ms }) : void 0;
 			timeout?.start();
 			budget?.start();
 			runSignal = this.#fold(workflow, signal, budget, timeout);
@@ -4147,7 +4153,7 @@ var WorkflowRunner = class WorkflowRunner {
 			return;
 		}
 		const ms = task.timeout;
-		const deadline = ms !== void 0 && Number.isFinite(ms) && ms > 0 && ms <= 2147483647 ? createTimeout({ ms }) : void 0;
+		const deadline = ms !== void 0 && isFiniteNumber(ms) && ms > 0 && ms <= 2147483647 ? createTimeout({ ms }) : void 0;
 		const signal = this.#taskSignal(task, controller.signal, runSignal, deadline);
 		try {
 			task.start();
@@ -4301,7 +4307,7 @@ var WorkflowRunner = class WorkflowRunner {
 		try {
 			if (workflow !== void 0 && isHalted(workflow, phase)) deferred.resolve(void 0);
 			const outcome = await Promise.race([wait, deferred.promise]);
-			return typeof outcome === "boolean" ? outcome : void 0;
+			return isBoolean(outcome) ? outcome : void 0;
 		} finally {
 			signal.removeEventListener("abort", onAbort);
 			workflow?.emitter.off("skip", onTerminal);
@@ -4384,20 +4390,20 @@ function createWorkflowContract() {
 * 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.
 *
@@ -4424,14 +4430,14 @@ function createWorkflow(definition, options) {
 * @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
@@ -4461,11 +4467,11 @@ function createWorkflowTree(definition, captured) {
 *
 * @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
@@ -4491,7 +4497,8 @@ function createRestoredWorkflow(snapshot, options) {
 	return new Workflow(cloneWorkflowSnapshot(snapshot), captured);
 }
 /**
-* 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
@@ -4520,18 +4527,17 @@ function createRecoveredWorkflow(snapshot, options) {
 }
 /**
 * 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}
@@ -4553,22 +4559,22 @@ function createMemoryWorkflowStore() {
 /**
 * 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
@@ -4596,22 +4602,22 @@ function createDatabaseWorkflowStore(driver = createMemoryDriver()) {
 	}).table("snapshots"));
 }
 /**
-* 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}.
@@ -4625,19 +4631,43 @@ function createDatabaseWorkflowStore(driver = createMemoryDriver()) {
 *   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
 * ```
 */
 function createWorkflowRunner(options) {
@@ -4646,15 +4676,17 @@ function createWorkflowRunner(options) {
 /**
 * 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.
 *
@@ -4669,7 +4701,7 @@ function createWorkflowRunner(options) {
 * 	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
 * ```
@@ -4725,12 +4757,13 @@ function createScheduler() {
 }
 /**
 * 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`,
@@ -4740,8 +4773,8 @@ function createScheduler() {
 * 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