@zhivex-ai/harness 1.1.1 → 1.2.0-rc.13

package/dist/integrations/mcp.d.ts

@@ -1,4 +1,5 @@
-import { type JsonValue, type McpClient, type McpListedTool, type ToolSet } from "@zhivex-ai/core";
+import { type McpHttpAuthProvider, type McpDestinationPolicy } from "@zhivex-ai/core/mcp-http";
+import { type JsonValue, type McpCallToolOptions, type McpClient, type McpListedTool, type ToolSet } from "@zhivex-ai/core";
 export declare const HARNESS_MCP_CONFIG_SCHEMA_VERSION: 1;
 export declare const HARNESS_MCP_PERMISSIONS: readonly ["read", "network", "write", "external-side-effect"];
 export type HarnessMcpPermission = (typeof HARNESS_MCP_PERMISSIONS)[number];
@@ -6,8 +7,12 @@ export type HarnessMcpTransport = "http" | "custom";
 export interface HarnessMcpServerConfig {
     name: string;
     transport: HarnessMcpTransport;
+    /** Explicit migration; absence retains the legacy 2025-06-18 handshake. */
+    protocolVersion?: "2025-06-18" | "2025-11-25";
     url?: string;
     includeTools: readonly string[];
+    /** Exact resource URIs only; templates and wildcard grants are not supported. */
+    includeResources?: readonly string[];
     excludeTools: readonly string[];
     toolNamePrefix: string;
     permissions: readonly HarnessMcpPermission[];
@@ -23,13 +28,28 @@ export interface HarnessMcpConfiguration {
     schemaVersion: typeof HARNESS_MCP_CONFIG_SCHEMA_VERSION;
     servers: readonly HarnessMcpServerConfig[];
 }
-export type HarnessMcpClients = Readonly<Record<string, McpClient>>;
+export interface HarnessMcpResourceClient extends Omit<McpClient, "listResources" | "readResource"> {
+    listResources?(input?: {
+        cursor?: string;
+    }, options?: McpCallToolOptions): Promise<unknown>;
+    readResource?(input: {
+        uri: string;
+    }, options?: McpCallToolOptions): Promise<unknown>;
+}
+export interface HarnessMcpHttpOptions {
+    /** Host-owned SDK OAuth/token provider; never serialized into workspace configuration. */
+    auth?: McpHttpAuthProvider;
+    /** Additional host DNS/IP/tenant restriction; cannot expand the configured endpoint. */
+    destinationPolicy?: McpDestinationPolicy;
+}
+export type HarnessMcpClients = Readonly<Record<string, HarnessMcpResourceClient>>;
 export declare const normalizeHarnessMcpConfiguration: (value: unknown) => HarnessMcpConfiguration;
 export declare const loadHarnessMcpConfiguration: (workspace: string, configPath: string) => Promise<HarnessMcpConfiguration>;
 type FetchImplementation = typeof fetch;
-export declare const createHttpMcpClient: (server: HarnessMcpServerConfig, env?: NodeJS.ProcessEnv, fetchImplementation?: FetchImplementation) => McpClient;
+export declare const createHttpMcpClient: (server: HarnessMcpServerConfig, env?: NodeJS.ProcessEnv, fetchImplementation?: FetchImplementation, options?: HarnessMcpHttpOptions) => HarnessMcpResourceClient;
 export declare const createHarnessMcpTools: (configuration: HarnessMcpConfiguration, options?: {
     clients?: HarnessMcpClients;
+    httpOptions?: Readonly<Record<string, HarnessMcpHttpOptions>>;
     env?: NodeJS.ProcessEnv;
     fetchImplementation?: FetchImplementation;
 }) => Promise<ToolSet>;

package/dist/models/catalog.d.ts

@@ -25,6 +25,44 @@ export declare const catalogModelSchema: z.ZodObject<{
     reason: z.ZodOptional<z.ZodString>;
     replacement: z.ZodOptional<z.ZodString>;
     retirementDate: z.ZodOptional<z.ZodISODate>;
+    limits: z.ZodOptional<z.ZodObject<{
+        contextWindowTokens: z.ZodNumber;
+        contextWindowType: z.ZodEnum<{
+            combined: "combined";
+            input: "input";
+        }>;
+        maxOutputTokens: z.ZodNumber;
+        maxInputTokens: z.ZodOptional<z.ZodNumber>;
+        evidence: z.ZodObject<{
+            sourceUrl: z.ZodURL;
+            checkedAt: z.ZodISODate;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    pricing: z.ZodOptional<z.ZodObject<{
+        currency: z.ZodLiteral<"USD">;
+        inputPerMillionTokens: z.ZodNumber;
+        outputPerMillionTokens: z.ZodNumber;
+        cachedInputPerMillionTokens: z.ZodOptional<z.ZodNumber>;
+        maxInputTokens: z.ZodOptional<z.ZodNumber>;
+        scope: z.ZodString;
+        evidence: z.ZodObject<{
+            sourceUrl: z.ZodURL;
+            checkedAt: z.ZodISODate;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    compaction: z.ZodOptional<z.ZodObject<{
+        suitability: z.ZodEnum<{
+            candidate: "candidate";
+            evaluated: "evaluated";
+            unknown: "unknown";
+            unsuitable: "unsuitable";
+        }>;
+        reason: z.ZodString;
+        evidence: z.ZodObject<{
+            sourceUrl: z.ZodURL;
+            checkedAt: z.ZodISODate;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
 }, z.core.$strict>;
 export declare const modelCatalogSchema: z.ZodObject<{
     schemaVersion: z.ZodLiteral<1>;
@@ -63,6 +101,44 @@ export declare const modelCatalogSchema: z.ZodObject<{
             reason: z.ZodOptional<z.ZodString>;
             replacement: z.ZodOptional<z.ZodString>;
             retirementDate: z.ZodOptional<z.ZodISODate>;
+            limits: z.ZodOptional<z.ZodObject<{
+                contextWindowTokens: z.ZodNumber;
+                contextWindowType: z.ZodEnum<{
+                    combined: "combined";
+                    input: "input";
+                }>;
+                maxOutputTokens: z.ZodNumber;
+                maxInputTokens: z.ZodOptional<z.ZodNumber>;
+                evidence: z.ZodObject<{
+                    sourceUrl: z.ZodURL;
+                    checkedAt: z.ZodISODate;
+                }, z.core.$strict>;
+            }, z.core.$strict>>;
+            pricing: z.ZodOptional<z.ZodObject<{
+                currency: z.ZodLiteral<"USD">;
+                inputPerMillionTokens: z.ZodNumber;
+                outputPerMillionTokens: z.ZodNumber;
+                cachedInputPerMillionTokens: z.ZodOptional<z.ZodNumber>;
+                maxInputTokens: z.ZodOptional<z.ZodNumber>;
+                scope: z.ZodString;
+                evidence: z.ZodObject<{
+                    sourceUrl: z.ZodURL;
+                    checkedAt: z.ZodISODate;
+                }, z.core.$strict>;
+            }, z.core.$strict>>;
+            compaction: z.ZodOptional<z.ZodObject<{
+                suitability: z.ZodEnum<{
+                    candidate: "candidate";
+                    evaluated: "evaluated";
+                    unknown: "unknown";
+                    unsuitable: "unsuitable";
+                }>;
+                reason: z.ZodString;
+                evidence: z.ZodObject<{
+                    sourceUrl: z.ZodURL;
+                    checkedAt: z.ZodISODate;
+                }, z.core.$strict>;
+            }, z.core.$strict>>;
         }, z.core.$strict>>;
     }, z.core.$strict>>;
 }, z.core.$strict>;

package/dist/models/compaction-recommendations.d.ts

@@ -0,0 +1,28 @@
+import type { CatalogModel, ModelCatalog } from "./catalog.js";
+export interface CompactionRecommendationRequest {
+    provider: string;
+    /** Include instructions, wrappers and transcript in this estimate. */
+    inputTokens: number;
+    /** Reserve output, including reasoning tokens if the provider counts them here. */
+    outputTokens: number;
+    /** Only recommend within explicitly available model IDs when supplied. */
+    availableModels?: readonly string[];
+    /** Inject a clock for reproducible recommendations. */
+    now?: number;
+    maxEvidenceAgeDays?: number;
+}
+export interface CompactionModelAssessment {
+    model: CatalogModel;
+    eligible: boolean;
+    reasons: string[];
+    warnings: string[];
+    estimatedCostUsd?: number;
+}
+export interface CompactionModelRecommendations {
+    /** Advisory only: callers must preserve an explicit user model selection. */
+    recommendedModel?: string;
+    candidates: CompactionModelAssessment[];
+    excluded: CompactionModelAssessment[];
+}
+/** Deterministic, same-provider advice; never loads credentials or selects a route. */
+export declare function recommendCompactionModels(catalog: ModelCatalog, request: CompactionRecommendationRequest): CompactionModelRecommendations;

package/dist/models/sdk-catalog-adapter.d.ts

@@ -0,0 +1,7 @@
+import { type ModelCatalog as SdkModelCatalog } from "@zhivex-ai/core";
+import type { ModelCatalog } from "./catalog.js";
+/** Preserve the public harness manifest while using the SDK's shared evidence contract.
+ * Per-million display rates become per-thousand SDK rates; absent facts stay absent.
+ * This is an application-owned snapshot, never the frozen core default inventory.
+ */
+export declare function toSdkCompactionCatalog(catalog: ModelCatalog, inputTokens: number): SdkModelCatalog;

package/dist/persistence/operations.d.ts

@@ -1,6 +1,8 @@
 import { type AgentRunState, type AgentStatus } from "@zhivex-ai/agents";
-import type { AgentMemoryStore, AgentRunStore } from "@zhivex-ai/agents/ops";
+import type { AgentMemoryStore, AgentRunStore, SqliteAgentRunStoreOptions } from "@zhivex-ai/agents/ops";
 import { type HarnessConfig, type HarnessStoreBackend } from "../runtime/config.js";
+import { SqliteDatabase } from "./sqlite-database.js";
+type SqliteDatabaseLike = SqliteAgentRunStoreOptions["db"];
 export declare const HARNESS_SQLITE_FILE = "operations.sqlite";
 export declare const HARNESS_OPERATIONS_SCHEMA_VERSION: 1;
 export declare const TERMINAL_RUN_STATUSES: readonly ["completed", "failed", "cancelled", "timed_out"];
@@ -126,8 +128,8 @@ export declare const inspectHarnessRun: (store: AgentRunStore, config: HarnessCo
         };
     };
     runtimeDiagnostics: {
-        schemaVersion: 1;
-        profile: "repair";
+        schemaVersion: 2;
+        requireVerifiedDelivery: boolean;
         budget: {
             inputTokens: number;
             outputTokens: number;
@@ -191,9 +193,9 @@ export declare const inspectHarnessRun: (store: AgentRunStore, config: HarnessCo
         }[];
     } | null;
     effectiveRuntime: {
-        schemaVersion: 1;
-        policyVersion: "repair-v2-durable-closure";
-        profile: "repair" | "strict";
+        schemaVersion: 2;
+        policyVersion: "assistant-v3-durable-closure";
+        requireVerifiedDelivery: boolean;
         backend: "none" | "oci";
         budget: {
             unlimitedTokens?: boolean | undefined;
@@ -313,7 +315,9 @@ export declare const cleanupHarnessRuns: (store: AgentRunStore, config: HarnessC
     statuses: AgentStatus[];
     deleted: number;
 }>;
+export declare const sqliteAdapter: (database: SqliteDatabase) => SqliteDatabaseLike;
 export declare const migrateLegacyFileRuns: (directory: string, target: AgentRunStore, config: HarnessConfig) => Promise<HarnessMigrationResult>;
 export declare const openHarnessPersistence: (config: HarnessConfig, options?: {
     migrateLegacyFileStore?: boolean;
 }) => Promise<HarnessPersistence>;
+export {};

package/dist/persistence/state-backup-stream.d.ts

@@ -0,0 +1,4 @@
+/** Canonical JSON without allocating a serialized copy of the entire bundle. */
+export declare function canonicalChunks(value: unknown): Generator<string>;
+export declare function segmentedChunks(value: unknown): Generator<string>;
+export declare function readBackupTransport(source: string, legacyMaxBytes: number): Promise<unknown>;

package/dist/persistence/state-backup.d.ts

@@ -99,6 +99,58 @@ export declare const stateBackupBundleSchema: z.ZodObject<{
             completedAt: z.ZodNullable<z.ZodNumber>;
             metadataBytes: z.ZodNumber;
         }, z.core.$strict>>;
+        workspaceCheckpoints: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            id: z.ZodString;
+            workspaceKey: z.ZodString;
+            scopeKey: z.ZodString;
+            kind: z.ZodLiteral<"checkpoint">;
+            body: z.ZodObject<{
+                id: z.ZodString;
+                sessionId: z.ZodString;
+                turnId: z.ZodString;
+                files: z.ZodArray<z.ZodObject<{
+                    path: z.ZodString;
+                    digest: z.ZodString;
+                    content: z.ZodString;
+                    mode: z.ZodNumber;
+                }, z.core.$strict>>;
+            }, z.core.$strict>;
+        }, z.core.$strict>, z.ZodObject<{
+            id: z.ZodString;
+            workspaceKey: z.ZodString;
+            scopeKey: z.ZodString;
+            kind: z.ZodLiteral<"restore">;
+            body: z.ZodObject<{
+                id: z.ZodString;
+                checkpoint: z.ZodObject<{
+                    id: z.ZodString;
+                    sessionId: z.ZodString;
+                    turnId: z.ZodString;
+                    files: z.ZodArray<z.ZodObject<{
+                        path: z.ZodString;
+                        digest: z.ZodString;
+                        content: z.ZodString;
+                        mode: z.ZodNumber;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>;
+                proposalId: z.ZodString;
+                expected: z.ZodRecord<z.ZodString, z.ZodString>;
+                stage: z.ZodEnum<{
+                    applied: "applied";
+                    applying: "applying";
+                    completed: "completed";
+                    forked: "forked";
+                    forking: "forking";
+                    prepared: "prepared";
+                }>;
+                forkSessionId: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>;
+        }, z.core.$strict>], "kind">>>;
+        budgetLedgers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            state: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            updatedAt: z.ZodNumber;
+        }, z.core.$strict>>>;
     }, z.core.$strict>;
     checksum: z.ZodString;
 }, z.core.$strict>;

package/dist/persistence/state-gitignore.d.ts

@@ -0,0 +1,2 @@
+/** Call after validating and creating the state directory, before writing state. */
+export declare function protectStateFromGit(workspace: string, stateDirectory: string): Promise<void>;

package/dist/persistence/workspace-checkpoints.d.ts

@@ -0,0 +1,149 @@
+import { z } from "zod";
+import { Workspace } from "../workspace/workspace.js";
+import { type FileDigest } from "../workspace/edit-contracts.js";
+import { type CliSessionStore } from "./sessions.js";
+export declare const workspaceCheckpointSchema: z.ZodObject<{
+    id: z.ZodString;
+    sessionId: z.ZodString;
+    turnId: z.ZodString;
+    files: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        digest: z.ZodString;
+        content: z.ZodString;
+        mode: z.ZodNumber;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const workspaceRestoreOperationSchema: z.ZodObject<{
+    id: z.ZodString;
+    checkpoint: z.ZodObject<{
+        id: z.ZodString;
+        sessionId: z.ZodString;
+        turnId: z.ZodString;
+        files: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            digest: z.ZodString;
+            content: z.ZodString;
+            mode: z.ZodNumber;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    proposalId: z.ZodString;
+    expected: z.ZodRecord<z.ZodString, z.ZodString>;
+    stage: z.ZodEnum<{
+        applied: "applied";
+        applying: "applying";
+        completed: "completed";
+        forked: "forked";
+        forking: "forking";
+        prepared: "prepared";
+    }>;
+    forkSessionId: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type WorkspaceCheckpoint = z.infer<typeof workspaceCheckpointSchema>;
+export type WorkspaceRestoreOperation = z.infer<typeof workspaceRestoreOperationSchema>;
+/** Existing text files only. No deletion, creation, binary file, or mode rollback. */
+export declare const openWorkspaceCheckpointStore: (workspace: Workspace, sessions: CliSessionStore) => Promise<{
+    close: () => void;
+    getCheckpoint: (id: string) => {
+        id: string;
+        sessionId: string;
+        turnId: string;
+        files: {
+            path: string;
+            digest: string;
+            content: string;
+            mode: number;
+        }[];
+    };
+    getOperation: (id: string) => {
+        id: string;
+        checkpoint: {
+            id: string;
+            sessionId: string;
+            turnId: string;
+            files: {
+                path: string;
+                digest: string;
+                content: string;
+                mode: number;
+            }[];
+        };
+        proposalId: string;
+        expected: Record<string, string>;
+        stage: "applied" | "applying" | "completed" | "forked" | "forking" | "prepared";
+        forkSessionId?: string | undefined;
+    };
+    capture: (input: {
+        sessionId: string;
+        turnId: string;
+        paths: readonly string[];
+    }) => Promise<WorkspaceCheckpoint>;
+    prepareRestore: (checkpointId: string, expectedCurrent: Readonly<Record<string, FileDigest>>) => Promise<{
+        operation: {
+            id: string;
+            checkpoint: {
+                id: string;
+                sessionId: string;
+                turnId: string;
+                files: {
+                    path: string;
+                    digest: string;
+                    content: string;
+                    mode: number;
+                }[];
+            };
+            proposalId: string;
+            expected: Record<string, string>;
+            stage: "applied" | "applying" | "completed" | "forked" | "forking" | "prepared";
+            forkSessionId?: string | undefined;
+        };
+        proposal: {
+            schemaVersion: 1;
+            kind: "edit-proposal";
+            proposalId: string;
+            digestAlgorithm: "sha256";
+            changes: {
+                path: string;
+                expectedDigest: string | undefined;
+                content: string;
+            }[];
+        };
+    }>;
+    /** Trusted operator invocation after reviewing this exact proposal ID. */
+    applyRestore: (id: string, reviewedProposalId: FileDigest) => Promise<{
+        id: string;
+        checkpoint: {
+            id: string;
+            sessionId: string;
+            turnId: string;
+            files: {
+                path: string;
+                digest: string;
+                content: string;
+                mode: number;
+            }[];
+        };
+        proposalId: string;
+        expected: Record<string, string>;
+        stage: "applied" | "applying" | "completed" | "forked" | "forking" | "prepared";
+        forkSessionId?: string | undefined;
+    }>;
+    /** Resolve only the uncertain fork window; never creates another fork. */
+    recoverFork: (id: string, forkSessionId: string) => Promise<{
+        id: string;
+        checkpoint: {
+            id: string;
+            sessionId: string;
+            turnId: string;
+            files: {
+                path: string;
+                digest: string;
+                content: string;
+                mode: number;
+            }[];
+        };
+        proposalId: string;
+        expected: Record<string, string>;
+        stage: "applied" | "applying" | "completed" | "forked" | "forking" | "prepared";
+        forkSessionId?: string | undefined;
+    }>;
+}>;

package/dist/providers/meta-continuation.d.ts

@@ -1 +1 @@
-export declare const createMetaContinuationFetch: (fetcher?: typeof fetch, waitMs?: number) => typeof fetch;
+export declare const createMetaContinuationFetch: (fetcher?: typeof fetch, backoff?: number | readonly number[]) => typeof fetch;

package/dist/providers/meta-errors.d.ts

@@ -0,0 +1,2 @@
+/** Persist only fixed diagnostic labels, never provider messages or payloads. */
+export declare function annotateMetaRequestError(error: unknown): never;

package/dist/providers/meta-replay.d.ts

@@ -0,0 +1,2 @@
+import { type MetaProviderOptions } from "@zhivex-ai/meta";
+export declare const createMetaReplayModel: (options: MetaProviderOptions, modelId: string) => import("@zhivex-ai/core").LanguageModel<import("@zhivex-ai/meta").MetaLanguageModelOptions>;

package/dist/providers/qwen-context.d.ts

@@ -0,0 +1,2 @@
+import type { LanguageModelMiddleware } from "@zhivex-ai/core";
+export declare const qwenLocalContext: LanguageModelMiddleware;

package/dist/providers/qwen-hosted-policy.d.ts

@@ -0,0 +1,5 @@
+import { type LanguageModel } from "@zhivex-ai/core";
+/** Model Studio's Kimi K3 documentation currently requires Chat Completions and
+ * thinking-only mode. Narrow the installed SDK snapshot until it catches up.
+ * https://help.aliyun.com/en/model-studio/kimi-api (2026-09-26). */
+export declare function withQwenHostedPolicy(model: LanguageModel): LanguageModel;

package/dist/providers/reasoning.d.ts

@@ -0,0 +1,18 @@
+import { z } from "zod";
+import { type LanguageModel, type ModelCapabilities } from "@zhivex-ai/core";
+export declare const reasoningEffortSchema: z.ZodEnum<{
+    default: "default";
+    high: "high";
+    low: "low";
+    max: "max";
+    medium: "medium";
+    minimal: "minimal";
+    none: "none";
+    xhigh: "xhigh";
+}>;
+export type HarnessReasoningEffort = z.infer<typeof reasoningEffortSchema>;
+export declare const supportedReasoningEfforts: (capabilities: ModelCapabilities) => HarnessReasoningEffort[];
+/** Capability inspection constructs an adapter only; it performs no requests and
+ * neither loads real credentials nor changes process environment. */
+export declare function modelReasoningEfforts(provider: string, model: string): HarnessReasoningEffort[];
+export declare function withReasoningEffort(model: LanguageModel, value?: HarnessReasoningEffort): LanguageModel;

package/dist/runtime/config.d.ts

@@ -1,3 +1,4 @@
+import { type HarnessReasoningEffort } from "../providers/reasoning.js";
 import type { LanguageModel } from "@zhivex-ai/agents";
 import type { AgentStoreScope } from "@zhivex-ai/agents/ops";
 import { BUILTIN_PROVIDER_REGISTRATIONS, DEFAULT_PROVIDER_REGISTRY, PROVIDERS, PROVIDER_DESCRIPTORS, createProviderRegistry, type BuiltInHarnessProvider, type HarnessProvider, type HarnessProviderRegistry, type ProviderAvailability, type ProviderCapability, type ProviderCredentials, type ProviderDescriptor, type ProviderDiagnosticsDescriptor, type ProviderEnumDiagnostic, type ProviderModelFactory, type ProviderModelFactoryContext, type ProviderPresenceDiagnostic, type ProviderRegistration, type ProviderSupport } from "../providers/providers.js";
@@ -25,6 +26,7 @@ export declare const DEFAULT_OCI_EXECUTION: {
 };
 export declare const HARNESS_REQUIRED_CAPABILITIES: readonly ["streaming", "tools", "structured-output", "parallel-tools", "reasoning", "web-search"];
 export declare const HARNESS_SUBAGENT_PROFILES: readonly ["explorer", "implementer", "tester", "reviewer"];
+export declare const DEFAULT_HARNESS_MAX_STEPS = 50;
 export declare const DEFAULT_HARNESS_BUDGET: {
     readonly maxToolCalls: 32;
     readonly maxToolErrors: 4;
@@ -65,6 +67,10 @@ export interface HarnessBudget {
     includeChildRuns: boolean;
 }
 export interface HarnessCompactionConfig {
+    model?: {
+        provider: string;
+        model: string;
+    };
     maxMessages: number;
     maxEstimatedInputTokens: number;
     keepRecentMessages: number;
@@ -106,13 +112,13 @@ export interface HarnessConfig {
     schemaVersion: typeof HARNESS_CONFIG_SCHEMA_VERSION;
     provider: HarnessProvider;
     model: string;
+    reasoningEffort?: HarnessReasoningEffort;
     workspace: string;
     stateDirectory: string;
     storeBackend: HarnessStoreBackend;
     scope: AgentStoreScope;
     maxSteps: number;
     timeoutMs: number;
-    agentProfile: "strict" | "repair";
     requireVerifiedDelivery: boolean;
     budget: HarnessBudget;
     costBudget?: HarnessCostBudget;
@@ -128,6 +134,7 @@ export interface HarnessConfigInput {
     schemaVersion?: number;
     provider?: string;
     model?: string;
+    reasoningEffort?: HarnessReasoningEffort;
     workspace?: string;
     stateDirectory?: string;
     storeBackend?: string;
@@ -136,8 +143,7 @@ export interface HarnessConfigInput {
     namespace?: string;
     maxSteps?: number;
     timeoutMs?: number;
-    agentProfile?: string;
-    /** Require an actual verified repair; only available with agentProfile repair. */
+    /** Require an actual verified repair instead of allowing an analysis-only completion. */
     requireVerifiedDelivery?: boolean;
     maxToolCalls?: number;
     maxToolErrors?: number;
@@ -152,6 +158,9 @@ export interface HarnessConfigInput {
     compactionMaxMessages?: number;
     compactionMaxEstimatedInputTokens?: number;
     compactionKeepRecentMessages?: number;
+    /** Explicit utility route. Omit for deterministic, zero-call compaction. */
+    compactionModel?: string;
+    compactionProvider?: string;
     allowedChecks?: readonly string[];
     requiredCapabilities?: readonly string[];
     subagentProfiles?: readonly string[];

package/dist/runtime/context-runtime.d.ts

@@ -0,0 +1,12 @@
+import type { AgentRunStore } from "@zhivex-ai/agents/ops";
+import type { LanguageModelMiddleware, ToolSet } from "@zhivex-ai/core";
+import type { Workspace } from "../workspace/workspace.js";
+export declare const SCOPED_CONTEXT_KEY = "zhivexScopedContext";
+/** Per invocation; only SDK-owned saves persist these observers. */
+export declare function createContextRuntime(workspace: Workspace, metadata: Record<string, unknown>, enabled: boolean, options?: {
+    newUserRequest?: boolean;
+}): Promise<{
+    wrapTools: (tools: ToolSet) => ToolSet;
+    middleware: LanguageModelMiddleware<import("@zhivex-ai/core").ProviderOptions>;
+    store: (original: AgentRunStore, runId: string) => AgentRunStore;
+}>;