@zhivex-ai/harness 1.4.0 → 1.5.0

package/dist/cli.js

@@ -1,13 +1,38 @@
 #!/usr/bin/env node
 import {
   HARNESS_VERSION,
+  NODE_ENGINE_RANGE,
   shortCliHelp
-} from "./cli-entry-w0hterjs.js";
+} from "./cli-entry-q8bgkn9m.js";
 import {
   __require
 } from "./cli-entry-1bx83sw4.js";
 
+// src/cli/node-engine.ts
+var nodeEngineError = (version, range) => {
+  const minimumMatch = /^>=(\d+)\.(\d+)\.(\d+)$/.exec(range.trim());
+  const actualMatch = /^(\d+)\.(\d+)\.(\d+)/.exec(version.trim());
+  const failure = `Node.js ${version} does not satisfy the package engine requirement (${range}).
+`;
+  if (!minimumMatch || !actualMatch)
+    return failure;
+  for (let index = 1;index <= 3; index += 1) {
+    const actual = Number(actualMatch[index]);
+    const minimum = Number(minimumMatch[index]);
+    if (actual !== minimum)
+      return actual > minimum ? undefined : failure;
+  }
+  return;
+};
+
 // src/cli-entry.ts
+if (!process.versions.bun) {
+  const engineError = nodeEngineError(process.versions.node, NODE_ENGINE_RANGE);
+  if (engineError) {
+    process.stderr.write(engineError);
+    process.exit(1);
+  }
+}
 var argv = process.argv.slice(2);
 if (argv.length === 1 && ["--version", "-v", "version"].includes(argv[0])) {
   process.stdout.write(`${HARNESS_VERSION}
@@ -16,6 +41,6 @@ if (argv.length === 1 && ["--version", "-v", "version"].includes(argv[0])) {
   process.stdout.write(`${shortCliHelp(HARNESS_VERSION)}
 `);
 } else {
-  const { runCli } = await import("./cli-2h37qyvg.js");
+  const { runCli } = await import("./cli-vyrytn3m.js");
   await runCli(argv);
 }

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

@@ -218,6 +218,8 @@ export declare const cliInitDocumentSchema: z.ZodObject<{
         schemaVersion: z.ZodNumber;
         provider: z.ZodEnum<{
             anthropic: "anthropic";
+            "azure-openai": "azure-openai";
+            bedrock: "bedrock";
             gemini: "gemini";
             meta: "meta";
             openai: "openai";
@@ -954,6 +956,8 @@ export declare const cliJsonDocumentSchema: z.ZodUnion<readonly [z.ZodObject<{
         schemaVersion: z.ZodNumber;
         provider: z.ZodEnum<{
             anthropic: "anthropic";
+            "azure-openai": "azure-openai";
+            bedrock: "bedrock";
             gemini: "gemini";
             meta: "meta";
             openai: "openai";

package/dist/client/protocol.d.ts

@@ -1,3 +1,4 @@
+import type { HarnessTaskProjection } from './task-projection.js';
 import type { HarnessErrorDocument, ProviderStreamDiagnostic } from "../runtime/errors.js";
 import type { HarnessPolicyDecisionEvent } from "../runtime/policy-decisions.js";
 import type { HarnessPolicyInspection } from "../runtime/policy-inspection.js";
@@ -89,6 +90,57 @@ export declare const harnessClientCommandSchema: z.ZodDiscriminatedUnion<[z.ZodO
     method: z.ZodLiteral<"run.start">;
     expectedRevision: z.ZodNumber;
     prompt: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    projectId: z.ZodString;
+    sessionId: z.ZodString;
+    idempotencyKey: z.ZodString;
+    method: z.ZodLiteral<"task.start">;
+    expectedRevision: z.ZodNumber;
+    brief: z.ZodObject<{
+        goal: z.ZodString;
+        paths: z.ZodArray<z.ZodString>;
+        checks: z.ZodArray<z.ZodString>;
+        constraints: z.ZodArray<z.ZodString>;
+        budget: z.ZodObject<{
+            inputTokens: z.ZodNumber;
+            outputTokens: z.ZodNumber;
+            totalTokens: z.ZodNumber;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    projectId: z.ZodString;
+    sessionId: z.ZodString;
+    runId: z.ZodString;
+    method: z.ZodLiteral<"task.review">;
+}, z.core.$strict>, z.ZodObject<{
+    projectId: z.ZodString;
+    sessionId: z.ZodString;
+    runId: z.ZodString;
+    idempotencyKey: z.ZodString;
+    method: z.ZodLiteral<"task.keep">;
+    reviewId: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    projectId: z.ZodString;
+    sessionId: z.ZodString;
+    runId: z.ZodString;
+    idempotencyKey: z.ZodString;
+    method: z.ZodLiteral<"task.revise">;
+    reviewId: z.ZodString;
+    correction: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    projectId: z.ZodString;
+    sessionId: z.ZodString;
+    runId: z.ZodString;
+    idempotencyKey: z.ZodString;
+    method: z.ZodLiteral<"task.continue">;
+    reviewId: z.ZodString;
+    prompt: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    projectId: z.ZodString;
+    sessionId: z.ZodString;
+    runId: z.ZodString;
+    method: z.ZodLiteral<"task.get">;
+    projectionVersion: z.ZodNumber;
 }, z.core.$strict>, z.ZodObject<{
     projectId: z.ZodString;
     sessionId: z.ZodString;
@@ -200,6 +252,57 @@ export declare const harnessClientRequestSchema: z.ZodObject<{
         method: z.ZodLiteral<"run.start">;
         expectedRevision: z.ZodNumber;
         prompt: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        projectId: z.ZodString;
+        sessionId: z.ZodString;
+        idempotencyKey: z.ZodString;
+        method: z.ZodLiteral<"task.start">;
+        expectedRevision: z.ZodNumber;
+        brief: z.ZodObject<{
+            goal: z.ZodString;
+            paths: z.ZodArray<z.ZodString>;
+            checks: z.ZodArray<z.ZodString>;
+            constraints: z.ZodArray<z.ZodString>;
+            budget: z.ZodObject<{
+                inputTokens: z.ZodNumber;
+                outputTokens: z.ZodNumber;
+                totalTokens: z.ZodNumber;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        projectId: z.ZodString;
+        sessionId: z.ZodString;
+        runId: z.ZodString;
+        method: z.ZodLiteral<"task.review">;
+    }, z.core.$strict>, z.ZodObject<{
+        projectId: z.ZodString;
+        sessionId: z.ZodString;
+        runId: z.ZodString;
+        idempotencyKey: z.ZodString;
+        method: z.ZodLiteral<"task.keep">;
+        reviewId: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        projectId: z.ZodString;
+        sessionId: z.ZodString;
+        runId: z.ZodString;
+        idempotencyKey: z.ZodString;
+        method: z.ZodLiteral<"task.revise">;
+        reviewId: z.ZodString;
+        correction: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        projectId: z.ZodString;
+        sessionId: z.ZodString;
+        runId: z.ZodString;
+        idempotencyKey: z.ZodString;
+        method: z.ZodLiteral<"task.continue">;
+        reviewId: z.ZodString;
+        prompt: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        projectId: z.ZodString;
+        sessionId: z.ZodString;
+        runId: z.ZodString;
+        method: z.ZodLiteral<"task.get">;
+        projectionVersion: z.ZodNumber;
     }, z.core.$strict>, z.ZodObject<{
         projectId: z.ZodString;
         sessionId: z.ZodString;
@@ -254,7 +357,30 @@ export interface HarnessClientRun {
         filePreview?: ApprovalFilePreview;
     }[];
 }
+export interface HarnessTaskHumanDecision {
+    status: 'not_recorded' | 'current' | 'stale';
+    at: number | null;
+    provenance: 'explicit_operator_review' | null;
+}
+export interface HarnessTaskReview {
+    reviewId: string;
+    expiresAt: number;
+    projection: HarnessTaskProjection;
+    diff: string;
+    complete: boolean;
+    canKeep: boolean;
+    canContinue: boolean;
+    canRevise: boolean;
+    humanDecision: HarnessTaskHumanDecision;
+}
 export type HarnessClientData = {
+    kind: "task";
+    projection: HarnessTaskProjection;
+    humanDecision?: HarnessTaskHumanDecision;
+} | {
+    kind: "taskReview";
+    review: HarnessTaskReview;
+} | {
     kind: "project";
     projectId: string;
 } | {
@@ -299,6 +425,11 @@ export type HarnessClientResponse = {
     error: {
         code: HarnessClientErrorCode;
         providerDiagnostic?: ProviderStreamDiagnostic;
+        taskDiagnostic?: {
+            cause: "UNSUPPORTED_VERSION" | "UNSUPPORTED_HOST" | "OUT_OF_SCOPE" | "CONTRACT_UNAVAILABLE" | "EVIDENCE_UNAVAILABLE" | "SNAPSHOT_CHANGED" | "PAYLOAD_LIMIT";
+            impact: "projection_unavailable";
+            safeAction: "retry_read" | "review_configuration" | "reconcile";
+        };
     };
 });
 export type HarnessClientNegotiation = {
@@ -314,6 +445,8 @@ export type HarnessClientNegotiation = {
     };
 };
 export interface HarnessClientAdapterOptions {
+    /** Host-owned secrets for the bounded task projection. Never supplied by commands. */
+    taskProjectionSensitiveValues?: readonly string[];
     approvalMaxAgeMs?: number;
     now?: () => number;
     onPolicyDecision?: (sessionId: string, runId: string, event: HarnessPolicyDecisionEvent) => void | Promise<void>;

package/dist/client/task-control-host.d.ts

@@ -0,0 +1,400 @@
+import type { ZhivexHarness } from '../runtime/harness.js';
+import { compileTaskAcceptanceContract } from '../runtime/task-acceptance.js';
+import type { HarnessTaskProjection } from './task-projection.js';
+import type { AgentRunState } from '@zhivex-ai/core';
+export declare const TASK_HUMAN_DECISION_KEY = "harnessClientHumanDecisionV1";
+export interface TaskBrief {
+    goal: string;
+    paths: string[];
+    checks: string[];
+    constraints: string[];
+    budget: {
+        inputTokens: number;
+        outputTokens: number;
+        totalTokens: number;
+    };
+}
+export declare const taskReviewIdentity: (p: HarnessTaskProjection) => string;
+export declare function taskHumanDecision(host: ZhivexHarness, p: HarnessTaskProjection): Promise<{
+    status: 'not_recorded';
+    at: null;
+    provenance: null;
+} | {
+    status: "current" | "stale";
+    at: number;
+    provenance: 'explicit_operator_review';
+}>;
+export declare function visibleTaskFiles(host: ZhivexHarness, paths: readonly string[]): Promise<void>;
+export declare function taskGitReview(host: ZhivexHarness): Promise<{
+    text: string;
+    identity: string;
+}>;
+/** Browser supplies a bounded operator brief, never a contract, receipt or execution grant. */
+export declare function prepareClientTask(host: ZhivexHarness, brief: TaskBrief): Promise<{
+    schemaVersion: 1;
+    budgetVersion: 1;
+    goal: string;
+    constraints: string[];
+    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";
+        }[];
+    };
+    baseline: Record<string, string>;
+}>;
+export declare function currentClientTask(host: ZhivexHarness, runId: string, allowedRunIds: readonly string[]): Promise<{
+    state: AgentRunState;
+    ledger: {
+        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";
+                }[];
+            };
+        }[];
+    };
+    evidence: {
+        report: {
+            schemaVersion: 1;
+            taskId: string;
+            budget: {
+                schemaVersion: 1;
+                taskId: string;
+                accountRunId: string;
+                revision: number;
+                limits: {
+                    inputTokens: number;
+                    outputTokens: number;
+                    totalTokens: number;
+                };
+                confirmed: {
+                    inputTokens: number;
+                    outputTokens: number;
+                    totalTokens: number;
+                };
+                reserved: {
+                    inputTokens: number;
+                    outputTokens: number;
+                    totalTokens: number;
+                };
+                unknown: {
+                    inputTokens: number;
+                    outputTokens: number;
+                    totalTokens: number;
+                };
+                remaining: {
+                    inputTokens: number;
+                    outputTokens: number;
+                    totalTokens: number;
+                };
+                usageComplete: boolean;
+                admissionsClosed: boolean;
+                invocationPending: boolean;
+                activeRunId: string | null;
+                runs: string[];
+                coordinatorId: string;
+                cancellations: {
+                    runId: string;
+                    requestedAt: number;
+                    origin: "abort" | "lease_lost" | "operator" | "timeout";
+                    localToolsDrainedAt?: number | undefined;
+                    localExecution: "native_tools_drained" | "unconfirmed";
+                    remoteExecution: 'unconfirmed';
+                }[];
+                monetary: {
+                    schemaVersion: number;
+                    runId: string;
+                    calls: number;
+                    routes: {
+                        provider: string;
+                        model: string;
+                        calls: number;
+                        inputTokens: number;
+                        outputTokens: number;
+                        unknownCalls: number;
+                        estimatedUsd: number | null;
+                        priceStatuses: string[];
+                    }[];
+                    inputTokens: number;
+                    outputTokens: number;
+                    historicalUsageUnknown: boolean;
+                    usageComplete: boolean;
+                    estimatedUsd: number | null;
+                    limitUsd: number | null;
+                    costKind: "estimate-not-invoice";
+                };
+                monetaryDetails: {
+                    schemaVersion: 1;
+                    confirmedCalls: number;
+                    reservedCalls: number;
+                    unknownCalls: number;
+                    lateCalls: number;
+                    estimatedConfirmedUsd: number | null;
+                    reservedUsd: number | null;
+                    unknownHeldUsd: number | null;
+                    remainingUsd: number | null;
+                    costComplete: boolean;
+                    categories: string[];
+                    costKind: "estimate-not-invoice";
+                };
+            } | null;
+            runs: {
+                runId: string;
+                revision: number | undefined;
+                status: import("@zhivex-ai/core").AgentStatus;
+                ledger: {
+                    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";
+                            }[];
+                        };
+                    }[];
+                };
+                sources: {
+                    id: string;
+                    text: string;
+                    original?: true;
+                }[];
+                decisions: import("../approvals/approval-history.js").ApprovalDecisionView[];
+                decisionsAvailability: string;
+                briefStatus: string;
+                objective: string | null;
+                constraints: string[];
+                hostPolicyCompatible: boolean;
+                assistantResponses: {
+                    id: string;
+                    text: string;
+                    truncated: boolean;
+                    untrusted: boolean;
+                    verified: boolean;
+                }[];
+                effects: {
+                    id: string;
+                    tool: string;
+                    revision: number;
+                    status: string;
+                    retry: string;
+                }[];
+                checks: {
+                    id: string;
+                    status: string;
+                }[];
+                snapshot: import("../runtime/task-acceptance-checks.js").TaskCheckBinding | null;
+                delivery: {} | null;
+                humanReview: {
+                    id: string;
+                    requirement: string;
+                    status: "pending";
+                }[];
+                fingerprint: import("@zhivex-ai/core").AgentHarnessBinding | null;
+            }[];
+            currentContract: {
+                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";
+                    }[];
+                };
+            } | null;
+            reasons: string[];
+            nextAction: string;
+            authorization: 'none';
+            automaticEffectReplay: false;
+        };
+        verify: () => Promise<void>;
+        verifyAll: () => Promise<void>;
+    };
+    current: {
+        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";
+            }[];
+        };
+    };
+    taskId: string;
+}>;
+/** Record a host preparation failure before any model invocation, retaining the original account.
+ * If authority cannot be acquired, the caller must leave the durable draft blocked, never downgrade to chat. */
+export declare function persistClientTaskPreparationFailure(host: ZhivexHarness, state: AgentRunState, contract: ReturnType<typeof compileTaskAcceptanceContract>['contract']): Promise<void>;
+/** Account exclusion is the same exclusion used for task admission; run CAS alone is insufficient. */
+export declare function keepClientTask(host: ZhivexHarness, runId: string, allowedRunIds: readonly string[], expected: {
+    runRevision: number;
+    contractDigest: string;
+    snapshotDigest: string;
+    budgetRevision: number;
+    gitIdentity: string;
+}): Promise<{
+    schemaVersion: number;
+    kind: string;
+    runId: string;
+    contractDigest: string;
+    contractRevision: number;
+    snapshotDigest: string;
+    reviewedRunRevision: number;
+    at: number;
+    provenance: string;
+}>;

package/dist/client/task-projection-host.d.ts

@@ -0,0 +1,12 @@
+import type { ZhivexHarness } from '../runtime/harness.js';
+import { type HarnessTaskProjection, type HarnessTaskProjectionScope } from './task-projection.js';
+export type TaskProjectionCause = 'UNSUPPORTED_VERSION' | 'UNSUPPORTED_HOST' | 'OUT_OF_SCOPE' | 'CONTRACT_UNAVAILABLE' | 'EVIDENCE_UNAVAILABLE' | 'SNAPSHOT_CHANGED' | 'PAYLOAD_LIMIT';
+export declare class TaskProjectionFault extends Error {
+    readonly causeCode: TaskProjectionCause;
+    constructor(causeCode: TaskProjectionCause);
+}
+export declare function redactTaskDisplayText(host: ZhivexHarness, raw: string, sensitiveValues?: readonly string[]): string;
+/** Derivation only: no session refresh, ledger creation, state save, checks or model calls. */
+export declare function projectHarnessTask(host: ZhivexHarness, request: HarnessTaskProjectionScope & {
+    sequence: number;
+}, allowedRunIds: readonly string[], sensitiveValues?: readonly string[]): Promise<HarnessTaskProjection>;