@agentium/harness 4.1.0 → 4.5.0

package/dist/definition.d.cts

@@ -0,0 +1,39 @@
+import type { RunContext } from "@agentium/core";
+import type { AbilityBinding } from "./runtime/index.cjs";
+import { type AbilityFactory, createHarnessDefinition, describeHarnessDefinition, exportHarnessManifest, extendHarnessDefinition, hashHarnessManifest, type JsonObject, type LocalAbilityUse, loadHarnessManifest } from "./runtime/index.cjs";
+export interface AbilityDescription {
+    toolNames: readonly string[];
+    requirements: readonly string[];
+    runtimeDependent?: boolean;
+}
+export interface AbilityDefinition<Options> {
+    type: string;
+    version?: number;
+    /** Pure validation/snapshotting. Preserve caller-owned service references; never freeze clients. */
+    validate: (options: Options) => Options;
+    describe: (options: Options) => AbilityDescription;
+    bind: (options: Options, ctx: RunContext) => AbilityBinding | Promise<AbilityBinding>;
+    /** Explicit trusted mapping. Omit for local callbacks/services that cannot be serialized. */
+    portable?: {
+        validateOptions: (options: JsonObject) => JsonObject;
+        toOptions: (options: JsonObject) => Options;
+        toJSON: (options: Options) => JsonObject;
+    };
+}
+export interface Ability<Options> {
+    (options: Options, config?: {
+        instanceId?: string;
+    }): LocalAbilityUse;
+    readonly type: string;
+    readonly version: number;
+    readonly factory?: AbilityFactory;
+}
+/** Capture typed local options; erase only the wrapper so heterogeneous abilities compose without casts. */
+export declare function defineAbility<Options>(definition: AbilityDefinition<Options>): Ability<Options>;
+export declare const defineHarness: typeof createHarnessDefinition;
+export declare const extendHarness: typeof extendHarnessDefinition;
+export declare const describeHarness: typeof describeHarnessDefinition;
+export declare const exportManifest: typeof exportHarnessManifest;
+export declare const loadManifest: typeof loadHarnessManifest;
+export declare const hashManifest: typeof hashHarnessManifest;
+//# sourceMappingURL=definition.d.ts.map

package/dist/drivers.d.cts

@@ -0,0 +1,14 @@
+import { Agent, type AgentConfig, type Team, type Workflow } from "@agentium/core";
+import type { ExecutionDriver, HarnessRunRequest } from "./runtime/index.cjs";
+/** Passing an Agent borrows it. Passing configuration creates/disposes a run-owned
+ * Agent and applies the definition's explicit defaults here, outside core. */
+export declare function agentDriver(agent: Agent | AgentConfig, config?: {
+    stream?: boolean;
+}): ExecutionDriver;
+/** Input defaults to a JSON object patch over the Workflow constructor's initial state. */
+export declare function workflowDriver<T extends Record<string, unknown>>(workflow: Workflow<T>, config?: {
+    input?: (input: HarnessRunRequest["input"]) => Partial<T>;
+}): ExecutionDriver;
+/** Remote Team members fail explicitly because their effects cannot be intercepted locally. */
+export declare function teamDriver(team: Team): ExecutionDriver;
+//# sourceMappingURL=drivers.d.ts.map

package/dist/index.d.cts

@@ -0,0 +1,16 @@
+export type { Ability, AbilityDefinition, AbilityDescription } from "./definition.cjs";
+export { defineAbility, defineHarness, describeHarness, exportManifest, extendHarness, hashManifest, loadManifest, } from "./definition.cjs";
+export { agentDriver, teamDriver, workflowDriver } from "./drivers.cjs";
+export type { MCPResourceClient, MCPResourceGrant, MCPResourcesOptions } from "./mcp-resources.cjs";
+export { mcpResources } from "./mcp-resources.cjs";
+export type { ReflectionPolicyOptions, SummaryContextPolicyOptions } from "./policies.cjs";
+export { reflectionPolicy, summaryContextPolicy } from "./policies.cjs";
+export type { BaseOptions, FileContextOptions, ResearchOptions, SuppliedToolsOptions, TextContextOptions, } from "./presets.cjs";
+export { base, fileContext, research, suppliedTools, textContext } from "./presets.cjs";
+export type { AbilityBinding, AbilityFactory, AbilitySelection, BoundHarness, CompletionDecision, CompletionPolicy, ContextPolicy, ContextProjection, ExecutionDriver, HarnessBudgets, HarnessContextBudget, HarnessContextEntry, HarnessContextSource, HarnessDefaults, HarnessDefinition, HarnessDescription, HarnessDiagnostic, HarnessDriverOutput, HarnessEvent, HarnessEventPayload, HarnessExecutionServices, HarnessExtension, HarnessGrants, HarnessIdentity, HarnessManifest, HarnessMiddleware, HarnessReason, HarnessRegistryEntry, HarnessRegistryReference, HarnessResult, HarnessRunRequest, HarnessRuntimeBindings, HarnessRuntimeConfig, HarnessRuntimeReferences, HarnessRuntimeRegistry, HarnessSendMode, HarnessSessionLease, HarnessSessionSnapshot, HarnessSessionStore, HarnessStartOptions, HarnessStatus, JsonObject, JsonValue, LocalAbilityUse, ModelRoleBinding, PromptFragment, ResolvedHarness, RunHandle, ScopedResource, SessionResourceLease, StepController, StepOverrides, } from "./runtime/index.cjs";
+export { HarnessBudgetError, HarnessEventGapError, HarnessResourcePool, HarnessRuntime, HarnessSessionConflict, HarnessUnsupportedError, InMemoryHarnessEventStore, InMemoryHarnessSessionStore, resolveHarnessRuntime, } from "./runtime/index.cjs";
+export { defineWatch, describeWatch } from "./watch/definition.cjs";
+export { type GmailWatchClient, type GmailWatchOptions, gmailWatchSource } from "./watch/gmail.cjs";
+export { DurableWatch } from "./watch/runtime.cjs";
+export type * from "./watch/types.cjs";
+//# sourceMappingURL=index.d.ts.map

package/dist/mcp-resources.d.cts

