@orkestrel/workflow 0.0.2 → 0.0.4

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

@@ -1,5 +1,4 @@
 import { AbortInterface } from '@orkestrel/abort';
-import { AgentInterface } from '@orkestrel/agent';
 import { ArrayShape } from '@orkestrel/contract';
 import { BudgetInterface } from '@orkestrel/budget';
 import { ContractInterface } from '@orkestrel/contract';
@@ -17,46 +16,6 @@ import { StringShape } from '@orkestrel/contract';
 import { Success } from '@orkestrel/contract';
 import { TableInterface } from '@orkestrel/database';
 import { TokenUsage } from '@orkestrel/budget';
-import { ToolInterface } from '@orkestrel/agent';
-import { ToolManagerInterface } from '@orkestrel/agent';
-
-/**
- * Options for {@link import('./factories.js').createAgentFunction} — the OPT-IN adapter that
- * wraps a live `AgentInterface` (`@orkestrel/agent`) as a {@link WorkflowFunction}, folding a
- * nested workflow-authoring depth / cycle guard into its closure.
- *
- * @remarks
- * All fields are optional: omitted entirely, the adapter runs the agent with no nested
- * workflow tool bound and no depth/cycle bound (depth `0`, empty ancestry).
- * - `runner` — when supplied, the adapter BINDS a depth/cycle-aware
- *   {@link import('./factories.js').createWorkflowTool} onto the agent's `context.tools` (the
- *   propagation seam), so the agent can author + run a NESTED workflow through it. Omitted ⇒
- *   the agent runs with no workflow tool bound.
- * - `depth` — this invocation's nesting depth (default `0`); the bound workflow tool runs its
- *   nested workflow at `depth + 1`, bounded by {@link import('./constants.js').MAX_WORKFLOW_DEPTH}.
- * - `ancestry` — the workflow / agent identifiers already in this run chain (default empty); a
- *   cycle (this agent already present) is rejected with a typed `DEPTH`
- *   {@link import('./errors.js').WorkflowError}.
- */
-export declare interface AgentFunctionOptions {
-    readonly runner?: WorkflowRunnerInterface;
-    readonly depth?: number;
-    readonly ancestry?: readonly string[];
-}
-
-/**
- * The ancestry identifier of an agent in a run chain — `agent:<name>`.
- *
- * @remarks
- * The agent counterpart of {@link workflowTag}: the runner adds one when it dispatches an
- * `agent` task, and rejects the task (a typed `DEPTH` `task.fail`) when the same tag is
- * already in the ancestry (a re-entry cycle). The `agent:` namespace keeps it distinct
- * from a same-string workflow id.
- *
- * @param name - The agent's registry name (the `agent`-form's `name`)
- * @returns The namespaced ancestry tag (`agent:<name>`)
- */
-export declare function agentTag(name: string): string;
 
 /**
  * Assert that a {@link WorkflowSnapshot} carries a `boolean` `bail` — at the workflow tier AND
@@ -145,48 +104,6 @@ export declare function canTransitionTask(from: TaskStatus, to: TaskStatus): boo
  */
 export declare function collectResults(phases: readonly (readonly TaskResult[])[]): readonly TaskResult[];
 
