@zhivex-ai/harness 1.4.0 → 1.4.1

package/dist/{cli-2h37qyvg.js → cli-1cf4dcnj.js}

@@ -1,137 +1,135 @@
 #!/usr/bin/env node
 import {
-  APPROVAL_HISTORY_KEY,
   ActivityHistory,
-  CLI_CHANGES_COMMANDS,
-  CLI_COMMANDS,
-  CLI_JSON_SCHEMA_VERSION,
-  CLI_RUNS_COMMANDS,
-  CLI_SESSIONS_COMMANDS,
-  CLI_STATE_COMMANDS,
   CliCredentials,
-  CliOciRuntimeAdapter,
-  CliUsageError,
   ConsoleInput,
   CredentialSetupError,
   DEFAULT_HARNESS_CONTEXT_MANIFEST,
-  FileChangedWhileReadingError,
-  FileSizeLimitError,
-  HARNESS_OPERATIONS_SCHEMA_VERSION,
   HARNESS_RESUME_METADATA_KEY,
   HARNESS_RESUME_METADATA_SCHEMA_VERSION,
-  HARNESS_SESSION_SCHEMA_VERSION,
-  HARNESS_SQLITE_FILE,
   MAX_HARNESS_CONTEXT_FILE_BYTES,
   MAX_HARNESS_CONTEXT_TOTAL_BYTES,
-  SqliteDatabase,
-  TASK_ACCEPTANCE_EVIDENCE_KEY,
-  TASK_SOURCE_KEY,
-  USAGE_LEDGER_KEY,
-  UnsafeFileTypeError,
-  Workspace,
   annotateCliStreamError,
   appendUserMessage,
-  applyCliProfile,
-  approvalDecisionViews,
   approvalResponses,
   assertRoutePricingIsSafe,
-  assertTaskBudgetBackupLinks,
-  cancelHarnessRun,
-  canonicalizeChangeEnvelope,
-  changeEnvelopePreconditionsSchema,
-  changeEnvelopeSchema,
   chooseReasoning,
-  cleanupHarnessExecutionArtifacts,
-  cleanupHarnessRuns,
   cliStreamErrorSequence,
   compactHarnessMessages,
-  createChangeEnvelope,
-  createCliProfile,
   createConfiguredHarness,
   createHarness,
   createHarnessResumeMetadata,
-  createHarnessRouteModels,
   credentialModel,
   decodeProjectMemory,
-  digestChangeEnvelopeArtifact,
   estimateMessages,
-  fileDigestSchema,
   flushToolActivity,
   formatAppliedFiles,
   formatConsoleHelp,
   formatConsoleWelcome,
-  formatUsageLedger,
   formatVerificationSummary,
   harnessConfigInput,
-  harnessPolicyDecisionEventSchema,
-  harnessToolExecution,
   inspectCliPolicy,
-  inspectHarnessRun,
-  inspectRuntimeDiagnostics,
-  inspectRuntimeManifest,
-  inspectUsageLedger,
   issueAutomaticApprovalResponses,
   issueObservedApprovalResponses,
-  listHarnessRuns,
-  loadCliProfile,
   loadHarnessMcpConfiguration,
   loadHarnessProjectContext,
   loadModelCatalog,
   navigateConsole,
   observeCliPolicy,
-  openCliSessionStore,
-  openHarnessActivityStore,
-  openHarnessPersistence,
   openHarnessProjectMemory,
   openWorkspaceCheckpointStore,
   orchestrationObserver,
-  parseCliArgs,
-  parseHarnessModelRoute,
   persistedCliOptions,
   printTerminalResult,
   projectMemoryRecordKey,
-  publishPendingPolicyDecision,
   readHarnessResumeConfig,
   readHarnessResumeRoutes,
-  readRegularFileChunksNoFollow,
-  readRegularFileNoFollow,
-  readTaskAcceptanceLedger,
   requiresExplicitHostReview,
-  resolveCliDefaults,
-  resolveHarnessModelRoutes,
-  resolvePackageManager,
   resolvedRouting,
   resumeCommand,
   runHarness,
   runHarnessReviewGroup,
-  runPortableProcess,
   runResultDocument,
   sanitizeTerminalText,
-  serializeHarnessModelRoutes,
-  sqliteAdapter,
   streamSink,
   summarizeApproval,
-  taskCheckReceiptSchema,
-  taskSources,
   terminalApprovalResolver,
   terminalContinuationMessages,
   terminalErrorMessage,
   terminalRunFailure,
   terminalSupportsColor,
-  updateCliProfile,
-  validateStateDirectory,
-  verifyChangeEnvelope,
   withTemporaryHarnessProfiles,
   workspaceCheckpointSchema,
   workspaceRestoreOperationSchema
-} from "./cli-entry-4ngptr62.js";
+} from "./cli-entry-a890x3kq.js";
+import {
+  exportHarnessGovernanceReport,
+  renderHarnessGovernanceMarkdown
+} from "./cli-entry-rgs6bxmy.js";
+import {
+  CLI_CHANGES_COMMANDS,
+  CLI_COMMANDS,
+  CLI_JSON_SCHEMA_VERSION,
+  CLI_RUNS_COMMANDS,
+  CLI_SESSIONS_COMMANDS,
+  CLI_STATE_COMMANDS,
+  CliOciRuntimeAdapter,
+  CliUsageError,
+  FileChangedWhileReadingError,
+  FileSizeLimitError,
+  HARNESS_OPERATIONS_SCHEMA_VERSION,
+  HARNESS_SESSION_SCHEMA_VERSION,
+  HARNESS_SQLITE_FILE,
+  SqliteDatabase,
+  TASK_SOURCE_KEY,
+  USAGE_LEDGER_KEY,
+  UnsafeFileTypeError,
+  Workspace,
+  applyCliProfile,
+  assertTaskBudgetBackupLinks,
+  cancelHarnessRun,
+  canonicalizeChangeEnvelope,
+  changeEnvelopePreconditionsSchema,
+  cleanupHarnessExecutionArtifacts,
+  cleanupHarnessRuns,
+  createChangeEnvelope,
+  createCliProfile,
+  createHarnessRouteModels,
+  digestChangeEnvelopeArtifact,
+  fileDigestSchema,
+  formatUsageLedger,
+  harnessToolExecution,
+  inspectHarnessRun,
+  inspectRuntimeDiagnostics,
+  inspectUsageLedger,
+  listHarnessRuns,
+  loadCliProfile,
+  openCliSessionStore,
+  openHarnessActivityStore,
+  openHarnessPersistence,
+  parseCliArgs,
+  parseHarnessModelRoute,
+  publishPendingPolicyDecision,
+  readRegularFileChunksNoFollow,
+  readRegularFileNoFollow,
+  resolveCliDefaults,
+  resolveHarnessModelRoutes,
+  resolvePackageManager,
+  runPortableProcess,
+  serializeHarnessModelRoutes,
+  sqliteAdapter,
+  taskSources,
+  updateCliProfile,
+  validateStateDirectory,
+  verifyChangeEnvelope
+} from "./cli-entry-7f0cen32.js";
 import {
   BUN_ENGINE_RANGE,
   HARNESS_VERSION,
   NODE_ENGINE_RANGE,
   formatCliHelp,
   shortCliHelp
-} from "./cli-entry-w0hterjs.js";
+} from "./cli-entry-3s63zn4w.js";
 import {
   DEFAULT_PROVIDER_REGISTRY,
   HARNESS_SUBAGENT_PROFILES,
@@ -147,7 +145,7 @@ import {
   providerDescriptor,
   reasoningEffortSchema,
   resolveHarnessConfig
-} from "./cli-entry-20w6nh0k.js";
+} from "./cli-entry-hdtfef27.js";
 import {
   __require
 } from "./cli-entry-1bx83sw4.js";