@@ -0,0 +1,42 @@
+import { RunContext } from "@agentium/core";
+/** Structural port: both MCP SDK generations can supply a connected Client. */
+export interface MCPResourceClient {
+    readResource(params: {
+        uri: string;
+    }, options?: {
+        signal?: AbortSignal;
+        timeout?: number;
+        cacheMode?: "bypass";
+    }): Promise<{
+        contents: readonly {
+            uri: string;
+            mimeType?: string;
+            text?: string;
+            blob?: string;
+        }[];
+    }>;
+}
+export interface MCPResourceGrant {
+    /** Exact server URI, never a local path or a URL fetched by the harness. */
+    uri: string;
+    /** Explicit text formats. A missing MIME is accepted only when listed as "". */
+    mimeTypes: readonly string[];
+}
+export interface MCPResourcesOptions {
+    id: string;
+    /** Creates a principal-scoped connection for this binding. Authentication belongs to the host. */
+    connect: (ctx: RunContext) => Promise<{
+        client: MCPResourceClient;
+        dispose?: () => Promise<void>;
+    }>;
+    /** Bounds setup even when the host connection factory ignores cancellation. Default 5000. */
+    connectTimeoutMs?: number;
+    resources: readonly MCPResourceGrant[];
+    /** Rechecked before reading and before returning content, including on every subsequent fetch. */
+    authorize: (grant: MCPResourceGrant, ctx: RunContext) => boolean | Promise<boolean>;
+    /** Optional host selector, constrained to the declared grants. No server-wide discovery. */
+    select?: (query: string, ctx: RunContext) => readonly string[] | Promise<readonly string[]>;
+}
+/** Approved text resources become untrusted, provenance-labelled context, never tools or prompts. */
+export declare const mcpResources: import("./definition.cjs").Ability<MCPResourcesOptions>;
+//# sourceMappingURL=mcp-resources.d.ts.map

package/dist/policies.d.cts

@@ -0,0 +1,29 @@
+import type { CompletionPolicy, ContextPolicy } from "./runtime/index.cjs";
+interface ControlOptions {
+    /** Explicit role in HarnessRuntime.models and grants.modelRoles. */
+    modelRole: string;
+    /** Maximum serialized source bytes sent to the policy model. Default: 65536. */
+    maxInputBytes?: number;
+}
+export interface ReflectionPolicyOptions extends ControlOptions {
+    id?: string;
+    /** Host-authored acceptance criteria, not retrieved instructions. */
+    criteria: string;
+    /** Maximum critic output tokens; the host binding must allow maxTokens. Default: 1024. */
+    maxTokens?: number;
+}
+export interface SummaryContextPolicyOptions extends ControlOptions {
+    id?: string;
+    /** Request token estimate including instructions, retained turns and summary. */
+    maxContextTokens: number;
+    /** Latest complete turn groups kept unchanged, including the live turn. Default: 1. */
+    keepRecentTurns?: number;
+    /** Maximum summary output tokens; the host binding must allow maxTokens. Default: 1024. */
+    summaryMaxTokens?: number;
+}
+/** A budgeted critic. Revisions and effect permissions remain owned by HarnessRuntime. */
+export declare function reflectionPolicy(options: ReflectionPolicyOptions): CompletionPolicy;
+/** Summarize removable historical turns, preserving host instructions and the latest whole turns. */
+export declare function summaryContextPolicy(options: SummaryContextPolicyOptions): ContextPolicy;
+export {};
+//# sourceMappingURL=policies.d.ts.map

package/dist/presets.d.cts

@@ -0,0 +1,41 @@
+import type { ToolDef } from "@agentium/core";
+import type { HarnessDefaults, HarnessDefinition, LocalAbilityUse } from "./runtime/index.cjs";
+export interface TextContextOptions {
+    id: string;
+    entries: readonly {
+        id: string;
+        text: string;
+        uri?: string;
+    }[];
+}
+/** Static source data. These entries are always marked source, never host instructions. */
+export declare const textContext: import("./definition.cjs").Ability<TextContextOptions>;
+export interface FileContextOptions {
+    id: string;
+    /** Explicit host grant. Must be absolute; filesystem access begins only during fetch. */
+    root: string;
+    files: readonly string[];
+}
+/** Read only explicitly selected UTF-8 files within a canonical workspace. Local-only host capability. */
+export declare const fileContext: import("./definition.cjs").Ability<FileContextOptions>;
+export interface SuppliedToolsOptions {
+    tools: readonly ToolDef[];
+    requirements?: readonly string[];
+}
+/** Application-owned search/document/service tools retain their existing ToolDef enforcement. */
+export declare const suppliedTools: import("./definition.cjs").Ability<SuppliedToolsOptions>;
+export interface BaseOptions {
+    id?: string;
+    abilities?: readonly LocalAbilityUse[];
+    defaults?: HarnessDefaults;
+}
+/** Minimal local composition, no background jobs, learning, tools or provider selected implicitly. */
+export declare function base(options?: BaseOptions): HarnessDefinition;
+export interface ResearchOptions extends BaseOptions {
+    text?: TextContextOptions;
+    files?: FileContextOptions;
+    tools?: readonly ToolDef[];
+}
+/** Real context sources plus application-supplied research tools; no connector credentials or implicit web calls. */
+export declare function research(options?: ResearchOptions): HarnessDefinition;
+//# sourceMappingURL=presets.d.ts.map

package/dist/runtime/context-policy.d.cts

@@ -0,0 +1,20 @@
+import type { ChatMessage, RunContext } from "@agentium/core";
+import type { HarnessContextEntry } from "./types.cjs";
+export interface ContextProjection {
+    messages: ChatMessage[];
+    provenance: readonly {
+        sourceId: string;
+        included: boolean;
+        reason?: string;
+    }[];
+}
+export interface ContextPolicy {
+    id: string;
+    project: (input: {
+        history: readonly ChatMessage[];
+        entries: readonly HarnessContextEntry[];
+    }, ctx: RunContext) => Promise<ContextProjection>;
+}
+/** Request projections never mutate the canonical history. */
+export declare function projectHarnessContext(policy: ContextPolicy | undefined, history: readonly ChatMessage[], ctx: RunContext, entries?: readonly HarnessContextEntry[]): Promise<ContextProjection>;
+//# sourceMappingURL=context-policy.d.ts.map

package/dist/runtime/context.d.cts

