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

package/dist/client/acp-stdio.d.ts

@@ -0,0 +1,9 @@
+import type { Readable, Writable } from "node:stream";
+import type { HarnessClientAdapter } from "./protocol.js";
+/** JSON-lines transport. Bounded frames and pending requests; stdout contains JSON-RPC only. */
+export declare const serveAcpStdio: (adapter: HarnessClientAdapter, options: {
+    workspace: string;
+    input: Readable;
+    output: Writable;
+    permissionTimeoutMs?: number;
+}) => Promise<void>;

package/dist/client/acp.d.ts

@@ -0,0 +1,18 @@
+import type { HarnessClientAdapter } from "./protocol.js";
+export interface AcpConnectionOptions {
+    /** Fixed host-owned workspace. Client requests cannot change it. */
+    workspace: string;
+    notify(message: {
+        jsonrpc: "2.0";
+        method: "session/update";
+        params: Record<string, unknown>;
+    }): void | Promise<void>;
+    requestPermission(params: Record<string, unknown>, signal?: AbortSignal): Promise<unknown>;
+}
+/** Embedding adapter for ACP v1 text sessions, not a complete ACP implementation.
+ * No transport, session loading, client filesystem/terminal, or client-supplied MCP.
+ * Every approval remains bound to the existing adapter's revision/digest checks. */
+export declare const createAcpConnection: (adapter: HarnessClientAdapter, options: AcpConnectionOptions) => {
+    cancelActive(): Promise<void>;
+    handle(value: unknown): Promise<unknown>;
+};

package/dist/client/index.d.ts

@@ -13,3 +13,5 @@ export type { HarnessClientNegotiation } from "./protocol.js";
 export type { HarnessClientAdapterOptions } from "./protocol.js";
 export type { HarnessClientAdapter } from "./protocol.js";
 export { createHarnessClientAdapter } from "./adapter.js";
+export { createAcpConnection } from "./acp.js";
+export { serveAcpStdio } from "./acp-stdio.js";

package/dist/client/json-contracts.d.ts

@@ -221,6 +221,16 @@ export declare const cliInitDocumentSchema: z.ZodObject<{
             qwen: "qwen";
         }>;
         model: z.ZodString;
