@orkestrel/study 0.0.1 → 0.0.3

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

@@ -1,17 +1,17 @@
+import type { BigIntStats } from 'node:fs';
 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 { OllamaDaemonIdentity } from '@orkestrel/ollama/server';
+import type { OllamaDaemonInterface } from '@orkestrel/ollama/server';
 import type { OllamaOptions } from '@orkestrel/ollama';
 import type { OllamaTiming } from '@orkestrel/ollama';
 import type { ProviderDelta } from '@orkestrel/agent';
@@ -21,6 +21,45 @@ import type { ProviderResult } from '@orkestrel/agent';
 import type { ResolveFnOutput } from 'node:module';
 import type { ResolveHookContext } from 'node:module';
 import type { ResolveHookSync } from 'node:module';
+import type { StudyAdmissionInterface } from '@orkestrel/study';
+import type { StudyAgentDispatch } from '@orkestrel/study';
+import type { StudyAgentReading } from '@orkestrel/study';
+import type { StudyAgentRuntime } from '@orkestrel/study';
+import type { StudyAttempt } from '@orkestrel/study';
+import type { StudyBounds } from '@orkestrel/study';
+import type { StudyCharge } from '@orkestrel/study';
+import type { StudyContext } from '@orkestrel/study';
+import type { StudyControl } from '@orkestrel/study';
+import type { StudyCriterion } from '@orkestrel/study';
+import type { StudyDefinition } from '@orkestrel/study';
+import type { StudyDriverInterface } from '@orkestrel/study';
+import { StudyError } from '@orkestrel/study';
+import type { StudyEvidence } from '@orkestrel/study';
+import type { StudyFailure } from '@orkestrel/study';
+import type { StudyGoal } from '@orkestrel/study';
+import type { StudyGrading } from '@orkestrel/study';
+import type { StudyIdentity } from '@orkestrel/study';
+import type { StudyJudgment } from '@orkestrel/study';
+import type { StudyLabeling } from '@orkestrel/study';
+import type { StudyLatchInterface } from '@orkestrel/study';
+import type { StudyLimit } from '@orkestrel/study';
+import type { StudyManifest } from '@orkestrel/study';
+import type { StudyObservation } from '@orkestrel/study';
+import type { StudyProduct } from '@orkestrel/study';
+import type { StudyProfile } from '@orkestrel/study';
+import type { StudyProvider } from '@orkestrel/study';
+import type { StudyRecord } from '@orkestrel/study';
+import type { StudyRole } from '@orkestrel/study';
+import type { StudyRoom } from '@orkestrel/study';
+import type { StudyRubric } from '@orkestrel/study';
+import type { StudyScenario } from '@orkestrel/study';
+import type { StudySessionInterface } from '@orkestrel/study';
+import type { StudySinkInterface } from '@orkestrel/study';
+import type { StudyStoreInterface } from '@orkestrel/study';
+import type { StudyTicket } from '@orkestrel/study';
+import type { StudyTrial } from '@orkestrel/study';
+import type { StudyUsage } from '@orkestrel/study';
+import type { ToolCall } from '@orkestrel/tool';
 
 /** Bounds all captured input bytes to 128 MiB. */
 export declare const ARTIFACT_BYTES: number;
@@ -28,6 +67,12 @@ export declare const ARTIFACT_BYTES: number;
 /** Bounds directory nesting below each selected root. */
 export declare const ARTIFACT_DEPTH = 64;
 
+/** Marks artifact errors across module formats and installations. */
+export declare const ARTIFACT_ERROR_BRAND: unique symbol;
+
+/** Lists the artifact refusal codes. */
+export declare const ARTIFACT_ERROR_CODES: readonly ArtifactErrorCode[];
+
 /** Bounds one captured input file to 16 MiB. */
 export declare const ARTIFACT_FILE_BYTES: number;
 
@@ -40,15 +85,34 @@ export declare const ARTIFACT_ROOTS = 128;
 /** Bounds all visited directory entries, including ignored assets. */
 export declare const ARTIFACT_VISITS = 32768;
 
+/** Binds a verified physical forest to its relocated selections and complete membership.
+ * @remarks
+ * Digest hashes sorted member keys, digests, sizes, and package roots relative to destination
+ * with their names and versions. Source paths and destination are excluded from that digest.
+ * Options contains canonical destination paths and preserves nested node_modules and distinct
+ * physical copies of one package. Members include non-entry dependencies and explicit assets.
+ * This value proves copying and verification, not successful adapter validation or publication.
+ */
+export declare interface ArtifactClosure {
+    readonly destination: string;
+    readonly digest: string;
+    readonly options: ArtifactLoaderOptions;
+    readonly members: readonly ArtifactMember[];
+}
+
 /** Reports an invalid or drifted artifact inventory. */
 export declare class ArtifactError extends Error {
-    readonly code: "ARTIFACT";
+    readonly code: ArtifactErrorCode;
     /** Records the refused artifact boundary.
      * @param message - The specific refusal.
+     * @param code - The refused boundary. Default: ARTIFACT.
      */
-    constructor(message: string);
+    constructor(message: string, code?: ArtifactErrorCode);
 }
 