@@ -0,0 +1,15 @@
+import type { ChatMessage } from "@agentium/core";
+import { RunContext } from "@agentium/core";
+import type { HarnessContextBudget, HarnessContextSource } from "./types.cjs";
+export interface HarnessContextDiagnostic {
+    sourceId: string;
+    entryId?: string;
+    code: "expired" | "invalid" | "truncated" | "budget" | "deadline" | "failed" | "trust_downgraded";
+    message: string;
+}
+/** All limits apply across every source. Tokens are centrally estimated, never accepted from the source. */
+export declare function fetchHarnessContext(sources: readonly HarnessContextSource[], query: string, ctx: RunContext, configured?: Partial<HarnessContextBudget>): Promise<{
+    messages: ChatMessage[];
+    diagnostics: HarnessContextDiagnostic[];
+}>;
+//# sourceMappingURL=context.d.ts.map

package/dist/runtime/controller.d.cts

@@ -0,0 +1,51 @@
+import type { ModelConfig, ModelResponse, RunContext, ToolDefinition } from "@agentium/core";
+import type { ContextPolicy } from "./context-policy.cjs";
+export interface StepOverrides {
+    activeToolIds?: readonly string[];
+    modelRole?: string;
+    options?: ModelConfig;
+    contextPolicy?: ContextPolicy;
+    stop?: {
+        reason: string;
+    };
+}
+export interface StepController {
+    id: string;
+    prepareRun?: (ctx: RunContext) => Promise<StepOverrides | undefined>;
+    prepareStep?: (step: {
+        index: number;
+        tools: readonly ToolDefinition[];
+    }, ctx: RunContext) => Promise<StepOverrides | undefined>;
+}
+export type CompletionDecision = {
+    action: "accept";
+    reason: string;
+    evidence?: readonly string[];
+} | {
+    action: "revise";
+    reason: string;
+    instruction: string;
+    evidence?: readonly string[];
+} | {
+    action: "await_input" | "stop";
+    reason: string;
+    evidence?: readonly string[];
+};
+export interface CompletionPolicy {
+    id: string;
+    evaluate: (response: {
+        text: string;
+        structured?: unknown;
+        revision: number;
+    }, ctx: RunContext) => Promise<CompletionDecision>;
+}
+export interface ModelRoleBinding {
+    provider: import("@agentium/core").ModelProvider;
+    /** Explicit allowlist of ModelConfig keys supported by this binding. */
+    options?: readonly (keyof ModelConfig)[];
+}
+export interface ModelInvocation {
+    response: ModelResponse;
+    modelRole: string;
+}
+//# sourceMappingURL=controller.d.ts.map

package/dist/runtime/driver.d.cts

@@ -0,0 +1,146 @@
+import type { ApprovalManager, ChatMessage, ExecutionPolicy, ExecutionServices, MessageContent, ModelConfig, ModelResponse, RunMode, TokenUsage, ToolDef } from "@agentium/core";
+import { EventBus } from "@agentium/core";
+import type { ContextPolicy } from "./context-policy.cjs";
+import type { CompletionPolicy, ModelRoleBinding, StepController } from "./controller.cjs";
+import { type HarnessEvent, type HarnessEventPayload, type HarnessReason, type HarnessResult, type HarnessStatus } from "./events.cjs";
+import { type HarnessIdentity, HarnessResourcePool, type HarnessSessionStore, type ScopedResource } from "./session-bindings.cjs";
+import type { HarnessDefinition } from "./types.cjs";
+export type HarnessSendMode = "follow_up" | "steer" | "replace";
+export declare class HarnessUnsupportedError extends Error {
+    readonly operation: string;
+    readonly code = "unsupported";
+    constructor(operation: string);
+}
+export declare class HarnessBudgetError extends Error {
+    readonly code = "budget_exhausted";
+    constructor(message: string);
+}
+export interface HarnessGrants {
+    toolIds: readonly string[];
+    requiredToolIds?: readonly string[];
+    modelRoles: readonly string[];
+}
+export interface HarnessBudgets {
+    maxModelCalls?: number;
+    maxToolCalls?: number;
+    maxTokens?: number;
+    maxRevisions?: number;
+}
+export interface HarnessRunRequest {
+    input: MessageContent;
+    identity: HarnessIdentity;
+    sessionId: string;
+    runId: string;
+    attemptId: string;
+    parentRunId?: string;
+    rootRunId: string;
+    signal: AbortSignal;
+    deadline?: number;
+    grants: HarnessGrants;
+    runMode: RunMode;
+}
+export interface HarnessDriverOutput {
+    status?: HarnessStatus;
+    text: string;
+    structured?: unknown;
+    reason?: HarnessReason;
+    usage?: TokenUsage;
+    history?: readonly ChatMessage[];
+    artifacts?: readonly {
+        id: string;
+        mimeType?: string;
+    }[];
+}
+export interface ExecutionDriver {
+    id: string;
+    version: number;
+    capabilities: {
+        controls: readonly HarnessSendMode[];
+        durable: boolean;
+        policyCoverage: "local" | "remote" | "none";
+        /** True only when each model/tool operation uses provided execution services. */
+        controlledExecution: boolean;
+    };
+    start: (request: HarnessRunRequest, services: HarnessExecutionServices) => Promise<HarnessDriverOutput>;
+}
+export interface HarnessExecutionServices extends ExecutionServices {
+    readonly definitionId?: string;
+    /** Agent-specific declarative options interpreted only by the configured Agent driver. */
+    readonly agentConfiguration?: {
+        defaults: import("./types.cjs").HarnessDefaults;
+        limits: NonNullable<import("./types.cjs").HarnessManifest["limits"]>;
+        projectRoot: string;
+    };
+    /** Independent, tool-free policy call using an explicitly granted host role and shared budgets.
+     * Skips task controllers, context projection and middleware to avoid policy recursion.
+     */
+    controlModel(role: string, messages: readonly ChatMessage[], options?: Pick<ModelConfig, "maxTokens" | "temperature">): Promise<ModelResponse>;
+    append(messages: readonly ChatMessage[]): void;
+    emit(payload: Exclude<HarnessEventPayload, {
+        type: "run.terminal" | "run.started";
+    }>): void;
+    takeInput(): {
+        input: MessageContent;
+        mode: HarnessSendMode;
+    } | undefined;
+    resource<T>(id: string, scope: "host" | "session" | "run", initialize: () => Promise<ScopedResource<T>>): Promise<T>;
+    putArtifact(value: unknown): string;
+    getArtifact(id: string): unknown;
+}
+export interface RunHandle {
+    readonly runId: string;
+    events(options?: {
+        after?: number;
+    }): AsyncGenerator<HarnessEvent>;
+    result(): Promise<HarnessResult>;
+    cancel(reason?: string): void;
+    send(input: MessageContent, options: {
+        mode: HarnessSendMode;
+    }): Promise<void>;
+}
+export interface HarnessRuntimeConfig {
+    /** Optional observer bus for the runtime and its direct model/controller calls.
+     * Keep Agent instrumentation on its own bus to avoid counting the same call twice. */
+    telemetry?: EventBus;
+    driver?: ExecutionDriver;
+    definition?: HarnessDefinition;
+    projectRoot?: string;
+    requirements?: readonly string[];
+    tools?: readonly ToolDef[];
+    models?: Readonly<Record<string, ModelRoleBinding>>;
+    grants: HarnessGrants;
+    budgets?: HarnessBudgets;
+    executionPolicy?: ExecutionPolicy;
+    approvalManager?: ApprovalManager;
+    controller?: StepController;
+    contextPolicy?: ContextPolicy;
+    completionPolicy?: CompletionPolicy;
+    /** Explicit opt-in to new tool effects in completion revisions. */
+    allowRevisionEffects?: boolean;
+    sessionStore?: HarnessSessionStore;
+    resources?: HarnessResourcePool;
+    eventCapacity?: number;
+}
+export interface HarnessStartOptions {
+    identity: HarnessIdentity;
+    sessionId: string;
+    parentRunId?: string;
+    rootRunId?: string;
+    signal?: AbortSignal;
+    deadline?: number;
+    grants?: HarnessGrants;
+    runMode?: RunMode;
+}
+/** Local lifecycle owner. Custom driver code is trusted; services enforce all intercepted effects. */
+export declare class HarnessRuntime {
+    readonly sessions: HarnessSessionStore;
+    readonly resources: HarnessResourcePool;
+    private config;
+    private artifacts;
+    getArtifact(identity: HarnessIdentity, sessionId: string, id: string): unknown;
+    constructor(config: HarnessRuntimeConfig);
+    run(input: MessageContent, options: HarnessStartOptions): Promise<HarnessResult>;
+    stream(input: MessageContent, options: HarnessStartOptions): AsyncGenerator<HarnessEvent>;
+    start(input: MessageContent, options: HarnessStartOptions): RunHandle;
+}
+//# sourceMappingURL=driver.d.ts.map

