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

package/dist/compat/code-support.js

@@ -1,104 +1,40 @@
 import {
-  FileChangedWhileReadingError,
-  FileSizeLimitError,
-  SqliteDatabase,
+  loadModelCatalog
+} from "../index-wg1sd3at.js";
+import {
+  estimateMessages
+} from "../index-8zzhggxv.js";
+import {
   TASK_SOURCE_KEY,
   USAGE_LEDGER_KEY,
-  UnsafeFileTypeError,
-  estimateMessages,
   formatUsageLedger,
   harnessToolExecution,
   inspectRuntimeDiagnostics,
   inspectUsageLedger,
-  readRegularFileNoFollow,
-  resolvePackageManager,
-  runPortableProcess,
   taskSources,
   usagePricingSchema
-} from "../index-pgqz45fj.js";
+} from "../index-42gp2hy8.js";
+import {
+  FileChangedWhileReadingError,
+  FileSizeLimitError,
+  SqliteDatabase,
+  UnsafeFileTypeError,
+  readRegularFileNoFollow,
+  resolvePackageManager,
+  runPortableProcess
+} from "../index-yb239ghk.js";
 import {
   DEFAULT_HARNESS_MAX_STEPS,
-  bundledModelCatalog,
-  catalogModels,
-  modelCatalogSchema,
-  modelDescription,
   modelReasoningEfforts,
   reasoningEffortSchema
-} from "../index-fvca1xea.js";
+} from "../index-gq9xagx2.js";
+import"../index-8705zxpr.js";
+import {
+  bundledModelCatalog,
+  catalogModels,
+  modelDescription
+} from "../index-xqxeypt5.js";
 import"../index-1bx83sw4.js";
-// src/models/catalog-store.ts
-import { mkdir, readFile, rename, writeFile, unlink } from "node:fs/promises";
-import { homedir } from "node:os";
-import path from "node:path";
-import { createHash, randomUUID } from "node:crypto";
-var MAX_BYTES = 1024 * 1024;
-var TTL = 60 * 60 * 1000;
-async function loadModelCatalog(options = {}) {
-  const fallback = { catalog: bundledModelCatalog, source: "bundled", stale: false };
-  const source = options.url ?? process.env.ZHIVEX_MODEL_CATALOG_URL;
-  if (!source)
-    return fallback;
-  let url;
-  try {
-    url = new URL(source);
-    if (url.protocol !== "https:" || url.username || url.password || url.hash)
-      return { ...fallback, stale: true };
-  } catch {
-    return { ...fallback, stale: true };
-  }
-  const now = options.now ?? Date.now();
-  const directory = options.cacheDirectory ?? path.join(homedir(), ".zhivex", "model-catalog");
-  const file = path.join(directory, `${createHash("sha256").update(url.href).digest("hex")}.json`);
-  let cached;
-  try {
-    const raw = await readFile(file, "utf8");
-    if (Buffer.byteLength(raw) > MAX_BYTES + 1024)
-      throw new Error("CATALOG_TOO_LARGE");
-    const envelope = JSON.parse(raw);
-    if (envelope.url !== url.href || !Number.isFinite(envelope.fetchedAt))
-      throw new Error("INVALID_CACHE");
-    cached = { catalog: modelCatalogSchema.parse(envelope.catalog), source: "cache", stale: true };
-    if (!options.refresh && now >= envelope.fetchedAt && now - envelope.fetchedAt < TTL)
-      return { ...cached, stale: false };
-  } catch {}
-  try {
-    const response = await (options.fetcher ?? fetch)(url, {
-      signal: AbortSignal.timeout(3000),
-      redirect: "error",
-      headers: { accept: "application/json" }
-    });
-    if (!response.ok || !response.body)
-      throw new Error("CATALOG_FETCH_FAILED");
-    const reader = response.body.getReader();
-    const chunks = [];
-    let size = 0;
-    try {
-      for (;; ) {
-        const { value, done } = await reader.read();
-        if (done)
-          break;
-        size += value.byteLength;
-        if (size > MAX_BYTES)
-          throw new Error("CATALOG_TOO_LARGE");
-        chunks.push(value);
-      }
-    } finally {
-      await reader.cancel().catch(() => {});
-    }
-    const catalog = modelCatalogSchema.parse(JSON.parse(Buffer.concat(chunks).toString("utf8")));
-    const temporary = `${file}.${randomUUID()}.tmp`;
-    try {
-      await mkdir(directory, { recursive: true, mode: 448 });
-      await writeFile(temporary, JSON.stringify({ url: url.href, fetchedAt: now, catalog }), { mode: 384, flag: "wx" });
-      await rename(temporary, file);
-    } catch {} finally {
-      await unlink(temporary).catch(() => {});
-    }
-    return { catalog, source: "remote", stale: false };
-  } catch {
-    return cached ?? { ...fallback, stale: true };
-  }
-}
 // src/compat/code-support.ts
 var inspectCodeStateDatabase = (databasePath) => {
   const database = new SqliteDatabase(databasePath, { create: false, readonly: true, strict: true });

package/dist/{config-q32jm1e6.js → config-c002f06f.js}

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

package/dist/{config-6gtpxvjv.js → config-j3jga5wh.js}

@@ -26,7 +26,9 @@ import {
   providerAvailability,
   providerDescriptor,
   resolveHarnessConfig
-} from "./index-fvca1xea.js";
+} from "./index-gq9xagx2.js";
+import"./index-8705zxpr.js";
+import"./index-xqxeypt5.js";
 import"./index-1bx83sw4.js";
 export {
   BUILTIN_PROVIDER_REGISTRATIONS,

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

@@ -2,3 +2,5 @@
 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

@@ -1,9 +1,205 @@
+import {
+  discardMcpWorkspaceSnapshot,
+  launchDockerMcpGroup,
+  prepareMcpWorkspaceSnapshot
+} from "../index-6m08wvab.js";
 import {
   createAcpConnection,
+  issueAcpMcpSessionProvider,
   serveAcpStdio
-} from "../index-77h9qr5h.js";
+} from "../index-3ah1f369.js";
+import {
+  createHarness,
+  createHarnessClientAdapter
+} 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/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
 };