-/**
- * Complete a {@link WorkflowDraft} into a strict {@link WorkflowDefinition} — synthesize
- * any MISSING `id` deterministically + positionally, and default any MISSING `name` to
- * its (now-resolved) `id`.
- *
- * @remarks
- * The positional id scheme is stable and human-legible: the workflow is `wf`, phase `i`
- * is `phase-<i>`, and task `j` of that phase is `<phaseId>-task-<j>` (so a provided phase
- * id flows into its tasks' synthesized ids). A PROVIDED `id` / `name` at any level is kept
- * VERBATIM — synthesis touches only the omitted ones. A missing `name` defaults to the
- * resolved `id` (never the other way round), so the result always has both. `run`,
- * `description`, the per-phase `concurrency` / `bail`, the per-task `retries` / `timeout`, and
- * the workflow `bail` carry over unchanged. The result is a complete
- * {@link WorkflowDefinition}; the caller still validates it against the STRICT contract.
- *
- * @param draft - The draft workflow (id/name optional at all three levels)
- * @returns A complete {@link WorkflowDefinition} with every id/name filled
- */
-export declare function completeDraft(draft: WorkflowDraft): WorkflowDefinition;
-
-/**
- * Complete one {@link PhaseDraft} into a strict {@link PhaseDefinition} — the per-phase
- * step of {@link completeDraft} (phase `index` → `phase-<index>` when its id is omitted).
- *
- * @param phase - The draft phase
- * @param index - The phase's positional index in the workflow
- * @returns A complete {@link PhaseDefinition}
- */
-export declare function completePhaseDraft(phase: PhaseDraft, index: number): PhaseDefinition;
-
-/**
- * Complete one {@link TaskDraft} into a strict {@link TaskDefinition} — the per-task leaf
- * step of {@link completeDraft} (task `index` of phase `<phaseId>` → `<phaseId>-task-<index>`
- * when its id is omitted).
- *
- * @param task - The draft task
- * @param phaseId - The (resolved) parent phase id, so the synthesized task id nests under it
- * @param index - The task's positional index within its phase
- * @returns A complete {@link TaskDefinition}
- */
-export declare function completeTaskDraft(task: TaskDraft, phaseId: string, index: number): TaskDefinition;
-
 /**
  * The per-unit handle a runner handler receives — wraps the unit's identity,
  * input, cancellation, and the run controls (`wait` / `spawn` / `abort`).
@@ -290,48 +207,6 @@ export declare interface ControllerInterface<TInput, TResult> {
     abort(reason?: unknown): void;
 }
 
-/**
- * Wrap a live `AgentInterface` (`@orkestrel/agent`) as a {@link WorkflowFunction} — the OPT-IN
- * adapter that runs the agent to a settled result, folding a nested workflow-authoring
- * depth / cycle guard into its own closure.
- *
- * @remarks
- * Composes into a caller's {@link WorkflowOptions.functions} registry like any other behavior;
- * the PURE {@link import('./WorkflowRunner.js').WorkflowRunner} has no knowledge of agents
- * itself. Before running the agent, the depth/cycle guard REJECTS the call (a THROWN typed
- * `DEPTH` {@link WorkflowError}, which the leaf `fail`s) when running it would push a nested
- * chain past {@link MAX_WORKFLOW_DEPTH}, OR when this agent is already an ancestor (a cycle) —
- * ported from the former engine-side guard. When {@link AgentFunctionOptions.runner} is
- * supplied, the adapter BINDS a depth/cycle-aware {@link createWorkflowTool} onto the agent's
- * `context.tools` (the propagation seam) — closed over `depth` and the extended ancestry (the
- * tool itself computes `depth + 1` internally) — so the agent can author + run a NESTED
- * workflow through it; the wrapped default is the CURRENT task's own workflow id (used only on
- * a no-args tool call). The task's cancellation folds into the agent run: an already-aborted
- * `controller.signal` cancels the agent up front; otherwise a one-shot listener fires
- * `agent.abort(reason)` when the task cancels, removed in `finally`. `agent.generate()` resolves
- * a partial `AgentResult` on a cancel (never rejects), returned as the task's completed value.
- *
- * A bound agent is effectively SINGLE-RUN: `context.tools.add` binds one {@link ToolInterface}
- * under the fixed {@link import('./constants.js').WORKFLOW_TOOL_NAME}, and `agent.generate()` /
- * `agent.abort()` are per-agent state. Two CONCURRENT tasks sharing the SAME `agent` instance
- * race on that one tool binding (last-write-wins) and on generate/abort — give each concurrent
- * task its OWN agent instance.
- *
- * @param agent - The live `AgentInterface` to run
- * @param options - The nested-workflow binding + depth/cycle bookkeeping (see {@link AgentFunctionOptions})
- * @returns A {@link WorkflowFunction} that runs `agent` to its settled result
- *
- * @example
- * ```ts
- * import { createAgentFunction, createWorkflowRunner } from '@src/core'
- *
- * const runner = createWorkflowRunner()
- * const review = createAgentFunction(myAgent, { runner })
- * await runner.execute(definition, { functions: { review } })
- * ```
- */
-export declare function createAgentFunction(agent: AgentInterface, options?: AgentFunctionOptions): WorkflowFunction;
-
 /**
  * Create a {@link DatabaseWorkflowStore} over any {@link DriverInterface} — the durable,
  * driver-pluggable backing for the W-d persistence seam, the opt-in twin of
@@ -495,38 +370,6 @@ export declare function createRunner<TInput, TResult>(options: RunnerOptions<TIn
  */
 export declare function createScheduler(): SchedulerInterface;
 
-/**
- * Wrap a registered tool as a {@link WorkflowFunction} — the OPT-IN adapter that lets a
- * `function`-form task run a `@orkestrel/agent` tool BY NAME.
- *
- * @remarks
- * Composes into a caller's {@link WorkflowOptions.functions} registry like any other behavior
- * (`{ publish: createToolFunction(tools, 'publish') }`); the PURE
- * {@link import('./WorkflowRunner.js').WorkflowRunner} has no knowledge of tools itself. The
- * returned function executes `name` against `tools` with the task's `controller.input` as the
- * call arguments, id-correlated to the task's own id. A `ToolManagerInterface.execute` NEVER
- * throws (a handler throw is isolated into `result.error`), so a failing tool is surfaced here
- * as a THROWN `Error` carrying the original message as `cause` — the leaf `fail`s, honouring
- * `bail`. An UNREGISTERED tool name is a programmer error (an explicit binding to a name that
- * doesn't exist) — unlike the engine's own silent auto-complete of an unresolved task handler,
- * this THROWS a typed `TOOL` {@link WorkflowError}.
- *
- * @param tools - The {@link ToolManagerInterface} the named tool is registered on
- * @param name - The registered tool's name
- * @returns A {@link WorkflowFunction} that runs the named tool
- *
- * @example
- * ```ts
- * import { createToolFunction, createToolManager, createWorkflowRunner } from '@src/core'
- *
- * const tools = createToolManager()
- * tools.add(myPublishTool)
- * const runner = createWorkflowRunner()
- * await runner.execute(definition, { functions: { publish: createToolFunction(tools, 'publish') } })
- * ```
- */
-export declare function createToolFunction(tools: ToolManagerInterface, name: string): WorkflowFunction;
-
 /**
  * Build the live W-b entity tree from a {@link WorkflowDefinition} — the whole
  * {@link WorkflowInterface} → {@link import('./types.js').PhaseInterface} →
@@ -593,32 +436,37 @@ export declare function createWorkflow(definition: WorkflowDefinition, options?:
 export declare function createWorkflowContract(): ContractInterface<WorkflowDefinition>;
 
 /**
- * Compile the LENIENT workflow DRAFT contract — identical to
- * {@link createWorkflowContract} EXCEPT `id` and `name` are OPTIONAL at all three levels
- * (workflow / phase / task), so a small model can omit the six identity strings.
+ * 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
- * The widened authoring surface {@link createWorkflowTool} parses an authored blob through
- * before {@link import('./helpers.js').completeDraft} fills the missing ids/names. It does
- * NOT relax the canonical contract — {@link createWorkflowContract} stays byte-for-byte
- * unchanged and STRICT, and the completed draft is re-validated against THAT strict gate
- * before running (soundness preserved). A PROVIDED `id` / `name` still carries `minLength: 1`,
- * so an explicitly-empty `id: ''` is REJECTED (parses to `undefined`), never auto-filled —
- * keeping "garbage" distinct from "omitted". `run` stays required.
+ * `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.
  *
- * @returns The compiled {@link WorkflowDraft} contract
+ * @param options - The optional `store` seam and the `functions` registry threaded into every mint/hydrate
+ * @returns A working {@link WorkflowManagerInterface}
  *
  * @example
  * ```ts
- * import { createWorkflowDraftContract, completeDraft } from '@src/core'
+ * import { createMemoryWorkflowStore, createWorkflowManager } from '@src/core'
  *
- * const draft = createWorkflowDraftContract()
- * const parsed = draft.parse({ phases: [{ tasks: [{ run: { via: 'function', name: 'f' } }] }] })
- * const definition = parsed && completeDraft(parsed) // ids/names filled positionally
- * draft.parse({ id: '', phases: [] })                // undefined — an explicit empty id is rejected
+ * 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 createWorkflowDraftContract(): ContractInterface<WorkflowDraft>;
+export declare function createWorkflowManager(options?: WorkflowManagerOptions): WorkflowManagerInterface;
 
 /**
  * Create a workflow runner — a {@link WorkflowRunnerInterface} that EXECUTES a live W-b
@@ -641,11 +489,11 @@ export declare function createWorkflowDraftContract(): ContractInterface<Workflo
  * the live entity (`start` → `complete` / `fail`), and resolves a
  * {@link import('./types.js').WorkflowResult}.
  *
- * Static tool / agent calling is OPT-IN, wired through the adapter factories
- * {@link createToolFunction} / {@link createAgentFunction} — plain
- * {@link import('./types.js').WorkflowFunction}s a caller composes into its OWN
- * {@link WorkflowOptions.functions} registry, same as any other behavior. A task with no
- * resolved handler AUTO-COMPLETES (the ROADMAP no-handler rule).
+ * Static tool / agent calling is OPT-IN: a caller wires a plain
+ * {@link import('./types.js').WorkflowFunction} into its OWN {@link WorkflowOptions.functions}
+ * registry, same as any other behavior — the `@orkestrel/tool` package ships the
+ * tool/agent adapter factories for that. A task with no resolved handler AUTO-COMPLETES
+ * (the ROADMAP no-handler rule).
  *
  * @param options - An optional pacing `scheduler` (default the shipped cross-environment one).
  *   See {@link WorkflowRunnerOptions}.
@@ -668,78 +516,6 @@ export declare function createWorkflowDraftContract(): ContractInterface<Workflo
  */
 export declare function createWorkflowRunner(options?: WorkflowRunnerOptions): WorkflowRunnerInterface;
 
