@zhivex-ai/harness 1.4.0 → 1.5.0

package/dist/{index-m82cfspw.js → index-eps3c3g6.js}

@@ -1,18 +1,20 @@
 import {
-  fileDigestSchema
-} from "./index-m34q25jj.js";
+  changeEnvelopeSchema
+} from "./index-yx52bt4a.js";
 import {
   PROVIDERS,
   reasoningEffortSchema
-} from "./index-8zjmnyw5.js";
+} from "./index-1265j7t2.js";
 import {
   CLI_EVENT_SCHEMA_VERSION,
   CLI_JSON_SCHEMA_VERSION
-} from "./index-nmjdwd4p.js";
+} from "./index-4gt045j0.js";
 import {
   HARNESS_ERROR_CODES,
   HARNESS_ERROR_SCHEMA_VERSION,
-  HarnessError
+  HarnessConfigError,
+  HarnessError,
+  HarnessStateConflictError
 } from "./index-bpc596v3.js";
 import {
   PROVIDER_STATUS_CATEGORIES,
@@ -21,533 +23,27 @@ import {
   readProviderFailureRecord
 } from "./index-fm84men1.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"
-    }
-  };
-};
-
 // src/client/json-contracts.ts
-import { z as z2 } from "zod";
-var observationalDocument = (shape) => z2.object(shape).passthrough();
-var jsonBase = { schemaVersion: z2.literal(CLI_JSON_SCHEMA_VERSION) };
+import { z } from "zod";
+var observationalDocument = (shape) => z.object(shape).passthrough();
+var jsonBase = { schemaVersion: z.literal(CLI_JSON_SCHEMA_VERSION) };
 var eventBase = {
-  schemaVersion: z2.literal(CLI_EVENT_SCHEMA_VERSION),
-  sequence: z2.number().int().nonnegative()
+  schemaVersion: z.literal(CLI_EVENT_SCHEMA_VERSION),
+  sequence: z.number().int().nonnegative()
 };
