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

package/dist/runtime/task-acceptance-host.d.ts

@@ -0,0 +1,20 @@
+import type { AgentRunInput, LanguageModel, ToolSet } from '@zhivex-ai/core';
+import type { ZhivexHarness } from './harness.js';
+import type { HarnessConfig } from './config.js';
+import type { HarnessToolPolicy } from './tool-policy.js';
+import type { TaskAcceptanceContract } from './task-acceptance.js';
+import { type TaskAcceptanceLedger } from './task-acceptance-record.js';
+export declare function bindTaskAcceptanceHost(host: object, context: {
+    config: HarnessConfig;
+    tools: ToolSet;
+    policy?: HarnessToolPolicy;
+}): void;
+export declare function inspectHarnessTaskAcceptance(host: ZhivexHarness, runId: string): Promise<TaskAcceptanceLedger | undefined>;
+/** Application API: revising requirements never grants approval or claims that checks passed. */
+export declare function reviseHarnessTaskAcceptance(host: ZhivexHarness, request: {
+    runId: string;
+    expectedRunRevision: number;
+    expectedContractRevision: number;
+    contract: TaskAcceptanceContract;
+}): Promise<TaskAcceptanceLedger>;
+export declare function withTaskAcceptanceRun<T>(host: ZhivexHarness, input: AgentRunInput<LanguageModel>, requirements: TaskAcceptanceContract | undefined, work: (input: AgentRunInput<LanguageModel>, ledger?: TaskAcceptanceLedger) => Promise<T>): Promise<T>;

package/dist/runtime/task-acceptance-record.d.ts

@@ -0,0 +1,107 @@
+import { z } from 'zod';
+import { type AgentRunState, type AgentRunStore, type AgentStoreScope } from '@zhivex-ai/core';
+export declare const TASK_ACCEPTANCE_KEY = "zhivexTaskAcceptanceV1";
+export declare const TASK_ACCEPTANCE_EVIDENCE_KEY = "zhivexTaskAcceptanceEvidenceV1";
+declare const ledgerSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    revisions: z.ZodArray<z.ZodObject<{
+        revision: z.ZodNumber;
+        digest: z.ZodString;
+        previousDigest: z.ZodNullable<z.ZodString>;
+        contract: z.ZodObject<{
+            schemaVersion: z.ZodLiteral<1>;
+            taskId: z.ZodString;
+            allowedWritePaths: z.ZodArray<z.ZodString>;
+            protectedFiles: z.ZodArray<z.ZodString>;
+            requiredChecks: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                id: z.ZodString;
+                command: z.ZodString;
+                args: z.ZodArray<z.ZodString>;
+                purpose: z.ZodString;
+                kind: z.ZodLiteral<"package-script">;
+                script: z.ZodString;
+                expectedScript: z.ZodString;
+                execution: z.ZodObject<{
+                    backend: z.ZodEnum<{
+                        none: "none";
+                        oci: "oci";
+                    }>;
+                    approval: z.ZodLiteral<"required">;
+                }, z.core.$strict>;
+            }, z.core.$strict>, z.ZodObject<{
+                id: z.ZodString;
+                command: z.ZodString;
+                args: z.ZodArray<z.ZodString>;
+                purpose: z.ZodString;
+                kind: z.ZodLiteral<"argv">;
+                execution: z.ZodObject<{
+                    backend: z.ZodLiteral<"oci">;
+                    approval: z.ZodLiteral<"required">;
+                    network: z.ZodLiteral<"none">;
+                }, z.core.$strict>;
+            }, z.core.$strict>], "kind">>;
+            humanReview: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                requirement: z.ZodString;
+                status: z.ZodLiteral<"pending">;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type TaskAcceptanceLedger = z.infer<typeof ledgerSchema>;
+export declare function readTaskAcceptanceLedger(state: Pick<AgentRunState, 'metadata'>): TaskAcceptanceLedger | undefined;
+/** Internal host-only transition. The caller must preflight the new requirements. */
+export declare function nextTaskAcceptanceLedger(current: TaskAcceptanceLedger | undefined, requirements: unknown): TaskAcceptanceLedger;
+/** CAS on the authoritative run; stale operator views never overwrite another revision. */
+export declare function persistTaskAcceptanceRevision(store: AgentRunStore, options: {
+    runId: string;
+    scope?: AgentStoreScope;
+    expectedRunRevision: number;
+    expectedContractRevision: number;
+    requirements: unknown;
+}): Promise<{
+    schemaVersion: 1;
+    revisions: {
+        revision: number;
+        digest: string;
+        previousDigest: string | null;
+        contract: {
+            schemaVersion: 1;
+            taskId: string;
+            allowedWritePaths: string[];
+            protectedFiles: string[];
+            requiredChecks: ({
+                id: string;
+                command: string;
+                args: string[];
+                purpose: string;
+                kind: "package-script";
+                script: string;
+                expectedScript: string;
+                execution: {
+                    backend: "none" | "oci";
+                    approval: "required";
+                };
+            } | {
+                id: string;
+                command: string;
+                args: string[];
+                purpose: string;
+                kind: "argv";
+                execution: {
+                    backend: "oci";
+                    approval: "required";
+                    network: "none";
+                };
+            })[];
+            humanReview: {
+                id: string;
+                requirement: string;
+                status: "pending";
+            }[];
+        };
+    }[];
+}>;
+/** Preserve host requirements through SDK checkpoints/compaction, independently of mutable model context. */
+export declare function taskAcceptanceCheckpointStore(store: AgentRunStore, runId: string, ledger: TaskAcceptanceLedger): AgentRunStore;
+export {};

