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

package/dist/integrations/mcp-host-session.d.ts

@@ -0,0 +1,26 @@
+import type { AgentRunStore, AgentStoreScope, ToolSet } from '@zhivex-ai/core';
+import type { McpStdioLaunchProposal } from './mcp-stdio-admission.js';
+/** Opaque capability issued only after the host's admitted OCI launch succeeds. */
+export type HarnessIsolatedMcpSession = Readonly<Record<never, never>>;
+/** Internal issuer; this module is not a package entry point. */
+export declare function issueMcpHostSession(options: {
+    tools: ToolSet;
+    store: AgentRunStore;
+    scope: AgentStoreScope;
+    runId: string;
+    proposal: Readonly<McpStdioLaunchProposal>;
+    close(): Promise<void>;
+}): HarnessIsolatedMcpSession;
+export declare function resolveMcpHostSession(token: HarnessIsolatedMcpSession): {
+    tools: ToolSet;
+    store: AgentRunStore;
+    scope: AgentStoreScope;
+    runId: string;
+    workspace: string;
+    fingerprint: string;
+    close(): Promise<void>;
+    active: boolean;
+};
+export declare function closeMcpHostSession(token: HarnessIsolatedMcpSession): Promise<void>;
+/** Internal composition of already admitted sessions; never accepts raw tools. */
+export declare function combineMcpHostSessions(tokens: readonly HarnessIsolatedMcpSession[]): HarnessIsolatedMcpSession;

package/dist/integrations/mcp-stdio-admission.d.ts