package/dist/runtime/events.d.cts

@@ -0,0 +1,83 @@
+import type { TokenUsage } from "@agentium/core";
+export type HarnessStatus = "completed" | "failed" | "cancelled" | "stopped" | "awaiting_input";
+export interface HarnessReason {
+    code: string;
+    message: string;
+}
+export interface HarnessResult {
+    status: HarnessStatus;
+    text: string;
+    structured?: unknown;
+    artifacts?: readonly {
+        id: string;
+        mimeType?: string;
+    }[];
+    reason?: HarnessReason;
+    usage: TokenUsage;
+    runId: string;
+    sessionId: string;
+    finalCursor: number;
+    cleanupDiagnostics?: readonly string[];
+}
+export type HarnessEventPayload = {
+    type: "run.started";
+    driverId: string;
+} | {
+    type: "text.delta";
+    text: string;
+} | {
+    type: "model.complete";
+    providerId: string;
+    modelId: string;
+    usage: TokenUsage;
+} | {
+    type: "tool.complete";
+    toolName: string;
+    toolCallId: string;
+    denied: boolean;
+} | {
+    type: "control";
+    operation: "cancel" | "follow_up" | "steer" | "replace";
+    reason?: string;
+} | {
+    type: "completion";
+    action: string;
+    reason: string;
+} | {
+    type: "run.terminal";
+    result: HarnessResult;
+};
+export interface HarnessEvent {
+    schemaVersion: 1;
+    eventId: string;
+    sequence: number;
+    timestamp: number;
+    sessionId: string;
+    runId: string;
+    attemptId: string;
+    parentRunId?: string;
+    rootRunId: string;
+    payload: HarnessEventPayload;
+}
+export declare class HarnessEventGapError extends Error {
+    readonly earliestCursor: number;
+    readonly code = "event_gap";
+    constructor(earliestCursor: number);
+}
+/** Bounded in-process history; no durability, network delivery, or audio backpressure promise. */
+export declare class InMemoryHarnessEventStore {
+    private identity;
+    readonly capacity: number;
+    readonly durable = false;
+    private history;
+    private sequence;
+    private finished;
+    private listeners;
+    constructor(identity: Omit<HarnessEvent, "schemaVersion" | "eventId" | "sequence" | "timestamp" | "payload">, capacity?: number);
+    get cursor(): number;
+    append(payload: HarnessEventPayload): HarnessEvent;
+    events(options?: {
+        after?: number;
+    }): AsyncGenerator<HarnessEvent>;
+}
+//# sourceMappingURL=events.d.ts.map

package/dist/runtime/index.d.cts

@@ -0,0 +1,9 @@
+export * from "./context-policy.cjs";
+export * from "./controller.cjs";
+export * from "./driver.cjs";
+export * from "./events.cjs";
+export * from "./resolve.cjs";
+export * from "./runtime-registry.cjs";
+export * from "./session-bindings.cjs";
+export * from "./types.cjs";
+//# sourceMappingURL=index.d.ts.map

package/dist/runtime/middleware.d.cts

@@ -0,0 +1,10 @@
+import type { RunContext } from "@agentium/core";
+export { validateConversationTransform as validateHarnessMessages } from "@agentium/core";
+import type { ChatMessage, ModelResponse, ToolCallResult } from "@agentium/core";
+import type { HarnessMiddleware } from "./types.cjs";
+/** Stable topological sort; declaration order breaks ties between ready nodes. */
+export declare function sortHarnessMiddleware(middleware: readonly HarnessMiddleware[]): HarnessMiddleware[];
+export declare function runBeforeModel(middleware: readonly HarnessMiddleware[], messages: readonly ChatMessage[], ctx: RunContext): Promise<ChatMessage[]>;
+export declare function runAfterModel(middleware: readonly HarnessMiddleware[], response: ModelResponse, ctx: RunContext): Promise<void>;
+export declare function runAfterTool(middleware: readonly HarnessMiddleware[], result: ToolCallResult, ctx: RunContext): Promise<void>;
+//# sourceMappingURL=middleware.d.ts.map

package/dist/runtime/resolve.d.cts

