@orkestrel/workflow 0.0.16 → 0.0.17

package/dist/src/core/index.js

@@ -1,38 +1,67 @@
 import { createAbort, isAbortSignal, linkSignal } from "@orkestrel/abort";
-import { arrayShape, attempt, cloneJSONRecord, cloneJSONValue, compileGuard, createContract, integerShape, isArray, isBoolean, isContractError, isFiniteNumber, isFunction, isInteger, isJSONValue, isNonEmptyString, isRecord, literalShape, objectShape, optionalShape, rawShape, stringShape } from "@orkestrel/contract";
+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.
+*
+* @remarks
+* Carries a {@link WorkflowErrorCode} and an optional `context` bag naming the
+* offending node id / status / parameter. Raised for an illegal lifecycle transition
+* (`TRANSITION`), a structurally invalid {@link import('./types.js').WorkflowSnapshot}
+* boundary (`RESTORE`), a refused structural/activity edit (`MUTATION`), a host
+* schedule refused before arming because the caller's `signal` is not a native
+* `AbortSignal` (`SCHEDULE`, delivered as a rejected promise), or a broken internal
+* invariant (`INVARIANT`).
+*/
+var WorkflowError = class extends Error {
+	code;
+	context;
+	constructor(code, message, context) {
+		super(message);
+		this.name = "WorkflowError";
+		this.code = code;
+		if (context !== void 0) this.context = context;
+	}
+};
+/**
+* Narrows an unknown caught value to a {@link WorkflowError}.
+*
+* @param value - The value to test (typically a `catch` binding)
+* @returns True if `value` is a {@link WorkflowError}; false otherwise
+*
+* @example
+* ```ts
+* try {
+* 	task.complete('done')
+* } catch (error) {
+* 	if (isWorkflowError(error) && error.code === 'TRANSITION') retry()
+* }
+* ```
+*/
+function isWorkflowError(value) {
+	try {
+		return value instanceof WorkflowError;
+	} catch {
+		return false;
+	}
+}
+//#endregion
 //#region src/core/constants.ts
-/** The default {@link import('./types.js').WorkflowDefinition.bail} — graceful (continue on a leaf failure). */
+/** Names the default {@link import('./types.js').WorkflowDefinition.bail} — graceful (continue on a leaf failure). */
 var DEFAULT_BAIL = false;
 /**
-* Every {@link TaskStatus} value, frozen — the lifecycle vocabulary of a task.
+* Lists every {@link LifecycleStatus} value, frozen — the vocabulary every tier draws from.
 *
 * @remarks
 * Ordered pending → running → terminal (`completed` / `failed` / `skipped` /
-* `stopped`). The source of truth for the union; compose guards / shapes from it.
+* `stopped`). The runtime source of truth for the union:
+* {@link import('./validators.js').isLifecycleStatus} reads this array.
 */