@@ -0,0 +1,54 @@
+import { z } from 'zod';
+declare const proposalSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    serverId: z.ZodString;
+    boundary: z.ZodLiteral<"oci">;
+    image: z.ZodString;
+    executable: z.ZodString;
+    args: z.ZodArray<z.ZodString>;
+    protocolVersion: z.ZodLiteral<"2025-11-25">;
+    workingDirectory: z.ZodString;
+    snapshotDigest: z.ZodString;
+    scope: z.ZodObject<{
+        principal: z.ZodString;
+        tenant: z.ZodString;
+        session: z.ZodString;
+        workspace: z.ZodString;
+    }, z.core.$strict>;
+    includeTools: z.ZodArray<z.ZodString>;
+    permissions: z.ZodArray<z.ZodEnum<{
+        read: "read";
+        write: "write";
+    }>>;
+    environment: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+    secretReferences: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+    limits: z.ZodObject<{
+        sessionMs: z.ZodNumber;
+        callMs: z.ZodNumber;
+        memoryMb: z.ZodNumber;
+        maxCpus: z.ZodNumber;
+        maxPids: z.ZodNumber;
+        maxWorkspaceBytes: z.ZodNumber;
+        maxFileWriteBytes: z.ZodNumber;
+        tmpfsMb: z.ZodNumber;
+        maxOutputBytes: z.ZodNumber;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type McpStdioLaunchProposal = z.infer<typeof proposalSchema>;
+export type McpStdioLaunchReceipt = Readonly<Record<never, never>>;
+export declare class McpStdioAdmissionError extends Error {
+    constructor(message: string);
+}
+/** Owned by the trusted host, never constructed from client/workspace configuration. */
+export declare function createMcpStdioAdmissionAuthority(options: {
+    policyVersion: string;
+    maximumLimits: McpStdioLaunchProposal['limits'];
+    authorize: (proposal: Readonly<McpStdioLaunchProposal>) => Promise<boolean>;
+    receiptTtlMs?: number;
+    reviewTimeoutMs?: number;
+    now?: () => number;
+}): {
+    admit(input: unknown): Promise<McpStdioLaunchReceipt>;
+    consume(receipt: McpStdioLaunchReceipt, input: unknown): Readonly<McpStdioLaunchProposal>;
+};
+export {};

package/dist/integrations/mcp-stdio-client.d.ts

@@ -0,0 +1,44 @@
+import type { McpCallToolOptions, McpCallToolRequest, McpCallToolResponse, McpClient, McpListToolsRequest, McpListToolsResponse } from '@zhivex-ai/core';
+/** Supplied only by the admitted isolated-process owner. No executable or spawn API. */
+export interface IsolatedMcpChannel {
+    stdout: AsyncIterable<Uint8Array>;
+    write(frame: Uint8Array): Promise<void>;
+    /** Resolves only after the entire boundary/process tree has been removed. */
+    close(): Promise<void>;
+}
+export declare class McpStdioClientError extends Error {
+    readonly code: 'closed' | 'busy' | 'timeout' | 'cancelled' | 'protocol' | 'remote' | 'cleanup_required';
+    readonly outcomeUnknown: boolean;
+    constructor(code: 'closed' | 'busy' | 'timeout' | 'cancelled' | 'protocol' | 'remote' | 'cleanup_required', message: string, outcomeUnknown?: boolean);
+}
+/** Internal protocol client. Admission, isolated launch and per-tool approval belong to the host. */
+export declare class IsolatedMcpStdioClient implements McpClient {
+    private readonly channel;
+    private readonly limits;
+    private nextId;
+    private pending;
+    private stopped;
+    private ready;
+    private initializing;
+    private closing;
+    private readonly decoder;
+    private readonly reading;
+    constructor(channel: IsolatedMcpChannel, limits: {
+        callMs: number;
+        initializeMs: number;
+        sessionMs: number;
+        maxFrameBytes: number;
+        closeMs?: number;
+    });
+    private readonly sessionTimer;
+    private receive;
+    private read;
+    private fail;
+    private request;
+    initialize(): Promise<void>;
+    private initializeInternal;
+    listTools(input?: McpListToolsRequest, options?: McpCallToolOptions): Promise<McpListToolsResponse>;
+    callTool(input: McpCallToolRequest, options?: McpCallToolOptions): Promise<McpCallToolResponse>;
+    private boundedCleanup;
+    close(): Promise<void>;
+}

package/dist/integrations/mcp-stdio-framing.d.ts

@@ -0,0 +1,18 @@
+/** Internal codec only. It does not spawn processes, admit servers or grant tools. */
+export type McpStdioMessage = Record<string, unknown> & {
+    jsonrpc: '2.0';
+};
+export declare class McpStdioProtocolError extends Error {
+    constructor(message: string);
+}
+/** Byte limits apply before UTF-8 decoding, including an unfinished line. */
+export declare class McpStdioFrameDecoder {
+    private readonly maxFrameBytes;
+    private readonly onMessage;
+    private readonly frame;
+    private size;
+    private ended;
+    constructor(maxFrameBytes: number, onMessage: (message: McpStdioMessage) => void);
+    push(chunk: Uint8Array): void;
+    finish(): void;
+}

package/dist/integrations/mcp-stdio-launch.d.ts

@@ -0,0 +1,20 @@
+import { consumeMcpWorkspaceSnapshot, type McpWorkspaceSnapshot } from '../execution/mcp-workspace-snapshot.js';
+import { type createMcpStdioAdmissionAuthority, type McpStdioLaunchProposal, type McpStdioLaunchReceipt } from './mcp-stdio-admission.js';
+type Authority = ReturnType<typeof createMcpStdioAdmissionAuthority>;
+type SnapshotFiles = Parameters<Parameters<typeof consumeMcpWorkspaceSnapshot>[2]>[0];
+/** Trusted host handoff only. The seeder owns creation, OCI attestation and cleanup. */
+export declare function withAdmittedMcpLaunch<T>(options: {
+    authority: Authority;
+    receipt: McpStdioLaunchReceipt;
+    proposal: unknown;
+    snapshot: McpWorkspaceSnapshot;
+    /** Supplied by the authenticated host session, never copied from proposal input. */
+    scope: McpStdioLaunchProposal['scope'];
+    resolveSecret: (reference: string, signal: AbortSignal) => Promise<string | undefined>;
+    seed: (launch: {
+        proposal: Readonly<McpStdioLaunchProposal>;
+        environment: Readonly<Record<string, string>>;
+        files: SnapshotFiles;
+    }) => Promise<T>;
+}): Promise<T>;
+export {};

package/dist/integrations/mcp-stdio-session.d.ts

@@ -0,0 +1,7 @@
+import { launchDockerMcpTools } from '../execution/mcp-oci-server.js';
+export type IsolatedMcpLaunchOptions = Omit<Parameters<typeof launchDockerMcpTools>[0], 'resourceJournal'>;
+/** Returns only the opaque harness capability and lifecycle control, not raw tools. */
+export declare function launchIsolatedMcpSession(options: IsolatedMcpLaunchOptions): Promise<Readonly<{
+    hostSession: Readonly<Record<never, never>>;
+    close: () => Promise<void>;
+}>>;

package/dist/integrations/mcp-stdio-tools.d.ts

@@ -0,0 +1,12 @@
+import { type McpClient, type ToolSet } from '@zhivex-ai/core';
+import type { McpStdioLaunchProposal } from './mcp-stdio-admission.js';
+import { createJournaledMcpClient } from '../persistence/mcp-execution-journal.js';
+/** Host tool bridge. Existing agent execution supplies durable interrupt approvals. */
+export declare function createIsolatedMcpTools(options: {
+    client: McpClient & {
+        close(): Promise<void>;
+    };
+    proposal: Readonly<McpStdioLaunchProposal>;
+    sensitiveValues?: readonly string[];
+    journal?: Pick<Parameters<typeof createJournaledMcpClient>[0], 'store' | 'runId' | 'scope'>;
+}): Promise<ToolSet>;

package/dist/internal/desktop/catalog.d.ts

@@ -0,0 +1,2 @@
+/** Renderer-safe metadata only: never load provider transports or credentials. */
+export { modelDescription } from "../../models/catalog.js";

package/dist/internal/desktop/persistence.d.ts

@@ -8,7 +8,6 @@ export { acquireSqliteAccess } from "../../persistence/sqlite-access.js";
 export { adoptExclusiveSqliteAccess } from "../../persistence/sqlite-access.js";
 export { exclusiveSqliteAccessDescriptor } from "../../persistence/sqlite-access.js";
 export type { SqliteAccessLease } from "../../persistence/sqlite-access.js";
-export { SqliteDatabase } from "../../persistence/sqlite-database.js";
-export { createArchivedHarnessStateBackup } from "../../persistence/state-backup.js";
-export { createHarnessStateBackup } from "../../persistence/state-backup.js";
+export { DESKTOP_DATABASE_BACKUP_LIMIT, createDesktopDatabaseBackup, verifyDesktopDatabaseBackup, verifyDesktopDatabaseState } from "../../persistence/host-database-backup.js";
+export type { DesktopDatabaseBackup, DesktopBackupConfig } from "../../persistence/host-database-backup.js";
 export { validateStateDirectory } from "../../persistence/state-directory.js";

package/dist/internal/desktop/providers.d.ts

@@ -4,6 +4,7 @@ export type { HarnessConfig } from "../../runtime/config.js";
 export { resolveHarnessConfig } from "../../runtime/config.js";
 export { DEFAULT_PROVIDER_REGISTRY } from "../../providers/providers.js";
 export { PROVIDERS } from "../../providers/providers.js";
+export { vertexConfigured, vertexEnvironment, vertexTokenSource, vertexRoute } from "../../providers/vertex-auth.js";
 export { bundledModelCatalog, catalogModels, modelDescription } from "../../models/catalog.js";
 export type { CatalogModel, ModelCatalog } from "../../models/catalog.js";
 export { loadModelCatalog } from "../../models/catalog-store.js";

package/dist/models/catalog.d.ts

@@ -69,10 +69,12 @@ export declare const modelCatalogSchema: z.ZodObject<{
     revision: z.ZodString;
     providers: z.ZodArray<z.ZodObject<{
         id: z.ZodEnum<{
+            anthropic: "anthropic";
             gemini: "gemini";
             meta: "meta";
             openai: "openai";
             qwen: "qwen";
+            vertex: "vertex";
         }>;
         defaultModel: z.ZodString;
         models: z.ZodArray<z.ZodObject<{

package/dist/persistence/governance-context.d.ts

@@ -0,0 +1,126 @@
+import { z } from 'zod';
+import type { CliSessionStore } from './sessions.js';
+export declare const governanceReference: (kind: string, value: string) => string;
+export declare const governanceSessionSchema: z.ZodObject<{
+    availability: z.ZodEnum<{
+        recorded: "recorded";
+        unavailable: "unavailable";
+    }>;
+    reference: z.ZodNullable<z.ZodString>;
+    revision: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strict>;
+export declare const governanceHistorySchema: z.ZodObject<{
+    availability: z.ZodEnum<{
+        recorded: "recorded";
+        unavailable: "unavailable";
+    }>;
+    retention: z.ZodEnum<{
+        expired: "expired";
+        retained: "retained";
+        unknown: "unknown";
+    }>;
+    incomplete: z.ZodBoolean;
+    policyDecisions: z.ZodArray<z.ZodObject<{
+        runReference: z.ZodString;
+        sequence: z.ZodNumber;
+        toolReference: z.ZodString;
+        phase: z.ZodEnum<{
+            "approval-request": "approval-request";
+            "tool-entry": "tool-entry";
+        }>;
+        decision: z.ZodEnum<{
+            allow: "allow";
+            ask_user: "ask_user";
+            deny: "deny";
+        }>;
+        policyDigest: z.ZodNullable<z.ZodString>;
+        source: z.ZodEnum<{
+            application: "application";
+            baseline: "baseline";
+            "operator-file": "operator-file";
+        }>;
+        ruleReferences: z.ZodArray<z.ZodString>;
+        explicitReviewRequired: z.ZodBoolean;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const governanceEnvelopeSchema: z.ZodObject<{
+    source: z.ZodLiteral<"caller-supplied">;
+    envelopeId: z.ZodNullable<z.ZodString>;
+    patchReference: z.ZodNullable<z.ZodString>;
+    patchDigest: z.ZodNullable<z.ZodString>;
+    linkedRunReferences: z.ZodArray<z.ZodString>;
+    schemaValid: z.ZodBoolean;
+    integrity: z.ZodEnum<{
+        invalid: "invalid";
+        valid: "valid";
+    }>;
+    expiration: z.ZodEnum<{
+        current: "current";
+        expired: "expired";
+        "not-yet-valid": "not-yet-valid";
+        unknown: "unknown";
+    }>;
+    checkedAt: z.ZodISODateTime;
+    expiredApprovals: z.ZodNumber;
+    authenticity: z.ZodLiteral<"not-verified">;
+    patchBytes: z.ZodLiteral<"not-verified">;
+}, z.core.$strict>;
+/** Both readers must already be bound to the same workspace and scope as the run store. */
+export interface GovernanceSessionSource {
+    id: string;
+    index: Pick<CliSessionStore, 'get'>;
+    history?: {
+        replay(sessionId: string, after?: number): {
+            schemaVersion: 1;
+            cursorExpired: boolean;
+            hasMore?: boolean;
+            policyEvidenceIncomplete?: boolean;
+            nextCursor: number;
+            events: Array<{
+                sessionId: string;
+                runId: string;
+                sequence: number;
+                activity: Record<string, unknown>;
+            }>;
+        };
+    };
+}
+export declare function readGovernanceSession(source: GovernanceSessionSource | undefined, rootRunId: string, runIds: ReadonlySet<string>): Promise<{
+    session: {
+        availability: "recorded" | "unavailable";
+        reference: string | null;
+        revision: number | null;
+    };
+    history: {
+        availability: "recorded" | "unavailable";
+        retention: "expired" | "retained" | "unknown";
+        incomplete: boolean;
+        policyDecisions: {
+            runReference: string;
+            sequence: number;
+            toolReference: string;
+            phase: "approval-request" | "tool-entry";
+            decision: "allow" | "ask_user" | "deny";
+            policyDigest: string | null;
+            source: "application" | "baseline" | "operator-file";
+            ruleReferences: string[];
+            explicitReviewRequired: boolean;
+        }[];
+    };
+    verify: () => Promise<void>;
+}>;
+/** Envelopes are references supplied by the caller, never inferred signatures or executed checks. */
+export declare function projectGovernanceEnvelopes(envelopes: readonly unknown[], patches: ReadonlyMap<string, readonly string[]>, now: number): {
+    source: "caller-supplied";
+    envelopeId: string | null;
+    patchReference: string | null;
+    patchDigest: string | null;
+    linkedRunReferences: string[];
+    schemaValid: boolean;
+    integrity: "invalid" | "valid";
+    expiration: "current" | "expired" | "not-yet-valid" | "unknown";
+    checkedAt: string;
+    expiredApprovals: number;
+    authenticity: "not-verified";
+    patchBytes: "not-verified";
+}[];

package/dist/persistence/governance-report.d.ts

@@ -0,0 +1,299 @@
+import { z } from 'zod';
+import type { AgentRunStore, AgentStoreScope } from '@zhivex-ai/core';
+import { type GovernanceSessionSource } from './governance-context.js';
+/** Experimental v1 projection. No messages, arguments, outputs or arbitrary metadata fields. */
+export declare const harnessGovernanceReportSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    kind: z.ZodLiteral<"harness-governance-report">;
+    exporterVersion: z.ZodString;
+    executionArtifact: z.ZodObject<{
+        version: z.ZodNullable<z.ZodString>;
+        digest: z.ZodNull;
+        availability: z.ZodEnum<{
+            "recorded-version": "recorded-version";
+            unavailable: "unavailable";
+        }>;
+        configurationFingerprint: z.ZodNullable<z.ZodString>;
+        authenticity: z.ZodLiteral<"not-verified">;
+    }, z.core.$strict>;
+    rootReference: z.ZodString;
+    identity: z.ZodLiteral<"not-verified">;
+    referencePolicy: z.ZodLiteral<"sha256-domain-separated-pseudonyms-not-anonymity">;
+    session: z.ZodObject<{
+        availability: z.ZodEnum<{
+            recorded: "recorded";
+            unavailable: "unavailable";
+        }>;
+        reference: z.ZodNullable<z.ZodString>;
+        revision: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strict>;
+    eventHistory: z.ZodObject<{
+        availability: z.ZodEnum<{
+            recorded: "recorded";
+            unavailable: "unavailable";
+        }>;
+        retention: z.ZodEnum<{
+            expired: "expired";
+            retained: "retained";
+            unknown: "unknown";
+        }>;
+        incomplete: z.ZodBoolean;
+        policyDecisions: z.ZodArray<z.ZodObject<{
+            runReference: z.ZodString;
+            sequence: z.ZodNumber;
+            toolReference: z.ZodString;
+            phase: z.ZodEnum<{
+                "approval-request": "approval-request";
+                "tool-entry": "tool-entry";
+            }>;
+            decision: z.ZodEnum<{
+                allow: "allow";
+                ask_user: "ask_user";
+                deny: "deny";
+            }>;
+            policyDigest: z.ZodNullable<z.ZodString>;
+            source: z.ZodEnum<{
+                application: "application";
+                baseline: "baseline";
+                "operator-file": "operator-file";
+            }>;
+            ruleReferences: z.ZodArray<z.ZodString>;
+            explicitReviewRequired: z.ZodBoolean;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    changeEnvelopes: z.ZodArray<z.ZodObject<{
+        source: z.ZodLiteral<"caller-supplied">;
+        envelopeId: z.ZodNullable<z.ZodString>;
+        patchReference: z.ZodNullable<z.ZodString>;
+        patchDigest: z.ZodNullable<z.ZodString>;
+        linkedRunReferences: z.ZodArray<z.ZodString>;
+        schemaValid: z.ZodBoolean;
+        integrity: z.ZodEnum<{
+            invalid: "invalid";
+            valid: "valid";
+        }>;
+        expiration: z.ZodEnum<{
+            current: "current";
+            expired: "expired";
+            "not-yet-valid": "not-yet-valid";
+            unknown: "unknown";
+        }>;
+        checkedAt: z.ZodISODateTime;
+        expiredApprovals: z.ZodNumber;
+        authenticity: z.ZodLiteral<"not-verified">;
+        patchBytes: z.ZodLiteral<"not-verified">;
+    }, z.core.$strict>>;
+    runs: z.ZodArray<z.ZodObject<{
+        reference: z.ZodString;
+        parentReference: z.ZodNullable<z.ZodString>;
+        revision: z.ZodNullable<z.ZodNumber>;
+        status: z.ZodEnum<{
+            cancel_requested: "cancel_requested";
+            cancelled: "cancelled";
+            completed: "completed";
+            created: "created";
+            failed: "failed";
+            running: "running";
+            timed_out: "timed_out";
+            unknown: "unknown";
+            waiting_approval: "waiting_approval";
+        }>;
+        finalized: z.ZodBoolean;
+        failure: z.ZodNullable<z.ZodEnum<{
+            cancelled: "cancelled";
+            not_reported: "not_reported";
+            run_failed: "run_failed";
+            timed_out: "timed_out";
+        }>>;
+        failureDetails: z.ZodObject<{
+            providerToolReason: z.ZodNullable<z.ZodEnum<{
+                arguments_too_large: "arguments_too_large";
+                empty_arguments: "empty_arguments";
+                incomplete_arguments: "incomplete_arguments";
+                inconsistent_metadata: "inconsistent_metadata";
+                invalid_json: "invalid_json";
+                response_failed: "response_failed";
+                response_incomplete: "response_incomplete";
+                stream_truncated: "stream_truncated";
+            }>>;
+            diagnosticReference: z.ZodNullable<z.ZodString>;
+            deliveryReason: z.ZodNullable<z.ZodEnum<{
+                TASK_ACCEPTANCE_CHECKS_MISSING: "TASK_ACCEPTANCE_CHECKS_MISSING";
+                TASK_ACCEPTANCE_DELIVERY_DRIFT: "TASK_ACCEPTANCE_DELIVERY_DRIFT";
+                TASK_ACCEPTANCE_DELIVERY_INSPECTION_FAILED: "TASK_ACCEPTANCE_DELIVERY_INSPECTION_FAILED";
+                TASK_ACCEPTANCE_HUMAN_REVIEW_REQUIRED: "TASK_ACCEPTANCE_HUMAN_REVIEW_REQUIRED";
+                TASK_ACCEPTANCE_IMPORT_UNCONFIRMED: "TASK_ACCEPTANCE_IMPORT_UNCONFIRMED";
+                TASK_ACCEPTANCE_NO_DELIVERY_EVIDENCE: "TASK_ACCEPTANCE_NO_DELIVERY_EVIDENCE";
+                TASK_ACCEPTANCE_RUN_NOT_COMPLETED: "TASK_ACCEPTANCE_RUN_NOT_COMPLETED";
+                TASK_ACCEPTANCE_RUN_NOT_FINISHED: "TASK_ACCEPTANCE_RUN_NOT_FINISHED";
+                TASK_ACCEPTANCE_SCOPE_VIOLATION: "TASK_ACCEPTANCE_SCOPE_VIOLATION";
+                TASK_ACCEPTANCE_VERIFIED: "TASK_ACCEPTANCE_VERIFIED";
+            }>>;
+        }, z.core.$strict>;
+        identity: z.ZodLiteral<"not-verified">;
+        runtimePolicy: z.ZodNullable<z.ZodEnum<{
+            "assistant-v3-durable-closure": "assistant-v3-durable-closure";
+        }>>;
+        contract: z.ZodObject<{
+            availability: z.ZodEnum<{
+                invalid: "invalid";
+                recorded: "recorded";
+                unavailable: "unavailable";
+            }>;
+            digest: z.ZodNullable<z.ZodString>;
+            revision: z.ZodNullable<z.ZodNumber>;
+            requiredChecks: z.ZodNullable<z.ZodNumber>;
+            humanReviewsPending: z.ZodNullable<z.ZodNumber>;
+            allowedWritePathReferences: z.ZodArray<z.ZodString>;
+            protectedPathReferences: z.ZodArray<z.ZodString>;
+            checks: z.ZodArray<z.ZodObject<{
+                reference: z.ZodString;
+                argvDigest: z.ZodString;
+                kind: z.ZodEnum<{
+                    argv: "argv";
+                    "package-script": "package-script";
+                }>;
+                backend: z.ZodEnum<{
+                    none: "none";
+                    oci: "oci";
+                }>;
+                approval: z.ZodLiteral<"required">;
+            }, z.core.$strict>>;
+            humanReviewReferences: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>;
+        delivery: z.ZodObject<{
+            availability: z.ZodEnum<{
+                invalid: "invalid";
+                recorded: "recorded";
+                unavailable: "unavailable";
+            }>;
+            status: z.ZodEnum<{
+                failed: "failed";
+                incomplete: "incomplete";
+                pending: "pending";
+                pending_review: "pending_review";
+                unknown: "unknown";
+                verified: "verified";
+            }>;
+            patchId: z.ZodNullable<z.ZodString>;
+            snapshotDigest: z.ZodNullable<z.ZodString>;
+            interpretation: z.ZodLiteral<"recorded-checkpoint-not-current-workspace-verification">;
+            checks: z.ZodArray<z.ZodObject<{
+                reference: z.ZodString;
+                argvDigest: z.ZodString;
+                patchId: z.ZodString;
+                snapshotDigest: z.ZodString;
+                exitCode: z.ZodNumber;
+                timedOut: z.ZodBoolean;
+                unchanged: z.ZodBoolean;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        approvals: z.ZodObject<{
+            availability: z.ZodEnum<{
+                invalid: "invalid";
+                recorded: "recorded";
+                unavailable: "unavailable";
+            }>;
+            items: z.ZodArray<z.ZodObject<{
+                reference: z.ZodString;
+                toolReference: z.ZodString;
+                approved: z.ZodBoolean;
+                origin: z.ZodEnum<{
+                    application: "application";
+                    automatic: "automatic";
+                    interactive: "interactive";
+                    unknown: "unknown";
+                }>;
+                channelReference: z.ZodString;
+                policyDigest: z.ZodNullable<z.ZodString>;
+                status: z.ZodEnum<{
+                    applied: "applied";
+                    approved: "approved";
+                    failed: "failed";
+                    rejected: "rejected";
+                    succeeded: "succeeded";
+                    unknown: "unknown";
+                }>;
+                proposalId: z.ZodNullable<z.ZodString>;
+                exitCode: z.ZodNullable<z.ZodNumber>;
+                timedOut: z.ZodNullable<z.ZodBoolean>;
+                effects: z.ZodArray<z.ZodObject<{
+                    pathReference: z.ZodString;
+                    beforeDigest: z.ZodNullable<z.ZodString>;
+                    afterDigest: z.ZodNullable<z.ZodString>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        usage: z.ZodObject<{
+            availability: z.ZodEnum<{
+                recorded: "recorded";
+                unavailable: "unavailable";
+            }>;
+            calls: z.ZodNullable<z.ZodNumber>;
+            inputTokens: z.ZodNullable<z.ZodNumber>;
+            outputTokens: z.ZodNullable<z.ZodNumber>;
+            complete: z.ZodNullable<z.ZodBoolean>;
+            estimatedUsd: z.ZodNullable<z.ZodNumber>;
+            costKind: z.ZodLiteral<"estimate-not-invoice">;
+        }, z.core.$strict>;
+        journal: z.ZodObject<{
+            availability: z.ZodEnum<{
+                recorded: "recorded";
+                unavailable: "unavailable";
+            }>;
+            entries: z.ZodNumber;
+            failed: z.ZodNumber;
+            unfinished: z.ZodNumber;
+        }, z.core.$strict>;
+        delegations: z.ZodObject<{
+            availability: z.ZodEnum<{
+                invalid: "invalid";
+                recorded: "recorded";
+                unavailable: "unavailable";
+            }>;
+            interpretation: z.ZodLiteral<"recorded-checkpoint-not-semantic-review">;
+            items: z.ZodArray<z.ZodObject<{
+                taskReference: z.ZodString;
+                childReference: z.ZodNullable<z.ZodString>;
+                recordedAcceptance: z.ZodBoolean;
+                reason: z.ZodEnum<{
+                    child_identity_unavailable: "child_identity_unavailable";
+                    coverage_missing: "coverage_missing";
+                    duplicate_claim: "duplicate_claim";
+                    evidence_missing: "evidence_missing";
+                    incomplete: "incomplete";
+                    invalid_json: "invalid_json";
+                    invalid_schema: "invalid_schema";
+                    missing_child: "missing_child";
+                    path_denied: "path_denied";
+                    task_mismatch: "task_mismatch";
+                    valid: "valid";
+                }>;
+                semanticReview: z.ZodEnum<{
+                    not_requested: "not_requested";
+                    pending: "pending";
+                }>;
+                correctionsUsed: z.ZodNullable<z.ZodNumber>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        children: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    missingChildren: z.ZodArray<z.ZodString>;
+    limitations: z.ZodArray<z.ZodEnum<{
+        invalid_approvals: "invalid_approvals";
+        invalid_contract: "invalid_contract";
+        invalid_delivery: "invalid_delivery";
+        journal_unavailable: "journal_unavailable";
+        missing_child: "missing_child";
+        tree_limit: "tree_limit";
+    }>>;
+}, z.core.$strict>;
+export type HarnessGovernanceReport = z.infer<typeof harnessGovernanceReportSchema>;
+export interface HarnessGovernanceOptions {
+    session?: GovernanceSessionSource;
+    changeEnvelopes?: readonly unknown[];
+    now?: number;
+}
+/** Read-only store projection. Refuses concurrent revision changes and excessive journals. */
+export declare function exportHarnessGovernanceReport(store: AgentRunStore, scope: AgentStoreScope | undefined, runId: string, options?: HarnessGovernanceOptions): Promise<HarnessGovernanceReport>;
+export declare function renderHarnessGovernanceMarkdown(input: unknown): string;