@orkestrel/toolbox 0.0.11 → 0.0.13

package/dist/src/core/index.cjs

@@ -10,40 +10,44 @@ let _orkestrel_tool = require("@orkestrel/tool");
 let _orkestrel_form = require("@orkestrel/form");
 //#region src/core/constants.ts
 /**
-* The name {@link import('./factories.js').createAgentTool} advertises by default — the key a
-* model calls and the `ToolManagerInterface` (`@orkestrel/tool`) registers under.
+* Holds the name {@link import('./factories.js').createAgentTool} advertises by default, `'agent'`
+* — the key a model calls and the `ToolManagerInterface` (`@orkestrel/tool`) registers under.
 */
 var AGENT_TOOL_NAME = "agent";
 /**
-* The maximum nesting depth a delegation chain (agent tool → sub-agent → agent tool → …) may
-* reach — the bound {@link import('./factories.js').createAgentTool}'s depth/cycle guard
+* Holds the maximum nesting depth a delegation chain (agent tool → sub-agent → agent tool → …) may
+* reach, `8` — the bound {@link import('./factories.js').createAgentTool}'s depth/cycle guard
 * enforces.
 *
 * @remarks
-* Deliberately a SEPARATE constant from {@link MAX_WORKFLOW_DEPTH} (rather than the two guards
-* sharing one reference): the two guards bound DIFFERENT chains (workflow nesting vs. agent
+* Deliberately a separate constant from {@link MAX_WORKFLOW_CHAIN} (rather than the guards
+* sharing one reference): they bound different chains (workflow nesting against agent
 * delegation) that happen to share a value today, and keeping this bound decoupled means a
 * future change to one never silently shifts the other. Same numeric value by convention, not
 * by shared reference.
 */
 var AGENT_TOOL_DEPTH = 8;
 /**
-* The lean {@link import('@orkestrel/tool').ToolInterface.summary} {@link import('./factories.js').createAgentTool}
-* advertises in place of {@link AGENT_TOOL_DESCRIPTION} — a `ToolManagerInterface.definitions()`
-* (`@orkestrel/tool`) advertises `summary ?? description`, so this one-sentence text stands in
-* for the full teaching description; the full text stays retrievable via
-* {@link import('./factories.js').createDescribeTool}.
+* Holds the lean {@link import('@orkestrel/tool').ToolInterface.summary}
+* {@link import('./factories.js').createAgentTool} advertises in place of
+* {@link AGENT_TOOL_DESCRIPTION} — one sentence offering sub-agent delegation and pointing at
+* `describe` for the optional overrides.
+*
+* @remarks
+* A `ToolManagerInterface.definitions()` call (`@orkestrel/tool`) advertises
+* `summary ?? description`, so this one-sentence text stands in for the full teaching description;
+* the full text stays retrievable through {@link import('./factories.js').createDescribeTool}.
 */
 var 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.";
 /**
-* The description {@link import('./factories.js').createAgentTool} advertises — a short guide
+* Holds the description {@link import('./factories.js').createAgentTool} advertises — a short guide
 * covering the required task and optional provider, tools, and system overrides.
 */
 var AGENT_TOOL_DESCRIPTION = [
 	"Delegate a task to a sub-agent and return its result. Every call runs ONE sub-agent turn to completion.",
 	"",
 	"Required:",
-	"  task     - the instructions the sub-agent should carry out.",
+	"  task     - the instructions the sub-agent carries out.",
 	"Optional overrides (default to the values this tool was configured with):",
 	"  provider - the registry key of the model/provider the sub-agent runs against.",
 	"  tools    - registry keys of the tools loaded into the sub-agent (replaces the default list, not merged).",
@@ -52,7 +56,7 @@ var AGENT_TOOL_DESCRIPTION = [
 	JSON.stringify({ task: "Summarize the attached notes in three bullet points." })
 ].join("\n");
 /**
-* The maximum nesting depth a workflow → agent → workflow chain may reach — the bound
+* Holds the maximum nesting depth a workflow → agent → workflow chain may reach, `8` — the bound
 * {@link import('./factories.js').createAgentFunction} and
 * {@link import('./factories.js').createWorkflowTool}'s depth/cycle guards enforce.
 *
@@ -61,42 +65,42 @@ var AGENT_TOOL_DESCRIPTION = [
 * workflows is allowed, while a ninth nested workflow is rejected with this package's typed
 * `DEPTH` `ToolboxError`.
 */
-var MAX_WORKFLOW_DEPTH = 8;
+var MAX_WORKFLOW_CHAIN = 8;
 /**
-* The name {@link import('./factories.js').createWorkflowTool} advertises by default — the key a
-* model calls and the `ToolManagerInterface` (`@orkestrel/tool`) registers under, and the name
-* {@link import('./factories.js').createAgentFunction} binds the depth/cycle-aware workflow tool
-* under onto a wrapped agent's `context.tools`.
+* Holds the name {@link import('./factories.js').createWorkflowTool} advertises by default,
+* `'workflow'` — the key a model calls and the `ToolManagerInterface` (`@orkestrel/tool`) registers
+* under, and the name {@link import('./factories.js').createAgentFunction} binds the
+* depth/cycle-aware workflow tool under onto a wrapped agent's `context.tools`.
 *
 * @remarks
 * 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}).
+* under this name to the agent's `context.tools`, so it can author and run a nested workflow
+* (bounded by {@link MAX_WORKFLOW_CHAIN}).
 */
 var WORKFLOW_TOOL_NAME = "workflow";
 /**
-* A complete FLAT authoring example — the PRIMARY way a small model authors a workflow through
-* {@link import('./factories.js').createWorkflowTool}: `{ name, steps: [{ name }] }`.
+* Holds 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
+* order; a step's `name` is a registered behavior name (not a label) — the registry key its
+* task's `behavior` resolves against. The tool expands this
 * ({@link import('./helpers.js').expandSteps}) into a valid `WorkflowDefinition`
-* (`@orkestrel/workflow`). It is embedded VERBATIM in {@link WORKFLOW_TOOL_DESCRIPTION}.
+* (`@orkestrel/workflow`). It is embedded verbatim in {@link WORKFLOW_TOOL_DESCRIPTION}.
 */
 var WORKFLOW_TOOL_FLAT_EXAMPLE = Object.freeze({
 	name: "release",
 	steps: Object.freeze([Object.freeze({ name: "compile" }), Object.freeze({ name: "publish" })])
 });
 /**
-* A minimal NESTED authoring example — the ADVANCED escape-hatch form a model may use instead of
-* the flat shape: a full `WorkflowDefinition` (`@orkestrel/workflow`).
+* Holds a minimal nested authoring example — the advanced escape-hatch form a model can use instead
+* of the flat shape: a full `WorkflowDefinition` (`@orkestrel/workflow`).
 *
 * @remarks
-* The full four-level form, documented in
-* {@link WORKFLOW_TOOL_DESCRIPTION} as the advanced alternative. It is embedded VERBATIM.
+* The full nested form, documented in
+* {@link WORKFLOW_TOOL_DESCRIPTION} as the advanced alternative. It is embedded verbatim.
 */
 var WORKFLOW_TOOL_NESTED_EXAMPLE = Object.freeze({
 	id: "release",
@@ -107,20 +111,24 @@ var WORKFLOW_TOOL_NESTED_EXAMPLE = Object.freeze({
 		tasks: Object.freeze([Object.freeze({
 			id: "compile",
 			name: "Compile",
-			run: "compile"
+			behavior: "compile"
 		})])
 	})])
 });
 /**
-* The lean {@link import('@orkestrel/tool').ToolInterface.summary} {@link import('./factories.js').createWorkflowTool}
-* advertises in place of {@link WORKFLOW_TOOL_DESCRIPTION} — a `ToolManagerInterface.definitions()`
-* (`@orkestrel/tool`) advertises `summary ?? description`, so this one-sentence text stands in
-* for the full teaching description; the full text stays retrievable via
-* {@link import('./factories.js').createDescribeTool}.
+* Holds the lean {@link import('@orkestrel/tool').ToolInterface.summary}
+* {@link import('./factories.js').createWorkflowTool} advertises in place of
+* {@link WORKFLOW_TOOL_DESCRIPTION} — one sentence offering multi-phase authoring and pointing at
+* `describe` for the authoring schema and its examples.
+*
+* @remarks
+* A `ToolManagerInterface.definitions()` call (`@orkestrel/tool`) advertises
+* `summary ?? description`, so this one-sentence text stands in for the full teaching description;
+* the full text stays retrievable through {@link import('./factories.js').createDescribeTool}.
 */
 var WORKFLOW_TOOL_SUMMARY = "Author and run a multi-phase workflow in one call — phases run in sequence, tasks within a phase run concurrently. Call describe('workflow') for the full authoring schema and examples.";
 /**
-* The description {@link import('./factories.js').createWorkflowTool} advertises — the flat
+* Holds the description {@link import('./factories.js').createWorkflowTool} advertises — the flat
 * authoring form, its worked example, and the advanced nested definition form.
 */
 var WORKFLOW_TOOL_DESCRIPTION = [
@@ -134,18 +142,19 @@ var WORKFLOW_TOOL_DESCRIPTION = [
 	"Example:",
 	JSON.stringify(WORKFLOW_TOOL_FLAT_EXAMPLE),
 	"",
-	"ADVANCED — the full nested form, for multi-task phases or explicit ids. A workflow has phases; a phase has tasks; a task may have a \"run\" (a registered behavior name); omitting it creates a JSON-null no-op:",
+	"ADVANCED — the full nested form, for multi-task phases or explicit ids. A workflow has phases; a phase has tasks; a task may have a \"behavior\" (a registered behavior name); omitting it creates a JSON-null no-op:",
 	JSON.stringify(WORKFLOW_TOOL_NESTED_EXAMPLE),
 	"In the nested form you may omit any \"id\"/\"name\" and they are filled in positionally; a provided one is kept."
 ].join("\n");
 /**
-* The name {@link import('./factories.js').createWorkspaceTool} advertises by default — the key a
-* model calls and the `ToolManagerInterface` (`@orkestrel/tool`) registers under.
+* Holds the name {@link import('./factories.js').createWorkspaceTool} advertises by default,
+* `'workspace'` — the key a model calls and the `ToolManagerInterface` (`@orkestrel/tool`)
+* registers under.
 */
 var WORKSPACE_TOOL_NAME = "workspace";
 /**
-* A valid {@link import('./types.js').WorkspaceOperation} object — the canonical example embedded
-* VERBATIM in {@link WORKSPACE_TOOL_DESCRIPTION}.
+* Holds a valid {@link import('./types.js').WorkspaceOperation} object — the canonical example
+* embedded verbatim in {@link WORKSPACE_TOOL_DESCRIPTION}.
 *
 * @remarks
 * A `'write'` op (the most common authoring
@@ -158,15 +167,19 @@ var WORKSPACE_TOOL_EXAMPLE = Object.freeze({
 	content: "hello"
 });
 /**
-* The lean {@link import('@orkestrel/tool').ToolInterface.summary} {@link import('./factories.js').createWorkspaceTool}
-* advertises in place of {@link WORKSPACE_TOOL_DESCRIPTION} — a `ToolManagerInterface.definitions()`
-* (`@orkestrel/tool`) advertises `summary ?? description`, so this one-sentence text stands in
-* for the full teaching description; the full text stays retrievable via
-* {@link import('./factories.js').createDescribeTool}.
+* Holds the lean {@link import('@orkestrel/tool').ToolInterface.summary}
+* {@link import('./factories.js').createWorkspaceTool} advertises in place of
+* {@link WORKSPACE_TOOL_DESCRIPTION} — one sentence offering the `operation`-keyed file editing and
+* pointing at `describe` for the operation list and its fields.
+*
+* @remarks
+* A `ToolManagerInterface.definitions()` call (`@orkestrel/tool`) advertises
+* `summary ?? description`, so this one-sentence text stands in for the full teaching description;
+* the full text stays retrievable through {@link import('./factories.js').createDescribeTool}.
 */
 var WORKSPACE_TOOL_SUMMARY = "Read and edit files in a workspace — one operation per call (read, write, list, search, replace, splice, move, remove, plus workspace switching), chosen by the 'operation' field. Call describe('workspace') for the full operation list and fields.";
 /**
-* The description {@link import('./factories.js').createWorkspaceTool} advertises — the
+* Holds the description {@link import('./factories.js').createWorkspaceTool} advertises — the
 * operation-keyed workspace protocol, all supported operations, and worked examples.
 *
 * @remarks
@@ -198,24 +211,26 @@ var WORKSPACE_TOOL_DESCRIPTION = [
 	JSON.stringify(WORKSPACE_TOOL_EXAMPLE)
 ].join("\n");
 /**
-* The name {@link import('./factories.js').createDescribeTool} advertises by default — the key a
-* model calls and the `ToolManagerInterface` (`@orkestrel/tool`) registers under.
+* Holds the name {@link import('./factories.js').createDescribeTool} advertises by default,
+* `'describe'` — the key a model calls and the `ToolManagerInterface` (`@orkestrel/tool`) registers
+* under.
 *
 * @remarks
-* Net-new: pairs with the other three tools' lean {@link AGENT_TOOL_SUMMARY} /
-* {@link WORKFLOW_TOOL_SUMMARY} / {@link WORKSPACE_TOOL_SUMMARY} — a model that reads only the
+* Pairs with the lean {@link AGENT_TOOL_SUMMARY} / {@link WORKFLOW_TOOL_SUMMARY} /
+* {@link WORKSPACE_TOOL_SUMMARY} — a model that reads only the
 * advertised summary can call `describe` with that tool's registered name to get its full
 * teaching description back.
 */
 var DESCRIBE_TOOL_NAME = "describe";
 /**
-* The lean {@link import('@orkestrel/tool').ToolInterface.summary} {@link import('./factories.js').createDescribeTool}
+* Holds the lean {@link import('@orkestrel/tool').ToolInterface.summary} {@link import('./factories.js').createDescribeTool}
 * advertises — this tool needs no teaching of its own, so its summary and description are both
 * short.
 */
 var DESCRIBE_TOOL_SUMMARY = "Return the full description of a named registered tool.";
 /**
-* The DESCRIPTION {@link import('./factories.js').createDescribeTool} advertises.
+* Holds the description {@link import('./factories.js').createDescribeTool} advertises — the
+* registered tool `name` it requires, and the full description of that tool it returns.
 *
 * @remarks
 * Deliberately short — unlike the workflow / workspace / agent tools, this one has no authoring
@@ -223,19 +238,27 @@ var DESCRIBE_TOOL_SUMMARY = "Return the full description of a named registered t
 */
 var DESCRIBE_TOOL_DESCRIPTION = "Return the full description of a registered tool by its name. Required: name - the registered tool name (see another tool listing for available names).";
 /**
-* The name {@link import('./factories.js').createPromptTool} advertises by default — the key a
-* model calls and the `ToolManagerInterface` (`@orkestrel/tool`) registers under.
+* Holds the name {@link import('./factories.js').createPromptTool} advertises by default, `'ask'` —
+* the key a model calls and the `ToolManagerInterface` (`@orkestrel/tool`) registers under.
 */
 var PROMPT_TOOL_NAME = "ask";
 /**
-* The lean {@link import('@orkestrel/tool').ToolInterface.summary} {@link import('./factories.js').createPromptTool}
-* advertises in place of {@link PROMPT_TOOL_DESCRIPTION} — a `ToolManagerInterface.definitions()`
-* (`@orkestrel/tool`) advertises `summary ?? description`, so this one-sentence text stands in
-* for the full teaching description; the full text stays retrievable via
-* {@link import('./factories.js').createDescribeTool}.
+* Holds the lean {@link import('@orkestrel/tool').ToolInterface.summary}
+* {@link import('./factories.js').createPromptTool} advertises in place of
+* {@link PROMPT_TOOL_DESCRIPTION} — one sentence offering the blocking multi-field ask and pointing
+* at `describe` for the schema.
+*
+* @remarks
+* A `ToolManagerInterface.definitions()` call (`@orkestrel/tool`) advertises
+* `summary ?? description`, so this one-sentence text stands in for the full teaching description;
+* the full text stays retrievable through {@link import('./factories.js').createDescribeTool}.
 */
 var PROMPT_TOOL_SUMMARY = "Ask another terminal a multi-field form and BLOCK until it answers; the call resolves with the values record. Call describe('ask') for the schema.";
-/** The full form protocol {@link import('./factories.js').createPromptTool} advertises. */
+/**
+* Holds the form protocol {@link import('./factories.js').createPromptTool} advertises — the
+* required `to` and `schema`, how a field declares its control and its rules, and a worked
+* example.
+*/
 var PROMPT_TOOL_DESCRIPTION = [
 	"Ask another terminal a multi-field form and block until it answers. This call does not return until the addressed terminal answers, or the form expires.",
 	"",
@@ -261,24 +284,32 @@ var PROMPT_TOOL_DESCRIPTION = [
 	})
 ].join("\n");
 /**
-* The name {@link import('./factories.js').createAnswerTool} advertises by default — the key a
-* model calls and the `ToolManagerInterface` (`@orkestrel/tool`) registers under.
+* Holds the name {@link import('./factories.js').createAnswerTool} advertises by default,
+* `'answer'` — the key a model calls and the `ToolManagerInterface` (`@orkestrel/tool`) registers
+* under.
 */
 var ANSWER_TOOL_NAME = "answer";
 /**
-* The lean {@link import('@orkestrel/tool').ToolInterface.summary} {@link import('./factories.js').createAnswerTool}
-* advertises in place of {@link ANSWER_TOOL_DESCRIPTION} — a `ToolManagerInterface.definitions()`
-* (`@orkestrel/tool`) advertises `summary ?? description`, so this one-sentence text stands in
-* for the full teaching description; the full text stays retrievable via
-* {@link import('./factories.js').createDescribeTool}.
+* Holds the lean {@link import('@orkestrel/tool').ToolInterface.summary}
+* {@link import('./factories.js').createAnswerTool} advertises in place of
+* {@link ANSWER_TOOL_DESCRIPTION} — one sentence offering the pending listing and the answer call,
+* and pointing at `describe` for the fields each takes.
+*
+* @remarks
+* A `ToolManagerInterface.definitions()` call (`@orkestrel/tool`) advertises
+* `summary ?? description`, so this one-sentence text stands in for the full teaching description;
+* the full text stays retrievable through {@link import('./factories.js').createDescribeTool}.
 */
 var ANSWER_TOOL_SUMMARY = "List forms addressed to this terminal, or answer one by id with a values record. Call describe('answer') for the required fields.";