@@ -237,7 +235,7 @@ var initializeCli = async (options, context = {}) => {
   process.stdout.write([
     `${options.updateProfile ? "Updated" : "Created"} personal profile ${profileName} at ${created.path}.`,
     `Provider: ${created.profile.provider} · Model: ${created.profile.model} · Reasoning: ${created.profile.reasoningEffort ?? "default"}`,
-    provider === "vertex" ? "Vertex uses host ADC. Set GOOGLE_CLOUD_PROJECT and VERTEX_LOCATION; route presence does not verify credentials or model access." : availability?.configured ? "Provider credential detected; no secret value was stored or printed." : `Open zhx to configure a managed key, or set ${availability?.credentialNames.join(" or ") || "the provider credential"} for automation.`,
+    provider === "vertex" ? "Vertex uses host ADC. Set GOOGLE_CLOUD_PROJECT and VERTEX_LOCATION; route presence does not verify credentials or model access." : provider === "bedrock" ? "Bedrock Converse uses the AWS credential chain and AWS_REGION or AWS_DEFAULT_REGION. BEDROCK_RUNTIME=openai also needs an https BEDROCK_OPENAI_BASE_URL and BEDROCK_API_KEY or AWS_BEARER_TOKEN_BEDROCK. Route presence does not verify credentials or model access." : provider === "azure-openai" ? "Azure OpenAI needs an https AZURE_OPENAI_ENDPOINT and AZURE_OPENAI_API_KEY. Optional AZURE_OPENAI_API_VERSION and AZURE_OPENAI_DEPLOYMENTS stay in the environment. Route presence does not verify account access." : availability?.configured ? "Provider credential detected; no secret value was stored or printed." : `Open zhx to configure a managed key, or set ${availability?.credentialNames.join(" or ") || "the provider credential"} for automation.`,
     "Next:",
     `  ${doctorCommand}`,
     `  ${runCommand}`,
@@ -247,6 +245,31 @@ var initializeCli = async (options, context = {}) => {
 `);
   return true;
 };
+var providerStatus = (provider, env = process.env) => {
+  if (provider.id === "vertex")
+    return provider.configured ? "route configured; ADC not checked" : "missing GOOGLE_CLOUD_PROJECT/VERTEX_LOCATION";
+  if (provider.id === "bedrock") {
+    if (provider.configuration.runtimeValid === false)
+      return "invalid BEDROCK_RUNTIME";
+    if (provider.configured)
+      return "route configured; AWS credentials not checked";
+    if (env.BEDROCK_RUNTIME?.trim() === "openai")
+      return "missing BEDROCK_API_KEY/AWS_BEARER_TOKEN_BEDROCK or https BEDROCK_OPENAI_BASE_URL";
+    return "missing AWS_REGION/AWS_DEFAULT_REGION";
+  }
+  if (provider.id === "azure-openai") {
+    if (!provider.configuration.customEndpoint)
+      return "missing AZURE_OPENAI_ENDPOINT";
+    if (!provider.configuration.endpointValid || !provider.configuration.endpointSecure)
+      return "invalid AZURE_OPENAI_ENDPOINT";
+    if (!provider.credentials.some((credential) => credential.present))
+      return "missing AZURE_OPENAI_API_KEY";
+    if (!provider.configured)
+      return "invalid AZURE_OPENAI_API_VERSION or AZURE_OPENAI_DEPLOYMENTS";
+    return "configured; account access not checked";
+  }
+  return provider.configured ? "configured" : `missing ${provider.credentialNames.join("/")}`;
+};
 var listProviders = (json) => {
   const document = providersDocument();
   if (json) {
@@ -255,7 +278,7 @@ var listProviders = (json) => {
     return;
   }
   for (const provider of document.providers) {
-    process.stdout.write(`${provider.id.padEnd(7)} ${provider.defaultModel.padEnd(22)} ${provider.support.padEnd(11)} ${provider.id === "vertex" ? provider.configured ? "route configured; ADC not checked" : "missing GOOGLE_CLOUD_PROJECT/VERTEX_LOCATION" : provider.configured ? "configured" : `missing ${provider.credentialNames.join("/")}`}
+    process.stdout.write(`${provider.id.padEnd(13)} ${provider.defaultModel.padEnd(28)} ${provider.support.padEnd(11)} ${providerStatus(provider)}
 `);
   }
 };
@@ -299,6 +322,8 @@ Advanced operations and automation:
   zhx state status
   zhx state export <backup.json>
   zhx state import <backup.json> [--apply]
+  zhx export-audit <task-id> --out <directory>
+  zhx verify-audit --out <directory>
 
 The long command zhivex-harness remains supported for compatibility.
 
@@ -378,6 +403,8 @@ Options (automation and advanced configuration):
   --cascade                      Cancel a run and its known child runs
   --final                        Record terminal cancellation immediately
   --apply                        Apply a validated state import (default: dry-run)
+  --out <directory>              Audit pack directory (export-audit, verify-audit)
+  --signing-key-file <path>      HMAC key file for an audit pack
   -h, --help                     Show this help
   -v, --version                  Show the version
 
@@ -758,6 +785,32 @@ var inspectProjectContext = async (config) => {
     });
   }
 };
