@orkestrel/toolbox 0.0.1 → 0.0.2

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

@@ -2,18 +2,16 @@ import { AgentInterface } from '@orkestrel/agent';
 import { AgentRegistryInterface } from '@orkestrel/agent';
 import { ArrayShape } from '@orkestrel/contract';
 import { BooleanShape } from '@orkestrel/contract';
-import { ColumnSchema } from '@orkestrel/database';
 import { Condition } from '@orkestrel/database';
-import { Connector } from '@orkestrel/database';
+import { ConditionConnector } from '@orkestrel/database';
 import { ContractInterface } from '@orkestrel/contract';
 import { ContractShape } from '@orkestrel/contract';
 import { ConversationStoreInterface } from '@orkestrel/agent';
-import { Criteria } from '@orkestrel/database';
 import { DatabaseErrorCode } from '@orkestrel/database';
 import { DatabaseInterface } from '@orkestrel/database';
-import { Direction } from '@orkestrel/database';
 import { DriverInterface } from '@orkestrel/database';
 import { Include } from '@orkestrel/relation';
+import { IndexMap } from '@orkestrel/database';
 import { JSONShape } from '@orkestrel/contract';
 import { KeyFunction } from '@orkestrel/database';
 import { LiteralShape } from '@orkestrel/contract';
@@ -21,25 +19,29 @@ import { ModelInterface } from '@orkestrel/relation';
 import { NumberShape } from '@orkestrel/contract';
 import { ObjectShape } from '@orkestrel/contract';
 import { OptionalShape } from '@orkestrel/contract';
+import { OrderDirection } from '@orkestrel/database';
+import { PrimaryMap } from '@orkestrel/database';
 import { PromptType } from '@orkestrel/terminal';
+import { QueryInput } from '@orkestrel/database';
 import { RelationErrorCode } from '@orkestrel/relation';
 import { RelationManagerInterface } from '@orkestrel/relation';
 import { StringShape } from '@orkestrel/contract';
 import { TableInterface } from '@orkestrel/database';
-import { TableSchema } from '@orkestrel/database';
-import { TablesShape } from '@orkestrel/database';
+import { TableMap } from '@orkestrel/database';
 import { TerminalManagerInterface } from '@orkestrel/terminal';
 import { ToolInterface } from '@orkestrel/tool';
 import { ToolManagerInterface } from '@orkestrel/tool';
 import { UnionShape } from '@orkestrel/contract';
 import { WorkflowDefinition } from '@orkestrel/workflow';
+import { WorkflowFault } from '@orkestrel/workflow';
 import { WorkflowFunction } from '@orkestrel/workflow';
+import { WorkflowFunctions } from '@orkestrel/workflow';
 import { WorkflowResult } from '@orkestrel/workflow';
 import { WorkflowRunnerInterface } from '@orkestrel/workflow';
 import { WorkflowStatus } from '@orkestrel/workflow';
 import { WorkflowStoreInterface } from '@orkestrel/workflow';
-import { WorkspaceManagerInterface } from '@orkestrel/agent';
-import { WorkspaceStoreInterface } from '@orkestrel/agent';
+import { WorkspaceManagerInterface } from '@orkestrel/workspace';
+import { WorkspaceStoreInterface } from '@orkestrel/workspace';
 
 /**
  * The maximum nesting depth a delegation chain (agent tool → sub-agent → agent tool → …) may
@@ -55,6 +57,10 @@ import { WorkspaceStoreInterface } from '@orkestrel/agent';
  */
 export declare const AGENT_TOOL_DEPTH = 8;
 
+/**
+ * The description {@link import('./factories.js').createAgentTool} advertises — a short guide
+ * covering the required task and optional provider, tools, and system overrides.
+ */
 export declare const AGENT_TOOL_DESCRIPTION: string;
 
 /**
@@ -72,30 +78,35 @@ export declare const AGENT_TOOL_NAME = "agent";
  */
 export declare const AGENT_TOOL_SUMMARY = "Delegate a task to a sub-agent and return its result; each call runs one sub-agent turn to completion. Call describe('agent') for the optional provider/tools/system overrides.";
 
+/** A contextual agent adapter carrying immutable metadata for Toolbox composition. */
+export declare type AgentFunction = WorkflowFunction & {
+    readonly category: 'agent';
+    readonly lineage: WorkflowLineage;
+};
+
 /**
  * Options for {@link import('./factories.js').createAgentFunction} — the OPT-IN adapter that
- * wraps a live `AgentInterface` (`@orkestrel/agent`) as a `WorkflowFunction`
- * (`@orkestrel/workflow`), folding a nested workflow-authoring depth / cycle guard into its
- * closure.
+ * wraps a live `AgentInterface` (`@orkestrel/agent`) as an {@link AgentFunction} with immutable
+ * lineage metadata and optional nested-workflow composition.
  *
  * @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
+ * All fields are optional. An empty lineage is resolved from the controller's root workflow when
+ * the adapter runs; a configured lineage must already identify that exact workflow.
+ * - `runner` — when supplied, the adapter binds a recursion-safe
  *   {@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
+ *   propagation seam), so the agent can author and 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` `WorkflowError`
- *   (`@orkestrel/workflow`).
+ * - `lineage` — the immutable alternating workflow/agent chain for this adapter's workflow.
+ * - `functions` — opaque host-owned leaf functions propagated unchanged.
+ * - `agents` — raw live agents Toolbox contextually adapts for each target workflow.
+ * - `store` — the native runner checkpoint store propagated through nested runs.
  */
 export declare interface AgentFunctionOptions {
     readonly runner?: WorkflowRunnerInterface;
-    readonly depth?: number;
-    readonly ancestry?: readonly string[];
+    readonly lineage?: WorkflowLineage;
+    readonly functions?: WorkflowFunctions;
+    readonly agents?: WorkflowAgents;
+    readonly store?: WorkflowStoreInterface;
 }
 
 /**
@@ -104,7 +115,7 @@ export declare interface AgentFunctionOptions {
  * @remarks
  * The agent counterpart of {@link workflowTag}: {@link import('./factories.js').createAgentFunction}
  * / {@link import('./factories.js').createWorkflowTool} guard against re-entering an agent or
- * workflow already in the chain (a typed `DEPTH` `WorkflowError`, `@orkestrel/workflow`). The
+ * workflow already in the chain (this package's typed `DEPTH` `ToolboxError`). The
  * `agent:` namespace keeps it distinct from a same-string workflow id.
  *
  * @param name - The agent's identifier / registry name
@@ -187,6 +198,7 @@ export declare const agentToolShape: ObjectShape<{
     system: OptionalShape<StringShape>;
 }, false>;
 
+/** The pending/answer protocol {@link import('./factories.js').createAnswerTool} advertises. */
 export declare const ANSWER_TOOL_DESCRIPTION: string;
 
 /**
@@ -246,33 +258,33 @@ export declare const answerToolShape: UnionShape<readonly [ ObjectShape<{
 }, false>]>;
 
 /**
- * Clamp a `'records'` call's criteria to a row cap, and build the PROBE criteria the caller reads
+ * Clamp a `'records'` call's query to a row cap, and build the PROBE query the caller reads
  * with — the pure leaf {@link import('./factories.js').createDatabaseTool}'s `'records'` operation
  * uses to detect truncation without a separate `count` round trip.
  *
  * @remarks
- * The effective limit is `min(criteria?.limit ?? cap, cap)`, floored at `0` (so a caller can never
- * exceed the configured cap by supplying a larger `criteria.limit`). The returned probe criteria
+ * The effective limit is `min(query?.limit ?? cap, cap)`, floored at `0` (so a caller can never
+ * exceed the configured cap by supplying a larger `query.limit`). The returned probe query
  * requests ONE MORE row than the effective limit (`limit: effective + 1`) — if storage returns
  * that many, the caller knows the true result was truncated (`rows.length > effective`) and slices
  * back down to `effective` before returning.
  *
  * @example
  * ```ts
- * import { clampCriteria } from '@src/core'
+ * import { clampQuery } from '@src/core'
  *
- * const { criteria, limit } = clampCriteria(undefined, 100)
- * // limit === 100, criteria.limit === 101 — a probe fetching one extra row
- * const rows = await table.records(criteria)
+ * const { query, limit } = clampQuery(undefined, 100)
+ * // limit === 100, query.limit === 101 — a probe fetching one extra row
+ * const rows = await table.records(query)
  * const truncated = rows.length > limit // true when storage had more than `limit` rows
  * ```
  *
- * @param criteria - The live criteria to clamp (or `undefined`)
+ * @param query - The live query to clamp (or `undefined`)
  * @param cap - The row-count ceiling
- * @returns The PROBE criteria (`limit` bumped by one) and the effective `limit`
+ * @returns The PROBE query (`limit` bumped by one) and the effective `limit`
  */