-/** The pending/answer protocol {@link import('./factories.js').createAnswerTool} advertises. */
+/**
+* Holds the protocol {@link import('./factories.js').createAnswerTool} advertises — the `pending`
+* and `answer` operations and the `values` record an answer supplies, each with a worked example.
+*/
 var ANSWER_TOOL_DESCRIPTION = [
-	"List the forms currently addressed to this terminal, or answer one of them by id. Every call is ONE operation, chosen by the \"operation\" field.",
+	"List the forms addressed to this terminal, or answer one of them by id. Every call is ONE operation, chosen by the \"operation\" field.",
 	"",
 	"Operations:",
-	"- pending { \"operation\": \"pending\" } — list every form currently addressed to this terminal (id, from, schema).",
+	"- pending { \"operation\": \"pending\" } — list every form addressed to this terminal (id, from, schema).",
 	"- answer  { \"operation\": \"answer\", \"id\": \"<form id>\", \"values\": { \"<field name>\": <field value> } } — answer every required field with the value its control accepts.",
 	"Example — list pending forms:",
 	JSON.stringify({ operation: "pending" }),
@@ -293,28 +324,31 @@ var ANSWER_TOOL_DESCRIPTION = [
 	})
 ].join("\n");
 /**
-* The name the upcoming `createDatabaseTool` factory will advertise by default — the key a model
-* calls and the `ToolManagerInterface` (`@orkestrel/tool`) registers under.
-*
-* @remarks
-* SRC-1 of a 3-unit spine: this unit lands the persistence + schema foundation
-* ({@link import('./types.js').DatabaseDefinition}, {@link import('./types.js').DefinitionStoreInterface},
-* {@link import('./helpers.js').expandTables}); `createDatabaseTool` itself is built in a later unit.
+* Holds the name {@link import('./factories.js').createDatabaseTool} advertises by default,
+* `'database'` — the key a model calls and the `ToolManagerInterface` (`@orkestrel/tool`) registers
+* under.
 */
 var 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}.
+* Holds the lean {@link import('@orkestrel/tool').ToolInterface.summary}
+* {@link import('./factories.js').createDatabaseTool} advertises in place of
+* {@link DATABASE_TOOL_DESCRIPTION} — one sentence offering the `operation`-keyed database call and
+* pointing at `describe` for the operation list, the query form, and the column DSL.
+*
+* @remarks
+* A `ToolManagerInterface.definitions()` call (`@orkestrel/tool`) advertises
+* `summary ?? description`, so this one-sentence text stands in for the full teaching description;
+* the full text stays retrievable through {@link import('./factories.js').createDescribeTool}.
 */
 var DATABASE_TOOL_SUMMARY = "Create and query a database — 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.";
 /**
-* The DESCRIPTION the upcoming database tool will advertise — a multi-line guide that teaches a
-* small model the operation list, the SERIALIZED query form, and the {@link import('./types.js').TableSpec}
-* column DSL.
+* Holds the description {@link import('./factories.js').createDatabaseTool} advertises — a
+* multi-line guide that teaches a small model the operation list, the serialized query form, and
+* the {@link import('./types.js').TableSpec} column DSL.
 *
 * @remarks
-* 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
+* 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.
 */
@@ -322,7 +356,7 @@ var DATABASE_TOOL_DESCRIPTION = [
 	"Create and query a database. Every call is ONE operation, chosen by the \"operation\" field.",
 	"",
 	"Operations (each takes the fields listed):",
-	"- create    { \"operation\": \"create\", \"id\": \"<database id>\", \"tables\": { \"<table>\": { \"columns\": { \"<column>\": \"string\" | \"integer\" | \"number\" | \"boolean\" | { \"type\": \"string\", \"optional\": true } } } }, \"primary\"?: { \"<table>\": \"<column>\" }, \"indexes\"?: { \"<table>\": [[\"<column>\"]] }, \"version\"?: <number> } — define a new database.",
+	"- create    { \"operation\": \"create\", \"id\": \"<database id>\", \"tables\": { \"<table>\": { \"columns\": { \"<column>\": \"string\" | \"integer\" | \"number\" | \"boolean\" | { \"primitive\": \"string\", \"optional\": true } } } }, \"primary\"?: { \"<table>\": \"<column>\" }, \"indexes\"?: { \"<table>\": [[\"<column>\"]] }, \"version\"?: <number> } — define a new database.",
 	"- tables    { \"operation\": \"tables\", \"id\": \"<database id>\" } — list a database's table names.",
 	"- get       { \"operation\": \"get\", \"id\": \"<database id>\", \"table\": \"<table>\", \"key\": \"<row key>\" } — fetch one row by its primary key.",
 	"- records   { \"operation\": \"records\", \"id\": \"<database id>\", \"table\": \"<table>\", \"query\"?: <Query> } — list rows matching a query.",
@@ -339,7 +373,7 @@ var DATABASE_TOOL_DESCRIPTION = [
 	"  operators: equals, not, above, below, from, to, between, like, glob, starts, ends, any, none, absent, present.",
 	"  \"connector\" joins this condition to the next (\"and\" | \"or\"); omit on the last condition.",
 	"",
-	"Column DSL (used by \"create\" \"tables\"): a column is either a bare type string (\"string\" | \"integer\" | \"number\" | \"boolean\"), or { \"type\": \"<type>\", \"optional\": true } when the column may be absent from a row.",
+	"Column DSL (used by \"create\" \"tables\"): a column is either a bare primitive string (\"string\" | \"integer\" | \"number\" | \"boolean\"), or { \"primitive\": \"<primitive>\", \"optional\": true } when the column may be absent from a row.",
 	"Schema configuration is creation-time only. Evolve a schema by opening a newly configured target-version database over a versioned persistent driver; reconciliation requires paired metadata/stamp capabilities.",
 	"Example — create a database:",
 	JSON.stringify({
@@ -349,7 +383,7 @@ var DATABASE_TOOL_DESCRIPTION = [
 			name: "string",
 			price: "number",
 			notes: {
-				type: "string",
+				primitive: "string",
 				optional: true
 			}
 		} } }
@@ -366,9 +400,12 @@ var DATABASE_TOOL_DESCRIPTION = [
 		}] }
 	})
 ].join("\n");
-/** The default cap on rows a `records` call returns when the caller omits `query.limit` — the upcoming database tool's default row ceiling. */
+/**
+* Holds the default cap on rows a `records` call returns when the caller omits `query.limit`,
+* `1000` — the database tool's default row ceiling.
+*/
 var DATABASE_TOOL_LIMIT = 1e3;