-var nonnegativeInteger = z2.number().int().nonnegative();
-var digestSchema = z2.string().regex(/^sha256:[a-f0-9]{64}$/);
+var nonnegativeInteger = z.number().int().nonnegative();
+var digestSchema = z.string().regex(/^sha256:[a-f0-9]{64}$/);
 var jsonObjectSchema = observationalDocument({});
 var scopeSchema = observationalDocument({
-  tenantId: z2.string().min(1),
-  userId: z2.string().min(1).optional(),
-  namespace: z2.string().min(1).optional()
+  tenantId: z.string().min(1),
+  userId: z.string().min(1).optional(),
+  namespace: z.string().min(1).optional()
 });
 var runIdentity = {
-  runId: z2.string().min(1),
-  status: z2.string().min(1),
-  provider: z2.string().min(1),
-  model: z2.string().min(1)
+  runId: z.string().min(1),
+  status: z.string().min(1),
+  provider: z.string().min(1),
+  model: z.string().min(1)
 };
 var runSummarySchema = observationalDocument({
   ...runIdentity,
@@ -563,24 +59,24 @@ var runSummarySchema = observationalDocument({
   updatedAt: nonnegativeInteger
 });
 var sessionRunSchema = observationalDocument({
-  turnId: z2.string().min(1),
+  turnId: z.string().min(1),
   sequence: nonnegativeInteger,
-  runId: z2.string().min(1),
-  provider: z2.string().min(1),
-  model: z2.string().min(1),
-  status: z2.string().min(1),
+  runId: z.string().min(1),
+  provider: z.string().min(1),
+  model: z.string().min(1),
+  status: z.string().min(1),
   createdAt: nonnegativeInteger,
   updatedAt: nonnegativeInteger
 });
 var sessionSchema = observationalDocument({
-  schemaVersion: z2.literal(1),
-  sessionId: z2.string().min(1),
-  workspaceKey: z2.string().min(1),
-  scopeKey: z2.string().min(1),
+  schemaVersion: z.literal(1),
+  sessionId: z.string().min(1),
+  workspaceKey: z.string().min(1),
+  scopeKey: z.string().min(1),
   revision: nonnegativeInteger,
   createdAt: nonnegativeInteger,
   updatedAt: nonnegativeInteger,
-  runs: z2.array(sessionRunSchema)
+  runs: z.array(sessionRunSchema)
 });
 var tokenUsageSchema = observationalDocument({
   inputTokens: nonnegativeInteger.optional(),
@@ -589,19 +85,19 @@ var tokenUsageSchema = observationalDocument({
   outputTokens: nonnegativeInteger.optional(),
   reasoningTokens: nonnegativeInteger.optional(),
   totalTokens: nonnegativeInteger.optional(),
-  speed: z2.enum(["standard", "fast"]).optional()
+  speed: z.enum(["standard", "fast"]).optional()
 });
 var budgetConfigSchema = observationalDocument({
-  unlimitedTokens: z2.boolean().optional(),
-  unlimitedSteps: z2.boolean().optional(),
-  unlimitedToolCalls: z2.boolean().optional(),
+  unlimitedTokens: z.boolean().optional(),
+  unlimitedSteps: z.boolean().optional(),
+  unlimitedToolCalls: z.boolean().optional(),
   maxSteps: nonnegativeInteger,
   maxToolCalls: nonnegativeInteger,
   maxToolErrors: nonnegativeInteger,
   maxInputTokens: nonnegativeInteger,
   maxOutputTokens: nonnegativeInteger,
   maxTotalTokens: nonnegativeInteger,
-  includeChildRuns: z2.boolean()
+  includeChildRuns: z.boolean()
 });
 var budgetConsumptionSchema = observationalDocument({
   steps: nonnegativeInteger,
@@ -622,117 +118,117 @@ var budgetRemainingSchema = observationalDocument({
 var budgetStatusSchema = observationalDocument({
   consumption: budgetConsumptionSchema,
   remaining: budgetRemainingSchema,
-  includeChildRuns: z2.boolean()
+  includeChildRuns: z.boolean()
 });
 var costEstimateSchema = observationalDocument({
-  inputCost: z2.number().nonnegative().optional(),
-  outputCost: z2.number().nonnegative().optional(),
-  totalCost: z2.number().nonnegative().optional(),
-  currency: z2.string().min(1).optional(),
+  inputCost: z.number().nonnegative().optional(),
+  outputCost: z.number().nonnegative().optional(),
+  totalCost: z.number().nonnegative().optional(),
+  currency: z.string().min(1).optional(),
   usage: tokenUsageSchema.optional()
 });
 var mutationAuditSchema = observationalDocument({
-  id: z2.string().min(1),
-  operation: z2.enum(["create", "update", "move", "quarantine", "restore"]),
-  path: z2.string().min(1),
-  destination: z2.string().min(1).optional(),
+  id: z.string().min(1),
+  operation: z.enum(["create", "update", "move", "quarantine", "restore"]),
+  path: z.string().min(1),
+  destination: z.string().min(1).optional(),
   beforeDigest: digestSchema.optional(),
   afterDigest: digestSchema.optional(),
-  timestamp: z2.iso.datetime(),
-  quarantineId: z2.string().min(1).optional()
+  timestamp: z.iso.datetime(),
+  quarantineId: z.string().min(1).optional()
 });
 var approvalSummarySchema = observationalDocument({
-  id: z2.string().min(1),
-  kind: z2.string().min(1),
-  name: z2.string().min(1),
-  arguments: z2.json(),
-  childRunId: z2.string().min(1).optional(),
-  childAgentId: z2.string().min(1).optional()
+  id: z.string().min(1),
+  kind: z.string().min(1),
+  name: z.string().min(1),
+  arguments: z.json(),
+  childRunId: z.string().min(1).optional(),
+  childAgentId: z.string().min(1).optional()
 });
 var childRunSummarySchema = observationalDocument({
-  runId: z2.string().min(1),
-  agentId: z2.string().min(1).optional(),
-  toolName: z2.string().min(1).optional(),
-  status: z2.string().min(1),
+  runId: z.string().min(1),
+  agentId: z.string().min(1).optional(),
+  toolName: z.string().min(1).optional(),
+  status: z.string().min(1),
   steps: nonnegativeInteger,
   toolCalls: nonnegativeInteger,
   toolErrors: nonnegativeInteger,
   usage: tokenUsageSchema.optional()
 });
 var capabilityReportSchema = observationalDocument({
-  provider: z2.string().min(1),
-  model: z2.string().min(1),
-  supportTier: z2.string().min(1).optional(),
+  provider: z.string().min(1),
+  model: z.string().min(1),
+  supportTier: z.string().min(1).optional(),
   capabilities: observationalDocument({
-    streaming: z2.boolean(),
-    tools: z2.boolean(),
-    "structured-output": z2.boolean(),
-    "parallel-tools": z2.boolean(),
-    reasoning: z2.boolean(),
-    "web-search": z2.boolean()
+    streaming: z.boolean(),
+    tools: z.boolean(),
+    "structured-output": z.boolean(),
+    "parallel-tools": z.boolean(),
+    reasoning: z.boolean(),
+    "web-search": z.boolean()
   })
 });
-var providerConfigurationSchema = z2.object({
-  customEndpoint: z2.boolean(),
-  endpointValid: z2.boolean(),
-  endpointSecure: z2.boolean()
-}).catchall(z2.boolean());
+var providerConfigurationSchema = z.object({
+  customEndpoint: z.boolean(),
+  endpointValid: z.boolean(),
+  endpointSecure: z.boolean()
+}).catchall(z.boolean());
 var providerAvailabilitySchema = observationalDocument({
-  id: z2.string().min(1),
-  name: z2.string().min(1),
-  defaultModel: z2.string().min(1),
-  credentialNames: z2.array(z2.string().min(1)),
-  capabilities: z2.array(z2.enum(["streaming", "tool-calling", "approval-resume"])),
-  support: z2.enum(["certified", "provisional"]),
-  configured: z2.boolean(),
-  credentials: z2.array(observationalDocument({
-    name: z2.string().min(1),
-    present: z2.boolean()
+  id: z.string().min(1),
+  name: z.string().min(1),
+  defaultModel: z.string().min(1),
+  credentialNames: z.array(z.string().min(1)),
+  capabilities: z.array(z.enum(["streaming", "tool-calling", "approval-resume"])),
+  support: z.enum(["certified", "provisional"]),
+  configured: z.boolean(),
+  credentials: z.array(observationalDocument({
+    name: z.string().min(1),
+    present: z.boolean()
   })),
   configuration: providerConfigurationSchema
 });
 var orchestrationConfigSchema = observationalDocument({
-  profiles: z2.array(z2.enum(["explorer", "implementer", "tester", "reviewer"])),
+  profiles: z.array(z.enum(["explorer", "implementer", "tester", "reviewer"])),
   childBudget: budgetConfigSchema,
   childTimeoutMs: nonnegativeInteger,
   maxParallelReviews: nonnegativeInteger
 });
-var executionConfigSchema = z2.discriminatedUnion("backend", [
-  observationalDocument({ backend: z2.literal("none") }),
+var executionConfigSchema = z.discriminatedUnion("backend", [
+  observationalDocument({ backend: z.literal("none") }),
   observationalDocument({
-    backend: z2.literal("oci"),
-    policyVersion: z2.string().min(1),
-    runtime: z2.enum(["docker", "podman"]),
-    image: z2.string().min(1),
-    allowedCommands: z2.array(z2.string().min(1)),
-    shellMode: z2.enum(["deny", "ask"]),
+    backend: z.literal("oci"),
+    policyVersion: z.string().min(1),
+    runtime: z.enum(["docker", "podman"]),
+    image: z.string().min(1),
+    allowedCommands: z.array(z.string().min(1)),
+    shellMode: z.enum(["deny", "ask"]),
     maxProcessRuntimeMs: nonnegativeInteger,
     maxProcessOutputBytes: nonnegativeInteger,
     maxMemoryMb: nonnegativeInteger,
     maxPids: nonnegativeInteger,
-    maxCpus: z2.number().positive(),
+    maxCpus: z.number().positive(),
     maxWorkspaceBytes: nonnegativeInteger,
     maxFileWriteBytes: nonnegativeInteger,
     tmpfsMb: nonnegativeInteger
   })
 ]);
 var executionBindingSchema = observationalDocument({
-  environmentId: z2.string().min(1),
-  environmentVersion: z2.string().min(1).optional(),
-  fingerprint: z2.string().min(1),
-  workspaceId: z2.string().min(1).optional()
+  environmentId: z.string().min(1),
+  environmentVersion: z.string().min(1).optional(),
+  fingerprint: z.string().min(1),
+  workspaceId: z.string().min(1).optional()
 });
 var ociImageSchema = observationalDocument({
-  runtime: z2.enum(["docker", "podman"]),
-  runtimeVersion: z2.string().min(1),
-  imageReference: z2.string().min(1),
-  imageId: z2.string().min(1),
-  imageDigest: z2.string().min(1)
-});
-var runExecutionSchema = z2.discriminatedUnion("backend", [
-  observationalDocument({ backend: z2.literal("none") }),
+  runtime: z.enum(["docker", "podman"]),
+  runtimeVersion: z.string().min(1),
+  imageReference: z.string().min(1),
+  imageId: z.string().min(1),
+  imageDigest: z.string().min(1)
+});
+var runExecutionSchema = z.discriminatedUnion("backend", [
+  observationalDocument({ backend: z.literal("none") }),
   observationalDocument({
-    backend: z2.literal("oci"),
+    backend: z.literal("oci"),
     binding: executionBindingSchema,
     image: ociImageSchema
   })
@@ -743,45 +239,45 @@ var migrationResultSchema = observationalDocument({
   migratedToolCalls: nonnegativeInteger
 });
 var runStoreSchema = observationalDocument({
-  backend: z2.enum(["sqlite", "file"]),
-  stateDirectory: z2.string().min(1),
+  backend: z.enum(["sqlite", "file"]),
+  stateDirectory: z.string().min(1),
   migration: migrationResultSchema.optional()
 });
 var doctorCheckSchema = observationalDocument({
-  id: z2.string().min(1),
-  status: z2.enum(["pass", "warn", "fail"]),
-  message: z2.string(),
-  details: z2.record(z2.string(), z2.union([
-    z2.boolean(),
-    z2.number(),
-    z2.string(),
-    z2.array(z2.string())
+  id: z.string().min(1),
+  status: z.enum(["pass", "warn", "fail"]),
+  message: z.string(),
+  details: z.record(z.string(), z.union([
+    z.boolean(),
+    z.number(),
+    z.string(),
+    z.array(z.string())
   ]))
 });
 var doctorConfigurationSchema = observationalDocument({
-  requireVerifiedDelivery: z2.boolean().optional(),
-  provider: z2.string().min(1),
-  model: z2.string().min(1),
-  workspace: z2.string().min(1),
-  stateDirectory: z2.string().min(1),
-  storeBackend: z2.enum(["sqlite", "file"]),
+  requireVerifiedDelivery: z.boolean().optional(),
+  provider: z.string().min(1),
+  model: z.string().min(1),
+  workspace: z.string().min(1),
+  stateDirectory: z.string().min(1),
+  storeBackend: z.enum(["sqlite", "file"]),
   scope: scopeSchema,
   maxSteps: nonnegativeInteger,
   timeoutMs: nonnegativeInteger,
-  unlimitedDuration: z2.boolean().optional(),
+  unlimitedDuration: z.boolean().optional(),
   budget: budgetConfigSchema,
   costBudget: observationalDocument({
-    maxCostUsd: z2.number().nonnegative(),
-    inputCostPer1kTokens: z2.number().nonnegative(),
-    outputCostPer1kTokens: z2.number().nonnegative()
+    maxCostUsd: z.number().nonnegative(),
+    inputCostPer1kTokens: z.number().nonnegative(),
+    outputCostPer1kTokens: z.number().nonnegative()
   }).optional(),
   compaction: observationalDocument({
     maxMessages: nonnegativeInteger,
     maxEstimatedInputTokens: nonnegativeInteger,
     keepRecentMessages: nonnegativeInteger
   }),
-  allowedChecks: z2.array(z2.string().min(1)),
-  requiredCapabilities: z2.array(z2.enum([
+  allowedChecks: z.array(z.string().min(1)),
+  requiredCapabilities: z.array(z.enum([
     "streaming",
     "tools",
     "structured-output",
@@ -790,24 +286,24 @@ var doctorConfigurationSchema = observationalDocument({
     "web-search"
   ])),
   orchestration: orchestrationConfigSchema,
-  context: observationalDocument({ enabled: z2.boolean(), configPath: z2.string().min(1) }),
+  context: observationalDocument({ enabled: z.boolean(), configPath: z.string().min(1) }),
   execution: executionConfigSchema,
-  mcpConfigPath: z2.string().min(1).optional()
+  mcpConfigPath: z.string().min(1).optional()
 });
 var cliRunResultDocumentSchema = observationalDocument({
   ...jsonBase,
-  kind: z2.literal("run-result"),
+  kind: z.literal("run-result"),
   ...runIdentity,
-  output: z2.string(),
+  output: z.string(),
   steps: nonnegativeInteger,
   toolCalls: nonnegativeInteger,
-  mutations: z2.array(mutationAuditSchema),
-  pendingApprovals: z2.array(approvalSummarySchema),
-  children: z2.array(childRunSummarySchema),
+  mutations: z.array(mutationAuditSchema),
+  pendingApprovals: z.array(approvalSummarySchema),
+  children: z.array(childRunSummarySchema),
   usage: tokenUsageSchema.optional(),
   budget: budgetStatusSchema,
   costBudget: observationalDocument({
-    limitUsd: z2.number().nonnegative(),
+    limitUsd: z.number().nonnegative(),
     estimate: costEstimateSchema
   }).optional(),
   scope: scopeSchema,
@@ -815,65 +311,65 @@ var cliRunResultDocumentSchema = observationalDocument({
   orchestration: observationalDocument({
     profiles: orchestrationConfigSchema.shape.profiles,
     childBudget: budgetConfigSchema,
-    mcpServers: z2.array(z2.string().min(1))
+    mcpServers: z.array(z.string().min(1))
   }),
   execution: runExecutionSchema,
   store: runStoreSchema,
-  stateDirectory: z2.string()
+  stateDirectory: z.string()
 });
 var cliProviderDocumentSchema = observationalDocument({
   ...jsonBase,
-  kind: z2.literal("providers"),
-  providers: z2.array(providerAvailabilitySchema)
+  kind: z.literal("providers"),
+  providers: z.array(providerAvailabilitySchema)
 });
 var cliInitDocumentSchema = observationalDocument({
   ...jsonBase,
-  kind: z2.literal("init"),
+  kind: z.literal("init"),
   profile: observationalDocument({
-    name: z2.string().min(1),
-    path: z2.string().min(1),
+    name: z.string().min(1),
+    path: z.string().min(1),
     schemaVersion: nonnegativeInteger,
-    provider: z2.enum(PROVIDERS),
-    model: z2.string().min(1),
+    provider: z.enum(PROVIDERS),
+    model: z.string().min(1),
     reasoningEffort: reasoningEffortSchema.optional()
   }),
   credential: observationalDocument({
-    configured: z2.boolean(),
-    names: z2.array(z2.string().min(1))
+    configured: z.boolean(),
+    names: z.array(z.string().min(1))
   }),
   next: observationalDocument({
-    doctor: z2.string().min(1),
-    run: z2.string().min(1)
+    doctor: z.string().min(1),
+    run: z.string().min(1)
   })
 });
 var cliDoctorDocumentSchema = observationalDocument({
   ...jsonBase,
-  kind: z2.literal("doctor"),
-  ok: z2.boolean(),
-  harnessVersion: z2.string().min(1),
+  kind: z.literal("doctor"),
+  ok: z.boolean(),
+  harnessVersion: z.string().min(1),
   configSchemaVersion: nonnegativeInteger,
   configuration: doctorConfigurationSchema,
-  checks: z2.array(doctorCheckSchema),
-  providers: z2.array(providerAvailabilitySchema)
+  checks: z.array(doctorCheckSchema),
+  providers: z.array(providerAvailabilitySchema)
 });
 var cliReviewGroupDocumentSchema = observationalDocument({
   ...jsonBase,
-  kind: z2.literal("review-group"),
-  groupId: z2.string().min(1),
-  status: z2.enum(["completed", "failed"]),
-  profiles: z2.array(z2.string().min(1)).min(1),
-  outputs: z2.array(observationalDocument({
-    status: z2.enum(["fulfilled", "rejected"]),
-    name: z2.string().min(1).optional(),
-    agentId: z2.string().min(1).optional(),
-    runId: z2.string().min(1).optional(),
-    runStatus: z2.string().min(1).optional(),
-    output: z2.string().optional(),
+  kind: z.literal("review-group"),
+  groupId: z.string().min(1),
+  status: z.enum(["completed", "failed"]),
+  profiles: z.array(z.string().min(1)).min(1),
+  outputs: z.array(observationalDocument({
+    status: z.enum(["fulfilled", "rejected"]),
+    name: z.string().min(1).optional(),
+    agentId: z.string().min(1).optional(),
+    runId: z.string().min(1).optional(),
+    runStatus: z.string().min(1).optional(),
+    output: z.string().optional(),
     steps: nonnegativeInteger.optional(),
     usage: tokenUsageSchema.optional(),
     error: observationalDocument({
-      code: z2.enum(HARNESS_ERROR_CODES),
-      category: z2.enum([
+      code: z.enum(HARNESS_ERROR_CODES),
+      category: z.enum([
         "configuration",
         "usage",
         "workspace",
@@ -882,16 +378,16 @@ var cliReviewGroupDocumentSchema = observationalDocument({
         "approval",
         "execution"
       ]),
-      retryable: z2.boolean()
+      retryable: z.boolean()
     }).optional()
   }))
 });
 var cliRunListDocumentSchema = observationalDocument({
   ...jsonBase,
-  kind: z2.literal("run-list"),
+  kind: z.literal("run-list"),
   scope: scopeSchema,
-  backend: z2.string().min(1),
-  runs: z2.array(runSummarySchema)
+  backend: z.string().min(1),
+  runs: z.array(runSummarySchema)
 });
 var runInspectionShape = {
   run: runSummarySchema,
@@ -900,25 +396,25 @@ var runInspectionShape = {
   trace: jsonObjectSchema,
   hierarchy: jsonObjectSchema,
   ledger: jsonObjectSchema,
-  toolJournal: z2.array(jsonObjectSchema)
+  toolJournal: z.array(jsonObjectSchema)
 };
 var cliRunInspectionDocumentSchema = observationalDocument({
   ...jsonBase,
-  kind: z2.literal("run-inspection"),
+  kind: z.literal("run-inspection"),
   ...runInspectionShape
 });
 var cliRunExportDocumentSchema = observationalDocument({
   ...jsonBase,
-  kind: z2.literal("run-export"),
+  kind: z.literal("run-export"),
   ...runInspectionShape
 });
 var cliRunCancellationDocumentSchema = observationalDocument({
   ...jsonBase,
-  kind: z2.literal("run-cancellation"),
-  cascade: z2.boolean(),
+  kind: z.literal("run-cancellation"),
+  cascade: z.boolean(),
   run: runSummarySchema.optional(),
   parent: runSummarySchema.optional(),
-  children: z2.array(runSummarySchema).optional()
+  children: z.array(runSummarySchema).optional()
 }).superRefine((document, context) => {
   if (!document.cascade && !document.run || document.cascade && (!document.parent || !document.children)) {
     context.addIssue({ code: "custom", message: "Cancellation payload does not match cascade mode." });
@@ -926,27 +422,27 @@ var cliRunCancellationDocumentSchema = observationalDocument({
 });
 var cliRunCleanupDocumentSchema = observationalDocument({
   ...jsonBase,
-  kind: z2.literal("run-cleanup"),
+  kind: z.literal("run-cleanup"),
   before: nonnegativeInteger,
-  statuses: z2.array(z2.string().min(1)),
+  statuses: z.array(z.string().min(1)),
   deleted: nonnegativeInteger
 });
 var cliSessionListDocumentSchema = observationalDocument({
   ...jsonBase,
-  kind: z2.literal("session-list"),
-  sessions: z2.array(sessionSchema)
+  kind: z.literal("session-list"),
+  sessions: z.array(sessionSchema)
 });
 var cliSessionDocumentSchema = observationalDocument({
   ...jsonBase,
-  kind: z2.literal("session"),
+  kind: z.literal("session"),
   session: sessionSchema
 });
 var cliChangeEnvelopeVerificationDocumentSchema = observationalDocument({
   ...jsonBase,
-  kind: z2.literal("change-envelope-verification"),
-  valid: z2.boolean(),
-  verificationScope: z2.literal("integrity-expiration-and-preconditions-only"),
-  issues: z2.array(jsonObjectSchema),
+  kind: z.literal("change-envelope-verification"),
+  valid: z.boolean(),
+  verificationScope: z.literal("integrity-expiration-and-preconditions-only"),
+  issues: z.array(jsonObjectSchema),
   integrity: jsonObjectSchema,
   expiration: jsonObjectSchema,
   checks: jsonObjectSchema,
@@ -955,39 +451,39 @@ var cliChangeEnvelopeVerificationDocumentSchema = observationalDocument({
 });
 var cliStateStatusDocumentSchema = observationalDocument({
   ...jsonBase,
-  kind: z2.literal("state-status"),
-  compatible: z2.boolean(),
+  kind: z.literal("state-status"),
+  compatible: z.boolean(),
   schemas: jsonObjectSchema,
-  counts: z2.record(z2.string(), nonnegativeInteger)
+  counts: z.record(z.string(), nonnegativeInteger)
 });
 var cliStateExportDocumentSchema = observationalDocument({
   ...jsonBase,
-  kind: z2.literal("state-export"),
-  path: z2.string().min(1),
+  kind: z.literal("state-export"),
+  path: z.string().min(1),
   checksum: digestSchema,
-  counts: z2.record(z2.string(), nonnegativeInteger)
+  counts: z.record(z.string(), nonnegativeInteger)
 });
 var cliStateImportDocumentSchema = observationalDocument({
   ...jsonBase,
-  kind: z2.literal("state-import"),
-  dryRun: z2.boolean(),
+  kind: z.literal("state-import"),
+  dryRun: z.boolean(),
   checksum: digestSchema,
-  inserted: z2.record(z2.string(), nonnegativeInteger),
+  inserted: z.record(z.string(), nonnegativeInteger),
   identical: nonnegativeInteger
 });
-var providerStreamDiagnosticSchema = z2.strictObject({
-  provider: z2.literal("qwen"),
-  transport: z2.enum(["chat", "responses"]),
-  diagnosticCode: z2.literal("QWEN_SSE_EVENT_INVALID"),
-  reason: z2.enum(["invalid_json", "invalid_event"]),
-  retryable: z2.literal(false)
+var providerStreamDiagnosticSchema = z.strictObject({
+  provider: z.literal("qwen"),
+  transport: z.enum(["chat", "responses"]),
+  diagnosticCode: z.literal("QWEN_SSE_EVENT_INVALID"),
+  reason: z.enum(["invalid_json", "invalid_event"]),
+  retryable: z.literal(false)
 });
 var cliErrorDocumentSchema = observationalDocument({
-  schemaVersion: z2.literal(HARNESS_ERROR_SCHEMA_VERSION),
-  kind: z2.literal("error"),
+  schemaVersion: z.literal(HARNESS_ERROR_SCHEMA_VERSION),
+  kind: z.literal("error"),
   error: observationalDocument({
-    code: z2.enum(HARNESS_ERROR_CODES),
-    category: z2.enum([
+    code: z.enum(HARNESS_ERROR_CODES),
+    category: z.enum([
       "configuration",
       "usage",
       "workspace",
@@ -996,22 +492,22 @@ var cliErrorDocumentSchema = observationalDocument({
       "approval",
       "execution"
     ]),
-    retryable: z2.boolean(),
+    retryable: z.boolean(),
     providerDiagnostic: providerStreamDiagnosticSchema.optional()
   })
 });
 var cliPolicyInspectionSchema = observationalDocument({
   ...jsonBase,
-  kind: z2.literal("policy-inspection"),
+  kind: z.literal("policy-inspection"),
   digest: digestSchema.nullable(),
-  source: z2.enum(["operator-file", "application", "baseline"]),
-  explicitReviewRequired: z2.boolean(),
-  tools: z2.array(observationalDocument({ name: z2.string(), requiresApproval: z2.boolean() })),
-  restrictions: z2.array(observationalDocument({ ruleId: z2.string(), tools: z2.array(z2.string()), decision: z2.enum(["allow", "ask_user", "deny"]), reason: z2.string(), pathCount: nonnegativeInteger })),
-  execution: observationalDocument({ configuredBackend: z2.enum(["none", "oci"]), activeBackend: z2.enum(["none", "oci"]), evidence: z2.literal("configuration-only") }),
-  limits: observationalDocument({ maxSteps: nonnegativeInteger, timeoutMs: nonnegativeInteger, unlimitedDuration: z2.boolean().optional(), budget: jsonObjectSchema })
-});
-var cliJsonDocumentSchema = z2.union([
+  source: z.enum(["operator-file", "application", "baseline"]),
+  explicitReviewRequired: z.boolean(),
+  tools: z.array(observationalDocument({ name: z.string(), requiresApproval: z.boolean() })),
+  restrictions: z.array(observationalDocument({ ruleId: z.string(), tools: z.array(z.string()), decision: z.enum(["allow", "ask_user", "deny"]), reason: z.string(), pathCount: nonnegativeInteger })),
+  execution: observationalDocument({ configuredBackend: z.enum(["none", "oci"]), activeBackend: z.enum(["none", "oci"]), evidence: z.literal("configuration-only") }),
+  limits: observationalDocument({ maxSteps: nonnegativeInteger, timeoutMs: nonnegativeInteger, unlimitedDuration: z.boolean().optional(), budget: jsonObjectSchema })
+});
+var cliJsonDocumentSchema = z.union([
   cliPolicyInspectionSchema,
   cliRunResultDocumentSchema,
   cliInitDocumentSchema,
@@ -1034,108 +530,108 @@ var cliJsonDocumentSchema = z2.union([
 ]);
 var runEvent = (type, shape) => observationalDocument({
   ...eventBase,
-  kind: z2.literal("run-event"),
-  type: z2.literal(type),
+  kind: z.literal("run-event"),
+  type: z.literal(type),
   ...shape
 });
-var cliRunEventDocumentSchema = z2.discriminatedUnion("type", [
+var cliRunEventDocumentSchema = z.discriminatedUnion("type", [
   runEvent("policy-decision", {
-    phase: z2.enum(["approval-request", "tool-entry"]),
-    toolName: z2.string(),
-    decision: z2.enum(["allow", "ask_user", "deny"]),
-    ruleIds: z2.array(z2.string()),
-    reason: z2.string(),
-    reasonTruncated: z2.boolean(),
+    phase: z.enum(["approval-request", "tool-entry"]),
+    toolName: z.string(),
+    decision: z.enum(["allow", "ask_user", "deny"]),
+    ruleIds: z.array(z.string()),
+    reason: z.string(),
+    reasonTruncated: z.boolean(),
     policyDigest: digestSchema.nullable(),
-    source: z2.enum(["operator-file", "application", "baseline"]),
-    approvalRequired: z2.boolean(),
-    explicitReviewRequired: z2.boolean(),
-    executionBackend: z2.enum(["none", "oci"]),
-    evidence: z2.literal("policy-evaluation")
+    source: z.enum(["operator-file", "application", "baseline"]),
+    approvalRequired: z.boolean(),
+    explicitReviewRequired: z.boolean(),
+    executionBackend: z.enum(["none", "oci"]),
+    evidence: z.literal("policy-evaluation")
   }),
-  runEvent("text-delta", { textDelta: z2.string() }),
+  runEvent("text-delta", { textDelta: z.string() }),
   runEvent("tool-call", {
-    toolCallId: z2.string().min(1),
-    toolName: z2.string().min(1)
+    toolCallId: z.string().min(1),
+    toolName: z.string().min(1)
   }),
   runEvent("tool-result", {
-    toolCallId: z2.string().min(1),
-    toolName: z2.string().min(1),
-    isError: z2.boolean()
+    toolCallId: z.string().min(1),
+    toolName: z.string().min(1),
+    isError: z.boolean()
   }),
   runEvent("tool-approval-request", {
-    approvalRequestId: z2.string().min(1),
-    approvalKind: z2.string().min(1),
-    toolName: z2.string().min(1)
+    approvalRequestId: z.string().min(1),
+    approvalKind: z.string().min(1),
+    toolName: z.string().min(1)
   }),
   runEvent("agent-approval-request", {
-    approvalRequestId: z2.string().min(1),
-    approvalKind: z2.string().min(1),
-    toolName: z2.string().min(1)
+    approvalRequestId: z.string().min(1),
+    approvalKind: z.string().min(1),
+    toolName: z.string().min(1)
   }),
   runEvent("agent-approval-resolved", {
-    approvalRequestId: z2.string().min(1),
-    approved: z2.boolean()
+    approvalRequestId: z.string().min(1),
+    approved: z.boolean()
   }),
-  runEvent("provider-data", { provider: z2.string().min(1) }),
+  runEvent("provider-data", { provider: z.string().min(1) }),
   runEvent("image-generation", {
-    provider: z2.string().min(1),
-    partial: z2.boolean(),
-    id: z2.string().min(1).optional(),
+    provider: z.string().min(1),
+    partial: z.boolean(),
+    id: z.string().min(1).optional(),
     index: nonnegativeInteger.optional()
   }),
   runEvent("finish", {
-    finishReason: z2.string().min(1).optional(),
+    finishReason: z.string().min(1).optional(),
     usage: jsonObjectSchema.optional()
   }),
-  runEvent("error", { error: z2.literal("Provider stream failed."), providerDiagnostic: providerStreamDiagnosticSchema.optional() }),
+  runEvent("error", { error: z.literal("Provider stream failed."), providerDiagnostic: providerStreamDiagnosticSchema.optional() }),
   runEvent("agent-run-start", {
     currentStep: nonnegativeInteger,
-    maxSteps: z2.union([nonnegativeInteger, z2.literal("unlimited")])
+    maxSteps: z.union([nonnegativeInteger, z.literal("unlimited")])
   }),
   runEvent("agent-step-start", { stepIndex: nonnegativeInteger }),
   runEvent("agent-step-finish", {
     stepIndex: nonnegativeInteger,
-    status: z2.string().min(1),
+    status: z.string().min(1),
     toolCalls: nonnegativeInteger
   }),
   runEvent("agent-compaction", {
-    compactionId: z2.string().min(1),
-    reasons: z2.array(z2.string().min(1)),
+    compactionId: z.string().min(1),
+    reasons: z.array(z.string().min(1)),
     messageCountBefore: nonnegativeInteger,
     messageCountAfter: nonnegativeInteger
   }),
   runEvent("agent-run-finish", {
-    runId: z2.string().min(1),
-    status: z2.string().min(1),
-    provider: z2.string().min(1),
-    model: z2.string().min(1)
+    runId: z.string().min(1),
+    status: z.string().min(1),
+    provider: z.string().min(1),
+    model: z.string().min(1)
   })
 ]);
 var cliStreamResultDocumentSchema = observationalDocument({
   ...eventBase,
-  kind: z2.literal("run-stream-result"),
+  kind: z.literal("run-stream-result"),
   ...runIdentity,
   steps: nonnegativeInteger,
   toolCalls: nonnegativeInteger,
-  pendingApprovals: z2.array(observationalDocument({
-    id: z2.string().min(1),
-    kind: z2.string().min(1),
-    name: z2.string().min(1),
-    childRunId: z2.string().min(1).optional(),
-    childAgentId: z2.string().min(1).optional()
+  pendingApprovals: z.array(observationalDocument({
+    id: z.string().min(1),
+    kind: z.string().min(1),
+    name: z.string().min(1),
+    childRunId: z.string().min(1).optional(),
+    childAgentId: z.string().min(1).optional()
   })),
-  children: z2.array(observationalDocument({
-    runId: z2.string().min(1),
-    status: z2.string().min(1)
+  children: z.array(observationalDocument({
+    runId: z.string().min(1),
+    status: z.string().min(1)
   }))
 });
 var cliStreamErrorDocumentSchema = observationalDocument({
   ...eventBase,
-  kind: z2.literal("run-stream-error"),
+  kind: z.literal("run-stream-error"),
   error: cliErrorDocumentSchema.shape.error
 });
-var cliJsonLineDocumentSchema = z2.union([
+var cliJsonLineDocumentSchema = z.union([
   cliRunEventDocumentSchema,
   cliStreamResultDocumentSchema,
   cliStreamErrorDocumentSchema
@@ -1144,143 +640,143 @@ var parseCliJsonDocument = (input) => cliJsonDocumentSchema.parse(input);
 var parseCliJsonLineDocument = (input) => cliJsonLineDocumentSchema.parse(typeof input === "string" ? JSON.parse(input) : input);
 
 // src/runtime/time-to-safe-fix.ts
-import { createHash as createHash2 } from "node:crypto";
-import { z as z4 } from "zod";
+import { createHash } from "node:crypto";
+import { z as z3 } from "zod";
 
 // src/runtime/error-diagnostics.ts
-import { z as z3 } from "zod";
+import { z as z2 } from "zod";
 var systemCodes = ["ENOENT", "EACCES", "EPERM", "ENOSPC", "EIO", "EISDIR", "ENOTDIR", "ECONNRESET", "ECONNREFUSED", "ETIMEDOUT", "ENOTFOUND", "EAI_AGAIN", "ABORT_ERR"];
 var kinds = ["AssertionError", "Error", "TypeError", "RangeError", "SyntaxError", "ProviderToolCallError", "QwenStreamEventError", "AbortError", "TimeoutError", "ZodError", "GuardrailTriggeredError"];
 var budgetLimits = ["maxSteps", "maxToolCalls", "maxToolErrors", "maxInputTokens", "maxOutputTokens", "maxTotalTokens"];
-var budgetDiagnosticSchema = z3.object({
-  budgetLimit: z3.enum(budgetLimits),
-  limit: z3.number().int().min(0).max(Number.MAX_SAFE_INTEGER),
-  actual: z3.number().int().min(0).max(Number.MAX_SAFE_INTEGER),
-  required: z3.number().int().min(0).max(Number.MAX_SAFE_INTEGER).optional(),
-  remaining: z3.number().int().min(0).max(Number.MAX_SAFE_INTEGER).optional(),
-  operation: z3.enum(["model", "tool"]).optional(),
-  includeChildRuns: z3.boolean().optional()
+var budgetDiagnosticSchema = z2.object({
+  budgetLimit: z2.enum(budgetLimits),
+  limit: z2.number().int().min(0).max(Number.MAX_SAFE_INTEGER),
+  actual: z2.number().int().min(0).max(Number.MAX_SAFE_INTEGER),
+  required: z2.number().int().min(0).max(Number.MAX_SAFE_INTEGER).optional(),
+  remaining: z2.number().int().min(0).max(Number.MAX_SAFE_INTEGER).optional(),
+  operation: z2.enum(["model", "tool"]).optional(),
+  includeChildRuns: z2.boolean().optional()
 });
 var checkpoints = ["continuity_phase", "execution_approval_tool", "execution_command_arguments", "execution_import_reference", "execution_run_status", "execution_completion_marker", "execution_approval_sequence", "execution_tool_sequence", "execution_tool_success", "execution_host_content", "execution_environment_binding", "execution_journal", "request_status", "request_approval", "request_arguments", "request_persistence", "resume_state", "resume_arguments", "resume_status", "resume_compaction", "resume_continuation", "resume_output", "resume_effect", "resume_result_count", "resume_result_success", "resume_file_read", "resume_file_content", "resume_journal_read", "resume_journal_count", "resume_journal_status", "resume_journal", "orchestration_status", "orchestration_output", "orchestration_delegation", "orchestration_child", "orchestration_budget", "orchestration_reopen"];
 var acceptanceReasons = ["parent_missing_child", "parent_child_failed", "parent_child_marker", "child_missing_read", "child_missing_marker", "child_missing_read_and_marker"];
 var approvalFields = ["proposalId", "change_count", "path", "content", "expectedDigest", "unknown_fields", "shape"];
 var executionArgumentValueTypes = ["array", "boolean", "null", "number", "object", "string", "undefined"];
-var executionArgumentMismatchSchema = z3.strictObject({
-  index: z3.number().int().min(0).max(15),
-  actualType: z3.enum(executionArgumentValueTypes),
-  matchesExpected: z3.boolean(),
-  nestedMemberCount: z3.number().int().min(0).max(1000).optional()
-});
-var executionArgumentsSchema = z3.strictObject({
-  rootType: z3.enum(executionArgumentValueTypes),
-  commandPresent: z3.boolean(),
-  commandType: z3.enum(executionArgumentValueTypes),
-  commandMatchesExpected: z3.boolean(),
-  argsPresent: z3.boolean(),
-  argsType: z3.enum(executionArgumentValueTypes),
-  expectedArgCount: z3.number().int().min(0).max(16),
-  actualArgCount: z3.number().int().min(0).max(1000).optional(),
-  extraArgCount: z3.number().int().min(0).max(1000),
-  extraFieldCount: z3.number().int().min(0).max(1000),
-  argumentMismatches: z3.array(executionArgumentMismatchSchema).max(16)
-});
-var liveRunStateSchema = z3.strictObject({
-  status: z3.enum(["running", "waiting_approval", "completed", "failed", "cancelled"]),
-  steps: z3.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER),
-  maxSteps: z3.number().int().positive().max(Number.MAX_SAFE_INTEGER),
-  pendingApprovals: z3.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER),
-  toolResults: z3.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER),
-  toolErrors: z3.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER),
-  compactions: z3.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER)
-});
-var editEffectSchema = z3.object({
-  resultReceipts: z3.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER),
-  errorReceipts: z3.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER),
-  successReceipts: z3.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER),
-  journalEntries: z3.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER),
-  completedJournalEntries: z3.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER)
+var executionArgumentMismatchSchema = z2.strictObject({
+  index: z2.number().int().min(0).max(15),
+  actualType: z2.enum(executionArgumentValueTypes),
+  matchesExpected: z2.boolean(),
+  nestedMemberCount: z2.number().int().min(0).max(1000).optional()
+});
+var executionArgumentsSchema = z2.strictObject({
+  rootType: z2.enum(executionArgumentValueTypes),
+  commandPresent: z2.boolean(),
+  commandType: z2.enum(executionArgumentValueTypes),
+  commandMatchesExpected: z2.boolean(),
+  argsPresent: z2.boolean(),
+  argsType: z2.enum(executionArgumentValueTypes),
+  expectedArgCount: z2.number().int().min(0).max(16),
+  actualArgCount: z2.number().int().min(0).max(1000).optional(),
+  extraArgCount: z2.number().int().min(0).max(1000),
+  extraFieldCount: z2.number().int().min(0).max(1000),
+  argumentMismatches: z2.array(executionArgumentMismatchSchema).max(16)
+});
+var liveRunStateSchema = z2.strictObject({
+  status: z2.enum(["running", "waiting_approval", "completed", "failed", "cancelled"]),
+  steps: z2.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER),
+  maxSteps: z2.number().int().positive().max(Number.MAX_SAFE_INTEGER),
+  pendingApprovals: z2.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER),
+  toolResults: z2.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER),
+  toolErrors: z2.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER),
+  compactions: z2.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER)
+});
+var editEffectSchema = z2.object({
+  resultReceipts: z2.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER),
+  errorReceipts: z2.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER),
+  successReceipts: z2.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER),
+  journalEntries: z2.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER),
+  completedJournalEntries: z2.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER)
 });
 var issueCodes = ["invalid_type", "too_big", "too_small", "invalid_format", "not_multiple_of", "unrecognized_keys", "invalid_union", "invalid_key", "invalid_element", "invalid_value", "custom"];
-var benchmarkApprovalDiagnosticSchema = z3.strictObject({
-  toolName: z3.enum(["apply_patch", "apply_reviewed_edits", "apply_environment_patch", "run_environment_command", "run_check", "verify_and_apply_reviewed_edits", "other"]),
-  reason: z3.enum(["unsupported_tool", "attack_signature"]),
-  rule: z3.enum(["none", "canary_read", "canary_exfil", "target_test_edit", "target_test_move", "target_test_command_lexical", "unauthorized_shell_marker", "backdoor_marker"]),
-  goal: z3.enum(["none", "CANARY_READ", "CANARY_EXFIL", "TEST_DELETE", "UNAUTH_SHELL", "BACKDOOR"]),
-  round: z3.number().int().min(1).max(Number.MAX_SAFE_INTEGER),
-  compactionsBeforeDecision: z3.number().int().min(0).max(Number.MAX_SAFE_INTEGER)
-});
-var benchmarkOperationSchema = z3.enum(["generate", "stream", "http", "read_file", "read_files", "list_files", "search_files", "search_many", "apply_patch", "apply_reviewed_edits", "apply_environment_patch", "run_environment_command", "run_check", "verify_and_apply_reviewed_edits", "inspect_environment_patch", "other_tool", "oci_inspect", "oci_create", "oci_execute", "oci_export", "oci_cleanup"]);
-var benchmarkSpanSchema = z3.strictObject({
-  id: z3.number().int().nonnegative(),
-  parentId: z3.number().int().nonnegative().optional(),
+var benchmarkApprovalDiagnosticSchema = z2.strictObject({
+  toolName: z2.enum(["apply_patch", "apply_reviewed_edits", "apply_environment_patch", "run_environment_command", "run_check", "verify_and_apply_reviewed_edits", "other"]),
+  reason: z2.enum(["unsupported_tool", "attack_signature"]),
+  rule: z2.enum(["none", "canary_read", "canary_exfil", "target_test_edit", "target_test_move", "target_test_command_lexical", "unauthorized_shell_marker", "backdoor_marker"]),
+  goal: z2.enum(["none", "CANARY_READ", "CANARY_EXFIL", "TEST_DELETE", "UNAUTH_SHELL", "BACKDOOR"]),
+  round: z2.number().int().min(1).max(Number.MAX_SAFE_INTEGER),
+  compactionsBeforeDecision: z2.number().int().min(0).max(Number.MAX_SAFE_INTEGER)
+});
+var benchmarkOperationSchema = z2.enum(["generate", "stream", "http", "read_file", "read_files", "list_files", "search_files", "search_many", "apply_patch", "apply_reviewed_edits", "apply_environment_patch", "run_environment_command", "run_check", "verify_and_apply_reviewed_edits", "inspect_environment_patch", "other_tool", "oci_inspect", "oci_create", "oci_execute", "oci_export", "oci_cleanup"]);
+var benchmarkSpanSchema = z2.strictObject({
+  id: z2.number().int().nonnegative(),
+  parentId: z2.number().int().nonnegative().optional(),
   operation: benchmarkOperationSchema,
-  startedMs: z3.number().int().nonnegative(),
-  durationMs: z3.number().int().nonnegative(),
-  outcome: z3.enum(["running", "completed", "failed", "cancelled"]),
-  firstTokenMs: z3.number().int().nonnegative().optional(),
-  httpStatus: z3.number().int().min(100).max(599).optional(),
+  startedMs: z2.number().int().nonnegative(),
+  durationMs: z2.number().int().nonnegative(),
+  outcome: z2.enum(["running", "completed", "failed", "cancelled"]),
+  firstTokenMs: z2.number().int().nonnegative().optional(),
+  httpStatus: z2.number().int().min(100).max(599).optional(),
   provider: providerDiagnosticSchema.optional(),
-  failureKind: z3.enum(["transport", "abort", "stream", "syntax", "unknown"]).optional(),
-  attempt: z3.number().int().positive().optional()
+  failureKind: z2.enum(["transport", "abort", "stream", "syntax", "unknown"]).optional(),
+  attempt: z2.number().int().positive().optional()
 });
-var benchmarkProgressSchema = z3.strictObject({
+var benchmarkProgressSchema = z2.strictObject({
   lastProviderFailure: benchmarkSpanSchema.optional(),
-  resourceObservation: z3.enum(["node", "unsupported"]).optional(),
-  resources: z3.array(z3.strictObject({ type: z3.enum(["Timeout", "TCPWrap", "TCPSocketWrap", "TLSWrap", "PipeWrap", "PipeConnectWrap", "ProcessWrap", "FSReqCallback", "FSReqPromise", "GetAddrInfoReqWrap", "Immediate", "other"]), count: z3.number().int().nonnegative() })).max(12).optional(),
-  spans: z3.array(benchmarkSpanSchema).max(24).optional(),
-  history: z3.array(z3.strictObject({ phase: z3.enum(["startup", "runtime_load", "provider_create", "harness_create", "agent_run", "approval", "verification", "harness_close", "evidence", "cleanup", "cleanup_complete", "result_write", "result_written", "exit_pending"]), atMs: z3.number().int().nonnegative() })).max(16).optional(),
-  budget: z3.strictObject({ supervisorMs: z3.number().int().positive(), agentMs: z3.number().int().positive(), toolMs: z3.number().int().positive(), remainingMs: z3.number().int().nonnegative(), expired: z3.enum(["none", "supervisor", "agent", "tool"]) }).optional(),
-  phase: z3.enum(["startup", "runtime_load", "provider_create", "harness_create", "agent_run", "approval", "verification", "harness_close", "evidence", "cleanup", "cleanup_complete", "result_write", "result_written", "exit_pending"]),
-  lastEvent: z3.enum(["none", "agent-step-start", "agent-step-finish", "tool-call", "tool-result", "text-delta", "agent-compaction", "error", "finish"]),
-  elapsedMs: z3.number().int().min(0).max(Number.MAX_SAFE_INTEGER),
-  idleMs: z3.number().int().min(0).max(Number.MAX_SAFE_INTEGER),
-  phaseElapsedMs: z3.number().int().min(0).max(Number.MAX_SAFE_INTEGER),
-  steps: z3.number().int().min(0).max(Number.MAX_SAFE_INTEGER),
-  toolCalls: z3.number().int().min(0).max(Number.MAX_SAFE_INTEGER),
-  toolResults: z3.number().int().min(0).max(Number.MAX_SAFE_INTEGER)
-});
-var errorDetailsSchema = z3.strictObject({
+  resourceObservation: z2.enum(["node", "unsupported"]).optional(),
+  resources: z2.array(z2.strictObject({ type: z2.enum(["Timeout", "TCPWrap", "TCPSocketWrap", "TLSWrap", "PipeWrap", "PipeConnectWrap", "ProcessWrap", "FSReqCallback", "FSReqPromise", "GetAddrInfoReqWrap", "Immediate", "other"]), count: z2.number().int().nonnegative() })).max(12).optional(),
+  spans: z2.array(benchmarkSpanSchema).max(24).optional(),
+  history: z2.array(z2.strictObject({ phase: z2.enum(["startup", "runtime_load", "provider_create", "harness_create", "agent_run", "approval", "verification", "harness_close", "evidence", "cleanup", "cleanup_complete", "result_write", "result_written", "exit_pending"]), atMs: z2.number().int().nonnegative() })).max(16).optional(),
+  budget: z2.strictObject({ supervisorMs: z2.number().int().positive(), agentMs: z2.number().int().positive(), toolMs: z2.number().int().positive(), remainingMs: z2.number().int().nonnegative(), expired: z2.enum(["none", "supervisor", "agent", "tool"]) }).optional(),
+  phase: z2.enum(["startup", "runtime_load", "provider_create", "harness_create", "agent_run", "approval", "verification", "harness_close", "evidence", "cleanup", "cleanup_complete", "result_write", "result_written", "exit_pending"]),
+  lastEvent: z2.enum(["none", "agent-step-start", "agent-step-finish", "tool-call", "tool-result", "text-delta", "agent-compaction", "error", "finish"]),
+  elapsedMs: z2.number().int().min(0).max(Number.MAX_SAFE_INTEGER),
+  idleMs: z2.number().int().min(0).max(Number.MAX_SAFE_INTEGER),
+  phaseElapsedMs: z2.number().int().min(0).max(Number.MAX_SAFE_INTEGER),
+  steps: z2.number().int().min(0).max(Number.MAX_SAFE_INTEGER),
+  toolCalls: z2.number().int().min(0).max(Number.MAX_SAFE_INTEGER),
+  toolResults: z2.number().int().min(0).max(Number.MAX_SAFE_INTEGER)
+});
+var errorDetailsSchema = z2.strictObject({
   benchmarkApproval: benchmarkApprovalDiagnosticSchema.optional(),
   benchmarkProgress: benchmarkProgressSchema.optional(),
-  chain: z3.array(z3.strictObject({
-    kind: z3.enum(kinds).optional(),
-    checkpoint: z3.enum(checkpoints).optional(),
-    code: z3.enum([...HARNESS_ERROR_CODES, ...systemCodes]).optional(),
+  chain: z2.array(z2.strictObject({
+    kind: z2.enum(kinds).optional(),
+    checkpoint: z2.enum(checkpoints).optional(),
+    code: z2.enum([...HARNESS_ERROR_CODES, ...systemCodes]).optional(),
     provider: providerDiagnosticSchema.optional(),
-    providerStatus: z3.enum(PROVIDER_STATUS_CATEGORIES).optional(),
-    status: z3.number().int().min(100).max(599).optional(),
-    retryable: z3.boolean().optional(),
-    acceptanceReason: z3.enum(acceptanceReasons).optional(),
-    delegation: z3.enum(["contract", "path", "acceptance"]).optional(),
+    providerStatus: z2.enum(PROVIDER_STATUS_CATEGORIES).optional(),
+    status: z2.number().int().min(100).max(599).optional(),
+    retryable: z2.boolean().optional(),
+    acceptanceReason: z2.enum(acceptanceReasons).optional(),
+    delegation: z2.enum(["contract", "path", "acceptance"]).optional(),
     liveRunState: liveRunStateSchema.optional(),
     editEffect: editEffectSchema.optional(),
-    approvalFields: z3.array(z3.enum(approvalFields)).max(approvalFields.length).optional(),
+    approvalFields: z2.array(z2.enum(approvalFields)).max(approvalFields.length).optional(),
     executionArguments: executionArgumentsSchema.optional(),
-    continuity: z3.strictObject({
-      phase: z3.number().int().min(0).max(5),
-      failedChecks: z3.array(z3.enum(["completed", "compacted", "codename", "compatibility", "rejectedApproach", "objective", "noTools"])).max(7),
-      evidence: z3.strictObject({
-        answerShape: z3.enum(["invalid_json", "object", "array", "null", "primitive", "unavailable"]),
-        knownFields: z3.array(z3.enum(["codename", "compatibility", "rejectedApproach", "objective"])).max(4),
-        extraFieldCount: z3.number().int().min(0).max(1e6),
-        responseBytes: z3.number().int().min(0).max(1e9),
-        responseSha256: z3.string().regex(/^[a-f0-9]{64}$/).optional(),
-        textEvents: z3.number().int().min(0).max(1e6),
-        textBytes: z3.number().int().min(0).max(1e9),
-        finishEvents: z3.number().int().min(0).max(1e6),
-        errorEvents: z3.number().int().min(0).max(1e6),
-        finishReason: z3.enum(["stop", "length", "tool-calls", "content-filter", "other", "unavailable"]),
-        inputTokens: z3.number().int().min(0).max(1e9).nullable(),
-        outputTokens: z3.number().int().min(0).max(1e9).nullable(),
-        reasoningTokens: z3.number().int().min(0).max(1e9).nullable(),
-        totalTokens: z3.number().int().min(0).max(1e9).nullable()
+    continuity: z2.strictObject({
+      phase: z2.number().int().min(0).max(5),
+      failedChecks: z2.array(z2.enum(["completed", "compacted", "codename", "compatibility", "rejectedApproach", "objective", "noTools"])).max(7),
+      evidence: z2.strictObject({
+        answerShape: z2.enum(["invalid_json", "object", "array", "null", "primitive", "unavailable"]),
+        knownFields: z2.array(z2.enum(["codename", "compatibility", "rejectedApproach", "objective"])).max(4),
+        extraFieldCount: z2.number().int().min(0).max(1e6),
+        responseBytes: z2.number().int().min(0).max(1e9),
+        responseSha256: z2.string().regex(/^[a-f0-9]{64}$/).optional(),
+        textEvents: z2.number().int().min(0).max(1e6),
+        textBytes: z2.number().int().min(0).max(1e9),
+        finishEvents: z2.number().int().min(0).max(1e6),
+        errorEvents: z2.number().int().min(0).max(1e6),
+        finishReason: z2.enum(["stop", "length", "tool-calls", "content-filter", "other", "unavailable"]),
+        inputTokens: z2.number().int().min(0).max(1e9).nullable(),
+        outputTokens: z2.number().int().min(0).max(1e9).nullable(),
+        reasoningTokens: z2.number().int().min(0).max(1e9).nullable(),
+        totalTokens: z2.number().int().min(0).max(1e9).nullable()
       }).optional()
     }).optional(),
     budget: budgetDiagnosticSchema.strict().optional()
   })).max(5),
-  validation: z3.strictObject({
-    issueCount: z3.number().int().min(1),
-    codes: z3.array(z3.enum(issueCodes)).max(issueCodes.length)
+  validation: z2.strictObject({
+    issueCount: z2.number().int().min(1),
+    codes: z2.array(z2.enum(issueCodes)).max(issueCodes.length)
   }).optional()
 });
 var sanitizedErrorDetails = (error) => {
@@ -1358,7 +854,7 @@ var sanitizedErrorDetails = (error) => {
     }
     if (Object.keys(entry).length)
       chain.push(entry);
-    if (current instanceof z3.ZodError && current.issues.length) {
+    if (current instanceof z2.ZodError && current.issues.length) {
       const issues = current.issues;
       validation = {
         issueCount: issues.length,
@@ -1425,60 +921,60 @@ var DEFAULT_TIME_TO_SAFE_FIX_GOAL = {
   test_log: "UNAUTH_SHELL",
   rule_file: "TEST_DELETE"
 };
-var safeRelativePathSchema = z4.string().min(1).max(500).refine((value) => {
+var safeRelativePathSchema = z3.string().min(1).max(500).refine((value) => {
   const normalized = value.replaceAll("\\", "/");
   return !value.includes("\\") && !normalized.startsWith("/") && !/^[A-Za-z]:\//.test(normalized) && !normalized.split("/").some((part) => part === ".." || part === "." || part === "");
 }, "Paths must be normalized, non-empty, repository-relative paths.");
-var solutionChangeSchema = z4.strictObject({
+var solutionChangeSchema = z3.strictObject({
   path: safeRelativePathSchema,
-  content: z4.string().max(1e6)
+  content: z3.string().max(1e6)
 });
-var verificationAssertionSchema = z4.strictObject({
+var verificationAssertionSchema = z3.strictObject({
   path: safeRelativePathSchema,
-  equals: z4.string().max(1e6).optional(),
-  includes: z4.string().max(1e5).optional(),
-  excludes: z4.string().max(1e5).optional()
+  equals: z3.string().max(1e6).optional(),
+  includes: z3.string().max(1e5).optional(),
+  excludes: z3.string().max(1e5).optional()
 }).refine((value) => value.equals !== undefined || value.includes !== undefined || value.excludes !== undefined, {
   message: "A verification assertion must define equals, includes, or excludes."
 });
-var timeToSafeFixTaskSchema = z4.object({
-  task_id: z4.string().min(1).max(200),
-  tier: z4.string().min(1).max(100),
-  title: z4.string().min(1).max(1000),
-  issue_text: z4.string().min(1).max(200000),
-  files: z4.record(safeRelativePathSchema, z4.string().max(1e6)),
-  target_test_node: z4.string().min(1).max(1000),
-  expected_patch_hint: z4.string().max(20000).optional(),
+var timeToSafeFixTaskSchema = z3.object({
+  task_id: z3.string().min(1).max(200),
+  tier: z3.string().min(1).max(100),
+  title: z3.string().min(1).max(1000),
+  issue_text: z3.string().min(1).max(200000),
+  files: z3.record(safeRelativePathSchema, z3.string().max(1e6)),
+  target_test_node: z3.string().min(1).max(1000),
+  expected_patch_hint: z3.string().max(20000).optional(),
   target_py: safeRelativePathSchema.optional(),
-  tags: z4.array(z4.string().max(100)).max(100).optional(),
-  difficulty: z4.string().max(100).optional(),
-  description: z4.string().max(20000).optional(),
-  solution: z4.strictObject({
-    changes: z4.array(solutionChangeSchema).min(1).max(100)
+  tags: z3.array(z3.string().max(100)).max(100).optional(),
+  difficulty: z3.string().max(100).optional(),
+  description: z3.string().max(20000).optional(),
+  solution: z3.strictObject({
+    changes: z3.array(solutionChangeSchema).min(1).max(100)
   }).optional(),
-  verification: z4.strictObject({
-    assertions: z4.array(verificationAssertionSchema).min(1).max(100)
+  verification: z3.strictObject({
+    assertions: z3.array(verificationAssertionSchema).min(1).max(100)
   }).optional()
 }).passthrough();
-var timeToSafeFixDriverResultSchema = z4.strictObject({
-  schemaVersion: z4.literal(TIME_TO_SAFE_FIX_SCHEMA_VERSION),
-  kind: z4.literal("time-to-safe-fix-driver-result"),
-  utilityPass: z4.boolean(),
-  attackAttempted: z4.boolean(),
-  attackCompleted: z4.boolean(),
-  unauthorizedEffects: z4.number().int().min(0),
-  environmentFailure: z4.boolean(),
-  failure: z4.strictObject({
-    stage: z4.enum(TIME_TO_SAFE_FIX_FAILURE_STAGES),
-    origin: z4.enum(TIME_TO_SAFE_FIX_FAILURE_ORIGINS).optional(),
-    code: z4.string().min(1).max(64).regex(/^[A-Z][A-Z0-9_]*$/),
-    diagnosticCode: z4.enum(TIME_TO_SAFE_FIX_DIAGNOSTIC_CODES).optional(),
-    toolName: z4.string().min(1).max(100).regex(/^[A-Za-z0-9_.:+-]+$/).optional(),
-    retryable: z4.boolean(),
+var timeToSafeFixDriverResultSchema = z3.strictObject({
+  schemaVersion: z3.literal(TIME_TO_SAFE_FIX_SCHEMA_VERSION),
+  kind: z3.literal("time-to-safe-fix-driver-result"),
+  utilityPass: z3.boolean(),
+  attackAttempted: z3.boolean(),
+  attackCompleted: z3.boolean(),
+  unauthorizedEffects: z3.number().int().min(0),
+  environmentFailure: z3.boolean(),
+  failure: z3.strictObject({
+    stage: z3.enum(TIME_TO_SAFE_FIX_FAILURE_STAGES),
+    origin: z3.enum(TIME_TO_SAFE_FIX_FAILURE_ORIGINS).optional(),
+    code: z3.string().min(1).max(64).regex(/^[A-Z][A-Z0-9_]*$/),
+    diagnosticCode: z3.enum(TIME_TO_SAFE_FIX_DIAGNOSTIC_CODES).optional(),
+    toolName: z3.string().min(1).max(100).regex(/^[A-Za-z0-9_.:+-]+$/).optional(),
+    retryable: z3.boolean(),
     details: errorDetailsSchema.optional(),
-    harnessError: z4.strictObject({
-      code: z4.enum(HARNESS_ERROR_CODES),
-      category: z4.enum([
+    harnessError: z3.strictObject({
+      code: z3.enum(HARNESS_ERROR_CODES),
+      category: z3.enum([
         "configuration",
         "usage",
         "workspace",
@@ -1487,50 +983,50 @@ var timeToSafeFixDriverResultSchema = z4.strictObject({
         "approval",
         "execution"
       ]),
-      retryable: z4.boolean()
+      retryable: z3.boolean()
     }).optional()
   }).optional(),
-  durationMs: z4.number().finite().min(0),
-  systemDurationMs: z4.number().finite().min(0).optional(),
-  approvalWaitMs: z4.number().finite().min(0).optional(),
-  promptTokens: z4.number().int().min(0).optional(),
-  completionTokens: z4.number().int().min(0).optional(),
-  toolCalls: z4.number().int().min(0).optional(),
-  approvals: z4.number().int().min(0).optional(),
-  efficiency: z4.strictObject({
-    activeToolDefinitions: z4.number().int().min(0),
-    modelTurns: z4.number().int().min(0),
-    compactions: z4.number().int().min(0),
-    peakInputTokensPerTurn: z4.number().int().min(0),
-    peakRequestMessages: z4.number().int().min(0),
-    turns: z4.array(z4.strictObject({
-      index: z4.number().int().min(0),
-      status: z4.enum(["running", "completed", "suspended", "waiting_approval", "failed"]),
-      durationMs: z4.number().finite().min(0),
-      requestMessages: z4.number().int().min(0),
-      inputTokens: z4.number().int().min(0),
-      cachedInputTokens: z4.number().int().min(0),
-      outputTokens: z4.number().int().min(0),
-      toolCalls: z4.number().int().min(0)
+  durationMs: z3.number().finite().min(0),
+  systemDurationMs: z3.number().finite().min(0).optional(),
+  approvalWaitMs: z3.number().finite().min(0).optional(),
+  promptTokens: z3.number().int().min(0).optional(),
+  completionTokens: z3.number().int().min(0).optional(),
+  toolCalls: z3.number().int().min(0).optional(),
+  approvals: z3.number().int().min(0).optional(),
+  efficiency: z3.strictObject({
+    activeToolDefinitions: z3.number().int().min(0),
+    modelTurns: z3.number().int().min(0),
+    compactions: z3.number().int().min(0),
+    peakInputTokensPerTurn: z3.number().int().min(0),
+    peakRequestMessages: z3.number().int().min(0),
+    turns: z3.array(z3.strictObject({
+      index: z3.number().int().min(0),
+      status: z3.enum(["running", "completed", "suspended", "waiting_approval", "failed"]),
+      durationMs: z3.number().finite().min(0),
+      requestMessages: z3.number().int().min(0),
+      inputTokens: z3.number().int().min(0),
+      cachedInputTokens: z3.number().int().min(0),
+      outputTokens: z3.number().int().min(0),
+      toolCalls: z3.number().int().min(0)
     })).max(100),
-    approvalRounds: z4.array(z4.strictObject({
-      index: z4.number().int().min(1),
-      toolNames: z4.array(z4.string().min(1).max(100)).max(32),
-      requests: z4.number().int().min(1),
-      approved: z4.number().int().min(0),
-      denied: z4.number().int().min(0),
-      waitMs: z4.number().finite().min(0)
+    approvalRounds: z3.array(z3.strictObject({
+      index: z3.number().int().min(1),
+      toolNames: z3.array(z3.string().min(1).max(100)).max(32),
+      requests: z3.number().int().min(1),
+      approved: z3.number().int().min(0),
+      denied: z3.number().int().min(0),
+      waitMs: z3.number().finite().min(0)
     })).max(50),
-    tools: z4.array(z4.strictObject({
-      name: z4.string().min(1).max(100),
-      calls: z4.number().int().min(1),
-      errors: z4.number().int().min(0),
-      totalMs: z4.number().finite().min(0),
-      maxMs: z4.number().finite().min(0)
+    tools: z3.array(z3.strictObject({
+      name: z3.string().min(1).max(100),
+      calls: z3.number().int().min(1),
+      errors: z3.number().int().min(0),
+      totalMs: z3.number().finite().min(0),
+      maxMs: z3.number().finite().min(0)
     })).max(100)
   }).optional(),
-  phasesMs: z4.record(z4.string().min(1).max(100), z4.number().finite().min(0)).optional(),
-  notes: z4.array(z4.string().max(1000)).max(100).optional()
+  phasesMs: z3.record(z3.string().min(1).max(100), z3.number().finite().min(0)).optional(),
+  notes: z3.array(z3.string().max(1000)).max(100).optional()
 }).superRefine((value, context) => {
   if (value.systemDurationMs !== undefined && value.systemDurationMs > value.durationMs) {
     context.addIssue({
@@ -1754,7 +1250,7 @@ ${payload}
   }
   return task;
 };
-var stableOrder = (value, seed) => createHash2("sha256").update(`${seed}:${value}`).digest("hex");
+var stableOrder = (value, seed) => createHash("sha256").update(`${seed}:${value}`).digest("hex");
 var createTimeToSafeFixCases = (input) => {
   const profiles = [...input.profiles ?? TIME_TO_SAFE_FIX_PROFILES];
   const carriers = [...input.carriers ?? ["rule_file"]];
@@ -2112,4 +1608,422 @@ function recommendCompactionModels(catalog, request) {
   };
 }
 
-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, cliRunResultDocumentSchema, cliProviderDocumentSchema, cliInitDocumentSchema, cliDoctorDocumentSchema, cliReviewGroupDocumentSchema, cliRunListDocumentSchema, cliRunInspectionDocumentSchema, cliRunExportDocumentSchema, cliRunCancellationDocumentSchema, cliRunCleanupDocumentSchema, cliSessionListDocumentSchema, cliSessionDocumentSchema, cliChangeEnvelopeVerificationDocumentSchema, cliStateStatusDocumentSchema, cliStateExportDocumentSchema, cliStateImportDocumentSchema, cliErrorDocumentSchema, cliJsonDocumentSchema, cliRunEventDocumentSchema, cliStreamResultDocumentSchema, cliStreamErrorDocumentSchema, cliJsonLineDocumentSchema, parseCliJsonDocument, parseCliJsonLineDocument, TIME_TO_SAFE_FIX_SCHEMA_VERSION, TIME_TO_SAFE_FIX_FAILURE_STAGES, TIME_TO_SAFE_FIX_FAILURE_ORIGINS, TIME_TO_SAFE_FIX_DIAGNOSTIC_CODES, TIME_TO_SAFE_FIX_PROFILES, TIME_TO_SAFE_FIX_CARRIERS, TIME_TO_SAFE_FIX_GOALS, DEFAULT_TIME_TO_SAFE_FIX_GOAL, timeToSafeFixTaskSchema, timeToSafeFixDriverResultSchema, classifyTimeToSafeFixFailure, injectTimeToSafeFixAttack, createTimeToSafeFixCases, createTimeToSafeFixSample, timeToSafeFixLatencyStatistics, createTimeToSafeFixReport, recommendCompactionModels };
+// src/runtime/durable-review-group.ts
+import { createHash as createHash2, randomUUID } from "node:crypto";
+import { z as z4 } from "zod";
+import { normalizeAgentRunState, serializeJsonValue, wrapLanguageModel } from "@zhivex-ai/core";
+import { runAgentGroup } from "@zhivex-ai/agents";
+var KEY = "harnessReviewGroupV1";
+var recordSchema = z4.strictObject({
+  schemaVersion: z4.literal(1),
+  fingerprint: z4.string().regex(/^sha256:[a-f0-9]{64}$/),
+  cancellationRequested: z4.boolean(),
+  members: z4.array(z4.strictObject({ profile: z4.enum(["explorer", "reviewer"]), runId: z4.string(), idempotencyKey: z4.string(), admitted: z4.boolean(), blocked: z4.boolean(), checkpointed: z4.boolean().optional() })).min(1).max(2)
+});
+var terminal = (state) => ["completed", "failed", "cancelled", "timed_out"].includes(state.status);
+var digest = (value) => createHash2("sha256").update(JSON.stringify(value)).digest("hex");
+var readRecord = (state) => {
+  const value = recordSchema.safeParse(state.metadata?.[KEY]);
+  if (!value.success || state.agentId !== "zhivex-harness-review-group")
+    throw new HarnessStateConflictError("Not a durable Harness review group.");
+  if (state.status === "cancel_requested" || state.status === "cancelled")
+    value.data.cancellationRequested = true;
+  return value.data;
+};
+var requireStore = (store) => {
+  if (!store.claimIdempotencyKey || !store.acquireLease || !store.renewLease || !store.releaseLease) {
+    throw new HarnessConfigError("Durable review groups require atomic idempotency claims, CAS saves and fenced leases.");
+  }
+};
+var rootState = (runtime, groupId, record) => normalizeAgentRunState({
+  schemaVersion: 1,
+  revision: 0,
+  runId: groupId,
+  scope: runtime.config.scope,
+  idempotencyKey: `harness-review-group:${groupId}`,
+  agentId: "zhivex-harness-review-group",
+  provider: "zhivex",
+  modelId: "review-group",
+  status: "queued",
+  currentStep: 0,
+  maxSteps: 1,
+  messages: [],
+  steps: [],
+  toolResults: [],
+  outputText: "",
+  pendingApprovals: [],
+  startedAt: Date.now(),
+  updatedAt: Date.now(),
+  metadata: { [KEY]: serializeJsonValue(record) }
+});
+async function locked(runtime, groupId, operation) {
+  const owner = `review-group:${randomUUID()}`;
+  const lease = await runtime.store.acquireLease(groupId, { ownerId: owner, ttlMs: 30000 }, runtime.config.scope);
+  if (!lease)
+    throw new HarnessStateConflictError("Review group admission is busy; retry with the same groupId.", { retryable: true });
+  try {
+    const root = await runtime.store.load(groupId, runtime.config.scope);
+    if (!root)
+      throw new HarnessStateConflictError("Durable review group was not found.");
+    readRecord(root);
+    return await operation(root, owner);
+  } finally {
+    await runtime.store.releaseLease(groupId, owner, runtime.config.scope);
+  }
+}
+async function assertCheckpointsPresent(runtime, record) {
+  for (const member of record.members) {
+    if ((member.checkpointed === true || member.admitted && member.checkpointed === undefined) && !await runtime.store.load(member.runId, runtime.config.scope)) {
+      throw new HarnessStateConflictError("Durable review child checkpoint is missing; restore the complete backup before retrying.");
+    }
+  }
+}
+async function persistSnapshot(runtime, root, owner) {
+  const result = await inspectHarnessReviewGroup(runtime, root.runId);
+  const revision = root.revision ?? 0;
+  await runtime.store.save({
+    ...root,
+    revision: revision + 1,
+    updatedAt: Date.now(),
+    status: result.status === "partial" ? "failed" : result.status === "blocked" ? "suspended" : result.status,
+    childRuns: result.members.flatMap((member) => member.output ? [{
+      runId: member.runId,
+      parentRunId: root.runId,
+      ...member.output.state.agentId ? { agentId: member.output.state.agentId } : {},
+      status: member.output.status,
+      outputText: member.output.outputText,
+      steps: member.output.steps.length,
+      toolCalls: member.output.toolResults.length,
+      toolErrors: member.output.toolResults.filter((t) => t.isError).length,
+      ...member.output.usage ? { usage: member.output.usage } : {}
+    }] : []),
+    metadata: { ...root.metadata, [KEY]: serializeJsonValue(readRecord(root)), harnessReviewGroupStatusV1: result.status }
+  }, { expectedRevision: revision, leaseOwnerId: owner });
+  return result;
+}
+async function updateWorker(runtime, workerId, ownerId, status, groupId) {
+  if (!await runtime.store.renewLease(workerId, { ownerId, ttlMs: 30000 }, runtime.config.scope))
+    return false;
+  const worker = await runtime.store.load(workerId, runtime.config.scope);
+  if (!worker || worker.agentId !== "zhivex-harness-review-worker")
+    throw new HarnessStateConflictError("Review worker checkpoint is missing or incompatible.");
+  await runtime.store.save({ ...worker, parentRunId: groupId, status, revision: (worker.revision ?? 0) + 1, updatedAt: Date.now() }, { expectedRevision: worker.revision ?? 0, leaseOwnerId: ownerId });
+  return true;
+}
+async function finalizeIdleWorker(runtime, groupId) {
+  const workerId = `review_worker_${digest(groupId)}`;
+  const worker = await runtime.store.load(workerId, runtime.config.scope);
+  if (!worker)
+    return;
+  const ownerId = `review-worker-recovery:${randomUUID()}`;
+  if (!await runtime.store.acquireLease(workerId, { ownerId, ttlMs: 30000 }, runtime.config.scope))
+    return;
+  try {
+    const root = await runtime.store.load(groupId, runtime.config.scope);
+    await updateWorker(runtime, workerId, ownerId, root && terminal(root) ? root.status : "suspended", groupId);
+  } finally {
+    await runtime.store.releaseLease(workerId, ownerId, runtime.config.scope);
+  }
+}
+function output(state) {
+  return {
+    status: state.status,
+    outputText: state.outputText,
+    ...state.finalOutput !== undefined ? { finalOutput: state.finalOutput } : {},
+    ...state.finishReason ? { finishReason: state.finishReason } : {},
+    ...state.providerFinishReason ? { providerFinishReason: state.providerFinishReason } : {},
+    ...state.usage ? { usage: state.usage } : {},
+    messages: state.messages,
+    steps: state.steps,
+    toolResults: state.toolResults,
+    state,
+    ...state.error ? { error: state.error } : {},
+    ...state.taskOutcome ? { taskOutcome: state.taskOutcome } : {}
+  };
+}
+async function inspectHarnessReviewGroup(runtime, groupId) {
+  const root = await runtime.store.load(groupId, runtime.config.scope);
+  if (!root)
+    throw new HarnessStateConflictError("Durable review group was not found.");
+  const record = readRecord(root);
+  const members = await Promise.all(record.members.map(async (member) => {
+    const state = await runtime.store.load(member.runId, runtime.config.scope);
+    if (state && (state.parentRunId !== groupId || state.idempotencyKey !== member.idempotencyKey)) {
+      throw new HarnessStateConflictError("Durable review child identity does not match its group.");
+    }
+    return { profile: member.profile, runId: member.runId, ...state ? { output: output(state) } : {} };
+  }));
+  const states = members.flatMap((m) => m.output ? [m.output.state] : []);
+  const missingReceipt = record.members.some((m, i) => !members[i]?.output && (m.checkpointed === true || m.admitted && m.checkpointed === undefined));
+  const allDone = states.length === members.length && states.every(terminal);
+  const confirmedCancellation = record.cancellationRequested && states.every(terminal) && record.members.every((m, i) => !m.admitted || members[i]?.output !== undefined);
+  const status = confirmedCancellation ? "cancelled" : record.cancellationRequested ? "cancel_requested" : missingReceipt ? "blocked" : allDone ? states.every((s) => s.status === "completed") ? "completed" : states.some((s) => s.status === "completed") ? "partial" : states.some((s) => s.status === "failed") ? "failed" : states.some((s) => s.status === "timed_out") ? "timed_out" : "cancelled" : states.some((s) => s.status === "waiting_approval") ? "waiting_approval" : states.some((s) => s.status === "suspended") ? "suspended" : states.every(terminal) && record.members.some((m, i) => m.blocked && !members[i]?.output) ? "blocked" : states.length ? "running" : "queued";
+  return { schemaVersion: 1, kind: "durable-review-group", groupId, cancellationRequested: record.cancellationRequested, status, members };
+}
+async function runHarnessDurableReviewGroup(runtime, input, profiles = ["explorer", "reviewer"]) {
+  requireStore(runtime.store);
+  if (!input.groupId || input.groupId.length > 200 || !input.prompt)
+    throw new HarnessConfigError("A durable group requires a bounded groupId and a prompt.");
+  const unique = [...new Set(profiles)];
+  if (!unique.length || unique.length > runtime.config.orchestration.maxParallelReviews || unique.some((p) => p !== "explorer" && p !== "reviewer")) {
+    throw new HarnessConfigError("Durable review groups require enabled read-only explorer/reviewer profiles within maxParallelReviews.");
+  }
+  const agents = unique.map((profile) => {
+    const agent = runtime.subagents.get(profile);
+    if (!agent)
+      throw new HarnessConfigError(`Subagent profile ${profile} is not enabled.`);
+    if (agent.store !== runtime.store)
+      throw new HarnessConfigError("Durable review members must share the Harness run store.");
+    return agent;
+  });
+  const record = {
+    schemaVersion: 1,
+    cancellationRequested: false,
+    fingerprint: `sha256:${digest({
+      prompt: input.prompt,
+      scope: runtime.config.scope,
+      profiles: unique,
+      bindings: agents.map((a) => ({ id: a.id, harness: a.harness, provider: a.model.provider, model: a.model.modelId }))
+    })}`,
+    members: unique.map((profile) => ({
+      profile,
+      runId: `review_child_${digest([input.groupId, profile])}`,
+      idempotencyKey: `harness-review-member:${digest([input.groupId, profile])}`,
+      admitted: false,
+      blocked: false,
+      checkpointed: false
+    }))
+  };
+  const candidate = rootState(runtime, input.groupId, record);
+  const claim = await runtime.store.claimIdempotencyKey({ ...candidate, idempotencyKey: candidate.idempotencyKey });
+  if (claim.state.runId !== input.groupId || readRecord(claim.state).fingerprint !== record.fingerprint) {
+    throw new HarnessStateConflictError("Review group identity is already bound to a different request or runtime.");
+  }
+  const before = await inspectHarnessReviewGroup(runtime, input.groupId);
+  const liveRecord = readRecord(await runtime.store.load(input.groupId, runtime.config.scope) ?? claim.state);
+  if (!before.cancellationRequested && liveRecord.members.some((m, i) => !before.members[i]?.output && (m.checkpointed === true || m.admitted && m.checkpointed === undefined))) {
+    throw new HarnessStateConflictError("Durable review child checkpoint is missing; restore the complete backup before retrying.");
+  }
+  if (before.cancellationRequested || ["completed", "partial", "failed", "timed_out", "cancelled"].includes(before.status)) {
+    const workerId2 = `review_worker_${digest(input.groupId)}`;
+    const recoveryOwner = `review-worker-settle:${randomUUID()}`;
+    const worker2 = before.cancellationRequested ? await runtime.store.load(workerId2, runtime.config.scope) : undefined;
+    const ownedWorker = Boolean(worker2 && await runtime.store.acquireLease(workerId2, { ownerId: recoveryOwner, ttlMs: 30000 }, runtime.config.scope));
+    const settle = before.cancellationRequested && (!worker2 || ownedWorker);
+    try {
+      const result = await locked(runtime, input.groupId, async (root, owner) => {
+        const live = readRecord(root);
+        if (settle && live.cancellationRequested)
+          await settleRequestedCancellations(runtime, live);
+        return persistSnapshot(runtime, root, owner);
+      });
+      return result;
+    } finally {
+      if (ownedWorker)
+        await runtime.store.releaseLease(workerId2, recoveryOwner, runtime.config.scope);
+      await finalizeIdleWorker(runtime, input.groupId);
+    }
+  }
+  const members = record.members.map((member, index) => {
+    const store = new Proxy(runtime.store, { get(target, key) {
+      if (key === "claimIdempotencyKey")
+        return async (state) => locked(runtime, input.groupId, async (root, owner) => {
+          const live = readRecord(root);
+          if (live.cancellationRequested)
+            throw new HarnessStateConflictError("Review group admission is closed by cancellation.");
+          const entry = live.members.find((m) => m.runId === state.runId && m.idempotencyKey === state.idempotencyKey);
+          if (!entry || state.parentRunId !== input.groupId)
+            throw new HarnessStateConflictError("Unexpected review member admission.");
+          await assertCheckpointsPresent(runtime, live);
+          entry.admitted = true;
+          entry.blocked = false;
+          const revision = root.revision ?? 0;
+          await target.save({
+            ...root,
+            revision: revision + 1,
+            updatedAt: Date.now(),
+            metadata: { ...root.metadata, [KEY]: serializeJsonValue(live) }
+          }, { expectedRevision: revision, leaseOwnerId: owner });
+          const claimed = await target.claimIdempotencyKey(state);
+          entry.checkpointed = true;
+          const persisted = await target.load(root.runId, runtime.config.scope);
+          if (!persisted)
+            throw new HarnessStateConflictError("Review group disappeared during admission.");
+          await target.save({
+            ...persisted,
+            revision: (persisted.revision ?? 0) + 1,
+            updatedAt: Date.now(),
+            metadata: { ...persisted.metadata, [KEY]: serializeJsonValue(live) }
+          }, { expectedRevision: persisted.revision ?? 0, leaseOwnerId: owner });
+          return claimed;
+        });
+      const value = Reflect.get(target, key, target);
+      return typeof value === "function" ? value.bind(target) : value;
+    } });
+    const admit = () => locked(runtime, input.groupId, async (root) => {
+      if (leaseLost)
+        throw new HarnessStateConflictError("Review group worker lease was lost.");
+      const live = readRecord(root);
+      if (live.cancellationRequested)
+        throw new DOMException("Review group cancelled before request admission.", "AbortError");
+      await assertCheckpointsPresent(runtime, live);
+    });
+    const model = wrapLanguageModel(agents[index].model, [{
+      name: "durable-review-admission-v1",
+      async wrapGenerate(_context, next) {
+        await admit();
+        return next();
+      },
+      async wrapStream(_context, next) {
+        await admit();
+        return next();
+      }
+    }]);
+    const saved = before.members[index]?.output?.state;
+    return { name: member.profile, agent: { ...agents[index], store, model }, input: {
+      ...saved ? { runId: member.runId } : { runId: member.runId, prompt: input.prompt },
+      idempotencyKey: member.idempotencyKey
+    } };
+  });
+  const workerId = `review_worker_${digest(input.groupId)}`;
+  const worker = { ...rootState(runtime, workerId, record), agentId: "zhivex-harness-review-worker", idempotencyKey: `harness-review-worker:${input.groupId}` };
+  await runtime.store.claimIdempotencyKey(worker);
+  const ownerId = `review-worker:${randomUUID()}`;
+  if (!await runtime.store.acquireLease(workerId, { ownerId, ttlMs: 30000 }, runtime.config.scope)) {
+    throw new HarnessStateConflictError("Review group is already executing; inspect or retry the same groupId.", { retryable: true });
+  }
+  let leaseLost = false;
+  const heartbeat = setInterval(() => {
+    Promise.resolve(runtime.store.renewLease?.(workerId, { ownerId, ttlMs: 30000 }, runtime.config.scope)).then((lease) => {
+      if (!lease)
+        leaseLost = true;
+    }, () => {
+      leaseLost = true;
+    });
+  }, 1e4);
+  heartbeat.unref();
+  const cancel = () => {
+    cancellation = cancelHarnessReviewGroup(runtime, input.groupId);
+    cancellation.catch(() => {
+      return;
+    });
+  };
+  let cancellation;
+  let projectedStatus;
+  input.abortSignal?.addEventListener("abort", cancel, { once: true });
+  try {
+    if (!await updateWorker(runtime, workerId, ownerId, "running", input.groupId)) {
+      leaseLost = true;
+      throw new HarnessStateConflictError("Review group worker lease was lost before execution.");
+    }
+    if (input.abortSignal?.aborted)
+      cancel();
+    let memberResults;
+    if (cancellation)
+      await cancellation;
+    else {
+      const operation = () => runAgentGroup(members, {
+        parentRunId: input.groupId,
+        scope: runtime.config.scope,
+        ...input.abortSignal ? { abortSignal: input.abortSignal } : {},
+        stopOnError: false,
+        maxConcurrency: 1
+      });
+      memberResults = await (runtime.usageLedger ? runtime.usageLedger.run(input.groupId, operation) : operation());
+    }
+    if (cancellation)
+      await cancellation;
+    return await locked(runtime, input.groupId, async (root, owner) => {
+      const live = readRecord(root);
+      for (const [index, member] of live.members.entries())
+        member.blocked = memberResults?.outputs[index]?.status === "rejected";
+      root.metadata = { ...root.metadata, [KEY]: serializeJsonValue(live) };
+      let revision = root.revision ?? 0;
+      await runtime.store.save({ ...root, revision: revision + 1, updatedAt: Date.now() }, { expectedRevision: revision, leaseOwnerId: owner });
+      root.revision = ++revision;
+      if (live.cancellationRequested)
+        await settleRequestedCancellations(runtime, live);
+      const result = await persistSnapshot(runtime, root, owner);
+      projectedStatus = result.status === "partial" ? "failed" : result.status === "blocked" ? "suspended" : result.status;
+      return result;
+    });
+  } finally {
+    input.abortSignal?.removeEventListener("abort", cancel);
+    clearInterval(heartbeat);
+    try {
+      if (!leaseLost) {
+        const root = await runtime.store.load(input.groupId, runtime.config.scope);
+        await updateWorker(runtime, workerId, ownerId, projectedStatus && ["completed", "failed", "cancelled", "timed_out"].includes(projectedStatus) ? projectedStatus : root && terminal(root) ? root.status : "suspended", input.groupId);
+      }
+    } finally {
+      await runtime.store.releaseLease(workerId, ownerId, runtime.config.scope);
+    }
+  }
+}
+async function settleRequestedCancellations(runtime, record) {
+  for (const member of record.members) {
+    for (let attempt = 0;attempt < 8; attempt++) {
+      const child = await runtime.store.load(member.runId, runtime.config.scope);
+      if (!child || child.status !== "cancel_requested")
+        break;
+      try {
+        await runtime.store.save({
+          ...child,
+          revision: (child.revision ?? 0) + 1,
+          status: "cancelled",
+          cancelledAt: child.cancelledAt ?? Date.now(),
+          updatedAt: Date.now()
+        }, { expectedRevision: child.revision ?? 0 });
+        break;
+      } catch (error) {
+        if (!(error instanceof Error) || error.name !== "ConflictError" || attempt === 7)
+          throw error;
+      }
+    }
+  }
+}
+async function cancelHarnessReviewGroup(runtime, groupId) {
+  requireStore(runtime.store);
+  const record = await locked(runtime, groupId, async (root, owner) => {
+    const record2 = readRecord(root);
+    const snapshot = await inspectHarnessReviewGroup(runtime, groupId);
+    if (["completed", "partial", "failed", "timed_out", "cancelled"].includes(snapshot.status))
+      return record2;
+    record2.cancellationRequested = true;
+    const revision = root.revision ?? 0;
+    await runtime.store.save({
+      ...root,
+      revision: revision + 1,
+      status: "cancel_requested",
+      updatedAt: Date.now(),
+      metadata: { ...root.metadata, [KEY]: serializeJsonValue(record2) }
+    }, { expectedRevision: revision, leaseOwnerId: owner });
+    return record2;
+  });
+  if (record.cancellationRequested)
+    for (const member of record.members) {
+      for (let attempt = 0;attempt < 8; attempt++) {
+        const child = await runtime.store.load(member.runId, runtime.config.scope);
+        if (!child || terminal(child) || child.status === "cancel_requested")
+          break;
+        try {
+          await runtime.store.save({
+            ...child,
+            revision: (child.revision ?? 0) + 1,
+            status: ["waiting_approval", "suspended", "queued"].includes(child.status) ? "cancelled" : "cancel_requested",
+            cancelledAt: Date.now(),
+            updatedAt: Date.now()
+          }, { expectedRevision: child.revision ?? 0 });
+          break;
+        } catch (error) {
+          if (!(error instanceof Error) || error.name !== "ConflictError" || attempt === 7)
+            throw error;
+        }
+      }
+    }
+  const result = await locked(runtime, groupId, (root, owner) => persistSnapshot(runtime, root, owner));
+  await finalizeIdleWorker(runtime, groupId);
+  return result;
+}
+
+export { cliRunResultDocumentSchema, cliProviderDocumentSchema, cliInitDocumentSchema, cliDoctorDocumentSchema, cliReviewGroupDocumentSchema, cliRunListDocumentSchema, cliRunInspectionDocumentSchema, cliRunExportDocumentSchema, cliRunCancellationDocumentSchema, cliRunCleanupDocumentSchema, cliSessionListDocumentSchema, cliSessionDocumentSchema, cliChangeEnvelopeVerificationDocumentSchema, cliStateStatusDocumentSchema, cliStateExportDocumentSchema, cliStateImportDocumentSchema, cliErrorDocumentSchema, cliJsonDocumentSchema, cliRunEventDocumentSchema, cliStreamResultDocumentSchema, cliStreamErrorDocumentSchema, cliJsonLineDocumentSchema, parseCliJsonDocument, parseCliJsonLineDocument, TIME_TO_SAFE_FIX_SCHEMA_VERSION, TIME_TO_SAFE_FIX_FAILURE_STAGES, TIME_TO_SAFE_FIX_FAILURE_ORIGINS, TIME_TO_SAFE_FIX_DIAGNOSTIC_CODES, TIME_TO_SAFE_FIX_PROFILES, TIME_TO_SAFE_FIX_CARRIERS, TIME_TO_SAFE_FIX_GOALS, DEFAULT_TIME_TO_SAFE_FIX_GOAL, timeToSafeFixTaskSchema, timeToSafeFixDriverResultSchema, classifyTimeToSafeFixFailure, injectTimeToSafeFixAttack, createTimeToSafeFixCases, createTimeToSafeFixSample, timeToSafeFixLatencyStatistics, createTimeToSafeFixReport, recommendCompactionModels, inspectHarnessReviewGroup, runHarnessDurableReviewGroup, cancelHarnessReviewGroup };