@orkestrel/brief 0.0.6 → 0.0.8

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

@@ -1,32 +1,32 @@
-import { Ambiguity } from '@orkestrel/interpret';
+import type { Ambiguity } from '@orkestrel/interpret';
 import { ArrayShape } from '@orkestrel/contract';
 import { BooleanShape } from '@orkestrel/contract';
-import { ContractInterface } from '@orkestrel/contract';
-import { EmitterErrorHandler } from '@orkestrel/emitter';
-import { EmitterHooks } from '@orkestrel/emitter';
-import { EmitterInterface } from '@orkestrel/emitter';
-import { Entity } from '@orkestrel/interpret';
-import { Guard } from '@orkestrel/contract';
-import { Intent } from '@orkestrel/interpret';
-import { Interpretation } from '@orkestrel/interpret';
-import { InterpretInterface } from '@orkestrel/interpret';
+import type { ContractInterface } from '@orkestrel/contract';
+import type { EmitterErrorHandler } from '@orkestrel/emitter';
+import type { EmitterHooks } from '@orkestrel/emitter';
+import type { EmitterInterface } from '@orkestrel/emitter';
+import type { Entity } from '@orkestrel/interpret';
+import type { Guard } from '@orkestrel/contract';
+import type { Intent } from '@orkestrel/interpret';
+import type { Interpretation } from '@orkestrel/interpret';
+import type { InterpretInterface } from '@orkestrel/interpret';
 import { LiteralShape } from '@orkestrel/contract';
-import { LogicalDefinition } from '@orkestrel/reason';
-import { LogicalResult } from '@orkestrel/reason';
-import { ManagerAddOptions } from '@orkestrel/interpret';
+import type { LogicalDefinition } from '@orkestrel/reason';
+import type { LogicalResult } from '@orkestrel/reason';
 import { NumberShape } from '@orkestrel/contract';
 import { ObjectShape } from '@orkestrel/contract';
 import { OptionalShape } from '@orkestrel/contract';
-import { ReasonInterface } from '@orkestrel/reason';
-import { ReasonValidationResult } from '@orkestrel/reason';
-import { StringShape } from '@orkestrel/contract';
-import { Subject } from '@orkestrel/reason';
+import type { ReasonInterface } from '@orkestrel/reason';
+import type { ReasonValidationResult } from '@orkestrel/reason';
+import type { RecordOptions } from '@orkestrel/interpret';
+import type { StringShape } from '@orkestrel/contract';
+import type { Subject } from '@orkestrel/reason';
 
 /**
- * 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.
@@ -40,22 +40,22 @@ import { Subject } from '@orkestrel/reason';
  * `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
      * ```
      */
- export declare function assertBrief(data: unknown): Brief;
+ export declare function assertBrief(value: unknown): Brief;
 
  /**
-  * 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
@@ -68,10 +68,10 @@ import { Subject } from '@orkestrel/reason';
  export declare const BLANK_PATTERN: RegExp;
 
  /**
-  * The closed execution contract — a rough request with every implicit decision resolved.
+  * Represents the closed execution contract — a rough request with every implicit decision resolved.
   *
   * @remarks
-  * `trace` and `hash` are DERIVED by `pinBrief`. The `brief` builder cannot set them, so
+  * `trace` and `hash` are DERIVED by `pinBrief`. The `buildBrief` builder cannot set them, so
   * nothing this package produces authors them.
   *
   * They are still SHAPE-checked rather than verified on the way in: `isBrief` and `parseBrief`
@@ -100,28 +100,7 @@ import { Subject } from '@orkestrel/reason';
  }
 
  /**
-  * Build 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.
-  * @returns A fresh, unpinned `Brief`.
-  *
-  * @example
-  * ```ts
-  * import { brief, outcome, proof, task } 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')],
-  * })
-  * ```
-  */
- export declare function brief(subject: Task, overrides?: Partial<Omit<Brief, 'task' | 'trace' | 'hash'>>): Brief;
-
- /**
-  * 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
@@ -131,13 +110,13 @@ import { Subject } from '@orkestrel/reason';
   *
   * @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()
@@ -150,30 +129,64 @@ import { Subject } from '@orkestrel/reason';
      get interpret(): InterpretInterface;
      get reason(): ReasonInterface;
      compile(input: BriefInput): Briefing;
-     gate(source: Brief): LogicalResult;
+     gate(brief: Brief): LogicalResult;
      destroy(): void;
  }
 
- /** The `BriefCompiler`'s push observation surface. */
+ /**
+  * Declares the `BriefCompiler`'s push observation surface.
+  *
+  * @remarks
+  * `compile` carries the `Briefing` the call produced, `block` carries the blocking `Gap` list
+  * that stopped emission, `error` carries the thrown value, and `destroy` carries nothing.
+  */
  export declare type BriefCompilerEventMap = {
-     compile: readonly [briefing: Briefing];
-     block: readonly [questions: readonly Gap[]];
-     error: readonly [error: unknown];
-     destroy: readonly [];
+     readonly compile: readonly [briefing: Briefing];
+     readonly block: readonly [questions: readonly Gap[]];
+     readonly error: readonly [error: unknown];
+     readonly destroy: readonly [];
  };
 