-/**
- * Wrap a {@link WorkflowDefinition} as an LLM-callable {@link ToolInterface} — it ADVERTISES
- * the SIMPLE flat authoring shape (`{ name?, steps: [{ name }] }`) as its `parameters` so
- * even a small model can author a complete tree, and its handler EXPANDS / COMPLETES the
- * authored blob, validates it against the STRICT contract, runs it through `runner`, and
- * returns the run SUMMARY (throwing a typed {@link WorkflowError} on failure).
- *
- * @remarks
- * A plain {@link ToolManagerInterface}-compatible tool (so `createMCPServer` / `createMCPRoutes`
- * expose it for free — nothing MCP is wired here). It is ALSO the propagation carrier
- * {@link createAgentFunction} binds onto a wrapped agent's `context.tools`: because a tool
- * handler receives ONLY the model-supplied `args` (no ambient context, no signal), the run's
- * depth + ancestry are CLOSED OVER at bind time via {@link WorkflowToolOptions}, and the
- * handler enforces the SAME depth / cycle guard itself (this function owns it now — the engine
- * carries none) before running the nested workflow at `depth + 1` with the extended ancestry.
- *
- * **Widened authoring surface (additive — the canonical contract + runner stay STRICT and
- * unchanged).** A 2B model reliably CALLS the tool but cannot reliably emit the full four-level
- * nested {@link WorkflowDefinition} (six required `id`/`name` strings, an all-or-nothing tree).
- * So the tool ACCEPTS three authoring forms and converges them on the SAME strict
- * {@link createWorkflowContract} gate before running (soundness preserved):
- * - the FLAT shape `{ name?, steps: [{ name }] }` — the ADVERTISED `parameters` (the simplest
- *   form, {@link import('./helpers.js').expandSteps}'d into one one-task phase per step);
- * - a nested DRAFT with any `id`/`name` OMITTED — {@link createWorkflowDraftContract}-parsed then
- *   {@link import('./helpers.js').completeDraft}'d (missing ids synthesized positionally);
- * - the full nested {@link WorkflowDefinition} — the advanced escape-hatch (documented in the
- *   description), accepted as the draft super-set.
- *
- * The handler conforms to the universal tool-handler contract (AGENTS §14): it returns the PLAIN
- * run-summary VALUE on success and THROWS a typed {@link WorkflowError} on every failure path. It
- * does NOT build a {@link ToolResult} itself — the `@orkestrel/agent` package's `ToolManager`
- * performs the ONE canonical wrap (`{ id, name, value }` on a return; `{ id, name, error }` on a
- * throw, ISOLATED so nothing escapes the run), so the outcome appears EXACTLY ONCE, identically,
- * over BOTH the agent loop and MCP (a throw → MCP `isError: true`):
- * - **No authored args** (an empty `arguments`) ⇒ runs the WRAPPED `definition`.
- * - **A `steps` array** ⇒ the FLAT form: parse it, {@link import('./helpers.js').expandSteps} it.
- * - **Otherwise** ⇒ the nested form: {@link createWorkflowDraftContract}-parse it,
- *   {@link import('./helpers.js').completeDraft} it.
- * - **Strict gate** ⇒ the expanded / completed result is validated against
- *   {@link createWorkflowContract}.`is`; a blob that can't expand, or whose result fails the strict
- *   gate (e.g. an explicit empty `id`, `concurrency: 0`) ⇒ THROW a `TOOL` {@link WorkflowError} (no run).
- * - **Over-deep / cyclic** ⇒ THROW a `DEPTH` {@link WorkflowError} when the nested run would exceed
- *   {@link MAX_WORKFLOW_DEPTH}, or the target workflow id is already an ancestor (a cycle) — the
- *   SAME `code` {@link createAgentFunction}'s own guard raises. Enforced HERE, INSIDE this
- *   handler, before ever calling `runner.execute` — the engine itself performs no such check.
- * - **Otherwise** ⇒ `runner.execute(target)`, RETURNING the plain summary of the terminal run
- *   (`{ status, count }`, via {@link workflowToolSummary}).
- *
- * The tool executes AUTHORED STRUCTURE, not consumer behavior: a nested tree authored through
- * it (flat, draft, or full form) carries no {@link WorkflowFunctions} registry, so EVERY one of
- * its tasks auto-completes under the no-handler rule. This handler validates and synthesizes
- * shape — it never runs a caller's handlers.
- *
- * @param definition - The workflow the tool runs when called with no authored args
- * @param runner - The {@link WorkflowRunnerInterface} that executes the (nested) workflow
- * @param options - The depth + ancestry to run the nested workflow under (see
- *   {@link WorkflowToolOptions}); omitted ⇒ depth `0` / empty ancestry (a top-level wrap)
- * @returns A {@link ToolInterface} (named {@link import('./constants.js').WORKFLOW_TOOL_NAME})
- *   whose `parameters` advertise the FLAT authoring schema (the nested form stays accepted)
- *
- * @example
- * ```ts
- * import { createWorkflowRunner, createWorkflowTool, createToolManager } from '@src/core'
- *
- * const runner = createWorkflowRunner()
- * const tool = createWorkflowTool(definition, runner)
- * const tools = createToolManager()
- * tools.add(tool) // a model can now author + run a workflow in one call
- * ```
- */
-export declare function createWorkflowTool(definition: WorkflowDefinition, runner: WorkflowRunnerInterface, options?: WorkflowToolOptions): ToolInterface;
-
 /**
  * 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
@@ -952,25 +728,6 @@ export declare function derivePhaseStatus(tasks: readonly TaskStatus[]): PhaseSt
  */
 export declare function deriveWorkflowStatus(phases: readonly PhaseDerivation[]): WorkflowStatus;
 