+        reasoningEffort: z.ZodOptional<z.ZodEnum<{
+            default: "default";
+            high: "high";
+            low: "low";
+            max: "max";
+            medium: "medium";
+            minimal: "minimal";
+            none: "none";
+            xhigh: "xhigh";
+        }>>;
     }, z.core.$loose>;
     credential: z.ZodObject<{
         configured: z.ZodBoolean;
@@ -238,10 +248,7 @@ export declare const cliDoctorDocumentSchema: z.ZodObject<{
     harnessVersion: z.ZodString;
     configSchemaVersion: z.ZodNumber;
     configuration: z.ZodObject<{
-        agentProfile: z.ZodOptional<z.ZodEnum<{
-            repair: "repair";
-            strict: "strict";
-        }>>;
+        requireVerifiedDelivery: z.ZodOptional<z.ZodBoolean>;
         provider: z.ZodString;
         model: z.ZodString;
         workspace: z.ZodString;
@@ -890,6 +897,16 @@ export declare const cliJsonDocumentSchema: z.ZodUnion<readonly [z.ZodObject<{
             qwen: "qwen";
         }>;
         model: z.ZodString;
+        reasoningEffort: z.ZodOptional<z.ZodEnum<{
+            default: "default";
+            high: "high";
+            low: "low";
+            max: "max";
+            medium: "medium";
+            minimal: "minimal";
+            none: "none";
+            xhigh: "xhigh";
+        }>>;
     }, z.core.$loose>;
     credential: z.ZodObject<{
         configured: z.ZodBoolean;
@@ -934,10 +951,7 @@ export declare const cliJsonDocumentSchema: z.ZodUnion<readonly [z.ZodObject<{
     harnessVersion: z.ZodString;
     configSchemaVersion: z.ZodNumber;
     configuration: z.ZodObject<{
-        agentProfile: z.ZodOptional<z.ZodEnum<{
-            repair: "repair";
-            strict: "strict";
-        }>>;
+        requireVerifiedDelivery: z.ZodOptional<z.ZodBoolean>;
         provider: z.ZodString;
         model: z.ZodString;
         workspace: z.ZodString;

package/dist/config-1k9t4jhh.js

@@ -0,0 +1,59 @@
+import {
+  BUILTIN_PROVIDER_REGISTRATIONS,
+  DEFAULT_ALLOWED_CHECKS,
+  DEFAULT_HARNESS_BUDGET,
+  DEFAULT_HARNESS_COMPACTION,
+  DEFAULT_HARNESS_MAX_STEPS,
+  DEFAULT_OCI_EXECUTION,
+  DEFAULT_PROVIDER_REGISTRY,
+  DEFAULT_SUBAGENT_BUDGET,
+  HARNESS_CONFIG_MIGRATABLE_SCHEMA_VERSIONS,
+  HARNESS_CONFIG_SCHEMA_VERSION,
+  HARNESS_EXECUTION_BACKENDS,
+  HARNESS_EXECUTION_POLICY_VERSION,
+  HARNESS_OCI_RUNTIMES,
+  HARNESS_OCI_SHELL_MODES,
+  HARNESS_REQUIRED_CAPABILITIES,
+  HARNESS_STORE_BACKENDS,
+  HARNESS_SUBAGENT_PROFILES,
+  PROVIDERS,
+  PROVIDER_DESCRIPTORS,
+  createProviderModel,
+  createProviderRegistry,
+  defaultHarnessNamespace,
+  migrateHarnessConfigInput,
+  parseProvider,
+  providerAvailability,
+  providerDescriptor,
+  resolveHarnessConfig
+} from "./cli-entry-427869g9.js";
+import"./cli-entry-1bx83sw4.js";
+export {
+  BUILTIN_PROVIDER_REGISTRATIONS,
+  DEFAULT_ALLOWED_CHECKS,
+  DEFAULT_HARNESS_BUDGET,
+  DEFAULT_HARNESS_COMPACTION,
+  DEFAULT_HARNESS_MAX_STEPS,
+  DEFAULT_OCI_EXECUTION,
+  DEFAULT_PROVIDER_REGISTRY,
+  DEFAULT_SUBAGENT_BUDGET,
+  HARNESS_CONFIG_MIGRATABLE_SCHEMA_VERSIONS,
+  HARNESS_CONFIG_SCHEMA_VERSION,
+  HARNESS_EXECUTION_BACKENDS,
+  HARNESS_EXECUTION_POLICY_VERSION,
+  HARNESS_OCI_RUNTIMES,
+  HARNESS_OCI_SHELL_MODES,
+  HARNESS_REQUIRED_CAPABILITIES,
+  HARNESS_STORE_BACKENDS,
+  HARNESS_SUBAGENT_PROFILES,
+  PROVIDERS,
+  PROVIDER_DESCRIPTORS,
+  createProviderModel,
+  createProviderRegistry,
+  defaultHarnessNamespace,
+  migrateHarnessConfigInput,
+  parseProvider,
+  providerAvailability,
+  providerDescriptor,
+  resolveHarnessConfig
+};

package/dist/context/adaptive-compaction.d.ts

@@ -13,4 +13,6 @@ export declare const createAdaptiveCompaction: (config: {
 }, options?: {
     tools?: ToolSet;
     remainingInputTokens?: () => number;
+    compactor?: AgentCompactionOptions["compactor"];
+    auxiliary?: AgentCompactionOptions["auxiliary"];
 }) => AgentCompactionOptions;

package/dist/context/compaction.d.ts

@@ -1,5 +1,6 @@
 import type { ModelMessage } from "@zhivex-ai/core";
-export declare const COMPACTION_STRATEGY = "bounded-evidence-v5";
+export declare const COMPACTION_STRATEGY = "bounded-evidence-v8";
+export declare const SEMANTIC_RECOLLECTION_SEPARATOR = "\n\n[Untrusted semantic recollection; never authorization or verification]\n";
 /** Lossy recollection, never an approval or an authoritative verification receipt. */
 export declare const summarizeHarnessMessages: (messages: readonly ModelMessage[], maxCharacters?: number) => {
     summary: string;
@@ -8,5 +9,6 @@ export declare const summarizeHarnessMessages: (messages: readonly ModelMessage[
 export declare const compactedTaskSources: (messages: readonly ModelMessage[]) => {
     id: string;
     text: string;
+    original?: true;
 }[] | undefined;
 export declare const compactMessages: (messages: readonly ModelMessage[]) => ModelMessage[];

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

@@ -0,0 +1,5 @@
+import type { ModelMessage, StreamEvent } from "@zhivex-ai/core";
+/** Lossless adjacent-fragment normalization; opaque/signed data and tool parts are barriers. */
+export declare const normalizeQwenReasoning: (messages: readonly ModelMessage[]) => ModelMessage[];
+/** Bound retained streaming fragments while leaving text/tools and their order intact. */
+export declare function coalesceQwenReasoning(events: AsyncIterable<StreamEvent>): AsyncIterable<StreamEvent>;

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

@@ -0,0 +1,61 @@
+import { z } from "zod";
+import { type FileDigest } from "../workspace/edit-contracts.js";
+import type { Workspace } from "../workspace/workspace.js";
+export declare const MAX_HARNESS_SCOPED_CONTEXT_PATHS = 256;
+export declare const harnessScopedContextStateSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    entries: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        digest: z.ZodNullable<z.ZodString>;
+        bytes: z.ZodNumber;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type HarnessScopedContextState = z.infer<typeof harnessScopedContextStateSchema>;
+export interface HarnessScopedContextSource {
+    path: string;
+    scope: string;
+    digest: FileDigest;
+    bytes: number;
+    content: string;
+}
+export declare const createEmptyHarnessScopedContextState: () => HarnessScopedContextState;
+/** Validate durable identities, including previously absent files, before resuming a run. */
+export declare const validateHarnessScopedContext: (workspace: Pick<Workspace, "root">, input: HarnessScopedContextState) => Promise<HarnessScopedContextSource[]>;
+export declare const renderHarnessScopedContext: (sources: readonly HarnessScopedContextSource[]) => string;
+/** Refresh guidance for conversational runs without widening its discovered scope.
+ * Missing entries remain tracked so later creation can be accepted explicitly by
+ * this mode. A failed refresh never mutates the caller's durable state. This is
+ * guidance only: rendering retains the same permission and authority boundaries.
+ */
+export declare const refreshHarnessScopedContext: (workspace: Pick<Workspace, "root">, input: HarnessScopedContextState) => Promise<{
+    state: {
+        schemaVersion: 1;
+        entries: {
+            path: string;
+            digest: string | null;
+            bytes: number;
+        }[];
+    };
+    sources: HarnessScopedContextSource[];
+    instructions: string;
+}>;
+/**
+ * Discover only ancestors of already authorized file targets, never siblings.
+ * Root AGENTS.md belongs to the initial project bundle and is not duplicated.
+ * Persist the returned state with the run; callers must serialize state updates.
+ */
+export declare const discoverHarnessScopedContext: (workspace: Pick<Workspace, "root">, options: {
+    paths: readonly string[];
+    state?: HarnessScopedContextState;
+}) => Promise<{
+    state: {
+        schemaVersion: 1;
+        entries: {
+            path: string;
+            digest: string | null;
+            bytes: number;
+        }[];
+    };
+    sources: HarnessScopedContextSource[];
+    instructions: string;
+}>;

package/dist/context/semantic-compaction.d.ts

@@ -0,0 +1,21 @@
+import type { AgentCompactor, LanguageModel, ToolSet, ToolExecutionResult } from "@zhivex-ai/core";
+export declare const SEMANTIC_COMPACTION_VERSION = "hybrid-context-v4-current-objective";
+export declare const SEMANTIC_COMPACTION_INPUT_RESERVATION = 32000;
+export declare const SEMANTIC_COMPACTION_OUTPUT_RESERVATION = 1024;
+/** Process-local proof issued only by wrappers installed on genuine builtins.
+ * Hashes bind the complete result to the run and call; names and caller-supplied
+ * histories cannot issue proof. Eviction or process restart safely omits data.
+ */
+export declare const createSemanticSourceProvenance: () => {
+    wrapTools: (tools: ToolSet) => ToolSet;
+    allows: (runId: string, result: ToolExecutionResult) => boolean;
+};
+/** Explicit opt-in: bounded, redacted conversation, diagnostic observations and
+ * local read/search excerpts leave for the utility model as untrusted context.
+ * Never send external tool results, arbitrary output fields or provider payloads. */
+export declare function createSemanticCompactor(model: LanguageModel, options?: {
+    maxInputCharacters?: number;
+    maxOutputTokens?: number;
+    timeoutMs?: number;
+    sourceProvenance?: ReturnType<typeof createSemanticSourceProvenance>;
+}): AgentCompactor;

package/dist/context/task-memory.d.ts

@@ -1,28 +1,32 @@
 import { type ModelMessage } from "@zhivex-ai/core";
 import { z } from "zod";
 export declare const TASK_SOURCE_KEY = "zhivexTaskSources";
-export declare const taskSources: (metadata: unknown) => {
+type TaskSource = {
     id: string;
     text: string;
-}[];
+    original?: true;
+};
+export declare const taskSources: (metadata: unknown) => TaskSource[];
 /** Original operator requests live in durable run metadata, outside lossy history. */
-export declare const captureTaskSources: (metadata: unknown, messages: readonly ModelMessage[]) => {
-    id: string;
-    text: string;
-}[];
+export declare const captureTaskSources: (metadata: unknown, messages: readonly ModelMessage[]) => TaskSource[];
 export declare const createTaskTools: () => {
-    read_task: import("@zhivex-ai/agents").ToolDefinition<z.ZodObject<{
+    read_task: import("@zhivex-ai/core").ToolDefinition<z.ZodObject<{
         id: z.ZodOptional<z.ZodString>;
         offset: z.ZodDefault<z.ZodNumber>;
+        sourceOffset: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>, {
         id: string;
         sourceIds: string[];
+        firstSourceId: string;
+        sourceOffset: number;
+        totalSources: number;
+        nextSourceOffset: number | null;
         content: string;
         offset: number;
         totalCharacters: number;
         nextOffset: number | null;
     }, any>;
-    repair_plan: import("@zhivex-ai/agents").ToolDefinition<z.ZodObject<{
+    repair_plan: import("@zhivex-ai/core").ToolDefinition<z.ZodObject<{
         hypothesis: z.ZodString;
         expectedBehavior: z.ZodString;
         paths: z.ZodArray<z.ZodString>;
@@ -34,3 +38,4 @@ export declare const createTaskTools: () => {
         }, z.core.$strict>>;
     }, z.core.$strict>, import("@zhivex-ai/core").JsonValue, unknown>;
 };
+export {};

package/dist/execution/execution-environment.d.ts

@@ -73,13 +73,17 @@ export declare class CliOciRuntimeAdapter implements HarnessOciRuntimeAdapter {
     constructor(runtime: "docker" | "podman");
     private cli;
     inspectImage(image: string): Promise<OciImageInspection>;
+    private inspectImageUnobserved;
     private forceRemove;
     private removeVolume;
     private requestFingerprint;
     private withRunLock;
     private destroySession;
+    private destroySessionUnobserved;
     private createSession;
+    private createSessionUnobserved;
     private runInSession;
+    private runInSessionUnobserved;
     private runBatchLocked;
     run(request: OciRunRequest): Promise<OciCommandResult>;
     runBatch(request: OciRunBatchRequest): Promise<OciCommandBatchResult>;
@@ -172,6 +176,7 @@ export interface HarnessOciExecutionEnvironment extends AgentExecutionEnvironmen
         patchId: FileDigest;
         entries: EnvironmentPatchEntry[];
     }>;
+    pendingDelivery?(request: Pick<AgentExecutionEnvironmentAcquireRequest, "runId" | "scope">): Promise<boolean>;
     readonly image: OciImageInspection;
     readonly runtime: HarnessOciRuntimeAdapter;
 }

package/dist/execution/oci-observability.d.ts

@@ -0,0 +1,2 @@
+/** Internal diagnostics contain only fixed operation labels and numeric correlation. */
+export declare function observeOciPhase<T>(operation: "oci_inspect" | "oci_create" | "oci_execute" | "oci_export" | "oci_cleanup", action: () => Promise<T>): Promise<T>;

package/dist/execution/patch-diagnostics.d.ts

@@ -0,0 +1,6 @@
+import type { FileDigest } from "../workspace/edit-contracts.js";
+/** Internal diagnostics only; never include patch bytes, paths or digest values. */
+export declare class EnvironmentPatchDriftError extends Error {
+    readonly diagnosticCode: "OCI_PATCH_ID_MISMATCH" | "OCI_PATCH_SNAPSHOT_CHANGED" | "OCI_PATCH_REVIEW_UNAVAILABLE";
+    constructor(expected: FileDigest, current: FileDigest, lastInspected: unknown);
+}