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

package/dist/client/stream.d.ts

@@ -0,0 +1,167 @@
+import type { AgentStreamEvent } from "@zhivex-ai/agents";
+export declare const CLI_JSON_SCHEMA_VERSION: 1;
+export declare const CLI_EVENT_SCHEMA_VERSION: 1;
+export interface StreamRunResultSource {
+    runId: string;
+    status: string;
+    provider: string;
+    model: string;
+    steps: number;
+    toolCalls: number;
+    pendingApprovals?: readonly ({
+        id: string;
+        kind: string;
+        name: string;
+        childRunId?: string;
+        childAgentId?: string;
+        [key: string]: unknown;
+    })[];
+    children?: readonly ({
+        runId: string;
+        status: string;
+        [key: string]: unknown;
+    })[];
+    [key: string]: unknown;
+}
+/**
+ * Convert runtime events into a stable, line-oriented CLI contract.
+ *
+ * Tool inputs, tool outputs, provider payloads, model messages, and error text
+ * are deliberately omitted: they can contain repository content or secrets.
+ */
+export declare const streamEventDocument: (event: AgentStreamEvent, sequence?: number) => {
+    schemaVersion: 1;
+    kind: "run-event";
+    sequence: number;
+    type: "agent-approval-request" | "agent-approval-resolved" | "agent-compaction" | "agent-run-finish" | "agent-run-start" | "agent-run-update" | "agent-step-finish" | "agent-step-start" | "error" | "finish" | "image-generation" | "provider-data" | "text-delta" | "tool-approval-request" | "tool-call" | "tool-result";
+    textDelta: string;
+} | {
+    schemaVersion: 1;
+    kind: "run-event";
+    sequence: number;
+    type: "agent-approval-request" | "agent-approval-resolved" | "agent-compaction" | "agent-run-finish" | "agent-run-start" | "agent-run-update" | "agent-step-finish" | "agent-step-start" | "error" | "finish" | "image-generation" | "provider-data" | "text-delta" | "tool-approval-request" | "tool-call" | "tool-result";
+    toolCallId: string;
+    toolName: string;
+} | {
+    schemaVersion: 1;
+    kind: "run-event";
+    sequence: number;
+    type: "agent-approval-request" | "agent-approval-resolved" | "agent-compaction" | "agent-run-finish" | "agent-run-start" | "agent-run-update" | "agent-step-finish" | "agent-step-start" | "error" | "finish" | "image-generation" | "provider-data" | "text-delta" | "tool-approval-request" | "tool-call" | "tool-result";
+    toolCallId: string;
+    toolName: string;
+    isError: boolean;
+} | {
+    schemaVersion: 1;
+    kind: "run-event";
+    sequence: number;
+    type: "agent-approval-request" | "agent-approval-resolved" | "agent-compaction" | "agent-run-finish" | "agent-run-start" | "agent-run-update" | "agent-step-finish" | "agent-step-start" | "error" | "finish" | "image-generation" | "provider-data" | "text-delta" | "tool-approval-request" | "tool-call" | "tool-result";
+    approvalRequestId: string;
+    approvalKind: "local-tool" | "provider" | "subagent";
+    toolName: string;
+} | {
+    schemaVersion: 1;
+    kind: "run-event";
+    sequence: number;
+    type: "agent-approval-request" | "agent-approval-resolved" | "agent-compaction" | "agent-run-finish" | "agent-run-start" | "agent-run-update" | "agent-step-finish" | "agent-step-start" | "error" | "finish" | "image-generation" | "provider-data" | "text-delta" | "tool-approval-request" | "tool-call" | "tool-result";
+    approvalRequestId: string;
+    approved: boolean;
+} | {
+    schemaVersion: 1;
+    kind: "run-event";
+    sequence: number;
+    type: "agent-approval-request" | "agent-approval-resolved" | "agent-compaction" | "agent-run-finish" | "agent-run-start" | "agent-run-update" | "agent-step-finish" | "agent-step-start" | "error" | "finish" | "image-generation" | "provider-data" | "text-delta" | "tool-approval-request" | "tool-call" | "tool-result";
+    provider: string;
+} | {
+    schemaVersion: 1;
+    kind: "run-event";
+    sequence: number;
+    type: "agent-approval-request" | "agent-approval-resolved" | "agent-compaction" | "agent-run-finish" | "agent-run-start" | "agent-run-update" | "agent-step-finish" | "agent-step-start" | "error" | "finish" | "image-generation" | "provider-data" | "text-delta" | "tool-approval-request" | "tool-call" | "tool-result";
+    provider: string;
+    partial: boolean;
+    id?: string;
+    index?: number;
+} | {
+    schemaVersion: 1;
+    kind: "run-event";
+    sequence: number;
+    type: "agent-approval-request" | "agent-approval-resolved" | "agent-compaction" | "agent-run-finish" | "agent-run-start" | "agent-run-update" | "agent-step-finish" | "agent-step-start" | "error" | "finish" | "image-generation" | "provider-data" | "text-delta" | "tool-approval-request" | "tool-call" | "tool-result";
+    finishReason?: import("@zhivex-ai/core").FinishReason;
+    usage?: import("@zhivex-ai/core").TokenUsage;
+} | {
+    schemaVersion: 1;
+    kind: "run-event";
+    sequence: number;
+    type: "agent-approval-request" | "agent-approval-resolved" | "agent-compaction" | "agent-run-finish" | "agent-run-start" | "agent-run-update" | "agent-step-finish" | "agent-step-start" | "error" | "finish" | "image-generation" | "provider-data" | "text-delta" | "tool-approval-request" | "tool-call" | "tool-result";
+    error: string;
+} | {
+    schemaVersion: 1;
+    kind: "run-event";
+    sequence: number;
+    type: "agent-approval-request" | "agent-approval-resolved" | "agent-compaction" | "agent-run-finish" | "agent-run-start" | "agent-run-update" | "agent-step-finish" | "agent-step-start" | "error" | "finish" | "image-generation" | "provider-data" | "text-delta" | "tool-approval-request" | "tool-call" | "tool-result";
+    currentStep: number;
+    maxSteps: number;
+} | {
+    schemaVersion: 1;
+    kind: "run-event";
+    sequence: number;
+    type: "agent-approval-request" | "agent-approval-resolved" | "agent-compaction" | "agent-run-finish" | "agent-run-start" | "agent-run-update" | "agent-step-finish" | "agent-step-start" | "error" | "finish" | "image-generation" | "provider-data" | "text-delta" | "tool-approval-request" | "tool-call" | "tool-result";
+    stepIndex: number;
+} | {
+    schemaVersion: 1;
+    kind: "run-event";
+    sequence: number;
+    type: "agent-approval-request" | "agent-approval-resolved" | "agent-compaction" | "agent-run-finish" | "agent-run-start" | "agent-run-update" | "agent-step-finish" | "agent-step-start" | "error" | "finish" | "image-generation" | "provider-data" | "text-delta" | "tool-approval-request" | "tool-call" | "tool-result";
+    stepIndex: number;
+    status: import("@zhivex-ai/core").AgentStepStatus;
+    toolCalls: number;
+} | {
+    schemaVersion: 1;
+    kind: "run-event";
+    sequence: number;
+    type: "agent-approval-request" | "agent-approval-resolved" | "agent-compaction" | "agent-run-finish" | "agent-run-start" | "agent-run-update" | "agent-step-finish" | "agent-step-start" | "error" | "finish" | "image-generation" | "provider-data" | "text-delta" | "tool-approval-request" | "tool-call" | "tool-result";
+    compactionId: string;
+    reasons: import("@zhivex-ai/core").AgentCompactionReason[];
+    messageCountBefore: number;
+    messageCountAfter: number;
+} | {
+    schemaVersion: 1;
+    kind: "run-event";
+    sequence: number;
+    type: "agent-approval-request" | "agent-approval-resolved" | "agent-compaction" | "agent-run-finish" | "agent-run-start" | "agent-run-update" | "agent-step-finish" | "agent-step-start" | "error" | "finish" | "image-generation" | "provider-data" | "text-delta" | "tool-approval-request" | "tool-call" | "tool-result";
+    runId: string;
+    status: import("@zhivex-ai/core").AgentStatus;
+    provider: string;
+    model: string;
+} | undefined;
+export declare const serializeStreamEvent: (event: AgentStreamEvent, sequence?: number) => string;
+/**
+ * Project the rich final JSON document onto the redacted JSONL contract.
+ *
+ * This is deliberately a whitelist. Output text, mutations, approval
+ * arguments, scope, paths, provider payloads, and configuration bindings can
+ * contain repository or operator data and must remain exclusive to the
+ * separate final-document contract.
+ */
+export declare const streamResultDocument: (result: StreamRunResultSource, sequence?: number) => {
+    schemaVersion: 1;
+    kind: "run-stream-result";
+    sequence: number;
+    runId: string;
+    status: string;
+    provider: string;
+    model: string;
+    steps: number;
+    toolCalls: number;
+    pendingApprovals: {
+        id: string;
+        kind: string;
+        name: string;
+        childRunId?: string;
+        childAgentId?: string;
+    }[];
+    children: {
+        runId: string;
+        status: string;
+    }[];
+};
+export declare const serializeStreamResult: (result: StreamRunResultSource, sequence?: number) => string;

