@zhivex-ai/harness 1.0.0 → 1.1.0-rc.2

package/dist/local-service.d.ts

@@ -0,0 +1,34 @@
+import { z } from "zod";
+import { type HarnessClientResponse, type HarnessClientNegotiation } from "./client-contract.js";
+import { type HarnessActivityPage } from "./service-events.js";
+import type { ZhivexHarness } from "./harness.js";
+export interface HarnessLocalService {
+    readonly socketPath: string;
+    readonly credentialsPath: string;
+    /** Atomically blocks new mutations, preserving reads and explicit cancellation. Returns whether mutations are still active. */
+    pauseAdmission(): boolean;
+    resumeAdmission(): void;
+    /** Requests cancellation of this host's active invocation; never force-finalizes it. */
+    cancelActive(): Promise<void>;
+    /** Stops admission, drains accepted commands, closes adapter and host runtime. */
+    close(): Promise<void>;
+}
+export interface HarnessLocalServiceOptions {
+    directory: string;
+    approvalNow?: () => number;
+    sensitiveValues?: readonly string[];
+    maxEvents?: number;
+    retentionMs?: number;
+}
+export declare const harnessLocalCredentialsSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    socketPath: z.ZodString;
+    token: z.ZodString;
+}, z.core.$strict>;
+export type HarnessLocalCredentials = z.infer<typeof harnessLocalCredentialsSchema>;
+export declare const startHarnessLocalService: (harness: ZhivexHarness, options: HarnessLocalServiceOptions) => Promise<HarnessLocalService>;
+/** Read only an owner-private regular credential file; never follow a symlink. */
+export declare const readHarnessLocalCredentials: (filename: string) => Promise<HarnessLocalCredentials>;
+export declare const requestHarnessLocalService: <E extends "hello" | "command" | "events">(credentials: HarnessLocalCredentials, endpoint: E, payload: unknown) => Promise<E extends "hello" ? HarnessClientNegotiation : E extends "command" ? HarnessClientResponse : HarnessActivityPage>;
+/** Explicit dead-owner recovery: preserves runtime DBs and never steals a live lease. */
+export declare const recoverHarnessLocalService: (harness: ZhivexHarness, directory: string) => Promise<void>;

package/dist/operations.d.ts

@@ -78,7 +78,7 @@ export declare const inspectHarnessRun: (store: AgentRunStore, config: HarnessCo
         cancelledAt: number | undefined;
         cancellationReason: string | undefined;
     };
-    budget: import("@zhivex-ai/agents").AgentBudgetStatus;
+    budget: import("@zhivex-ai/core").AgentBudgetStatus;
     snapshot: {
         runId: string;
         agentId?: string;
@@ -168,6 +168,28 @@ export declare const inspectHarnessRun: (store: AgentRunStore, config: HarnessCo
             purpose: string;
         }[];
     } | null;
