@agentium/harness 4.1.0 → 4.6.0

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.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_driver = require("./driver-Cr2BGG4h.cjs");
+const require_driver = require("./driver-Bh_wLWCP.cjs");
 let node_crypto = require("node:crypto");
 //#region src/testing.ts
 /** No test-framework dependency. Calls the driver once and throws on violated public lifecycle invariants. */

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/testing.js

@@ -1,4 +1,4 @@
-import { n as HarnessRuntime } from "./driver-BvzvqvpB.js";
+import { n as HarnessRuntime } from "./driver-reTLBJ_o.js";
 import { randomUUID } from "node:crypto";
 //#region src/testing.ts
 /** No test-framework dependency. Calls the driver once and throws on violated public lifecycle invariants. */

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.6.0",
   "description": "Composable harness developer kit for Agentium tools, context, middleware and presets",
   "license": "MIT",
   "publishConfig": {
@@ -25,29 +25,40 @@
   "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"
     }
   },
   "files": [
-    "dist"
+    "dist",
+    "CONVERSATIONAL-RUNS.md"
   ],
   "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.6.0"
   },
   "dependencies": {
     "zod": "^4.6.5"