package/dist/runtime/task-acceptance-validation.d.ts

@@ -0,0 +1,25 @@
+import type { ToolSet } from '@zhivex-ai/core';
+import type { HarnessConfig } from './config.js';
+import { type HarnessToolPolicy } from './tool-policy.js';
+/** Admission-time inspection only; execution must still revalidate changing files. */
+export declare function validateTaskAcceptanceWorkspace(input: unknown, host: {
+    config: HarnessConfig;
+    tools: ToolSet;
+    policy?: HarnessToolPolicy;
+}): Promise<{
+    digest: string;
+    contract: import("./task-acceptance.js").TaskAcceptanceContract;
+}>;
+/** Read-only host preflight. Manifest must come from the host's bounded safe reader. */
+export declare function validateTaskAcceptanceContract(input: unknown, host: {
+    config: HarnessConfig;
+    tools: ToolSet;
+    packageManifest?: {
+        packageManager?: unknown;
+        scripts?: unknown;
+    };
+    policy?: HarnessToolPolicy;
+}): Promise<{
+    digest: string;
+    contract: import("./task-acceptance.js").TaskAcceptanceContract;
+}>;

package/dist/runtime/task-acceptance.d.ts

@@ -0,0 +1,47 @@
+import { z } from 'zod';
+/** Host-authored requirements. This contract contains no successful-check or approval claims. */
+export declare const taskAcceptanceContractSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    taskId: z.ZodString;
+    allowedWritePaths: z.ZodArray<z.ZodString>;
+    protectedFiles: z.ZodArray<z.ZodString>;
+    requiredChecks: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        id: z.ZodString;
+        command: z.ZodString;
+        args: z.ZodArray<z.ZodString>;
+        purpose: z.ZodString;
+        kind: z.ZodLiteral<"package-script">;
+        script: z.ZodString;
+        expectedScript: z.ZodString;
+        execution: z.ZodObject<{
+            backend: z.ZodEnum<{
+                none: "none";
+                oci: "oci";
+            }>;
+            approval: z.ZodLiteral<"required">;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        id: z.ZodString;
+        command: z.ZodString;
+        args: z.ZodArray<z.ZodString>;
+        purpose: z.ZodString;
+        kind: z.ZodLiteral<"argv">;
+        execution: z.ZodObject<{
+            backend: z.ZodLiteral<"oci">;
+            approval: z.ZodLiteral<"required">;
+            network: z.ZodLiteral<"none">;
+        }, z.core.$strict>;
+    }, z.core.$strict>], "kind">>;
+    humanReview: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        requirement: z.ZodString;
+        status: z.ZodLiteral<"pending">;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type TaskAcceptanceContract = z.infer<typeof taskAcceptanceContractSchema>;
+export declare const MAX_TASK_ACCEPTANCE_BYTES: number;
+/** Canonical requirements identity; array ordering of sets is irrelevant, argv ordering is significant. */
+export declare function compileTaskAcceptanceContract(input: unknown): {
+    digest: string;
+    contract: TaskAcceptanceContract;
+};

package/dist/runtime/time-to-safe-fix.d.ts

@@ -163,6 +163,7 @@ export declare const timeToSafeFixDriverResultSchema: 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";
@@ -261,6 +262,7 @@ export declare const timeToSafeFixDriverResultSchema: 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";
@@ -376,6 +378,7 @@ export declare const timeToSafeFixDriverResultSchema: 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";
@@ -398,6 +401,8 @@ export declare const timeToSafeFixDriverResultSchema: 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";
@@ -439,6 +444,7 @@ export declare const timeToSafeFixDriverResultSchema: 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";
@@ -480,6 +486,21 @@ export declare const timeToSafeFixDriverResultSchema: 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;
@@ -496,6 +517,68 @@ export declare const timeToSafeFixDriverResultSchema: 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";