-/**
- * Expand a flat {@link WorkflowSteps} blob into a strict {@link WorkflowDefinition} — each
- * step becomes a one-task phase, IN ORDER.
- *
- * @remarks
- * The expansion of the tool's ADVERTISED surface (AGENTS §21 — the simplest form a small
- * model can author). Each {@link WorkflowStep} maps to a phase holding exactly one task:
- * the step's `name` becomes the task's `run` (the behavior-registry key). Ids/names are
- * auto-filled positionally — it builds an ids-omitted {@link WorkflowDraft} and delegates
- * to {@link completeDraft}, so the two lenient surfaces share ONE synthesis path (step `i`
- * → phase `phase-<i>`, its task `phase-<i>-task-0`). The optional `name` becomes the
- * workflow's `name`. The result is a complete definition the caller validates against the
- * STRICT contract before running.
- *
- * @param flat - The flat steps blob (`{ name?, steps: [{ name }] }`)
- * @returns A complete {@link WorkflowDefinition} (one one-task phase per step)
- */
-export declare function expandSteps(flat: WorkflowSteps): WorkflowDefinition;
-
 /**
  * Box an error as a {@link Failure} — the graceful outcome half of a {@link Result}.
  *
@@ -1104,21 +861,6 @@ export declare function isWorkflowSnapshot(value: unknown): value is WorkflowSna
  */
 export declare type LifecycleStatus = 'pending' | 'running' | 'completed' | 'failed' | 'skipped' | 'stopped';
 
-/**
- * The maximum nesting depth a workflow → agent → workflow chain may reach — the bound
- * the {@link import('./factories.js').createAgentFunction} and
- * {@link import('./factories.js').createWorkflowTool} adapters' depth/cycle guards enforce.
- *
- * @remarks
- * The limit lives in ONE place. An {@link import('./factories.js').createAgentFunction}-wrapped
- * agent running at this depth can no longer author + run a NESTED workflow through its bound
- * workflow tool (that would be depth `MAX_WORKFLOW_DEPTH + 1`), so the over-deep invocation is
- * REJECTED (a typed `DEPTH` {@link import('./errors.js').WorkflowError} throw). The chain
- * therefore nests workflows down to this depth, and the nested run at
- * depth `MAX_WORKFLOW_DEPTH` fails.
- */
-export declare const MAX_WORKFLOW_DEPTH = 8;
-
 /**
  * The in-memory {@link WorkflowStoreInterface} — a process-lifetime `Map` of
  * {@link WorkflowSnapshot}s keyed by workflow id, the DEFAULT store
@@ -1367,38 +1109,6 @@ export declare interface PhaseDerivation {
     readonly bail: boolean;
 }
 
-/** A draft phase — a {@link PhaseDefinition} with OPTIONAL `id` / `name` and {@link TaskDraft} tasks. */
-export declare interface PhaseDraft {
-    readonly id?: string;
-    readonly name?: string;
-    readonly description?: string;
-    readonly tasks: readonly TaskDraft[];
-    /** Max tasks in flight at once (a resource throttle); omitted ⇒ unbounded. */
-    readonly concurrency?: number;
-    /** The per-phase failure-policy OVERRIDE; omitted ⇒ inherits the workflow `bail` (`effectiveBail = phase.bail ?? workflow.bail`). */
-    readonly bail?: boolean;
-}
-
-/**
- * The shape of a PHASE in a draft workflow — identical to {@link phaseShape} EXCEPT
- * `id` and `name` are OPTIONAL, and its tasks are {@link taskDraftShape}s.
- */
-export declare const phaseDraftShape: ObjectShape<{
-    id: OptionalShape<StringShape>;
-    name: OptionalShape<StringShape>;
-    description: OptionalShape<StringShape>;
-    tasks: ArrayShape<ObjectShape<{
-        id: OptionalShape<StringShape>;
-        name: OptionalShape<StringShape>;
-        description: OptionalShape<StringShape>;
-        run: OptionalShape<StringShape>;
-        retries: OptionalShape<NumberShape>;
-        timeout: OptionalShape<NumberShape>;
-    }>>;
-    concurrency: OptionalShape<NumberShape>;
-    bail: OptionalShape<LiteralShape<readonly [true, false]>>;
-}>;
-
 /**
  * The push observation surface (AGENTS §13) of the phase entity (W-b) — analogous
  * to {@link WorkflowEventMap}, scoped to one phase.
@@ -2327,19 +2037,6 @@ export declare interface SchedulerOptions {
  */
 export declare type SchedulerPriority = 'user' | 'normal' | 'background';
 
