opencode-swarm 7.164.0 → 7.164.2

package/dist/cli/{index-12f1tsn2.js → index-hnwg5gt6.js}

@@ -2,22 +2,19 @@
 import {
   canonicalRootKeyFresh
 } from "./index-ddszzne4.js";
-import {
-  PrReviewResultReceiptSchema
-} from "./index-w7ekntej.js";
 import {
   validateSwarmPath
-} from "./index-dtn0pne5.js";
+} from "./index-v56mhyhs.js";
 import {
   bunWrite
 } from "./index-r3mvsbtq.js";
 import {
   observeDelegationLedgerPressure
-} from "./index-wdtckfnf.js";
+} from "./index-ac39znep.js";
 import {
   EvidenceLockTimeoutError,
   withEvidenceLock
-} from "./index-36nt17m8.js";
+} from "./index-yep24wn4.js";
 import {
   exports_external,
   init_zod
@@ -33,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";
@@ -396,6 +393,648 @@ 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";
+
+// src/pr-review/critic-routing.ts
+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;
+}
+
+// src/background/pr-review-contract.ts
+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)"
+    });
+  }
+});
+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"
+  };
+}
+function pad(value, width) {
+  return `${value}`.padStart(width, "0");
+}
+function generatePrReviewRunId(now = new Date) {
+  return `pr-review-${now.getUTCFullYear()}` + `${pad(now.getUTCMonth() + 1, 2)}` + `${pad(now.getUTCDate(), 2)}` + `${pad(now.getUTCHours(), 2)}` + `${pad(now.getUTCMinutes(), 2)}` + `${pad(now.getUTCSeconds(), 2)}` + `${pad(now.getUTCMilliseconds(), 3)}`;
+}
 // src/background/pending-delegations.ts
 var BACKGROUND_DELEGATIONS_FILE = "background-delegations.jsonl";
 var BACKGROUND_DELEGATION_FALLBACK_DIR = "background-delegation-fallback";
@@ -874,7 +1513,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([
@@ -1753,7 +2392,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) {
@@ -1856,7 +2495,7 @@ async function publishPrReviewResultReceipt(directory, input) {
           ...current.result ?? {
             chars: 0,
             truncated: false,
-            digest: createHash2("sha256").update("").digest("hex")
+            digest: createHash3("sha256").update("").digest("hex")
           },
           prReviewResultReceipt: parsed.data
         }
@@ -1880,7 +2519,7 @@ 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);
@@ -2338,7 +2977,7 @@ 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: current.schemaVersion === 4 ? 4 : 3,
@@ -2690,7 +3329,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) {
@@ -2948,7 +3587,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;
@@ -3308,7 +3947,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-84je6bza.js");
+  const { transferCoderSettlementToBackground } = await import("./coder-settlement-kv1x94w6.js");
   let transferred = 0;
   for (const record of candidates) {
     try {
@@ -3665,4 +4304,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, publishPrReviewResultReceipt, buildBackgroundCompletionEventId, claimTerminalResult, claimCoderSettlement, normalizeBackgroundObservedFiles, updateCoderSettlement, registerLegacyCoderSettlementReconciler, _internals, markLegacyCoderSettlementTransferPending, clearLegacyCoderSettlementTransferPending, claimDelegationIngestion, recordDelegationIngestionResult, putPendingBackgroundAdvisory, replacePendingBackgroundAdvisory, preparePendingBackgroundAdvisories, acknowledgeObservedBackgroundAdvisories, releasePreparedBackgroundAdvisories, findByBatchId, findOpenAsyncLaneBatches, isTerminalDelegationStatus, sweepStaleDelegations, readDelegationFallback, listDelegationFallbacks, scanDelegationFallbacksForRecovery, writeDelegationFallback, removeDelegationFallback, findDelegationForCompletion, promoteDelegationFallback, buildBackgroundCoderReservationId, scanBackgroundCoderReservationsForAdmission, reserveBackgroundCoderSlot, bindBackgroundCoderReservation, releaseBackgroundCoderReservation, maintainBackgroundDelegations };
+export { prReviewFindingRequiresCritic, PR_REVIEW_BASE_DIMENSION_IDS, PR_REVIEW_RISK_IMPACTS, PR_REVIEW_RISK_TAGS, prReviewLegacyTranscriptCompatibilityEnabled, PrReviewLaneResultEnvelopeSchema, prReviewLaneResultEnvelopeDigest, PrReviewResultReceiptSchema, PR_REVIEW_FINDINGS_MAX_BYTES, PR_REVIEW_HANDOFF_MAX_BYTES, PR_REVIEW_DISCARDED_EXAMPLE_ITEM_ID, PrReviewRunIdSchema, parsePrReviewRiskTagsField, PrReviewReviewerVerdictFieldsSchema, PrReviewCriticVerdictFieldsSchema, parsePrReviewVerdictRow, generatePrReviewRunId, 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, isTerminalDelegationStatus, sweepStaleDelegations, readDelegationFallback, listDelegationFallbacks, scanDelegationFallbacksForRecovery, writeDelegationFallback, removeDelegationFallback, findDelegationForCompletion, promoteDelegationFallback, buildBackgroundCoderReservationId, scanBackgroundCoderReservationsForAdmission, reserveBackgroundCoderSlot, bindBackgroundCoderReservation, releaseBackgroundCoderReservation, maintainBackgroundDelegations };