package/dist/compat/cli-options.d.ts

@@ -0,0 +1,53 @@
+export interface CliOptionDefinition {
+    repeatable: boolean;
+    conflictsWith: readonly string[];
+}
+export interface CliCommandOptionContract {
+    allowed: readonly string[];
+    required: readonly (string | readonly string[])[];
+    repeatable: readonly string[];
+    conflicts: Readonly<Record<string, readonly string[]>>;
+}
+export declare const CLI_OPTION_NAMES: readonly ["--compaction-model", "--compaction-provider", "--provider", "--model", "--reasoning", "--profile", "--route", "--workspace", "--state-dir", "--mcp-config", "--context-config", "--no-project-context", "--patch", "--preconditions", "--now", "--require-verified-delivery", "--execution", "--oci-runtime", "--oci-image", "--oci-allow-command", "--oci-shell", "--oci-max-process-runtime-ms", "--oci-max-process-output-bytes", "--oci-max-memory-mb", "--oci-max-pids", "--oci-max-cpus", "--oci-max-workspace-bytes", "--oci-max-file-write-bytes", "--oci-tmpfs-mb", "--store", "--tenant", "--user", "--namespace", "--idempotency-key", "--token-budget", "--context-tokens", "--no-token-budget", "--max-steps", "--timeout-ms", "--max-tool-calls", "--max-tool-errors", "--max-input-tokens", "--max-output-tokens", "--max-total-tokens", "--subagent-max-steps", "--subagent-max-tool-calls", "--subagent-max-tool-errors", "--subagent-max-input-tokens", "--subagent-max-output-tokens", "--subagent-max-total-tokens", "--subagent-timeout-ms", "--max-parallel-reviews", "--max-cost-usd", "--input-cost-per-million", "--output-cost-per-million", "--allow-check", "--require-capability", "--subagent", "--reviewer", "--approval-mode", "--yes", "--approve", "--deny", "--json", "--jsonl", "--session", "--continue", "--update", "--status", "--limit", "--cursor", "--before", "--reason", "--cascade", "--final", "--service", "--apply", "--help", "--version", "--search", "--tool-policy", "--pricing-file", "--usage-limit-usd"];
+export type CliOptionName = (typeof CLI_OPTION_NAMES)[number];
+export declare const CLI_OPTION_DEFINITIONS: Readonly<Record<CliOptionName, CliOptionDefinition>>;
+export declare const CLI_COMMAND_OPTION_CONTRACTS: {
+    readonly init: CliCommandOptionContract;
+    readonly run: CliCommandOptionContract;
+    readonly review: CliCommandOptionContract;
+    readonly chat: CliCommandOptionContract;
+    readonly providers: CliCommandOptionContract;
+    readonly policy: CliCommandOptionContract;
+    readonly doctor: CliCommandOptionContract;
+    readonly resume: CliCommandOptionContract;
+    readonly "runs:list": CliCommandOptionContract;
+    readonly "runs:inspect": CliCommandOptionContract;
+    readonly "runs:cancel": CliCommandOptionContract;
+    readonly "runs:cleanup": CliCommandOptionContract;
+    readonly "runs:export": CliCommandOptionContract;
+    readonly "runs:report": CliCommandOptionContract;
+    readonly "sessions:list": CliCommandOptionContract;
+    readonly "sessions:inspect": CliCommandOptionContract;
+    readonly "sessions:rename": CliCommandOptionContract;
+    readonly "sessions:fork": CliCommandOptionContract;
+    readonly "sessions:archive": CliCommandOptionContract;
+    readonly "checkpoints:storage": CliCommandOptionContract;
+    readonly "checkpoints:prune-review": CliCommandOptionContract;
+    readonly "checkpoints:prune-apply": CliCommandOptionContract;
+    readonly "checkpoints:list": CliCommandOptionContract;
+    readonly "checkpoints:capture": CliCommandOptionContract;
+    readonly "checkpoints:inspect": CliCommandOptionContract;
+    readonly "checkpoints:prepare": CliCommandOptionContract;
+    readonly "checkpoints:review": CliCommandOptionContract;
+    readonly "checkpoints:apply": CliCommandOptionContract;
+    readonly "checkpoints:recover": CliCommandOptionContract;
+    readonly "changes:create": CliCommandOptionContract;
+    readonly "changes:verify": CliCommandOptionContract;
+    readonly "state:status": CliCommandOptionContract;
+    readonly "state:export": CliCommandOptionContract;
+    readonly "state:import": CliCommandOptionContract;
+    readonly help: CliCommandOptionContract;
+    readonly version: CliCommandOptionContract;
+};
+export type CliCommandOptionContractKey = keyof typeof CLI_COMMAND_OPTION_CONTRACTS;
+export declare const validateCliCommandOptions: (commandKey: CliCommandOptionContractKey, counts: ReadonlyMap<string, number>) => void;