-/**
- * The shape of ONE flat step — `{ name }` — the building block of
- * {@link workflowStepsShape}.
- *
- * @remarks
- * `name` is the REGISTERED behavior name the step runs (it becomes the task's `run`). The
- * tool expands each step into a one-task phase, in order
- * ({@link import('./helpers.js').expandSteps}).
- */
-export declare const stepShape: ObjectShape<{
-    name: StringShape;
-}>;
-
 /**
  * Box a value as a {@link Success} — the graceful outcome half of a {@link Result}.
  *
@@ -2580,44 +2277,6 @@ export declare interface TaskDefinition {
  */
 export declare function taskDefinitionToSnapshot(task: WorkflowDefinition['phases'][number]['tasks'][number]): TaskSnapshot;
 
-/**
- * A draft task — a {@link TaskDefinition} with OPTIONAL `id` / `name`.
- *
- * @remarks
- * The tool synthesizes a missing `id` positionally and defaults a missing `name` to
- * its `id` ({@link import('./helpers.js').completeDraft}). A PROVIDED `id` / `name` is
- * preserved verbatim (and must be non-empty — the draft contract's `minLength: 1`).
- */
-export declare interface TaskDraft {
-    readonly id?: string;
-    readonly name?: string;
-    readonly description?: string;
-    /** The behavior reference — a registry key resolved against {@link WorkflowFunctions} at construction; omitted ⇒ no handler. */
-    readonly run?: string;
-    /** Extra attempts after the first on failure (a non-negative integer); overrides the phase Runner default. Execution-only. */
-    readonly retries?: number;
-    /** The per-attempt deadline in milliseconds (a non-negative integer); overrides the phase Runner default. Execution-only. */
-    readonly timeout?: number;
-}
-
-/**
- * The shape of a TASK in a draft workflow — identical to {@link taskShape} EXCEPT `id`
- * and `name` are OPTIONAL (the tool synthesizes any missing one positionally).
- *
- * @remarks
- * A PROVIDED `id` / `name` still carries `minLength: 1`, so an explicitly-empty `id: ''`
- * is INVALID (rejected by the draft contract), never auto-filled — keeping "garbage"
- * distinct from "omitted". `run` stays optional, mirroring {@link taskShape}.
- */
-export declare const taskDraftShape: ObjectShape<{
-    id: OptionalShape<StringShape>;
-    name: OptionalShape<StringShape>;
-    description: OptionalShape<StringShape>;
-    run: OptionalShape<StringShape>;
-    retries: OptionalShape<NumberShape>;
-    timeout: OptionalShape<NumberShape>;
-}>;
-
 /**
  * The push observation surface (AGENTS §13) of the task entity (W-b) — the
  * lifecycle moments of one task.
@@ -3100,64 +2759,6 @@ export declare class Workflow implements WorkflowInterface {
 /** Every {@link WorkflowStatus} value, frozen — the lifecycle vocabulary of a workflow. */
 export declare const WORKFLOW_STATUSES: readonly WorkflowStatus[];
 
