@orkestrel/study 0.0.1 → 0.0.2

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

@@ -1,16 +1,13 @@
 import type { ChildProcess } from 'node:child_process';
 import type { Dir } from 'node:fs';
 import type { Dirent } from 'node:fs';
-import type { estimateRequest } from '@orkestrel/agent';
 import type { extractTiming } from '@orkestrel/ollama';
 import type { FileHandle } from 'node:fs/promises';
-import type { isAgentError } from '@orkestrel/agent';
 import type { JSONValue } from '@orkestrel/contract';
 import type { LedgerGauge } from '@orkestrel/agent';
 import type { LoadFnOutput } from 'node:module';
 import type { LoadHookContext } from 'node:module';
 import type { LoadHookSync } from 'node:module';
-import type { measureRequest } from '@orkestrel/agent';
 import type { Message } from '@orkestrel/agent';
 import type { OllamaOptions } from '@orkestrel/ollama';
 import type { OllamaTiming } from '@orkestrel/ollama';
@@ -21,6 +18,44 @@ 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 { 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;
@@ -174,6 +209,32 @@ 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;
+
 /**
  * Declares the pinned serving identities the Ollama transport verifies, keyed by the label their inventory evidence carries.
  * @param provider - Declared serving identities
@@ -687,6 +748,23 @@ export declare function isStudyTrial(value: unknown): value is StudyTrial;
  */
 export declare function iterateArtifactEntries(handle: Dir): Generator<Dirent, void>;
 
+/** 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.
@@ -741,6 +819,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 +849,39 @@ export declare function readStudyAgentResult(stream: AsyncGenerator<ProviderDelt
  */
 export declare function readStudyBytes(path: string, limit: number): Promise<Uint8Array>;
 
+/** 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 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
@@ -837,6 +965,20 @@ export declare function readStudyOllamaTiming(extract: StudyOllamaTransportOptio
  */
 export declare function readStudyResult(directory: string): Promise<StudyResultReading>;
 
+/** 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;
+
 /** Enforces captured inventory membership at every synchronous native import edge. */
 export declare class Resolution {
     #private;
@@ -931,7 +1073,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>]\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";
 
 /** Names the command route beneath the native supervisor. */
 export declare const STUDY_COMMAND_OPERATION = "study-command";
@@ -1010,21 +1152,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 +1163,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 +1186,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;
@@ -1311,16 +1417,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 +1430,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 +1461,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;
@@ -1435,66 +1508,6 @@ 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;
-}
-
 /** Holds the evidence sink's shared admission budget. */
 export declare interface StudyCustodyBudget {
     readonly reserve: (bytes: number) => void;
@@ -1511,28 +1524,13 @@ 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;
-}
-
-/** Creates isolated domain state through a concrete package consumer. */
-declare interface StudyDriverInterface {
-    /** Creates fresh domain state for one scheduled trial.
-     * @param trial - The scheduled scenario, arm, and repetition.
-     * @param signal - The caller's cancellation.
-     * @returns The isolated session for this trial.
-     */
-    open(trial: StudyTrial, signal: AbortSignal): Promise<StudySessionInterface>;
+/** 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. */
@@ -1544,29 +1542,6 @@ export declare interface StudyDriverOptions {
     readonly directory: string;
 }
 
-/** Reports a study contract or operational failure with a stable code. */
-declare class StudyError extends Error {
-    readonly code: StudyErrorCode;
-    readonly failure: StudyFailure | undefined;
-    /**
-     * Records the failing boundary and optional operational attribution.
-     * @param code - The machine-readable boundary
-     * @param message - The specific failure
-     * @param failure - The optional operational reading
-     */
-    constructor(code: StudyErrorCode, message: string, failure?: StudyFailure);
-}
-
-/** Names malformed configuration, evidence, custody and operational failures. */
-declare type StudyErrorCode = 'CONFIG' | 'EVIDENCE' | 'CUSTODY' | 'CAPACITY' | 'FAULT' | 'DEADLINE';
-
-/** Holds append-only domain evidence in a JSON-compatible form. */
-declare interface StudyEvidence {
-    readonly event: string;
-    readonly goal: string;
-    readonly value: JSONValue;
-}
-
 /** Retains admitted evidence in order and closes admission before terminal records. */
 export declare class StudyEvidenceSink implements StudyCustodySinkInterface {
     #private;
@@ -1608,15 +1583,6 @@ export declare interface StudyExecutionRequest {
     readonly expected: string | undefined;
 }
 
-/** Holds an attributable operational fault without awarding a task verdict. */
-declare interface StudyFailure {
-    readonly cause: StudyCause;
-    readonly message: string;
-    readonly role: StudyRole | undefined;
-    /** Names the ceiling that stopped the run; undefined for a failure no ceiling caused, and for a record sealed before this member existed. */
-    readonly stop: StudyStop | undefined;
-}
-
 /** Holds the exact byte identity of one execution file. */
 export declare interface StudyFile {
     readonly path: string;
@@ -1631,12 +1597,6 @@ 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;
-}
-
 /** Reads one declared target against the consumer's domain predicate. */
 export declare type StudyGradeFunction = (target: StudyGradeTarget) => StudyGradeReading;
 
@@ -1665,19 +1625,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 +1667,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 +1675,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 +1683,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,53 +1709,9 @@ export declare interface StudyLaunchResult {
     readonly output: string;
 }
 
-/**
- * Names the ceiling that stopped a run.
- * @remarks
- * `scope` is a limit Study declares: the calls, tokens, bytes, or duration of a request, goal,
- * trial, series, or operation, the product output allowance, and a provider's declared byte bound.
- * `window` is a prompt room. `custody` is an evidence allowance. `meter`, `budget`, and `model`
- * mirror the `layer` of the `AgentStop` type from `@orkestrel/agent`: the run's estimate allowance,
- * any other budget, and the model's own token limit, which also names the daemon's context and
- * output caps.
- */
-declare type StudyLayer = 'scope' | 'window' | 'custody' | 'meter' | 'budget' | 'model';
-
-/** Holds finite allowances in milliseconds, calls, tokens and bytes. */
-declare interface StudyLimit {
-    readonly duration: number;
-    readonly calls: number;
-    readonly tokens: number;
-    readonly bytes: number;
-}
-
-/** Holds the execution declaration sealed before any trial begins. */
-declare interface StudyManifest {
-    readonly id: string;
-    readonly created: string;
-    readonly definition: StudyDefinition;
-    readonly scenarios: readonly StudyScenario[];
-    readonly identity: StudyIdentity;
-    readonly schedule: readonly StudyTrial[];
-    readonly bounds: StudyBounds;
-    readonly qualification: string | undefined;
-    readonly host: Readonly<Record<string, string>>;
-}
-
 /** Handles validated transport requests at their owning domain boundary. */
 export declare type StudyMessageHandler = (operation: StudyOperation, value: JSONValue) => Promise<JSONValue>;
 
-/** Holds the retained outcome of a scheduled goal. */
-declare interface StudyObservation {
-    readonly goal: string;
-    readonly product: StudyProduct | undefined;
-    readonly failure: StudyFailure | undefined;
-    readonly usage: readonly StudyUsage[];
-    readonly duration: number;
-    /** Records whether the engine dispatched the goal to the session; never inferred from product, usage, duration or failure. */
-    readonly executed: boolean;
-}
-
 /** Holds one active goal's accounting and attribution. */
 export declare interface StudyOllamaActivity {
     readonly goal: string;
@@ -2066,7 +1926,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;
@@ -2153,46 +2013,6 @@ 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;
-    };
-}
-
-/** 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;
@@ -2343,31 +2163,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 +2179,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;
@@ -2483,46 +2225,12 @@ 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;
-}
-
 /** Holds declarations for domain validation before agent, subject or provider execution. */
 export declare interface StudyValidation {
     readonly definition: StudyDefinition;