-/** The runtime-frozen database-tool mutation names disabled by `DatabaseToolOptions.readonly`. */
+/** Lists the runtime-frozen database-tool mutation names disabled by `DatabaseToolOptions.readonly`. */
 var DATABASE_TOOL_MUTATIONS = Object.freeze([
 	"create",
 	"add",
@@ -378,21 +415,30 @@ var DATABASE_TOOL_MUTATIONS = Object.freeze([
 	"destroy"
 ]);
 /**
-* The name `createRelationTool` advertises by default — the key a model calls and the
-* `ToolManagerInterface` (`@orkestrel/tool`) registers under.
+* Holds the name {@link import('./factories.js').createRelationTool} advertises by default,
+* `'relation'` — the key a model calls and the `ToolManagerInterface` (`@orkestrel/tool`) registers
+* under.
 */
 var RELATION_TOOL_NAME = "relation";
 /**
-* The lean {@link import('@orkestrel/tool').ToolInterface.summary} the relation tool advertises
-* in place of {@link RELATION_TOOL_DESCRIPTION}.
+* Holds the lean {@link import('@orkestrel/tool').ToolInterface.summary}
+* {@link import('./factories.js').createRelationTool} advertises in place of
+* {@link RELATION_TOOL_DESCRIPTION} — one sentence offering the `operation`-keyed relationship
+* traversal and pointing at `describe` for the include-path syntax.
+*
+* @remarks
+* A `ToolManagerInterface.definitions()` call (`@orkestrel/tool`) advertises
+* `summary ?? description`, so this one-sentence text stands in for the full teaching description;
+* the full text stays retrievable through {@link import('./factories.js').createDescribeTool}.
 */
 var RELATION_TOOL_SUMMARY = "Traverse and edit relationships between database rows — one operation per call (load, find, link, unlink, links), chosen by the 'operation' field. Call describe('relation') for the include-path syntax.";
 /**
-* The DESCRIPTION the relation tool advertises — a multi-line guide that teaches a small model
-* the operation list and the flat dot-path `include` syntax.
+* Holds the description {@link import('./factories.js').createRelationTool} advertises — a
+* multi-line guide that teaches a small model the operation list and the flat dot-path `include`
+* syntax.
 *
 * @remarks
-* An include path is a FLAT dot-separated string (`'contacts.account'`), never a nested object —
+* An include path is a flat dot-separated string (`'contacts.account'`), never a nested object —
 * the same small-model ergonomic lever the other tools in this package use for flat args.
 */
 var RELATION_TOOL_DESCRIPTION = [
@@ -414,24 +460,38 @@ var RELATION_TOOL_DESCRIPTION = [
 		include: ["contacts.account"]
 	})
 ].join("\n");
-/** The default cap on rows a `find` / `links` call returns when the caller omits `limit` — the relation tool's default row ceiling. */
+/**
+* Holds the default cap on rows a `find` or `links` call returns when the caller omits `limit`,
+* `1000` — the relation tool's default row ceiling.
+*/
 var RELATION_TOOL_LIMIT = 1e3;
-/** The default cap on how many `include` path segments deep a `load` / `find` call may traverse — the relation tool's default include-depth ceiling. */
+/**
+* Holds the default cap on how many `include` path segments deep a `load` or `find` call may
+* traverse, `3` — the relation tool's default include-depth ceiling.
+*/
 var RELATION_TOOL_DEPTH = 3;
 /**
-* The name {@link import('./factories.js').createInferTool} advertises by default — the key a
-* model calls and the `ToolManagerInterface` (`@orkestrel/tool`) registers under.
+* Holds the name {@link import('./factories.js').createInferTool} advertises by default, `'infer'`
+* — the key a model calls and the `ToolManagerInterface` (`@orkestrel/tool`) registers under.
 */
 var INFER_TOOL_NAME = "infer";
 /**
-* The lean {@link import('@orkestrel/tool').ToolInterface.summary} {@link import('./factories.js').createInferTool}
-* advertises in place of {@link INFER_TOOL_DESCRIPTION} — a `ToolManagerInterface.definitions()`
-* (`@orkestrel/tool`) advertises `summary ?? description`, so this one-sentence text stands in
-* for the full teaching description; the full text stays retrievable via
-* {@link import('./factories.js').createDescribeTool}.
+* Holds the lean {@link import('@orkestrel/tool').ToolInterface.summary}
+* {@link import('./factories.js').createInferTool} advertises in place of
+* {@link INFER_TOOL_DESCRIPTION} — one sentence offering schema inference from example values and
+* pointing at `describe` for the fields it takes.
+*
+* @remarks
+* A `ToolManagerInterface.definitions()` call (`@orkestrel/tool`) advertises
+* `summary ?? description`, so this one-sentence text stands in for the full teaching description;
+* the full text stays retrievable through {@link import('./factories.js').createDescribeTool}.
 */
 var INFER_TOOL_SUMMARY = "Infer a JSON Schema (as advertised tool parameters) from one or more example values. Call describe('infer') for the required fields.";
-/** The schema-inference protocol {@link import('./factories.js').createInferTool} advertises. */
+/**
+* Holds the schema-inference protocol {@link import('./factories.js').createInferTool} advertises —
+* the required `samples`, the optional `format`, `enum`, and `candidates` arguments, and a worked
+* example of the bare return and of the `candidates`-wrapped return.
+*/
 var INFER_TOOL_DESCRIPTION = [
 	"Infer a JSON Schema from example values, returned in the same shape a tool advertises its parameters.",
 	"",
@@ -444,7 +504,7 @@ var INFER_TOOL_DESCRIPTION = [
 	"               is wrapped as { parameters, checks } instead of the bare parameters record, one",
 	"               check per candidate (same index). Every check has the uniform shape",
 	"               { index, valid, coercible, faults? }. `valid` is a STRICT verdict (no coercion)",
-	"               — e.g. the number 7 is NOT valid against a string slot. `coercible` answers a",
+	"               — for example the number 7 is NOT valid against a string slot. `coercible` answers a",
 	"               separate question: would the SAME value be accepted by an endpoint tool call,",
 	"               whose enforcement NORMALIZES args (7 coerces to '7')? So 7 against a string slot",
 	"               yields { valid: false, coercible: true, faults: [] } — a strict mismatch that",
@@ -524,7 +584,7 @@ var INFER_TOOL_DESCRIPTION = [
 //#endregion
 //#region src/core/errors.ts
 /**
-* A package-owned tool-call failure: malformed input or unresolved configuration (`TOOL`),
+* Represents 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`).
 *
@@ -556,10 +616,10 @@ var ToolboxError = class extends Error {
 	}
 };
 /**
-* Type guard narrowing an unknown caught value to an {@link ToolboxError}.
+* Narrows an unknown caught value to a {@link ToolboxError}.
 *
 * @param value - The value to test (typically a `catch` binding)
-* @returns `true` when `value` is an {@link ToolboxError}
+* @returns True if `value` is an {@link ToolboxError}; false otherwise
 *
 * @example
 * ```ts
@@ -576,9 +636,102 @@ function isToolboxError(value) {
 	return value instanceof ToolboxError;
 }
 //#endregion
+//#region src/core/validators.ts
+/**
+* Narrows an unknown value to a valid alternating workflow lineage.
+*
+* @param value - The value to inspect
+* @returns True if `value` is a unique, nonempty-tagged workflow/agent chain; false otherwise
+*/
+function isWorkflowLineage(value) {
+	const inspected = (0, _orkestrel_contract.attempt)(() => {
+		if (!Array.isArray(value)) return false;
+		const seen = /* @__PURE__ */ new Set();
+		for (const [index, tag] of value.entries()) {
+			if (!(0, _orkestrel_contract.isString)(tag)) return false;
+			const prefix = index % 2 === 0 ? "workflow:" : "agent:";
+			if (!tag.startsWith(prefix) || tag.length === prefix.length || seen.has(tag)) return false;
+			seen.add(tag);
+		}
+		return true;
+	});
+	return inspected.success && inspected.value;
+}
+/**
+* Narrows an unknown callable to Toolbox's frozen contextual agent adapter metadata.
+*
+* @param value - The value to inspect
+* @returns True if it is a frozen {@link AgentFunction} with a frozen valid lineage; false otherwise
+*/
+function isAgentFunction(value) {
+	const inspected = (0, _orkestrel_contract.attempt)(() => {
+		if (typeof value !== "function" || !Object.isFrozen(value)) return false;
+		const category = Reflect.getOwnPropertyDescriptor(value, "category");
+		const lineage = Reflect.getOwnPropertyDescriptor(value, "lineage");
+		return category?.value === "agent" && lineage !== void 0 && "value" in lineage && Object.isFrozen(lineage.value) && isWorkflowLineage(lineage.value);
+	});
+	return inspected.success && inspected.value;
+}
+/**
+* Narrows an unknown value to a {@link ColumnSpec}.
+*
+* @param value - The value to inspect
+* @returns True if `value` is a valid {@link ColumnPrimitive} shorthand or a `{ primitive, optional }` record with a valid `primitive`; false otherwise
+*/
+function isColumnSpec(value) {
+	if (isColumnPrimitive(value)) return true;
+	if (!(0, _orkestrel_contract.isRecord)(value)) return false;
+	return isColumnPrimitive(value.primitive) && (value.optional === void 0 || typeof value.optional === "boolean");
+}
+/**
+* Narrows an unknown value to a {@link ColumnPrimitive}.
+*
+* @param value - The value to inspect
+* @returns True if `value` is `'string'`, `'integer'`, `'number'`, or `'boolean'`; false otherwise
+*/
+function isColumnPrimitive(value) {
+	return value === "string" || value === "integer" || value === "number" || value === "boolean";
+}
+/**
+* Narrows an unknown value to a {@link DatabaseDefinition} — a non-empty `id` and `driver`, a
+* `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`).
+*
+* @param value - The value to inspect
+* @returns True if `value` is a complete {@link DatabaseDefinition}; false otherwise
+*/
+function isDatabaseDefinition(value) {
+	if (!(0, _orkestrel_contract.isRecord)(value)) return false;
+	if ("keys" in value) return false;
+	if (!(0, _orkestrel_contract.isNonEmptyString)(value.id) || !(0, _orkestrel_contract.isNonEmptyString)(value.driver)) return false;
+	if (!(0, _orkestrel_contract.isRecord)(value.tables)) return false;
+	for (const table of Object.values(value.tables)) {
+		if (!(0, _orkestrel_contract.isRecord)(table) || !(0, _orkestrel_contract.isRecord)(table.columns)) return false;
+		for (const column of Object.values(table.columns)) if (!isColumnSpec(column)) return false;
+	}
+	if (value.primary !== void 0) {
+		if (!(0, _orkestrel_contract.isRecord)(value.primary)) return false;
+		for (const key of Object.values(value.primary)) if (!(0, _orkestrel_contract.isNonEmptyString)(key)) return false;
+	}
+	if (value.indexes !== void 0) {
+		if (!(0, _orkestrel_contract.isRecord)(value.indexes)) return false;
+		for (const groups of Object.values(value.indexes)) {
+			if (!Array.isArray(groups)) return false;
+			for (const group of groups) {
+				if (!Array.isArray(group) || group.length === 0) return false;
+				for (const column of group) if (!(0, _orkestrel_contract.isNonEmptyString)(column)) return false;
+			}
+		}
+	}
+	if (value.version !== void 0 && !(0, _orkestrel_contract.isFiniteNumber)(value.version)) return false;
+	return true;
+}
+//#endregion
 //#region src/core/shapers.ts
 /**
-* The shape of {@link import('./factories.js').createPromptTool}'s call arguments — `to` names the
+* Describes the shape of {@link import('./factories.js').createPromptTool}'s call arguments — `to` names the
 * terminal identity and `schema` carries the complete multi-field form document.
 *
 * @remarks
@@ -593,7 +746,7 @@ var promptToolShape = (0, _orkestrel_contract.objectShape)({
 	schema: (0, _orkestrel_contract.jsonShape)({ description: "The @orkestrel/form schema to ask, with form metadata and one or more typed fields." })
 });
 /**
-* The shape of {@link import('./factories.js').createAnswerTool}'s call arguments — discriminated
+* Describes the shape of {@link import('./factories.js').createAnswerTool}'s call arguments — discriminated
 * by `operation`: `'pending'` lists the forms addressed to this tool's terminal, while `'answer'`
 * resolves one by `id` with a complete `values` record.
 *
@@ -601,7 +754,7 @@ var promptToolShape = (0, _orkestrel_contract.objectShape)({
 * `values` is first bounded to exact JSON. The handler then narrows it with the originating Form
 * package's `isFormValues` guard before the terminal manager applies it to the parked live form.
 */
-var answerToolShape = (0, _orkestrel_contract.unionShape)((0, _orkestrel_contract.objectShape)({ operation: (0, _orkestrel_contract.literalShape)(["pending"], { description: "List the forms currently addressed to this terminal." }) }), (0, _orkestrel_contract.objectShape)({
+var answerToolShape = (0, _orkestrel_contract.unionShape)((0, _orkestrel_contract.objectShape)({ operation: (0, _orkestrel_contract.literalShape)(["pending"], { description: "List the forms addressed to this terminal." }) }), (0, _orkestrel_contract.objectShape)({
 	operation: (0, _orkestrel_contract.literalShape)(["answer"], { description: "Answer one pending form by id." }),
 	id: (0, _orkestrel_contract.stringShape)({
 		min: 1,
@@ -610,7 +763,7 @@ var answerToolShape = (0, _orkestrel_contract.unionShape)((0, _orkestrel_contrac
 	values: (0, _orkestrel_contract.jsonShape)({ description: "The form answers keyed by field name." })
 }));
 /**
-* The shape of {@link import('./types.js').AgentToolArguments} —
+* Describes the shape of {@link import('./types.js').AgentToolArguments} —
 * {@link import('./factories.js').createAgentTool}'s advertised `parameters`.
 *
 * @remarks
@@ -620,7 +773,7 @@ var answerToolShape = (0, _orkestrel_contract.unionShape)((0, _orkestrel_contrac
 var agentToolShape = (0, _orkestrel_contract.objectShape)({
 	task: (0, _orkestrel_contract.stringShape)({
 		min: 1,
-		description: "The instructions the sub-agent should carry out."
+		description: "The instructions the sub-agent carries out."
 	}),
 	provider: (0, _orkestrel_contract.optionalShape)((0, _orkestrel_contract.stringShape)({
 		min: 1,
@@ -630,7 +783,7 @@ var agentToolShape = (0, _orkestrel_contract.objectShape)({
 	system: (0, _orkestrel_contract.optionalShape)((0, _orkestrel_contract.stringShape)({ description: "A system prompt seeding the sub-agent's context (overrides the default)." }))
 });
 /**
-* The shape of {@link import('./types.js').DescribeToolArguments} —
+* Describes the shape of {@link import('./types.js').DescribeToolArguments} —
 * {@link import('./factories.js').createDescribeTool}'s advertised `parameters`.
 *
 * @remarks
@@ -641,8 +794,8 @@ var describeToolShape = (0, _orkestrel_contract.objectShape)({ name: (0, _orkest
 	description: "The registered name of the tool whose full description to return."
 }) });
 /**
-* The shape of a {@link import('./types.js').TaskDraft} — identical to a strict task shape
-* EXCEPT `id` and `name` are OPTIONAL.
+* Describes the shape of a {@link import('./types.js').TaskDraft} — identical to a strict task
+* shape except that `id` and `name` are optional.
 */
 var taskDraftShape = (0, _orkestrel_contract.objectShape)({
 	id: (0, _orkestrel_contract.optionalShape)((0, _orkestrel_contract.stringShape)({
@@ -654,7 +807,7 @@ var taskDraftShape = (0, _orkestrel_contract.objectShape)({
 		description: "Task name; defaults to the id when omitted."
 	})),
 	description: (0, _orkestrel_contract.optionalShape)((0, _orkestrel_contract.stringShape)({ description: "Optional task description." })),
-	run: (0, _orkestrel_contract.optionalShape)((0, _orkestrel_contract.stringShape)({
+	behavior: (0, _orkestrel_contract.optionalShape)((0, _orkestrel_contract.stringShape)({
 		min: 1,
 		description: "The registered behavior name to invoke (a registry key, not a label); omitted completes with JSON null."
 	})),
@@ -669,8 +822,8 @@ var taskDraftShape = (0, _orkestrel_contract.objectShape)({
 	}))
 });
 /**
-* The shape of a PHASE in a draft workflow — identical to a strict phase shape EXCEPT `id` and
-* `name` are OPTIONAL, and its tasks are {@link taskDraftShape}s.
+* Describes the shape of a phase in a draft workflow — identical to a strict phase shape except
+* that `id` and `name` are optional and each task takes {@link taskDraftShape}.
 */
 var phaseDraftShape = (0, _orkestrel_contract.objectShape)({
 	id: (0, _orkestrel_contract.optionalShape)((0, _orkestrel_contract.stringShape)({
@@ -690,17 +843,17 @@ var phaseDraftShape = (0, _orkestrel_contract.objectShape)({
 	bail: (0, _orkestrel_contract.optionalShape)((0, _orkestrel_contract.literalShape)([true, false], { description: "Per-phase failure-policy override; omitted inherits the workflow bail." }))
 });
 /**
-* The shape of a DRAFT workflow — identical to a strict workflow shape 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.
+* Describes the shape of a draft workflow — identical to a strict workflow shape except that `id`
+* and `name` are optional at the workflow, phase, and task levels, so a small model can omit every
+* identity string and let the tool synthesize them positionally.
 *
 * @remarks
 * The lenient counterpart {@link import('./factories.js').createWorkflowDraftContract} compiles.
-* `run` stays optional like the strict form; omission is the deliberate JSON `null` no-op. A
+* `behavior` 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
+* 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
+* validated against the strict `createWorkflowContract` (`@orkestrel/workflow`) gate before
 * running.
 */
 var workflowDraftShape = (0, _orkestrel_contract.objectShape)({
@@ -717,27 +870,29 @@ var workflowDraftShape = (0, _orkestrel_contract.objectShape)({
 	bail: (0, _orkestrel_contract.optionalShape)((0, _orkestrel_contract.literalShape)([true, false], { description: "Failure policy: false (default) continues gracefully, true halts on the first failure." }))
 });
 /**
-* The shape of ONE flat step — `{ name }` — the building block of {@link workflowStepsShape}.
+* Describes 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
+* `name` is the registered behavior name the step runs (it becomes the task's `behavior`). The tool
 * expands each step into a one-task phase, in order ({@link import('./helpers.js').expandSteps}).
 */
 var stepShape = (0, _orkestrel_contract.objectShape)({ name: (0, _orkestrel_contract.stringShape)({
 	min: 1,
-	description: "The registered behavior name this step runs (becomes the task run)."
+	description: "The registered behavior name this step runs (becomes the task behavior)."
 }) });
 /**
-* The FLAT authoring shape {@link import('./factories.js').createWorkflowTool} advertises as its
-* `parameters` — the simplest surface a small model can fill: `{ name?, steps: [{ name }] }`.
+* Describes the flat authoring shape {@link import('./factories.js').createWorkflowTool} advertises
+* as its `parameters` — the simplest surface a small model can fill:
+* `{ name?, steps: [{ name }] }`.
 *
 * @remarks
 * A deliberately-reduced surface: a flat ordered list of steps, each a `{ name }`. The tool
-* EXPANDS it ({@link import('./helpers.js').expandSteps}) into a full
+* 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 `createWorkflowContract` (`@orkestrel/workflow`) 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
+* then validates against the strict `createWorkflowContract` (`@orkestrel/workflow`) 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.
 */
 var workflowStepsShape = (0, _orkestrel_contract.objectShape)({
@@ -748,20 +903,20 @@ var workflowStepsShape = (0, _orkestrel_contract.objectShape)({
 	steps: (0, _orkestrel_contract.arrayShape)(stepShape, { description: "The ordered steps to run, one after another (each becomes a one-task phase)." })
 });
 /**
-* The shape of a {@link import('./types.js').WorkspaceOperation} — a descriptive tagged union
-* over the 13 workspace edit / read / navigation operations, discriminated by the `operation`
-* literal (never a bare `kind`; AGENTS §4.4). Each variant leads with its `operation`
-* discriminant then its FLAT fields, every field via `stringShape` / `optionalShape` /
+* Describes the shape of a {@link import('./types.js').WorkspaceOperation} — a descriptive tagged union
+* over the workspace edit, read, and navigation operations, discriminated by the `operation`
+* literal (never a bare `kind`). Each variant leads with its `operation`
+* discriminant then its flat fields, every field through `stringShape` / `optionalShape` /
 * `integerShape({ min: 1 })` / `booleanShape`, each carrying a strong field-level `description`.
 *
 * @remarks
-* The union compiles to an `anyOf` JSON Schema + a `unionOf` guard + a first-match parser
+* The union compiles to an `anyOf` JSON Schema, a `unionOf` guard, and 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` / `sensitive`
-* are `optionalShape(booleanShape(...))`. The two REGISTRY arms — `workspaces` (list the
+* hand-written {@link import('./types.js').WorkspaceOperation}). `limit` and the `'splice'`
+* caret components are positive integers (`integerShape({ min: 1 })`); `regex` / `sensitive`
+* are `optionalShape(booleanShape(...))`. The 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.
+* model discover then choose which workspace the edit / read arms target.
 */
 var workspaceToolShape = (0, _orkestrel_contract.unionShape)((0, _orkestrel_contract.objectShape)({
 	operation: (0, _orkestrel_contract.literalShape)(["read"], { description: "Read a whole text file's text by path." }),
@@ -831,27 +986,37 @@ var workspaceToolShape = (0, _orkestrel_contract.unionShape)((0, _orkestrel_cont
 	operation: (0, _orkestrel_contract.literalShape)(["switch"], { description: "Switch the active workspace to the one with this id (get ids from the \"workspaces\" operation). Edit and read operations then target it." }),
 	id: (0, _orkestrel_contract.stringShape)({ description: "The id of the workspace to make active (from the \"workspaces\" listing)." })
 }));
-/** A {@link import('./types.js').ColumnKind} literal — the leaf {@link columnSpecShape} wraps. */
-var columnKindShape = (0, _orkestrel_contract.literalShape)([
+/** Describes a {@link import('./types.js').ColumnPrimitive} literal — the leaf {@link columnSpecShape} wraps. */
+var columnPrimitiveShape = (0, _orkestrel_contract.literalShape)([
 	"string",
 	"integer",
 	"number",
 	"boolean"
-], { description: "A column type: \"string\" | \"integer\" | \"number\" | \"boolean\"." });
-/** A {@link import('./types.js').ColumnSpec} — a bare {@link columnKindShape}, or `{ type, optional }`. */
-var columnSpecShape = (0, _orkestrel_contract.unionShape)(columnKindShape, (0, _orkestrel_contract.objectShape)({
-	type: columnKindShape,
+], { description: "A column primitive: \"string\" | \"integer\" | \"number\" | \"boolean\"." });
+/** Describes a {@link import('./types.js').ColumnSpec} — a bare {@link columnPrimitiveShape}, or `{ primitive, optional }`. */
+var columnSpecShape = (0, _orkestrel_contract.unionShape)(columnPrimitiveShape, (0, _orkestrel_contract.objectShape)({
+	primitive: columnPrimitiveShape,
 	optional: (0, _orkestrel_contract.optionalShape)((0, _orkestrel_contract.booleanShape)({ description: "Whether the column may be absent from a row." }))
 }));
-/** A {@link import('./types.js').TableSpec} — table name to `{ columns }`, each column a {@link columnSpecShape}. */
-var tableSpecShape = (0, _orkestrel_contract.recordShape)((0, _orkestrel_contract.objectShape)({ columns: (0, _orkestrel_contract.recordShape)(columnSpecShape, { description: "Column name to its type." }) }), { description: "Table name to its column layout." });
-/** One key value — a string or number; the array form (multiple keys, positional) resolves FIRST per AGENTS §9.2. */
+/** Describes a {@link import('./types.js').TableSpec} — table name to `{ columns }`, each column a {@link columnSpecShape}. */
+var tableSpecShape = (0, _orkestrel_contract.recordShape)((0, _orkestrel_contract.objectShape)({ columns: (0, _orkestrel_contract.recordShape)(columnSpecShape, { description: "Column name to its primitive or its { primitive, optional } spec." }) }), { description: "Table name to its column layout." });
+/**
+* Describes one key value for the database tool and the relation tool — a string or number; the
+* array form (multiple keys, positional) resolves first, so an array argument is read as many keys
+* rather than one.
+*/
 var keyShape = (0, _orkestrel_contract.unionShape)((0, _orkestrel_contract.arrayShape)((0, _orkestrel_contract.unionShape)((0, _orkestrel_contract.stringShape)(), (0, _orkestrel_contract.numberShape)()), { description: "Multiple row keys, positional — a miss at an index is undefined there." }), (0, _orkestrel_contract.stringShape)({ description: "One row key." }), (0, _orkestrel_contract.numberShape)({ description: "One row key." }));
-/** A loose row — a flat object of column name to JSON value; the array form (multiple rows) resolves FIRST per AGENTS §9.2. */
+/** Describes a loose row — a flat object of column name to JSON value. */
 var rowShape = (0, _orkestrel_contract.recordShape)((0, _orkestrel_contract.jsonShape)(), { description: "A row as a flat object of column name to value." });
-/** One or many loose rows — the array form resolves FIRST per AGENTS §9.2. */
+/**
+* Describes one or many loose rows — the array form resolves first, so an array argument is read as
+* many rows rather than one.
+*/
 var rowsShape = (0, _orkestrel_contract.unionShape)((0, _orkestrel_contract.arrayShape)(rowShape, { description: "Multiple rows." }), rowShape);
-/** One SERIALIZED WHERE condition — `values` is ALWAYS an array, even for a single-value operator. */
+/**
+* Describes one serialized where condition — `values` is always an array, even for a single-value
+* operator.
+*/
 var conditionShape = (0, _orkestrel_contract.objectShape)({
 	column: (0, _orkestrel_contract.stringShape)({ description: "The column this condition applies to." }),
 	operator: (0, _orkestrel_contract.literalShape)([
@@ -874,12 +1039,12 @@ var conditionShape = (0, _orkestrel_contract.objectShape)({
 	values: (0, _orkestrel_contract.arrayShape)((0, _orkestrel_contract.jsonShape)(), { description: "The operand values the operator needs (always an array, even for one value)." }),
 	connector: (0, _orkestrel_contract.optionalShape)((0, _orkestrel_contract.literalShape)(["and", "or"], { description: "Joins this condition to the next; omit on the last condition." }))
 });
-/** One sort term. */
+/** Describes one sort term — a `column` to sort by and the `direction` to sort it in. */
 var orderShape = (0, _orkestrel_contract.objectShape)({
 	column: (0, _orkestrel_contract.stringShape)({ description: "The column to sort by." }),
 	direction: (0, _orkestrel_contract.literalShape)(["ascending", "descending"], { description: "The sort direction." })
 });
-/** The SERIALIZED query form — conditions, order, and pagination. */
+/** Describes the serialized query form — conditions, order, and pagination. */
 var queryShape = (0, _orkestrel_contract.objectShape)({
 	conditions: (0, _orkestrel_contract.optionalShape)((0, _orkestrel_contract.arrayShape)(conditionShape, { description: "The WHERE conditions, folded left to right." })),
 	order: (0, _orkestrel_contract.optionalShape)((0, _orkestrel_contract.arrayShape)(orderShape, { description: "The sort terms, applied in order." })),
@@ -893,18 +1058,17 @@ var queryShape = (0, _orkestrel_contract.objectShape)({
 	}))
 });
 /**
-* The shape of {@link import('./factories.js').createDatabaseTool}'s call arguments —
-* discriminated by `operation` into the 11 database operations (`'create'` / `'tables'` /
-* `'get'` / `'records'` / `'count'` / `'aggregate'` / `'add'` / `'set'` / `'update'` /
-* `'remove'` / `'destroy'`).
+* Describes the shape of {@link import('./factories.js').createDatabaseTool}'s call arguments —
+* discriminated by `operation` into the database operations `'create'`, `'tables'`, `'get'`,
+* `'records'`, `'count'`, `'aggregate'`, `'add'`, `'set'`, `'update'`, `'remove'`, and `'destroy'`.
 *
 * @remarks
 * 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`
+* {@link import('./types.js').TableSpec} column DSL, compiled through
+* {@link import('./compilers.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 `query` (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).
 */
 var databaseToolShape = (0, _orkestrel_contract.unionShape)((0, _orkestrel_contract.objectShape)({
@@ -1037,21 +1201,19 @@ var databaseToolShape = (0, _orkestrel_contract.unionShape)((0, _orkestrel_contr
 		description: "The database id."
 	})
 }));
-/** One key value — a string or number; the array form (multiple keys, positional) resolves FIRST per AGENTS §9.2. */
-var relationKeyShape = (0, _orkestrel_contract.unionShape)((0, _orkestrel_contract.arrayShape)((0, _orkestrel_contract.unionShape)((0, _orkestrel_contract.stringShape)(), (0, _orkestrel_contract.numberShape)()), { description: "Multiple row keys, positional — a miss at an index is undefined there." }), (0, _orkestrel_contract.stringShape)({ description: "One row key." }), (0, _orkestrel_contract.numberShape)({ description: "One row key." }));
-/** A single row key (not an array) — used by `'link'` / `'unlink'` / `'links'`, which address exactly one owning row. */
+/** Describes a single row key (not an array) — used by `'link'` / `'unlink'` / `'links'`, which address exactly one owning row. */
 var singleKeyShape = (0, _orkestrel_contract.unionShape)((0, _orkestrel_contract.stringShape)({ description: "The owning row key." }), (0, _orkestrel_contract.numberShape)({ description: "The owning row key." }));
-/** Flat dot-path relation include list, expanded via {@link import('./helpers.js').expandInclude}. */
-var includeShape = (0, _orkestrel_contract.optionalShape)((0, _orkestrel_contract.arrayShape)((0, _orkestrel_contract.stringShape)({ description: "A dot-separated chain of relation names, e.g. \"contacts.account\"." }), { description: "Which relations to attach, as flat dot-paths." }));
-/** Which registered relation manager to address — omitted resolves to the sole registered manager. */
+/** Describes the flat dot-path relation include list, expanded through {@link import('./helpers.js').expandInclude}. */
+var includeShape = (0, _orkestrel_contract.optionalShape)((0, _orkestrel_contract.arrayShape)((0, _orkestrel_contract.stringShape)({ description: "A dot-separated chain of relation names, for example \"contacts.account\"." }), { description: "Which relations to attach, as flat dot-paths." }));
+/** Describes which registered relation manager to address — omitted resolves to the sole registered manager. */
 var managerShape = (0, _orkestrel_contract.optionalShape)((0, _orkestrel_contract.stringShape)({
 	min: 1,
 	description: "Which registered relation manager to address."
 }));
 /**
-* The shape of {@link import('./factories.js').createRelationTool}'s call arguments —
-* discriminated by `operation` into the 5 relation operations (`'load'` / `'find'` / `'link'` /
-* `'unlink'` / `'links'`).
+* Describes the shape of {@link import('./factories.js').createRelationTool}'s call arguments —
+* discriminated by `operation` into the relation operations `'load'`, `'find'`, `'link'`,
+* `'unlink'`, and `'links'`.
 *
 * @remarks
 * `'load'` fetches one or more rows (positional key/array) with `include` attached. `'find'`
@@ -1065,7 +1227,7 @@ var relationToolShape = (0, _orkestrel_contract.unionShape)((0, _orkestrel_contr
 		min: 1,
 		description: "The model (table) name."
 	}),
-	key: relationKeyShape,
+	key: keyShape,
 	include: includeShape
 }), (0, _orkestrel_contract.objectShape)({
 	operation: (0, _orkestrel_contract.literalShape)(["find"], { description: "List rows, with related rows attached." }),
@@ -1128,7 +1290,7 @@ var relationToolShape = (0, _orkestrel_contract.unionShape)((0, _orkestrel_contr
 	})
 }));
 /**
-* The shape of {@link import('./factories.js').createInferTool}'s call arguments — one or more
+* Describes the shape of {@link import('./factories.js').createInferTool}'s call arguments — one or more
 * example `samples` to infer a JSON Schema from, plus per-call `format` / `enum` toggles and an
 * optional `candidates` array to check against the inferred schema.
 *
@@ -1136,8 +1298,8 @@ var relationToolShape = (0, _orkestrel_contract.unionShape)((0, _orkestrel_contr
 * `samples` requires at least one element (`min: 1`) — an empty array parses to `undefined`,
 * surfaced by the handler as a typed `TOOL` {@link import('./errors.js').ToolboxError}. When
 * `candidates` is present (any array, including empty), the handler compiles a contract from the
-* freshly inferred schema and checks each candidate against it with a STRICT guard (`.is`, no
-* coercion) — the opposite of {@link import('./factories.js').createEndpointTool}'s NORMALIZING
+* freshly inferred schema and checks each candidate against it with a strict guard (`.is`, no
+* coercion) — the opposite of {@link import('./factories.js').createEndpointTool}'s normalizing
 * `.parse` enforcement.
 */
 var inferToolShape = (0, _orkestrel_contract.objectShape)({
@@ -1152,24 +1314,24 @@ var inferToolShape = (0, _orkestrel_contract.objectShape)({
 //#endregion
 //#region src/core/helpers.ts
 /**
-* The ancestry identifier of a workflow in a run chain — `workflow:<id>`.
+* Returns the ancestry identifier of a workflow in a run chain — `workflow:<id>`.
 *
 * @remarks
-* Namespacing keeps a workflow id and an {@link agentTag} agent name in ONE set without
-* collision, so re-entering a workflow OR an agent already in the chain is a single `includes`
+* Namespacing keeps a workflow id and a {@link tagAgent} agent name in one 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>`)
 */
-function workflowTag(id) {
+function tagWorkflow(id) {
 	return `workflow:${id}`;
 }
 /**
-* The ancestry identifier of an agent in a run chain — `agent:<name>`.
+* Returns the ancestry identifier of an agent in a run chain — `agent:<name>`.
 *
 * @remarks
-* The agent counterpart of {@link workflowTag}: {@link import('./factories.js').createAgentFunction}
+* The agent counterpart of {@link tagWorkflow}: {@link import('./factories.js').createAgentFunction}
 * / {@link import('./factories.js').createWorkflowTool} guard against re-entering an agent or
 * workflow already in the chain (this package's typed `DEPTH` `ToolboxError`). The
 * `agent:` namespace keeps it distinct from a same-string workflow id.
@@ -1177,88 +1339,53 @@ function workflowTag(id) {
 * @param name - The agent's identifier / registry name
 * @returns The namespaced ancestry tag (`agent:<name>`)
 */
-function agentTag(name) {
+function tagAgent(name) {
 	return `agent:${name}`;
 }
 /**
-* 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
-*/
-function isWorkflowLineage(value) {
-	const inspected = (0, _orkestrel_contract.attempt)(() => {
-		if (!Array.isArray(value)) return false;
-		const seen = /* @__PURE__ */ new Set();
-		for (const [index, tag] of value.entries()) {
-			if (!(0, _orkestrel_contract.isString)(tag)) return false;
-			const prefix = index % 2 === 0 ? "workflow:" : "agent:";
-			if (!tag.startsWith(prefix) || tag.length === prefix.length || seen.has(tag)) return false;
-			seen.add(tag);
-		}
-		return true;
-	});
-	return inspected.success && inspected.value;
-}
-/**
-* Build a validated, copied, and frozen workflow lineage value.
+* Returns the canonical workflow lineage — validated, copied, and frozen.
 *
 * @param lineage - The configured chain; omitted means a direct root
 * @returns An immutable caller-isolated lineage
 */
-function lineageOf(lineage = []) {
+function normalizeLineage(lineage = []) {
 	if (!isWorkflowLineage(lineage)) throw new ToolboxError("TOOL", "workflow lineage must alternate unique workflow and agent tags");
 	return Object.freeze([...lineage]);
 }
 /**
-* Append one tag to a workflow lineage and return a frozen copy.
+* Appends one tag to a workflow lineage and returns a frozen copy.
 *
 * @param lineage - The valid chain to extend
 * @param tag - The workflow or agent tag to append
 * @returns The validated immutable extension
 */
 function extendLineage(lineage, tag) {
-	return lineageOf([...lineage, tag]);
+	return normalizeLineage([...lineage, tag]);
 }
 /**
-* Derive the zero-based workflow nesting depth from a valid lineage.
+* Derives 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
 */
 function deriveWorkflowDepth(lineage) {
-	const workflows = lineageOf(lineage).filter((tag) => tag.startsWith("workflow:")).length;
+	const workflows = normalizeLineage(lineage).filter((tag) => tag.startsWith("workflow:")).length;
 	return Math.max(0, workflows - 1);
 }
 /**
-* 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
-*/
-function isAgentFunction(value) {
-	const inspected = (0, _orkestrel_contract.attempt)(() => {
-		if (typeof value !== "function" || !Object.isFrozen(value)) return false;
-		const category = Reflect.getOwnPropertyDescriptor(value, "category");
-		const lineage = Reflect.getOwnPropertyDescriptor(value, "lineage");
-		return category?.value === "agent" && lineage !== void 0 && "value" in lineage && Object.isFrozen(lineage.value) && isWorkflowLineage(lineage.value);
-	});
-	return inspected.success && inspected.value;
-}
-/**
-* 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.
+* Builds the plain success summary {@link import('./factories.js').createWorkflowTool} returns on a
+* completed run — the universal tool-handler contract: 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`, settled-task count, and exact optional
+* 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, durable?, fault? }`
 */
-function workflowToolSummary(result) {
+function summarizeWorkflow(result) {
 	return {
 		status: result.status,
 		count: result.results.length,
@@ -1267,21 +1394,21 @@ function workflowToolSummary(result) {
 	};
 }
 /**
-* 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`.
+* Completes a {@link WorkflowDraft} into a strict {@link WorkflowDefinition} — synthesizes a
+* missing `id` deterministically and positionally, and defaults a missing `name` to its 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 —
+* 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
+* the other way round), so the result always carries an `id` and a `name`. `behavior`, `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.
+* against the strict contract.
 *
-* @param draft - The draft workflow (id/name optional at all three levels)
+* @param draft - The draft workflow (`id` and `name` optional at the workflow, phase, and task levels)
 * @returns A complete {@link WorkflowDefinition} with every id/name filled
 */
 function completeDraft(draft) {
@@ -1295,7 +1422,7 @@ function completeDraft(draft) {
 	};
 }
 /**
-* Complete one {@link PhaseDraft} into a strict phase definition — the per-phase step of
+* Completes one {@link PhaseDraft} into a strict phase definition — the per-phase step of
 * {@link completeDraft} (phase `index` → `phase-<index>` when its id is omitted).
 *
 * @param phase - The draft phase
@@ -1314,7 +1441,7 @@ function completePhaseDraft(phase, index) {
 	};
 }
 /**
-* Complete one {@link TaskDraft} into a strict task definition — the per-task leaf step of
+* Completes one {@link TaskDraft} into a strict task definition — the per-task leaf step of
 * {@link completeDraft} (task `index` of phase `<phaseId>` → `<phaseId>-task-<index>` when its id
 * is omitted).
 *
@@ -1329,25 +1456,25 @@ function completeTaskDraft(task, phaseId, index) {
 		id,
 		name: task.name ?? id,
 		...task.description === void 0 ? {} : { description: task.description },
-		...task.run === void 0 ? {} : { run: task.run },
+		...task.behavior === void 0 ? {} : { behavior: task.behavior },
 		...task.retries === void 0 ? {} : { retries: task.retries },
 		...task.timeout === void 0 ? {} : { timeout: task.timeout }
 	};
 }
 /**
-* Expand a flat {@link WorkflowSteps} blob into a strict {@link WorkflowDefinition} — each step
-* becomes a one-task phase, IN ORDER.
+* Expands 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: the deliberately-reduced flat form. Each
+* The expansion of the tool's advertised surface: the deliberately-reduced flat form. Each
 * {@link import('./types.js').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
+* `name` becomes the task's `behavior` (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
+* {@link completeDraft}, so the lenient surfaces share one synthesis path (step `i` → phase
 * `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.
+* 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)
@@ -1358,12 +1485,12 @@ function expandSteps(flat) {
 			id: flat.name,
 			name: flat.name
 		},
-		phases: flat.steps.map((step) => ({ tasks: [{ run: step.name }] }))
+		phases: flat.steps.map((step) => ({ tasks: [{ behavior: step.name }] }))
 	});
 }
 /**
-* Map a caught error to the {@link ToolboxErrorCode} the terminal-tool factory should throw
-* with — the pure classification step of that factory's error handling.
+* Maps a caught error to the {@link ToolboxErrorCode} the terminal-tool factory throws with — the
+* pure classification step of that factory's error handling.
 *
 * @remarks
 * Narrows `error` with {@link isTerminalError} (`@orkestrel/terminal`) first: a non-`TerminalError`
@@ -1376,119 +1503,46 @@ function expandSteps(flat) {
 * @param error - The value caught from a terminal-manager operation (`ask` / `answer` / …)
 * @returns The mapped {@link ToolboxErrorCode}, or `undefined` if `error` is not a `TerminalError`
 */
-function terminalToolCode(error) {
+function inferTerminalCode(error) {
 	if (!(0, _orkestrel_terminal.isTerminalError)(error)) return void 0;
 	if (error.code === "DEADLOCK") return "DEADLOCK";
 	if (error.code === "EXPIRE") return "EXPIRE";
 	return "TOOL";
 }
-/** Narrow an unknown value to a {@link ColumnSpec} — a valid {@link import('./types.js').ColumnKind} shorthand, or `{ type, optional }` with a valid `type`. */
-function isColumnSpec(value) {
-	if (isColumnKind(value)) return true;
-	if (!(0, _orkestrel_contract.isRecord)(value)) return false;
-	return isColumnKind(value.type) && (value.optional === void 0 || typeof value.optional === "boolean");
-}
-/** Narrow an unknown value to a {@link import('./types.js').ColumnKind}. */
-function isColumnKind(value) {
-	return value === "string" || value === "integer" || value === "number" || value === "boolean";
-}
-/**
-* 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 `TableMap` a `@orkestrel/database` `createDatabase` call accepts
-*/
-function expandTables(spec) {
-	const tables = {};
-	for (const [table, definition] of Object.entries(spec)) {
-		const columns = {};
-		for (const [column, kind] of Object.entries(definition.columns)) columns[column] = columnShape(kind);
-		tables[table] = columns;
-	}
-	return tables;
-}
-/** Compile one {@link ColumnSpec} into its `@orkestrel/database` column shape — the per-column leaf {@link expandTables} maps over. */
-function columnShape(spec) {
-	const kind = (0, _orkestrel_contract.isString)(spec) ? spec : spec.type;
-	const optional = !(0, _orkestrel_contract.isString)(spec) && spec.optional === true;
-	const shape = kindShape(kind);
-	return optional ? (0, _orkestrel_contract.optionalShape)(shape) : shape;
-}
-/** Map one {@link import('./types.js').ColumnKind} to its primitive `@orkestrel/database` shape — the leaf {@link columnShape} wraps. */
-function kindShape(kind) {
-	if (kind === "string") return (0, _orkestrel_contract.stringShape)();
-	if (kind === "integer") return (0, _orkestrel_contract.integerShape)();
-	if (kind === "number") return (0, _orkestrel_contract.numberShape)();
-	return (0, _orkestrel_contract.booleanShape)();
-}
-/**
-* 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 }`, 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`).
-*/
-function isDatabaseDefinition(value) {
-	if (!(0, _orkestrel_contract.isRecord)(value)) return false;
-	if ("keys" in value) return false;
-	if (!(0, _orkestrel_contract.isNonEmptyString)(value.id) || !(0, _orkestrel_contract.isNonEmptyString)(value.driver)) return false;
-	if (!(0, _orkestrel_contract.isRecord)(value.tables)) return false;
-	for (const table of Object.values(value.tables)) {
-		if (!(0, _orkestrel_contract.isRecord)(table) || !(0, _orkestrel_contract.isRecord)(table.columns)) return false;
-		for (const column of Object.values(table.columns)) if (!isColumnSpec(column)) return false;
-	}
-	if (value.primary !== void 0) {
-		if (!(0, _orkestrel_contract.isRecord)(value.primary)) return false;
-		for (const key of Object.values(value.primary)) if (!(0, _orkestrel_contract.isNonEmptyString)(key)) return false;
-	}
-	if (value.indexes !== void 0) {
-		if (!(0, _orkestrel_contract.isRecord)(value.indexes)) return false;
-		for (const groups of Object.values(value.indexes)) {
-			if (!Array.isArray(groups)) return false;
-			for (const group of groups) {
-				if (!Array.isArray(group) || group.length === 0) return false;
-				for (const column of group) if (!(0, _orkestrel_contract.isNonEmptyString)(column)) return false;
-			}
-		}
-	}
-	if (value.version !== void 0 && !(0, _orkestrel_contract.isFiniteNumber)(value.version)) return false;
-	return true;
-}
 /**
-* Map a caught error to the {@link ToolboxErrorCode} the upcoming database tool should throw
-* with — the pure classification step of that factory's error handling, mirroring
-* {@link terminalToolCode}'s idiom for `@orkestrel/database`.
+* Maps a caught error to the granular {@link DatabaseErrorCode} (`@orkestrel/database`) the code
+* {@link import('./factories.js').createDatabaseTool} throws with — the pure classification step
+* of that factory's error handling, mirroring {@link inferTerminalCode}'s idiom for
+* `@orkestrel/database`.
 *
 * @param error - The value caught from a `@orkestrel/database` table operation
 * @returns The granular {@link DatabaseErrorCode}, or `undefined` if `error` is not a `DatabaseError`
 */
-function databaseToolCode(error) {
+function inferDatabaseCode(error) {
 	return (0, _orkestrel_database.isDatabaseError)(error) ? error.code : void 0;
 }
 /**
-* Map a caught error to the {@link ToolboxErrorCode} the upcoming relation tool should throw
-* with — the pure classification step of that factory's error handling, mirroring
-* {@link terminalToolCode}'s idiom for `@orkestrel/relation`.
+* Maps a caught error to the granular {@link RelationErrorCode} (`@orkestrel/relation`) the code
+* {@link import('./factories.js').createRelationTool} throws with — the pure classification step
+* of that factory's error handling, mirroring {@link inferTerminalCode}'s idiom for
+* `@orkestrel/relation`.
 *
 * @param error - The value caught from a `@orkestrel/relation` operation
 * @returns The granular {@link RelationErrorCode}, or `undefined` if `error` is not a `RelationError`
 */
-function relationToolCode(error) {
+function inferRelationCode(error) {
 	return (0, _orkestrel_relation.isRelationError)(error) ? error.code : void 0;
 }
 /**
-* Expand the relation tool's FLAT dot-path `include` list into a live `@orkestrel/relation`
+* Expands the relation tool's flat dot-path `include` list into a live `@orkestrel/relation`
 * {@link Include} tree — the pure leaf {@link import('./factories.js').createRelationTool} calls
 * before a `'load'` / `'find'` call.
 *
 * @remarks
 * Each path splits on `'.'` into a chain of relation names, deep-merged into one nested
-* `Include` object with a leaf `true`. A longer path SUBSUMES a shorter sibling's bare `true` —
+* `Include` object with a leaf `true`. A longer path subsumes a shorter sibling's bare `true` —
 * `'contacts'` followed by `'contacts.account'` yields `{ contacts: { account: true } }`, never
-* overwriting the deeper chain. An EMPTY segment (`''`, from a leading/trailing/doubled `.`) or a
+* overwriting the deeper chain. An empty segment (`''`, from a leading/trailing/doubled `.`) or a
 * path whose segment count exceeds `depth` throws a typed `TOOL` {@link ToolboxError}.
 *
 * @param paths - The flat dot-path `include` list (or `undefined` — yields `{}`)
@@ -1551,20 +1605,20 @@ function expandInclude(paths, depth) {
 	return include;
 }
 /**
-* Resolve which registered {@link RelationManagerInterface} a relation-tool call addresses — the
+* Resolves which registered {@link RelationManagerInterface} a relation-tool call addresses — the
 * pure manager-resolution leaf {@link import('./factories.js').createRelationTool} calls on
 * every operation.
 *
 * @remarks
 * An explicit `name` must match a key of `managers` (a miss throws a typed `TOOL`
-* {@link ToolboxError} naming the registered managers). An OMITTED `name` resolves to the sole
+* {@link ToolboxError} naming the registered managers). An omitted `name` resolves to the sole
 * registered manager when exactly one is registered, else throws the same typed error.
 *
 * @param managers - The tool's registered `RelationManagerInterface` map
 * @param name - The call's optional `manager` field
 * @returns The resolved {@link RelationManagerInterface}
 */
-function relationManagerOf(managers, name) {
+function resolveRelationManager(managers, name) {
 	if (name !== void 0) {
 		const manager = managers[name];
 		if (manager === void 0) throw new ToolboxError("TOOL", `unknown relation manager '${name}'`, {
@@ -1582,35 +1636,35 @@ function relationManagerOf(managers, name) {
 	throw new ToolboxError("TOOL", "no relation manager resolved for the call", { managers: names });
 }
 /**
-* Resolve a `model` name against a live {@link RelationManagerInterface} — the pure model-lookup
+* Resolves a `model` name against a live {@link RelationManagerInterface} — the pure model-lookup
 * leaf {@link import('./factories.js').createRelationTool} calls on every operation, mirroring
-* {@link relationManagerOf}'s guard shape.
+* {@link resolveRelationManager}'s guard shape.
 *
 * @param manager - The resolved {@link RelationManagerInterface}
 * @param name - The call's `model` field
 * @returns The model's {@link ModelInterface}
 */
-function relationModelOf(manager, name) {
+function resolveRelationModel(manager, name) {
 	if (!manager.has(name)) throw new ToolboxError("TOOL", `unknown model '${name}'`, {
 		model: name,
-		models: manager.models()
+		models: manager.names()
 	});
 	return manager.model(name);
 }
 /**
-* Normalize the database tool's parsed SERIALIZED query into a live `@orkestrel/database`
-* {@link QueryInput} — default each condition's OMITTED `connector` to `'and'`.
+* Returns the canonical live `@orkestrel/database` {@link QueryInput} for the database tool's
+* parsed serialized query — each condition's omitted `connector` defaults 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
+* 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`
 */
-function queryOf(query) {
+function normalizeQuery(query) {
 	if (query === void 0) return void 0;
 	const conditions = query.conditions?.map((condition) => ({
 		...condition,
@@ -1624,14 +1678,39 @@ function queryOf(query) {
 	};
 }
 /**
-* 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.
+* Picks the effective row limit a tool reads with — the requested count when it sits inside the
+* cap, the cap when it exceeds it, and `0` when either falls below zero.
 *
 * @remarks
-* 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
+* The one place the database tool's `'records'` clamp ({@link clampQuery}) and the relation tool's
+* `'find'` / `'links'` truncation both take their ceiling from, so a negative construction-time
+* option can never reach a slice. Pure and total.
+*
+* @example
+* ```ts
+* import { resolveLimit } from '@src/core'
+*
+* resolveLimit(undefined, 100) // 100 — an omitted request takes the cap
+* resolveLimit(500, 100) // 100 — a request over the cap is clamped down
+* resolveLimit(-1, 100) // 0 — a negative request floors at zero
+* ```
+*
+* @param requested - The caller's requested row count (or `undefined`)
+* @param cap - The row-count ceiling
+* @returns The effective row limit, never below `0` and never above `cap`
+*/
+function resolveLimit(requested, cap) {
+	return Math.max(0, Math.min(requested ?? cap, cap));
+}
+/**
+* Clamps a `'records'` call's query to a row cap, and builds 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
+* {@link resolveLimit} picks the effective limit, so a caller can never exceed the configured cap
+* by supplying a larger `query.limit`, and can never drive it below `0`. 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.
 *
@@ -1647,10 +1726,10 @@ function queryOf(query) {
 *
 * @param query - The live query to clamp (or `undefined`)
 * @param cap - The row-count ceiling
-* @returns The PROBE query (`limit` bumped by one) and the effective `limit`
+* @returns The probe query (`limit` bumped by one) and the effective `limit`
 */
 function clampQuery(query, cap) {
-	const limit = Math.max(0, Math.min(query?.limit ?? cap, cap));
+	const limit = resolveLimit(query?.limit, cap);
 	return {
 		query: {
 			...query,
@@ -1660,28 +1739,77 @@ function clampQuery(query, cap) {
 	};
 }
 //#endregion
+//#region src/core/compilers.ts
+/**
+* Compiles 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 `TableMap` a `@orkestrel/database` `createDatabase` call accepts
+*/
+function expandTables(spec) {
+	const tables = {};
+	for (const [table, definition] of Object.entries(spec)) {
+		const columns = {};
+		for (const [column, columnSpec] of Object.entries(definition.columns)) columns[column] = compileColumn(columnSpec);
+		tables[table] = columns;
+	}
+	return tables;
+}
+/**
+* Compiles one {@link ColumnSpec} into its `@orkestrel/database` column shape — the per-column leaf
+* {@link expandTables} maps over.
+*
+* @param spec - The column spec to compile
+* @returns The `@orkestrel/database` column shape, wrapped in `optionalShape` when the spec declares `optional: true`
+*/
+function compileColumn(spec) {
+	const primitive = (0, _orkestrel_contract.isString)(spec) ? spec : spec.primitive;
+	const optional = !(0, _orkestrel_contract.isString)(spec) && spec.optional === true;
+	const shape = compileColumnPrimitive(primitive);
+	return optional ? (0, _orkestrel_contract.optionalShape)(shape) : shape;
+}
+/**
+* Compiles one {@link import('./types.js').ColumnPrimitive} into its primitive
+* `@orkestrel/database` shape — the leaf {@link compileColumn} wraps.
+*
+* @param primitive - The declared column primitive
+* @returns The matching primitive `@orkestrel/database` shape
+*/
+function compileColumnPrimitive(primitive) {
+	if (primitive === "string") return (0, _orkestrel_contract.stringShape)();
+	if (primitive === "integer") return (0, _orkestrel_contract.integerShape)();
+	if (primitive === "number") return (0, _orkestrel_contract.numberShape)();
+	return (0, _orkestrel_contract.booleanShape)();
+}
+//#endregion
 //#region src/core/stores/MemoryDefinitionStore.ts
 /**
-* The in-memory {@link DefinitionStoreInterface} — a process-lifetime `Map` of
-* {@link DatabaseDefinition}s keyed by database id, the DEFAULT store
-* {@link import('../factories.js').createMemoryDefinitionStore} builds. The EXACT twin of
-* {@link import('./DatabaseDefinitionStore.js').DatabaseDefinitionStore}.
+* Represents the in-memory {@link DefinitionStoreInterface} — a process-lifetime `Map` of
+* {@link DatabaseDefinition}s keyed by database id, the default store
+* {@link import('../factories.js').createMemoryDefinitionStore} builds. It implements the same
+* {@link DefinitionStoreInterface} contract as
+* {@link import('./DatabaseDefinitionStore.js').DatabaseDefinitionStore}: this store copies on
+* write and on read; the table-backed store narrows an untrusted stored blob and reports
+* `undefined` for a malformed one.
 *
 * @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). 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
+* A plain `Map<string, DatabaseDefinition>` (the definition is already pure,
+* 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
 * {@link import('./DatabaseDefinitionStore.js').DatabaseDefinitionStore} (the definition as one
 * opaque JSON column).
 *
 * - **`get` resolves the persisted definition for an id**, or `undefined` if none is stored.
-* - **`set` inserts / replaces under the definition's OWN `id`** (no separate id param).
+* - **`set` inserts / replaces under the definition's own `id`** (no separate id param).
 * - **`delete` drops a definition by id**; an absent id is a no-op (no throw).
 *
-* The public surface is EXACTLY `get` / `set` / `delete` — no extra members (the §22 method
+* The public surface is exactly `get` / `set` / `delete` — no extra members (the method
 * bijection with {@link DefinitionStoreInterface}).
 *
 * @example
@@ -1696,14 +1824,32 @@ function clampQuery(query, cap) {
 */
 var MemoryDefinitionStore = class {
 	#definitions = /* @__PURE__ */ new Map();
+	/**
+	* Resolves the persisted definition for `id`, copied out of the backing `Map`.
+	*
+	* @param id - The database id to read
+	* @returns The stored {@link DatabaseDefinition}, or `undefined` when none is stored
+	*/
 	get(id) {
 		const definition = this.#definitions.get(id);
 		return Promise.resolve(definition === void 0 ? void 0 : structuredClone(definition));
 	}
+	/**
+	* Inserts or replaces a definition under its own `id`, copied into the backing `Map`.
+	*
+	* @param definition - The config to persist; its own `id` is the key (no separate id param)
+	* @returns A promise settling after the definition is stored
+	*/
 	set(definition) {
 		this.#definitions.set(definition.id, structuredClone(definition));
 		return Promise.resolve();
 	}
+	/**
+	* Drops the definition stored under `id`.
+	*
+	* @param id - The database id to drop; an absent id is a no-op, never a throw
+	* @returns A promise settling after no definition is stored under `id`
+	*/
 	delete(id) {
 		this.#definitions.delete(id);
 		return Promise.resolve();
@@ -1712,34 +1858,34 @@ var MemoryDefinitionStore = class {
 //#endregion
 //#region src/core/stores/DatabaseDefinitionStore.ts
 /**
-* A {@link DefinitionStoreInterface} backed by one table of the `@orkestrel/database` layer — a
-* database's durable CONFIG state IS a row, so persistence reduces to keyed point-access
+* Represents a {@link DefinitionStoreInterface} backed by one table of the `@orkestrel/database` layer — a
+* database's durable config state is a row, so persistence reduces to keyed point-access
 * (`get` / `set` / `delete`) over a {@link TableInterface}, the driver-pluggable twin of the
 * plain-`Map` {@link import('./MemoryDefinitionStore.js').MemoryDefinitionStore}.
 *
 * @remarks
 * The store is driver-agnostic: it holds a single {@link TableInterface} whose backend (memory,
 * JSON, SQLite, IndexedDB) is chosen by whoever builds it (the factories), so a JSON / SQLite /
-* IndexedDB backend swaps in WITHOUT touching a consumer — the same seam as
+* IndexedDB backend swaps in without touching a consumer — the same seam as
 * {@link import('./MemoryDefinitionStore.js').MemoryDefinitionStore}. The driver defaults to
 * memory ({@link import('../factories.js').createDatabaseDefinitionStore} passes
-* `createMemoryDriver()`), so it ALSO works in memory out of the box; you opt into the durable
+* `createMemoryDriver()`), so it also works in memory out of the box; you opt into the durable
 * plumbing by passing a JSON / SQLite / IndexedDB driver.
 *
-* The {@link DatabaseDefinition} is stored as ONE OPAQUE JSON COLUMN — the table is a row of
-* `{ id; definition }` ({@link DatabaseDefinitionRow}). The definition is already a COMPLETE,
-* self-contained, pure-JSON CONFIG payload (never a live handle), so storing it whole is lossless
-* AND keeps the row type flat (`definition` reads back as `unknown`).
+* The {@link DatabaseDefinition} is stored as one opaque JSON column — the table is a row of
+* `{ id; definition }` ({@link DatabaseDefinitionRow}). The definition is already a complete,
+* self-contained, pure-JSON config payload (never a live handle), so storing it whole is lossless
+* and keeps the row type flat (`definition` reads back as `unknown`).
 *
-* - **`set(definition)` upserts under the definition's OWN `id`** (no separate id param) — it
+* - **`set(definition)` upserts under the definition's own `id`** (no separate id param) — it
 *   writes the row `{ id: definition.id, definition }`.
 * - **`get(id)` resolves the stored definition for an id**, narrowing the opaque JSON column back
-*   to a {@link DatabaseDefinition} ({@link import('../helpers.js').isDatabaseDefinition} — the
-*   AGENTS §14 boundary narrow for an untrusted storage read), or `undefined` if none is stored
+*   to a {@link DatabaseDefinition} ({@link import('../validators.js').isDatabaseDefinition} — the
+*   boundary narrow for an untrusted storage read), or `undefined` if none is stored
 *   or the stored blob is malformed.
 * - **`delete(id)` drops a definition by id**; an absent id is a no-op (no throw).
 *
-* The public surface is EXACTLY `get` / `set` / `delete` — no extra members (the §22 method
+* The public surface is exactly `get` / `set` / `delete` — no extra members (the method
 * bijection with {@link DefinitionStoreInterface}).
 *
 * @example
@@ -1755,7 +1901,7 @@ var MemoryDefinitionStore = class {
 var DatabaseDefinitionStore = class {
 	#table;
 	/**
-	* Wrap a table as a definition store.
+	* Wraps a table as a definition store.
 	*
 	* @param table - The {@link TableInterface} holding the definitions — its row is the
 	*   {@link DatabaseDefinitionRow} `{ id; definition }` shape (the definition one opaque JSON column)
@@ -1763,20 +1909,37 @@ var DatabaseDefinitionStore = class {
 	constructor(table) {
 		this.#table = table;
 	}
-	/** Resolve the persisted definition for `id`, narrowing the opaque JSON column back to a `DatabaseDefinition`. */
+	/**
+	* Resolves the persisted definition for `id`, narrowing the opaque JSON column back to a
+	* {@link DatabaseDefinition}.
+	*
+	* @param id - The database id to read
+	* @returns The stored {@link DatabaseDefinition}, or `undefined` when none is stored or the
+	*   stored blob is malformed
+	*/
 	async get(id) {
 		const row = await this.#table.get(id);
 		if (row === void 0) return void 0;
 		return isDatabaseDefinition(row.definition) ? row.definition : void 0;
 	}
-	/** Insert or replace under the definition's OWN `id` (no separate id param) — the row is `{ id, definition }`. */
+	/**
+	* Inserts or replaces a definition under its own `id` — the written row is `{ id, definition }`.
+	*
+	* @param definition - The config to persist; its own `id` is the row key (no separate id param)
+	* @returns A promise settling after the row is written
+	*/
 	async set(definition) {
 		await this.#table.set({
 			id: definition.id,
 			definition
 		});
 	}
-	/** Drop a definition by id; an absent id is a no-op (no throw). */
+	/**
+	* Drops the definition stored under `id`.
+	*
+	* @param id - The database id to drop; an absent id is a no-op, never a throw
+	* @returns A promise settling after no row is stored under `id`
+	*/
 	async delete(id) {
 		await this.#table.remove(id);
 	}
@@ -1784,7 +1947,8 @@ var DatabaseDefinitionStore = class {
 //#endregion
 //#region src/core/databases/DatabaseResolver.ts
 /**
-* Resolve database definitions into cached live handles for database tools.
+* Resolves a database definition into a cached live handle for a database tool, over the tool's
+* live handles, its stored definitions, its driver registry, and an optional key generator.
 *
 * @example
 * ```ts
@@ -1800,7 +1964,7 @@ var DatabaseResolver = class {
 	#generator;
 	#store;
 	/**
-	* Create a database resolver over the tool's live state and optional definition store.
+	* Creates a database resolver over the tool's live state and optional definition store.
 	*
 	* @param handles - Initial live database handles cached by id
 	* @param drivers - Driver factories keyed by definition driver name
@@ -1814,16 +1978,16 @@ var DatabaseResolver = class {
 		this.#store = store;
 	}
 	/**
-	* Determine whether a live database is cached by id.
+	* Determines whether a live database is cached by id.
 	*
 	* @param id - Database id
-	* @returns Whether a live handle is cached
+	* @returns True if a live handle is cached; false otherwise
 	*/
 	has(id) {
 		return this.#handles.has(id);
 	}
 	/**
-	* Read a cached database without consulting the definition store.
+	* Reads a cached database without consulting the definition store.
 	*
 	* @param id - Database id
 	* @returns The cached live database, or `undefined`
@@ -1832,7 +1996,7 @@ var DatabaseResolver = class {
 		return this.#handles.get(id);
 	}
 	/**
-	* Cache a live database by id.
+	* Caches a live database by id.
 	*
 	* @param id - Database id
 	* @param database - Live database handle
@@ -1842,7 +2006,7 @@ var DatabaseResolver = class {
 		this.#handles.set(id, database);
 	}
 	/**
-	* Remove a cached live database by id.
+	* Removes a cached live database by id.
 	*
 	* @param id - Database id
 	* @returns Nothing
@@ -1851,7 +2015,8 @@ var DatabaseResolver = class {
 		this.#handles.delete(id);
 	}
 	/**
-	* Resolve a cached or stored database by id.
+	* Resolves a live database by id — the cached handle when one exists, otherwise a database
+	* constructed from its stored definition.
 	*
 	* @param id - Database definition id
 	* @returns The cached or newly constructed live database
@@ -1886,8 +2051,8 @@ var DatabaseResolver = class {
 //#endregion
 //#region src/core/factories.ts
 /**
-* Wrap a registered tool as a {@link WorkflowFunction} (`@orkestrel/workflow`) — the OPT-IN
-* adapter that lets a `function`-form task run a `@orkestrel/tool` tool BY NAME.
+* Wraps a registered tool as a {@link WorkflowFunction} (`@orkestrel/workflow`) — the opt-in
+* adapter that lets a `function`-form task run a `@orkestrel/tool` tool by name.
 *
 * @remarks
 * Composes into a caller's `WorkflowOptions.functions` registry like any other behavior
@@ -1925,7 +2090,7 @@ function createToolFunction(tools, name) {
 	};
 }
 /**
-* Wrap a live `AgentInterface` (`@orkestrel/agent`) as a {@link WorkflowFunction}
+* Wraps a live `AgentInterface` (`@orkestrel/agent`) as a {@link WorkflowFunction}
 * (`@orkestrel/workflow`) — the opt-in adapter that runs the agent to a settled result and carries
 * immutable lineage metadata for contextual Toolbox composition.
 *
@@ -1933,7 +2098,7 @@ function createToolFunction(tools, name) {
 * 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
+* targets deeper than {@link import('./constants.js').MAX_WORKFLOW_CHAIN} 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
@@ -1961,12 +2126,12 @@ function createToolFunction(tools, name) {
 * ```
 */
 function createAgentFunction(agent, options) {
-	const lineage = lineageOf(options?.lineage);
+	const lineage = normalizeLineage(options?.lineage);
 	if (lineage.length > 0 && !lineage.at(-1)?.startsWith("workflow:")) throw new ToolboxError("TOOL", "agent function lineage must end with a workflow tag");
 	const functions = options?.functions === void 0 ? void 0 : Object.freeze({ ...options.functions });
 	const agents = options?.agents === void 0 ? void 0 : Object.freeze({ ...options.agents });
 	return Object.freeze(Object.assign(async (controller) => {
-		const workflow = workflowTag(controller.task.phase.workflow.id);
+		const workflow = tagWorkflow(controller.task.phase.workflow.id);
 		const current = lineage.length === 0 ? extendLineage(lineage, workflow) : lineage;
 		if (current.at(-1) !== workflow) throw new ToolboxError("DEPTH", "agent function workflow does not match its lineage", {
 			workflow,
@@ -1978,7 +2143,7 @@ function createAgentFunction(agent, options) {
 			depth,
 			max: 8
 		});
-		const tag = agentTag(agent.id);
+		const tag = tagAgent(agent.id);
 		if (current.includes(tag)) throw new ToolboxError("DEPTH", `agent '${agent.id}' is already an ancestor (cycle)`, {
 			agent: agent.id,
 			lineage: [...current]
@@ -2010,7 +2175,7 @@ function createAgentFunction(agent, options) {
 	}));
 }
 /**
-* Compose opaque host functions and raw agents into one immutable workflow registry.
+* Composes opaque host functions and raw agents into one immutable workflow registry.
 *
 * @remarks
 * This is the target-aware composition boundary used by direct runner consumers and
@@ -2037,7 +2202,7 @@ function createAgentFunction(agent, options) {
 * ```
 */
 function createWorkflowFunctions(runner, options) {
-	const lineage = lineageOf(options?.lineage);
+	const lineage = normalizeLineage(options?.lineage);
 	if (lineage.length > 0 && !lineage.at(-1)?.startsWith("workflow:")) throw new ToolboxError("TOOL", "workflow functions lineage must end with a workflow tag");
 	const functions = options?.functions === void 0 ? Object.freeze({}) : Object.freeze({ ...options.functions });
 	const agents = options?.agents === void 0 ? Object.freeze({}) : Object.freeze({ ...options.agents });
@@ -2061,7 +2226,9 @@ function createWorkflowFunctions(runner, options) {
 	return Object.freeze(composed);
 }
 /**
-* Compile the lenient workflow draft contract used by {@link createWorkflowTool}.
+* Compiles the lenient workflow draft contract {@link createWorkflowTool} parses an authored tree
+* with — a `ContractInterface` over a {@link WorkflowDraft}, whose `id` and `name` are optional at
+* the workflow, phase, and task levels.
 *
 * @returns The compiled {@link import('./types.js').WorkflowDraft} contract
 */
@@ -2069,34 +2236,33 @@ function createWorkflowDraftContract() {
 	return (0, _orkestrel_contract.createContract)(workflowDraftShape);
 }
 /**
-* 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, and runs it through `runner`, forwarding the caller's optional
-* named functions and native checkpoint store.
+* Wraps a {@link WorkflowDefinition} as an LLM-callable tool — it advertises the flat authoring
+* shape (`{ name?, steps: [{ name }] }`) as its `parameters`, and its handler completes the
+* authored blob, validates it 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
 * Toolbox's flat / draft / full authoring contract, strict soundness gate, and lineage guard.
-* It is ALSO the propagation carrier
+* 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`, 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
-* 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
+* **Widened authoring surface (additive — the canonical contract and runner stay strict and
+* unchanged).** A 2B model reliably calls the tool but cannot reliably emit the full nested
+* {@link WorkflowDefinition}, whose every `id` and `name` is required across an all-or-nothing
+* tree. So the tool accepts the authoring forms that follow and converges them on the same strict
 * `createWorkflowContract` gate before running (soundness preserved):
-* - the FLAT shape `{ name?, steps: [{ name }] }` — the ADVERTISED `parameters` (the simplest
+* - 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
+* - 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, accepted as the draft
 *   super-set.
 *
-* The universal tool-handler contract (AGENTS §14): returns the plain run summary
-* (`{ status, count, durable?, fault? }`) on success, THROWS a typed `ToolboxError` on Toolbox
+* The universal tool-handler contract: returns the plain run summary
+* (`{ 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
@@ -2110,6 +2276,34 @@ function createWorkflowDraftContract() {
 * @returns A `ToolInterface` (named {@link import('./constants.js').WORKFLOW_TOOL_NAME}) whose
 *   `parameters` advertise the flat authoring schema
 *
+* @example Authoring and running a workflow through the tool with a real ToolManager
+* ```ts
+* import { createWorkflowTool } from '@orkestrel/toolbox'
+* import { createToolManager } from '@orkestrel/tool'
+* import { createWorkflowRunner } from '@orkestrel/workflow'
+* import type { WorkflowDefinition } from '@orkestrel/workflow'
+*
+* const definition: WorkflowDefinition = { id: 'release', name: 'Release', phases: [] }
+* const runner = createWorkflowRunner()
+* const functions = {
+* 	compile: () => 'compiled',
+* 	publish: () => 'published',
+* }
+* const tool = createWorkflowTool(definition, runner, { functions })
+*
+* const tools = createToolManager()
+* tools.add(tool)
+*
+* // A small model authors the simple flat shape — no ids/names required.
+* const result = await tools.execute({
+* 	id: 'call-1',
+* 	name: 'workflow',
+* 	arguments: { name: 'release', steps: [{ name: 'compile' }, { name: 'publish' }] },
+* })
+* if (!result.success) throw new Error(result.error)
+* result.value // { status: 'completed', count: 2 } — the single-level envelope; no nested { id, name, value }
+* ```
+*
 * @example
 * ```ts
 * import { createWorkflowTool } from '@src/core'
@@ -2127,7 +2321,7 @@ function createWorkflowTool(definition, runner, options) {
 	const strict = (0, _orkestrel_workflow.createWorkflowContract)();
 	const draft = createWorkflowDraftContract();
 	const steps = (0, _orkestrel_contract.createContract)(workflowStepsShape);
-	const lineage = lineageOf(options?.lineage);
+	const lineage = normalizeLineage(options?.lineage);
 	if (lineage.length > 0 && !lineage.at(-1)?.startsWith("agent:")) throw new ToolboxError("TOOL", "workflow tool lineage must end with an agent tag");
 	const functions = options?.functions === void 0 ? void 0 : Object.freeze({ ...options.functions });
 	const agents = options?.agents === void 0 ? void 0 : Object.freeze({ ...options.agents });
@@ -2152,7 +2346,7 @@ function createWorkflowTool(definition, runner, options) {
 				target = parsed === void 0 ? void 0 : completeDraft(parsed);
 			}
 			if (target === void 0 || !strict.is(target)) throw new ToolboxError("TOOL", "malformed workflow definition", { workflow: definition.id });
-			const tag = workflowTag(target.id);
+			const tag = tagWorkflow(target.id);
 			if (lineage.includes(tag)) throw new ToolboxError("DEPTH", `workflow '${target.id}' is already an ancestor (cycle)`, {
 				workflow: target.id,
 				lineage: [...lineage]
@@ -2170,7 +2364,7 @@ function createWorkflowTool(definition, runner, options) {
 				...agents === void 0 ? {} : { agents },
 				...store === void 0 ? {} : { store }
 			});
-			return workflowToolSummary(await runner.execute(target, {
+			return summarizeWorkflow(await runner.execute(target, {
 				...registry === void 0 ? {} : { functions: registry },
 				...store === void 0 ? {} : { store }
 			}));
@@ -2178,42 +2372,35 @@ function createWorkflowTool(definition, runner, options) {
 	});
 }
 /**
-* Build an LLM-callable workspace-editing tool — it ADVERTISES the `operation`-discriminated
-* 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. 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.
+* Builds an LLM-callable workspace-editing tool — it advertises the `operation`-discriminated 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, returning the plain result.
 *
 * @remarks
-* MANAGER-DRIVEN: every edit / read op (read / list / has / search / replace / write / splice /
+* Manager-driven: every edit / read op (read / list / has / search / replace / write / splice /
 * prepend / append / move / remove) targets `manager.active`, so the model edits whichever
 * workspace is active and a host can re-point it (`WorkspaceManagerInterface.switch`) between
-* turns. Two REGISTRY ops make the model self-sufficient: `workspaces` LISTS the registered
+* turns. The registry ops make the model self-sufficient: `workspaces` lists the registered
 * workspaces (each `{ id, files, active }`) so it can discover an id, and `switch` re-points the
 * active workspace by id (lenient — an unknown id is a no-op reporting `switched: false`, never a
 * throw).
 *
-* NO-ACTIVE RULE (the ergonomic seam): a WRITING op (write / splice / prepend / append / move /
-* remove / replace) run when `manager.active` is `undefined` AUTO-CREATES + activates a default
-* workspace (`manager.add()`) so the model can just start writing; a pure-READ op (read / list /
-* has / search) against no active workspace returns the EMPTY result (`undefined` / `[]` /
+* No-active rule (the ergonomic seam): a writing op (write / splice / prepend / append / move /
+* remove / replace) run when `manager.active` is `undefined` auto-creates and activates a default
+* workspace (`manager.add()`) so the model can start writing; a pure-read op (read / list /
+* has / search) against no active workspace returns the empty result (`undefined` / `[]` /
 * `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` `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
+* The handler conforms to the universal tool-handler contract: it `contract.parse`s
+* 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 (`MISSING` / `MODALITY` / `PATTERN` / `RANGE`)
+* propagate uncaught. The range edit is the flat `'splice'` op: its flat caret integers are
 * 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 ⇒
+* @param options - `manager` (drive directly) or `store` (build a manager over it); neither ⇒
 *   an in-memory-backed manager (see {@link import('./types.js').WorkspaceToolOptions})
 * @returns A `ToolInterface` (named {@link import('./constants.js').WORKSPACE_TOOL_NAME} by default)
 *
@@ -2331,19 +2518,19 @@ function createWorkspaceTool(options) {
 	});
 }
 /**
-* Build an LLM-callable sub-agent delegation tool — resolves a live, seeded `AgentInterface`
-* from `registry` and runs it to completion for ONE delegated `task`.
+* Builds an LLM-callable sub-agent delegation tool — it resolves a live, seeded `AgentInterface`
+* from `registry` and runs it to completion for one delegated `task`.
 *
 * @remarks
-* The universal tool-handler contract (AGENTS §14): validates the call args against
+* The universal tool-handler contract: validates the call args against
 * {@link import('./shapers.js').agentToolShape}, assembles an `AgentJobInput` (`task` seeds the
 * sub-agent's conversation as a single `user` message; `provider` / `tools` / `system` fall
-* back to the tool's own {@link import('./types.js').AgentToolOptions} defaults), rehydrates the sub-agent via
+* back to the tool's own {@link import('./types.js').AgentToolOptions} defaults), rehydrates the sub-agent through
 * `registry.build`, runs it with `agent.generate()`, and returns the settled
-* `AgentResult.content` string (the sub-agent's final text). A missing / unresolvable `provider`, or a malformed call, THROWS a typed `TOOL`
+* `AgentResult.content` string (the sub-agent's final text). A missing / unresolvable `provider`, or a malformed call, throws a typed `TOOL`
 * {@link import('./errors.js').ToolboxError}; a delegation that would exceed
 * {@link import('./constants.js').AGENT_TOOL_DEPTH}, or re-enter an already-delegated agent (a
-* cycle), THROWS a typed `DEPTH` {@link import('./errors.js').ToolboxError} — both isolated
+* cycle), throws a typed `DEPTH` {@link import('./errors.js').ToolboxError}, each isolated
 * by the `ToolManagerInterface` into the canonical tool result's top-level `error`.
 *
 * `AgentInterface` (`@orkestrel/agent`) exposes no teardown method — a bound sub-agent's
@@ -2389,7 +2576,7 @@ function createAgentTool(registry, options) {
 				depth,
 				max: 8
 			});
-			const tag = agentTag(provider);
+			const tag = tagAgent(provider);
 			if (ancestry.includes(tag)) throw new ToolboxError("DEPTH", `agent '${provider}' is already an ancestor (cycle)`, {
 				provider,
 				ancestry: [...ancestry]
@@ -2415,21 +2602,20 @@ function createAgentTool(registry, options) {
 	});
 }
 /**
-* Build an LLM-callable tool that returns the FULL `description` of another registered tool by
-* name — the counterpart to the lean `summary` the other tools in this package advertise
-* (`AGENT_TOOL_SUMMARY` / `WORKFLOW_TOOL_SUMMARY` / `WORKSPACE_TOOL_SUMMARY`).
+* Builds an LLM-callable tool that returns the full `description` of another registered tool by
+* name — the counterpart to the lean `summary` the other tools in this package advertise.
 *
 * @remarks
 * `ToolManagerInterface.definitions()` (`@orkestrel/tool`) advertises `tool.summary ??
 * tool.description` — a lean one-sentence summary stands in for a tool's full teaching
 * description when `summary` is set, keeping the advertised tool list compact for a small model.
 * This tool is the on-demand expansion seam: given a registered tool's `name`, it looks the tool
-* up via `tools.tool(name)` and returns its full `description` (falling back to `summary` when a
+* up through `tools.tool(name)` and returns its full `description` (falling back to `summary` when a
 * tool has no `description` of its own, then a placeholder when it has neither).
 *
-* The universal tool-handler contract (AGENTS §14): validates the call args against
-* {@link import('./shapers.js').describeToolShape}, RETURNS the plain description string on
-* success, THROWS a typed `TOOL` {@link import('./errors.js').ToolboxError} on a malformed call
+* The universal tool-handler contract: validates the call args against
+* {@link import('./shapers.js').describeToolShape}, returns the plain description string on
+* success, throws a typed `TOOL` {@link import('./errors.js').ToolboxError} on a malformed call
 * or an unknown tool name.
 *
 * @param tools - The `ToolManagerInterface` (`@orkestrel/tool`) whose registered tools this
@@ -2466,20 +2652,23 @@ function createDescribeTool(tools) {
 	});
 }
 /**
-* Build an LLM-callable form tool — the ASK side of the terminal seam. Asks
-* a multi-field form and BLOCKS until it answers, returning the resolved values record.
+* Builds an LLM-callable form tool — the ask side of the terminal seam. It asks a multi-field form
+* and blocks until the addressed terminal answers, returning the resolved values record.
 *
 * @remarks
-* The universal tool-handler contract (AGENTS §14): validates the call args against
+* The universal tool-handler contract: validates the call args against
 * {@link import('./shapers.js').promptToolShape}, parses the call's schema through
 * `@orkestrel/form`, constructs the live form, and passes it to `TerminalManagerInterface.ask`.
-* `from` is FIXED at construction
+* `from` is fixed at construction
 * ({@link import('./types.js').PromptToolOptions.from}) — never read from the model-supplied
-* args — so a model cannot spoof which terminal is asking. A form CYCLE rejects with
+* args — so a model cannot spoof which terminal is asking. A form cycle rejects with
 * `TerminalError('DEADLOCK')`, re-surfaced as a typed `DEADLOCK`
 * {@link import('./errors.js').ToolboxError}; an expired form re-surfaces as `EXPIRE`; an
 * unknown `to` (or any other `TerminalError`) re-surfaces as `TOOL`, naming the unknown terminal
-* plus the known ones (`manager.terminals()`).
+* and how many brokers the manager holds (`manager.count`). A schema `parseForm` refuses — an
+* unknown control, a duplicate field name, a `'select'` or `'checkbox'` field without usable
+* `choices` — throws a typed `TOOL` error up front, so a malformed schema never parks as a form
+* nobody can answer.
 *
 * @param options - The live manager, the fixed `from` identity, and advertised overrides (see
 *   {@link import('./types.js').PromptToolOptions})
@@ -2520,7 +2709,7 @@ function createPromptTool(options) {
 				return await options.manager.ask(options.from, call.to, (0, _orkestrel_form.createForm)(schema));
 			} catch (error) {
 				if ((0, _orkestrel_form.isFormError)(error) && error.code === "ABANDONED") throw new ToolboxError("EXPIRE", `form to '${call.to}' expired before it was answered`, { to: call.to });
-				const code = terminalToolCode(error);
+				const code = inferTerminalCode(error);
 				if (code === void 0) throw error;
 				if (code === "DEADLOCK") throw new ToolboxError("DEADLOCK", `asking '${call.to}' would create a form cycle`, (0, _orkestrel_terminal.isTerminalError)(error) ? error.context : {
 					from: options.from,
@@ -2529,7 +2718,7 @@ function createPromptTool(options) {
 				if (code === "EXPIRE") throw new ToolboxError("EXPIRE", `form to '${call.to}' expired before it was answered`, { to: call.to });
 				if ((0, _orkestrel_terminal.isTerminalError)(error) && error.code === "TARGET") throw new ToolboxError("TOOL", `unknown terminal '${call.to}'`, {
 					to: call.to,
-					known: options.manager.terminals()
+					count: options.manager.count
 				});
 				throw new ToolboxError("TOOL", `asking '${call.to}' failed`, { to: call.to });
 			}
@@ -2537,22 +2726,21 @@ function createPromptTool(options) {
 	});
 }
 /**
-* Build an LLM-callable answer tool — the ANSWER side of the terminal seam. Lists the forms
-* currently addressed to {@link import('./types.js').AnswerToolOptions.to}, or answers one of
-* them by id.
+* Builds an LLM-callable answer tool — the answer side of the terminal seam. It lists the forms
+* addressed to {@link import('./types.js').AnswerToolOptions.to}, or answers one of them by id.
 *
 * @remarks
-* The universal tool-handler contract (AGENTS §14): validates the call args against
+* The universal tool-handler contract: validates the call args against
 * {@link import('./shapers.js').answerToolShape} (discriminated by `operation`). `'pending'`
-* returns a compact list (`{ id, from, schema }`) of every form currently addressed to `to`.
+* returns a compact list (`{ id, from, schema }`) of every form addressed to `to`.
 * `'answer'` looks the form up by `id`, narrows the supplied `values` through `@orkestrel/form`,
-* and applies it via
+* and applies it through
 * `TerminalManagerInterface.answer` — a rejected / unknown / unresolvable outcome
 * (`TerminalAnswerResult.error`) re-surfaces as a typed `ANSWER` `ToolboxError`; success returns
-* `{ answered: id }`. `to` is FIXED at construction
+* `{ answered: id }`. `to` is fixed at construction
 * ({@link import('./types.js').AnswerToolOptions.to}) — never read from the model-supplied args —
 * so a model cannot spoof which terminal it is answering for. Concurrent answerers racing on one
-* endpoint are FIRST-WRITE-WINS — a late answer to an already-settled form returns a typed
+* endpoint are first-write-wins — a late answer to an already-settled form returns a typed
 * `ANSWER` `ToolboxError` (surfaced as a 422 over HTTP).
 *
 * @param options - The live manager, the fixed `to` identity, and advertised overrides (see
@@ -2604,9 +2792,9 @@ function createAnswerTool(options) {
 	});
 }
 /**
-* Create the in-memory {@link DefinitionStoreInterface} — a process-lifetime `Map` of database
-* definitions, the DEFAULT store the upcoming database / relation tools will persist their
-* `DatabaseDefinition` configs through.
+* Creates the in-memory {@link DefinitionStoreInterface} — a process-lifetime `Map` of database
+* definitions, the default store the database and relation tools persist their `DatabaseDefinition`
+* configs through.
 *
 * @returns A {@link DefinitionStoreInterface}
 *
@@ -2621,7 +2809,7 @@ function createMemoryDefinitionStore() {
 	return new MemoryDefinitionStore();
 }
 /**
-* Create a {@link DefinitionStoreInterface} backed by one table of the `@orkestrel/database`
+* Creates a {@link DefinitionStoreInterface} backed by one table of the `@orkestrel/database`
 * layer — the driver-pluggable twin of {@link createMemoryDefinitionStore}, storing each
 * database's definition as one opaque JSON column.
 *
@@ -2646,15 +2834,15 @@ function createDatabaseDefinitionStore(driver = (0, _orkestrel_database.createMe
 	}).table("definitions"));
 }
 /**
-* Build an LLM-callable database tool — create, query, and mutate `@orkestrel/database`
-* databases through one `operation`-discriminated call (AGENTS §14, matching
+* Builds an LLM-callable database tool — it creates, queries, and mutates `@orkestrel/database`
+* databases through one `operation`-discriminated call (matching
 * {@link createWorkspaceTool}'s single-tool-many-operations shape).
 *
 * @remarks
-* The universal tool-handler contract (AGENTS §14): validates the call args against
+* The universal tool-handler contract: validates the call args against
 * {@link import('./shapers.js').databaseToolShape}, dispatches to the matching operation, and
-* RETURNS a plain result on success. A database is resolved lazily and cached for the tool's
-* lifetime — `'create'` mints one from `tables` ({@link import('./helpers.js').expandTables}) and
+* returns a plain result on success. A database is resolved lazily and cached for the tool's
+* lifetime — `'create'` mints one from `tables` ({@link import('./compilers.js').expandTables}) and
 * a registered `driver` key ({@link import('./types.js').DatabaseToolOptions.drivers}, default
 * `{ memory: () => createMemoryDriver() }`); any other operation addressing an uncached id falls
 * back to {@link import('./types.js').DatabaseToolOptions.store} (an unknown id throws a typed
@@ -2663,10 +2851,10 @@ function createDatabaseDefinitionStore(driver = (0, _orkestrel_database.createMe
 *
 * `'records'` clamps its `query` to
 * {@link import('./types.js').DatabaseToolOptions.limit} (default
-* {@link import('./constants.js').DATABASE_TOOL_LIMIT}) via
+* {@link import('./constants.js').DATABASE_TOOL_LIMIT}) through
 * {@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'`).
+* than the cap. Every operation's `query` is normalized through
+* {@link import('./helpers.js').normalizeQuery} (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. A configured
 * {@link import('./types.js').DatabaseToolOptions.timeout} is passed as a fresh
@@ -2675,10 +2863,10 @@ function createDatabaseDefinitionStore(driver = (0, _orkestrel_database.createMe
 * 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
+* ({@link import('./helpers.js').inferDatabaseCode}); an `ToolboxError` thrown by this tool's own
 * guards passes through unwrapped.
 *
-* A lazily re-minted database over the DEFAULT in-memory driver yields an EMPTY database — only
+* A lazily re-minted database over the default in-memory driver yields an empty database — only
 * the {@link import('./types.js').DatabaseDefinition} schema persists in `store`, never rows;
 * durable rows need a persistent driver factory registered in
 * {@link import('./types.js').DatabaseToolOptions.drivers}. `'destroy'` closes whatever handle is
@@ -2686,7 +2874,7 @@ function createDatabaseDefinitionStore(driver = (0, _orkestrel_database.createMe
 * {@link import('./types.js').DatabaseToolOptions.databases} handle — the embedder relinquishes
 * that handle's lifecycle to this tool for any id it wires in. This tool assumes the
 * single-writer, non-reentrant model `@orkestrel/database` itself assumes — concurrent calls
-* against one id are NOT serialized by this tool. `'get'` is uncapped by
+* against one id are not serialized by this tool. `'get'` is uncapped by
 * {@link import('./types.js').DatabaseToolOptions.limit} (bounded only by the caller's `key` array
 * size), unlike `'records'` / `'find'` / `'links'`.
 *
@@ -2783,7 +2971,7 @@ function createDatabaseTool(options = {}) {
 					}
 					case "records": {
 						const table = (await resolver.resolve(call.id)).table(call.table);
-						const { query: probe, limit } = clampQuery(queryOf(call.query), cap);
+						const { query: probe, limit } = clampQuery(normalizeQuery(call.query), cap);
 						const rows = await table.records(probe, read);
 						const truncated = rows.length > limit;
 						const sliced = rows.slice(0, limit);
@@ -2794,8 +2982,8 @@ function createDatabaseTool(options = {}) {
 							limit
 						};
 					}
-					case "count": return { count: await (await resolver.resolve(call.id)).table(call.table).count(queryOf(call.query), read) };
-					case "aggregate": return { value: await (await resolver.resolve(call.id)).table(call.table).aggregate(call.function, call.column, queryOf(call.query), read) };
+					case "count": return { count: await (await resolver.resolve(call.id)).table(call.table).count(normalizeQuery(call.query), read) };
+					case "aggregate": return { value: await (await resolver.resolve(call.id)).table(call.table).aggregate(call.function, call.column, normalizeQuery(call.query), read) };
 					case "add": {
 						const table = (await resolver.resolve(call.id)).table(call.table);
 						const many = Array.isArray(call.row);
@@ -2841,7 +3029,7 @@ function createDatabaseTool(options = {}) {
 				}
 			} catch (error) {
 				if (isToolboxError(error)) throw error;
-				const code = databaseToolCode(error);
+				const code = inferDatabaseCode(error);
 				if (code === void 0) throw error;
 				throw new ToolboxError("DATABASE", error instanceof Error ? error.message : String(error), {
 					code,
@@ -2854,32 +3042,33 @@ function createDatabaseTool(options = {}) {
 	});
 }
 /**
-* Build an LLM-callable relation tool — traverse and edit `@orkestrel/relation` relationships
-* through one `operation`-discriminated call (AGENTS §14, matching {@link createDatabaseTool}'s
+* Builds an LLM-callable relation tool — it traverses and edits `@orkestrel/relation` relationships
+* through one `operation`-discriminated call (matching {@link createDatabaseTool}'s
 * single-tool-many-operations shape).
 *
 * @remarks
-* The universal tool-handler contract (AGENTS §14): validates the call args against
+* The universal tool-handler contract: validates the call args against
 * {@link import('./shapers.js').relationToolShape}, resolves the addressed
 * {@link import('@orkestrel/relation').RelationManagerInterface} — an explicit `manager` field
-* must match a key of {@link import('./types.js').RelationToolOptions.managers}, an OMITTED one
-* resolves to the SOLE registered manager, either miss throwing a typed `TOOL`
+* must match a key of {@link import('./types.js').RelationToolOptions.managers}, an omitted one
+* resolves to the sole registered manager, either miss throwing a typed `TOOL`
 * {@link import('./errors.js').ToolboxError}
-* ({@link import('./helpers.js').relationManagerOf}) — then resolves `model` against it
-* ({@link import('./helpers.js').relationModelOf}, same typed-`TOOL`-on-miss shape), and
-* dispatches to the matched operation, RETURNING a plain result on success.
+* ({@link import('./helpers.js').resolveRelationManager}) — then resolves `model` against it
+* ({@link import('./helpers.js').resolveRelationModel}, same typed-`TOOL`-on-miss shape), and
+* dispatches to the matched operation, returning a plain result on success.
 *
-* `'load'` / `'find'` expand the call's FLAT dot-path `include` list into a live
-* `@orkestrel/relation` `Include` tree via {@link import('./helpers.js').expandInclude}, capped
+* `'load'` / `'find'` expand the call's flat dot-path `include` list into a live
+* `@orkestrel/relation` `Include` tree through {@link import('./helpers.js').expandInclude}, capped
 * at {@link import('./types.js').RelationToolOptions.depth} (default
 * {@link import('./constants.js').RELATION_TOOL_DEPTH}) — a path exceeding the cap, or carrying an
 * empty segment, throws a typed `TOOL` error. `'load'` dispatches on whether `key` is an array
-* (positional many-key form, AGENTS §9.2) or a single key. `'find'` and `'links'` clamp their
+* (positional many-key form — an array key is read as many keys rather than one) 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').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
+* {@link import('./constants.js').RELATION_TOOL_LIMIT}), taken through
+* {@link import('./helpers.js').resolveLimit} — `'find'` probes one row past the effective limit 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.
 *
 * A typed `@orkestrel/relation` failure (`RelationError`) re-surfaces as a typed `RELATION`
@@ -2914,7 +3103,7 @@ function createRelationTool(options) {
 			const call = contract.parse(args);
 			if (call === void 0) throw new ToolboxError("TOOL", "malformed relation call", { args });
 			try {
-				const model = relationModelOf(relationManagerOf(options.managers, call.manager), call.model);
+				const model = resolveRelationModel(resolveRelationManager(options.managers, call.manager), call.model);
 				switch (call.operation) {
 					case "load": {
 						const include = expandInclude(call.include, depth);
@@ -2923,7 +3112,7 @@ function createRelationTool(options) {
 					}
 					case "find": {
 						const include = expandInclude(call.include, depth);
-						const effective = Math.min(call.limit ?? cap, cap);
+						const effective = resolveLimit(call.limit, cap);
 						const rows = await model.find(include, {
 							limit: effective + 1,
 							...call.offset === void 0 ? {} : { offset: call.offset },
@@ -2946,27 +3135,28 @@ function createRelationTool(options) {
 						await model.unlink(call.key, call.relation, call.target);
 						return { unlinked: true };
 					case "links": {
+						const effective = resolveLimit(void 0, cap);
 						const keys = await model.links(call.key, call.relation);
-						const truncated = keys.length > cap;
-						const sliced = keys.slice(0, cap);
+						const truncated = keys.length > effective;
+						const sliced = keys.slice(0, effective);
 						return {
 							keys: sliced,
 							count: sliced.length,
 							truncated,
-							limit: cap
+							limit: effective
 						};
 					}
 				}
 			} catch (error) {
 				if (isToolboxError(error)) throw error;
-				const relation = relationToolCode(error);
+				const relation = inferRelationCode(error);
 				if (relation !== void 0) throw new ToolboxError("RELATION", error instanceof Error ? error.message : String(error), {
 					code: relation,
 					operation: call.operation,
 					model: call.model,
 					..."relation" in call ? { relation: call.relation } : {}
 				});
-				const database = databaseToolCode(error);
+				const database = inferDatabaseCode(error);
 				if (database === void 0) throw error;
 				throw new ToolboxError("DATABASE", error instanceof Error ? error.message : String(error), {
 					code: database,
@@ -2977,44 +3167,44 @@ function createRelationTool(options) {
 	});
 }
 /**
-* Build a standalone LLM-callable tool that infers a JSON Schema from example values — the
-* utility half of the "existing API/DB → MCP tool" bridge (the other half,
-* {@link createEndpointTool}, wraps one CONCRETE endpoint).
+* Builds a standalone LLM-callable tool that infers a JSON Schema from example values — the utility
+* half of the bridge from an existing API or database into an MCP tool (the other half,
+* {@link createEndpointTool}, wraps one concrete endpoint).
 *
 * @remarks
-* The universal tool-handler contract (AGENTS §14): validates the call args against
+* The universal tool-handler contract: validates the call args against
 * {@link import('./shapers.js').inferToolShape} (`samples` non-empty, `format` / `enum` optional
-* booleans, `candidates` an optional array), infers a schema via `@orkestrel/contract`'s
-* `samplesToSchema`, wraps a non-object root as `{ value: <schema> }` via `schemaToObject` (mirrors
-* the tool-parameters convention every other `create*Tool` factory advertises), and RETURNS the
+* booleans, `candidates` an optional array), infers a schema through `@orkestrel/contract`'s
+* `samplesToSchema`, wraps a non-object root as `{ value: <schema> }` through `schemaToObject` (mirrors
+* the tool-parameters convention every other `create*Tool` factory advertises), and returns the
 * resulting parameters record. An empty `samples` array fails `inferToolShape`'s `min: 1` bound —
 * `contract.parse` returns `undefined` and the handler throws a typed `TOOL`
 * {@link import('./errors.js').ToolboxError}.
 *
-* When `candidates` is ABSENT, the return is the bare parameters record — unchanged from before
-* this array existed. When `candidates` is PRESENT (any array, including empty), the handler
-* compiles a SEPARATE per-call contract from the RAW inferred schema (via `@orkestrel/contract`'s
-* `schemaToShape`, NOT the `schemaToObject`-wrapped parameters — a bare-value sample checks a
+* When `candidates` is absent, the return is the bare parameters record — unchanged from before
+* this array existed. When `candidates` is present (any array, including empty), the handler
+* compiles a separate per-call contract from the raw inferred schema (through `@orkestrel/contract`'s
+* `schemaToShape`, not the `schemaToObject`-wrapped parameters — a bare-value sample checks a
 * bare-value candidate) and returns `{ parameters, checks }`, one check per candidate at the same
-* index. Every entry has a UNIFORM shape — `{ index, valid, coercible }`, with `faults` added ONLY
-* when `valid` is `false`: `valid` is the STRICT guard verdict (`checker.is(candidate)`), the
-* OPPOSITE of {@link createEndpointTool}'s enforcement, which coerces (`7` becomes `'7'` for a
-* string slot) — here a conformance report answers "does this value conform AS-IS": `7` against a
-* string slot is `valid: false`, full stop. `coercible` answers a SEPARATE question — "would the
-* NORMALIZING parse accept this value", i.e. would {@link createEndpointTool}'s default enforcement
+* index. Every entry has a uniform shape — `{ index, valid, coercible }`, with `faults` added only
+* when `valid` is `false`: `valid` is the strict guard verdict (`checker.is(candidate)`), the
+* opposite of {@link createEndpointTool}'s enforcement, which coerces (`7` becomes `'7'` for a
+* string slot) — here a conformance report answers "does this value conform as-is": `7` against a
+* string slot is `valid: false`, full stop. `coercible` answers a separate question — "would the
+* normalizing parse accept this value", that is would {@link createEndpointTool}'s default enforcement
 * admit it (`checker.parse(candidate) !== undefined`) — computed for every candidate regardless of
-* `valid`; by the house parse/guard round-trip guarantee (AGENTS §14), a `valid: true` entry is
-* ALWAYS also `coercible: true`. `@orkestrel/contract` 0.0.7's `explain` mirrors the normalizing
+* `valid`; by the house parse/guard round-trip, a `valid: true` entry is
+* always also `coercible: true`. `@orkestrel/contract`'s `explain` mirrors the normalizing
 * `parse`'s leniency, not `is`'s strictness — so a strictly-invalid but coercible candidate (`7`
-* against a string slot) yields `{ valid: false, coercible: true, faults: [] }`: EMPTY faults, since
+* against a string slot) yields `{ valid: false, coercible: true, faults: [] }`: empty faults, because
 * the mismatch the normalizing parse would silently fix is not one `explain` reports. `faults`
-* therefore only ever populates for a NON-coercible mismatch — a wrong type the parse can't coerce
+* therefore only ever populates for a non-coercible mismatch — a wrong type the parse can't coerce
 * (a boolean in a string slot), a missing required key, or an out-of-enum value — where
 * `coercible: false`. `checker.is` / `.parse` / `.explain` are all total over JSON-safe input — a
-* JSON-safe hostile candidate (a `__proto__`-carrying object, deeply nested data) reaches all three
-* and yields a bounded, non-throwing per-candidate verdict; a NON-JSON-safe candidate (e.g. a
-* throwing-getter `Proxy`) never reaches the checker at all — it fails the OUTER `args` parse
-* against {@link import('./shapers.js').inferToolShape} and rejects the WHOLE call with the same
+* JSON-safe hostile candidate (a `__proto__`-carrying object, deeply nested data) reaches each of them
+* and yields a bounded, non-throwing per-candidate verdict; a non-JSON-safe candidate (for example a
+* throwing-getter `Proxy`) never reaches the checker at all — it fails the outer `args` parse
+* against {@link import('./shapers.js').inferToolShape} and rejects the whole call with the same
 * `TOOL` {@link import('./errors.js').ToolboxError} a malformed `samples`/`format`/`enum` throws,
 * with no per-candidate verdict produced.
 *
@@ -3093,36 +3283,36 @@ function createInferTool(options) {
 	});
 }
 /**
-* Wrap one CONCRETE endpoint ({@link import('./types.js').EndpointDefinition}) as an LLM-callable
-* `ToolInterface` — the endpoint half of the "existing API/DB → MCP tool" bridge (the other half,
-* {@link createInferTool}, is a standalone inference utility).
+* Wraps one concrete endpoint ({@link import('./types.js').EndpointDefinition}) as an LLM-callable
+* `ToolInterface` — the endpoint half of the bridge from an existing API or database into an MCP
+* tool (the other half, {@link createInferTool}, is a standalone inference utility).
 *
 * @remarks
-* `parameters` is inferred ONCE at construction from `definition.samples` via
+* `parameters` is inferred once at construction from `definition.samples` through
 * `@orkestrel/contract`'s `samplesToSchema` (tuned by {@link import('./types.js').EndpointToolOptions}'s
-* `format` / `enum`), wrapping a non-object root as `{ value: <schema> }` via `schemaToObject` —
-* the SAME object-rooted schema is both the ADVERTISED `parameters` and, by default
-* ({@link import('./types.js').EndpointToolOptions.validate} `true`), the ENFORCED contract:
-* `@orkestrel/contract` 0.0.7's `schemaToShape` compiles it ONCE (via `createContract`) into a
-* `ContractInterface` whose `.parse` runs on every call's `args` before `definition.invoke` — a
-* NORMALIZING parse, not a strict type check: a scalar is COERCED to its inferred type where the
+* `format` / `enum`), wrapping a non-object root as `{ value: <schema> }` through `schemaToObject` —
+* the same object-rooted schema is both the advertised `parameters` and, by default
+* ({@link import('./types.js').EndpointToolOptions.validate} `true`), the enforced contract:
+* `@orkestrel/contract`'s `schemaToShape` compiles it once (through `createContract`) into a
+* `ContractInterface` whose `.parse` runs on every call's `args` before `definition.execute` — a
+* normalizing parse, not a strict type check: a scalar is coerced to its inferred type where the
 * house parsers coerce (a number to/from a numeric string, a boolean from `'1'`/`'0'`/`'true'`/
-* `'false'`/`1`/`0`), so `definition.invoke` receives the COERCED value (e.g. `7` sent for a
+* `'false'`/`1`/`0`), so `definition.execute` receives the coerced value (for example `7` sent for a
 * string slot arrives as `'7'`), not the raw call value. A call whose `args` fails to parse into
-* a record — a required key missing, or a value not coercible to its slot's type — THROWS a
+* a record — a required key missing, or a value not coercible to its slot's type — throws a
 * typed `TOOL` {@link import('./errors.js').ToolboxError} carrying the compiled contract's
-* structured `explain` faults, and `definition.invoke` is never called. `format` annotations are
-* NEVER asserted, and a key outside the closed inferred schema is SILENTLY DROPPED rather than
+* structured `explain` faults, and `definition.execute` is never called. `format` annotations are
+* never asserted, and a key outside the closed inferred schema is silently dropped rather than
 * rejected (see {@link import('./types.js').EndpointToolOptions.validate}). With
-* `validate: false`, `execute` PASSES THROUGH the model-supplied `args` to `definition.invoke`
-* WITHOUT re-validation — the pre-0.0.7 behavior, preserved as an explicit opt-out. Either way,
-* `invoke`'s return flows back as the tool call's plain result; a throw PROPAGATES uncaught,
+* `validate: false`, the tool's `execute` passes through the model-supplied `args` to
+* `definition.execute` without re-validation — the raw-passthrough opt-out. Either way, the
+* definition's return flows back as the tool call's plain result; a throw propagates uncaught,
 * isolated by the `ToolManagerInterface` (`@orkestrel/tool`) into the canonical error envelope
-* (AGENTS §14) — never caught or re-wrapped here.
+* — never caught or re-wrapped here.
 *
 * @param definition - The endpoint's identity, non-empty samples, and local handler (see
 *   {@link import('./types.js').EndpointDefinition})
-* @param options - Construction-time inference tuning + the validate opt-out (see
+* @param options - Construction-time inference tuning and the validate opt-out (see
 *   {@link import('./types.js').EndpointToolOptions})
 * @returns A `ToolInterface` named `definition.name`
 *
@@ -3135,12 +3325,12 @@ function createInferTool(options) {
 * 	name: 'lookupUser',
 * 	description: 'Look up a user by id.',
 * 	samples: [{ id: '1', name: 'Ada' }, { id: '2', name: 'Bob' }],
-* 	invoke: (args) => ({ id: args.id, name: 'Ada' }),
+* 	execute: (args) => ({ id: args.id, name: 'Ada' }),
 * })
 * const tools = createToolManager()
 * tools.add(tool)
 *
-* // conforming args (all required keys present) parse and reach `invoke`
+* // conforming args (all required keys present) parse and reach the definition's `execute`
 * const result = await tools.execute({
 * 	id: 'call-1',
 * 	name: 'lookupUser',
@@ -3149,7 +3339,7 @@ function createInferTool(options) {
 * // result.value -> { id: '1', name: 'Ada' }
 *
 * // a nonconforming call (id is not coercible to the required string) is rejected before
-* // `invoke` runs
+* // the definition's `execute` runs
 * const rejected = await tools.execute({
 * 	id: 'call-2',
 * 	name: 'lookupUser',
@@ -3170,7 +3360,7 @@ function createEndpointTool(definition, options) {
 		description: definition.description,
 		...parameters === void 0 ? {} : { parameters },
 		execute(args) {
-			return definition.invoke(args);
+			return definition.execute(args);
 		}
 	});
 	const contract = (0, _orkestrel_contract.createContract)((0, _orkestrel_contract.schemaToShape)(objectSchema));
@@ -3184,7 +3374,7 @@ function createEndpointTool(definition, options) {
 				name: definition.name,
 				faults: contract.explain(args)
 			});
-			return definition.invoke(parsed);
+			return definition.execute(parsed);
 		}
 	});
 }
@@ -3209,7 +3399,7 @@ exports.DatabaseResolver = DatabaseResolver;
 exports.INFER_TOOL_DESCRIPTION = INFER_TOOL_DESCRIPTION;
 exports.INFER_TOOL_NAME = INFER_TOOL_NAME;
 exports.INFER_TOOL_SUMMARY = INFER_TOOL_SUMMARY;
-exports.MAX_WORKFLOW_DEPTH = MAX_WORKFLOW_DEPTH;
+exports.MAX_WORKFLOW_CHAIN = MAX_WORKFLOW_CHAIN;
 exports.MemoryDefinitionStore = MemoryDefinitionStore;
 exports.PROMPT_TOOL_DESCRIPTION = PROMPT_TOOL_DESCRIPTION;
 exports.PROMPT_TOOL_NAME = PROMPT_TOOL_NAME;
@@ -3229,13 +3419,13 @@ exports.WORKSPACE_TOOL_DESCRIPTION = WORKSPACE_TOOL_DESCRIPTION;
 exports.WORKSPACE_TOOL_EXAMPLE = WORKSPACE_TOOL_EXAMPLE;
 exports.WORKSPACE_TOOL_NAME = WORKSPACE_TOOL_NAME;
 exports.WORKSPACE_TOOL_SUMMARY = WORKSPACE_TOOL_SUMMARY;
-exports.agentTag = agentTag;
 exports.agentToolShape = agentToolShape;
 exports.answerToolShape = answerToolShape;
 exports.clampQuery = clampQuery;
-exports.columnKindShape = columnKindShape;
-exports.columnShape = columnShape;
+exports.columnPrimitiveShape = columnPrimitiveShape;
 exports.columnSpecShape = columnSpecShape;
+exports.compileColumn = compileColumn;
+exports.compileColumnPrimitive = compileColumnPrimitive;
 exports.completeDraft = completeDraft;
 exports.completePhaseDraft = completePhaseDraft;
 exports.completeTaskDraft = completeTaskDraft;
@@ -3256,7 +3446,6 @@ exports.createWorkflowDraftContract = createWorkflowDraftContract;
 exports.createWorkflowFunctions = createWorkflowFunctions;
 exports.createWorkflowTool = createWorkflowTool;
 exports.createWorkspaceTool = createWorkspaceTool;
-exports.databaseToolCode = databaseToolCode;
 exports.databaseToolShape = databaseToolShape;
 exports.deriveWorkflowDepth = deriveWorkflowDepth;
 exports.describeToolShape = describeToolShape;
@@ -3265,38 +3454,39 @@ exports.expandSteps = expandSteps;
 exports.expandTables = expandTables;
 exports.extendLineage = extendLineage;
 exports.includeShape = includeShape;
+exports.inferDatabaseCode = inferDatabaseCode;
+exports.inferRelationCode = inferRelationCode;
+exports.inferTerminalCode = inferTerminalCode;
 exports.inferToolShape = inferToolShape;
 exports.isAgentFunction = isAgentFunction;
-exports.isColumnKind = isColumnKind;
+exports.isColumnPrimitive = isColumnPrimitive;
 exports.isColumnSpec = isColumnSpec;
 exports.isDatabaseDefinition = isDatabaseDefinition;
 exports.isToolboxError = isToolboxError;
 exports.isWorkflowLineage = isWorkflowLineage;
 exports.keyShape = keyShape;
-exports.kindShape = kindShape;
-exports.lineageOf = lineageOf;
 exports.managerShape = managerShape;
+exports.normalizeLineage = normalizeLineage;
+exports.normalizeQuery = normalizeQuery;
 exports.orderShape = orderShape;
 exports.phaseDraftShape = phaseDraftShape;
 exports.promptToolShape = promptToolShape;
-exports.queryOf = queryOf;
 exports.queryShape = queryShape;
-exports.relationKeyShape = relationKeyShape;
-exports.relationManagerOf = relationManagerOf;
-exports.relationModelOf = relationModelOf;
-exports.relationToolCode = relationToolCode;
 exports.relationToolShape = relationToolShape;
+exports.resolveLimit = resolveLimit;
+exports.resolveRelationManager = resolveRelationManager;
+exports.resolveRelationModel = resolveRelationModel;
 exports.rowShape = rowShape;
 exports.rowsShape = rowsShape;
 exports.singleKeyShape = singleKeyShape;
 exports.stepShape = stepShape;
+exports.summarizeWorkflow = summarizeWorkflow;
 exports.tableSpecShape = tableSpecShape;
+exports.tagAgent = tagAgent;
+exports.tagWorkflow = tagWorkflow;
 exports.taskDraftShape = taskDraftShape;
-exports.terminalToolCode = terminalToolCode;
 exports.workflowDraftShape = workflowDraftShape;
 exports.workflowStepsShape = workflowStepsShape;
-exports.workflowTag = workflowTag;
-exports.workflowToolSummary = workflowToolSummary;
 exports.workspaceToolShape = workspaceToolShape;
 
 //# sourceMappingURL=index.cjs.map