@zhivex-ai/harness 1.3.0-rc.3 → 1.3.0

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;

package/dist/persistence/host-database-backup.d.ts

@@ -0,0 +1,28 @@
+import type { HarnessConfig } from "../runtime/config.js";
+import { type SqliteAccessLease } from "./sqlite-access.js";
+export declare const DESKTOP_DATABASE_BACKUP_LIMIT: number;
+export interface DesktopDatabaseBackup {
+    directory: string;
+    size: number;
+    sha256: string;
+    logicalChecksum: string;
+}
+export interface DesktopBackupConfig extends HarnessConfig {
+    workspaceAbsent?: true;
+    accessLease?: SqliteAccessLease;
+}
+/** Full SQLite snapshot, including visual activity and any other tables.
+ * Caller must hold desktop admission closed and provide host-controlled paths.
+ * This captures one database; cross-project/index consistency belongs to the update transaction.
+ */
+export declare function createDesktopDatabaseBackup(config: DesktopBackupConfig, backupRoot: string): Promise<DesktopDatabaseBackup>;
+/** Rechecks the immutable copy against the host-held receipt before recovery may consume it. */
+export declare function verifyDesktopDatabaseBackup(backup: DesktopDatabaseBackup): Promise<void>;
+/** Worker state check under an exclusive inherited lease. Reads the live database
+ * without migrations, checkpointing, opening sessions or recreating a checkout.
+ * Core export validation covers its records; it is not an equality comparison
+ * against the backup or a semantic validator for every desktop activity table.
+ */
+export declare function verifyDesktopDatabaseState(config: DesktopBackupConfig & {
+    accessLease: SqliteAccessLease;
+}): Promise<void>;

package/dist/persistence/mcp-execution-journal.d.ts

@@ -0,0 +1,19 @@
+import type { AgentRunStore, AgentStoreScope, McpClient } from '@zhivex-ai/core';
+import type { McpStdioLaunchProposal } from '../integrations/mcp-stdio-admission.js';
+export declare class McpExecutionJournalError extends Error {
+    readonly code: 'persistence_failed' | 'identity_changed' | 'replay_denied' | 'outcome_unknown' | 'cleanup_required';
+    readonly outcomeUnknown: boolean;
+    constructor(code: 'persistence_failed' | 'identity_changed' | 'replay_denied' | 'outcome_unknown' | 'cleanup_required', outcomeUnknown: boolean);
+}
+/** Reuses the scoped operations journal. Never stores raw arguments, secrets or server output. */
+export declare function createJournaledMcpClient(options: {
+    client: McpClient & {
+        close(): Promise<void>;
+    };
+    proposal: Readonly<McpStdioLaunchProposal>;
+    store: AgentRunStore;
+    runId: string;
+    scope: AgentStoreScope;
+}): McpClient & {
+    close(): Promise<void>;
+};

package/dist/persistence/mcp-reconciliation.d.ts

@@ -0,0 +1,33 @@
+import { z } from 'zod';
+import type { AgentRunStore, AgentStoreScope } from '@zhivex-ai/core';
+declare const decisionSchema: z.ZodObject<{
+    toolCallId: z.ZodString;
+    expectedRevision: z.ZodNumber;
+    outcome: z.ZodEnum<{
+        effect_confirmed: "effect_confirmed";
+        no_effect_confirmed: "no_effect_confirmed";
+    }>;
+    evidenceDigest: z.ZodString;
+}, z.core.$strict>;
+export type McpReconciliationDecision = z.infer<typeof decisionSchema>;
+export interface McpReconciliationReview extends McpReconciliationDecision {
+    readonly runId: string;
+    readonly scope: Readonly<AgentStoreScope>;
+    readonly proposalHash: string;
+    readonly argumentsHash: string;
+    readonly toolNameHash: string;
+}
+/** Host-only decision authority. No model tool or workspace configuration exposes it.
+ * A resolution never supplies a fabricated result or replays the original key.
+ * Fresh execution still requires fresh host admission and agent approval.
+ */
+export declare function createMcpReconciliationAuthority(options: {
+    store: AgentRunStore;
+    runId: string;
+    scope: AgentStoreScope;
+    hostId: string;
+    authorize(review: Readonly<McpReconciliationReview>): Promise<boolean>;
+}): Readonly<{
+    reconcile(input: McpReconciliationDecision): Promise<void>;
+}>;
+export {};