- /** The compilation orchestrator contract. */
+ /** Declares the compilation orchestrator contract. */
  export declare interface BriefCompilerInterface {
+     /** Holds the typed emitter carrying `compile`, `block`, `error`, and `destroy`. */
      readonly emitter: EmitterInterface<BriefCompilerEventMap>;
+     /** Holds the interpret pipeline the `interpret` stage delegates to, owned or borrowed. */
      readonly interpret: InterpretInterface;
+     /** Holds the reasoner the gate evaluates its `LogicalDefinition` on, owned or borrowed. */
      readonly reason: ReasonInterface;
+     /**
+      * Runs the `interpret` → `draft` → `gate` → `pin` pipeline over a `BriefInput`, returning a
+      * complete or visible-incomplete result.
+      *
+      * @remarks
+      * Synchronous, and it never throws for a brief it cannot emit: a blocking gap, a refused
+      * gate, and a thrown stage each record their cause on `failures` and leave `brief` absent.
+      *
+      * @param input - The caller's text, interpretation, and authored sections.
+      * @returns The `Briefing` for this call, complete exactly when `brief` is present.
+      */
      compile(input: BriefInput): Briefing;
+     /**
+      * Evaluates one brief's readiness through the reasons gate — `briefToSubject` against
+      * `buildGateDefinition()`.
+      *
+      * @param brief - The brief to measure.
+      * @returns The reasoner's traceable verdict, whose `conclusion` is the `ready` fact.
+      */
      gate(brief: Brief): LogicalResult;
+     /**
+      * Tears the orchestrator down idempotently — owned engines first, the emitter last.
+      *
+      * @remarks
+      * Emits `destroy` between the two, and releases only the engines it created. Every method
+      * except this one throws `BriefError('DESTROYED', …)` afterwards.
+      */
      destroy(): void;
  }
 
  /**
-  * Input to `createBriefCompiler`.
+  * Represents the input to `createBriefCompiler`.
   *
   * @remarks
   * `interpret` and `reason` are BORROWED when supplied — the compiler destroys only
@@ -221,9 +234,12 @@ import { Subject } from '@orkestrel/reason';
  }
 
  /**
-  * The one error class this package throws.
+  * Represents the one error class this package throws.
   *
   * @remarks
+  * Extends `Error` with a readonly `code` on the `BriefErrorCode` vocabulary and an optional
+  * readonly `context` record carrying whatever the raising site can supply.
+  *
   * Throws are reserved for caller misuse: `assertBrief`, `snapshotBrief`, and `pinBrief` on
   * off-contract data throw `INVALID`; any method after `destroy()` throws `DESTROYED`; and `BriefCompiler.gate` throws
   * `GATE_FAILED` when a borrowed reasoner returns a non-logical result. A stage that fails
@@ -247,26 +263,26 @@ import { Subject } from '@orkestrel/reason';
  }
 
  /**
-  * The machine-readable reasons a {@link BriefError} carries.
+  * Names the machine-readable reasons a {@link BriefError} carries.
   *
   * @remarks
-  * Inside `compile` every stage failure is CONTAINED: the four `*_FAILED` codes and
-  * `BLOCKED` mark it on the {@link Briefing} rather than throwing.
+  * Inside `compile` every stage failure is CONTAINED: the `*_FAILED` codes and `BLOCKED`
+  * mark it on the {@link Briefing} rather than throwing.
   *
   * `INTERPRET_FAILED` needs a FOREIGN `InterpretInterface`. `@orkestrel/interpret` contains
   * its own stage failures and returns a degraded `Interpretation` rather than throwing, so
   * the default engine never raises it; `BriefCompilerOptions.interpret` is the seam a caller
-  * reaches it through. Three codes also reach a
-  * throw, from methods outside that containment — `INVALID` from `assertBrief`,
-  * `snapshotBrief`, and `pinBrief`; `DESTROYED` from any method after
-  * `destroy()`; and `GATE_FAILED` from `BriefCompiler.gate` when a borrowed reasoner returns a
-  * non-logical result OR throws its own error, which is translated rather than leaked so that
-  * every throw out of this module stays a `BriefError` an `isBriefError` catch can narrow.
+  * reaches it through. Other codes also reach a throw, from methods outside that containment —
+  * `INVALID` from `assertBrief`, `snapshotBrief`, and `pinBrief`; `DESTROYED` from any method
+  * after `destroy()`; and `GATE_FAILED` from `BriefCompiler.gate` when a borrowed reasoner
+  * returns a non-logical result OR throws its own error, which is translated rather than
+  * leaked so that every throw out of this module stays a `BriefError` an `isBriefError` catch
+  * can narrow.
   */
  export declare type BriefErrorCode = 'INTERPRET_FAILED' | 'DRAFT_FAILED' | 'GATE_FAILED' | 'PIN_FAILED' | 'BLOCKED' | 'INVALID' | 'DESTROYED';
 
  /**
-  * The full, replayable outcome of one `compile()` call.
+  * Represents the full, replayable outcome of one `compile()` call.
   *
   * @remarks
   * `brief` is present exactly when the compile completed, so it is ALSO the completeness
@@ -279,7 +295,7 @@ import { Subject } from '@orkestrel/reason';
   * types — import them from `@orkestrel/interpret` and `@orkestrel/reason`.
   *
   * `digest` identifies this OUTCOME — the brief, the questions, and the failures together — so
-  * two identical compiles share it and a refused compile has one just as a complete one does.
+  * two identical compiles share it and a refused compile has one the same way a complete one does.
   * It is not `Brief.hash`, which identifies the brief's content alone and exists only on an
   * emitted brief. Key a cache of compile results by `digest`; key a registry of briefs by
   * `hash`.
@@ -295,14 +311,15 @@ import { Subject } from '@orkestrel/reason';
  }
 
  /**
-  * One `compile()` input.
+  * Represents one `compile()` input.
   *
   * @remarks
-  * THREE classes of input, not two. `text` selects the interpret stage. `interpretation`
-  * supplies that stage's result directly: with no `text` it drives `deriveTask`,
-  * `deriveGivens`, and `deriveGaps` without running the language pipeline at all, and with
-  * `text` present it is also the FALLBACK the draft uses when the interpret engine throws.
-  * Every remaining key is a caller-authored section merged OVER whatever the draft derived.
+  * `text`, `interpretation`, and the caller-authored sections are SEPARATE classes of input.
+  * `text` selects the interpret stage. `interpretation` supplies that stage's result
+  * directly: with no `text` it drives `deriveTask`, `deriveGivens`, and `deriveGaps` without
+  * running the language pipeline at all, and with `text` present it is also the FALLBACK the
+  * draft uses when the interpret engine throws. Every remaining key is a caller-authored
+  * section merged OVER whatever the draft derived.
   *
   * Supplying both `text` and `interpretation` is therefore meaningful: the engine's result
   * wins when it succeeds, and the supplied one carries the compile when it does not.
@@ -327,7 +344,7 @@ import { Subject } from '@orkestrel/reason';
  }
 
  /**
-  * 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,
@@ -337,10 +354,10 @@ import { Subject } from '@orkestrel/reason';
   *
   * @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()
   * ```
@@ -349,54 +366,107 @@ import { Subject } from '@orkestrel/reason';
      #private;
      constructor(options?: BriefManagerOptions);
      get emitter(): EmitterInterface<BriefManagerEventMap>;
-     get size(): number;
+     get count(): number;
      has(id: string): boolean;
      brief(id: string): BriefRecord | undefined;
      briefs(): readonly BriefRecord[];
-     add(source: Brief, options?: ManagerAddOptions): BriefRecord;
+     add(brief: Brief, options?: RecordOptions): BriefRecord;
      remove(ids: readonly string[]): boolean;
      remove(id: string): boolean;
      remove(): void;
      destroy(): void;
  }
 
- /** The `BriefManager`'s push observation surface. */
+ /**
+  * Declares the `BriefManager`'s push observation surface.
+  *
+  * @remarks
+  * `add` and `remove` each carry the record id the store minted from the brief's content hash,
+  * and `destroy` carries nothing.
+  */
  export declare type BriefManagerEventMap = {
-     add: readonly [id: string];
-     remove: readonly [id: string];
-     destroy: readonly [];
+     readonly add: readonly [id: string];
+     readonly remove: readonly [id: string];
+     readonly destroy: readonly [];
  };
 
  /**
-  * The brief registry contract.
+  * Declares the brief registry contract.
   *
   * @remarks
   * The array overload of `remove` is declared FIRST so an id list resolves to the batch
-  * form. `add` takes the fleet's own `ManagerAddOptions` from `@orkestrel/interpret`;
+  * form. `add` takes the fleet's own `RecordOptions` from `@orkestrel/interpret`;
   * omit its `id` and the record is keyed by the brief's own content hash, so re-adding
   * unchanged content is a version no-op.
   */
  export declare interface BriefManagerInterface {
+     /** Holds the typed emitter carrying `add`, `remove`, and `destroy`. */
      readonly emitter: EmitterInterface<BriefManagerEventMap>;
-     readonly size: number;
+     /** Holds how many records are registered. */
+     readonly count: number;
+     /**
+      * Reports whether a brief with the given id is registered.
+      *
+      * @param id - The record id to look for.
+      * @returns True if a record carries that id; false otherwise.
+      */
      has(id: string): boolean;
+     /**
+      * Looks up one registered brief record by id.
+      *
+      * @param id - The record id to read.
+      * @returns The record, or `undefined` when no record carries that id.
+      */
      brief(id: string): BriefRecord | undefined;
+     /**
+      * Lists every registered brief record.
+      *
+      * @returns The records, in registration order.
+      */
      briefs(): readonly BriefRecord[];
-     add(brief: Brief, options?: ManagerAddOptions): BriefRecord;
+     /**
+      * Registers one brief from its data, minting the id from its content hash when none is given.
+      *
+      * @remarks
+      * Emits `add`. `version` bumps only when the content hash moves, so re-adding unchanged
+      * content is a no-op that keeps the record it already had.
+      *
+      * @param brief - The brief to register.
+      * @param options - An explicit `id` to key the record by.
+      * @returns The registered record.
+      */
+     add(brief: Brief, options?: RecordOptions): BriefRecord;
+     /**
+      * Removes the listed briefs by id, one brief by id, or every brief.
+      *
+      * @remarks
+      * Emits `remove` once per removed id. The array overload is declared first so an id list
+      * resolves to the batch form, which reports `true` only when every listed id was present.
+      *
+      * @param ids - The record ids to remove.
+      * @returns True when every listed id was registered; false otherwise.
+      */
      remove(ids: readonly string[]): boolean;
      remove(id: string): boolean;
      remove(): void;
+     /**
+      * Tears the registry down idempotently — the collection first, the emitter last.
+      *
+      * @remarks
+      * Emits `destroy` between the two. Every method except this one throws
+      * `BriefError('DESTROYED', …)` afterwards.
+      */
      destroy(): void;
  }
 
- /** Input to `createBriefManager`. */
+ /** Represents the input to `createBriefManager`. */
  export declare interface BriefManagerOptions {
      readonly briefs?: readonly Brief[];
      readonly on?: EmitterHooks<BriefManagerEventMap>;
      readonly error?: EmitterErrorHandler;
  }
 
- /** A versioned, content-hashed `Brief` inside a {@link BriefManagerInterface}. */
+ /** Represents a versioned, content-hashed `Brief` inside a {@link BriefManagerInterface}. */
  export declare interface BriefRecord {
      readonly id: string;
      readonly brief: Brief;
@@ -405,92 +475,92 @@ import { Subject } from '@orkestrel/reason';
  }
 
  /**
-  * 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
   * on-contract without them.
   */
