@zhivex-ai/harness 1.4.0 → 1.5.0

package/dist/{index-tfzta544.js → index-xfedewpt.js}

@@ -1,23 +1,28 @@
 import {
   workspaceCheckpointSchema,
   workspaceRestoreOperationSchema
-} from "./index-6dft2vev.js";
+} from "./index-63gbp0cz.js";
 import {
   HARNESS_OPERATIONS_SCHEMA_VERSION,
-  HARNESS_SESSION_SCHEMA_VERSION,
   HARNESS_SQLITE_FILE,
-  assertTaskBudgetBackupLinks,
   decodeProjectMemory,
-  openCliSessionStore,
   openHarnessPersistence,
   projectMemoryRecordKey,
-  sqliteAdapter,
+  sqliteAdapter
+} from "./index-wwthv10a.js";
+import {
+  BUDGET_LEDGER_NAMESPACE,
+  BUDGET_OWNER_NAMESPACE_KEY,
+  HARNESS_SESSION_SCHEMA_VERSION,
+  assertTaskBudgetBackupLinks,
+  budgetLedgerNamespace,
+  openCliSessionStore,
   validateStateDirectory
-} from "./index-s2k2edts.js";
+} from "./index-fqqz1yt8.js";
 import {
   SqliteDatabase,
   readRegularFileChunksNoFollow
-} from "./index-m34q25jj.js";
+} from "./index-6dxrbnxm.js";
 import {
   HarnessStateConflictError,
   HarnessWorkspaceError
@@ -396,7 +401,8 @@ var coordinatorIds = (runs) => new Set(runs.flatMap(({ state }) => {
 var validateBudgetLedger = (config, run, identities) => {
   const state = validatedRunState(run.state, `Budget ledger ${run.key}`);
   const identity = state.metadata?.budgetIdentity;
-  if (state.scope?.namespace !== "__zhivex_budget__" || state.scope?.tenantId !== config.scope.tenantId || (state.scope?.userId ?? undefined) !== (config.scope.userId ?? undefined) || state.provider !== "zhivex" || state.modelId !== "budget-coordinator" || state.metadata?.budgetCoordinator !== true || typeof identity !== "string" || !identities.has(identity) || !/^budget_[a-f0-9]{64}$/.test(state.runId) || !sdkRunKeyMatches(run.key, state.scope, state.runId)) {
+  const ownerNamespace = config.scope.namespace;
+  if (!ownerNamespace || state.scope?.namespace !== budgetLedgerNamespace(ownerNamespace) || state.metadata?.[BUDGET_OWNER_NAMESPACE_KEY] !== ownerNamespace || state.scope?.tenantId !== config.scope.tenantId || (state.scope?.userId ?? undefined) !== (config.scope.userId ?? undefined) || state.provider !== "zhivex" || state.modelId !== "budget-coordinator" || state.metadata?.budgetCoordinator !== true || typeof identity !== "string" || !identities.has(identity) || !/^budget_[a-f0-9]{64}$/.test(state.runId) || !sdkRunKeyMatches(run.key, state.scope, state.runId)) {
     throw new HarnessStateConflictError("Budget ledger is not bound to an exported run and durable scope.");
   }
   assertTerminalState(state, `Budget ledger ${run.key}`);
@@ -530,7 +536,9 @@ var readPayload = async (config, recordedWorkspace, accessLease) => {
       const metadata = state.metadata;
       if (typeof metadata?.budgetIdentity !== "string" || !identities.has(metadata.budgetIdentity)) {
         const scope = state.scope;
-        if (scope?.namespace === "__zhivex_budget__" && scope.tenantId === config.scope.tenantId && (scope.userId ?? undefined) === (config.scope.userId ?? undefined)) {
+        const sameTenant = scope?.tenantId === config.scope.tenantId && (scope?.userId ?? undefined) === (config.scope.userId ?? undefined);
+        const boundNamespace = config.scope.namespace ? budgetLedgerNamespace(config.scope.namespace) : undefined;
+        if (sameTenant && (scope?.namespace === BUDGET_LEDGER_NAMESPACE || scope?.namespace === boundNamespace)) {
           throw new HarnessStateConflictError("An unlinked shared budget ledger cannot be safely assigned to this backup scope; retain the original database.");
         }
         return [];

package/dist/index-yx52bt4a.js

@@ -0,0 +1,511 @@
+import {
+  fileDigestSchema
+} from "./index-6dxrbnxm.js";
+
+// src/workspace/change-envelope.ts
+import { createHash } from "node:crypto";
+import { z } from "zod";
+var CHANGE_ENVELOPE_SCHEMA_VERSION = 1;
+var CHANGE_ENVELOPE_DIGEST_ALGORITHM = "sha256";
+var MAX_CHANGE_ENVELOPE_CHECKS = 100;
+var MAX_CHANGE_ENVELOPE_APPROVALS = 100;
+var MAX_CHANGE_ENVELOPE_APPROVAL_SCOPES = 32;
+var MAX_CHANGE_ENVELOPE_ATTESTATIONS = 32;
+var timestampSchema = z.iso.datetime({ precision: 3 });
+var boundedIdentifierSchema = z.string().min(1).max(200).regex(/^[A-Za-z0-9][A-Za-z0-9._:@/-]*$/, "Identifier must contain only bounded non-secret token characters.");
+var approvalScopeSchema = z.string().min(1).max(128).regex(/^[A-Za-z0-9][A-Za-z0-9._:/*-]*$/, "Approval scope must contain only bounded token characters.");
+var attestationFormatSchema = z.string().min(1).max(128).regex(/^[A-Za-z0-9][A-Za-z0-9.+_-]*$/);
+var mediaTypeSchema = z.string().min(3).max(200).regex(/^[A-Za-z0-9][A-Za-z0-9!#$&^_.+-]*\/[A-Za-z0-9][A-Za-z0-9!#$&^_.+-]*$/);
+var addDuplicateIssues = (values, key, context, path) => {
+  const seen = new Set;
+  for (let index = 0;index < values.length; index += 1) {
+    const value = values[index];
+    if (value === undefined)
+      continue;
+    const identifier = key(value);
+    if (seen.has(identifier)) {
+      context.addIssue({
+        code: "custom",
+        path: [index, path],
+        message: `Duplicate ${path}: ${identifier}.`
+      });
+    }
+    seen.add(identifier);
+  }
+};
+var addCanonicalOrderIssue = (values, key, context, path) => {
+  for (let index = 1;index < values.length; index += 1) {
+    const previous = values[index - 1];
+    const current = values[index];
+    if (previous !== undefined && current !== undefined && key(previous) >= key(current)) {
+      context.addIssue({
+        code: "custom",
+        path: [index, path],
+        message: `${path} entries must be unique and in canonical ascending order.`
+      });
+    }
+  }
+};
+var approvalScopesInputSchema = z.array(approvalScopeSchema).min(1).max(MAX_CHANGE_ENVELOPE_APPROVAL_SCOPES).superRefine((scopes, context) => addDuplicateIssues(scopes, (scope) => scope, context, "scope"));
+var canonicalApprovalScopesSchema = z.array(approvalScopeSchema).min(1).max(MAX_CHANGE_ENVELOPE_APPROVAL_SCOPES).superRefine((scopes, context) => addCanonicalOrderIssue(scopes, (scope) => scope, context, "scope"));
+var changeEnvelopeCheckSchema = z.strictObject({
+  checkId: boundedIdentifierSchema,
+  status: z.enum(["passed", "failed", "skipped"]),
+  redacted: z.literal(true),
+  startedAt: timestampSchema,
+  completedAt: timestampSchema,
+  durationMs: z.number().int().min(0).max(Number.MAX_SAFE_INTEGER),
+  exitCode: z.number().int().min(0).max(255).optional(),
+  redactedOutputDigest: fileDigestSchema.optional(),
+  runnerFingerprint: fileDigestSchema.optional()
+}).superRefine((check, context) => {
+  const startedAt = Date.parse(check.startedAt);
+  const completedAt = Date.parse(check.completedAt);
+  if (completedAt < startedAt) {
+    context.addIssue({
+      code: "custom",
+      path: ["completedAt"],
+      message: "Check completion cannot precede its start."
+    });
+  }
+  if (check.status === "passed" && check.exitCode !== undefined && check.exitCode !== 0) {
+    context.addIssue({
+      code: "custom",
+      path: ["exitCode"],
+      message: "A passed check cannot have a non-zero exit code."
+    });
+  }
+  if (check.status === "failed" && check.exitCode === 0) {
+    context.addIssue({
+      code: "custom",
+      path: ["exitCode"],
+      message: "A failed check cannot have a zero exit code."
+    });
+  }
+  if (check.status === "skipped" && check.exitCode !== undefined) {
+    context.addIssue({
+      code: "custom",
+      path: ["exitCode"],
+      message: "A skipped check cannot have an exit code."
+    });
+  }
+});
+var checkInputListSchema = z.array(changeEnvelopeCheckSchema).min(1).max(MAX_CHANGE_ENVELOPE_CHECKS).superRefine((checks, context) => addDuplicateIssues(checks, (check) => check.checkId, context, "checkId"));
+var canonicalCheckListSchema = z.array(changeEnvelopeCheckSchema).min(1).max(MAX_CHANGE_ENVELOPE_CHECKS).superRefine((checks, context) => addCanonicalOrderIssue(checks, (check) => check.checkId, context, "checkId"));
+var changeEnvelopeApprovalSchema = z.strictObject({
+  kind: z.literal("approval-reference"),
+  approvalId: boundedIdentifierSchema,
+  approvalDigest: fileDigestSchema,
+  approverDigest: fileDigestSchema,
+  scopes: canonicalApprovalScopesSchema,
+  approvedAt: timestampSchema,
+  expiresAt: timestampSchema.optional()
+}).superRefine((approval, context) => {
+  if (approval.expiresAt && Date.parse(approval.expiresAt) <= Date.parse(approval.approvedAt)) {
+    context.addIssue({
+      code: "custom",
+      path: ["expiresAt"],
+      message: "Approval expiry must be later than approval time."
+    });
+  }
+});
+var changeEnvelopeApprovalInputSchema = z.strictObject({
+  kind: z.literal("approval-reference"),
+  approvalId: boundedIdentifierSchema,
+  approvalDigest: fileDigestSchema,
+  approverDigest: fileDigestSchema,
+  scopes: approvalScopesInputSchema,
+  approvedAt: timestampSchema,
+  expiresAt: timestampSchema.optional()
+}).superRefine((approval, context) => {
+  if (approval.expiresAt && Date.parse(approval.expiresAt) <= Date.parse(approval.approvedAt)) {
+    context.addIssue({
+      code: "custom",
+      path: ["expiresAt"],
+      message: "Approval expiry must be later than approval time."
+    });
+  }
+});
+var approvalInputListSchema = z.array(changeEnvelopeApprovalInputSchema).min(1).max(MAX_CHANGE_ENVELOPE_APPROVALS).superRefine((approvals, context) => addDuplicateIssues(approvals, (approval) => approval.approvalId, context, "approvalId"));
+var canonicalApprovalListSchema = z.array(changeEnvelopeApprovalSchema).min(1).max(MAX_CHANGE_ENVELOPE_APPROVALS).superRefine((approvals, context) => addCanonicalOrderIssue(approvals, (approval) => approval.approvalId, context, "approvalId"));
+var externalAttestationReferenceSchema = z.strictObject({
+  kind: z.literal("external-attestation-reference"),
+  attestationId: boundedIdentifierSchema,
+  format: attestationFormatSchema,
+  mediaType: mediaTypeSchema,
+  bundleDigest: fileDigestSchema
+});
+var externalAttestationInputListSchema = z.array(externalAttestationReferenceSchema).min(1).max(MAX_CHANGE_ENVELOPE_ATTESTATIONS).superRefine((attestations, context) => addDuplicateIssues(attestations, (attestation) => attestation.attestationId, context, "attestationId"));
+var canonicalExternalAttestationListSchema = z.array(externalAttestationReferenceSchema).min(1).max(MAX_CHANGE_ENVELOPE_ATTESTATIONS).superRefine((attestations, context) => addCanonicalOrderIssue(attestations, (attestation) => attestation.attestationId, context, "attestationId"));
+var changeEnvelopeBaseSchema = z.strictObject({
+  workspaceDigest: fileDigestSchema,
+  treeDigest: fileDigestSchema
+});
+var changeEnvelopePatchSchema = z.strictObject({
+  patchId: boundedIdentifierSchema,
+  patchDigest: fileDigestSchema
+});
+var changeEnvelopeFingerprintsSchema = z.strictObject({
+  harness: fileDigestSchema,
+  policy: fileDigestSchema,
+  environment: fileDigestSchema
+});
+var changeEnvelopeEvidenceSchema = z.strictObject({
+  schemaVersion: z.literal(CHANGE_ENVELOPE_SCHEMA_VERSION),
+  kind: z.literal("check-evidence-summary"),
+  digestAlgorithm: z.literal(CHANGE_ENVELOPE_DIGEST_ALGORITHM),
+  evidenceDigest: fileDigestSchema,
+  checks: canonicalCheckListSchema
+});
+var changeEnvelopeInputSchema = z.strictObject({
+  createdAt: timestampSchema,
+  expiresAt: timestampSchema.optional(),
+  base: changeEnvelopeBaseSchema,
+  patch: changeEnvelopePatchSchema,
+  fingerprints: changeEnvelopeFingerprintsSchema,
+  checks: checkInputListSchema,
+  approvals: approvalInputListSchema.optional(),
+  externalAttestations: externalAttestationInputListSchema.optional()
+});
+var changeEnvelopeSchema = z.strictObject({
+  schemaVersion: z.literal(CHANGE_ENVELOPE_SCHEMA_VERSION),
+  kind: z.literal("change-envelope"),
+  digestAlgorithm: z.literal(CHANGE_ENVELOPE_DIGEST_ALGORITHM),
+  envelopeId: fileDigestSchema,
+  createdAt: timestampSchema,
+  expiresAt: timestampSchema.optional(),
+  base: changeEnvelopeBaseSchema,
+  patch: changeEnvelopePatchSchema,
+  fingerprints: changeEnvelopeFingerprintsSchema,
+  evidence: changeEnvelopeEvidenceSchema,
+  approvals: canonicalApprovalListSchema.optional(),
+  externalAttestations: canonicalExternalAttestationListSchema.optional()
+}).superRefine((envelope, context) => {
+  if (envelope.expiresAt && Date.parse(envelope.expiresAt) <= Date.parse(envelope.createdAt)) {
+    context.addIssue({
+      code: "custom",
+      path: ["expiresAt"],
+      message: "Envelope expiry must be later than creation time."
+    });
+  }
+  for (let index = 0;index < envelope.evidence.checks.length; index += 1) {
+    const check = envelope.evidence.checks[index];
+    if (check && Date.parse(check.completedAt) > Date.parse(envelope.createdAt)) {
+      context.addIssue({
+        code: "custom",
+        path: ["evidence", "checks", index, "completedAt"],
+        message: "Check completion cannot be later than envelope creation time."
+      });
+    }
+  }
+  for (let index = 0;index < (envelope.approvals?.length ?? 0); index += 1) {
+    const approval = envelope.approvals?.[index];
+    if (approval && Date.parse(approval.approvedAt) > Date.parse(envelope.createdAt)) {
+      context.addIssue({
+        code: "custom",
+        path: ["approvals", index, "approvedAt"],
+        message: "Approval time cannot be later than envelope creation time."
+      });
+    }
+  }
+});
+var canonicalJson = (value) => {
+  if (value === null || typeof value === "boolean" || typeof value === "string") {
+    return JSON.stringify(value);
+  }
+  if (typeof value === "number") {
+    if (!Number.isFinite(value))
+      throw new TypeError("Canonical JSON cannot encode a non-finite number.");
+    return JSON.stringify(Object.is(value, -0) ? 0 : value);
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map((entry) => canonicalJson(entry)).join(",")}]`;
+  }
+  if (typeof value === "object") {
+    const record = value;
+    return `{${Object.keys(record).sort().map((key) => `${JSON.stringify(key)}:${canonicalJson(record[key])}`).join(",")}}`;
+  }
+  throw new TypeError(`Canonical JSON cannot encode ${typeof value}.`);
+};
+var digestCanonical = (value) => `sha256:${createHash("sha256").update(canonicalJson(value)).digest("hex")}`;
+var digestChangeEnvelopeArtifact = (value) => `sha256:${createHash("sha256").update(value).digest("hex")}`;
+var evidencePayload = (checks) => ({
+  schemaVersion: CHANGE_ENVELOPE_SCHEMA_VERSION,
+  kind: "check-evidence-summary",
+  digestAlgorithm: CHANGE_ENVELOPE_DIGEST_ALGORITHM,
+  checks: [...checks]
+});
+var envelopePayload = (envelope) => {
+  const { envelopeId: _envelopeId, ...payload } = envelope;
+  return payload;
+};
+var sortBy = (values, key) => [...values].sort((left, right) => {
+  const leftKey = key(left);
+  const rightKey = key(right);
+  return leftKey < rightKey ? -1 : leftKey > rightKey ? 1 : 0;
+});
+var createChangeEnvelope = (input) => {
+  const parsed = changeEnvelopeInputSchema.parse(input);
+  const checks = sortBy(parsed.checks, (check) => check.checkId);
+  const evidenceWithoutDigest = evidencePayload(checks);
+  const evidence = {
+    ...evidenceWithoutDigest,
+    evidenceDigest: digestCanonical(evidenceWithoutDigest)
+  };
+  const approvals = parsed.approvals ? sortBy(parsed.approvals, (approval) => approval.approvalId).map((approval) => ({
+    ...approval,
+    scopes: [...approval.scopes].sort()
+  })) : undefined;
+  const externalAttestations = parsed.externalAttestations ? sortBy(parsed.externalAttestations, (attestation) => attestation.attestationId) : undefined;
+  const payload = {
+    schemaVersion: CHANGE_ENVELOPE_SCHEMA_VERSION,
+    kind: "change-envelope",
+    digestAlgorithm: CHANGE_ENVELOPE_DIGEST_ALGORITHM,
+    createdAt: parsed.createdAt,
+    ...parsed.expiresAt ? { expiresAt: parsed.expiresAt } : {},
+    base: parsed.base,
+    patch: parsed.patch,
+    fingerprints: parsed.fingerprints,
+    evidence,
+    ...approvals ? { approvals } : {},
+    ...externalAttestations ? { externalAttestations } : {}
+  };
+  return changeEnvelopeSchema.parse({
+    ...payload,
+    envelopeId: digestCanonical(payload)
+  });
+};
+var canonicalizeChangeEnvelope = (input) => canonicalJson(changeEnvelopeSchema.parse(input));
+var computeChangeEnvelopeDigest = (input) => {
+  const parsed = changeEnvelopeSchema.parse(input);
+  return digestCanonical(envelopePayload(parsed));
+};
+var computeChangeEnvelopeEvidenceDigest = (input) => {
+  const parsed = changeEnvelopeEvidenceSchema.parse(input);
+  return digestCanonical(evidencePayload(parsed.checks));
+};
+var changeEnvelopePreconditionsSchema = z.strictObject({
+  envelopeId: fileDigestSchema.optional(),
+  baseWorkspaceDigest: fileDigestSchema.optional(),
+  baseTreeDigest: fileDigestSchema.optional(),
+  patchId: boundedIdentifierSchema.optional(),
+  patchDigest: fileDigestSchema.optional(),
+  harnessFingerprint: fileDigestSchema.optional(),
+  policyFingerprint: fileDigestSchema.optional(),
+  environmentFingerprint: fileDigestSchema.optional(),
+  evidenceDigest: fileDigestSchema.optional(),
+  requiredPassedChecks: z.array(boundedIdentifierSchema).max(MAX_CHANGE_ENVELOPE_CHECKS).optional(),
+  requiredApprovalDigests: z.array(fileDigestSchema).max(MAX_CHANGE_ENVELOPE_APPROVALS).optional(),
+  requiredApprovalScopes: z.array(approvalScopeSchema).max(MAX_CHANGE_ENVELOPE_APPROVAL_SCOPES).optional(),
+  requiredAttestationDigests: z.array(fileDigestSchema).max(MAX_CHANGE_ENVELOPE_ATTESTATIONS).optional()
+}).superRefine((preconditions, context) => {
+  if (preconditions.requiredPassedChecks) {
+    addDuplicateIssues(preconditions.requiredPassedChecks, (checkId) => checkId, context, "requiredPassedCheck");
+  }
+  if (preconditions.requiredApprovalDigests) {
+    addDuplicateIssues(preconditions.requiredApprovalDigests, (digest) => digest, context, "requiredApprovalDigest");
+  }
+  if (preconditions.requiredApprovalScopes) {
+    addDuplicateIssues(preconditions.requiredApprovalScopes, (scope) => scope, context, "requiredApprovalScope");
+  }
+  if (preconditions.requiredAttestationDigests) {
+    addDuplicateIssues(preconditions.requiredAttestationDigests, (digest) => digest, context, "requiredAttestationDigest");
+  }
+});
+var verificationOptionsSchema = z.strictObject({
+  now: z.union([z.date(), z.number().int(), timestampSchema]).optional(),
+  preconditions: changeEnvelopePreconditionsSchema.optional()
+});
+var verificationTime = (value) => {
+  const date = value === undefined ? new Date : value instanceof Date ? value : new Date(value);
+  if (!Number.isFinite(date.getTime()))
+    throw new TypeError("Verification time must be a valid date.");
+  return date;
+};
+var verifyChangeEnvelope = (input, options = {}) => {
+  const parsedOptions = verificationOptionsSchema.parse(options);
+  const now = verificationTime(parsedOptions.now);
+  const checkedAt = now.toISOString();
+  const parsedEnvelope = changeEnvelopeSchema.safeParse(input);
+  if (!parsedEnvelope.success) {
+    return {
+      valid: false,
+      verificationScope: "integrity-expiration-and-preconditions-only",
+      issues: parsedEnvelope.error.issues.map((issue) => ({
+        code: "invalid-schema",
+        path: issue.path.map((segment) => typeof segment === "symbol" ? segment.description ?? "symbol" : segment),
+        message: issue.message
+      })),
+      integrity: { envelopeDigestValid: false, evidenceDigestValid: false },
+      expiration: { checkedAt, envelopeNotYetValid: false, envelopeExpired: false, expiredApprovalIds: [] },
+      checks: {
+        recorded: 0,
+        passed: [],
+        failed: [],
+        skipped: [],
+        requiredPassed: [...parsedOptions.preconditions?.requiredPassedChecks ?? []].sort(),
+        missingPassed: [...parsedOptions.preconditions?.requiredPassedChecks ?? []].sort()
+      },
+      approvals: {
+        recorded: 0,
+        requiredScopes: [...parsedOptions.preconditions?.requiredApprovalScopes ?? []].sort(),
+        missingScopes: [...parsedOptions.preconditions?.requiredApprovalScopes ?? []].sort(),
+        authenticity: "not-verified"
+      },
+      externalAttestations: {
+        referenced: 0,
+        requiredDigests: [...parsedOptions.preconditions?.requiredAttestationDigests ?? []].sort(),
+        missingDigests: [...parsedOptions.preconditions?.requiredAttestationDigests ?? []].sort(),
+        authenticity: "not-verified"
+      }
+    };
+  }
+  const envelope = parsedEnvelope.data;
+  const issues = [];
+  const computedEvidenceDigest = digestCanonical(evidencePayload(envelope.evidence.checks));
+  const evidenceDigestValid = computedEvidenceDigest === envelope.evidence.evidenceDigest;
+  if (!evidenceDigestValid) {
+    issues.push({
+      code: "evidence-digest-mismatch",
+      path: ["evidence", "evidenceDigest"],
+      message: "Evidence digest does not match the canonical redacted check summary.",
+      expected: computedEvidenceDigest,
+      actual: envelope.evidence.evidenceDigest
+    });
+  }
+  const computedEnvelopeDigest = digestCanonical(envelopePayload(envelope));
+  const envelopeDigestValid = computedEnvelopeDigest === envelope.envelopeId;
+  if (!envelopeDigestValid) {
+    issues.push({
+      code: "envelope-digest-mismatch",
+      path: ["envelopeId"],
+      message: "Envelope digest does not match its canonical payload.",
+      expected: computedEnvelopeDigest,
+      actual: envelope.envelopeId
+    });
+  }
+  const envelopeNotYetValid = now.getTime() < Date.parse(envelope.createdAt);
+  if (envelopeNotYetValid) {
+    issues.push({
+      code: "envelope-not-yet-valid",
+      path: ["createdAt"],
+      message: "Change envelope creation time is in the future."
+    });
+  }
+  const envelopeExpired = envelope.expiresAt !== undefined && now.getTime() >= Date.parse(envelope.expiresAt);
+  if (envelopeExpired) {
+    issues.push({
+      code: "envelope-expired",
+      path: ["expiresAt"],
+      message: "Change envelope has expired."
+    });
+  }
+  const expiredApprovalIds = (envelope.approvals ?? []).filter((approval) => approval.expiresAt !== undefined && now.getTime() >= Date.parse(approval.expiresAt)).map((approval) => approval.approvalId);
+  for (const approvalId of expiredApprovalIds) {
+    issues.push({
+      code: "approval-expired",
+      path: ["approvals", envelope.approvals?.findIndex((approval) => approval.approvalId === approvalId) ?? 0, "expiresAt"],
+      message: `Recorded approval has expired: ${approvalId}.`
+    });
+  }
+  const preconditions = parsedOptions.preconditions;
+  const comparePrecondition = (field, expected, actual, path) => {
+    if (expected !== undefined && expected !== actual) {
+      issues.push({
+        code: "precondition-mismatch",
+        path,
+        message: `Change envelope precondition does not match: ${field}.`,
+        expected,
+        actual
+      });
+    }
+  };
+  comparePrecondition("envelopeId", preconditions?.envelopeId, envelope.envelopeId, ["envelopeId"]);
+  comparePrecondition("baseWorkspaceDigest", preconditions?.baseWorkspaceDigest, envelope.base.workspaceDigest, ["base", "workspaceDigest"]);
+  comparePrecondition("baseTreeDigest", preconditions?.baseTreeDigest, envelope.base.treeDigest, ["base", "treeDigest"]);
+  comparePrecondition("patchId", preconditions?.patchId, envelope.patch.patchId, ["patch", "patchId"]);
+  comparePrecondition("patchDigest", preconditions?.patchDigest, envelope.patch.patchDigest, ["patch", "patchDigest"]);
+  comparePrecondition("harnessFingerprint", preconditions?.harnessFingerprint, envelope.fingerprints.harness, ["fingerprints", "harness"]);
+  comparePrecondition("policyFingerprint", preconditions?.policyFingerprint, envelope.fingerprints.policy, ["fingerprints", "policy"]);
+  comparePrecondition("environmentFingerprint", preconditions?.environmentFingerprint, envelope.fingerprints.environment, ["fingerprints", "environment"]);
+  comparePrecondition("evidenceDigest", preconditions?.evidenceDigest, envelope.evidence.evidenceDigest, ["evidence", "evidenceDigest"]);
+  const passedChecks = envelope.evidence.checks.filter((check) => check.status === "passed").map((check) => check.checkId);
+  const failedChecks = envelope.evidence.checks.filter((check) => check.status === "failed").map((check) => check.checkId);
+  const skippedChecks = envelope.evidence.checks.filter((check) => check.status === "skipped").map((check) => check.checkId);
+  const passedCheckSet = new Set(passedChecks);
+  const requiredPassed = [...preconditions?.requiredPassedChecks ?? []].sort();
+  const missingPassed = requiredPassed.filter((checkId) => !passedCheckSet.has(checkId));
+  for (const checkId of missingPassed) {
+    issues.push({
+      code: "missing-passed-check",
+      path: ["evidence", "checks"],
+      message: `Required passed check is not recorded: ${checkId}.`,
+      expected: checkId
+    });
+  }
+  const expiredApprovals = new Set(expiredApprovalIds);
+  const activeApprovals = (envelope.approvals ?? []).filter((approval) => !expiredApprovals.has(approval.approvalId));
+  const approvalDigests = new Set(activeApprovals.map((approval) => approval.approvalDigest));
+  for (const requiredDigest of preconditions?.requiredApprovalDigests ?? []) {
+    if (!approvalDigests.has(requiredDigest)) {
+      issues.push({
+        code: "missing-approval-digest",
+        path: ["approvals"],
+        message: `Required active approval digest is not recorded: ${requiredDigest}.`,
+        expected: requiredDigest
+      });
+    }
+  }
+  const approvedScopes = new Set(activeApprovals.flatMap((approval) => approval.scopes));
+  const requiredScopes = [...preconditions?.requiredApprovalScopes ?? []].sort();
+  const missingScopes = requiredScopes.filter((scope) => !approvedScopes.has(scope));
+  for (const scope of missingScopes) {
+    issues.push({
+      code: "missing-approval-scope",
+      path: ["approvals"],
+      message: `Required active approval scope is not recorded: ${scope}.`,
+      expected: scope
+    });
+  }
+  const attestationDigests = new Set((envelope.externalAttestations ?? []).map((attestation) => attestation.bundleDigest));
+  const requiredAttestationDigests = [...preconditions?.requiredAttestationDigests ?? []].sort();
+  const missingAttestationDigests = requiredAttestationDigests.filter((digest) => !attestationDigests.has(digest));
+  for (const requiredDigest of missingAttestationDigests) {
+    issues.push({
+      code: "missing-attestation-digest",
+      path: ["externalAttestations"],
+      message: `Required external attestation digest is not referenced: ${requiredDigest}.`,
+      expected: requiredDigest
+    });
+  }
+  return {
+    valid: issues.length === 0,
+    verificationScope: "integrity-expiration-and-preconditions-only",
+    envelope,
+    issues,
+    integrity: { envelopeDigestValid, evidenceDigestValid },
+    expiration: { checkedAt, envelopeNotYetValid, envelopeExpired, expiredApprovalIds },
+    checks: {
+      recorded: envelope.evidence.checks.length,
+      passed: passedChecks,
+      failed: failedChecks,
+      skipped: skippedChecks,
+      requiredPassed,
+      missingPassed
+    },
+    approvals: {
+      recorded: envelope.approvals?.length ?? 0,
+      requiredScopes,
+      missingScopes,
+      authenticity: "not-verified"
+    },
+    externalAttestations: {
+      referenced: envelope.externalAttestations?.length ?? 0,
+      requiredDigests: requiredAttestationDigests,
+      missingDigests: missingAttestationDigests,
+      authenticity: "not-verified"
+    }
+  };
+};
+
+export { CHANGE_ENVELOPE_SCHEMA_VERSION, CHANGE_ENVELOPE_DIGEST_ALGORITHM, MAX_CHANGE_ENVELOPE_CHECKS, MAX_CHANGE_ENVELOPE_APPROVALS, MAX_CHANGE_ENVELOPE_APPROVAL_SCOPES, MAX_CHANGE_ENVELOPE_ATTESTATIONS, changeEnvelopeCheckSchema, changeEnvelopeApprovalSchema, externalAttestationReferenceSchema, changeEnvelopeBaseSchema, changeEnvelopePatchSchema, changeEnvelopeFingerprintsSchema, changeEnvelopeEvidenceSchema, changeEnvelopeInputSchema, changeEnvelopeSchema, digestChangeEnvelopeArtifact, createChangeEnvelope, canonicalizeChangeEnvelope, computeChangeEnvelopeDigest, computeChangeEnvelopeEvidenceDigest, changeEnvelopePreconditionsSchema, verifyChangeEnvelope };

package/dist/index.d.ts

@@ -60,3 +60,6 @@ export { serveAcpStdio } from "./client/acp-stdio.js";
 export { openWorkspaceCheckpointStore } from "./persistence/workspace-checkpoints.js";
 export type { WorkspaceCheckpoint, WorkspaceRestoreOperation } from "./persistence/workspace-checkpoints.js";
 export type { HarnessMcpResourceClient } from "./integrations/mcp.js";
+export { runHarnessDurableReviewGroup, inspectHarnessReviewGroup, cancelHarnessReviewGroup } from "./runtime/durable-review-group.js";
+export type { HarnessDurableReviewGroupResult } from "./runtime/durable-review-group.js";
+export type { HarnessSharedBudgetOptions } from "./runtime/shared-budget.js";