opencode-swarm 7.160.0 → 7.160.2

package/dist/cli/{index-sy5aeegg.js → index-k50kxd3w.js}

@@ -10,7 +10,7 @@ import {
 } from "./index-r3mvsbtq.js";
 import {
   observeDelegationLedgerPressure
-} from "./index-e75bzfgd.js";
+} from "./index-mmr96pwr.js";
 import {
   EvidenceLockTimeoutError,
   withEvidenceLock
@@ -20,6 +20,7 @@ import {
   init_zod
 } from "./index-bpmtbmy9.js";
 import {
+  criticalWarn,
   init_logger,
   warn
 } from "./index-zgwm4ryv.js";
@@ -29,7 +30,7 @@ import {
 
 // src/background/pending-delegations.ts
 init_zod();
-import { createHash as createHash2 } from "crypto";
+import { createHash as createHash3 } from "crypto";
 import * as fs2 from "fs";
 import * as path2 from "path";
 import { isDeepStrictEqual } from "util";
@@ -392,6 +393,638 @@ function parsePrReviewCollectionReceiptFooter(binding, result) {
   const payload = parsed.data;
   return payload.parentSessionId === binding.parentSessionId && payload.batchId === (binding.batchId ?? binding.callID) && payload.laneId === (binding.laneId ?? binding.correlationId) && payload.mode === binding.mode && payload.workflowLane === binding.workflowLane && payload.outputDigest === result.digest ? payload : null;
 }
+
+// src/background/pr-review-contract.ts
+init_zod();
+import { createHash as createHash2 } from "crypto";
+var PR_REVIEW_REVIEWER_CLASSIFICATIONS = [
+  "CONFIRMED",
+  "DISPROVED",
+  "UNVERIFIED",
+  "PRE_EXISTING"
+];
+var PR_REVIEW_REVIEWER_EVIDENCE_TYPES = [
+  "STRUCTURALLY_PROVEN",
+  "EXECUTION_PROVEN",
+  "STATIC_TRACE_PROVEN",
+  "PLAUSIBLE_BUT_UNVERIFIED"
+];
+var PR_REVIEW_SEVERITIES = [
+  "CRITICAL",
+  "HIGH",
+  "MEDIUM",
+  "LOW",
+  "INFO",
+  "NONE"
+];
+var PR_REVIEW_CRITIC_STATUSES = [
+  "UPHELD",
+  "DOWNGRADED",
+  "DISPROVED",
+  "NEEDS_MORE_EVIDENCE"
+];
+var PR_REVIEW_FINDING_STATUSES = [
+  "PENDING",
+  "CONFIRMED",
+  "DISPROVED",
+  "PRE_EXISTING"
+];
+var PR_REVIEW_FINDING_ACTIONS = [
+  "route_to_reviewer",
+  "route_to_critic",
+  "report",
+  "suppress_with_reason",
+  "handoff_to_feedback"
+];
+var PR_REVIEW_ARTIFACT_BOUNDARIES = [
+  "post_explorer",
+  "post_reviewer",
+  "post_critic"
+];
+var PR_REVIEW_BASE_DIMENSION_IDS = [
+  "intent-architecture",
+  "correctness-state",
+  "tests-falsifiability",
+  "security-trust",
+  "reliability-performance",
+  "compatibility-delivery"
+];
+var PR_REVIEW_RISK_IMPACTS = [
+  "ORDINARY",
+  "HIGH_IMPACT",
+  "UNKNOWN"
+];
+var PR_REVIEW_RISK_TAGS = [
+  "SECURITY",
+  "AUTH_PERMISSIONS",
+  "STATE_INTEGRITY",
+  "WRITE_PATH",
+  "EVIDENCE_INTEGRITY",
+  "GIT",
+  "CONFIGURATION"
+];
+var PR_REVIEW_RESULT_LANE_MODES = [
+  "swarm-pr-review:base",
+  "swarm-pr-review:micro"
+];
+var PR_REVIEW_RESULT_OUTCOMES = [
+  "CLEAN",
+  "FINDINGS",
+  "INCOMPLETE"
+];
+var PR_REVIEW_RESULT_FINDING_SEVERITIES = [
+  "CRITICAL",
+  "HIGH",
+  "MEDIUM",
+  "LOW",
+  "INFO"
+];
+var PR_REVIEW_RESULT_UNRESOLVED_REASONS = [
+  "NOT_EXECUTED",
+  "PARTIAL_OUTPUT",
+  "CONTRACT_FAILURE",
+  "RESOURCE_LIMIT",
+  "DEADLINE_EXCEEDED",
+  "STALE_BINDING",
+  "PARENT_CANCELLED"
+];
+var MAX_PR_REVIEW_RESULT_OWNED_LANES = 11;
+var MAX_PR_REVIEW_RESULT_FINDINGS = 256;
+var MAX_PR_REVIEW_RESULT_RECEIPT_BYTES = 64 * 1024;
+function prReviewLegacyTranscriptCompatibilityEnabled(value) {
+  return value === true;
+}
+var PrReviewResultLaneIdSchema = exports_external.string().trim().min(1).max(120);
+var PrReviewResultChildSessionSchema = exports_external.string().trim().min(1).max(256);
+var PrReviewResultShaSchema = exports_external.string().trim().regex(/^[0-9a-f]{6,64}$/i);
+var PrReviewResultDigestSchema = exports_external.string().trim().regex(/^[0-9a-f]{64}$/i);
+function addDuplicateIssue(ctx, path2, label, value) {
+  ctx.addIssue({
+    code: exports_external.ZodIssueCode.custom,
+    path: path2,
+    message: `${label} must not contain duplicate value "${value}"`
+  });
+}
+function assertUniqueStrings(values, ctx, path2, label) {
+  const seen = new Set;
+  for (const value of values) {
+    if (seen.has(value)) {
+      addDuplicateIssue(ctx, path2, label, value);
+      return;
+    }
+    seen.add(value);
+  }
+}
+var PrReviewResultLocationSchema = exports_external.discriminatedUnion("kind", [
+  exports_external.object({
+    kind: exports_external.literal("local"),
+    file: exports_external.string().trim().min(1).max(4096),
+    line: exports_external.number().int().positive().max(1e6).optional(),
+    endLine: exports_external.number().int().positive().max(1e6).optional(),
+    column: exports_external.number().int().positive().max(1e4).optional(),
+    endColumn: exports_external.number().int().positive().max(1e4).optional()
+  }).strict().superRefine((value, ctx) => {
+    if (value.endLine !== undefined && value.line !== undefined && value.endLine < value.line) {
+      ctx.addIssue({
+        code: exports_external.ZodIssueCode.custom,
+        path: ["endLine"],
+        message: "endLine must be greater than or equal to line"
+      });
+    }
+    if (value.endColumn !== undefined && value.column !== undefined && value.endColumn < value.column) {
+      ctx.addIssue({
+        code: exports_external.ZodIssueCode.custom,
+        path: ["endColumn"],
+        message: "endColumn must be greater than or equal to column"
+      });
+    }
+  }),
+  exports_external.object({
+    kind: exports_external.literal("non_local"),
+    label: exports_external.string().trim().min(1).max(200),
+    detail: exports_external.string().trim().min(1).max(2000)
+  }).strict()
+]);
+var PrReviewResultFindingSchema = exports_external.object({
+  id: exports_external.string().trim().min(1).max(128),
+  workflowLane: PrReviewResultLaneIdSchema,
+  severity: exports_external.enum(PR_REVIEW_RESULT_FINDING_SEVERITIES),
+  riskImpact: exports_external.enum(PR_REVIEW_RISK_IMPACTS),
+  riskTags: exports_external.array(exports_external.enum(PR_REVIEW_RISK_TAGS)).max(PR_REVIEW_RISK_TAGS.length),
+  title: exports_external.string().trim().min(1).max(200),
+  body: exports_external.string().trim().min(1).max(4000),
+  evidence: exports_external.string().trim().min(1).max(4000),
+  location: PrReviewResultLocationSchema
+}).strict().superRefine((value, ctx) => {
+  assertUniqueStrings(value.riskTags, ctx, ["riskTags"], "riskTags");
+});
+var PrReviewCleanAttestationSchema = exports_external.object({
+  workflowLane: PrReviewResultLaneIdSchema,
+  coverageScope: exports_external.string().trim().min(12).max(2000),
+  evidence: exports_external.string().trim().min(20).max(4000)
+}).strict();
+var PrReviewUnresolvedLaneSchema = exports_external.object({
+  workflowLane: PrReviewResultLaneIdSchema,
+  reason: exports_external.enum(PR_REVIEW_RESULT_UNRESOLVED_REASONS),
+  detail: exports_external.string().trim().min(1).max(4000)
+}).strict();
+var PrReviewLaneResultEnvelopeSchema = exports_external.object({
+  schemaVersion: exports_external.literal(1),
+  outcome: exports_external.enum(PR_REVIEW_RESULT_OUTCOMES),
+  creditedLanes: exports_external.array(PrReviewResultLaneIdSchema).max(MAX_PR_REVIEW_RESULT_OWNED_LANES),
+  findings: exports_external.array(PrReviewResultFindingSchema).max(MAX_PR_REVIEW_RESULT_FINDINGS),
+  cleanAttestations: exports_external.array(PrReviewCleanAttestationSchema).max(MAX_PR_REVIEW_RESULT_OWNED_LANES),
+  unresolved: exports_external.array(PrReviewUnresolvedLaneSchema).max(MAX_PR_REVIEW_RESULT_OWNED_LANES)
+}).strict().superRefine((value, ctx) => {
+  assertUniqueStrings(value.creditedLanes, ctx, ["creditedLanes"], "creditedLanes");
+  const findingIds = value.findings.map((finding) => finding.id);
+  assertUniqueStrings(findingIds, ctx, ["findings"], "findings");
+  const findingLanes = value.findings.map((finding) => finding.workflowLane);
+  assertUniqueStrings(value.cleanAttestations.map((entry) => entry.workflowLane), ctx, ["cleanAttestations"], "cleanAttestations");
+  assertUniqueStrings(value.unresolved.map((entry) => entry.workflowLane), ctx, ["unresolved"], "unresolved");
+  for (const lane of findingLanes) {
+    if (value.cleanAttestations.some((entry) => entry.workflowLane === lane)) {
+      ctx.addIssue({
+        code: exports_external.ZodIssueCode.custom,
+        path: ["findings"],
+        message: `workflow lane "${lane}" cannot be both CLEAN and FINDINGS`
+      });
+      return;
+    }
+  }
+  const coveredLanes = new Set([
+    ...findingLanes,
+    ...value.cleanAttestations.map((entry) => entry.workflowLane)
+  ]);
+  for (const lane of value.creditedLanes) {
+    if (!coveredLanes.has(lane)) {
+      ctx.addIssue({
+        code: exports_external.ZodIssueCode.custom,
+        path: ["creditedLanes"],
+        message: `credited workflow lane "${lane}" must be backed by a finding or CLEAN attestation`
+      });
+      return;
+    }
+  }
+  for (const lane of coveredLanes) {
+    if (!value.creditedLanes.includes(lane)) {
+      ctx.addIssue({
+        code: exports_external.ZodIssueCode.custom,
+        path: ["creditedLanes"],
+        message: `covered workflow lane "${lane}" must appear in creditedLanes`
+      });
+      return;
+    }
+  }
+  for (const lane of value.unresolved.map((entry) => entry.workflowLane)) {
+    if (coveredLanes.has(lane)) {
+      ctx.addIssue({
+        code: exports_external.ZodIssueCode.custom,
+        path: ["unresolved"],
+        message: `workflow lane "${lane}" cannot be both credited and unresolved`
+      });
+      return;
+    }
+  }
+  const totalCovered = value.creditedLanes.length + value.unresolved.length;
+  if (totalCovered === 0) {
+    ctx.addIssue({
+      code: exports_external.ZodIssueCode.custom,
+      path: ["creditedLanes"],
+      message: "result envelope must cover at least one workflow lane"
+    });
+    return;
+  }
+  if (value.outcome === "CLEAN") {
+    if (value.findings.length > 0 || value.unresolved.length > 0) {
+      ctx.addIssue({
+        code: exports_external.ZodIssueCode.custom,
+        path: ["outcome"],
+        message: "CLEAN outcome cannot include findings or unresolved lanes"
+      });
+    }
+    if (value.cleanAttestations.length !== value.creditedLanes.length) {
+      ctx.addIssue({
+        code: exports_external.ZodIssueCode.custom,
+        path: ["cleanAttestations"],
+        message: "CLEAN outcome must attest every credited workflow lane exactly once"
+      });
+    }
+  }
+  if (value.outcome === "FINDINGS") {
+    if (value.findings.length === 0) {
+      ctx.addIssue({
+        code: exports_external.ZodIssueCode.custom,
+        path: ["findings"],
+        message: "FINDINGS outcome requires at least one finding"
+      });
+    }
+    if (value.unresolved.length > 0) {
+      ctx.addIssue({
+        code: exports_external.ZodIssueCode.custom,
+        path: ["unresolved"],
+        message: "FINDINGS outcome cannot include unresolved lanes"
+      });
+    }
+  }
+  if (value.outcome === "INCOMPLETE" && value.unresolved.length === 0) {
+    ctx.addIssue({
+      code: exports_external.ZodIssueCode.custom,
+      path: ["unresolved"],
+      message: "INCOMPLETE outcome requires at least one unresolved lane"
+    });
+  }
+});
+function serializedPrReviewResultReceiptBytes(value) {
+  return new TextEncoder().encode(JSON.stringify(value)).byteLength;
+}
+function prReviewLaneResultEnvelopeDigest(value) {
+  return createHash2("sha256").update(JSON.stringify(value)).digest("hex");
+}
+var PrReviewResultReceiptSchema = exports_external.object({
+  schemaVersion: exports_external.literal(1),
+  mode: exports_external.enum(PR_REVIEW_RESULT_LANE_MODES),
+  workflowInstanceId: exports_external.string().trim().min(1).max(256),
+  workflowRevision: exports_external.number().int().nonnegative(),
+  batchId: exports_external.string().trim().min(1).max(120),
+  laneId: exports_external.string().trim().min(1).max(120),
+  workflowLane: PrReviewResultLaneIdSchema,
+  ownedWorkflowLanes: exports_external.array(PrReviewResultLaneIdSchema).min(1).max(MAX_PR_REVIEW_RESULT_OWNED_LANES),
+  baseSha: PrReviewResultShaSchema,
+  headSha: PrReviewResultShaSchema,
+  dispatchRevisionDigest: PrReviewResultDigestSchema,
+  childSessionId: PrReviewResultChildSessionSchema,
+  generation: exports_external.number().int().positive().max(1e6),
+  semanticEnvelopeDigest: PrReviewResultDigestSchema,
+  envelope: PrReviewLaneResultEnvelopeSchema
+}).strict().superRefine((value, ctx) => {
+  assertUniqueStrings(value.ownedWorkflowLanes, ctx, ["ownedWorkflowLanes"], "ownedWorkflowLanes");
+  if (!value.ownedWorkflowLanes.includes(value.workflowLane)) {
+    ctx.addIssue({
+      code: exports_external.ZodIssueCode.custom,
+      path: ["workflowLane"],
+      message: "workflowLane must be included in ownedWorkflowLanes"
+    });
+  }
+  const covered = new Set([
+    ...value.envelope.creditedLanes,
+    ...value.envelope.unresolved.map((entry) => entry.workflowLane)
+  ]);
+  if (covered.size !== value.ownedWorkflowLanes.length) {
+    ctx.addIssue({
+      code: exports_external.ZodIssueCode.custom,
+      path: ["envelope"],
+      message: "envelope credited and unresolved workflow lanes must exactly partition ownedWorkflowLanes"
+    });
+    return;
+  }
+  for (const lane of value.ownedWorkflowLanes) {
+    if (!covered.has(lane)) {
+      ctx.addIssue({
+        code: exports_external.ZodIssueCode.custom,
+        path: ["ownedWorkflowLanes"],
+        message: `owned workflow lane "${lane}" is missing from the envelope coverage`
+      });
+      return;
+    }
+  }
+  const expectedDigest = prReviewLaneResultEnvelopeDigest(value.envelope);
+  if (value.semanticEnvelopeDigest !== expectedDigest) {
+    ctx.addIssue({
+      code: exports_external.ZodIssueCode.custom,
+      path: ["semanticEnvelopeDigest"],
+      message: "semanticEnvelopeDigest must match the canonical envelope digest"
+    });
+  }
+  const bytes = serializedPrReviewResultReceiptBytes(value);
+  if (bytes > MAX_PR_REVIEW_RESULT_RECEIPT_BYTES) {
+    ctx.addIssue({
+      code: exports_external.ZodIssueCode.custom,
+      path: [],
+      message: `receipt exceeds the ${MAX_PR_REVIEW_RESULT_RECEIPT_BYTES}-byte bound`
+    });
+  }
+});
+var PR_REVIEW_FINDINGS_MAX_BYTES = 10 * 1024 * 1024;
+var PR_REVIEW_FINDINGS_WRITE_MAX_BYTES = 3 * 1024 * 1024;
+var PR_REVIEW_HANDOFF_MAX_BYTES = 128 * 1024;
+var PR_REVIEW_HANDOFF_WRITE_MAX_BYTES = 120 * 1024;
+var PR_REVIEW_DISCARDED_EXAMPLE_ITEM_ID = "discarded-id";
+function serializedPrReviewArtifactInputBytes(value) {
+  return new TextEncoder().encode(JSON.stringify(value)).byteLength;
+}
+var PrReviewRunIdSchema = exports_external.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/, "run_id must be a safe relative identifier");
+var PrReviewFindingSchema = exports_external.object({
+  finding_id: exports_external.string().trim().min(1).max(128),
+  status: exports_external.enum(PR_REVIEW_FINDING_STATUSES),
+  file_line: exports_external.string().trim().min(1).max(1000),
+  evidence: exports_external.string().trim().min(1).max(20000),
+  next_action: exports_external.enum(PR_REVIEW_FINDING_ACTIONS),
+  severity: exports_external.enum(PR_REVIEW_SEVERITIES).optional(),
+  category: exports_external.string().trim().min(1).max(128).optional(),
+  risk_impact: exports_external.enum(PR_REVIEW_RISK_IMPACTS).optional(),
+  risk_tags: exports_external.array(exports_external.enum(PR_REVIEW_RISK_TAGS)).max(PR_REVIEW_RISK_TAGS.length).optional()
+}).strict().superRefine((value, ctx) => {
+  if (value.status !== "CONFIRMED")
+    return;
+  if (value.risk_impact === undefined) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["risk_impact"],
+      message: "is required on every newly written CONFIRMED finding (issue #2383 typed critic routing)"
+    });
+  }
+  if (value.risk_tags === undefined) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["risk_tags"],
+      message: "is required on every newly written CONFIRMED finding (issue #2383 typed critic routing)"
+    });
+  }
+});
+function prReviewFindingRequiresCritic(input) {
+  if (input.classification !== "CONFIRMED")
+    return false;
+  const impact = input.risk_impact ?? "UNKNOWN";
+  const tags = input.risk_tags ?? [];
+  if (impact === "UNKNOWN")
+    return true;
+  if (input.severity === undefined)
+    return true;
+  if (input.severity === "CRITICAL" || input.severity === "HIGH")
+    return true;
+  if (input.severity === "MEDIUM") {
+    return impact === "HIGH_IMPACT" || tags.length > 0;
+  }
+  return false;
+}
+var PrReviewHandoffSchema = exports_external.object({
+  pr_url: exports_external.string().url().max(2000),
+  finding_ids: exports_external.array(exports_external.string().trim().min(1).max(128)).min(1).max(1000),
+  summary: exports_external.string().trim().min(1).max(20000),
+  provenance: exports_external.array(exports_external.string().trim().min(1).max(4000)).min(1).max(1000)
+}).strict();
+var PrReviewPartialBaseCoverageSchema = exports_external.object({
+  unresolved_dimensions: exports_external.array(exports_external.enum(PR_REVIEW_BASE_DIMENSION_IDS)).min(1).max(PR_REVIEW_BASE_DIMENSION_IDS.length)
+}).strict().superRefine((value, ctx) => {
+  const seen = new Set;
+  for (const dimension of value.unresolved_dimensions) {
+    if (seen.has(dimension)) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["unresolved_dimensions"],
+        message: `must not contain duplicate dimension "${dimension}"`
+      });
+      return;
+    }
+    seen.add(dimension);
+  }
+});
+var WritePrReviewArtifactArgsSchema = exports_external.discriminatedUnion("kind", [
+  exports_external.object({
+    kind: exports_external.literal("findings"),
+    run_id: PrReviewRunIdSchema.optional(),
+    pr_head_sha: exports_external.string().trim().regex(/^[0-9a-f]{6,64}$/i),
+    boundary: exports_external.enum(PR_REVIEW_ARTIFACT_BOUNDARIES),
+    records: exports_external.array(PrReviewFindingSchema).min(1).max(1000),
+    partial_base_coverage: PrReviewPartialBaseCoverageSchema.optional()
+  }).strict(),
+  exports_external.object({
+    kind: exports_external.literal("handoff"),
+    run_id: PrReviewRunIdSchema.optional(),
+    pr_head_sha: exports_external.string().trim().regex(/^[0-9a-f]{6,64}$/i),
+    handoff: PrReviewHandoffSchema
+  }).strict()
+]).superRefine((value, ctx) => {
+  if (value.kind === "findings" && value.partial_base_coverage !== undefined && value.boundary !== "post_explorer") {
+    ctx.addIssue({
+      code: "custom",
+      path: ["partial_base_coverage"],
+      message: "is valid only for the post_explorer boundary"
+    });
+  }
+  const bytes = serializedPrReviewArtifactInputBytes(value);
+  const maxBytes = value.kind === "findings" ? PR_REVIEW_FINDINGS_WRITE_MAX_BYTES : PR_REVIEW_HANDOFF_WRITE_MAX_BYTES;
+  if (bytes > maxBytes) {
+    ctx.addIssue({
+      code: "custom",
+      path: [value.kind === "findings" ? "records" : "handoff"],
+      message: `serialized UTF-8 payload must be at most ${maxBytes} bytes (got ${bytes})`
+    });
+  }
+});
+var introducedByPrSchema = exports_external.string().regex(/^(?:introduced_by_pr\s*:\s*)?(?:YES|NO|UNKNOWN)$/i);
+var PrReviewRiskTagsFieldPattern = new RegExp(`^(?:(?:${PR_REVIEW_RISK_TAGS.join("|")})(?:,(?:${PR_REVIEW_RISK_TAGS.join("|")}))*)?$`);
+var PrReviewRiskTagsFieldSchema = exports_external.string().regex(PrReviewRiskTagsFieldPattern, `must be a comma-separated subset of the canonical risk tags (${PR_REVIEW_RISK_TAGS.join(", ")}), or empty`);
+var PR_REVIEW_REVIEWER_LEGACY_FIELD_COUNT = 10;
+function parsePrReviewRiskTagsField(field) {
+  const trimmed = field.trim();
+  if (!trimmed)
+    return [];
+  return trimmed.split(",").map((tag) => tag.trim());
+}
+var PrReviewReviewerVerdictFieldsSchema = exports_external.tuple([
+  exports_external.literal("[REVIEWED]"),
+  exports_external.string().min(1),
+  exports_external.enum(PR_REVIEW_REVIEWER_CLASSIFICATIONS),
+  exports_external.enum(PR_REVIEW_REVIEWER_EVIDENCE_TYPES),
+  exports_external.enum(PR_REVIEW_SEVERITIES),
+  introducedByPrSchema,
+  exports_external.string().min(1),
+  exports_external.string().min(8),
+  exports_external.string().min(5),
+  exports_external.string().min(3),
+  exports_external.enum(PR_REVIEW_RISK_IMPACTS),
+  PrReviewRiskTagsFieldSchema
+]).superRefine((fields, ctx) => {
+  if (fields[2] === "DISPROVED" && fields[4] !== "NONE") {
+    ctx.addIssue({
+      code: "custom",
+      path: [4],
+      message: "DISPROVED reviewer severity must be NONE"
+    });
+  }
+});
+var PrReviewCriticVerdictFieldsSchema = exports_external.tuple([
+  exports_external.literal("[CRITIC]"),
+  exports_external.string().min(1),
+  exports_external.enum(PR_REVIEW_CRITIC_STATUSES),
+  exports_external.enum(PR_REVIEW_SEVERITIES),
+  exports_external.string().min(6),
+  exports_external.string().min(6)
+]).superRefine((fields, ctx) => {
+  const status = fields[2];
+  const severity = fields[3];
+  if (status === "NEEDS_MORE_EVIDENCE") {
+    ctx.addIssue({
+      code: "custom",
+      path: [2],
+      message: "NEEDS_MORE_EVIDENCE is not a terminal transport verdict"
+    });
+  }
+  if (status === "DISPROVED" && severity !== "NONE") {
+    ctx.addIssue({
+      code: "custom",
+      path: [3],
+      message: "DISPROVED critic severity must be NONE"
+    });
+  }
+  if (status === "UPHELD" && !["CRITICAL", "HIGH", "MEDIUM"].includes(severity)) {
+    ctx.addIssue({
+      code: "custom",
+      path: [3],
+      message: "UPHELD critic severity must be CRITICAL, HIGH, or MEDIUM"
+    });
+  }
+  if (status === "DOWNGRADED" && severity === "CRITICAL") {
+    ctx.addIssue({
+      code: "custom",
+      path: [3],
+      message: "DOWNGRADED critic severity cannot be CRITICAL"
+    });
+  }
+});
+var PR_REVIEW_VERDICT_ROW_DESCRIPTORS = {
+  reviewer: {
+    marker: "[REVIEWED]",
+    fieldCount: 12,
+    fieldRoles: [
+      "marker",
+      "item_id",
+      "classification",
+      "evidence_type",
+      "severity",
+      "introduced_by_pr",
+      "file:line",
+      "rationale",
+      "probe",
+      "reviewer_notes",
+      "risk_impact",
+      "risk_tags"
+    ],
+    schema: PrReviewReviewerVerdictFieldsSchema
+  },
+  critic: {
+    marker: "[CRITIC]",
+    fieldCount: 6,
+    fieldRoles: [
+      "marker",
+      "item_id",
+      "status",
+      "severity",
+      "rationale",
+      "required_change"
+    ],
+    schema: PrReviewCriticVerdictFieldsSchema
+  }
+};
+function parsePrReviewVerdictRow(line, kind) {
+  const descriptor = PR_REVIEW_VERDICT_ROW_DESCRIPTORS[kind];
+  const fields = [];
+  let current = "";
+  let usedCanonicalEscape = false;
+  for (let index = 0;index < line.length; index++) {
+    const char = line[index];
+    if (char === "\\") {
+      const next = line[index + 1];
+      if (next === "\\") {
+        current += "\\";
+        usedCanonicalEscape = true;
+        index++;
+        continue;
+      }
+      if (next === "|") {
+        current += "|";
+        usedCanonicalEscape = true;
+        index++;
+        continue;
+      }
+      if (next === "n") {
+        current += `
+`;
+        usedCanonicalEscape = true;
+        index++;
+        continue;
+      }
+      if (next === "r") {
+        current += "\r";
+        usedCanonicalEscape = true;
+        index++;
+        continue;
+      }
+      current += "\\";
+      continue;
+    }
+    if (char === "|") {
+      fields.push(current.trim());
+      current = "";
+      continue;
+    }
+    current += char;
+  }
+  fields.push(current.trim());
+  if (fields[0] !== descriptor.marker)
+    return null;
+  if (kind === "reviewer" && fields.length === PR_REVIEW_REVIEWER_LEGACY_FIELD_COUNT) {
+    fields.push("UNKNOWN", "");
+  }
+  if (fields.length > descriptor.fieldCount) {
+    const retained = fields.slice(0, descriptor.fieldCount - 1);
+    retained.push(fields.slice(descriptor.fieldCount - 1).join("|"));
+    return {
+      marker: descriptor.marker,
+      fields: retained,
+      recoveredOverflow: true,
+      overflowClass: fields.length === descriptor.fieldCount + 1 && fields[fields.length - 1] === "" ? "legacy-fidelity-safe" : "legacy-lossy"
+    };
+  }
+  return {
+    marker: descriptor.marker,
+    fields,
+    recoveredOverflow: false,
+    overflowClass: fields.length === descriptor.fieldCount ? usedCanonicalEscape ? "canonical" : "legacy-fidelity-safe" : "legacy-lossy"
+  };
+}
 // src/background/pending-delegations.ts
 var BACKGROUND_DELEGATIONS_FILE = "background-delegations.jsonl";
 var BACKGROUND_DELEGATION_FALLBACK_DIR = "background-delegation-fallback";