+/** Names the refused boundary of a captured or materialized artifact graph. */
+export declare type ArtifactErrorCode = 'ARTIFACT' | 'TRAVERSAL' | 'REDIRECT' | 'ALIAS' | 'NAME' | 'DUPLICATE' | 'OCCUPIED' | 'OVERLAP' | 'STALE' | 'VOLUME' | 'DRIFT' | 'LIMIT';
+
 /** Records the exact bytes admitted at one absolute file path. */
 export declare interface ArtifactFile {
     readonly path: string;
@@ -75,14 +139,16 @@ export declare interface ArtifactInventory {
     readonly source?: ArtifactSourceOptions;
     readonly instrument?: string;
     readonly files: readonly ArtifactFile[];
+    /** Binds explicit custody-only selections independently of executable entries. */
+    readonly assets?: readonly string[];
 }
 
 /** 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
+ * Loads trusted code without sandboxing untrusted code. Native process APIs, eval and external
  * services are not replayed. One inventory may load per process; terminate it afterwards.
  */
-export declare class ArtifactLoader {
+export declare class ArtifactLoader implements ArtifactLoaderInterface {
     #private;
     /** Captures selections without reading or executing selected modules.
      * @param options - Canonical built selections and optional consumer source selection.
@@ -103,6 +169,43 @@ export declare class ArtifactLoader {
      * @throws Thrown for drift, unsupported edges, evaluation failures, or a reused worker.
      */
     load(entry: string): Promise<unknown>;
+    /** Copies the inspected physical forest into an exclusive absent destination.
+     * @param destination - The canonical absent absolute directory under an existing physical parent.
+     * @returns The independently verified copied membership and relocated selections.
+     * @throws ArtifactError - Thrown at the refused path, stale-source, volume, or drift boundary.
+     */
+    materialize(destination: string): Promise<ArtifactClosure>;
+}
+
+/** Captures, verifies, loads, and materializes one admitted physical artifact graph. */
+export declare interface ArtifactLoaderInterface {
+    /** Captures the complete admitted population without evaluating modules.
+     * @returns The immutable inventory and runtime identity.
+     */
+    inspect(): ArtifactInventory;
+    /** Refuses changed bytes or membership after inspection.
+     * @returns Nothing when the inspected population still matches.
+     */
+    verify(): void;
+    /** Loads an admitted entry through captured-byte hooks in a fresh process.
+     * @param entry - The canonical selected module path.
+     * @returns The actual module namespace.
+     */
+    load(entry: string): Promise<unknown>;
+    /** Copies the inspected physical forest into an exclusive absent destination.
+     * @remarks
+     * Preserves relative resolution and duplicate package copies. Refuses different source or
+     * destination volumes, overlapping or occupied destinations, redirected ancestors, aliases, unsafe names,
+     * duplicate keys, traversal, and stale source references before copying through them. Applies
+     * the aggregate ARTIFACT limits to the whole population, verifies source before and after copy,
+     * and independently verifies destination bytes and membership before returning. Separate path
+     * checks and reads do not establish an atomic snapshot or concurrent hardlink-race resistance.
+     * This operation writes no completion marker; freeze validates in a fresh captured child first.
+     * @param destination - The absolute absent directory under an existing physical parent.
+     * @returns The verified relocation and complete physical membership.
+     * @throws ArtifactError - Thrown with the refused boundary's ArtifactErrorCode.
+     */
+    materialize(destination: string): Promise<ArtifactClosure>;
 }
 
 /** Selects built packages and an optional separate consumer source graph. */
@@ -114,11 +217,23 @@ export declare interface ArtifactLoaderOptions {
     readonly instrument?: string;
     /** Refuses these built files at every import edge; the inventory identity is unchanged. */
     readonly excluded?: readonly string[];
+    /** Admits explicitly selected canonical regular files without granting import eligibility. */
+    readonly assets?: readonly string[];
 }
 
 /** Names Node's synchronous loading continuation. */
 export declare type ArtifactLoadHandler = Parameters<LoadHookSync>[2];
 
+/** Maps one admitted physical file to its exact bytes inside a materialized forest. */
+export declare interface ArtifactMember {
+    /** Names the canonical source path retained as provenance, never used for relocated loading. */
+    readonly source: string;
+    /** Names a portable slash-separated key relative to the closure destination. */
+    readonly key: string;
+    readonly digest: string;
+    readonly size: number;
+}
+
 /** Records the identity declared by an admitted package manifest. */
 export declare interface ArtifactPackage {
     readonly root: string;
@@ -143,7 +258,7 @@ export declare interface ArtifactSource extends ArtifactFile {
 }
 
 /** 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.
+ * @remarks Source JSON assets are not executable imports; explicitly selected assets retain custody only.
  */
 export declare interface ArtifactSourceOptions {
     readonly root: string;
@@ -174,6 +289,44 @@ export declare function buildStudyAgentReadings(result: unknown): JSONValue;
  */
 export declare function buildStudyAgentRevision(request: ProviderRequest): string | undefined;
 
+/**
+ * Builds the JSON evidence form of an Agent tool call the Agent denied before dispatch.
+ * @param call - The call received from the admitted Agent
+ * @param reason - The denial reason, retained only when it is a string
+ * @returns The call identity with the optional string reason
+ * @throws StudyError - Thrown with code `FAULT` when the call is malformed
+ * @example
+ * ```ts
+ * buildStudyAgentToolDenial(call, 'refused')
+ * ```
+ */
+export declare function buildStudyAgentToolDenial(call: unknown, reason: unknown): JSONValue;
+
+/**
+ * Builds the JSON evidence form of an Agent tool call and its executed result.
+ * @param call - The call received from the admitted Agent
+ * @param result - The executed tool result
+ * @returns The call identity, owned arguments, success, and owned value or error text
+ * @throws StudyError - Thrown with code `FAULT` when the call, result, arguments, or value is malformed
+ * @example
+ * ```ts
+ * buildStudyAgentToolResult(call, { success: true, value: 'stored' })
+ * ```
+ */
+export declare function buildStudyAgentToolResult(call: unknown, result: unknown): JSONValue;
+
+/** Projects the declaration onto its complete ordered HTTP identity population.
+ * @param declaration - The validated opening row.
+ * @returns Maintenance, preflight, model and postflight identities in declaration order.
+ */
+export declare function buildStudyExchangeSequence(declaration: StudyExchangeDeclaration): readonly StudyExchangeIdentity[];
+
+/** Encodes exact application bytes with their decoded size and SHA-256 identity.
+ * @param bytes - The request or response application bytes.
+ * @returns Canonical base64 and the independent byte receipt.
+ */
+export declare function buildStudyOllamaBytes(bytes: Uint8Array): StudyExchangeBytes;
+
 /**
  * Declares the pinned serving identities the Ollama transport verifies, keyed by the label their inventory evidence carries.
  * @param provider - Declared serving identities
@@ -224,8 +377,8 @@ export declare function buildStudyOllamaTiming(timing: OllamaTiming | undefined)
  * 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.
+ * copied and frozen; the caller's objects are never frozen. The cancellation signal, timing
+ * extractor, and fetch collaborator keep their live identity.
  * @param options - The caller's transport configuration
  * @returns The owned configuration, not yet validated
  */
@@ -312,6 +465,14 @@ export declare function collectStudyEntries(profile: StudyProfile): readonly str
  */
 export declare function collectStudyEvidence(result: StudySealedResult): Promise<Readonly<Record<string, readonly StudyEvidence[]>>>;
 
+/** Computes a destination-independent digest of members and relative package identities.
+ * @param members - Complete copied membership, with source provenance excluded from identity.
+ * @param packages - Package identities with relocated roots.
+ * @param destination - The common destination directory.
+ * @returns The portable SHA-256 identity.
+ */
+export declare function computeArtifactClosureDigest(members: readonly ArtifactMember[], packages: readonly ArtifactPackage[], destination: string): string;
+
 /**
  * Groups failed records by cause, role, and layer, each group carrying its source readings.
  * @remarks
@@ -504,12 +665,40 @@ export declare function gradeStudyEvidence(input: StudyAdjudication, grade: Stud
  */
 export declare function hashStudyBytes(input: string | Uint8Array): string;
 
+/** Checks a bounded materialization record before any path is used.
+ * @param value - The decoded record.
+ * @returns True if its selections and member records have the declared shapes; false otherwise.
+ */
+export declare function isArtifactClosure(value: unknown): value is ArtifactClosure;
+
 /** Narrows a caught value to an artifact refusal.
+ * @remarks
+ * Recognizes subclasses and other module copies by an own identity brand and valid members.
+ * The brand is a recognition marker. A transparent proxy, a look-alike without the brand,
+ * throwing accessors, and revoked proxies return false.
  * @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 key names portable, non-credential members within a closure.
+ * @param value - The untrusted slash-separated key.
+ * @returns True if every segment is safe and contained; false otherwise.
+ */
+export declare function isArtifactKey(value: unknown): value is string;
+
+/** Checks the bounded loader selections retained in a publication.
+ * @param value - The decoded selections.
+ * @returns True if required selections and optional groups have their declared shapes; false otherwise.
+ */
+export declare function isArtifactLoaderOptions(value: unknown): value is ArtifactLoaderOptions;
+
+/** Checks the exact file identity and provenance of a closure member.
+ * @param value - The decoded member.
+ * @returns True if the member has a safe key, source, digest and bounded size; false otherwise.
+ */
+export declare function isArtifactMember(value: unknown): value is ArtifactMember;
+
 /** 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.
@@ -544,6 +733,12 @@ export declare function isStudyAgentResponse(value: unknown): value is StudyAgen
  */
 export declare function isStudyCharge(value: unknown): value is StudyCharge;
 
+/** Checks a closure publication before using its command inputs.
+ * @param value - The decoded closure.json value.
+ * @returns True if relocation, selectors, and both identities are declared; false otherwise.
+ */
+export declare function isStudyClosure(value: unknown): value is StudyClosure;
+
 /**
  * Checks whether an attempt terminally accounts for the exact scheduled goal horizon.
  * @param value - The candidate attempt
@@ -657,6 +852,48 @@ export declare function isStudyCustodyTrial(value: unknown): value is StudyTrial
  */
 export declare function isStudyEvidence(value: unknown): value is StudyEvidence;
 
+/** Checks whether encoded body bytes have their exact canonical base64 and SHA-256 identity.
+ * @param value - The candidate byte envelope.
+ * @returns True if decoded length and digest match; false otherwise.
+ */
+export declare function isStudyExchangeBytes(value: unknown): value is StudyExchangeBytes;
+
+/** Checks whether the opening row declares a finite ordered procedure and serving identities.
+ * @param value - The candidate declaration.
+ * @returns True if all declared populations are valid; false otherwise.
+ */
+export declare function isStudyExchangeDeclaration(value: unknown): value is StudyExchangeDeclaration;
+
+/** Checks whether a worker destination has an absolute sidecar path and finite reservation.
+ * @param value - The decoded destination.
+ * @returns True if its path, allowance and optional retained identity are valid; false otherwise.
+ */
+export declare function isStudyExchangeDestination(value: unknown): value is StudyExchangeDestination;
+
+/** Checks whether a history has verified row shapes before its complete relational validation.
+ * @param value - The candidate history.
+ * @returns True if its envelopes and rows have valid types; false otherwise.
+ */
+export declare function isStudyExchangeHistory(value: unknown): value is StudyExchangeHistory;
+
+/** Checks whether an exchange carries an admissible ordered HTTP identity.
+ * @param value - The candidate identity.
+ * @returns True if identity and stage fields are valid; false otherwise.
+ */
+export declare function isStudyExchangeIdentity(value: unknown): value is StudyExchangeIdentity;
+
+/** Checks whether a retained reply describes bounded successful application bytes and chunks.
+ * @param value - The candidate reply.
+ * @returns True if status, selected headers and chunk lengths are valid; false otherwise.
+ */
+export declare function isStudyExchangeReply(value: unknown): value is StudyExchangeReply;
+
+/** Checks whether a sidecar row has exactly its declared fields and verified byte identities.
+ * @param value - The candidate row.
+ * @returns True if the row belongs to the closed sidecar grammar; false otherwise.
+ */
+export declare function isStudyExchangeRow(value: unknown): value is StudyExchangeRow;
+
 /** 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.
@@ -669,12 +906,42 @@ export declare function isStudyFrame(value: unknown): value is StudyFrame;
  */
 export declare function isStudyIdentity(value: unknown): value is StudyIdentity;
 
+/** Checks whether a value declares independent positive metadata allowances.
+ * @param value - The untrusted metadata declaration.
+ * @returns True if the declaration has positive safe calls and bytes and finite duration; false otherwise.
+ */
+export declare function isStudyOllamaMetadata(value: unknown): value is StudyOllamaMetadata;
+
+/** Checks whether a value pins a served model name and SHA-256 digest.
+ * @param value - The untrusted model pin.
+ * @returns True if the value declares a nonempty name and lowercase SHA-256 digest; false otherwise.
+ */
+export declare function isStudyOllamaModel(value: unknown): value is StudyOllamaModel;
+
+/** Checks whether a value declares a complete finite model-generation policy.
+ * @param value - The untrusted role policy.
+ * @returns True if every policy member and output allowance is valid; false otherwise.
+ */
+export declare function isStudyOllamaPolicy(value: unknown): value is StudyOllamaPolicy;
+
+/** Checks whether a value declares exclusive exact or capture admission with a valid receipt.
+ * @param value - The untrusted ordered step.
+ * @returns True if identity, policy, admission shape and exact receipt are valid; false otherwise.
+ */
+export declare function isStudyOllamaStep(value: unknown): value is StudyOllamaStep;
+
 /** 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 whether replay explicitly selects a sealed directory and per-trial prefix counts.
+ * @param value - The decoded replay selection.
+ * @returns True if result, offline and every prefix are declared; false otherwise.
+ */
+export declare function isStudyReplaySelection(value: unknown): value is StudyOllamaReplaySelection;
+
 /** Checks a fresh trial's declared identifiers.
  * @param value - Decoded trial.
  * @returns True if every identifier and repetition is valid; false otherwise.
@@ -687,6 +954,29 @@ export declare function isStudyTrial(value: unknown): value is StudyTrial;
  */
 export declare function iterateArtifactEntries(handle: Dir): Generator<Dirent, void>;
 
+/** Checks whether a portable segment identifies credentials.
+ * @param value - One untrusted path segment.
+ * @returns True if the segment has a credential filename; false otherwise.
+ */
+export declare function matchesArtifactCredential(value: string): boolean;
+
+/** Reports whether a caught value is a Node error carrying the given system code.
+ * @remarks Requires an `Error` from this realm. Structured cloning, such as a worker's `postMessage`,
+ * drops a Node error's system code, so the cloned error does not match.
+ * @param value - The caught value.
+ * @param code - The system error code to match.
+ * @returns True if the value is an Error from this realm carrying the code; false otherwise.
+ * @example Match a system error
+ * ```ts
+ * import { matchesSystemError } from '@orkestrel/study/server'
+ *
+ * const error = Object.assign(new Error('Missing declaration'), { code: 'ENOENT' })
+ * matchesSystemError(error, 'ENOENT') // true
+ * matchesSystemError({ code: 'ENOENT' }, 'ENOENT') // false
+ * ```
+ */
+export declare function matchesSystemError(value: unknown, code: string): boolean;
+
 /** Parses public command tokens with operation-specific grammar diagnostics.
  * @param arguments_ - Exact command tokens, after the CLI help boundary.
  * @returns The independent operation request.
@@ -700,6 +990,12 @@ export declare function iterateArtifactEntries(handle: Dir): Generator<Dirent, v
  */
 export declare function parseStudyArguments(arguments_: readonly string[]): StudyCommandRequest;
 
+/** Projects only the repeated identity fields of a retained HTTP exchange.
+ * @param identity - The row whose body and lifecycle fields are omitted.
+ * @returns The identity repeated by its attempt and terminal.
+ */
+export declare function projectStudyExchangeIdentity(identity: StudyExchangeIdentity): StudyExchangeIdentity;
+
 /** 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.
@@ -716,6 +1012,13 @@ export declare function readArtifact(path: string, maximum?: number): ArtifactSo
  */
 export declare function readArtifactBytes(descriptor: number, target: Buffer, offset?: number): Buffer;
 
+/** Checks every existing physical ancestor before using a canonical absolute path.
+ * @param path - The existing absolute file or directory.
+ * @returns Its physical filesystem metadata.
+ * @throws ArtifactError - Thrown for traversal, unsafe names, aliases or redirects before reading bytes.
+ */
+export declare function readArtifactPhysical(path: string): BigIntStats;
+
 /** Reads a complete adapter from an admitted module namespace.
  * @param namespace - The captured consumer module.
  * @returns The validated adapter instance.
@@ -741,6 +1044,23 @@ export declare function readStudyAgentMessages(value: unknown): readonly JSONVal
  */
 export declare function readStudyAgentResult(stream: AsyncGenerator<ProviderDelta, ProviderResult>): Promise<ProviderResult>;
 
+/**
+ * Reads an Agent tool call into a validated envelope from one read of each foreign field.
+ * @remarks The returned envelope owns its fields; arguments retain their original record identity.
+ * JSON validation and copying belong to the executed-result projection.
+ * @param call - The call received from the admitted Agent
+ * @returns A fresh ToolCall envelope with the original arguments record
+ * @throws StudyError - Thrown with code `FAULT` when a field cannot be read or the envelope is malformed
+ * @example Read an Agent tool call
+ * ```ts
+ * import { readStudyAgentToolCall } from '@orkestrel/study/server'
+ *
+ * const call = readStudyAgentToolCall({ id: 'c1', name: 'write', arguments: { path: 'note.txt' } })
+ * // { id: 'c1', name: 'write', arguments: { path: 'note.txt' } }
+ * ```
+ */
+export declare function readStudyAgentToolCall(call: unknown): ToolCall;
+
 /**
  * Reads bounded regular-file bytes without following a symbolic link.
  * @param path - The custody file path
@@ -754,6 +1074,60 @@ export declare function readStudyAgentResult(stream: AsyncGenerator<ProviderDelt
  */
 export declare function readStudyBytes(path: string, limit: number): Promise<Uint8Array>;
 
+/** Reads and independently verifies an exclusively published closure.
+ * @param directory - The canonical closure destination.
+ * @returns The verified publication and its copied physical forest.
+ * @throws StudyError - Thrown when publication or its command inputs are invalid.
+ */
+export declare function readStudyClosure(directory: string): StudyClosure;
+
+/** Reads a study declaration, its driver's scenarios, and its rubric as the command resolves them.
+ * @param root - The consumer root containing the studies directory.
+ * @param study - The selected study name.
+ * @param signal - Optional cancellation checked between scenario reads.
+ * @returns The parsed declaration, driver bundle, ordered scenarios, fixtures, and selected rubric.
+ * @throws StudyError - Thrown when declarations are missing, invalid, or incompatible.
+ * @example Read a study declaration
+ * ```ts
+ * import type { StudyDeclaration } from '@orkestrel/study/server'
+ * import { readStudyDeclaration } from '@orkestrel/study/server'
+ *
+ * declare const root: string
+ * const declaration: StudyDeclaration = await readStudyDeclaration(root, 'assessment')
+ * ```
+ */
+export declare function readStudyDeclaration(root: string, study: string, signal?: AbortSignal): Promise<StudyDeclaration>;
+
+/** Reads one declaration file and refuses a missing or linked path with its root-relative path.
+ * @param root - The consumer root used to describe a missing or linked declaration.
+ * @param path - The already resolved and contained declaration path.
+ * @returns The exact declaration bytes under the custody metadata allowance.
+ * @throws StudyError - Thrown with code `CONFIG` when the path is missing or linked; other custody refusals retain their codes.
+ * @example Read declaration bytes
+ * ```ts
+ * import { readStudyDeclarationBytes } from '@orkestrel/study/server'
+ *
+ * declare const root: string
+ * declare const path: string
+ * await readStudyDeclarationBytes(root, path)
+ * ```
+ */
+export declare function readStudyDeclarationBytes(root: string, path: string): Promise<Uint8Array>;
+
+/** Reads strict complete LF-framed exchange rows with verified bodies and declaration joins.
+ * @param bytes - The bounded retained sidecar bytes.
+ * @param complete - If true, requires completion; if false, admits a verified unfinished prefix.
+ * @returns Owned rows in physical order.
+ */
+export declare function readStudyExchangeRows(bytes: Uint8Array, complete?: boolean): readonly StudyExchangeRow[];
+
+/** Reads a sealed trial's exact complete exchange history after reverifying its entire result.
+ * @param result - The sealed execution selected for replay.
+ * @param trial - The scheduled trial id.
+ * @returns Complete ordered request and response pairs with their verified file and seal identities.
+ */
+export declare function readStudyExchanges(result: StudySealedResult, trial: string): Promise<StudyExchangeHistory>;
+
 /**
  * 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
@@ -825,6 +1199,28 @@ export declare function readStudyOllamaTerminal(value: unknown, request: StudyOl
  */
 export declare function readStudyOllamaTiming(extract: StudyOllamaTransportOptions['timing'], record: Readonly<Record<string, unknown>>): OllamaTiming | undefined;
 
+/** Validates parent preparation output without permitting a destination or allowance substitution.
+ * @param original - The parent-reserved destination, or undefined without recording.
+ * @param prepared - The callback's retained destination.
+ * @returns The validated destination for the worker.
+ */
+export declare function readStudyPreparedDestination(original: StudyExchangeDestination | undefined, prepared: StudyExchangeDestination | undefined): StudyExchangeDestination | undefined;
+
+/** Reads the executing profile's explicit recording declarations before a worker starts.
+ * @param profile - The validated executing profile.
+ * @param trial - The scheduled trial identity.
+ * @returns A validated opening row, with no inferred metadata or replay allowance.
+ */
+export declare function readStudyRecordingDeclaration(profile: StudyProfile, trial: StudyTrial): StudyExchangeDeclaration;
+
+/** Rechecks the sealed source and this trial's prefix under the executing profile declaration.
+ * @param selection - The explicit sealed source and offline behavior.
+ * @param profile - The executing profile, whose bounds remain authoritative.
+ * @param trial - The trial whose history must be present.
+ * @returns Complete verified history before any dependent sender or worker starts.
+ */
+export declare function readStudyReplayHistory(selection: StudyOllamaReplaySelection, profile: StudyProfile, trial: StudyTrial): Promise<StudyExchangeHistory>;
+
 /**
  * Inspects custody bytes offline and verifies complete execution before grading.
  * @param directory - The result directory
@@ -837,6 +1233,37 @@ export declare function readStudyOllamaTiming(extract: StudyOllamaTransportOptio
  */
 export declare function readStudyResult(directory: string): Promise<StudyResultReading>;
 
+/** Reads and joins a complete trial sidecar before or after sealing.
+ * @param directory - The result directory.
+ * @param manifest - The verified manifest declaring recording and bounds.
+ * @param trial - The exact scheduled trial id.
+ * @param file - The inventory identity read for this sidecar.
+ * @returns Complete rows after byte, declaration and evidence joins.
+ */
+export declare function readStudyTrialExchanges(directory: string, manifest: StudyManifest, trial: string, file: StudyFile): Promise<readonly StudyExchangeRow[]>;
+
+/** Reads the version of the study package that owns an executable entry.
+ * @param entry - The installed runtime's executable entry.
+ * @returns The non-empty version declared by the owning study package.
+ * @throws StudyError - Thrown when no study package owns the entry or its version is absent or empty.
+ * @example Read the installed version
+ * ```ts
+ * import { readStudyVersion } from '@orkestrel/study/server'
+ *
+ * declare const entry: string
+ * readStudyVersion(entry)
+ * ```
+ */
+export declare function readStudyVersion(entry: string): string;
+
+/** Relocates an original path through a closure's retained physical forest.
+ * @param closure - The verified closure record.
+ * @param path - An original member or ancestor within its forest.
+ * @returns The corresponding destination path.
+ * @throws ArtifactError - Thrown when provenance or containment is inconsistent.
+ */
+export declare function relocateArtifactPath(closure: ArtifactClosure, path: string): string;
+
 /** Enforces captured inventory membership at every synchronous native import edge. */
 export declare class Resolution {
     #private;
@@ -860,6 +1287,21 @@ export declare class Resolution {
     load(href: string, context: LoadHookContext, next: ArtifactLoadHandler): LoadFnOutput;
 }
 
+/** Finds the common physical parent that preserves every selected path's relative resolution.
+ * @param paths - Existing absolute members or selected roots on one volume.
+ * @returns Their common ancestor directory.
+ * @throws ArtifactError - Thrown when selections span volumes or contain no files.
+ */
+export declare function resolveArtifactBase(paths: readonly string[]): string;
+
+/** Resolves a portable member key without traversing outside its destination.
+ * @param destination - The canonical absolute destination.
+ * @param key - The slash-separated member key.
+ * @returns The contained host path.
+ * @throws ArtifactError - Thrown for traversal or an unsafe name.
+ */
+export declare function resolveArtifactMember(destination: string, key: string): string;
+
 /**
  * Resolves the content a scripted response serves, from its declaration or from a prior tool message.
  * @param request - The projected actual request messages
@@ -869,6 +1311,14 @@ export declare class Resolution {
  */
 export declare function resolveStudyAgentContent(request: readonly JSONValue[], response: StudyAgentResponse): string;
 
+/** Resolves a profile path through a retained physical relocation when selected.
+ * @param root - The active consumer root.
+ * @param path - The profile's absolute or consumer-relative selection.
+ * @param closure - The optional verified physical forest.
+ * @returns The active canonical selection.
+ */
+export declare function resolveStudyClosurePath(root: string, path: string, closure?: ArtifactClosure): 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.
@@ -892,13 +1342,14 @@ export declare function resolveStudyPath(directory: string, path: string): strin
  * Resolves the execution profile's caller-selected built artifact paths.
  * @param root - The repository root
  * @param profile - The validated source profile
+ * @param closure - The optional verified physical forest used to relocate executable selections
  * @returns The reproducible resolved execution profile
  * @example
  * ```ts
  * resolveStudyProfile(root, profile)
  * ```
  */
-export declare function resolveStudyProfile(root: string, profile: StudyProfile): StudyProfile;
+export declare function resolveStudyProfile(root: string, profile: StudyProfile, closure?: ArtifactClosure): StudyProfile;
 
 /**
  * Scans regular execution files while refusing unknown directories and linked paths.
@@ -922,7 +1373,7 @@ export declare function scanStudyExecution(directory: string, manifest: StudyMan
  * @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[]>;
+export declare function scanStudyTree(directory: string, prefix: string, known: ReadonlySet<string>, allowance: number, recording?: boolean): Promise<readonly StudyFile[]>;
 
 /** Caps declared execution duration at the native supervisor's host ceiling. */
 export declare const STUDY_COMMAND_DURATION = 86400000;
@@ -931,7 +1382,7 @@ export declare const STUDY_COMMAND_DURATION = 86400000;
 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";
+export declare const STUDY_COMMAND_HELP = "study check <study> [--profile <name>] [--closure <directory>]\nstudy freeze <study> --profile <name> --to <directory>\nstudy execute <study> [--profile <name>] [--out <path>] [--expected <sha256>] [--closure <directory>] [--replay <result> --prefix <JSON trial counts> --offline <true|false>]\nstudy grade <result> --rubric <path>\nstudy label <result> --grading <sha256> --labels <path>\nstudy report <result> --grading <sha256>\nstudy --help\nstudy --version\n\nProfiles default to local; freeze requires --profile. 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.\n--closure selects retained artifacts. Replay requires explicit prefix counts and offline behavior.\nSuccess writes one JSON document; next contains suggested argv, never executed automatically.\ncheck, freeze, 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";
@@ -1010,21 +1461,6 @@ export declare interface StudyAdjudication {
     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;
 
@@ -1036,14 +1472,6 @@ export declare interface StudyAgentPlan {
     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
@@ -1067,19 +1495,6 @@ export declare interface StudyAgentResponse {
 /** 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;
@@ -1302,6 +1717,8 @@ export declare interface StudyArtifactLoaderOptions {
     readonly root: string;
     readonly profile: StudyProfile;
     readonly adapter: string;
+    /** Selects relocated captured bytes and their checked identity instead of original paths. */
+    readonly closure?: StudyClosure;
 }
 
 /** Holds actual namespaces loaded only during worker execution. */
@@ -1311,16 +1728,6 @@ export declare interface StudyArtifactModule {
     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
@@ -1334,22 +1741,6 @@ export declare interface StudyAttributionSource {
     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;
@@ -1381,13 +1772,6 @@ export declare interface StudyChannelOptions {
     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;
@@ -1402,6 +1786,26 @@ export declare class StudyCLI {
     execute(arguments_: readonly string[]): Promise<number>;
 }
 
+/** Publishes a validated closure with relocated command inputs and execution provenance.
+ * @remarks
+ * Freeze writes this value as closure.json exclusively only after a fresh captured check and
+ * verification of both source and destination. Root and entry are relocated canonical paths;
+ * target and profile retain their command selectors. Source is the pre-copy execution identity,
+ * identity is the checked relocated identity, and fingerprint is the relocated check result.
+ * Closure.json is a publication marker outside the copied-member census, never an admitted
+ * executable or source asset. Its sole permitted presence must not hide any other addition.
+ */
+export declare interface StudyClosure {
+    readonly closure: ArtifactClosure;
+    readonly root: string;
+    readonly entry: string;
+    readonly target: string;
+    readonly profile: string;
+    readonly source: StudyIdentity;
+    readonly identity: StudyIdentity;
+    readonly fingerprint: string;
+}
+
 /** Executes validated study operations with execution and grading custody kept independent. */
 export declare class StudyCommand {
     #private;
@@ -1433,67 +1837,7 @@ export declare interface StudyCommandOptions {
 }
 
 /** 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;
-}
+export declare type StudyCommandRequest = StudyExecutionRequest | StudyFreezeRequest | StudyGradeRequest | StudyLabelRequest | StudyReportRequest;
 
 /** Holds the evidence sink's shared admission budget. */
 export declare interface StudyCustodyBudget {
@@ -1511,28 +1855,85 @@ export declare interface StudyCustodySinkInterface extends StudySinkInterface {
     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;
+/** Owns the declared daemon and its serial trial preparation through permanent cleanup.
+ * @example
+ * ```ts
+ * const session = new StudyDaemonSession(options)
+ * try { await session.start() } finally { await session.stop() }
+ * ```
+ */
+export declare class StudyDaemonSession {
+    #private;
+    /** Captures resolved declarations without loading the daemon runtime.
+     * @param options - The execution profile, scenarios, workspace, and cancellation.
+     */
+    constructor(options: StudyDaemonSessionOptions);
+    /** Starts the daemon and returns its verified execution provenance.
+     * @returns The executable, endpoint, owned pid, and model receipt.
+     */
+    start(): Promise<OllamaDaemonIdentity>;
+    /** Unloads the declared population before opening one trial worker.
+     * @param trial - The scheduled trial.
+     * @param signal - The trial's cancellation.
+     * @param destination - The optional reserved recording destination.
+     * @returns The unchanged destination with its verified maintenance prefix when recording.
+     */
+    prepare(trial: StudyTrial, signal: AbortSignal, destination?: StudyExchangeDestination): Promise<StudyExchangeDestination | undefined>;
+    /** Stops and joins the owned tree and refuses an unconfirmed cleanup.
+     * @returns Completion after daemon and emitter teardown.
+     */
+    stop(): Promise<void>;
 }
 
-/** 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.
+/** Supplies the resolved provider, trial population, workspace, and execution cancellation. */
+export declare interface StudyDaemonSessionOptions {
+    readonly profile: StudyProfile;
+    readonly scenarios: readonly StudyScenario[];
+    readonly workspace: string;
+    readonly signal: AbortSignal;
+}
+
+/** Records one trial's daemon maintenance before handing its verified prefix to a worker.
+ * @example
+ * ```ts
+ * const trial = new StudyDaemonTrial(options)
+ * await trial.execute(daemon)
+ * ```
+ */
+export declare class StudyDaemonTrial {
+    #private;
+    /** Owns the declaration and reserved destination for one preparation.
+     * @param options - The immutable trial declaration, destination, and cancellation.
      */
-    open(trial: StudyTrial, signal: AbortSignal): Promise<StudySessionInterface>;
+    constructor(options: StudyDaemonTrialOptions);
+    /** Unloads declared models, drains the journal, and returns its exact retained identity.
+     * @remarks The daemon's unload sender must call this instance's fetch method. Startup metadata must forward without recording.
+     * @param daemon - The verified execution-owned daemon.
+     * @returns The original destination with its closed maintenance prefix identity.
+     */
+    execute(daemon: OllamaDaemonInterface): Promise<StudyExchangeDestination>;
+    /** Retains each request before sending and preserves the sender's native response chunks.
+     * @param input - The daemon's exact HTTP input.
+     * @param init - The daemon's method, body, redirect policy, and cancellation.
+     * @returns An unread response carrying the same body bytes for daemon validation.
+     */
+    fetch(input: Parameters<typeof globalThis.fetch>[0], init?: RequestInit): Promise<Response>;
+}
+
+/** Supplies one reserved sidecar and its complete maintenance declaration. */
+export declare interface StudyDaemonTrialOptions {
+    readonly destination: StudyExchangeDestination;
+    readonly declaration: StudyExchangeDeclaration;
+    readonly signal: AbortSignal;
+}
+
+/** Holds a parsed study declaration with its driver bundle, scenarios, scenario fixtures, and rubric. */
+export declare interface StudyDeclaration {
+    readonly bundle: string;
+    readonly definition: StudyDefinition;
+    readonly scenarios: readonly StudyScenario[];
+    readonly fixtures: readonly StudyCommandArtifact[];
+    readonly rubric: StudyRubric;
 }
 
 /** Supplies admitted modules and an exclusive scratch parent without grader truth. */
@@ -1542,29 +1943,10 @@ export declare interface StudyDriverOptions {
     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;
+    /** Supplies the worker-owned sidecar sink whenever the profile declares recording. */
+    readonly exchanges?: StudyExchangeSinkInterface;
+    /** Supplies verified replay whose fetch is passed to the transport inside this worker. */
+    readonly replay?: StudyOllamaReplayInterface;
 }
 
 /** Retains admitted evidence in order and closes admission before terminal records. */
@@ -1598,6 +1980,183 @@ export declare interface StudyEvidenceSinkOptions {
     readonly budget: StudyCustodyBudget;
 }
 
+/** Retains admitted request bytes durably before the corresponding send begins. */
+export declare interface StudyExchangeAttempt extends StudyExchangeIdentity, StudyExchangeBytes {
+    readonly phase: 'attempt';
+}
+
+/** Retains an application HTTP body's exact bytes independently of text decoding.
+ * @remarks
+ * Body is canonical base64, digest is lowercase SHA-256 of decoded bytes, and size is their safe
+ * byte count. An empty body has size zero and the digest of empty bytes. This representation
+ * retains no TLS records or HTTP transfer framing.
+ */
+export declare interface StudyExchangeBytes {
+    readonly body: string;
+    readonly digest: string;
+    readonly size: number;
+}
+
+/** Closes a sidecar after the declared procedure and postflight have fully completed.
+ * @remarks
+ * Count equals the complete HTTP exchange population. This final row is forbidden after a
+ * failed attempt, while a request or append is pending, or before all declared steps and both
+ * verification passes finish. The strict reader joins it to evidence before sealing.
+ */
+export declare interface StudyExchangeCompletion {
+    readonly phase: 'complete';
+    readonly count: number;
+}
+
+/** Declares the complete trial procedure before any exchange attempt is appended.
+ * @remarks
+ * This is the first sidecar row. Version and models pin both verification passes. Procedure
+ * contains every model step in order. Metadata declares an independent budget. Maintenance
+ * declares each model to unload before preflight; it is empty when no daemon is owned.
+ * Preflight and postflight each require version, tags, and one show per distinct model, in
+ * that order. No model attempt precedes preflight or follows postflight.
+ */
+export declare interface StudyExchangeDeclaration {
+    readonly phase: 'declaration';
+    readonly trial: string;
+    readonly version: string;
+    readonly models: Readonly<Record<string, StudyOllamaModel>>;
+    readonly metadata: StudyOllamaMetadata;
+    readonly procedure: readonly StudyOllamaStep[];
+    readonly maintenance: readonly StudyOllamaModel[];
+}
+
+/** Holds the parent-reserved destination of one trial's exchange sidecar.
+ * @remarks
+ * Path is absolute and ends in execution/trials/<trial>/exchanges.jsonl. The parent reserves
+ * record.bytes against series custody before the worker starts. Without retained, the worker
+ * opens the absent file exclusively. With retained, staging has closed a declaration and
+ * maintenance prefix; the worker verifies that file identity and resumes appending after it.
+ * Only file identities and declarations cross IPC, never a sidecar's recorded bodies.
+ */
+export declare interface StudyExchangeDestination {
+    readonly path: string;
+    readonly record: StudyRecord;
+    readonly retained?: StudyFile;
+}
+
+/** Retains an attempted exchange's failure and any bounded response bytes already observed.
+ * @remarks
+ * Response is absent when no reply arrived or its bytes did not fit the sidecar allowance; the
+ * reason names which. A retained response may contain an incomplete body. Failure
+ * preserves admitted charges and never invents completion, usage, or a successful terminal.
+ */
+export declare interface StudyExchangeFailure extends StudyExchangeIdentity {
+    readonly phase: 'failure';
+    readonly reason: string;
+    readonly response?: StudyExchangeReply;
+}
+
+/** Binds complete ordered exchanges to a verified sealed sidecar and its declaration.
+ * @remarks
+ * The strict reader verifies the seal and file digest, declared byte allowance, complete LF
+ * rows, declaration and completion, every request/response byte digest and size, contiguous
+ * order, stages, and the exact evidence-ordinal join before returning. Duplicate, orphaned,
+ * reordered, partial, failed, or unsealed histories refuse with CUSTODY. File names the exact
+ * member in the result seal; seal is that seal's id. An interface value alone is not proof of
+ * provenance, so a replay constructor validates these invariants again before dependent work.
+ */
+export declare interface StudyExchangeHistory {
+    readonly seal: string;
+    readonly file: StudyFile;
+    readonly declaration: StudyExchangeDeclaration;
+    readonly exchanges: readonly StudyRecordedExchange[];
+    readonly completion: StudyExchangeCompletion;
+}
+
+/** Binds one HTTP exchange to its trial-local position and declared execution stage.
+ * @remarks
+ * Ordinal is contiguous and one-based across all HTTP exchanges, including metadata and
+ * maintenance. Step is present only for execution and names the model procedure's ordinal.
+ * Goal names the declared goal whose evidence joins the exchange; pre-trial maintenance uses
+ * the trial's first declared goal. Path excludes origin, query, and fragment. Every attempt and
+ * terminal repeats this identity exactly, and dispatch and wire evidence retain ordinal even
+ * when passive observation is disabled.
+ */
+export declare interface StudyExchangeIdentity {
+    readonly ordinal: number;
+    readonly goal: string;
+    readonly role: StudyRole;
+    readonly path: '/api/chat' | '/api/generate' | '/api/version' | '/api/tags' | '/api/show';
+    readonly method: 'GET' | 'POST';
+    readonly stage: StudyOllamaStage;
+    readonly step?: number;
+}
+
+/** Retains response status, headers, and original application-body chunk lengths.
+ * @remarks
+ * Headers are ordered name/value pairs restricted to content-type and content-encoding; their
+ * encoded representation consumes the sidecar allowance. Chunks contains positive safe byte
+ * lengths whose sum equals size. Body retains the bytes fetch exposed before text decoding,
+ * so replay must not apply the original content encoding again.
+ */
+export declare interface StudyExchangeReply extends StudyExchangeBytes {
+    readonly status: number;
+    readonly headers: ReadonlyArray<readonly [string, string]>;
+    readonly chunks: readonly number[];
+}
+
+/** Retains a fully consumed response only after status and terminal validation succeed. */
+export declare interface StudyExchangeResponse extends StudyExchangeIdentity, StudyExchangeReply {
+    readonly phase: 'response';
+}
+
+/** Names every admitted row of the bounded per-trial exchange sidecar. */
+export declare type StudyExchangeRow = StudyExchangeDeclaration | StudyExchangeAttempt | StudyExchangeResponse | StudyExchangeFailure | StudyExchangeCompletion;
+
+/** Retains ordered exchange rows under a parent-reserved serialized byte allowance. */
+export declare class StudyExchangeSink implements StudyExchangeSinkInterface {
+    #private;
+    /** Owns the descriptor and restores a verified prefix without rewriting it.
+     * @param options - The exclusive descriptor, byte bound and optional retained rows.
+     */
+    constructor(options: StudyExchangeSinkOptions);
+    /** Holds the next contiguous one-based HTTP ordinal, including the retained prefix. */
+    get next(): number;
+    /** Appends one owned row after validating order and reserving its complete serialized size.
+     * @param row - The next declaration, attempt, terminal or completion.
+     * @returns Completion after synchronized retention; callers await each append before proceeding.
+     */
+    append(row: StudyExchangeRow): Promise<void>;
+    /** Closes admission, drains accepted writes and synchronizes the owned descriptor.
+     * @returns Completion after descriptor release, with a retained refusal propagated.
+     */
+    close(): Promise<void>;
+}
+
+/** Owns serialized exchange appends under a reserved trial byte allowance.
+ * @remarks
+ * Reserves bounded terminal-failure space before admitting an attempt, accounts JSON framing and
+ * base64 expansion before accepting bytes, and bounds pending append work through backpressure.
+ * The first custody refusal remains latched and prevents completion even if the caller catches it.
+ */
+export declare interface StudyExchangeSinkInterface {
+    /** Holds the next contiguous one-based HTTP ordinal, derived from every accepted row, including a retained prefix. */
+    readonly next: number;
+    /** Appends one validated row after reserving its complete serialized size.
+     * @param row - The next declaration, attempt, terminal, or completion in strict order.
+     * @returns Completion after the bytes are retained; a refusal stays latched.
+     */
+    append(row: StudyExchangeRow): Promise<void>;
+    /** Closes admission and synchronizes all admitted writes without inventing completion.
+     * @returns Completion after the descriptor closes, including on interrupted histories.
+     */
+    close(): Promise<void>;
+}
+
+/** Supplies an exclusive sidecar descriptor and its parent-reserved byte allowance. */
+export declare interface StudyExchangeSinkOptions {
+    readonly file: FileHandle;
+    readonly record: StudyRecord;
+    /** Restores append state from a strictly verified prefix on the owned descriptor, without rewriting it. */
+    readonly retained?: readonly StudyExchangeRow[];
+}
+
 /** Holds a checked execution selection with optional output custody. */
 export declare interface StudyExecutionRequest {
     readonly command: 'check' | 'execute';
@@ -1606,15 +2165,10 @@ export declare interface StudyExecutionRequest {
     /** 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;
+    /** Selects a published closure directory, reverified before captured validation and execution. */
+    readonly closure?: string;
+    /** Selects sealed exchanges and explicit trial prefixes before any dependent worker or daemon. */
+    readonly replay?: StudyOllamaReplaySelection;
 }
 
 /** Holds the exact byte identity of one execution file. */
@@ -1631,10 +2185,13 @@ export declare interface StudyFrame {
     readonly value: JSONValue;
 }
 
-/** Holds a declared goal's public input without its grading truth. */
-declare interface StudyGoal {
-    readonly id: string;
-    readonly input: JSONValue;
+/** Requests exclusive materialization and captured validation before publishing closure.json. */
+export declare interface StudyFreezeRequest {
+    readonly command: 'freeze';
+    readonly target: string;
+    readonly profile: string;
+    /** Names the absent absolute destination supplied by --to. */
+    readonly destination: string;
 }
 
 /** Reads one declared target against the consumer's domain predicate. */
@@ -1665,19 +2222,6 @@ export declare interface StudyGradeTarget {
     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;
@@ -1720,16 +2264,6 @@ export declare interface StudyGradingStoreOptions {
     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';
@@ -1738,26 +2272,6 @@ export declare interface StudyInterruptedResult {
     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';
@@ -1766,19 +2280,6 @@ export declare interface StudyLabelRequest {
     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;
@@ -1805,59 +2306,65 @@ export declare interface StudyLaunchResult {
     readonly output: string;
 }
 
-/**
- * Names the ceiling that stopped a run.
+/** Handles validated transport requests at their owning domain boundary. */
+export declare type StudyMessageHandler = (operation: StudyOperation, value: JSONValue) => Promise<JSONValue>;
+
+/** Holds one active goal's accounting and attribution. */
+export declare interface StudyOllamaActivity {
+    readonly goal: string;
+    readonly context: StudyContext;
+    /** Holds the public view retained with the goal's first observed dispatch; undefined omits that view and observed request bodies independently of exchange recording. */
+    readonly checkpoint: JSONValue | undefined;
+}
+
+/** Declares a captured request's positive safe byte length without predicting its content.
  * @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.
+ * Body and input are forbidden own members, including explicit undefined at runtime. Capture
+ * proves declared identity, policy, and encoded length; it makes no content-fidelity claim.
  */
-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;
+export declare interface StudyOllamaCaptureStep extends StudyOllamaStepIdentity {
+    readonly admission: 'capture';
     readonly bytes: number;
+    readonly body?: never;
+    readonly input?: never;
 }
 
-/** 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>>;
+/** Declares an exact UTF-8 request body and its SHA-256 input receipt.
+ * @remarks
+ * Body is compared byte for byte, never as parsed JSON or by length alone. Input is a SHA-256
+ * receipt of the encoded body, verified before execution rather than trusted in place of bytes.
+ * Encoded length is derived from body, so an independent bytes declaration is forbidden.
+ */
+export declare interface StudyOllamaExactStep extends StudyOllamaStepIdentity {
+    readonly admission: 'exact';
+    readonly body: string;
+    readonly input: string;
+    readonly bytes?: never;
 }
 
-/** Handles validated transport requests at their owning domain boundary. */
-export declare type StudyMessageHandler = (operation: StudyOperation, value: JSONValue) => Promise<JSONValue>;
+/**
+ * Sends one validated, admitted request under its Study role and returns the native response.
+ * @remarks
+ * Study owns response validation, cancellation, accounting, and the failure latch. The collaborator
+ * receives the validated URL, encoded body, headers, bounded signal, and redirect policy;
+ * it never settles a Study ticket.
+ * @param role - The validated transport role, independent of the model name
+ * @param input - The validated request URL
+ * @param init - The owned request settings with the bounded signal and `redirect: 'error'`
+ * @returns The native response Study reads and accounts
+ */
+export declare type StudyOllamaFetchFunction = (role: StudyRole, input: string | URL, init: RequestInit) => Promise<Response>;
 
-/** 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[];
+/** Bounds metadata calls, encoded bytes, and elapsed milliseconds outside model quotas.
+ * @remarks
+ * Each allowance is positive and finite; calls and bytes are safe integers. This budget covers
+ * both verification passes across a trial and has no model-meter parent. The enclosing wall
+ * deadline and sidecar custody budget still apply. No default is inferred from model limits.
+ */
+export declare interface StudyOllamaMetadata {
+    readonly calls: number;
+    readonly bytes: number;
     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. */
@@ -1894,6 +2401,79 @@ export declare interface StudyOllamaPolicy {
     readonly length: boolean;
 }
 
+/** Answers declared HTTP prefixes from complete ordered recorded application bytes. */
+export declare class StudyOllamaReplay implements StudyOllamaReplayInterface {
+    #private;
+    /** Owns and revalidates the complete selected history before any sender can be reached.
+     * @param options - Verified history, explicit prefix, executing origin and independent bounds.
+     */
+    constructor(options: StudyOllamaReplayOptions);
+    /** Holds exact recorded bodies for model requests inside the declared prefix. */
+    get procedure(): readonly StudyOllamaStep[];
+    /** Supplies recorded native responses, forwarding only after the exact declared prefix.
+     * @param role - The validated Study responsibility.
+     * @param input - The executing origin and exact route.
+     * @param init - The method, encoded body and bounded signal.
+     * @returns The recorded response or the explicit live collaborator's response.
+     */
+    readonly fetch: StudyOllamaFetchFunction;
+    /** Refuses a mismatch, an unread response or an incompletely consumed prefix. */
+    check(): void;
+    /** Closes admission and cancels retained replay responses.
+     * @returns Completion after pending sends and owned readers settle.
+     */
+    close(): Promise<void>;
+}
+
+/** Answers an exact recorded prefix through the role-aware transport collaborator. */
+export declare interface StudyOllamaReplayInterface {
+    /** Holds model steps with recorded prefix bodies projected to exact admission. */
+    readonly procedure: readonly StudyOllamaStep[];
+    /** Supplies native responses over retained bytes without settling a Study ticket. */
+    readonly fetch: StudyOllamaFetchFunction;
+    /** Refuses a latched mismatch, an unread response, or an incompletely consumed prefix.
+     * @returns Nothing after the complete declared prefix has been consumed.
+     */
+    check(): void;
+    /** Closes admission and cancels or drains owned response readers.
+     * @returns Completion after all replay resources are released.
+     */
+    close(): Promise<void>;
+}
+
+/** Configures exact recorded replies and optional live continuation after a declared prefix.
+ * @remarks
+ * History must come from the strict sealed sidecar reader and be checked completely before
+ * construction, including declarations, byte digests, order, evidence joins, and completion.
+ * Url pins the executing origin. Prefix counts complete HTTP exchanges, not JSONL rows. Limit
+ * bounds replay work independently of recorded timing. Without fetch, the prefix must consume
+ * the entire history and all later requests refuse; no native sender or daemon is created.
+ * With fetch, only requests after the prefix are forwarded. A prefix mismatch never forwards.
+ */
+export declare interface StudyOllamaReplayOptions {
+    readonly history: StudyExchangeHistory;
+    readonly url: string;
+    readonly prefix: number;
+    readonly limit: StudyOllamaMetadata;
+    readonly signal: AbortSignal;
+    readonly fetch?: StudyOllamaFetchFunction;
+}
+
+/** Selects a sealed recording and an explicit replay prefix for every scheduled trial.
+ * @remarks
+ * Result names a sealed result directory. Prefix maps each trial id to its positive safe count
+ * of complete HTTP exchanges, including metadata and maintenance; each prefix ends at an
+ * exchange boundary. Offline true requires the complete recorded population and forbids daemon
+ * startup or a live sender. Offline false permits live continuation only after that prefix.
+ * A changed request inside the prefix always refuses. Replay uses the executing profile's
+ * bounds, never the recorded execution's elapsed-time allowance.
+ */
+export declare interface StudyOllamaReplaySelection {
+    readonly result: string;
+    readonly prefix: Readonly<Record<string, number>>;
+    readonly offline: boolean;
+}
+
 /** Holds validated wire dispatch facts without retaining payload text. */
 export declare interface StudyOllamaRequest {
     readonly role: StudyRole;
@@ -1928,6 +2508,27 @@ export declare interface StudyOllamaSnapshot {
     readonly dispatch: StudyAgentDispatch | undefined;
 }
 
+/** Names the ordered verification, model work, and daemon maintenance stages. */
+export declare type StudyOllamaStage = 'preflight' | 'execution' | 'postflight' | 'maintenance';
+
+/** Separates exact request admission from length-declared capture admission. */
+export declare type StudyOllamaStep = StudyOllamaExactStep | StudyOllamaCaptureStep;
+
+/** Declares an ordered model request's goal, responsibility, route, and wire policy.
+ * @remarks
+ * Ordinal is a positive, contiguous, one-based position among declared model steps in a trial.
+ * Metadata and maintenance have their own sidecar ordinals and consume no model-step position.
+ * Path is /api/chat for agent or summary and /api/generate for judge. Goal must be a declared
+ * member of the trial. Policy is checked before body collection and again before sending.
+ */
+export declare interface StudyOllamaStepIdentity {
+    readonly ordinal: number;
+    readonly goal: string;
+    readonly role: StudyOllamaRole;
+    readonly path: '/api/chat' | '/api/generate';
+    readonly policy: StudyOllamaPolicy;
+}
+
 /** Holds a validated terminal's finish reason and actual usage, unknown when unreported. */
 export declare interface StudyOllamaTerminal {
     readonly prompt: number | undefined;
@@ -1989,21 +2590,44 @@ export declare class StudyOllamaTransport implements StudyLatchInterface {
  * 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.
+ * correlation fields; if `false`, passive fields are absent. Recording always retains exchange
+ * ordinals and raw bytes independently of observation. `timing` extracts daemon timing; the selected Ollama runtime supplies the extractor and the transport imports none.
+ * `fetch` optionally sends the validated request under its role. Default: native fetch. Study keeps
+ * response validation and accounting; the collaborator returns a native response and settles no ticket.
  */
 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 roles: Readonly<Partial<Record<StudyOllamaRole, StudyOllamaPolicy>>> & {
+        /** Forbids a model-generation policy for daemon maintenance. */
+        readonly maintenance?: never;
+    };
     readonly signal: AbortSignal;
     readonly observe: boolean;
     readonly timing: typeof extractTiming;
+    readonly fetch?: StudyOllamaFetchFunction | undefined;
+    /** Bounds both metadata passes independently of every model quota. */
+    readonly metadata: StudyOllamaMetadata;
+    /** Pins GET /api/version before and after model execution; required with recording. */
+    readonly version?: string;
+    /** Declares every ordered model step; present together with exchanges and version. */
+    readonly procedure?: readonly StudyOllamaStep[];
+    /** Retains exact bytes regardless of observe or checkpoint; present together with procedure. */
+    readonly exchanges?: StudyExchangeSinkInterface;
 }
 
 /** Tracks one owned HTTP response until its end or cancellation. */
 export declare interface StudyOllamaWire {
+    /** Holds the admission registry key until this exchange settles. */
+    readonly slot: symbol;
+    /** Holds the sidecar identity when recording is declared. */
+    readonly identity: StudyExchangeIdentity | undefined;
+    /** Holds bounded reply headers in native iteration order. */
+    readonly headers: ReadonlyArray<readonly [string, string]>;
+    /** Holds the combined request and response byte ceiling admitted for this exchange. */
+    readonly ceiling: number;
     readonly activity: StudyOllamaActivity;
     readonly request: StudyOllamaRequest;
     readonly ticket: StudyTicket;
@@ -2066,7 +2690,7 @@ export declare interface StudyParentTicket {
 
 /** Holds checked public declarations and reproducible executable identities. */
 export declare interface StudyPreparation {
-    readonly directory: string;
+    readonly bundle: string;
     readonly definition: StudyDefinition;
     readonly scenarios: readonly StudyScenario[];
     readonly rubric: StudyRubric;
@@ -2074,6 +2698,8 @@ export declare interface StudyPreparation {
     readonly identity: StudyIdentity;
     readonly artifacts: StudyArtifactLoader;
     readonly source: string;
+    /** Carries the verified closure publication when preparation uses relocated inputs. */
+    readonly closure?: StudyClosure;
 }
 
 /** Opens one fresh native child for each scheduled trial. */
@@ -2082,7 +2708,7 @@ export declare class StudyProcessDriver implements StudyDriverInterface {
     /** Owns immutable resolved launch settings.
      * @param options - Built entry, admitted identities and exclusive scratch parent.
      */
-    constructor(options: StudyProcessOptions);
+    constructor(options: StudyProcessDriverOptions);
     /** Opens isolated child state and waits for its verified readiness.
      * @param trial - The public scheduled trial.
      * @param signal - Authoritative parent cancellation.
@@ -2091,6 +2717,11 @@ export declare class StudyProcessDriver implements StudyDriverInterface {
     open(trial: StudyTrial, signal: AbortSignal): Promise<StudySessionInterface>;
 }
 
+/** Supplies parent-only trial preparation separately from serializable worker options. */
+export declare interface StudyProcessDriverOptions extends StudyProcessOptions {
+    readonly prepare?: StudyTrialPreparationFunction;
+}
+
 /** Holds one goal's parent context and the worker admission sequence it issues while the goal runs.
  * @example Issue worker admissions in sequence
  * ```ts
@@ -2126,6 +2757,10 @@ export declare interface StudyProcessOptions extends StudyArtifactLoaderOptions
     readonly identity: StudyIdentity;
     readonly driver: string;
     readonly directory: string;
+    /** Names parent-reserved sidecars by scheduled trial; no recorded bodies cross IPC. */
+    readonly exchanges?: Readonly<Record<string, StudyExchangeDestination>>;
+    /** Carries sealed source selection; each fresh worker rechecks its own trial's file. */
+    readonly replay?: StudyOllamaReplaySelection;
 }
 
 /** Keeps admission and evidence custody in the parent of one fresh trial process. */
@@ -2153,46 +2788,12 @@ export declare interface StudyProcessSessionOptions extends StudyProcessOptions
     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;
-    };
+/** Holds a strictly verified successful request and response pair. */
+export declare interface StudyRecordedExchange {
+    readonly attempt: StudyExchangeAttempt;
+    readonly response: StudyExchangeResponse;
 }
 
-/** 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;
@@ -2303,6 +2904,11 @@ export declare class StudyResultStore implements StudyResultStoreInterface {
      * @throws StudyError - Thrown when creation repeats or custody bounds are exceeded
      */
     create(): Promise<void>;
+    /** Reserves a trial's entire exchange allowance before any worker starts.
+     * @param trial - The exact scheduled trial whose manifest declares recording.
+     * @returns Its exclusive sidecar destination, without creating the trial directory.
+     */
+    exchanges(trial: StudyTrial): Promise<StudyExchangeDestination>;
     /**
      * Exclusively creates the evidence sink for an exact scheduled trial.
      * @param trial - The scheduled trajectory
@@ -2335,6 +2941,11 @@ export declare interface StudyResultStoreInterface extends StudyStoreInterface {
      * @returns The synchronized execution seal.
      */
     seal(): Promise<StudySeal>;
+    /** Reserves a declared trial's sidecar allowance and returns its exclusive write destination.
+     * @param trial - A scheduled trial whose recording declaration is present.
+     * @returns The destination after reserving its complete allowance from series custody.
+     */
+    exchanges(trial: StudyTrial): Promise<StudyExchangeDestination>;
 }
 
 /** Holds the inert execution store configuration. */
@@ -2343,31 +2954,6 @@ export declare interface StudyResultStoreOptions {
     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;
@@ -2384,59 +2970,6 @@ export declare interface StudySealedResult {
     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;
@@ -2459,6 +2992,8 @@ export declare interface StudyTaskOptions {
     readonly adapter: string;
     readonly roots: readonly string[];
     readonly duration?: number;
+    /** Binds fresh adapter validation to the already verified relocated selection. */
+    readonly closure?: StudyClosure;
 }
 
 /** Carries only declarations or sealed evidence to an adapter child. */
@@ -2483,45 +3018,25 @@ export declare class StudyTaskWorker {
     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;
-}
+/** Prepares one trial's external resources before its worker starts.
+ * @remarks
+ * The execution owns daemon start and stop. This callback performs the declared pre-trial
+ * unload and closes any maintenance prefix before returning its retained file identity.
+ * A returned destination must preserve the supplied path and record allowance. The driver
+ * awaits it before constructing the session and never serializes this callback over IPC.
+ * Offline replay supplies no callback and starts no external resource.
+ * @param trial - The exact scheduled trial about to open.
+ * @param signal - The enclosing execution cancellation.
+ * @param exchanges - The parent-reserved sidecar destination, when recording is declared.
+ * @returns The same destination with verified maintenance-prefix identity, or undefined without recording.
+ */
+export declare type StudyTrialPreparationFunction = (trial: StudyTrial, signal: AbortSignal, exchanges: StudyExchangeDestination | undefined) => Promise<StudyExchangeDestination | undefined>;
 
 /** Holds declarations for domain validation before agent, subject or provider execution. */
 export declare interface StudyValidation {
@@ -2574,6 +3089,33 @@ export declare function translateStudyPacketLabeling(result: StudySealedResult,
  */
 export declare function validateStudyEvidenceBytes(bytes: Uint8Array, manifest: StudyManifest, trial: string): void;
 
+/** Joins recorded exchanges to exactly one dispatch and wire evidence identity per ordinal.
+ * @param rows - The complete successful sidecar rows.
+ * @param evidence - The validated trial evidence rows.
+ * @returns Nothing when all retained exchange identities have exact evidence counterparts.
+ */
+export declare function validateStudyExchangeEvidence(rows: readonly StudyExchangeRow[], evidence: readonly StudyEvidence[]): void;
+
+/** Validates complete history envelopes again before a replay may perform dependent work.
+ * @param history - The strict-reader result, treated as untrusted at this boundary.
+ * @returns Nothing after complete row, file and declaration verification.
+ */
+export declare function validateStudyExchangeHistory(history: StudyExchangeHistory): void;
+
+/** Validates the exact declaration order and request bytes of an admitted exchange.
+ * @param declaration - The complete opening procedure.
+ * @param request - The admitted request to join.
+ * @returns Nothing after identity, exact-body or capture-length validation.
+ */
+export declare function validateStudyExchangeRequest(declaration: StudyExchangeDeclaration, request: StudyExchangeAttempt): void;
+
+/** Validates a serialized journal prefix or its complete successful population.
+ * @param rows - The owned rows in physical append order.
+ * @param complete - If true, requires successful completion; if false, admits an unfinished prefix.
+ * @returns Nothing when every row joins its preceding attempt and declared sequence.
+ */
+export declare function validateStudyExchangeRows(rows: readonly StudyExchangeRow[], complete?: boolean): void;
+
 /**
  * Checks terminal policy after the actual wire cost has been retained.
  * @param terminal - The valid terminal facts
@@ -2593,6 +3135,13 @@ export declare function validateStudyOllamaCompletion(terminal: StudyOllamaTermi
  */
 export declare function validateStudyOllamaInventory(value: unknown, models: StudyOllamaTransportOptions['models']): void;
 
+/** Validates independent metadata bounds and the complete optional recording group.
+ * @param options - The owned transport configuration.
+ * @returns Nothing when declarations are executable.
+ * @throws StudyError - Thrown with CONFIG for invalid bounds, groups, identities or ordered policies.
+ */
+export declare function validateStudyOllamaRecording(options: StudyOllamaTransportOptions): void;
+
 /**
  * Validates declared role policies against the pinned inventory before any dispatch.
  * @param roles - The declared wire policy of each model role
@@ -2602,6 +3151,16 @@ export declare function validateStudyOllamaInventory(value: unknown, models: Stu
  */
 export declare function validateStudyOllamaRoles(roles: StudyOllamaTransportOptions['roles'], models: StudyOllamaTransportOptions['models']): void;
 
+/** Admits one model request against its next exact or capture declaration.
+ * @param step - The next model step, absent after the procedure ends.
+ * @param goal - The bound goal identity.
+ * @param request - The independently validated request policy and byte length.
+ * @param body - The owned encoded request body.
+ * @returns Nothing when identity, policy and bytes match the declaration.
+ * @throws StudyError - Thrown with FAULT before sending any mismatched request.
+ */
+export declare function validateStudyOllamaStep(step: StudyOllamaStep | undefined, goal: string, request: StudyOllamaRequest, body: RequestInit['body']): 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.
@@ -2620,6 +3179,14 @@ export declare function validateStudyRuntime(instrument: string, roots: readonly
  */
 export declare function valueToWire(value: unknown): JSONValue;
 
+/** Verifies complete copied membership, path safety, exact bytes, and portable identity.
+ * @param closure - The materialization record to verify independently.
+ * @param published - If true, permits the root publication marker; if false, refuses every extra file. Default: false.
+ * @returns Nothing when the entire forest matches.
+ * @throws ArtifactError - Thrown for malformed records, changed membership, bytes, or physical paths.
+ */
+export declare function verifyArtifactClosure(closure: ArtifactClosure, published?: boolean): void;
+
 /**
  * Writes an exclusive regular record and synchronizes it before reporting success.
  * @param path - The new custody path