package/dist/engine/client.js

@@ -2,14 +2,21 @@ import {
   createHarnessClientAdapter,
   runResultDocument,
   terminalContinuationMessages
-} from "../index-5wjwe91x.js";
-import"../index-pgqz45fj.js";
-import"../index-fvca1xea.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 {
   HARNESS_CLIENT_PROTOCOL_VERSION,
   harnessClientCommandSchema,
   harnessClientRequestSchema
-} from "../index-2aymdsqc.js";
+} from "../index-qfpz5y2v.js";
 import"../index-1bx83sw4.js";
 export {
   HARNESS_CLIENT_PROTOCOL_VERSION,

package/dist/engine/desktop-providers-v1.d.ts

@@ -0,0 +1,4 @@
+/** Host-only integration helpers; never import this entrypoint from a renderer. */
+export { loadModelCatalog } from "../models/catalog-store.js";
+export type { CatalogLoadOptions, CatalogSnapshot } from "../models/catalog-store.js";
+export { vertexConfigured, vertexEnvironment, vertexTokenSource, vertexRoute } from "../providers/vertex-auth.js";

package/dist/engine/desktop-providers-v1.js

@@ -0,0 +1,18 @@
+import {
+  loadModelCatalog
+} from "../index-wg1sd3at.js";
+import {
+  vertexConfigured,
+  vertexEnvironment,
+  vertexRoute,
+  vertexTokenSource
+} from "../index-8705zxpr.js";
+import"../index-xqxeypt5.js";
+import"../index-1bx83sw4.js";
+export {
+  loadModelCatalog,
+  vertexConfigured,
+  vertexEnvironment,
+  vertexRoute,
+  vertexTokenSource
+};

package/dist/engine/desktop-state-v1.d.ts

@@ -0,0 +1,10 @@
+/** Versioned, host-only Desktop update/recovery contract. No renderer or SQL API. */
+export { DESKTOP_DATABASE_BACKUP_LIMIT as HOST_DATABASE_SNAPSHOT_LIMIT, createDesktopDatabaseBackup as createHostDatabaseSnapshot, verifyDesktopDatabaseBackup as verifyHostDatabaseSnapshot, verifyDesktopDatabaseState as verifyHostDatabaseState } from "../persistence/host-database-backup.js";
+export type { DesktopDatabaseBackup as HostDatabaseSnapshot, DesktopBackupConfig as HostDatabaseSnapshotConfig } from "../persistence/host-database-backup.js";
+export { HARNESS_SQLITE_FILE } from "../persistence/operations.js";
+export { validateStateDirectory } from "../persistence/state-directory.js";
+export { validateRecordedWorkspace } from "../persistence/recorded-workspace.js";
+export { acquireSqliteAccess, adoptExclusiveSqliteAccess, exclusiveSqliteAccessDescriptor } from "../persistence/sqlite-access.js";
+export type { SqliteAccessLease } from "../persistence/sqlite-access.js";
+export { protectPersistenceSecret } from "../persistence/persistence-secrets.js";
+export { readRegularFileNoFollow, statRegularFileNoFollow } from "../workspace/file-security.js";

package/dist/engine/desktop-state-v1.js

@@ -0,0 +1,168 @@
+import {
+  createArchivedHarnessStateBackup,
+  createHarnessStateBackup,
+  validateRecordedWorkspace
+} from "../index-a97bezbz.js";
+import {
+  HARNESS_SQLITE_FILE
+} from "../index-h0mqx2ed.js";
+import {
+  validateStateDirectory
+} from "../index-42gp2hy8.js";
+import"../index-z0qxmkm2.js";
+import {
+  SqliteDatabase,
+  acquireSqliteAccess,
+  adoptExclusiveSqliteAccess,
+  exclusiveSqliteAccessDescriptor,
+  protectPersistenceSecret,
+  readRegularFileNoFollow,
+  statRegularFileNoFollow
+} from "../index-yb239ghk.js";
+import"../index-gq9xagx2.js";
+import"../index-8705zxpr.js";
+import"../index-xqxeypt5.js";
+import"../index-1bx83sw4.js";
+
+// src/persistence/host-database-backup.ts
+import { createHash } from "node:crypto";
+import { constants } from "node:fs";
+import { chmod, lstat, mkdir, mkdtemp, open, realpath, rm } from "node:fs/promises";
+import path from "node:path";
+var DESKTOP_DATABASE_BACKUP_LIMIT = 128 * 1024 * 1024;
+function assertIdle(db) {
+  const terminal = "('completed','failed','cancelled','timed_out')";
+  if (db.query(`SELECT count(*) AS n FROM zhivex_agent_runs WHERE json_extract(state_json,'$.status') IS NULL OR json_extract(state_json,'$.status') NOT IN ${terminal} OR coalesce(json_array_length(json_extract(state_json,'$.pendingApprovals')),0)>0`).get().n || db.query("SELECT count(*) AS n FROM zhivex_agent_runs_leases WHERE expires_at_ms > ?").get(Date.now()).n || db.query(`SELECT count(*) AS n FROM zhivex_cli_session_runs WHERE status NOT IN ${terminal}`).get().n || db.query("SELECT count(*) AS n FROM zhivex_agent_runs_tool_journal WHERE json_extract(entry_json,'$.status') IS NULL OR json_extract(entry_json,'$.status') NOT IN ('completed','failed')").get().n)
+    throw new Error("BACKUP_WORK_ACTIVE");
+}
+async function privateDirectory(directory) {
+  const stat = await lstat(directory);
+  if (!stat.isDirectory() || stat.isSymbolicLink() || stat.uid !== process.getuid?.() || stat.mode & 63)
+    throw new Error;
+  return realpath(directory);
+}
+async function createDesktopDatabaseBackup(config, backupRoot) {
+  let directory;
+  try {
+    await validateStateDirectory(config.workspace, config.stateDirectory);
+    const sourceDirectory = await privateDirectory(config.stateDirectory);
+    const source = path.join(sourceDirectory, HARNESS_SQLITE_FILE);
+    const sourceStat = await statRegularFileNoFollow(source, { label: "desktop database", requireSingleLink: true });
+    if (sourceStat.uid !== process.getuid?.() || sourceStat.mode & 63 || sourceStat.size > DESKTOP_DATABASE_BACKUP_LIMIT)
+      throw new Error;
+    await mkdir(backupRoot, { recursive: true, mode: 448 });
+    directory = await mkdtemp(path.join(await privateDirectory(backupRoot), "database-"));
+    const destination = path.join(directory, HARNESS_SQLITE_FILE);
+    const sourceDb = new SqliteDatabase(source, { readonly: true, ...config.accessLease ? { accessLease: config.accessLease } : {} });
+    try {
+      sourceDb.exec("PRAGMA busy_timeout=1000");
+      const before = sourceDb.query("PRAGMA data_version").get().data_version;
+      if (sourceDb.query("PRAGMA page_count").get().page_count * sourceDb.query("PRAGMA page_size").get().page_size > DESKTOP_DATABASE_BACKUP_LIMIT)
+        throw new Error;
+      assertIdle(sourceDb);
+      sourceDb.query("VACUUM INTO ?").run(destination);
+      if (sourceDb.query("PRAGMA data_version").get().data_version !== before)
+        throw new Error;
+    } finally {
+      sourceDb.close();
+    }
+    await chmod(destination, 384);
+    const snapshot = new SqliteDatabase(destination, { readonly: true });
+    try {
+      if (snapshot.query("PRAGMA quick_check").all().some((row) => row.quick_check !== "ok"))
+        throw new Error;
+      assertIdle(snapshot);
+    } finally {
+      snapshot.close();
+    }
+    const logical = await (config.workspaceAbsent ? createArchivedHarnessStateBackup : createHarnessStateBackup)({ ...config, stateDirectory: directory, storeBackend: "sqlite" });
+    const finalDb = new SqliteDatabase(destination);
+    try {
+      const checkpoint = finalDb.query("PRAGMA wal_checkpoint(TRUNCATE)").get();
+      if (checkpoint && checkpoint.busy !== 0)
+        throw new Error;
+    } finally {
+      finalDb.close();
+    }
+    const file = await open(destination, constants.O_RDONLY | constants.O_NOFOLLOW);
+    try {
+      await file.sync();
+    } finally {
+      await file.close();
+    }
+    const contents = await readRegularFileNoFollow(destination, { label: "desktop backup", maxBytes: DESKTOP_DATABASE_BACKUP_LIMIT, requireSingleLink: true });
+    const result = { directory, size: contents.contents.length, sha256: createHash("sha256").update(contents.contents).digest("hex"), logicalChecksum: logical.checksum };
+    const parent = await open(directory, constants.O_RDONLY | constants.O_NOFOLLOW);
+    try {
+      await parent.sync();
+    } finally {
+      await parent.close();
+    }
+    const rootHandle = await open(path.dirname(directory), constants.O_RDONLY | constants.O_NOFOLLOW);
+    try {
+      await rootHandle.sync();
+    } finally {
+      await rootHandle.close();
+    }
+    return result;
+  } catch {
+    if (directory)
+      try {
+        await rm(directory, { recursive: true, force: true });
+      } catch {
+        throw new Error("DESKTOP_BACKUP_CLEANUP_FAILED");
+      }
+    throw new Error("DESKTOP_BACKUP_FAILED");
+  }
+}
+async function verifyDesktopDatabaseBackup(backup) {
+  try {
+    await privateDirectory(backup.directory);
+    const contents = await readRegularFileNoFollow(path.join(backup.directory, HARNESS_SQLITE_FILE), { label: "desktop backup", maxBytes: DESKTOP_DATABASE_BACKUP_LIMIT, requireSingleLink: true });
+    if (contents.stat.uid !== process.getuid?.() || contents.stat.mode & 63 || contents.contents.length !== backup.size || createHash("sha256").update(contents.contents).digest("hex") !== backup.sha256)
+      throw new Error;
+  } catch {
+    throw new Error("DESKTOP_BACKUP_INVALID");
+  }
+}
+async function verifyDesktopDatabaseState(config) {
+  try {
+    await validateRecordedWorkspace(config.workspace, config.workspaceAbsent === true);
+    await validateStateDirectory(config.workspace, config.stateDirectory);
+    const directory = await privateDirectory(config.stateDirectory), filename = path.join(directory, HARNESS_SQLITE_FILE);
+    const stat = await statRegularFileNoFollow(filename, { label: "desktop state", requireSingleLink: true });
+    if (stat.uid !== process.getuid?.() || stat.mode & 63 || stat.size > DESKTOP_DATABASE_BACKUP_LIMIT)
+      throw new Error;
+    exclusiveSqliteAccessDescriptor(config.accessLease, filename);
+    const db = new SqliteDatabase(filename, { readonly: true, create: false, accessLease: config.accessLease });
+    try {
+      db.exec("PRAGMA busy_timeout=1000");
+      if (db.query("PRAGMA page_count").get().page_count * db.query("PRAGMA page_size").get().page_size > DESKTOP_DATABASE_BACKUP_LIMIT)
+        throw new Error;
+      if (db.query("PRAGMA quick_check").all().some((row) => row.quick_check !== "ok"))
+        throw new Error;
+      assertIdle(db);
+    } finally {
+      db.close();
+    }
+    await createArchivedHarnessStateBackup(config, { accessLease: config.accessLease });
+    exclusiveSqliteAccessDescriptor(config.accessLease, filename);
+  } catch {
+    throw new Error("DESKTOP_DATABASE_STATE_INVALID");
+  }
+}
+export {
+  HARNESS_SQLITE_FILE,
+  DESKTOP_DATABASE_BACKUP_LIMIT as HOST_DATABASE_SNAPSHOT_LIMIT,
+  acquireSqliteAccess,
+  adoptExclusiveSqliteAccess,
+  createDesktopDatabaseBackup as createHostDatabaseSnapshot,
+  exclusiveSqliteAccessDescriptor,
+  protectPersistenceSecret,
+  readRegularFileNoFollow,
+  statRegularFileNoFollow,
+  validateRecordedWorkspace,
+  validateStateDirectory,
+  verifyDesktopDatabaseBackup as verifyHostDatabaseSnapshot,
+  verifyDesktopDatabaseState as verifyHostDatabaseState
+};

package/dist/engine/index.d.ts

@@ -59,3 +59,15 @@ export { serveAcpStdio } from "../client/acp-stdio.js";
 export { openWorkspaceCheckpointStore } from "../persistence/workspace-checkpoints.js";
 export type { WorkspaceCheckpoint, WorkspaceRestoreOperation } from "../persistence/workspace-checkpoints.js";
 export type { HarnessMcpResourceClient } from "../integrations/mcp.js";
+/** Experimental read-only host policy view. */
+export { inspectHarnessPolicy } from "../runtime/policy-inspection.js";
+export type { HarnessPolicyInspection } from "../runtime/policy-inspection.js";
+/** Experimental application-owned task acceptance; enforcement is a separate layer. */
+export { taskAcceptanceContractSchema, compileTaskAcceptanceContract } from '../runtime/task-acceptance.js';
+export type { TaskAcceptanceContract } from '../runtime/task-acceptance.js';
+export { inspectHarnessTaskAcceptance, reviseHarnessTaskAcceptance } from '../runtime/task-acceptance-host.js';
+export type { TaskAcceptanceLedger } from '../runtime/task-acceptance-record.js';
+/** Experimental bounded portable governance projection. */
+export { exportHarnessGovernanceReport, harnessGovernanceReportSchema, renderHarnessGovernanceMarkdown } from '../persistence/governance-report.js';
+export type { HarnessGovernanceReport, HarnessGovernanceOptions } from '../persistence/governance-report.js';
+export type { GovernanceSessionSource } from '../persistence/governance-context.js';