+var bedrockDoctorMessage = (provider, configured, env) => {
+  if (provider.configuration.runtimeValid === false)
+    return "BEDROCK_RUNTIME must be converse or openai.";
+  if (provider.configuration.customEndpoint && (!provider.configuration.endpointValid || !provider.configuration.endpointSecure)) {
+    return "BEDROCK_OPENAI_BASE_URL must be an https URL without credentials.";
+  }
+  if (configured)
+    return "Amazon Bedrock route configured; AWS credentials and model access have not been checked. Live support is provisional.";
+  if (env.BEDROCK_RUNTIME?.trim() === "openai") {
+    return "Bedrock OpenAI-compatible runtime requires BEDROCK_API_KEY or AWS_BEARER_TOKEN_BEDROCK and an https BEDROCK_OPENAI_BASE_URL.";
+  }
+  return "Bedrock Converse requires a valid AWS_REGION or AWS_DEFAULT_REGION. No API key is stored for the AWS credential chain.";
+};
+var azureDoctorMessage = (provider, configured, credential) => {
+  if (!provider.configuration.customEndpoint)
+    return "Azure OpenAI requires AZURE_OPENAI_ENDPOINT.";
+  if (!provider.configuration.endpointValid || !provider.configuration.endpointSecure) {
+    return "AZURE_OPENAI_ENDPOINT must be an https URL without credentials or a query.";
+  }
+  if (!configured && (provider.credentials.some((item) => item.present) || credential?.configured)) {
+    return "AZURE_OPENAI_API_VERSION or AZURE_OPENAI_DEPLOYMENTS is invalid.";
+  }
+  if (!configured)
+    return "Azure OpenAI credential is missing. Set AZURE_OPENAI_API_KEY. Account access is not checked.";
+  return "Azure OpenAI route configured; account access has not been checked. Live support is provisional.";
+};
 var createDoctorReport = async (options = {}, context = {}) => {
   const env = context.env ?? process.env;
   const config = resolveHarnessConfig({
@@ -824,12 +877,13 @@ var createDoctorReport = async (options = {}, context = {}) => {
   checks.push(await inspectExecutionEnvironment(config.execution, context.ociRuntimeAdapter));
   for (const provider of providers) {
     const invalidRegion = provider.id === "qwen" && provider.configuration.regionValid === false;
-    const invalidEndpoint = !provider.configuration.endpointValid;
+    const invalidRuntime = provider.id === "bedrock" && provider.configuration.runtimeValid === false;
+    const invalidEndpoint = !provider.configuration.endpointValid || (provider.id === "bedrock" || provider.id === "azure-openai") && provider.configuration.customEndpoint && !provider.configuration.endpointSecure;
     const selected = provider.id === selectedProvider?.id;
     const credential = selected ? context.credentialStatus : undefined;
     const configured = credential?.configured ?? provider.configured;
-    const status = invalidRegion || invalidEndpoint || !configured ? selected ? "fail" : "warn" : provider.support === "provisional" ? "warn" : "pass";
-    const message = provider.id === "vertex" ? configured ? "Vertex project/location configured; host ADC and model access have not been checked. Live support is provisional." : "Vertex requires GOOGLE_CLOUD_PROJECT and VERTEX_LOCATION plus host Application Default Credentials. No API key is stored by zhx." : invalidEndpoint ? `${provider.name} custom endpoint configuration is invalid.` : invalidRegion ? "Qwen region configuration is invalid." : credential ? credential.configured ? `${provider.name} credential present (${credential.source}); account access has not been checked.${provider.support === "provisional" ? " Live support is provisional." : ""}` : credential.source === "blocked" ? `${provider.name} managed credentials require the default endpoint. Remove endpoint overrides or provide an environment key.` : `${provider.name} credential ${credential.source === "unavailable" ? "could not be checked: keychain unavailable or locked" : "is missing"}. Run zhx to configure a key, or set ${provider.credentialNames.join(" or ")} for automation.` : provider.configured ? provider.support === "provisional" ? `${provider.name} credentials are present, but live support is provisional.` : `${provider.name} credentials are present.` : `${provider.name} credentials are missing. Set ${provider.credentialNames.join(" or ")} in the environment and rerun zhx doctor.`;
+    const status = invalidRegion || invalidRuntime || invalidEndpoint || !configured ? selected ? "fail" : "warn" : provider.support === "provisional" ? "warn" : "pass";
+    const message = provider.id === "vertex" ? configured ? "Vertex project/location configured; host ADC and model access have not been checked. Live support is provisional." : "Vertex requires GOOGLE_CLOUD_PROJECT and VERTEX_LOCATION plus host Application Default Credentials. No API key is stored by zhx." : provider.id === "bedrock" ? bedrockDoctorMessage(provider, configured, env) : provider.id === "azure-openai" ? azureDoctorMessage(provider, configured, credential) : invalidEndpoint ? `${provider.name} custom endpoint configuration is invalid.` : invalidRegion ? "Qwen region configuration is invalid." : credential ? credential.configured ? `${provider.name} credential present (${credential.source}); account access has not been checked.${provider.support === "provisional" ? " Live support is provisional." : ""}` : credential.source === "blocked" ? `${provider.name} managed credentials require the default endpoint. Remove endpoint overrides or provide an environment key.` : `${provider.name} credential ${credential.source === "unavailable" ? "could not be checked: keychain unavailable or locked" : "is missing"}. Run zhx to configure a key, or set ${provider.credentialNames.join(" or ")} for automation.` : provider.configured ? provider.support === "provisional" ? `${provider.name} credentials are present, but live support is provisional.` : `${provider.name} credentials are present.` : `${provider.name} credentials are missing. Set ${provider.credentialNames.join(" or ")} in the environment and rerun zhx doctor.`;
     checks.push(diagnostic(`provider:${provider.id}`, status, message, {
       provider: provider.id,
       selected,
@@ -845,6 +899,17 @@ var createDoctorReport = async (options = {}, context = {}) => {
         regionConfigured: provider.configuration.regionConfigured,
         regionValid: provider.configuration.regionValid,
         workspaceIdConfigured: provider.configuration.workspaceIdConfigured
+      } : {},
+      ...provider.id === "bedrock" ? {
+        runtimeConfigured: provider.configuration.runtimeConfigured === true,
+        runtimeValid: provider.configuration.runtimeValid !== false,
+        regionConfigured: provider.configuration.regionConfigured === true,
+        defaultRegionConfigured: provider.configuration.defaultRegionConfigured === true,
+        profileConfigured: provider.configuration.profileConfigured === true
+      } : {},
+      ...provider.id === "azure-openai" ? {
+        apiVersionConfigured: provider.configuration.apiVersionConfigured === true,
+        deploymentsConfigured: provider.configuration.deploymentsConfigured === true
       } : {}
     }));
   }
@@ -1383,7 +1448,7 @@ async function handleConsoleCompaction(command, deps) {
   const provider = value.slice(0, separator);
   const model = value.slice(separator + 1);
   if (separator < 1 || !PROVIDERS.includes(provider) || !/^[a-zA-Z0-9][a-zA-Z0-9._:/-]{0,159}$/.test(model)) {
-    write("Use /compaction provider:model with openai, qwen, gemini, meta, anthropic or vertex; /compaction off disables model-assisted compaction.");
+    write(`Use /compaction provider:model with ${PROVIDERS.slice(0, -1).join(", ")} or ${PROVIDERS.at(-1)}; /compaction off disables model-assisted compaction.`);
     return true;
   }
   await deps.replaceOptions({ ...deps.options, compactionProvider: provider, compactionModel: model });
@@ -2493,474 +2558,6 @@ ${summarizeApproval(approval)}
 
 // src/cli/governance-report.ts
 import path2 from "node:path";
-
-// src/persistence/governance-report.ts
-import { createHash as createHash3 } from "node:crypto";
-import { z as z2 } from "zod";
-
-// src/persistence/governance-context.ts
-import { createHash as createHash2 } from "node:crypto";
-import { z } from "zod";
-var digest = z.string().regex(/^sha256:[a-f0-9]{64}$/);
-var count = z.number().int().nonnegative().safe();
-var governanceReference = (kind, value) => "sha256:" + createHash2("sha256").update(JSON.stringify([kind, value])).digest("hex");
-var governanceSessionSchema = z.strictObject({ availability: z.enum(["recorded", "unavailable"]), reference: digest.nullable(), revision: count.nullable() });
-var governanceHistorySchema = z.strictObject({
-  availability: z.enum(["recorded", "unavailable"]),
-  retention: z.enum(["unknown", "retained", "expired"]),
-  incomplete: z.boolean(),
-  policyDecisions: z.array(z.strictObject({
-    runReference: digest,
-    sequence: count,
-    toolReference: digest,
-    phase: z.enum(["approval-request", "tool-entry"]),
-    decision: z.enum(["allow", "ask_user", "deny"]),
-    policyDigest: digest.nullable(),
-    source: z.enum(["operator-file", "application", "baseline"]),
-    ruleReferences: z.array(digest).max(128),
-    explicitReviewRequired: z.boolean()
-  })).max(512)
-});
-var governanceEnvelopeSchema = z.strictObject({
-  source: z.literal("caller-supplied"),
-  envelopeId: digest.nullable(),
-  patchReference: digest.nullable(),
-  patchDigest: digest.nullable(),
-  linkedRunReferences: z.array(digest).max(64),
-  schemaValid: z.boolean(),
-  integrity: z.enum(["valid", "invalid"]),
-  expiration: z.enum(["unknown", "current", "expired", "not-yet-valid"]),
-  checkedAt: z.iso.datetime(),
-  expiredApprovals: count,
-  authenticity: z.literal("not-verified"),
-  patchBytes: z.literal("not-verified")
-});
-async function readGovernanceSession(source, rootRunId, runIds) {
-  const session = { availability: "unavailable", reference: null, revision: null };
-  const history = { availability: "unavailable", retention: "unknown", incomplete: true, policyDecisions: [] };
-  if (!source)
-    return { session, history, verify: async () => {} };
-  const initial = await source.index.get(source.id);
-  if (!initial || initial.sessionId !== source.id || !initial.runs.some((run) => run.runId === rootRunId))
-    throw new Error("GOVERNANCE_SESSION_MISMATCH");
-  const captured = JSON.stringify(initial);
-  session.availability = "recorded";
-  session.reference = governanceReference("session", initial.sessionId);
-  session.revision = initial.revision;
-  const pages = [];
-  if (source.history) {
-    let cursor = 0;
-    history.availability = "recorded";
-    history.retention = "retained";
-    history.incomplete = false;
-    for (let pageIndex = 0;pageIndex < 50; pageIndex++) {
-      const page = source.history.replay(source.id, cursor);
-      pages.push({ cursor, digest: governanceReference("history-page", JSON.stringify(page)) });
-      if (page.schemaVersion !== 1 || !Number.isSafeInteger(page.nextCursor) || page.nextCursor < cursor || page.events.length > 200)
-        throw new Error("GOVERNANCE_HISTORY_INVALID");
-      if (page.cursorExpired || page.policyEvidenceIncomplete) {
-        history.retention = "expired";
-        history.incomplete = true;
-      }
-      let lastSequence = cursor;
-      for (const event of page.events) {
-        if (event.sessionId !== source.id || !Number.isSafeInteger(event.sequence) || event.sequence <= lastSequence || event.sequence > page.nextCursor)
-          throw new Error("GOVERNANCE_HISTORY_INVALID");
-        lastSequence = event.sequence;
-        if (!runIds.has(event.runId) || event.activity.type !== "policy-decision")
-          continue;
-        const parsed = harnessPolicyDecisionEventSchema.safeParse(event.activity);
-        if (!parsed.success) {
-          history.incomplete = true;
-          continue;
-        }
-        if (history.policyDecisions.length === 512) {
-          history.incomplete = true;
-          continue;
-        }
-        const value = parsed.data;
-        history.policyDecisions.push({
-          runReference: governanceReference("run", event.runId),
-          sequence: event.sequence,
-          toolReference: governanceReference("tool", value.toolName),
-          phase: value.phase,
-          decision: value.decision,
-          policyDigest: value.policyDigest,
-          source: value.source,
-          ruleReferences: value.ruleIds.map((rule) => governanceReference("rule", rule)),
-          explicitReviewRequired: value.explicitReviewRequired
-        });
-      }
-      if (page.cursorExpired || !page.hasMore)
-        break;
-      if (page.nextCursor === cursor)
-        throw new Error("GOVERNANCE_HISTORY_INVALID");
-      cursor = page.nextCursor;
-      if (pageIndex === 49)
-        history.incomplete = true;
-    }
-  }
-  return { session, history, verify: async () => {
-    for (const page of pages)
-      if (governanceReference("history-page", JSON.stringify(source.history.replay(source.id, page.cursor))) !== page.digest)
-        throw new Error("GOVERNANCE_STATE_CHANGED");
-    if (JSON.stringify(await source.index.get(source.id)) !== captured)
-      throw new Error("GOVERNANCE_STATE_CHANGED");
-  } };
-}
-function projectGovernanceEnvelopes(envelopes, patches, now) {
-  if (envelopes.length > 32)
-    throw new Error("GOVERNANCE_ENVELOPE_LIMIT");
-  return envelopes.map((input) => {
-    if (Buffer.byteLength(JSON.stringify(input) ?? "") > 256 * 1024)
-      throw new Error("GOVERNANCE_ENVELOPE_LIMIT");
-    const parsed = changeEnvelopeSchema.safeParse(input);
-    const proof = verifyChangeEnvelope(input, { now });
-    const envelope = parsed.success ? parsed.data : undefined;
-    return governanceEnvelopeSchema.parse({
-      source: "caller-supplied",
-      envelopeId: envelope?.envelopeId ?? null,
-      patchReference: envelope ? governanceReference("patch", envelope.patch.patchId) : null,
-      patchDigest: envelope?.patch.patchDigest ?? null,
-      linkedRunReferences: envelope ? [...patches.get(envelope.patch.patchId) ?? []] : [],
-      schemaValid: parsed.success,
-      integrity: proof.integrity.envelopeDigestValid && proof.integrity.evidenceDigestValid ? "valid" : "invalid",
-      expiration: !envelope ? "unknown" : proof.expiration.envelopeNotYetValid ? "not-yet-valid" : proof.expiration.envelopeExpired ? "expired" : "current",
-      checkedAt: proof.expiration.checkedAt,
-      expiredApprovals: proof.expiration.expiredApprovalIds.length,
-      authenticity: "not-verified",
-      patchBytes: "not-verified"
-    });
-  });
-}
-
-// src/persistence/governance-report.ts
-var digest2 = z2.string().regex(/^sha256:[a-f0-9]{64}$/);
-var version = z2.string().regex(/^\d+\.\d+\.\d+(?:[-+][a-zA-Z0-9.-]+)?$/);
-var bindingSchema = z2.object({ schemaVersion: z2.literal(1), id: z2.literal("zhivex-harness"), version, fingerprint: digest2, algorithm: z2.literal("sha256") });
-var count2 = z2.number().int().nonnegative().safe();
-var status = z2.enum(["created", "running", "waiting_approval", "cancel_requested", "completed", "failed", "cancelled", "timed_out", "unknown"]);
-var availability = z2.enum(["recorded", "unavailable", "invalid"]);
-var providerReason = z2.enum(["empty_arguments", "invalid_json", "arguments_too_large", "incomplete_arguments", "inconsistent_metadata", "response_failed", "response_incomplete", "stream_truncated"]);
-var deliveryReason = z2.enum(["TASK_ACCEPTANCE_NO_DELIVERY_EVIDENCE", "TASK_ACCEPTANCE_SCOPE_VIOLATION", "TASK_ACCEPTANCE_RUN_NOT_COMPLETED", "TASK_ACCEPTANCE_RUN_NOT_FINISHED", "TASK_ACCEPTANCE_IMPORT_UNCONFIRMED", "TASK_ACCEPTANCE_CHECKS_MISSING", "TASK_ACCEPTANCE_DELIVERY_DRIFT", "TASK_ACCEPTANCE_DELIVERY_INSPECTION_FAILED", "TASK_ACCEPTANCE_HUMAN_REVIEW_REQUIRED", "TASK_ACCEPTANCE_VERIFIED"]);
-var deliveryStatus = z2.enum(["pending", "incomplete", "failed", "pending_review", "verified", "unknown"]);
-var checkSchema = z2.strictObject({
-  reference: digest2,
-  argvDigest: digest2,
-  patchId: digest2,
-  snapshotDigest: digest2,
-  exitCode: z2.number().int(),
-  timedOut: z2.boolean(),
-  unchanged: z2.boolean()
-});
-var deliverySchema = z2.object({
-  schemaVersion: z2.literal(1),
-  contractRevision: count2,
-  contractDigest: digest2,
-  status: deliveryStatus,
-  checks: z2.array(taskCheckReceiptSchema).max(32),
-  delivery: z2.object({ runId: z2.string().max(512), executionIdentity: z2.string().max(512), patchId: digest2, snapshotDigest: digest2 }).optional()
-});
-var approvalSchema = z2.strictObject({
-  reference: digest2,
-  toolReference: digest2,
-  approved: z2.boolean(),
-  origin: z2.enum(["interactive", "automatic", "application", "unknown"]),
-  channelReference: digest2,
-  policyDigest: digest2.nullable(),
-  status: z2.enum(["rejected", "approved", "applied", "succeeded", "failed", "unknown"]),
-  proposalId: digest2.nullable(),
-  exitCode: z2.number().int().nullable(),
-  timedOut: z2.boolean().nullable(),
-  effects: z2.array(z2.strictObject({ pathReference: digest2, beforeDigest: digest2.nullable(), afterDigest: digest2.nullable() })).max(50)
-});
-var delegationReason = z2.enum(["valid", "invalid_json", "invalid_schema", "task_mismatch", "incomplete", "duplicate_claim", "path_denied", "evidence_missing", "coverage_missing", "missing_child", "child_identity_unavailable"]);
-var delegationSchema = z2.strictObject({
-  taskReference: digest2,
-  childReference: digest2.nullable(),
-  recordedAcceptance: z2.boolean(),
-  reason: delegationReason,
-  semanticReview: z2.enum(["pending", "not_requested"]),
-  correctionsUsed: count2.nullable()
-});
-var delegationInput = z2.object({ schemaVersion: z2.literal(1), evaluations: z2.array(z2.object({
-  taskId: z2.string().max(128),
-  childRunId: z2.string().max(512).nullable(),
-  childStatus: z2.string().max(32),
-  accepted: z2.boolean(),
-  reason: delegationReason,
-  semanticReview: z2.enum(["pending", "not_requested"]),
-  correctionsUsed: count2.optional()
-})).max(64) });
-var runSchema = z2.strictObject({
-  reference: digest2,
-  parentReference: digest2.nullable(),
-  revision: count2.nullable(),
-  status,
-  finalized: z2.boolean(),
-  failure: z2.enum(["run_failed", "cancelled", "timed_out", "not_reported"]).nullable(),
-  failureDetails: z2.strictObject({ providerToolReason: providerReason.nullable(), diagnosticReference: digest2.nullable(), deliveryReason: deliveryReason.nullable() }),
-  identity: z2.literal("not-verified"),
-  runtimePolicy: z2.enum(["assistant-v3-durable-closure"]).nullable(),
-  contract: z2.strictObject({
-    availability,
-    digest: digest2.nullable(),
-    revision: count2.nullable(),
-    requiredChecks: count2.nullable(),
-    humanReviewsPending: count2.nullable(),
-    allowedWritePathReferences: z2.array(digest2).max(256),
-    protectedPathReferences: z2.array(digest2).max(256),
-    checks: z2.array(z2.strictObject({ reference: digest2, argvDigest: digest2, kind: z2.enum(["argv", "package-script"]), backend: z2.enum(["none", "oci"]), approval: z2.literal("required") })).max(32),
-    humanReviewReferences: z2.array(digest2).max(32)
-  }),
-  delivery: z2.strictObject({
-    availability,
-    status: deliveryStatus,
-    patchId: digest2.nullable(),
-    snapshotDigest: digest2.nullable(),
-    interpretation: z2.literal("recorded-checkpoint-not-current-workspace-verification"),
-    checks: z2.array(checkSchema).max(32)
-  }),
-  approvals: z2.strictObject({ availability, items: z2.array(approvalSchema).max(512) }),
-  usage: z2.strictObject({
-    availability: z2.enum(["recorded", "unavailable"]),
-    calls: count2.nullable(),
-    inputTokens: count2.nullable(),
-    outputTokens: count2.nullable(),
-    complete: z2.boolean().nullable(),
-    estimatedUsd: z2.number().finite().nonnegative().nullable(),
-    costKind: z2.literal("estimate-not-invoice")
-  }),
-  journal: z2.strictObject({ availability: z2.enum(["recorded", "unavailable"]), entries: count2, failed: count2, unfinished: count2 }),
-  delegations: z2.strictObject({ availability, interpretation: z2.literal("recorded-checkpoint-not-semantic-review"), items: z2.array(delegationSchema).max(64) }),
-  children: z2.array(digest2).max(64)
-});
-var harnessGovernanceReportSchema = z2.strictObject({
-  schemaVersion: z2.literal(1),
-  kind: z2.literal("harness-governance-report"),
-  exporterVersion: z2.string().regex(/^\d+\.\d+\.\d+(?:[-+][a-zA-Z0-9.-]+)?$/),
-  executionArtifact: z2.strictObject({ version: version.nullable(), digest: z2.null(), availability: z2.enum(["recorded-version", "unavailable"]), configurationFingerprint: digest2.nullable(), authenticity: z2.literal("not-verified") }),
-  rootReference: digest2,
-  identity: z2.literal("not-verified"),
-  referencePolicy: z2.literal("sha256-domain-separated-pseudonyms-not-anonymity"),
-  session: governanceSessionSchema,
-  eventHistory: governanceHistorySchema,
-  changeEnvelopes: z2.array(governanceEnvelopeSchema).max(32),
-  runs: z2.array(runSchema).max(64),
-  missingChildren: z2.array(digest2).max(64),
-  limitations: z2.array(z2.enum(["tree_limit", "missing_child", "invalid_contract", "invalid_delivery", "invalid_approvals", "journal_unavailable"])).max(6)
-});
-var MAX_JOURNAL = 2048;
-var MAX_REPORT_BYTES = 2 * 1024 * 1024;
-var sameScope = (state, scope) => !state.scope || state.scope.tenantId === scope?.tenantId && state.scope.userId === scope?.userId && state.scope.namespace === scope?.namespace;
-function projectRun(state, journal, limitations) {
-  const runStatus = status.safeParse(state.status);
-  const stateStatus = runStatus.success ? runStatus.data : "unknown";
-  let ledger;
-  let contractAvailability = "unavailable";
-  try {
-    ledger = readTaskAcceptanceLedger(state);
-    if (ledger)
-      contractAvailability = "recorded";
-  } catch {
-    contractAvailability = "invalid";
-    limitations.add("invalid_contract");
-  }
-  const contract = ledger?.revisions.at(-1);
-  const rawDelivery = state.metadata?.[TASK_ACCEPTANCE_EVIDENCE_KEY];
-  const parsedDelivery = deliverySchema.safeParse(rawDelivery);
-  const bound = parsedDelivery.success && contract && parsedDelivery.data.contractDigest === contract.digest && parsedDelivery.data.contractRevision === contract.revision && (!parsedDelivery.data.delivery || parsedDelivery.data.delivery.runId === state.runId);
-  const candidate = bound ? parsedDelivery.data : undefined;
-  const verified = candidate?.status === "verified" || candidate?.status === "pending_review";
-  const validSuccess = !verified || stateStatus === "completed" && candidate.delivery && contract && contract.contract.requiredChecks.every((required) => candidate.checks.some((check) => check.checkId === required.id && check.runId === state.runId && check.argvDigest === "sha256:" + createHash3("sha256").update(JSON.stringify([required.command, ...required.args])).digest("hex") && check.contractDigest === contract.digest && check.contractRevision === contract.revision && check.exitCode === 0 && !check.timedOut && check.unchanged && check.patchId === candidate.delivery.patchId && check.snapshotDigest === candidate.delivery.snapshotDigest && check.executionIdentity === candidate.delivery.executionIdentity)) && candidate.status === "pending_review" === contract.contract.humanReview.length > 0;
-  const delivery = validSuccess ? candidate : undefined;
-  if (rawDelivery !== undefined && !delivery)
-    limitations.add("invalid_delivery");
-  const approvals = { availability: state.metadata?.[APPROVAL_HISTORY_KEY] === undefined ? "unavailable" : "recorded", items: [] };
-  try {
-    for (let offset = 0;offset < 512; offset += 25) {
-      const rows = approvalDecisionViews(state, journal ?? [], offset);
-      for (const row of rows)
-        approvals.items.push({
-          reference: governanceReference("approval", row.approvalId),
-          toolReference: governanceReference("tool", row.name),
-          approved: row.approved,
-          origin: row.provenance?.origin ?? "unknown",
-          channelReference: governanceReference("channel", row.provenance?.channel ?? "unknown"),
-          policyDigest: row.provenance?.policyDigest ?? null,
-          status: row.status,
-          proposalId: row.evidence?.proposalId ?? null,
-          exitCode: row.evidence?.exitCode ?? null,
-          timedOut: row.evidence?.timedOut ?? null,
-          effects: (row.evidence?.effects ?? []).map((effect) => ({ pathReference: governanceReference("path", effect.path), beforeDigest: effect.beforeDigest, afterDigest: effect.afterDigest }))
-        });
-      if (rows.length < 25)
-        break;
-    }
-  } catch {
-    approvals.availability = "invalid";
-    approvals.items = [];
-    limitations.add("invalid_approvals");
-  }
-  const parsedUsage = inspectUsageLedger(state.metadata?.[USAGE_LEDGER_KEY]);
-  const usage = parsedUsage?.runId === state.runId ? parsedUsage : null;
-  const rawDelegations = state.metadata?.zhivexDelegationAcceptanceV1;
-  const delegations = delegationInput.safeParse(rawDelegations);
-  const manifest = inspectRuntimeManifest(state.metadata?.effectiveRuntime);
-  return {
-    reference: governanceReference("run", state.runId),
-    parentReference: state.parentRunId ? governanceReference("run", state.parentRunId) : null,
-    revision: count2.safeParse(state.revision).success ? state.revision : null,
-    status: stateStatus,
-    finalized: ["completed", "failed", "cancelled", "timed_out"].includes(stateStatus),
-    failure: stateStatus === "failed" ? "run_failed" : stateStatus === "cancelled" ? "cancelled" : stateStatus === "timed_out" ? "timed_out" : state.error ? "not_reported" : null,
-    failureDetails: {
-      providerToolReason: providerReason.safeParse(state.error?.reason).success ? state.error.reason : null,
-      diagnosticReference: state.error?.diagnosticCode ? governanceReference("diagnostic", state.error.diagnosticCode) : null,
-      deliveryReason: deliveryReason.safeParse(rawDelivery && typeof rawDelivery === "object" && !Array.isArray(rawDelivery) ? rawDelivery.reason : undefined).success ? rawDelivery.reason : null
-    },
-    identity: "not-verified",
-    runtimePolicy: manifest?.policyVersion ?? null,
-    contract: {
-      availability: contractAvailability,
-      digest: contract?.digest ?? null,
-      revision: contract?.revision ?? null,
-      requiredChecks: contract?.contract.requiredChecks.length ?? null,
-      humanReviewsPending: contract?.contract.humanReview.length ?? null,
-      allowedWritePathReferences: contract?.contract.allowedWritePaths.map((file) => governanceReference("path", file)) ?? [],
-      protectedPathReferences: contract?.contract.protectedFiles.map((file) => governanceReference("path", file)) ?? [],
-      checks: contract?.contract.requiredChecks.map((check) => ({ reference: governanceReference("check", check.id), argvDigest: "sha256:" + createHash3("sha256").update(JSON.stringify([check.command, ...check.args])).digest("hex"), kind: check.kind, backend: check.execution.backend, approval: check.execution.approval })) ?? [],
-      humanReviewReferences: contract?.contract.humanReview.map((review) => governanceReference("review", review.id)) ?? []
-    },
-    delivery: {
-      availability: delivery ? "recorded" : rawDelivery === undefined ? "unavailable" : "invalid",
-      status: delivery?.status ?? "unknown",
-      patchId: delivery?.delivery?.patchId ?? null,
-      snapshotDigest: delivery?.delivery?.snapshotDigest ?? null,
-      interpretation: "recorded-checkpoint-not-current-workspace-verification",
-      checks: (delivery?.checks ?? []).filter((check) => check.runId === state.runId && check.contractDigest === contract?.digest && check.contractRevision === contract?.revision).map((check) => ({ reference: governanceReference("check", check.checkId), argvDigest: check.argvDigest, patchId: check.patchId, snapshotDigest: check.snapshotDigest, exitCode: check.exitCode, timedOut: check.timedOut, unchanged: check.unchanged }))
-    },
-    approvals,
-    usage: {
-      availability: usage ? "recorded" : "unavailable",
-      calls: usage?.calls ?? null,
-      inputTokens: usage?.inputTokens ?? null,
-      outputTokens: usage?.outputTokens ?? null,
-      complete: usage?.usageComplete ?? null,
-      estimatedUsd: usage?.estimatedUsd ?? null,
-      costKind: "estimate-not-invoice"
-    },
-    journal: {
-      availability: journal ? "recorded" : "unavailable",
-      entries: journal?.length ?? 0,
-      failed: journal?.filter((entry) => entry.status === "failed").length ?? 0,
-      unfinished: journal?.filter((entry) => entry.status !== "completed" && entry.status !== "failed").length ?? 0
-    },
-    delegations: {
-      availability: rawDelegations === undefined ? "unavailable" : delegations.success ? "recorded" : "invalid",
-      interpretation: "recorded-checkpoint-not-semantic-review",
-      items: delegations.success ? delegations.data.evaluations.map((item) => ({
-        taskReference: governanceReference("task", item.taskId),
-        childReference: item.childRunId ? governanceReference("run", item.childRunId) : null,
-        recordedAcceptance: item.accepted,
-        reason: item.reason,
-        semanticReview: item.semanticReview,
-        correctionsUsed: item.correctionsUsed ?? null
-      })) : []
-    },
-    children: (state.childRuns ?? []).slice(0, 64).map((child) => governanceReference("run", child.runId))
-  };
-}
-async function exportHarnessGovernanceReport(store, scope, runId, options = {}) {
-  const limitations = new Set;
-  const runs = [], missingChildren = [];
-  const observed = [];
-  const queue = [{ id: runId }], seen = new Set;
-  while (queue.length && runs.length + missingChildren.length < 64) {
-    const item = queue.shift();
-    if (seen.has(item.id))
-      continue;
-    seen.add(item.id);
-    const loaded = await store.load(item.id, scope);
-    const state = loaded ? structuredClone(loaded) : undefined;
-    if (!state || state.runId !== item.id || !sameScope(state, scope) || item.parent !== undefined && state.parentRunId !== item.parent) {
-      if (item.parent === undefined)
-        throw new Error("GOVERNANCE_RUN_UNAVAILABLE");
-      missingChildren.push(governanceReference("run", item.id));
-      limitations.add("missing_child");
-      continue;
-    }
-    const loadedJournal = await store.listToolCalls?.(state.runId, scope);
-    const journal = loadedJournal ? structuredClone(loadedJournal) : undefined;
-    if (journal && journal.length > MAX_JOURNAL)
-      throw new Error("GOVERNANCE_JOURNAL_LIMIT");
-    if (journal?.some((entry) => entry.runId !== state.runId))
-      throw new Error("GOVERNANCE_JOURNAL_SCOPE");
-    if (!journal)
-      limitations.add("journal_unavailable");
-    observed.push({ state, journal });
-    runs.push(projectRun(state, journal, limitations));
-    if ((state.childRuns?.length ?? 0) > 64)
-      limitations.add("tree_limit");
-    for (const child of (state.childRuns ?? []).slice(0, 64))
-      queue.push({ id: child.runId, parent: state.runId });
-  }
-  if (queue.length)
-    limitations.add("tree_limit");
-  const context = await readGovernanceSession(options.session, runId, new Set(observed.map((item) => item.state.runId)));
-  for (const { state, journal } of observed) {
-    const current = await store.load(state.runId, scope);
-    const currentJournal = await store.listToolCalls?.(state.runId, scope);
-    if (!current || JSON.stringify(current) !== JSON.stringify(state) || JSON.stringify(currentJournal) !== JSON.stringify(journal))
-      throw new Error("GOVERNANCE_STATE_CHANGED");
-  }
-  await context.verify();
-  const patches = new Map;
-  for (const run of runs)
-    for (const patch of new Set([run.delivery.patchId, ...run.approvals.items.map((row) => row.proposalId)].filter((id) => id !== null)))
-      patches.set(patch, [...patches.get(patch) ?? [], run.reference]);
-  const binding = bindingSchema.safeParse(observed[0]?.state.harness);
-  const report = harnessGovernanceReportSchema.parse({
-    schemaVersion: 1,
-    kind: "harness-governance-report",
-    exporterVersion: HARNESS_VERSION,
-    executionArtifact: { version: binding.success ? binding.data.version : null, digest: null, availability: binding.success ? "recorded-version" : "unavailable", configurationFingerprint: binding.success ? binding.data.fingerprint : null, authenticity: "not-verified" },
-    rootReference: governanceReference("run", runId),
-    identity: "not-verified",
-    referencePolicy: "sha256-domain-separated-pseudonyms-not-anonymity",
-    session: context.session,
-    eventHistory: context.history,
-    changeEnvelopes: projectGovernanceEnvelopes(options.changeEnvelopes ?? [], patches, options.now ?? Date.now()),
-    runs,
-    missingChildren,
-    limitations: [...limitations].sort()
-  });
-  if (Buffer.byteLength(JSON.stringify(report)) > MAX_REPORT_BYTES)
-    throw new Error("GOVERNANCE_REPORT_LIMIT");
-  return report;
-}
-function renderHarnessGovernanceMarkdown(input) {
-  const report = harnessGovernanceReportSchema.parse(input);
-  return [
-    "# Execution and governance report",
-    "",
-    `Schema: ${report.schemaVersion}. Exporter: ${report.exporterVersion}.`,
-    `Identity: not verified. Recorded execution version: ${report.executionArtifact.version ?? "unavailable"}. Artifact digest: unavailable. Hash references are pseudonyms, not signatures.`,
-    "Delivery describes a recorded checkpoint; export does not recheck the workspace.",
-    "",
-    "| Run reference | Execution | Recorded delivery | Usage |",
-    "| --- | --- | --- | --- |",
-    ...report.runs.map((run) => `| ${run.reference} | ${run.status} | ${run.delivery.status} | ${run.usage.availability === "unavailable" ? "unavailable" : `${run.usage.inputTokens} input / ${run.usage.outputTokens} output (${run.usage.complete ? "complete" : "incomplete"})`} |`),
-    "",
-    `Missing children: ${report.missingChildren.length}. Limitations: ${report.limitations.join(", ") || "none detected"}.`,
-    `Session: ${report.session.availability}. Event history: ${report.eventHistory.availability}. Retention: ${report.eventHistory.retention}. Incomplete: ${report.eventHistory.incomplete}.`,
-    `Change envelopes: ${report.changeEnvelopes.length}. Envelope integrity does not verify patch bytes or authenticity. Estimates are not invoices.`,
-    ""
-  ].join(`
-`);
-}
-
-// src/cli/governance-report.ts
 async function governanceReportCli(options, config, store) {
   let index;
   let history;
@@ -3415,17 +3012,17 @@ async function readBackupTransport(source, legacyMaxBytes) {
 }
 
 // src/persistence/state-backup.ts
-import { createHash as createHash5, randomUUID as randomUUID2 } from "node:crypto";
+import { createHash as createHash3, randomUUID as randomUUID2 } from "node:crypto";
 import { constants as fsConstants2 } from "node:fs";
 import { chmod, link, lstat as lstat2, open, realpath, unlink } from "node:fs/promises";
 import path4 from "node:path";
-import { z as z3 } from "zod";
+import { z } from "zod";
 import { normalizeAgentRunState } from "@zhivex-ai/agents";
 import { createSqliteAgentRunStore } from "@zhivex-ai/agents/ops";
 
 // src/persistence/sdk-store-identity.ts
-import { createHash as createHash4 } from "node:crypto";
-var sdkCanonicalKey = (kind, scope, value) => `${kind}:v2:${createHash4("sha256").update(JSON.stringify([
+import { createHash as createHash2 } from "node:crypto";
+var sdkCanonicalKey = (kind, scope, value) => `${kind}:v2:${createHash2("sha256").update(JSON.stringify([
   JSON.stringify([scope.namespace ?? null, scope.tenantId, scope.userId ?? null]),
   value
 ])).digest("hex")}`;
@@ -3437,128 +3034,128 @@ var HARNESS_STATE_BACKUP_SCHEMA_VERSION = 1;
 var HARNESS_STATE_BACKUP_MAX_BYTES = 64 * 1024 * 1024;
 var terminalRunStatuses = new Set(["completed", "failed", "cancelled", "timed_out"]);
 var terminalSessionStatuses = new Set(["completed", "failed", "cancelled", "timed_out"]);
-var digestSchema = z3.string().regex(/^sha256:[a-f0-9]{64}$/);
-var bindingKeySchema = z3.string().regex(/^[a-f0-9]{64}$/);
-var jsonRecordSchema = z3.record(z3.string(), z3.unknown());
-var durableScopeSchema = z3.object({
-  tenantId: z3.string().min(1),
-  userId: z3.string().min(1).optional(),
-  namespace: z3.string().min(1).optional()
+var digestSchema = z.string().regex(/^sha256:[a-f0-9]{64}$/);
+var bindingKeySchema = z.string().regex(/^[a-f0-9]{64}$/);
+var jsonRecordSchema = z.record(z.string(), z.unknown());
+var durableScopeSchema = z.object({
+  tenantId: z.string().min(1),
+  userId: z.string().min(1).optional(),
+  namespace: z.string().min(1).optional()
 }).strict();
-var journalEntrySchema = z3.object({
-  runId: z3.string().min(1),
+var journalEntrySchema = z.object({
+  runId: z.string().min(1),
   scope: durableScopeSchema,
-  toolCallId: z3.string().min(1),
-  toolName: z3.string().min(1),
-  status: z3.enum(["pending", "running", "completed", "failed"]),
-  idempotencyKey: z3.string().min(1),
-  revision: z3.number().int().nonnegative(),
-  input: z3.json().optional(),
-  output: z3.json().optional(),
-  error: z3.object({ message: z3.string() }).strict().optional(),
-  startedAt: z3.number().nonnegative().optional(),
-  completedAt: z3.number().nonnegative().optional(),
-  updatedAt: z3.number().nonnegative()
+  toolCallId: z.string().min(1),
+  toolName: z.string().min(1),
+  status: z.enum(["pending", "running", "completed", "failed"]),
+  idempotencyKey: z.string().min(1),
+  revision: z.number().int().nonnegative(),
+  input: z.json().optional(),
+  output: z.json().optional(),
+  error: z.object({ message: z.string() }).strict().optional(),
+  startedAt: z.number().nonnegative().optional(),
+  completedAt: z.number().nonnegative().optional(),
+  updatedAt: z.number().nonnegative()
 }).passthrough();
-var runRecordSchema = z3.object({
-  key: z3.string().min(1).max(1024),
+var runRecordSchema = z.object({
+  key: z.string().min(1).max(1024),
   state: jsonRecordSchema,
-  updatedAt: z3.number().int().nonnegative()
+  updatedAt: z.number().int().nonnegative()
 }).strict();
-var journalRecordSchema = z3.object({
-  runKey: z3.string().min(1).max(1024),
-  toolCallId: z3.string().min(1).max(1024),
+var journalRecordSchema = z.object({
+  runKey: z.string().min(1).max(1024),
+  toolCallId: z.string().min(1).max(1024),
   entry: journalEntrySchema,
-  revision: z3.number().int().nonnegative(),
-  updatedAt: z3.number().int().nonnegative()
+  revision: z.number().int().nonnegative(),
+  updatedAt: z.number().int().nonnegative()
 }).strict();
-var idempotencyRecordSchema = z3.object({
-  key: z3.string().min(1).max(1024),
-  runKey: z3.string().min(1).max(1024),
-  updatedAt: z3.number().int().nonnegative()
+var idempotencyRecordSchema = z.object({
+  key: z.string().min(1).max(1024),
+  runKey: z.string().min(1).max(1024),
+  updatedAt: z.number().int().nonnegative()
 }).strict();
-var parentRecordSchema = z3.object({
-  runKey: z3.string().min(1).max(1024),
-  parentRunKey: z3.string().min(1).max(1024),
-  updatedAt: z3.number().int().nonnegative()
+var parentRecordSchema = z.object({
+  runKey: z.string().min(1).max(1024),
+  parentRunKey: z.string().min(1).max(1024),
+  updatedAt: z.number().int().nonnegative()
 }).strict();
-var memoryRecordSchema = z3.object({
-  key: z3.string().min(1).max(1024),
-  messages: z3.array(z3.unknown()),
-  updatedAt: z3.number().int().nonnegative()
+var memoryRecordSchema = z.object({
+  key: z.string().min(1).max(1024),
+  messages: z.array(z.unknown()),
+  updatedAt: z.number().int().nonnegative()
 }).strict();
 var serializedMemory = (entry) => JSON.stringify(entry.key.startsWith("agent-memory:v2:") ? { schemaVersion: 1, memoryKey: entry.key, messages: entry.messages } : entry.messages);
 var memoryKeysForRuns = (config, runs) => new Set(runs.flatMap(({ state }) => [...new Set([state.runId, state.agentId].filter((id) => typeof id === "string"))].flatMap((id) => [sdkLegacyKey(config.scope, id), sdkCanonicalKey("agent-memory", config.scope, id)])));
-var sessionRecordSchema = z3.object({
-  sessionId: z3.string().min(1).max(260),
+var sessionRecordSchema = z.object({
+  sessionId: z.string().min(1).max(260),
   workspaceKey: bindingKeySchema,
   scopeKey: bindingKeySchema,
-  title: z3.string().nullable(),
-  parentSessionId: z3.string().nullable(),
-  forkedFromTurnId: z3.string().nullable(),
-  revision: z3.number().int().nonnegative(),
-  activitySequence: z3.number().int().nonnegative(),
-  createdAt: z3.number().int().nonnegative(),
-  updatedAt: z3.number().int().nonnegative(),
-  archivedAt: z3.number().int().nonnegative().nullable(),
-  deletedAt: z3.number().int().nonnegative().nullable(),
-  metadataBytes: z3.number().int().nonnegative()
+  title: z.string().nullable(),
+  parentSessionId: z.string().nullable(),
+  forkedFromTurnId: z.string().nullable(),
+  revision: z.number().int().nonnegative(),
+  activitySequence: z.number().int().nonnegative(),
+  createdAt: z.number().int().nonnegative(),
+  updatedAt: z.number().int().nonnegative(),
+  archivedAt: z.number().int().nonnegative().nullable(),
+  deletedAt: z.number().int().nonnegative().nullable(),
+  metadataBytes: z.number().int().nonnegative()
 }).strict();
-var sessionRunRecordSchema = z3.object({
-  turnId: z3.string().min(1).max(260),
-  sourceTurnId: z3.string().nullable(),
-  sessionId: z3.string().min(1).max(260),
-  ordinal: z3.number().int().nonnegative(),
-  runId: z3.string().min(1).max(260),
-  provider: z3.string().min(1).max(260),
-  model: z3.string().min(1).max(260),
-  role: z3.string().nullable(),
-  status: z3.string().min(1),
-  createdAt: z3.number().int().nonnegative(),
-  updatedAt: z3.number().int().nonnegative(),
-  completedAt: z3.number().int().nonnegative().nullable(),
-  metadataBytes: z3.number().int().nonnegative()
+var sessionRunRecordSchema = z.object({
+  turnId: z.string().min(1).max(260),
+  sourceTurnId: z.string().nullable(),
+  sessionId: z.string().min(1).max(260),
+  ordinal: z.number().int().nonnegative(),
+  runId: z.string().min(1).max(260),
+  provider: z.string().min(1).max(260),
+  model: z.string().min(1).max(260),
+  role: z.string().nullable(),
+  status: z.string().min(1),
+  createdAt: z.number().int().nonnegative(),
+  updatedAt: z.number().int().nonnegative(),
+  completedAt: z.number().int().nonnegative().nullable(),
+  metadataBytes: z.number().int().nonnegative()
 }).strict();
-var checkpointRecordSchema = z3.discriminatedUnion("kind", [
-  z3.object({
-    id: z3.string().uuid(),
+var checkpointRecordSchema = z.discriminatedUnion("kind", [
+  z.object({
+    id: z.string().uuid(),
     workspaceKey: bindingKeySchema,
     scopeKey: bindingKeySchema,
-    kind: z3.literal("checkpoint"),
+    kind: z.literal("checkpoint"),
     body: workspaceCheckpointSchema
   }).strict(),
-  z3.object({
-    id: z3.string().uuid(),
+  z.object({
+    id: z.string().uuid(),
     workspaceKey: bindingKeySchema,
     scopeKey: bindingKeySchema,
-    kind: z3.literal("restore"),
+    kind: z.literal("restore"),
     body: workspaceRestoreOperationSchema
   }).strict()
 ]);
 var checkpointTableSql = "CREATE TABLE IF NOT EXISTS zhivex_workspace_checkpoints (id TEXT PRIMARY KEY, workspace_key TEXT NOT NULL, scope_key TEXT NOT NULL, kind TEXT NOT NULL, body TEXT NOT NULL)";
-var stateBackupPayloadSchema = z3.object({
-  schemaVersion: z3.literal(HARNESS_STATE_BACKUP_SCHEMA_VERSION),
-  kind: z3.literal("state-backup"),
-  createdAt: z3.iso.datetime({ precision: 3 }),
-  binding: z3.object({
+var stateBackupPayloadSchema = z.object({
+  schemaVersion: z.literal(HARNESS_STATE_BACKUP_SCHEMA_VERSION),
+  kind: z.literal("state-backup"),
+  createdAt: z.iso.datetime({ precision: 3 }),
+  binding: z.object({
     workspaceKey: bindingKeySchema,
     scopeKey: bindingKeySchema,
-    scopePrefix: z3.string().min(1).max(1024)
+    scopePrefix: z.string().min(1).max(1024)
   }).strict(),
-  schemas: z3.object({
-    operations: z3.literal(HARNESS_OPERATIONS_SCHEMA_VERSION),
-    sessions: z3.literal(HARNESS_SESSION_SCHEMA_VERSION)
+  schemas: z.object({
+    operations: z.literal(HARNESS_OPERATIONS_SCHEMA_VERSION),
+    sessions: z.literal(HARNESS_SESSION_SCHEMA_VERSION)
   }).strict(),
-  records: z3.object({
-    runs: z3.array(runRecordSchema),
-    toolJournal: z3.array(journalRecordSchema),
-    idempotency: z3.array(idempotencyRecordSchema),
-    parents: z3.array(parentRecordSchema),
-    memory: z3.array(memoryRecordSchema),
-    sessions: z3.array(sessionRecordSchema),
-    sessionRuns: z3.array(sessionRunRecordSchema),
-    workspaceCheckpoints: z3.array(checkpointRecordSchema).max(100).optional(),
-    budgetLedgers: z3.array(runRecordSchema).optional()
+  records: z.object({
+    runs: z.array(runRecordSchema),
+    toolJournal: z.array(journalRecordSchema),
+    idempotency: z.array(idempotencyRecordSchema),
+    parents: z.array(parentRecordSchema),
+    memory: z.array(memoryRecordSchema),
+    sessions: z.array(sessionRecordSchema),
+    sessionRuns: z.array(sessionRunRecordSchema),
+    workspaceCheckpoints: z.array(checkpointRecordSchema).max(100).optional(),
+    budgetLedgers: z.array(runRecordSchema).optional()
   }).strict()
 }).strict();
 var stateBackupBundleSchema = stateBackupPayloadSchema.extend({ checksum: digestSchema }).strict();
@@ -3570,12 +3167,12 @@ var canonicalJson = (value) => {
   return `{${Object.entries(value).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0).map(([key, entry]) => `${JSON.stringify(key)}:${canonicalJson(entry)}`).join(",")}}`;
 };
 var checksumPayload = (payload) => {
-  const hash = createHash5("sha256");
+  const hash = createHash3("sha256");
   for (const chunk of canonicalChunks(payload))
     hash.update(chunk);
   return `sha256:${hash.digest("hex")}`;
 };
-var stableKey = (kind, value) => createHash5("sha256").update(kind).update("\x00").update(value).digest("hex");
+var stableKey = (kind, value) => createHash3("sha256").update(kind).update("\x00").update(value).digest("hex");
 var scopeValue = (config) => `${config.scope.tenantId}\x00${config.scope.userId ?? ""}\x00${config.scope.namespace ?? ""}`;
 var scopePrefix = (config) => `${encodeURIComponent(config.scope.namespace ?? "default")}:${encodeURIComponent(config.scope.tenantId)}:${encodeURIComponent(config.scope.userId ?? "*")}:`;
 var stateMatchesScope = (config, state) => {
@@ -3778,10 +3375,10 @@ var readPayload = async (config, recordedWorkspace, accessLease) => {
     const memory = database.query("SELECT memory_key, messages_json, updated_at_ms FROM zhivex_agent_memory ORDER BY memory_key").all().filter((row) => memoryKeys.has(row.memory_key)).map((row) => {
       const value = JSON.parse(row.messages_json);
       if (row.memory_key.startsWith("agent-memory:v2:")) {
-        const envelope = z3.strictObject({ schemaVersion: z3.literal(1), memoryKey: z3.literal(row.memory_key), messages: z3.array(z3.unknown()) }).parse(value);
+        const envelope = z.strictObject({ schemaVersion: z.literal(1), memoryKey: z.literal(row.memory_key), messages: z.array(z.unknown()) }).parse(value);
         return { key: row.memory_key, messages: envelope.messages, updatedAt: row.updated_at_ms };
       }
-      return { key: row.memory_key, messages: z3.array(z3.unknown()).parse(value), updatedAt: row.updated_at_ms };
+      return { key: row.memory_key, messages: z.array(z.unknown()).parse(value), updatedAt: row.updated_at_ms };
     });
     const sessionRows = database.query("SELECT * FROM zhivex_cli_sessions ORDER BY session_id").all().filter((row) => row.workspace_key === binding.workspaceKey && row.scope_key === binding.scopeKey);
     const selectedSessionIds = new Set(sessionRows.map((row) => row.session_id));
@@ -4066,7 +3663,7 @@ var validateBundleBinding = async (config, bundle) => {
     const turn = bundle.records.sessionRuns.find((run) => run.turnId === checkpoint.turnId && run.sessionId === checkpoint.sessionId);
     if (!turn || !terminalSessionStatuses.has(turn.status))
       throw new HarnessStateConflictError("Checkpoint targets a missing terminal turn.");
-    if (new Set(checkpoint.files.map((file) => file.path)).size !== checkpoint.files.length || checkpoint.files.some((file) => `sha256:${createHash5("sha256").update(file.content).digest("hex")}` !== file.digest || Buffer.byteLength(file.content) > 65536)) {
+    if (new Set(checkpoint.files.map((file) => file.path)).size !== checkpoint.files.length || checkpoint.files.some((file) => `sha256:${createHash3("sha256").update(file.content).digest("hex")}` !== file.digest || Buffer.byteLength(file.content) > 65536)) {
       throw new HarnessStateConflictError("Checkpoint content identity is invalid.");
     }
     if (record.kind === "restore") {
@@ -4488,7 +4085,7 @@ var main = async (argv = process.argv.slice(2)) => {
     parsedOptions = { ...parsedOptions, prompt: await readStdinTask() };
   }
   if (parsedOptions.serviceFile) {
-    const { runServiceCli } = await import("./service-client-cli-fn54ev6w.js");
+    const { runServiceCli } = await import("./service-client-cli-eqrdc9zq.js");
     await runServiceCli(parsedOptions, annotateCliStreamError);
     return;
   }
@@ -4551,6 +4148,12 @@ var main = async (argv = process.argv.slice(2)) => {
     case "state":
       await manageState(options);
       return;
+    case "export-audit":
+    case "verify-audit": {
+      const { auditPackCli } = await import("./audit-pack-e4vaq7np.js");
+      await auditPackCli(options);
+      return;
+    }
     case "run":
       await runOnce(options);
       return;