-/**
- * The DESCRIPTION {@link import('./factories.js').createWorkflowTool} advertises — a
- * multi-line guide that teaches a small model how to author a complete workflow tree.
- *
- * @remarks
- * Presents the SIMPLE flat shape (`{ name, steps: [{ name }] }`) as the PRIMARY way with
- * one complete worked example ({@link WORKFLOW_TOOL_FLAT_EXAMPLE}), names that a step's
- * `name` is a REGISTERED name (not a human label), and documents the full nested
- * {@link WorkflowDefinition} as the ADVANCED form with a minimal example
- * ({@link WORKFLOW_TOOL_NESTED_EXAMPLE}). Both examples are interpolated VERBATIM from the
- * validated constants, so a parity test pins them — the description can never drift from a
- * real, contract-valid example. The `parameters` the tool advertises are the FLAT shape's
- * schema; the nested form is the documented escape-hatch (the tool accepts both). NOTE: a step's
- * "registered behavior name" is authored STRUCTURE only —
- * {@link import('./factories.js').createWorkflowTool} runs the authored tree with no
- * {@link WorkflowFunctions} registry of its own, so every one of its tasks auto-completes under
- * the no-handler rule; the tool validates/synthesizes shape, it does not dispatch behavior.
- */
-export declare const WORKFLOW_TOOL_DESCRIPTION: string;
-
-/**
- * A complete FLAT authoring example — the PRIMARY way a small model authors a workflow
- * through {@link import('./factories.js').createWorkflowTool}: `{ name, steps: [{ name }] }`.
- *
- * @remarks
- * Each step becomes a one-task phase, in order; a step's `name` is a REGISTERED behavior name
- * (not a label) — the registry key its task's `run` resolves against. The tool expands this
- * ({@link import('./helpers.js').expandSteps}) into a valid {@link WorkflowDefinition}. It
- * is embedded VERBATIM in {@link WORKFLOW_TOOL_DESCRIPTION} and guarded by a parity test
- * (it must expand to a tree the STRICT contract accepts), so the doc example can never drift.
- */
-export declare const WORKFLOW_TOOL_FLAT_EXAMPLE: WorkflowSteps;
-
-/**
- * The name under which {@link import('./factories.js').createAgentFunction} BINDS the
- * depth/cycle-aware workflow tool onto a wrapped agent's `context.tools` (`AgentContextInterface`,
- * `@orkestrel/agent`).
- *
- * @remarks
- * The propagation seam's well-known key: when its `runner` option is supplied, the adapter adds a
- * {@link import('./factories.js').createWorkflowTool}-built tool under this name to the
- * agent's `context.tools`, so it can author + run a NESTED workflow (bounded by
- * {@link MAX_WORKFLOW_DEPTH}). An agent that wants to fan out into a workflow calls this tool by
- * this name; the bound handler runs the nested workflow at depth + 1.
- */
-export declare const WORKFLOW_TOOL_NAME = "workflow";
-
-/**
- * A minimal NESTED authoring example — the ADVANCED escape-hatch form a model may use
- * instead of the flat shape: a full {@link WorkflowDefinition}.
- *
- * @remarks
- * The full four-level form, documented in {@link WORKFLOW_TOOL_DESCRIPTION} as the advanced
- * alternative. It is embedded VERBATIM and guarded by a parity test (`createWorkflowContract().is`
- * must accept it), so the doc example can never drift from a valid definition.
- */
-export declare const WORKFLOW_TOOL_NESTED_EXAMPLE: WorkflowDefinition;
-
 /**
  * The ambient context of a workflow — the identity every level inherits.
  *
@@ -3193,60 +2794,6 @@ export declare interface WorkflowDefinition {
     readonly bail?: boolean;
 }
 
-/**
- * A draft workflow — a {@link WorkflowDefinition} with OPTIONAL `id` / `name` at all
- * three levels (workflow / phase / task).
- *
- * @remarks
- * The lenient authoring form `createWorkflowDraftContract` validates and
- * {@link import('./helpers.js').completeDraft} completes into a strict
- * {@link WorkflowDefinition}. `run` stays optional (a plain name string); the `bail`
- * policy carries over.
- */
-export declare interface WorkflowDraft {
-    readonly id?: string;
-    readonly name?: string;
-    readonly description?: string;
-    readonly phases: readonly PhaseDraft[];
-    /** Failure policy: `false` (default) continues gracefully, `true` halts on the first failure. */
-    readonly bail?: boolean;
-}
-
-/**
- * The shape of a DRAFT workflow — identical to {@link workflowShape} EXCEPT `id` and
- * `name` are OPTIONAL at all three levels (workflow / phase / task), so a small model
- * can omit the six identity strings and let the tool synthesize them positionally.
- *
- * @remarks
- * The lenient counterpart {@link import('./factories.js').createWorkflowDraftContract}
- * compiles. `run` stays required; a provided `id` / `name` still has `minLength: 1` (so an
- * explicitly-empty `id: ''` is REJECTED, not auto-filled). After
- * {@link import('./helpers.js').completeDraft} fills the missing ids/names, the result is
- * validated against the STRICT {@link import('./factories.js').createWorkflowContract} gate
- * before running.
- */
-export declare const workflowDraftShape: ObjectShape<{
-    id: OptionalShape<StringShape>;
-    name: OptionalShape<StringShape>;
-    description: OptionalShape<StringShape>;
-    phases: ArrayShape<ObjectShape<{
-        id: OptionalShape<StringShape>;
-        name: OptionalShape<StringShape>;
-        description: OptionalShape<StringShape>;
-        tasks: ArrayShape<ObjectShape<{
-            id: OptionalShape<StringShape>;
-            name: OptionalShape<StringShape>;
-            description: OptionalShape<StringShape>;
-            run: OptionalShape<StringShape>;
-            retries: OptionalShape<NumberShape>;
-            timeout: OptionalShape<NumberShape>;
-        }>>;
-        concurrency: OptionalShape<NumberShape>;
-        bail: OptionalShape<LiteralShape<readonly [true, false]>>;
-    }>>;
-    bail: OptionalShape<LiteralShape<readonly [true, false]>>;
-}>;
-
 /**
  * An error thrown by the workflow entity + W-c2 recursion layer.
  *
@@ -3255,11 +2802,11 @@ export declare const workflowDraftShape: ObjectShape<{
  * offending node id / status. Thrown for an illegal lifecycle transition
  * (`TRANSITION`), a structurally invalid {@link import('./types.js').WorkflowSnapshot}
  * passed to {@link import('./factories.js').restoreWorkflow} (`RESTORE`), an over-deep /
- * cyclic nested-workflow dispatch (`DEPTH`), and a malformed
- * {@link import('./factories.js').createWorkflowTool} args blob (`TOOL`). On the
- * workflow-tool seam the `DEPTH` / `TOOL` throw is ISOLATED by the
- * `@orkestrel/agent` package's `ToolManager` into the tool result's
- * top-level `error` (AGENTS §14 — the universal tool-handler contract).
+ * cyclic nested-workflow dispatch (`DEPTH`), and a malformed workflow-authoring-tool args
+ * blob (`TOOL`). `DEPTH` and `TOOL` are public type surface constructed by the
+ * `@orkestrel/tool` package's workflow-tool / agent-function adapters; on that seam the
+ * throw is ISOLATED by its `ToolManager` into the tool result's top-level `error`
+ * (AGENTS §14 — the universal tool-handler contract).
  */
 export declare class WorkflowError extends Error {
     readonly code: WorkflowErrorCode;
@@ -3277,21 +2824,21 @@ export declare class WorkflowError extends Error {
  *   the offending current status + requested transition in the error `context`.
  * - `RESTORE` — a {@link import('./factories.js').restoreWorkflow} given a structurally
  *   invalid {@link WorkflowSnapshot} (a status outside the lifecycle vocabulary).
- * - `DEPTH` — a nested-workflow dispatch (W-c2) that the runner's depth / cycle guard
- *   rejected: running it would push the nested-workflow chain past
- *   {@link import('./constants.js').MAX_WORKFLOW_DEPTH}, OR its target agent (or a
- *   workflow it would author) is already an ancestor of the current run (a re-entry
- *   cycle). Raised on BOTH seams of the W-c2 recursion — an `agent`-task dispatch
- *   (`fail`ed with this code; it never runs) AND the
- *   {@link import('./factories.js').createWorkflowTool} handler (thrown, then ISOLATED
- *   by the `@orkestrel/agent` package's `ToolManager` into the tool
- *   result's `error`). The error `context` names the offending agent / workflow id + the depth.
- * - `TOOL` — the {@link import('./factories.js').createWorkflowTool} handler was handed
- *   a MALFORMED / over-constraint authored args blob (e.g. an empty `id`, `concurrency: 0`)
- *   that the contract rejected, so no workflow ran. The handler THROWS it (rather than
- *   returning a failure result), and the `@orkestrel/agent` package's `ToolManager`
- *   ISOLATES the throw into the canonical tool result's top-level `error` (AGENTS §14 — the
- *   universal tool-handler contract); the error `context` names the wrapped workflow id.
+ * - `DEPTH` — a nested-workflow dispatch (W-c2) that a depth / cycle guard rejected:
+ *   running it would push the nested-workflow chain past a bounded max depth, OR its
+ *   target agent (or a workflow it would author) is already an ancestor of the current
+ *   run (a re-entry cycle). Public type surface consumed by the `@orkestrel/tool`
+ *   package's workflow-tool / agent-function adapters, which construct
+ *   {@link import('./errors.js').WorkflowError}s with this code (thrown, then ISOLATED
+ *   by that package's `ToolManager` into the tool result's `error`). The error `context`
+ *   names the offending agent / workflow id + the depth.
+ * - `TOOL` — a workflow-authoring tool handler (in `@orkestrel/tool`) was handed a
+ *   MALFORMED / over-constraint authored args blob (e.g. an empty `id`, `concurrency: 0`)
+ *   that {@link import('./factories.js').createWorkflowContract} rejected, so no workflow
+ *   ran. Public type surface: `@orkestrel/tool` constructs this code and THROWS it
+ *   (rather than returning a failure result); its `ToolManager` ISOLATES the throw into
+ *   the canonical tool result's top-level `error` (AGENTS §14 — the universal
+ *   tool-handler contract); the error `context` names the wrapped workflow id.
  * - `MUTATION` — a GATED structural or patch edit was refused: a duplicate id on
  *   `append`/`add`, a target that does not exist or is not `pending`, an out-of-bounds
  *   `index`, a patch that failed shaper validation, or a live structural edit refused by
@@ -3588,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}
@@ -3670,10 +3401,10 @@ export declare interface WorkflowResult {
  *   {@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". Static tool / agent calling is an
- *   OPT-IN concern of `factories.ts`'s adapter factories ({@link import('./factories.js').createToolFunction},
- *   {@link import('./factories.js').createAgentFunction}) — plain {@link import('./types.js').WorkflowFunction}s a
- *   caller wires into {@link WorkflowOptions.functions} like any other behavior. This module
- *   never imports `@orkestrel/agent`.
+ *   OPT-IN concern of the `@orkestrel/tool` package's adapter factories — plain
+ *   {@link import('./types.js').WorkflowFunction}s a caller wires into
+ *   {@link WorkflowOptions.functions} like any other behavior. This module never imports
+ *   any tool/agent package.
  * - **Two `execute` forms, one engine.** `execute(definition, options)` BUILDS the live tree
  *   from a {@link WorkflowDefinition} (single source of truth for the `run` / `concurrency`
  *   metadata); `execute(workflow, options)` DRIVES a caller-owned, ALREADY-BUILT
@@ -3910,9 +3641,8 @@ export declare interface WorkflowRunnerInterface {
  * The runner is a PURE engine — it carries no `functions` / `tools` / `agents` registry
  * (each live task already resolved its own handler at construction from
  * {@link WorkflowOptions.functions}); wiring a `function`-form task to a tool or an agent is
- * an OPT-IN concern of `factories.ts`'s adapter factories
- * ({@link import('./factories.js').createToolFunction}, {@link import('./factories.js').createAgentFunction}),
- * which a caller composes into its OWN `functions` registry.
+ * an OPT-IN concern of the `@orkestrel/tool` package's adapter factories, which a caller
+ * composes into its OWN `functions` registry.
  * - `scheduler` — the {@link SchedulerInterface} that paces the tree (a cooperative
  *   `yield` between phases). Omitted ⇒ the shipped cross-environment default
  *   ({@link createScheduler}).
@@ -3957,8 +3687,8 @@ export declare interface WorkflowRunnerOptions {
  *
  * The engine itself carries NO nesting bookkeeping — the depth / cycle guard for a nested
  * `agent` → workflow-tool → workflow chain lives entirely in the OPT-IN adapter factories
- * ({@link import('./factories.js').createAgentFunction}, {@link import('./factories.js').createWorkflowTool}),
- * closed over their own `depth` / `ancestry`, never threaded through `execute`'s options.
+ * shipped by `@orkestrel/tool`, closed over their own `depth` / `ancestry`, never threaded
+ * through `execute`'s options.
  */
 export declare type WorkflowRunOptions = WorkflowOptions & {
     readonly signal?: AbortSignal;
@@ -4057,54 +3787,6 @@ export declare interface WorkflowSnapshotRow {
  */
 export declare type WorkflowStatus = LifecycleStatus;
 
-/**
- * One flat step — `{ name }` — the building block of a {@link WorkflowSteps} blob.
- *
- * @remarks
- * `name` is the REGISTERED behavior name the step runs (it becomes the task's `run`,
- * NOT a human label) — resolved against a workflow-level {@link WorkflowFunctions}
- * registry at construction.
- */
-export declare interface WorkflowStep {
-    /** The registered behavior name this step runs (becomes the task's `run`). */
-    readonly name: string;
-}
-
-/**
- * The FLAT authoring blob `createWorkflowTool` advertises — `{ name?, steps }` — the
- * simplest surface a small model can fill.
- *
- * @remarks
- * Each {@link WorkflowStep} becomes a one-task phase, in order
- * ({@link import('./helpers.js').expandSteps}); `name` is the optional workflow name
- * (defaulted when omitted). The expanded tree is validated against the STRICT
- * {@link import('./factories.js').createWorkflowContract} gate before running.
- */
-export declare interface WorkflowSteps {
-    readonly name?: string;
-    readonly steps: readonly WorkflowStep[];
-}
-
-/**
- * The FLAT authoring shape `createWorkflowTool` advertises as its `parameters` — the
- * simplest surface a small model can fill: `{ name?, steps: [{ name }] }`.
- *
- * @remarks
- * The deliberately-reduced surface (AGENTS §21): a flat ordered list of steps, each a
- * `{ name }`. The tool EXPANDS it ({@link import('./helpers.js').expandSteps}) into a
- * full {@link import('./types.js').WorkflowDefinition} — one one-task phase per step, in
- * order — then validates against the STRICT
- * {@link import('./factories.js').createWorkflowContract} gate. The full nested form is
- * STILL accepted by the tool (it branches on the args' shape) and is documented as the
- * advanced escape-hatch in the tool's description — but THIS is what `parameters` advertises.
- */
-export declare const workflowStepsShape: ObjectShape<{
-    name: OptionalShape<StringShape>;
-    steps: ArrayShape<ObjectShape<{
-        name: StringShape;
-    }>>;
-}>;
-
 /**
  * The durable persistence seam for a {@link WorkflowSnapshot} — three async primitives
  * (`get` / `set` / `delete`) keyed by a workflow id, the snapshot analogue of
@@ -4152,69 +3834,4 @@ export declare interface WorkflowStoreInterface {
     delete(id: string): Promise<void>;
 }
 
-/**
- * The ancestry identifier of a workflow run — `workflow:<id>`.
- *
- * @remarks
- * The {@link import('./WorkflowRunner.js').WorkflowRunner}'s cycle guard records one of
- * these per workflow in the current nested run chain (carried on
- * {@link import('./types.js').WorkflowRunOptions.ancestry}). Tagging the bare id keeps a
- * workflow id and an {@link agentTag} agent name in ONE namespaced set without collision,
- * so re-entering a workflow OR an agent already in the chain is a single `includes` check.
- *
- * @param id - The workflow definition's `id`
- * @returns The namespaced ancestry tag (`workflow:<id>`)
- */
-export declare function workflowTag(id: string): string;
-
-/**
- * Options for {@link import('./factories.js').createWorkflowTool} — the depth + ancestry the
- * wrapped {@link WorkflowDefinition} runs the NESTED workflow at when an LLM invokes the tool.
- *
- * @remarks
- * This is the PROPAGATION carrier across the agent/tool boundary. A `Tool`'s handler receives
- * ONLY the model-supplied `args` (no ambient context, no signal — see
- * the `@orkestrel/agent` package's `ToolOptions`), so the run's position in the
- * workflow→agent→workflow chain CANNOT be threaded through a tool call at runtime. Instead the
- * runner CLOSES it over the tool at BIND time: when it dispatches an `agent` task at depth `D`
- * with ancestry `A`, it builds the agent's workflow tool with `{ depth: D, ancestry: A }`, so
- * the handler's closure carries them. On invocation the handler runs the nested workflow at
- * `depth: D + 1` with `ancestry: A ∪ { workflow:<id> }` — bounded by
- * {@link import('./constants.js').MAX_WORKFLOW_DEPTH} (an over-deep / cyclic nested run THROWS a
- * typed `DEPTH` {@link import('./errors.js').WorkflowError}, which the `ToolManager` isolates into
- * the tool result's top-level `error`, AGENTS §14).
- *
- * Both fields are OPTIONAL: a workflow tool built for a TOP-LEVEL caller (not by the runner's
- * agent-task binding) omits them — its nested run starts the chain at depth `1` with the bare
- * `workflow:<id>` ancestry.
- */
-export declare interface WorkflowToolOptions {
-    /** The depth the INVOKING agent runs at; the nested workflow runs at `depth + 1`. Default `0`. */
-    readonly depth?: number;
-    /** The ancestry of the invoking run; the nested run extends it with its own `workflow:<id>`. Default empty. */
-    readonly ancestry?: readonly string[];
-}
-
-/**
- * Summarize a terminal {@link WorkflowResult} into the PLAIN value a
- * {@link import('./factories.js').createWorkflowTool} handler returns on success.
- *
- * @remarks
- * This is the run summary the handler returns DIRECTLY — NOT a `ToolResult` (the future `@orkestrel/agent` package).
- * The handler conforms to the universal tool-handler contract (AGENTS §14): it returns the plain value
- * (and throws on failure), so the `@orkestrel/agent` package's `ToolManager` performs
- * the ONE canonical wrap (`{ id, name, value }`) and the model reads exactly this summary — once,
- * identically — over BOTH the agent loop and MCP. The summary is LEAN: the workflow's terminal `status`
- * and the COUNT of settled task results — enough for a caller / model to react without serializing the
- * whole live tree. (It carries no synthetic `id` / `name`: a tool handler has no call id; the manager
- * supplies the canonical envelope's identity.)
- *
- * @param result - The terminal {@link WorkflowResult} the run produced
- * @returns The plain success summary — `{ status, count }`
- */
-export declare function workflowToolSummary(result: WorkflowResult): Readonly<{
-    status: WorkflowStatus;
-    count: number;
-}>;
-
 export { }