-var TASK_STATUSES = Object.freeze([
-	"pending",
-	"running",
-	"completed",
-	"failed",
-	"skipped",
-	"stopped"
-]);
-/** Every {@link PhaseStatus} value, frozen — the lifecycle vocabulary of a phase. */
-var PHASE_STATUSES = Object.freeze([
-	"pending",
-	"running",
-	"completed",
-	"failed",
-	"skipped",
-	"stopped"
-]);
-/** Every {@link WorkflowStatus} value, frozen — the lifecycle vocabulary of a workflow. */
-var WORKFLOW_STATUSES = Object.freeze([
+var LIFECYCLE_STATUSES = Object.freeze([
 	"pending",
 	"running",
 	"completed",
@@ -41,21 +70,21 @@ var WORKFLOW_STATUSES = Object.freeze([
 	"stopped"
 ]);
 /**
-* The {@link TaskStatus} values that are TERMINAL — a task in one of these will
+* Lists the {@link LifecycleStatus} values that are TERMINAL — a node in one of these will
 * not transition further, frozen.
 *
 * @remarks
 * The source of truth behind {@link import('./helpers.js').isTerminalStatus}.
 * `pending` and `running` are the only non-terminal members.
 */
-var TERMINAL_TASK_STATUSES = Object.freeze([
+var TERMINAL_STATUSES = Object.freeze([
 	"completed",
 	"failed",
 	"skipped",
 	"stopped"
 ]);
 /**
-* The legal {@link TaskStatus} transition graph of the live W-b task state machine —
+* Declares the legal {@link LifecycleStatus} transition graph of the live W-b task state machine —
 * each current status mapped to the statuses it may move to directly, frozen.
 *
 * @remarks
@@ -85,7 +114,7 @@ var TASK_TRANSITIONS = Object.freeze({
 	stopped: []
 });
 /**
-* The default per-phase task concurrency the {@link import('./factories.js').createWorkflowRunner}
+* Names the default per-phase task concurrency the {@link import('./factories.js').createWorkflowRunner}
 * runner applies when a {@link import('./types.js').PhaseDefinition} omits its `concurrency`
 * throttle — a cap that is effectively unbounded for any realistic phase.
 *
@@ -105,74 +134,138 @@ var TASK_TRANSITIONS = Object.freeze({
 */
 var DEFAULT_PHASE_CONCURRENCY = 1024;
 /**
-* 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.
 */
 var MAX_TIMER_MS = 2147483647;
+/**
+* Lists the {@link WorkflowEventMap} / {@link PhaseEventMap} events that make a durable observer
+* re-persist the live tree, frozen.
+*
+* @remarks
+* The two maps carry the same event names, so one list serves both tiers. It is the source of
+* truth behind {@link import('./WorkflowPersistence.js').WorkflowPersistence}'s attach and detach
+* passes: subscribing and unsubscribing loop over these names, so an added event reaches both
+* passes from one edit. `add` and `remove` are deliberately absent — they carry the new or dropped
+* child, so the persistence layer binds its own attaching handler to them instead.
+*/
+var PERSISTED_NODE_EVENTS = Object.freeze([
+	"start",
+	"complete",
+	"fail",
+	"skip",
+	"stop",
+	"move",
+	"update"
+]);
+/**
+* Lists the {@link TaskEventMap} events that make a durable observer re-persist the live tree, frozen.
+*
+* @remarks
+* The leaf counterpart of {@link PERSISTED_NODE_EVENTS}, and the source of truth behind the task
+* attach and detach passes of
+* {@link import('./WorkflowPersistence.js').WorkflowPersistence}. `report` and `pulse` join the
+* lifecycle events because an accepted activity frame changes the persisted snapshot; a leaf has
+* no children, so there is no structural event to bind separately.
+*/
+var PERSISTED_TASK_EVENTS = Object.freeze([
+	"start",
+	"complete",
+	"fail",
+	"skip",
+	"stop",
+	"report",
+	"pulse"
+]);
 //#endregion
-//#region src/core/errors.ts
+//#region src/core/validators.ts
 /**
-* An error raised by the workflow runtime.
+* Checks whether an unknown value belongs to the workflow lifecycle vocabulary.
 *
 * @remarks
-* Carries a {@link WorkflowErrorCode} and an optional `context` bag naming the
-* offending node id / status / parameter. Raised for an illegal lifecycle transition
-* (`TRANSITION`), a structurally invalid {@link import('./types.js').WorkflowSnapshot}
-* boundary (`RESTORE`), a refused structural/activity edit (`MUTATION`), or a host
-* schedule refused before arming because the caller's `signal` is not a native
-* `AbortSignal` (`SCHEDULE`, delivered as a rejected promise).
+* Reads {@link import('./constants.js').LIFECYCLE_STATUSES}, the runtime array every tier draws
+* from, so the vocabulary has one definition rather than a hard-coded copy per guard.
+*
+* @param value - The value to test
+* @returns True if `value` is a {@link LifecycleStatus}; false otherwise
+*
+* @example
+* ```ts
+* isLifecycleStatus('running') // true
+* isLifecycleStatus('paused') // false
+* ```
 */
-var WorkflowError = class extends Error {
-	code;
-	context;
-	constructor(code, message, context) {
-		super(message);
-		this.name = "WorkflowError";
-		this.code = code;
-		if (context !== void 0) this.context = context;
-	}
-};
+function isLifecycleStatus(value) {
+	return LIFECYCLE_STATUSES.some((status) => status === value);
+}
 /**
-* Narrow an unknown caught value to a {@link WorkflowError}.
+* Tests a normalized persisted task failure.
 *
-* @param value - The value to test (typically a `catch` binding)
-* @returns `true` when `value` is a {@link WorkflowError}
+* @remarks
+* The exact-record guard behind a persisted {@link TaskFailure}: exactly `origin` and `message`,
+* an `origin` drawn from the {@link import('./types.js').TaskFailureOrigin} vocabulary, and a
+* non-empty `message`. Total — a hostile prototype or accessor answers `false` rather than
+* throwing.
+*
+* @param value - The value to test
+* @returns True if `value` is a persisted {@link TaskFailure}; false otherwise
 *
 * @example
 * ```ts
-* try {
-* 	task.complete('done')
-* } catch (error) {
-* 	if (isWorkflowError(error) && error.code === 'TRANSITION') retry()
-* }
+* isTaskFailure({ origin: 'handler', message: 'boom' }) // true
+* isTaskFailure({ origin: 'handler' }) // false
 * ```
 */
-function isWorkflowError(value) {
+function isTaskFailure(value) {
 	try {
-		return value instanceof WorkflowError;
+		return isRecord(value) && Object.keys(value).every((key) => key === "origin" || key === "message") && (value.origin === "handler" || value.origin === "timeout" || value.origin === "recovery") && isNonEmptyString(value.message);
 	} catch {
 		return false;
 	}
 }
-//#endregion
-//#region src/core/validators.ts
-/** Test the workflow lifecycle vocabulary. */
-function isLifecycleStatus(value) {
-	return value === "pending" || value === "running" || value === "completed" || value === "failed" || value === "skipped" || value === "stopped";
-}
-/** Test a normalized persisted task failure. */
-function isTaskFailure(value) {
+/**
+* Checks whether an unknown value is a live workflow entity rather than a definition.
+*
+* @remarks
+* The discriminator behind the overloaded
+* {@link import('./types.js').WorkflowRunnerInterface.execute}: a
+* {@link import('./types.js').WorkflowInterface} is the only one of the two carrying `destroyed`
+* (RUNTIME-ONLY, never a field on the pure-JSON
+* {@link import('./types.js').WorkflowDefinition}) AND a callable `snapshot`. Requiring both is
+* sturdier than `destroyed` alone — a definition could coincidentally carry a `destroyed` field as
+* arbitrary data, and pairing it with a function-typed `snapshot` narrows to the actual entity
+* shape without an `as`. It reads a live class instance, so it tests object identity rather than a
+* plain-record brand, and it is total: any other value answers `false`.
+*
+* @param value - The value to test
+* @returns True if `value` is a live {@link WorkflowInterface}; false otherwise
+*
+* @example
+* ```ts
+* isWorkflowInterface(createWorkflow(definition)) // true
+* isWorkflowInterface(definition) // false
+* ```
+*/
+function isWorkflowInterface(value) {
 	try {
-		return isRecord(value) && Object.keys(value).every((key) => key === "origin" || key === "message") && (value.origin === "handler" || value.origin === "timeout" || value.origin === "recovery") && isNonEmptyString(value.message);
+		return isObject(value) && "destroyed" in value && "snapshot" in value && isFunction(value.snapshot);
 	} catch {
 		return false;
 	}
 }
 /**
-* Validate a safe owned JSON graph as a coherent workflow snapshot.
+* Validates a safe owned JSON graph as a coherent workflow snapshot.
 *
 * @remarks
 * Callers at hostile boundaries use {@link isWorkflowSnapshot}, which owns the
 * graph first so this semantic pass never observes accessors or prototypes.
+*
+* @param value - The already-owned JSON graph to validate
+* @returns True if `value` is a coherent {@link WorkflowSnapshot}; false otherwise
+*
+* @example
+* ```ts
+* isOwnedWorkflowSnapshot(workflow.snapshot()) // true
+* ```
 */
 function isOwnedWorkflowSnapshot(value) {
 	try {
@@ -194,7 +287,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 === "run" || 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.run !== void 0 && !isNonEmptyString(task.run) || 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 && 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;
 				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;
@@ -222,13 +315,82 @@ function isOwnedWorkflowSnapshot(value) {
 		return false;
 	}
 }
-/** Total hostile-boundary workflow snapshot guard. */
+/**
+* Guards the hostile boundary totally for a workflow snapshot.
+*
+* @remarks
+* Owns the value first through the exact-JSON clone of `@orkestrel/contract`, then runs the
+* semantic pass {@link isOwnedWorkflowSnapshot} over the owned copy — so no accessor, prototype,
+* or cycle in the caller's graph is ever observed by the semantic pass. Total: an unclonable
+* value answers `false` rather than throwing.
+*
+* @param value - The untrusted value to test
+* @returns True if `value` is a coherent {@link WorkflowSnapshot}; false otherwise
+*
+* @example
+* ```ts
+* isWorkflowSnapshot(JSON.parse(payload)) // true only for a coherent snapshot
+* ```
+*/
 function isWorkflowSnapshot(value) {
 	const cloned = attempt(() => cloneJSONValue(value));
 	return cloned.success && isOwnedWorkflowSnapshot(cloned.value);
 }
 /**
-* Test whether an unknown value is a valid whole-frame activity report.
+* Checks whether an unknown value is a valid list of task activity claims.
+*
+* @remarks
+* The one guard behind both claim lists of a {@link TaskActivityInput} — its `operations` and its
+* `constraints` — because {@link import('./types.js').TaskOperation} and
+* {@link import('./types.js').TaskConstraint} are the same {@link TaskClaim} shape. Every member must be a plain record carrying exactly `id`, `name`, and
+* `started`, with non-empty string `id` and `name`, a finite non-negative `started`, and an `id`
+* unique within the list. Total: a hostile prototype, an accessor, or a cycle returns `false`
+* rather than throwing.
+*
+* @param value - The value to test
+* @returns True if `value` is a list of valid, uniquely identified claims; false otherwise
+*
+* @example
+* ```ts
+* isTaskClaimList([{ id: 'fetch', name: 'Fetch', started: 1 }]) // true
+* isTaskClaimList([{ id: 'fetch', name: 'Fetch' }]) // false
+* ```
+*/
+function isTaskClaimList(value) {
+	try {
+		if (!isArray(value)) return false;
+		const ids = /* @__PURE__ */ new Set();
+		for (const claim of value) {
+			if (!isRecord(claim)) return false;
+			const prototype = Object.getPrototypeOf(claim);
+			if (prototype !== Object.prototype && prototype !== null || !Object.keys(claim).every((key) => key === "id" || key === "name" || key === "started")) return false;
+			const id = claim.id;
+			const name = claim.name;
+			const started = claim.started;
+			if (!isNonEmptyString(id) || !isNonEmptyString(name) || !isFiniteNumber(started) || started < 0 || ids.has(id)) return false;
+			ids.add(id);
+		}
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* Tests whether an unknown value is a valid whole-frame activity report.
+*
+* @remarks
+* The guard behind {@link import('./types.js').TaskInterface.report}: exactly the optional `note`,
+* `progress`, `operations`, and `constraints` keys, with the two claim lists checked by
+* {@link isTaskClaimList} and `progress` a finite non-negative value under an optional `total` at
+* least as large. Total — a hostile prototype or accessor answers `false` rather than throwing.
+*
+* @param value - The value to test
+* @returns True if `value` is a valid {@link TaskActivityInput}; false otherwise
+*
+* @example
+* ```ts
+* isTaskActivityInput({ note: 'compiling', progress: { progress: 2, total: 5 } }) // true
+* ```
 */
 function isTaskActivityInput(value) {
 	try {
@@ -249,41 +411,29 @@ function isTaskActivityInput(value) {
 			const message = progress.message;
 			if (!isFiniteNumber(reported) || reported < 0 || total !== void 0 && (!isFiniteNumber(total) || total < reported) || message !== void 0 && !isNonEmptyString(message)) return false;
 		}
-		if (operations !== void 0) {
-			if (!isArray(operations)) return false;
-			const ids = /* @__PURE__ */ new Set();
-			for (const operation of operations) {
-				if (!isRecord(operation)) return false;
-				const operationPrototype = Object.getPrototypeOf(operation);
-				if (operationPrototype !== Object.prototype && operationPrototype !== null || !Object.keys(operation).every((key) => key === "id" || key === "name" || key === "started")) return false;
-				const id = operation.id;
-				const name = operation.name;
-				const started = operation.started;
-				if (!isNonEmptyString(id) || !isNonEmptyString(name) || !isFiniteNumber(started) || started < 0 || ids.has(id)) return false;
-				ids.add(id);
-			}
-		}
-		if (constraints !== void 0) {
-			if (!isArray(constraints)) return false;
-			const ids = /* @__PURE__ */ new Set();
-			for (const constraint of constraints) {
-				if (!isRecord(constraint)) return false;
-				const constraintPrototype = Object.getPrototypeOf(constraint);
-				if (constraintPrototype !== Object.prototype && constraintPrototype !== null || !Object.keys(constraint).every((key) => key === "id" || key === "name" || key === "started")) return false;
-				const id = constraint.id;
-				const name = constraint.name;
-				const started = constraint.started;
-				if (!isNonEmptyString(id) || !isNonEmptyString(name) || !isFiniteNumber(started) || started < 0 || ids.has(id)) return false;
-				ids.add(id);
-			}
-		}
+		if (operations !== void 0 && !isTaskClaimList(operations)) return false;
+		if (constraints !== void 0 && !isTaskClaimList(constraints)) return false;
 		return true;
 	} catch {
 		return false;
 	}
 }
 /**
-* Test whether an unknown value is valid persisted task activity.
+* Tests whether an unknown value is valid persisted task activity.
+*
+* @remarks
+* The persisted counterpart of {@link isTaskActivityInput}: the same frame plus the REQUIRED
+* `operations`, `constraints`, and a finite non-negative `updated` stamp, because a stored frame
+* has already been accepted and normalized. Total — a hostile prototype or accessor answers
+* `false` rather than throwing.
+*
+* @param value - The value to test
+* @returns True if `value` is a persisted {@link TaskActivity}; false otherwise
+*
+* @example
+* ```ts
+* isTaskActivity({ operations: [], constraints: [], updated: 1 }) // true
+* ```
 */
 function isTaskActivity(value) {
 	try {
@@ -309,7 +459,7 @@ function isTaskActivity(value) {
 //#endregion
 //#region src/core/helpers.ts
 /**
-* Capture every top-level {@link WorkflowOptions} value exactly once into an owned plain bag.
+* Captures every top-level {@link WorkflowOptions} value exactly once into an owned plain bag.
 *
 * @remarks
 * Direct property reads preserve inherited and non-enumerable option values while preventing
@@ -344,25 +494,151 @@ function captureWorkflowOptions(options) {
 	});
 }
 /**
-* Test whether a {@link LifecycleStatus} is TERMINAL — a node in this state will not
+* Tests whether a {@link LifecycleStatus} is TERMINAL — a node in this state will not
 * transition further.
 *
 * @remarks
-* The ONE terminal check across all three tiers (AGENTS §4.4 "one concept = one word"):
+* The ONE terminal check across every tier (AGENTS.md § Design laws, "one concept, one term"):
 * a task, a phase, and a workflow share the same {@link LifecycleStatus} vocabulary, so a
 * single predicate covers them — {@link derivePhaseStatus} and {@link deriveWorkflowStatus}
-* both consult it to tell a settled node from an in-flight one. Terminal: `completed` /
-* `failed` / `skipped` / `stopped`; the only non-terminal states are `pending` and
-* `running`.
+* both consult it to tell a settled node from an in-flight one. It reads the terminal set from
+* {@link import('./constants.js').TERMINAL_STATUSES} (`completed` / `failed` / `skipped` /
+* `stopped`), so that constant is the one definition; the only non-terminal states are `pending`
+* and `running`.
 *
 * @param status - The lifecycle status to test (a task / phase / workflow status)
-* @returns `true` when the status is terminal
+* @returns True if the status is terminal; false otherwise
 */
 function isTerminalStatus(status) {
-	return status === "completed" || status === "failed" || status === "skipped" || status === "stopped";
+	return TERMINAL_STATUSES.includes(status);
+}
+/**
+* Tests whether a driving run must stop giving a workflow more work.
+*
+* @remarks
+* The halt gate a {@link import('./WorkflowRunner.js').WorkflowRunner} consults before starting a
+* phase, before dispatching a task, and after every cooperative gate. A workflow is halted after
+* its derived status is terminal but NOT `completed` — a `bail: true` failure, a caller's own
+* graceful `stop()`, or a forced `skip`. `completed` is excluded deliberately: a workflow that
+* completed vacuously is settled, not halted, and the distinction is what keeps the run from
+* sweeping a finished tree. When a `phase` is supplied, its own forced `skipped` / `stopped` halts
+* that phase's work too; a `failed` phase does not, because the workflow's own `bail` policy
+* decides whether a failed phase ends the run.
+*
+* @param workflow - The live workflow the run is driving
+* @param phase - The phase whose own forced terminal status also halts its tasks
+* @returns True if the run must stop giving this workflow (or phase) more work; false otherwise
+*
+* @example
+* ```ts
+* isHalted(workflow) // false while pending or running
+* workflow.stop()
+* isHalted(workflow) // true
+* ```
+*/
+function isHalted(workflow, phase) {
+	const status = workflow.status;
+	return isTerminalStatus(status) && status !== "completed" || phase?.status === "skipped" || phase?.status === "stopped";
+}
+/**
+* Tests whether forcing a workflow `stopped` would still record something.
+*
+* @remarks
+* `stop()` is a no-op after a workflow's status becomes terminal, so a run that must record a
+* cancellation forces it only while this holds. It is NOT the negation of
+* {@link isTerminalStatus}: `completed` and `skipped` both pass, because a run-level cancel that
+* lands on a vacuously-completed or fully-skipped tree still records `stopped` as the outcome the
+* caller asked for. Only an already-`failed` or already-`stopped` workflow has a terminal state
+* worth keeping.
+*
+* @param workflow - The live workflow a run-level cancel would force
+* @returns True if forcing `stopped` would change the recorded outcome; false otherwise
+*
+* @example
+* ```ts
+* isStoppable(workflow) // true while pending, running, completed, or skipped
+* workflow.stop()
+* isStoppable(workflow) // false
+* ```
+*/
+function isStoppable(workflow) {
+	const status = workflow.status;
+	return status !== "failed" && status !== "stopped";
+}
+/**
+* Tests whether a naturally-finished run may force its workflow `completed`.
+*
+* @remarks
+* A run that walked every phase and still derives `pending` executed nothing — zero phases, or
+* every phase empty — so it is vacuously done and the run settles it `completed`. Gated on
+* EXACTLY `pending` so a real `completed`, a `bail: true` `failed`, a `stopped`, or a derived
+* `skipped` is never overridden. The tree-is-empty half of the rule is
+* {@link WorkflowInterface.complete}'s own guard, which refuses a pending tree that still holds
+* tasks.
+*
+* @param workflow - The live workflow the run has finished walking
+* @returns True if the run may force the vacuous completion; false otherwise
+*
+* @example
+* ```ts
+* isCompletable(createWorkflow({ id: 'w', name: 'W', phases: [] })) // true
+* ```
+*/
+function isCompletable(workflow) {
+	return workflow.status === "pending";
+}
+/**
+* Tests whether a task attempt is being genuinely cancelled rather than merely timed out.
+*
+* @remarks
+* The discriminator that keeps a per-attempt deadline off the skip path. Three causes fire a
+* running task's folded signal, and only two of them mean "skip this task": the task's own
+* `signal` (its `stop` / `skip`), and the unit or run signal (a sibling fail-fast under
+* `bail: true`, or a run-level abort / timeout / budget / `destroy`). A bare per-attempt timeout
+* fires NEITHER — it aborts only the deadline portion of the attempt signal — so it stays a
+* retryable failure of that attempt instead of skipping the leaf and losing the recorded fault.
+* Read fresh at each call so a cancel that lands mid-dispatch is seen.
+*
+* @param task - The live task the attempt is driving
+* @param controller - The substrate unit handle carrying the unit-level abort
+* @param runSignal - The run's folded cancellation signal
+* @returns True if the attempt is being genuinely cancelled; false otherwise
+*
+* @example
+* ```ts
+* isSkipping(task, controller, runSignal) // false until a cancel fires
+* ```
+*/
+function isSkipping(task, controller, runSignal) {
+	return task.signal.aborted || controller.aborted || runSignal.aborted;
 }
 /**
-* Derive a phase's status from its tasks' statuses (tasks are concurrent, so this
+* Tests whether one attempt still owns the task it launched.
+*
+* @remarks
+* A retried task is re-dispatched while an earlier attempt's handler may still be resolving, so
+* every settlement path re-checks ownership before touching the leaf. Ownership needs BOTH
+* halves: the run-local `owners` ledger must still name this attempt, and the live task's own
+* `attempts` tally must still match it. A superseded attempt reads `false` and returns without
+* recording anything, so a late resolution can never overwrite the newer attempt's outcome.
+*
+* @param owners - The run-local ledger of the attempt owning each task id
+* @param task - The live task the attempt launched
+* @param attempt - The one-based attempt number to test
+* @returns True if `attempt` still owns `task`; false otherwise
+*
+* @example
+* ```ts
+* const owners = new Map([[task.id, 1]])
+* ownsAttempt(owners, task, 1) // true while the task's own `attempts` is 1
+* ownsAttempt(owners, task, 2) // false
+* ```
+*/
+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).
 *
 * @remarks
@@ -380,7 +656,7 @@ function isTerminalStatus(status) {
 * task makes the phase `failed`.
 *
 * @param tasks - The phase's task statuses, in any order
-* @returns The derived {@link PhaseStatus}
+* @returns The derived phase {@link LifecycleStatus}
 */
 function derivePhaseStatus(tasks) {
 	if (tasks.length === 0) return "pending";
@@ -392,13 +668,13 @@ function derivePhaseStatus(tasks) {
 	return "skipped";
 }
 /**
-* Derive a workflow's status from its phases' {@link PhaseDerivation}s — each phase's status
+* Derives a workflow's status from its phases' {@link PhaseDerivation}s — each phase's status
 * paired with the EFFECTIVE `bail` it ran under (`phase.bail ?? workflow.bail`) — so the
 * failure outcome is PER-PHASE-bail-aware (phases are sequential, but the derivation is an
 * order-insensitive reduction over the settled set).
 *
 * @remarks
-* `bail` is now a per-phase override (AGENTS §4.4), so it is carried on each
+* `bail` is a per-phase override, so it is carried on each
 * {@link PhaseDerivation} rather than passed as one scalar. It is the ONLY axis that changes
 * the failure outcome, decided per phase:
 * - **A `failed` phase whose effective `bail` is `true` (halt)** propagates ⇒ the workflow is
@@ -417,7 +693,7 @@ function derivePhaseStatus(tasks) {
 *   else (all `skipped`) ⇒ `skipped`.
 *
 * @param phases - The workflow's per-phase {@link PhaseDerivation}s (status + effective bail), in any order
-* @returns The derived {@link WorkflowStatus}
+* @returns The derived workflow {@link LifecycleStatus}
 */
 function deriveWorkflowStatus(phases) {
 	if (phases.length === 0) return "pending";
@@ -429,16 +705,16 @@ function deriveWorkflowStatus(phases) {
 	return "skipped";
 }
 /**
-* Derive the PENDING SUFFIX boundary of a positional list of {@link LifecycleStatus}es —
+* Derives the PENDING SUFFIX boundary of a positional list of {@link LifecycleStatus}es —
 * the index of the first entry in the contiguous trailing run of `pending` entries.
 *
 * @remarks
-* The native, hook-free replacement for a runner-installed cursor (AGENTS §12): a
+* The native, hook-free replacement for a runner-installed cursor: a
 * {@link import('./types.js').WorkflowInterface}'s `add` / `remove` / `move` / `update`
 * reads this over its live phases' statuses to decide which positions are safe to edit.
 * Because entries run SEQUENTIALLY (phases sequential, AGENTS determinism), every
 * already-started entry forms a contiguous LEADING prefix and every still-`pending`
-* entry forms the trailing suffix — so the boundary is simply the count of leading
+* entry forms the trailing suffix — so the boundary is the count of leading
 * non-`pending` entries: the index of the first `pending` entry, or the full length when
 * none is `pending` (nothing is safely editable). A `pending` container's entries are ALL
 * `pending`, so the boundary is `0` and every position is naturally accepted — callers
@@ -459,8 +735,8 @@ function deriveBoundary(statuses) {
 	return index === -1 ? statuses.length : index;
 }
 /**
-* Test whether the live W-b task state machine may move directly from one
-* {@link TaskStatus} to another — the legal-transition guard.
+* Tests whether the live W-b task state machine may move directly from one
+* {@link LifecycleStatus} to another — the legal-transition guard.
 *
 * @remarks
 * Reads the {@link import('./constants.js').TASK_TRANSITIONS} graph: `true` only when
@@ -470,13 +746,13 @@ function deriveBoundary(statuses) {
 *
 * @param from - The task's current status
 * @param to - The status the transition would move it to
-* @returns `true` when the move is legal
+* @returns True if the move is legal; false otherwise
 */
 function canTransitionTask(from, to) {
 	return TASK_TRANSITIONS[from].includes(to);
 }
 /**
-* Resolve a task's runtime silence window against its workflow default.
+* Resolves a task's runtime silence window against its workflow default.
 *
 * @param value - The task-level override; any present non-positive or non-finite value disables
 * @param fallback - The workflow-level default
@@ -487,7 +763,7 @@ function resolveTaskSilence(value, fallback) {
 	return fallback !== void 0 && Number.isFinite(fallback) && fallback > 0 && fallback <= 2147483647 ? fallback : void 0;
 }
 /**
-* Box a value as a {@link Success} — the graceful outcome half of a {@link Result}.
+* Boxes a value as a {@link Success} — the graceful outcome half of a {@link Result}.
 *
 * @typeParam T - The boxed value's type
 * @param value - The value to box
@@ -505,7 +781,7 @@ function success(value) {
 	};
 }
 /**
-* Box an error as a {@link Failure} — the graceful outcome half of a {@link Result}.
+* Boxes an error as a {@link Failure} — the graceful outcome half of a {@link Result}.
 *
 * @typeParam E - The boxed error's type
 * @param error - The error to box
@@ -523,7 +799,7 @@ function failure(error) {
 	};
 }
 /**
-* Normalize an unknown thrown value to a non-empty persistence-safe message.
+* Normalizes an unknown thrown value to a non-empty persistence-safe message.
 *
 * @param error - The caught value
 * @returns A non-empty message without stack or cause data
@@ -537,7 +813,7 @@ function errorToMessage(error) {
 	}
 }
 /**
-* Find the first {@link TaskResult} in a positional list whose boxed outcome is a
+* Finds the first {@link TaskResult} in a positional list whose boxed outcome is a
 * `Failure` — the pure scan shared by a phase's and a workflow's derived-`failed`
 * `fail`-event lookup.
 *
@@ -545,8 +821,8 @@ function errorToMessage(error) {
 * The shared leaf behind {@link import('./phases/Phase.js').Phase} and
 * {@link import('./Workflow.js').Workflow}'s own `#failure` — each gathers ITS tier's
 * results (a phase's own settled tasks, a workflow's flattened `results()`) and feeds
-* them here; the tier-local method keeps the §12 invariant throw (a derived `failed`
-* status guarantees a failing result exists) since throwing on `undefined` is
+* them here; the tier-local method keeps the invariant throw (a derived `failed`
+* status means a failing result exists) because throwing on `undefined` is
 * orchestration, not a leaf concern.
 *
 * @param results - The results to scan, in any order
@@ -561,7 +837,7 @@ function findFailure(results) {
 	return results.find((result) => result.result?.success === false);
 }
 /**
-* Build a {@link WorkflowContext} — the identity every level inherits — from a node's
+* Builds a {@link WorkflowContext} — the identity every level inherits — from a node's
 * `id` / `name` / optional `description`.
 *
 * @remarks
@@ -580,7 +856,7 @@ function buildWorkflowContext(node) {
 	});
 }
 /**
-* Build a {@link PhaseContext} — a phase's own identity plus a back-reference to its
+* 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)
@@ -594,7 +870,7 @@ function buildPhaseContext(workflow, node) {
 	});
 }
 /**
-* Build a {@link TaskContext} — a task's own identity plus a back-reference to its phase
+* Builds a {@link TaskContext} — a task's own identity plus a back-reference to its phase
 * (and, transitively, its workflow) — from the parent {@link PhaseContext} and the task
 * node's identity.
 *
@@ -609,20 +885,20 @@ function buildTaskContext(phase, node) {
 	});
 }
 /**
-* Convert a {@link WorkflowDefinition} into an INITIAL {@link WorkflowSnapshot} — every
+* Converts a {@link WorkflowDefinition} into an INITIAL {@link WorkflowSnapshot} — every
 * node `pending`, no results, empty metadata — so the live W-b tree has ONE construction
 * path (snapshot-driven) for both a fresh build and a restore.
 *
 * @remarks
 * The structural fields (`id` / `name` / `description` + the ordered phases / tasks)
 * carry over verbatim, as does each phase's `concurrency` (persisted on the
-* {@link PhaseSnapshot} so a restore reinstates the same throttle) and each task's `run` /
+* {@link PhaseSnapshot} so a restore reinstates the same throttle) and each task's `behavior` /
 * `retries` / `timeout` (persisted on the {@link TaskSnapshot}, like `bail` / `concurrency`,
 * so a restore + a {@link import('./types.js').WorkflowOptions.functions} registry resumes
 * real work). The `bail` policy carries over — at the
 * workflow tier AND, per phase, the
 * EFFECTIVE policy (`phase.bail ?? workflowBail`) on each {@link PhaseSnapshot} — so the seeded
-* snapshot is self-contained; a fresh seed has no `override`. `created` / `updated` are stamped now.
+* snapshot is self-contained; a fresh seed has no `override`. `created` / `updated` are stamped at that point.
 * {@link import('./factories.js').createWorkflow} builds from this.
 *
 * The optional `bail` override is the EFFECTIVE workflow policy the tree will run under
@@ -651,7 +927,7 @@ function definitionToSnapshot(definition, bail) {
 	};
 }
 /**
-* Convert one {@link import('./types.js').PhaseDefinition} into an initial, all-`pending`
+* Converts one {@link import('./types.js').PhaseDefinition} into an initial, all-`pending`
 * {@link PhaseSnapshot} — the per-phase step of {@link definitionToSnapshot}.
 *
 * @remarks
@@ -676,14 +952,14 @@ function phaseDefinitionToSnapshot(phase, workflowBail) {
 	};
 }
 /**
-* Convert one {@link import('./types.js').TaskDefinition} into an initial, `pending`
+* Converts one {@link import('./types.js').TaskDefinition} into an initial, `pending`
 * {@link TaskSnapshot} — the per-task leaf step of {@link definitionToSnapshot} (no
 * result yet, empty metadata).
 *
 * @remarks
-* `run` / `retries` / `timeout` carry over verbatim (persisted declarative config, like a
+* `behavior` / `retries` / `timeout` carry over verbatim (persisted declarative config, like a
 * phase's `bail` / `concurrency`) — a restore reinstates the same behavior reference and
-* reliability overrides once paired with a {@link import('./types.js').WorkflowOptions.functions}
+* reliability overrides after pairing with a {@link import('./types.js').WorkflowOptions.functions}
 * registry.
 *
 * @param task - The task definition to seed from
@@ -697,13 +973,13 @@ function taskDefinitionToSnapshot(task) {
 		status: "pending",
 		metadata: {},
 		attempts: 0,
-		...task.run === void 0 ? {} : { run: task.run },
+		...task.behavior === void 0 ? {} : { behavior: task.behavior },
 		...task.retries === void 0 ? {} : { retries: task.retries },
 		...task.timeout === void 0 ? {} : { timeout: task.timeout }
 	};
 }
 /**
-* Convert interrupted running work into a recoverable pending suffix or an
+* Converts interrupted running work into a recoverable pending suffix or an
 * exhausted recovery failure without replenishing attempts.
 *
 * @param snapshot - A fully validated owned snapshot with no terminal overrides
@@ -780,11 +1056,58 @@ function recoverWorkflowSnapshot(snapshot) {
 		updated: now
 	};
 }
-/** Compare two optional description values. */
+/**
+* Compares two optional description values.
+*
+* @remarks
+* The equality rule a lineage check needs: two descriptions match when they are the same value
+* AND that value is either a string or genuine absence. Anything else — a number, an object, a
+* `null` — never matches, even against itself, so a lineage stamped with a non-string description
+* is rejected rather than silently accepted.
+*
+* @param left - The first description value
+* @param right - The second description value
+* @returns True if both are the same string or both absent; false otherwise
+*
+* @example
+* ```ts
+* matchesDescription('build', 'build') // true
+* matchesDescription(undefined, undefined) // true
+* matchesDescription('build', undefined) // false
+* ```
+*/
 function matchesDescription(left, right) {
 	return left === right && (left === void 0 || typeof left === "string");
 }
-/** Test a result's lineage against its containing snapshot nodes. */
+/**
+* Tests a result's lineage against its containing snapshot nodes.
+*
+* @remarks
+* The four arguments are the result and the three snapshot nodes it claims to belong to, read
+* from the OUTSIDE in: a {@link TaskResult} is self-describing, so restoring one is only safe
+* when every identity it carries agrees with the tree it was found in. It checks the exact key
+* set at each level, that `status` equals the owning task's, and that the `task` / `phase` /
+* `workflow` contexts — including the nested `task.phase.workflow` lineage — carry the same `id`,
+* `name`, and `description` as the nodes containing them. It then requires the boxed outcome to
+* match the status: a `Success` holding JSON for `completed`, a `Failure` holding a
+* {@link TaskFailure} for `failed`, and nothing for any other status. Total — a hostile
+* prototype, accessor, or cycle answers `false` rather than throwing.
+*
+* @param value - The candidate {@link TaskResult}
+* @param workflow - The workflow snapshot node containing it
+* @param phase - The phase snapshot node containing it
+* @param task - The task snapshot node the result belongs to
+* @returns True if `value` is a {@link TaskResult} whose lineage and outcome match
+*   those nodes; false otherwise
+*
+* @example
+* ```ts
+* const snapshot = workflow.snapshot()
+* const phase = snapshot.phases[0]
+* const task = phase?.tasks[0]
+* isTaskResult(task?.result, snapshot, phase, task) // true for a settled task
+* ```
+*/
 function isTaskResult(value, workflow, phase, task) {
 	try {
 		if (!isRecord(value) || !isRecord(workflow) || !isRecord(phase) || !isRecord(task) || !Object.keys(value).every((key) => key === "task" || key === "phase" || key === "workflow" || key === "status" || key === "result" || key === "timestamp") || !isLifecycleStatus(value.status) || value.status !== task.status || !isFiniteNumber(value.timestamp) || value.timestamp < 0 || !isRecord(value.task) || !isRecord(value.phase) || !isRecord(value.workflow) || !Object.keys(value.workflow).every((key) => key === "id" || key === "name" || key === "description") || !Object.keys(value.phase).every((key) => key === "id" || key === "name" || key === "description" || key === "workflow") || !Object.keys(value.task).every((key) => key === "id" || key === "name" || key === "description" || key === "phase")) return false;
@@ -800,19 +1123,30 @@ function isTaskResult(value, workflow, phase, task) {
 }
 function hasWorkflowHandlers(workflow, functions) {
 	if ("destroyed" in workflow) {
-		for (const phase of workflow.phases.phases()) for (const task of phase.tasks.tasks()) if (task.run !== void 0 && !isFunction(task.handler)) return false;
+		for (const phase of workflow.phases.phases()) for (const task of phase.tasks.tasks()) if (task.behavior !== void 0 && !isFunction(task.handler)) return false;
 		return true;
 	}
-	const runs = /* @__PURE__ */ new Set();
+	const behaviors = /* @__PURE__ */ new Set();
 	for (const phase of workflow.phases) for (const task of phase.tasks) {
-		if (task.run === void 0 || runs.has(task.run)) continue;
-		runs.add(task.run);
-		if (!isFunction(functions?.[task.run])) return false;
+		if (task.behavior === void 0 || behaviors.has(task.behavior)) continue;
+		behaviors.add(task.behavior);
+		if (!isFunction(functions?.[task.behavior])) return false;
 	}
 	return true;
 }
-/** Locate the nearest identifiable node for an inconsistent owned snapshot. */
-function workflowSnapshotContext(value) {
+/**
+* Locates the nearest identifiable node for an inconsistent owned snapshot.
+*
+* @remarks
+* The walk stops at the first phase or task whose persisted fields are inconsistent and returns
+* the identifiers it could read there, so a diagnostic can name the offending node even when part
+* of its identity is unreadable.
+*
+* @param value - The candidate snapshot, which may be any unknown value
+* @returns The nearest identifying record naming the offending `phase` and `task`, or `undefined`
+* when no inconsistent node is identifiable
+*/
+function scanSnapshotContext(value) {
 	if (!isRecord(value) || !isArray(value.phases)) return void 0;
 	for (const phase of value.phases) {
 		if (!isRecord(phase)) continue;
@@ -820,7 +1154,7 @@ function workflowSnapshotContext(value) {
 		if (!isBoolean(phase.bail) || phase.concurrency !== void 0 && (!isInteger(phase.concurrency) || phase.concurrency < 1) || !isArray(phase.tasks)) return phaseContext;
 		for (const task of phase.tasks) {
 			if (!isRecord(task)) continue;
-			if (task.run !== void 0 && !isNonEmptyString(task.run) || task.retries !== void 0 && (!isInteger(task.retries) || task.retries < 0) || task.timeout !== void 0 && (!isInteger(task.timeout) || task.timeout < 0 || task.timeout > 2147483647) || !isInteger(task.attempts) || task.attempts < 0) return {
+			if (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) || !isInteger(task.attempts) || task.attempts < 0) return {
 				...phaseContext ?? {},
 				...isNonEmptyString(task.id) ? { task: task.id } : {}
 			};
@@ -828,7 +1162,7 @@ function workflowSnapshotContext(value) {
 	}
 }
 /**
-* Flatten a nested list of per-phase {@link TaskResult} lists into one positional list
+* Flattens a nested list of per-phase {@link TaskResult} lists into one positional list
 * — the workflow tier of the result tree, built from each phase's `results()`.
 *
 * @remarks
@@ -843,16 +1177,15 @@ function collectResults(phases) {
 	return phases.flat();
 }
 /**
-* Insert one `[key, value]` entry at a positional index into a readonly entries array —
+* Inserts one `[key, value]` entry at a positional index into a readonly entries array —
 * the pure splice-in step behind an insertion-ordered registry's `add`.
 *
 * @remarks
-* Shared by {@link import('./tasks/TaskManager.js').TaskManager} and
-* {@link import('./phases/PhaseManager.js').PhaseManager}: both convert their
-* insertion-ordered `Map` to `[...map.entries()]`, call this to splice the new entry
-* in at the target index, then rebuild the `Map` from the result (a stateful step that
-* stays a `#` private method — this helper does no `Map` construction). Does not
-* mutate `entries`; returns a new array.
+* Used by the shared {@link import('./Collection.js').Collection} store both managers hold: it
+* converts its insertion-ordered `Map` to `[...map.entries()]`, calls this to splice the new entry
+* in at the target index, then rebuilds the `Map` from the result (a stateful step that stays a
+* `#` private method — this helper does no `Map` construction). Does not mutate `entries`;
+* returns a new array.
 *
 * @typeParam T - The entry's value type
 * @param entries - The current positional entries, in order
@@ -872,16 +1205,17 @@ function insertEntry(entries, index, key, value) {
 	return next;
 }
 /**
-* Reposition the entry keyed `key` to a new positional index in a readonly entries
+* Repositions the entry keyed `key` to a new positional index in a readonly entries
 * array — the pure remove-then-reinsert step behind an insertion-ordered registry's
 * `move`.
 *
 * @remarks
 * The move counterpart of {@link insertEntry}: finds the entry by `key`, splices it
 * out, then splices it back in at `index`. An absent `key` is a no-op (returns a copy
-* of `entries` unchanged) — the caller (`TaskManager.move` / `PhaseManager.move`)
-* already gates on the target's existence before calling this, so the no-op branch is
-* defensive, never reached in practice. Does not mutate `entries`; returns a new array.
+* of `entries` unchanged) — the caller, the shared
+* {@link import('./Collection.js').Collection} store's `move`, already gates on the target's
+* existence before calling this, so the no-op branch is defensive, never reached in practice.
+* Does not mutate `entries`; returns a new array.
 *
 * @typeParam T - The entry's value type
 * @param entries - The current positional entries, in order
@@ -903,17 +1237,7 @@ function moveEntry(entries, key, index) {
 	return next;
 }
 /**
-* Create a {@link DeferredInterface} — a promise whose settlement is driven
-* externally, so a caller can resolve/reject it from outside the executor.
-*
-* @typeParam T - The value the deferred promise resolves
-* @returns A deferred `promise` plus its `resolve` / `reject`
-*/
-function createDeferred() {
-	return Promise.withResolvers();
-}
-/**
-* Schedule one cancellable host operation behind an owned settlement signal.
+* Schedules one cancellable host operation behind an owned settlement signal.
 *
 * @remarks
 * A defined `signal` that is not a native `AbortSignal` is refused before anything is armed, as a
@@ -980,7 +1304,36 @@ function scheduleHost(start, signal) {
 	});
 }
 /**
-* Park until `signal` aborts — a promise-parked wait (AGENTS §21), never a timer or
+* Schedules the shared host timer boundary every scheduler backend resumes from.
+*
+* @remarks
+* The one `setTimeout` / `clearTimeout` boundary in the package: the cross-environment
+* {@link import('./Scheduler.js').Scheduler}, both Node primitives, and every browser backend's
+* `delay` and macrotask fallback route here, so the timer is armed and cleared in one place. It
+* composes {@link scheduleHost}, which owns listener safety, the cancellation race, the exact
+* caller reason, and once-only settlement. It does NOT validate `ms`: the value passes straight to
+* the host `setTimeout`, which clamps a negative value or `NaN` to about zero, so an
+* out-of-domain `ms` resumes on the next host turn rather than throwing. Pass a non-negative
+* finite `ms`.
+*
+* @param ms - The milliseconds to wait before resuming
+* @param signal - Optional caller cancellation signal
+* @returns A promise that resolves after `ms`, or rejects with the caller's exact abort reason
+*
+* @example
+* ```ts
+* const controller = new AbortController()
+* await delayHost(0, controller.signal) // a real macrotask host turn
+* ```
+*/
+function delayHost(ms, signal) {
+	return scheduleHost((complete) => {
+		const handle = setTimeout(complete, ms);
+		return () => clearTimeout(handle);
+	}, signal);
+}
+/**
+* Parks until `signal` aborts — a promise-parked wait, never a timer or
 * busy-loop, that NEVER rejects.
 *
 * @remarks
@@ -990,7 +1343,7 @@ function scheduleHost(start, signal) {
 * at every fold point.
 *
 * @param signal - The signal to park on
-* @returns A promise that resolves once `signal` has aborted
+* @returns A promise that resolves after `signal` has aborted
 *
 * @example
 * ```ts
@@ -1007,9 +1360,109 @@ function parkSignal(signal) {
 	});
 }
 //#endregion
+//#region src/core/Collection.ts
+/**
+* Implements the insertion-ordered gated store both lean managers hold — entities keyed by `id`,
+* positional order preserved across an interior `skip` or `remove`.
+*
+* @remarks
+* - **One engine, two managers.** {@link import('./tasks/TaskManager.js').TaskManager} and
+*   {@link import('./phases/PhaseManager.js').PhaseManager} differ only in the entity noun and the
+*   patch shape they validate, so both hold one of these and add only their domain accessors
+*   (`task` / `tasks`, `phase` / `phases`). The `Map`'s insertion order is the single source of
+*   positional truth; `add` and `move` rebuild it through the pure
+*   {@link import('./helpers.js').insertEntry} / {@link import('./helpers.js').moveEntry} leaves.
+* - **Gated mutation API.** `append` is the build-time wiring path and THROWS on a
+*   duplicate id; `add` / `remove` / `move` / `update` return a graceful `MUTATION`
+*   {@link WorkflowError} failure instead. Gating reads ONLY the target's own existence, `pending`
+*   status, id, and bounds — a container's own status is the owning entity's gate, applied before
+*   it delegates here.
+* - **Event-free.** A purely structural container; the entity that owns it emits on success.
+*
+* @typeParam TEntry - The stored entity
+* @typeParam TPatch - The declarative partial update `update` validates and applies
+*
+* @example
+* ```ts
+* import { compileGuard } from '@orkestrel/contract'
+* import { Collection, taskUpdateShape } from '@orkestrel/workflow'
+* import type { TaskInterface, TaskUpdate } from '@orkestrel/workflow'
+*
+* const tasks = new Collection<TaskInterface, TaskUpdate>('task', compileGuard(taskUpdateShape))
+* tasks.append(task) // a live Task
+* tasks.entry(task.id) // the same task
+* tasks.entries() // [task]
+* tasks.count // 1
+* tasks.add(other, 0) // Result — inserted first
+* tasks.move(other.id, 1) // Result — repositioned
+* tasks.update(task.id, { name: 'Renamed task' }) // Result — patched
+* tasks.remove(other.id) // Result — dropped
+* ```
+*/
+var Collection = class {
+	#entries = /* @__PURE__ */ new Map();
+	#noun;
+	#isPatch;
+	constructor(noun, patch) {
+		this.#noun = noun;
+		this.#isPatch = patch;
+	}
+	get count() {
+		return this.#entries.size;
+	}
+	append(entry) {
+		if (this.#entries.has(entry.id)) throw new WorkflowError("MUTATION", `duplicate ${this.#noun} id '${entry.id}'`, { id: entry.id });
+		this.#entries.set(entry.id, entry);
+	}
+	add(entry, index) {
+		if (this.#entries.has(entry.id)) return failure(new WorkflowError("MUTATION", `duplicate ${this.#noun} id '${entry.id}'`, { id: entry.id }));
+		const at = index ?? this.#entries.size;
+		if (at < 0 || at > this.#entries.size) return failure(new WorkflowError("MUTATION", `index '${at}' out of bounds`, { index: at }));
+		this.#reorder(insertEntry([...this.#entries.entries()], at, entry.id, entry));
+		return success(entry);
+	}
+	remove(id) {
+		const target = this.#pending(id);
+		if (target === void 0) return this.#refuse(id);
+		this.#entries.delete(id);
+		return success(target);
+	}
+	move(id, index) {
+		const target = this.#pending(id);
+		if (target === void 0) return this.#refuse(id);
+		if (index < 0 || index >= this.#entries.size) return failure(new WorkflowError("MUTATION", `index '${index}' out of bounds`, { index }));
+		this.#reorder(moveEntry([...this.#entries.entries()], id, index));
+		return success(target);
+	}
+	update(id, patch) {
+		const target = this.#pending(id);
+		if (target === void 0) return this.#refuse(id);
+		if (!this.#isPatch(patch)) return failure(new WorkflowError("MUTATION", `invalid patch for ${this.#noun} '${id}'`, { id }));
+		target.patch(patch);
+		return success(target);
+	}
+	entry(id) {
+		return this.#entries.get(id);
+	}
+	entries() {
+		return [...this.#entries.values()];
+	}
+	#pending(id) {
+		const target = this.#entries.get(id);
+		return target === void 0 || target.status !== "pending" ? void 0 : target;
+	}
+	#refuse(id) {
+		return failure(new WorkflowError("MUTATION", `${this.#noun} '${id}' is not a pending ${this.#noun}`, { id }));
+	}
+	#reorder(entries) {
+		this.#entries.clear();
+		for (const [key, value] of entries) this.#entries.set(key, value);
+	}
+};
+//#endregion
 //#region src/core/Scheduler.ts
 /**
-* The safe cross-environment cooperative-yield default — a {@link SchedulerInterface}
+* Implements the safe cross-environment cooperative-yield default — a {@link SchedulerInterface}
 * built on `setTimeout` / `clearTimeout` alone, so it runs unchanged in both the
 * browser and Node.
 *
@@ -1025,7 +1478,7 @@ function parkSignal(signal) {
 *   rendering run — it only defers within the current task. A zero-delay timer is
 *   the correct cross-environment "give the host a turn".
 * - **Abort-aware.** A pending `yield` / `delay` rejects with `signal.reason` exactly.
-*   {@link scheduleHost} links an owned settlement composite to the caller before arming
+*   {@link delayHost} links an owned settlement composite to the caller before arming
 *   the timer, so pre-abort schedules nothing, caller signal method mutation is harmless,
 *   cancellation clears the handle, and native first-settlement wins exactly once.
 * - **Priority is accepted but uniform.** `options.priority` is part of the
@@ -1044,36 +1497,30 @@ function parkSignal(signal) {
 */
 var Scheduler = class {
 	/**
-	* Yield control back to the host so other tasks (I/O, timers, rendering) can
-	* run, then resume — a macrotask turn via `setTimeout(0)` (NOT a microtask,
+	* Yields control back to the host so other tasks (I/O, timers, rendering) can
+	* run, then resumes — a macrotask turn through `setTimeout(0)` (NOT a microtask,
 	* which would resume before the host regains control).
 	*/
 	yield(options) {
-		return this.#sleep(0, options?.signal);
+		return delayHost(0, options?.signal);
 	}
 	/**
-	* Resume after at least `ms` milliseconds; abort rejects with `signal.reason`.
+	* Resumes after at least `ms` milliseconds; abort rejects with `signal.reason`.
 	*
 	* @remarks
-	* `ms` should be a non-negative finite number. The primitive stays minimal and
-	* does no validation: it passes `ms` straight to the host `setTimeout`, which
-	* clamps a negative value or `NaN` to ~0 — so an out-of-domain `ms` resolves on
-	* the next host turn rather than throwing.
+	* Pass a non-negative finite `ms`. The primitive stays minimal and does no
+	* validation: it passes `ms` straight to the host `setTimeout`, which clamps a
+	* negative value or `NaN` to ~0 — so an out-of-domain `ms` resolves on the next
+	* host turn rather than throwing.
 	*/
 	delay(ms, options) {
-		return this.#sleep(ms, options?.signal);
-	}
-	#sleep(ms, signal) {
-		return scheduleHost((complete) => {
-			const handle = setTimeout(complete, ms);
-			return () => clearTimeout(handle);
-		}, signal);
+		return delayHost(ms, options?.signal);
 	}
 };
 //#endregion
 //#region src/core/cloners.ts
 /**
-* Validate and own a workflow snapshot before live construction.
+* Validates and owns a workflow snapshot before live construction.
 *
 * @param input - The hostile snapshot boundary
 * @param id - The optional storage key the owned snapshot must match
@@ -1089,7 +1536,7 @@ function cloneWorkflowSnapshot(input, id) {
 		if (isContractError(error)) throw new WorkflowError("RESTORE", `workflow snapshot could not be read safely: ${error.message}`);
 		throw new WorkflowError("RESTORE", "workflow snapshot could not be read safely");
 	}
-	if (!isOwnedWorkflowSnapshot(cloned)) throw new WorkflowError("RESTORE", "workflow snapshot is inconsistent", workflowSnapshotContext(cloned));
+	if (!isOwnedWorkflowSnapshot(cloned)) throw new WorkflowError("RESTORE", "workflow snapshot is inconsistent", scanSnapshotContext(cloned));
 	if (id !== void 0 && cloned.id !== id) throw new WorkflowError("RESTORE", `workflow snapshot '${cloned.id}' does not match storage key '${id}'`, {
 		requested: id,
 		payload: cloned.id
@@ -1097,7 +1544,49 @@ function cloneWorkflowSnapshot(input, id) {
 	return cloned;
 }
 /**
-* Validate and clone one complete task activity frame.
+* Validates and owns one list of task activity claims.
+*
+* @remarks
+* The one cloner behind both claim lists of a task activity frame — its `operations` and its
+* `constraints` — because {@link import('./types.js').TaskOperation} and
+* {@link import('./types.js').TaskConstraint} are the same {@link import('./types.js').TaskClaim}
+* shape. An omitted
+* list is an empty one. Each member is read exactly once inside the caller's protected boundary
+* and returned frozen; the semantic pass over the copied values is
+* {@link import('./validators.js').isTaskClaimList}, so this cloner refuses only what it cannot
+* read: a non-array list, a non-record member, a hostile prototype, or an unexpected key.
+*
+* @param input - The untrusted claim list
+* @param noun - The singular claim noun the refusal message names, pluralized by adding `s`
+* @returns The owned frozen claims, in input order
+* @throws {WorkflowError} With `MUTATION` when the list or one of its members cannot be read
+*
+* @example
+* ```ts
+* cloneTaskClaims([{ id: 'fetch', name: 'Fetch', started: 1 }], 'operation')
+* ```
+*/
+function cloneTaskClaims(input, noun) {
+	const inputs = input === void 0 ? [] : isArray(input) ? [...input] : void 0;
+	if (inputs === void 0) throw new WorkflowError("MUTATION", `task activity ${noun}s must be an array`);
+	const claims = [];
+	for (const claim of inputs) {
+		if (!isRecord(claim)) throw new WorkflowError("MUTATION", `task activity contains an invalid ${noun}`);
+		const prototype = Object.getPrototypeOf(claim);
+		if (prototype !== Object.prototype && prototype !== null || !Object.keys(claim).every((key) => key === "id" || key === "name" || key === "started")) throw new WorkflowError("MUTATION", `task activity contains an invalid ${noun}`);
+		const id = claim.id;
+		const name = claim.name;
+		const started = claim.started;
+		claims.push(Object.freeze({
+			id,
+			name,
+			started
+		}));
+	}
+	return claims;
+}
+/**
+* Validates and clones one complete task activity frame.
 *
 * @remarks
 * This is the hostile boundary behind task reports and snapshot hydration. Supplying
@@ -1121,22 +1610,7 @@ function cloneTaskActivity(input, updated) {
 		const operationsInput = input.operations;
 		const constraintsInput = input.constraints;
 		const accepted = updated === void 0 ? input.updated : updated;
-		const operationInputs = operationsInput === void 0 ? [] : isArray(operationsInput) ? [...operationsInput] : void 0;
-		if (operationInputs === void 0) throw new WorkflowError("MUTATION", "task activity operations must be an array");
-		const operations = [];
-		for (const operation of operationInputs) {
-			if (!isRecord(operation)) throw new WorkflowError("MUTATION", "task activity contains an invalid operation");
-			const operationPrototype = Object.getPrototypeOf(operation);
-			if (operationPrototype !== Object.prototype && operationPrototype !== null || !Object.keys(operation).every((key) => key === "id" || key === "name" || key === "started")) throw new WorkflowError("MUTATION", "task activity contains an invalid operation");
-			const id = operation.id;
-			const name = operation.name;
-			const started = operation.started;
-			operations.push(Object.freeze({
-				id,
-				name,
-				started
-			}));
-		}
+		const operations = cloneTaskClaims(operationsInput, "operation");
 		let progress;
 		if (progressInput !== void 0) {
 			if (!isRecord(progressInput)) throw new WorkflowError("MUTATION", "task activity contains invalid progress");
@@ -1151,22 +1625,7 @@ function cloneTaskActivity(input, updated) {
 				...message === void 0 ? {} : { message }
 			});
 		}
-		const constraintInputs = constraintsInput === void 0 ? [] : isArray(constraintsInput) ? [...constraintsInput] : void 0;
-		if (constraintInputs === void 0) throw new WorkflowError("MUTATION", "task activity constraints must be an array");
-		const constraints = [];
-		for (const constraint of constraintInputs) {
-			if (!isRecord(constraint)) throw new WorkflowError("MUTATION", "task activity contains an invalid constraint");
-			const constraintPrototype = Object.getPrototypeOf(constraint);
-			if (constraintPrototype !== Object.prototype && constraintPrototype !== null || !Object.keys(constraint).every((key) => key === "id" || key === "name" || key === "started")) throw new WorkflowError("MUTATION", "task activity contains an invalid constraint");
-			const id = constraint.id;
-			const name = constraint.name;
-			const started = constraint.started;
-			constraints.push(Object.freeze({
-				id,
-				name,
-				started
-			}));
-		}
+		const constraints = cloneTaskClaims(constraintsInput, "constraint");
 		const activity = Object.freeze({
 			...note === void 0 ? {} : { note },
 			...progress === void 0 ? {} : { progress },
@@ -1184,8 +1643,8 @@ function cloneTaskActivity(input, updated) {
 //#endregion
 //#region src/core/shapers.ts
 /**
-* The shape of a {@link import('./types.js').TaskDefinition} — identity plus an optional
-* `run` behavior reference (a plain registry-key string, min length 1). `description` is
+* Describes the shape of a {@link import('./types.js').TaskDefinition} — identity plus an optional
+* `behavior` behavior reference (a plain registry-key string, min length 1). `description` is
 * optional prose.
 */
 var taskShape = objectShape({
@@ -1198,7 +1657,7 @@ var taskShape = objectShape({
 		description: "Human-readable task name."
 	}),
 	description: optionalShape(stringShape({ description: "Optional task description." })),
-	run: optionalShape(stringShape({
+	behavior: optionalShape(stringShape({
 		min: 1,
 		description: "The registered behavior name to invoke (a registry key, not a label); omitted has no handler."
 	})),
@@ -1213,7 +1672,7 @@ var taskShape = objectShape({
 	}))
 });
 /**
-* The shape of a {@link import('./types.js').PhaseDefinition} — identity, its ordered
+* Describes the shape of a {@link import('./types.js').PhaseDefinition} — identity, its ordered
 * {@link taskShape} tasks, and an optional positive-integer `concurrency` throttle
 * (max tasks in flight; omitted ⇒ unbounded).
 */
@@ -1235,7 +1694,7 @@ var phaseShape = objectShape({
 	bail: optionalShape(literalShape([true, false], { description: "Per-phase failure-policy override; omitted inherits the workflow bail." }))
 });
 /**
-* The shape of a {@link import('./types.js').WorkflowDefinition} — the contract root:
+* Describes the shape of a {@link import('./types.js').WorkflowDefinition} — the contract root:
 * identity, its ordered {@link phaseShape} phases, and the optional `bail` boolean
 * failure policy (the literal pair `true`/`false`, the runtime mirror of the boolean
 * toggle; omitted ⇒ the graceful default).
@@ -1254,13 +1713,13 @@ var workflowShape = objectShape({
 	bail: optionalShape(literalShape([true, false], { description: "Failure policy: false (default) continues gracefully, true halts on the first failure." }))
 });
 /**
-* The shape of a {@link import('./types.js').TaskUpdate} — a partial edit to a
+* Describes the shape of a {@link import('./types.js').TaskUpdate} — a partial edit to a
 * `pending` task's `name` / `description`, both optional.
 *
 * @remarks
 * Mirrors {@link taskShape}'s `name` / `description` constraints exactly (a provided
-* `name` still has `minLength: 1`); never `id` / `run` / `retries` / `timeout` (those
-* are not patchable fields, AGENTS §12).
+* `name` still has `minLength: 1`); never `id` / `behavior` / `retries` / `timeout` (those
+* are not patchable fields).
 */
 var taskUpdateShape = objectShape({
 	name: optionalShape(stringShape({
@@ -1270,13 +1729,13 @@ var taskUpdateShape = objectShape({
 	description: optionalShape(stringShape({ description: "New task description." }))
 });
 /**
-* The shape of a {@link import('./types.js').PhaseUpdate} — a partial edit to a
+* Describes the shape of a {@link import('./types.js').PhaseUpdate} — a partial edit to a
 * `pending` phase's `name` / `description` / `concurrency` / `bail`, all optional.
 *
 * @remarks
 * Mirrors {@link phaseShape}'s corresponding field constraints exactly; never `id` /
 * `tasks` (structural children change through the phase's own `add` / `remove` /
-* `move`, not a patch, AGENTS §12).
+* `move`, not a patch).
 */
 var phaseUpdateShape = objectShape({
 	name: optionalShape(stringShape({
@@ -1293,7 +1752,7 @@ var phaseUpdateShape = objectShape({
 //#endregion
 //#region src/core/stores/DatabaseWorkflowStore.ts
 /**
-* A {@link WorkflowStoreInterface} backed by one table of the `databases` layer — a
+* Implements a {@link WorkflowStoreInterface} backed by one table of the `databases` layer — a
 * workflow's durable run-state IS a row, so persistence reduces to keyed point-access
 * (`get` / `set` / `delete`) over a `TableInterface`, the driver-pluggable twin of the
 * plain-`Map` {@link import('./MemoryWorkflowStore.js').MemoryWorkflowStore}.
@@ -1317,16 +1776,18 @@ var phaseUpdateShape = objectShape({
 *
 * - **`set(snapshot)` upserts under the snapshot's OWN `id`** (no separate id param) — it writes
 *   the row `{ id: snapshot.id, snapshot }`.
-* - **`get(id)` resolves the stored snapshot for an id**, narrowing the opaque JSON column back to
-*   a {@link WorkflowSnapshot} ({@link import('../helpers.js').isWorkflowSnapshot} — the AGENTS §14
-*   boundary narrow for an untrusted storage read), or `undefined` if none is stored. A present
-*   snapshot whose own id differs from the requested key rejects with normalized `RESTORE` evidence.
+* - **`get(id)` resolves the stored snapshot for an id**, owning and narrowing the opaque JSON
+*   column back to a {@link WorkflowSnapshot} through
+*   {@link import('../cloners.js').cloneWorkflowSnapshot}, whose semantic pass is
+*   {@link import('../validators.js').isOwnedWorkflowSnapshot} — the boundary narrow for
+*   an untrusted storage read — or `undefined` if none is stored. A present snapshot whose own id
+*   differs from the requested key rejects with normalized `RESTORE` evidence.
 * - **`delete(id)` drops a snapshot by id**; an absent id is a no-op (no throw).
 *
 * UNLIKE the server package's `SessionStoreInterface` there is NO
 * idle-TTL / eviction — a persisted run-state is durable orchestration state that lives until an
 * explicit `delete`. The public surface is EXACTLY `get` / `set` / `delete` — no extra members (the
-* §22 method bijection with {@link WorkflowStoreInterface}). Restore stays a caller concern: read a
+* guide's method bijection with {@link WorkflowStoreInterface}). Restore stays a caller concern: read a
 * snapshot back and rebuild the live tree with {@link import('../factories.js').createRestoredWorkflow}.
 *
 * @example
@@ -1345,7 +1806,7 @@ var phaseUpdateShape = objectShape({
 var DatabaseWorkflowStore = class {
 	#table;
 	/**
-	* Wrap a table as a workflow store.
+	* Wraps a table as a workflow store.
 	*
 	* @param table - The {@link TableInterface} holding the snapshots — its row is the
 	*   {@link WorkflowSnapshotRow} `{ id; snapshot }` shape (the snapshot one opaque JSON column)
@@ -1353,13 +1814,13 @@ var DatabaseWorkflowStore = class {
 	constructor(table) {
 		this.#table = table;
 	}
-	/** Resolve and key-check the snapshot for `id`, narrowing the opaque column to `WorkflowSnapshot`. */
+	/** Resolves and key-checks the snapshot for `id`, narrowing the opaque column to `WorkflowSnapshot`. */
 	async get(id) {
 		const row = await this.#table.get(id);
 		if (row === void 0) return void 0;
 		return cloneWorkflowSnapshot(row.snapshot, id);
 	}
-	/** Insert or replace under the snapshot's OWN `id` (no separate id param) — the row is `{ id, snapshot }`. */
+	/** Inserts or replaces under the snapshot's OWN `id` (no separate id param) — the row is `{ id, snapshot }`. */
 	async set(snapshot) {
 		const owned = cloneWorkflowSnapshot(snapshot);
 		await this.#table.set({
@@ -1367,7 +1828,7 @@ var DatabaseWorkflowStore = class {
 			snapshot: owned
 		});
 	}
-	/** Drop a snapshot by id; an absent id is a no-op (no throw). */
+	/** Drops a snapshot by id; an absent id is a no-op (no throw). */
 	async delete(id) {
 		await this.#table.remove(id);
 	}
@@ -1375,12 +1836,12 @@ var DatabaseWorkflowStore = class {
 //#endregion
 //#region src/core/stores/MemoryWorkflowStore.ts
 /**
-* The in-memory {@link WorkflowStoreInterface} — a process-lifetime `Map` of
+* Implements the in-memory {@link WorkflowStoreInterface} — a process-lifetime `Map` of
 * {@link WorkflowSnapshot}s keyed by workflow id, the DEFAULT store
 * {@link import('../factories.js').createMemoryWorkflowStore} builds.
 *
 * @remarks
-* A plain `Map<string, WorkflowSnapshot>` (AGENTS §21 — the snapshot is already pure,
+* A plain `Map<string, WorkflowSnapshot>` (the snapshot is already pure,
 * self-contained JSON, so no encoding is needed for the memory tier). UNLIKE the server
 * package's `SessionStoreInterface`'s memory store there is
 * NO idle-TTL and NO eviction: a persisted workflow run-state is durable orchestration state
@@ -1396,7 +1857,7 @@ var DatabaseWorkflowStore = class {
 * - **`set` inserts / replaces under the snapshot's OWN `id`** (no separate id param).
 * - **`delete` drops a snapshot by id**; an absent id is a no-op (no throw).
 *
-* The public surface is EXACTLY `get` / `set` / `delete` — no extra members (the §22 method
+* The public surface is EXACTLY `get` / `set` / `delete` — no extra members (the guide's method
 * bijection with {@link WorkflowStoreInterface}). Restore is a caller concern: read a snapshot
 * back and rebuild the live tree with {@link import('../factories.js').createRestoredWorkflow}.
 *
@@ -1431,18 +1892,18 @@ var MemoryWorkflowStore = class {
 //#endregion
 //#region src/core/tasks/Task.ts
 /**
-* The live leaf state machine (W-b) for one task — an observable (AGENTS §13), guarded
-* synchronous task whose explicit {@link TaskStatus} advances through the AGENTS §10
+* Implements the live leaf state machine (W-b) for one task — an observable, guarded
+* synchronous task whose explicit {@link LifecycleStatus} advances through the declared
 * transitions, recording a {@link TaskResult} on a terminal outcome.
 *
 * @remarks
-* - **Guarded transitions (AGENTS §10).** `start` (→ `running`), then `complete(value)`
+* - **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
-*   `TRANSITION` {@link WorkflowError} on an illegal move (e.g. completing a non-`running`
-*   task) — the legal graph is the single source of truth, so the leaf can never reach an
-*   impossible state.
+*   `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
@@ -1450,16 +1911,16 @@ var MemoryWorkflowStore = class {
 *   transition propagates UP (Task → Phase → Workflow re-derive). The own-event-before-cascade
 *   order means an observer sees the CAUSE (this leaf changed) before the EFFECT (the parents
 *   re-derive) — the project precedent (`Runner.#settle` emits its own `fail` before propagating).
-* - **Observable (AGENTS §13).** The owned {@link emitter} ({@link TaskEventMap}) fires the
+* - **Observable.** The owned {@link emitter} ({@link TaskEventMap}) fires the
 *   matching event strictly AFTER the state change, BEFORE the cascade; the emitter isolates
 *   a listener throw and routes it to its `error` handler (the `error` option), so a buggy
 *   observer can never corrupt a transition.
-* - **Declarative config (AGENTS §12).** `run` / `retries` / `timeout` PERSIST in a
+* - **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 — `run` 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 `run` 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 {
@@ -1472,7 +1933,8 @@ var Task = class {
 	#status;
 	#result;
 	#name;
-	#run;
+	#description;
+	#behavior;
 	#retries;
 	#timeout;
 	#attempts;
@@ -1485,7 +1947,7 @@ var Task = class {
 	#paused;
 	#gate;
 	#timerSignal;
-	constructor(context, phase, workflow, recompute, options, status = "pending", result, run, retries, timeout, metadata = {}, attempts = 0, activity, handler, silence) {
+	constructor(context, phase, workflow, recompute, options, status = "pending", result, behavior, retries, timeout, metadata = {}, attempts = 0, activity, handler, silence) {
 		this.#context = buildTaskContext(context.phase, context);
 		this.#phase = phase;
 		this.#workflow = workflow;
@@ -1507,11 +1969,8 @@ var Task = class {
 		this.#status = status;
 		this.#result = result;
 		this.#name = context.name;
-		if (context.description !== void 0) Object.defineProperty(this, "description", {
-			configurable: true,
-			value: context.description
-		});
-		this.#run = run;
+		this.#description = context.description;
+		this.#behavior = behavior;
 		this.#retries = retries;
 		this.#timeout = timeout;
 		this.#attempts = attempts;
@@ -1537,6 +1996,9 @@ var Task = class {
 	get name() {
 		return this.#name;
 	}
+	get description() {
+		return this.#description;
+	}
 	get context() {
 		return this.#context;
 	}
@@ -1555,8 +2017,8 @@ var Task = class {
 	get attempts() {
 		return this.#attempts;
 	}
-	get run() {
-		return this.#run;
+	get behavior() {
+		return this.#behavior;
 	}
 	get handler() {
 		return this.#handler;
@@ -1595,7 +2057,7 @@ var Task = class {
 		this.#activity = cloneTaskActivity({}, this.#stamp());
 		this.#arm();
 		this.#emitter.emit("start", this.id);
-		this.#escalate();
+		this.#recompute();
 	}
 	complete(value) {
 		let owned;
@@ -1612,7 +2074,7 @@ var Task = class {
 			value: owned
 		}));
 		this.#emitter.emit("complete", result);
-		this.#escalate();
+		this.#recompute();
 	}
 	fail(error) {
 		const origin = error.origin === "handler" || error.origin === "timeout" || error.origin === "recovery" ? error.origin : "handler";
@@ -1627,21 +2089,21 @@ var Task = class {
 			})
 		}));
 		this.#emitter.emit("fail", result);
-		this.#escalate();
+		this.#recompute();
 	}
 	skip() {
 		this.#transition("skipped");
 		this.#finish();
 		this.#abort.abort();
 		this.#emitter.emit("skip");
-		this.#escalate();
+		this.#recompute();
 	}
 	stop() {
 		this.#transition("stopped");
 		this.#finish();
 		this.#abort.abort();
 		this.#emitter.emit("stop");
-		this.#escalate();
+		this.#recompute();
 	}
 	report(input) {
 		if (this.#status !== "running") return failure(new WorkflowError("TRANSITION", `task '${this.id}' cannot report while '${this.#status}'`, {
@@ -1669,7 +2131,7 @@ var Task = class {
 	pause() {
 		if (this.#paused || this.#status !== "pending" && this.#status !== "running") return;
 		this.#paused = true;
-		this.#gate = createDeferred();
+		this.#gate = Promise.withResolvers();
 		this.#emitter.emit("pause");
 	}
 	resume() {
@@ -1682,10 +2144,10 @@ var Task = class {
 		return this.#paused && this.#gate !== void 0 ? this.#gate.promise : Promise.resolve();
 	}
 	/**
-	* Apply a validated declarative patch to SELF (`name` / `description`).
+	* Applies a validated declarative patch to SELF (`name` / `description`).
 	*
 	* @remarks
-	* Defense-in-depth (AGENTS §12): the owning
+	* 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
 	* `MUTATION` {@link WorkflowError} unless this task's own `status` is `pending`.
@@ -1702,21 +2164,18 @@ var Task = class {
 			status: this.#status
 		});
 		if (value.name !== void 0) this.#name = value.name;
-		if (value.description !== void 0) Object.defineProperty(this, "description", {
-			configurable: true,
-			value: value.description
-		});
+		if (value.description !== void 0) this.#description = value.description;
 	}
 	snapshot() {
 		return {
 			id: this.id,
 			name: this.name,
-			...this.description === void 0 ? {} : { description: this.description },
+			...this.#description === void 0 ? {} : { description: this.#description },
 			status: this.#status,
 			...this.#result === void 0 ? {} : { result: this.#result },
 			metadata: this.#metadata,
 			attempts: this.#attempts,
-			...this.#run === void 0 ? {} : { run: this.#run },
+			...this.#behavior === void 0 ? {} : { behavior: this.#behavior },
 			...this.#retries === void 0 ? {} : { retries: this.#retries },
 			...this.#timeout === void 0 ? {} : { timeout: this.#timeout },
 			...this.#activity === void 0 ? {} : { activity: this.#activity }
@@ -1743,9 +2202,6 @@ var Task = class {
 		this.#result = frozen;
 		return frozen;
 	}
-	#escalate() {
-		this.#recompute();
-	}
 	#touch() {
 		if (this.#activity === void 0) return;
 		this.#activity = Object.freeze({
@@ -1790,25 +2246,30 @@ var Task = class {
 //#endregion
 //#region src/core/tasks/TaskManager.ts
 /**
-* The lean child manager (AGENTS §9) of a {@link import('../phases/Phase.js').Phase}'s live
-* tasks — an insertion-ordered registry keyed by task `id`, so positional order is
-* preserved across an interior `skip` / `remove`.
+* Implements the lean child manager of a {@link import('../phases/Phase.js').Phase}'s live
+* tasks — the task vocabulary over one insertion-ordered {@link Collection}, so positional order
+* is preserved across an interior `skip` / `remove`.
 *
 * @remarks
-* - **Positional store.** Tasks live in an insertion-ordered `Map` keyed by `id`;
-*   `append` adds one at the end (the build-time wiring path), `task(id)` looks one up,
-*   `tasks()` lists them in positional order, `count` is the size. A `skip` is a STATUS
-*   change on a stored task (never a removal), so order survives it; a snapshot RESTORE
-*   re-`append`s in the snapshot's order, reproducing it exactly.
-* - **Gated mutation API (AGENTS §12).** `add` / `remove` / `move` / `update` are the
-*   graceful `Result` counterparts to `append`, gating ONLY on the target's OWN
-*   existence/status/id/bounds — a duplicate id, an absent/non-`pending` target, an
-*   out-of-bounds `index`, or a patch that fails {@link taskUpdateShape} validation all
-*   fail gracefully with a `MUTATION` {@link WorkflowError} instead of throwing.
-* - **No batch matrix.** A phase's tasks are a fixed positional set, so AGENTS §9.2 (the
-*   bulk verb overloads) is deliberately omitted — there is no `remove` family here.
-* - **Event-free.** A purely structural container — the live {@link TaskInterface}s own
-*   their own emitters; the manager observes nothing.
+* - **One shared store.** The insertion-ordered `Map`, the reorder step, the bounds checks, and
+*   the gated `add` / `remove` / `move` / `update` all live in {@link Collection}, built with the
+*   `task` noun its refusals name and the compiled {@link taskUpdateShape} guard. This class adds
+*   the domain accessors `task` / `tasks` and nothing else, so the task and phase managers cannot
+*   drift apart.
+* - **Positional store.** `append` adds one live {@link TaskInterface} at the end (the build-time
+*   wiring path), `task(id)` looks one up, `tasks()` lists them in positional order, `count` is
+*   the tally. A `skip` is a STATUS change on a stored task (never a removal), so order survives
+*   it; a snapshot RESTORE re-`append`s in the snapshot's order, reproducing it exactly.
+* - **Gated mutation API.** `add` / `remove` / `move` / `update` are the graceful
+*   `Result` counterparts to `append`, gating ONLY on the target's OWN existence/status/id/bounds
+*   — a duplicate id, an absent/non-`pending` target, an out-of-bounds `index`, or a patch that
+*   fails {@link taskUpdateShape} validation all fail gracefully with a `MUTATION`
+*   {@link WorkflowError} instead of throwing.
+* - **No batch matrix.** A phase's tasks are a fixed positional set, so
+*   `.claude/rules/patterns.md` § Batch operations (the bulk verb
+*   overloads) is deliberately omitted — no `remove` family lives here.
+* - **Event-free.** A purely structural container — the live {@link TaskInterface}s own their own
+*   emitters; the manager observes nothing.
 *
 * @example
 * ```ts
@@ -1819,58 +2280,37 @@ var Task = class {
 * ```
 */
 var TaskManager = class {
-	#tasks = /* @__PURE__ */ new Map();
-	#isUpdate = compileGuard(taskUpdateShape);
+	#tasks = new Collection("task", compileGuard(taskUpdateShape));
 	get count() {
-		return this.#tasks.size;
+		return this.#tasks.count;
 	}
 	append(task) {
-		if (this.#tasks.has(task.id)) throw new WorkflowError("MUTATION", `duplicate task id '${task.id}'`, { id: task.id });
-		this.#tasks.set(task.id, task);
+		this.#tasks.append(task);
 	}
 	add(task, index) {
-		if (this.#tasks.has(task.id)) return failure(new WorkflowError("MUTATION", `duplicate task id '${task.id}'`, { id: task.id }));
-		const at = index ?? this.#tasks.size;
-		if (at < 0 || at > this.#tasks.size) return failure(new WorkflowError("MUTATION", `index '${at}' out of bounds`, { index: at }));
-		this.#reorder(insertEntry([...this.#tasks.entries()], at, task.id, task));
-		return success(task);
+		return this.#tasks.add(task, index);
 	}
 	remove(id) {
-		const target = this.#tasks.get(id);
-		if (target === void 0 || target.status !== "pending") return failure(new WorkflowError("MUTATION", `task '${id}' is not a pending task`, { id }));
-		this.#tasks.delete(id);
-		return success(target);
+		return this.#tasks.remove(id);
 	}
 	move(id, index) {
-		const target = this.#tasks.get(id);
-		if (target === void 0 || target.status !== "pending") return failure(new WorkflowError("MUTATION", `task '${id}' is not a pending task`, { id }));
-		if (index < 0 || index >= this.#tasks.size) return failure(new WorkflowError("MUTATION", `index '${index}' out of bounds`, { index }));
-		this.#reorder(moveEntry([...this.#tasks.entries()], id, index));
-		return success(target);
+		return this.#tasks.move(id, index);
 	}
 	update(id, patch) {
-		const target = this.#tasks.get(id);
-		if (target === void 0 || target.status !== "pending") return failure(new WorkflowError("MUTATION", `task '${id}' is not a pending task`, { id }));
-		if (!this.#isUpdate(patch)) return failure(new WorkflowError("MUTATION", `invalid patch for task '${id}'`, { id }));
-		target.patch(patch);
-		return success(target);
+		return this.#tasks.update(id, patch);
 	}
 	task(id) {
-		return this.#tasks.get(id);
+		return this.#tasks.entry(id);
 	}
 	tasks() {
-		return [...this.#tasks.values()];
-	}
-	#reorder(entries) {
-		this.#tasks.clear();
-		for (const [key, value] of entries) this.#tasks.set(key, value);
+		return this.#tasks.entries();
 	}
 };
 //#endregion
 //#region src/core/phases/Phase.ts
 /**
-* The live DERIVED state machine (W-b) for one phase — an observable (AGENTS §13) whose
-* {@link PhaseStatus} is computed from its tasks (never set directly) and recomputed
+* 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
@@ -1878,20 +2318,20 @@ var TaskManager = class {
 *   {@link derivePhaseStatus} over the live tasks' statuses. `#recompute` (passed to
 *   each child {@link Task}) re-derives on every child transition; a CHANGE emits the matching
 *   event AND escalates to the workflow (`#escalate`, the upward step of the cascade).
-* - **Override (AGENTS §10).** `skip` / `stop` FORCE the phase's status (e.g. skipping a whole
+* - **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 (AGENTS §9).** `tasks` is the lean {@link TaskManager} (an accessor + `count`,
+* - **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.
-* - **Observable (AGENTS §13).** The owned {@link emitter} ({@link PhaseEventMap}) fires
+* - **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 (AGENTS §7).** `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
 *   gating, purely from this phase's own derived `status` (no runner-installed hook): while
@@ -1899,22 +2339,22 @@ var TaskManager = class {
 *   append (a live runner subscribed to the `add` event picks it up), and `remove` / `move` /
 *   `update` always fail gracefully (the tasks are already handed to the execution
 *   substrate); while terminal, everything is refused.
-* - **Patch (AGENTS §12).** `patch` applies a validated {@link PhaseUpdate} to SELF
+* - **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 (AGENTS §7).** {@link add} MINTS a live {@link Task} from a {@link TaskDefinition}
+* - **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
-*   {@link import('../types.js').WorkflowFunctions} registry (threaded from
-*   {@link import('../types.js').WorkflowOptions.functions}) resolves every unique initial `run`
+*   {@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
 *   runtime {@link import('../types.js').TaskInterface.handler}. A later live {@link add} reads
 *   that name once from the retained registry at its own mint moment. An omitted or unregistered
-*   `run` resolves to no handler; only omission is a no-op, while an unresolved present name makes
+*   `behavior` resolves to no handler; only omission is a no-op, while an unresolved present name makes
 *   the containing tree non-drivable.
-* - **Runtime lifecycle (AGENTS §10).** `pause` / `resume` / `wait` mirror the workflow's own
+* - **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
@@ -1926,6 +2366,7 @@ var TaskManager = class {
 var Phase = class {
 	#id;
 	#name;
+	#description;
 	#workflow;
 	#escalateUp;
 	#tasks = new TaskManager();
@@ -1944,16 +2385,13 @@ var Phase = class {
 		const tasks = options?.tasks;
 		this.#id = snapshot.id;
 		this.#name = snapshot.name;
-		if (snapshot.description !== void 0) Object.defineProperty(this, "description", {
-			configurable: true,
-			value: snapshot.description
-		});
+		this.#description = snapshot.description;
 		this.#workflow = workflow;
 		this.#escalateUp = escalate;
 		this.#functions = functions;
 		this.#silence = silence;
 		const handlers = /* @__PURE__ */ new Map();
-		for (const task of snapshot.tasks) if (task.run !== void 0 && !handlers.has(task.run)) handlers.set(task.run, functions?.[task.run]);
+		for (const task of snapshot.tasks) if (task.behavior !== void 0 && !handlers.has(task.behavior)) handlers.set(task.behavior, functions?.[task.behavior]);
 		this.#bail = bail ?? snapshot.bail;
 		this.#concurrency = snapshot.concurrency;
 		this.#emitter = new Emitter({
@@ -1962,7 +2400,7 @@ var Phase = class {
 		});
 		for (const task of snapshot.tasks) {
 			const taskOptions = tasks?.[task.id];
-			const handler = task.run === void 0 ? void 0 : handlers.get(task.run);
+			const handler = task.behavior === void 0 ? void 0 : handlers.get(task.behavior);
 			this.#append(task, taskOptions, handler);
 		}
 		this.#override = snapshot.override;
@@ -1979,11 +2417,14 @@ var Phase = class {
 	get name() {
 		return this.#name;
 	}
+	get description() {
+		return this.#description;
+	}
 	get context() {
 		return buildPhaseContext(this.#workflow.context, {
 			id: this.#id,
 			name: this.#name,
-			...this.description === void 0 ? {} : { description: this.description }
+			...this.#description === void 0 ? {} : { description: this.#description }
 		});
 	}
 	get workflow() {
@@ -2025,7 +2466,7 @@ var Phase = class {
 	pause() {
 		if (this.#paused || isTerminalStatus(this.status)) return;
 		this.#paused = true;
-		this.#gate = createDeferred();
+		this.#gate = Promise.withResolvers();
 		this.#emitter.emit("pause");
 	}
 	resume() {
@@ -2087,10 +2528,7 @@ var Phase = class {
 			status: this.status
 		});
 		if (value.name !== void 0) this.#name = value.name;
-		if (value.description !== void 0) Object.defineProperty(this, "description", {
-			configurable: true,
-			value: value.description
-		});
+		if (value.description !== void 0) this.#description = value.description;
 		if (value.concurrency !== void 0) this.#concurrency = value.concurrency;
 		if (value.bail !== void 0) this.#bail = value.bail;
 	}
@@ -2098,7 +2536,7 @@ var Phase = class {
 		return {
 			id: this.id,
 			name: this.name,
-			...this.description === void 0 ? {} : { description: this.description },
+			...this.#description === void 0 ? {} : { description: this.#description },
 			status: this.status,
 			...this.#override === void 0 ? {} : { override: this.#override },
 			bail: this.#bail,
@@ -2133,7 +2571,7 @@ var Phase = class {
 	}
 	#failure() {
 		const found = findFailure(this.results());
-		if (found === void 0) throw new Error(`phase '${this.id}' derived failed with no failing task result`);
+		if (found === void 0) throw new WorkflowError("INVARIANT", `phase '${this.id}' derived failed with no failing task result`, { phase: this.id });
 		return found;
 	}
 	#release() {
@@ -2151,11 +2589,11 @@ var Phase = class {
 		this.#tasks.append(created);
 	}
 	#create(snapshot, options, handler) {
-		return new Task(buildTaskContext(this.context, snapshot), this, this.#workflow, () => this.#recompute(), options, snapshot.status, snapshot.result, snapshot.run, snapshot.retries, snapshot.timeout, snapshot.metadata, snapshot.attempts, snapshot.activity, handler, this.#silence);
+		return new Task(buildTaskContext(this.context, snapshot), this, this.#workflow, () => this.#recompute(), options, snapshot.status, snapshot.result, snapshot.behavior, snapshot.retries, snapshot.timeout, snapshot.metadata, snapshot.attempts, snapshot.activity, handler, this.#silence);
 	}
 	#mint(definition) {
 		const snapshot = taskDefinitionToSnapshot(definition);
-		const handler = snapshot.run === void 0 ? void 0 : this.#functions?.[snapshot.run];
+		const handler = snapshot.behavior === void 0 ? void 0 : this.#functions?.[snapshot.behavior];
 		return this.#create(snapshot, void 0, handler);
 	}
 	#statuses() {
@@ -2165,24 +2603,28 @@ var Phase = class {
 //#endregion
 //#region src/core/phases/PhaseManager.ts
 /**
-* The lean child manager (AGENTS §9) of a {@link import('../Workflow.js').Workflow}'s
-* live phases — an insertion-ordered registry keyed by phase `id`, the phase analogue
+* Implements the lean child manager of a {@link import('../Workflow.js').Workflow}'s live
+* phases — the phase vocabulary over one insertion-ordered {@link Collection}, the phase analogue
 * of {@link import('../tasks/TaskManager.js').TaskManager}.
 *
 * @remarks
-* - **Positional store.** Phases live in an insertion-ordered `Map` keyed by `id`;
-*   `append` adds one at the end, `phase(id)` looks one up, `phases()` lists them in
-*   positional order, `count` is the size. A snapshot RESTORE re-`append`s in the
-*   snapshot's order, reproducing it exactly.
-* - **Gated mutation API (AGENTS §12).** `add` / `remove` / `move` / `update` are the
-*   graceful `Result` counterparts to `append`, gating ONLY on the target's OWN
-*   existence/status/id/bounds — a duplicate id, an absent/non-`pending` target, an
-*   out-of-bounds `index`, or a patch that fails {@link phaseUpdateShape} validation
-*   all fail gracefully with a `MUTATION` {@link WorkflowError} instead of throwing.
-* - **No batch matrix.** A workflow's phases are a fixed positional set, so AGENTS §9.2
-*   is deliberately omitted.
-* - **Event-free.** A purely structural container — the live {@link PhaseInterface}s own
-*   their own emitters.
+* - **One shared store.** The insertion-ordered `Map`, the reorder step, the bounds checks, and
+*   the gated `add` / `remove` / `move` / `update` all live in {@link Collection}, built with the
+*   `phase` noun its refusals name and the compiled {@link phaseUpdateShape} guard. This class
+*   adds the domain accessors `phase` / `phases` and nothing else.
+* - **Positional store.** `append` adds one live {@link PhaseInterface} at the end, `phase(id)`
+*   looks one up, `phases()` lists them in positional order, `count` is the tally. A snapshot
+*   RESTORE re-`append`s in the snapshot's order, reproducing it exactly.
+* - **Gated mutation API.** `add` / `remove` / `move` / `update` are the graceful
+*   `Result` counterparts to `append`, gating ONLY on the target's OWN existence/status/id/bounds
+*   — a duplicate id, an absent/non-`pending` target, an out-of-bounds `index`, or a patch that
+*   fails {@link phaseUpdateShape} validation all fail gracefully with a `MUTATION`
+*   {@link WorkflowError} instead of throwing.
+* - **No batch matrix.** A workflow's phases are a fixed positional set, so the batch verbs of
+*   `.claude/rules/patterns.md` § Batch operations are
+*   deliberately omitted.
+* - **Event-free.** A purely structural container — the live {@link PhaseInterface}s own their own
+*   emitters.
 *
 * @example
 * ```ts
@@ -2193,58 +2635,37 @@ var Phase = class {
 * ```
 */
 var PhaseManager = class {
-	#phases = /* @__PURE__ */ new Map();
-	#isUpdate = compileGuard(phaseUpdateShape);
+	#phases = new Collection("phase", compileGuard(phaseUpdateShape));
 	get count() {
-		return this.#phases.size;
+		return this.#phases.count;
 	}
 	append(phase) {
-		if (this.#phases.has(phase.id)) throw new WorkflowError("MUTATION", `duplicate phase id '${phase.id}'`, { id: phase.id });
-		this.#phases.set(phase.id, phase);
+		this.#phases.append(phase);
 	}
 	add(phase, index) {
-		if (this.#phases.has(phase.id)) return failure(new WorkflowError("MUTATION", `duplicate phase id '${phase.id}'`, { id: phase.id }));
-		const at = index ?? this.#phases.size;
-		if (at < 0 || at > this.#phases.size) return failure(new WorkflowError("MUTATION", `index '${at}' out of bounds`, { index: at }));
-		this.#reorder(insertEntry([...this.#phases.entries()], at, phase.id, phase));
-		return success(phase);
+		return this.#phases.add(phase, index);
 	}
 	remove(id) {
-		const target = this.#phases.get(id);
-		if (target === void 0 || target.status !== "pending") return failure(new WorkflowError("MUTATION", `phase '${id}' is not a pending phase`, { id }));
-		this.#phases.delete(id);
-		return success(target);
+		return this.#phases.remove(id);
 	}
 	move(id, index) {
-		const target = this.#phases.get(id);
-		if (target === void 0 || target.status !== "pending") return failure(new WorkflowError("MUTATION", `phase '${id}' is not a pending phase`, { id }));
-		if (index < 0 || index >= this.#phases.size) return failure(new WorkflowError("MUTATION", `index '${index}' out of bounds`, { index }));
-		this.#reorder(moveEntry([...this.#phases.entries()], id, index));
-		return success(target);
+		return this.#phases.move(id, index);
 	}
 	update(id, patch) {
-		const target = this.#phases.get(id);
-		if (target === void 0 || target.status !== "pending") return failure(new WorkflowError("MUTATION", `phase '${id}' is not a pending phase`, { id }));
-		if (!this.#isUpdate(patch)) return failure(new WorkflowError("MUTATION", `invalid patch for phase '${id}'`, { id }));
-		target.patch(patch);
-		return success(target);
+		return this.#phases.update(id, patch);
 	}
 	phase(id) {
-		return this.#phases.get(id);
+		return this.#phases.entry(id);
 	}
 	phases() {
-		return [...this.#phases.values()];
-	}
-	#reorder(entries) {
-		this.#phases.clear();
-		for (const [key, value] of entries) this.#phases.set(key, value);
+		return this.#phases.entries();
 	}
 };
 //#endregion
 //#region src/core/Workflow.ts
 /**
-* The live DERIVED state machine (W-b) for a whole workflow — the observable (AGENTS §13)
-* ROOT whose {@link WorkflowStatus} is computed from its phases under the `bail` policy and
+* Implements the live DERIVED state machine (W-b) for a whole workflow — the observable ROOT
+* whose {@link LifecycleStatus} is computed from its phases under the `bail` policy and
 * recomputed reactively as the cascade propagates up from a task transition.
 *
 * @remarks
@@ -2257,7 +2678,7 @@ var PhaseManager = class {
 *   reachable ONLY under `bail: true` (a single failed task halts the workflow); under
 *   `bail: false` a failed phase folds into `completed`. `#recompute` diffs on each phase
 *   change; a CHANGE emits.
-* - **Override (AGENTS §10).** `skip` / `stop` FORCE the status; an executed task-free pending tree
+* - **Override.** `skip` / `stop` FORCE the status; an executed task-free pending tree
 *   may also be force-completed vacuously. The override is PERSISTED in the snapshot's own
 *   `override` field and restored DIRECTLY (no divergence guess). The snapshot also persists
 *   `bail`, so a restore re-derives status identically without a silent policy default.
@@ -2266,12 +2687,12 @@ var PhaseManager = class {
 *   navigate UP.
 * - **Snapshot.** `snapshot()` serializes the whole live tree to a {@link WorkflowSnapshot} (pure
 *   JSON); {@link import('./factories.js').createRestoredWorkflow} rebuilds an equivalent live tree.
-* - **Observable (AGENTS §13).** The owned {@link emitter} ({@link WorkflowEventMap}) fires
+* - **Observable.** The owned {@link emitter} ({@link WorkflowEventMap}) fires
 *   `start` / `complete` / `fail` / `pause` / `resume` / `skip` / `stop` after the
 *   corresponding status or runtime-gate change; the emitter isolates a listener throw and
 *   routes it to its `error` handler (the `error` option); `fail` carries the failing task's
 *   {@link TaskResult}.
-* - **Structural API (AGENTS §7).** `add` / `remove` / `move` / `update` gate BEFORE
+* - **Structural API.** `add` / `remove` / `move` / `update` gate BEFORE
 *   delegating to {@link phases} (the manager gates the target's own existence/status/id/
 *   bounds), then emit the matching {@link WorkflowEventMap} event on success only. NATIVE,
 *   bottom-up gating (no runner-installed hook): refused outright while this workflow's own
@@ -2280,12 +2701,27 @@ var PhaseManager = class {
 *   {@link import('./helpers.js').deriveBoundary} over the live phases' statuses. A `pending`
 *   workflow's phases are all `pending`, so the boundary is `0` and every position is
 *   naturally accepted.
-* - **Runtime lifecycle (AGENTS §10).** `pause` / `resume` / `wait` gate execution at the runner's
+* - **Runtime lifecycle.** `pause` / `resume` / `wait` gate execution at the runner's
 *   phase/task boundaries WITHOUT touching {@link status} — `paused` is runtime-only, never
 *   persisted. `destroy` is a terminal teardown: it `stop`s every non-terminal task and
 *   phase (releasing their gates and liveness resources), aborts {@link signal}, forces the
 *   workflow `stop` override when needed, releases its parked waiter, and marks
 *   {@link destroyed} — all idempotent.
+*
+* @example
+* ```ts
+* import { definitionToSnapshot, Workflow } from '@orkestrel/workflow'
+*
+* const definition = {
+* 	id: 'release',
+* 	name: 'Release',
+* 	phases: [{ id: 'build', name: 'Build', tasks: [{ id: 'compile', name: 'Compile' }] }],
+* }
+* const workflow = new Workflow(definitionToSnapshot(definition))
+* workflow.status // 'pending'
+* workflow.phase('build')?.task('compile')?.status // 'pending'
+* workflow.snapshot().id // 'release'
+* ```
 */
 var Workflow = class {
 	#context;
@@ -2312,7 +2748,6 @@ var Workflow = class {
 		const functions = captured.functions;
 		const silence = captured.silence;
 		this.#context = buildWorkflowContext(snapshot);
-		if (snapshot.description !== void 0) Object.defineProperty(this, "description", { value: snapshot.description });
 		this.#bail = bail ?? snapshot.bail;
 		this.#bailOverride = bail;
 		this.#functions = functions;
@@ -2343,6 +2778,9 @@ var Workflow = class {
 	get name() {
 		return this.#context.name;
 	}
+	get description() {
+		return this.#context.description;
+	}
 	get context() {
 		return this.#context;
 	}
@@ -2386,7 +2824,7 @@ var Workflow = class {
 	pause() {
 		if (this.#paused || isTerminalStatus(this.status) || this.#destroyed) return;
 		this.#paused = true;
-		this.#gate = createDeferred();
+		this.#gate = Promise.withResolvers();
 		this.#emitter.emit("pause");
 	}
 	resume() {
@@ -2474,7 +2912,7 @@ var Workflow = class {
 		return cloneWorkflowSnapshot({
 			id: this.id,
 			name: this.name,
-			...this.description === void 0 ? {} : { description: this.description },
+			...this.#context.description === void 0 ? {} : { description: this.#context.description },
 			status: this.status,
 			...this.#override === void 0 ? {} : { override: this.#override },
 			bail: this.#bail,
@@ -2518,7 +2956,7 @@ var Workflow = class {
 	}
 	#failure() {
 		const found = findFailure(this.results());
-		if (found === void 0) throw new Error(`workflow '${this.id}' derived failed with no failing task result`);
+		if (found === void 0) throw new WorkflowError("INVARIANT", `workflow '${this.id}' derived failed with no failing task result`, { workflow: this.id });
 		return found;
 	}
 	#append(phase, options) {
@@ -2543,14 +2981,15 @@ var Workflow = class {
 //#endregion
 //#region src/core/WorkflowManager.ts
 /**
-* The store-backed registry of {@link WorkflowInterface}s keyed by `id`, in insertion order —
+* Implements the store-backed registry of {@link WorkflowInterface}s keyed by `id`, in insertion order —
 * the additive manager tier mirroring the `@orkestrel/agent` line's `ConversationManager` /
 * `WorkspaceManager`. Event-free (a registry, like its twins); the observability lives on each
 * {@link WorkflowInterface}.
 *
 * @remarks
 * - **Registry.** Workflows live in an insertion-ordered `Map` keyed by `id`. `add(definition)`
-*   mints a live {@link WorkflowInterface} through {@link createWorkflow} (flowing the manager's
+*   mints a live {@link WorkflowInterface} through the same construction path
+*   {@link import('./factories.js').createWorkflow} takes (flowing the manager's
 *   `functions` registry in) and stores it under `definition.id` — an already-present id
 *   OVERWRITES (last write wins). `count` is the map size, `workflow(id)` looks one up,
 *   `workflows()` lists them in insertion order.
@@ -2559,8 +2998,8 @@ var Workflow = class {
 *   earlier reads; wrong-key payloads reject with `RESTORE`. `save(id)` captures a registered
 *   workflow's snapshot at invocation and serializes same-id writes without coupling other ids.
 *   Both remain lenient without a store or registered id.
-* - **Removal.** `remove` drops one by id, or a batch (§9.2, array overload FIRST) — `true` when
-*   any was removed. `clear` empties the registry.
+* - **Removal.** `remove` drops one by id, or a batch (array overload FIRST) — `true` only when
+*   every id was removed. `clear` empties the registry.
 * - **No active pointer.** Unlike its `ConversationManager` / `WorkspaceManager` twins, there is
 *   no `active` / `switch` — nothing in the workflow domain renders "the current workflow".
 *
@@ -2598,7 +3037,7 @@ var WorkflowManager = class {
 		return [...this.#workflows.values()];
 	}
 	add(definition) {
-		const workflow = createWorkflow(definition, { ...this.#functions === void 0 ? {} : { functions: this.#functions } });
+		const workflow = this.#build(definition);
 		const mutation = this.#invalidate(workflow.id);
 		if (mutation === void 0) this.#additions.delete(workflow.id);
 		else this.#additions.set(workflow.id, mutation);
@@ -2635,11 +3074,11 @@ var WorkflowManager = class {
 	}
 	remove(ids) {
 		if (isArray(ids)) {
-			let removed = false;
+			let removed = true;
 			for (const id of ids) {
 				this.#invalidate(id);
 				this.#additions.delete(id);
-				if (this.#workflows.delete(id)) removed = true;
+				if (!this.#workflows.delete(id)) removed = false;
 			}
 			return removed;
 		}
@@ -2669,7 +3108,7 @@ var WorkflowManager = class {
 			if (!this.#owns(id, mutation, generation)) return this.#resolve(id, generation);
 			let workflow;
 			try {
-				workflow = createRestoredWorkflow(owned, { ...this.#functions === void 0 ? {} : { functions: this.#functions } });
+				workflow = this.#restore(owned);
 			} catch (error) {
 				if (!this.#owns(id, mutation, generation)) return this.#resolve(id, generation);
 				throw error;
@@ -2680,6 +3119,15 @@ var WorkflowManager = class {
 			this.#releaseHydration(id, lease);
 		}
 	}
+	#build(definition) {
+		return createWorkflowTree(definition, this.#captured());
+	}
+	#restore(snapshot) {
+		return new Workflow(cloneWorkflowSnapshot(snapshot), this.#captured());
+	}
+	#captured() {
+		return captureWorkflowOptions(this.#functions === void 0 ? {} : { functions: this.#functions });
+	}
 	#owns(id, mutation, generation) {
 		return this.#generation === generation && this.#mutations.get(id) === mutation;
 	}
@@ -2735,9 +3183,50 @@ var WorkflowManager = class {
 	}
 };
 //#endregion
+//#region src/core/RunHolder.ts
+/**
+* Holds the active phase {@link RunnerInterface} for one
+* {@link import('./types.js').WorkflowRunnerInterface.execute} call, for the lifetime of that run.
+*
+* @remarks
+* - **One holder per run.** The engine mints a holder as a run begins and threads that one
+*   instance through every phase of the run, so a nested `execute` reached through application
+*   composition gets its own holder and can never clobber the suspended outer run's.
+* - **`hold` is the only mutation.** A phase takes the substrate runner with `hold(runner)` as it
+*   starts and releases it with `hold()` as it settles; `runner` reads the held value back and is
+*   `undefined` between phases and after the last one.
+* - **A cancel closes over the holder.** The run-level abort listener reads `runner` when it
+*   fires, so it reaches whichever phase runner is live at that moment rather than the one that
+*   was live when the listener was armed.
+* - **Event-free.** A plain cell — no emitter, no lifecycle of its own.
+*/
+var RunHolder = class {
+	#runner;
+	get runner() {
+		return this.#runner;
+	}
+	/**
+	* Takes the phase runner a starting phase hands this run, or releases the held one.
+	*
+	* @param runner - The phase runner to hold; omitted releases the held runner
+	* @example
+	* ```ts
+	* import type { TaskInterface } from '@orkestrel/workflow'
+	* import { createRunner, RunHolder } from '@orkestrel/workflow'
+	*
+	* const holder = new RunHolder()
+	* holder.hold(createRunner<TaskInterface, void>({ handler: () => undefined }))
+	* holder.hold() // released — `runner` reads `undefined` again
+	* ```
+	*/
+	hold(runner) {
+		this.#runner = runner;
+	}
+};
+//#endregion
 //#region src/core/Controller.ts
 /**
-* The per-unit handle a runner handler receives — wraps the unit's identity,
+* Implements the per-unit handle a runner handler receives — wraps the unit's identity,
 * input, cancellation, and the run controls (`wait` / `spawn` / `abort`).
 *
 * @remarks
@@ -2749,10 +3238,10 @@ var WorkflowManager = class {
 *   unit's own abort, the runner-level abort (the runner aborts every unit), and
 *   the per-attempt timeout — so it fires on any of the three. `aborted` and
 *   `abort(reason)` delegate to the unit's `Abort` (the cancellation source of
-*   truth); since the attempt signal ANY-includes that abort, `abort()` fires
+*   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) via a one-shot listener — no
+*   `signal` fires (immediately if already aborted) through a one-shot listener — no
 *   `setTimeout`, no polling, no busy-yield — so a parked unit costs no CPU.
 * - **`spawn` is fire-and-track.** It delegates to the runner's launch-a-sibling
 *   callback, which routes the sibling through the queue; the runner's `execute`
@@ -2763,23 +3252,32 @@ var WorkflowManager = class {
 *   {@link RunnerInterface.emitter} instead (`unit` / `spawn` / `settle` / `fail` carry the id).
 */
 var Controller = class {
-	id;
-	input;
-	signal;
+	#id;
+	#input;
+	#signal;
 	#abort;
 	#spawn;
 	constructor(id, input, abort, signal, spawn) {
-		this.id = id;
-		this.input = input;
+		this.#id = id;
+		this.#input = input;
 		this.#abort = abort;
-		this.signal = signal;
+		this.#signal = signal;
 		this.#spawn = spawn;
 	}
+	get id() {
+		return this.#id;
+	}
+	get input() {
+		return this.#input;
+	}
+	get signal() {
+		return this.#signal;
+	}
 	get aborted() {
 		return this.#abort.aborted;
 	}
 	wait() {
-		return parkSignal(this.signal);
+		return parkSignal(this.#signal);
 	}
 	spawn(input) {
 		return this.#spawn(input);
@@ -2791,7 +3289,7 @@ var Controller = class {
 //#endregion
 //#region src/core/Runner.ts
 /**
-* A thin generic orchestrator that drives declared units — and any they `spawn` —
+* Implements a thin generic orchestrator that drives declared units — and any they `spawn` —
 * through a bounded-concurrency {@link createQueue}, collecting ordered results.
 *
 * @remarks
@@ -2805,12 +3303,12 @@ var Controller = class {
 *   Results are read back as `#order.map(id => #values.get(id))` — declared first (in
 *   input order), then spawns (in spawn order). There is no one-time task snapshot,
 *   so a unit spawned mid-handler is run and ordered like any other.
-* - **`execute` awaits the full spawn closure via a count gate.** `#launch` increments
+* - **`execute` awaits the full spawn closure through a count gate.** `#launch` increments
 *   an outstanding-unit `#count` BEFORE enqueuing and every settle decrements it,
 *   resolving the `#drained` deferred at zero. Because `spawn` calls `#launch` (so
 *   `#count += 1`) before the parent handler returns, the count never reaches zero
 *   mid-run — `execute` parks on `#drained` and so awaits the entire transitive
-*   closure, not just the declared units.
+*   closure, not only the declared units.
 * - **`spawn` is fire-and-track.** A spawned unit runs through the queue regardless of
 *   whether its promise is awaited; the Runner never awaits a spawned promise from
 *   within a handler's slot (it awaits the count gate instead), so a slot-holding
@@ -2824,16 +3322,16 @@ var Controller = class {
 *   unit failure (after its retries) records the error and `abort()`s the run, so every
 *   sibling's signal fires; later failures are ignored and `execute` rejects with the
 *   first error. A user `abort(reason)` likewise rejects a running `execute`.
-* - **`pause` / `resume` / `stop` (§10) ride the backing Queue.** `pause` / `resume`
+* - **`pause` / `resume` / `stop` ride the backing Queue.** `pause` / `resume`
 *   delegate straight to the Queue's own pause/resume (holding/releasing the NEXT
 *   dispatch while an in-flight unit finishes); `paused` mirrors the Queue's. `stop` is a
 *   GRACEFUL permanent end, distinct from `abort`: still-pending (never-dispatched)
 *   units are rejected by the Queue's own stop WITHOUT their handler ever running, and
 *   `#settle` reads that fact (`#dispatched`) to treat the rejection as a stop artifact —
 *   not a failure, never tripping fail-fast — while an in-flight unit still runs to
-*   completion and settles normally. `execute` RESOLVES (never rejects) once every unit
+*   completion and settles normally. `execute` RESOLVES (never rejects) after every unit
 *   has settled, with whatever results actually completed.
-* - **Observable (§13).** The owned {@link emitter} ({@link RunnerEventMap}) carries the run
+* - **Observable.** The owned {@link emitter} ({@link RunnerEventMap}) carries the run
 *   lifecycle — `start` / `unit` / `spawn` / `settle` / `fail` / `finish` / `abort` — for
 *   fire-and-forget observers. Every event is emitted directly, strictly AFTER the relevant
 *   launch / settle / drain transition; the emitter isolates a listener throw and routes it
@@ -2896,20 +3394,20 @@ var Runner = class {
 		return this.#queue.paused;
 	}
 	/**
-	* Inject one more unit into an IN-FLIGHT `execute` run — a LIVE counterpart to a
+	* Injects one more unit into an IN-FLIGHT `execute` run — a LIVE counterpart to a
 	* `Controller.spawn`, called from OUTSIDE any unit's handler.
 	*
 	* @remarks
-	* Returns `undefined` synchronously (graceful, non-throwing — AGENTS §12) unless the
-	* runner is currently mid-`execute` and not yet stopped — covering "never started",
+	* Returns `undefined` synchronously (graceful, non-throwing) unless the
+	* runner is mid-`execute` and not yet stopped — covering "never started",
 	* "already drained", "aborted", and "destroyed". Otherwise the unit is routed through
-	* the SAME backing queue as a declared/`spawn`ed unit via `#launch` — the outstanding-
+	* the SAME backing queue as a declared/`spawn`ed unit through `#launch` — the outstanding-
 	* unit count gate increments BEFORE this call returns, so an in-flight `execute`
 	* keeps awaiting it (the drain race: `#running` flips to `false` as the very first
 	* step after `execute`'s `await drained.promise` settles, so a `spawn` reaching this
 	* method after the run has fully drained is cleanly rejected with `undefined` —
 	* never silently dropped, never hangs `execute`). Emits {@link RunnerEventMap.spawn}
-	* with a `parent` of `undefined` (this call has no spawning unit) once accepted.
+	* with a `parent` of `undefined` (this call has no spawning unit) after acceptance.
 	*
 	* @param input - The unit's work payload
 	* @returns The unit's result promise, or `undefined` when no in-flight run can accept it
@@ -2926,11 +3424,11 @@ var Runner = class {
 		return this.#launch(input, void 0, true);
 	}
 	async execute(inputs) {
-		if (this.#started) throw new Error("runner has already executed");
-		if (this.#stopped) throw new Error("runner is stopped");
+		if (this.#started) throw new WorkflowError("TRANSITION", "runner has already executed", { started: true });
+		if (this.#stopped) throw new WorkflowError("TRANSITION", "runner is stopped", { stopped: true });
 		this.#started = true;
 		this.#running = true;
-		const drained = createDeferred();
+		const drained = Promise.withResolvers();
 		this.#drained = drained;
 		for (const input of inputs) {
 			if (!this.#accepts()) break;
@@ -2951,23 +3449,23 @@ var Runner = class {
 	}
 	abort(reason) {
 		if (this.#abortPromise !== void 0) return this.#abortPromise;
-		const barrier = createDeferred();
+		const barrier = Promise.withResolvers();
 		this.#abortPromise = barrier.promise;
 		barrier.promise.catch(() => {});
-		if (this.#running && this.#failure === void 0) this.#failure = { error: reason === void 0 ? /* @__PURE__ */ new Error("runner aborted") : reason };
+		if (this.#running && this.#failure === void 0) this.#failure = failure(reason === void 0 ? /* @__PURE__ */ new Error("runner aborted") : reason);
 		this.#cancel(reason);
 		this.#stopped = true;
 		const cleanup = this.#queue.abort(reason);
-		this.#settleLifecycle(barrier, cleanup);
+		this.#settleBarrier(barrier, cleanup, false);
 		this.#emitter.emit("abort", reason);
 		return barrier.promise;
 	}
 	/**
-	* Suspend dispatch (AGENTS §10 — resumable): delegates to the backing queue's own
+	* Suspends dispatch (resumable): delegates to the backing queue's own
 	* `pause`, which holds the NEXT dispatch while any in-flight unit finishes.
 	*
 	* @remarks
-	* A no-op once the runner is `stopped` — a stopped runner has no dispatch left to
+	* A no-op after the runner is `stopped` — a stopped runner has no dispatch left to
 	* suspend, mirroring the guard `stop()` itself applies. Also a no-op when already
 	* `paused` (the queue's own `pause` is idempotent), so calling it repeatedly is safe.
 	*/
@@ -2976,11 +3474,11 @@ var Runner = class {
 		this.#queue.pause();
 	}
 	/**
-	* Continue a paused runner (AGENTS §10); delegates to the backing queue's `resume`.
+	* Continues a paused runner; delegates to the backing queue's `resume`.
 	*
 	* @remarks
-	* A no-op once the runner is `stopped` (nothing left to resume) and a no-op when the
-	* runner is not currently `paused`, so calling it repeatedly or on a never-paused
+	* A no-op after the runner is `stopped` (nothing left to resume) and a no-op when the
+	* runner is not `paused`, so calling it repeatedly or on a never-paused
 	* runner is safe.
 	*/
 	resume() {
@@ -2988,7 +3486,7 @@ var Runner = class {
 		this.#queue.resume();
 	}
 	/**
-	* Permanently end the runner (AGENTS §10) — a GRACEFUL stop, distinct from `abort`.
+	* Ends the runner permanently — a GRACEFUL stop, distinct from `abort`.
 	* Marks the runner `stopping` + `stopped`, then stops the backing queue: every
 	* still-PENDING (never-dispatched) unit is rejected by the queue with its own
 	* "queue is stopped" error, WITHOUT running its handler; every already-in-flight unit
@@ -3001,24 +3499,24 @@ var Runner = class {
 		if (this.#destroyPromise !== void 0) return this.#destroyPromise;
 		if (this.#abortPromise !== void 0) return this.#abortPromise;
 		if (this.#stopPromise !== void 0) return this.#stopPromise;
-		const barrier = createDeferred();
+		const barrier = Promise.withResolvers();
 		this.#stopPromise = barrier.promise;
 		barrier.promise.catch(() => {});
 		this.#stopping = true;
 		this.#stopped = true;
 		const cleanup = this.#queue.stop();
-		this.#settleLifecycle(barrier, cleanup);
+		this.#settleBarrier(barrier, cleanup, false);
 		return barrier.promise;
 	}
 	destroy() {
 		if (this.#destroyPromise !== void 0) return this.#destroyPromise;
-		const barrier = createDeferred();
+		const barrier = Promise.withResolvers();
 		this.#destroyPromise = barrier.promise;
 		barrier.promise.catch(() => {});
 		this.#stopped = true;
 		this.abort();
 		const cleanup = this.#queue.destroy();
-		this.#settleDestroy(barrier, cleanup);
+		this.#settleBarrier(barrier, cleanup, true);
 		return barrier.promise;
 	}
 	#launch(input, parent, announce = parent !== void 0) {
@@ -3046,33 +3544,27 @@ var Runner = class {
 		} catch (error) {
 			promise = Promise.reject(error);
 		}
-		promise.then((value) => this.#settle(id, {
-			ok: true,
-			value
-		}), (error) => this.#settle(id, {
-			ok: false,
-			error
-		}));
+		promise.then((value) => this.#settle(id, success(value)), (error) => this.#settle(id, failure(error)));
 		return promise;
 	}
-	#dispatch(unit, execution) {
+	#dispatch(unit, context) {
 		const abort = this.#aborts.get(unit.id);
-		if (abort === void 0) throw new Error("unit abort missing");
+		if (abort === void 0) throw new WorkflowError("INVARIANT", "unit abort missing", { unit: unit.id });
 		this.#dispatched.add(unit.id);
-		const controller = new Controller(unit.id, unit.input, abort, execution.signal, (input) => this.#spawn(input, unit.id));
+		const controller = new Controller(unit.id, unit.input, abort, context.signal, (input) => this.#spawn(input, unit.id));
 		this.#emitter.emit("unit", unit.id);
 		return this.#handler(controller);
 	}
 	#spawn(input, parent) {
-		if (!this.#accepts()) throw new Error("spawn is unavailable outside an active run");
+		if (!this.#accepts()) throw new WorkflowError("TRANSITION", "spawn is unavailable outside an active run", { parent });
 		return this.#launch(input, parent);
 	}
 	#settle(id, outcome) {
-		if (outcome.ok) {
-			this.#values.set(id, { value: outcome.value });
+		if (outcome.success) {
+			this.#values.set(id, outcome);
 			this.#emitter.emit("settle", id);
 		} else if (this.#stopping && this.#queued.has(id) && !this.#dispatched.has(id)) {} else if (this.#failure === void 0) {
-			this.#failure = { error: outcome.error };
+			this.#failure = failure(outcome.error);
 			this.#emitter.emit("fail", id, outcome.error);
 			this.abort(outcome.error);
 		}
@@ -3097,31 +3589,20 @@ var Runner = class {
 			await cleanup;
 			return;
 		} catch (error) {
-			return { error };
+			return failure(error);
 		}
 	}
-	async #settleLifecycle(barrier, cleanup) {
-		let failure;
+	async #settleBarrier(barrier, cleanup, teardown) {
+		let cleanupFailure;
 		try {
 			await cleanup;
 		} catch (error) {
-			failure = { error };
+			cleanupFailure = failure(error);
 		}
 		await this.#waitDrain();
-		if (failure === void 0) barrier.resolve();
-		else barrier.reject(failure.error);
-	}
-	async #settleDestroy(barrier, cleanup) {
-		let failure;
-		try {
-			await cleanup;
-		} catch (error) {
-			failure = { error };
-		}
-		await this.#waitDrain();
-		this.#emitter.destroy();
-		if (failure === void 0) barrier.resolve();
-		else barrier.reject(failure.error);
+		if (teardown) this.#emitter.destroy();
+		if (cleanupFailure === void 0) barrier.resolve();
+		else barrier.reject(cleanupFailure.error);
 	}
 	async #waitDrain() {
 		if (this.#count === 0) return;
@@ -3134,7 +3615,7 @@ var Runner = class {
 //#endregion
 //#region src/core/tasks/TaskController.ts
 /**
-* The attempt-scoped handle a {@link import('./types.js').WorkflowFunction} receives.
+* 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
@@ -3157,26 +3638,38 @@ var Runner = class {
 *   observe the W-b entities' own emitters (`task.emitter` / `phase.emitter`) instead.
 */
 var TaskController = class {
-	signal;
-	input;
-	task;
-	attempt;
+	#signal;
+	#input;
+	#task;
+	#attempt;
 	#entity;
 	#report;
 	#pulse;
 	#results;
 	constructor(signal, input, task, attempt, results, report, pulse) {
-		this.signal = signal;
-		this.input = input;
-		this.task = task.context;
-		this.attempt = attempt;
+		this.#signal = signal;
+		this.#input = input;
+		this.#task = task.context;
+		this.#attempt = attempt;
 		this.#entity = task;
 		this.#results = results;
 		this.#report = report;
 		this.#pulse = pulse;
 	}
+	get signal() {
+		return this.#signal;
+	}
+	get input() {
+		return this.#input;
+	}
+	get task() {
+		return this.#task;
+	}
+	get attempt() {
+		return this.#attempt;
+	}
 	get aborted() {
-		return this.signal.aborted;
+		return this.#signal.aborted;
 	}
 	get paused() {
 		if (this.#ancestorTerminal()) return false;
@@ -3189,7 +3682,7 @@ var TaskController = class {
 		return this.#pulse();
 	}
 	async wait() {
-		while (this.paused && !this.signal.aborted) await this.#race(this.#gates());
+		while (this.paused && !this.#signal.aborted) await this.#race(this.#gates());
 	}
 	results() {
 		return this.#results();
@@ -3203,11 +3696,11 @@ var TaskController = class {
 		return gates;
 	}
 	async #race(gates) {
-		if (this.signal.aborted || gates.length === 0) return;
+		if (this.#signal.aborted || gates.length === 0) return;
 		const deferred = Promise.withResolvers();
 		const onAbort = this.#resolve.bind(this, deferred);
 		const onTerminal = this.#resolve.bind(this, deferred);
-		this.signal.addEventListener("abort", onAbort, { once: true });
+		this.#signal.addEventListener("abort", onAbort, { once: true });
 		this.#entity.workflow.emitter.on("skip", onTerminal);
 		this.#entity.workflow.emitter.on("stop", onTerminal);
 		this.#entity.phase.emitter.on("skip", onTerminal);
@@ -3216,7 +3709,7 @@ var TaskController = class {
 			if (this.#ancestorTerminal()) deferred.resolve();
 			await Promise.race([Promise.all(gates), deferred.promise]);
 		} finally {
-			this.signal.removeEventListener("abort", onAbort);
+			this.#signal.removeEventListener("abort", onAbort);
 			this.#entity.workflow.emitter.off("skip", onTerminal);
 			this.#entity.workflow.emitter.off("stop", onTerminal);
 			this.#entity.phase.emitter.off("skip", onTerminal);
@@ -3233,24 +3726,33 @@ var TaskController = class {
 //#endregion
 //#region src/core/WorkflowPersistence.ts
 /**
-* Advanced run-local snapshot persistence with one writer and one coalesced latest obligation.
+* Coordinates advanced run-local snapshot persistence with one writer and one coalesced most recent obligation.
 *
 * @remarks
 * Normally composed by `WorkflowRunner.execute({ store })`; exported for hosts that need to
 * coordinate the same required boundaries around their own runner integration.
+*
+* @example
+* ```ts
+* import { WorkflowPersistence, createMemoryWorkflowStore, createWorkflow } from '@orkestrel/workflow'
+*
+* const workflow = createWorkflow({ id: 'durable', name: 'Durable', phases: [] })
+* const persistence = new WorkflowPersistence(workflow, createMemoryWorkflowStore())
+* await persistence.checkpoint('initial')
+* const durable = await persistence.finalize()
+* persistence.detach() // idempotent after finalize
+* ```
 */
 var WorkflowPersistence = class {
 	#workflow;
 	#store;
 	#phases = /* @__PURE__ */ new Set();
 	#tasks = /* @__PURE__ */ new Set();
-	#onWorkflowChange;
+	#onChange;
 	#onWorkflowAdd;
 	#onWorkflowRemove;
-	#onPhaseChange;
 	#onPhaseAdd;
 	#onPhaseRemove;
-	#onTaskChange;
 	#writing;
 	#error;
 	#fault;
@@ -3260,32 +3762,29 @@ var WorkflowPersistence = class {
 	constructor(workflow, store) {
 		this.#workflow = workflow;
 		this.#store = store;
-		this.#onWorkflowChange = this.#change.bind(this);
+		this.#onChange = this.#change.bind(this);
 		this.#onWorkflowAdd = this.#addPhase.bind(this);
 		this.#onWorkflowRemove = this.#removePhase.bind(this);
-		this.#onPhaseChange = this.#change.bind(this);
 		this.#onPhaseAdd = this.#addTask.bind(this);
 		this.#onPhaseRemove = this.#removeTask.bind(this);
-		this.#onTaskChange = this.#change.bind(this);
 		this.#attachWorkflow();
 	}
 	get fault() {
 		return this.#fault;
 	}
 	/**
-	* Persist every change through this required boundary.
+	* Persists every change through this required boundary.
 	*
 	* @param checkpoint - The boundary being made durable
 	* @param task - The task owning an attempt or settlement
 	* @param attempt - The persisted attempt number
-	* @returns Whether the latest state reached the store
+	* @returns True if the most recent state reached the store; false otherwise
 	*/
 	async checkpoint(checkpoint, task, attempt) {
 		const revision = this.#mark();
 		while (this.#stored < revision) await this.#flush();
 		if (this.#error === void 0) return true;
 		if (this.#fault === void 0) this.#fault = Object.freeze({
-			origin: "persistence",
 			checkpoint,
 			message: this.#error,
 			...task === void 0 ? {} : { task: task.id },
@@ -3294,37 +3793,25 @@ var WorkflowPersistence = class {
 		return false;
 	}
 	/**
-	* Stop observing the live tree and persist its final state.
+	* Stops observing the live tree and persists its final state.
 	*
-	* @returns Whether the final snapshot reached the store
+	* @returns True if the final snapshot reached the store; false otherwise
 	*/
 	async finalize() {
 		this.detach();
 		return this.checkpoint("final");
 	}
-	/** Stop observing the live tree. */
+	/** Stops observing the live tree. */
 	detach() {
 		if (!this.#attached) return;
 		this.#attached = false;
-		this.#workflow.emitter.off("start", this.#onWorkflowChange);
-		this.#workflow.emitter.off("complete", this.#onWorkflowChange);
-		this.#workflow.emitter.off("fail", this.#onWorkflowChange);
-		this.#workflow.emitter.off("skip", this.#onWorkflowChange);
-		this.#workflow.emitter.off("stop", this.#onWorkflowChange);
-		this.#workflow.emitter.off("move", this.#onWorkflowChange);
-		this.#workflow.emitter.off("update", this.#onWorkflowChange);
+		for (const event of PERSISTED_NODE_EVENTS) this.#workflow.emitter.off(event, this.#onChange);
 		this.#workflow.emitter.off("add", this.#onWorkflowAdd);
 		this.#workflow.emitter.off("remove", this.#onWorkflowRemove);
 		for (const phase of this.#phases) this.#detachPhase(phase);
 	}
 	#attachWorkflow() {
-		this.#workflow.emitter.on("start", this.#onWorkflowChange);
-		this.#workflow.emitter.on("complete", this.#onWorkflowChange);
-		this.#workflow.emitter.on("fail", this.#onWorkflowChange);
-		this.#workflow.emitter.on("skip", this.#onWorkflowChange);
-		this.#workflow.emitter.on("stop", this.#onWorkflowChange);
-		this.#workflow.emitter.on("move", this.#onWorkflowChange);
-		this.#workflow.emitter.on("update", this.#onWorkflowChange);
+		for (const event of PERSISTED_NODE_EVENTS) this.#workflow.emitter.on(event, this.#onChange);
 		this.#workflow.emitter.on("add", this.#onWorkflowAdd);
 		this.#workflow.emitter.on("remove", this.#onWorkflowRemove);
 		for (const phase of this.#workflow.phases.phases()) this.#attachPhase(phase);
@@ -3332,26 +3819,14 @@ var WorkflowPersistence = class {
 	#attachPhase(phase) {
 		if (this.#phases.has(phase)) return;
 		this.#phases.add(phase);
-		phase.emitter.on("start", this.#onPhaseChange);
-		phase.emitter.on("complete", this.#onPhaseChange);
-		phase.emitter.on("fail", this.#onPhaseChange);
-		phase.emitter.on("skip", this.#onPhaseChange);
-		phase.emitter.on("stop", this.#onPhaseChange);
-		phase.emitter.on("move", this.#onPhaseChange);
-		phase.emitter.on("update", this.#onPhaseChange);
+		for (const event of PERSISTED_NODE_EVENTS) phase.emitter.on(event, this.#onChange);
 		phase.emitter.on("add", this.#onPhaseAdd);
 		phase.emitter.on("remove", this.#onPhaseRemove);
 		for (const task of phase.tasks.tasks()) this.#attachTask(task);
 	}
 	#detachPhase(phase) {
 		if (!this.#phases.delete(phase)) return;
-		phase.emitter.off("start", this.#onPhaseChange);
-		phase.emitter.off("complete", this.#onPhaseChange);
-		phase.emitter.off("fail", this.#onPhaseChange);
-		phase.emitter.off("skip", this.#onPhaseChange);
-		phase.emitter.off("stop", this.#onPhaseChange);
-		phase.emitter.off("move", this.#onPhaseChange);
-		phase.emitter.off("update", this.#onPhaseChange);
+		for (const event of PERSISTED_NODE_EVENTS) phase.emitter.off(event, this.#onChange);
 		phase.emitter.off("add", this.#onPhaseAdd);
 		phase.emitter.off("remove", this.#onPhaseRemove);
 		for (const task of phase.tasks.tasks()) this.#detachTask(task);
@@ -3359,23 +3834,11 @@ var WorkflowPersistence = class {
 	#attachTask(task) {
 		if (this.#tasks.has(task)) return;
 		this.#tasks.add(task);
-		task.emitter.on("start", this.#onTaskChange);
-		task.emitter.on("complete", this.#onTaskChange);
-		task.emitter.on("fail", this.#onTaskChange);
-		task.emitter.on("skip", this.#onTaskChange);
-		task.emitter.on("stop", this.#onTaskChange);
-		task.emitter.on("report", this.#onTaskChange);
-		task.emitter.on("pulse", this.#onTaskChange);
+		for (const event of PERSISTED_TASK_EVENTS) task.emitter.on(event, this.#onChange);
 	}
 	#detachTask(task) {
 		if (!this.#tasks.delete(task)) return;
-		task.emitter.off("start", this.#onTaskChange);
-		task.emitter.off("complete", this.#onTaskChange);
-		task.emitter.off("fail", this.#onTaskChange);
-		task.emitter.off("skip", this.#onTaskChange);
-		task.emitter.off("stop", this.#onTaskChange);
-		task.emitter.off("report", this.#onTaskChange);
-		task.emitter.off("pulse", this.#onTaskChange);
+		for (const event of PERSISTED_TASK_EVENTS) task.emitter.off(event, this.#onChange);
 	}
 	#addPhase(phase) {
 		this.#attachPhase(phase);
@@ -3433,13 +3896,14 @@ var WorkflowPersistence = class {
 //#endregion
 //#region src/core/WorkflowRunner.ts
 /**
-* The thin orchestrator that EXECUTES a live W-b workflow tree by COMPOSING the shipped
+* Implements the thin orchestrator that EXECUTES a live W-b workflow tree by COMPOSING the shipped
 * substrate — phases sequential, tasks concurrent — dispatching each task through its OWN
 * resolved handler under the `bail` policy.
 *
 * @remarks
 * - **Composes, never re-implements.** Per-phase bounded concurrency is one
-*   {@link createRunner} per phase (the substrate {@link RunnerInterface} over the workers
+*   {@link createRunner} per phase (the substrate {@link import('./types.js').RunnerInterface}
+*   over the workers
 *   `Queue`); `bail` maps onto that Runner's fail-fast vs settle-all; the run-level abort /
 *   timeout / budget / entity `signal` fold through the `@orkestrel/abort` signal contract,
 *   {@link createTimeout}, and `AbortSignal.any` (exactly as the agent runtime folds its bounds);
@@ -3453,15 +3917,15 @@ var WorkflowPersistence = class {
 *   resolved its own {@link import('./types.js').WorkflowFunction} into
 *   {@link import('./types.js').TaskInterface.handler} ONCE at construction (build, restore,
 *   or a live mint all resolve it identically, from {@link WorkflowOptions.functions}), so
-*   dispatch is simply "invoke the task's own handler". Provider, protocol, and tool
+*   dispatch is "invoke the task's own handler". Provider, protocol, and tool
 *   integrations remain application-owned {@link import('./types.js').WorkflowFunction}s
 *   composed into {@link WorkflowOptions.functions}. This module imports none of them.
 * - **Two `execute` forms, one engine.** `execute(definition, options)` BUILDS the live tree
-*   from a {@link WorkflowDefinition} (single source of truth for the `run` / `concurrency`
+*   from a {@link WorkflowDefinition} (single source of truth for the `behavior` / `concurrency`
 *   metadata); `execute(workflow, options)` DRIVES a caller-owned, ALREADY-BUILT
-*   {@link WorkflowInterface} instead — the entity-native control surface (AGENTS §10:
-*   `pause` / `resume` / `add` / `stop` / `destroy` live on the entity itself). Both forms
-*   converge on the SAME `#execute` engine: neither reads a `WorkflowDefinition` once the tree
+*   {@link WorkflowInterface} instead — the entity-native control surface
+*   (`pause` / `resume` / `add` / `stop` / `destroy` live on the entity itself). Both forms
+*   converge on the SAME `#execute` engine: neither reads a `WorkflowDefinition` after the tree
 *   exists — `#runTask` reads each task's OWN {@link import('./types.js').TaskInterface.handler}
 *   / `retries` / `timeout`, and `#runPhase` reads each phase's OWN
 *   {@link PhaseInterface.concurrency} / `bail`, so a live `add`-minted phase or task (V5)
@@ -3475,7 +3939,7 @@ var WorkflowPersistence = class {
 *   for `spawn` to accept (the runner already drained) is swept `skip`ped afterward so the
 *   phase always reaches a coherent terminal state.
 * - **Dispatch by handler.** `#runTask` invokes the live task's own
-*   {@link import('./types.js').TaskInterface.handler} directly. An omitted `run` deliberately
+*   {@link import('./types.js').TaskInterface.handler} directly. An omitted `behavior` deliberately
 *   auto-completes with JSON `null`; a present unresolved name is rejected by the synchronous
 *   execution claim and never false-completes.
 * - **`bail` → substrate.** Under `bail: true` (halt) a genuine task failure `fail`s the leaf
@@ -3506,9 +3970,9 @@ var WorkflowPersistence = class {
 *   and the workflow is force-`stop`ped (settles `stopped`). Each task's
 *   {@link TaskController} signal `AbortSignal.any`-combines the substrate per-unit signal with
 *   `runSignal`, so a handler observes either cause directly.
-* - **Re-entrant-safe.** No shared per-run mutable field: the active-Runner holder is LOCAL to
-*   each `#execute`, so a nested application-level `execute` cannot clobber the outer run's
-*   state.
+* - **Re-entrant-safe.** No shared per-run mutable field: each `#execute` mints its own
+*   {@link import('./RunHolder.js').RunHolder}, so a nested application-level `execute` cannot
+*   clobber the outer run's state.
 */
 var WorkflowRunner = class WorkflowRunner {
 	static #executions = /* @__PURE__ */ new WeakSet();
@@ -3517,7 +3981,7 @@ var WorkflowRunner = class WorkflowRunner {
 		this.#scheduler = scheduler;
 	}
 	execute(target, options) {
-		if (this.#isWorkflow(target)) {
+		if (isWorkflowInterface(target)) {
 			const signal = options?.signal;
 			const timeout = options?.timeout;
 			const budget = options?.budget;
@@ -3530,7 +3994,7 @@ var WorkflowRunner = class WorkflowRunner {
 		const timeout = options?.timeout;
 		const budget = options?.budget;
 		const store = options?.store;
-		const workflow = new Workflow(definitionToSnapshot(target, captured.bail ?? target.bail ?? false), captured);
+		const workflow = createWorkflowTree(target, captured);
 		this.#acquire(workflow);
 		return this.#execute(workflow, signal, timeout, budget, store);
 	}
@@ -3544,7 +4008,7 @@ var WorkflowRunner = class WorkflowRunner {
 		WorkflowRunner.#executions.add(workflow);
 	}
 	async #execute(workflow, signal, ms, budget, store) {
-		const holder = { runner: void 0 };
+		const holder = new RunHolder();
 		let timeout;
 		let persistence;
 		let runSignal;
@@ -3559,7 +4023,7 @@ var WorkflowRunner = class WorkflowRunner {
 			if (runSignal.aborted) onCancel();
 			else runSignal.addEventListener("abort", onCancel, { once: true });
 			if (persistence !== void 0 && !await persistence.checkpoint("initial")) {
-				if (this.#stoppable(workflow)) workflow.stop();
+				if (isStoppable(workflow)) workflow.stop();
 				this.#skipFrom(workflow.phases.phases(), 0);
 			}
 			let index = 0;
@@ -3571,12 +4035,12 @@ var WorkflowRunner = class WorkflowRunner {
 					index += 1;
 					continue;
 				}
-				if (this.#cancelled(runSignal) || this.#halted(workflow)) {
+				if (runSignal.aborted || isHalted(workflow)) {
 					this.#haltFrom(phases, index, workflow, runSignal);
 					break;
 				}
 				if (workflow.paused) await this.#raceWait(workflow.wait(), runSignal, void 0, workflow);
-				if (this.#cancelled(runSignal) || this.#halted(workflow)) {
+				if (runSignal.aborted || isHalted(workflow)) {
 					this.#haltFrom(workflow.phases.phases(), index, workflow, runSignal);
 					break;
 				}
@@ -3591,10 +4055,10 @@ var WorkflowRunner = class WorkflowRunner {
 				}
 				index += 1;
 				const remaining = workflow.phases.phases();
-				if (index < remaining.length && !this.#cancelled(runSignal)) await this.#pace(runSignal);
+				if (index < remaining.length && !runSignal.aborted) await this.#pace(runSignal);
 			}
-			if (this.#cancelled(runSignal)) this.#haltFrom(workflow.phases.phases(), 0, workflow, runSignal);
-			else if (this.#completable(workflow)) workflow.complete();
+			if (runSignal.aborted) this.#haltFrom(workflow.phases.phases(), 0, workflow, runSignal);
+			else if (isCompletable(workflow)) workflow.complete();
 			const durable = await persistence?.finalize();
 			return {
 				workflow,
@@ -3604,7 +4068,7 @@ var WorkflowRunner = class WorkflowRunner {
 				...persistence?.fault === void 0 ? {} : { fault: persistence.fault }
 			};
 		} catch (error) {
-			if (this.#stoppable(workflow)) workflow.stop();
+			if (isStoppable(workflow)) workflow.stop();
 			this.#skipFrom(workflow.phases.phases(), 0);
 			await persistence?.finalize();
 			throw error;
@@ -3639,22 +4103,22 @@ var WorkflowRunner = class WorkflowRunner {
 				entries: this.#entry.bind(this),
 				handler: this.#runUnit.bind(this, workflow, runSignal, bail, attempts, owners, persistence)
 			});
-			holder.runner = created;
+			holder.hold(created);
 			try {
 				await created.execute(tasks);
 				return false;
 			} catch {
-				return !this.#cancelled(runSignal);
+				return !runSignal.aborted;
 			} finally {
 				try {
 					await created.destroy();
 				} finally {
-					holder.runner = void 0;
+					holder.hold();
 				}
 			}
 		} finally {
 			phase.emitter.off("add", onAdd);
-			if (this.#cancelled(runSignal) && this.#stoppable(workflow)) workflow.stop();
+			if (runSignal.aborted && isStoppable(workflow)) workflow.stop();
 			for (const task of phase.tasks.tasks()) this.#skip(task);
 		}
 	}
@@ -3678,7 +4142,7 @@ var WorkflowRunner = class WorkflowRunner {
 		attempts.set(task.id, attempt);
 		const last = attempt > Math.max(0, task.retries ?? 0);
 		if (task.status !== "pending" && task.status !== "running") return;
-		if (this.#skipping(task, controller, runSignal) || this.#halted(workflow, task.phase)) {
+		if (isSkipping(task, controller, runSignal) || isHalted(workflow, task.phase)) {
 			this.#settleCancelled(task, workflow, runSignal);
 			return;
 		}
@@ -3691,15 +4155,15 @@ var WorkflowRunner = class WorkflowRunner {
 			owners.set(task.id, attempt);
 			deadline?.start();
 			const durable = persistence === void 0 ? true : await persistence.checkpoint("attempt", task, attempt);
-			if (!this.#owns(owners, task, attempt)) return;
+			if (!ownsAttempt(owners, task, attempt)) return;
 			if (!durable) {
-				if (this.#stoppable(workflow)) workflow.stop();
+				if (isStoppable(workflow)) workflow.stop();
 				return;
 			}
-			if (task.run !== void 0 && task.handler === void 0) {
-				const error = new WorkflowError("TRANSITION", `task '${task.id}' has an unresolved run '${task.run}'`, {
+			if (task.behavior !== void 0 && task.handler === void 0) {
+				const error = new WorkflowError("TRANSITION", `task '${task.id}' has an unresolved behavior '${task.behavior}'`, {
 					task: task.id,
-					run: task.run
+					behavior: task.behavior
 				});
 				task.fail({
 					origin: "handler",
@@ -3711,21 +4175,21 @@ var WorkflowRunner = class WorkflowRunner {
 			if (await this.#gate(workflow.paused ? workflow.wait() : void 0, task, workflow, controller, runSignal, signal, attempts, owners, attempt, last, bail)) return;
 			if (await this.#gate(task.phase.paused ? task.phase.wait() : void 0, task, workflow, controller, runSignal, signal, attempts, owners, attempt, last, bail)) return;
 			if (await this.#gate(task.paused ? task.wait() : void 0, task, workflow, controller, runSignal, signal, attempts, owners, attempt, last, bail)) return;
-			if (this.#skipping(task, controller, runSignal) || this.#halted(workflow, task.phase)) {
+			if (isSkipping(task, controller, runSignal) || isHalted(workflow, task.phase)) {
 				this.#settleCancelled(task, workflow, runSignal);
 				return;
 			}
 			if (task.status !== "running") return;
-			const handle = new TaskController(signal, task.snapshot().metadata, task, attempt, () => workflow.results(), (input) => this.#owns(owners, task, attempt) && !signal.aborted ? task.report(input) : failure(new WorkflowError("TRANSITION", `task '${task.id}' attempt '${attempt}' no longer owns activity`, {
+			const handle = new TaskController(signal, task.snapshot().metadata, task, attempt, () => workflow.results(), (input) => ownsAttempt(owners, task, attempt) && !signal.aborted ? task.report(input) : failure(new WorkflowError("TRANSITION", `task '${task.id}' attempt '${attempt}' no longer owns activity`, {
 				task: task.id,
 				attempt
-			})), () => this.#owns(owners, task, attempt) && !signal.aborted && task.pulse());
+			})), () => ownsAttempt(owners, task, attempt) && !signal.aborted && task.pulse());
 			let outcome;
 			try {
-				outcome = task.handler === void 0 ? [true, null] : await this.#raceHandler(Promise.resolve(task.handler(handle)), signal, this.#skipping.bind(this, task, controller, runSignal));
+				outcome = task.handler === void 0 ? [true, null] : await this.#raceHandler(Promise.resolve(task.handler(handle)), signal, () => isSkipping(task, controller, runSignal));
 			} catch (error) {
-				if (!this.#owns(owners, task, attempt)) return;
-				if (task.status !== "running" || this.#skipping(task, controller, runSignal)) {
+				if (!ownsAttempt(owners, task, attempt)) return;
+				if (task.status !== "running" || isSkipping(task, controller, runSignal)) {
 					this.#settleCancelled(task, workflow, runSignal);
 					return;
 				}
@@ -3736,13 +4200,13 @@ var WorkflowRunner = class WorkflowRunner {
 				this.#failed(owners, task, attempt, error, last, bail);
 				return;
 			}
-			if (!this.#owns(owners, task, attempt)) return;
+			if (!ownsAttempt(owners, task, attempt)) return;
 			if (!outcome[0]) {
 				this.#settleAttempt(task, workflow, controller, runSignal, signal, attempts, owners, attempt, last, bail, outcome[2]);
 				return;
 			}
 			if (task.status !== "running") return;
-			if (this.#skipping(task, controller, runSignal)) {
+			if (isSkipping(task, controller, runSignal)) {
 				this.#settleCancelled(task, workflow, runSignal);
 				return;
 			}
@@ -3750,32 +4214,32 @@ var WorkflowRunner = class WorkflowRunner {
 				this.#timedOut(owners, task, attempt, last, bail);
 				return;
 			}
-			if (!this.#owns(owners, task, attempt)) return;
+			if (!ownsAttempt(owners, task, attempt)) return;
 			try {
 				task.complete(outcome[1]);
 			} catch (error) {
-				if (!this.#owns(owners, task, attempt)) return;
+				if (!ownsAttempt(owners, task, attempt)) return;
 				if (task.status !== "running") throw error;
 				this.#failed(owners, task, attempt, error, last, bail);
 			}
 		} finally {
 			deadline?.clear();
-			if (persistence !== void 0 && this.#owns(owners, task, attempt) && isTerminalStatus(task.status) && !await persistence.checkpoint("settlement", task, attempt) && this.#stoppable(workflow)) workflow.stop();
+			if (persistence !== void 0 && ownsAttempt(owners, task, attempt) && isTerminalStatus(task.status) && !await persistence.checkpoint("settlement", task, attempt) && isStoppable(workflow)) workflow.stop();
 			this.#revoke(owners, task.id, attempt);
 		}
 	}
 	async #gate(wait, task, workflow, controller, runSignal, signal, attempts, owners, attempt, last, bail) {
-		const genuine = wait === void 0 ? void 0 : await this.#raceWait(wait, signal, this.#skipping.bind(this, task, controller, runSignal), workflow, task.phase);
+		const genuine = wait === void 0 ? void 0 : await this.#raceWait(wait, signal, () => isSkipping(task, controller, runSignal), workflow, task.phase);
 		return this.#settleAttempt(task, workflow, controller, runSignal, signal, attempts, owners, attempt, last, bail, genuine);
 	}
 	#settleAttempt(task, workflow, controller, runSignal, signal, attempts, owners, attempt, last, bail, genuine) {
-		if (attempts.get(task.id) !== attempt || !this.#owns(owners, task, attempt)) return true;
+		if (attempts.get(task.id) !== attempt || !ownsAttempt(owners, task, attempt)) return true;
 		if (signal.aborted) {
-			if (genuine ?? this.#skipping(task, controller, runSignal)) this.#settleCancelled(task, workflow, runSignal);
+			if (genuine ?? isSkipping(task, controller, runSignal)) this.#settleCancelled(task, workflow, runSignal);
 			else this.#timedOut(owners, task, attempt, last, bail);
 			return true;
 		}
-		if (this.#skipping(task, controller, runSignal) || this.#halted(workflow, task.phase)) {
+		if (isSkipping(task, controller, runSignal) || isHalted(workflow, task.phase)) {
 			this.#settleCancelled(task, workflow, runSignal);
 			return true;
 		}
@@ -3804,7 +4268,7 @@ var WorkflowRunner = class WorkflowRunner {
 		]);
 	}
 	#timedOut(owners, task, attempt, last, bail) {
-		if (!this.#owns(owners, task, attempt)) return;
+		if (!ownsAttempt(owners, task, attempt)) return;
 		const error = /* @__PURE__ */ new Error(`task '${task.id}' timed out`);
 		if (last) task.fail({
 			origin: "timeout",
@@ -3813,7 +4277,7 @@ var WorkflowRunner = class WorkflowRunner {
 		if (!last || bail) throw error;
 	}
 	#failed(owners, task, attempt, error, last, bail) {
-		if (!this.#owns(owners, task, attempt)) return;
+		if (!ownsAttempt(owners, task, attempt)) return;
 		if (!last) throw error;
 		task.fail({
 			origin: "handler",
@@ -3821,9 +4285,6 @@ var WorkflowRunner = class WorkflowRunner {
 		});
 		if (bail) throw error;
 	}
-	#owns(owners, task, attempt) {
-		return owners.get(task.id) === attempt && task.attempts === attempt;
-	}
 	#revoke(owners, id, attempt) {
 		if (owners.get(id) === attempt) owners.delete(id);
 	}
@@ -3838,7 +4299,7 @@ var WorkflowRunner = class WorkflowRunner {
 		phase?.emitter.on("skip", onTerminal);
 		phase?.emitter.on("stop", onTerminal);
 		try {
-			if (workflow !== void 0 && this.#halted(workflow, phase)) deferred.resolve(void 0);
+			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;
 		} finally {
@@ -3869,7 +4330,7 @@ var WorkflowRunner = class WorkflowRunner {
 		return signals.length === 1 ? workflow.signal : AbortSignal.any(signals);
 	}
 	#haltFrom(phases, index, workflow, runSignal) {
-		if (this.#cancelled(runSignal) && this.#stoppable(workflow)) workflow.stop();
+		if (runSignal.aborted && isStoppable(workflow)) workflow.stop();
 		this.#skipFrom(phases, index);
 	}
 	#skipFrom(phases, index) {
@@ -3880,37 +4341,17 @@ var WorkflowRunner = class WorkflowRunner {
 		}
 	}
 	#settleCancelled(task, workflow, runSignal) {
-		if (this.#cancelled(runSignal) && this.#stoppable(workflow)) workflow.stop();
+		if (runSignal.aborted && isStoppable(workflow)) workflow.stop();
 		this.#skip(task);
 	}
 	#skip(task) {
 		if (task.status === "pending" || task.status === "running") task.skip();
 	}
-	#skipping(task, controller, runSignal) {
-		return task.signal.aborted || controller.aborted || runSignal.aborted;
-	}
-	#cancelled(runSignal) {
-		return runSignal.aborted;
-	}
-	#halted(workflow, phase) {
-		const status = workflow.status;
-		return status === "failed" || status === "skipped" || status === "stopped" || phase?.status === "skipped" || phase?.status === "stopped";
-	}
-	#stoppable(workflow) {
-		const status = workflow.status;
-		return status !== "failed" && status !== "stopped";
-	}
-	#completable(workflow) {
-		return workflow.status === "pending";
-	}
-	#isWorkflow(target) {
-		return "destroyed" in target && "snapshot" in target && typeof target.snapshot === "function";
-	}
 };
 //#endregion
 //#region src/core/factories.ts
 /**
-* Compile the workflow definition contract — the JSON Schema, guard, parser, and
+* Compiles the workflow definition contract — the JSON Schema, guard, parser, and
 * seeded generator for a {@link WorkflowDefinition}, all derived from one shape and
 * kept in lockstep.
 *
@@ -3940,7 +4381,7 @@ function createWorkflowContract() {
 	return createContract(workflowShape);
 }
 /**
-* Build the live W-b entity tree from a {@link WorkflowDefinition} — the whole
+* Builds the live W-b entity tree from a {@link WorkflowDefinition} — the whole
 * {@link WorkflowInterface} → {@link import('./types.js').PhaseInterface} →
 * {@link import('./types.js').TaskInterface} tree, each level wired with its lineage
 * context, its emitter, and the cascade.
@@ -3952,11 +4393,11 @@ function createWorkflowContract() {
 * definition's `bail`, else the graceful {@link import('./constants.js').DEFAULT_BAIL}; it
 * feeds {@link import('./helpers.js').deriveWorkflowStatus}. Per-phase / per-task initial
 * listeners + metadata travel through `options.phases[id].on` /
-* `options.phases[id].tasks[id]` (the AGENTS §8 nested-by-id bag). The W-b tree is the
+* `options.phases[id].tasks[id]` (the nested-by-id bag). The W-b tree is the
 * state machine ONLY — it does not execute tasks (W-c drives the transitions).
 *
-* `options.functions` is the {@link import('./types.js').WorkflowFunctions} registry each live
-* task's `run` name resolves against ONCE at construction into its runtime
+* `options.functions` is the {@link import('./types.js').WorkflowRegistry} registry each live
+* task's `behavior` name resolves against ONCE at construction into its runtime
 * {@link import('./types.js').TaskInterface.handler}. An omitted name is the deliberate no-op;
 * an unresolved present name remains inspectable but is rejected if execution is attempted.
 *
@@ -3974,11 +4415,47 @@ function createWorkflowContract() {
 * ```
 */
 function createWorkflow(definition, options) {
-	const captured = captureWorkflowOptions(options);
-	return new Workflow(definitionToSnapshot(definition, captured.bail ?? definition.bail ?? false), captured);
+	return createWorkflowTree(definition, captureWorkflowOptions(options));
+}
+/**
+* Builds the live entity tree one definition and one owned options bag describe — the shared
+* construction path behind every definition-driven mint.
+*
+* @remarks
+* Seeds an initial all-`pending` {@link WorkflowSnapshot} from the definition and constructs the
+* live {@link WorkflowInterface} over it. `bail` is the caller's own override, forwarded to
+* {@link definitionToSnapshot} so it reaches BOTH tiers: the workflow snapshot AND the inheritance
+* default of every phase that declares no `bail` of its own, while a phase declaring one still
+* wins. Omitted, the definition's own `bail` governs, defaulting to the graceful
+* {@link import('./constants.js').DEFAULT_BAIL}.
+*
+* `captured` is forwarded to the entity UNCHANGED — its own `bail` is deliberately not replaced
+* with the resolved policy, because the snapshot already carries the resolved value at both tiers
+* and an injected one would make `Workflow` read it as an EXPLICIT uniform override and clobber
+* the per-phase overrides. Each task's `behavior` / `retries` / `timeout` travel onto the snapshot
+* too, so `captured.functions` resolves every handler identically whether the tree is built fresh
+* or restored. Pass a bag {@link captureWorkflowOptions} already owns: this constructs over it
+* without re-capturing.
+*
+* @param definition - The workflow definition to bring to life
+* @param captured - The already-owned {@link WorkflowOptions} bag the entity is constructed with,
+* whose `bail` is the caller's failure-policy override, or `undefined` to take the definition's
+* @returns The live {@link WorkflowInterface} root
+*
+* @example
+* ```ts
+* import { captureWorkflowOptions, createWorkflowTree } from '@orkestrel/workflow'
+*
+* const captured = captureWorkflowOptions({ bail: true })
+* const workflow = createWorkflowTree(definition, captured)
+* workflow.bail // true — the override reached the workflow and every inheriting phase
+* ```
+*/
+function createWorkflowTree(definition, captured) {
+	return new Workflow(definitionToSnapshot(definition, captured.bail), captured);
 }
 /**
-* Build an equivalent live W-b entity tree from a {@link WorkflowSnapshot} — the
+* Builds an equivalent live W-b entity tree from a {@link WorkflowSnapshot} — the
 * inverse of {@link WorkflowInterface.snapshot}, restoring structure + each node's status
 * + recorded results + positional order + the persisted `#override`.
 *
@@ -3993,7 +4470,7 @@ function createWorkflow(definition, options) {
 * still wins when supplied (to deliberately re-run under a different policy). A structurally
 * invalid snapshot (a status — or override — outside the lifecycle vocabulary, or a
 * non-boolean `bail`) throws a `RESTORE` {@link WorkflowError}.
-* Runtime handlers are optional: without a matching `functions` entry, a persisted `run`
+* Runtime handlers are optional: without a matching `functions` entry, a persisted `behavior`
 * remains visible with an undefined `handler` so the exact state is inspectable. The runner
 * rejects that unresolved tree if execution is attempted.
 *
@@ -4014,10 +4491,10 @@ function createRestoredWorkflow(snapshot, options) {
 	return new Workflow(cloneWorkflowSnapshot(snapshot), captured);
 }
 /**
-* Build an interrupted workflow back to life at its remaining retry budget.
+* Builds an interrupted workflow back to life at its remaining retry budget.
 *
 * @remarks
-* Each phase captures every unique initial `run` binding once before constructing tasks. Recovery
+* Each phase captures every unique initial `behavior` binding once before constructing tasks. Recovery
 * validates those live tasks' captured callable handlers without rereading the registry, while the
 * retained registry identity remains available to resolve future live additions at their mint time.
 *
@@ -4038,18 +4515,19 @@ function createRecoveredWorkflow(snapshot, options) {
 	const owned = cloneWorkflowSnapshot(snapshot);
 	if (owned.override !== void 0 || owned.phases.some((phase) => phase.override !== void 0)) throw new WorkflowError("RESTORE", `workflow '${owned.id}' has a terminal override`, { workflow: owned.id });
 	const workflow = new Workflow(cloneWorkflowSnapshot(recoverWorkflowSnapshot(owned)), captured);
-	if (!hasWorkflowHandlers(workflow)) throw new WorkflowError("RESTORE", `workflow '${owned.id}' has an unresolved run`, { workflow: owned.id });
+	if (!hasWorkflowHandlers(workflow)) throw new WorkflowError("RESTORE", `workflow '${owned.id}' has an unresolved behavior`, { workflow: owned.id });
 	return workflow;
 }
 /**
-* Create the in-memory durable {@link WorkflowStoreInterface} — a process-lifetime
+* Creates the in-memory durable {@link WorkflowStoreInterface} — a process-lifetime
 * {@link MemoryWorkflowStore} persisting {@link WorkflowSnapshot}s by workflow id, the DEFAULT
 * backend behind the W-d persistence seam.
 *
 * @remarks
 * The snapshot analogue of the server package's `createMemorySessionStore`
 * (and the `createMemoryQueueStore` family), but LEANER — there is no idle-TTL, so no
-* options bag (AGENTS §21 minimal): a persisted run-state lives until an explicit `delete`. This is
+* options bag (the smallest interface the capability requires): a persisted run-state lives until
+* an explicit `delete`. This is
 * the zero-plumbing DEFAULT (a plain `Map`); its driver-pluggable twin is
 * {@link createDatabaseWorkflowStore} (the snapshot as one opaque JSON column over a `databases`
 * table) — for a DURABLE store (run-state surviving a restart) pass it a JSON / SQLite / IndexedDB
@@ -4073,7 +4551,7 @@ function createMemoryWorkflowStore() {
 	return new MemoryWorkflowStore();
 }
 /**
-* Create a {@link DatabaseWorkflowStore} over any {@link DriverInterface} — the durable,
+* Creates a {@link DatabaseWorkflowStore} over any {@link DriverInterface} — the durable,
 * driver-pluggable backing for the W-d persistence seam, the opt-in twin of
 * {@link createMemoryWorkflowStore}.
 *
@@ -4084,8 +4562,9 @@ function createMemoryWorkflowStore() {
 * snapshot is already a COMPLETE, self-contained, pure-JSON payload, so storing it whole is lossless
 * AND keeps the row type FLAT — a structured multi-column snapshot table would force the contract to
 * `Infer` the deeply-nested snapshot shape (workflow → phases → tasks → results) and trip TS2589;
-* the opaque column sidesteps it (the column reads back as `unknown`, narrowed on `get` by
-* {@link import('./helpers.js').isWorkflowSnapshot}). The `driver` DEFAULTS to
+* the opaque column sidesteps it (the column reads back as `unknown`, owned and narrowed on `get` by
+* {@link cloneWorkflowSnapshot}, whose semantic pass is
+* {@link import('./validators.js').isOwnedWorkflowSnapshot}). The `driver` DEFAULTS to
 * {@link createMemoryDriver}, so the store ALSO works in memory out of the box; pass a server
 * `createJSONDriver` / `createSQLiteDriver` (or a browser IndexedDB driver) for a persistent one —
 * the durability is the driver's job, the store engine is shared. It swaps in behind
@@ -4117,9 +4596,9 @@ function createDatabaseWorkflowStore(driver = createMemoryDriver()) {
 	}).table("snapshots"));
 }
 /**
-* Create a workflow runner — a {@link WorkflowRunnerInterface} that EXECUTES a live W-b
-* workflow tree by COMPOSING the shipped substrate: phases sequential, tasks concurrent,
-* each task dispatched through its OWN resolved handler under the workflow's `bail` policy.
+* Creates the thin orchestrator — a {@link WorkflowRunnerInterface} — that EXECUTES a live W-b
+* workflow tree by COMPOSING the shipped substrate: phases sequential, tasks concurrent, each
+* task dispatched through its OWN resolved handler under the workflow's `bail` policy.
 *
 * @remarks
 * The runner is a PURE engine — it re-implements no concurrency / retry / abort logic, AND it
@@ -4132,14 +4611,14 @@ function createDatabaseWorkflowStore(driver = createMemoryDriver()) {
 * rest) vs settle-all (`false` — failures are recorded, the run finishes); the run-level abort
 * / timeout / budget ({@link import('./types.js').WorkflowRunOptions}) fold through
 * `AbortSignal.any` (the agent runtime's pattern); pacing is the shipped scheduler.
-* `execute(definition, options?)` BUILDS the live tree from the definition itself (via
+* `execute(definition, options?)` BUILDS the live tree from the definition itself (through
 * {@link createWorkflow} — one source of truth, returned in `WorkflowResult.workflow`), drives
 * the live entity (`start` → `complete` / `fail`), and resolves a
 * {@link import('./types.js').WorkflowResult}.
 *
 * External integrations remain application-owned: a caller wires an ordinary
 * {@link import('./types.js').WorkflowFunction} into its own {@link WorkflowOptions.functions}
-* registry. Only a task that omits `run` auto-completes; unresolved named work is rejected
+* registry. Only a task that omits `behavior` auto-completes; unresolved named work is rejected
 * before dispatch.
 *
 * @param options - An optional pacing `scheduler` (default the shipped cross-environment one).
@@ -4152,7 +4631,7 @@ function createDatabaseWorkflowStore(driver = createMemoryDriver()) {
 *
 * const runner = createWorkflowRunner()
 * const definition = { id: 'w', name: 'W', phases: [{ id: 'p', name: 'P', tasks: [
-* 	{ id: 't', name: 'T', run: 'compile' },
+* 	{ id: 't', name: 'T', behavior: 'compile' },
 * ] }] }
 * const result = await runner.execute(definition, {
 * 	functions: { compile: async (controller) => `built ${controller.task.id}` },
@@ -4165,13 +4644,13 @@ function createWorkflowRunner(options) {
 	return new WorkflowRunner(options?.scheduler ?? createScheduler());
 }
 /**
-* Create a {@link WorkflowManagerInterface} — the store-backed registry of
+* Creates a {@link WorkflowManagerInterface} — the store-backed registry of
 * {@link WorkflowInterface}s, the additive manager tier mirroring the `@orkestrel/agent`
 * line's `createConversationManager` / `createWorkspaceManager`.
 *
 * @remarks
-* `options.functions` flows into every workflow the manager mints (`add`, via
-* {@link createWorkflow}) or hydrates (`open`'s registry-miss path, via
+* `options.functions` flows into every workflow the manager mints (`add`, through
+* {@link createWorkflow}) or hydrates (`open`'s registry-miss path, through
 * {@link createRestoredWorkflow}), so a hydrated workflow is RUNNABLE rather than a dead snapshot
 * mirror. `options.store` is the EXACT analogue of the twins' `store` seam — omitted ⇒ the
 * manager is registry-only (`open` resolves only what is registered, `save` is a no-op). This
@@ -4199,12 +4678,12 @@ function createWorkflowManager(options) {
 	return new WorkflowManager(options);
 }
 /**
-* Create the safe cross-environment cooperative-yield default — a
+* Creates the safe cross-environment cooperative-yield default — a
 * {@link SchedulerInterface} built on `setTimeout` / `clearTimeout` alone, so it
 * runs unchanged in both the browser and Node.
 *
 * @remarks
-* `yield()` gives the host a turn via a zero-delay macrotask (so pending I/O,
+* `yield()` gives the host a turn through a zero-delay macrotask (so pending I/O,
 * timers, and rendering actually run — a microtask would not); `delay(ms)` resumes
 * after at least `ms`. Pass `options.signal` to make a pending yield/delay reject
 * with the signal's exact `reason`; the shared owned-signal lifecycle clears the timer
@@ -4245,7 +4724,7 @@ function createScheduler() {
 	return new Scheduler();
 }
 /**
-* Create a thin generic orchestrator that drives declared units — and any they
+* Creates a thin generic orchestrator that drives declared units — and any they
 * `spawn` — through a bounded-concurrency queue, collecting their results in order.
 *
 * @remarks
@@ -4257,13 +4736,13 @@ function createScheduler() {
 * `id` / `input`, a `signal` that fires on the unit's `abort`, a runner-level `abort`,
 * or the attempt's timeout, a promise-parked `wait()`, and `spawn(input)` to fan out
 * sibling units. The run is **fail-fast**: the first unit failure (after retries)
-* aborts every other unit and rejects `execute` with that error. **Observable (§13):** a
+* aborts every other unit and rejects `execute` with that error. **Observable:** a
 * typed `emitter` surfaces `start` / `unit` / `spawn` / `settle` / `fail` / `finish` / `abort`.
 *
-* Because `spawn` is fire-and-track (the runner awaits the whole spawn closure via an
+* Because `spawn` is fire-and-track (the runner awaits the whole spawn closure through an
 * outstanding-unit count, not a one-time snapshot), a handler need NOT await its spawns
-* for them to run — and on a bounded runner it should NOT `await` a spawn inline (a
-* slot-holding handler awaiting its own spawn can deadlock); fan out and return instead.
+* for them to run — and on a bounded runner do NOT `await` a spawn inline (a slot-holding
+* handler awaiting its own spawn can deadlock); fan out and return instead.
 *
 * @typeParam TInput - The work input each unit carries
 * @typeParam TResult - The value a unit's handler resolves
@@ -4292,6 +4771,6 @@ function createRunner(options) {
 	return new Runner(options);
 }
 //#endregion
-export { Controller, DEFAULT_BAIL, DEFAULT_PHASE_CONCURRENCY, DatabaseWorkflowStore, MAX_TIMER_MS, MemoryWorkflowStore, PHASE_STATUSES, Phase, PhaseManager, Runner, Scheduler, TASK_STATUSES, TASK_TRANSITIONS, TERMINAL_TASK_STATUSES, Task, TaskController, TaskManager, WORKFLOW_STATUSES, Workflow, WorkflowError, WorkflowManager, WorkflowPersistence, WorkflowRunner, buildPhaseContext, buildTaskContext, buildWorkflowContext, canTransitionTask, captureWorkflowOptions, cloneTaskActivity, cloneWorkflowSnapshot, collectResults, createDatabaseWorkflowStore, createDeferred, createMemoryWorkflowStore, createRecoveredWorkflow, createRestoredWorkflow, createRunner, createScheduler, createWorkflow, createWorkflowContract, createWorkflowManager, createWorkflowRunner, definitionToSnapshot, deriveBoundary, derivePhaseStatus, deriveWorkflowStatus, errorToMessage, failure, findFailure, hasWorkflowHandlers, insertEntry, isLifecycleStatus, isOwnedWorkflowSnapshot, isTaskActivity, isTaskActivityInput, isTaskFailure, isTaskResult, isTerminalStatus, isWorkflowError, isWorkflowSnapshot, matchesDescription, moveEntry, parkSignal, phaseDefinitionToSnapshot, phaseShape, phaseUpdateShape, recoverWorkflowSnapshot, resolveTaskSilence, scheduleHost, success, taskDefinitionToSnapshot, taskShape, taskUpdateShape, workflowShape, workflowSnapshotContext };
+export { Collection, DEFAULT_BAIL, DEFAULT_PHASE_CONCURRENCY, DatabaseWorkflowStore, LIFECYCLE_STATUSES, MAX_TIMER_MS, MemoryWorkflowStore, PERSISTED_NODE_EVENTS, PERSISTED_TASK_EVENTS, PhaseManager, RunHolder, Runner, Scheduler, TASK_TRANSITIONS, TERMINAL_STATUSES, TaskManager, Workflow, WorkflowError, WorkflowManager, WorkflowPersistence, WorkflowRunner, buildPhaseContext, buildTaskContext, buildWorkflowContext, canTransitionTask, captureWorkflowOptions, cloneTaskActivity, cloneTaskClaims, cloneWorkflowSnapshot, collectResults, createDatabaseWorkflowStore, createMemoryWorkflowStore, createRecoveredWorkflow, createRestoredWorkflow, createRunner, createScheduler, createWorkflow, createWorkflowContract, createWorkflowManager, createWorkflowRunner, createWorkflowTree, definitionToSnapshot, delayHost, deriveBoundary, derivePhaseStatus, deriveWorkflowStatus, errorToMessage, failure, findFailure, hasWorkflowHandlers, insertEntry, isCompletable, isHalted, isLifecycleStatus, isOwnedWorkflowSnapshot, isSkipping, isStoppable, isTaskActivity, isTaskActivityInput, isTaskClaimList, isTaskFailure, isTaskResult, isTerminalStatus, isWorkflowError, isWorkflowInterface, isWorkflowSnapshot, matchesDescription, moveEntry, ownsAttempt, parkSignal, phaseDefinitionToSnapshot, phaseShape, phaseUpdateShape, recoverWorkflowSnapshot, resolveTaskSilence, scanSnapshotContext, scheduleHost, success, taskDefinitionToSnapshot, taskShape, taskUpdateShape, workflowShape };
 
 //# sourceMappingURL=index.js.map