package/dist/runtime/tool-policy-file.d.ts

@@ -0,0 +1,23 @@
+/** Explicit host input only. Never discover this file from repository instructions. */
+export declare const loadHarnessToolPolicyFile: (filename: string, workspaceRoot: string) => Promise<{
+    digest: string;
+    evaluate: (request: {
+        toolName: string;
+        paths?: readonly string[];
+        requiresApproval?: boolean;
+        hardDenied?: boolean;
+    }) => import("./tool-policy.js").HarnessToolPolicyDecision;
+    policy: {
+        schemaVersion: number;
+        explicitReview?: {
+            schemaVersion: 1;
+        };
+        rules: {
+            id: string;
+            paths?: string[] | undefined;
+            decision: "allow" | "ask_user" | "deny";
+            reason: string;
+            tools: string[];
+        }[];
+    };
+}>;

package/dist/runtime/tool-policy-paths.d.ts

@@ -0,0 +1,5 @@
+import type { HarnessToolPolicy } from './tool-policy.js';
+export declare const BUILTIN_TOOL_POLICY_PATHS_VERSION = "builtin-exact-files-v1";
+export declare const validateBuiltinToolPolicy: (policy: HarnessToolPolicy, tools: readonly string[]) => void;
+/** Only invoked for tools with a path-scoped rule; irrelevant inputs stay opaque. */
+export declare const builtinToolPolicyPathResolver: (policy: HarnessToolPolicy) => (name: string, input: unknown) => readonly string[];

package/dist/runtime/tool-policy.d.ts

@@ -2,6 +2,9 @@ import type { ToolSet } from "@zhivex-ai/core";
 import { z } from "zod";
 export declare const harnessToolPolicySchema: z.ZodObject<{
     schemaVersion: z.ZodLiteral<1>;
+    explicitReview: z.ZodOptional<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+    }, z.core.$strict>>;
     rules: z.ZodArray<z.ZodObject<{
         id: z.ZodString;
         tools: z.ZodArray<z.ZodString>;
@@ -31,6 +34,9 @@ export declare const createHarnessToolPolicy: (input: HarnessToolPolicy) => {
     }) => HarnessToolPolicyDecision;
     policy: {
         schemaVersion: number;
+        explicitReview?: {
+            schemaVersion: 1;
+        };
         rules: {
             id: string;
             paths?: string[] | undefined;

package/dist/service-cli.js

@@ -2,13 +2,20 @@
 import {
   recoverHarnessLocalService,
   startHarnessLocalService
-} from "./index-kfgt9yqq.js";
+} from "./index-w2sj0wkw.js";
 import {
   createHarness
-} from "./index-5wjwe91x.js";
-import"./index-pgqz45fj.js";
-import"./index-fvca1xea.js";
-import"./index-2aymdsqc.js";
+} from "./index-hnaxfpb5.js";
+import"./index-h0mqx2ed.js";
+import"./index-8zzhggxv.js";
+import"./index-42gp2hy8.js";
+import"./index-azmwjp95.js";
+import"./index-z0qxmkm2.js";
+import"./index-yb239ghk.js";
+import"./index-gq9xagx2.js";
+import"./index-8705zxpr.js";
+import"./index-xqxeypt5.js";
+import"./index-qfpz5y2v.js";
 import"./index-1bx83sw4.js";
 
 // src/service-cli.ts
@@ -22,13 +29,13 @@ var main = async () => {
       recover = true;
       continue;
     }
-    if (!["--workspace", "--directory", "--provider", "--model"].includes(name) || !args[i + 1] || values[name] !== undefined)
+    if (!["--workspace", "--directory", "--provider", "--model", "--tool-policy"].includes(name) || !args[i + 1] || values[name] !== undefined)
       throw new Error("SERVICE_USAGE_INVALID");
     values[name] = args[++i];
   }
   if (!values["--workspace"] || !values["--directory"])
     throw new Error("SERVICE_USAGE_INVALID");
-  const harness = await createHarness({ workspace: values["--workspace"], ...values["--provider"] ? { provider: values["--provider"] } : {}, ...values["--model"] ? { model: values["--model"] } : {} });
+  const harness = await createHarness({ workspace: values["--workspace"], ...values["--tool-policy"] ? { toolPolicyFile: values["--tool-policy"] } : {}, ...values["--provider"] ? { provider: values["--provider"] } : {}, ...values["--model"] ? { model: values["--model"] } : {} });
   try {
     if (recover)
       await recoverHarnessLocalService(harness, values["--directory"]);