@@ -0,0 +1,20 @@
+import type { RunContext } from "@agentium/core";
+import { type HarnessRuntimeRegistry } from "./runtime-registry.cjs";
+import type { AbilityFactory, BoundHarness, HarnessDefinition, HarnessDefinitionInput, HarnessDescription, HarnessDiagnostic, HarnessExtension, HarnessManifest, ResolvedHarness } from "./types.cjs";
+export declare class HarnessValidationError extends Error {
+    readonly diagnostics: readonly HarnessDiagnostic[];
+    constructor(path: string, message: string, code?: string);
+}
+export declare function validateHarnessManifest(input: unknown): HarnessManifest;
+export declare function loadHarnessManifest(input: unknown, factories: readonly AbilityFactory[], runtimeRegistry?: HarnessRuntimeRegistry): HarnessDefinition;
+export declare function createHarnessDefinition(input: HarnessDefinitionInput): HarnessDefinition;
+export declare function extendHarnessDefinition(base: HarnessDefinition, extension: HarnessExtension): HarnessDefinition;
+export declare function describeHarnessDefinition(input: HarnessDefinition): HarnessDescription;
+export declare function resolveHarness(input: HarnessDefinition, options: {
+    projectRoot: string;
+    requirements?: readonly string[];
+}): ResolvedHarness;
+export declare function exportHarnessManifest(input: HarnessDefinition): HarnessManifest;
+export declare function hashHarnessManifest(input: HarnessManifest): string;
+export declare function bindHarness(resolved: ResolvedHarness, ctx: RunContext): Promise<BoundHarness>;
+//# sourceMappingURL=resolve.d.ts.map

package/dist/runtime/runtime-registry.d.cts

@@ -0,0 +1,35 @@
+import type { ContextPolicy } from "./context-policy.cjs";
+import type { CompletionPolicy, StepController } from "./controller.cjs";
+import type { ExecutionDriver } from "./driver.cjs";
+import type { HarnessDefinition } from "./types.cjs";
+export interface HarnessRegistryReference {
+    id: string;
+    version: number;
+}
+export interface HarnessRuntimeReferences {
+    driver?: HarnessRegistryReference;
+    controller?: HarnessRegistryReference;
+    contextPolicy?: HarnessRegistryReference;
+    completionPolicy?: HarnessRegistryReference;
+    /** Role -> approved host binding name; credentials/providers stay host-owned. */
+    modelRoles?: Readonly<Record<string, string>>;
+}
+export interface HarnessRuntimeBindings {
+    driver?: ExecutionDriver;
+    controller?: StepController;
+    contextPolicy?: ContextPolicy;
+    completionPolicy?: CompletionPolicy;
+    modelRoles?: Readonly<Record<string, string>>;
+}
+export interface HarnessRegistryEntry<T> extends HarnessRegistryReference {
+    implementation: T;
+}
+export interface HarnessRuntimeRegistry {
+    driver?: readonly HarnessRegistryEntry<ExecutionDriver>[];
+    controller?: readonly HarnessRegistryEntry<StepController>[];
+    contextPolicy?: readonly HarnessRegistryEntry<ContextPolicy>[];
+    completionPolicy?: readonly HarnessRegistryEntry<CompletionPolicy>[];
+}
+/** Registry resolution is static; it never initializes providers or executes drivers. */
+export declare function resolveHarnessRuntime(definition: HarnessDefinition): HarnessRuntimeBindings;
+//# sourceMappingURL=runtime-registry.d.ts.map

package/dist/runtime/session-bindings.d.cts

@@ -0,0 +1,60 @@
+import type { ChatMessage } from "@agentium/core";
+export interface HarnessIdentity {
+    userId: string;
+    tenantId: string;
+}
+export interface HarnessSessionSnapshot {
+    conversations?: Record<string, ChatMessage[]>;
+    history: ChatMessage[];
+    state: Record<string, unknown>;
+    revision: number;
+    replayable: boolean;
+}
+export interface HarnessSessionLease {
+    read(): HarnessSessionSnapshot;
+    commit(snapshot: Omit<HarnessSessionSnapshot, "revision">): void;
+    release(): void;
+}
+export declare class HarnessSessionConflict extends Error {
+    readonly code = "session_conflict";
+    constructor();
+}
+export interface HarnessSessionStore {
+    readonly guarantees: {
+        durable: boolean;
+        compareAndSwap: boolean;
+        singleWriter: "process" | "distributed";
+    };
+    acquire(identity: HarnessIdentity, sessionId: string): Promise<HarnessSessionLease>;
+}
+export declare function harnessSessionKey(identity: HarnessIdentity, sessionId: string): string;
+/** One writer per scoped session; deliberately rejects rather than silently interleaving. */
+export declare class InMemoryHarnessSessionStore implements HarnessSessionStore {
+    readonly guarantees: {
+        durable: boolean;
+        compareAndSwap: boolean;
+        singleWriter: "process";
+    };
+    private records;
+    private active;
+    acquire(identity: HarnessIdentity, sessionId: string): Promise<HarnessSessionLease>;
+    /** Imported display-only transcripts are readable but never represented as complete replay state. */
+    importLegacy(identity: HarnessIdentity, sessionId: string, history: ChatMessage[]): void;
+}
+export interface ScopedResource<T = unknown> {
+    value: T;
+    ownership: "host" | "runtime";
+    dispose?: () => Promise<void>;
+}
+export interface SessionResourceLease<T> {
+    value: T;
+    release: () => Promise<void>;
+}
+/** Session resources live until explicit closeSession; run resources use their returned lease. */
+export declare class HarnessResourcePool {
+    private sessions;
+    private pending;
+    acquire<T>(identity: HarnessIdentity, sessionId: string, id: string, scope: "host" | "session" | "run", initialize: () => Promise<ScopedResource<T>>): Promise<SessionResourceLease<T>>;
+    closeSession(identity: HarnessIdentity, sessionId: string): Promise<readonly string[]>;
+}
+//# sourceMappingURL=session-bindings.d.ts.map

package/dist/runtime/types.d.cts