+    usageLedger: {
+        calls: number;
+        inputTokens: number;
+        outputTokens: number;
+        usageComplete: boolean;
+        estimatedUsd: number | null;
+        limitUsd: number | null;
+        schemaVersion: 1;
+        runId: string;
+        historicalUsageUnknown?: boolean | undefined;
+        costKind: "estimate-not-invoice";
+        routes: {
+            provider: string;
+            model: string;
+            calls: number;
+            inputTokens: number;
+            outputTokens: number;
+            unknownCalls: number;
+            estimatedUsd: number | null;
+            priceStatuses: ("estimate" | "missing" | "stale")[];
+        }[];
+    } | null;
     effectiveRuntime: {
         schemaVersion: 1;
         policyVersion: "repair-v2-durable-closure";

package/dist/orchestration.d.ts

@@ -1,3 +1,4 @@
+import type { UsageLedger } from "./usage-ledger.js";
 import { runAgentGroup, type AgentDefinition, type AgentHarnessBinding, type AgentRunInput, type AgentSubAgentDefinition, type LanguageModel, type ToolSet } from "@zhivex-ai/agents";
 import type { AgentMemoryStore, AgentRunStore, AgentTelemetryObserver } from "@zhivex-ai/agents/ops";
 import type { HarnessConfig, HarnessSubagentProfile } from "./config.js";
@@ -26,6 +27,7 @@ export declare const createHarnessSubagents: (options: {
     executionEnvironment?: AgentDefinition<LanguageModel>["executionEnvironment"];
 }) => HarnessSubagentRuntime;
 export interface HarnessReviewGroupResult {
+    usageLedger?: ReturnType<UsageLedger["summary"]>;
     schemaVersion: 1;
     kind: "review-group";
     groupId: string;
@@ -36,6 +38,7 @@ export interface HarnessReviewGroupResult {
 export declare const runHarnessReviewGroup: (runtime: {
     config: HarnessConfig;
     subagents: ReadonlyMap<HarnessSubagentProfile, AgentDefinition<LanguageModel>>;
+    usageLedger?: UsageLedger;
 }, input: {
     prompt: string;
     scope?: AgentRunInput<LanguageModel>["scope"];

package/dist/persistence-secrets.d.ts

@@ -0,0 +1,2 @@
+export declare function protectPersistenceSecret(secret: string): void;
+export declare function assertNoPersistenceSecret(value: unknown): void;

package/dist/recorded-workspace.d.ts

@@ -0,0 +1,4 @@
+/** Validate an already-recorded canonical identity without creating its checkout.
+ * Missing paths are allowed only for archive/restore callers holding that identity.
+ */
+export declare function validateRecordedWorkspace(workspace: string, allowAbsent?: boolean): Promise<string>;

package/dist/run-document.d.ts

@@ -0,0 +1,91 @@
+import { type AgentRunOutput } from "@zhivex-ai/agents";
+import type { ZhivexHarness } from "./harness.js";
+export declare const runResultDocument: (result: AgentRunOutput, harness: ZhivexHarness) => {
+    schemaVersion: 1;
+    kind: "run-result";
+    runId: string;
+    status: import("@zhivex-ai/core").AgentStatus;
+    provider: string;
+    model: string;
+    output: string;
+    steps: number;
+    toolCalls: number;
+    mutations: readonly {
+        id: string;
+        operation: "create" | "move" | "quarantine" | "restore" | "update";
+        path: string;
+        destination?: string | undefined;
+        beforeDigest?: string | undefined;
+        afterDigest?: string | undefined;
+        timestamp: string;
+        quarantineId?: string | undefined;
+    }[];
+    pendingApprovals: {
+        id: string;
+        kind: "local-tool" | "provider" | "subagent";
+        name: string;
+        arguments: string;
+        childRunId?: string;
+        childAgentId?: string;
+    }[];
+    children: {
+        runId: string;
+        agentId: string | undefined;
+        toolName: string | undefined;
+        status: import("@zhivex-ai/core").AgentStatus;
+        steps: number;
+        toolCalls: number;
+        toolErrors: number;
+        usage: import("@zhivex-ai/core").TokenUsage | undefined;
+    }[];
+    usage: import("@zhivex-ai/core").TokenUsage | undefined;
+    usageLedger?: {
+        calls: number;
+        inputTokens: number;
+        outputTokens: number;
+        usageComplete: boolean;
+        estimatedUsd: number | null;
+        limitUsd: number | null;
+        schemaVersion: 1;
+        runId: string;
+        historicalUsageUnknown?: boolean | undefined;
+        costKind: "estimate-not-invoice";
+        routes: {
+            provider: string;
+            model: string;
+            calls: number;
+            inputTokens: number;
+            outputTokens: number;
+            unknownCalls: number;
+            estimatedUsd: number | null;
+            priceStatuses: ("estimate" | "missing" | "stale")[];
+        }[];
+    } | null;
+    budget: import("@zhivex-ai/core").AgentBudgetStatus;
+    costBudget?: {
+        limitUsd: number;
+        estimate: import("@zhivex-ai/core").CostEstimate;
+    };
+    scope: import("@zhivex-ai/core").AgentStoreScope | undefined;
+    capabilities: import("./capabilities.js").HarnessModelCapabilityReport;
+    orchestration: {
+        profiles: readonly ("explorer" | "implementer" | "reviewer" | "tester")[];
+        childBudget: import("./config.js").HarnessBudget;
+        mcpServers: string[];
+    };
+    execution: {
+        backend: "oci";
+        binding: import("@zhivex-ai/core").AgentExecutionEnvironmentBinding | undefined;
+        image: import("./execution-environment.js").OciImageInspection;
+    } | {
+        binding?: never;
+        image?: never;
+        backend: "none";
+    };
+    store: {
+        backend: "file" | "sqlite";
+        stateDirectory: string;
+        migration: import("./operations.js").HarnessMigrationResult | undefined;
+    };
+    stateDirectory: string;
+};

package/dist/runtime-policy.d.ts

@@ -3,9 +3,9 @@ import type { HarnessConfig } from "./config.js";
 /** Main runs and children use identical durable guards. Token transport controls
  * remain separate for providers that cannot accept maxTokens. */
 export declare const createRuntimeBudget: (budget: HarnessConfig["budget"], transportTokens: boolean) => {
-    limits: import("@zhivex-ai/agents").BudgetGuardOptions;
-    inputGuardrail: import("@zhivex-ai/agents").AgentInputGuardrail;
-    outputGuardrail: import("@zhivex-ai/agents").AgentOutputGuardrail;
+    limits: import("@zhivex-ai/core").BudgetGuardOptions;
+    inputGuardrail: import("@zhivex-ai/core").AgentInputGuardrail;
+    outputGuardrail: import("@zhivex-ai/core").AgentOutputGuardrail;
 };
 export declare const runtimeManifest: (config: HarnessConfig, tools: readonly string[], role?: string) => {
     schemaVersion: number;
@@ -27,7 +27,7 @@ export declare const runtimeManifest: (config: HarnessConfig, tools: readonly st
     closureController: boolean;
     contextEnabled: boolean;
 };
-export declare const childRuntimeSafety: (config: HarnessConfig) => import("@zhivex-ai/agents").SafetyPolicy;
+export declare const childRuntimeSafety: (config: HarnessConfig) => import("@zhivex-ai/core").SafetyPolicy;
 /** Cap each request against observed usage and the persisted checkpoint, including
  * resumed runs and compaction usage. SDK 1.20 computes its own transport ceiling only once per
  * invocation; retaining that ceiling in preflight rejects valid second turns.

package/dist/service-cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};