package/dist/compat/code-support.d.ts

@@ -0,0 +1,22 @@
+/** @experimental Explicit host helpers used by the Code terminal product. No terminal implementation. */
+export { estimateMessages } from "../context/adaptive-compaction.js";
+export { TASK_SOURCE_KEY, taskSources } from "../context/task-memory.js";
+export { resolvePackageManager } from "../execution/package-manager.js";
+export { runPortableProcess } from "../execution/process-runtime.js";
+export { loadModelCatalog } from "../models/catalog-store.js";
+export type { CatalogSnapshot } from "../models/catalog-store.js";
+export { bundledModelCatalog, catalogModels, modelDescription } from "../models/catalog.js";
+export type { ModelCatalog } from "../models/catalog.js";
+/** Read-only diagnostic projection; never exposes a database connection or arbitrary SQL. */
+export declare const inspectCodeStateDatabase: (databasePath: string) => {
+    integrity: string | undefined;
+    tables: string[];
+    sessionVersion: number | undefined;
+};
+export { modelReasoningEfforts, reasoningEffortSchema } from "../providers/reasoning.js";
+export type { HarnessReasoningEffort } from "../providers/reasoning.js";
+export { DEFAULT_HARNESS_MAX_STEPS } from "../runtime/config.js";
+export { inspectRuntimeDiagnostics } from "../runtime/runtime-diagnostics.js";
+export { harnessToolExecution } from "../runtime/tool-execution.js";
+export { USAGE_LEDGER_KEY, formatUsageLedger, inspectUsageLedger, usagePricingSchema } from "../runtime/usage-ledger.js";
+export { FileChangedWhileReadingError, FileSizeLimitError, UnsafeFileTypeError, readRegularFileNoFollow } from "../workspace/file-security.js";

