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

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;
+};

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

@@ -0,0 +1,73 @@
+import { z } from 'zod';
+import { type AgentRunState, type AgentRunStore, type AgentStoreScope, type ToolExecutionResult } from '@zhivex-ai/core';
+import type { HarnessDelegationContract } from './delegation-contracts.js';
+export declare const delegationResultContractSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    requiredReadPaths: z.ZodArray<z.ZodString>;
+    humanReviewRequired: z.ZodBoolean;
+    maxCorrections: z.ZodNumber;
+}, z.core.$strict>;
+export type DelegationResultContract = Readonly<Omit<z.infer<typeof delegationResultContractSchema>, 'requiredReadPaths'> & {
+    requiredReadPaths: readonly string[];
+}>;
+export declare const delegationResultSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    taskId: z.ZodString;
+    status: z.ZodEnum<{
+        completed: "completed";
+        incomplete: "incomplete";
+    }>;
+    inspectedFiles: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        digest: z.ZodString;
+        evidence: z.ZodArray<z.ZodObject<{
+            toolCallId: z.ZodString;
+            startLine: z.ZodNumber;
+            endLine: z.ZodNumber;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    findings: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        message: z.ZodString;
+        evidence: z.ZodArray<z.ZodObject<{
+            toolCallId: z.ZodString;
+            startLine: z.ZodNumber;
+            endLine: z.ZodNumber;
+            path: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type DelegationResult = z.infer<typeof delegationResultSchema>;
+export type DelegationAcceptanceReason = 'valid' | 'invalid_json' | 'invalid_schema' | 'task_mismatch' | 'incomplete' | 'duplicate_claim' | 'path_denied' | 'evidence_missing' | 'coverage_missing';
+export interface DelegationAcceptance {
+    schemaVersion: 1;
+    taskId: string;
+    accepted: boolean;
+    reason: DelegationAcceptanceReason;
+    semanticReview: 'pending' | 'not_requested';
+    result?: DelegationResult;
+}
+/** Receipts must come from the host's child state, never from the declared result. */
+export declare function validateDelegationResult(contract: HarnessDelegationContract, text: string, toolResults: readonly ToolExecutionResult[]): DelegationAcceptance;
+/** SDK outputText can concatenate narration from earlier tool steps; the final response owns the result. */
+export declare const delegationTerminalText: (state: Pick<AgentRunState, 'steps' | 'outputText'>) => string;
+/** Parent independently checks durable child evidence rather than trusting the child's prose. */
+export declare function inspectDelegatedResults(state: AgentRunState, contracts: readonly HarnessDelegationContract[], store: AgentRunStore, defaultScope?: AgentStoreScope): Promise<({
+    taskId: string;
+    childRunId: null;
+    childStatus: string;
+    accepted: boolean;
+    reason: string;
+    semanticReview: string;
+    correctionsUsed?: never;
+} | {
+    taskId: string;
+    childRunId: string;
+    childStatus: string;
+    accepted: boolean;
+    correctionsUsed: number;
+    reason: string;
+    semanticReview: "not_requested" | "pending";
+})[]>;
+/** Persist host-computed observations even when output guardrails receive SDK copies. */
+export declare function delegationAcceptanceStore(store: AgentRunStore, contracts: readonly HarnessDelegationContract[], scope: AgentStoreScope): AgentRunStore;

package/dist/runtime/error-diagnostics.d.ts

@@ -99,6 +99,7 @@ export declare const benchmarkSpanSchema: z.ZodObject<{
             context_length_exceeded: "context_length_exceeded";
             invalid_request: "invalid_request";
             model_unavailable: "model_unavailable";
+            payment_required: "payment_required";
             permission: "permission";
             previous_response_unavailable: "previous_response_unavailable";
             rate_limit: "rate_limit";
@@ -177,6 +178,7 @@ export declare const benchmarkProgressSchema: z.ZodObject<{
                 context_length_exceeded: "context_length_exceeded";
                 invalid_request: "invalid_request";
                 model_unavailable: "model_unavailable";
+                payment_required: "payment_required";
                 permission: "permission";
                 previous_response_unavailable: "previous_response_unavailable";
                 rate_limit: "rate_limit";
@@ -275,6 +277,7 @@ export declare const benchmarkProgressSchema: z.ZodObject<{
                 context_length_exceeded: "context_length_exceeded";
                 invalid_request: "invalid_request";
                 model_unavailable: "model_unavailable";
+                payment_required: "payment_required";
                 permission: "permission";
                 previous_response_unavailable: "previous_response_unavailable";
                 rate_limit: "rate_limit";
@@ -454,6 +457,7 @@ export declare const errorDetailsSchema: z.ZodObject<{
                     context_length_exceeded: "context_length_exceeded";
                     invalid_request: "invalid_request";
                     model_unavailable: "model_unavailable";
+                    payment_required: "payment_required";
                     permission: "permission";
                     previous_response_unavailable: "previous_response_unavailable";
                     rate_limit: "rate_limit";
@@ -552,6 +556,7 @@ export declare const errorDetailsSchema: z.ZodObject<{
                     context_length_exceeded: "context_length_exceeded";
                     invalid_request: "invalid_request";
                     model_unavailable: "model_unavailable";
+                    payment_required: "payment_required";
                     permission: "permission";
                     previous_response_unavailable: "previous_response_unavailable";
                     rate_limit: "rate_limit";
@@ -667,6 +672,7 @@ export declare const errorDetailsSchema: z.ZodObject<{
             ZodError: "ZodError";
         }>>;
         checkpoint: z.ZodOptional<z.ZodEnum<{
+            continuity_phase: "continuity_phase";
             execution_approval_sequence: "execution_approval_sequence";
             execution_approval_tool: "execution_approval_tool";
             execution_command_arguments: "execution_command_arguments";
@@ -689,6 +695,8 @@ export declare const errorDetailsSchema: z.ZodObject<{
             request_persistence: "request_persistence";
             request_status: "request_status";
             resume_arguments: "resume_arguments";
+            resume_compaction: "resume_compaction";
+            resume_continuation: "resume_continuation";
             resume_effect: "resume_effect";
             resume_file_content: "resume_file_content";
             resume_file_read: "resume_file_read";
@@ -730,6 +738,7 @@ export declare const errorDetailsSchema: z.ZodObject<{
                 context_length_exceeded: "context_length_exceeded";
                 invalid_request: "invalid_request";
                 model_unavailable: "model_unavailable";
+                payment_required: "payment_required";
                 permission: "permission";
                 previous_response_unavailable: "previous_response_unavailable";
                 rate_limit: "rate_limit";
@@ -771,6 +780,21 @@ export declare const errorDetailsSchema: z.ZodObject<{
             contract: "contract";
             path: "path";
         }>>;
+        liveRunState: z.ZodOptional<z.ZodObject<{
+            status: z.ZodEnum<{
+                cancelled: "cancelled";
+                completed: "completed";
+                failed: "failed";
+                running: "running";
+                waiting_approval: "waiting_approval";
+            }>;
+            steps: z.ZodNumber;
+            maxSteps: z.ZodNumber;
+            pendingApprovals: z.ZodNumber;
+            toolResults: z.ZodNumber;
+            toolErrors: z.ZodNumber;
+            compactions: z.ZodNumber;
+        }, z.core.$strict>>;
         editEffect: z.ZodOptional<z.ZodObject<{
             resultReceipts: z.ZodNumber;
             errorReceipts: z.ZodNumber;
@@ -787,6 +811,68 @@ export declare const errorDetailsSchema: z.ZodObject<{
             shape: "shape";
             unknown_fields: "unknown_fields";
         }>>>;
+        executionArguments: z.ZodOptional<z.ZodObject<{
+            rootType: z.ZodEnum<{
+                array: "array";
+                boolean: "boolean";
+                null: "null";
+                number: "number";
+                object: "object";
+                string: "string";
+                undefined: "undefined";
+            }>;
+            commandPresent: z.ZodBoolean;
+            commandType: z.ZodEnum<{
+                array: "array";
+                boolean: "boolean";
+                null: "null";
+                number: "number";
+                object: "object";
+                string: "string";
+                undefined: "undefined";
+            }>;
+            commandMatchesExpected: z.ZodBoolean;
+            argsPresent: z.ZodBoolean;
+            argsType: z.ZodEnum<{
+                array: "array";
+                boolean: "boolean";
+                null: "null";
+                number: "number";
+                object: "object";
+                string: "string";
+                undefined: "undefined";
+            }>;
+            expectedArgCount: z.ZodNumber;
+            actualArgCount: z.ZodOptional<z.ZodNumber>;
+            extraArgCount: z.ZodNumber;
+            extraFieldCount: z.ZodNumber;
+            argumentMismatches: z.ZodArray<z.ZodObject<{
+                index: z.ZodNumber;
+                actualType: z.ZodEnum<{
+                    array: "array";
+                    boolean: "boolean";
+                    null: "null";
+                    number: "number";
+                    object: "object";
+                    string: "string";
+                    undefined: "undefined";
+                }>;
+                matchesExpected: z.ZodBoolean;
+                nestedMemberCount: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        continuity: z.ZodOptional<z.ZodObject<{
+            phase: z.ZodNumber;
+            failedChecks: z.ZodArray<z.ZodEnum<{
+                codename: "codename";
+                compacted: "compacted";
+                compatibility: "compatibility";
+                completed: "completed";
+                noTools: "noTools";
+                objective: "objective";
+                rejectedApproach: "rejectedApproach";
+            }>>;
+        }, z.core.$strict>>;
         budget: z.ZodOptional<z.ZodObject<{
             budgetLimit: z.ZodEnum<{
                 maxInputTokens: "maxInputTokens";