-export declare function clampCriteria(criteria: Criteria | undefined, cap: number): Readonly<{
-    criteria: Criteria;
+export declare function clampQuery(query: QueryInput | undefined, cap: number): Readonly<{
+    query: QueryInput;
     limit: number;
 }>;
 
@@ -304,9 +316,6 @@ export declare type ColumnKind = 'string' | 'integer' | 'number' | 'boolean';
 /** A {@link import('./types.js').ColumnKind} literal — the leaf {@link columnSpecShape} wraps. */
 export declare const columnKindShape: LiteralShape<readonly ["string", "integer", "number", "boolean"]>;
 
-/** Map a column NAME + its live `@orkestrel/database` `ContractShape` to a {@link ColumnSchema} — the leaf {@link tableSchema} maps over. */
-export declare function columnSchema(name: string, shape: ContractShape): ColumnSchema;
-
 /** Compile one {@link ColumnSpec} into its `@orkestrel/database` column shape — the per-column leaf {@link expandTables} maps over. */
 export declare function columnShape(spec: ColumnSpec): ContractShape;
 
@@ -377,34 +386,29 @@ export declare const conditionShape: ObjectShape<{
 
 /**
  * Wrap a live `AgentInterface` (`@orkestrel/agent`) as a {@link WorkflowFunction}
- * (`@orkestrel/workflow`) — 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
- * OWNED here now (ported from `@orkestrel/workflow`). Composes into a caller's
- * `WorkflowOptions.functions` registry like any other behavior; the pure workflow runner has no
- * knowledge of agents itself. Before running the agent, the depth/cycle guard REJECTS the call
- * (a THROWN typed `DEPTH` `WorkflowError`, which the leaf `fail`s) when running it would push a
- * nested chain past {@link import('./constants.js').MAX_WORKFLOW_DEPTH}, OR when this agent is
- * already an ancestor (a cycle). When {@link import('./types.js').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 `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.
+ * (`@orkestrel/workflow`) — the opt-in adapter that runs the agent to a settled result and carries
+ * immutable lineage metadata for contextual Toolbox composition.
+ *
+ * @remarks
+ * Composes into a caller's registry like any other behavior; the pure workflow runner has no
+ * knowledge of agents itself. A root adapter derives its workflow lineage from the controller,
+ * while a contextual adapter requires an exact match. Repeated agents, repeated workflows, and
+ * targets deeper than {@link import('./constants.js').MAX_WORKFLOW_DEPTH} are rejected before
+ * agent or runner activity. When {@link import('./types.js').AgentFunctionOptions.runner} is
+ * supplied, the adapter binds a recursion-safe {@link createWorkflowTool} onto the agent's
+ * `context.tools`, propagating opaque leaves, raw agents, lineage, and the native store. The
+ * task's cancellation propagates through the Agent's native per-run signal seam:
+ * `agent.generate({ signal: controller.signal })` resolves a partial `AgentResult` on a cancel
+ * (never rejects), projected onto its exact JSON fields.
+ *
+ * A bound agent is single-run. A concurrent branch sharing the same real agent is rejected before
+ * its fixed {@link import('./constants.js').WORKFLOW_TOOL_NAME} binding can be replaced. Toolbox
+ * cannot serialize opaque external wrappers that hide or bypass the raw agent registry; hosts
+ * must give such concurrent work distinct agents.
  *
  * @param agent - The live `AgentInterface` to run
- * @param options - The nested-workflow binding + depth/cycle bookkeeping (see {@link import('./types.js').AgentFunctionOptions})
- * @returns A {@link WorkflowFunction} that runs `agent` to its settled result
+ * @param options - The nested-workflow composition and lineage options
+ * @returns A frozen {@link AgentFunction} that runs `agent` to its settled result
  *
  * @example
  * ```ts
@@ -416,7 +420,7 @@ export declare const conditionShape: ObjectShape<{
  * await runner.execute(definition, { functions: { review } })
  * ```
  */
-export declare function createAgentFunction(agent: AgentInterface, options?: AgentFunctionOptions): WorkflowFunction;
+export declare function createAgentFunction(agent: AgentInterface, options?: AgentFunctionOptions): AgentFunction;
 
 /**
  * Build an LLM-callable sub-agent delegation tool — resolves a live, seeded `AgentInterface`
@@ -532,20 +536,18 @@ export declare function createDatabaseDefinitionStore(driver?: DriverInterface):
  * `TOOL` {@link import('./errors.js').ToolboxError}). When a `store` is configured, `'create'`
  * persists the new {@link import('./types.js').DatabaseDefinition} and `'destroy'` deletes it.
  *
- * `'migrate'` re-declares a LIVE handle's tables via `DatabaseInterface.import` (the SAME driver
- * and storage, a NEW typed view) and calls its `migrate` against the OLD deployed schema —
- * derived from the handle's OWN `export()` (via {@link import('./helpers.js').tableSchema}), so it
- * works for any handle, config-tracked or caller-supplied via
- * {@link import('./types.js').DatabaseToolOptions.databases}. `'records'` clamps its `criteria` to
+ * `'records'` clamps its `query` to
  * {@link import('./types.js').DatabaseToolOptions.limit} (default
  * {@link import('./constants.js').DATABASE_TOOL_LIMIT}) via
- * {@link import('./helpers.js').clampCriteria}, reporting `truncated` when storage held more rows
- * than the cap. Every operation's `criteria` is normalized via
- * {@link import('./helpers.js').criteriaOf} (defaults an omitted condition `connector` to `'and'`).
+ * {@link import('./helpers.js').clampQuery}, reporting `truncated` when storage held more rows
+ * than the cap. Every operation's `query` is normalized via
+ * {@link import('./helpers.js').queryOf} (defaults an omitted condition `connector` to `'and'`).
  * When {@link import('./types.js').DatabaseToolOptions.readonly} is `true`, every mutating
- * operation throws a typed `TOOL` `ToolboxError` before doing anything. When
- * {@link import('./types.js').DatabaseToolOptions.timeout} is set, every `@orkestrel/database` call
- * this tool makes is given a fresh `AbortSignal.timeout(timeout)`. A typed `@orkestrel/database`
+ * operation throws a typed `TOOL` `ToolboxError` before doing anything. A configured
+ * {@link import('./types.js').DatabaseToolOptions.timeout} is passed as a fresh
+ * `AbortSignal.timeout(timeout)` only to table operations whose current database API accepts
+ * operation options (`records`, `count`, `aggregate`, `add`, `set`, `update`, and `remove`). It is
+ * not an outer deadline for resolution, construction, schema inspection, `get`, or `close`. A typed `@orkestrel/database`
  * failure (`DatabaseError`) re-surfaces as a typed `DATABASE` `ToolboxError` carrying the
  * original {@link import('@orkestrel/database').DatabaseErrorCode} in `context.code`
  * ({@link import('./helpers.js').databaseToolCode}); an `ToolboxError` thrown by this tool's own
@@ -840,7 +842,7 @@ export declare function createPromptTool(options: PromptToolOptions): ToolInterf
  * (positional many-key form, AGENTS §9.2) or a single key. `'find'` and `'links'` clamp their
  * result to {@link import('./types.js').RelationToolOptions.limit} (default
  * {@link import('./constants.js').RELATION_TOOL_LIMIT}) — `'find'` probes one row past the
- * effective limit (mirroring {@link import('./helpers.js').clampCriteria}'s idiom) to report
+ * effective limit (mirroring {@link import('./helpers.js').clampQuery}'s idiom) to report
  * `truncated`; `'links'` (which has no upstream pagination) fetches the FULL linked-key list and
  * slices/truncates it the same way. `'link'` / `'unlink'` write / remove one `through` junction
  * row.
@@ -870,17 +872,13 @@ export declare function createRelationTool(options: RelationToolOptions): ToolIn
  * adapter that lets a `function`-form task run a `@orkestrel/tool` tool BY NAME.
  *
  * @remarks
- * OWNED here now (ported from `@orkestrel/workflow`). Composes into a caller's
- * `WorkflowOptions.functions` registry like any other behavior
+ * Composes into a caller's `WorkflowOptions.functions` registry like any other behavior
  * (`{ publish: createToolFunction(tools, 'publish') }`); the pure workflow runner 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` (`@orkestrel/tool`) 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`
- * `WorkflowError` (`@orkestrel/workflow`).
+ * task's `controller.input` as the call arguments. The adapter resolves the live tool, calls its
+ * `execute` method directly, and deep-gates the returned unknown through `parseJSONValue`.
+ * Genuine execution throws retain identity. An unregistered name or non-JSON return throws this
+ * package's typed `TOOL` `ToolboxError`.
  *
  * @param tools - The `ToolManagerInterface` (`@orkestrel/tool`) the named tool is registered on
  * @param name - The registered tool's name
@@ -901,51 +899,55 @@ export declare function createRelationTool(options: RelationToolOptions): ToolIn
 export declare function createToolFunction(tools: ToolManagerInterface, name: string): WorkflowFunction;
 
 /**
- * Compile the LENIENT workflow DRAFT contract — identical to `createWorkflowContract`
- * (`@orkestrel/workflow`) EXCEPT `id` and `name` are OPTIONAL at all three levels (workflow /
- * phase / task), so a small model can omit the six identity strings.
+ * Compile the lenient workflow draft contract used by {@link createWorkflowTool}.
+ *
+ * @returns The compiled {@link import('./types.js').WorkflowDraft} contract
+ */
+export declare function createWorkflowDraftContract(): ContractInterface<WorkflowDraft>;
+
+/**
+ * Compose opaque host functions and raw agents into one immutable workflow registry.
  *
  * @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 — `createWorkflowContract` (`@orkestrel/workflow`) 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 optional (a plain name
- * string).
+ * This is the target-aware composition boundary used by direct runner consumers and
+ * {@link createWorkflowTool}. Opaque leaves are copied unchanged, marked agent adapters are
+ * rejected from that channel, raw agents are rebound to the supplied lineage, collisions fail
+ * closed, and the returned null-prototype record prevents inherited names from becoming phantom
+ * Workflow handlers.
  *
- * @returns The compiled {@link import('./types.js').WorkflowDraft} contract
+ * @param runner - The native runner propagated into contextual agent adapters
+ * @param options - Target lineage, opaque functions, raw agents, and native store
+ * @returns A frozen null-prototype snapshot of the target workflow's callable registry
  *
  * @example
  * ```ts
- * import { createWorkflowDraftContract, completeDraft } from '@src/core'
+ * import { createWorkflowFunctions } from '@src/core'
+ * import { createWorkflowRunner } from '@orkestrel/workflow'
  *
- * const draft = createWorkflowDraftContract()
- * const parsed = draft.parse({ phases: [{ tasks: [{ run: 'compile' }] }] })
- * const definition = parsed && completeDraft(parsed) // ids/names filled positionally
- * draft.parse({ id: '', phases: [] }) // undefined — an explicit empty id is rejected
+ * const runner = createWorkflowRunner()
+ * const functions = createWorkflowFunctions(runner, {
+ * 	functions: { publish: async () => 'published' },
+ * 	agents: { review: reviewAgent },
+ * })
+ * await runner.execute(definition, { functions })
  * ```
  */
-export declare function createWorkflowDraftContract(): ContractInterface<WorkflowDraft>;
+export declare function createWorkflowFunctions(runner: WorkflowRunnerInterface, options?: WorkflowToolOptions): WorkflowFunctions;
 
 /**
  * Wrap a {@link WorkflowDefinition} as an LLM-callable tool — 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, when
- * {@link import('./types.js').WorkflowToolOptions.store} is supplied, PERSISTS each executed
- * workflow's final snapshot after the run settles.
+ * against the STRICT contract, and runs it through `runner`, forwarding the caller's optional
+ * named functions and native checkpoint store.
  *
  * @remarks
  * A plain `ToolManagerInterface`-compatible tool (`@orkestrel/tool`), reproducing
- * `@orkestrel/workflow`'s former call contract exactly (flat / draft / full authoring forms, the
- * strict soundness gate, the depth/cycle guard). It is ALSO the propagation carrier
+ * Toolbox's flat / draft / full authoring contract, strict soundness gate, and lineage guard.
+ * 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 import('./types.js').WorkflowToolOptions},
- * and the handler enforces the SAME depth / cycle guard itself before running the nested
- * workflow at `depth + 1` with the extended ancestry.
+ * handler receives only the model-supplied `args`, the immutable lineage is closed over at bind
+ * time. The authored target is appended and its zero-based depth derived from workflow tags.
  *
  * **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
@@ -960,17 +962,17 @@ export declare function createWorkflowDraftContract(): ContractInterface<Workflo
  *   super-set.
  *
  * The universal tool-handler contract (AGENTS §14): returns the plain run summary
- * (`{ status, count }`) on success, THROWS a typed `WorkflowError` (`@orkestrel/workflow`) on
- * every failure path — malformed authored args (`TOOL`), or an over-deep / cyclic nested run
- * (`DEPTH`). The `ToolManagerInterface` isolates every throw into the canonical tool result's
- * top-level `error`, so nothing escapes the run. `options.depth` / `options.ancestry` are the
- * propagation carrier across a workflow → agent → workflow chain; `options.store` is this
- * package's ADDITION — the persisted snapshot is retrievable via the store afterwards (a caller
- * restores it through `@orkestrel/workflow`'s own `Workflow.restore` / store-backed factories).
+ * (`{ status, count, durable?, fault? }`) on success, THROWS a typed `ToolboxError` on Toolbox
+ * boundary failures — malformed authored args (`TOOL`), or an over-deep / cyclic nested run
+ * (`DEPTH`) — and preserves genuine runner `WorkflowError`s. The `ToolManagerInterface` isolates every throw into the canonical tool result's
+ * top-level `error`, so nothing escapes the run. `options.lineage` is the propagation carrier
+ * across a workflow → agent → workflow chain. Opaque `functions` remain host leaves; raw `agents`
+ * are contextually adapted through {@link createWorkflowFunctions}; native checkpoint persistence
+ * makes the final snapshot retrievable without a second Toolbox write.
  *
  * @param definition - The workflow the tool runs when called with no authored args
  * @param runner - The `WorkflowRunnerInterface` (`@orkestrel/workflow`) that executes the (nested) workflow
- * @param options - Depth/ancestry bookkeeping plus the optional durable store (see {@link import('./types.js').WorkflowToolOptions})
+ * @param options - Lineage-aware functions, agents, and optional native store
  * @returns A `ToolInterface` (named {@link import('./constants.js').WORKFLOW_TOOL_NAME}) whose
  *   `parameters` advertise the flat authoring schema
  *
@@ -984,7 +986,7 @@ export declare function createWorkflowDraftContract(): ContractInterface<Workflo
  * const store = createMemoryWorkflowStore()
  * const tool = createWorkflowTool(definition, runner, { store })
  * const tools = createToolManager()
- * tools.add(tool) // authored runs are now persisted to `store` on settle
+ * tools.add(tool) // authored runs now use native checkpoints through `store`
  * ```
  */
 export declare function createWorkflowTool(definition: WorkflowDefinition, runner: WorkflowRunnerInterface, options?: WorkflowToolOptions): ToolInterface;
@@ -994,12 +996,13 @@ export declare function createWorkflowTool(definition: WorkflowDefinition, runne
  * 13-op union ({@link import('./shapers.js').workspaceToolShape}) as its `parameters`, and its
  * handler PARSES the model-supplied args against that contract and DISPATCHES the matched
  * operation against the manager's ACTIVE workspace (the registry ops drive the manager itself),
- * returning the plain result (throwing a typed `WorkspaceError`, `@orkestrel/agent`, on
- * failure). EITHER drives a caller-supplied {@link WorkspaceToolOptions.manager} directly, OR
- * constructs a fresh `WorkspaceManagerInterface` (`@orkestrel/agent`) over
- * {@link import('./types.js').WorkspaceToolOptions.store} (via `@orkestrel/agent`'s
- * `createWorkspaceManager`); neither given constructs a manager backed by `@orkestrel/agent`'s
- * in-memory store default.
+ * returning the plain result. A malformed operation throws this package's `ToolboxError`; a
+ * genuine workspace-domain failure propagates `@orkestrel/workspace`'s typed `WorkspaceError`.
+ * EITHER drives a caller-supplied {@link WorkspaceToolOptions.manager} directly, OR
+ * constructs a fresh `WorkspaceManagerInterface` (`@orkestrel/workspace`) over
+ * {@link import('./types.js').WorkspaceToolOptions.store} (via `@orkestrel/workspace`'s
+ * `createWorkspaceManager`); neither given constructs a manager backed by
+ * `@orkestrel/workspace`'s in-memory store default.
  *
  * @remarks
  * MANAGER-DRIVEN: every edit / read op (read / list / has / search / replace / write / splice /
@@ -1017,12 +1020,12 @@ export declare function createWorkflowTool(definition: WorkflowDefinition, runne
  * `false`), never creating one and never throwing.
  *
  * The handler conforms to the universal tool-handler contract (AGENTS §14): it `contract.parse`s
- * the args, THROWS a `TOOL` `WorkspaceError` when no operation arm matched (a malformed / unknown
+ * the args, THROWS a `TOOL` `ToolboxError` when no operation arm matched (a malformed / unknown
  * operation), else `switch`es on `op.operation` and RETURNS the plain result — letting a
  * `WorkspaceError` raised by the live workspace (`MODALITY` / `PATTERN` / `RANGE`) PROPAGATE
  * uncaught. The range edit is the FLAT `'splice'` op: its four flat caret integers are
- * reassembled into a `Range` (`@orkestrel/agent`) by `rangeOf` and fed to the workspace's ranged
- * `write`.
+ * reassembled into a `Range` (`@orkestrel/workspace`) by `rangeOf` and fed to the workspace's
+ * ranged `write`.
  *
  * @param options - `manager` (drive directly) OR `store` (build a manager over it); neither ⇒
  *   an in-memory-backed manager (see {@link import('./types.js').WorkspaceToolOptions})
@@ -1040,68 +1043,24 @@ export declare function createWorkflowTool(definition: WorkflowDefinition, runne
  */
 export declare function createWorkspaceTool(options?: WorkspaceToolOptions): ToolInterface;
 
-/**
- * Normalize the database tool's parsed SERIALIZED criteria into a live `@orkestrel/database`
- * {@link Criteria} — default each condition's OMITTED `connector` to `'and'`.
- *
- * @remarks
- * The wire form ({@link import('./shapers.js').databaseToolShape}) lets a caller drop `connector`
- * on the last condition (it has nothing to join FORWARD to); the compiled `Condition` a live
- * `@orkestrel/database` table call accepts always carries one, so this fills the gap. `order` /
- * `limit` / `offset` pass through unchanged. Pure and total.
- *
- * @param criteria - The parsed criteria (or `undefined`)
- * @returns The equivalent live `Criteria`, or `undefined` when `criteria` is `undefined`
- */
-export declare function criteriaOf(criteria: Readonly<{
-    conditions?: readonly Readonly<{
-        column: string;
-        operator: Condition['operator'];
-        values: readonly unknown[];
-        connector?: Connector;
-    }>[];
-    order?: readonly Readonly<{
-        column: string;
-        direction: Direction;
-    }>[];
-    limit?: number;
-    offset?: number;
-}> | undefined): Criteria | undefined;
-
-/** The SERIALIZED criteria form — conditions, order, and pagination. */
-export declare const criteriaShape: ObjectShape<{
-    conditions: OptionalShape<ArrayShape<ObjectShape<{
-        column: StringShape;
-        operator: LiteralShape<readonly ["equals", "not", "above", "below", "from", "to", "between", "like", "glob", "starts", "ends", "any", "none", "absent", "present"]>;
-        values: ArrayShape<JSONShape>;
-        connector: OptionalShape<LiteralShape<readonly ["and", "or"]>>;
-    }, false>>>;
-    order: OptionalShape<ArrayShape<ObjectShape<{
-        column: StringShape;
-        direction: LiteralShape<readonly ["ascending", "descending"]>;
-    }, false>>>;
-    limit: OptionalShape<NumberShape>;
-    offset: OptionalShape<NumberShape>;
-}, false>;
-
 /**
  * The DESCRIPTION the upcoming database tool will advertise — a multi-line guide that teaches a
- * small model the operation list, the SERIALIZED criteria form, and the {@link import('./types.js').TableSpec}
+ * small model the operation list, the SERIALIZED query form, and the {@link import('./types.js').TableSpec}
  * column DSL.
  *
  * @remarks
- * The criteria form is deliberately SERIALIZED (never fluent) — every condition is a flat object
+ * The query form is deliberately SERIALIZED (never fluent) — every condition is a flat object
  * `{ column, operator, values, connector? }` where `values` is ALWAYS an array, even for a
  * single-value operator (`{ column: 'age', operator: 'from', values: [18] }`), so a small model
  * never has to chain method calls or guess whether a value is scalar or a list.
  */
 export declare const DATABASE_TOOL_DESCRIPTION: string;
 
-/** The default cap on rows a `records` / `remove` call returns (or acts on) when the caller omits `criteria.limit` — the upcoming database tool's default row ceiling. */
+/** The default cap on rows a `records` call returns when the caller omits `query.limit` — the upcoming database tool's default row ceiling. */
 export declare const DATABASE_TOOL_LIMIT = 1000;
 
-/** The database tool's mutating operations — disabled by `DatabaseToolOptions.readonly`. */
-export declare const DATABASE_TOOL_MUTATIONS: Set<string>;
+/** The runtime-frozen database-tool mutation names disabled by `DatabaseToolOptions.readonly`. */
+export declare const DATABASE_TOOL_MUTATIONS: readonly string[];
 
 /**
  * The name the upcoming `createDatabaseTool` factory will advertise by default — the key a model
@@ -1118,24 +1077,26 @@ export declare const DATABASE_TOOL_NAME = "database";
  * The lean {@link import('@orkestrel/tool').ToolInterface.summary} the upcoming database tool
  * will advertise in place of {@link DATABASE_TOOL_DESCRIPTION}.
  */
-export declare const DATABASE_TOOL_SUMMARY = "Create and query a database \u2014 one operation per call (create, tables, get, records, count, aggregate, add, set, update, remove, migrate, destroy), chosen by the 'operation' field. Call describe('database') for the full operation list, the criteria form, and the column DSL.";
+export declare const DATABASE_TOOL_SUMMARY = "Create and query a database \u2014 one operation per call (create, tables, get, records, count, aggregate, add, set, update, remove, destroy), chosen by the 'operation' field. Call describe('database') for the full operation list, the query form, and the column DSL.";
 
 /**
- * One database's CONFIG-ONLY definition — `id` + `driver` + {@link TableSpec} (+ optional `keys`),
- * the pure-JSON blueprint the upcoming database / relation tools build a live database from.
+ * One database's CONFIG-ONLY definition — `id` + `driver` + {@link TableSpec}, with optional
+ * `primary`, `indexes`, and `version` schema configuration.
  *
  * @remarks
  * A `DatabaseDefinition` is NEVER a live handle — it is the durable, serializable config a
  * {@link DefinitionStoreInterface} persists and a tool factory turns into a real
  * `@orkestrel/database` `DatabaseInterface` (via `createDatabase` + {@link import('./helpers.js').expandTables})
- * on demand. `keys`, when present, maps a table name to its primary-key column (omitted ⇒ the
- * driver's default primary key).
+ * on demand. `primary` maps table names to primary-key columns; `indexes` maps table names to
+ * index column groups; `version` opts a capable driver into open-time schema reconciliation.
  */
 export declare interface DatabaseDefinition {
     readonly id: string;
     readonly driver: string;
     readonly tables: TableSpec;
-    readonly keys?: Readonly<Record<string, string>>;
+    readonly primary?: PrimaryMap;
+    readonly indexes?: IndexMap;
+    readonly version?: number;
 }
 
 /** One opaque persisted row — the shape a `TableInterface<DatabaseDefinitionRow>`-backed store reads/writes; `definition` is narrowed with {@link import('./helpers.js').isDatabaseDefinition} on read. */
@@ -1209,7 +1170,7 @@ export declare class DatabaseDefinitionStore implements DefinitionStoreInterface
  * ```ts
  * import { DatabaseResolver } from '@orkestrel/toolbox'
  *
- * const resolver = new DatabaseResolver(handles, drivers, key, store)
+ * const resolver = new DatabaseResolver(handles, drivers, generator, store)
  * const database = await resolver.resolve('shop')
  * ```
  */
@@ -1220,10 +1181,10 @@ export declare class DatabaseResolver {
      *
      * @param handles - Initial live database handles cached by id
      * @param drivers - Driver factories keyed by definition driver name
-     * @param key - Key generator supplied to newly created databases
+     * @param generator - Optional key generator supplied to newly created databases
      * @param store - Optional persistent definition store
      */
-    constructor(handles: ReadonlyMap<string, DatabaseInterface>, drivers: Readonly<Record<string, () => DriverInterface>>, key: KeyFunction, store?: DefinitionStoreInterface);
+    constructor(handles: ReadonlyMap<string, DatabaseInterface>, drivers: Readonly<Record<string, () => DriverInterface>>, generator?: KeyFunction, store?: DefinitionStoreInterface);
     /**
      * Determine whether a live database is cached by id.
      *
@@ -1281,22 +1242,26 @@ export declare function databaseToolCode(error: unknown): DatabaseErrorCode | un
  * - `databases` — live `DatabaseInterface` handles to seed the tool's cache with (e.g. a
  *   caller-constructed database it should manage alongside store-backed ones); keyed by the id a
  *   call's `id` field addresses.
- * - `store` — the {@link DefinitionStoreInterface} the `'create'` / `'migrate'` operations persist
- *   their {@link DatabaseDefinition} CONFIG through, and `'destroy'` deletes from; also the source
+ * - `store` — the {@link DefinitionStoreInterface} the `'create'` operation persists its
+ *   {@link DatabaseDefinition} CONFIG through, and `'destroy'` deletes from; also the source
  *   `'get'`/every other operation resolves an id from when it isn't already cached. Omitted means
  *   no persistence — a database created without a store lives only for the tool's lifetime.
  * - `drivers` — registry of driver-name to `() => DriverInterface` factories a `'create'` call's
  *   `driver` field (or a persisted definition's `driver`) resolves against. Defaults to
  *   `{ memory: () => createMemoryDriver() }` (`@orkestrel/database`).
- * - `key` — the `KeyFunction` (`@orkestrel/database`) every minted database is constructed with,
- *   used when a written row lacks its primary key. Defaults to `generateUUID`.
- * - `limit` — the row cap `'records'` / `'remove'` — via {@link import('./helpers.js').clampCriteria}
- *   — enforce when a call's `criteria.limit` is omitted or exceeds it. Defaults to
+ * - `generator` — the optional `KeyFunction` (`@orkestrel/database`) every minted database is
+ *   constructed with, used when a written row lacks its primary key. Omitted delegates to the
+ *   database's default generator.
+ * - `limit` — the `'records'` row cap — via {@link import('./helpers.js').clampQuery}
+ *   — enforce when a call's `query.limit` is omitted or exceeds it. Defaults to
  *   {@link import('./constants.js').DATABASE_TOOL_LIMIT}.
- * - `timeout` — milliseconds; when set, every `@orkestrel/database` call this tool makes is given
- *   a fresh `AbortSignal.timeout(timeout)` per tool call.
+ * - `timeout` — a nonnegative safe-integer number of milliseconds. A fresh
+ *   `AbortSignal.timeout(timeout)` is passed only to table operations whose current database API
+ *   accepts operation options: `records`, `count`, `aggregate`, `add`, `set`, `update`, and
+ *   `remove`. It does not bound store resolution, construction, schema inspection, `get`, or
+ *   `close`, and is not an outer tool-call deadline.
  * - `readonly` — when `true`, every mutating operation (`'create'` / `'add'` / `'set'` /
- *   `'update'` / `'remove'` / `'migrate'` / `'destroy'`) throws a typed `TOOL`
+ *   `'update'` / `'remove'` / `'destroy'`) throws a typed `TOOL`
  *   {@link import('./errors.js').ToolboxError} before doing anything.
  * - `name` / `description` — advertised tool overrides; default to
  *   {@link import('./constants.js').DATABASE_TOOL_NAME} / {@link import('./constants.js').DATABASE_TOOL_DESCRIPTION}.
@@ -1307,7 +1272,7 @@ export declare interface DatabaseToolOptions {
     readonly databases?: Readonly<Record<string, DatabaseInterface>>;
     readonly store?: DefinitionStoreInterface;
     readonly drivers?: Readonly<Record<string, () => DriverInterface>>;
-    readonly key?: KeyFunction;
+    readonly generator?: KeyFunction;
     readonly limit?: number;
     readonly timeout?: number;
     readonly readonly?: boolean;
@@ -1315,17 +1280,17 @@ export declare interface DatabaseToolOptions {
 
 /**
  * The shape of {@link import('./factories.js').createDatabaseTool}'s call arguments —
- * discriminated by `operation` into the 12 database operations (`'create'` / `'tables'` /
+ * discriminated by `operation` into the 11 database operations (`'create'` / `'tables'` /
  * `'get'` / `'records'` / `'count'` / `'aggregate'` / `'add'` / `'set'` / `'update'` /
- * `'remove'` / `'migrate'` / `'destroy'`).
+ * `'remove'` / `'destroy'`).
  *
  * @remarks
- * Every arm carries `id` (the database id). `'create'` / `'migrate'` carry `tables` (the
+ * Every arm carries `id` (the database id). `'create'` carries `tables` (the
  * {@link import('./types.js').TableSpec} column DSL, compiled via
  * {@link import('./helpers.js').expandTables}); `'get'` / `'update'` / `'remove'` carry `key`
  * (one key or an array of keys, positional); `'add'` / `'set'` carry `row` (one row or an array of
  * rows); `'update'` also carries `changes` (a loose partial row); `'records'` / `'count'` /
- * `'aggregate'` carry an optional `criteria` (the SERIALIZED form — `values` is ALWAYS an array,
+ * `'aggregate'` carry an optional `query` (the SERIALIZED form — `values` is ALWAYS an array,
  * even for a single-value operator, so a caller never chains method calls or guesses arity).
  */
 export declare const databaseToolShape: UnionShape<readonly [ ObjectShape<{
@@ -1338,7 +1303,9 @@ export declare const databaseToolShape: UnionShape<readonly [ ObjectShape<{
         }, false>]>>;
     }, false>>;
     driver: OptionalShape<StringShape>;
-    keys: OptionalShape<ObjectShape<Record<never, never>, StringShape>>;
+    primary: OptionalShape<ObjectShape<Record<never, never>, StringShape>>;
+    indexes: OptionalShape<ObjectShape<Record<never, never>, ArrayShape<ArrayShape<StringShape>>>>;
+    version: OptionalShape<NumberShape>;
 }, false>, ObjectShape<{
     operation: LiteralShape<readonly ["tables"]>;
     id: StringShape;
@@ -1351,7 +1318,7 @@ export declare const databaseToolShape: UnionShape<readonly [ ObjectShape<{
     operation: LiteralShape<readonly ["records"]>;
     id: StringShape;
     table: StringShape;
-    criteria: OptionalShape<ObjectShape<{
+    query: OptionalShape<ObjectShape<{
         conditions: OptionalShape<ArrayShape<ObjectShape<{
             column: StringShape;
             operator: LiteralShape<readonly ["equals", "not", "above", "below", "from", "to", "between", "like", "glob", "starts", "ends", "any", "none", "absent", "present"]>;
@@ -1369,7 +1336,7 @@ export declare const databaseToolShape: UnionShape<readonly [ ObjectShape<{
     operation: LiteralShape<readonly ["count"]>;
     id: StringShape;
     table: StringShape;
-    criteria: OptionalShape<ObjectShape<{
+    query: OptionalShape<ObjectShape<{
         conditions: OptionalShape<ArrayShape<ObjectShape<{
             column: StringShape;
             operator: LiteralShape<readonly ["equals", "not", "above", "below", "from", "to", "between", "like", "glob", "starts", "ends", "any", "none", "absent", "present"]>;
@@ -1389,7 +1356,7 @@ export declare const databaseToolShape: UnionShape<readonly [ ObjectShape<{
     table: StringShape;
     function: LiteralShape<readonly ["count", "sum", "average", "minimum", "maximum"]>;
     column: StringShape;
-    criteria: OptionalShape<ObjectShape<{
+    query: OptionalShape<ObjectShape<{
         conditions: OptionalShape<ArrayShape<ObjectShape<{
             column: StringShape;
             operator: LiteralShape<readonly ["equals", "not", "above", "below", "from", "to", "between", "like", "glob", "starts", "ends", "any", "none", "absent", "present"]>;
@@ -1424,15 +1391,6 @@ export declare const databaseToolShape: UnionShape<readonly [ ObjectShape<{
     id: StringShape;
     table: StringShape;
     key: UnionShape<readonly [ ArrayShape<UnionShape<readonly [ StringShape, NumberShape]>>, StringShape, NumberShape]>;
-}, false>, ObjectShape<{
-    operation: LiteralShape<readonly ["migrate"]>;
-    id: StringShape;
-    tables: ObjectShape<Record<never, never>, ObjectShape<{
-        columns: ObjectShape<Record<never, never>, UnionShape<readonly [ LiteralShape<readonly ["string", "integer", "number", "boolean"]>, ObjectShape<{
-            type: LiteralShape<readonly ["string", "integer", "number", "boolean"]>;
-            optional: OptionalShape<BooleanShape>;
-        }, false>]>>;
-    }, false>>;
 }, false>, ObjectShape<{
     operation: LiteralShape<readonly ["destroy"]>;
     id: StringShape;
@@ -1449,6 +1407,14 @@ export declare interface DefinitionStoreInterface {
     delete(id: string): Promise<void>;
 }
 
+/**
+ * Derive the zero-based workflow nesting depth from a valid lineage.
+ *
+ * @param lineage - The workflow/agent chain
+ * @returns Zero for an empty/root lineage, then one per nested workflow
+ */
+export declare function deriveWorkflowDepth(lineage: WorkflowLineage): number;
+
 /**
  * The DESCRIPTION {@link import('./factories.js').createDescribeTool} advertises.
  *
@@ -1606,9 +1572,10 @@ export declare function expandInclude(paths: readonly string[] | undefined, dept
  * `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.
+ * `phase-<i>`, its task `phase-<i>-task-0`). The optional `name` becomes both the workflow's
+ * deterministic id and its name, so named flat workflows retain distinct persistence keys;
+ * omission keeps the shared draft fallback `wf`. 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)
@@ -1616,19 +1583,29 @@ export declare function expandInclude(paths: readonly string[] | undefined, dept
 export declare function expandSteps(flat: WorkflowSteps): WorkflowDefinition;
 
 /**
- * Compile a {@link TableSpec} into the `@orkestrel/database` {@link TablesShape} it configures —
+ * Compile a {@link TableSpec} into the `@orkestrel/database` {@link TableMap} it configures —
  * each {@link ColumnSpec} maps to the matching primitive shaper (`'string'` → `stringShape()`,
  * `'integer'` → `integerShape()`, `'number'` → `numberShape()`, `'boolean'` → `booleanShape()`),
  * wrapped in `optionalShape` when the column declares `optional: true`. Total, pure.
  *
  * @param spec - The small-model-facing table layout
- * @returns The compiled `TablesShape` a `@orkestrel/database` `createDatabase` call accepts
+ * @returns The compiled `TableMap` a `@orkestrel/database` `createDatabase` call accepts
+ */
+export declare function expandTables(spec: TableSpec): TableMap;
+
+/**
+ * Append one tag to a workflow lineage and return a frozen copy.
+ *
+ * @param lineage - The valid chain to extend
+ * @param tag - The workflow or agent tag to append
+ * @returns The validated immutable extension
  */
-export declare function expandTables(spec: TableSpec): TablesShape;
+export declare function extendLineage(lineage: WorkflowLineage, tag: string): WorkflowLineage;
 
 /** Flat dot-path relation include list, expanded via {@link import('./helpers.js').expandInclude}. */
 export declare const includeShape: OptionalShape<ArrayShape<StringShape>>;
 
+/** The schema-inference protocol {@link import('./factories.js').createInferTool} advertises. */
 export declare const INFER_TOOL_DESCRIPTION: string;
 
 /**
@@ -1677,6 +1654,14 @@ export declare const inferToolShape: ObjectShape<{
     candidates: OptionalShape<ArrayShape<JSONShape>>;
 }, false>;
 
+/**
+ * Narrow an unknown callable to Toolbox's frozen contextual agent adapter metadata.
+ *
+ * @param value - The value to inspect
+ * @returns Whether it is a frozen {@link AgentFunction} with a frozen valid lineage
+ */
+export declare function isAgentFunction(value: unknown): value is AgentFunction;
+
 /** Narrow an unknown value to a {@link import('./types.js').ColumnKind}. */
 export declare function isColumnKind(value: unknown): value is ColumnKind;
 
@@ -1685,9 +1670,10 @@ export declare function isColumnSpec(value: unknown): value is ColumnSpec;
 
 /**
  * Narrow an unknown value to a {@link DatabaseDefinition} — a non-empty `id` + `driver`, a
- * `tables` record whose every value is `{ columns: record of valid ColumnSpec }`, and an optional
- * `keys` record of strings. The boundary guard a {@link import('./types.js').DefinitionStoreInterface}
- * applies to an untrusted persisted blob before trusting it as a definition (never an `as`).
+ * `tables` record whose every value is `{ columns: record of valid ColumnSpec }`, plus optional
+ * `primary`, `indexes`, and finite `version` schema configuration. The boundary guard a
+ * {@link import('./types.js').DefinitionStoreInterface} applies to an untrusted persisted blob
+ * before trusting it as a definition (never an `as`).
  */
 export declare function isDatabaseDefinition(value: unknown): value is DatabaseDefinition;
 
@@ -1710,12 +1696,28 @@ export declare function isDatabaseDefinition(value: unknown): value is DatabaseD
  */
 export declare function isToolboxError(value: unknown): value is ToolboxError;
 
+/**
+ * Narrow an unknown value to a valid alternating workflow lineage.
+ *
+ * @param value - The value to inspect
+ * @returns Whether `value` is a unique, nonempty-tagged workflow/agent chain
+ */
+export declare function isWorkflowLineage(value: unknown): value is WorkflowLineage;
+
 /** One key value — a string or number; the array form (multiple keys, positional) resolves FIRST per AGENTS §9.2. */
 export declare const keyShape: UnionShape<readonly [ ArrayShape<UnionShape<readonly [ StringShape, NumberShape]>>, StringShape, NumberShape]>;
 
 /** Map one {@link import('./types.js').ColumnKind} to its primitive `@orkestrel/database` shape — the leaf {@link columnShape} wraps. */
 export declare function kindShape(kind: ColumnKind): ContractShape;
 
+/**
+ * Build a validated, copied, and frozen workflow lineage value.
+ *
+ * @param lineage - The configured chain; omitted means a direct root
+ * @returns An immutable caller-isolated lineage
+ */
+export declare function lineageOf(lineage?: WorkflowLineage): WorkflowLineage;
+
 /** Which registered relation manager to address — omitted resolves to the sole registered manager. */
 export declare const managerShape: OptionalShape<StringShape>;
 
@@ -1725,11 +1727,9 @@ export declare const managerShape: OptionalShape<StringShape>;
  * {@link import('./factories.js').createWorkflowTool}'s depth/cycle guards enforce.
  *
  * @remarks
- * OWNED here now (ported from `@orkestrel/workflow`, whose engine no longer uses it — only the
- * tool-authoring guards this package now owns consume it). The limit lives in ONE place: an
- * agent-function-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` `WorkflowError` throw, `@orkestrel/workflow`).
+ * Depth is zero-based and counts workflow tags after the root: the root plus eight nested
+ * workflows is allowed, while a ninth nested workflow is rejected with this package's typed
+ * `DEPTH` `ToolboxError`.
  */
 export declare const MAX_WORKFLOW_DEPTH = 8;
 
@@ -1741,7 +1741,8 @@ export declare const MAX_WORKFLOW_DEPTH = 8;
  *
  * @remarks
  * A plain `Map<string, DatabaseDefinition>` (AGENTS §21 — the definition is already pure,
- * self-contained CONFIG-only JSON, so no encoding is needed for the memory tier). There is NO
+ * self-contained CONFIG-only JSON, so no encoding is needed for the memory tier). Values are
+ * structured-cloned on both write and read, keeping caller mutation outside the store. There is NO
  * idle-TTL and NO eviction: a persisted definition lives until an explicit `delete`. A durable
  * backend (JSON / SQLite / IndexedDB) swaps in through the SAME interface without touching a
  * consumer — its driver-pluggable twin is
@@ -1810,6 +1811,7 @@ export declare const phaseDraftShape: ObjectShape<{
     bail: OptionalShape<LiteralShape<readonly [true, false]>>;
 }, false>;
 
+/** The full prompt protocol {@link import('./factories.js').createPromptTool} advertises. */
 export declare const PROMPT_TOOL_DESCRIPTION: string;
 
 /**
@@ -1893,6 +1895,50 @@ export declare const promptToolShape: ObjectShape<{
     timeout: OptionalShape<NumberShape>;
 }, false>;
 
+/**
+ * Normalize the database tool's parsed SERIALIZED query into a live `@orkestrel/database`
+ * {@link QueryInput} — default each condition's OMITTED `connector` to `'and'`.
+ *
+ * @remarks
+ * The wire form ({@link import('./shapers.js').databaseToolShape}) lets a caller drop `connector`
+ * on the last condition (it has nothing to join FORWARD to); the compiled `Condition` a live
+ * `@orkestrel/database` table call accepts always carries one, so this fills the gap. `order` /
+ * `limit` / `offset` pass through unchanged. Pure and total.
+ *
+ * @param query - The parsed query (or `undefined`)
+ * @returns The equivalent live `QueryInput`, or `undefined` when `query` is `undefined`
+ */
+export declare function queryOf(query: Readonly<{
+    conditions?: readonly Readonly<{
+        column: string;
+        operator: Condition['operator'];
+        values: readonly unknown[];
+        connector?: ConditionConnector;
+    }>[];
+    order?: readonly Readonly<{
+        column: string;
+        direction: OrderDirection;
+    }>[];
+    limit?: number;
+    offset?: number;
+}> | undefined): QueryInput | undefined;
+
+/** The SERIALIZED query form — conditions, order, and pagination. */
+export declare const queryShape: ObjectShape<{
+    conditions: OptionalShape<ArrayShape<ObjectShape<{
+        column: StringShape;
+        operator: LiteralShape<readonly ["equals", "not", "above", "below", "from", "to", "between", "like", "glob", "starts", "ends", "any", "none", "absent", "present"]>;
+        values: ArrayShape<JSONShape>;
+        connector: OptionalShape<LiteralShape<readonly ["and", "or"]>>;
+    }, false>>>;
+    order: OptionalShape<ArrayShape<ObjectShape<{
+        column: StringShape;
+        direction: LiteralShape<readonly ["ascending", "descending"]>;
+    }, false>>>;
+    limit: OptionalShape<NumberShape>;
+    offset: OptionalShape<NumberShape>;
+}, false>;
+
 /** The default cap on how many `include` path segments deep a `load` / `find` call may traverse — the relation tool's default include-depth ceiling. */
 export declare const RELATION_TOOL_DEPTH = 3;
 
@@ -2055,25 +2101,10 @@ export declare const stepShape: ObjectShape<{
     name: StringShape;
 }, false>;
 
-/**
- * Build one {@link TableSchema} from a table NAME and its `@orkestrel/database` `TableExport` —
- * the "deployed" schema shape `DatabaseInterface.migrate` diffs against, derived from a LIVE
- * handle's `export()` rather than a re-declared {@link TableSpec}, so it works for ANY handle
- * (config-tracked or caller-supplied).
- *
- * @param name - The table name
- * @param table - The table's `TableExport` (`{ key, columns }`, `@orkestrel/database`)
- * @returns The equivalent {@link TableSchema} (`indexes` empty — this package declares none)
- */
-export declare function tableSchema(name: string, table: Readonly<{
-    key: string;
-    columns: Readonly<Record<string, ContractShape>>;
-}>): TableSchema;
-
 /**
  * A database's table layout — one entry per table, each a flat map of column name to
  * {@link ColumnSpec}. The small-model-facing DSL {@link import('./helpers.js').expandTables}
- * compiles into an `@orkestrel/database` `TablesShape`.
+ * compiles into an `@orkestrel/database` `TableMap`.
  */
 export declare type TableSpec = Readonly<Record<string, Readonly<{
     columns: Readonly<Record<string, ColumnSpec>>;
@@ -2099,11 +2130,11 @@ export declare interface TaskDraft {
     readonly id?: string;
     readonly name?: string;
     readonly description?: string;
-    /** The behavior reference — a registry key resolved against a workflow's functions registry at construction; omitted ⇒ no handler. */
+    /** The behavior reference — a registry key resolved against a workflow's functions registry at construction; omitted ⇒ a deliberate JSON `null` no-op. */
     readonly run?: string;
-    /** Extra attempts after the first on failure (a non-negative integer); overrides the phase Runner default. Execution-only. */
+    /** Extra attempts after the first on failure (a non-negative integer); persisted with the workflow. */
     readonly retries?: number;
-    /** The per-attempt deadline in milliseconds (a non-negative integer); overrides the phase Runner default. Execution-only. */
+    /** The per-attempt deadline in milliseconds (`0..MAX_TIMER_MS`); persisted with the workflow. */
     readonly timeout?: number;
 }
 
@@ -2138,13 +2169,9 @@ export declare const taskDraftShape: ObjectShape<{
 export declare function terminalToolCode(error: unknown): ToolboxErrorCode | undefined;
 
 /**
- * Thrown by {@link import('./factories.js').createAgentTool}'s and
- * {@link import('./factories.js').createDescribeTool}'s handlers on every failure path — a
- * malformed / unresolvable call or an unknown tool name (`TOOL`), a delegation that would
- * exceed the configured depth bound or re-enter an ancestor (`DEPTH`), a prompt cycle
- * (`DEADLOCK`), a prompt that expired before it was answered (`EXPIRE`), or an answer that
- * failed to apply (`ANSWER`) — the last three thrown by
- * {@link import('./factories.js').createPromptTool} / {@link import('./factories.js').createAnswerTool}.
+ * A package-owned tool-call failure: malformed input or unresolved configuration (`TOOL`),
+ * delegation depth/cycle rejection (`DEPTH`), prompt failure (`DEADLOCK` / `EXPIRE` / `ANSWER`),
+ * or a translated upstream database/relation failure (`DATABASE` / `RELATION`).
  *
  * @remarks
  * Carries a machine-readable `code` (see {@link import('./types.js').ToolboxErrorCode}) and
@@ -2195,6 +2222,10 @@ export declare class ToolboxError extends Error {
  */
 export declare type ToolboxErrorCode = 'TOOL' | 'DEPTH' | 'DEADLOCK' | 'EXPIRE' | 'ANSWER' | 'DATABASE' | 'RELATION';
 
+/**
+ * The description {@link import('./factories.js').createWorkflowTool} advertises — the flat
+ * authoring form, its worked example, and the advanced nested definition form.
+ */
 export declare const WORKFLOW_TOOL_DESCRIPTION: string;
 
 /**
@@ -2202,7 +2233,7 @@ export declare const WORKFLOW_TOOL_DESCRIPTION: string;
  * {@link import('./factories.js').createWorkflowTool}: `{ name, steps: [{ name }] }`.
  *
  * @remarks
- * OWNED here now (ported from `@orkestrel/workflow`). Each step becomes a one-task phase, in
+ * 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 `WorkflowDefinition`
@@ -2217,7 +2248,7 @@ export declare const WORKFLOW_TOOL_FLAT_EXAMPLE: WorkflowSteps;
  * under onto a wrapped agent's `context.tools`.
  *
  * @remarks
- * OWNED here now (ported from `@orkestrel/workflow`). The propagation seam's well-known key: when
+ * The propagation seam's well-known key: when
  * `createAgentFunction`'s `runner` option is supplied, it adds a `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}).
@@ -2229,7 +2260,7 @@ export declare const WORKFLOW_TOOL_NAME = "workflow";
  * the flat shape: a full `WorkflowDefinition` (`@orkestrel/workflow`).
  *
  * @remarks
- * OWNED here now (ported from `@orkestrel/workflow`). The full four-level form, documented in
+ * The full four-level form, documented in
  * {@link WORKFLOW_TOOL_DESCRIPTION} as the advanced alternative. It is embedded VERBATIM.
  */
 export declare const WORKFLOW_TOOL_NESTED_EXAMPLE: WorkflowDefinition;
@@ -2243,6 +2274,9 @@ export declare const WORKFLOW_TOOL_NESTED_EXAMPLE: WorkflowDefinition;
  */
 export declare const WORKFLOW_TOOL_SUMMARY = "Author and run a multi-phase workflow in one call \u2014 phases run in sequence, tasks within a phase run concurrently. Call describe('workflow') for the full authoring schema and examples.";
 
+/** Raw live agents keyed by the workflow function names that invoke them. */
+export declare type WorkflowAgents = Readonly<Record<string, AgentInterface>>;
+
 /**
  * A draft workflow — a `WorkflowDefinition` (`@orkestrel/workflow`) with OPTIONAL `id` / `name`
  * at all three levels (workflow / phase / task).
@@ -2269,7 +2303,8 @@ export declare interface WorkflowDraft {
  *
  * @remarks
  * The lenient counterpart {@link import('./factories.js').createWorkflowDraftContract} compiles.
- * `run` stays required on the strict form; a provided `id` / `name` still has `minLength: 1` (so
+ * `run` stays optional like the strict form; omission is the deliberate JSON `null` no-op. 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 `createWorkflowContract` (`@orkestrel/workflow`) gate before
@@ -2297,6 +2332,9 @@ export declare const workflowDraftShape: ObjectShape<{
     bail: OptionalShape<LiteralShape<readonly [true, false]>>;
 }, false>;
 
+/** One immutable workflow/agent call chain, beginning with a workflow tag. */
+export declare type WorkflowLineage = readonly string[];
+
 /**
  * One flat step — `{ name }` — the building block of a {@link WorkflowSteps} blob.
  *
@@ -2315,8 +2353,8 @@ export declare interface WorkflowStep {
  *
  * @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).
+ * ({@link import('./helpers.js').expandSteps}); `name` is the optional workflow name and
+ * deterministic persistence id (both default to `wf` when omitted).
  */
 export declare interface WorkflowSteps {
     readonly name?: string;
@@ -2357,51 +2395,59 @@ export declare const workflowStepsShape: ObjectShape<{
 export declare function workflowTag(id: string): string;
 
 /**
- * Options for {@link import('./factories.js').createWorkflowTool} — the depth + ancestry a
- * nested workflow run is bound at, plus the optional durable {@link WorkflowStoreInterface}
- * (`@orkestrel/workflow`) this package layers on top of the ported handler logic.
+ * Options for {@link import('./factories.js').createWorkflowTool} and
+ * {@link import('./factories.js').createWorkflowFunctions} — lineage-aware composition of opaque
+ * leaves, raw agents, and native workflow persistence.
  *
  * @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 `@orkestrel/tool`'s
- * `ToolOptions`), so the run's position in the workflow→agent→workflow chain CANNOT be threaded
- * through a tool call at runtime. Instead {@link import('./factories.js').createAgentFunction}
- * CLOSES `depth` / `ancestry` over the tool at BIND time. Both are OPTIONAL: a workflow tool
- * built for a TOP-LEVEL caller omits them — its nested run starts the chain at depth `1` with
- * the bare `workflow:<id>` ancestry.
- *
- * `store` is this package's ADDITION: when supplied, the tool's handler persists the run's final
- * snapshot (`store.set(result.workflow.snapshot())`) once the run settles, so a workflow
- * authored + run through the tool is retrievable / restorable afterwards. Omitted ⇒ no
- * persistence.
+ * A top-level workflow tool uses an empty lineage and establishes its authored target as depth
+ * zero. A tool bound onto an agent carries a lineage ending in that agent; the target workflow is
+ * appended at invocation. `functions` remains strictly opaque host behavior. `agents` is the raw
+ * live registry Toolbox uses to mint target-specific {@link AgentFunction}s. `store` is forwarded
+ * to the native runner, which owns checkpoints and reports final durability/fault state.
  */
 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[];
+    readonly lineage?: WorkflowLineage;
+    readonly functions?: WorkflowFunctions;
+    readonly agents?: WorkflowAgents;
     readonly store?: WorkflowStoreInterface;
 }
 
+/** The JSON-safe run summary returned by {@link import('./factories.js').createWorkflowTool}. */
+export declare interface WorkflowToolResult {
+    /** The workflow's native terminal status. */
+    readonly status: WorkflowStatus;
+    /** The number of settled task results. */
+    readonly count: number;
+    /** Whether the native runner stored its final state; omitted when no store was supplied. */
+    readonly durable?: boolean;
+    /** The native runner's first persistence failure; omitted when none occurred. */
+    readonly fault?: WorkflowFault;
+}
+
 /**
  * Build the plain success summary {@link import('./factories.js').createWorkflowTool} returns on
  * a completed run — the universal tool-handler contract (AGENTS §14): return a plain value on
  * success, appearing identically over BOTH the agent loop and MCP.
  *
  * @remarks
- * 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 `ToolManagerInterface`
- * (`@orkestrel/tool`) supplies the canonical envelope's identity.)
+ * The summary is LEAN: the workflow's terminal `status`, settled-task count, and exact optional
+ * native persistence outcome. It carries no synthetic `id` / `name`: a tool handler has no call
+ * id; the `ToolManagerInterface` (`@orkestrel/tool`) supplies the canonical envelope's identity.
  *
  * @param result - The terminal `WorkflowResult` (`@orkestrel/workflow`) the run produced
- * @returns The plain success summary — `{ status, count }`
+ * @returns The plain success summary — `{ status, count, durable?, fault? }`
  */
-export declare function workflowToolSummary(result: WorkflowResult): Readonly<{
-    status: WorkflowStatus;
-    count: number;
-}>;
+export declare function workflowToolSummary(result: WorkflowResult): WorkflowToolResult;
 
+/**
+ * The description {@link import('./factories.js').createWorkspaceTool} advertises — the
+ * operation-keyed workspace protocol, all supported operations, and worked examples.
+ *
+ * @remarks
+ * Mirrors {@link WORKFLOW_TOOL_DESCRIPTION}'s teaching style and embeds
+ * {@link WORKSPACE_TOOL_EXAMPLE} verbatim.
+ */
 export declare const WORKSPACE_TOOL_DESCRIPTION: string;
 
 /**
@@ -2409,7 +2455,7 @@ export declare const WORKSPACE_TOOL_DESCRIPTION: string;
  * VERBATIM in {@link WORKSPACE_TOOL_DESCRIPTION}.
  *
  * @remarks
- * OWNED here now (ported from `@orkestrel/agent`). A `'write'` op (the most common authoring
+ * A `'write'` op (the most common authoring
  * action): create or overwrite `notes.txt` with `hello`. Frozen so it cannot be mutated in
  * place.
  */
@@ -2418,9 +2464,6 @@ export declare const WORKSPACE_TOOL_EXAMPLE: WorkspaceOperation;
 /**
  * The name {@link import('./factories.js').createWorkspaceTool} advertises by default — the key a
  * model calls and the `ToolManagerInterface` (`@orkestrel/tool`) registers under.
- *
- * @remarks
- * OWNED here now (ported from `@orkestrel/agent`).
  */
 export declare const WORKSPACE_TOOL_NAME = "workspace";
 
@@ -2444,7 +2487,8 @@ export declare const WORKSPACE_TOOL_SUMMARY = "Read and edit files in a workspac
  * ({@link import('./shapers.js').workspaceToolShape} compiles to a structurally-identical guard /
  * parser / JSON Schema). Every field is FLAT (no nested objects) — the small-model ergonomic
  * lever: a range edit is the four flat integers of the `'splice'` arm (`fromLine` /
- * `fromColumn` / `toLine` / `toColumn`), reassembled into a 1-based `Range` (`@orkestrel/agent`)
+ * `fromColumn` / `toLine` / `toColumn`), reassembled into a 1-based `Range`
+ * (`@orkestrel/workspace`)
  * by `rangeOf`, never a nested `{ start, end }`. Each EDIT / READ arm maps onto exactly one
  * `WorkspaceInterface` call against the manager's ACTIVE workspace; the two REGISTRY arms
  * (`switch` / `workspaces`) drive the {@link WorkspaceManagerInterface} pointer instead —
@@ -2471,28 +2515,28 @@ export declare type WorkspaceOperation =
 *
 * @remarks
 * `regex` treats `query` as a regular-expression source (default `false` — a literal substring);
-* `exact` matches case-sensitively (default `true`); `limit` caps the total hits returned.
+* `sensitive` matches case-sensitively (default `true`); `limit` caps the total hits returned.
 */
 | {
     readonly operation: 'search';
     readonly query: string;
     readonly regex?: boolean;
-    readonly exact?: boolean;
+    readonly sensitive?: boolean;
     readonly limit?: number;
 }
 /**
 * Replace `query` with `replacement` across every text file, returning the tally.
 *
 * @remarks
-* Same matching axes as `search`: `regex` (default `false`), `exact` (default `true`), `limit`
-* (cap the total replacements).
+* Same matching axes as `search`: `regex` (default `false`), `sensitive` (default `true`),
+* `limit` (cap the total replacements).
 */
 | {
     readonly operation: 'replace';
     readonly query: string;
     readonly replacement: string;
     readonly regex?: boolean;
-    readonly exact?: boolean;
+    readonly sensitive?: boolean;
     readonly limit?: number;
 }
 /** Write (create or overwrite) the whole file at `path` with `content`. */
@@ -2507,8 +2551,8 @@ export declare type WorkspaceOperation =
 *
 * @remarks
 * The FLAT range edit — the four positive-integer caret components reassemble into a `Range`
-* (`@orkestrel/agent`) via `rangeOf`. An empty span (`from === to`) inserts; a span past the
-* end is clamped. An inverted / sub-1 range throws `RANGE`; a binary target throws
+* (`@orkestrel/workspace`) via `rangeOf`. An empty span (`from === to`) inserts; a span past
+* the end is clamped. An inverted / sub-1 range throws `RANGE`; a binary target throws
 * `MODALITY`.
 */
 | {
@@ -2557,16 +2601,16 @@ export declare type WorkspaceOperation =
  * Options for {@link import('./factories.js').createWorkspaceTool} — EITHER a caller-built
  * {@link WorkspaceManagerInterface} to drive directly, OR a {@link WorkspaceStoreInterface} the
  * tool constructs a fresh manager over; neither given constructs a manager over
- * `@orkestrel/agent`'s in-memory store.
+ * `@orkestrel/workspace`'s in-memory store.
  *
  * @remarks
  * - `manager` — drive THIS manager directly (its `active` workspace is what every edit / read
  *   operation targets). Takes priority over `store` when both are supplied.
  * - `store` — construct a manager over this durable {@link WorkspaceStoreInterface} (via
- *   `@orkestrel/agent`'s `createWorkspaceManager`) — used only when `manager` is omitted.
+ *   `@orkestrel/workspace`'s `createWorkspaceManager`) — used only when `manager` is omitted.
  *   The store only backs the manager's own `open` / `save` operations: the tool's edits are
  *   NOT auto-persisted — durability requires an explicit caller `save` on the manager
- *   (unlike the workflow tool's `store`, which persists each executed snapshot on settle).
+ *   (unlike the workflow tool's `store`, which is forwarded into native run-wide checkpoints).
  * - `name` / `description` — advertised tool overrides; default to
  *   {@link import('./constants.js').WORKSPACE_TOOL_NAME} / {@link import('./constants.js').WORKSPACE_TOOL_DESCRIPTION}.
  */
@@ -2588,10 +2632,10 @@ export declare interface WorkspaceToolOptions {
  * The union compiles to an `anyOf` JSON Schema + a `unionOf` guard + a first-match parser
  * automatically ({@link import('./factories.js').createWorkspaceTool} types the result to the
  * hand-written {@link import('./types.js').WorkspaceOperation}). `limit` and the four `'splice'`
- * caret components are POSITIVE integers (`integerShape({ min: 1 })`); `regex` / `exact` are
- * `optionalShape(booleanShape(...))`. The two REGISTRY arms — `workspaces` (list the workspaces
- * the model can move between) and `switch` (re-point the active one by `id`) — let a model
- * DISCOVER then CHOOSE which workspace the edit / read arms target.
+ * caret components are POSITIVE integers (`integerShape({ min: 1 })`); `regex` / `sensitive`
+ * are `optionalShape(booleanShape(...))`. The two REGISTRY arms — `workspaces` (list the
+ * workspaces the model can move between) and `switch` (re-point the active one by `id`) — let a
+ * model DISCOVER then CHOOSE which workspace the edit / read arms target.
  */
 export declare const workspaceToolShape: UnionShape<readonly [ ObjectShape<{
     operation: LiteralShape<readonly ["read"]>;
@@ -2605,14 +2649,14 @@ export declare const workspaceToolShape: UnionShape<readonly [ ObjectShape<{
     operation: LiteralShape<readonly ["search"]>;
     query: StringShape;
     regex: OptionalShape<BooleanShape>;
-    exact: OptionalShape<BooleanShape>;
+    sensitive: OptionalShape<BooleanShape>;
     limit: OptionalShape<NumberShape>;
 }, false>, ObjectShape<{
     operation: LiteralShape<readonly ["replace"]>;
     query: StringShape;
     replacement: StringShape;
     regex: OptionalShape<BooleanShape>;
-    exact: OptionalShape<BooleanShape>;
+    sensitive: OptionalShape<BooleanShape>;
     limit: OptionalShape<NumberShape>;
 }, false>, ObjectShape<{
     operation: LiteralShape<readonly ["write"]>;