package/dist/compat/code-support.js

@@ -0,0 +1,74 @@
+import {
+  loadModelCatalog
+} from "../index-wg1sd3at.js";
+import {
+  estimateMessages
+} from "../index-8zzhggxv.js";
+import {
+  TASK_SOURCE_KEY,
+  USAGE_LEDGER_KEY,
+  formatUsageLedger,
+  harnessToolExecution,
+  inspectRuntimeDiagnostics,
+  inspectUsageLedger,
+  taskSources,
+  usagePricingSchema
+} from "../index-42gp2hy8.js";
+import {
+  FileChangedWhileReadingError,
+  FileSizeLimitError,
+  SqliteDatabase,
+  UnsafeFileTypeError,
+  readRegularFileNoFollow,
+  resolvePackageManager,
+  runPortableProcess
+} from "../index-yb239ghk.js";
+import {
+  DEFAULT_HARNESS_MAX_STEPS,
+  modelReasoningEfforts,
+  reasoningEffortSchema
+} from "../index-gq9xagx2.js";
+import"../index-8705zxpr.js";
+import {
+  bundledModelCatalog,
+  catalogModels,
+  modelDescription
+} from "../index-xqxeypt5.js";
+import"../index-1bx83sw4.js";
+// src/compat/code-support.ts
+var inspectCodeStateDatabase = (databasePath) => {
+  const database = new SqliteDatabase(databasePath, { create: false, readonly: true, strict: true });
+  try {
+    const integrity = database.query("PRAGMA quick_check").get()?.quick_check;
+    const tables = database.query("SELECT name FROM sqlite_master WHERE type = 'table'").all().map((row) => row.name);
+    const sessionVersion = tables.includes("zhivex_cli_session_schema") ? database.query("SELECT version FROM zhivex_cli_session_schema WHERE singleton = 1").get()?.version : undefined;
+    return { integrity, tables, sessionVersion };
+  } finally {
+    database.close(false);
+  }
+};
+export {
+  DEFAULT_HARNESS_MAX_STEPS,
+  FileChangedWhileReadingError,
+  FileSizeLimitError,
+  TASK_SOURCE_KEY,
+  USAGE_LEDGER_KEY,
+  UnsafeFileTypeError,
+  bundledModelCatalog,
+  catalogModels,
+  estimateMessages,
+  formatUsageLedger,
+  harnessToolExecution,
+  inspectCodeStateDatabase,
+  inspectRuntimeDiagnostics,
+  inspectUsageLedger,
+  loadModelCatalog,
+  modelDescription,
+  modelReasoningEfforts,
+  readRegularFileNoFollow,
+  reasoningEffortSchema,
+  resolvePackageManager,
+  runPortableProcess,
+  taskSources,
+  usagePricingSchema
+};