@@ -405,6 +1038,8 @@ var MAX_BACKGROUND_ADVISORY_CHARS = 4000;
 var LEGACY_CODER_SETTLEMENT_PENDING_ADVISORY_MARKER = "legacy coder settlement transfer is pending";
 var MAX_BACKGROUND_DELEGATION_GENERATION = 1e6;
 var MAX_RECOVERY_FALLBACK_BYTES = 1024 * 1024;
+var MAX_TRACKED_LENIENT_LEDGER_SIGNALS = 32;
+var LENIENT_LEDGER_SIGNAL_SOURCE = "lenient-read";
 var DELEGATION_COMPACTION_LOW_WATER_BYTES = 256 * 1024;
 var DELEGATION_COMPACTION_HIGH_WATER_BYTES = 1024 * 1024;
 var MAX_CHECKPOINT_BYTES = 2 * 1024 * 1024;
@@ -457,6 +1092,7 @@ var ResultSchema = exports_external.object({
   outputArtifactError: exports_external.string().optional(),
   transcriptIncomplete: exports_external.boolean().optional(),
   messageCount: exports_external.number().optional(),
+  prReviewResultReceipt: PrReviewResultReceiptSchema.optional(),
   workflowLaneFailureClass: exports_external.enum(["contract", "resource", "deadline"]).optional(),
   terminalErrorClass: exports_external.object({
     kind: exports_external.enum(["provider", "aborted", "output_length", "unknown"]),
@@ -652,7 +1288,12 @@ var PromptSchema = exports_external.object({
   digest: exports_external.string()
 }).strict();
 var RecordSchema = exports_external.object({
-  schemaVersion: exports_external.union([exports_external.literal(1), exports_external.literal(2), exports_external.literal(3)]),
+  schemaVersion: exports_external.union([
+    exports_external.literal(1),
+    exports_external.literal(2),
+    exports_external.literal(3),
+    exports_external.literal(4)
+  ]),
   correlationId: exports_external.string().min(1),
   jobId: exports_external.string().nullable(),
   subagentSessionId: exports_external.string().min(1),
@@ -679,6 +1320,7 @@ var RecordSchema = exports_external.object({
   mode: exports_external.string().optional(),
   workflowLane: exports_external.string().optional(),
   ownedWorkflowLanes: exports_external.array(exports_external.string().min(1).max(120)).min(1).max(11).optional(),
+  prReviewLegacyTranscriptCompatibility: exports_external.boolean().optional(),
   promptHash: exports_external.string().optional(),
   workspace: WorkspaceSchema.optional(),
   taskChangeContext: TaskChangeContextSchema.optional(),
@@ -861,7 +1503,7 @@ function readDelegationCheckpoint(directory) {
   return { kind: "ok", checkpoint: parsed.data, bytes };
 }
 function sha256Hex(data) {
-  return createHash2("sha256").update(data).digest("hex");
+  return createHash3("sha256").update(data).digest("hex");
 }
 function checkpointPayloadChecksum(checkpoint) {
   return sha256Hex(JSON.stringify([
@@ -879,6 +1521,8 @@ function checkpointPayloadChecksum(checkpoint) {
 }
 var CHECKPOINT_REBIND_HINT = "remove .swarm/background-delegations.manifest.json (manifest only) after verifying no in-flight background delegations; recovery then falls back to the full-ledger read. Only if you also want to discard pre-cut closed summaries and audit history \u2014 which for a compacted (rolled) ledger exist ONLY in .swarm/background-delegations.checkpoint.json \u2014 remove the checkpoint too or use the full reset below";
 var CHECKPOINT_RESET_HINT = "the rolled tail no longer carries pre-checkpoint state: stop swarm processes, verify no in-flight background delegations, and remove .swarm/background-delegations.manifest.json, .swarm/background-delegations.checkpoint.json, and .swarm/background-delegations.jsonl to reset the store (or restore them from backup)";
+var lenientLedgerSignalByRoot = new Map;
+var lenientLedgerSignalOrder = [];
 function loadFoldedState(directory, options) {
   const manifestRead = readDelegationManifest(directory);
   if (manifestRead.kind === "invalid") {
@@ -968,9 +1612,13 @@ function loadFoldedState(directory, options) {
   for (const summary of checkpoint.closed) {
     records.set(summary.correlationId, summary);
   }
-  const foldError = foldLedgerTail(records, tail, options.strict, checkpoint);
+  const lenientSkips = emptyLenientLedgerSkipCounts();
+  const foldError = foldLedgerTail(records, tail, options.strict, checkpoint, lenientSkips);
   if (foldError)
     return { status: "uncertain", reason: foldError };
+  if (!options.strict) {
+    recordLenientLedgerSkips(directory, mode, lenientSkips);
+  }
   return {
     status: "ok",
     mode,
@@ -1005,7 +1653,7 @@ function readBoundedRecentLedgerWindow(directory, size) {
   const firstNewline = window.indexOf(10);
   return firstNewline === -1 ? Buffer.alloc(0) : window.subarray(firstNewline + 1);
 }
-function foldLedgerTail(records, tail, strict, checkpoint) {
+function foldLedgerTail(records, tail, strict, checkpoint, lenientSkips) {
   let lineNumber = 0;
   for (const line of tail.toString("utf-8").split(`
 `)) {
@@ -1020,6 +1668,8 @@ function foldLedgerTail(records, tail, strict, checkpoint) {
       if (strict) {
         return `background delegation ledger has malformed JSON at line ${lineNumber}`;
       }
+      if (lenientSkips)
+        lenientSkips.malformedJson += 1;
       continue;
     }
     const parsed = RecordSchema.safeParse(parsedJson);
@@ -1027,6 +1677,8 @@ function foldLedgerTail(records, tail, strict, checkpoint) {
       if (strict) {
         return `background delegation ledger has an invalid record at line ${lineNumber}`;
       }
+      if (lenientSkips)
+        lenientSkips.invalidRecord += 1;
       continue;
     }
     const existing = checkpoint ? records.get(parsed.data.correlationId) : undefined;
@@ -1055,7 +1707,9 @@ function loadLegacyLedger(directory, strict) {
       };
     }
     const records2 = new Map;
-    const foldError2 = foldLedgerTail(records2, Buffer.from(raw2, "utf-8"), false);
+    const lenientSkips = emptyLenientLedgerSkipCounts();
+    const foldError2 = foldLedgerTail(records2, Buffer.from(raw2, "utf-8"), false, undefined, lenientSkips);
+    recordLenientLedgerSkips(directory, "legacy-ledger", lenientSkips);
     return {
       status: "ok",
       mode: "legacy",
@@ -1145,6 +1799,48 @@ function recordLedgerUncertainty(directory, reason, source, repairHint) {
     });
   } catch {}
 }
+function emptyLenientLedgerSkipCounts() {
+  return { malformedJson: 0, invalidRecord: 0 };
+}
+function shouldEmitLenientLedgerSignal(directory, signature) {
+  const key = canonicalRootKeyFresh(directory);
+  const existing = lenientLedgerSignalByRoot.get(key);
+  if (existing === signature)
+    return false;
+  if (!existing) {
+    if (lenientLedgerSignalOrder.length >= MAX_TRACKED_LENIENT_LEDGER_SIGNALS) {
+      const evicted = lenientLedgerSignalOrder.shift();
+      if (evicted)
+        lenientLedgerSignalByRoot.delete(evicted);
+    }
+    lenientLedgerSignalOrder.push(key);
+  }
+  lenientLedgerSignalByRoot.set(key, signature);
+  return true;
+}
+function recordLenientLedgerSkips(directory, source, counts) {
+  const skipped = counts.malformedJson + counts.invalidRecord;
+  if (skipped <= 0)
+    return;
+  const reason = `background delegation ledger skipped ${skipped} malformed/invalid row${skipped === 1 ? "" : "s"} ` + `during lenient ${source} read (${counts.malformedJson} malformed JSON, ${counts.invalidRecord} invalid records)`;
+  const signature = `${source}:${counts.malformedJson}:${counts.invalidRecord}`;
+  if (shouldEmitLenientLedgerSignal(directory, signature)) {
+    criticalWarn(`[background] ${reason}`);
+  }
+  try {
+    const current = readDelegationHealthArtifact(directory);
+    if (current?.lastUncertainty && current.lastUncertainty.source !== LENIENT_LEDGER_SIGNAL_SOURCE) {
+      return;
+    }
+    writeDelegationHealthArtifact(directory, {
+      lastUncertainty: {
+        reason,
+        at: Date.now(),
+        source: LENIENT_LEDGER_SIGNAL_SOURCE
+      }
+    });
+  } catch {}
+}
 function isUnsettledWorktreeOwner(record) {
   return Boolean(record.worktree) && !(record.coderSettlement?.state === "settled" && record.coderSettlement.outcome?.kind === "standard-worktree" && (record.coderSettlement.outcome.result === "merged" || record.coderSettlement.outcome.result === "unchanged"));
 }
@@ -1175,7 +1871,7 @@ function buildClosedSummary(record) {
   if (summary.terminalResult) {
     summary.terminalResult = {
       ...summary.terminalResult,
-      result: dropResultBody(summary.terminalResult.result)
+      result: dropTerminalResultBody(summary.terminalResult.result)
     };
   }
   const parsed = RecordSchema.safeParse(summary);
@@ -1197,6 +1893,10 @@ function dropResultBody(result) {
   } = result;
   return rest;
 }
+function dropTerminalResultBody(result) {
+  const { prReviewResultReceipt: _receipt, ...rest } = dropResultBody(result);
+  return rest;
+}
 function dropRetainedPrReviewReceipt(record) {
   const compact = (result) => {
     const payload = parsePrReviewCollectionReceiptFooter(record, result);
@@ -1222,7 +1922,7 @@ function dropRetainedPrReviewReceipt(record) {
     ...record.terminalResult ? {
       terminalResult: {
         ...record.terminalResult,
-        result: dropResultBody(record.terminalResult.result)
+        result: dropTerminalResultBody(record.terminalResult.result)
       }
     } : {}
   };
@@ -1587,6 +2287,9 @@ function buildPendingRecord(input, now) {
     ...input.mode ? { mode: input.mode } : {},
     ...input.workflowLane ? { workflowLane: input.workflowLane } : {},
     ...input.ownedWorkflowLanes?.length ? { ownedWorkflowLanes: [...input.ownedWorkflowLanes] } : {},
+    ...input.prReviewLegacyTranscriptCompatibility !== undefined ? {
+      prReviewLegacyTranscriptCompatibility: input.prReviewLegacyTranscriptCompatibility
+    } : {},
     ...input.promptHash ? { promptHash: input.promptHash } : {},
     ...input.workspace ? { workspace: input.workspace } : {},
     ...input.taskChangeContext ? { taskChangeContext: input.taskChangeContext } : {},
@@ -1679,7 +2382,7 @@ function buildPromptSnapshot(text, maxChars) {
     text: bounded,
     chars: text.length,
     truncated,
-    digest: createHash2("sha256").update(text).digest("hex")
+    digest: createHash3("sha256").update(text).digest("hex")
   };
 }
 async function appendDelegationTransition(directory, correlationId, transition) {
@@ -1703,7 +2406,7 @@ async function appendDelegationTransition(directory, correlationId, transition)
       }
       next = {
         ...current,
-        schemaVersion: current.schemaVersion === 1 ? 2 : current.schemaVersion,
+        schemaVersion: transition.result?.prReviewResultReceipt ? 4 : current.schemaVersion === 1 ? 2 : current.schemaVersion,
         status: transition.status,
         updatedAt: now,
         ...transition.completedAt !== undefined ? { completedAt: transition.completedAt } : transition.status === "completed" || transition.status === "error" ? { completedAt: now } : {},
@@ -1718,6 +2421,87 @@ async function appendDelegationTransition(directory, correlationId, transition)
     return null;
   }
 }
+async function publishPrReviewResultReceipt(directory, input) {
+  const parsed = PrReviewResultReceiptSchema.safeParse(input.receipt);
+  if (!parsed.success) {
+    return { status: "conflict", reason: "receipt schema validation failed" };
+  }
+  let outcome = {
+    status: "uncertain",
+    reason: "receipt publication did not complete"
+  };
+  try {
+    await withEvidenceLock(directory, BACKGROUND_DELEGATIONS_FILE, STORE_LOCK_AGENT, STORE_LOCK_TASK, async () => {
+      const records = loadRecordsForWrite(directory);
+      if (records === null) {
+        outcome = {
+          status: "uncertain",
+          reason: "delegation state is uncertain"
+        };
+        return;
+      }
+      const target = findReceiptPublicationTarget(records, input);
+      if (target.count !== 1 || !target.record) {
+        outcome = {
+          status: "not_found",
+          reason: `expected one exact delegation record, found ${target.count}`
+        };
+        return;
+      }
+      const current = target.record;
+      if (current.result?.prReviewResultReceipt) {
+        const existing = current.result.prReviewResultReceipt;
+        if (samePrReviewReceiptSemantics(existing, parsed.data)) {
+          outcome = { status: "duplicate", record: current };
+        } else {
+          outcome = {
+            status: "conflict",
+            reason: "a different bound receipt is already recorded"
+          };
+        }
+        return;
+      }
+      if (current.status !== "pending" && current.status !== "running") {
+        outcome = {
+          status: "terminal",
+          reason: `delegation is already ${current.status}`
+        };
+        return;
+      }
+      const owned = current.ownedWorkflowLanes?.length ? current.ownedWorkflowLanes : current.workflowLane ? [current.workflowLane] : [];
+      const sameOwned = owned.length === parsed.data.ownedWorkflowLanes.length && owned.every((lane) => parsed.data.ownedWorkflowLanes.includes(lane));
+      if (parsed.data.workflowInstanceId !== input.expectedWorkflowInstanceId || parsed.data.workflowRevision !== input.expectedWorkflowRevision || parsed.data.baseSha !== input.expectedBaseSha || current.mode !== parsed.data.mode || current.workflowLane !== parsed.data.workflowLane || !sameOwned || current.workspace?.prHeadSha !== parsed.data.headSha || current.workspace?.gitHead !== parsed.data.headSha || (current.generation ?? 1) !== parsed.data.generation) {
+        outcome = {
+          status: "conflict",
+          reason: "receipt does not match immutable delegation identity"
+        };
+        return;
+      }
+      const next = {
+        ...current,
+        schemaVersion: 4,
+        updatedAt: Date.now(),
+        result: {
+          ...current.result ?? {
+            chars: 0,
+            truncated: false,
+            digest: createHash3("sha256").update("").digest("hex")
+          },
+          prReviewResultReceipt: parsed.data
+        }
+      };
+      appendRecord(directory, next);
+      maybeCompactDelegationsLocked(directory);
+      outcome = { status: "recorded", record: next };
+    });
+    return outcome;
+  } catch (error) {
+    return {
+      status: "uncertain",
+      reason: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
 function buildBackgroundCompletionEventId(input) {
   const canonical = JSON.stringify([
     input.correlationId,
@@ -1725,16 +2509,59 @@ function buildBackgroundCompletionEventId(input) {
     input.status,
     input.resultDigest
   ]);
-  return `bgc1:${createHash2("sha256").update(canonical).digest("hex")}`;
+  return `bgc1:${createHash3("sha256").update(canonical).digest("hex")}`;
 }
 function sameJson(left, right) {
   return JSON.stringify(left) === JSON.stringify(right);
 }
+function canonicalJson(value) {
+  if (Array.isArray(value)) {
+    return value.map(canonicalJson).sort((left, right) => {
+      const leftJson = JSON.stringify(left);
+      const rightJson = JSON.stringify(right);
+      return leftJson < rightJson ? -1 : leftJson > rightJson ? 1 : 0;
+    });
+  }
+  if (value && typeof value === "object") {
+    return Object.fromEntries(Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, entry]) => [key, canonicalJson(entry)]));
+  }
+  return value;
+}
+function sameCanonicalJson(left, right) {
+  return JSON.stringify(canonicalJson(left)) === JSON.stringify(canonicalJson(right));
+}
+function samePrReviewReceiptSemantics(left, right) {
+  const { semanticEnvelopeDigest: _leftDigest, ...leftSemantic } = left;
+  const { semanticEnvelopeDigest: _rightDigest, ...rightSemantic } = right;
+  return sameCanonicalJson(leftSemantic, rightSemantic);
+}
 function sameTerminalEvent(left, right) {
   return left.eventId === right.eventId && left.status === right.status && sameRetainedResult(left.result, right.result);
 }
 function sameRetainedResult(left, right) {
-  return left.chars === right.chars && left.truncated === right.truncated && left.digest === right.digest && left.outputRef === right.outputRef && left.outputPreviewChars === right.outputPreviewChars && left.outputDegraded === right.outputDegraded && left.outputArtifactError === right.outputArtifactError && left.transcriptIncomplete === right.transcriptIncomplete && left.messageCount === right.messageCount && left.workflowLaneFailureClass === right.workflowLaneFailureClass && sameJson(left.salvagedWorkflowLanes, right.salvagedWorkflowLanes) && sameJson(left.salvagedWorkflowLaneRecoveries, right.salvagedWorkflowLaneRecoveries);
+  return left.chars === right.chars && left.truncated === right.truncated && left.digest === right.digest && left.outputRef === right.outputRef && left.outputPreviewChars === right.outputPreviewChars && left.outputDegraded === right.outputDegraded && left.outputArtifactError === right.outputArtifactError && left.transcriptIncomplete === right.transcriptIncomplete && left.messageCount === right.messageCount && sameJson(left.prReviewResultReceipt, right.prReviewResultReceipt) && left.workflowLaneFailureClass === right.workflowLaneFailureClass && sameJson(left.salvagedWorkflowLanes, right.salvagedWorkflowLanes) && sameJson(left.salvagedWorkflowLaneRecoveries, right.salvagedWorkflowLaneRecoveries);
+}
+function recordedPrReviewResultReceipt(record) {
+  return record.result?.prReviewResultReceipt ?? record.terminalResult?.result.prReviewResultReceipt;
+}
+function mergeRecordedPrReviewResultReceipt(record, result) {
+  const existing = recordedPrReviewResultReceipt(record);
+  if (!existing || result.prReviewResultReceipt)
+    return result;
+  return { ...result, prReviewResultReceipt: existing };
+}
+function findReceiptPublicationTarget(records, input) {
+  let count = 0;
+  let record = null;
+  for (const candidate of records) {
+    if (candidate.parentSessionId !== input.parentSessionId || candidate.subagentSessionId !== input.childSessionId || candidate.batchId !== input.batchId || candidate.laneId !== input.laneId) {
+      continue;
+    }
+    count += 1;
+    if (count === 1)
+      record = candidate;
+  }
+  return { count, record: count === 1 ? record : null };
 }
 function settlementProvenanceFor(record) {
   const baseline = record.taskChangeContext?.baseline;
@@ -1773,9 +2600,11 @@ async function claimTerminalResult(directory, correlationId, terminalResult) {
       const current = findRecordForWrite(records, correlationId);
       if (!current)
         return;
+      const normalizedResult = mergeRecordedPrReviewResultReceipt(current, parsedTerminal.data.result);
+      const normalizedTerminal = normalizedResult === parsedTerminal.data.result ? parsedTerminal.data : { ...parsedTerminal.data, result: normalizedResult };
       if (current.terminalResult) {
-        if (!sameTerminalEvent(current.terminalResult, parsedTerminal.data)) {
-          warn(`[background] claimTerminalResult: different terminal event for ` + `correlationId=${correlationId}; ` + `existing={status: ${current.terminalResult.status}, eventId: ${current.terminalResult.eventId}} ` + `incoming={status: ${parsedTerminal.data.status}, eventId: ${parsedTerminal.data.eventId}}; ` + `rejected`);
+        if (!sameTerminalEvent(current.terminalResult, normalizedTerminal)) {
+          warn(`[background] claimTerminalResult: different terminal event for ` + `correlationId=${correlationId}; ` + `existing={status: ${current.terminalResult.status}, eventId: ${current.terminalResult.eventId}} ` + `incoming={status: ${normalizedTerminal.status}, eventId: ${normalizedTerminal.eventId}}; ` + `rejected`);
           incrementLateTerminalCount(directory);
           return;
         }
@@ -1796,18 +2625,18 @@ async function claimTerminalResult(directory, correlationId, terminalResult) {
             state: "pending",
             provenance,
             observedFiles: null,
-            updatedAt: parsedTerminal.data.recordedAt
+            updatedAt: normalizedTerminal.recordedAt
           };
         }
       }
-      const foldUpdatedAt = Math.max(parsedTerminal.data.recordedAt, current.updatedAt);
+      const foldUpdatedAt = Math.max(normalizedTerminal.recordedAt, current.updatedAt);
       const next = {
         ...current,
-        schemaVersion: 3,
-        status: parsedTerminal.data.status,
-        terminalResult: parsedTerminal.data,
-        result: parsedTerminal.data.result,
-        completedAt: parsedTerminal.data.recordedAt,
+        schemaVersion: normalizedTerminal.result.prReviewResultReceipt ? 4 : current.schemaVersion === 4 ? 4 : 3,
+        status: normalizedTerminal.status,
+        terminalResult: normalizedTerminal,
+        result: normalizedTerminal.result,
+        completedAt: normalizedTerminal.recordedAt,
         updatedAt: foldUpdatedAt,
         ...coderSettlement ? { coderSettlement } : {}
       };
@@ -1885,7 +2714,7 @@ async function claimCoderSettlement(directory, correlationId, operationId, input
       };
       const next = {
         ...current,
-        schemaVersion: 3,
+        schemaVersion: current.schemaVersion === 4 ? 4 : 3,
         coderSettlement: settlement,
         updatedAt: settlement.updatedAt
       };
@@ -1993,7 +2822,7 @@ async function updateCoderSettlement(directory, correlationId, input) {
       };
       const next = {
         ...current,
-        schemaVersion: 3,
+        schemaVersion: current.schemaVersion === 4 ? 4 : 3,
         coderSettlement: settlement,
         updatedAt
       };
@@ -2077,7 +2906,7 @@ async function updateLegacyCoderSettlementTransfer(directory, correlationId, tra
       const updatedAt = Date.now();
       const next = transfer ? {
         ...current,
-        schemaVersion: 3,
+        schemaVersion: current.schemaVersion === 4 ? 4 : 3,
         legacyCoderSettlementTransfer: {
           ...transfer,
           updatedAt
@@ -2138,10 +2967,10 @@ async function claimDelegationIngestion(directory, correlationId, options) {
       }
       const disposition = current.status === "ingestion_error" || current.ingestion?.state === "claimed" ? "retry" : "claimed";
       const attempt = (current.ingestion?.attempt ?? 0) + 1;
-      const claimToken = createHash2("sha256").update(JSON.stringify([correlationId, options.claimantId, attempt, now])).digest("hex");
+      const claimToken = createHash3("sha256").update(JSON.stringify([correlationId, options.claimantId, attempt, now])).digest("hex");
       const next = {
         ...current,
-        schemaVersion: 3,
+        schemaVersion: current.schemaVersion === 4 ? 4 : 3,
         ingestion: {
           state: "claimed",
           attempt,
@@ -2182,7 +3011,7 @@ async function recordDelegationIngestionResult(directory, correlationId, claimTo
       const updatedAt = options.now ?? Date.now();
       const next = {
         ...current,
-        schemaVersion: 3,
+        schemaVersion: current.schemaVersion === 4 ? 4 : 3,
         status: success ? "consumed" : "ingestion_error",
         ingestion: {
           state: success ? "consumed" : "retryable",
@@ -2231,7 +3060,7 @@ async function putPendingBackgroundAdvisory(directory, correlationId, input) {
       }
       const next = {
         ...current,
-        schemaVersion: 3,
+        schemaVersion: current.schemaVersion === 4 ? 4 : 3,
         advisoryInbox: parsed.data,
         updatedAt: createdAt
       };
@@ -2272,7 +3101,7 @@ async function replacePendingBackgroundAdvisory(directory, correlationId, input)
       }
       const next = {
         ...current,
-        schemaVersion: 3,
+        schemaVersion: current.schemaVersion === 4 ? 4 : 3,
         advisoryInbox: parsed.data,
         updatedAt: createdAt
       };
@@ -2320,7 +3149,7 @@ async function preparePendingBackgroundAdvisories(directory, parentSessionId, op
         };
         const next = {
           ...current,
-          schemaVersion: 3,
+          schemaVersion: current.schemaVersion === 4 ? 4 : 3,
           advisoryInbox: nextAdvisory,
           updatedAt: now
         };
@@ -2365,7 +3194,7 @@ async function releaseBackgroundAdvisoryPreparation(directory, parentSessionId,
         const now = Date.now();
         const next = {
           ...current,
-          schemaVersion: 3,
+          schemaVersion: current.schemaVersion === 4 ? 4 : 3,
           advisoryInbox: {
             ...current.advisoryInbox,
             preparation: undefined
@@ -2407,7 +3236,7 @@ async function acknowledgeObservedBackgroundAdvisories(directory, parentSessionI
         }
         const next = {
           ...current,
-          schemaVersion: 3,
+          schemaVersion: current.schemaVersion === 4 ? 4 : 3,
           advisoryInbox: {
             ...advisory,
             state: "delivered",
@@ -2487,7 +3316,7 @@ async function sweepStaleDelegations(directory, timeoutMs, options = {}) {
   }
 }
 function fallbackRelativePath(correlationId) {
-  const digest = createHash2("sha256").update(correlationId).digest("hex");
+  const digest = createHash3("sha256").update(correlationId).digest("hex");
   return path2.join(BACKGROUND_DELEGATION_FALLBACK_DIR, `${digest}.json`);
 }
 function fallbackPath(directory, correlationId) {
@@ -2745,7 +3574,7 @@ function reservationStorePath(directory) {
 }
 function buildBackgroundCoderReservationId(input) {
   const ownerIdentity = input.planTaskId === null ? ["call", input.parentSessionId, input.callID] : ["task", input.parentSessionId, input.planTaskId];
-  return `bgcr1:${createHash2("sha256").update(JSON.stringify(ownerIdentity)).digest("hex")}`;
+  return `bgcr1:${createHash3("sha256").update(JSON.stringify(ownerIdentity)).digest("hex")}`;
 }
 function scanBackgroundCoderReservationsForAdmission(directory) {
   let absolutePath;
@@ -3105,7 +3934,7 @@ async function reconcileLegacyCoderSettlements(directory, maxRecords, onReconcil
   const candidates = readDelegations(directory).filter((record) => record.normalizedAgent === "coder" && Boolean(record.legacyCoderSettlementTransfer) && Boolean(record.terminalResult)).slice(0, maxRecords);
   if (candidates.length === 0)
     return 0;
-  const { transferCoderSettlementToBackground } = await import("./coder-settlement-zn552sp9.js");
+  const { transferCoderSettlementToBackground } = await import("./coder-settlement-gzar5ypz.js");
   let transferred = 0;
   for (const record of candidates) {
     try {
@@ -3462,4 +4291,4 @@ async function maintainBackgroundDelegations(directory, options = {}) {
   return emitObservation("ok");
 }
 
-export { MAX_RECOVERY_LEDGER_BYTES, readDelegationHealthArtifact, collectDelegationLedgerHealth, MAX_PR_REVIEW_COLLECTION_RECEIPT_ITEM_IDS, BACKGROUND_DELEGATIONS_FILE, BACKGROUND_DELEGATION_FALLBACK_DIR, BACKGROUND_CODER_RESERVATIONS_FILE, BACKGROUND_DELEGATIONS_CHECKPOINT_FILE, BACKGROUND_DELEGATIONS_MANIFEST_FILE, MAX_LIVE_BACKGROUND_FALLBACKS, MAX_LIVE_BACKGROUND_CODER_RESERVATIONS, MAX_BACKGROUND_OBSERVED_FILES, MAX_BACKGROUND_ADVISORY_CHARS, LEGACY_CODER_SETTLEMENT_PENDING_ADVISORY_MARKER, DELEGATION_COMPACTION_LOW_WATER_BYTES, DELEGATION_COMPACTION_HIGH_WATER_BYTES, MAX_CHECKPOINT_BYTES, MAX_CHECKPOINT_RECORDS, TOMBSTONE_MIN_AGE_MS, BACKGROUND_INGESTION_LEASE_MS, BACKGROUND_CODER_RESERVATION_LEASE_MS, BACKGROUND_CODER_RESERVATION_LEASE_MAX_MS, BACKGROUND_CODER_RESERVATION_LEASE_MIN_MS, DEFAULT_STALE_DELEGATION_TIMEOUT_MS, DEFAULT_SWEEPABLE_DELEGATION_STATUSES, _checkpointInternals, isUnsettledWorktreeOwner, compactBackgroundDelegations, readDelegations, scanDelegationsForRecovery, findByCorrelationId, recordPendingDelegationDetailed, recordPendingDelegation, buildPromptSnapshot, appendDelegationTransition, buildBackgroundCompletionEventId, claimTerminalResult, claimCoderSettlement, normalizeBackgroundObservedFiles, updateCoderSettlement, registerLegacyCoderSettlementReconciler, _internals, markLegacyCoderSettlementTransferPending, clearLegacyCoderSettlementTransferPending, claimDelegationIngestion, recordDelegationIngestionResult, putPendingBackgroundAdvisory, replacePendingBackgroundAdvisory, preparePendingBackgroundAdvisories, acknowledgeObservedBackgroundAdvisories, releasePreparedBackgroundAdvisories, findByBatchId, findOpenAsyncLaneBatches, sweepStaleDelegations, readDelegationFallback, listDelegationFallbacks, scanDelegationFallbacksForRecovery, writeDelegationFallback, removeDelegationFallback, findDelegationForCompletion, promoteDelegationFallback, buildBackgroundCoderReservationId, scanBackgroundCoderReservationsForAdmission, reserveBackgroundCoderSlot, bindBackgroundCoderReservation, releaseBackgroundCoderReservation, maintainBackgroundDelegations };
+export { PR_REVIEW_BASE_DIMENSION_IDS, PR_REVIEW_RISK_IMPACTS, PR_REVIEW_RISK_TAGS, prReviewLegacyTranscriptCompatibilityEnabled, PrReviewResultReceiptSchema, PR_REVIEW_FINDINGS_MAX_BYTES, PR_REVIEW_HANDOFF_MAX_BYTES, PR_REVIEW_DISCARDED_EXAMPLE_ITEM_ID, PrReviewRunIdSchema, prReviewFindingRequiresCritic, parsePrReviewRiskTagsField, PrReviewReviewerVerdictFieldsSchema, PrReviewCriticVerdictFieldsSchema, parsePrReviewVerdictRow, MAX_RECOVERY_LEDGER_BYTES, readDelegationHealthArtifact, collectDelegationLedgerHealth, MAX_PR_REVIEW_COLLECTION_RECEIPT_ITEM_IDS, BACKGROUND_DELEGATIONS_FILE, BACKGROUND_DELEGATION_FALLBACK_DIR, BACKGROUND_CODER_RESERVATIONS_FILE, BACKGROUND_DELEGATIONS_CHECKPOINT_FILE, BACKGROUND_DELEGATIONS_MANIFEST_FILE, MAX_LIVE_BACKGROUND_FALLBACKS, MAX_LIVE_BACKGROUND_CODER_RESERVATIONS, MAX_BACKGROUND_OBSERVED_FILES, MAX_BACKGROUND_ADVISORY_CHARS, LEGACY_CODER_SETTLEMENT_PENDING_ADVISORY_MARKER, DELEGATION_COMPACTION_LOW_WATER_BYTES, DELEGATION_COMPACTION_HIGH_WATER_BYTES, MAX_CHECKPOINT_BYTES, MAX_CHECKPOINT_RECORDS, TOMBSTONE_MIN_AGE_MS, BACKGROUND_INGESTION_LEASE_MS, BACKGROUND_CODER_RESERVATION_LEASE_MS, BACKGROUND_CODER_RESERVATION_LEASE_MAX_MS, BACKGROUND_CODER_RESERVATION_LEASE_MIN_MS, DEFAULT_STALE_DELEGATION_TIMEOUT_MS, DEFAULT_SWEEPABLE_DELEGATION_STATUSES, _checkpointInternals, isUnsettledWorktreeOwner, compactBackgroundDelegations, readDelegations, scanDelegationsForRecovery, findByCorrelationId, recordPendingDelegationDetailed, recordPendingDelegation, buildPromptSnapshot, appendDelegationTransition, publishPrReviewResultReceipt, buildBackgroundCompletionEventId, claimTerminalResult, claimCoderSettlement, normalizeBackgroundObservedFiles, updateCoderSettlement, registerLegacyCoderSettlementReconciler, _internals, markLegacyCoderSettlementTransferPending, clearLegacyCoderSettlementTransferPending, claimDelegationIngestion, recordDelegationIngestionResult, putPendingBackgroundAdvisory, replacePendingBackgroundAdvisory, preparePendingBackgroundAdvisories, acknowledgeObservedBackgroundAdvisories, releasePreparedBackgroundAdvisories, findByBatchId, findOpenAsyncLaneBatches, sweepStaleDelegations, readDelegationFallback, listDelegationFallbacks, scanDelegationFallbacksForRecovery, writeDelegationFallback, removeDelegationFallback, findDelegationForCompletion, promoteDelegationFallback, buildBackgroundCoderReservationId, scanBackgroundCoderReservationsForAdmission, reserveBackgroundCoderSlot, bindBackgroundCoderReservation, releaseBackgroundCoderReservation, maintainBackgroundDelegations };