@zhivex-ai/harness 1.4.0 → 1.5.0

package/dist/audit-pack-kvw7ng34.js

@@ -0,0 +1,532 @@
+import {
+  exportHarnessGovernanceReport,
+  harnessGovernanceReportSchema
+} from "./cli-entry-75j3r49b.js";
+import {
+  APPROVAL_HISTORY_KEY,
+  CliUsageError,
+  TASK_BUDGET_ACCOUNT_KEY,
+  TaskBudget,
+  USAGE_LEDGER_KEY,
+  UsageLedger,
+  approvalDecisionViews,
+  harnessPolicyDecisionEventSchema,
+  inspectUsageLedger,
+  openCliSessionStore,
+  openHarnessActivityStore,
+  openHarnessPersistence,
+  readRegularFileNoFollow,
+  validateStateDirectory
+} from "./cli-entry-928p8h41.js";
+import {
+  HARNESS_VERSION
+} from "./cli-entry-q8bgkn9m.js";
+import {
+  resolveHarnessConfig
+} from "./cli-entry-hdtfef27.js";
+import"./cli-entry-1bx83sw4.js";
+
+// src/cli/audit-pack.ts
+import path2 from "node:path";
+
+// src/audit/pack.ts
+import { createHash, createHmac, timingSafeEqual } from "node:crypto";
+import { lstat, mkdir, readdir, rm, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { z } from "zod";
+import { createRedactionPolicy } from "@zhivex-ai/agents";
+var MAX_FILE_BYTES = 8 * 1024 * 1024;
+var MAX_PACK_BYTES = 32 * 1024 * 1024;
+var MAX_ACTIVITY_EVENTS = 2000;
+var COMPONENT_NAMES = ["governance-report.json", "approvals.json", "policy-decisions.json", "redaction.jsonl", "usage-ledger.json"];
+var digest = z.string().regex(/^[a-f0-9]{64}$/);
+var relativePath = z.string().regex(/^[A-Za-z0-9._-]{1,80}(?:\/[A-Za-z0-9._-]{1,80}){0,3}$/);
+var fileEntry = z.strictObject({ path: relativePath, sha256: digest, bytes: z.number().int().nonnegative().safe() });
+var subjectSchema = z.strictObject({
+  kind: z.enum(["run", "task"]),
+  id: z.string().min(1).max(256),
+  runIds: z.array(z.string().min(1).max(256)).min(1).max(64)
+});
+var unsignedManifestSchema = z.strictObject({
+  schemaVersion: z.literal(1),
+  kind: z.literal("zhivex-harness-audit-pack"),
+  integrity: z.literal("hmac-sha256"),
+  exporterVersion: z.string().regex(/^\d+\.\d+\.\d+(?:[-+][a-zA-Z0-9.-]+)?$/),
+  createdAt: z.iso.datetime(),
+  subject: subjectSchema,
+  files: z.array(fileEntry).min(5).max(320)
+}).superRefine((value, ctx) => {
+  const seen = new Set;
+  for (const file of value.files) {
+    if (seen.has(file.path) || file.path === "manifest.json")
+      ctx.addIssue({ code: "custom", message: "Duplicate or reserved audit pack path." });
+    seen.add(file.path);
+  }
+});
+var signatureSchema = z.strictObject({
+  algorithm: z.literal("hmac-sha256"),
+  keyId: z.string().regex(/^[a-f0-9]{16}$/),
+  value: z.string().regex(/^[A-Za-z0-9+/]{43}=$/)
+});
+var auditPackManifestSchema = unsignedManifestSchema.extend({ signature: signatureSchema });
+var accountView = z.object({
+  taskId: z.string().min(1).max(256),
+  runs: z.array(z.string().min(1).max(256)).max(64)
+}).passthrough();
+function fail(code) {
+  throw new Error(code);
+}
+var canonical = (value) => Array.isArray(value) ? `[${value.map(canonical).join(",")}]` : value && typeof value === "object" ? `{${Object.entries(value).filter(([, item]) => item !== undefined).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([key, item]) => `${JSON.stringify(key)}:${canonical(item)}`).join(",")}}` : JSON.stringify(value) ?? "null";
+var canonicalizeAuditPackManifest = (value) => canonical(unsignedManifestSchema.parse(value));
+var keyIdFor = (key) => createHash("sha256").update(key).digest("hex").slice(0, 16);
+var signManifest = (unsigned, key) => createHmac("sha256", key).update(canonicalizeAuditPackManifest(unsigned)).digest("base64");
+var assertKey = (key) => {
+  if (key.byteLength < 32 || key.byteLength > 4096)
+    fail("AUDIT_PACK_KEY_INVALID");
+};
+var redaction = createRedactionPolicy({ includeEmails: true });
+var redactText = (value) => redaction.redactText(value).replace(/\b(?:sk|ghp|github_pat|xox[baprs])[-_][A-Za-z0-9_-]+/gi, "[REDACTED]");
+var redactValue = (value) => typeof value === "string" ? redactText(value) : Array.isArray(value) ? value.map(redactValue) : value && typeof value === "object" ? Object.fromEntries(Object.entries(value).map(([key, item]) => [key, redactValue(item)])) : value;
+var sameScope = (state, scope) => !state.scope || state.scope.tenantId === scope?.tenantId && state.scope.userId === scope?.userId && state.scope.namespace === scope?.namespace;
+var contained = (root, relativePath2) => {
+  if (relativePath2.includes("\\") || path.isAbsolute(relativePath2) || relativePath2.split("/").some((part) => part === "" || part === "." || part === ".."))
+    fail("AUDIT_PACK_PATH_INVALID");
+  const target = path.resolve(root, relativePath2);
+  const relative = path.relative(root, target);
+  if (relative.startsWith("..") || path.isAbsolute(relative))
+    fail("AUDIT_PACK_PATH_INVALID");
+  return target;
+};
+var runSegment = (runId, used) => {
+  const base = /^[A-Za-z0-9._-]{1,64}$/.test(runId) ? runId : `run-${createHash("sha256").update(runId).digest("hex").slice(0, 16)}`;
+  let name = base;
+  for (let suffix = 2;used.has(name); suffix += 1)
+    name = `${base}-${suffix}`;
+  used.add(name);
+  return name;
+};
+async function loadRun(store, scope, runId) {
+  const state = await store.load(runId, scope);
+  if (!state || state.runId !== runId || !sameScope(state, scope))
+    fail("AUDIT_PACK_SUBJECT_UNAVAILABLE");
+  return structuredClone(state);
+}
+async function readJournal(store, scope, runId) {
+  if (!store.listToolCalls)
+    return;
+  const listed = await store.listToolCalls(runId, scope);
+  return listed ? structuredClone(listed) : undefined;
+}
+async function captureRun(store, scope, runId) {
+  return { state: await loadRun(store, scope, runId), journal: await readJournal(store, scope, runId) };
+}
+var sameJson = (left, right) => JSON.stringify(left) === JSON.stringify(right);
+async function assertCaptured(store, scope, captured) {
+  const current = await store.load(captured.state.runId, scope);
+  const currentJournal = store.listToolCalls ? await store.listToolCalls(captured.state.runId, scope) : undefined;
+  if (!current || !sameJson(current, captured.state) || !sameJson(currentJournal, captured.journal))
+    fail("AUDIT_PACK_STATE_CHANGED");
+}
+function snapshotStore(real, captured) {
+  return {
+    async load(id, scope) {
+      const snap = captured.get(id);
+      if (snap)
+        return structuredClone(snap.state);
+      return real.load(id, scope);
+    },
+    ...real.listToolCalls ? { async listToolCalls(id, scope) {
+      const snap = captured.get(id);
+      if (snap)
+        return snap.journal ? structuredClone(snap.journal) : undefined;
+      return real.listToolCalls(id, scope);
+    } } : {}
+  };
+}
+async function resolveSubject(store, scope, subjectId) {
+  const direct = await store.load(subjectId, scope);
+  const accountOf = (state) => {
+    const parsed = accountView.safeParse(state?.metadata?.[TASK_BUDGET_ACCOUNT_KEY]);
+    return parsed.success && state?.runId.startsWith("task_budget_") ? parsed.data : undefined;
+  };
+  const directAccount = direct && direct.runId === subjectId && sameScope(direct, scope) ? accountOf(direct) : undefined;
+  if (direct && direct.runId === subjectId && sameScope(direct, scope) && !directAccount) {
+    return { kind: "run", id: subjectId, runs: [{ state: structuredClone(direct), journal: await readJournal(store, scope, subjectId) }], accountState: undefined };
+  }
+  let account = directAccount;
+  let taskId = account?.taskId;
+  let accountState = direct && directAccount ? structuredClone(direct) : undefined;
+  if (!account && scope) {
+    const loaded = await store.load(TaskBudget.accountId(scope, subjectId), scope);
+    const parsed = loaded && sameScope(loaded, scope) ? accountOf(loaded) : undefined;
+    if (parsed && parsed.taskId === subjectId) {
+      account = parsed;
+      taskId = parsed.taskId;
+      accountState = structuredClone(loaded);
+    }
+  }
+  if (!account || !taskId || !accountState || account.runs.length === 0)
+    fail("AUDIT_PACK_SUBJECT_UNAVAILABLE");
+  const runs = [];
+  for (const runId of account.runs)
+    runs.push(await captureRun(store, scope, runId));
+  return { kind: "task", id: taskId, runs, accountState };
+}
+function collectActivity(session, runIds) {
+  if (!session?.history)
+    return { availability: "unavailable", truncated: false, retention: "unknown", events: [] };
+  const events = [];
+  let cursor = 0;
+  let truncated = false;
+  let retention = "retained";
+  for (let pageIndex = 0;pageIndex < 50; pageIndex += 1) {
+    const page = session.history.replay(session.id, cursor);
+    if (page.schemaVersion !== 1 || !Number.isSafeInteger(page.nextCursor) || page.nextCursor < cursor)
+      fail("AUDIT_PACK_HISTORY_INVALID");
+    if (page.cursorExpired || page.policyEvidenceIncomplete)
+      retention = "expired";
+    let last = cursor;
+    for (const event of page.events) {
+      if (event.sessionId !== session.id || !Number.isSafeInteger(event.sequence) || event.sequence <= last || event.sequence > page.nextCursor)
+        fail("AUDIT_PACK_HISTORY_INVALID");
+      last = event.sequence;
+      if (!runIds.has(event.runId))
+        continue;
+      if (events.length >= MAX_ACTIVITY_EVENTS) {
+        truncated = true;
+        continue;
+      }
+      events.push({ sequence: event.sequence, runId: event.runId, ...typeof event.at === "number" ? { at: event.at } : {}, activity: event.activity });
+    }
+    if (page.cursorExpired || !page.hasMore)
+      break;
+    if (page.nextCursor === cursor)
+      fail("AUDIT_PACK_HISTORY_INVALID");
+    cursor = page.nextCursor;
+    if (pageIndex === 49)
+      truncated = true;
+  }
+  return { availability: truncated || retention === "expired" ? "incomplete" : "recorded", truncated, retention, events };
+}
+function approvalPages(state, journal) {
+  const decisions = [];
+  for (let offset = 0;offset < 512; offset += 25) {
+    const rows = approvalDecisionViews(state, journal, offset);
+    decisions.push(...rows);
+    if (rows.length < 25)
+      break;
+  }
+  return decisions;
+}
+async function componentFiles(captured, store, scope, session, activity, ledger) {
+  const state = captured.state;
+  const rows = captured.journal ?? [];
+  let approvals;
+  try {
+    const decisions = approvalPages(state, rows);
+    approvals = { schemaVersion: 1, kind: "zhivex-audit-approvals", runId: state.runId, availability: state.metadata?.[APPROVAL_HISTORY_KEY] === undefined && decisions.length === 0 ? "unavailable" : "recorded", decisions: redactValue(decisions) };
+  } catch {
+    approvals = { schemaVersion: 1, kind: "zhivex-audit-approvals", runId: state.runId, availability: "invalid", decisions: [] };
+  }
+  const policyEvents = [];
+  let invalid = 0;
+  for (const event of activity.events) {
+    if (event.runId !== state.runId || event.activity.type !== "policy-decision")
+      continue;
+    const parsed = harnessPolicyDecisionEventSchema.safeParse(event.activity);
+    if (!parsed.success) {
+      invalid += 1;
+      continue;
+    }
+    policyEvents.push({ sequence: event.sequence, event: parsed.data });
+  }
+  const policy = {
+    schemaVersion: 1,
+    kind: "zhivex-audit-policy-decisions",
+    runId: state.runId,
+    availability: activity.availability === "unavailable" ? "unavailable" : invalid > 0 || activity.availability === "incomplete" ? "incomplete" : "recorded",
+    invalid,
+    decisions: policyEvents
+  };
+  const own = activity.events.filter((event) => event.runId === state.runId);
+  const header = { schemaVersion: 1, kind: "zhivex-redaction-log", availability: activity.availability, count: own.length, truncated: activity.truncated, retention: activity.retention };
+  const lines = [header, ...own.map((event) => ({ schemaVersion: 1, kind: "zhivex-redacted-activity", sequence: event.sequence, runId: event.runId, ...event.at === undefined ? {} : { at: event.at }, activity: event.activity }))];
+  const redactionLog = `${lines.map((line) => JSON.stringify(line)).join(`
+`)}
+`;
+  let transport = null;
+  let transportAvailability = "unavailable";
+  if (ledger) {
+    try {
+      transport = ledger.summary(state.runId);
+      transportAvailability = "recorded";
+    } catch {
+      transport = null;
+      transportAvailability = "unavailable";
+    }
+  }
+  const usage = {
+    schemaVersion: 1,
+    kind: "zhivex-audit-usage-ledger",
+    runId: state.runId,
+    projection: inspectUsageLedger(state.metadata?.[USAGE_LEDGER_KEY]),
+    transport,
+    transportAvailability
+  };
+  const report = await exportHarnessGovernanceReport(store, scope, state.runId, session ? { session } : {});
+  return new Map([
+    ["governance-report.json", Buffer.from(`${JSON.stringify(report, null, 2)}
+`)],
+    ["approvals.json", Buffer.from(`${JSON.stringify(approvals, null, 2)}
+`)],
+    ["policy-decisions.json", Buffer.from(`${JSON.stringify(policy, null, 2)}
+`)],
+    ["redaction.jsonl", Buffer.from(redactionLog)],
+    ["usage-ledger.json", Buffer.from(`${JSON.stringify(usage, null, 2)}
+`)]
+  ]);
+}
+async function loadAuditSigningKey(input) {
+  let bytes;
+  if (input.file) {
+    const data = await readRegularFileNoFollow(path.resolve(input.file), { label: "Audit signing key", maxBytes: 4096 });
+    bytes = data.contents;
+    if (bytes.at(-1) === 10)
+      bytes = bytes.subarray(0, -1);
+    if (bytes.at(-1) === 13)
+      bytes = bytes.subarray(0, -1);
+  } else if (input.value !== undefined)
+    bytes = Buffer.from(input.value, "utf8");
+  else
+    fail("AUDIT_PACK_KEY_INVALID");
+  assertKey(bytes);
+  return Buffer.from(bytes);
+}
+async function exportHarnessAuditPack(options) {
+  assertKey(options.signingKey);
+  const subject = await resolveSubject(options.store, options.scope, options.subjectId);
+  const runIds = new Set(subject.runs.map((run) => run.state.runId));
+  const activity = collectActivity(options.session, runIds);
+  let ledger;
+  if (options.config) {
+    try {
+      ledger = await UsageLedger.open(options.config);
+    } catch {
+      ledger = undefined;
+    }
+  }
+  try {
+    const files = new Map;
+    const segments = new Set;
+    const frozen = snapshotStore(options.store, new Map(subject.runs.map((run) => [run.state.runId, run])));
+    const prefixFor = subject.runs.length === 1 ? (_runId) => "" : (runId) => `runs/${runSegment(runId, segments)}/`;
+    for (const captured of subject.runs) {
+      const prefix = prefixFor(captured.state.runId);
+      const parts = await componentFiles(captured, frozen, options.scope, options.session, activity, ledger);
+      for (const name of COMPONENT_NAMES) {
+        const bytes = parts.get(name);
+        if (!bytes)
+          fail("AUDIT_PACK_CONTENT_INVALID");
+        if (bytes.byteLength > MAX_FILE_BYTES)
+          fail("AUDIT_PACK_LIMIT");
+        files.set(`${prefix}${name}`, bytes);
+      }
+    }
+    const listed = [...files.keys()].sort();
+    let total = 0;
+    const entries = listed.map((file) => {
+      const bytes = files.get(file);
+      total += bytes.byteLength;
+      return { path: file, sha256: createHash("sha256").update(bytes).digest("hex"), bytes: bytes.byteLength };
+    });
+    for (const captured of subject.runs)
+      await assertCaptured(options.store, options.scope, captured);
+    if (subject.accountState) {
+      const currentAccount = await options.store.load(subject.accountState.runId, options.scope);
+      if (!currentAccount || !sameJson(currentAccount, subject.accountState))
+        fail("AUDIT_PACK_STATE_CHANGED");
+    }
+    const unsigned = {
+      schemaVersion: 1,
+      kind: "zhivex-harness-audit-pack",
+      integrity: "hmac-sha256",
+      exporterVersion: HARNESS_VERSION,
+      createdAt: new Date(options.now ?? Date.now()).toISOString(),
+      subject: { kind: subject.kind, id: subject.id, runIds: subject.runs.map((run) => run.state.runId) },
+      files: entries
+    };
+    const manifest = auditPackManifestSchema.parse({
+      ...unsigned,
+      signature: { algorithm: "hmac-sha256", keyId: keyIdFor(options.signingKey), value: signManifest(unsigned, options.signingKey) }
+    });
+    const manifestBytes = Buffer.from(`${JSON.stringify(manifest, null, 2)}
+`);
+    if (manifestBytes.byteLength > MAX_FILE_BYTES || total + manifestBytes.byteLength > MAX_PACK_BYTES)
+      fail("AUDIT_PACK_LIMIT");
+    const directory = path.resolve(options.directory);
+    const parent = await lstat(path.dirname(directory)).catch(() => fail("AUDIT_PACK_OUTPUT_UNAVAILABLE"));
+    if (!parent.isDirectory() || parent.isSymbolicLink())
+      fail("AUDIT_PACK_OUTPUT_UNAVAILABLE");
+    await mkdir(directory, { mode: 448 }).catch((error) => fail(error.code === "EEXIST" ? "AUDIT_PACK_OUTPUT_EXISTS" : "AUDIT_PACK_OUTPUT_UNAVAILABLE"));
+    try {
+      for (const file of listed) {
+        const target = contained(directory, file);
+        await mkdir(path.dirname(target), { recursive: true, mode: 448 });
+        await writeFile(target, files.get(file), { flag: "wx", mode: 384 });
+      }
+      await writeFile(path.join(directory, "manifest.json"), `${JSON.stringify(manifest, null, 2)}
+`, { flag: "wx", mode: 384 });
+    } catch (error) {
+      await rm(directory, { recursive: true, force: true });
+      if (error instanceof Error && error.message.startsWith("AUDIT_PACK_"))
+        throw error;
+      fail("AUDIT_PACK_WRITE_FAILED");
+    }
+    return manifest;
+  } finally {
+    ledger?.close();
+  }
+}
+var kindSchema = (kind) => z.object({ schemaVersion: z.literal(1), kind: z.literal(kind) }).passthrough();
+async function verifyHarnessAuditPack(options) {
+  assertKey(options.signingKey);
+  const directory = path.resolve(options.directory);
+  const root = await lstat(directory).catch(() => fail("AUDIT_PACK_UNAVAILABLE"));
+  if (!root.isDirectory() || root.isSymbolicLink())
+    fail("AUDIT_PACK_UNAVAILABLE");
+  const manifestBytes = await readRegularFileNoFollow(path.join(directory, "manifest.json"), { label: "Audit manifest", maxBytes: MAX_FILE_BYTES });
+  let manifest;
+  try {
+    manifest = auditPackManifestSchema.parse(JSON.parse(manifestBytes.contents.toString("utf8")));
+  } catch {
+    fail("AUDIT_PACK_MANIFEST_INVALID");
+  }
+  const present = [];
+  const walk = async (current, prefix) => {
+    const entries = await readdir(current, { withFileTypes: true });
+    for (const entry of entries.sort((a, b) => a.name < b.name ? -1 : 1)) {
+      const relative = prefix ? `${prefix}/${entry.name}` : entry.name;
+      if (entry.isSymbolicLink())
+        fail("AUDIT_PACK_PATH_INVALID");
+      const full = path.join(current, entry.name);
+      if (entry.isDirectory())
+        await walk(full, relative);
+      else if (entry.isFile())
+        present.push(relative);
+      else
+        fail("AUDIT_PACK_PATH_INVALID");
+    }
+  };
+  await walk(directory, "");
+  present.sort();
+  const expected = ["manifest.json", ...manifest.files.map((file) => file.path)].sort();
+  if (present.length !== expected.length || present.some((file, index) => file !== expected[index]))
+    fail("AUDIT_PACK_FILES_MISMATCH");
+  let total = manifestBytes.contents.byteLength;
+  for (const file of manifest.files) {
+    const target = contained(directory, file.path);
+    const contents = await readRegularFileNoFollow(target, { label: "Audit pack file", maxBytes: MAX_FILE_BYTES }).catch((error) => {
+      if (error instanceof Error && error.message.startsWith("AUDIT_PACK_"))
+        throw error;
+      fail("AUDIT_PACK_HASH_MISMATCH");
+    });
+    total += contents.contents.byteLength;
+    if (contents.contents.byteLength !== file.bytes || createHash("sha256").update(contents.contents).digest("hex") !== file.sha256)
+      fail("AUDIT_PACK_HASH_MISMATCH");
+    try {
+      if (file.path.endsWith("governance-report.json")) {
+        if (!harnessGovernanceReportSchema.safeParse(JSON.parse(contents.contents.toString("utf8"))).success)
+          fail("AUDIT_PACK_CONTENT_INVALID");
+      } else if (file.path.endsWith("approvals.json")) {
+        if (!kindSchema("zhivex-audit-approvals").safeParse(JSON.parse(contents.contents.toString("utf8"))).success)
+          fail("AUDIT_PACK_CONTENT_INVALID");
+      } else if (file.path.endsWith("policy-decisions.json")) {
+        if (!kindSchema("zhivex-audit-policy-decisions").safeParse(JSON.parse(contents.contents.toString("utf8"))).success)
+          fail("AUDIT_PACK_CONTENT_INVALID");
+      } else if (file.path.endsWith("usage-ledger.json")) {
+        if (!kindSchema("zhivex-audit-usage-ledger").safeParse(JSON.parse(contents.contents.toString("utf8"))).success)
+          fail("AUDIT_PACK_CONTENT_INVALID");
+      } else if (file.path.endsWith("redaction.jsonl")) {
+        const lines = contents.contents.toString("utf8").split(`
+`);
+        if (lines.at(-1) !== "")
+          fail("AUDIT_PACK_CONTENT_INVALID");
+        for (const line of lines.slice(0, -1)) {
+          if (!kindSchema("zhivex-redaction-log").or(kindSchema("zhivex-redacted-activity")).safeParse(JSON.parse(line)).success)
+            fail("AUDIT_PACK_CONTENT_INVALID");
+        }
+      } else
+        fail("AUDIT_PACK_PATH_INVALID");
+    } catch (error) {
+      if (error instanceof Error && error.message.startsWith("AUDIT_PACK_"))
+        throw error;
+      fail("AUDIT_PACK_CONTENT_INVALID");
+    }
+  }
+  if (total > MAX_PACK_BYTES)
+    fail("AUDIT_PACK_LIMIT");
+  if (manifest.signature.keyId !== keyIdFor(options.signingKey))
+    fail("AUDIT_PACK_KEY_MISMATCH");
+  const { signature, ...unsigned } = manifest;
+  const expectedSignature = Buffer.from(signManifest(unsigned, options.signingKey), "base64");
+  const actualSignature = Buffer.from(signature.value, "base64");
+  if (actualSignature.length !== expectedSignature.length || actualSignature.toString("base64") !== signature.value || !timingSafeEqual(actualSignature, expectedSignature)) {
+    fail("AUDIT_PACK_SIGNATURE_INVALID");
+  }
+  return { schemaVersion: 1, kind: "zhivex-audit-pack-verification", subject: manifest.subject, fileCount: manifest.files.length, keyId: signature.keyId };
+}
+// src/cli/audit-pack.ts
+var signingKey = async (file) => {
+  if (!file && process.env.ZHIVEX_AUDIT_SIGNING_KEY === undefined) {
+    throw new CliUsageError("Set ZHIVEX_AUDIT_SIGNING_KEY or pass --signing-key-file. The key is not stored in the pack.");
+  }
+  try {
+    return await loadAuditSigningKey({ ...file ? { file } : {}, ...file ? {} : { value: process.env.ZHIVEX_AUDIT_SIGNING_KEY ?? "" } });
+  } catch (error) {
+    if (error instanceof Error && (error.message === "AUDIT_PACK_KEY_INVALID" || error.name === "UnsafeFileTypeError" || error.name === "FileSizeLimitError")) {
+      throw new CliUsageError("Audit signing key must be a regular file or environment value of 32 to 4096 bytes.");
+    }
+    throw error;
+  }
+};
+async function auditPackCli(options) {
+  const key = await signingKey(options.signingKeyFile);
+  if (options.command === "verify-audit") {
+    const result = await verifyHarnessAuditPack({ directory: path2.resolve(options.auditOut), signingKey: key });
+    process.stdout.write(options.json ? `${JSON.stringify(result, null, 2)}
+` : `Audit pack verified: ${result.subject.kind} ${result.subject.id} (${result.fileCount} files, key ${result.keyId}).
+`);
+    return result;
+  }
+  const config = resolveHarnessConfig(options);
+  await validateStateDirectory(config.workspace, config.stateDirectory);
+  const persistence = await openHarnessPersistence(config);
+  let index;
+  let history;
+  try {
+    if (options.sessionId) {
+      index = await openCliSessionStore({ workspace: config.workspace, stateDirectory: config.stateDirectory, scope: config.scope });
+      history = await openHarnessActivityStore(config);
+    }
+    const manifest = await exportHarnessAuditPack({
+      store: persistence.store,
+      scope: config.scope,
+      subjectId: options.runId,
+      directory: path2.resolve(options.auditOut),
+      signingKey: key,
+      config,
+      ...index && history && options.sessionId ? { session: { id: options.sessionId, index, history } } : {}
+    });
+    process.stdout.write(options.json ? `${JSON.stringify(manifest, null, 2)}
+` : `Audit pack written to ${path2.resolve(options.auditOut)} (${manifest.subject.kind} ${manifest.subject.id}, ${manifest.files.length} files).
+`);
+    return manifest;
+  } finally {
+    history?.close();
+    index?.close();
+    persistence.close();
+  }
+}
+export {
+  auditPackCli
+};

package/dist/cli/arguments.d.ts

@@ -2,7 +2,7 @@ import { type HarnessReasoningEffort } from "../providers/reasoning.js";
 import { type AgentStatus } from "@zhivex-ai/agents";
 import { type HarnessSubagentProfile } from "../runtime/config.js";
 import { HarnessError } from "../runtime/errors.js";
-export declare const CLI_COMMANDS: readonly ["init", "run", "review", "chat", "providers", "doctor", "policy", "resume", "runs", "sessions", "checkpoints", "changes", "state", "memory", "help", "version"];
+export declare const CLI_COMMANDS: readonly ["init", "run", "review", "chat", "providers", "doctor", "policy", "resume", "runs", "sessions", "checkpoints", "changes", "state", "memory", "export-audit", "verify-audit", "help", "version"];
 export declare const CLI_RUNS_COMMANDS: readonly ["list", "inspect", "cancel", "cleanup", "export", "report"];
 export declare const CLI_SESSIONS_COMMANDS: readonly ["list", "inspect", "rename", "fork", "archive"];
 export declare const CLI_CHANGES_COMMANDS: readonly ["create", "verify"];
@@ -114,6 +114,8 @@ export interface CliOptions {
     approve?: boolean;
     json: boolean;
     jsonl: boolean;
+    auditOut?: string;
+    signingKeyFile?: string;
 }
 export declare class CliUsageError extends HarnessError {
     constructor(message: string);

package/dist/cli/audit-pack.d.ts

@@ -0,0 +1,24 @@
+import { type CliOptions } from "./arguments.js";
+/** Experimental operator command. Verification reads the pack and key only. Export reads durable state and writes a new directory. */
+export declare function auditPackCli(options: CliOptions): Promise<import("../audit/pack.js").AuditPackVerification | {
+    schemaVersion: 1;
+    kind: "zhivex-harness-audit-pack";
+    integrity: "hmac-sha256";
+    exporterVersion: string;
+    createdAt: string;
+    subject: {
+        kind: "run" | "task";
+        id: string;
+        runIds: string[];
+    };
+    files: {
+        path: string;
+        sha256: string;
+        bytes: number;
+    }[];
+    signature: {
+        algorithm: "hmac-sha256";
+        keyId: string;
+        value: string;
+    };
+}>;

package/dist/cli/cli-credentials.d.ts

@@ -43,8 +43,14 @@ export declare class CliCredentials {
     private endpointOverride;
     /** Presence only: never contacts a provider or returns a secret. */
     inspect(provider: HarnessProvider): Promise<CredentialStatus>;
+    private inspectBedrock;
+    private inspectAzure;
+    private inspectSecret;
     configure(provider: HarnessProvider, input: CredentialInput): Promise<boolean>;
     private configureOnce;
+    private managedSecret;
+    private bedrockProviderEnvironment;
+    private azureProviderEnvironment;
     providerEnvironment(provider: HarnessProvider, input: CredentialInput): Promise<NodeJS.ProcessEnv>;
     clear(): void;
 }

package/dist/cli/cli-profiles.d.ts

@@ -8,6 +8,8 @@ export declare const cliProfileSchema: z.ZodObject<{
     schemaVersion: z.ZodLiteral<1>;
     provider: z.ZodEnum<{
         anthropic: "anthropic";
+        "azure-openai": "azure-openai";
+        bedrock: "bedrock";
         gemini: "gemini";
         meta: "meta";
         openai: "openai";
@@ -44,7 +46,7 @@ export declare const createCliProfile: (name: string, input: {
     path: string;
     profile: {
         schemaVersion: 1;
-        provider: "anthropic" | "gemini" | "meta" | "openai" | "qwen" | "vertex";
+        provider: "anthropic" | "azure-openai" | "bedrock" | "gemini" | "meta" | "openai" | "qwen" | "vertex";
         reasoningEffort?: "default" | "high" | "low" | "max" | "medium" | "minimal" | "none" | "xhigh" | undefined;
         model: string;
     };
@@ -58,7 +60,7 @@ export declare const updateCliProfile: (name: string, input: {
     path: string;
     profile: {
         schemaVersion: 1;
-        provider: "anthropic" | "gemini" | "meta" | "openai" | "qwen" | "vertex";
+        provider: "anthropic" | "azure-openai" | "bedrock" | "gemini" | "meta" | "openai" | "qwen" | "vertex";
         reasoningEffort?: "default" | "high" | "low" | "max" | "medium" | "minimal" | "none" | "xhigh" | undefined;
         model: string;
     };

package/dist/cli/node-engine.d.ts

@@ -0,0 +1,2 @@
+/** Fast-path engine check. Does not load the doctor or the engine. */
+export declare const nodeEngineError: (version: string, range: string) => string | undefined;