@orkestrel/workflow 0.0.3 → 0.0.4

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

@@ -435,6 +435,39 @@ export declare function createWorkflow(definition: WorkflowDefinition, options?:
  */
 export declare function createWorkflowContract(): ContractInterface<WorkflowDefinition>;
 
+/**
+ * Create 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
+ * {@link restoreWorkflow}), so a hydrated workflow is RUNNABLE rather than a dead snapshot
+ * mirror. `options.store` is the EXACT analogue of the twins' `store` seam — omitted ⇒ the
+ * manager is registry-only (`open` resolves only what is registered, `save` is a no-op). This
+ * is PURELY ADDITIVE: direct {@link WorkflowStoreInterface} use and
+ * {@link restoreWorkflow} remain valid — the manager is one more caller-driven persistence
+ * seam, not a replacement.
+ *
+ * @param options - The optional `store` seam and the `functions` registry threaded into every mint/hydrate
+ * @returns A working {@link WorkflowManagerInterface}
+ *
+ * @example
+ * ```ts
+ * import { createMemoryWorkflowStore, createWorkflowManager } from '@src/core'
+ *
+ * const manager = createWorkflowManager({
+ * 	store: createMemoryWorkflowStore(),
+ * 	functions: { compile: async (controller) => `built ${controller.task.id}` },
+ * })
+ * const workflow = manager.add(definition) // minted, registered, RUNNABLE
+ * await manager.save(workflow.id)          // persisted to the store
+ * const reopened = await manager.open(workflow.id) // already registered — no store hit
+ * ```
+ */
+export declare function createWorkflowManager(options?: WorkflowManagerOptions): WorkflowManagerInterface;
+
 /**
  * Create a workflow runner — a {@link WorkflowRunnerInterface} that EXECUTES a live W-b
  * workflow tree by COMPOSING the shipped substrate: phases sequential, tasks concurrent,
@@ -3102,6 +3135,190 @@ export declare interface WorkflowInterface {
     snapshot(): WorkflowSnapshot;
 }
 
+/**
+ * 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
+ *   `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.
+ * - **Durable open / save.** `open(id)` returns an already-registered workflow directly; on a
+ *   registry MISS with a `store` set it rehydrates through {@link restoreWorkflow} (flowing the
+ *   manager's `functions` registry in so the rehydrated tree is RUNNABLE), registers it, and
+ *   returns it — lenient (`undefined`) with no store or a store miss. `save(id)` persists a
+ *   registered workflow's `snapshot()` to the `store` — lenient (`false`) with no store or an
+ *   unknown id.
+ * - **Removal.** `remove` drops one by id, or a batch (§9.2, array overload FIRST) — `true` when
+ *   any 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".
+ *
+ * @example
+ * ```ts
+ * const manager = new WorkflowManager({
+ * 	functions: { compile: async (controller) => `built ${controller.task.id}` },
+ * })
+ * const workflow = manager.add(definition) // minted, registered, RUNNABLE
+ * manager.workflow(workflow.id) // the same workflow
+ * manager.count // 1
+ * ```
+ */
+export declare class WorkflowManager implements WorkflowManagerInterface {
+    #private;
+    constructor(options?: WorkflowManagerOptions);
+    get count(): number;
+    workflow(id: string): WorkflowInterface | undefined;
+    workflows(): readonly WorkflowInterface[];
+    add(definition: WorkflowDefinition): WorkflowInterface;
+    open(id: string): Promise<WorkflowInterface | undefined>;
+    save(id: string): Promise<boolean>;
+    remove(ids: readonly string[]): boolean;
+    remove(id: string): boolean;
+    clear(): void;
+}
+
+/**
+ * A store-backed registry of {@link WorkflowInterface}s keyed by their `id`, in insertion
+ * order — the additive manager tier mirroring `ConversationManagerInterface` /
+ * `WorkspaceManagerInterface` from the `@orkestrel/agent` line, adapted for the workflow
+ * domain: `add` mints from a {@link WorkflowDefinition} (not an empty `Input`, since a
+ * workflow only exists relative to a definition), and the optional `store` seam's `open`
+ * threads the manager's {@link WorkflowFunctions} registry so a HYDRATED workflow is
+ * immediately RUNNABLE, not merely a restored state mirror. NO `active` / `switch` pointer
+ * (AGENTS §21) — the workflow domain has no consumer that renders "the current workflow" the
+ * way an agent context renders the active conversation/workspace.
+ *
+ * @remarks
+ * - **Registry.** `count` is how many are stored. `add(definition)` mints a live
+ *   {@link WorkflowInterface} via {@link import('./factories.js').createWorkflow} (flowing
+ *   this manager's `functions` registry in) and registers it under `definition.id` — an
+ *   already-present id OVERWRITES (last write wins, since `createWorkflow` keys the tree by
+ *   the definition's own id). `workflow(id)` looks one up (`undefined` when absent);
+ *   `workflows()` lists them in insertion order.
+ * - **Durable open / save (the optional `store` seam).** When a {@link WorkflowStoreInterface}
+ *   is supplied (the `store` option), `open(id)` resolves an already-registered workflow
+ *   directly (no store hit); on a registry MISS it HYDRATES one from `store.get(id)` through
+ *   {@link import('./factories.js').restoreWorkflow} — flowing this manager's `functions`
+ *   registry in so the rehydrated tree is RUNNABLE — registers it, and returns it. `save(id)`
+ *   PERSISTS a registered workflow's {@link WorkflowInterface.snapshot} to the store. Both are
+ *   LENIENT without a store — `open` resolves only registered ids, `save` is a no-op
+ *   (`false`) — never a throw. The EXACT analogue of
+ *   `ConversationManagerInterface.open` / `.save` and `WorkspaceManagerInterface.open` /
+ *   `.save` — this is the workflow line's caller-driven persistence gaining the standard
+ *   open/save seam, ADDITIVE alongside direct {@link WorkflowStoreInterface} use and
+ *   {@link import('./factories.js').restoreWorkflow} (both remain valid).
+ * - **Removal.** `remove` drops one by id, or a batch (§9.2, array overload FIRST) — `true`
+ *   when any was removed. `clear` empties the registry.
+ * - **Event-free.** A purely registry store — no `Emitter`, no events (each
+ *   {@link WorkflowInterface} owns its own {@link WorkflowEventMap} emitter).
+ *
+ * @example
+ * ```ts
+ * import { createWorkflowManager } from '@src/core'
+ *
+ * const manager = createWorkflowManager({
+ * 	functions: { compile: async (controller) => `built ${controller.task.id}` },
+ * })
+ * const workflow = manager.add(definition) // minted, registered, RUNNABLE (functions flow in)
+ * manager.count // 1
+ * ```
+ */
+export declare interface WorkflowManagerInterface {
+    readonly count: number;
+    workflow(id: string): WorkflowInterface | undefined;
+    workflows(): readonly WorkflowInterface[];
+    /**
+     * MINT a live {@link WorkflowInterface} from `definition` (via
+     * {@link import('./factories.js').createWorkflow}, flowing this manager's `functions`
+     * registry in) and register it under `definition.id`.
+     *
+     * @remarks
+     * An already-registered `definition.id` OVERWRITES (last write wins) — `createWorkflow`
+     * keys the live tree by the definition's own id, so a re-`add` under the same id is
+     * indistinguishable from a fresh mint at the registry level.
+     *
+     * @param definition - The {@link WorkflowDefinition} to build the live tree from
+     * @returns The minted, registered {@link WorkflowInterface}
+     */
+    add(definition: WorkflowDefinition): WorkflowInterface;
+    /**
+     * Resolve a workflow by id — from the registry if present, else HYDRATED from the
+     * optional {@link WorkflowStoreInterface} (`store`), RUNNABLE (this manager's `functions`
+     * registry is threaded into the rehydration).
+     *
+     * @remarks
+     * - If `id` is ALREADY registered, it is returned directly — no store hit.
+     * - Else if a `store` is set, `store.get(id)` is awaited; on a HIT the snapshot is
+     *   rehydrated into a fresh {@link WorkflowInterface} via
+     *   {@link import('./factories.js').restoreWorkflow}, flowing this manager's `functions`
+     *   registry in (so the rehydrated tree carries real resolved `handler`s and can RESUME
+     *   real work), registers it, and returns it.
+     * - Else (no store, or a store MISS) ⇒ `undefined` (lenient — no throw).
+     *
+     * @param id - The workflow id to open
+     * @returns The resolved, RUNNABLE {@link WorkflowInterface}, or `undefined` when neither registered nor stored
+     */
+    open(id: string): Promise<WorkflowInterface | undefined>;
+    /**
+     * Persist a REGISTERED workflow's {@link WorkflowInterface.snapshot} to the optional
+     * {@link WorkflowStoreInterface} (`store`).
+     *
+     * @remarks
+     * Lenient: when a `store` is set AND `id` is registered, `store.set(workflow.snapshot())`
+     * is awaited and `true` is returned; otherwise (no store, OR an unknown id) it is a NO-OP
+     * returning `false` — never a throw.
+     *
+     * @param id - The id of the registered workflow to persist
+     * @returns `true` when the snapshot was persisted; `false` when no store / unknown id
+     */
+    save(id: string): Promise<boolean>;
+    remove(ids: readonly string[]): boolean;
+    remove(id: string): boolean;
+    clear(): void;
+}
+
+/**
+ * Options for `createWorkflowManager` — the optional durable {@link WorkflowStoreInterface}
+ * seam plus the {@link WorkflowFunctions} registry every workflow the manager mints or
+ * hydrates resolves its tasks' handlers against.
+ *
+ * @remarks
+ * `store` is the EXACT analogue of `ConversationManagerOptions.store` /
+ * `WorkspaceManagerOptions.store` (the `@orkestrel/agent` line's store standard) — omitted ⇒
+ * the manager is registry-only: {@link WorkflowManagerInterface.open} resolves only what is
+ * already registered, and {@link WorkflowManagerInterface.save} is a no-op (`false`). `functions`
+ * is the workflow-specific addition: the SAME {@link WorkflowFunctions} registry threaded into
+ * every {@link import('./factories.js').createWorkflow} ({@link WorkflowManagerInterface.add})
+ * and every {@link import('./factories.js').restoreWorkflow}
+ * ({@link WorkflowManagerInterface.open}'s hydration path) the manager performs — so a
+ * hydrated workflow carries real resolved `handler`s and is RUNNABLE, not merely a restored
+ * state mirror. Omitted ⇒ every minted/hydrated task resolves no `handler` (the no-handler
+ * rule — it auto-completes if driven).
+ */
+export declare interface WorkflowManagerOptions {
+    /**
+     * The optional durable {@link WorkflowStoreInterface} backing
+     * {@link WorkflowManagerInterface.open} / {@link WorkflowManagerInterface.save} — a memory
+     * / JSON / SQLite / IndexedDB store a workflow is HYDRATED from (`open` a registry miss)
+     * and PERSISTED to (`save`). Omitted ⇒ the manager is registry-only: `open` resolves only
+     * what is already registered, and `save` is a no-op (`false`).
+     */
+    readonly store?: WorkflowStoreInterface;
+    /**
+     * The {@link WorkflowFunctions} registry threaded into every workflow this manager mints
+     * (`add`, via {@link import('./factories.js').createWorkflow}) or hydrates (`open`'s
+     * registry-miss path, via {@link import('./factories.js').restoreWorkflow}) — so a
+     * hydrated workflow is RUNNABLE, its tasks carrying real resolved `handler`s. Omitted ⇒
+     * every task resolves no `handler` (the no-handler rule).
+     */
+    readonly functions?: WorkflowFunctions;
+}
+
 /**
  * The runtime options for a {@link WorkflowInterface} — the construction bag the
  * live derived workflow state machine (W-b) carries, the root {@link createWorkflow}

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

@@ -435,6 +435,39 @@ export declare function createWorkflow(definition: WorkflowDefinition, options?:
  */
 export declare function createWorkflowContract(): ContractInterface<WorkflowDefinition>;
 
+/**
+ * Create 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
+ * {@link restoreWorkflow}), so a hydrated workflow is RUNNABLE rather than a dead snapshot
+ * mirror. `options.store` is the EXACT analogue of the twins' `store` seam — omitted ⇒ the
+ * manager is registry-only (`open` resolves only what is registered, `save` is a no-op). This
+ * is PURELY ADDITIVE: direct {@link WorkflowStoreInterface} use and
+ * {@link restoreWorkflow} remain valid — the manager is one more caller-driven persistence
+ * seam, not a replacement.
+ *
+ * @param options - The optional `store` seam and the `functions` registry threaded into every mint/hydrate
+ * @returns A working {@link WorkflowManagerInterface}
+ *
+ * @example
+ * ```ts
+ * import { createMemoryWorkflowStore, createWorkflowManager } from '@src/core'
+ *
+ * const manager = createWorkflowManager({
+ * 	store: createMemoryWorkflowStore(),
+ * 	functions: { compile: async (controller) => `built ${controller.task.id}` },
+ * })
+ * const workflow = manager.add(definition) // minted, registered, RUNNABLE
+ * await manager.save(workflow.id)          // persisted to the store
+ * const reopened = await manager.open(workflow.id) // already registered — no store hit
+ * ```
+ */
+export declare function createWorkflowManager(options?: WorkflowManagerOptions): WorkflowManagerInterface;
+
 /**
  * Create a workflow runner — a {@link WorkflowRunnerInterface} that EXECUTES a live W-b
  * workflow tree by COMPOSING the shipped substrate: phases sequential, tasks concurrent,
@@ -3102,6 +3135,190 @@ export declare interface WorkflowInterface {
     snapshot(): WorkflowSnapshot;
 }
 
+/**
+ * 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
+ *   `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.
+ * - **Durable open / save.** `open(id)` returns an already-registered workflow directly; on a
+ *   registry MISS with a `store` set it rehydrates through {@link restoreWorkflow} (flowing the
+ *   manager's `functions` registry in so the rehydrated tree is RUNNABLE), registers it, and
+ *   returns it — lenient (`undefined`) with no store or a store miss. `save(id)` persists a
+ *   registered workflow's `snapshot()` to the `store` — lenient (`false`) with no store or an
+ *   unknown id.
+ * - **Removal.** `remove` drops one by id, or a batch (§9.2, array overload FIRST) — `true` when
+ *   any 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".
+ *
+ * @example
+ * ```ts
+ * const manager = new WorkflowManager({
+ * 	functions: { compile: async (controller) => `built ${controller.task.id}` },
+ * })
+ * const workflow = manager.add(definition) // minted, registered, RUNNABLE
+ * manager.workflow(workflow.id) // the same workflow
+ * manager.count // 1
+ * ```
+ */
+export declare class WorkflowManager implements WorkflowManagerInterface {
+    #private;
+    constructor(options?: WorkflowManagerOptions);
+    get count(): number;
+    workflow(id: string): WorkflowInterface | undefined;
+    workflows(): readonly WorkflowInterface[];
+    add(definition: WorkflowDefinition): WorkflowInterface;
+    open(id: string): Promise<WorkflowInterface | undefined>;
+    save(id: string): Promise<boolean>;
+    remove(ids: readonly string[]): boolean;
+    remove(id: string): boolean;
+    clear(): void;
+}
+
+/**
+ * A store-backed registry of {@link WorkflowInterface}s keyed by their `id`, in insertion
+ * order — the additive manager tier mirroring `ConversationManagerInterface` /
+ * `WorkspaceManagerInterface` from the `@orkestrel/agent` line, adapted for the workflow
+ * domain: `add` mints from a {@link WorkflowDefinition} (not an empty `Input`, since a
+ * workflow only exists relative to a definition), and the optional `store` seam's `open`
+ * threads the manager's {@link WorkflowFunctions} registry so a HYDRATED workflow is
+ * immediately RUNNABLE, not merely a restored state mirror. NO `active` / `switch` pointer
+ * (AGENTS §21) — the workflow domain has no consumer that renders "the current workflow" the
+ * way an agent context renders the active conversation/workspace.
+ *
+ * @remarks
+ * - **Registry.** `count` is how many are stored. `add(definition)` mints a live
+ *   {@link WorkflowInterface} via {@link import('./factories.js').createWorkflow} (flowing
+ *   this manager's `functions` registry in) and registers it under `definition.id` — an
+ *   already-present id OVERWRITES (last write wins, since `createWorkflow` keys the tree by
+ *   the definition's own id). `workflow(id)` looks one up (`undefined` when absent);
+ *   `workflows()` lists them in insertion order.
+ * - **Durable open / save (the optional `store` seam).** When a {@link WorkflowStoreInterface}
+ *   is supplied (the `store` option), `open(id)` resolves an already-registered workflow
+ *   directly (no store hit); on a registry MISS it HYDRATES one from `store.get(id)` through
+ *   {@link import('./factories.js').restoreWorkflow} — flowing this manager's `functions`
+ *   registry in so the rehydrated tree is RUNNABLE — registers it, and returns it. `save(id)`
+ *   PERSISTS a registered workflow's {@link WorkflowInterface.snapshot} to the store. Both are
+ *   LENIENT without a store — `open` resolves only registered ids, `save` is a no-op
+ *   (`false`) — never a throw. The EXACT analogue of
+ *   `ConversationManagerInterface.open` / `.save` and `WorkspaceManagerInterface.open` /
+ *   `.save` — this is the workflow line's caller-driven persistence gaining the standard
+ *   open/save seam, ADDITIVE alongside direct {@link WorkflowStoreInterface} use and
+ *   {@link import('./factories.js').restoreWorkflow} (both remain valid).
+ * - **Removal.** `remove` drops one by id, or a batch (§9.2, array overload FIRST) — `true`
+ *   when any was removed. `clear` empties the registry.
+ * - **Event-free.** A purely registry store — no `Emitter`, no events (each
+ *   {@link WorkflowInterface} owns its own {@link WorkflowEventMap} emitter).
+ *
+ * @example
+ * ```ts
+ * import { createWorkflowManager } from '@src/core'
+ *
+ * const manager = createWorkflowManager({
+ * 	functions: { compile: async (controller) => `built ${controller.task.id}` },
+ * })
+ * const workflow = manager.add(definition) // minted, registered, RUNNABLE (functions flow in)
+ * manager.count // 1
+ * ```
+ */
+export declare interface WorkflowManagerInterface {
+    readonly count: number;
+    workflow(id: string): WorkflowInterface | undefined;
+    workflows(): readonly WorkflowInterface[];
+    /**
+     * MINT a live {@link WorkflowInterface} from `definition` (via
+     * {@link import('./factories.js').createWorkflow}, flowing this manager's `functions`
+     * registry in) and register it under `definition.id`.
+     *
+     * @remarks
+     * An already-registered `definition.id` OVERWRITES (last write wins) — `createWorkflow`
+     * keys the live tree by the definition's own id, so a re-`add` under the same id is
+     * indistinguishable from a fresh mint at the registry level.
+     *
+     * @param definition - The {@link WorkflowDefinition} to build the live tree from
+     * @returns The minted, registered {@link WorkflowInterface}
+     */
+    add(definition: WorkflowDefinition): WorkflowInterface;
+    /**
+     * Resolve a workflow by id — from the registry if present, else HYDRATED from the
+     * optional {@link WorkflowStoreInterface} (`store`), RUNNABLE (this manager's `functions`
+     * registry is threaded into the rehydration).
+     *
+     * @remarks
+     * - If `id` is ALREADY registered, it is returned directly — no store hit.
+     * - Else if a `store` is set, `store.get(id)` is awaited; on a HIT the snapshot is
+     *   rehydrated into a fresh {@link WorkflowInterface} via
+     *   {@link import('./factories.js').restoreWorkflow}, flowing this manager's `functions`
+     *   registry in (so the rehydrated tree carries real resolved `handler`s and can RESUME
+     *   real work), registers it, and returns it.
+     * - Else (no store, or a store MISS) ⇒ `undefined` (lenient — no throw).
+     *
+     * @param id - The workflow id to open
+     * @returns The resolved, RUNNABLE {@link WorkflowInterface}, or `undefined` when neither registered nor stored
+     */
+    open(id: string): Promise<WorkflowInterface | undefined>;
+    /**
+     * Persist a REGISTERED workflow's {@link WorkflowInterface.snapshot} to the optional
+     * {@link WorkflowStoreInterface} (`store`).
+     *
+     * @remarks
+     * Lenient: when a `store` is set AND `id` is registered, `store.set(workflow.snapshot())`
+     * is awaited and `true` is returned; otherwise (no store, OR an unknown id) it is a NO-OP
+     * returning `false` — never a throw.
+     *
+     * @param id - The id of the registered workflow to persist
+     * @returns `true` when the snapshot was persisted; `false` when no store / unknown id
+     */
+    save(id: string): Promise<boolean>;
+    remove(ids: readonly string[]): boolean;
+    remove(id: string): boolean;
+    clear(): void;
+}
+
+/**
+ * Options for `createWorkflowManager` — the optional durable {@link WorkflowStoreInterface}
+ * seam plus the {@link WorkflowFunctions} registry every workflow the manager mints or
+ * hydrates resolves its tasks' handlers against.
+ *
+ * @remarks
+ * `store` is the EXACT analogue of `ConversationManagerOptions.store` /
+ * `WorkspaceManagerOptions.store` (the `@orkestrel/agent` line's store standard) — omitted ⇒
+ * the manager is registry-only: {@link WorkflowManagerInterface.open} resolves only what is
+ * already registered, and {@link WorkflowManagerInterface.save} is a no-op (`false`). `functions`
+ * is the workflow-specific addition: the SAME {@link WorkflowFunctions} registry threaded into
+ * every {@link import('./factories.js').createWorkflow} ({@link WorkflowManagerInterface.add})
+ * and every {@link import('./factories.js').restoreWorkflow}
+ * ({@link WorkflowManagerInterface.open}'s hydration path) the manager performs — so a
+ * hydrated workflow carries real resolved `handler`s and is RUNNABLE, not merely a restored
+ * state mirror. Omitted ⇒ every minted/hydrated task resolves no `handler` (the no-handler
+ * rule — it auto-completes if driven).
+ */
+export declare interface WorkflowManagerOptions {
+    /**
+     * The optional durable {@link WorkflowStoreInterface} backing
+     * {@link WorkflowManagerInterface.open} / {@link WorkflowManagerInterface.save} — a memory
+     * / JSON / SQLite / IndexedDB store a workflow is HYDRATED from (`open` a registry miss)
+     * and PERSISTED to (`save`). Omitted ⇒ the manager is registry-only: `open` resolves only
+     * what is already registered, and `save` is a no-op (`false`).
+     */
+    readonly store?: WorkflowStoreInterface;
+    /**
+     * The {@link WorkflowFunctions} registry threaded into every workflow this manager mints
+     * (`add`, via {@link import('./factories.js').createWorkflow}) or hydrates (`open`'s
+     * registry-miss path, via {@link import('./factories.js').restoreWorkflow}) — so a
+     * hydrated workflow is RUNNABLE, its tasks carrying real resolved `handler`s. Omitted ⇒
+     * every task resolves no `handler` (the no-handler rule).
+     */
+    readonly functions?: WorkflowFunctions;
+}
+
 /**
  * The runtime options for a {@link WorkflowInterface} — the construction bag the
  * live derived workflow state machine (W-b) carries, the root {@link createWorkflow}

package/dist/src/core/index.js

@@ -1843,6 +1843,91 @@ var Workflow = class {
 	}
 };
 //#endregion
+//#region src/core/WorkflowManager.ts
+/**
+* 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
+*   `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.
+* - **Durable open / save.** `open(id)` returns an already-registered workflow directly; on a
+*   registry MISS with a `store` set it rehydrates through {@link restoreWorkflow} (flowing the
+*   manager's `functions` registry in so the rehydrated tree is RUNNABLE), registers it, and
+*   returns it — lenient (`undefined`) with no store or a store miss. `save(id)` persists a
+*   registered workflow's `snapshot()` to the `store` — lenient (`false`) with no store or an
+*   unknown id.
+* - **Removal.** `remove` drops one by id, or a batch (§9.2, array overload FIRST) — `true` when
+*   any 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".
+*
+* @example
+* ```ts
+* const manager = new WorkflowManager({
+* 	functions: { compile: async (controller) => `built ${controller.task.id}` },
+* })
+* const workflow = manager.add(definition) // minted, registered, RUNNABLE
+* manager.workflow(workflow.id) // the same workflow
+* manager.count // 1
+* ```
+*/
+var WorkflowManager = class {
+	#workflows = /* @__PURE__ */ new Map();
+	#functions;
+	#store;
+	constructor(options) {
+		this.#functions = options?.functions;
+		this.#store = options?.store;
+	}
+	get count() {
+		return this.#workflows.size;
+	}
+	workflow(id) {
+		return this.#workflows.get(id);
+	}
+	workflows() {
+		return [...this.#workflows.values()];
+	}
+	add(definition) {
+		const workflow = createWorkflow(definition, { functions: this.#functions });
+		this.#workflows.set(workflow.id, workflow);
+		return workflow;
+	}
+	async open(id) {
+		const existing = this.#workflows.get(id);
+		if (existing !== void 0) return existing;
+		if (this.#store === void 0) return void 0;
+		const snapshot = await this.#store.get(id);
+		if (snapshot === void 0) return void 0;
+		const workflow = restoreWorkflow(snapshot, { functions: this.#functions });
+		this.#workflows.set(workflow.id, workflow);
+		return workflow;
+	}
+	async save(id) {
+		const workflow = this.#workflows.get(id);
+		if (this.#store === void 0 || workflow === void 0) return false;
+		await this.#store.set(workflow.snapshot());
+		return true;
+	}
+	remove(ids) {
+		if (isArray(ids)) {
+			let removed = false;
+			for (const id of ids) if (this.#workflows.delete(id)) removed = true;
+			return removed;
+		}
+		return this.#workflows.delete(ids);
+	}
+	clear() {
+		this.#workflows.clear();
+	}
+};
+//#endregion
 //#region src/core/Controller.ts
 /**
 * The per-unit handle a runner handler receives — wraps the unit's identity,
@@ -2804,6 +2889,40 @@ function createWorkflowRunner(options) {
 	return new WorkflowRunner(options?.scheduler ?? createScheduler());
 }
 /**
+* Create 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
+* {@link restoreWorkflow}), so a hydrated workflow is RUNNABLE rather than a dead snapshot
+* mirror. `options.store` is the EXACT analogue of the twins' `store` seam — omitted ⇒ the
+* manager is registry-only (`open` resolves only what is registered, `save` is a no-op). This
+* is PURELY ADDITIVE: direct {@link WorkflowStoreInterface} use and
+* {@link restoreWorkflow} remain valid — the manager is one more caller-driven persistence
+* seam, not a replacement.
+*
+* @param options - The optional `store` seam and the `functions` registry threaded into every mint/hydrate
+* @returns A working {@link WorkflowManagerInterface}
+*
+* @example
+* ```ts
+* import { createMemoryWorkflowStore, createWorkflowManager } from '@src/core'
+*
+* const manager = createWorkflowManager({
+* 	store: createMemoryWorkflowStore(),
+* 	functions: { compile: async (controller) => `built ${controller.task.id}` },
+* })
+* const workflow = manager.add(definition) // minted, registered, RUNNABLE
+* await manager.save(workflow.id)          // persisted to the store
+* const reopened = await manager.open(workflow.id) // already registered — no store hit
+* ```
+*/
+function createWorkflowManager(options) {
+	return new WorkflowManager(options);
+}
+/**
 * Create 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.
@@ -2895,6 +3014,6 @@ function createRunner(options) {
 	return new Runner(options);
 }
 //#endregion
-export { Controller, DEFAULT_BAIL, DEFAULT_PHASE_CONCURRENCY, DatabaseWorkflowStore, MemoryWorkflowStore, PHASE_STATUSES, Phase, PhaseManager, Runner, Scheduler, TASK_STATUSES, TASK_TRANSITIONS, TERMINAL_TASK_STATUSES, Task, TaskController, TaskManager, WORKFLOW_STATUSES, Workflow, WorkflowError, WorkflowRunner, assertSnapshot, buildPhaseContext, buildTaskContext, buildWorkflowContext, canTransitionTask, collectResults, createDatabaseWorkflowStore, createDeferred, createMemoryWorkflowStore, createRunner, createScheduler, createWorkflow, createWorkflowContract, createWorkflowRunner, definitionToSnapshot, deriveBoundary, derivePhaseStatus, deriveWorkflowStatus, failure, findFailure, insertEntry, isTerminalStatus, isWorkflowError, isWorkflowSnapshot, moveEntry, parkSignal, phaseDefinitionToSnapshot, phaseShape, phaseUpdateShape, restoreWorkflow, success, taskDefinitionToSnapshot, taskShape, taskUpdateShape, workflowShape };
+export { Controller, DEFAULT_BAIL, DEFAULT_PHASE_CONCURRENCY, DatabaseWorkflowStore, MemoryWorkflowStore, PHASE_STATUSES, Phase, PhaseManager, Runner, Scheduler, TASK_STATUSES, TASK_TRANSITIONS, TERMINAL_TASK_STATUSES, Task, TaskController, TaskManager, WORKFLOW_STATUSES, Workflow, WorkflowError, WorkflowManager, WorkflowRunner, assertSnapshot, buildPhaseContext, buildTaskContext, buildWorkflowContext, canTransitionTask, collectResults, createDatabaseWorkflowStore, createDeferred, createMemoryWorkflowStore, createRunner, createScheduler, createWorkflow, createWorkflowContract, createWorkflowManager, createWorkflowRunner, definitionToSnapshot, deriveBoundary, derivePhaseStatus, deriveWorkflowStatus, failure, findFailure, insertEntry, isTerminalStatus, isWorkflowError, isWorkflowSnapshot, moveEntry, parkSignal, phaseDefinitionToSnapshot, phaseShape, phaseUpdateShape, restoreWorkflow, success, taskDefinitionToSnapshot, taskShape, taskUpdateShape, workflowShape };
 
 //# sourceMappingURL=index.js.map