@zhivex-ai/harness 1.2.0 → 1.3.0-rc.7

package/dist/cli.js

@@ -1,10 +1,8 @@
 #!/usr/bin/env node
 import {
+  HARNESS_VERSION,
   shortCliHelp
-} from "./cli-entry-b1mfvmxe.js";
-import {
-  HARNESS_VERSION
-} from "./cli-entry-64pdp3k5.js";
+} from "./cli-entry-ev76ezcd.js";
 import {
   __require
 } from "./cli-entry-1bx83sw4.js";
@@ -18,6 +16,6 @@ if (argv.length === 1 && ["--version", "-v", "version"].includes(argv[0])) {
   process.stdout.write(`${shortCliHelp(HARNESS_VERSION)}
 `);
 } else {
-  const { runCli } = await import("./cli-3jmy4h5h.js");
+  const { runCli } = await import("./cli-t7hrhayq.js");
   await runCli(argv);
 }

package/dist/client/acp-mcp-admission.d.ts

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+import type { McpStdioLaunchProposal } from '../integrations/mcp-stdio-admission.js';
+declare const descriptor: z.ZodObject<{
+    name: z.ZodString;
+    command: z.ZodString;
+    args: z.ZodArray<z.ZodString>;
+    env: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        value: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type AcpMcpStdioDescriptor = z.infer<typeof descriptor>;
+/** ACP v1 request data, never executable host configuration. */
+export declare function parseAcpMcpDescriptors(input: unknown): readonly AcpMcpStdioDescriptor[];
+export interface AcpMcpHostRule {
+    /** Exact client command/argv mapped to a host-provisioned immutable image. */
+    clientCommand: string;
+    clientArgs: readonly string[];
+    clientName: string;
+    proposal: Omit<McpStdioLaunchProposal, 'scope' | 'snapshotDigest'>;
+    /** Explicit client env -> admitted ZHIVEX_MCP_* name translation. */
+    environmentBindings: Readonly<Record<string, string>>;
+}
+/** Pure translation. It cannot authorize, spawn, read secrets or choose a snapshot.
+ * The returned proposals must still cross the host's MCP admission authority.
+ */
+export declare function proposeAcpMcpLaunches(input: unknown, options: {
+    rules: readonly AcpMcpHostRule[];
+    scope: McpStdioLaunchProposal['scope'];
+    snapshotDigest: string;
+}): readonly McpStdioLaunchProposal[];
+export {};

package/dist/client/acp-mcp-host.d.ts

@@ -0,0 +1,19 @@
+import { type CreateHarnessOptions } from '../runtime/harness.js';
+import type { HarnessClientAdapter } from './protocol.js';
+import { type AcpMcpHostRule } from './acp-mcp-admission.js';
+import { launchDockerMcpTools } from '../execution/mcp-oci-server.js';
+/** Trusted host composition. Client descriptors never become process arguments
+ * without an exact host rule, immutable snapshot and fresh admission receipt. */
+export declare function createAcpMcpHost(options: {
+    harness: CreateHarnessOptions;
+    rules: readonly AcpMcpHostRule[];
+    authority: Parameters<typeof launchDockerMcpTools>[0]['authority'];
+    provisionerImageId: string;
+    hostId: string;
+    resolveSecret: Parameters<typeof launchDockerMcpTools>[0]['resolveSecret'];
+}): Promise<Readonly<{
+    adapter: HarnessClientAdapter;
+    workspace: string;
+    mcpSessionProvider: Readonly<Record<never, never>>;
+    close(): Promise<void>;
+}>>;

package/dist/client/acp-mcp-session.d.ts

@@ -0,0 +1,14 @@
+import type { HarnessClientAdapter } from './protocol.js';
+import type { AcpMcpStdioDescriptor } from './acp-mcp-admission.js';
+export type AcpMcpSessionProvider = Readonly<Record<never, never>>;
+/** Internal issuer. Only the wired host factory exports a provider capability. */
+export declare function issueAcpMcpSessionProvider(provider: {
+    adapter: HarnessClientAdapter;
+    parse(input: unknown): readonly AcpMcpStdioDescriptor[];
+    bind(sessionId: string, servers: readonly AcpMcpStdioDescriptor[]): void;
+}): AcpMcpSessionProvider;
+export declare function resolveAcpMcpSessionProvider(token: AcpMcpSessionProvider, adapter: HarnessClientAdapter): {
+    adapter: HarnessClientAdapter;
+    parse(input: unknown): readonly AcpMcpStdioDescriptor[];
+    bind(sessionId: string, servers: readonly AcpMcpStdioDescriptor[]): void;
+};

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

@@ -1,8 +1,10 @@
 import type { Readable, Writable } from "node:stream";
+import { type AcpConnectionOptions } from "./acp.js";
 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;
+    mcpSessionProvider?: AcpConnectionOptions['mcpSessionProvider'];
     input: Readable;
     output: Writable;
     permissionTimeoutMs?: number;

package/dist/client/acp.d.ts

@@ -1,7 +1,10 @@
+import { type AcpMcpSessionProvider } from './acp-mcp-session.js';
 import type { HarnessClientAdapter } from "./protocol.js";
 export interface AcpConnectionOptions {
     /** Fixed host-owned workspace. Client requests cannot change it. */
     workspace: string;
+    /** Opaque capability returned by the isolated MCP host factory. */
+    mcpSessionProvider?: AcpMcpSessionProvider;
     notify(message: {
         jsonrpc: "2.0";
         method: "session/update";
@@ -10,7 +13,7 @@ export interface AcpConnectionOptions {
     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.
+ * No transport, session loading or client filesystem/terminal. Client MCP requires a host capability.
  * Every approval remains bound to the existing adapter's revision/digest checks. */
 export declare const createAcpConnection: (adapter: HarnessClientAdapter, options: AcpConnectionOptions) => {
     cancelActive(): Promise<void>;

package/dist/client/adapter.d.ts

@@ -1,4 +1,16 @@
 import { type ZhivexHarness } from "../runtime/harness.js";
 import { type HarnessClientAdapter, type HarnessClientAdapterOptions } from "./protocol.js";
+/** Trusted host lifecycle hook; never accepted from a protocol request. */
+export interface HarnessClientRunRuntimeOptions {
+    prepareRun?(context: {
+        sessionId: string;
+        runId: string;
+        resuming: boolean;
+        signal: AbortSignal;
+    }): Promise<{
+        harness: ZhivexHarness;
+        release(): Promise<void>;
+    }>;
+}
 /** One trusted host, one workspace/scope, one connection epoch; no multi-writer guarantee. */
-export declare const createHarnessClientAdapter: (harness: ZhivexHarness, options?: HarnessClientAdapterOptions) => Promise<HarnessClientAdapter>;
+export declare const createHarnessClientAdapter: (harness: ZhivexHarness, options?: HarnessClientAdapterOptions & HarnessClientRunRuntimeOptions) => Promise<HarnessClientAdapter>;

package/dist/client/continuation.d.ts

@@ -0,0 +1,3 @@
+import type { ModelMessage } from "@zhivex-ai/core";
+/** Close transcript gaps from a terminal run; never replay an unrecorded tool effect. */
+export declare function terminalContinuationMessages(messages: readonly ModelMessage[]): ModelMessage[];

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

@@ -215,10 +215,12 @@ export declare const cliInitDocumentSchema: z.ZodObject<{
         path: z.ZodString;
         schemaVersion: z.ZodNumber;
         provider: z.ZodEnum<{
+            anthropic: "anthropic";
             gemini: "gemini";
             meta: "meta";
             openai: "openai";
             qwen: "qwen";
+            vertex: "vertex";
         }>;
         model: z.ZodString;
         reasoningEffort: z.ZodOptional<z.ZodEnum<{
@@ -701,11 +703,48 @@ export declare const cliErrorDocumentSchema: z.ZodObject<{
         retryable: z.ZodBoolean;
     }, z.core.$loose>;
 }, z.core.$loose>;
-/**
- * Stable parser for final structured output. Observational documents retain
- * additive fields; the digest-bound change envelope remains strict.
- */
 export declare const cliJsonDocumentSchema: z.ZodUnion<readonly [z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    kind: z.ZodLiteral<"policy-inspection">;
+    digest: z.ZodNullable<z.ZodString>;
+    source: z.ZodEnum<{
+        application: "application";
+        baseline: "baseline";
+        "operator-file": "operator-file";
+    }>;
+    explicitReviewRequired: z.ZodBoolean;
+    tools: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        requiresApproval: z.ZodBoolean;
+    }, z.core.$loose>>;
+    restrictions: z.ZodArray<z.ZodObject<{
+        ruleId: z.ZodString;
+        tools: z.ZodArray<z.ZodString>;
+        decision: z.ZodEnum<{
+            allow: "allow";
+            ask_user: "ask_user";
+            deny: "deny";
+        }>;
+        reason: z.ZodString;
+        pathCount: z.ZodNumber;
+    }, z.core.$loose>>;
+    execution: z.ZodObject<{
+        configuredBackend: z.ZodEnum<{
+            none: "none";
+            oci: "oci";
+        }>;
+        activeBackend: z.ZodEnum<{
+            none: "none";
+            oci: "oci";
+        }>;
+        evidence: z.ZodLiteral<"configuration-only">;
+    }, z.core.$loose>;
+    limits: z.ZodObject<{
+        maxSteps: z.ZodNumber;
+        timeoutMs: z.ZodNumber;
+        budget: z.ZodObject<{}, z.core.$loose>;
+    }, z.core.$loose>;
+}, z.core.$loose>, z.ZodObject<{
     schemaVersion: z.ZodLiteral<1>;
     runId: z.ZodString;
     status: z.ZodString;
@@ -891,10 +930,12 @@ export declare const cliJsonDocumentSchema: z.ZodUnion<readonly [z.ZodObject<{
         path: z.ZodString;
         schemaVersion: z.ZodNumber;
         provider: z.ZodEnum<{
+            anthropic: "anthropic";
             gemini: "gemini";
             meta: "meta";
             openai: "openai";
             qwen: "qwen";
+            vertex: "vertex";
         }>;
         model: z.ZodString;
         reasoningEffort: z.ZodOptional<z.ZodEnum<{
@@ -1449,6 +1490,37 @@ export declare const cliJsonDocumentSchema: z.ZodUnion<readonly [z.ZodObject<{
     }, z.core.$strict>>>;
 }, z.core.$strict>]>;
 export declare const cliRunEventDocumentSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    sequence: z.ZodNumber;
+    kind: z.ZodLiteral<"run-event">;
+    type: z.ZodLiteral<"policy-decision">;
+    phase: z.ZodEnum<{
+        "approval-request": "approval-request";
+        "tool-entry": "tool-entry";
+    }>;
+    toolName: z.ZodString;
+    decision: z.ZodEnum<{
+        allow: "allow";
+        ask_user: "ask_user";
+        deny: "deny";
+    }>;
+    ruleIds: z.ZodArray<z.ZodString>;
+    reason: z.ZodString;
+    reasonTruncated: z.ZodBoolean;
+    policyDigest: z.ZodNullable<z.ZodString>;
+    source: z.ZodEnum<{
+        application: "application";
+        baseline: "baseline";
+        "operator-file": "operator-file";
+    }>;
+    approvalRequired: z.ZodBoolean;
+    explicitReviewRequired: z.ZodBoolean;
+    executionBackend: z.ZodEnum<{
+        none: "none";
+        oci: "oci";
+    }>;
+    evidence: z.ZodLiteral<"policy-evaluation">;
+}, z.core.$loose>, z.ZodObject<{
     schemaVersion: z.ZodLiteral<1>;
     sequence: z.ZodNumber;
     kind: z.ZodLiteral<"run-event">;
@@ -1610,6 +1682,37 @@ export declare const cliStreamErrorDocumentSchema: z.ZodObject<{
 }, z.core.$loose>;
 /** Stable parser for one JSONL record. Every record kind is unambiguous. */
 export declare const cliJsonLineDocumentSchema: z.ZodUnion<readonly [z.ZodDiscriminatedUnion<[z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    sequence: z.ZodNumber;
+    kind: z.ZodLiteral<"run-event">;
+    type: z.ZodLiteral<"policy-decision">;
+    phase: z.ZodEnum<{
+        "approval-request": "approval-request";
+        "tool-entry": "tool-entry";
+    }>;
+    toolName: z.ZodString;
+    decision: z.ZodEnum<{
+        allow: "allow";
+        ask_user: "ask_user";
+        deny: "deny";
+    }>;
+    ruleIds: z.ZodArray<z.ZodString>;
+    reason: z.ZodString;
+    reasonTruncated: z.ZodBoolean;
+    policyDigest: z.ZodNullable<z.ZodString>;
+    source: z.ZodEnum<{
+        application: "application";
+        baseline: "baseline";
+        "operator-file": "operator-file";
+    }>;
+    approvalRequired: z.ZodBoolean;
+    explicitReviewRequired: z.ZodBoolean;
+    executionBackend: z.ZodEnum<{
+        none: "none";
+        oci: "oci";
+    }>;
+    evidence: z.ZodLiteral<"policy-evaluation">;
+}, z.core.$loose>, z.ZodObject<{
     schemaVersion: z.ZodLiteral<1>;
     sequence: z.ZodNumber;
     kind: z.ZodLiteral<"run-event">;

package/dist/client/local-service.d.ts

@@ -10,6 +10,8 @@ export interface HarnessLocalService {
     resumeAdmission(): void;
     /** Requests cancellation of this host's active invocation; never force-finalizes it. */
     cancelActive(): Promise<void>;
+    /** Trusted host channel after full review; never exposed by the HTTP router. */
+    dispatchReviewed(request: unknown): Promise<HarnessClientResponse>;
     /** Stops admission, drains accepted commands, closes adapter and host runtime. */
     close(): Promise<void>;
 }

package/dist/client/protocol.d.ts

@@ -1,13 +1,20 @@
+import type { HarnessPolicyDecisionEvent } from "../runtime/policy-decisions.js";
+import type { HarnessPolicyInspection } from "../runtime/policy-inspection.js";
 import { type ApprovalDecisionView } from "../approvals/approval-history.js";
 import { type ApprovalFilePreview } from "../approvals/approval-preview.js";
 import { z } from "zod";
 import type { AgentStreamEvent } from "@zhivex-ai/agents";
 import { type CliSession } from "../persistence/sessions.js";
 export declare const HARNESS_CLIENT_PROTOCOL_VERSION: 1;
+type CheckpointStore = Awaited<ReturnType<typeof import('../persistence/workspace-checkpoints.js').openWorkspaceCheckpointStore>>;
+type RestoreSummary = ReturnType<CheckpointStore['listRestores']>[number];
 /** Strict command union; configuration, credentials and filesystem paths are host-owned. */
 export declare const harnessClientCommandSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     projectId: z.ZodString;
     method: z.ZodLiteral<"project.get">;
+}, z.core.$strict>, z.ZodObject<{
+    projectId: z.ZodString;
+    method: z.ZodLiteral<"policy.get">;
 }, z.core.$strict>, z.ZodObject<{
     projectId: z.ZodString;
     method: z.ZodLiteral<"session.list">;
@@ -28,6 +35,52 @@ export declare const harnessClientCommandSchema: z.ZodDiscriminatedUnion<[z.ZodO
     method: z.ZodLiteral<"session.rename">;
     expectedRevision: z.ZodNumber;
     title: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    projectId: z.ZodString;
+    sessionId: z.ZodString;
+    method: z.ZodLiteral<"checkpoint.list">;
+}, z.core.$strict>, z.ZodObject<{
+    projectId: z.ZodString;
+    sessionId: z.ZodString;
+    checkpointId: z.ZodString;
+    method: z.ZodLiteral<"checkpoint.inspect">;
+}, z.core.$strict>, z.ZodObject<{
+    projectId: z.ZodString;
+    sessionId: z.ZodString;
+    idempotencyKey: z.ZodString;
+    method: z.ZodLiteral<"checkpoint.capture">;
+    expectedRevision: z.ZodNumber;
+    turnId: z.ZodString;
+    paths: z.ZodArray<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    projectId: z.ZodString;
+    sessionId: z.ZodString;
+    idempotencyKey: z.ZodString;
+    checkpointId: z.ZodString;
+    method: z.ZodLiteral<"restore.prepare">;
+    expectedRevision: z.ZodNumber;
+    expected: z.ZodRecord<z.ZodString, z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    projectId: z.ZodString;
+    sessionId: z.ZodString;
+    operationId: z.ZodString;
+    method: z.ZodLiteral<"restore.get">;
+}, z.core.$strict>, z.ZodObject<{
+    projectId: z.ZodString;
+    sessionId: z.ZodString;
+    idempotencyKey: z.ZodString;
+    operationId: z.ZodString;
+    method: z.ZodLiteral<"restore.apply">;
+    expectedRevision: z.ZodNumber;
+    reviewedProposalId: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    projectId: z.ZodString;
+    sessionId: z.ZodString;
+    idempotencyKey: z.ZodString;
+    operationId: z.ZodString;
+    method: z.ZodLiteral<"restore.recoverFork">;
+    expectedRevision: z.ZodNumber;
+    forkSessionId: z.ZodString;
 }, z.core.$strict>, z.ZodObject<{
     projectId: z.ZodString;
     sessionId: z.ZodString;
@@ -70,6 +123,9 @@ export declare const harnessClientRequestSchema: z.ZodObject<{
     command: z.ZodDiscriminatedUnion<[z.ZodObject<{
         projectId: z.ZodString;
         method: z.ZodLiteral<"project.get">;
+    }, z.core.$strict>, z.ZodObject<{
+        projectId: z.ZodString;
+        method: z.ZodLiteral<"policy.get">;
     }, z.core.$strict>, z.ZodObject<{
         projectId: z.ZodString;
         method: z.ZodLiteral<"session.list">;
@@ -90,6 +146,52 @@ export declare const harnessClientRequestSchema: z.ZodObject<{
         method: z.ZodLiteral<"session.rename">;
         expectedRevision: z.ZodNumber;
         title: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        projectId: z.ZodString;
+        sessionId: z.ZodString;
+        method: z.ZodLiteral<"checkpoint.list">;
+    }, z.core.$strict>, z.ZodObject<{
+        projectId: z.ZodString;
+        sessionId: z.ZodString;
+        checkpointId: z.ZodString;
+        method: z.ZodLiteral<"checkpoint.inspect">;
+    }, z.core.$strict>, z.ZodObject<{
+        projectId: z.ZodString;
+        sessionId: z.ZodString;
+        idempotencyKey: z.ZodString;
+        method: z.ZodLiteral<"checkpoint.capture">;
+        expectedRevision: z.ZodNumber;
+        turnId: z.ZodString;
+        paths: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        projectId: z.ZodString;
+        sessionId: z.ZodString;
+        idempotencyKey: z.ZodString;
+        checkpointId: z.ZodString;
+        method: z.ZodLiteral<"restore.prepare">;
+        expectedRevision: z.ZodNumber;
+        expected: z.ZodRecord<z.ZodString, z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        projectId: z.ZodString;
+        sessionId: z.ZodString;
+        operationId: z.ZodString;
+        method: z.ZodLiteral<"restore.get">;
+    }, z.core.$strict>, z.ZodObject<{
+        projectId: z.ZodString;
+        sessionId: z.ZodString;
+        idempotencyKey: z.ZodString;
+        operationId: z.ZodString;
+        method: z.ZodLiteral<"restore.apply">;
+        expectedRevision: z.ZodNumber;
+        reviewedProposalId: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        projectId: z.ZodString;
+        sessionId: z.ZodString;
+        idempotencyKey: z.ZodString;
+        operationId: z.ZodString;
+        method: z.ZodLiteral<"restore.recoverFork">;
+        expectedRevision: z.ZodNumber;
+        forkSessionId: z.ZodString;
     }, z.core.$strict>, z.ZodObject<{
         projectId: z.ZodString;
         sessionId: z.ZodString;
@@ -128,7 +230,7 @@ export declare const harnessClientRequestSchema: z.ZodObject<{
 }, z.core.$strict>;
 export type HarnessClientCommand = z.infer<typeof harnessClientCommandSchema>;
 export type HarnessClientRequest = z.infer<typeof harnessClientRequestSchema>;
-export type HarnessClientErrorCode = "INVALID_REQUEST" | "VERSION_UNSUPPORTED" | "CONNECTION_EXPIRED" | "NOT_FOUND" | "REVISION_CONFLICT" | "IDEMPOTENCY_CONFLICT" | "CAPACITY_EXCEEDED" | "APPROVAL_MISMATCH" | "INVALID_STATE" | "BUSY" | "EXECUTION_FAILED";
+export type HarnessClientErrorCode = "INVALID_REQUEST" | "VERSION_UNSUPPORTED" | "CONNECTION_EXPIRED" | "NOT_FOUND" | "REVISION_CONFLICT" | "IDEMPOTENCY_CONFLICT" | "CAPACITY_EXCEEDED" | "APPROVAL_MISMATCH" | "EXPLICIT_REVIEW_REQUIRED" | "INVALID_STATE" | "BUSY" | "EXECUTION_FAILED";
 export interface HarnessClientSession extends CliSession {
 }
 export interface HarnessClientRun {
@@ -153,12 +255,32 @@ export interface HarnessClientRun {
 export type HarnessClientData = {
     kind: "project";
     projectId: string;
+} | {
+    kind: "policy";
+    policy: HarnessPolicyInspection;
 } | {
     kind: "session";
     session: HarnessClientSession;
 } | {
     kind: "sessions";
     sessions: HarnessClientSession[];
+} | {
+    kind: "checkpoints";
+    checkpoints: ReturnType<CheckpointStore['listCheckpoints']>;
+    restores: ReturnType<CheckpointStore['listRestores']>;
+} | {
+    kind: "checkpoint";
+    inspection: Awaited<ReturnType<CheckpointStore['inspectCheckpoint']>>;
+} | {
+    kind: "restore";
+    operation: RestoreSummary;
+    preview: {
+        status: "available";
+        diff: Awaited<ReturnType<CheckpointStore['previewRestore']>>;
+    } | {
+        status: "unavailable";
+    };
+    session?: HarnessClientSession;
 } | {
     kind: "run";
     session: HarnessClientSession;
@@ -191,6 +313,7 @@ export type HarnessClientNegotiation = {
 export interface HarnessClientAdapterOptions {
     approvalMaxAgeMs?: number;
     now?: () => number;
+    onPolicyDecision?: (sessionId: string, runId: string, event: HarnessPolicyDecisionEvent) => void | Promise<void>;
     onPrompt?: (sessionId: string, runId: string, prompt: string) => void | Promise<void>;
     onEvent?: (sessionId: string, runId: string, event: AgentStreamEvent) => void | Promise<void>;
     onCheckpoint?: (sessionId: string, runId: string, status: string) => void | Promise<void>;
@@ -198,8 +321,11 @@ export interface HarnessClientAdapterOptions {
 export interface HarnessClientAdapter {
     negotiate(versions: readonly number[]): HarnessClientNegotiation;
     dispatch(request: unknown): Promise<HarnessClientResponse>;
+    /** Trusted in-process host only, after complete interactive review. Not a transport command. */
+    dispatchReviewed?(request: unknown): Promise<HarnessClientResponse>;
     /** Trusted host shutdown control; requests cancellation without finalizing effects. */
     cancelActive(): Promise<void>;
     /** Closes this connection and its session index, not the host-owned harness. */
     close(): void;
 }
+export {};

package/dist/client/run-document.d.ts

@@ -0,0 +1,91 @@
+import { type AgentRunOutput } from "@zhivex-ai/agents";
+import type { ZhivexHarness } from "../runtime/harness.js";
+export declare const runResultDocument: (result: AgentRunOutput, harness: ZhivexHarness) => {
+    schemaVersion: 1;
+    kind: "run-result";
+    runId: string;
+    status: import("@zhivex-ai/core").AgentStatus;
+    provider: string;
+    model: string;
+    output: string;
+    steps: number;
+    toolCalls: number;
+    mutations: readonly {
+        id: string;
+        operation: "create" | "move" | "quarantine" | "restore" | "update";
+        path: string;
+        destination?: string | undefined;
+        beforeDigest?: string | undefined;
+        afterDigest?: string | undefined;
+        timestamp: string;
+        quarantineId?: string | undefined;
+    }[];
+    pendingApprovals: {
+        id: string;
+        kind: "local-tool" | "provider" | "subagent";
+        name: string;
+        arguments: string;
+        childRunId?: string;
+        childAgentId?: string;
+    }[];
+    children: {
+        runId: string;
+        agentId: string | undefined;
+        toolName: string | undefined;
+        status: import("@zhivex-ai/core").AgentStatus;
+        steps: number;
+        toolCalls: number;
+        toolErrors: number;
+        usage: import("@zhivex-ai/core").TokenUsage | undefined;
+    }[];
+    usage: import("@zhivex-ai/core").TokenUsage | undefined;
+    usageLedger?: {
+        calls: number;
+        inputTokens: number;
+        outputTokens: number;
+        usageComplete: boolean;
+        estimatedUsd: number | null;
+        limitUsd: number | null;
+        schemaVersion: 1;
+        runId: string;
+        historicalUsageUnknown?: boolean | undefined;
+        costKind: "estimate-not-invoice";
+        routes: {
+            provider: string;
+            model: string;
+            calls: number;
+            inputTokens: number;
+            outputTokens: number;
+            unknownCalls: number;
+            estimatedUsd: number | null;
+            priceStatuses: ("estimate" | "missing" | "stale")[];
+        }[];
+    } | null;
+    budget: import("@zhivex-ai/core").AgentBudgetStatus;
+    costBudget?: {
+        limitUsd: number;
+        estimate: import("@zhivex-ai/core").CostEstimate;
+    };
+    scope: import("@zhivex-ai/core").AgentStoreScope | undefined;
+    capabilities: import("../index.js").HarnessModelCapabilityReport;
+    orchestration: {
+        profiles: readonly ("explorer" | "implementer" | "reviewer" | "tester")[];
+        childBudget: import("../index.js").HarnessBudget;
+        mcpServers: string[];
+    };
+    execution: {
+        backend: "oci";
+        binding: import("@zhivex-ai/core").AgentExecutionEnvironmentBinding | undefined;
+        image: import("../index.js").OciImageInspection;
+    } | {
+        binding?: never;
+        image?: never;
+        backend: "none";
+    };
+    store: {
+        backend: "file" | "sqlite";
+        stateDirectory: string;
+        migration: import("../index.js").HarnessMigrationResult | undefined;
+    };
+    stateDirectory: string;
+};

package/dist/client/service-events.d.ts

@@ -1,3 +1,4 @@
+import { type HarnessPolicyDecisionEvent } from "../runtime/policy-decisions.js";
 import { type AgentStreamEvent } from "@zhivex-ai/agents";
 import type { HarnessConfig } from "../runtime/config.js";
 export interface HarnessActivityEvent {
@@ -30,11 +31,14 @@ export interface HarnessActivitySnapshot {
 export interface HarnessActivityPage {
     schemaVersion: 1;
     cursorExpired: boolean;
+    hasMore?: boolean;
+    policyEvidenceIncomplete?: boolean;
     nextCursor: number;
     events: HarnessActivityEvent[];
     snapshot?: HarnessActivitySnapshot;
 }
 export interface HarnessActivityStore {
+    policyDecision(sessionId: string, runId: string, event: HarnessPolicyDecisionEvent): void;
     prompt(sessionId: string, runId: string, prompt: string): void;
     append(sessionId: string, runId: string, event: AgentStreamEvent): void;
     checkpoint(sessionId: string, runId: string, status: string): void;