@zhivex-ai/harness 1.4.0 → 1.5.0

package/dist/index-jpdvn09j.js

@@ -0,0 +1,490 @@
+import {
+  changeEnvelopeSchema,
+  verifyChangeEnvelope
+} from "./index-yx52bt4a.js";
+import {
+  APPROVAL_HISTORY_KEY,
+  approvalDecisionViews,
+  harnessPolicyDecisionEventSchema
+} from "./index-bt2p8x7r.js";
+import {
+  TASK_ACCEPTANCE_EVIDENCE_KEY,
+  USAGE_LEDGER_KEY,
+  inspectRuntimeManifest,
+  inspectUsageLedger,
+  readTaskAcceptanceLedger
+} from "./index-fqqz1yt8.js";
+import {
+  HARNESS_VERSION
+} from "./index-pq3kz1r8.js";
+import {
+  taskCheckReceiptSchema
+} from "./index-6dxrbnxm.js";
+
+// src/persistence/governance-report.ts
+import { createHash as createHash2 } from "node:crypto";
+import { z as z2 } from "zod";
+
+// src/persistence/governance-context.ts
+import { createHash } 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:" + createHash("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:" + createHash2("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:" + createHash2("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(`
+`);
+}
+
+export { harnessGovernanceReportSchema, exportHarnessGovernanceReport, renderHarnessGovernanceMarkdown };

package/dist/{index-xqxeypt5.js → index-mzydbzp8.js}

@@ -3,7 +3,7 @@ import { z } from "zod";
 // src/models/catalog.json
 var catalog_default = {
   schemaVersion: 1,
-  revision: "2026-09-29-vertex",
+  revision: "2026-10-15-bedrock-azure",
   providers: [
     {
       id: "openai",
@@ -768,6 +768,78 @@ var catalog_default = {
           reason: "Provisional Vertex route; availability depends on project, region and IAM. No live certification."
         }
       ]
+    },
+    {
+      id: "bedrock",
+      defaultModel: "anthropic.claude-haiku-5-5",
+      models: [
+        {
+          id: "anthropic.claude-haiku-5-5",
+          name: "Claude Haiku 5.5 (Bedrock)",
+          group: "primary",
+          order: 0,
+          lifecycle: "unknown",
+          validation: "unverified",
+          capabilities: ["chat", "tools"],
+          reason: "Provisional Bedrock Converse route. Account access, region, and live Harness certification are not verified. No prices or context limits are inferred."
+        },
+        {
+          id: "anthropic.claude-sonnet-5-5",
+          name: "Claude Sonnet 5.5 (Bedrock)",
+          group: "other",
+          order: 1,
+          lifecycle: "unknown",
+          validation: "unverified",
+          capabilities: ["chat", "tools"],
+          reason: "Provisional Bedrock model id. Availability depends on the account and region. No live certification."
+        },
+        {
+          id: "amazon.nova-2-lite-v1:0",
+          name: "Amazon Nova 2 Lite (Bedrock)",
+          group: "other",
+          order: 2,
+          lifecycle: "unknown",
+          validation: "unverified",
+          capabilities: ["chat", "tools"],
+          reason: "Provisional Bedrock model id. Availability depends on the account and region. No live certification."
+        }
+      ]
+    },
+    {
+      id: "azure-openai",
+      defaultModel: "gpt-5.4",
+      models: [
+        {
+          id: "gpt-5.4",
+          name: "GPT-5.4 (Azure OpenAI)",
+          group: "primary",
+          order: 0,
+          lifecycle: "unknown",
+          validation: "unverified",
+          capabilities: ["chat", "tools"],
+          reason: "Provisional Azure OpenAI route. Deployment name, API version, and live Harness certification are not verified. No prices are copied from the OpenAI API."
+        },
+        {
+          id: "gpt-5",
+          name: "GPT-5 (Azure OpenAI)",
+          group: "other",
+          order: 1,
+          lifecycle: "unknown",
+          validation: "unverified",
+          capabilities: ["chat", "tools"],
+          reason: "Provisional Azure OpenAI model id. Use AZURE_OPENAI_DEPLOYMENTS when the deployment name differs. No live certification."
+        },
+        {
+          id: "gpt-6-astra",
+          name: "GPT-6 Astra (Azure OpenAI)",
+          group: "other",
+          order: 2,
+          lifecycle: "unknown",
+          validation: "unverified",
+          capabilities: ["chat", "tools"],
+          reason: "Provisional Azure OpenAI model id. Account rollout and deployment availability are not verified. No live certification."
+        }
+      ]
     }
   ]
 };
@@ -830,13 +902,13 @@ var modelCatalogSchema = z.object({
   schemaVersion: z.literal(1),
   revision: z.string().min(1).max(80).regex(/^[a-zA-Z0-9._-]+$/),
   providers: z.array(z.object({
-    id: z.enum(["openai", "qwen", "gemini", "meta", "anthropic", "vertex"]),
+    id: z.enum(["openai", "qwen", "gemini", "meta", "anthropic", "vertex", "bedrock", "azure-openai"]),
     defaultModel: modelId,
     models: z.array(catalogModelSchema).min(1).max(500)
-  }).strict()).length(6)
+  }).strict()).length(8)
 }).strict().superRefine((catalog, ctx) => {
   const invalid = (message) => ctx.addIssue({ code: "custom", message });
-  if (new Set(catalog.providers.map((p) => p.id)).size !== 6)
+  if (new Set(catalog.providers.map((p) => p.id)).size !== 8)
     invalid("Duplicate providers");
   for (const provider of catalog.providers) {
     const ids = new Set(provider.models.map((m) => m.id));