@@ -0,0 +1,176 @@
+import type { ChatMessage, ModelResponse, RunContext, ToolCallResult, ToolDef } from "@agentium/core";
+import type { HarnessRuntimeBindings, HarnessRuntimeReferences, HarnessRuntimeRegistry } from "./runtime-registry.cjs";
+export type JsonValue = null | boolean | number | string | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+export type JsonObject = {
+    [key: string]: JsonValue;
+};
+export interface AbilitySelection {
+    instanceId: string;
+    type: string;
+    version: number;
+    options: JsonObject;
+}
+export interface HarnessDefaults {
+    workspace?: false | {
+        path: string;
+        mode: "read" | "write";
+    };
+    skillDirs?: readonly string[] | false;
+    contextFiles?: boolean;
+    filesystem?: boolean;
+    subagents?: boolean;
+    fileMemory?: boolean;
+    searchPastSessions?: boolean;
+}
+export interface HarnessManifest {
+    contractVersion: 1;
+    runtime?: HarnessRuntimeReferences;
+    id: string;
+    abilities: readonly AbilitySelection[];
+    defaults?: HarnessDefaults;
+    limits?: {
+        toolRoundtrips?: number;
+        maxChildDepth?: number;
+    };
+}
+export interface PromptFragment {
+    id: string;
+    text: string;
+}
+export interface HarnessContextBudget {
+    maxEntries: number;
+    maxBytes: number;
+    maxTokens?: number;
+    deadlineMs: number;
+}
+export interface HarnessContextEntry {
+    id: string;
+    text: string;
+    trust: "host" | "source";
+    source?: {
+        uri: string;
+        version?: string;
+        locator?: string;
+    };
+    expiresAt?: number;
+    estimatedTokens?: number;
+    byteLength: number;
+}
+export interface HarnessContextSource {
+    id: string;
+    fetch: (query: string, ctx: RunContext, budget: HarnessContextBudget) => Promise<readonly HarnessContextEntry[]>;
+}
+export interface HarnessMiddleware {
+    id: string;
+    before?: readonly string[];
+    after?: readonly string[];
+    beforeModel?: (messages: readonly ChatMessage[], ctx: RunContext) => Promise<ChatMessage[]>;
+    afterModel?: (response: ModelResponse, ctx: RunContext) => Promise<void>;
+    afterTool?: (result: ToolCallResult, ctx: RunContext) => Promise<void>;
+}
+export interface AbilityBinding {
+    tools: readonly ToolDef[];
+    promptFragments?: readonly PromptFragment[];
+    contextSources?: readonly HarnessContextSource[];
+    middleware?: readonly HarnessMiddleware[];
+    dispose?: () => Promise<void>;
+}
+export interface AbilityDescription {
+    toolNames: readonly string[];
+    requirements: readonly string[];
+    runtimeDependent?: boolean;
+}
+export interface AbilityFactory {
+    type: string;
+    version: number;
+    validateOptions: (input: JsonObject) => JsonObject;
+    describe: (options: JsonObject) => AbilityDescription;
+    bind: (options: JsonObject, ctx: RunContext) => Promise<AbilityBinding>;
+}
+export interface LocalAbilityUse {
+    instanceId: string;
+    validate: () => void;
+    describe: () => AbilityDescription;
+    bind: (ctx: RunContext) => Promise<AbilityBinding>;
+    portable?: AbilitySelection;
+    /** Trusted factory approved by the creator/host, never recovered from JSON. */
+    factory?: AbilityFactory;
+}
+export type HarnessDefinition = {
+    readonly kind: "portable";
+    readonly manifest: HarnessManifest;
+    readonly factories: readonly AbilityFactory[];
+    readonly runtimeRegistry?: HarnessRuntimeRegistry;
+} | {
+    readonly kind: "local";
+    readonly id?: string;
+    readonly abilities: readonly LocalAbilityUse[];
+    readonly defaults?: HarnessDefaults;
+    readonly limits?: HarnessManifest["limits"];
+    readonly runtime?: HarnessRuntimeBindings;
+    readonly runtimeReferences?: HarnessRuntimeReferences;
+    readonly runtimeRegistry?: HarnessRuntimeRegistry;
+};
+export type HarnessDefinitionInput = HarnessDefinition | {
+    id?: string;
+    abilities?: readonly LocalAbilityUse[];
+    defaults?: HarnessDefaults;
+    limits?: HarnessManifest["limits"];
+    runtime?: HarnessRuntimeBindings;
+    runtimeReferences?: HarnessRuntimeReferences;
+    runtimeRegistry?: HarnessRuntimeRegistry;
+};
+export interface HarnessExtension {
+    runtime?: HarnessRuntimeBindings;
+    runtimeReferences?: HarnessRuntimeReferences;
+    runtimeRegistry?: HarnessRuntimeRegistry;
+    id?: string;
+    abilities?: readonly LocalAbilityUse[];
+    disable?: readonly string[];
+    replaceAbilities?: readonly LocalAbilityUse[];
+    defaults?: HarnessDefaults;
+    limits?: HarnessManifest["limits"];
+}
+export interface HarnessDiagnostic {
+    code: string;
+    path: string;
+    message: string;
+    severity: "info" | "warning" | "error";
+}
+export interface HarnessDescription {
+    id: string;
+    kind: "portable" | "local";
+    contractVersion: 1;
+    abilities: readonly (AbilityDescription & {
+        instanceId: string;
+        type?: string;
+        version?: number;
+    })[];
+    toolNames: readonly string[];
+    requirements: readonly string[];
+    runtimeDependent: boolean;
+    defaults: HarnessDefaults;
+    limits: NonNullable<HarnessManifest["limits"]>;
+    diagnostics: readonly HarnessDiagnostic[];
+}
+export interface HarnessProvenance {
+    path: string;
+    origin: string;
+}
+export interface ResolvedHarness {
+    readonly definition: HarnessDefinition;
+    readonly defaults: HarnessDefaults;
+    readonly limits: NonNullable<HarnessManifest["limits"]>;
+    readonly description: HarnessDescription;
+    readonly provenance: readonly HarnessProvenance[];
+}
+export interface BoundHarness {
+    readonly tools: ToolDef[];
+    readonly promptFragments: PromptFragment[];
+    readonly contextSources: HarnessContextSource[];
+    readonly middleware: HarnessMiddleware[];
+    dispose: () => Promise<readonly HarnessDiagnostic[]>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/testing.d.cts

@@ -0,0 +1,7 @@
+import { type ExecutionDriver, type HarnessResult, type HarnessRuntimeConfig } from "./runtime/index.cjs";
+/** No test-framework dependency. Calls the driver once and throws on violated public lifecycle invariants. */
+export declare function testDriverContract(driver: ExecutionDriver, config?: Omit<HarnessRuntimeConfig, "driver">): Promise<{
+    result: HarnessResult;
+    eventCount: number;
+}>;
+//# sourceMappingURL=testing.d.ts.map

package/dist/watch/definition.d.cts

@@ -0,0 +1,11 @@
+import type { WatchDefinition, WatchDefinitionInput } from "./types.cjs";
+export declare function watchId(value: unknown): asserts value is string;
+/** Pure definition: validates/copies JSON, without binding services or activating anything. */
+export declare function defineWatch(input: WatchDefinitionInput): WatchDefinition;
+export declare function describeWatch(definition: WatchDefinitionInput): {
+    definition: WatchDefinition;
+    hash: string;
+    activation: "explicit";
+    modelCalls: false;
+};
+//# sourceMappingURL=definition.d.ts.map

package/dist/watch/gmail.d.cts

@@ -0,0 +1,104 @@
+import type { WatchIdentity, WatchSource } from "./types.cjs";
+type Result<T> = Promise<{
+    data: T;
+}>;
+type RequestOptions = {
+    signal: AbortSignal;
+};
+interface GmailMessage {
+    id?: string | null;
+    internalDate?: string | null;
+    snippet?: string | null;
+    payload?: {
+        headers?: Array<{
+            name?: string | null;
+            value?: string | null;
+        }>;
+    } | null;
+}
+/** Structural subset of an already-authenticated Gmail client; no SDK or credentials are loaded. */
+export interface GmailWatchClient {
+    users: {
+        getProfile(params: {
+            userId: string;
+        }, options: RequestOptions): Result<{
+            historyId?: string | null;
+            emailAddress?: string | null;
+        }>;
+        watch(params: {
+            userId: string;
+            requestBody: {
+                topicName: string;
+                labelIds?: string[];
+                labelFilterBehavior?: "INCLUDE";
+            };
+        }, options: RequestOptions): Result<{
+            historyId?: string | null;
+            expiration?: string | null;
+        }>;
+        stop(params: {
+            userId: string;
+        }, options: RequestOptions): Promise<unknown>;
+        history: {
+            list(params: {
+                userId: string;
+                startHistoryId: string;
+                historyTypes: string[];
+                maxResults: number;
+                pageToken?: string;
+            }, options: RequestOptions): Result<{
+                historyId?: string | null;
+                nextPageToken?: string | null;
+                history?: Array<{
+                    id?: string | null;
+                    messagesAdded?: Array<{
+                        message?: {
+                            id?: string | null;
+                            labelIds?: string[] | null;
+                        } | null;
+                    }>;
+                }>;
+            }>;
+        };
+        messages: {
+            list(params: {
+                userId: string;
+                maxResults: number;
+                pageToken?: string;
+                labelIds?: string[];
+            }, options: RequestOptions): Result<{
+                messages?: Array<{
+                    id?: string | null;
+                }>;
+                nextPageToken?: string | null;
+            }>;
+            get(params: {
+                userId: string;
+                id: string;
+                format: "metadata";
+                metadataHeaders: string[];
+            }, options: RequestOptions): Result<GmailMessage>;
+        };
+    };
+}
+export interface GmailWatchOptions {
+    id: string;
+    mailbox: string;
+    identity: WatchIdentity;
+    topicName: string;
+    labelIds?: string[];
+    client: GmailWatchClient;
+    /** Host verifies Pub/Sub signature, audience and subscription ownership before decoding. */
+    verifyPush?: (raw: unknown) => Promise<{
+        identity: WatchIdentity;
+        messageId: string;
+        data: {
+            emailAddress: string;
+            historyId: string;
+        };
+    }>;
+}
+/** Optional Gmail source: daily renewal/polling are scheduled by DurableWatch, not in this constructor. */
+export declare function gmailWatchSource(options: GmailWatchOptions): WatchSource;
+export {};
+//# sourceMappingURL=gmail.d.ts.map

package/dist/watch/quiet-hours.d.cts

@@ -0,0 +1,10 @@
+import type { WatchQuietHours } from "./types.cjs";
+export declare function watchClock(now: number, timeZone: string): {
+    day: string;
+    minute: number;
+};
+export declare function quietMinute(value: string): number;
+export declare function isWatchQuiet(now: number, timeZone: string, quiet?: WatchQuietHours): boolean;
+/** Scan actual instants: repeated local hours are both quiet; skipped boundaries advance naturally. */
+export declare function nextWatchDelivery(now: number, timeZone: string, quiet?: WatchQuietHours, nextDay?: boolean): number;
+//# sourceMappingURL=quiet-hours.d.ts.map

package/dist/watch/runtime.d.cts

@@ -0,0 +1,42 @@
+import type { WatchDefinition, WatchDefinitionInput, WatchServices, WatchState } from "./types.cjs";
+/** A bounded, versioned watch. Construction is inert; all I/O requires an explicit method call. */
+export declare class DurableWatch {
+    private readonly services;
+    readonly definition: WatchDefinition;
+    readonly key: {
+        tenantId: string;
+        taskId: string;
+    };
+    private readonly hash;
+    private readonly supervisor;
+    private readonly connectorVersion;
+    constructor(definition: WatchDefinitionInput, services: WatchServices);
+    private checkBindings;
+    private authorize;
+    private state;
+    private read;
+    private mutate;
+    private ensureRecord;
+    private owned;
+    private scheduleKey;
+    private syncSchedules;
+    private start;
+    private renewAt;
+    private deliveryAt;
+    activate(): Promise<void>;
+    resume(): Promise<void>;
+    inspect(): Promise<WatchState>;
+    pause(): Promise<void>;
+    delete(): Promise<void>;
+    /** Explicit fail-closed rollout. Old pending/unknown sends stay bound to the old definition. */
+    update(definition: WatchDefinitionInput, services?: WatchServices): Promise<DurableWatch>;
+    private validateCursor;
+    trigger(raw: unknown): Promise<void>;
+    poll(): Promise<void>;
+    renew(): Promise<void>;
+    /** Delivers at most one digest. It never retries an unresolved external effect. */
+    flush(): Promise<void>;
+    /** Reconciliation remains available after pause/delete/update; it never dispatches a send. */
+    reconcile(outboxId: string): Promise<void>;
+}
+//# sourceMappingURL=runtime.d.ts.map

package/dist/watch/types.d.cts

@@ -0,0 +1,147 @@
+import type { DurableActionConnector, DurableJSON, DurableTaskStore } from "@agentium/core";
+export interface WatchIdentity {
+    tenantId: string;
+    actorId: string;
+}
+export interface WatchQuietHours {
+    start: string;
+    end: string;
+}
+export interface WatchLimits {
+    maxOperations: number;
+    maxWakes: number;
+    maxEventsPerWake: number;
+    maxPagesPerWake: number;
+    maxResyncEvents: number;
+    maxPendingEvents: number;
+    maxDecisions: number;
+    maxOutbox: number;
+    maxEventBytes: number;
+    maxStateBytes: number;
+    maxNotificationsPerDay: number;
+}
+export interface WatchDefinition {
+    id: string;
+    version: number;
+    identity: WatchIdentity;
+    sourceId: string;
+    sourceScope: string;
+    destination: string;
+    channel: string;
+    policyRevision: number;
+    grantRefs: string[];
+    timeZone: string;
+    quietHours?: WatchQuietHours;
+    pollIntervalMs: number;
+    renewalIntervalMs: number;
+    cooldownMs: number;
+    limits: WatchLimits;
+}
+export type WatchDefinitionInput = Omit<WatchDefinition, "limits" | "pollIntervalMs" | "renewalIntervalMs" | "cooldownMs"> & {
+    limits?: Partial<WatchLimits>;
+    pollIntervalMs?: number;
+    renewalIntervalMs?: number;
+    cooldownMs?: number;
+};
+export interface WatchEvent {
+    id: string;
+    occurredAt: number;
+    data: DurableJSON;
+}
+export interface WatchSubscription {
+    reference: string;
+    expiresAt: number;
+}
+export interface WatchSourceBatch {
+    cursor: string;
+    events: WatchEvent[];
+    resynced: boolean;
+}
+export interface VerifiedWatchTrigger extends WatchIdentity {
+    sourceId: string;
+    sourceScope: string;
+    eventId: string;
+    cursor: string;
+}
+/** A scoped, host-owned source. Implementations must honor read bounds before returning a cursor. */
+export interface WatchSource {
+    id: string;
+    scope: string;
+    capabilities: {
+        idempotentActivation: true;
+        polling: true;
+        push: boolean;
+    };
+    baseline(signal: AbortSignal): Promise<string>;
+    activate(key: string, signal: AbortSignal): Promise<WatchSubscription>;
+    stop(subscription: WatchSubscription | null, signal: AbortSignal): Promise<void>;
+    read(cursor: string, limits: Pick<WatchLimits, "maxEventsPerWake" | "maxPagesPerWake" | "maxResyncEvents">, signal: AbortSignal): Promise<WatchSourceBatch>;
+    compareCursors(left: string, right: string): number;
+    /** Verify signature/audience and authenticated mailbox ownership before returning a trusted hint. */
+    verifyTrigger?(raw: unknown): Promise<VerifiedWatchTrigger>;
+}
+export type WatchScheduleKind = "poll" | "renew" | "flush";
+export interface WatchSchedule {
+    key: string;
+    identity: WatchIdentity;
+    watchId: string;
+    configVersion: number;
+    kind: WatchScheduleKind;
+    at: number;
+}
+export interface WatchScheduler {
+    capabilities: {
+        durable: boolean;
+        idempotentUpsert: true;
+    };
+    schedule(job: WatchSchedule): Promise<void>;
+    cancel(key: string): Promise<void>;
+}
+export type WatchOperation = "activate" | "update" | "pause" | "resume" | "delete" | "trigger" | "poll" | "renew" | "flush" | "reconcile" | "inspect";
+export interface WatchAuthorization {
+    operation: WatchOperation;
+    definition: Readonly<WatchDefinition>;
+    /** Notification count includes digests; authorization must validate destination/channel and amount. */
+    notifications: number;
+    events: number;
+}
+export interface WatchServices {
+    store: DurableTaskStore;
+    source: WatchSource;
+    scheduler: WatchScheduler;
+    notifications: DurableActionConnector & {
+        channel: string;
+        destination: string;
+    };
+    /** Trusted host authority, including exclusive ownership of a source mailbox where required. */
+    authorize(request: WatchAuthorization): Promise<boolean>;
+    /** Deterministic local classification only; no model/network work in this callback. */
+    filter?(event: Readonly<WatchEvent>): boolean;
+    leaseMs?: number;
+    requireDurability?: boolean;
+}
+export interface WatchOutbox {
+    id: string;
+    eventIds: string[];
+    events: WatchEvent[];
+    state: "pending" | "confirmed";
+    reservedDay: string | null;
+    resultRef: string | null;
+}
+export interface WatchState {
+    status: "inactive" | "activating" | "active" | "paused" | "deleted";
+    cursor: string | null;
+    subscription: WatchSubscription | null;
+    wakes: number;
+    decisions: Record<string, {
+        id: string;
+        decision: "pending" | "ignored" | "resync" | "outbox";
+        at: number;
+    }>;
+    pending: WatchEvent[];
+    outbox: Record<string, WatchOutbox>;
+    daily: Record<string, number>;
+    cooldownUntil: number;
+    schedules: Partial<Record<WatchScheduleKind, number>>;
+}
+//# sourceMappingURL=types.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentium/harness",
-  "version": "4.1.0",
+  "version": "4.5.0",
   "description": "Composable harness developer kit for Agentium tools, context, middleware and presets",
   "license": "MIT",
   "publishConfig": {
@@ -25,15 +25,25 @@
   "types": "./dist/index.d.ts",
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js",
-      "require": "./dist/index.cjs",
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      },
       "default": "./dist/index.js"
     },
     "./testing": {
-      "types": "./dist/testing.d.ts",
-      "import": "./dist/testing.js",
-      "require": "./dist/testing.cjs",
+      "import": {
+        "types": "./dist/testing.d.ts",
+        "default": "./dist/testing.js"
+      },
+      "require": {
+        "types": "./dist/testing.d.cts",
+        "default": "./dist/testing.cjs"
+      },
       "default": "./dist/testing.js"
     }
   },
@@ -41,13 +51,13 @@
     "dist"
   ],
   "scripts": {
-    "build": "tsdown --config ../../tsdown.config.ts && tsc -p tsconfig.build.json --emitDeclarationOnly --declaration --pretty false",
+    "build": "tsdown --config ../../tsdown.config.ts && tsc -p tsconfig.build.json --emitDeclarationOnly --declaration --pretty false && node ../../scripts/cjs-declarations.mjs",
     "dev": "tsdown --config ../../tsdown.config.ts --watch",
     "prepublishOnly": "npm run build",
     "test:package": "cd ../.. && AGENTIUM_TEST_PACKAGES=1 vitest run packages/harness/src/__tests__/package-consumption.test.ts"
   },
   "peerDependencies": {
-    "@agentium/core": "^4.1.0"
+    "@agentium/core": "^4.5.0"
   },
   "dependencies": {
     "zod": "^4.6.5"