@orkestrel/study 0.0.0-stage → 0.0.1

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

@@ -0,0 +1,2635 @@
+import type { ChildProcess } from 'node:child_process';
+import type { Dir } from 'node:fs';
+import type { Dirent } from 'node:fs';
+import type { estimateRequest } from '@orkestrel/agent';
+import type { extractTiming } from '@orkestrel/ollama';
+import type { FileHandle } from 'node:fs/promises';
+import type { isAgentError } from '@orkestrel/agent';
+import type { JSONValue } from '@orkestrel/contract';
+import type { LedgerGauge } from '@orkestrel/agent';
+import type { LoadFnOutput } from 'node:module';
+import type { LoadHookContext } from 'node:module';
+import type { LoadHookSync } from 'node:module';
+import type { measureRequest } from '@orkestrel/agent';
+import type { Message } from '@orkestrel/agent';
+import type { OllamaOptions } from '@orkestrel/ollama';
+import type { OllamaTiming } from '@orkestrel/ollama';
+import type { ProviderDelta } from '@orkestrel/agent';
+import type { ProviderInterface } from '@orkestrel/agent';
+import type { ProviderRequest } from '@orkestrel/agent';
+import type { ProviderResult } from '@orkestrel/agent';
+import type { ResolveFnOutput } from 'node:module';
+import type { ResolveHookContext } from 'node:module';
+import type { ResolveHookSync } from 'node:module';
+
+/** Bounds all captured input bytes to 128 MiB. */
+export declare const ARTIFACT_BYTES: number;
+
+/** Bounds directory nesting below each selected root. */
+export declare const ARTIFACT_DEPTH = 64;
+
+/** Bounds one captured input file to 16 MiB. */
+export declare const ARTIFACT_FILE_BYTES: number;
+
+/** Bounds admitted files before another capture is allocated. */
+export declare const ARTIFACT_FILES = 8192;
+
+/** Bounds selected package roots before traversal begins. */
+export declare const ARTIFACT_ROOTS = 128;
+
+/** Bounds all visited directory entries, including ignored assets. */
+export declare const ARTIFACT_VISITS = 32768;
+
+/** Reports an invalid or drifted artifact inventory. */
+export declare class ArtifactError extends Error {
+    readonly code: "ARTIFACT";
+    /** Records the refused artifact boundary.
+     * @param message - The specific refusal.
+     */
+    constructor(message: string);
+}
+
+/** Records the exact bytes admitted at one absolute file path. */
+export declare interface ArtifactFile {
+    readonly path: string;
+    readonly digest: string;
+    readonly size: number;
+}
+
+/** Supplies the private namespace and separate source selection to resolution. */
+export declare interface ArtifactHookInput {
+    readonly token: string;
+    readonly files: readonly ArtifactSource[];
+    readonly source?: ArtifactSourceOptions;
+    readonly instrument?: string;
+    readonly excluded?: readonly string[];
+}
+
+/** Records all admitted module bytes, selections, and native runtime identity. */
+export declare interface ArtifactInventory {
+    readonly digest: string;
+    readonly node: string;
+    readonly runtime: ArtifactRuntime;
+    readonly entries: readonly string[];
+    readonly packages: readonly ArtifactPackage[];
+    readonly source?: ArtifactSourceOptions;
+    readonly instrument?: string;
+    readonly files: readonly ArtifactFile[];
+}
+
+/** Captures built ESM and a separate strip-only consumer adapter in a fresh worker.
+ * @remarks
+ * Loads trusted code, not a hostile-code sandbox. Native process APIs, eval and external
+ * services are not replayed. One inventory may load per process; terminate it afterwards.
+ */
+export declare class ArtifactLoader {
+    #private;
+    /** Captures selections without reading or executing selected modules.
+     * @param options - Canonical built selections and optional consumer source selection.
+     */
+    constructor(options: ArtifactLoaderOptions);
+    /** Reads and identifies admitted files without evaluating selected modules.
+     * @returns Frozen evidence identifying all captured bytes and the native runtime.
+     * @throws Thrown for invalid selections, unsupported TypeScript, limits, or drift.
+     */
+    inspect(): ArtifactInventory;
+    /** Refuses byte and population drift since inspection.
+     * @throws Thrown when any admitted file or the admitted population changes.
+     */
+    verify(): void;
+    /** Imports one selected entry through synchronous captured-byte hooks.
+     * @param entry - The exact canonical built entry or selected source adapter entry.
+     * @returns The actual module namespace for the caller to narrow.
+     * @throws Thrown for drift, unsupported edges, evaluation failures, or a reused worker.
+     */
+    load(entry: string): Promise<unknown>;
+}
+
+/** Selects built packages and an optional separate consumer source graph. */
+export declare interface ArtifactLoaderOptions {
+    readonly entries: readonly string[];
+    readonly roots: readonly string[];
+    readonly source?: ArtifactSourceOptions;
+    /** Selects one already admitted trusted instrument package permitted to import loader builtins. */
+    readonly instrument?: string;
+    /** Refuses these built files at every import edge; the inventory identity is unchanged. */
+    readonly excluded?: readonly string[];
+}
+
+/** Names Node's synchronous loading continuation. */
+export declare type ArtifactLoadHandler = Parameters<LoadHookSync>[2];
+
+/** Records the identity declared by an admitted package manifest. */
+export declare interface ArtifactPackage {
+    readonly root: string;
+    readonly name: string;
+    readonly version: string;
+}
+
+/** Names Node's synchronous resolution continuation. */
+export declare type ArtifactResolveHandler = Parameters<ResolveHookSync>[2];
+
+/** Binds native conditions and host-sensitive builtin behavior to the inventory. */
+export declare interface ArtifactRuntime {
+    readonly arguments: readonly string[];
+    readonly platform: string;
+    readonly architecture: string;
+    readonly options?: string;
+}
+
+/** Retains captured bytes for the native loader. */
+export declare interface ArtifactSource extends ArtifactFile {
+    readonly source: Uint8Array;
+}
+
+/** Selects a consumer-owned executable source directory and its exact adapter entry.
+ * @remarks Source JSON assets are not admitted; parsed fixtures and rubrics retain separate identities.
+ */
+export declare interface ArtifactSourceOptions {
+    readonly root: string;
+    readonly entry: string;
+}
+
+/** Counts the directory entries visited and the file bytes admitted so far in one capture. */
+export declare interface ArtifactTally {
+    readonly visits: number;
+    readonly bytes: number;
+}
+
+/**
+ * Builds the JSON evidence form of a Ledger result's logical classifier readings.
+ * @param result - Value returned by the Ledger
+ * @returns Null when the result carries no readings array, else one entry per well-formed reading in asking order, each with its duration or null
+ */
+export declare function buildStudyAgentReadings(result: unknown): JSONValue;
+
+/**
+ * Builds a request revision by hashing its canonical rendering exactly as rendered.
+ * @remarks
+ * The request is rendered once with key-sorted canonical JSON and hashed as rendered; no
+ * newline or JSON round trip is added. Any change to content, order, ids, tools, or options
+ * changes the revision.
+ * @param request - The exact pre-encoding request
+ * @returns The lowercase SHA-256 digest, or undefined when the request cannot be canonically rendered; a rendering failure never throws
+ */
+export declare function buildStudyAgentRevision(request: ProviderRequest): string | undefined;
+
+/**
+ * Declares the pinned serving identities the Ollama transport verifies, keyed by the label their inventory evidence carries.
+ * @param provider - Declared serving identities
+ * @returns The model pin, plus the judge pin when the provider declares both the judge name and its digest
+ */
+export declare function buildStudyOllamaModels(provider: StudyProvider): StudyOllamaTransportOptions['models'];
+
+/**
+ * Builds the provider options one role's declared wire policy determines.
+ * @remarks
+ * The policy's `options` object keeps its identity and key order. A strict policy adds `truncate`
+ * and `shift` as `false`; any other policy omits both keys. The `length` allowance is read by the
+ * transport and projects nothing.
+ * @param policy - The role's declared wire policy
+ * @returns The model, think flag, options object, and the strict native fields when declared
+ */
+export declare function buildStudyOllamaOptions(policy: StudyOllamaPolicy): StudyOllamaOptions;
+
+/**
+ * Builds a reading of the raw prompt text an encoded request body carries, as sent.
+ * @param body - The encoded request body
+ * @returns The prompt's UTF-16 code units and UTF-8 bytes, labeled with its encoding, or undefined when there is no string prompt; these are readings of the actual text, not token allocations
+ */
+export declare function buildStudyOllamaRaw(body: unknown): JSONValue | undefined;
+
+/**
+ * Builds an owned snapshot of one outbound request before anything is awaited.
+ * @remarks
+ * The URL spelling, accepted settings, headers, and dispatch are copied at the call, each caller
+ * member read once; headers are cloned from the copied settings. The settings' `signal` keeps its
+ * live identity so caller cancellation still reaches the request.
+ * @param input - The requested URL
+ * @param init - The native fetch settings
+ * @param dispatch - The canonical dispatch the caller measured
+ * @returns The owned request facts
+ * @throws StudyError - Thrown with code `CONFIG` when the input is a `Request`
+ */
+export declare function buildStudyOllamaSnapshot(input: string | URL | Request, init: RequestInit | undefined, dispatch: StudyAgentDispatch | undefined): StudyOllamaSnapshot;
+
+/**
+ * Builds the JSON evidence form of a timing observation with raw nanoseconds and counts.
+ * @param timing - The extracted timing
+ * @returns Null when no terminal timing was observed; otherwise every unreported member as null
+ */
+export declare function buildStudyOllamaTiming(timing: OllamaTiming | undefined): JSONValue;
+
+/**
+ * Builds a frozen owned copy of transport configuration that later caller mutation cannot reach.
+ * @remarks
+ * Every caller member is read once, outer fields before nested data. Every nested data object is
+ * copied and frozen; the caller's objects are never frozen. The cancellation signal and timing
+ * extractor keep their live identity.
+ * @param options - The caller's transport configuration
+ * @returns The owned configuration, not yet validated
+ */
+export declare function buildStudyOllamaTransportOptions(options: StudyOllamaTransportOptions): StudyOllamaTransportOptions;
+
+/**
+ * Builds deterministic public semantic inputs and a separately retained private map.
+ * @param result - The verified sealed execution
+ * @param rubric - The compatible semantic criterion declaration
+ * @param digest - The exact imported rubric-byte identity
+ * @returns The packet bundle, or undefined for a purely mechanical rubric
+ * @throws StudyError - Thrown when a semantic pair has no declared input or terminal record
+ * @example
+ * ```ts
+ * buildStudyPacket(result, rubric, rubricDigest)
+ * ```
+ */
+export declare function buildStudyPacket(result: StudySealedResult, rubric: StudyRubric, digest: string): StudyPacketBundle | undefined;
+
+/**
+ * Builds neutral semantic identities for the complete eligible sealed horizon.
+ * @param result - The verified sealed execution
+ * @param rubric - The compatible independently held rubric
+ * @returns Deterministically sorted neutral mappings
+ * @example
+ * ```ts
+ * buildStudyPacketLinks(result, rubric)
+ * ```
+ */
+export declare function buildStudyPacketLinks(result: StudySealedResult, rubric: StudyRubric): readonly StudyPacketLink[];
+
+/**
+ * Renders a citation of one retained trial file or evidence row.
+ * @param target - The declared pair whose retained observations the citation must name
+ * @param reference - The attempt file, the evidence file, or one zero-based evidence row
+ * @returns The retained path, with a one-based row position for an evidence row
+ * @throws StudyError - Thrown when the trial was not retained, or the citation names a row that does not exist or a row of the attempt file
+ * @example Cite a retained evidence row
+ * ```ts
+ * import type { StudyGradeTarget } from '@orkestrel/study/server'
+ * import { buildStudyReference } from '@orkestrel/study/server'
+ *
+ * declare const target: StudyGradeTarget
+ *
+ * buildStudyReference(target, { file: 'evidence', row: 0 }) // 'trials/r1-s1-a1/evidence.jsonl#1'
+ * ```
+ */
+export declare function buildStudyReference(target: StudyGradeTarget, reference: StudyReference): string;
+
+/**
+ * Refuses symbolic links and non-directory ancestors before custody operations.
+ * @param directory - The absolute or relative directory
+ * @returns The resolved checked directory
+ * @throws StudyError - Thrown when any ancestor is linked or is not a directory
+ * @example
+ * ```ts
+ * await checkStudyDirectory(directory)
+ * ```
+ */
+export declare function checkStudyDirectory(directory: string): Promise<string>;
+
+/** Collects a directory and each of its ancestors up to the filesystem root, nearest first.
+ * @param directory - The absolute directory to start from.
+ * @returns The directory followed by every parent directory, ending at the root.
+ */
+export declare function collectStudyAncestors(directory: string): readonly string[];
+
+/** Collects the executable entries a profile selects, each canonical path once.
+ * @param profile - The resolved execution profile.
+ * @returns The agent, subject, and provider entries without repeating a shared entry.
+ * @remarks The declared roles stay separate in the profile; only capture and loading deduplicate.
+ */
+export declare function collectStudyEntries(profile: StudyProfile): readonly string[];
+
+/**
+ * Reads sealed evidence bytes through custody checks without loading executable code.
+ * @param result - The independently verified sealed execution
+ * @returns Evidence records keyed by scheduled trial identity
+ * @throws StudyError - Thrown when evidence drifts, becomes partial, or fails validation
+ * @example
+ * ```ts
+ * await collectStudyEvidence(result)
+ * ```
+ */
+export declare function collectStudyEvidence(result: StudySealedResult): Promise<Readonly<Record<string, readonly StudyEvidence[]>>>;
+
+/**
+ * Groups failed records by cause, role, and layer, each group carrying its source readings.
+ * @remarks
+ * A group exists for each cause, role, and layer that holds at least one record. Groups follow
+ * `STUDY_CAUSES`, then `STUDY_ROLES` with an absent role last, then `STUDY_LAYERS` with an absent
+ * layer last. `role` and `layer` are null when absent. `executed` and `unexecuted` partition the
+ * group by each record's own execution fact. `readings` lists every record of the group that carries
+ * a stop, in source order, with `trial`, `goal` at the goal level only, `id`, `max`, and `consumed`
+ * (null when the source reported none). A failure sealed before the `stop` member existed groups with
+ * a null layer and no reading; the helper infers no layer from a message.
+ * @param sources - The failed records, in source order
+ * @returns The JSON groups
+ * @example
+ * ```ts
+ * computeStudyAttributions([{ trial: 'r1-s1-a1', goal: undefined, failure, executed: true }])
+ * ```
+ */
+export declare function computeStudyAttributions(sources: readonly StudyAttributionSource[]): JSONValue;
+
+/**
+ * Computes the native supervisor's exact validated execution fingerprint.
+ * @param identity - The reproducible executable identities
+ * @param bounds - The validated nested execution limits
+ * @param definition - The optional full declaration binding supervisor check to execute
+ * @returns The fingerprint that execute must compare before any writes or child work
+ * @example
+ * ```ts
+ * computeStudyCommandFingerprint(identity, bounds)
+ * ```
+ */
+export declare function computeStudyCommandFingerprint(identity: StudyIdentity, bounds: StudyBounds, definition?: StudyDefinition): string;
+
+/**
+ * Computes public fixture identity from execution policy and exact scenario bytes.
+ * @param definition - The complete retained study declaration
+ * @param scenarios - The exact public scenario artifact identities
+ * @returns The digest shared by compatible capacity and memory executions
+ * @example
+ * ```ts
+ * computeStudyFixtureDigest(definition, scenarios)
+ * ```
+ */
+export declare function computeStudyFixtureDigest(definition: StudyDefinition, scenarios: readonly StudyCommandArtifact[]): string;
+
+/** Computes the instrument identity binding trusted runtime bytes to the adapter inventory.
+ * @param entry - The SHA-256 identity of the trusted runtime entry bytes.
+ * @param inventory - The captured adapter inventory digest.
+ * @returns The identity that validation, grading, and trial children must share.
+ */
+export declare function computeStudyInstrumentDigest(entry: string, inventory: string): string;
+
+/**
+ * Computes a bundle identity binding exact public packet and private map bytes.
+ * @param packet - The immutable grading packet bundle
+ * @returns The exact bundle digest
+ * @example
+ * ```ts
+ * computeStudyPacketDigest(packet)
+ * ```
+ */
+export declare function computeStudyPacketDigest(packet: StudyPacketBundle): string;
+
+/**
+ * Partitions records by their explicit execution fact without inferring any.
+ * @param records - The attempts, observations, or attribution sources to partition
+ * @returns Counts of executed and unexecuted records, which sum to the record count
+ * @example
+ * ```ts
+ * computeStudyPartition(attempts) // { executed: 2, unexecuted: 1 }
+ * ```
+ */
+export declare function computeStudyPartition(records: ReadonlyArray<StudyAttempt | StudyObservation | StudyAttributionSource>): Readonly<Record<'executed' | 'unexecuted', number>>;
+
+/** Binds the canonical fully resolved execution profile carried over IPC.
+ * @param profile - The resolved execution settings, with optional absent leaves.
+ * @returns The SHA256 digest of the canonical JSON wire representation.
+ */
+export declare function computeStudyProfileDigest(profile: StudyProfile): string;
+
+/**
+ * Computes whole-horizon results with operational costs and repetitions kept distinct.
+ * @param result - The verified complete execution
+ * @param rubric - The retained compatible rubric
+ * @param grading - The independently verified selected grading
+ * @returns The JSON report without pooling identities or inventing absent measurements
+ * @remarks
+ * Operations count affected trial and goal records, not independent failure events, and the
+ * trial and goal counts overlap and are never added. Completion is operational: a goal is
+ * completed when it holds a non-partial product and no failure, and a trial when it holds no
+ * failure and every goal completed. It is neither task success nor a qualification gate.
+ * @example
+ * ```ts
+ * computeStudyReport(result, rubric, grading)
+ * ```
+ */
+export declare function computeStudyReport(result: StudySealedResult, rubric: StudyRubric, grading: StudyGrading): JSONValue;
+
+/**
+ * Computes an execution seal identity from its exact sorted inventory.
+ * @param result - The manifest result identity
+ * @param files - The sorted inventory
+ * @returns The deterministic seal digest
+ * @example
+ * ```ts
+ * computeStudySealId('execution', files)
+ * ```
+ */
+export declare function computeStudySealId(result: string, files: readonly StudyFile[]): string;
+
+/** Checks strict lexical containment under a selected directory.
+ * @param root - The canonical directory.
+ * @param path - The candidate absolute file.
+ * @returns True if the file is below the directory; false otherwise.
+ */
+export declare function containsArtifact(root: string, path: string): boolean;
+
+/** Creates attributable protocol infrastructure failure.
+ * @param message - The refused operation or broken boundary.
+ * @returns A domain failure that never awards task credit.
+ */
+export declare function createStudyProcessFailure(message: string): StudyFailure;
+
+/**
+ * Decodes strict UTF-8 custody bytes and parses their JSON text.
+ * @param bytes - The exact retained bytes
+ * @returns The parsed value, or undefined when the text is not JSON
+ * @throws TypeError - Thrown when the bytes are not valid UTF-8
+ * @example
+ * ```ts
+ * decodeStudyJSON(new TextEncoder().encode('{"id":1}')) // { id: 1 }
+ * ```
+ */
+export declare function decodeStudyJSON(bytes: Uint8Array): unknown;
+
+/** Releases inherited output handles a bounded time after native exit.
+ * @param child - A newly spawned child, subscribed before native exit.
+ * @remarks A descendant that outlives an exited root is outside discoverable-tree cleanup; this only stops the parent from waiting on its pipes.
+ */
+export declare function drainStudyChild(child: ChildProcess): void;
+
+/**
+ * Encodes deterministic JSON bytes without synthesizing execution metadata.
+ * @param value - The validated record
+ * @returns The exact canonical UTF-8 bytes
+ * @throws StudyError - Thrown when the record cannot be serialized
+ * @example Encode custody bytes
+ * ```ts
+ * import { encodeStudyJSON } from '@orkestrel/study/server'
+ *
+ * encodeStudyJSON({ id: 1 })
+ * ```
+ */
+export declare function encodeStudyJSON(value: unknown): Uint8Array;
+
+/**
+ * Grades every declared trial and criterion pair through the consumer's predicate.
+ * @param input - The sealed declaration, retained attempts, retained evidence, and independent rubric
+ * @param grade - The consumer's domain predicate; it supplies each verdict, method, reason, and citation
+ * @returns One judgment for each declared pair, in schedule then rubric order, with one-based evidence references
+ * @remarks
+ * The traversal validates its input at this boundary, so a direct call retains the checks the
+ * host also makes. A trial without a retained attempt still receives a judgment: the predicate
+ * sees no attempt and no evidence, and missing evidence stays whatever verdict the consumer
+ * reads from it. The traversal never decides success, and it cites nothing the retained
+ * evidence cannot back.
+ * @throws StudyError - Thrown when the rubric, declaration, attempts, or evidence are invalid or foreign, when a criterion names an undeclared goal, or when a reading is not a valid judgment
+ * @example Grade retained evidence with a consumer predicate
+ * ```ts
+ * import type { StudyAdjudication, StudyGradeFunction } from '@orkestrel/study/server'
+ * import { gradeStudyEvidence } from '@orkestrel/study/server'
+ *
+ * declare const input: StudyAdjudication
+ * declare const grade: StudyGradeFunction
+ *
+ * gradeStudyEvidence(input, grade)
+ * ```
+ */
+export declare function gradeStudyEvidence(input: StudyAdjudication, grade: StudyGradeFunction): readonly StudyJudgment[];
+
+/**
+ * Computes the lowercase SHA-256 identity of exact bytes or UTF-8 text.
+ * @param input - The retained bytes, or text identified by its UTF-8 bytes
+ * @returns The lowercase hexadecimal digest
+ * @example Identify captured bytes
+ * ```ts
+ * import { hashStudyBytes } from '@orkestrel/study/server'
+ *
+ * hashStudyBytes('retained evidence')
+ * ```
+ */
+export declare function hashStudyBytes(input: string | Uint8Array): string;
+
+/** Narrows a caught value to an artifact refusal.
+ * @param value - The caught value.
+ * @returns True if the value is an artifact error; false otherwise.
+ */
+export declare function isArtifactError(value: unknown): value is ArtifactError;
+
+/** Checks whether a factory returned the complete consumer adapter contract.
+ * @param value - The unknown factory result.
+ * @returns True if validation, construction, and grading are callable; false otherwise.
+ * @example Refuse an incomplete adapter
+ * ```ts
+ * import { isStudyAdapter } from '@orkestrel/study/server'
+ *
+ * isStudyAdapter({}) // false
+ * ```
+ */
+export declare function isStudyAdapter(value: unknown): value is StudyAdapterInterface;
+
+/**
+ * Checks whether a scripted response has JSON calls and workload controls.
+ * @remarks
+ * The guard accepts exact own data keys: `content` and `calls` are required; `consume`, `abort`,
+ * `tokens`, `bytes` and `truncated` are optional. Each call must satisfy the Tool package's call
+ * guard and carry JSON arguments. The guard sets no size limit on content, calls or `consume`; a
+ * consumer composes its own workload bounds. A throwing accessor returns false.
+ * @param value - The candidate response
+ * @returns True if every declared response member is valid; false otherwise
+ * @example
+ * ```ts
+ * isStudyAgentResponse({ content: 'done', calls: [] }) // true
+ * ```
+ */
+export declare function isStudyAgentResponse(value: unknown): value is StudyAgentResponse;
+
+/** Checks a request's declared role and finite cost ceilings.
+ * @param value - Decoded charge.
+ * @returns True if all charge leaves are valid; false otherwise.
+ */
+export declare function isStudyCharge(value: unknown): value is StudyCharge;
+
+/**
+ * Checks whether an attempt terminally accounts for the exact scheduled goal horizon.
+ * @param value - The candidate attempt
+ * @param manifest - The authoritative declaration
+ * @returns True if the terminal record is compatible and its execution facts are consistent; false otherwise
+ * @remarks
+ * Executed goals form a prefix of the horizon and an executed goal with a failure ends it.
+ * An unexecuted attempt holds only unexecuted goals, and an attempt without a failure holds only
+ * executed goals that did not fail.
+ * @example
+ * ```ts
+ * isStudyCustodyAttempt({}, manifest) // false
+ * ```
+ */
+export declare function isStudyCustodyAttempt(value: unknown, manifest: StudyManifest): value is StudyAttempt;
+
+/**
+ * Checks whether evidence is exact JSON with a declared event and goal name.
+ * @param value - The candidate evidence
+ * @returns True if evidence is valid; false otherwise
+ * @example
+ * ```ts
+ * isStudyCustodyEvidence({ event: 'saved', goal: 'write', value: true }) // true
+ * ```
+ */
+export declare function isStudyCustodyEvidence(value: unknown): value is StudyEvidence;
+
+/**
+ * Checks whether a failure carries exact attributable operational fields.
+ * @remarks
+ * `role` and `stop` are optional keys. A `stop` is valid only on a `capacity` or `deadline` failure,
+ * and it must satisfy `isStudyStop`; a failure sealed before the `stop` member existed has no key.
+ * @param value - The candidate failure
+ * @returns True if the failure is valid; false otherwise
+ * @example
+ * ```ts
+ * isStudyCustodyFailure({}) // false
+ * ```
+ */
+export declare function isStudyCustodyFailure(value: unknown): value is StudyFailure;
+
+/**
+ * Checks whether an execution file inventory entry is path-safe and bounded.
+ * @param value - The candidate entry
+ * @returns True if the entry is valid; false otherwise
+ * @example
+ * ```ts
+ * isStudyCustodyFile({}) // false
+ * ```
+ */
+export declare function isStudyCustodyFile(value: unknown): value is StudyFile;
+
+/**
+ * Checks whether a manifest exactly binds its declared population and identities.
+ * @param value - The candidate manifest
+ * @returns True if the manifest is valid; false otherwise
+ * @example
+ * ```ts
+ * isStudyCustodyManifest({}) // false
+ * ```
+ */
+export declare function isStudyCustodyManifest(value: unknown): value is StudyManifest;
+
+/**
+ * Checks whether a trial name is portable on all supported hosts.
+ * @param value - The candidate name
+ * @returns True if the name is portable; false otherwise
+ * @example
+ * ```ts
+ * isStudyCustodyName('r1-s1-a1') // true
+ * ```
+ */
+export declare function isStudyCustodyName(value: unknown): value is string;
+
+/**
+ * Checks whether an observation preserves output or an explicit unexecuted failure.
+ * @param value - The candidate observation
+ * @returns True if the observation is valid, with an executed fact or an unexecuted fact that holds a failure and no product, usage or duration; false otherwise
+ * @example
+ * ```ts
+ * isStudyCustodyObservation({}) // false
+ * ```
+ */
+export declare function isStudyCustodyObservation(value: unknown): value is StudyObservation;
+
+/**
+ * Checks whether a seal has an exact unique execution inventory.
+ * @param value - The candidate seal
+ * @returns True if the seal is structurally valid; false otherwise
+ * @example
+ * ```ts
+ * isStudyCustodySeal({}) // false
+ * ```
+ */
+export declare function isStudyCustodySeal(value: unknown): value is StudySeal;
+
+/**
+ * Checks whether a scheduled trial has exact valid identity fields.
+ * @param value - The candidate trial
+ * @returns True if its identity is valid; false otherwise
+ * @example
+ * ```ts
+ * isStudyCustodyTrial({}) // false
+ * ```
+ */
+export declare function isStudyCustodyTrial(value: unknown): value is StudyTrial;
+
+/** Checks append-only public evidence.
+ * @param value - Decoded evidence.
+ * @returns True if event, goal and payload are valid; false otherwise.
+ */
+export declare function isStudyEvidence(value: unknown): value is StudyEvidence;
+
+/** Checks the complete transport envelope before domain handling.
+ * @param value - Native IPC decoded value.
+ * @returns True if the envelope is bounded in shape and JSON-compatible; false otherwise.
+ */
+export declare function isStudyFrame(value: unknown): value is StudyFrame;
+
+/** Checks the exact digest fields carried by the execution declaration.
+ * @param value - Decoded identity.
+ * @returns True if all required identities are digests; false otherwise.
+ */
+export declare function isStudyIdentity(value: unknown): value is StudyIdentity;
+
+/** Checks operational failure attribution arriving over IPC.
+ * @param value - Decoded failure value.
+ * @returns True if the failure carries a known cause, an optional role, and an optional stop that satisfies `isStudyStop` on a `capacity` or `deadline` cause; false otherwise.
+ */
+export declare function isStudyProcessFailure(value: unknown): value is StudyFailure;
+
+/** Checks a fresh trial's declared identifiers.
+ * @param value - Decoded trial.
+ * @returns True if every identifier and repetition is valid; false otherwise.
+ */
+export declare function isStudyTrial(value: unknown): value is StudyTrial;
+
+/** Iterates the remaining entries of an open directory handle lazily, in read order.
+ * @param handle - The open synchronous directory handle; the caller owns it and closes it.
+ * @returns Each remaining entry until the handle reports the end. An entry is read only when the consumer asks for it, so a consumer that stops early leaves the rest unread.
+ */
+export declare function iterateArtifactEntries(handle: Dir): Generator<Dirent, void>;
+
+/** Parses public command tokens with operation-specific grammar diagnostics.
+ * @param arguments_ - Exact command tokens, after the CLI help boundary.
+ * @returns The independent operation request.
+ * @throws StudyError when a token, required flag, or portable path is invalid.
+ * @example Parse a study command
+ * ```ts
+ * import { parseStudyArguments } from '@orkestrel/study/server'
+ *
+ * parseStudyArguments(['check', 'files', '--profile', 'local'])
+ * ```
+ */
+export declare function parseStudyArguments(arguments_: readonly string[]): StudyCommandRequest;
+
+/** Reads a bounded regular file only through its canonical absolute path.
+ * @param path - The absolute path to inspect.
+ * @param maximum - The remaining capture budget; Default: 16 MiB.
+ * @returns Captured bytes with their identity.
+ * @throws Thrown when the path is linked, noncanonical, oversized, or changes while read.
+ */
+export declare function readArtifact(path: string, maximum?: number): ArtifactSource;
+
+/** Fills a buffer from an open descriptor, one positioned read at a time.
+ * @param descriptor - The open file descriptor to read.
+ * @param target - The buffer to fill.
+ * @param offset - The position in the file and the buffer to continue from; Default: 0.
+ * @returns The bytes read, as the whole buffer when the file filled it or as its leading part when the file ended first.
+ */
+export declare function readArtifactBytes(descriptor: number, target: Buffer, offset?: number): Buffer;
+
+/** Reads a complete adapter from an admitted module namespace.
+ * @param namespace - The captured consumer module.
+ * @returns The validated adapter instance.
+ */
+export declare function readStudyAdapter(namespace: unknown): StudyAdapterInterface;
+
+/**
+ * Projects foreign provider messages onto the exact fields the workload reads.
+ * @param value - The foreign provider message collection
+ * @returns Owned JSON message readings in original order
+ * @throws StudyError - Thrown when a dereferenced foreign member is malformed
+ * @example
+ * ```ts
+ * readStudyAgentMessages([{ id: 'm1', role: 'user', content: 'Hi' }]) // [{ role: 'user', content: 'Hi' }]
+ * ```
+ */
+export declare function readStudyAgentMessages(value: unknown): readonly JSONValue[];
+
+/**
+ * Drains a scripted provider stream into its assembled result.
+ * @param stream - The provider stream to consume to its end
+ * @returns The result the stream returns after its last delta
+ */
+export declare function readStudyAgentResult(stream: AsyncGenerator<ProviderDelta, ProviderResult>): Promise<ProviderResult>;
+
+/**
+ * Reads bounded regular-file bytes without following a symbolic link.
+ * @param path - The custody file path
+ * @param limit - The byte allowance
+ * @returns Exact retained bytes
+ * @throws StudyError - Thrown when the file is linked, oversized, changed, or not regular
+ * @example
+ * ```ts
+ * await readStudyBytes(path, 1024)
+ * ```
+ */
+export declare function readStudyBytes(path: string, limit: number): Promise<Uint8Array>;
+
+/**
+ * Reads from an open file handle into a buffer until the buffer is full or the file ends.
+ * @param handle - The open file handle to read
+ * @param target - The buffer to fill from the start of the file
+ * @param offset - The position in the file and the buffer to continue from; Default: 0
+ * @returns The bytes read, as the whole buffer when the file filled it or as its leading part when the file ended first
+ */
+export declare function readStudyHandle(handle: FileHandle, target: Buffer, offset?: number): Promise<Buffer>;
+
+/**
+ * Reads the pinned serving digest of an admitted request's model.
+ * @param models - The pinned served identities
+ * @param request - The admitted dispatch
+ * @returns The pinned digest, or undefined for an inventory request or an unpinned model
+ */
+export declare function readStudyOllamaDigest(models: StudyOllamaTransportOptions['models'], request: StudyOllamaRequest): string | undefined;
+
+/**
+ * Reads a native Ollama error member as the attributable failure it names, without usage.
+ * @remarks
+ * No token usage is read from the member.
+ * The failure is `CAPACITY` when the member, a string or an object, names the exact structured
+ * type `exceed_context_size_error` with a finite positive integer `n_prompt_tokens` above `n_ctx`,
+ * a `code` of 400 if supplied, and a status of 400 if supplied. Every other member, a malformed
+ * one included, is `FAULT` with its readable reason.
+ * @param value - The parsed HTTP error body or wire row
+ * @param role - The responsibility whose request was dispatched; the failure retains it
+ * @param status - The HTTP status of the carrying response; undefined for a row of a stream that answered 200
+ * @returns Undefined when the value carries no `error` member; otherwise the attributable failure
+ */
+export declare function readStudyOllamaFailure(value: unknown, role: StudyRole, status?: number): StudyError | undefined;
+
+/**
+ * Reads exact outbound Ollama facts and refuses a request outside its declared policy.
+ * @remarks
+ * The refusal happens before admission, so a refused request is never accounted.
+ * @param options - The admitted origin, pinned inventory, and declared role policies
+ * @param role - The responsible request role
+ * @param input - The requested URL
+ * @param init - The native fetch settings
+ * @returns The validated dispatch facts
+ * @throws StudyError - Thrown with code `CONFIG` when the endpoint, model, options, flags, or strict fields differ from the declaration, or the role declares no policy
+ */
+export declare function readStudyOllamaRequest(options: Pick<StudyOllamaTransportOptions, 'url' | 'models' | 'roles'>, role: StudyRole, input: string | URL | Request, init?: RequestInit): StudyOllamaRequest;
+
+/**
+ * Reads the declared model context ceiling without claiming daemon allocation.
+ * @param value - The parsed Ollama show response
+ * @param context - The requested total context
+ * @returns The unambiguous model context ceiling
+ * @throws StudyError - Thrown with code `FAULT` when context metadata is missing, or `CAPACITY` when it is ambiguous or below the requested context
+ */
+export declare function readStudyOllamaSupport(value: unknown, context: number): number;
+
+/**
+ * Reads one Ollama response row without inventing absent usage.
+ * @param value - The parsed wire row
+ * @param request - The admitted dispatch
+ * @returns The terminal facts, or undefined for a nonterminal row
+ * @throws StudyError - Thrown with the recognized provider failure when the row carries an `error` member, before any other row check; `FAULT` for a malformed row, model, message, finish reason, or usage
+ */
+export declare function readStudyOllamaTerminal(value: unknown, request: StudyOllamaRequest): StudyOllamaTerminal | undefined;
+
+/**
+ * Reads daemon timing from a terminal row without letting an observation fail the request.
+ * @param extract - The admitted extractor
+ * @param record - The validated terminal row
+ * @returns The raw timing, or undefined when absent or the extractor throws
+ */
+export declare function readStudyOllamaTiming(extract: StudyOllamaTransportOptions['timing'], record: Readonly<Record<string, unknown>>): OllamaTiming | undefined;
+
+/**
+ * Inspects custody bytes offline and verifies complete execution before grading.
+ * @param directory - The result directory
+ * @returns A sealed result or explicitly interrupted safe metadata
+ * @throws StudyError - Thrown when existing custody bytes are invalid or tampered
+ * @example
+ * ```ts
+ * await readStudyResult(directory)
+ * ```
+ */
+export declare function readStudyResult(directory: string): Promise<StudyResultReading>;
+
+/** Enforces captured inventory membership at every synchronous native import edge. */
+export declare class Resolution {
+    #private;
+    /** Retains the trusted captured inventory and its private namespace.
+     * @param input - Captured built bytes and separate source selection.
+     */
+    constructor(input: ArtifactHookInput);
+    /** Resolves native edges with source-local JavaScript-to-TypeScript substitution.
+     * @param specifier - The requested native specifier.
+     * @param context - Node's resolution context.
+     * @param next - The remaining native resolution chain.
+     * @returns An admitted URL in the captured namespace.
+     */
+    resolve(specifier: string, context: ResolveHookContext, next: ArtifactResolveHandler): ResolveFnOutput;
+    /** Returns captured bytes after verifying their live disk identity.
+     * @param href - Node's resolved URL.
+     * @param context - Node's load context.
+     * @param next - The remaining native load chain.
+     * @returns Captured ESM, JSON, or native strip-only TypeScript output.
+     */
+    load(href: string, context: LoadHookContext, next: ArtifactLoadHandler): LoadFnOutput;
+}
+
+/**
+ * Resolves the content a scripted response serves, from its declaration or from a prior tool message.
+ * @param request - The projected actual request messages
+ * @param response - The declared response being served
+ * @returns The declared content, or the content of the actual tool message the response consumes
+ * @throws StudyError - Thrown when a consuming response has no actual referenced tool result
+ */
+export declare function resolveStudyAgentContent(request: readonly JSONValue[], response: StudyAgentResponse): string;
+
+/** Resolves the actual host package from its trusted executable entry.
+ * @param entry - The runtime's own executable, never a consumer-supplied module.
+ * @returns The canonical study package root.
+ */
+export declare function resolveStudyInstrument(entry: string): string;
+
+/**
+ * Resolves a portable relative artifact path strictly inside its selected directory.
+ * @param directory - The selected custody or study directory
+ * @param path - The slash-separated relative artifact path
+ * @returns The contained absolute host path
+ * @throws StudyError - Thrown when a path is malformed, reserved, absolute, or escaping
+ * @example
+ * ```ts
+ * resolveStudyPath(directory, 'profiles/local.json')
+ * ```
+ */
+export declare function resolveStudyPath(directory: string, path: string): string;
+
+/**
+ * Resolves the execution profile's caller-selected built artifact paths.
+ * @param root - The repository root
+ * @param profile - The validated source profile
+ * @returns The reproducible resolved execution profile
+ * @example
+ * ```ts
+ * resolveStudyProfile(root, profile)
+ * ```
+ */
+export declare function resolveStudyProfile(root: string, profile: StudyProfile): StudyProfile;
+
+/**
+ * Scans regular execution files while refusing unknown directories and linked paths.
+ * @param directory - The execution directory
+ * @param manifest - The authoritative population
+ * @returns Sorted exact inventory entries
+ * @throws StudyError - Thrown when inventory escapes its declared tree
+ * @example
+ * ```ts
+ * await scanStudyExecution(directory, manifest)
+ * ```
+ */
+export declare function scanStudyExecution(directory: string, manifest: StudyManifest): Promise<readonly StudyFile[]>;
+
+/**
+ * Scans one execution directory and the subdirectories it admits, reading each admitted file under the series bytes that remain.
+ * @param directory - The execution directory
+ * @param prefix - The slash-separated path of the scanned directory; the empty string names the execution root
+ * @param known - The scheduled trial identities
+ * @param allowance - The series bytes that remain before this directory
+ * @returns The admitted files in read order: this directory's files, then each admitted subdirectory's, last listed first
+ * @throws StudyError - Thrown when the tree holds a link, an unknown directory or file, or a file beyond the remaining allowance
+ */
+export declare function scanStudyTree(directory: string, prefix: string, known: ReadonlySet<string>, allowance: number): Promise<readonly StudyFile[]>;
+
+/** Caps declared execution duration at the native supervisor's host ceiling. */
+export declare const STUDY_COMMAND_DURATION = 86400000;
+
+/** Names the trusted command's independent offline predicate. */
+export declare const STUDY_COMMAND_GRADER = "consumer-adapter";
+
+/** Defines the complete public CLI reference shared by help and grammar diagnostics. */
+export declare const STUDY_COMMAND_HELP = "study check <study> [--profile <name>]\nstudy execute <study> [--profile <name>] [--out <path>] [--expected <sha256>]\nstudy grade <result> --rubric <path>\nstudy label <result> --grading <sha256> --labels <path>\nstudy report <result> --grading <sha256>\nstudy --help\n\nProfiles default to local. Flags require values and may appear only once.\nResults default to tmp/studies/<result>; scratch also uses tmp/studies.\nA result is its id under tmp/studies, a root-relative path, or an absolute path.\nRelative paths, including --out, must stay inside the consumer working directory.\nOutput directories must be new; existing results are never overwritten.\n--expected pins the fingerprint returned by check. --grading selects an exact grading.\n--rubric selects independent criteria. --labels imports caller-supplied semantic labels.\nSuccess writes one JSON document; next contains suggested argv, never executed automatically.\ncheck, grade, label and report have a fixed allowance of 60 seconds.\nexecute checks first, then uses the declared series duration plus 15 seconds for cleanup.\nExit codes: 0 success, 64 invalid input, 124 deadline, 130 interruption, 1 operational failure.\n";
+
+/** Names the command route beneath the native supervisor. */
+export declare const STUDY_COMMAND_OPERATION = "study-command";
+
+/** Limits untrusted metadata before JSON parsing or file allocation. */
+export declare const STUDY_CUSTODY_BYTES: number;
+
+/** Bounds how long inherited output handles stay open after native exit, in milliseconds. */
+export declare const STUDY_DRAIN_DURATION = 1000;
+
+/** Limits each serialized IPC envelope, including its JSON framing. */
+export declare const STUDY_FRAME_BYTES: number;
+
+/** Bounds combined supervised command output to 16 MiB before terminating the tree. */
+export declare const STUDY_LAUNCH_BYTES: number;
+
+/** Extends supervised execution beyond its declared series duration for cleanup. */
+export declare const STUDY_LAUNCH_CLEANUP = 15000;
+
+/** Bounds each supervised operation other than execution to 60 seconds. */
+export declare const STUDY_LAUNCH_DURATION = 60000;
+
+/** Limits combined worker stdout and stderr before termination. */
+export declare const STUDY_LOG_BYTES: number;
+
+/** Discloses the limits of neutral identifiers when public text remains visible. */
+export declare const STUDY_PACKET_DISCLOSURE = "Identifiers omit treatment and model names. Input and product text may still reveal design details.";
+
+/** Limits outstanding bidirectional protocol work per process. */
+export declare const STUDY_PENDING_LIMIT = 64;
+
+/** Attributes an expired process handshake or cleanup deadline. */
+export declare const STUDY_PROCESS_LABEL = "Process lifecycle";
+
+/** Rejects names that Windows reserves even on other hosts. */
+export declare const STUDY_RESERVED_NAME: RegExp;
+
+/** Caps pure domain work independently of its event loop. */
+export declare const STUDY_TASK_DURATION = 60000;
+
+/** Names the private bounded validation and grading route. */
+export declare const STUDY_TASK_OPERATION = "study-adapter";
+
+/** Names the worker operation routed by the built application entry. */
+export declare const STUDY_WORKER_OPERATION = "study-worker";
+
+/** Defines the consumer's domain checks, driver construction, and retained-evidence grading.
+ * @remarks
+ * An authored module exports a createStudyAdapter factory returning this interface.
+ * The host invokes adapter code in a bounded child. It passes criteria to validation
+ * and grading only; a trial receives the admitted modules and its public input.
+ * Adapter code is trusted instrumentation, not a security sandbox.
+ */
+export declare interface StudyAdapterInterface {
+    /** Checks domain declarations before loading a selected agent, subject or provider.
+     * @param input - The generic declarations already parsed by the host.
+     */
+    validate(input: StudyValidation): void;
+    /** Constructs the consumer's driver over admitted module namespaces.
+     * @param options - Modules, runtime profile, and owned scratch parent.
+     * @returns The actual driver used for this isolated trial.
+     */
+    driver(options: StudyDriverOptions): StudyDriverInterface;
+    /** Judges retained evidence without changing the executed trajectory.
+     * @param input - The sealed observations and independently selected rubric.
+     * @returns Criterion readings; unavailable evidence remains unknown.
+     */
+    grade(input: StudyAdjudication): readonly StudyJudgment[];
+}
+
+/** Holds retained observations and independent criteria for a grading operation. */
+export declare interface StudyAdjudication {
+    readonly manifest: StudyManifest;
+    readonly rubric: StudyRubric;
+    readonly attempts: readonly StudyAttempt[];
+    readonly evidence: Readonly<Record<string, readonly StudyEvidence[]>>;
+}
+
+/** Admits requests against enclosing limits before an adapter dispatches them. */
+declare interface StudyAdmissionInterface {
+    readonly signal: AbortSignal;
+    readonly usage: readonly StudyUsage[];
+    /** Resolves admission before dispatch; local meters may return the ticket synchronously. */
+    admit(charge: StudyCharge): StudyTicket | Promise<StudyTicket>;
+}
+
+/** Holds the trial-local canonical dispatch identity a wire request joins to. */
+declare interface StudyAgentDispatch {
+    readonly id: number;
+    /** Holds the SHA-256 revision of the canonical request, or undefined when it could not be rendered. */
+    readonly revision: string | undefined;
+}
+
+/** Joins each message of a measured request to its origin, one JSON entry per message in order. */
+export declare type StudyAgentOriginHandler = (messages: readonly Message[]) => JSONValue;
+
+/** Holds one goal's scripted replies and the resources the provider charges and cancels through. */
+export declare interface StudyAgentPlan {
+    readonly responses: readonly StudyAgentResponse[];
+    readonly goal: string;
+    readonly context: StudyContext;
+    readonly workload: AbortController;
+}
+
+/** Holds one dispatched request's explicit size reading. */
+declare interface StudyAgentReading {
+    /** Holds the runtime's estimate of the complete pre-encoding request. */
+    readonly estimate: number;
+    /** Holds the gauge projection of that estimate; undefined when no gauge applies. */
+    readonly projected: number | undefined;
+}
+
+/**
+ * Declares one scripted reply.
+ * @remarks
+ * `content` and `calls` are the reply the provider returns. `consume` names the prior tool result
+ * the reply consumes; undefined consumes none. `abort`: if `true`, the reply aborts the goal's
+ * workload; if `false` or undefined, it does not. `tokens` and `bytes` override the admitted
+ * token count and byte charge of the reply; undefined keeps the defaults. `truncated`: if `true`,
+ * the reply reports that the model ended it at its own token limit, which the Agent reads as a
+ * `model` stop; if `false` or undefined, it does not.
+ */
+export declare interface StudyAgentResponse {
+    readonly content: string;
+    readonly calls: NonNullable<ProviderResult['tools']>;
+    readonly consume: string | undefined;
+    readonly abort: boolean | undefined;
+    readonly tokens: number | undefined;
+    readonly bytes: number | undefined;
+    readonly truncated: boolean | undefined;
+}
+
+/** Names the model responsibilities whose requests the trace and summary measure. */
+export declare type StudyAgentRole = Extract<StudyRole, 'agent' | 'summary'>;
+
+/**
+ * Holds the admitted Agent namespace capabilities the shared instrumentation invokes.
+ * @remarks
+ * Each member has the exact signature of the export of the same name in the selected Agent
+ * runtime. The consumer supplies the admitted namespace; the instrumentation never imports a
+ * runtime value from an installed Agent copy. No Ledger capability is required.
+ */
+declare interface StudyAgentRuntime {
+    readonly estimateRequest: typeof estimateRequest;
+    readonly measureRequest: typeof measureRequest;
+    readonly isAgentError: typeof isAgentError;
+}
+
+/** Serves declared inert responses through the actual Agent provider boundary. */
+export declare class StudyAgentScript implements ProviderInterface {
+    #private;
+    readonly id: `${string}-${string}-${string}-${string}-${string}`;
+    readonly name = "scripted-study";
+    /**
+     * Binds the encoded byte bound every served request and response must fit.
+     * @param options - The explicit encoded bound; it is also each response's default admitted bytes
+     * @throws StudyError - Thrown when the bound is not a nonnegative safe integer
+     */
+    constructor(options: StudyAgentScriptOptions);
+    /**
+     * Prepares one goal's declared response sequence and metered operational boundary until `clear` ends the goal.
+     * @param plan - The workload's responses and its operational context
+     * @returns Nothing when the provider is ready
+     * @throws StudyError - Thrown with code `CONFIG` when a response is still running, a goal is already prepared, or a declared response is invalid; a prepared goal stays prepared
+     */
+    prepare(plan: StudyAgentPlan): void;
+    /**
+     * Ends the prepared goal so another goal can be prepared; a stream already running keeps serving its own goal.
+     * @returns Nothing; a provider with no prepared goal stays unprepared
+     */
+    clear(): void;
+    /**
+     * Consumes the same streaming response into its assembled provider result.
+     * @param messages - The actual Agent conversation
+     * @param signal - The enclosing Agent run signal
+     * @returns The assembled declared response
+     */
+    generate(messages: readonly Message[], signal: AbortSignal): Promise<ProviderResult>;
+    /**
+     * Streams a declared response after authoritative admission and retains actual request bytes.
+     * @param messages - The actual Agent conversation
+     * @param signal - The enclosing Agent run signal
+     * @returns The declared response, optionally consuming an actual prior tool message
+     * @remarks
+     * A stream abandoned after admission accounts for an Agent budget cut without latching a failure.
+     * Other abandoned streams fail the admitted request with the run signal's reason, or a `FAULT`
+     * when the signal carries none.
+     * @throws StudyError - Thrown with code `CONFIG` when no goal is prepared, another response is running, or the responses are exhausted; thrown with the meter's refusal when admission fails
+     */
+    stream(messages: readonly Message[], signal: AbortSignal): AsyncGenerator<ProviderDelta, ProviderResult>;
+}
+
+/** Holds the scripted provider's fixed byte bound; the admitted token count defaults to one. */
+export declare interface StudyAgentScriptOptions {
+    readonly bytes: number;
+}
+
+/**
+ * Names where a measurement was taken.
+ * @remarks
+ * `admission` is a window or room check before a request is admitted; `dispatch` is the request
+ * the provider sends.
+ */
+export declare type StudyAgentStage = 'admission' | 'dispatch';
+
+/**
+ * Holds the ordinal and revision one measurement received.
+ * @remarks
+ * `revision` is null, never omitted, when the request could not be canonically rendered; the
+ * retained evidence format distinguishes the two.
+ */
+export declare interface StudyAgentStamp {
+    readonly ordinal: number;
+    readonly revision: string | null;
+}
+
+/** Folds a conversation through the real provider under an explicit gauge and prompt limit. */
+export declare class StudyAgentSummary {
+    #private;
+    /** Binds the provider, the measuring trace, the gauge, the limit and the consumer's instruction.
+     * @param options - Delegate, measurement seam, limits and cancellation.
+     * @throws StudyError - Thrown with code `CONFIG` when the limit is not a positive safe integer, or the gauge scale is not finite and greater than 0 or its overhead is not finite and at least 0.
+     */
+    constructor(options: StudyAgentSummaryOptions);
+    /** Measures one canonical request, refuses it at the limit, and sends the very same array to the provider.
+     * @param messages - The conversation to fold; the instruction follows as the final user turn.
+     * @param signal - Bounds the request; the options' signal bounds it when omitted.
+     * @returns The summary content, retained as evidence before a blank result is refused.
+     * @throws StudyError - Thrown with code `CAPACITY` when the projection reaches the limit, and with code `FAULT` when usage is unusable, no goal is active, or the content is blank.
+     */
+    summarize(messages: readonly Message[], signal: AbortSignal | undefined): Promise<string>;
+}
+
+/**
+ * Holds the gauged summary's delegate, measurement seam, explicit limits and cancellation.
+ * @remarks
+ * `provider` receives the one canonical array the summary measured. `runtime` prices it. `trace`
+ * retains the summary's measurement, refusal and evidence rows. `latch` refuses work after a
+ * retained failure. `gauge` prices each request and `limit` is the prompt projection at which a
+ * request is refused; it must be a positive safe integer, and `gauge.scale` must be finite and
+ * greater than 0 and `gauge.overhead` finite and at least 0, or construction refuses with `CONFIG`.
+ * The summary keeps its own copy of the gauge. `instruction` is the final user turn appended to the
+ * folded messages. `signal` bounds work when the caller supplies none.
+ */
+export declare interface StudyAgentSummaryOptions {
+    readonly provider: ProviderInterface;
+    readonly runtime: Pick<StudyAgentRuntime, 'estimateRequest'>;
+    readonly trace: StudyAgentTrace;
+    readonly latch: StudyLatchInterface;
+    readonly gauge: LedgerGauge;
+    readonly limit: number;
+    readonly instruction: Message;
+    readonly signal: AbortSignal;
+}
+
+/** Correlates measured Agent requests and retains their evidence across a trial's goals. */
+export declare class StudyAgentTrace {
+    #private;
+    /** Binds the measuring runtime, the failure owner and the consumer origin join.
+     * @param options - Runtime, latch, observation switch and origin handler.
+     */
+    constructor(options: StudyAgentTraceOptions);
+    /** Reports the active goal; undefined between goals. */
+    get goal(): string | undefined;
+    /** Begins a goal's rows. Ordinals, dispatch numbers and role identities continue from earlier goals.
+     * @param goal - The goal whose rows follow.
+     * @throws StudyError - Thrown with code `CONFIG` when a goal is already active; the active goal and its rows stay unchanged.
+     */
+    start(goal: string): void;
+    /** Retains one domain row for the active goal, whether or not observation is enabled; a row outside a goal is dropped.
+     * @param event - The evidence event name.
+     * @param value - The JSON evidence value.
+     */
+    append(event: string, value: JSONValue): void;
+    /** Appends the retained rows in order, including rows added during the flush, and ends the goal even when custody refuses a row.
+     * @param evidence - The sink that takes custody of each row.
+     * @returns Completion after every row is appended; immediately when no goal is active.
+     * @throws StudyError - Thrown with code `CONFIG` when another flush is pending; the pending flush is untouched.
+     */
+    flush(evidence: StudySinkInterface): Promise<void>;
+    /** Prices a window measurement and, when observing, retains it as the goal's admission.
+     * @param request - The measured request.
+     * @param gauge - The explicit gauge pricing the estimate.
+     * @returns The projected prompt tokens.
+     */
+    admit(request: ProviderRequest, gauge: LedgerGauge): number;
+    /** Retains a dispatching agent request's reading, names it for the wire request that follows, and records its estimate.
+     * @param reading - The explicit size reading.
+     * @param request - The exact pre-encoding request.
+     */
+    record(reading: StudyAgentReading, request: ProviderRequest): void;
+    /** Takes one synchronous measurement row; the goal's flush appends it, failure included.
+     * @param stage - Where the measurement was taken.
+     * @param role - The responsibility whose request was measured.
+     * @param request - The exact pre-encoding request.
+     * @param reading - The explicit size reading.
+     * @param dispatch - The dispatch number the request received; undefined for an admission.
+     * @returns The ordinal and revision; undefined when not observing.
+     */
+    measure(stage: StudyAgentStage, role: StudyAgentRole, request: ProviderRequest, reading: StudyAgentReading, dispatch: number | undefined): StudyAgentStamp | undefined;
+    /** Numbers a request about to be dispatched and retains it as its role's current dispatch; does nothing unless observing.
+     * @param role - The responsibility dispatching.
+     * @param request - The exact pre-encoding request.
+     * @param reading - The explicit size reading.
+     */
+    dispatch(role: StudyAgentRole, request: ProviderRequest, reading: StudyAgentReading): void;
+    /** Reads the role's current dispatch identity for the wire request that follows it.
+     * @param role - The responsibility dispatching.
+     * @returns The dispatch id and revision; undefined before any observed dispatch of the role.
+     */
+    canonical(role: StudyAgentRole): StudyAgentDispatch | undefined;
+    /** Latches the study-level reading of a failure before an enclosing runtime can swallow it and retains one refusal row per refused identity in a goal.
+     * @param error - The caught or reported value.
+     * @returns The translated failure, or the same value when it is not an Agent window refusal.
+     */
+    translate(error: unknown): unknown;
+}
+
+/**
+ * Holds the trace's measuring runtime, failure owner and consumer origin join.
+ * @remarks
+ * `runtime` measures requests and recognizes the nominal Agent refusal. `latch` retains the first
+ * operational failure. `observe`: if `true`, the trace retains measurement and refusal rows; if
+ * `false`, it retains none, while domain rows still follow an active goal. `origins` supplies the
+ * consumer's origin annotation for a measured request's messages.
+ */
+export declare interface StudyAgentTraceOptions {
+    readonly runtime: StudyAgentRuntime;
+    readonly latch: StudyLatchInterface;
+    readonly observe: boolean;
+    readonly origins: StudyAgentOriginHandler;
+}
+
+/** Holds the separately bound instrument and selected module inventory identities. */
+export declare interface StudyArtifactIdentity {
+    readonly agent: string;
+    readonly subject: string;
+    readonly provider: string | undefined;
+    readonly instrument: string;
+}
+
+/** Binds consumer instrumentation separately from selected executable identities. */
+export declare class StudyArtifactLoader {
+    #private;
+    /** Owns resolved built and consumer source selections.
+     * @param options - The trusted host, adapter, and profile.
+     */
+    constructor(options: StudyArtifactLoaderOptions);
+    /** Inventories bytes without importing selected code.
+     * @returns Bound executable and instrumentation identities.
+     */
+    inspect(): Promise<StudyArtifactIdentity>;
+    /** Loads the adapter from the trial inventory.
+     * @returns The complete consumer adapter.
+     */
+    adapter(): Promise<StudyAdapterInterface>;
+    /** Loads admitted built namespaces inside the trial child.
+     * @returns The agent, subject and optional provider; a shared entry loads once and keeps each role.
+     */
+    load(): Promise<StudyArtifactModule>;
+    /** Refuses instrument and inventory drift after inspection. */
+    verify(): void;
+}
+
+/** Holds the trusted instrument and caller-selected built artifact locations. */
+export declare interface StudyArtifactLoaderOptions {
+    readonly entry: string;
+    readonly root: string;
+    readonly profile: StudyProfile;
+    readonly adapter: string;
+}
+
+/** Holds actual namespaces loaded only during worker execution. */
+export declare interface StudyArtifactModule {
+    readonly agent: unknown;
+    readonly subject: unknown;
+    readonly provider: unknown;
+}
+
+/** Holds a terminal trial record, including goals never dispatched. */
+declare interface StudyAttempt {
+    readonly trial: StudyTrial;
+    readonly observations: readonly StudyObservation[];
+    readonly failure: StudyFailure | undefined;
+    readonly duration: number;
+    /** Records whether the trial entered execution without an inherited terminal series failure, including failures before the driver opened; not a claim that the driver was opened. */
+    readonly executed: boolean;
+}
+
+/**
+ * Holds one failed record the report groups by cause, role, and layer.
+ * @remarks
+ * `trial` names the trial the failure belongs to. `goal` names the goal at the goal level and is
+ * undefined at the trial level. `executed` is the record's own execution fact, never inferred.
+ */
+export declare interface StudyAttributionSource {
+    readonly trial: string;
+    readonly goal: string | undefined;
+    readonly failure: StudyFailure;
+    readonly executed: boolean;
+}
+
+/** Holds nested execution allowances; each request also has a deadline. */
+declare interface StudyBounds {
+    readonly request: StudyLimit;
+    readonly goal: StudyLimit;
+    readonly trial: StudyLimit;
+    readonly series: StudyLimit;
+}
+
+/**
+ * Names an operational ending separately from task achievement.
+ * @remarks
+ * `content` means a request completed but its consumer refused the content as unusable. It
+ * claims no model or decoder cause and grades no semantic quality.
+ */
+declare type StudyCause = 'capacity' | 'infrastructure' | 'deadline' | 'interrupted' | 'content';
+
+/** Correlates bounded IPC work and rejects every outstanding request on transport failure. */
+export declare class StudyChannel {
+    #private;
+    /** Subscribes to one native IPC endpoint.
+     * @param options - Native endpoint and owning domain handlers; the bag is snapshotted while selected collaborators keep their identity.
+     */
+    constructor(options: StudyChannelOptions);
+    get signal(): AbortSignal;
+    /** Sends one correlated domain request.
+     * @param operation - The domain operation expected by the peer.
+     * @param value - Public JSON payload.
+     * @returns The peer's acknowledged result.
+     */
+    request(operation: StudyOperation, value: JSONValue): Promise<JSONValue>;
+    /** Forwards cancellation without closing the cleanup transport.
+     * @param value - Validated goal, trial or ticket cancellation attribution.
+     */
+    abort(value: JSONValue): void;
+    /** Removes endpoint handlers and rejects all unresolved calls.
+     * @param error - The first transport or owning lifecycle failure.
+     */
+    close(error?: unknown): void;
+}
+
+/** Holds one native IPC endpoint and its domain handlers. */
+export declare interface StudyChannelOptions {
+    readonly endpoint: ChildProcess | NodeJS.Process;
+    readonly handle: StudyMessageHandler;
+    readonly abort: (value: JSONValue) => void;
+}
+
+/** Holds a request's pre-dispatch upper bounds. */
+declare interface StudyCharge {
+    readonly role: StudyRole;
+    readonly tokens: number;
+    readonly bytes: number;
+}
+
+/** Dispatches private child routes before the public native supervisor. */
+export declare class StudyCLI {
+    #private;
+    /** Owns the installed executable path and consumer working directory.
+     * @param options - Exact runtime entry and consumer root, snapshotted at construction.
+     */
+    constructor(options: StudyLaunchOptions);
+    /** Executes one route with truthful public exit semantics.
+     * @param arguments_ - Native command arguments.
+     * @returns The command, deadline, interruption, or invalid-input exit code.
+     */
+    execute(arguments_: readonly string[]): Promise<number>;
+}
+
+/** Executes validated study operations with execution and grading custody kept independent. */
+export declare class StudyCommand {
+    #private;
+    /**
+     * Owns the trusted host entry and repository location without reading or writing files.
+     * @param options - The repository root and built trusted application entry
+     */
+    constructor(options: StudyCommandOptions);
+    /**
+     * Parses command tokens once and executes their independent operation.
+     * @param arguments_ - The exact command tokens
+     * @param signal - The caller's execution cancellation
+     * @returns Truthful operation metadata or a verified whole-horizon report
+     * @throws StudyError - Thrown when arguments, declarations, identities, or custody fail
+     */
+    execute(arguments_: readonly string[], signal: AbortSignal): Promise<JSONValue>;
+}
+
+/** Holds one bounded source artifact retained during offline validation. */
+export declare interface StudyCommandArtifact {
+    readonly path: string;
+    readonly digest: string;
+}
+
+/** Holds the trusted application entry and repository location. */
+export declare interface StudyCommandOptions {
+    readonly root: string;
+    readonly entry: string;
+}
+
+/** Names the independently dispatched study command operation. */
+export declare type StudyCommandRequest = StudyExecutionRequest | StudyGradeRequest | StudyLabelRequest | StudyReportRequest;
+
+/** Holds the resources visible to one running goal. */
+declare interface StudyContext {
+    readonly signal: AbortSignal;
+    readonly meter: StudyAdmissionInterface;
+    readonly evidence: StudySinkInterface;
+}
+
+/** Retains the first operational failure while bounding asynchronous waits. */
+declare class StudyControl implements StudyControlInterface {
+    #private;
+    /** Links cancellation to the caller without assigning it a task verdict.
+     * @param signal - Optional parent cancellation.
+     */
+    constructor(signal?: AbortSignal);
+    get signal(): AbortSignal;
+    get failure(): StudyFailure | undefined;
+    /** Latches an operational failure and cancels all linked work.
+     * @param failure - The first attribution to preserve.
+     */
+    fail(failure: StudyFailure): void;
+    /** Races work against cancellation and removes its listener after either ending.
+     * @param work - Already-started work whose rejection remains observed after cancellation.
+     * @returns The work's result if it settles before cancellation.
+     * @throws Thrown with the retained operational attribution when cancelled.
+     */
+    wait<T>(work: PromiseLike<T>): Promise<T>;
+    /** Removes the lifecycle listener without changing the retained failure. */
+    close(): void;
+}
+
+/** Owns the first operational failure and cancellation of enclosing work. */
+declare interface StudyControlInterface {
+    readonly signal: AbortSignal;
+    readonly failure: StudyFailure | undefined;
+    /** Latches an operational failure and cancels all linked work.
+     * @param failure - The first attribution to preserve.
+     * @returns Nothing after failure propagation.
+     */
+    fail(failure: StudyFailure): void;
+    /** Races work against cancellation and removes its listener after either ending.
+     * @param work - Work whose late rejection remains observed.
+     * @returns The result when work settles before cancellation.
+     */
+    wait<T>(work: PromiseLike<T>): Promise<T>;
+    /** Removes the lifecycle listener without changing the retained failure.
+     * @returns Nothing after listener release.
+     */
+    close(): void;
+}
+
+/** Holds a grader-owned criterion outside the driver's public input. */
+declare interface StudyCriterion {
+    readonly id: string;
+    readonly scenario: string;
+    readonly goal: string;
+    readonly method: 'state' | 'trace' | 'semantic';
+    readonly critical: boolean;
+    readonly assertion: JSONValue;
+}
+
+/** Holds the evidence sink's shared admission budget. */
+export declare interface StudyCustodyBudget {
+    readonly reserve: (bytes: number) => void;
+}
+
+/** Names the execution custody lifecycle without inferring seal completeness. */
+export declare type StudyCustodyPhase = 'new' | 'creating' | 'ready' | 'sealing' | 'sealed' | 'failed';
+
+/** Closes evidence admission and drains already admitted appends. */
+export declare interface StudyCustodySinkInterface extends StudySinkInterface {
+    /** Closes admission immediately and synchronizes all previously admitted writes.
+     * @returns A promise that resolves after the evidence descriptor closes.
+     */
+    close(): Promise<void>;
+}
+
+/** Holds the frozen study question, population and explicit repetition orders. */
+declare interface StudyDefinition {
+    readonly name: string;
+    readonly version: string;
+    readonly question: string;
+    readonly purpose: StudyPurpose;
+    readonly driver: string;
+    readonly arms: readonly string[];
+    readonly scenarios: readonly string[];
+    readonly order: ReadonlyArray<readonly string[]>;
+    readonly retries: 0;
+    readonly rubric: string;
+}
+
+/** Creates isolated domain state through a concrete package consumer. */
+declare interface StudyDriverInterface {
+    /** Creates fresh domain state for one scheduled trial.
+     * @param trial - The scheduled scenario, arm, and repetition.
+     * @param signal - The caller's cancellation.
+     * @returns The isolated session for this trial.
+     */
+    open(trial: StudyTrial, signal: AbortSignal): Promise<StudySessionInterface>;
+}
+
+/** Supplies admitted modules and an exclusive scratch parent without grader truth. */
+export declare interface StudyDriverOptions {
+    readonly agent: unknown;
+    readonly subject: unknown;
+    readonly provider: unknown;
+    readonly profile: StudyProfile;
+    readonly directory: string;
+}
+
+/** Reports a study contract or operational failure with a stable code. */
+declare class StudyError extends Error {
+    readonly code: StudyErrorCode;
+    readonly failure: StudyFailure | undefined;
+    /**
+     * Records the failing boundary and optional operational attribution.
+     * @param code - The machine-readable boundary
+     * @param message - The specific failure
+     * @param failure - The optional operational reading
+     */
+    constructor(code: StudyErrorCode, message: string, failure?: StudyFailure);
+}
+
+/** Names malformed configuration, evidence, custody and operational failures. */
+declare type StudyErrorCode = 'CONFIG' | 'EVIDENCE' | 'CUSTODY' | 'CAPACITY' | 'FAULT' | 'DEADLINE';
+
+/** Holds append-only domain evidence in a JSON-compatible form. */
+declare interface StudyEvidence {
+    readonly event: string;
+    readonly goal: string;
+    readonly value: JSONValue;
+}
+
+/** Retains admitted evidence in order and closes admission before terminal records. */
+export declare class StudyEvidenceSink implements StudyCustodySinkInterface {
+    #private;
+    /**
+     * Owns the descriptor selection and constraints while retaining the live file and budget.
+     * @param options - The owned descriptor, goal names, and byte admission bounds
+     */
+    constructor(options: StudyEvidenceSinkOptions);
+    /**
+     * Admits exact encoded bytes before queuing an append in call order.
+     * @param evidence - The validated domain record
+     * @returns Nothing after the admitted append completes
+     * @throws StudyError - Thrown when admission is closed or a byte limit is exceeded
+     */
+    append(evidence: StudyEvidence): Promise<void>;
+    /**
+     * Closes admission immediately and synchronizes all previously admitted writes.
+     * @returns Nothing when the evidence descriptor has closed
+     */
+    close(): Promise<void>;
+}
+
+/** Holds the owned evidence descriptor and byte admission constraints. */
+export declare interface StudyEvidenceSinkOptions {
+    readonly file: FileHandle;
+    readonly goals: readonly string[];
+    readonly goal: number;
+    readonly trial: number;
+    readonly budget: StudyCustodyBudget;
+}
+
+/** Holds a checked execution selection with optional output custody. */
+export declare interface StudyExecutionRequest {
+    readonly command: 'check' | 'execute';
+    readonly target: string;
+    readonly profile: string;
+    /** Selects an absolute output or a portable path contained by the consumer root. */
+    readonly out: string | undefined;
+    readonly expected: string | undefined;
+}
+
+/** Holds an attributable operational fault without awarding a task verdict. */
+declare interface StudyFailure {
+    readonly cause: StudyCause;
+    readonly message: string;
+    readonly role: StudyRole | undefined;
+    /** Names the ceiling that stopped the run; undefined for a failure no ceiling caused, and for a record sealed before this member existed. */
+    readonly stop: StudyStop | undefined;
+}
+
+/** Holds the exact byte identity of one execution file. */
+export declare interface StudyFile {
+    readonly path: string;
+    readonly bytes: number;
+    readonly digest: string;
+}
+
+/** Holds a correlated JSON request, reply or cancellation notification. */
+export declare interface StudyFrame {
+    readonly id: number;
+    readonly operation: StudyOperation | 'reply' | 'error' | 'abort';
+    readonly value: JSONValue;
+}
+
+/** Holds a declared goal's public input without its grading truth. */
+declare interface StudyGoal {
+    readonly id: string;
+    readonly input: JSONValue;
+}
+
+/** Reads one declared target against the consumer's domain predicate. */
+export declare type StudyGradeFunction = (target: StudyGradeTarget) => StudyGradeReading;
+
+/** Holds a consumer predicate's reading of one target, citing only retained files and rows. */
+export declare interface StudyGradeReading {
+    readonly verdict: StudyJudgment['verdict'];
+    readonly method: StudyJudgment['method'];
+    readonly reason: string;
+    readonly references: readonly StudyReference[];
+}
+
+/** Holds an offline predicate grading request. */
+export declare interface StudyGradeRequest {
+    readonly command: 'grade';
+    readonly target: string;
+    readonly rubric: string;
+}
+
+/** Holds one declared trial and criterion pair with its retained observations. */
+export declare interface StudyGradeTarget {
+    readonly trial: StudyTrial;
+    readonly criterion: StudyCriterion;
+    /** Holds the retained terminal record, or undefined when the trial was never retained. */
+    readonly attempt: StudyAttempt | undefined;
+    /** Holds the trial's retained evidence rows in append order; empty when the trial was never retained. */
+    readonly evidence: readonly StudyEvidence[];
+}
+
+/** Holds a grading identity that cannot replace or mutate execution bytes. */
+declare interface StudyGrading {
+    readonly result: string;
+    readonly rubric: string;
+    readonly grader: string;
+    readonly instrument: string;
+    readonly attempts: readonly string[];
+    readonly labels: string | undefined;
+    /** Binds the retained public packet and private mapping when semantic criteria exist. */
+    readonly packet?: string;
+    readonly judgments: readonly StudyJudgment[];
+}
+
+/** Holds artifacts already verified inside a selected immutable grading directory. */
+export declare interface StudyGradingContext {
+    readonly grading: StudyGrading;
+    readonly rubric: StudyRubric;
+    readonly bytes: Uint8Array;
+    readonly packet: StudyPacketBundle | undefined;
+    readonly labels: Uint8Array | undefined;
+}
+
+/** Retains immutable deterministic grading versions independently of execution bytes. */
+export declare class StudyGradingStore {
+    #private;
+    /**
+     * Owns exact imported grading bytes without writing any custody files.
+     * @param options - The verified execution and exact rubric and optional labels bytes
+     * @throws StudyError - Thrown when imported bytes exceed bounds or fail validation
+     */
+    constructor(options: StudyGradingStoreOptions);
+    /**
+     * Retains a deterministic grading version or verifies identical existing bytes.
+     * @param grading - The complete evidence-backed judgments and artifact bindings
+     * @returns The exact grading-byte SHA-256 identity
+     * @throws StudyError - Thrown when coverage, bindings, or existing bytes are invalid
+     */
+    write(grading: StudyGrading): Promise<string>;
+    /**
+     * Reads an immutable grading version and verifies every bound artifact byte.
+     * @param id - The grading-byte SHA-256 identity
+     * @returns The verified grading, or undefined when the version does not exist
+     * @throws StudyError - Thrown when an existing version is partial or tampered
+     */
+    read(id: string): Promise<StudyGrading | undefined>;
+}
+
+/** Holds imported grading artifacts independently of execution. */
+export declare interface StudyGradingStoreOptions {
+    readonly result: StudySealedResult;
+    readonly rubric: Uint8Array;
+    readonly labels?: Uint8Array;
+    readonly packet?: StudyPacketBundle;
+}
+
+/** Holds byte identities that qualification and comparisons must agree on. */
+declare interface StudyIdentity {
+    readonly agent: string;
+    readonly subject: string;
+    readonly provider: string | undefined;
+    readonly instrument: string;
+    readonly fixtures: string;
+    readonly profile: string;
+}
+
+/** Holds inspected execution metadata that is never gradeable before sealing. */
+export declare interface StudyInterruptedResult {
+    readonly status: 'interrupted';
+    readonly directory: string;
+    readonly manifest: StudyManifest | undefined;
+    readonly attempts: readonly StudyAttempt[];
+}
+
+/** Holds an evidence-backed verdict; missing evidence stays unknown. */
+declare interface StudyJudgment {
+    readonly trial: string;
+    readonly criterion: string;
+    readonly verdict: 'achieved' | 'unsuccessful' | 'unknown';
+    readonly method: 'state' | 'trace' | 'human' | 'model';
+    readonly reason: string;
+    readonly references: readonly string[];
+}
+
+/** Holds imported semantic judgments and their accountable origin. */
+declare interface StudyLabeling {
+    readonly packet: string;
+    readonly labeler: string;
+    readonly version: string;
+    readonly created: string;
+    readonly usage: readonly StudyUsage[];
+    readonly judgments: readonly StudyJudgment[];
+}
+
+/** Holds an imported-label grading request. */
+export declare interface StudyLabelRequest {
+    readonly command: 'label';
+    readonly target: string;
+    readonly grading: string;
+    readonly labels: string;
+}
+
+/** Retains the first operational failure of instrumented work and refuses work after it. */
+declare interface StudyLatchInterface {
+    /** Refuses work after a retained failure or cancellation.
+     * @returns Nothing when work may continue.
+     */
+    check(): void;
+    /** Retains an operational failure even when an enclosing runtime catches it.
+     * @param error - The observed failure; an earlier retained failure keeps its identity, and a branded `BudgetError` can retain nothing because Agent reports that stop in its own result.
+     * @returns Nothing after retention.
+     */
+    fail(error: unknown): void;
+}
+
+/** Supervises finite command trees and binds offline check to execution. */
+export declare class StudyLauncher {
+    #private;
+    /** Owns the trusted runtime entry and caller working directory.
+     * @param options - Native entry and consumer root.
+     */
+    constructor(options: StudyLaunchOptions);
+    /** Checks and supervises the requested command under its finite native allowance.
+     * @param arguments_ - Public command tokens.
+     * @returns The exact operational or supervisor exit code.
+     */
+    execute(arguments_: readonly string[]): Promise<number>;
+}
+
+/** Selects the native command entry and the caller's consumer root. */
+export declare interface StudyLaunchOptions {
+    readonly root: string;
+    readonly entry: string;
+}
+
+/** Retains the bounded command exit and captured output. */
+export declare interface StudyLaunchResult {
+    readonly code: number;
+    readonly output: string;
+}
+
+/**
+ * Names the ceiling that stopped a run.
+ * @remarks
+ * `scope` is a limit Study declares: the calls, tokens, bytes, or duration of a request, goal,
+ * trial, series, or operation, the product output allowance, and a provider's declared byte bound.
+ * `window` is a prompt room. `custody` is an evidence allowance. `meter`, `budget`, and `model`
+ * mirror the `layer` of the `AgentStop` type from `@orkestrel/agent`: the run's estimate allowance,
+ * any other budget, and the model's own token limit, which also names the daemon's context and
+ * output caps.
+ */
+declare type StudyLayer = 'scope' | 'window' | 'custody' | 'meter' | 'budget' | 'model';
+
+/** Holds finite allowances in milliseconds, calls, tokens and bytes. */
+declare interface StudyLimit {
+    readonly duration: number;
+    readonly calls: number;
+    readonly tokens: number;
+    readonly bytes: number;
+}
+
+/** Holds the execution declaration sealed before any trial begins. */
+declare interface StudyManifest {
+    readonly id: string;
+    readonly created: string;
+    readonly definition: StudyDefinition;
+    readonly scenarios: readonly StudyScenario[];
+    readonly identity: StudyIdentity;
+    readonly schedule: readonly StudyTrial[];
+    readonly bounds: StudyBounds;
+    readonly qualification: string | undefined;
+    readonly host: Readonly<Record<string, string>>;
+}
+
+/** Handles validated transport requests at their owning domain boundary. */
+export declare type StudyMessageHandler = (operation: StudyOperation, value: JSONValue) => Promise<JSONValue>;
+
+/** Holds the retained outcome of a scheduled goal. */
+declare interface StudyObservation {
+    readonly goal: string;
+    readonly product: StudyProduct | undefined;
+    readonly failure: StudyFailure | undefined;
+    readonly usage: readonly StudyUsage[];
+    readonly duration: number;
+    /** Records whether the engine dispatched the goal to the session; never inferred from product, usage, duration or failure. */
+    readonly executed: boolean;
+}
+
+/** Holds one active goal's accounting and attribution. */
+export declare interface StudyOllamaActivity {
+    readonly goal: string;
+    readonly context: StudyContext;
+    /** Holds the owned public view retained with the goal's first model dispatch; undefined retains neither it nor request bodies. */
+    readonly checkpoint: JSONValue | undefined;
+}
+
+/** Pins one served model identity the inventory verifies. */
+export declare interface StudyOllamaModel {
+    readonly name: string;
+    readonly digest: string;
+}
+
+/**
+ * Holds the Ollama provider options one role's declared policy determines.
+ * @remarks
+ * `truncate` and `shift` are present, and `false`, only when the policy is strict; the policy's
+ * `length` allowance is transport-only and projects nothing.
+ */
+export declare type StudyOllamaOptions = Pick<OllamaOptions, 'model' | 'think' | 'options' | 'truncate' | 'shift'>;
+
+/**
+ * Declares one model role's exact wire policy.
+ * @remarks
+ * `model` names the served model the role dispatches to; the inventory must pin it. `options`
+ * mirrors the Ollama `options` object the role must send exactly, and its `num_predict` member
+ * is the role's output allowance. `think`: if `true`, a chat request may enable `think`; if
+ * `false`, it must send `think: false`. `strict`: if `true`, a chat request must carry the Ollama
+ * `truncate` and `shift` fields as `false`; if `false`, neither field is read. `length`: if
+ * `true`, a `length` finish is the declared completion and generation may reach its allowance;
+ * if `false`, either is a capacity refusal. The `judge` role dispatches the raw generate wire,
+ * which carries no strict fields.
+ */
+export declare interface StudyOllamaPolicy {
+    readonly model: string;
+    readonly options: Readonly<Record<string, number>>;
+    readonly think: boolean;
+    readonly strict: boolean;
+    readonly length: boolean;
+}
+
+/** Holds validated wire dispatch facts without retaining payload text. */
+export declare interface StudyOllamaRequest {
+    readonly role: StudyRole;
+    readonly path: string;
+    readonly model: string | undefined;
+    readonly output: number;
+    readonly bytes: number;
+    readonly options: Readonly<Record<string, number>>;
+    /** Reports whether the request's native `truncate` and `shift` fields were verified false. */
+    readonly strict: boolean;
+    /** Reports whether the declared policy admits a `length` finish. */
+    readonly length: boolean;
+}
+
+/**
+ * Names the model roles an Ollama study transport dispatches under a declared policy.
+ * @remarks
+ * Inventory and metadata reads use the `metadata` role and need no policy.
+ */
+export declare type StudyOllamaRole = Extract<StudyRole, 'agent' | 'summary' | 'judge'>;
+
+/**
+ * Holds one outbound request's facts as owned at admission.
+ * @remarks
+ * `url` is the caller's URL spelling and `init` carries a copy of the caller's accepted settings
+ * with owned headers; the caller's `signal` keeps its live identity. `dispatch` is a copy of the
+ * caller's canonical dispatch. Later caller mutation changes none of them.
+ */
+export declare interface StudyOllamaSnapshot {
+    readonly url: string;
+    readonly init: RequestInit | undefined;
+    readonly dispatch: StudyAgentDispatch | undefined;
+}
+
+/** Holds a validated terminal's finish reason and actual usage, unknown when unreported. */
+export declare interface StudyOllamaTerminal {
+    readonly prompt: number | undefined;
+    readonly completion: number | undefined;
+    readonly reason: string;
+}
+
+/** Admits and accounts Ollama wire requests under declared policies and latches failure. */
+export declare class StudyOllamaTransport implements StudyLatchInterface {
+    #private;
+    /** Records immutable transport bounds and refuses a role policy the inventory cannot serve.
+     * @param options - Origin, room, request limit, pinned inventory, role policies, and cancellation.
+     */
+    constructor(options: StudyOllamaTransportOptions);
+    /** Binds subsequent wire requests to one live goal until `clear` or `close` ends it.
+     * @param activity - The goal's accounting boundary.
+     * @throws StudyError - Thrown with code `FAULT` when a model response is still open or a goal is still bound; the bound goal stays bound.
+     * @throws unknown - Thrown with the retained failure or the cancellation reason, as `check` throws it.
+     */
+    prepare(activity: StudyOllamaActivity): void;
+    /** Ends the bound goal so another goal can be prepared; a request already admitted keeps its own goal.
+     * @returns Nothing; a transport with no bound goal stays unbound, and a closed transport stays closed.
+     */
+    clear(): void;
+    /** Refuses work after any retained failure or cancellation.
+     * @returns Nothing when work may continue.
+     */
+    check(): void;
+    /** Retains an operational failure even when an inner runtime catches it.
+     * @param error - The observed failure; the first retained failure keeps its identity, and a branded `BudgetError` retains nothing because Agent reports that stop in its own result.
+     */
+    fail(error: unknown): void;
+    /** Checks every pinned serving identity through admitted inventory and metadata requests.
+     * @returns Completion after inventory validation and support evidence.
+     * @throws StudyError - Thrown with code `FAULT` when no goal is bound; the transport retains this refusal as its failure, as it retains every verification failure.
+     */
+    verify(): Promise<void>;
+    /** Dispatches exactly one admitted request with bounded streaming reads.
+     * @param role - The accountable responsibility.
+     * @param input - The exact configured URL.
+     * @param init - The native fetch settings.
+     * @param original - The immutable canonical dispatch the caller measured for this request; it joins the observation rows and never changes the request.
+     * @returns A validated streaming response.
+     * @throws StudyError - Thrown with code `FAULT` when no goal is bound, before admission and without retaining a failure.
+     * @throws StudyError - Thrown with the recognized provider failure or a role-attributed `FAULT` for a non-2xx response, after its bounded body was read and its request accounted once.
+     */
+    fetch(role: StudyRole, input: string | URL | Request, init?: RequestInit, original?: StudyAgentDispatch): Promise<Response>;
+    /** Cancels every outstanding native reader and permanently closes the transport.
+     * @returns Completion after finite native cancellation.
+     */
+    close(): Promise<void>;
+}
+
+/**
+ * Holds the Ollama study transport's immutable configuration.
+ * @remarks
+ * `url` is the admitted daemon origin. `room` supplies the context the transport reserves and the
+ * safety margin it keeps. `limit` bounds each request's duration and encoded bytes. `models` pins
+ * the served identities, keyed by the label their inventory evidence carries. `roles` declares the
+ * wire policy of every model role the consumer dispatches; an undeclared role is refused.
+ * `signal` cancels all work. `observe`: if `true`, existing evidence rows gain passive timing and
+ * correlation fields; if `false`, they carry none. `timing` extracts daemon timing; the selected Ollama runtime supplies the extractor and the transport imports none.
+ */
+export declare interface StudyOllamaTransportOptions {
+    readonly url: string;
+    readonly room: Pick<StudyRoom, 'context' | 'safety'>;
+    readonly limit: Pick<StudyLimit, 'duration' | 'bytes'>;
+    readonly models: Readonly<Record<string, StudyOllamaModel>>;
+    readonly roles: Readonly<Partial<Record<StudyOllamaRole, StudyOllamaPolicy>>>;
+    readonly signal: AbortSignal;
+    readonly observe: boolean;
+    readonly timing: typeof extractTiming;
+}
+
+/** Tracks one owned HTTP response until its end or cancellation. */
+export declare interface StudyOllamaWire {
+    readonly activity: StudyOllamaActivity;
+    readonly request: StudyOllamaRequest;
+    readonly ticket: StudyTicket;
+    readonly signal: AbortSignal;
+    readonly reader: ReadableStreamDefaultReader<Uint8Array>;
+    readonly decoder: TextDecoder;
+    /** Holds the HTTP status the daemon answered with. */
+    readonly status: number;
+    readonly started: number;
+    /** Holds the trial-local request id. */
+    readonly id: number;
+    /** Holds the monotonic millisecond reading taken immediately before native fetch. */
+    readonly sent: number;
+    /** Holds the canonical dispatch this wire request was made for, when the caller measured one. */
+    readonly dispatch: StudyAgentDispatch | undefined;
+    /** Holds the encoded request bytes plus every response byte counted so far. */
+    readonly bytes: number;
+    /** Holds the decoded response text not yet consumed as complete rows. */
+    readonly text: string;
+    readonly terminal: StudyOllamaTerminal | undefined;
+    /** Holds the daemon timing of the terminal row once observed. */
+    readonly timing: OllamaTiming | undefined;
+    /** Reports whether the request was accounted, finished or failed. */
+    readonly settled: boolean;
+}
+
+/** Names the bounded transport's domain operations. */
+export declare type StudyOperation = 'open' | 'goal' | 'close' | 'admit' | 'finish' | 'fail' | 'evidence';
+
+/** Holds exact neutral public packet bytes and private mapping bytes. */
+export declare interface StudyPacketBundle {
+    readonly content: Uint8Array;
+    readonly mapping: Uint8Array;
+}
+
+/** Holds one neutral semantic grading input without treatment or model identifiers. */
+export declare interface StudyPacketEntry {
+    readonly trial: string;
+    readonly criterion: string;
+    readonly input: JSONValue;
+    readonly product: StudyProduct | undefined;
+    readonly assertion: JSONValue;
+}
+
+/** Holds the neutral identity mapping to a sealed semantic trial-criterion pair. */
+export declare interface StudyPacketLink {
+    readonly trial: string;
+    readonly criterion: string;
+    readonly source: {
+        readonly trial: string;
+        readonly criterion: string;
+    };
+}
+
+/** Holds an authoritative parent ticket and its transport listener lifetime. */
+export declare interface StudyParentTicket {
+    readonly ticket: StudyTicket;
+    readonly listeners: AbortController;
+}
+
+/** Holds checked public declarations and reproducible executable identities. */
+export declare interface StudyPreparation {
+    readonly directory: string;
+    readonly definition: StudyDefinition;
+    readonly scenarios: readonly StudyScenario[];
+    readonly rubric: StudyRubric;
+    readonly profile: StudyProfile;
+    readonly identity: StudyIdentity;
+    readonly artifacts: StudyArtifactLoader;
+    readonly source: string;
+}
+
+/** Opens one fresh native child for each scheduled trial. */
+export declare class StudyProcessDriver implements StudyDriverInterface {
+    #private;
+    /** Owns immutable resolved launch settings.
+     * @param options - Built entry, admitted identities and exclusive scratch parent.
+     */
+    constructor(options: StudyProcessOptions);
+    /** Opens isolated child state and waits for its verified readiness.
+     * @param trial - The public scheduled trial.
+     * @param signal - Authoritative parent cancellation.
+     * @returns A ready process-backed session.
+     */
+    open(trial: StudyTrial, signal: AbortSignal): Promise<StudySessionInterface>;
+}
+
+/** Holds one goal's parent context and the worker admission sequence it issues while the goal runs.
+ * @example Issue worker admissions in sequence
+ * ```ts
+ * import type { StudyContext } from '@orkestrel/study'
+ * import { StudyProcessGoal } from '@orkestrel/study/server'
+ *
+ * declare const context: StudyContext
+ *
+ * const goal = new StudyProcessGoal(context)
+ * goal.issue(2) // undefined
+ * goal.issue(1) // 1
+ * goal.issue(1) // undefined
+ * goal.issue(2) // 2
+ * ```
+ */
+export declare class StudyProcessGoal {
+    #private;
+    /** Binds one goal to the parent meter and evidence sink it runs under.
+     * @param context - The actual parent meter, evidence sink and cancellation of the goal.
+     */
+    constructor(context: StudyContext);
+    /** Reports the parent meter and evidence sink the goal runs under. */
+    get context(): StudyContext;
+    /** Issues the identifier of the next worker admission when the worker asked for exactly that one.
+     * @param requested - The identifier the worker supplied.
+     * @returns The issued identifier, or undefined when the requested one is not the next in sequence.
+     */
+    issue(requested: unknown): number | undefined;
+}
+
+/** Holds the parent-owned fresh trial process configuration. */
+export declare interface StudyProcessOptions extends StudyArtifactLoaderOptions {
+    readonly identity: StudyIdentity;
+    readonly driver: string;
+    readonly directory: string;
+}
+
+/** Keeps admission and evidence custody in the parent of one fresh trial process. */
+export declare class StudyProcessSession implements StudySessionInterface {
+    #private;
+    /** Owns one trial's process lifecycle without starting host work.
+     * @param options - Public trial and process configuration; the configuration is snapshotted while the borrowed signal keeps its identity.
+     */
+    constructor(options: StudyProcessSessionOptions);
+    /** Starts the child and verifies its artifact-bound readiness. */
+    start(): Promise<void>;
+    /** Runs one ordered goal through parent-authorized requests and acknowledged evidence.
+     * @param goal - Public goal without grading truth.
+     * @param context - Actual parent meter and evidence sink.
+     * @returns The retained child product after every admitted operation settles.
+     */
+    execute(goal: StudyGoal, context: StudyContext): Promise<StudyProduct>;
+    /** Requests verified cleanup, then terminates only this recorded process tree. */
+    close(): Promise<void>;
+}
+
+/** Holds one fresh child trial's launch parameters and cancellation. */
+export declare interface StudyProcessSessionOptions extends StudyProcessOptions {
+    readonly trial: StudyTrial;
+    readonly signal: AbortSignal;
+}
+
+/** Holds observed output and partial completion, never self-awarded success. */
+declare interface StudyProduct {
+    readonly value: JSONValue;
+    readonly partial: boolean;
+}
+
+/** Holds execution settings independently of scenario and grading declarations. */
+declare interface StudyProfile {
+    readonly name: string;
+    /** Selects the Agent runtime entry, independently of the package under study. */
+    readonly agent: string;
+    /** Selects the entry of the package under study; it can equal the Agent entry. */
+    readonly subject: string;
+    readonly roots: readonly string[];
+    readonly bounds: StudyBounds;
+    readonly room: StudyRoom;
+    readonly provider: StudyProvider | undefined;
+    readonly qualification: string | undefined;
+    /** Holds driver-owned JSON; the driver owns its interpretation and Study only validates and owns the object. */
+    readonly settings: Readonly<Record<string, JSONValue>> | undefined;
+}
+
+/** Holds caller-selected provider artifacts and model identities. */
+declare interface StudyProvider {
+    readonly entry: string;
+    readonly url: string;
+    readonly model: string;
+    /** Names the judge model; declared together with its digest or both absent. */
+    readonly judge: string | undefined;
+    /** Pins the serving inventory independently of mutable model names. */
+    readonly digest: {
+        readonly model: string;
+        /** Pins the judge model; declared together with its name or both absent. */
+        readonly judge: string | undefined;
+    };
+}
+
+/** Names the evidence a study can establish. */
+declare type StudyPurpose = 'mechanism' | 'quality' | 'capacity';
+
+/** Cites a retained trial file, or one evidence row of it by its zero-based position. */
+export declare interface StudyReference {
+    readonly file: StudyReferenceFile;
+    /** Selects one retained evidence row; the cited string carries its one-based position. Valid only for the evidence file. */
+    readonly row?: number;
+}
+
+/** Names a retained file of one trial that a judgment cites. */
+export declare type StudyReferenceFile = 'attempt' | 'evidence';
+
+/** Waits for authoritative parent admission and drains acknowledged settlements. */
+export declare class StudyRemoteMeter implements StudyRemoteMeterInterface {
+    #private;
+    /** Owns one goal's transported tickets without local budget decisions.
+     * @param options - Parent transport and shared worker failure control, snapshotted at construction.
+     */
+    constructor(options: StudyRemoteMeterOptions);
+    get signal(): AbortSignal;
+    get usage(): readonly StudyUsage[];
+    /** Requests and awaits the parent's dispatch grant.
+     * @param charge - Upper bounds that the parent reserves before replying.
+     * @returns A ticket only after authoritative admission succeeds.
+     */
+    admit(charge: StudyCharge): Promise<StudyTicket>;
+    /** Propagates the parent's ticket cancellation without changing its cause.
+     * @param id - Parent-issued ticket identity.
+     * @param failure - Authoritative parent attribution.
+     */
+    abort(id: number, failure: StudyFailure): void;
+    /** Closes admission and requires every ticket and acknowledgment to finish. */
+    close(): Promise<void>;
+}
+
+/** Owns transported admission, parent cancellation, and settlement drainage. */
+export declare interface StudyRemoteMeterInterface extends StudyAdmissionInterface {
+    /** Propagates the parent's ticket cancellation without changing its cause.
+     * @param id - The parent-issued ticket identity.
+     * @param failure - The authoritative parent attribution.
+     * @returns Nothing after cancellation propagation.
+     */
+    abort(id: number, failure: StudyFailure): void;
+    /** Closes admission and requires every ticket and acknowledgment to finish.
+     * @returns A promise that resolves after acknowledged settlements drain.
+     */
+    close(): Promise<void>;
+}
+
+/** Holds the worker meter's parent-authorized transport and failure latch. */
+export declare interface StudyRemoteMeterOptions {
+    readonly channel: StudyChannel;
+    readonly control: StudyControl;
+}
+
+/** Transmits one settlement without inventing local admission authority. */
+export declare class StudyRemoteTicket implements StudyTicket {
+    #private;
+    /** Owns the parent's ticket identity and composed cancellation.
+     * @param options - Transported ticket state and settlement callback, snapshotted at construction.
+     */
+    constructor(options: StudyRemoteTicketOptions);
+    get signal(): AbortSignal;
+    get settled(): boolean;
+    /** Sends actual usage for authoritative parent settlement.
+     * @param usage - Actual measured request usage.
+     */
+    finish(usage: StudyUsage): void;
+    /** Sends operational failure while preserving unknown actual cost.
+     * @param failure - The first observed request failure.
+     */
+    fail(failure: StudyFailure): void;
+}
+
+/** Holds one transported ticket's identity and settlement owner. */
+export declare interface StudyRemoteTicketOptions {
+    readonly id: number;
+    readonly signal: AbortSignal;
+    readonly settle: (operation: 'finish' | 'fail', value: StudyUsage | StudyFailure) => void;
+}
+
+/** Holds a selected immutable report request. */
+export declare interface StudyReportRequest {
+    readonly command: 'report';
+    readonly target: string;
+    readonly grading: string;
+}
+
+/** Holds an outstanding bounded IPC response. */
+export declare interface StudyResponse {
+    readonly resolve: (value: JSONValue) => void;
+    readonly reject: (error: unknown) => void;
+}
+
+/** Holds an offline execution reading discriminated by custody completeness. */
+export declare type StudyResultReading = StudyInterruptedResult | StudySealedResult;
+
+/** Owns append-only execution bytes and seals only a complete terminal population. */
+export declare class StudyResultStore implements StudyResultStoreInterface {
+    #private;
+    /**
+     * Owns a validated manifest snapshot without creating any files.
+     * @param options - The new result directory and execution declaration
+     * @throws StudyError - Thrown when the manifest is invalid
+     */
+    constructor(options: StudyResultStoreOptions);
+    /**
+     * Exclusively creates the result directory and initial manifest bytes.
+     * @returns Nothing after the manifest is synchronized
+     * @throws StudyError - Thrown when creation repeats or custody bounds are exceeded
+     */
+    create(): Promise<void>;
+    /**
+     * Exclusively creates the evidence sink for an exact scheduled trial.
+     * @param trial - The scheduled trajectory
+     * @returns The bounded append-only sink
+     * @throws StudyError - Thrown when the trial is foreign, repeated, or late
+     */
+    start(trial: StudyTrial): Promise<StudySinkInterface>;
+    /**
+     * Closes evidence admission, drains admitted appends, and writes a terminal record.
+     * @param attempt - The complete scheduled goal horizon
+     * @returns Nothing after the terminal record is synchronized
+     * @throws StudyError - Thrown when the terminal record is invalid, repeated, or late
+     */
+    finish(attempt: StudyAttempt): Promise<void>;
+    /**
+     * Seals exact execution inventory after every scheduled trial has terminated.
+     * @returns The immutable deterministic execution seal
+     * @throws StudyError - Thrown when custody is incomplete, invalid, or already sealed
+     */
+    seal(): Promise<StudySeal>;
+}
+
+/** Owns execution custody from exclusive creation through complete sealing. */
+export declare interface StudyResultStoreInterface extends StudyStoreInterface {
+    /** Exclusively creates the result directory and initial manifest bytes.
+     * @returns A promise that resolves after the manifest is synchronized.
+     */
+    create(): Promise<void>;
+    /** Seals a complete terminal population with its exact execution-byte inventory.
+     * @returns The synchronized execution seal.
+     */
+    seal(): Promise<StudySeal>;
+}
+
+/** Holds the inert execution store configuration. */
+export declare interface StudyResultStoreOptions {
+    readonly directory: string;
+    readonly manifest: StudyManifest;
+}
+
+/** Names a request's measured responsibility. */
+declare type StudyRole = 'agent' | 'judge' | 'summary' | 'metadata' | 'tool';
+
+/** Holds the model context and generation allowance as separate measurements. */
+declare interface StudyRoom {
+    readonly context: number;
+    readonly output: number;
+    readonly safety: number;
+    /** Declares the recap allowance; absent when the workflow produces no recap. */
+    readonly recap: number | undefined;
+    readonly think: boolean;
+}
+
+/** Holds a versioned grading declaration independently of execution. */
+declare interface StudyRubric {
+    readonly version: string;
+    readonly criteria: readonly StudyCriterion[];
+}
+
+/** Holds ordered goals sharing state within an isolated trial. */
+declare interface StudyScenario {
+    readonly id: string;
+    readonly goals: readonly StudyGoal[];
+}
+
+/** Holds a complete execution inventory and its deterministic identity. */
+export declare interface StudySeal {
+    readonly result: string;
+    readonly id: string;
+    readonly files: readonly StudyFile[];
+}
+
+/** Holds independently verified sealed execution bytes. */
+export declare interface StudySealedResult {
+    readonly status: 'sealed';
+    readonly directory: string;
+    readonly manifest: StudyManifest;
+    readonly attempts: readonly StudyAttempt[];
+    readonly seal: StudySeal;
+}
+
+/** Owns domain state across a trial and releases it before the next trial. */
+declare interface StudySessionInterface {
+    /** Executes one public goal against the trial's retained domain state.
+     * @param goal - The declared public input.
+     * @param context - Cancellation, borrowed admission, and evidence custody.
+     * @returns The observed product without a task verdict.
+     */
+    execute(goal: StudyGoal, context: StudyContext): Promise<StudyProduct>;
+    /** Releases the trial's domain resources.
+     * @returns A promise that resolves after release.
+     */
+    close(): Promise<void>;
+}
+
+/** Holds an evidence sink whose implementation owns byte limits and custody. */
+declare interface StudySinkInterface {
+    /** Appends bounded domain evidence to the owned execution record.
+     * @param evidence - The public evidence for a declared goal.
+     * @returns A promise that resolves when custody accepts the bytes.
+     */
+    append(evidence: StudyEvidence): Promise<void>;
+}
+
+/**
+ * Holds the ceiling that stopped a run and the readings it crossed.
+ * @remarks
+ * `id` names the ceiling: a Study label and quantity such as `Goal tokens`, an Agent budget's trace
+ * id, or the provider option that capped the model such as `num_predict`. `max` is the ceiling and
+ * `consumed` the tally at the crossing, the refused charge included; each is undefined when its
+ * source reports none. On the `model` layer `max` is the cap and `consumed` the completion or prompt.
+ * Finite foreign readings retain their source values, including negative and fractional values.
+ */
+declare interface StudyStop {
+    readonly layer: StudyLayer;
+    readonly id: string;
+    readonly max: number | undefined;
+    readonly consumed: number | undefined;
+}
+
+/** Appends terminal records without overwriting a prior attempt. */
+declare interface StudyStoreInterface {
+    /** Opens append-only evidence custody for one scheduled trial.
+     * @param trial - The exact scheduled trial.
+     * @returns The borrowed evidence sink.
+     */
+    start(trial: StudyTrial): Promise<StudySinkInterface>;
+    /** Retains the terminal record for one scheduled trial.
+     * @param attempt - The complete scheduled goal horizon.
+     * @returns A promise that resolves after custody retains the record.
+     */
+    finish(attempt: StudyAttempt): Promise<void>;
+}
+
+/** Bounds adapter evaluation by an independent native parent timer. */
+export declare class StudyTask {
+    #private;
+    /** Owns the built child route and captured source selection.
+     * @param options - Consumer root, runtime entry, adapter, and admitted dependencies.
+     */
+    constructor(options: StudyTaskOptions);
+    /** Executes one validation or grading operation in a fresh child.
+     * @param request - Declarations or retained evidence, never a trial payload.
+     * @param signal - Caller cancellation.
+     * @returns Verified adapter output and active instrumentation identity.
+     */
+    execute(request: StudyTaskRequest, signal: AbortSignal): Promise<StudyTaskResult>;
+}
+
+/** Holds a bounded adapter-only native operation. */
+export declare interface StudyTaskOptions {
+    readonly entry: string;
+    readonly root: string;
+    readonly adapter: string;
+    readonly roots: readonly string[];
+    readonly duration?: number;
+}
+
+/** Carries only declarations or sealed evidence to an adapter child. */
+export declare type StudyTaskRequest = {
+    readonly operation: 'validate';
+    readonly input: StudyValidation;
+} | {
+    readonly operation: 'grade';
+    readonly input: StudyAdjudication;
+};
+
+/** Returns adapter output with the exact active instrumentation digest. */
+export declare interface StudyTaskResult {
+    readonly instrument: string;
+    readonly value: JSONValue;
+}
+
+/** Evaluates only admitted instrumentation in a disposable native child. */
+export declare class StudyTaskWorker {
+    #private;
+    /** Processes exactly one inherited request and returns a bounded response. */
+    execute(): Promise<void>;
+}
+
+/** Holds one admitted request until its actual charge is recorded. */
+declare interface StudyTicket {
+    readonly signal: AbortSignal;
+    /** Reports whether this ticket already recorded its own settlement; an aborted signal does not establish it. */
+    readonly settled: boolean;
+    /** Records actual measurements for one admitted request.
+     * @param usage - The request's measured charges.
+     * @returns Nothing after settlement.
+     */
+    finish(usage: StudyUsage): void;
+    /** Records an attributable failure for one admitted request.
+     * @param failure - The retained operational attribution.
+     * @returns Nothing after failure propagation.
+     */
+    fail(failure: StudyFailure): void;
+}
+
+/** Holds a scheduled trajectory, with a fresh state for each repetition and arm. */
+declare interface StudyTrial {
+    readonly id: string;
+    readonly scenario: string;
+    readonly arm: string;
+    readonly repetition: number;
+}
+
+/** Holds the trial sink's admitted writes and terminal lifecycle. */
+export declare interface StudyTrialCustody {
+    readonly sink: StudyCustodySinkInterface;
+    readonly terminal: Promise<void> | undefined;
+}
+
+/** Holds actual request measurements; absent token usage remains unknown. */
+declare interface StudyUsage {
+    readonly role: StudyRole;
+    readonly calls: number;
+    readonly tokens: number | undefined;
+    readonly bytes: number | undefined;
+    readonly duration: number;
+}
+
+/** Holds declarations for domain validation before agent, subject or provider execution. */
+export declare interface StudyValidation {
+    readonly definition: StudyDefinition;
+    readonly scenarios: readonly StudyScenario[];
+    readonly rubric: StudyRubric;
+    readonly profile: StudyProfile;
+}
+
+/** Executes one verified trial behind parent-authorized admission and custody. */
+export declare class StudyWorker {
+    #private;
+    /** Serves the inherited IPC channel until its parent disconnects.
+     * @returns Completion after channel and acquired session cleanup.
+     */
+    execute(): Promise<void>;
+}
+
+/** Terminates the recorded native process tree under a finite cleanup allowance.
+ * @param child - The exclusively owned child process.
+ */
+export declare function terminateStudyChild(child: ChildProcess): void;
+
+/**
+ * Translates bound neutral imported labels through the sealed semantic horizon.
+ * @param result - The verified sealed execution
+ * @param rubric - The retained rubric
+ * @param digest - The exact retained rubric-byte identity
+ * @param labels - The original imported neutral labels
+ * @returns Judgments translated to scheduled trial and criterion identities
+ * @throws StudyError - Thrown when the packet or a label identity is foreign
+ * @example
+ * ```ts
+ * translateStudyPacketLabeling(result, rubric, rubricDigest, labels)
+ * ```
+ */
+export declare function translateStudyPacketLabeling(result: StudySealedResult, rubric: StudyRubric, digest: string, labels: StudyLabeling): readonly StudyJudgment[];
+
+/**
+ * Validates complete evidence lines and per-goal encoded evidence bounds.
+ * @param bytes - The exact JSONL file
+ * @param manifest - The bounds and scenario declarations
+ * @param trial - The scheduled trial identity
+ * @returns Nothing when evidence satisfies its custody contract
+ * @throws StudyError - Thrown when evidence is partial, invalid, foreign, or oversized
+ * @example
+ * ```ts
+ * validateStudyEvidenceBytes(bytes, manifest, trial)
+ * ```
+ */
+export declare function validateStudyEvidenceBytes(bytes: Uint8Array, manifest: StudyManifest, trial: string): void;
+
+/**
+ * Checks terminal policy after the actual wire cost has been retained.
+ * @param terminal - The valid terminal facts
+ * @param room - The reserved context and safety margin
+ * @param request - The admitted dispatch and its declared finish policy; every refusal retains its role
+ * @returns Nothing when the completion satisfies the declared policy
+ * @throws StudyError - Thrown with code `CAPACITY` when the actual prompt exceeds its room, generation exceeds its allowance, or an undeclared `length` finish or capped generation occurs; `FAULT` for another unsupported finish reason
+ */
+export declare function validateStudyOllamaCompletion(terminal: StudyOllamaTerminal, room: Pick<StudyRoom, 'context' | 'safety'>, request: StudyOllamaRequest): void;
+
+/**
+ * Verifies that each pinned name resolves to one inventory entry with its pinned digest.
+ * @param value - The parsed inventory response
+ * @param models - The pinned served identities
+ * @returns Nothing for a matching inventory
+ * @throws StudyError - Thrown with code `FAULT` when the inventory is unsupported or a pinned identity does not match
+ */
+export declare function validateStudyOllamaInventory(value: unknown, models: StudyOllamaTransportOptions['models']): void;
+
+/**
+ * Validates declared role policies against the pinned inventory before any dispatch.
+ * @param roles - The declared wire policy of each model role
+ * @param models - The pinned served identities
+ * @returns Nothing when every policy names a pinned model and a positive output allowance
+ * @throws StudyError - Thrown with code `CONFIG` when a policy names an unpinned model, declares no positive safe-integer `num_predict`, or makes the raw judge wire strict
+ */
+export declare function validateStudyOllamaRoles(roles: StudyOllamaTransportOptions['roles'], models: StudyOllamaTransportOptions['models']): void;
+
+/** Refuses a profile that omits the actual host runtime's declared dependency bytes.
+ * @param instrument - The canonical package owning the trusted runtime entry.
+ * @param roots - Explicitly admitted package roots, including the instrument.
+ */
+export declare function validateStudyRuntime(instrument: string, roots: readonly string[]): void;
+
+/** Projects optional domain fields into the JSON wire representation.
+ * @param value - An owned domain value with optional undefined fields.
+ * @returns A JSON-compatible snapshot.
+ * @example Project a wire value
+ * ```ts
+ * import { valueToWire } from '@orkestrel/study/server'
+ *
+ * valueToWire({ state: 'ready', failure: undefined }) // { state: 'ready' }
+ * ```
+ */
+export declare function valueToWire(value: unknown): JSONValue;
+
+/**
+ * Writes an exclusive regular record and synchronizes it before reporting success.
+ * @param path - The new custody path
+ * @param bytes - The exact encoded record
+ * @returns Nothing after the record is synchronized
+ * @example
+ * ```ts
+ * await writeStudyBytes(path, bytes)
+ * ```
+ */
+export declare function writeStudyBytes(path: string, bytes: Uint8Array): Promise<void>;
+
+export { }