@orkestrel/brief 0.0.6 → 0.0.7

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

@@ -13,20 +13,20 @@ import { 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 { 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 { RecordOptions } from '@orkestrel/interpret';
 import { StringShape } from '@orkestrel/contract';
 import { 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,19 +129,19 @@ 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. */
  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 {
      readonly emitter: EmitterInterface<BriefCompilerEventMap>;
      readonly interpret: InterpretInterface;
@@ -173,7 +152,7 @@ import { Subject } from '@orkestrel/reason';
  }
 
  /**
-  * Input to `createBriefCompiler`.
+  * Represents the input to `createBriefCompiler`.
   *
   * @remarks
   * `interpret` and `reason` are BORROWED when supplied — the compiler destroys only
@@ -221,7 +200,7 @@ import { Subject } from '@orkestrel/reason';
  }
 
  /**
-  * The one error class this package throws.
+  * Represents the one error class this package throws.
   *
   * @remarks
   * Throws are reserved for caller misuse: `assertBrief`, `snapshotBrief`, and `pinBrief` on
@@ -247,26 +226,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
@@ -295,14 +274,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 +307,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 +317,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 +329,54 @@ 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. */
  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 {
      readonly emitter: EmitterInterface<BriefManagerEventMap>;
-     readonly size: number;
+     readonly count: number;
      has(id: string): boolean;
      brief(id: string): BriefRecord | undefined;
      briefs(): readonly BriefRecord[];
-     add(brief: Brief, options?: ManagerAddOptions): BriefRecord;
+     add(brief: Brief, options?: RecordOptions): BriefRecord;
      remove(ids: readonly string[]): boolean;
      remove(id: string): boolean;
      remove(): void;
      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,7 +385,7 @@ 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
@@ -487,10 +467,10 @@ import { Subject } from '@orkestrel/reason';
      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 +478,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 +487,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 +499,42 @@ 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.
   *
   * `authority` is exactly `brief.authority` in rank order, and it is a SEPARATE axis from the
-  * four permission sets rather than a fifth partition — a ranked path normally also appears in
+  * permission sets rather than a further partition — a ranked path normally also appears in
   * `read` or `locked`, because the executor has to open what it obeys. It is projected as
   * paths so a machine consumer never has to parse `prompt`, which is written for a model.
   *
-  * @param source - The brief to project.
-  * @returns The dispatch — the rendered prompt, the ranked authority, and the four path sets.
+  * @param input - The brief to project.
+  * @returns The dispatch — the rendered prompt, the ranked authority, and the path sets.
   *
   * @example
   * ```ts
-  * import { brief, briefToDispatch, manifest, reference, task } from '@orkestrel/brief'
-  *
-  * const draft = brief(task('migrate', 'code', 'Migrate the stores.'), {
-  * 	authority: [reference('AGENTS.md', 'project law')],
-  * 	manifest: manifest({ edit: [reference('src/core/stores/**', 'the legacy stores')] }),
+  * import {
+  * 	briefToDispatch,
+  * 	buildBrief,
+  * 	buildManifest,
+  * 	buildReference,
+  * 	buildTask,
+  * } from '@orkestrel/brief'
+  *
+  * const draft = buildBrief(buildTask('migrate', 'code', 'Migrate the stores.'), {
+  * 	authority: [buildReference('AGENTS.md', 'project law')],
+  * 	manifest: buildManifest({ edit: [buildReference('src/core/stores/**', 'the legacy stores')] }),
   * })
   * briefToDispatch(draft).edit // ['src/core/stores/**']
   * briefToDispatch(draft).authority // ['AGENTS.md']
@@ -557,28 +543,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 +576,52 @@ 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.
   *
-  * @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 +634,256 @@ 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.
+  *
+  * @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 +911,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 +931,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,28 +945,7 @@ 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. */
+ /** Describes the `Citation` shape — a name, a locator, and why the source is cited. */
  export declare const citationShape: ObjectShape<{
      name: StringShape;
      url: StringShape;
@@ -745,7 +953,7 @@ import { Subject } from '@orkestrel/reason';
  }, 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 +986,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,7 +994,8 @@ 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
@@ -800,7 +1009,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 +1032,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 +1042,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 +1058,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 +1079,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 +1100,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 +1149,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 +1180,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 +1189,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 +1198,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,31 +1218,14 @@ 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 highest-leverage ambiguity remover. */
  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. */
+ /** Describes the `Example` shape — one input to output exemplar. */
  export declare const exampleShape: ObjectShape<{
      input: StringShape;
      output: StringShape;
@@ -1037,7 +1233,7 @@ import { Subject } from '@orkestrel/reason';
  }, 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 +1245,25 @@ 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.
   *
   * @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 +1271,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 +1286,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 +1306,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 simply never says the executor may open what it must obey.
   *
   * Paths are compared as EXACT strings, matching `findManifestOverlaps`. A glob is never
   * expanded, so `read: 'guides/**'` does not grant `authority: 'guides/brief.md'`. State a
@@ -1126,11 +1328,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 +1346,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 +1377,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 +1389,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 +1401,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 +1417,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 +1431,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 +1447,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,26 +1460,7 @@ 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. */
+ /** 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;
@@ -1279,40 +1468,10 @@ import { Subject } from '@orkestrel/reason';
      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,31 +1479,14 @@ 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. */
+ /** Describes the `Given` shape — one categorized context fact. */
  export declare const givenShape: ObjectShape<{
      category: StringShape;
      name: StringShape;
@@ -1352,7 +1494,7 @@ import { Subject } from '@orkestrel/reason';
  }, 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 +1507,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 +1524,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 +1554,172 @@ 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.
+  *
+  * @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 just `\n`: a renderer that splits on any of them
+  * would let the others forge a markdown row. CRLF leads the alternation so a Windows
+  * exemplar splits as ONE break rather than two, which would insert a blank line the caller
+  * never wrote. Kept unanchored and stateless — no `g` flag — so `test` never carries
   * `lastIndex` between calls.
   */
  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
@@ -1507,22 +1732,7 @@ import { Subject } from '@orkestrel/reason';
      readonly forbidden: readonly Reference[];
  }
 
- /**
-  * 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'
-  *
-  * manifest({ edit: [reference('src/core/helpers.ts', 'implementation')] })
-  * ```
-  */
- export declare function manifest(partitions?: Partial<Manifest>): Manifest;
-
- /** The `Manifest` shape — four disjoint reference partitions. */
+ /** Describes the `Manifest` shape — disjoint reference partitions. */
  export declare const manifestShape: ObjectShape<{
      read: ArrayShape<ObjectShape<{
          path: StringShape;
@@ -1543,7 +1753,7 @@ import { Subject } from '@orkestrel/reason';
  }, 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.
@@ -1554,25 +1764,7 @@ import { Subject } from '@orkestrel/reason';
      readonly required: boolean;
  }
 
- /**
-  * 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`.
-  *
-  * @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)
-  * ```
-  */
- 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. */
+ /** Describes the `Outcome` shape — a one-based rank, the result text, and whether it gates done. */
  export declare const outcomeShape: ObjectShape<{
      rank: NumberShape;
      text: StringShape;
@@ -1580,7 +1772,7 @@ import { Subject } from '@orkestrel/reason';
  }, false>;
 
  /**
-  * The closed shape of the deliverable.
+  * Represents the closed shape of the deliverable.
   *
   * @remarks
   * `format` is required; `sections` / `include` / `exclude` refine it.
@@ -1592,30 +1784,13 @@ 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. */
+ /** Describes the `Output` shape — a closed format plus its optional refinements. */
  export declare const outputShape: ObjectShape<{
      format: LiteralShape<readonly OutputFormat[]>;
      sections: OptionalShape<ArrayShape<StringShape>>;
@@ -1624,7 +1799,7 @@ import { Subject } from '@orkestrel/reason';
  }, 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 +1830,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 +1846,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 +1864,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. */
+  /** 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,59 +1899,26 @@ 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. */
+  /** 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. */
+  /** Describes the `Risk` shape — a closed severity, the risk, and its mitigation. */
   export declare const riskShape: ObjectShape<{
       severity: LiteralShape<readonly RiskSeverity[]>;
       text: StringShape;
@@ -1800,7 +1926,7 @@ import { Subject } from '@orkestrel/reason';
   }, false>;
 
   /**
-   * The positive form of {@link LINE_BREAK_PATTERN}, for the shape DSL.
+   * Holds the positive form of {@link LINE_BREAK_PATTERN}, for the shape DSL.
    *
    * @remarks
    * `stringShape`'s `pattern` must MATCH an accepted value, so the guard's refusal regex
@@ -1810,7 +1936,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 +1960,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 +1971,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 +1982,36 @@ import { Subject } from '@orkestrel/reason';
        readonly statement: string;
    }
 
-   /**
-    * 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`.
-    *
-    * @example
-    * ```ts
-    * import { task } from '@orkestrel/brief'
-    *
-    * task('refactor', 'code', 'Refactor useForm to native browser form APIs.')
-    * ```
-    */
-   export declare function task(operation: TaskOperation, domain: TaskDomain, statement: string): Task;
-
-   /** The eight `TaskDomain` values, frozen. */
+   /** Lists the `TaskDomain` values, frozen. */
    export declare const TASK_DOMAINS: readonly TaskDomain[];
 
-   /** The twelve `TaskOperation` values, frozen. */
+   /** Lists the `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. */
+   /** Describes 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;
    }, false>;
 
-   /** A single-line string of any length, including empty. */
+   /** Describes a single-line string of any length, including empty. */
    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 +2025,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
     * ```
     */