package/dist/persistence/mcp-resource-journal.d.ts

@@ -0,0 +1,54 @@
+import { z } from 'zod';
+import type { AgentRunStore, AgentStoreScope } from '@zhivex-ai/core';
+import type { McpStdioLaunchProposal } from '../integrations/mcp-stdio-admission.js';
+declare const phases: readonly ['reserved', 'provisioning', 'ready', 'closing', 'closed', 'cleanup_required'];
+export type McpResourcePhase = typeof phases[number];
+export declare const mcpResourcePlanSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    kind: z.ZodLiteral<"isolated-mcp-resources">;
+    leaseId: z.ZodString;
+    scopeHash: z.ZodString;
+    hostHash: z.ZodString;
+    proposalHash: z.ZodString;
+    daemonId: z.ZodString;
+    ownerPid: z.ZodNumber;
+    ownerInstance: z.ZodString;
+    serverImageId: z.ZodString;
+    provisionerImageId: z.ZodString;
+    serverName: z.ZodString;
+    volumeName: z.ZodString;
+    seederName: z.ZodString;
+}, z.core.$strict>;
+export type McpResourcePlan = Readonly<z.infer<typeof mcpResourcePlanSchema>>;
+export declare const mcpResourceOutputSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    phase: z.ZodEnum<{
+        cleanup_required: "cleanup_required";
+        closed: "closed";
+        closing: "closing";
+        provisioning: "provisioning";
+        ready: "ready";
+        reserved: "reserved";
+    }>;
+}, z.core.$strict>;
+export interface McpResourceLeaseJournal {
+    readonly plan: McpResourcePlan;
+    /** Label values contain only scoped identifiers, never commands or credentials. */
+    readonly labels: Readonly<Record<string, string>>;
+    advance(phase: McpResourcePhase): Promise<void>;
+}
+/** Reserve all names durably before creating any Docker resource. Host identity is host-owned. */
+export declare function reserveMcpResources(options: {
+    store: AgentRunStore;
+    runId: string;
+    scope: AgentStoreScope;
+    hostId: string;
+    daemonId: string;
+    proposal: Readonly<McpStdioLaunchProposal>;
+    serverImageId: string;
+    provisionerImageId: string;
+}): Promise<McpResourceLeaseJournal>;
+/** Reconstruct only non-secret ownership labels from a validated durable plan. */
+export declare function mcpResourceLabels(plan: McpResourcePlan): Readonly<Record<string, string>>;
+export declare function matchesMcpResourceScope(plan: McpResourcePlan, runId: string, scope: AgentStoreScope, hostId: string): boolean;
+export {};

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

@@ -40,6 +40,10 @@ export declare const workspaceRestoreOperationSchema: z.ZodObject<{
 }, z.core.$strict>;
 export type WorkspaceCheckpoint = z.infer<typeof workspaceCheckpointSchema>;
 export type WorkspaceRestoreOperation = z.infer<typeof workspaceRestoreOperationSchema>;
