@orkestrel/brief 0.0.5 → 0.0.7

package/dist/src/core/index.cjs

@@ -4,7 +4,7 @@ let _orkestrel_interpret = require("@orkestrel/interpret");
 let _orkestrel_reason = require("@orkestrel/reason");
 let _orkestrel_emitter = require("@orkestrel/emitter");
 //#region src/core/constants.ts
-/** The twelve `TaskOperation` values, frozen. */
+/** Lists the `TaskOperation` values, frozen. */
 var TASK_OPERATIONS = Object.freeze([
 	"create",
 	"refactor",
@@ -19,7 +19,7 @@ var TASK_OPERATIONS = Object.freeze([
 	"document",
 	"plan"
 ]);
-/** The eight `TaskDomain` values, frozen. */
+/** Lists the `TaskDomain` values, frozen. */
 var TASK_DOMAINS = Object.freeze([
 	"code",
 	"writing",
@@ -30,7 +30,7 @@ var TASK_DOMAINS = Object.freeze([
 	"ops",
 	"other"
 ]);
-/** The five `OutputFormat` values, frozen. */
+/** Lists the `OutputFormat` values, frozen. */
 var OUTPUT_FORMATS = Object.freeze([
 	"markdown",
 	"json",
@@ -38,35 +38,64 @@ var OUTPUT_FORMATS = Object.freeze([
 	"diff",
 	"prose"
 ]);
-/** The three `RiskSeverity` values, frozen. */
+/** Lists the `RiskSeverity` values, frozen. */
 var RISK_SEVERITIES = Object.freeze([
 	"low",
 	"medium",
 	"high"
 ]);
 /**
-* `16` — the default turn cap `briefToGoal` renders.
+* Lists every published `Interpretation` member name, frozen.
+*
+* @remarks
+* The capture list `BriefCompiler` hands `captureValue` at each interpret door — the borrowed
+* engine's return, and the caller's supplied interpretation. A class instance carries its
+* contract on the prototype, so the captured view materializes exactly the members named here,
+* and a name missing from the list is a member the view drops.
+*
+* The `satisfies` clause refuses a name `Interpretation` does not declare, and it holds the
+* element type at the listed names rather than widening it to `string`. That is what lets the
+* equality assertion beside the capture cases refuse a list that has fallen short of the
+* published shape.
+*/
+var INTERPRETATION_MEMBERS = Object.freeze([
+	"text",
+	"normalized",
+	"intent",
+	"entities",
+	"subject",
+	"definition",
+	"mappings",
+	"ambiguities",
+	"prompt",
+	"stages",
+	"failures",
+	"confidence",
+	"digest"
+]);
+/**
+* Holds `16` — the default turn cap `briefToGoal` renders.
 *
 * @remarks
 * Domain-qualified so the barrel stays collision-free as sibling modules add their own
 * turn defaults.
 */
 var DEFAULT_BRIEF_TURNS = 16;
-/** `'gate'` — the id of the `gateDefinition()` logical definition. */
+/** Holds `'gate'` — the id of the `buildGateDefinition()` logical definition. */
 var GATE_ID = "gate";
 /**
-* Every line terminator a brief field refuses.
+* Matches every line terminator a brief field refuses.
 *
 * @remarks
-* The four ECMAScript line terminators, not just `\n`: a renderer that splits on any of
-* them would let the other three forge a markdown row. CRLF leads the alternation so a
-* Windows exemplar splits as ONE break rather than two, which would insert a blank line the
-* caller never wrote. Kept unanchored and stateless — no `g` flag — so `test` never carries
+* Every ECMAScript line terminator, not just `\n`: a renderer that splits on any of them
+* would let the others forge a markdown row. CRLF leads the alternation so a Windows
+* exemplar splits as ONE break rather than two, which would insert a blank line the caller
+* never wrote. Kept unanchored and stateless — no `g` flag — so `test` never carries
 * `lastIndex` between calls.
 */
 var LINE_BREAK_PATTERN = /\r\n|[\n\r\u2028\u2029]/;
 /**
-* The positive form of {@link LINE_BREAK_PATTERN}, for the shape DSL.
+* Holds the positive form of {@link LINE_BREAK_PATTERN}, for the shape DSL.
 *
 * @remarks
 * `stringShape`'s `pattern` must MATCH an accepted value, so the guard's refusal regex
@@ -75,7 +104,7 @@ var LINE_BREAK_PATTERN = /\r\n|[\n\r\u2028\u2029]/;
 */
 var SINGLE_LINE_PATTERN = /^[^\n\r\u2028\u2029]*$/;
 /**
-* A string of one or more spaces and nothing else.
+* Matches a string of one or more spaces and nothing else.
 *
 * @remarks
 * The one exemplar side `exampleToLines` must NOT pad. CommonMark strips a fully-blank code
@@ -89,7 +118,7 @@ var BLANK_PATTERN = /^ +$/;
 //#endregion
 //#region src/core/errors.ts
 /**
-* The one error class this package throws.
+* Represents the one error class this package throws.
 *
 * @remarks
 * Throws are reserved for caller misuse: `assertBrief`, `snapshotBrief`, and `pinBrief` on
@@ -119,10 +148,10 @@ var BriefError = class extends Error {
 	}
 };
 /**
-* Narrow a caught value to a {@link BriefError}.
+* Narrows a caught value to a {@link BriefError}.
 *
 * @param value - The caught value to inspect.
-* @returns `true` when `value` is a `BriefError`.
+* @returns True if `value` is a `BriefError`; false otherwise.
 *
 * @example
 * ```ts
@@ -140,82 +169,82 @@ function isBriefError(value) {
 }
 //#endregion
 //#region src/core/shapers.ts
-/** A single-line string of any length, including empty. */
+/** Describes a single-line string of any length, including empty. */
 var textShape = (0, _orkestrel_contract.stringShape)({ pattern: SINGLE_LINE_PATTERN });
-/** A non-empty single-line string — the shape mirror of `isLine`. */
+/** Describes a non-empty single-line string — the shape mirror of `isLine`. */
 var lineShape = (0, _orkestrel_contract.stringShape)({
 	min: 1,
 	pattern: SINGLE_LINE_PATTERN
 });
-/** The `Task` shape — closed operation and domain vocabularies plus a non-empty statement. */
+/** Describes the `Task` shape — closed operation and domain vocabularies plus a non-empty statement. */
 var taskShape = (0, _orkestrel_contract.objectShape)({
 	operation: (0, _orkestrel_contract.literalShape)(TASK_OPERATIONS),
 	domain: (0, _orkestrel_contract.literalShape)(TASK_DOMAINS),
 	statement: lineShape
 }, { description: "What the brief asks for, in one imperative sentence." });
-/** The `Reference` shape — a path and the note that justifies listing it. */
+/** Describes the `Reference` shape — a path and the note that justifies listing it. */
 var referenceShape = (0, _orkestrel_contract.objectShape)({
 	path: lineShape,
 	note: lineShape
 }, { description: "One referenced path and why it is listed." });
-/** The `Manifest` shape — four disjoint reference partitions. */
+/** Describes the `Manifest` shape — disjoint reference partitions. */
 var manifestShape = (0, _orkestrel_contract.objectShape)({
 	read: (0, _orkestrel_contract.arrayShape)(referenceShape),
 	edit: (0, _orkestrel_contract.arrayShape)(referenceShape),
 	locked: (0, _orkestrel_contract.arrayShape)(referenceShape),
 	forbidden: (0, _orkestrel_contract.arrayShape)(referenceShape)
-}, { description: "The four disjoint file partitions of a brief." });
-/** The `Outcome` shape — a one-based rank, the result text, and whether it gates done. */
+}, { description: "The disjoint file partitions of a brief." });
+/** Describes the `Outcome` shape — a one-based rank, the result text, and whether it gates done. */
 var outcomeShape = (0, _orkestrel_contract.objectShape)({
 	rank: (0, _orkestrel_contract.integerShape)({ min: 1 }),
 	text: lineShape,
 	required: (0, _orkestrel_contract.booleanShape)()
 }, { description: "One ranked outcome — a result, never a step." });
-/** The `Given` shape — one categorized context fact. */
+/** Describes the `Given` shape — one categorized context fact. */
 var givenShape = (0, _orkestrel_contract.objectShape)({
 	category: lineShape,
 	name: lineShape,
 	value: textShape
 }, { description: "One context fact handed to the executor." });
-/** The `Example` shape — one input to output exemplar. */
+/** Describes the `Example` shape — one input to output exemplar. */
 var exampleShape = (0, _orkestrel_contract.objectShape)({
 	input: (0, _orkestrel_contract.stringShape)({ min: 1 }),
 	output: (0, _orkestrel_contract.stringShape)({ min: 1 }),
 	note: (0, _orkestrel_contract.optionalShape)(lineShape)
 }, { description: "One input to output exemplar." });
-/** The `Citation` shape — a name, a locator, and why the source is cited. */
+/** Describes the `Citation` shape — a name, a locator, and why the source is cited. */
 var citationShape = (0, _orkestrel_contract.objectShape)({
 	name: lineShape,
 	url: lineShape,
 	note: lineShape
 }, { description: "One external source; list order is the trust order." });
-/** The `Gap` shape — an unknown, whether it blocks, and the candidates that would close it. */
+/** Describes the `Gap` shape — an unknown, whether it blocks, and the candidates that would close it. */
 var gapShape = (0, _orkestrel_contract.objectShape)({
 	field: lineShape,
 	question: lineShape,
 	blocking: (0, _orkestrel_contract.booleanShape)(),
 	candidates: (0, _orkestrel_contract.optionalShape)((0, _orkestrel_contract.arrayShape)(lineShape))
 }, { description: "One unresolved decision; blocking means the gate fails closed." });
-/** The `Risk` shape — a closed severity, the risk, and its mitigation. */
+/** Describes the `Risk` shape — a closed severity, the risk, and its mitigation. */
 var riskShape = (0, _orkestrel_contract.objectShape)({
 	severity: (0, _orkestrel_contract.literalShape)(RISK_SEVERITIES),
 	text: lineShape,
 	mitigation: lineShape
 }, { description: "One pre-empted risk and the mitigation that answers it." });
-/** The `Output` shape — a closed format plus its optional refinements. */
+/** Describes the `Output` shape — a closed format plus its optional refinements. */
 var outputShape = (0, _orkestrel_contract.objectShape)({
 	format: (0, _orkestrel_contract.literalShape)(OUTPUT_FORMATS),
 	sections: (0, _orkestrel_contract.optionalShape)((0, _orkestrel_contract.arrayShape)(lineShape)),
 	include: (0, _orkestrel_contract.optionalShape)((0, _orkestrel_contract.arrayShape)(lineShape)),
 	exclude: (0, _orkestrel_contract.optionalShape)((0, _orkestrel_contract.arrayShape)(lineShape))
 }, { description: "The closed shape of the deliverable." });
-/** The `Proof` shape — the claim and the command that settles it. */
+/** Describes the `Proof` shape — the claim and the command that settles it. */
 var proofShape = (0, _orkestrel_contract.objectShape)({
 	text: lineShape,
 	command: lineShape
 }, { description: "One mechanical, transcript-provable check." });
 /**
-* The whole `Brief` shape, section shapes composed.
+* Describes the whole `Brief` shape, section shapes composed.
 *
 * @remarks
 * `trace` and `hash` are optional because `pinBrief` fills them; an unpinned draft is
@@ -242,40 +271,82 @@ var briefShape = (0, _orkestrel_contract.objectShape)({
 //#endregion
 //#region src/core/validators.ts
 /**
-* `true` when the value is a string holding no line terminator, empty included.
+* Checks whether the value is a string holding no line terminator, empty included.
 *
 * @remarks
 * `briefToMarkdown` renders each brief field as ONE markdown row, so a field carrying a
 * line break would forge a heading or an extra manifest row — which is how a rendered
 * prompt and `briefToDispatch`'s path sets could disagree about the same brief.
+*
+* @param value - The value to inspect.
+* @returns True if `value` is a string holding no line terminator, empty included; false
+*   otherwise.
 */
 var isText = (value) => (0, _orkestrel_contract.isString)(value) && !LINE_BREAK_PATTERN.test(value);
-/** `true` when the value is a non-empty string holding no line terminator. */
+/**
+* Checks whether the value is a non-empty string holding no line terminator.
+*
+* @param value - The value to inspect.
+* @returns True if `value` is a non-empty string holding no line terminator; false otherwise.
+*/
 var isLine = (0, _orkestrel_contract.andOf)(_orkestrel_contract.isNonEmptyString, isText);
-/** `true` when the value is one of the twelve `TaskOperation` literals. */
+/**
+* Checks whether the value is one of the `TaskOperation` literals.
+*
+* @param value - The value to inspect.
+* @returns True if `value` is one of the `TaskOperation` literals; false otherwise.
+*/
 var isTaskOperation = (0, _orkestrel_contract.literalOf)(TASK_OPERATIONS);
-/** `true` when the value is one of the eight `TaskDomain` literals. */
+/**
+* Checks whether the value is one of the `TaskDomain` literals.
+*
+* @param value - The value to inspect.
+* @returns True if `value` is one of the `TaskDomain` literals; false otherwise.
+*/
 var isTaskDomain = (0, _orkestrel_contract.literalOf)(TASK_DOMAINS);
-/** `true` when the value is one of the five `OutputFormat` literals. */
+/**
+* Checks whether the value is one of the `OutputFormat` literals.
+*
+* @param value - The value to inspect.
+* @returns True if `value` is one of the `OutputFormat` literals; false otherwise.
+*/
 var isOutputFormat = (0, _orkestrel_contract.literalOf)(OUTPUT_FORMATS);
-/** `true` when the value is one of the three `RiskSeverity` literals. */
+/**
+* Checks whether the value is one of the `RiskSeverity` literals.
+*
+* @param value - The value to inspect.
+* @returns True if `value` is one of the `RiskSeverity` literals; false otherwise.
+*/
 var isRiskSeverity = (0, _orkestrel_contract.literalOf)(RISK_SEVERITIES);
-/** `true` when the value is a well-formed `Task` — both vocabularies closed, statement one line. */
+/**
+* Checks whether the value is a well-formed `Task` — both vocabularies closed, statement one line.
+*
+* @param value - The value to inspect.
+* @returns True if `value` is a well-formed `Task`; false otherwise.
+*/
 var isTask = (0, _orkestrel_contract.recordOf)({
 	operation: isTaskOperation,
 	domain: isTaskDomain,
 	statement: isLine
 });
-/** `true` when the value is a well-formed `Reference` — both members required, both single-line. */
+/**
+* Checks whether the value is a well-formed `Reference` — both members required, both single-line.
+*
+* @param value - The value to inspect.
+* @returns True if `value` is a well-formed `Reference`; false otherwise.
+*/
 var isReference = (0, _orkestrel_contract.recordOf)({
 	path: isLine,
 	note: isLine
 });
 /**
-* `true` when the value is a well-formed `Manifest`.
+* Checks whether the value is a well-formed `Manifest`.
 *
 * @remarks
 * Partition presence only — disjointness is `validateBrief`'s semantic pass.
+*
+* @param value - The value to inspect.
+* @returns True if `value` is a well-formed `Manifest`; false otherwise.
 */
 var isManifest = (0, _orkestrel_contract.recordOf)({
 	read: (0, _orkestrel_contract.arrayOf)(isReference),
@@ -283,50 +354,83 @@ var isManifest = (0, _orkestrel_contract.recordOf)({
 	locked: (0, _orkestrel_contract.arrayOf)(isReference),
 	forbidden: (0, _orkestrel_contract.arrayOf)(isReference)
 });
-/** `true` when the value is a well-formed `Outcome` — `rank` a positive integer. */
+/**
+* Checks whether the value is a well-formed `Outcome` — `rank` a positive integer.
+*
+* @param value - The value to inspect.
+* @returns True if `value` is a well-formed `Outcome`; false otherwise.
+*/
 var isOutcome = (0, _orkestrel_contract.recordOf)({
 	rank: (0, _orkestrel_contract.andOf)(_orkestrel_contract.isInteger, (0, _orkestrel_contract.boundsOf)(1)),
 	text: isLine,
 	required: _orkestrel_contract.isBoolean
 });
-/** `true` when the value is a well-formed `Given` — `value` may be empty but stays one line. */
+/**
+* Checks whether the value is a well-formed `Given` — its `value` may be empty but stays one line.
+*
+* @param value - The value to inspect.
+* @returns True if `value` is a well-formed `Given`; false otherwise.
+*/
 var isGiven = (0, _orkestrel_contract.recordOf)({
 	category: isLine,
 	name: isLine,
 	value: isText
 });
 /**
-* `true` when the value is a well-formed `Example`.
+* Checks whether the value is a well-formed `Example`.
 *
 * @remarks
 * An exemplar's two sides are the ONLY members a brief lets span lines, because they
 * carry code. `briefToMarkdown` fences them rather than rendering them as a row.
+*
+* @param value - The value to inspect.
+* @returns True if `value` is a well-formed `Example`; false otherwise.
 */
 var isExample = (0, _orkestrel_contract.recordOf)({
 	input: _orkestrel_contract.isNonEmptyString,
 	output: _orkestrel_contract.isNonEmptyString,
 	note: isLine
 }, ["note"]);
-/** `true` when the value is a well-formed `Citation` — all three members single-line. */
+/**
+* Checks whether the value is a well-formed `Citation` — every member single-line.
+*
+* @param value - The value to inspect.
+* @returns True if `value` is a well-formed `Citation`; false otherwise.
+*/
 var isCitation = (0, _orkestrel_contract.recordOf)({
 	name: isLine,
 	url: isLine,
 	note: isLine
 });
-/** `true` when the value is a well-formed `Gap`. */
+/**
+* Checks whether the value is a well-formed `Gap`.
+*
+* @param value - The value to inspect.
+* @returns True if `value` is a well-formed `Gap`; false otherwise.
+*/
 var isGap = (0, _orkestrel_contract.recordOf)({
 	field: isLine,
 	question: isLine,
 	blocking: _orkestrel_contract.isBoolean,
 	candidates: (0, _orkestrel_contract.arrayOf)(isLine)
 }, ["candidates"]);
-/** `true` when the value is a well-formed `Risk` — `severity` on the closed vocabulary. */
+/**
+* Checks whether the value is a well-formed `Risk` — `severity` on the closed vocabulary.
+*
+* @param value - The value to inspect.
+* @returns True if `value` is a well-formed `Risk`; false otherwise.
+*/
 var isRisk = (0, _orkestrel_contract.recordOf)({
 	severity: isRiskSeverity,
 	text: isLine,
 	mitigation: isLine
 });
-/** `true` when the value is a well-formed `Output` — `format` on the closed vocabulary. */
+/**
+* Checks whether the value is a well-formed `Output` — `format` on the closed vocabulary.
+*
+* @param value - The value to inspect.
+* @returns True if `value` is a well-formed `Output`; false otherwise.
+*/
 var isOutput = (0, _orkestrel_contract.recordOf)({
 	format: isOutputFormat,
 	sections: (0, _orkestrel_contract.arrayOf)(isLine),
@@ -337,17 +441,25 @@ var isOutput = (0, _orkestrel_contract.recordOf)({
 	"include",
 	"exclude"
 ]);
-/** `true` when the value is a well-formed `Proof`. */
+/**
+* Checks whether the value is a well-formed `Proof`.
+*
+* @param value - The value to inspect.
+* @returns True if `value` is a well-formed `Proof`; false otherwise.
+*/
 var isProof = (0, _orkestrel_contract.recordOf)({
 	text: isLine,
 	command: isLine
 });
 /**
-* `true` when the value satisfies the whole exact-record `Brief` contract.
+* Checks whether the value satisfies the whole exact-record `Brief` contract.
 *
 * @remarks
 * Every section must be present; an extra key fails. `trace` and `hash` are the only
 * optional members, because `pinBrief` rather than the author fills them.
+*
+* @param value - The value to inspect.
+* @returns True if `value` satisfies the whole exact-record `Brief` contract; false otherwise.
 */
 var isBrief = (0, _orkestrel_contract.recordOf)({
 	task: isTask,
@@ -448,7 +560,7 @@ function captureValue(source, members) {
 	return target;
 }
 /**
-* Return a deeply owned, deeply frozen copy of a brief, refusing anything off-contract.
+* Returns a deeply owned, deeply frozen copy of a brief, refusing anything off-contract.
 *
 * @remarks
 * The one reading boundary this package has, used by the pin, the registry, and every
@@ -472,10 +584,10 @@ function captureValue(source, members) {
 *
 * @example
 * ```ts
-* import { brief, outcome, snapshotBrief, task } from '@orkestrel/brief'
+* import { buildBrief, buildOutcome, buildTask, snapshotBrief } from '@orkestrel/brief'
 *
-* const outcomes = [outcome(1, 'shipped')]
-* const owned = snapshotBrief(brief(task('plan', 'ops', 'Plan the release.'), { outcomes }))
+* const outcomes = [buildOutcome(1, 'shipped')]
+* const owned = snapshotBrief(buildBrief(buildTask('plan', 'ops', 'Plan the release.'), { outcomes }))
 * owned.outcomes === outcomes // false — the alias is broken
 * Object.isFrozen(owned.outcomes) // true
 * ```
@@ -488,7 +600,7 @@ function snapshotBrief(source) {
 //#endregion
 //#region src/core/helpers.ts
 /**
-* Build a `Task`.
+* Assembles a `Task` from an operation, a domain, and a statement.
 *
 * @param operation - What the brief asks for, from the closed operation vocabulary.
 * @param domain - The subject matter, from the closed domain vocabulary.
@@ -497,12 +609,12 @@ function snapshotBrief(source) {
 *
 * @example
 * ```ts
-* import { task } from '@orkestrel/brief'
+* import { buildTask } from '@orkestrel/brief'
 *
-* task('refactor', 'code', 'Refactor useForm to native browser form APIs.')
+* buildTask('refactor', 'code', 'Refactor useForm to native browser form APIs.')
 * ```
 */
-function task(operation, domain, statement) {
+function buildTask(operation, domain, statement) {
 	return {
 		operation,
 		domain,
@@ -510,7 +622,7 @@ function task(operation, domain, statement) {
 	};
 }
 /**
-* Build a `Reference`.
+* Assembles a `Reference` from a path and the note that justifies listing it.
 *
 * @param path - The referenced path or glob.
 * @param note - Why the path is listed.
@@ -518,31 +630,31 @@ function task(operation, domain, statement) {
 *
 * @example
 * ```ts
-* import { reference } from '@orkestrel/brief'
+* import { buildReference } from '@orkestrel/brief'
 *
-* reference('AGENTS.md', 'project law') // { path: 'AGENTS.md', note: 'project law' }
+* buildReference('AGENTS.md', 'project law') // { path: 'AGENTS.md', note: 'project law' }
 * ```
 */
-function reference(path, note) {
+function buildReference(path, note) {
 	return {
 		path,
 		note
 	};
 }
 /**
-* Build a `Manifest`, defaulting every absent partition to an empty list.
+* Assembles a `Manifest`, defaulting every absent partition to an empty list.
 *
 * @param partitions - The partitions to fill; a partial literal is enough.
-* @returns A fresh `Manifest` with all four partitions present.
+* @returns A fresh `Manifest` with every partition present.
 *
 * @example
 * ```ts
-* import { manifest, reference } from '@orkestrel/brief'
+* import { buildManifest, buildReference } from '@orkestrel/brief'
 *
-* manifest({ edit: [reference('src/core/helpers.ts', 'implementation')] })
+* buildManifest({ edit: [buildReference('src/core/helpers.ts', 'implementation')] })
 * ```
 */
-function manifest(partitions) {
+function buildManifest(partitions) {
 	return {
 		read: partitions?.read ?? [],
 		edit: partitions?.edit ?? [],
@@ -551,22 +663,23 @@ function manifest(partitions) {
 	};
 }
 /**
-* Build an `Outcome`.
+* Assembles an `Outcome` from a rank and its result text.
 *
 * @param rank - The one-based rank; lower ranks matter more.
 * @param text - The result, never a step.
-* @param required - Whether the outcome gates "done"; defaults to `true`.
+* @param required - If `true`, the outcome gates "done"; if `false`, it is desirable but not
+*   blocking. Default: `true`.
 * @returns A fresh `Outcome`.
 *
 * @example
 * ```ts
-* import { outcome } from '@orkestrel/brief'
+* import { buildOutcome } from '@orkestrel/brief'
 *
-* outcome(1, 'useForm uses native FormData with no behavior change') // required: true
-* outcome(2, 'the diff stays under 200 lines', false)
+* buildOutcome(1, 'useForm uses native FormData with no behavior change') // required: true
+* buildOutcome(2, 'the diff stays under 200 lines', false)
 * ```
 */
-function outcome(rank, text, required = true) {
+function buildOutcome(rank, text, required = true) {
 	return {
 		rank,
 		text,
@@ -574,7 +687,7 @@ function outcome(rank, text, required = true) {
 	};
 }
 /**
-* Build a `Given`.
+* Assembles a `Given` from a category, a name, and a value.
 *
 * @param category - The kind of fact — a convention, a version, a constraint.
 * @param name - The fact's name.
@@ -583,12 +696,12 @@ function outcome(rank, text, required = true) {
 *
 * @example
 * ```ts
-* import { given } from '@orkestrel/brief'
+* import { buildGiven } from '@orkestrel/brief'
 *
-* given('convention', 'indentation', 'tabs')
+* buildGiven('convention', 'indentation', 'tabs')
 * ```
 */
-function given(category, name, value) {
+function buildGiven(category, name, value) {
 	return {
 		category,
 		name,
@@ -596,32 +709,32 @@ function given(category, name, value) {
 	};
 }
 /**
-* Build an `Example`.
+* Assembles an `Example` from an exemplar input and its expected output.
 *
 * @param input - The exemplar input.
-* @param result - The expected output for that input.
+* @param output - The expected output for that input.
 * @param note - Optional detail; the key is OMITTED when absent.
 * @returns A fresh `Example`.
 *
 * @example
 * ```ts
-* import { example } from '@orkestrel/brief'
+* import { buildExample } from '@orkestrel/brief'
 *
-* example('<input required>', 'validity read from el.validity')
+* buildExample('<input required>', 'validity read from el.validity')
 * ```
 */
-function example(input, result, note) {
+function buildExample(input, output, note) {
 	return note === void 0 ? {
 		input,
-		output: result
+		output
 	} : {
 		input,
-		output: result,
+		output,
 		note
 	};
 }
 /**
-* Build a `Citation`.
+* Assembles a `Citation` from a name, a URL, and the note that justifies citing it.
 *
 * @param name - The source's display name.
 * @param url - Where the source lives.
@@ -630,16 +743,16 @@ function example(input, result, note) {
 *
 * @example
 * ```ts
-* import { citation } from '@orkestrel/brief'
+* import { buildCitation } from '@orkestrel/brief'
 *
-* citation(
+* buildCitation(
 * 	'MDN Constraint Validation',
 * 	'https://developer.mozilla.org/',
 * 	'the native validity behavior being adopted',
 * )
 * ```
 */
-function citation(name, url, note) {
+function buildCitation(name, url, note) {
 	return {
 		name,
 		url,
@@ -647,23 +760,23 @@ function citation(name, url, note) {
 	};
 }
 /**
-* Build a `Gap`.
+* Assembles a `Gap` from the section it belongs to and the question that would close it.
 *
 * @param field - The brief section the unknown belongs to.
 * @param question - The question that would close it.
-* @param overrides - Optional `blocking` (defaults `false`) and `candidates`; an absent
-*   `candidates` key is OMITTED entirely.
+* @param overrides - Optional `blocking` and `candidates`; an absent `candidates` key is
+*   OMITTED entirely. Default: `blocking: false`.
 * @returns A fresh `Gap`.
 *
 * @example
 * ```ts
-* import { gap } from '@orkestrel/brief'
+* import { buildGap } from '@orkestrel/brief'
 *
-* gap('rules', 'Should validation message wording change?') // blocking: false
-* gap('output', 'Diff or full files?', { blocking: true, candidates: ['diff', 'code'] })
+* buildGap('rules', 'Does validation message wording need to change?') // blocking: false
+* buildGap('output', 'Diff or full files?', { blocking: true, candidates: ['diff', 'code'] })
 * ```
 */
-function gap(field, question, overrides) {
+function buildGap(field, question, overrides) {
 	const blocking = overrides?.blocking ?? false;
 	return overrides?.candidates === void 0 ? {
 		field,
@@ -677,7 +790,7 @@ function gap(field, question, overrides) {
 	};
 }
 /**
-* Build a `Risk`.
+* Assembles a `Risk` from a severity, what could go wrong, and the mitigation that answers it.
 *
 * @param severity - The closed severity.
 * @param text - What could go wrong.
@@ -686,12 +799,12 @@ function gap(field, question, overrides) {
 *
 * @example
 * ```ts
-* import { risk } from '@orkestrel/brief'
+* import { buildRisk } from '@orkestrel/brief'
 *
-* risk('medium', 'native validation differs subtly', 'assert message and state in tests')
+* buildRisk('medium', 'native validation differs subtly', 'assert message and state in tests')
 * ```
 */
-function risk(severity, text, mitigation) {
+function buildRisk(severity, text, mitigation) {
 	return {
 		severity,
 		text,
@@ -699,7 +812,7 @@ function risk(severity, text, mitigation) {
 	};
 }
 /**
-* Build an `Output`.
+* Assembles an `Output` from a format plus its optional refinements.
 *
 * @param format - The closed deliverable format.
 * @param overrides - Optional `sections` / `include` / `exclude`; absent keys are OMITTED.
@@ -707,13 +820,13 @@ function risk(severity, text, mitigation) {
 *
 * @example
 * ```ts
-* import { output } from '@orkestrel/brief'
+* import { buildOutput } from '@orkestrel/brief'
 *
-* output('markdown') // { format: 'markdown' }
-* output('diff', { include: ['updated useForm.ts'] })
+* buildOutput('markdown') // { format: 'markdown' }
+* buildOutput('diff', { include: ['updated useForm.ts'] })
 * ```
 */
-function output(format, overrides) {
+function buildOutput(format, overrides) {
 	return {
 		format,
 		...overrides?.sections === void 0 ? {} : { sections: overrides.sections },
@@ -722,7 +835,7 @@ function output(format, overrides) {
 	};
 }
 /**
-* Build a `Proof`.
+* Assembles a `Proof` from what the check settles and the command that settles it.
 *
 * @param text - What the check settles.
 * @param command - The command whose exit signal settles it.
@@ -730,41 +843,41 @@ function output(format, overrides) {
 *
 * @example
 * ```ts
-* import { proof } from '@orkestrel/brief'
+* import { buildProof } from '@orkestrel/brief'
 *
-* proof('type-check and lint pass', 'npm run check')
+* buildProof('type-check and lint pass', 'npm run check')
 * ```
 */
-function proof(text, command) {
+function buildProof(text, command) {
 	return {
 		text,
 		command
 	};
 }
 /**
-* Build a `Brief` from a `Task` plus section overrides.
+* Assembles a `Brief` from a `Task` plus section overrides.
 *
 * @param subject - The task the brief is about.
-* @param overrides - Any sections to fill; every absent collection defaults to `[]`,
-*   `output` defaults to `output('markdown')`, and `trace` / `hash` stay OMITTED so
-*   `pinBrief` can fill them.
+* @param overrides - Any sections to fill; `trace` / `hash` stay OMITTED so `pinBrief` can
+*   fill them. Default: `[]` for every absent collection and `buildOutput('markdown')` for
+*   `output`.
 * @returns A fresh, unpinned `Brief`.
 *
 * @example
 * ```ts
-* import { brief, outcome, proof, task } from '@orkestrel/brief'
+* import { buildBrief, buildOutcome, buildProof, buildTask } from '@orkestrel/brief'
 *
-* brief(task('audit', 'code', 'Audit the barrel for undocumented exports.'), {
-* 	outcomes: [outcome(1, 'every export appears in the guide')],
-* 	proofs: [proof('parity passes', 'npm run test:guides')],
+* buildBrief(buildTask('audit', 'code', 'Audit the barrel for undocumented exports.'), {
+* 	outcomes: [buildOutcome(1, 'every export appears in the guide')],
+* 	proofs: [buildProof('parity passes', 'npm run test:guides')],
 * })
 * ```
 */
-function brief(subject, overrides) {
+function buildBrief(subject, overrides) {
 	return {
 		task: subject,
 		authority: overrides?.authority ?? [],
-		manifest: overrides?.manifest ?? manifest(),
+		manifest: overrides?.manifest ?? buildManifest(),
 		outcomes: overrides?.outcomes ?? [],
 		rules: overrides?.rules ?? [],
 		invariants: overrides?.invariants ?? [],
@@ -774,17 +887,17 @@ function brief(subject, overrides) {
 		citations: overrides?.citations ?? [],
 		gaps: overrides?.gaps ?? [],
 		risks: overrides?.risks ?? [],
-		output: overrides?.output ?? output("markdown"),
+		output: overrides?.output ?? buildOutput("markdown"),
 		proofs: overrides?.proofs ?? []
 	};
 }
 /**
-* Build the fail-closed readiness gate as a reasons `LogicalDefinition`.
+* Assembles the fail-closed readiness gate as a reasons `LogicalDefinition`.
 *
 * @remarks
-* Six readiness rules each derive one named fact from `briefToSubject`'s measures, and a
-* final `ready` rule conjoins all six. Forward chaining reports the LAST rule's
-* conclusion, so `LogicalResult.conclusion` is exactly `ready`.
+* Each readiness rule derives one named fact from `briefToSubject`'s measures, and a final
+* `ready` rule conjoins them all. Forward chaining reports the LAST rule's conclusion, so
+* `LogicalResult.conclusion` is exactly `ready`.
 *
 * The gate takes NO parameters, and that is deliberate rather than unfinished. The
 * reasoner overlays every derived fact into one flat namespace, so a caller rule named
@@ -798,50 +911,50 @@ function brief(subject, overrides) {
 *
 * @example
 * ```ts
-* import { briefToSubject, gateDefinition } from '@orkestrel/brief'
+* import { briefToSubject, buildGateDefinition } from '@orkestrel/brief'
 * import { createLogicalReasoner, createReason } from '@orkestrel/reason'
 *
 * const reason = createReason({ reasoners: [createLogicalReasoner()] })
-* const verdict = reason.reason(briefToSubject(pinned), gateDefinition())
+* const verdict = reason.reason(briefToSubject(pinned), buildGateDefinition())
 * reason.destroy()
 * ```
 */
-function gateDefinition() {
+function buildGateDefinition() {
 	const readiness = [
-		(0, _orkestrel_reason.rule)("specified", [(0, _orkestrel_reason.atom)("blocking", "equals", 0)], (0, _orkestrel_reason.atom)("specified", "equals", true)),
-		(0, _orkestrel_reason.rule)("aimed", [(0, _orkestrel_reason.compound)("and", [(0, _orkestrel_reason.atom)("outcomes", "above", 0), (0, _orkestrel_reason.atom)("required", "above", 0)])], (0, _orkestrel_reason.atom)("aimed", "equals", true)),
-		(0, _orkestrel_reason.rule)("proven", [(0, _orkestrel_reason.atom)("proofs", "above", 0)], (0, _orkestrel_reason.atom)("proven", "equals", true)),
-		(0, _orkestrel_reason.rule)("disjoint", [(0, _orkestrel_reason.atom)("overlaps", "equals", 0)], (0, _orkestrel_reason.atom)("disjoint", "equals", true)),
-		(0, _orkestrel_reason.rule)("granted", [(0, _orkestrel_reason.atom)("ungranted", "equals", 0)], (0, _orkestrel_reason.atom)("granted", "equals", true)),
-		(0, _orkestrel_reason.rule)("single", [(0, _orkestrel_reason.atom)("sentences", "equals", 1)], (0, _orkestrel_reason.atom)("single", "equals", true))
+		(0, _orkestrel_reason.createRule)("specified", [(0, _orkestrel_reason.createAtom)("blocking", "equals", 0)], (0, _orkestrel_reason.createAtom)("specified", "equals", true)),
+		(0, _orkestrel_reason.createRule)("aimed", [(0, _orkestrel_reason.createCompound)("and", [(0, _orkestrel_reason.createAtom)("outcomes", "above", 0), (0, _orkestrel_reason.createAtom)("required", "above", 0)])], (0, _orkestrel_reason.createAtom)("aimed", "equals", true)),
+		(0, _orkestrel_reason.createRule)("proven", [(0, _orkestrel_reason.createAtom)("proofs", "above", 0)], (0, _orkestrel_reason.createAtom)("proven", "equals", true)),
+		(0, _orkestrel_reason.createRule)("disjoint", [(0, _orkestrel_reason.createAtom)("overlaps", "equals", 0)], (0, _orkestrel_reason.createAtom)("disjoint", "equals", true)),
+		(0, _orkestrel_reason.createRule)("granted", [(0, _orkestrel_reason.createAtom)("ungranted", "equals", 0)], (0, _orkestrel_reason.createAtom)("granted", "equals", true)),
+		(0, _orkestrel_reason.createRule)("single", [(0, _orkestrel_reason.createAtom)("sentences", "equals", 1)], (0, _orkestrel_reason.createAtom)("single", "equals", true))
 	];
-	return (0, _orkestrel_reason.logicalDefinition)(GATE_ID, "Brief readiness", [...readiness, (0, _orkestrel_reason.rule)("ready", [(0, _orkestrel_reason.compound)("and", readiness.map((entry) => (0, _orkestrel_reason.atom)(entry.id, "equals", true)))], (0, _orkestrel_reason.atom)("ready", "equals", true))]);
+	return (0, _orkestrel_reason.createLogicalDefinition)(GATE_ID, "Brief readiness", [...readiness, (0, _orkestrel_reason.createRule)("ready", [(0, _orkestrel_reason.createCompound)("and", readiness.map((entry) => (0, _orkestrel_reason.createAtom)(entry.id, "equals", true)))], (0, _orkestrel_reason.createAtom)("ready", "equals", true))]);
 }
 /**
-* The readiness rules a brief fails, computed directly from its own measures.
+* Lists the readiness rules a brief fails, computed directly from its own measures.
 *
 * @remarks
-* The gate's decision, in code. `gateDefinition()` states the same six rules as data for a
+* The gate's decision, in code. `buildGateDefinition()` states the same rules as data for a
 * reasoner to narrate, and a narration is not a decision: `BriefCompilerOptions.reason` lets a
 * caller supply the engine, and an engine that answers "met" to everything would otherwise
 * emit a brief with no proofs. `compile` refuses on THIS and keeps the verdict for its
 * trace, so a supplied engine can add detail and never remove a refusal.
 *
-* The two must agree. `tests/src/core/helpers.test.ts` drives both over one value set, which
-* is what stops the data and the code from drifting apart.
+* The data and the code must agree. `tests/src/core/helpers.test.ts` drives both over one
+* value set, which is what stops them from drifting apart.
 *
 * @param source - The brief to measure.
 * @returns The unmet rule ids, in gate order; empty when the brief is ready.
 *
 * @example
 * ```ts
-* import { brief, findUnmetRules, outcome, proof, task } from '@orkestrel/brief'
+* import { buildBrief, buildOutcome, buildProof, buildTask, findUnmetRules } from '@orkestrel/brief'
 *
-* findUnmetRules(brief(task('plan', 'ops', 'Plan the release.'))) // ['aimed', 'proven']
+* findUnmetRules(buildBrief(buildTask('plan', 'ops', 'Plan the release.'))) // ['aimed', 'proven']
 * findUnmetRules(
-* 	brief(task('plan', 'ops', 'Plan the release.'), {
-* 		outcomes: [outcome(1, 'shipped')],
-* 		proofs: [proof('x', 'npm test')],
+* 	buildBrief(buildTask('plan', 'ops', 'Plan the release.'), {
+* 		outcomes: [buildOutcome(1, 'shipped')],
+* 		proofs: [buildProof('x', 'npm test')],
 * 	}),
 * ) // []
 * ```
@@ -857,7 +970,7 @@ function findUnmetRules(source) {
 	return unready;
 }
 /**
-* Count the sentences a statement holds.
+* Counts the sentences a statement holds.
 *
 * @remarks
 * A terminator run (`.`, `!`, `?`) followed by whitespace or the end of the text closes one
@@ -895,17 +1008,17 @@ function countSentences(statement) {
 	return /[.!?]$/u.test(text) ? matches.length : matches.length + 1;
 }
 /**
-* The gaps that block emission.
+* Lists the gaps that block emission.
 *
 * @param source - The brief to inspect.
 * @returns Every gap carrying `blocking: true`, in declaration order.
 *
 * @example
 * ```ts
-* import { brief, findBlockingGaps, gap, task } from '@orkestrel/brief'
+* import { buildBrief, buildGap, buildTask, findBlockingGaps } from '@orkestrel/brief'
 *
-* const draft = brief(task('plan', 'ops', 'Plan the release.'), {
-* 	gaps: [gap('output', 'Diff or files?', { blocking: true })],
+* const draft = buildBrief(buildTask('plan', 'ops', 'Plan the release.'), {
+* 	gaps: [buildGap('output', 'Diff or files?', { blocking: true })],
 * })
 * findBlockingGaps(draft).length // 1
 * ```
@@ -914,18 +1027,18 @@ function findBlockingGaps(source) {
 	return source.gaps.filter((entry) => entry.blocking);
 }
 /**
-* The authority paths the manifest never grants access to.
+* Lists the authority paths the manifest never grants access to.
 *
 * @remarks
 * An authority the executor cannot open is an instruction it cannot follow, so every ranked
-* path must appear in `read`, `edit`, or `locked`. Those three are the grants: `locked` is a
+* path must appear in `read`, `edit`, or `locked`. Those are the grants: `locked` is a
 * grant, because read-only is exactly what obeying a file requires.
 *
-* This subsumes the narrower question of an authority sitting in `forbidden`. The four
-* partitions are disjoint — `findManifestOverlaps` and the `disjoint` rule enforce it — so a
-* forbidden path is in none of the three grants and is reported here. An authority named in
-* NO partition at all is reported for the same reason, and that is the case a forbidden-only
-* check misses entirely: the brief simply never says the executor may open what it must obey.
+* This subsumes the narrower question of an authority sitting in `forbidden`. The partitions
+* are disjoint — `findManifestOverlaps` and the `disjoint` rule enforce it — so a forbidden
+* path is in none of the grants and is reported here. An authority named in NO partition at
+* all is reported for the same reason, and that is the case a forbidden-only check misses
+* entirely: the brief simply never says the executor may open what it must obey.
 *
 * Paths are compared as EXACT strings, matching `findManifestOverlaps`. A glob is never
 * expanded, so `read: 'guides/**'` does not grant `authority: 'guides/brief.md'`. State a
@@ -936,11 +1049,17 @@ function findBlockingGaps(source) {
 *
 * @example
 * ```ts
-* import { brief, findUngrantedAuthority, manifest, reference, task } from '@orkestrel/brief'
-*
-* const draft = brief(task('debug', 'code', 'Fix the leak.'), {
-* 	authority: [reference('AGENTS.md', 'project law')],
-* 	manifest: manifest(),
+* import {
+* 	buildBrief,
+* 	buildManifest,
+* 	buildReference,
+* 	buildTask,
+* 	findUngrantedAuthority,
+* } from '@orkestrel/brief'
+*
+* const draft = buildBrief(buildTask('debug', 'code', 'Fix the leak.'), {
+* 	authority: [buildReference('AGENTS.md', 'project law')],
+* 	manifest: buildManifest(),
 * })
 * findUngrantedAuthority(draft) // ['AGENTS.md'] — ranked, but no partition opens it
 * ```
@@ -956,10 +1075,10 @@ function findUngrantedAuthority(source) {
 	return ungranted;
 }
 /**
-* The paths appearing in more than one manifest partition.
+* Lists the paths appearing in more than one manifest partition.
 *
 * @remarks
-* Duplicates WITHIN one partition are not an overlap; the four partitions must be
+* Duplicates WITHIN one partition are not an overlap; the partitions must be
 * mutually disjoint, which is what `validateBrief` errors on.
 *
 * Paths are compared as EXACT strings. A glob is never expanded, so `edit: 'app/file.ts'`
@@ -971,12 +1090,18 @@ function findUngrantedAuthority(source) {
 *
 * @example
 * ```ts
-* import { brief, findManifestOverlaps, manifest, reference, task } from '@orkestrel/brief'
-*
-* const draft = brief(task('debug', 'code', 'Fix the leak.'), {
-* 	manifest: manifest({
-* 		edit: [reference('src/core/BriefCompiler.ts', 'the leaking pipeline')],
-* 		locked: [reference('src/core/BriefCompiler.ts', 'the published contract')],
+* import {
+* 	buildBrief,
+* 	buildManifest,
+* 	buildReference,
+* 	buildTask,
+* 	findManifestOverlaps,
+* } from '@orkestrel/brief'
+*
+* const draft = buildBrief(buildTask('debug', 'code', 'Fix the leak.'), {
+* 	manifest: buildManifest({
+* 		edit: [buildReference('src/core/BriefCompiler.ts', 'the leaking pipeline')],
+* 		locked: [buildReference('src/core/BriefCompiler.ts', 'the published contract')],
 * 	}),
 * })
 * findManifestOverlaps(draft) // ['src/core/BriefCompiler.ts']
@@ -996,7 +1121,7 @@ function findManifestOverlaps(source) {
 	return overlaps;
 }
 /**
-* The open gaps with no assumption to stand on.
+* Lists the open gaps with no assumption to stand on.
 *
 * @remarks
 * The discipline is exactly one recorded assumption per open gap, so the open gaps past
@@ -1008,10 +1133,10 @@ function findManifestOverlaps(source) {
 *
 * @example
 * ```ts
-* import { brief, findUnpairedGaps, gap, task } from '@orkestrel/brief'
+* import { buildBrief, buildGap, buildTask, findUnpairedGaps } from '@orkestrel/brief'
 *
-* const draft = brief(task('plan', 'ops', 'Plan the release.'), {
-* 	gaps: [gap('rules', 'Keep the wording?'), gap('output', 'Diff or files?')],
+* const draft = buildBrief(buildTask('plan', 'ops', 'Plan the release.'), {
+* 	gaps: [buildGap('rules', 'Keep the wording?'), buildGap('output', 'Diff or files?')],
 * 	assumptions: ['Wording is preserved.'],
 * })
 * findUnpairedGaps(draft).length // 1
@@ -1021,16 +1146,16 @@ function findUnpairedGaps(source) {
 	return source.gaps.filter((entry) => !entry.blocking).slice(source.assumptions.length);
 }
 /**
-* Project a brief into the reasons `Subject` of readiness measures the gate reads.
+* Projects a brief into the reasons `Subject` of readiness measures the gate reads.
 *
 * @param source - The brief to measure.
-* @returns A flat record of counts plus the task's two vocabulary values.
+* @returns A flat record of counts plus the task's vocabulary values.
 *
 * @example
 * ```ts
-* import { brief, briefToSubject, proof, task } from '@orkestrel/brief'
+* import { briefToSubject, buildBrief, buildProof, buildTask } from '@orkestrel/brief'
 *
-* briefToSubject(brief(task('test', 'code', 'Cover the gate.'), { proofs: [proof('x', 'y')] }))
+* briefToSubject(buildBrief(buildTask('test', 'code', 'Cover the gate.'), { proofs: [buildProof('x', 'y')] }))
 * // { operation: 'test', domain: 'code', sentences: 1, proofs: 1, … }
 * ```
 */
@@ -1057,7 +1182,7 @@ function briefToSubject(source) {
 	};
 }
 /**
-* The semantic pass over an already-shape-valid brief.
+* Runs the semantic pass over an already-shape-valid brief.
 *
 * @remarks
 * ERRORS are the structural violations no assumption can paper over: a manifest
@@ -1071,11 +1196,11 @@ function briefToSubject(source) {
 *
 * @example
 * ```ts
-* import { brief, proof, task, validateBrief } from '@orkestrel/brief'
+* import { buildBrief, buildProof, buildTask, validateBrief } from '@orkestrel/brief'
 *
-* validateBrief(brief(task('plan', 'ops', 'Plan the release.'))) // valid: false — no proofs
+* validateBrief(buildBrief(buildTask('plan', 'ops', 'Plan the release.'))) // valid: false — no proofs
 * validateBrief(
-* 	brief(task('plan', 'ops', 'Plan the release.'), { proofs: [proof('ok', 'npm test')] }),
+* 	buildBrief(buildTask('plan', 'ops', 'Plan the release.'), { proofs: [buildProof('ok', 'npm test')] }),
 * ) // valid: true
 * ```
 */
@@ -1103,7 +1228,7 @@ function validateBrief(source) {
 	};
 }
 /**
-* The canonical structural digest of a brief's content.
+* Computes the canonical structural digest of a brief's content.
 *
 * @remarks
 * `trace` and `hash` are stripped before digesting, so the value is the identity of what
@@ -1115,9 +1240,9 @@ function validateBrief(source) {
 *
 * @example
 * ```ts
-* import { brief, briefToHash, pinBrief, task } from '@orkestrel/brief'
+* import { briefToHash, buildBrief, buildTask, pinBrief } from '@orkestrel/brief'
 *
-* const draft = brief(task('plan', 'ops', 'Plan the release.'))
+* const draft = buildBrief(buildTask('plan', 'ops', 'Plan the release.'))
 * briefToHash(draft) === briefToHash(pinBrief(draft)) // true — pinning does not move it
 * ```
 */
@@ -1125,7 +1250,7 @@ function briefToHash(source) {
 	return (0, _orkestrel_interpret.digestValue)(briefToContent(source));
 }
 /**
-* The canonical text of exactly what a brief's hash describes.
+* Renders the canonical text of exactly what a brief's hash describes.
 *
 * @remarks
 * `trace` and `hash` are stripped, then interprets `canonicalize` renders the rest in a
@@ -1137,9 +1262,9 @@ function briefToHash(source) {
 *
 * @example
 * ```ts
-* import { brief, briefToContent, pinBrief, task } from '@orkestrel/brief'
+* import { briefToContent, buildBrief, buildTask, pinBrief } from '@orkestrel/brief'
 *
-* const draft = brief(task('plan', 'ops', 'Plan the release.'))
+* const draft = buildBrief(buildTask('plan', 'ops', 'Plan the release.'))
 * briefToContent(draft) === briefToContent(pinBrief(draft)) // true — pinning adds no content
 * ```
 */
@@ -1148,7 +1273,7 @@ function briefToContent(source) {
 	return (0, _orkestrel_interpret.canonicalize)(content);
 }
 /**
-* Freeze a value and everything reachable from it.
+* Freezes a value and everything reachable from it.
 *
 * @remarks
 * `Object.freeze` is SHALLOW, so freezing a record leaves every nested array and object
@@ -1162,7 +1287,7 @@ function briefToContent(source) {
 * Reaches PLAIN objects and arrays, which is the whole of a `Brief` — it is JSON-serializable
 * by contract. A `Map`, `Set`, or typed array is frozen as an object and its CONTENTS are left
 * writable, and `Object.isFrozen` reports `true` for it either way. Nothing this package
-* produces contains one; a caller freezing their own value should know the limit.
+* produces contains one; the limit lands on a caller freezing their own value.
 *
 * @param value - The value to freeze in place; returned for convenience.
 * @returns The same value, now deeply frozen.
@@ -1179,7 +1304,7 @@ function freezeDeep(value) {
 	return freezeBranch(value, /* @__PURE__ */ new WeakSet());
 }
 /**
-* Freeze one branch of a value graph, skipping what the visited set already holds.
+* Freezes one branch of a value graph, skipping what the visited set already holds.
 *
 * @param value - The branch to freeze.
 * @param seen - The objects already frozen on this walk; what makes a cycle terminate.
@@ -1201,7 +1326,7 @@ function freezeBranch(value, seen) {
 	return value;
 }
 /**
-* Render a value thrown by a stage into a message.
+* Renders a value thrown by a stage into a message.
 *
 * @remarks
 * TOTAL: it never throws, for any input. That is load-bearing rather than tidy, because this
@@ -1210,7 +1335,7 @@ function freezeBranch(value, seen) {
 * falsifies the package's central promise that a failing stage yields an incomplete
 * `Briefing` rather than an exception.
 *
-* Three real inputs used to throw: an `Error` subclass whose `message` getter throws, a value
+* Real inputs used to throw: an `Error` subclass whose `message` getter throws, a value
 * whose string conversion throws, and a null-prototype object, which has no inherited
 * conversion for String() to reach. Each is wrapped, and an unreadable value degrades to its
 * type rather than propagating.
@@ -1234,10 +1359,10 @@ function errorToMessage(error) {
 	return `an unreadable ${typeof error} was thrown`;
 }
 /**
-* Narrow unknown data to a `Brief`, throwing when it is off-contract.
+* Narrows unknown data to a `Brief`, throwing when it is off-contract.
 *
 * @remarks
-* The throwing half of the intake pair: this returns its argument by IDENTITY once the
+* The throwing half of the intake pair: this returns its argument by IDENTITY after the
 * guard passes, while `parseBrief` returns `undefined` for bad input. It constructs
 * nothing, so it is an assertion rather than a factory. Reserve it for programmer-error
 * contexts where invalidity is a bug.
@@ -1251,24 +1376,24 @@ function errorToMessage(error) {
 * `briefToTrace` read the value they are handed instead, so a caller reaching one of those
 * directly owns that reading. Pass `assertBrief` a value you already own.
 *
-* @param data - The candidate brief data.
+* @param value - The candidate brief value.
 * @returns The same value, now known to satisfy {@link Brief}.
-* @throws {@link BriefError} `INVALID` when `data` fails `isBrief`.
+* @throws {@link BriefError} `INVALID` when `value` fails `isBrief`.
 *
 * @example
 * ```ts
-* import { assertBrief, brief, proof, task } from '@orkestrel/brief'
+* import { assertBrief, buildBrief, buildProof, buildTask } from '@orkestrel/brief'
 *
-* assertBrief(brief(task('plan', 'ops', 'Plan the release.'), { proofs: [proof('x', 'y')] }))
+* assertBrief(buildBrief(buildTask('plan', 'ops', 'Plan the release.'), { proofs: [buildProof('x', 'y')] }))
 * assertBrief({ task: { operation: 'plan', domain: 'ops', statement: 'x.' } }) // throws INVALID
 * ```
 */
-function assertBrief(data) {
-	if (!isBrief(data)) throw new BriefError("INVALID", "Brief failed the exact-record contract", { field: "brief" });
-	return data;
+function assertBrief(value) {
+	if (!isBrief(value)) throw new BriefError("INVALID", "Brief failed the exact-record contract", { field: "brief" });
+	return value;
 }
 /**
-* Return a fresh brief with `trace` and `hash` derived from its own content.
+* Returns a fresh brief with `trace` and `hash` derived from its own content.
 *
 * @remarks
 * Deterministic: no clock, no randomness, no run-specific data. Any existing `trace` /
@@ -1284,9 +1409,9 @@ function assertBrief(data) {
 *
 * @example
 * ```ts
-* import { brief, pinBrief, task } from '@orkestrel/brief'
+* import { buildBrief, buildTask, pinBrief } from '@orkestrel/brief'
 *
-* const pinned = pinBrief(brief(task('document', 'writing', 'Write the brief guide.')))
+* const pinned = pinBrief(buildBrief(buildTask('document', 'writing', 'Write the brief guide.')))
 * pinned.hash // an 8-hex-digit structural digest
 * pinned.trace // 'document/writing · outcomes:0 · gaps:0/0 · proofs:0'
 * ```
@@ -1301,7 +1426,7 @@ function pinBrief(source) {
 	});
 }
 /**
-* The one-line census `pinBrief` stamps onto a brief.
+* Renders the one-line census `pinBrief` stamps onto a brief.
 *
 * @remarks
 * Extracted so it has ONE implementation. `pinBrief` derives it and `BriefManager` re-derives
@@ -1314,9 +1439,9 @@ function pinBrief(source) {
 *
 * @example
 * ```ts
-* import { brief, briefToTrace, task } from '@orkestrel/brief'
+* import { briefToTrace, buildBrief, buildTask } from '@orkestrel/brief'
 *
-* briefToTrace(brief(task('document', 'writing', 'Write the guide.')))
+* briefToTrace(buildBrief(buildTask('document', 'writing', 'Write the guide.')))
 * // 'document/writing · outcomes:0 · gaps:0/0 · proofs:0'
 * ```
 */
@@ -1329,7 +1454,7 @@ function briefToTrace(source) {
 	].join(" · ");
 }
 /**
-* Render one exemplar as markdown lines.
+* Renders one exemplar as markdown lines.
 *
 * @remarks
 * An `Example`'s two sides are the only brief members permitted to span lines, so a
@@ -1341,9 +1466,9 @@ function briefToTrace(source) {
 *
 * @example
 * ```ts
-* import { example, exampleToLines } from '@orkestrel/brief'
+* import { buildExample, exampleToLines } from '@orkestrel/brief'
 *
-* exampleToLines(example('<input required>', 'el.validity')) // ['- ` <input required> ` → ` el.validity `']
+* exampleToLines(buildExample('<input required>', 'el.validity')) // ['- ` <input required> ` → ` el.validity `']
 * ```
 */
 function exampleToLines(entry) {
@@ -1374,20 +1499,20 @@ function exampleToLines(entry) {
 	];
 }
 /**
-* Project a brief into the copy-ready agent prompt.
+* Projects a brief into the copy-ready agent prompt.
 *
 * @remarks
 * Paths are REFERENCED, never inlined — the executor retrieves them. An empty section is
 * omitted entirely, so the rendering carries no filler an executor must read past.
 *
-* @param source - The brief to render.
+* @param input - The brief to render.
 * @returns The markdown prompt.
 *
 * @example
 * ```ts
-* import { brief, briefToMarkdown, task } from '@orkestrel/brief'
+* import { briefToMarkdown, buildBrief, buildTask } from '@orkestrel/brief'
 *
-* briefToMarkdown(brief(task('review', 'code', 'Review the gate rules.')))
+* briefToMarkdown(buildBrief(buildTask('review', 'code', 'Review the gate rules.')))
 * // '# Brief: Review the gate rules.\n\nreview · code\n\n## Output\n\n- format: markdown\n'
 * ```
 */
@@ -1481,21 +1606,21 @@ function briefToMarkdown(input) {
 	return lines.join("\n");
 }
 /**
-* Project a brief into a `/goal` completion condition.
+* Projects a brief into a `/goal` completion condition.
 *
 * @remarks
 * The proofs' commands VERBATIM plus a turn cap — the goal never adds a condition the
 * brief does not carry.
 *
-* @param source - The brief to render.
-* @param turns - The turn cap; defaults to `DEFAULT_BRIEF_TURNS`.
+* @param input - The brief to render.
+* @param turns - The turn cap. Default: `DEFAULT_BRIEF_TURNS`.
 * @returns The one-line completion condition.
 *
 * @example
 * ```ts
-* import { brief, briefToGoal, proof, task } from '@orkestrel/brief'
+* import { briefToGoal, buildBrief, buildProof, buildTask } from '@orkestrel/brief'
 *
-* briefToGoal(brief(task('test', 'code', 'Cover the gate.'), { proofs: [proof('x', 'npm test')] }))
+* briefToGoal(buildBrief(buildTask('test', 'code', 'Cover the gate.'), { proofs: [buildProof('x', 'npm test')] }))
 * // 'Done when every proof passes: npm test exits 0. Cap: 16 turns.'
 * ```
 */
@@ -1504,27 +1629,33 @@ function briefToGoal(input, turns = 16) {
 	return `Done when every proof passes: ${source.proofs.length === 0 ? "no proofs recorded" : source.proofs.map((entry) => `${entry.command} exits 0`).join("; ")}. Cap: ${String(turns)} turns.`;
 }
 /**
-* Project a brief into a subagent `Dispatch`.
+* Projects a brief into a subagent `Dispatch`.
 *
 * @remarks
 * `edit` is exactly `manifest.edit`, so two dispatches whose `edit` sets do not intersect
 * can run concurrently under the same brief without conflict.
 *
 * `authority` is exactly `brief.authority` in rank order, and it is a SEPARATE axis from the
-* four permission sets rather than a fifth partition — a ranked path normally also appears in
+* permission sets rather than a further partition — a ranked path normally also appears in
 * `read` or `locked`, because the executor has to open what it obeys. It is projected as
 * paths so a machine consumer never has to parse `prompt`, which is written for a model.
 *
-* @param source - The brief to project.
-* @returns The dispatch — the rendered prompt, the ranked authority, and the four path sets.
+* @param input - The brief to project.
+* @returns The dispatch — the rendered prompt, the ranked authority, and the path sets.
 *
 * @example
 * ```ts
-* import { brief, briefToDispatch, manifest, reference, task } from '@orkestrel/brief'
-*
-* const draft = brief(task('migrate', 'code', 'Migrate the stores.'), {
-* 	authority: [reference('AGENTS.md', 'project law')],
-* 	manifest: manifest({ edit: [reference('src/core/stores/**', 'the legacy stores')] }),
+* import {
+* 	briefToDispatch,
+* 	buildBrief,
+* 	buildManifest,
+* 	buildReference,
+* 	buildTask,
+* } from '@orkestrel/brief'
+*
+* const draft = buildBrief(buildTask('migrate', 'code', 'Migrate the stores.'), {
+* 	authority: [buildReference('AGENTS.md', 'project law')],
+* 	manifest: buildManifest({ edit: [buildReference('src/core/stores/**', 'the legacy stores')] }),
 * })
 * briefToDispatch(draft).edit // ['src/core/stores/**']
 * briefToDispatch(draft).authority // ['AGENTS.md']
@@ -1542,36 +1673,39 @@ function briefToDispatch(input) {
 	};
 }
 /**
-* Derive one imperative statement from free text.
+* Derives one imperative statement from free text.
 *
 * @remarks
 * Whitespace collapses, the first character uppercases, and a terminator is appended
 * when the text carries none. Nothing else is invented.
 *
 * @param text - The raw request text.
-* @returns The statement, or `''` for empty or whitespace-only text.
+* @returns The statement, or `undefined` for empty or whitespace-only text.
 *
 * @example
 * ```ts
 * import { deriveStatement } from '@orkestrel/brief'
 *
 * deriveStatement('  clean up   useForm ') // 'Clean up useForm.'
-* deriveStatement('') // ''
+* deriveStatement('') // undefined
 * ```
 */
 function deriveStatement(text) {
 	const collapsed = (0, _orkestrel_interpret.collapseWhitespace)(text);
-	if (collapsed.length === 0) return "";
+	if (collapsed.length === 0) return void 0;
 	const capitalized = collapsed.charAt(0).toUpperCase() + collapsed.slice(1);
 	return /[.!?]$/u.test(capitalized) ? capitalized : `${capitalized}.`;
 }
 /**
-* Derive a `Task` from an interprets `Intent` through the caller's vocabularies.
+* Derives a `Task` from an interprets `Intent` through the caller's vocabularies.
 *
 * @remarks
 * The vocabularies are the CALLER's policy: this maps and never guesses. An action or
 * domain the caller did not map — or mapped to an off-vocabulary value — yields
-* `undefined` rather than an invented task. Inherited keys never resolve.
+* `undefined` rather than an invented task. Inherited keys never resolve. `Intent.action`
+* and `Intent.domain` are optional, because `classifyIntent` leaves an unmatched axis
+* absent, and an absent axis is unmapped by definition: it yields `undefined` before
+* either vocabulary is read.
 *
 * @param intent - The classified intent from an interpret pipeline.
 * @param text - The text the statement derives from.
@@ -1590,16 +1724,17 @@ function deriveStatement(text) {
 * ```
 */
 function deriveTask(intent, text, actions, domains) {
+	if (intent.action === void 0 || intent.domain === void 0) return void 0;
 	const operationDescriptor = Object.getOwnPropertyDescriptor(actions, intent.action);
 	const domainDescriptor = Object.getOwnPropertyDescriptor(domains, intent.domain);
 	const operation = operationDescriptor === void 0 ? void 0 : "value" in operationDescriptor ? operationDescriptor.value : operationDescriptor.get === void 0 ? void 0 : Reflect.apply(operationDescriptor.get, actions, []);
 	const domain = domainDescriptor === void 0 ? void 0 : "value" in domainDescriptor ? domainDescriptor.value : domainDescriptor.get === void 0 ? void 0 : Reflect.apply(domainDescriptor.get, domains, []);
 	if (!isTaskOperation(operation) || !isTaskDomain(domain)) return void 0;
 	const statement = deriveStatement(text);
-	return statement.length === 0 ? void 0 : task(operation, domain, statement);
+	return statement === void 0 ? void 0 : buildTask(operation, domain, statement);
 }
 /**
-* Derive `Given[]` from an interprets `Entity[]`.
+* Derives `Given[]` from an interprets `Entity[]`.
 *
 * @remarks
 * Every extracted entity becomes one `extracted` fact. A nameless entity is dropped; an
@@ -1618,10 +1753,10 @@ function deriveTask(intent, text, actions, domains) {
 * ```
 */
 function deriveGivens(entities) {
-	return entities.filter((entity) => entity.name.length > 0).map((entity) => given("extracted", entity.name, typeof entity.value === "string" ? entity.value : typeof entity.value === "object" && entity.value !== null ? (0, _orkestrel_interpret.canonicalize)(entity.value) : String(entity.value)));
+	return entities.filter((entity) => entity.name.length > 0).map((entity) => buildGiven("extracted", entity.name, typeof entity.value === "string" ? entity.value : typeof entity.value === "object" && entity.value !== null ? (0, _orkestrel_interpret.canonicalize)(entity.value) : String(entity.value)));
 }
 /**
-* Derive `Gap[]` from an interprets `Ambiguity[]`.
+* Derives `Gap[]` from an interprets `Ambiguity[]`.
 *
 * @remarks
 * A REQUIRED ambiguity becomes a BLOCKING gap — the gate must fail closed on it. The
@@ -1642,7 +1777,7 @@ function deriveGivens(entities) {
 function deriveGaps(ambiguities) {
 	return ambiguities.map((ambiguity) => {
 		const candidates = ambiguity.candidates.filter((candidate) => candidate.length > 0);
-		return gap((0, _orkestrel_reason.formatField)(ambiguity.field), ambiguity.question, {
+		return buildGap((0, _orkestrel_reason.formatField)(ambiguity.field), ambiguity.question, {
 			blocking: ambiguity.required,
 			...candidates.length === 0 ? {} : { candidates }
 		});
@@ -1651,7 +1786,7 @@ function deriveGaps(ambiguities) {
 //#endregion
 //#region src/core/parsers.ts
 /**
-* Parse a JSON string into a `Brief`.
+* Parses a JSON string into a `Brief`.
 *
 * @remarks
 * The parse-then-trust boundary for a stored brief, a tool argument, or an agent's
@@ -1685,7 +1820,7 @@ function parseBrief(value) {
 //#endregion
 //#region src/core/BriefManager.ts
 /**
-* The self-owning, versioned and content-hashed brief registry.
+* Implements the self-owning, versioned and content-hashed brief registry.
 *
 * @remarks
 * Record ids are MINTED from each brief's own content hash unless the caller names one,
@@ -1695,10 +1830,10 @@ function parseBrief(value) {
 *
 * @example
 * ```ts
-* import { BriefManager, brief, task } from '@orkestrel/brief'
+* import { BriefManager, buildBrief, buildTask } from '@orkestrel/brief'
 *
 * const briefs = new BriefManager()
-* const record = briefs.add(brief(task('document', 'writing', 'Write the brief guide.')))
+* const record = briefs.add(buildBrief(buildTask('document', 'writing', 'Write the brief guide.')))
 * record.id === record.hash // true
 * briefs.destroy()
 * ```
@@ -1725,7 +1860,7 @@ var BriefManager = class {
 	get emitter() {
 		return this.#emitter;
 	}
-	get size() {
+	get count() {
 		return this.#records.size;
 	}
 	has(id) {
@@ -1740,9 +1875,9 @@ var BriefManager = class {
 		this.#refuseDestroyed();
 		return [...this.#records.values()];
 	}
-	add(source, options) {
+	add(brief, options) {
 		this.#refuseDestroyed();
-		const record = this.#stage(source, this.#records, options);
+		const record = this.#stage(brief, this.#records, options);
 		this.#commit(record);
 		return record;
 	}
@@ -1809,7 +1944,7 @@ var BriefManager = class {
 //#endregion
 //#region src/core/BriefCompiler.ts
 /**
-* The compilation orchestrator — the four-stage `[interpret, draft, gate, pin]` pipeline.
+* Implements the compilation orchestrator — the `[interpret, draft, gate, pin]` pipeline.
 *
 * @remarks
 * `compile` is genuinely SYNCHRONOUS and never throws for a brief it cannot emit: a
@@ -1819,13 +1954,13 @@ var BriefManager = class {
 *
 * @example
 * ```ts
-* import { BriefCompiler, proof, task } from '@orkestrel/brief'
+* import { BriefCompiler, buildProof, buildTask } from '@orkestrel/brief'
 *
 * const compiler = new BriefCompiler()
 * const briefing = compiler.compile({
-* 	task: task('audit', 'code', 'Audit the barrel for undocumented exports.'),
+* 	task: buildTask('audit', 'code', 'Audit the barrel for undocumented exports.'),
 * 	outcomes: [{ rank: 1, text: 'every export appears in the guide', required: true }],
-* 	proofs: [proof('parity passes', 'npm run test:guides')],
+* 	proofs: [buildProof('parity passes', 'npm run test:guides')],
 * })
 * briefing.brief !== undefined // true — the presence of the brief IS the completeness test
 * compiler.destroy()
@@ -1976,9 +2111,9 @@ var BriefCompiler = class {
 		this.#emitter.emit("compile", briefing);
 		return briefing;
 	}
-	gate(source) {
+	gate(brief) {
 		this.#refuseDestroyed();
-		const ruled = (0, _orkestrel_contract.attempt)(() => this.#own(this.#reason.reason(briefToSubject(source), gateDefinition()), [
+		const ruled = (0, _orkestrel_contract.attempt)(() => this.#own(this.#reason.reason(briefToSubject(brief), buildGateDefinition()), [
 			"reasoning",
 			"conclusion",
 			"rules",
@@ -2014,25 +2149,9 @@ var BriefCompiler = class {
 		return cloned.success ? freezeDeep(cloned.value) : captureValue(value, members);
 	}
 	#read(input, raw, stages, failures) {
-		const members = [
-			"text",
-			"normalized",
-			"intent",
-			"entities",
-			"subject",
-			"definition",
-			"mappings",
-			"ambiguities",
-			"prompt",
-			"stages",
-			"failures",
-			"complete",
-			"confidence",
-			"digest"
-		];
 		const text = input.text;
 		if (text !== void 0) {
-			const read = (0, _orkestrel_contract.attempt)(() => this.#own(this.#interpret.interpret(text), members));
+			const read = (0, _orkestrel_contract.attempt)(() => this.#own(this.#interpret.interpret(text), INTERPRETATION_MEMBERS));
 			if (read.success && (0, _orkestrel_interpret.isInterpretation)(read.value)) {
 				stages.push(Object.freeze({
 					stage: "interpret",
@@ -2057,7 +2176,7 @@ var BriefCompiler = class {
 		const supplied = input.interpretation;
 		if (supplied === void 0 || (0, _orkestrel_interpret.isInterpretation)(supplied)) return supplied;
 		const live = raw.interpretation;
-		const captured = (0, _orkestrel_contract.attempt)(() => captureValue(live, members));
+		const captured = (0, _orkestrel_contract.attempt)(() => captureValue(live, INTERPRETATION_MEMBERS));
 		if (captured.success && (0, _orkestrel_interpret.isInterpretation)(captured.value)) return captured.value;
 		const message = "The supplied interpretation does not satisfy the published shape";
 		stages.push(Object.freeze({
@@ -2083,7 +2202,7 @@ var BriefCompiler = class {
 			message: `Gate refused: ${unready.join(", ")}`
 		};
 		if (verdict === void 0) return void 0;
-		const refused = verdict.rules.filter((entry) => !entry.conclusion).map((entry) => entry.id).join(", ");
+		const refused = verdict.rules.filter((entry) => !entry.applied).map((entry) => entry.id).join(", ");
 		if (refused.length === 0) return {
 			stage: "gate",
 			code: "BLOCKED",
@@ -2098,7 +2217,7 @@ var BriefCompiler = class {
 	#unresolved(interpretation, failures) {
 		if (interpretation !== void 0) return [];
 		if (!failures.some((entry) => entry.stage === "interpret")) return [];
-		return [gap("gaps", "The interpret stage failed, so the request is unread and its unknowns are unknown", { blocking: true })];
+		return [buildGap("gaps", "The interpret stage failed, so the request is unread and its unknowns are unknown", { blocking: true })];
 	}
 	#draft(input, interpretation, unresolved) {
 		const derived = interpretation === void 0 ? void 0 : deriveTask(interpretation.intent, interpretation.text, this.#actions, this.#domains);
@@ -2107,9 +2226,9 @@ var BriefCompiler = class {
 			stage: "draft",
 			field: "task"
 		});
-		return snapshotBrief(brief(subject, {
+		return snapshotBrief(buildBrief(subject, {
 			authority: input.authority ?? [],
-			manifest: input.manifest ?? manifest(),
+			manifest: input.manifest ?? buildManifest(),
 			outcomes: input.outcomes ?? [],
 			rules: input.rules ?? [],
 			invariants: input.invariants ?? [],
@@ -2123,7 +2242,7 @@ var BriefCompiler = class {
 				...input.gaps ?? []
 			],
 			risks: input.risks ?? [],
-			output: input.output ?? output("markdown"),
+			output: input.output ?? buildOutput("markdown"),
 			proofs: input.proofs ?? []
 		}));
 	}
@@ -2151,7 +2270,7 @@ var BriefCompiler = class {
 //#endregion
 //#region src/core/factories.ts
 /**
-* Create a compilation orchestrator.
+* Creates a compilation orchestrator.
 *
 * @remarks
 * With no engines supplied the compiler wires its own: a default `createInterpret()`
@@ -2159,7 +2278,8 @@ var BriefCompiler = class {
 * `createReason` carrying one `LogicalReasoner` for the gate. Pass your own to share
 * instances or observe their emitters — the compiler destroys ONLY what it created.
 *
-* @param options - Engines to borrow, the two intent vocabularies, and emitter hooks.
+* @param options - Engines to borrow, the `actions` and `domains` intent vocabularies, and
+* emitter hooks.
 * @returns A working {@link BriefCompilerInterface}.
 *
 * @example
@@ -2174,7 +2294,7 @@ function createBriefCompiler(options) {
 	return new BriefCompiler(options);
 }
 /**
-* Create a brief registry.
+* Creates a brief registry.
 *
 * @param options - An optional seed collection plus emitter hooks.
 * @returns A working {@link BriefManagerInterface}.
@@ -2184,7 +2304,7 @@ function createBriefCompiler(options) {
 * import { createBriefManager } from '@orkestrel/brief'
 *
 * const briefs = createBriefManager()
-* briefs.size // 0
+* briefs.count // 0
 * briefs.destroy()
 * ```
 */
@@ -2192,7 +2312,7 @@ function createBriefManager(options) {
 	return new BriefManager(options);
 }
 /**
-* Compile `briefShape` into a guard, parser, JSON Schema, and seeded generator bundle.
+* Compiles `briefShape` into a guard, parser, JSON Schema, and seeded generator bundle.
 *
 * @remarks
 * The schema is what a tool boundary needs — hand it to `schemaToParameters` — and
@@ -2222,6 +2342,7 @@ exports.BriefError = BriefError;
 exports.BriefManager = BriefManager;
 exports.DEFAULT_BRIEF_TURNS = DEFAULT_BRIEF_TURNS;
 exports.GATE_ID = GATE_ID;
+exports.INTERPRETATION_MEMBERS = INTERPRETATION_MEMBERS;
 exports.LINE_BREAK_PATTERN = LINE_BREAK_PATTERN;
 exports.OUTPUT_FORMATS = OUTPUT_FORMATS;
 exports.RISK_SEVERITIES = RISK_SEVERITIES;
@@ -2229,7 +2350,6 @@ exports.SINGLE_LINE_PATTERN = SINGLE_LINE_PATTERN;
 exports.TASK_DOMAINS = TASK_DOMAINS;
 exports.TASK_OPERATIONS = TASK_OPERATIONS;
 exports.assertBrief = assertBrief;
-exports.brief = brief;
 exports.briefShape = briefShape;
 exports.briefToContent = briefToContent;
 exports.briefToDispatch = briefToDispatch;
@@ -2238,8 +2358,20 @@ exports.briefToHash = briefToHash;
 exports.briefToMarkdown = briefToMarkdown;
 exports.briefToSubject = briefToSubject;
 exports.briefToTrace = briefToTrace;
+exports.buildBrief = buildBrief;
+exports.buildCitation = buildCitation;
+exports.buildExample = buildExample;
+exports.buildGap = buildGap;
+exports.buildGateDefinition = buildGateDefinition;
+exports.buildGiven = buildGiven;
+exports.buildManifest = buildManifest;
+exports.buildOutcome = buildOutcome;
+exports.buildOutput = buildOutput;
+exports.buildProof = buildProof;
+exports.buildReference = buildReference;
+exports.buildRisk = buildRisk;
+exports.buildTask = buildTask;
 exports.captureValue = captureValue;
-exports.citation = citation;
 exports.citationShape = citationShape;
 exports.countSentences = countSentences;
 exports.createBriefCompiler = createBriefCompiler;
@@ -2250,7 +2382,6 @@ exports.deriveGivens = deriveGivens;
 exports.deriveStatement = deriveStatement;
 exports.deriveTask = deriveTask;
 exports.errorToMessage = errorToMessage;
-exports.example = example;
 exports.exampleShape = exampleShape;
 exports.exampleToLines = exampleToLines;
 exports.findBlockingGaps = findBlockingGaps;
@@ -2260,10 +2391,7 @@ exports.findUnmetRules = findUnmetRules;
 exports.findUnpairedGaps = findUnpairedGaps;
 exports.freezeBranch = freezeBranch;
 exports.freezeDeep = freezeDeep;
-exports.gap = gap;
 exports.gapShape = gapShape;
-exports.gateDefinition = gateDefinition;
-exports.given = given;
 exports.givenShape = givenShape;
 exports.isBrief = isBrief;
 exports.isBriefError = isBriefError;
@@ -2285,22 +2413,15 @@ exports.isTaskDomain = isTaskDomain;
 exports.isTaskOperation = isTaskOperation;
 exports.isText = isText;
 exports.lineShape = lineShape;
-exports.manifest = manifest;
 exports.manifestShape = manifestShape;
-exports.outcome = outcome;
 exports.outcomeShape = outcomeShape;
-exports.output = output;
 exports.outputShape = outputShape;
 exports.parseBrief = parseBrief;
 exports.pinBrief = pinBrief;
-exports.proof = proof;
 exports.proofShape = proofShape;
-exports.reference = reference;
 exports.referenceShape = referenceShape;
-exports.risk = risk;
 exports.riskShape = riskShape;
 exports.snapshotBrief = snapshotBrief;
-exports.task = task;
 exports.taskShape = taskShape;
 exports.textShape = textShape;
 exports.validateBrief = validateBrief;