@orkestrel/study 0.0.2 → 0.0.3

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

@@ -1,3 +1,4 @@
+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';
@@ -9,6 +10,8 @@ import type { LoadFnOutput } from 'node:module';
 import type { LoadHookContext } from 'node:module';
 import type { LoadHookSync } from 'node:module';
 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';
@@ -45,6 +48,7 @@ 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';
@@ -63,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;
 
@@ -75,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;
@@ -110,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.
@@ -138,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. */
@@ -149,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;
@@ -178,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;
@@ -235,6 +315,18 @@ export declare function buildStudyAgentToolDenial(call: unknown, reason: unknown
  */
 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
@@ -285,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
  */
@@ -373,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
@@ -565,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.
@@ -605,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
@@ -718,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.
@@ -730,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.
@@ -748,6 +954,12 @@ 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.
@@ -778,6 +990,12 @@ export declare function matchesSystemError(value: unknown, code: string): boolea
  */
 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.
@@ -794,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.
@@ -849,6 +1074,13 @@ export declare function readStudyAgentToolCall(call: unknown): ToolCall;
  */
 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.
@@ -882,6 +1114,20 @@ export declare function readStudyDeclaration(root: string, study: string, signal
  */
 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
@@ -953,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
@@ -965,6 +1233,15 @@ 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.
@@ -979,6 +1256,14 @@ export declare function readStudyResult(directory: string): Promise<StudyResultR
  */
 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;
@@ -1002,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
@@ -1011,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.
@@ -1034,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.
@@ -1064,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;
@@ -1073,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\nstudy --version\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";
@@ -1408,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. */
@@ -1475,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;
@@ -1506,7 +1837,7 @@ export declare interface StudyCommandOptions {
 }
 
 /** Names the independently dispatched study command operation. */
-export declare type StudyCommandRequest = StudyExecutionRequest | StudyGradeRequest | StudyLabelRequest | StudyReportRequest;
+export declare type StudyCommandRequest = StudyExecutionRequest | StudyFreezeRequest | StudyGradeRequest | StudyLabelRequest | StudyReportRequest;
 
 /** Holds the evidence sink's shared admission budget. */
 export declare interface StudyCustodyBudget {
@@ -1524,6 +1855,78 @@ export declare interface StudyCustodySinkInterface extends StudySinkInterface {
     close(): Promise<void>;
 }
 
+/** 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>;
+}
+
+/** 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.
+     */
+    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;
@@ -1540,6 +1943,10 @@ export declare interface StudyDriverOptions {
     readonly provider: unknown;
     readonly profile: StudyProfile;
     readonly directory: string;
+    /** 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. */
@@ -1573,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';
@@ -1581,6 +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;
+    /** 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. */
@@ -1597,6 +2185,15 @@ export declare interface StudyFrame {
     readonly value: 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. */
 export declare type StudyGradeFunction = (target: StudyGradeTarget) => StudyGradeReading;
 
@@ -1716,10 +2313,60 @@ export declare type StudyMessageHandler = (operation: StudyOperation, value: JSO
 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. */
+    /** 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
+ * 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.
+ */
+export declare interface StudyOllamaCaptureStep extends StudyOllamaStepIdentity {
+    readonly admission: 'capture';
+    readonly bytes: number;
+    readonly body?: never;
+    readonly input?: never;
+}
+
+/** 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;
+}
+
+/**
+ * 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>;
+
+/** 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;
+}
+
 /** Pins one served model identity the inventory verifies. */
 export declare interface StudyOllamaModel {
     readonly name: string;
@@ -1754,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;
@@ -1788,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;
@@ -1849,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;
@@ -1934,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. */
@@ -1942,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.
@@ -1951,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
@@ -1986,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. */
@@ -2013,6 +2788,12 @@ export declare interface StudyProcessSessionOptions extends StudyProcessOptions
     readonly signal: AbortSignal;
 }
 
+/** Holds a strictly verified successful request and response pair. */
+export declare interface StudyRecordedExchange {
+    readonly attempt: StudyExchangeAttempt;
+    readonly response: StudyExchangeResponse;
+}
+
 /** Cites a retained trial file, or one evidence row of it by its zero-based position. */
 export declare interface StudyReference {
     readonly file: StudyReferenceFile;
@@ -2123,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
@@ -2155,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. */
@@ -2201,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. */
@@ -2231,6 +3024,20 @@ export declare interface StudyTrialCustody {
     readonly terminal: Promise<void> | undefined;
 }
 
+/** 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 {
     readonly definition: StudyDefinition;
@@ -2282,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
@@ -2301,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
@@ -2310,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.
@@ -2328,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