+declare const retentionSelection: z.ZodObject<{
+    checkpointIds: z.ZodArray<z.ZodString>;
+    completedRestoreIds: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
 /** Existing text files only. No deletion, creation, binary file, or mode rollback. */
 export declare const openWorkspaceCheckpointStore: (workspace: Workspace, sessions: CliSessionStore) => Promise<{
     close: () => void;
@@ -72,6 +76,139 @@ export declare const openWorkspaceCheckpointStore: (workspace: Workspace, sessio
         stage: "applied" | "applying" | "completed" | "forked" | "forking" | "prepared";
         forkSessionId?: string | undefined;
     };
+    storageStatus: () => {
+        policy: 'explicit-reviewed-removal';
+        automaticEviction: false;
+        maxRecords: number;
+        maxRecordBytes: number;
+        maxFilesPerCheckpoint: number;
+        maxFileBytes: number;
+        records: number;
+        availableRecords: number;
+        serializedBytes: number;
+        pendingRestores: number;
+        checkpoints: {
+            id: string;
+            referenced: boolean;
+        }[];
+    };
+    prepareRetention: (input: z.infer<typeof retentionSelection>) => {
+        planId: string;
+        selection: {
+            checkpointIds: string[];
+            completedRestoreIds: string[];
+        };
+        records: {
+            id: string;
+            kind: string;
+            sessionId: string;
+            bytes: number;
+        }[];
+        recordsBefore: number;
+        recordsAfter: number;
+        bytesRemoved: number;
+        workspaceFilesChanged: false;
+        conversationsChanged: false;
+    };
+    /** Explicit operator review. Atomic scoped deletion never removes workspace files or sessions. */
+    applyRetention: (selection: z.infer<typeof retentionSelection>, reviewedPlanId: FileDigest) => Promise<{
+        planId: string;
+        selection: {
+            checkpointIds: string[];
+            completedRestoreIds: string[];
+        };
+        records: {
+            id: string;
+            kind: string;
+            sessionId: string;
+            bytes: number;
+        }[];
+        recordsBefore: number;
+        recordsAfter: number;
+        bytesRemoved: number;
+        workspaceFilesChanged: false;
+        conversationsChanged: false;
+    }>;
+    /** Scoped metadata only; file contents are disclosed only by explicit review. */
+    listCheckpoints: (sessionId: string) => {
+        id: string;
+        sessionId: string;
+        turnId: string;
+        files: {
+            path: string;
+            digest: string;
+            bytes: number;
+            mode: number;
+        }[];
+    }[];
+    listRestores: (sessionId: string) => {
+        id: string;
+        checkpointId: string;
+        proposalId: string;
+        stage: "applied" | "applying" | "completed" | "forked" | "forking" | "prepared";
+        forkSessionId?: string;
+    }[];
+    /** Read projection, not authorization. Digests must still be supplied to prepareRestore.
+     * Missing/protected/binary/oversized files are unavailable, never recreated. */
+    inspectCheckpoint: (id: string) => Promise<{
+        checkpoint: {
+            id: string;
+            sessionId: string;
+            turnId: string;
+            files: {
+                path: string;
+                digest: string;
+                bytes: number;
+                mode: number;
+            }[];
+        };
+        files: ({
+            path: string;
+            status: "mode-conflict";
+            before?: never;
+            after?: never;
+            expectedDigest?: never;
+            afterDigest?: never;
+            mode?: never;
+        } | {
+            path: string;
+            status: "available";
+            before: string;
+            after: string;
+            expectedDigest: string;
+            afterDigest: string;
+            mode: number;
+        } | {
+            before?: never;
+            after?: never;
+            expectedDigest?: never;
+            afterDigest?: never;
+            mode?: never;
+            path: string;
+            status: "unavailable";
+        })[];
+        coverage: {
+            existingTextOnly: true;
+            maxFiles: number;
+            maxFileBytes: number;
+            creation: false;
+            deletion: false;
+            binary: false;
+            modeRollback: false;
+            fullWorkspaceSnapshot: false;
+        };
+    }>;
+    /** Exact prepared diff. Reading it never forks a conversation or writes files. */
+    previewRestore: (id: string) => Promise<{
+        proposalId: string;
+        files: {
+            path: string;
+            expectedDigest: FileDigest | null;
+            before: string | null;
+            after: string;
+            afterDigest: FileDigest;
+        }[];
+    }>;
     capture: (input: {
         sessionId: string;
         turnId: string;
@@ -147,3 +284,4 @@ export declare const openWorkspaceCheckpointStore: (workspace: Workspace, sessio
         forkSessionId?: string | undefined;
     }>;
 }>;
+export {};

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

@@ -0,0 +1,5 @@
+import { type LanguageModel, type StreamEvent } from "@zhivex-ai/core";
+/** SDK 0.12.4 exposes thinking/signature deltas as provider-data. Reassemble the
+ * signed block before it enters durable history; never replay raw delta objects. */
+export declare function assembleAnthropicContinuation(events: AsyncIterable<StreamEvent>): AsyncIterable<StreamEvent>;
+export declare const withAnthropicContinuation: (model: LanguageModel) => LanguageModel;

package/dist/providers/providers.d.ts

@@ -1,6 +1,6 @@
 import type { LanguageModel } from "@zhivex-ai/agents";
 import { type ModelGenerateInput, type ToolCall } from "@zhivex-ai/core";
-export declare const PROVIDERS: readonly ["meta", "qwen", "openai", "gemini"];
+export declare const PROVIDERS: readonly ["meta", "qwen", "openai", "gemini", "anthropic", "vertex"];
 export type BuiltInHarnessProvider = (typeof PROVIDERS)[number];
 export type HarnessProvider = BuiltInHarnessProvider | (string & {});
 export type ProviderCapability = "streaming" | "tool-calling" | "approval-resume";

package/dist/providers/vertex-auth.d.ts

@@ -0,0 +1,27 @@
+export interface VertexRoute {
+    readonly projectId: string;
+    readonly location: string;
+}
+/** Reject malformed resource segments without including customer identifiers in errors. */
+export declare function vertexRoute(env: NodeJS.ProcessEnv): VertexRoute;
+/** Configuration presence only; does not assert ADC validity or contact Google. */
+export declare function vertexConfigured(env: NodeJS.ProcessEnv): boolean;
+export declare const VERTEX_ENVIRONMENT: readonly ["GOOGLE_CLOUD_PROJECT", "VERTEX_LOCATION", "GOOGLE_APPLICATION_CREDENTIALS"];
+export declare function vertexEnvironment(env: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
+interface TokenSource {
+    getAccessToken(): Promise<string | null | undefined>;
+}
+type AuthFactory = (options: {
+    projectId: string;
+    scopes: string[];
+    keyFilename?: string;
+}) => TokenSource;
+/** ADC owns token caching/refresh. Never cache a bearer token in Harness configuration. */
+export declare function vertexTokenSource(env: NodeJS.ProcessEnv, route: VertexRoute, createAuth?: AuthFactory): () => Promise<string>;
+export declare class VertexAuthenticationError extends Error {
+    readonly status = 401;
+    readonly retryable = false;
+    constructor();
+}
+export declare function createVertexModel(model: string, env: NodeJS.ProcessEnv, createAuth?: AuthFactory): import("@zhivex-ai/core").LanguageModel<import("@zhivex-ai/vertex").VertexLanguageModelOptions>;
+export {};

package/dist/runtime/delegation-contracts.d.ts

@@ -1,4 +1,5 @@
 import { type LanguageModel } from "@zhivex-ai/core";
+import { type DelegationResultContract } from "./delegation-result.js";
 /** Trusted application input, never constructed from a model tool call. */
 export interface HarnessDelegationContract {
     taskId: string;
@@ -6,6 +7,8 @@ export interface HarnessDelegationContract {
     prompt: string;
     allowedReadPaths: readonly string[];
     requiredOutput: string;
+    /** Opt-in experimental result evidence; legacy marker contracts remain unchanged. */
+    resultContract?: DelegationResultContract;
 }
 export declare const normalizeDelegationContracts: (value?: readonly HarnessDelegationContract[]) => Readonly<{
     taskId: string;
@@ -13,6 +16,12 @@ export declare const normalizeDelegationContracts: (value?: readonly HarnessDele
     prompt: string;
     requiredOutput: string;
     allowedReadPaths: readonly string[];
+    resultContract?: Readonly<{
+        requiredReadPaths: readonly string[];
+        schemaVersion: 1;
+        humanReviewRequired: boolean;
+        maxCorrections: number;
+    }>;
 }>[];
 export declare const delegationPrompt: (contract: HarnessDelegationContract) => string;
 export declare const delegationFingerprint: (contracts: readonly HarnessDelegationContract[]) => string;

package/dist/runtime/delegation-correction.d.ts

@@ -0,0 +1,9 @@
+import { type LanguageModel, type ToolExecutionResult, type ToolSet } from '@zhivex-ai/core';
+import type { HarnessDelegationContract } from './delegation-contracts.js';
+export declare const DELEGATION_FEEDBACK_TOOL = "__harness_result_feedback";
+export declare const delegationCorrectionCount: (results: readonly ToolExecutionResult[]) => number;
+/** Internal no-effect continuation lets SDK steps, journals, budgets and cancellation govern every retry. */
+export declare function createDelegationCorrection(model: LanguageModel, contract: HarnessDelegationContract): {
+    model: LanguageModel;
+    tools: ToolSet;
+};