package/dist/{config-1k9t4jhh.js → config-c002f06f.js}

@@ -26,7 +26,7 @@ import {
   providerAvailability,
   providerDescriptor,
   resolveHarnessConfig
-} from "./cli-entry-427869g9.js";
+} from "./cli-entry-d5788aay.js";
 import"./cli-entry-1bx83sw4.js";
 export {
   BUILTIN_PROVIDER_REGISTRATIONS,

package/dist/config-j3jga5wh.js

@@ -0,0 +1,61 @@
+import {
+  BUILTIN_PROVIDER_REGISTRATIONS,
+  DEFAULT_ALLOWED_CHECKS,
+  DEFAULT_HARNESS_BUDGET,
+  DEFAULT_HARNESS_COMPACTION,
+  DEFAULT_HARNESS_MAX_STEPS,
+  DEFAULT_OCI_EXECUTION,
+  DEFAULT_PROVIDER_REGISTRY,
+  DEFAULT_SUBAGENT_BUDGET,
+  HARNESS_CONFIG_MIGRATABLE_SCHEMA_VERSIONS,
+  HARNESS_CONFIG_SCHEMA_VERSION,
+  HARNESS_EXECUTION_BACKENDS,
+  HARNESS_EXECUTION_POLICY_VERSION,
+  HARNESS_OCI_RUNTIMES,
+  HARNESS_OCI_SHELL_MODES,
+  HARNESS_REQUIRED_CAPABILITIES,
+  HARNESS_STORE_BACKENDS,
+  HARNESS_SUBAGENT_PROFILES,
+  PROVIDERS,
+  PROVIDER_DESCRIPTORS,
+  createProviderModel,
+  createProviderRegistry,
+  defaultHarnessNamespace,
+  migrateHarnessConfigInput,
+  parseProvider,
+  providerAvailability,
+  providerDescriptor,
+  resolveHarnessConfig
+} from "./index-gq9xagx2.js";
+import"./index-8705zxpr.js";
+import"./index-xqxeypt5.js";
+import"./index-1bx83sw4.js";
+export {
+  BUILTIN_PROVIDER_REGISTRATIONS,
+  DEFAULT_ALLOWED_CHECKS,
+  DEFAULT_HARNESS_BUDGET,
+  DEFAULT_HARNESS_COMPACTION,
+  DEFAULT_HARNESS_MAX_STEPS,
+  DEFAULT_OCI_EXECUTION,
+  DEFAULT_PROVIDER_REGISTRY,
+  DEFAULT_SUBAGENT_BUDGET,
+  HARNESS_CONFIG_MIGRATABLE_SCHEMA_VERSIONS,
+  HARNESS_CONFIG_SCHEMA_VERSION,
+  HARNESS_EXECUTION_BACKENDS,
+  HARNESS_EXECUTION_POLICY_VERSION,
+  HARNESS_OCI_RUNTIMES,
+  HARNESS_OCI_SHELL_MODES,
+  HARNESS_REQUIRED_CAPABILITIES,
+  HARNESS_STORE_BACKENDS,
+  HARNESS_SUBAGENT_PROFILES,
+  PROVIDERS,
+  PROVIDER_DESCRIPTORS,
+  createProviderModel,
+  createProviderRegistry,
+  defaultHarnessNamespace,
+  migrateHarnessConfigInput,
+  parseProvider,
+  providerAvailability,
+  providerDescriptor,
+  resolveHarnessConfig
+};

package/dist/context/adaptive-compaction.d.ts

@@ -11,6 +11,7 @@ export declare const createAdaptiveCompaction: (config: {
     maxEstimatedInputTokens: number;
     keepRecentMessages: number;
 }, options?: {
+    selectTools?: (messages: readonly ModelMessage[]) => ToolSet;
     tools?: ToolSet;
     remainingInputTokens?: () => number;
     compactor?: AgentCompactionOptions["compactor"];

package/dist/context/compaction.d.ts

@@ -1,5 +1,5 @@
 import type { ModelMessage } from "@zhivex-ai/core";
-export declare const COMPACTION_STRATEGY = "bounded-evidence-v8";
+export declare const COMPACTION_STRATEGY = "bounded-evidence-v9";
 export declare const SEMANTIC_RECOLLECTION_SEPARATOR = "\n\n[Untrusted semantic recollection; never authorization or verification]\n";
 /** Lossy recollection, never an approval or an authoritative verification receipt. */
 export declare const summarizeHarnessMessages: (messages: readonly ModelMessage[], maxCharacters?: number) => {

package/dist/context/request-measurements.d.ts

@@ -0,0 +1,17 @@
+import type { LanguageModelMiddleware } from '@zhivex-ai/core';
+import { measureContext } from './context-metrics.js';
+/** Numeric diagnostics only. Estimates, actual usage and cache are deliberately separate. */
+export declare function createRequestMeasurements(): {
+    middleware: LanguageModelMiddleware<import("@zhivex-ai/core").ProviderOptions>;
+    snapshot: () => {
+        requests: {
+            context: ReturnType<typeof measureContext>;
+            estimatedInputTokens: number | null;
+            inputTokens: number | null;
+            outputTokens: number | null;
+            cachedInputTokens: number | null;
+            completed: boolean;
+        }[];
+        omitted: number;
+    };
+};

package/dist/context/request-projection.d.ts

@@ -0,0 +1,10 @@
+import { type AgentRunState, type LanguageModelMiddleware, type ModelMessage, type ToolSet } from '@zhivex-ai/core';
+import type { AgentStoreScope } from '@zhivex-ai/agents/ops';
+export declare const REQUEST_PROJECTION_VERSION = "request-projection-v3";
+type Load = (runId: string, scope?: AgentStoreScope) => Promise<AgentRunState | undefined>;
+/** Changes advertised schemas only. Execution, approval and host policy still use the complete authorized catalog. */
+export declare function selectRequestTools(tools: ToolSet, messages: readonly ModelMessage[], preserve?: readonly string[]): ToolSet;
+export declare function createRequestContextTools(catalog: () => ToolSet, load: Load): ToolSet;
+/** Project only evidence that can be recovered from this exact durable run. Never alter persisted messages/results. */
+export declare function createRequestProjection(load: () => Promise<AgentRunState | undefined>, preserve?: readonly string[]): LanguageModelMiddleware;
+export {};

package/dist/context/task-memory.d.ts

@@ -17,6 +17,7 @@ export declare const createTaskTools: () => {
     }, z.core.$strip>, {
         id: string;
         sourceIds: string[];
+        acceptance?: import("@zhivex-ai/core").JsonValue;
         firstSourceId: string;
         sourceOffset: number;
         totalSources: number;

package/dist/engine/acp.d.ts

@@ -0,0 +1,6 @@
+/** Explicit Harness integration surface. See contracts/engine-api.json for stability tiers. */
+export { createAcpConnection } from "../client/acp.js";
+export type { AcpConnectionOptions } from "../client/acp.js";
+export { serveAcpStdio } from "../client/acp-stdio.js";
+export { createAcpMcpHost } from "../client/acp-mcp-host.js";
+export type { AcpMcpHostRule } from "../client/acp-mcp-admission.js";

package/dist/engine/acp.js

@@ -0,0 +1,205 @@
+import {
+  discardMcpWorkspaceSnapshot,
+  launchDockerMcpGroup,
+  prepareMcpWorkspaceSnapshot
+} from "../index-z4e8d0ph.js";
+import {
+  createAcpConnection,
+  issueAcpMcpSessionProvider,
+  serveAcpStdio
+} from "../index-3ah1f369.js";
+import {
+  createHarness,
+  createHarnessClientAdapter
+} from "../index-jgrx804e.js";
+import"../index-h0mqx2ed.js";
+import"../index-8zzhggxv.js";
+import"../index-42gp2hy8.js";
+import"../index-t60rva31.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/client/acp-mcp-host.ts
+import { createHash } from "node:crypto";
+
+// src/client/acp-mcp-admission.ts
+import { z } from "zod";
+var literal = z.string().max(4096).refine((value) => !/[\x00-\x1f\x7f]/.test(value));
+var command = literal.refine((value) => value.startsWith("/") && !value.includes("\\") && value.split("/").slice(1).every((part) => part && part !== "." && part !== ".."));
+var descriptor = z.object({
+  name: z.string().min(1).max(128),
+  command,
+  args: z.array(literal).max(128),
+  env: z.array(z.object({ name: z.string().regex(/^[A-Za-z_][A-Za-z0-9_]{0,127}$/), value: literal }).strict()).max(64)
+}).strict();
+function parseAcpMcpDescriptors(input) {
+  const parsed = z.array(descriptor).max(8).safeParse(input);
+  if (!parsed.success || Buffer.byteLength(JSON.stringify(parsed.data)) > 64 * 1024)
+    throw new Error("Invalid ACP MCP configuration.");
+  const servers = parsed.data;
+  if (new Set(servers.map((server) => server.name)).size !== servers.length || servers.some((server) => new Set(server.env.map((variable) => variable.name)).size !== server.env.length))
+    throw new Error("Ambiguous ACP MCP configuration.");
+  return Object.freeze(servers.map((server) => Object.freeze({
+    ...server,
+    args: Object.freeze([...server.args]),
+    env: Object.freeze(server.env.map((variable) => Object.freeze({ ...variable })))
+  })));
+}
+function proposeAcpMcpLaunches(input, options) {
+  const servers = parseAcpMcpDescriptors(input);
+  const proposals = servers.map((server) => {
+    const matching = options.rules.filter((rule2) => rule2.clientName === server.name && rule2.clientCommand === server.command && JSON.stringify(rule2.clientArgs) === JSON.stringify(server.args));
+    if (matching.length !== 1)
+      throw new Error("ACP MCP server has no unique host mapping.");
+    const rule = matching[0];
+    const environment = { ...rule.proposal.environment };
+    const targets = new Set;
+    for (const variable of server.env) {
+      const target = Object.hasOwn(rule.environmentBindings, variable.name) ? rule.environmentBindings[variable.name] : undefined;
+      if (!target || !/^ZHIVEX_MCP_[A-Z0-9_]{1,96}$/.test(target) || targets.has(target) || Object.hasOwn(environment, target) || Object.hasOwn(rule.proposal.secretReferences, target)) {
+        throw new Error("ACP MCP environment was not uniquely allowed by the host.");
+      }
+      targets.add(target);
+      environment[target] = variable.value;
+    }
+    return structuredClone({ ...rule.proposal, environment, scope: options.scope, snapshotDigest: options.snapshotDigest });
+  });
+  if (new Set(proposals.map((proposal) => proposal.serverId)).size !== proposals.length)
+    throw new Error("ACP MCP host mappings collide.");
+  return proposals;
+}
+
+// src/client/acp-mcp-host.ts
+async function beforeCancellation(pending, signal) {
+  let cancel;
+  const aborted = new Promise((_, reject) => {
+    cancel = () => reject(new Error("ACP MCP preparation cancelled."));
+    if (signal.aborted)
+      cancel();
+    else
+      signal.addEventListener("abort", cancel, { once: true });
+  });
+  try {
+    return await Promise.race([pending, aborted]);
+  } finally {
+    signal.removeEventListener("abort", cancel);
+  }
+}
+async function createAcpMcpHost(options) {
+  if (options.harness.isolatedMcpSession)
+    throw new Error("ACP host must own its MCP sessions.");
+  const rules = structuredClone(options.rules);
+  const baseOptions = { ...options.harness };
+  const base = await createHarness(baseOptions);
+  const workspace = `sha256:${createHash("sha256").update(base.workspace.root).digest("hex")}`;
+  const descriptors = new Map;
+  const pending = new Set;
+  let closing = false;
+  const scopeFor = (runId) => ({ principal: base.config.scope.userId, tenant: base.config.scope.tenantId, session: runId, workspace });
+  try {
+    if (!base.config.scope.userId || !base.config.scope.tenantId || !options.hostId)
+      throw new Error("ACP MCP host requires an explicit identity.");
+    const adapter = await createHarnessClientAdapter(base, { prepareRun: async (context) => {
+      if (closing)
+        throw new Error("ACP host is closing.");
+      const servers = descriptors.get(context.sessionId);
+      if (!servers)
+        throw new Error("ACP session has no host registration.");
+      if (!servers.length)
+        return { harness: base, release: async () => {} };
+      const templates = proposeAcpMcpLaunches(servers, { rules, scope: scopeFor(context.runId), snapshotDigest: workspace });
+      const launches = [];
+      const snapshots = [];
+      let group;
+      try {
+        for (const template of templates) {
+          if (context.signal.aborted)
+            throw new Error("ACP MCP preparation cancelled.");
+          const snapshot = await prepareMcpWorkspaceSnapshot(base.workspace, template.limits.maxWorkspaceBytes);
+          snapshots.push(snapshot);
+          const proposal = { ...template, snapshotDigest: snapshot.digest };
+          const receipt = await beforeCancellation(options.authority.admit(proposal), context.signal);
+          launches.push({
+            authority: options.authority,
+            receipt,
+            proposal,
+            snapshot,
+            scope: proposal.scope,
+            provisionerImageId: options.provisionerImageId,
+            resolveSecret: options.resolveSecret,
+            journal: { store: base.store, runId: context.runId, scope: base.config.scope, hostId: options.hostId }
+          });
+        }
+        group = await launchDockerMcpGroup(launches, context.signal);
+        if (context.signal.aborted)
+          throw new Error("ACP MCP preparation cancelled.");
+        const runtime = await createHarness({ ...baseOptions, store: base.store, isolatedMcpSession: group.hostSession });
+        return { harness: runtime, release: () => runtime.close() };
+      } catch {
+        const cleanup = await Promise.allSettled([group?.close(), ...snapshots.map(discardMcpWorkspaceSnapshot)]);
+        if (cleanup.some((result) => result.status === "rejected"))
+          throw new Error("ACP MCP cleanup was not confirmed.");
+        throw new Error("ACP MCP admission or preparation failed.");
+      }
+    } });
+    const exposed = {
+      negotiate: (versions) => adapter.negotiate(versions),
+      cancelActive: () => adapter.cancelActive(),
+      close: () => adapter.close(),
+      dispatch(request) {
+        if (closing)
+          return Promise.resolve({ protocolVersion: 1, requestId: null, ok: false, error: { code: "CONNECTION_EXPIRED" } });
+        const operation = adapter.dispatch(request);
+        pending.add(operation);
+        operation.then(() => pending.delete(operation), () => pending.delete(operation));
+        return operation;
+      }
+    };
+    const mcpSessionProvider = issueAcpMcpSessionProvider({
+      adapter: exposed,
+      parse(input) {
+        if (closing || descriptors.size >= 256)
+          throw new Error("ACP MCP host is unavailable.");
+        const servers = parseAcpMcpDescriptors(input);
+        proposeAcpMcpLaunches(servers, { rules, scope: scopeFor("pending"), snapshotDigest: workspace });
+        return servers;
+      },
+      bind(sessionId, servers) {
+        if (closing || descriptors.has(sessionId))
+          throw new Error("ACP MCP registration is unavailable.");
+        descriptors.set(sessionId, servers);
+      }
+    });
+    let closed;
+    return Object.freeze({
+      adapter: exposed,
+      workspace: base.workspace.root,
+      mcpSessionProvider,
+      close() {
+        return closed ??= (async () => {
+          closing = true;
+          try {
+            await adapter.cancelActive();
+            await Promise.allSettled([...pending]);
+            adapter.close();
+          } finally {
+            descriptors.clear();
+            await base.close();
+          }
+        })();
+      }
+    });
+  } catch (error) {
+    await base.close();
+    throw error;
+  }
+}
+export {
+  createAcpConnection,
+  createAcpMcpHost,
+  serveAcpStdio
+};