- export declare const briefShape: ObjectShape<{
-     task: ObjectShape<{
-         operation: LiteralShape<readonly TaskOperation[]>;
-         domain: LiteralShape<readonly TaskDomain[]>;
-         statement: StringShape;
-     }, false>;
-     authority: ArrayShape<ObjectShape<{
-         path: StringShape;
-         note: StringShape;
-     }, false>>;
-     manifest: ObjectShape<{
-         read: ArrayShape<ObjectShape<{
-             path: StringShape;
-             note: StringShape;
-         }, false>>;
-         edit: ArrayShape<ObjectShape<{
-             path: StringShape;
-             note: StringShape;
-         }, false>>;
-         locked: ArrayShape<ObjectShape<{
-             path: StringShape;
-             note: StringShape;
-         }, false>>;
-         forbidden: ArrayShape<ObjectShape<{
-             path: StringShape;
-             note: StringShape;
-         }, false>>;
-     }, false>;
-     outcomes: ArrayShape<ObjectShape<{
-         rank: NumberShape;
-         text: StringShape;
-         required: BooleanShape;
-     }, false>>;
-     rules: ArrayShape<StringShape>;
-     invariants: ArrayShape<StringShape>;
-     givens: ArrayShape<ObjectShape<{
-         category: StringShape;
-         name: StringShape;
-         value: StringShape;
-     }, false>>;
-     examples: ArrayShape<ObjectShape<{
-         input: StringShape;
-         output: StringShape;
-         note: OptionalShape<StringShape>;
-     }, false>>;
-     assumptions: ArrayShape<StringShape>;
-     citations: ArrayShape<ObjectShape<{
-         name: StringShape;
-         url: StringShape;
-         note: StringShape;
-     }, false>>;
-     gaps: ArrayShape<ObjectShape<{
-         field: StringShape;
-         question: StringShape;
-         blocking: BooleanShape;
-         candidates: OptionalShape<ArrayShape<StringShape>>;
-     }, false>>;
-     risks: ArrayShape<ObjectShape<{
-         severity: LiteralShape<readonly RiskSeverity[]>;
-         text: StringShape;
-         mitigation: StringShape;
-     }, false>>;
-     output: ObjectShape<{
-         format: LiteralShape<readonly OutputFormat[]>;
-         sections: OptionalShape<ArrayShape<StringShape>>;
-         include: OptionalShape<ArrayShape<StringShape>>;
-         exclude: OptionalShape<ArrayShape<StringShape>>;
-     }, false>;
-     proofs: ArrayShape<ObjectShape<{
-         text: StringShape;
-         command: StringShape;
-     }, false>>;
-     trace: OptionalShape<StringShape>;
-     hash: OptionalShape<StringShape>;
+ export declare const briefShape: ObjectShape<    {
+ task: ObjectShape<    {
+ operation: LiteralShape<readonly TaskOperation[]>;
+ domain: LiteralShape<readonly TaskDomain[]>;
+ statement: StringShape;
+ }, false>;
+ authority: ArrayShape<ObjectShape<    {
+ path: StringShape;
+ note: StringShape;
+ }, false>>;
+ manifest: ObjectShape<    {
+ read: ArrayShape<ObjectShape<    {
+ path: StringShape;
+ note: StringShape;
+ }, false>>;
+ edit: ArrayShape<ObjectShape<    {
+ path: StringShape;
+ note: StringShape;
+ }, false>>;
+ locked: ArrayShape<ObjectShape<    {
+ path: StringShape;
+ note: StringShape;
+ }, false>>;
+ forbidden: ArrayShape<ObjectShape<    {
+ path: StringShape;
+ note: StringShape;
+ }, false>>;
+ }, false>;
+ outcomes: ArrayShape<ObjectShape<    {
+ rank: NumberShape;
+ text: StringShape;
+ required: BooleanShape;
+ }, false>>;
+ rules: ArrayShape<StringShape>;
+ invariants: ArrayShape<StringShape>;
+ givens: ArrayShape<ObjectShape<    {
+ category: StringShape;
+ name: StringShape;
+ value: StringShape;
+ }, false>>;
+ examples: ArrayShape<ObjectShape<    {
+ input: StringShape;
+ output: StringShape;
+ note: OptionalShape<StringShape>;
+ }, false>>;
+ assumptions: ArrayShape<StringShape>;
+ citations: ArrayShape<ObjectShape<    {
+ name: StringShape;
+ url: StringShape;
+ note: StringShape;
+ }, false>>;
+ gaps: ArrayShape<ObjectShape<    {
+ field: StringShape;
+ question: StringShape;
+ blocking: BooleanShape;
+ candidates: OptionalShape<ArrayShape<StringShape>>;
+ }, false>>;
+ risks: ArrayShape<ObjectShape<    {
+ severity: LiteralShape<readonly RiskSeverity[]>;
+ text: StringShape;
+ mitigation: StringShape;
+ }, false>>;
+ output: ObjectShape<    {
+ format: LiteralShape<readonly OutputFormat[]>;
+ sections: OptionalShape<ArrayShape<StringShape>>;
+ include: OptionalShape<ArrayShape<StringShape>>;
+ exclude: OptionalShape<ArrayShape<StringShape>>;
+ }, false>;
+ proofs: ArrayShape<ObjectShape<    {
+ text: StringShape;
+ command: StringShape;
+ }, false>>;
+ trace: OptionalShape<StringShape>;
+ hash: OptionalShape<StringShape>;
  }, false>;
 
- /** The four fixed compilation phases, in pipeline order. */
+ /** Names the fixed compilation phases, in pipeline order. */
  export declare type BriefStage = 'interpret' | 'draft' | 'gate' | 'pin';
 
- /** A visible marker for a phase that failed. */
+ /** Represents a visible marker for a phase that failed. */
  export declare interface BriefStageFailure {
      readonly stage: BriefStage;
      readonly code: BriefErrorCode;
@@ -498,7 +568,7 @@ import { Subject } from '@orkestrel/reason';
  }
 
  /**
-  * One pipeline phase, discriminated by `stage`.
+  * Represents one pipeline phase, discriminated by `stage`.
   *
   * @remarks
   * Narrowing on `stage` types both payloads exactly, so a consumer reads a replay without
@@ -507,7 +577,7 @@ import { Subject } from '@orkestrel/reason';
  export declare type BriefStageRecord = InterpretStageRecord | DraftStageRecord | GateStageRecord | PinStageRecord;
 
  /**
-  * 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
@@ -519,36 +589,43 @@ import { Subject } from '@orkestrel/reason';
   *
   * @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
   * ```
   */
  export declare function briefToContent(source: Brief): string;
 
  /**
-  * 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.
+  * `edit` is exactly `manifest.edit` — the owned set — so two dispatches whose `edit` sets do
+  * not intersect can run concurrently under the same brief without conflict. `locked` and
+  * `forbidden` cross unchanged as the do-not-touch sets.
   *
-  * `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
+  * `authority` is exactly `brief.authority` in rank order, and it is a separate axis from the
+  * 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']
@@ -557,28 +634,28 @@ import { Subject } from '@orkestrel/reason';
  export declare function briefToDispatch(input: Brief): Dispatch;
 
  /**
-  * 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.'
   * ```
   */
  export declare function briefToGoal(input: Brief, turns?: number): string;
 
  /**
-  * 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
@@ -590,52 +667,53 @@ import { Subject } from '@orkestrel/reason';
   *
   * @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
   * ```
   */
  export declare function briefToHash(source: Brief): string;
 
  /**
-  * 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.
+  * Sections render in authority order, so the executor meets what wins a conflict before what
+  * it may touch. 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'
   * ```
   */
  export declare function briefToMarkdown(input: Brief): string;
 
  /**
-  * 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, … }
   * ```
   */
  export declare function briefToSubject(source: Brief): Subject;
 
  /**
-  * 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
@@ -648,14 +726,260 @@ import { Subject } from '@orkestrel/reason';
   *
   * @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'
   * ```
   */
  export declare function briefToTrace(source: Brief): string;
 
+ /**
+  * Assembles a `Brief` from a `Task` plus section overrides.
+  *
+  * @param subject - The task the brief is about.
+  * @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 { buildBrief, buildOutcome, buildProof, buildTask } from '@orkestrel/brief'
+  *
+  * 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')],
+  * })
+  * ```
+  */
+ export declare function buildBrief(subject: Task, overrides?: Partial<Omit<Brief, 'task' | 'trace' | 'hash'>>): Brief;
+
+ /**
+  * 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.
+  * @param note - Why the source is cited.
+  * @returns A fresh `Citation`.
+  *
+  * @example
+  * ```ts
+  * import { buildCitation } from '@orkestrel/brief'
+  *
+  * buildCitation(
+  * 	'MDN Constraint Validation',
+  * 	'https://developer.mozilla.org/',
+  * 	'the native validity behavior being adopted',
+  * )
+  * ```
+  */
+ export declare function buildCitation(name: string, url: string, note: string): Citation;
+
+ /**
+  * Assembles an `Example` from an exemplar input and its expected output.
+  *
+  * @param input - The exemplar 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 { buildExample } from '@orkestrel/brief'
+  *
+  * buildExample('<input required>', 'validity read from el.validity')
+  * ```
+  */
+ export declare function buildExample(input: string, output: string, note?: string): Example;
+
+ /**
+  * 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` and `candidates`; an absent `candidates` key is
+  *   OMITTED entirely. Default: `blocking: false`.
+  * @returns A fresh `Gap`.
+  *
+  * @example
+  * ```ts
+  * import { buildGap } from '@orkestrel/brief'
+  *
+  * buildGap('rules', 'Does validation message wording need to change?') // blocking: false
+  * buildGap('output', 'Diff or full files?', { blocking: true, candidates: ['diff', 'code'] })
+  * ```
+  */
+ export declare function buildGap(field: string, question: string, overrides?: Partial<Omit<Gap, 'field' | 'question'>>): Gap;
+
+ /**
+  * Assembles the fail-closed readiness gate as a reasons `LogicalDefinition`.
+  *
+  * @remarks
+  * 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
+  * for a readiness fact overwrites it and `ready` then conjoins a fact no base rule
+  * proved — a refusal silently becomes a pass. Readiness is this package's contract, not
+  * a caller setting. A caller who needs different readiness composes their own
+  * `LogicalDefinition` over `briefToSubject` and evaluates it on their own reasoner; both
+  * are exported for exactly that, and neither can reach this definition.
+  *
+  * @returns A fresh `LogicalDefinition` with id `GATE_ID`.
+  *
+  * @example
+  * ```ts
+  * import { briefToSubject, buildGateDefinition } from '@orkestrel/brief'
+  * import { createLogicalReasoner, createReason } from '@orkestrel/reason'
+  *
+  * const reason = createReason({ reasoners: [createLogicalReasoner()] })
+  * const verdict = reason.reason(briefToSubject(pinned), buildGateDefinition())
+  * reason.destroy()
+  * ```
+  */
+ export declare function buildGateDefinition(): LogicalDefinition;
+
+ /**
+  * 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.
+  * @param value - The fact's value, already rendered as text.
+  * @returns A fresh `Given`.
+  *
+  * @example
+  * ```ts
+  * import { buildGiven } from '@orkestrel/brief'
+  *
+  * buildGiven('convention', 'indentation', 'tabs')
+  * ```
+  */
+ export declare function buildGiven(category: string, name: string, value: string): Given;
+
+ /**
+  * 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 every partition present.
+  *
+  * @example
+  * ```ts
+  * import { buildManifest, buildReference } from '@orkestrel/brief'
+  *
+  * buildManifest({ edit: [buildReference('src/core/helpers.ts', 'implementation')] })
+  * ```
+  */
+ export declare function buildManifest(partitions?: Partial<Manifest>): Manifest;
+
+ /**
+  * 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 - If `true`, the outcome gates "done"; if `false`, it is desirable but not
+  *   blocking. Default: `true`.
+  * @returns A fresh `Outcome`.
+  *
+  * @example
+  * ```ts
+  * import { buildOutcome } from '@orkestrel/brief'
+  *
+  * buildOutcome(1, 'useForm uses native FormData with no behavior change') // required: true
+  * buildOutcome(2, 'the diff stays under 200 lines', false)
+  * ```
+  */
+ export declare function buildOutcome(rank: number, text: string, required?: boolean): Outcome;
+
+ /**
+  * 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.
+  * @returns A fresh `Output`.
+  *
+  * @example
+  * ```ts
+  * import { buildOutput } from '@orkestrel/brief'
+  *
+  * buildOutput('markdown') // { format: 'markdown' }
+  * buildOutput('diff', { include: ['updated useForm.ts'] })
+  * ```
+  */
+ export declare function buildOutput(format: OutputFormat, overrides?: Partial<Omit<Output, 'format'>>): Output;
+
+ /**
+  * 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.
+  * @returns A fresh `Proof`.
+  *
+  * @example
+  * ```ts
+  * import { buildProof } from '@orkestrel/brief'
+  *
+  * buildProof('type-check and lint pass', 'npm run check')
+  * ```
+  */
+ export declare function buildProof(text: string, command: string): Proof;
+
+ /**
+  * Assembles a `Reference` from a path and the note that justifies listing it.
+  *
+  * @remarks
+  * The one builder for an authority entry and a manifest entry alike: the container the record
+  * lands in is what says whether the path is ranked or permitted.
+  *
+  * @param path - The referenced path or glob.
+  * @param note - Why the path is listed.
+  * @returns A fresh `Reference`.
+  *
+  * @example
+  * ```ts
+  * import { buildReference } from '@orkestrel/brief'
+  *
+  * buildReference('AGENTS.md', 'project law') // { path: 'AGENTS.md', note: 'project law' }
+  * ```
+  */
+ export declare function buildReference(path: string, note: string): Reference;
+
+ /**
+  * 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.
+  * @param mitigation - What answers it.
+  * @returns A fresh `Risk`.
+  *
+  * @example
+  * ```ts
+  * import { buildRisk } from '@orkestrel/brief'
+  *
+  * buildRisk('medium', 'native validation differs subtly', 'assert message and state in tests')
+  * ```
+  */
+ export declare function buildRisk(severity: RiskSeverity, text: string, mitigation: string): Risk;
+
+ /**
+  * 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.
+  * @param statement - One imperative sentence naming the object of the work.
+  * @returns A fresh `Task`.
+  *
+  * @example
+  * ```ts
+  * import { buildTask } from '@orkestrel/brief'
+  *
+  * buildTask('refactor', 'code', 'Refactor useForm to native browser form APIs.')
+  * ```
+  */
+ export declare function buildTask(operation: TaskOperation, domain: TaskDomain, statement: string): Task;
+
  /**
   * Captures one stable, frozen view of a foreign contract value.
   *
@@ -683,7 +1007,7 @@ import { Subject } from '@orkestrel/reason';
  export declare function captureValue(source: unknown, members: readonly string[]): unknown;
 
  /**
-  * One external source — what it is called, where it lives, and why it is cited.
+  * Represents one external source — what it is called, where it lives, and why it is cited.
   *
   * @remarks
   * List ORDER is the trust order; there is no per-entry weight.
@@ -703,12 +1027,13 @@ import { Subject } from '@orkestrel/reason';
   * and the shape DSL's seeded generator builds a random alphanumeric string and throws when it
   * fails the pattern — so any pattern requiring a scheme's colon makes `createBriefContract()`
   * ungeneratable for the whole brief. Constraining only the guard would leave the guard and the
-  * compiled shape disagreeing, which is the parity this package holds in lockstep. Four working
-  * mechanisms beat one stricter member.
+  * compiled shape disagreeing, which is the parity this package holds in lockstep. Keeping the
+  * guard, the compiled shape, the generator, and `createBriefContract()` working beats one
+  * stricter member.
   *
-  * The cost lands on one migration: `citation` takes `(name, url, note)` where it once took
-  * `(name, role, url)` — three strings either way, so a stale call still compiles and still
-  * passes the guard, and only renders wrong. Nothing is published, so a version bump carries it.
+  * The cost lands on one migration: `buildCitation` takes `(name, url, note)` where the 0.0.6
+  * release took `(name, role, url)` — strings in the same positions either way, so a stale call
+  * still compiles and still passes the guard, and only renders wrong.
   */
  export declare interface Citation {
      readonly name: string;
@@ -716,36 +1041,15 @@ import { Subject } from '@orkestrel/reason';
      readonly note: string;
  }
 
- /**
-  * Build a `Citation`.
-  *
-  * @param name - The source's display name.
-  * @param url - Where the source lives.
-  * @param note - Why the source is cited.
-  * @returns A fresh `Citation`.
-  *
-  * @example
-  * ```ts
-  * import { citation } from '@orkestrel/brief'
-  *
-  * citation(
-  * 	'MDN Constraint Validation',
-  * 	'https://developer.mozilla.org/',
-  * 	'the native validity behavior being adopted',
-  * )
-  * ```
-  */
- export declare function citation(name: string, url: string, note: string): Citation;
-
- /** The `Citation` shape — a name, a locator, and why the source is cited. */
- export declare const citationShape: ObjectShape<{
-     name: StringShape;
-     url: StringShape;
-     note: StringShape;
+ /** Describes the `Citation` shape — a name, a locator, and why the source is cited. */
+ export declare const citationShape: ObjectShape<    {
+ name: StringShape;
+ url: StringShape;
+ note: StringShape;
  }, false>;
 
  /**
-  * 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
@@ -778,7 +1082,7 @@ import { Subject } from '@orkestrel/reason';
  export declare function countSentences(statement: string): number;
 
  /**
-  * Create a compilation orchestrator.
+  * Creates a compilation orchestrator.
   *
   * @remarks
   * With no engines supplied the compiler wires its own: a default `createInterpret()`
@@ -786,9 +1090,49 @@ import { Subject } from '@orkestrel/reason';
   * `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 Compile and project a brief
+  * ```ts
+  * import {
+  * 	briefToGoal,
+  * 	briefToMarkdown,
+  * 	buildOutcome,
+  * 	buildProof,
+  * 	buildTask,
+  * 	createBriefCompiler,
+  * } from '@orkestrel/brief'
+  *
+  * const compiler = createBriefCompiler()
+  *
+  * const briefing = compiler.compile({
+  * 	task: buildTask('refactor', 'code', 'Refactor useForm to native browser form APIs.'),
+  * 	authority: [{ path: 'AGENTS.md', note: 'project law; wins every conflict' }],
+  * 	manifest: {
+  * 		read: [
+  * 			{ path: 'AGENTS.md', note: 'project law; wins every conflict' },
+  * 			{ path: 'guides/browser.md', note: 'the composable contract' },
+  * 		],
+  * 		edit: [{ path: 'src/browser/composables/useForm.ts', note: 'the composable being refactored' }],
+  * 		locked: [{ path: 'src/browser/types.ts', note: 'the published contract' }],
+  * 		forbidden: [{ path: 'app/**', note: 'out of scope' }],
+  * 	},
+  * 	outcomes: [buildOutcome(1, 'useForm uses native FormData with no behavior change')],
+  * 	proofs: [buildProof('type-check and lint pass', 'npm run check')],
+  * })
+  *
+  * briefing.brief !== undefined // true — the brief is present exactly when the gate passed
+  * if (briefing.brief !== undefined) {
+  * 	briefToMarkdown(briefing.brief) // the copy-ready agent prompt
+  * 	briefToGoal(briefing.brief) // the /goal completion condition
+  * }
+  *
+  * compiler.emitter.on('block', (questions) => questions.length)
+  * compiler.destroy()
+  * ```
+  *
   * @example
   * ```ts
   * import { createBriefCompiler } from '@orkestrel/brief'
@@ -800,7 +1144,7 @@ import { Subject } from '@orkestrel/reason';
  export declare function createBriefCompiler(options?: BriefCompilerOptions): BriefCompilerInterface;
 
  /**
-  * 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
@@ -823,7 +1167,7 @@ import { Subject } from '@orkestrel/reason';
  export declare function createBriefContract(): ContractInterface<Brief>;
 
  /**
-  * Create a brief registry.
+  * Creates a brief registry.
   *
   * @param options - An optional seed collection plus emitter hooks.
   * @returns A working {@link BriefManagerInterface}.
@@ -833,14 +1177,14 @@ import { Subject } from '@orkestrel/reason';
   * import { createBriefManager } from '@orkestrel/brief'
   *
   * const briefs = createBriefManager()
-  * briefs.size // 0
+  * briefs.count // 0
   * briefs.destroy()
   * ```
   */
  export declare function createBriefManager(options?: BriefManagerOptions): BriefManagerInterface;
 
  /**
-  * `16` — the default turn cap `briefToGoal` renders.
+  * Holds `16` — the default turn cap `briefToGoal` renders.
   *
   * @remarks
   * Domain-qualified so the barrel stays collision-free as sibling modules add their own
@@ -849,7 +1193,7 @@ import { Subject } from '@orkestrel/reason';
  export declare const DEFAULT_BRIEF_TURNS = 16;
 
  /**
-  * 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
@@ -870,7 +1214,7 @@ import { Subject } from '@orkestrel/reason';
  export declare function deriveGaps(ambiguities: readonly Ambiguity[]): readonly Gap[];
 
  /**
-  * 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
@@ -891,32 +1235,35 @@ import { Subject } from '@orkestrel/reason';
  export declare function deriveGivens(entities: readonly Entity[]): readonly Given[];
 
  /**
-  * 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
   * ```
   */
- export declare function deriveStatement(text: string): string;
+ export declare function deriveStatement(text: string): string | undefined;
 
  /**
-  * 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.
@@ -937,23 +1284,24 @@ import { Subject } from '@orkestrel/reason';
  export declare function deriveTask(intent: Intent, text: string, actions: Readonly<Record<string, TaskOperation>>, domains: Readonly<Record<string, TaskDomain>>): Task | undefined;
 
  /**
-  * The subagent projection of a brief.
+  * Represents the subagent projection of a brief.
   *
   * @remarks
-  * Two orthogonal axes, not five partitions. PERMISSION is `read`, `edit`, `locked`, and
-  * `forbidden`, with `edit` the owned set two concurrent dispatches must not intersect on and
-  * `locked` and `forbidden` do-not-touch. PRECEDENCE is `authority`, in ranked order, index 0
-  * winning every conflict.
+  * PERMISSION and PRECEDENCE are orthogonal axes rather than one flat partition set.
+  * PERMISSION is `read`, `edit`, `locked`, and `forbidden`, with `edit` the owned set two
+  * concurrent dispatches must not intersect on and `locked` and `forbidden` do-not-touch.
+  * PRECEDENCE is `authority`, in ranked order, index 0 winning every conflict.
   *
   * `authority` therefore OVERLAPS the permission arrays by design: a ranked path ALWAYS also
   * sits in `read`, `edit`, or `locked`, because the executor has to open what it obeys, and
-  * the `granted` gate rule refuses a brief where it does not. Read the four to decide what may
-  * be touched and `authority` to decide what wins. Never union all five — that was already
-  * wrong before `authority` existed, because `forbidden` is an exclusion rather than a grant.
+  * the `granted` gate rule refuses a brief where it does not. Read the permission arrays to
+  * decide what may be touched and `authority` to decide what wins. Never union the permission
+  * arrays with `authority` — that was already wrong before `authority` existed, because
+  * `forbidden` is an exclusion rather than a grant.
   * `authority` is a path list rather than a rendered section because a machine consumer must
   * reach mandatory authority without parsing `prompt`, which is written for a model.
   *
-  * The four permission arrays are mutually disjoint in a GATED brief — `findManifestOverlaps`
+  * The permission arrays are mutually disjoint in a GATED brief — `findManifestOverlaps`
   * measures it and the `disjoint` rule refuses on it. `briefToDispatch` is a pure projection
   * and runs no gate, so projecting an unvetted draft can produce arrays that intersect. Gate
   * before you dispatch, or treat disjointness as unproven.
@@ -967,7 +1315,7 @@ import { Subject } from '@orkestrel/reason';
      readonly forbidden: readonly string[];
  }
 
- /** The `draft` phase snapshot — the caller's input in, an unpinned `Brief` out. */
+ /** Records the `draft` phase snapshot — the caller's input in, an unpinned `Brief` out. */
  export declare interface DraftStageRecord {
      readonly stage: 'draft';
      readonly input: BriefInput;
@@ -976,7 +1324,7 @@ import { Subject } from '@orkestrel/reason';
  }
 
  /**
-  * 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
@@ -985,7 +1333,7 @@ import { Subject } from '@orkestrel/reason';
   * 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.
@@ -1005,39 +1353,22 @@ import { Subject } from '@orkestrel/reason';
   */
  export declare function errorToMessage(error: unknown): string;
 
- /** One input to output exemplar — the highest-leverage ambiguity remover. */
+ /** Represents one input to output exemplar — the ambiguity remover that leaves the least to interpret. */
  export declare interface Example {
      readonly input: string;
      readonly output: string;
      readonly note?: string;
  }
 
- /**
-  * Build an `Example`.
-  *
-  * @param input - The exemplar input.
-  * @param result - 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'
-  *
-  * example('<input required>', 'validity read from el.validity')
-  * ```
-  */
- export declare function example(input: string, result: string, note?: string): Example;
-
- /** The `Example` shape — one input to output exemplar. */
- export declare const exampleShape: ObjectShape<{
-     input: StringShape;
-     output: StringShape;
-     note: OptionalShape<StringShape>;
+ /** Describes the `Example` shape — one input to output exemplar. */
+ export declare const exampleShape: ObjectShape<    {
+ input: StringShape;
+ output: StringShape;
+ note: OptionalShape<StringShape>;
  }, false>;
 
  /**
-  * 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
@@ -1049,25 +1380,29 @@ import { Subject } from '@orkestrel/reason';
   *
   * @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 `']
   * ```
   */
  export declare function exampleToLines(entry: Example): readonly string[];
 
  /**
-  * The gaps that block emission.
+  * Lists the gaps that block emission.
+  *
+  * @remarks
+  * A non-empty result means the gate must fail closed: a blocking gap has no safe default, so
+  * the compile yields a visible incomplete `Briefing` carrying the questions instead of a brief.
   *
   * @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
   * ```
@@ -1075,10 +1410,10 @@ import { Subject } from '@orkestrel/reason';
  export declare function findBlockingGaps(source: Brief): readonly Gap[];
 
  /**
-  * 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'`
@@ -1090,12 +1425,18 @@ import { Subject } from '@orkestrel/reason';
   *
   * @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']
@@ -1104,18 +1445,18 @@ import { Subject } from '@orkestrel/reason';
  export declare function findManifestOverlaps(source: Brief): readonly string[];
 
  /**
-  * 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 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
@@ -1126,11 +1467,17 @@ import { Subject } from '@orkestrel/reason';
   *
   * @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
   * ```
@@ -1138,30 +1485,30 @@ import { Subject } from '@orkestrel/reason';
  export declare function findUngrantedAuthority(source: Brief): readonly string[];
 
  /**
-  * 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')],
   * 	}),
   * ) // []
   * ```
@@ -1169,7 +1516,7 @@ import { Subject } from '@orkestrel/reason';
  export declare function findUnmetRules(source: Brief): readonly string[];
 
  /**
-  * 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
@@ -1181,10 +1528,10 @@ import { Subject } from '@orkestrel/reason';
   *
   * @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
@@ -1193,7 +1540,7 @@ import { Subject } from '@orkestrel/reason';
  export declare function findUnpairedGaps(source: Brief): readonly Gap[];
 
  /**
-  * 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.
@@ -1209,7 +1556,7 @@ import { Subject } from '@orkestrel/reason';
  export declare function freezeBranch<T>(value: T, seen: WeakSet<object>): T;
 
  /**
-  * 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
@@ -1223,7 +1570,7 @@ import { Subject } from '@orkestrel/reason';
   * 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.
@@ -1239,7 +1586,7 @@ import { Subject } from '@orkestrel/reason';
  export declare function freezeDeep<T>(value: T): T;
 
  /**
-  * One unknown the brief has not resolved.
+  * Represents one unknown the brief has not resolved.
   *
   * @remarks
   * `blocking: true` means no safe default exists and the gate must fail closed. An
@@ -1252,67 +1599,18 @@ import { Subject } from '@orkestrel/reason';
      readonly candidates?: readonly string[];
  }
 
- /**
-  * Build a `Gap`.
-  *
-  * @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.
-  * @returns A fresh `Gap`.
-  *
-  * @example
-  * ```ts
-  * import { gap } from '@orkestrel/brief'
-  *
-  * gap('rules', 'Should validation message wording change?') // blocking: false
-  * gap('output', 'Diff or full files?', { blocking: true, candidates: ['diff', 'code'] })
-  * ```
-  */
- export declare function gap(field: string, question: string, overrides?: Partial<Omit<Gap, 'field' | 'question'>>): Gap;
-
- /** The `Gap` shape — an unknown, whether it blocks, and the candidates that would close it. */
- export declare const gapShape: ObjectShape<{
-     field: StringShape;
-     question: StringShape;
-     blocking: BooleanShape;
-     candidates: OptionalShape<ArrayShape<StringShape>>;
+ /** Describes the `Gap` shape — an unknown, whether it blocks, and the candidates that would close it. */
+ export declare const gapShape: ObjectShape<    {
+ field: StringShape;
+ question: StringShape;
+ blocking: BooleanShape;
+ candidates: OptionalShape<ArrayShape<StringShape>>;
  }, false>;
 
- /** `'gate'` — the id of the `gateDefinition()` logical definition. */
+ /** Holds `'gate'` — the id of the `buildGateDefinition()` logical definition. */
  export declare const GATE_ID = "gate";
 
- /**
-  * Build 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`.
-  *
-  * 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
-  * for a readiness fact overwrites it and `ready` then conjoins a fact no base rule
-  * proved — a refusal silently becomes a pass. Readiness is this package's contract, not
-  * a caller setting. A caller who needs different readiness composes their own
-  * `LogicalDefinition` over `briefToSubject` and evaluates it on their own reasoner; both
-  * are exported for exactly that, and neither can reach this definition.
-  *
-  * @returns A fresh `LogicalDefinition` with id `GATE_ID`.
-  *
-  * @example
-  * ```ts
-  * import { briefToSubject, gateDefinition } from '@orkestrel/brief'
-  * import { createLogicalReasoner, createReason } from '@orkestrel/reason'
-  *
-  * const reason = createReason({ reasoners: [createLogicalReasoner()] })
-  * const verdict = reason.reason(briefToSubject(pinned), gateDefinition())
-  * reason.destroy()
-  * ```
-  */
- export declare function gateDefinition(): LogicalDefinition;
-
- /** The `gate` phase snapshot — the readiness `Subject` in, the reasoner's verdict out. */
+ /** Records the `gate` phase snapshot — the readiness `Subject` in, the reasoner's verdict out. */
  export declare interface GateStageRecord {
      readonly stage: 'gate';
      readonly input: Subject;
@@ -1320,39 +1618,22 @@ import { Subject } from '@orkestrel/reason';
      readonly error?: string;
  }
 
- /** One context fact handed to the executor — a convention, a version, a constraint value. */
+ /** Represents one context fact handed to the executor — a convention, a version, a constraint value. */
  export declare interface Given {
      readonly category: string;
      readonly name: string;
      readonly value: string;
  }
 
- /**
-  * Build a `Given`.
-  *
-  * @param category - The kind of fact — a convention, a version, a constraint.
-  * @param name - The fact's name.
-  * @param value - The fact's value, already rendered as text.
-  * @returns A fresh `Given`.
-  *
-  * @example
-  * ```ts
-  * import { given } from '@orkestrel/brief'
-  *
-  * given('convention', 'indentation', 'tabs')
-  * ```
-  */
- export declare function given(category: string, name: string, value: string): Given;
-
- /** The `Given` shape — one categorized context fact. */
- export declare const givenShape: ObjectShape<{
-     category: StringShape;
-     name: StringShape;
-     value: StringShape;
+ /** Describes the `Given` shape — one categorized context fact. */
+ export declare const givenShape: ObjectShape<    {
+ category: StringShape;
+ name: StringShape;
+ value: StringShape;
  }, false>;
 
  /**
-  * Every published `Interpretation` member name, frozen.
+  * Lists every published `Interpretation` member name, frozen.
   *
   * @remarks
   * The capture list `BriefCompiler` hands `captureValue` at each interpret door — the borrowed
@@ -1365,10 +1646,10 @@ import { Subject } from '@orkestrel/reason';
   * equality assertion beside the capture cases refuse a list that has fallen short of the
   * published shape.
   */
- export declare const INTERPRETATION_MEMBERS: readonly ("text" | "normalized" | "intent" | "entities" | "subject" | "definition" | "mappings" | "ambiguities" | "prompt" | "stages" | "failures" | "complete" | "confidence" | "digest")[];
+ export declare const INTERPRETATION_MEMBERS: readonly ("text" | "normalized" | "intent" | "entities" | "subject" | "definition" | "mappings" | "ambiguities" | "prompt" | "stages" | "failures" | "confidence" | "digest")[];
 
  /**
-  * The `interpret` phase snapshot — raw text in, an `Interpretation` out.
+  * Records the `interpret` phase snapshot — raw text in, an `Interpretation` out.
   *
   * @remarks
   * `output` is absent exactly when `error` is present, which is what makes the phase
@@ -1382,19 +1663,22 @@ import { Subject } from '@orkestrel/reason';
  }
 
  /**
-  * `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.
   */
  export declare const isBrief: Guard<Brief>;
 
  /**
-  * 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
@@ -1409,92 +1693,176 @@ import { Subject } from '@orkestrel/reason';
   */
  export declare function isBriefError(value: unknown): value is BriefError;
 
- /** `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.
+  */
  export declare const isCitation: Guard<Citation>;
 
  /**
-  * `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.
   */
  export declare const isExample: Guard<Example>;
 
- /** `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.
+  */
  export declare const isGap: Guard<Gap>;
 
- /** `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.
+  */
  export declare const isGiven: Guard<Given>;
 
- /** `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.
+  *
+  * @remarks
+  * The shape of nearly every brief field: a path, a note, a statement, a rule, and a command
+  * all narrow through it.
+  *
+  * @param value - The value to inspect.
+  * @returns True if `value` is a non-empty string holding no line terminator; false otherwise.
+  */
  export declare const isLine: Guard<string>;
 
  /**
-  * `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.
   */
  export declare const isManifest: Guard<Manifest>;
 
- /** `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.
+  */
  export declare const isOutcome: Guard<Outcome>;
 
- /** `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.
+  */
  export declare const isOutput: Guard<Output>;
 
- /** `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.
+  */
  export declare const isOutputFormat: Guard<OutputFormat>;
 
- /** `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.
+  */
  export declare const isProof: Guard<Proof>;
 
- /** `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.
+  */
  export declare const isReference: Guard<Reference>;
 
- /** `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.
+  */
  export declare const isRisk: Guard<Risk>;
 
- /** `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.
+  */
  export declare const isRiskSeverity: Guard<RiskSeverity>;
 
- /** `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.
+  */
  export declare const isTask: Guard<Task>;
 
- /** `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.
+  */
  export declare const isTaskDomain: Guard<TaskDomain>;
 
- /** `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.
+  */
  export declare const isTaskOperation: Guard<TaskOperation>;
 
  /**
-  * `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.
   */
  export declare const isText: Guard<string>;
 
  /**
-  * 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 only `\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.
   */
  export declare const LINE_BREAK_PATTERN: RegExp;
 
- /** A non-empty single-line string — the shape mirror of `isLine`. */
+ /** Describes a non-empty single-line string — the shape mirror of `isLine`. */
  export declare const lineShape: StringShape;
 
  /**
-  * The four disjoint file partitions of a brief.
+  * Represents the disjoint file partitions of a brief.
   *
   * @remarks
   * `read` order is the reading order. A path in more than one partition is a
@@ -1508,42 +1876,33 @@ import { Subject } from '@orkestrel/reason';
  }
 
  /**
-  * Build 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.
-  *
-  * @example
-  * ```ts
-  * import { manifest, reference } from '@orkestrel/brief'
+  * Describes the `Manifest` shape — disjoint reference partitions.
   *
-  * manifest({ edit: [reference('src/core/helpers.ts', 'implementation')] })
-  * ```
+  * @remarks
+  * Each partition is an `arrayShape(referenceShape)`; disjointness is `validateBrief`'s pass
+  * rather than the shape's.
   */
- export declare function manifest(partitions?: Partial<Manifest>): Manifest;
-
- /** The `Manifest` shape — four disjoint reference partitions. */
- export declare const manifestShape: ObjectShape<{
-     read: ArrayShape<ObjectShape<{
-         path: StringShape;
-         note: StringShape;
-     }, false>>;
-     edit: ArrayShape<ObjectShape<{
-         path: StringShape;
-         note: StringShape;
-     }, false>>;
-     locked: ArrayShape<ObjectShape<{
-         path: StringShape;
-         note: StringShape;
-     }, false>>;
-     forbidden: ArrayShape<ObjectShape<{
-         path: StringShape;
-         note: StringShape;
-     }, false>>;
+ export declare const manifestShape: ObjectShape<    {
+ read: ArrayShape<ObjectShape<    {
+ path: StringShape;
+ note: StringShape;
+ }, false>>;
+ edit: ArrayShape<ObjectShape<    {
+ path: StringShape;
+ note: StringShape;
+ }, false>>;
+ locked: ArrayShape<ObjectShape<    {
+ path: StringShape;
+ note: StringShape;
+ }, false>>;
+ forbidden: ArrayShape<ObjectShape<    {
+ path: StringShape;
+ note: StringShape;
+ }, false>>;
  }, false>;
 
  /**
-  * One ranked outcome — a result, never a step.
+  * Represents one ranked outcome — a result, never a step.
   *
   * @remarks
   * `required: true` gates "done"; a demoted outcome is desirable but not blocking.
@@ -1555,32 +1914,19 @@ import { Subject } from '@orkestrel/reason';
  }
 
  /**
-  * Build an `Outcome`.
-  *
-  * @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`.
-  * @returns A fresh `Outcome`.
+  * Describes the `Outcome` shape — a one-based rank, the result text, and whether it gates done.
   *
-  * @example
-  * ```ts
-  * import { outcome } from '@orkestrel/brief'
-  *
-  * outcome(1, 'useForm uses native FormData with no behavior change') // required: true
-  * outcome(2, 'the diff stays under 200 lines', false)
-  * ```
+  * @remarks
+  * `rank` is an `integerShape({ min: 1 })`, so a zero or fractional rank is off-contract.
   */
- export declare function outcome(rank: number, text: string, required?: boolean): Outcome;
-
- /** The `Outcome` shape — a one-based rank, the result text, and whether it gates done. */
- export declare const outcomeShape: ObjectShape<{
-     rank: NumberShape;
-     text: StringShape;
-     required: BooleanShape;
+ export declare const outcomeShape: ObjectShape<    {
+ rank: NumberShape;
+ text: StringShape;
+ required: BooleanShape;
  }, false>;
 
  /**
-  * The closed shape of the deliverable.
+  * Represents the closed shape of the deliverable.
   *
   * @remarks
   * `format` is required; `sections` / `include` / `exclude` refine it.
@@ -1592,39 +1938,22 @@ import { Subject } from '@orkestrel/reason';
      readonly exclude?: readonly string[];
  }
 
- /**
-  * Build an `Output`.
-  *
-  * @param format - The closed deliverable format.
-  * @param overrides - Optional `sections` / `include` / `exclude`; absent keys are OMITTED.
-  * @returns A fresh `Output`.
-  *
-  * @example
-  * ```ts
-  * import { output } from '@orkestrel/brief'
-  *
-  * output('markdown') // { format: 'markdown' }
-  * output('diff', { include: ['updated useForm.ts'] })
-  * ```
-  */
- export declare function output(format: OutputFormat, overrides?: Partial<Omit<Output, 'format'>>): Output;
-
- /** The five `OutputFormat` values, frozen. */
+ /** Lists the `OutputFormat` values, frozen. */
  export declare const OUTPUT_FORMATS: readonly OutputFormat[];
 
- /** The closed vocabulary of deliverable shapes. */
+ /** Names the closed vocabulary of deliverable shapes. */
  export declare type OutputFormat = 'markdown' | 'json' | 'code' | 'diff' | 'prose';
 
- /** The `Output` shape — a closed format plus its optional refinements. */
- export declare const outputShape: ObjectShape<{
-     format: LiteralShape<readonly OutputFormat[]>;
-     sections: OptionalShape<ArrayShape<StringShape>>;
-     include: OptionalShape<ArrayShape<StringShape>>;
-     exclude: OptionalShape<ArrayShape<StringShape>>;
+ /** Describes the `Output` shape — a closed format plus its optional refinements. */
+ export declare const outputShape: ObjectShape<    {
+ format: LiteralShape<readonly OutputFormat[]>;
+ sections: OptionalShape<ArrayShape<StringShape>>;
+ include: OptionalShape<ArrayShape<StringShape>>;
+ exclude: OptionalShape<ArrayShape<StringShape>>;
  }, false>;
 
  /**
-  * 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
@@ -1655,7 +1984,7 @@ import { Subject } from '@orkestrel/reason';
  export declare function parseBrief(value: string): Brief | undefined;
 
  /**
-  * 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` /
@@ -1671,16 +2000,16 @@ import { Subject } from '@orkestrel/reason';
       *
       * @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'
       * ```
       */
   export declare function pinBrief(source: Brief): Brief;
 
-  /** The `pin` phase snapshot — the drafted `Brief` in, the pinned `Brief` out. */
+  /** Records the `pin` phase snapshot — the drafted `Brief` in, the pinned `Brief` out. */
   export declare interface PinStageRecord {
       readonly stage: 'pin';
       readonly input: Brief;
@@ -1689,40 +2018,24 @@ import { Subject } from '@orkestrel/reason';
   }
 
   /**
-   * One mechanical, transcript-provable check.
+   * Represents one mechanical, transcript-provable check.
    *
    * @remarks
-   * `command` should carry a clear exit signal — it becomes the `/goal` condition verbatim.
+   * Give `command` a clear exit signal; it becomes the `/goal` condition verbatim.
    */
   export declare interface Proof {
       readonly text: string;
       readonly command: string;
   }
 
-  /**
-   * Build a `Proof`.
-   *
-   * @param text - What the check settles.
-   * @param command - The command whose exit signal settles it.
-   * @returns A fresh `Proof`.
-   *
-   * @example
-   * ```ts
-   * import { proof } from '@orkestrel/brief'
-   *
-   * proof('type-check and lint pass', 'npm run check')
-   * ```
-   */
-  export declare function proof(text: string, command: string): Proof;
-
-  /** The `Proof` shape — the claim and the command that settles it. */
-  export declare const proofShape: ObjectShape<{
-      text: StringShape;
-      command: StringShape;
+  /** Describes the `Proof` shape — the claim and the command that settles it. */
+  export declare const proofShape: ObjectShape<    {
+  text: StringShape;
+  command: StringShape;
   }, false>;
 
   /**
-   * One referenced path and why it is listed.
+   * Represents one referenced path and why it is listed.
    *
    * @remarks
    * The ONE path record. A reference means different things in different containers, and the
@@ -1740,67 +2053,34 @@ import { Subject } from '@orkestrel/reason';
       readonly note: string;
   }
 
-  /**
-   * Build a `Reference`.
-   *
-   * @param path - The referenced path or glob.
-   * @param note - Why the path is listed.
-   * @returns A fresh `Reference`.
-   *
-   * @example
-   * ```ts
-   * import { reference } from '@orkestrel/brief'
-   *
-   * reference('AGENTS.md', 'project law') // { path: 'AGENTS.md', note: 'project law' }
-   * ```
-   */
-  export declare function reference(path: string, note: string): Reference;
-
-  /** The `Reference` shape — a path and the note that justifies listing it. */
-  export declare const referenceShape: ObjectShape<{
-      path: StringShape;
-      note: StringShape;
+  /** Describes the `Reference` shape — a path and the note that justifies listing it. */
+  export declare const referenceShape: ObjectShape<    {
+  path: StringShape;
+  note: StringShape;
   }, false>;
 
-  /** One pre-empted risk and the mitigation that answers it. */
+  /** Represents one pre-empted risk and the mitigation that answers it. */
   export declare interface Risk {
       readonly severity: RiskSeverity;
       readonly text: string;
       readonly mitigation: string;
   }
 
-  /**
-   * Build a `Risk`.
-   *
-   * @param severity - The closed severity.
-   * @param text - What could go wrong.
-   * @param mitigation - What answers it.
-   * @returns A fresh `Risk`.
-   *
-   * @example
-   * ```ts
-   * import { risk } from '@orkestrel/brief'
-   *
-   * risk('medium', 'native validation differs subtly', 'assert message and state in tests')
-   * ```
-   */
-  export declare function risk(severity: RiskSeverity, text: string, mitigation: string): Risk;
-
-  /** The three `RiskSeverity` values, frozen. */
+  /** Lists the `RiskSeverity` values, frozen. */
   export declare const RISK_SEVERITIES: readonly RiskSeverity[];
 
-  /** The closed vocabulary of risk severities. */
+  /** Names the closed vocabulary of risk severities. */
   export declare type RiskSeverity = 'low' | 'medium' | 'high';
 
-  /** The `Risk` shape — a closed severity, the risk, and its mitigation. */
-  export declare const riskShape: ObjectShape<{
-      severity: LiteralShape<readonly RiskSeverity[]>;
-      text: StringShape;
-      mitigation: StringShape;
+  /** Describes the `Risk` shape — a closed severity, the risk, and its mitigation. */
+  export declare const riskShape: ObjectShape<    {
+  severity: LiteralShape<readonly RiskSeverity[]>;
+  text: StringShape;
+  mitigation: StringShape;
   }, false>;
 
   /**
-   * The positive form of {@link LINE_BREAK_PATTERN}, for the shape DSL.
+   * Holds the positive form of {@link LINE_BREAK_PATTERN}, for a `stringShape` `pattern`.
    *
    * @remarks
    * `stringShape`'s `pattern` must MATCH an accepted value, so the guard's refusal regex
@@ -1810,7 +2090,7 @@ import { Subject } from '@orkestrel/reason';
   export declare const SINGLE_LINE_PATTERN: RegExp;
 
   /**
-   * 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
@@ -1834,10 +2114,10 @@ import { Subject } from '@orkestrel/reason';
        *
        * @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
        * ```
@@ -1845,7 +2125,7 @@ import { Subject } from '@orkestrel/reason';
    export declare function snapshotBrief(source: Brief): Brief;
 
    /**
-    * What the brief asks for, in one imperative sentence.
+    * States what the brief asks for, in one imperative sentence.
     *
     * @remarks
     * A compound `statement` is two briefs — `validateBrief` errors on more than one sentence.
@@ -1856,53 +2136,49 @@ import { Subject } from '@orkestrel/reason';
        readonly statement: string;
    }
 
+   /** Lists the `TaskDomain` values, frozen. */
+   export declare const TASK_DOMAINS: readonly TaskDomain[];
+
    /**
-    * Build a `Task`.
-    *
-    * @param operation - What the brief asks for, from the closed operation vocabulary.
-    * @param domain - The subject matter, from the closed domain vocabulary.
-    * @param statement - One imperative sentence naming the object of the work.
-    * @returns A fresh `Task`.
+    * Lists the `TaskOperation` values, frozen.
     *
-    * @example
-    * ```ts
-    * import { task } from '@orkestrel/brief'
-    *
-    * task('refactor', 'code', 'Refactor useForm to native browser form APIs.')
-    * ```
+    * @remarks
+    * Compose the tuple rather than restating its members: `literalOf(TASK_OPERATIONS)` builds the
+    * guard and `parseEnum(value, TASK_OPERATIONS)` coerces a bare value against it.
     */
-   export declare function task(operation: TaskOperation, domain: TaskDomain, statement: string): Task;
-
-   /** The eight `TaskDomain` values, frozen. */
-   export declare const TASK_DOMAINS: readonly TaskDomain[];
-
-   /** The twelve `TaskOperation` values, frozen. */
    export declare const TASK_OPERATIONS: readonly TaskOperation[];
 
-   /** The closed vocabulary of the subject matter a brief operates on. */
+   /** Names the closed vocabulary of the subject matter a brief operates on. */
    export declare type TaskDomain = 'code' | 'writing' | 'research' | 'analysis' | 'design' | 'data' | 'ops' | 'other';
 
    /**
-    * The closed vocabulary of what a brief asks for.
+    * Names the closed vocabulary of what a brief asks for.
     *
     * @remarks
-    * A request that fits none of these twelve is mis-scoped rather than a missing
-    * literal. Compose with `literalOf(TASK_OPERATIONS)` or `parseEnum(value, TASK_OPERATIONS)`.
+    * A request that fits none of these is mis-scoped rather than a missing literal. Compose
+    * with `literalOf(TASK_OPERATIONS)` or `parseEnum(value, TASK_OPERATIONS)`.
     */
    export declare type TaskOperation = 'create' | 'refactor' | 'debug' | 'extract' | 'migrate' | 'explain' | 'review' | 'optimize' | 'audit' | 'test' | 'document' | 'plan';
 
-   /** The `Task` shape — closed operation and domain vocabularies plus a non-empty statement. */
-   export declare const taskShape: ObjectShape<{
-       operation: LiteralShape<readonly TaskOperation[]>;
-       domain: LiteralShape<readonly TaskDomain[]>;
-       statement: StringShape;
+   /**
+    * Describes the `Task` shape — closed operation and domain vocabularies plus a non-empty
+    * statement.
+    *
+    * @remarks
+    * `literalShape(TASK_OPERATIONS)` and `literalShape(TASK_DOMAINS)` compile the same tuples the
+    * guards read, and `statement` carries `min: 1`.
+    */
+   export declare const taskShape: ObjectShape<    {
+   operation: LiteralShape<readonly TaskOperation[]>;
+   domain: LiteralShape<readonly TaskDomain[]>;
+   statement: StringShape;
    }, false>;
 
-   /** A single-line string of any length, including empty. */
+   /** Describes a single-line string of any length, including empty — the shape mirror of `isText`. */
    export declare const textShape: StringShape;
 
    /**
-    * 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
@@ -1916,11 +2192,11 @@ import { Subject } from '@orkestrel/reason';
     *
     * @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
     * ```
     */