@fro.bot/systematic 3.18.3 → 3.18.4

package/skills/ce-review/scripts/validate-review.mjs

@@ -2,6 +2,7 @@
 // biome-ignore-all assist/source/organizeImports: generated bundle
 // Generated by scripts/generate-ce-review-validator.ts; do not edit by hand.
 // Run `bun run ce-review-validator:build` to regenerate.
+// source-digest: e190da64b4101889aec4ed850be0ef1316410ad46f7f05c626071592bad384b9
 var __defProp = Object.defineProperty
 var __returnValue = (v) => v
 function __exportSetter(name, newValue) {
@@ -6400,7 +6401,6 @@ var REVIEW_ARTIFACT_CUSTOM_MESSAGES = [
   'provenance.agreement_credit must not contain duplicate reviewers',
   'provenance.agreement_credit must not overlap provenance.submitters',
   'provenance.agreement_credit requires an eligible returned persona with admitted evidence',
-  'satisfied risk coverage must cite a validated finding on the lost persona selection surface',
   'satisfied risk coverage must cite an admitted ledger row owned by another persona',
 ]
 var boundedText = (maxLength) => string2().min(1).max(maxLength).regex(/\S/)
@@ -6840,24 +6840,6 @@ var ReviewArtifactSchema = object({
         return
       }
       if (owner === coverage.persona) {
-        ctx.addIssue({
-          code: 'custom',
-          path: ['risk_coverage', coverageIndex, 'input_finding_id'],
-          message: REVIEW_ARTIFACT_CUSTOM_MESSAGES[19],
-        })
-        return
-      }
-      const lostDispatch = artifact.dispatches.find(
-        (dispatch) => dispatch.persona === coverage.persona,
-      )
-      const surface = lostDispatch?.selection_surface ?? []
-      const covered = artifact.findings.some(
-        (finding) =>
-          finding.input_finding_ids.includes(citedId) &&
-          finding.validated !== false &&
-          surface.includes(finding.file),
-      )
-      if (!covered) {
         ctx.addIssue({
           code: 'custom',
           path: ['risk_coverage', coverageIndex, 'input_finding_id'],
@@ -7018,6 +7000,351 @@ function runClaudeCodeValidator(options) {
 if (false) {
 }
 
+// src/lib/review-pipeline.ts
+import path2 from 'node:path'
+
+// src/lib/review-pipeline-contract.ts
+var boundedText2 = (maxLength) => string2().min(1).max(maxLength).regex(/\S/)
+var PipelineInputIdSchema = boundedText2(MAX_INPUT_ID_LENGTH)
+var PipelineReasonSchema = boundedText2(MAX_REASON_LENGTH)
+var RejectedSummaryDispatchOutcomeSchema2 = DispatchOutcomeSchema.exclude([
+  'validation_unavailable',
+])
+var AdmittedScreenDispositionSchema = DispositionSchema.exclude(['rejected'])
+var ScreenInputSchema = object({
+  raw_return: SubAgentReturnSchema,
+  expected_reviewer: SubAgentReturnSchema.shape.reviewer,
+  invoking_harness: HarnessSchema,
+}).strict()
+var AdmittedScreenFindingSchema = ParentFindingSchema.extend({
+  input_id: PipelineInputIdSchema,
+  disposition: AdmittedScreenDispositionSchema,
+}).strict()
+var ScreenRejectedSummarySchema = object({
+  dispatch_outcome: RejectedSummaryDispatchOutcomeSchema2,
+  rejected_finding_count: number2().int().positive().max(MAX_FINDINGS),
+  rejected_severities: array(SeveritySchema).max(MAX_FINDINGS),
+  reason: PipelineReasonSchema,
+})
+  .strict()
+  .superRefine((summary, ctx) => {
+    if (summary.rejected_severities.length !== summary.rejected_finding_count) {
+      ctx.addIssue({
+        code: 'custom',
+        path: ['rejected_severities'],
+        message: 'severity count must match rejected finding count',
+      })
+    }
+  })
+var ScreenOutputSchema = object({
+  dispatch_outcome: DispatchOutcomeSchema,
+  admitted_findings: array(AdmittedScreenFindingSchema).max(MAX_FINDINGS),
+  rejected_summary: ScreenRejectedSummarySchema.optional(),
+  residual_risks: SubAgentReturnSchema.shape.residual_risks,
+  testing_gaps: SubAgentReturnSchema.shape.testing_gaps,
+  harness: HarnessSchema,
+}).strict()
+var ScreenResultSchema = object({
+  reviewer: SubAgentReturnSchema.shape.reviewer,
+  result: ScreenOutputSchema,
+}).strict()
+var SelectedDispatchSchema = object({
+  persona: SubAgentReturnSchema.shape.reviewer,
+  dispatch_outcome: DispatchOutcomeSchema,
+  selection_surface: array(RepoRelativePathSchema).max(MAX_FINDINGS).optional(),
+  selection_reason: PipelineReasonSchema.optional(),
+}).strict()
+var PrepareInputSchema = object({
+  screen_results: array(ScreenResultSchema).max(MAX_PERSONAS),
+  selected_dispatches: array(SelectedDispatchSchema).max(MAX_PERSONAS),
+}).strict()
+var ConfidenceDispositionSchema = object({
+  input_id: PipelineInputIdSchema,
+  disposition: DispositionSchema.extract(['surviving', 'suppressed']),
+  confidence: ParentFindingSchema.shape.confidence,
+  reason: PipelineReasonSchema.optional(),
+}).strict()
+var CandidateGroupMemberSchema = object({
+  input_id: PipelineInputIdSchema,
+  line: ParentFindingSchema.shape.line,
+}).strict()
+var CandidateGroupSchema = object({
+  file: RepoRelativePathSchema,
+  members: array(CandidateGroupMemberSchema).min(2).max(MAX_FINDINGS),
+}).strict()
+var SurvivingAdmittedFindingSchema = ParentFindingSchema.extend({
+  input_id: PipelineInputIdSchema,
+  reviewer: SubAgentReturnSchema.shape.reviewer,
+}).strict()
+var PrepareOutputSchema = object({
+  confidence_dispositions: array(ConfidenceDispositionSchema).max(
+    MAX_FINDINGS * MAX_PERSONAS,
+  ),
+  coverage_union: array(RepoRelativePathSchema).max(
+    MAX_FINDINGS * MAX_PERSONAS,
+  ),
+  singletons: array(PipelineInputIdSchema).max(MAX_FINDINGS * MAX_PERSONAS),
+  candidate_groups: array(CandidateGroupSchema).max(MAX_FINDINGS),
+  surviving_findings: array(SurvivingAdmittedFindingSchema).max(
+    MAX_FINDINGS * MAX_PERSONAS,
+  ),
+}).strict()
+var PER_FINDING_BYTE_ASSUMPTION = 8192
+var AGGREGATE_BYTE_CAP_HEADROOM = 65536
+var AGGREGATE_STDIN_BYTE_CAP =
+  MAX_PERSONAS * MAX_FINDINGS * PER_FINDING_BYTE_ASSUMPTION +
+  AGGREGATE_BYTE_CAP_HEADROOM
+var AutofixClassRouteSchema = ParentFindingSchema.shape.autofix_class
+var OwnerRouteSchema = ParentFindingSchema.shape.owner
+var AUTOFIX_CLASS_NARROWS_TO = {
+  safe_auto: ['safe_auto', 'gated_auto', 'manual', 'advisory'],
+  gated_auto: ['gated_auto', 'manual', 'advisory'],
+  manual: ['manual', 'advisory'],
+  advisory: ['advisory'],
+}
+var OWNER_NARROWS_TO = {
+  'review-fixer': ['review-fixer', 'downstream-resolver', 'human', 'release'],
+  'downstream-resolver': ['downstream-resolver', 'release'],
+  human: ['human', 'release'],
+  release: ['release'],
+}
+var REQUIRES_VERIFICATION_NARROWS_TO = {
+  false: ['false', 'true'],
+  true: ['true'],
+}
+var ROUTE_REFUSAL_TABLE = {
+  autofix_class: AUTOFIX_CLASS_NARROWS_TO,
+  owner: OWNER_NARROWS_TO,
+  requires_verification: REQUIRES_VERIFICATION_NARROWS_TO,
+}
+var isRouteTransitionAllowed = (from, to) => {
+  const autofixAllowed = ROUTE_REFUSAL_TABLE.autofix_class[
+    from.autofix_class
+  ].includes(to.autofix_class)
+  const ownerAllowed = ROUTE_REFUSAL_TABLE.owner[from.owner].includes(to.owner)
+  const fromVerification = from.requires_verification ? 'true' : 'false'
+  const toVerification = to.requires_verification ? 'true' : 'false'
+  const verificationAllowed =
+    ROUTE_REFUSAL_TABLE.requires_verification[fromVerification].includes(
+      toVerification,
+    )
+  return autofixAllowed && ownerAllowed && verificationAllowed
+}
+var AgreementCreditSchema = SubAgentReturnSchema.shape.reviewer
+var DisagreementFactsSchema = array(PipelineReasonSchema).max(MAX_FINDINGS)
+var ProposedRouteSchema = object({
+  autofix_class: AutofixClassRouteSchema,
+  owner: OwnerRouteSchema,
+  requires_verification: ParentFindingSchema.shape.requires_verification,
+}).strict()
+var MergedDecisionSchema = object({
+  decision_id: PipelineInputIdSchema,
+  disposition: literal('merged'),
+  input_finding_ids: array(PipelineInputIdSchema).min(2).max(MAX_FINDINGS),
+  title: ParentFindingSchema.shape.title,
+  why_it_matters: ParentFindingSchema.shape.why_it_matters,
+  evidence: ParentFindingSchema.shape.evidence,
+  suggested_fix: ParentFindingSchema.shape.suggested_fix,
+  line: ParentFindingSchema.shape.line,
+  disagreement_facts: DisagreementFactsSchema.optional(),
+  eligible_agreement_credit: array(AgreementCreditSchema)
+    .max(MAX_PERSONAS)
+    .optional(),
+  proposed_route: ProposedRouteSchema.optional(),
+  route_narrowing_reason: PipelineReasonSchema.optional(),
+}).strict()
+var DeclinedDecisionSchema = object({
+  decision_id: PipelineInputIdSchema,
+  disposition: literal('declined'),
+  input_finding_id: PipelineInputIdSchema,
+  declined_reason: PipelineReasonSchema,
+  disagreement_facts: DisagreementFactsSchema.optional(),
+  proposed_route: ProposedRouteSchema.optional(),
+  route_narrowing_reason: PipelineReasonSchema.optional(),
+}).strict()
+var MergeDecisionSchema = discriminatedUnion('disposition', [
+  MergedDecisionSchema,
+  DeclinedDecisionSchema,
+])
+var AdjudicationEnvelopeSchema = object({
+  decisions: array(MergeDecisionSchema).max(MAX_FINDINGS),
+})
+  .strict()
+  .superRefine((envelope, ctx) => {
+    const seenDecisionIds = new Set()
+    const seenInputIds = new Set()
+    envelope.decisions.forEach((decision, decisionIndex) => {
+      if (seenDecisionIds.has(decision.decision_id)) {
+        ctx.addIssue({
+          code: 'custom',
+          path: ['decisions', decisionIndex, 'decision_id'],
+          message: 'duplicate decision ID',
+        })
+      }
+      seenDecisionIds.add(decision.decision_id)
+      if (decision.proposed_route && !decision.route_narrowing_reason) {
+        ctx.addIssue({
+          code: 'custom',
+          path: ['decisions', decisionIndex, 'route_narrowing_reason'],
+          message:
+            'route_narrowing_reason is required when proposed_route is present',
+        })
+      }
+      if (decision.disposition === 'merged') {
+        decision.input_finding_ids.forEach((inputId, inputIndex) => {
+          if (seenInputIds.has(inputId)) {
+            ctx.addIssue({
+              code: 'custom',
+              path: [
+                'decisions',
+                decisionIndex,
+                'input_finding_ids',
+                inputIndex,
+              ],
+              message: 'input finding ID already claimed by another decision',
+            })
+          }
+          seenInputIds.add(inputId)
+        })
+        return
+      }
+      if (seenInputIds.has(decision.input_finding_id)) {
+        ctx.addIssue({
+          code: 'custom',
+          path: ['decisions', decisionIndex, 'input_finding_id'],
+          message: 'input finding ID already claimed by another decision',
+        })
+      }
+      seenInputIds.add(decision.input_finding_id)
+    })
+  })
+var MergeInputSchema = object({
+  prepared: PrepareOutputSchema,
+  adjudication: AdjudicationEnvelopeSchema,
+}).strict()
+var ValidatorRequestSchema = object({
+  finding_id: PipelineInputIdSchema,
+  file: RepoRelativePathSchema,
+  line: ParentFindingSchema.shape.line,
+}).strict()
+var MergedFindingSchema = object({
+  finding_id: PipelineInputIdSchema,
+  file: RepoRelativePathSchema,
+  title: ParentFindingSchema.shape.title,
+  why_it_matters: ParentFindingSchema.shape.why_it_matters,
+  line: ParentFindingSchema.shape.line,
+  autofix_class: ParentFindingSchema.shape.autofix_class,
+  owner: ParentFindingSchema.shape.owner,
+  requires_verification: ParentFindingSchema.shape.requires_verification,
+  evidence: ParentFindingSchema.shape.evidence,
+  suggested_fix: ParentFindingSchema.shape.suggested_fix,
+  input_finding_ids: array(PipelineInputIdSchema).min(1).max(MAX_FINDINGS),
+  agreement_credit: array(AgreementCreditSchema).max(MAX_PERSONAS).optional(),
+  severity: ParentFindingSchema.shape.severity,
+  confidence: ParentFindingSchema.shape.confidence,
+  pre_existing: ParentFindingSchema.shape.pre_existing,
+  fingerprint: ProvenanceSchema.shape.fingerprint,
+  submitters: ProvenanceSchema.shape.submitters,
+}).strict()
+var MergeOutputSchema = object({
+  merged_findings: array(MergedFindingSchema).max(MAX_FINDINGS),
+  validator_requests: array(ValidatorRequestSchema).max(MAX_FINDINGS),
+  disagreement_facts: DisagreementFactsSchema,
+}).strict()
+var ValidatorLifecycleResultSchema = discriminatedUnion('outcome', [
+  object({ outcome: literal('true') }).strict(),
+  object({ outcome: literal('false'), reason: PipelineReasonSchema }).strict(),
+  object({ outcome: literal('failed'), reason: PipelineReasonSchema }).strict(),
+  object({
+    outcome: literal('unavailable'),
+    reason: PipelineReasonSchema,
+  }).strict(),
+])
+var ValidatorLifecycleRecordSchema = object({
+  finding_id: PipelineInputIdSchema,
+  result: ValidatorLifecycleResultSchema,
+}).strict()
+var ValidatorLifecycleResultsSchema = array(ValidatorLifecycleRecordSchema).max(
+  MAX_FINDINGS,
+)
+var PlanAssessmentResultSchema = object({
+  kind: _enum(['explicit_unmet_requirement', 'inferred_gap']),
+  description: PipelineReasonSchema,
+}).strict()
+var PlanAssessmentEnvelopeSchema = object({
+  verdict: ReviewArtifactSchema.shape.verdict,
+  results: array(PlanAssessmentResultSchema).max(MAX_FINDINGS),
+}).strict()
+var ParentRunModeSchema = _enum([
+  ...ReviewArtifactSchema.shape.mode.options,
+  'report-only',
+])
+var ParentRunMetadataSchema = object({
+  run_id: ReviewArtifactSchema.shape.run_id,
+  mode: ParentRunModeSchema,
+  harness: ReviewArtifactSchema.shape.harness,
+  branch: ReviewArtifactSchema.shape.branch,
+  head_sha: ReviewArtifactSchema.shape.head_sha,
+  selected_dispatches: array(SelectedDispatchSchema).max(MAX_PERSONAS),
+  timestamps: object({
+    started_at: ReviewArtifactSchema.shape.completed_at,
+    completed_at: ReviewArtifactSchema.shape.completed_at,
+  }).strict(),
+  validation: ReviewArtifactSchema.shape.validation.unwrap(),
+  applied_fixes: ReviewArtifactSchema.shape.applied_fixes,
+}).strict()
+var FinalizeInputSchema = object({
+  merge: MergeOutputSchema,
+  prepared: PrepareOutputSchema,
+  screen_results: PrepareInputSchema.shape.screen_results,
+  dispatch_records: array(SelectedDispatchSchema).max(MAX_PERSONAS),
+  validator_lifecycle_results: ValidatorLifecycleResultsSchema,
+  plan_assessment: PlanAssessmentEnvelopeSchema,
+  parent_run_metadata: ParentRunMetadataSchema,
+}).strict()
+var FinalizedInputDispositionSchema = object({
+  input_id: PipelineInputIdSchema,
+  disposition: DispositionSchema.extract([
+    'suppressed',
+    'filtered',
+    'merged',
+    'surviving',
+  ]),
+  reason: PipelineReasonSchema.optional(),
+}).strict()
+var ReportQueueEntrySchema = object({
+  finding_id: PipelineInputIdSchema,
+  unconfirmed: boolean2(),
+}).strict()
+var ReportQueuesSchema = object({
+  fixer: array(ReportQueueEntrySchema).max(MAX_FINDINGS),
+  residual: array(ReportQueueEntrySchema).max(MAX_FINDINGS),
+  report_only: array(ReportQueueEntrySchema).max(MAX_FINDINGS),
+}).strict()
+var ReportProjectionSchema = object({
+  verdict: ReviewArtifactSchema.shape.verdict,
+  findings: ReviewArtifactSchema.shape.findings,
+  applied_fixes: ReviewArtifactSchema.shape.applied_fixes,
+  residual_actionable_work: ReviewArtifactSchema.shape.residual_actionable_work,
+  advisory_outputs: ReviewArtifactSchema.shape.advisory_outputs,
+  coverage: ReviewArtifactSchema.shape.coverage,
+  input_dispositions: array(FinalizedInputDispositionSchema).max(
+    MAX_FINDINGS * MAX_PERSONAS,
+  ),
+  disposition_counts: ReviewArtifactSchema.shape.disposition_counts,
+  queues: ReportQueuesSchema,
+  pre_existing_findings: array(ReportQueueEntrySchema).max(MAX_FINDINGS),
+  risk_coverage: ReviewArtifactSchema.shape.risk_coverage,
+}).strict()
+var FinalizeOutputSchema = discriminatedUnion('kind', [
+  object({
+    kind: literal('writing'),
+    artifact: ReviewArtifactSchema,
+    report: ReportProjectionSchema,
+  }).strict(),
+  ReportProjectionSchema.extend({ kind: literal('report_only') }).strict(),
+])
+
 // src/lib/review-return-validator.ts
 import fs2 from 'node:fs'
 var VALIDATE_REVIEW_RETURN_USAGE = 'Usage: systematic validate-review-return'
@@ -7074,11 +7401,11 @@ function readChunkWithRetry(fd, buffer, toRead, readChunk) {
     }
   }
 }
-function readBoundedStdin(fd, readChunk) {
+function readBoundedStdin(fd, readChunk, maxBytes = MAX_REVIEW_RETURN_BYTES) {
   const chunks = []
   let total = 0
   while (true) {
-    const remaining = MAX_REVIEW_RETURN_BYTES + 1 - total
+    const remaining = maxBytes + 1 - total
     if (remaining <= 0) return { status: 'oversized' }
     const toRead = Math.min(READ_CHUNK_BYTES, remaining)
     const buffer = Buffer.allocUnsafe(toRead)
@@ -7087,7 +7414,7 @@ function readBoundedStdin(fd, readChunk) {
     if (read.bytesRead <= 0) break
     total += read.bytesRead
     chunks.push(buffer.subarray(0, read.bytesRead))
-    if (total > MAX_REVIEW_RETURN_BYTES) return { status: 'oversized' }
+    if (total > maxBytes) return { status: 'oversized' }
   }
   return { buffer: Buffer.concat(chunks, total), status: 'ok' }
 }
@@ -7150,48 +7477,2940 @@ function runReviewReturnValidator(options) {
   return 1
 }
 
-// src/ce-review-validator.ts
-var CE_REVIEW_VALIDATOR_USAGE =
-  'Usage: node validate-review.mjs <return|artifact> [...]'
-function runCeReviewValidator(options) {
-  const outputSink = options.outputSink ?? ((message) => console.log(message))
-  const errorSink = options.errorSink ?? ((message) => console.error(message))
-  const subcommand = options.argv[0]
-  if (subcommand === 'return') {
-    return runReviewReturnValidator({
-      argv: ['systematic', 'validate-review-return', ...options.argv.slice(1)],
-      isTTY: options.isTTY,
-      readChunk: options.readChunk,
-      outputSink,
-      errorSink,
-    })
+// src/lib/review-pipeline.ts
+function normalizeRepoRelativePath(filePath) {
+  return path2.posix.normalize(filePath.replaceAll('\\', '/'))
+}
+var JSON_ROOT_PATH = '$'
+var RECOGNIZED_SEVERITIES = ['P0', 'P1', 'P2', 'P3']
+function classifyRejectedSeverity(value) {
+  return typeof value === 'string' && RECOGNIZED_SEVERITIES.includes(value)
+    ? value
+    : 'unknown'
+}
+function extractRejectedSeverities(rawValue) {
+  if (typeof rawValue !== 'object' || rawValue === null) return
+  const findings = rawValue.findings
+  if (!Array.isArray(findings)) return
+  if (findings.length > MAX_FINDINGS) return
+  return findings.map((finding) =>
+    typeof finding === 'object' && finding !== null
+      ? classifyRejectedSeverity(finding.severity)
+      : 'unknown',
+  )
+}
+function formatDiagnostic(persona, fieldPath, reason) {
+  const jsonPath =
+    typeof fieldPath === 'string'
+      ? fieldPath
+      : formatReviewArtifactIssuePath(fieldPath)
+  return `Rejected persona ${persona} return: field ${jsonPath} failed ${reason}.`
+}
+function truncateReason(reason) {
+  if (reason.length <= MAX_REASON_LENGTH) return reason
+  return reason.slice(0, MAX_REASON_LENGTH)
+}
+function parseRawReturn(rawReturn) {
+  if (typeof rawReturn !== 'string') return { ok: true, value: rawReturn }
+  try {
+    return { ok: true, value: JSON.parse(rawReturn) }
+  } catch {
+    return { ok: false }
+  }
+}
+function wholePayloadRejection(
+  persona,
+  fieldPath,
+  reason,
+  rejectedSeverities,
+  harness,
+) {
+  const rejectedFindingCount = rejectedSeverities?.length ?? 0
+  return ScreenOutputSchema.parse({
+    admitted_findings: [],
+    dispatch_outcome: 'malformed',
+    ...(rejectedFindingCount > 0
+      ? {
+          rejected_summary: {
+            dispatch_outcome: 'malformed',
+            reason: truncateReason(
+              formatDiagnostic(persona, fieldPath, reason),
+            ),
+            rejected_finding_count: rejectedFindingCount,
+            rejected_severities: rejectedSeverities,
+          },
+        }
+      : {}),
+    residual_risks: [],
+    testing_gaps: [],
+    harness,
+  })
+}
+function screenReviewReturn(input) {
+  const persona = input.expected_reviewer
+  const harness = input.invoking_harness
+  const parsed = parseRawReturn(input.raw_return)
+  if (!parsed.ok) {
+    return wholePayloadRejection(
+      persona,
+      JSON_ROOT_PATH,
+      'malformed JSON',
+      undefined,
+      harness,
+    )
   }
-  if (subcommand === 'artifact') {
-    return runClaudeCodeValidator({
-      argv: options.argv.slice(1),
-      cwd: options.cwd,
-      outputSink,
-      errorSink,
-    })
+  const validation = validateReviewReturnValue(parsed.value)
+  if (!validation.ok) {
+    const fieldPath = validation.issues[0]?.path ?? JSON_ROOT_PATH
+    return wholePayloadRejection(
+      persona,
+      fieldPath,
+      'schema validation',
+      extractRejectedSeverities(parsed.value),
+      harness,
+    )
+  }
+  const raw = SubAgentReturnSchema.parse(parsed.value)
+  if (raw.reviewer !== persona) {
+    return wholePayloadRejection(
+      persona,
+      'reviewer',
+      'schema validation',
+      raw.findings.map((finding) => finding.severity),
+      harness,
+    )
   }
-  errorSink(CE_REVIEW_VALIDATOR_USAGE)
-  return 2
+  const admittedFindings = raw.findings.map((finding, originalIndex) => ({
+    ...finding,
+    disposition: 'surviving',
+    input_id: `${persona}#${originalIndex}`,
+  }))
+  const dispatchOutcome = raw.findings.length === 0 ? 'empty' : 'findings'
+  return ScreenOutputSchema.parse({
+    admitted_findings: admittedFindings,
+    dispatch_outcome: dispatchOutcome,
+    residual_risks: raw.residual_risks,
+    testing_gaps: raw.testing_gaps,
+    harness,
+  })
 }
-function resolveRealPath(candidate) {
-  if (candidate === undefined) return
+var STANDARD_CONFIDENCE_FLOOR = 0.6
+var P0_CONFIDENCE_FLOOR = 0.5
+var CONFIDENCE_GATE_SUPPRESSED_REASON = 'confidence below gate threshold'
+function rejectPrepare(path, reason) {
+  return { ok: false, rejection: { path, reason } }
+}
+function compareStrings(a, b) {
+  if (a < b) return -1
+  if (a > b) return 1
+  return 0
+}
+function payloadByteLength(rawInput) {
+  if (typeof rawInput === 'string') return Buffer.byteLength(rawInput, 'utf8')
   try {
-    return fs3.realpathSync(candidate)
+    return Buffer.byteLength(JSON.stringify(rawInput), 'utf8')
   } catch {
     return
   }
 }
-var entryPath = resolveRealPath(process.argv[1])
-var modulePath = resolveRealPath(fileURLToPath(import.meta.url))
-var isMainModule =
-  entryPath !== undefined &&
-  modulePath !== undefined &&
-  entryPath === modulePath
-if (isMainModule) {
-  process.exitCode = runCeReviewValidator({ argv: process.argv.slice(2) })
+function survivesConfidenceGate(finding) {
+  if (finding.confidence >= STANDARD_CONFIDENCE_FLOOR) return true
+  return finding.severity === 'P0' && finding.confidence >= P0_CONFIDENCE_FLOOR
+}
+function validatePrepareStructure(screenResults, selectedDispatches) {
+  const seenPersonas = new Set()
+  for (const [index, entry] of screenResults.entries()) {
+    if (seenPersonas.has(entry.reviewer)) {
+      return {
+        path: formatReviewArtifactIssuePath([
+          'screen_results',
+          index,
+          'reviewer',
+        ]),
+        reason: 'duplicate persona outcome',
+      }
+    }
+    seenPersonas.add(entry.reviewer)
+  }
+  const seenInputIds = new Set()
+  for (const [screenIndex, entry] of screenResults.entries()) {
+    for (const [
+      findingIndex,
+      finding,
+    ] of entry.result.admitted_findings.entries()) {
+      if (seenInputIds.has(finding.input_id)) {
+        return {
+          path: formatReviewArtifactIssuePath([
+            'screen_results',
+            screenIndex,
+            'result',
+            'admitted_findings',
+            findingIndex,
+            'input_id',
+          ]),
+          reason: 'duplicate input id',
+        }
+      }
+      seenInputIds.add(finding.input_id)
+    }
+  }
+  const selectedPersonas = new Set(
+    selectedDispatches.map((dispatch) => dispatch.persona),
+  )
+  for (const [index, entry] of screenResults.entries()) {
+    if (!selectedPersonas.has(entry.reviewer)) {
+      return {
+        path: formatReviewArtifactIssuePath([
+          'screen_results',
+          index,
+          'reviewer',
+        ]),
+        reason: 'unselected persona screen result',
+      }
+    }
+  }
+  const screenedPersonas = new Set(screenResults.map((entry) => entry.reviewer))
+  for (const [index, dispatch] of selectedDispatches.entries()) {
+    if (!screenedPersonas.has(dispatch.persona)) {
+      return {
+        path: formatReviewArtifactIssuePath([
+          'selected_dispatches',
+          index,
+          'persona',
+        ]),
+        reason: 'missing screen result for selected dispatch',
+      }
+    }
+  }
+  return
+}
+function applyConfidenceGate(screenResults) {
+  const confidenceDispositions = []
+  const survivors = []
+  const survivingFindings = []
+  for (const entry of screenResults) {
+    for (const finding of entry.result.admitted_findings) {
+      if (survivesConfidenceGate(finding)) {
+        confidenceDispositions.push({
+          input_id: finding.input_id,
+          disposition: 'surviving',
+          confidence: finding.confidence,
+        })
+        survivors.push({
+          inputId: finding.input_id,
+          persona: entry.reviewer,
+          normalizedFile: normalizeRepoRelativePath(finding.file),
+          line: finding.line,
+        })
+        survivingFindings.push({
+          ...finding,
+          reviewer: entry.reviewer,
+        })
+      } else {
+        confidenceDispositions.push({
+          input_id: finding.input_id,
+          disposition: 'suppressed',
+          confidence: finding.confidence,
+          reason: CONFIDENCE_GATE_SUPPRESSED_REASON,
+        })
+      }
+    }
+  }
+  confidenceDispositions.sort((a, b) => compareStrings(a.input_id, b.input_id))
+  survivingFindings.sort((a, b) => compareStrings(a.input_id, b.input_id))
+  return { confidenceDispositions, survivors, survivingFindings }
+}
+function computeCoverageUnion(selectedDispatches) {
+  const coverageSet = new Set()
+  for (const dispatch of selectedDispatches) {
+    for (const surface of dispatch.selection_surface ?? []) {
+      coverageSet.add(surface)
+    }
+  }
+  return [...coverageSet].sort(compareStrings)
+}
+function groupCandidates(survivors) {
+  const groupsByFile = new Map()
+  for (const survivor of survivors) {
+    const bucket = groupsByFile.get(survivor.normalizedFile)
+    if (bucket) {
+      bucket.push(survivor)
+    } else {
+      groupsByFile.set(survivor.normalizedFile, [survivor])
+    }
+  }
+  const candidateGroups = []
+  const singletonIds = []
+  for (const [file, members] of groupsByFile) {
+    const distinctPersonas = new Set(members.map((member) => member.persona))
+    if (distinctPersonas.size >= 2) {
+      const sortedMembers = [...members].sort((a, b) => {
+        if (a.line !== b.line) return a.line - b.line
+        return compareStrings(a.inputId, b.inputId)
+      })
+      candidateGroups.push({
+        file,
+        members: sortedMembers.map((member) => ({
+          input_id: member.inputId,
+          line: member.line,
+        })),
+      })
+    } else {
+      for (const member of members) {
+        singletonIds.push(member.inputId)
+      }
+    }
+  }
+  candidateGroups.sort((a, b) => compareStrings(a.file, b.file))
+  singletonIds.sort(compareStrings)
+  return { candidateGroups, singletonIds }
+}
+function prepareReviewCandidates(input) {
+  const byteLength = payloadByteLength(input.raw_input)
+  if (byteLength !== undefined && byteLength > AGGREGATE_STDIN_BYTE_CAP) {
+    return rejectPrepare(JSON_ROOT_PATH, 'aggregate payload exceeds byte cap')
+  }
+  const parsed = parseRawReturn(input.raw_input)
+  if (!parsed.ok) {
+    return rejectPrepare(JSON_ROOT_PATH, 'malformed JSON')
+  }
+  const validation = PrepareInputSchema.safeParse(parsed.value)
+  if (!validation.success) {
+    const issue = validation.error.issues[0]
+    const issuePath = issue
+      ? formatReviewArtifactIssuePath(issue.path)
+      : JSON_ROOT_PATH
+    return rejectPrepare(issuePath, 'schema validation')
+  }
+  const {
+    screen_results: screenResults,
+    selected_dispatches: selectedDispatches,
+  } = validation.data
+  const structuralViolation = validatePrepareStructure(
+    screenResults,
+    selectedDispatches,
+  )
+  if (structuralViolation) {
+    return rejectPrepare(structuralViolation.path, structuralViolation.reason)
+  }
+  const { confidenceDispositions, survivors, survivingFindings } =
+    applyConfidenceGate(screenResults)
+  const coverageUnion = computeCoverageUnion(selectedDispatches)
+  const { candidateGroups, singletonIds } = groupCandidates(survivors)
+  const output = PrepareOutputSchema.parse({
+    candidate_groups: candidateGroups,
+    confidence_dispositions: confidenceDispositions,
+    coverage_union: coverageUnion,
+    singletons: singletonIds,
+    surviving_findings: survivingFindings,
+  })
+  return { ok: true, value: output }
+}
+function rejectAdjudication(path, reason) {
+  return { ok: false, rejection: { path, reason } }
+}
+function citedInputIds(decision) {
+  return decision.disposition === 'merged'
+    ? decision.input_finding_ids
+    : [decision.input_finding_id]
+}
+function citationPath(decision, decisionIndex, citedIndex) {
+  return decision.disposition === 'merged'
+    ? formatReviewArtifactIssuePath([
+        'decisions',
+        decisionIndex,
+        'input_finding_ids',
+        citedIndex,
+      ])
+    : formatReviewArtifactIssuePath([
+        'decisions',
+        decisionIndex,
+        'input_finding_id',
+      ])
+}
+function buildCandidateIndex(candidateGroups) {
+  const groupIndexByInputId = new Map()
+  candidateGroups.forEach((group, groupIndex) => {
+    for (const member of group.members) {
+      groupIndexByInputId.set(member.input_id, groupIndex)
+    }
+  })
+  return { groupIndexByInputId }
+}
+function buildSuppressedSet(confidenceDispositions) {
+  const suppressed = new Set()
+  for (const disposition of confidenceDispositions) {
+    if (disposition.disposition === 'suppressed') {
+      suppressed.add(disposition.input_id)
+    }
+  }
+  return suppressed
+}
+function validateCitations(decisions, index, suppressed) {
+  const seen = new Set()
+  for (const [decisionIndex, decision] of decisions.entries()) {
+    for (const [citedIndex, inputId] of citedInputIds(decision).entries()) {
+      const path = citationPath(decision, decisionIndex, citedIndex)
+      if (suppressed.has(inputId)) {
+        return { path, reason: 'suppressed input id' }
+      }
+      if (!index.groupIndexByInputId.has(inputId)) {
+        return { path, reason: 'unknown input id' }
+      }
+      if (seen.has(inputId)) {
+        return { path, reason: 'duplicate input id citation' }
+      }
+      seen.add(inputId)
+    }
+  }
+  return
+}
+function validateNoOmissions(candidateGroups, citedIds) {
+  for (const [groupIndex, group] of candidateGroups.entries()) {
+    for (const [memberIndex, member] of group.members.entries()) {
+      if (!citedIds.has(member.input_id)) {
+        return {
+          path: formatReviewArtifactIssuePath([
+            'candidate_groups',
+            groupIndex,
+            'members',
+            memberIndex,
+            'input_id',
+          ]),
+          reason: 'omitted eligible input id',
+        }
+      }
+    }
+  }
+  return
+}
+function collectCitedIds(decisions) {
+  const cited = new Set()
+  for (const decision of decisions) {
+    for (const inputId of citedInputIds(decision)) cited.add(inputId)
+  }
+  return cited
+}
+function validateMergedDecisionConsistency(
+  decision,
+  decisionIndex,
+  index,
+  candidateGroups,
+) {
+  const ids = decision.input_finding_ids
+  const firstId = ids[0]
+  if (firstId === undefined) return
+  const expectedGroupIndex = index.groupIndexByInputId.get(firstId)
+  if (expectedGroupIndex === undefined) return
+  for (const [citedIndex, inputId] of ids.entries()) {
+    const groupIndex = index.groupIndexByInputId.get(inputId)
+    if (groupIndex !== expectedGroupIndex) {
+      return {
+        path: formatReviewArtifactIssuePath([
+          'decisions',
+          decisionIndex,
+          'input_finding_ids',
+          citedIndex,
+        ]),
+        reason: 'cross-group input id citation',
+      }
+    }
+  }
+  const group = candidateGroups[expectedGroupIndex]
+  if (group && !group.members.some((member) => member.line === decision.line)) {
+    return {
+      path: formatReviewArtifactIssuePath(['decisions', decisionIndex, 'line']),
+      reason: 'representative line mismatch',
+    }
+  }
+  return
+}
+function validateMergedDecisions(decisions, index, candidateGroups) {
+  for (const [decisionIndex, decision] of decisions.entries()) {
+    if (decision.disposition !== 'merged') continue
+    const violation = validateMergedDecisionConsistency(
+      decision,
+      decisionIndex,
+      index,
+      candidateGroups,
+    )
+    if (violation) return violation
+  }
+  return
+}
+function resolveDecisionFile(decision, index, candidateGroups) {
+  const firstId = citedInputIds(decision)[0]
+  if (firstId === undefined) return
+  const groupIndex = index.groupIndexByInputId.get(firstId)
+  if (groupIndex === undefined) return
+  return candidateGroups[groupIndex]?.file
+}
+function buildValidatedPartition(
+  decisions,
+  index,
+  candidateGroups,
+  singletons,
+) {
+  const merged = []
+  const declined = []
+  for (const decision of decisions) {
+    const file = resolveDecisionFile(decision, index, candidateGroups) ?? ''
+    if (decision.disposition === 'merged') {
+      merged.push({ decision, file })
+    } else {
+      declined.push({ decision, file })
+    }
+  }
+  merged.sort((a, b) =>
+    compareStrings(a.decision.decision_id, b.decision.decision_id),
+  )
+  declined.sort((a, b) =>
+    compareStrings(a.decision.decision_id, b.decision.decision_id),
+  )
+  return {
+    merged,
+    declined,
+    singletons: [...singletons].sort(compareStrings),
+  }
+}
+function validateAdjudication(prepared, decisions) {
+  if (prepared.candidate_groups.length === 0) {
+    if (decisions.length > 0) {
+      return rejectAdjudication(
+        formatReviewArtifactIssuePath(['decisions']),
+        'unexpected decisions for empty candidate set',
+      )
+    }
+    return {
+      ok: true,
+      value: buildValidatedPartition(
+        decisions,
+        buildCandidateIndex([]),
+        [],
+        prepared.singletons,
+      ),
+    }
+  }
+  const index = buildCandidateIndex(prepared.candidate_groups)
+  const suppressed = buildSuppressedSet(prepared.confidence_dispositions)
+  const citationViolation = validateCitations(decisions, index, suppressed)
+  if (citationViolation) {
+    return { ok: false, rejection: citationViolation }
+  }
+  const citedIds = collectCitedIds(decisions)
+  const omissionViolation = validateNoOmissions(
+    prepared.candidate_groups,
+    citedIds,
+  )
+  if (omissionViolation) {
+    return { ok: false, rejection: omissionViolation }
+  }
+  const mergedViolation = validateMergedDecisions(
+    decisions,
+    index,
+    prepared.candidate_groups,
+  )
+  if (mergedViolation) {
+    return { ok: false, rejection: mergedViolation }
+  }
+  return {
+    ok: true,
+    value: buildValidatedPartition(
+      decisions,
+      index,
+      prepared.candidate_groups,
+      prepared.singletons,
+    ),
+  }
+}
+function rejectMergedFinding(path, reason) {
+  return { ok: false, rejection: { path, reason } }
+}
+var SEVERITY_RANK = {
+  P0: 0,
+  P1: 1,
+  P2: 2,
+  P3: 3,
+}
+function deriveSeverity(contributing) {
+  return contributing.reduce(
+    (highest, finding) =>
+      SEVERITY_RANK[finding.severity] < SEVERITY_RANK[highest]
+        ? finding.severity
+        : highest,
+    contributing[0].severity,
+  )
+}
+function deriveSubmitters(contributing) {
+  return [...new Set(contributing.map((finding) => finding.reviewer))].sort(
+    compareStrings,
+  )
+}
+function deriveAgreementCredit(claimed, submitters, returnedReviewers) {
+  if (!claimed || claimed.length === 0) return { ok: true, value: [] }
+  const credited = new Set()
+  for (const [index, reviewer] of claimed.entries()) {
+    const path = formatReviewArtifactIssuePath([
+      'eligible_agreement_credit',
+      index,
+    ])
+    if (credited.has(reviewer)) {
+      return rejectMergedFinding(path, 'duplicate agreement credit reviewer')
+    }
+    if (submitters.has(reviewer)) {
+      return rejectMergedFinding(
+        path,
+        'agreement credit reviewer already a submitter',
+      )
+    }
+    if (!returnedReviewers.has(reviewer)) {
+      return rejectMergedFinding(
+        path,
+        'agreement credit reviewer did not return',
+      )
+    }
+    credited.add(reviewer)
+  }
+  return { ok: true, value: [...credited].sort(compareStrings) }
+}
+var CONFIDENCE_AGREEMENT_BOOST = 0.1
+var MAX_CONFIDENCE = 1
+function deriveConfidence(contributing, distinctReviewerCount) {
+  const highest = contributing.reduce(
+    (max, finding) => Math.max(max, finding.confidence),
+    contributing[0].confidence,
+  )
+  if (distinctReviewerCount < 2) return highest
+  const boosted = Math.round((highest + CONFIDENCE_AGREEMENT_BOOST) * 100) / 100
+  return Math.min(MAX_CONFIDENCE, boosted)
+}
+function derivePreExisting(contributing) {
+  return contributing.every((finding) => finding.pre_existing)
+}
+function deriveFingerprint(normalizedFile, representativeLine, severity) {
+  return `${normalizedFile}:${representativeLine}:${severity}`
+}
+function meetOverNarrowsTo(narrowsTo, values) {
+  const domain = Object.keys(narrowsTo)
+  const validCandidates = domain.filter((candidate) =>
+    values.every((value) => narrowsTo[value].includes(candidate)),
+  )
+  return validCandidates.find((candidate) =>
+    validCandidates.every((other) => narrowsTo[candidate].includes(other)),
+  )
+}
+function deriveRouteMeet(contributing) {
+  const autofixClasses = contributing.map((finding) => finding.autofix_class)
+  const owners = contributing.map((finding) => finding.owner)
+  const verifications = contributing.map((finding) =>
+    finding.requires_verification ? 'true' : 'false',
+  )
+  return {
+    autofix_class:
+      meetOverNarrowsTo(ROUTE_REFUSAL_TABLE.autofix_class, autofixClasses) ??
+      'advisory',
+    owner: meetOverNarrowsTo(ROUTE_REFUSAL_TABLE.owner, owners) ?? 'release',
+    requires_verification:
+      (meetOverNarrowsTo(
+        ROUTE_REFUSAL_TABLE.requires_verification,
+        verifications,
+      ) ?? 'true') === 'true',
+  }
+}
+function deriveRoute(contributing, decision) {
+  const meet = deriveRouteMeet(contributing)
+  if (!decision.proposed_route) return { ok: true, value: meet }
+  if (!decision.route_narrowing_reason) {
+    return rejectMergedFinding(
+      formatReviewArtifactIssuePath(['route_narrowing_reason']),
+      'route narrowing missing reason',
+    )
+  }
+  if (!isRouteTransitionAllowed(meet, decision.proposed_route)) {
+    return rejectMergedFinding(
+      formatReviewArtifactIssuePath(['proposed_route']),
+      'route widening',
+    )
+  }
+  return { ok: true, value: decision.proposed_route }
+}
+function deriveMergedFindingFields(input) {
+  const submitters = deriveSubmitters(input.contributing)
+  const submitterSet = new Set(submitters)
+  const returnedReviewerSet = new Set(input.returned_reviewers)
+  const agreementCreditResult = deriveAgreementCredit(
+    input.decision.eligible_agreement_credit,
+    submitterSet,
+    returnedReviewerSet,
+  )
+  if (!agreementCreditResult.ok) return agreementCreditResult
+  const routeResult = deriveRoute(input.contributing, input.decision)
+  if (!routeResult.ok) return routeResult
+  const severity = deriveSeverity(input.contributing)
+  const distinctReviewerCount =
+    submitters.length + agreementCreditResult.value.length
+  const confidence = deriveConfidence(input.contributing, distinctReviewerCount)
+  const preExisting = derivePreExisting(input.contributing)
+  const normalizedFile = normalizeRepoRelativePath(input.contributing[0].file)
+  const fingerprint = deriveFingerprint(
+    normalizedFile,
+    input.decision.line,
+    severity,
+  )
+  return {
+    ok: true,
+    value: {
+      severity,
+      submitters,
+      confidence,
+      agreement_credit: agreementCreditResult.value,
+      pre_existing: preExisting,
+      fingerprint,
+      route: routeResult.value,
+    },
+  }
+}
+function reviewerFromInputId(inputId) {
+  const separatorIndex = inputId.indexOf('#')
+  return separatorIndex === -1 ? inputId : inputId.slice(0, separatorIndex)
+}
+function deriveReturnedReviewers(prepared) {
+  const reviewers = new Set()
+  for (const finding of prepared.surviving_findings) {
+    reviewers.add(finding.reviewer)
+  }
+  for (const disposition of prepared.confidence_dispositions) {
+    if (disposition.disposition === 'suppressed') {
+      reviewers.add(reviewerFromInputId(disposition.input_id))
+    }
+  }
+  return [...reviewers]
+}
+function buildSurvivingFindingIndex(prepared) {
+  return new Map(
+    prepared.surviving_findings.map((finding) => [finding.input_id, finding]),
+  )
+}
+function requireSurvivingFinding(index, inputId) {
+  const finding = index.get(inputId)
+  if (!finding) {
+    throw new Error(
+      `applyReviewAdjudication: no surviving finding for input ID ${inputId}`,
+    )
+  }
+  return finding
+}
+function toContributingTuple(findings) {
+  const [first, second, ...rest] = findings
+  if (!first || !second) {
+    throw new Error(
+      'applyReviewAdjudication: contributing findings require at least two entries',
+    )
+  }
+  return [first, second, ...rest]
+}
+function assemblyFromDerivation(base, derived) {
+  return {
+    ...base,
+    agreement_credit:
+      derived.agreement_credit.length > 0
+        ? derived.agreement_credit
+        : undefined,
+    severity: derived.severity,
+    confidence: derived.confidence,
+    pre_existing: derived.pre_existing,
+    fingerprint: derived.fingerprint,
+    submitters: derived.submitters,
+    autofix_class: derived.route.autofix_class,
+    owner: derived.route.owner,
+    requires_verification: derived.route.requires_verification,
+  }
+}
+function assembleMergedGroupFinding(group, survivingIndex, returnedReviewers) {
+  const decision = group.decision
+  const sortedInputIds = [...decision.input_finding_ids].sort(compareStrings)
+  const contributing = toContributingTuple(
+    sortedInputIds.map((inputId) =>
+      requireSurvivingFinding(survivingIndex, inputId),
+    ),
+  )
+  const derived = deriveMergedFindingFields({
+    contributing,
+    decision: {
+      line: decision.line,
+      eligible_agreement_credit: decision.eligible_agreement_credit,
+      proposed_route: decision.proposed_route,
+      route_narrowing_reason: decision.route_narrowing_reason,
+    },
+    returned_reviewers: returnedReviewers,
+  })
+  if (!derived.ok) return derived
+  return {
+    ok: true,
+    value: assemblyFromDerivation(
+      {
+        finding_id: decision.decision_id,
+        file: group.file,
+        title: decision.title,
+        why_it_matters: decision.why_it_matters,
+        line: decision.line,
+        evidence: decision.evidence,
+        suggested_fix: decision.suggested_fix,
+        input_finding_ids: sortedInputIds,
+      },
+      derived.value,
+    ),
+  }
+}
+function assembleSingletonFinding(
+  findingId,
+  finding,
+  decisionFields,
+  returnedReviewers,
+) {
+  const contributing = [finding, finding]
+  const derived = deriveMergedFindingFields({
+    contributing,
+    decision: {
+      line: finding.line,
+      proposed_route: decisionFields.proposed_route,
+      route_narrowing_reason: decisionFields.route_narrowing_reason,
+    },
+    returned_reviewers: returnedReviewers,
+  })
+  if (!derived.ok) return derived
+  return {
+    ok: true,
+    value: assemblyFromDerivation(
+      {
+        finding_id: findingId,
+        file: normalizeRepoRelativePath(finding.file),
+        title: finding.title,
+        why_it_matters: finding.why_it_matters,
+        line: finding.line,
+        evidence: finding.evidence,
+        suggested_fix: finding.suggested_fix,
+        input_finding_ids: [finding.input_id],
+      },
+      derived.value,
+    ),
+  }
+}
+function compareMergedFindingAssembly(a, b) {
+  const severityDelta = SEVERITY_RANK[a.severity] - SEVERITY_RANK[b.severity]
+  if (severityDelta !== 0) return severityDelta
+  if (a.confidence !== b.confidence) return b.confidence - a.confidence
+  const pathDelta = compareStrings(a.file, b.file)
+  if (pathDelta !== 0) return pathDelta
+  if (a.line !== b.line) return a.line - b.line
+  const fingerprintDelta = compareStrings(a.fingerprint, b.fingerprint)
+  if (fingerprintDelta !== 0) return fingerprintDelta
+  return compareStrings(a.finding_id, b.finding_id)
+}
+function requiresValidatorRequest(assembly) {
+  return (
+    assembly.severity === 'P0' ||
+    assembly.severity === 'P1' ||
+    assembly.requires_verification
+  )
+}
+function toMergedFindingWireShape(assembly) {
+  return {
+    finding_id: assembly.finding_id,
+    file: assembly.file,
+    title: assembly.title,
+    why_it_matters: assembly.why_it_matters,
+    line: assembly.line,
+    autofix_class: assembly.autofix_class,
+    owner: assembly.owner,
+    requires_verification: assembly.requires_verification,
+    evidence: assembly.evidence,
+    suggested_fix: assembly.suggested_fix,
+    input_finding_ids: [...assembly.input_finding_ids],
+    severity: assembly.severity,
+    confidence: assembly.confidence,
+    pre_existing: assembly.pre_existing,
+    fingerprint: assembly.fingerprint,
+    submitters: [...assembly.submitters],
+    ...(assembly.agreement_credit
+      ? { agreement_credit: [...assembly.agreement_credit] }
+      : {}),
+  }
+}
+function mergeFindingIdCollisionReason(first, second) {
+  if (first === second) {
+    if (first === 'merged group') return 'duplicate merged group decision id'
+    if (first === 'declined decision') return 'duplicate declined decision id'
+    return 'duplicate passthrough singleton input id'
+  }
+  const pair = [first, second].sort(compareStrings).join('|')
+  if (pair === 'declined decision|merged group') {
+    return 'declined decision id collides with merged group decision id'
+  }
+  if (pair === 'declined decision|passthrough singleton') {
+    return 'declined decision id collides with passthrough singleton input id'
+  }
+  return 'passthrough singleton input id collides with merged group decision id'
+}
+function checkNoDuplicateAssembledFindingIds(origins) {
+  const seen = new Map()
+  for (const [index, entry] of origins.entries()) {
+    const priorOrigin = seen.get(entry.finding_id)
+    if (priorOrigin !== undefined) {
+      return {
+        path: formatReviewArtifactIssuePath([
+          'merge_assembly',
+          index,
+          'finding_id',
+        ]),
+        reason: mergeFindingIdCollisionReason(priorOrigin, entry.origin),
+      }
+    }
+    seen.set(entry.finding_id, entry.origin)
+  }
+  return
+}
+function applyReviewAdjudication(input) {
+  const validated = validateAdjudication(input.prepared, input.decisions)
+  if (!validated.ok) return validated
+  const survivingIndex = buildSurvivingFindingIndex(input.prepared)
+  const returnedReviewers = deriveReturnedReviewers(input.prepared)
+  const assemblies = []
+  const assemblyOrigins = []
+  const disagreementFacts = []
+  for (const group of validated.value.merged) {
+    const result = assembleMergedGroupFinding(
+      group,
+      survivingIndex,
+      returnedReviewers,
+    )
+    if (!result.ok) return result
+    assemblies.push(result.value)
+    assemblyOrigins.push({
+      finding_id: result.value.finding_id,
+      origin: 'merged group',
+    })
+    if (group.decision.disagreement_facts) {
+      disagreementFacts.push(...group.decision.disagreement_facts)
+    }
+  }
+  for (const singleton of validated.value.declined) {
+    const finding = requireSurvivingFinding(
+      survivingIndex,
+      singleton.decision.input_finding_id,
+    )
+    const result = assembleSingletonFinding(
+      singleton.decision.decision_id,
+      finding,
+      {
+        proposed_route: singleton.decision.proposed_route,
+        route_narrowing_reason: singleton.decision.route_narrowing_reason,
+      },
+      returnedReviewers,
+    )
+    if (!result.ok) return result
+    assemblies.push(result.value)
+    assemblyOrigins.push({
+      finding_id: result.value.finding_id,
+      origin: 'declined decision',
+    })
+    disagreementFacts.push(singleton.decision.declined_reason)
+    if (singleton.decision.disagreement_facts) {
+      disagreementFacts.push(...singleton.decision.disagreement_facts)
+    }
+  }
+  for (const inputId of validated.value.singletons) {
+    const finding = requireSurvivingFinding(survivingIndex, inputId)
+    const result = assembleSingletonFinding(
+      inputId,
+      finding,
+      {},
+      returnedReviewers,
+    )
+    if (!result.ok) return result
+    assemblies.push(result.value)
+    assemblyOrigins.push({
+      finding_id: result.value.finding_id,
+      origin: 'passthrough singleton',
+    })
+  }
+  const collision = checkNoDuplicateAssembledFindingIds(assemblyOrigins)
+  if (collision) return { ok: false, rejection: collision }
+  assemblies.sort(compareMergedFindingAssembly)
+  disagreementFacts.sort(compareStrings)
+  const mergedFindings = assemblies.map(toMergedFindingWireShape)
+  const validatorRequests = assemblies
+    .filter(requiresValidatorRequest)
+    .map((assembly) => ({
+      finding_id: assembly.finding_id,
+      file: assembly.file,
+      line: assembly.line,
+    }))
+  return {
+    ok: true,
+    value: MergeOutputSchema.parse({
+      merged_findings: mergedFindings,
+      validator_requests: validatorRequests,
+      disagreement_facts: disagreementFacts,
+    }),
+  }
+}
+function rejectReconcile(path, reason) {
+  return { ok: false, rejection: { path, reason } }
+}
+function indexLifecycleResults(results, requestedIds) {
+  const resultsByFindingId = new Map()
+  for (const [index, record] of results.entries()) {
+    const path = formatReviewArtifactIssuePath([
+      'validator_lifecycle_results',
+      index,
+      'finding_id',
+    ])
+    if (resultsByFindingId.has(record.finding_id)) {
+      return rejectReconcile(path, 'duplicate validator result')
+    }
+    if (!requestedIds.has(record.finding_id)) {
+      return rejectReconcile(path, 'unrequested validator result')
+    }
+    resultsByFindingId.set(record.finding_id, record.result)
+  }
+  return { ok: true, value: resultsByFindingId }
+}
+function validateNoMissingResults(validatorRequests, resultsByFindingId) {
+  for (const [index, request] of validatorRequests.entries()) {
+    if (!resultsByFindingId.has(request.finding_id)) {
+      return {
+        path: formatReviewArtifactIssuePath([
+          'validator_requests',
+          index,
+          'finding_id',
+        ]),
+        reason: 'missing validator result',
+      }
+    }
+  }
+  return
+}
+function classifyFinding(finding, result) {
+  if (!result) return { finding: { ...finding }, filtered: false }
+  if (result.outcome === 'true') {
+    return { finding: { ...finding, validated: true }, filtered: false }
+  }
+  if (result.outcome === 'false') {
+    return {
+      finding: {
+        ...finding,
+        validated: false,
+        validation_reason: result.reason,
+      },
+      filtered: true,
+    }
+  }
+  return {
+    finding: { ...finding },
+    filtered: false,
+    failure: {
+      finding_id: finding.finding_id,
+      outcome: result.outcome,
+      reason: result.reason,
+    },
+  }
+}
+function reconcileValidatorResults(input) {
+  const requestedIds = new Set(
+    input.merge.validator_requests.map((request) => request.finding_id),
+  )
+  const indexed = indexLifecycleResults(
+    input.validator_lifecycle_results,
+    requestedIds,
+  )
+  if (!indexed.ok) return indexed
+  const missingViolation = validateNoMissingResults(
+    input.merge.validator_requests,
+    indexed.value,
+  )
+  if (missingViolation) return { ok: false, rejection: missingViolation }
+  const findings = []
+  const filteredFindingIds = new Set()
+  const filteredInputIds = new Set()
+  const lifecycleFailures = []
+  for (const finding of input.merge.merged_findings) {
+    const classified = classifyFinding(
+      finding,
+      indexed.value.get(finding.finding_id),
+    )
+    findings.push(classified.finding)
+    if (classified.filtered) {
+      filteredFindingIds.add(finding.finding_id)
+      for (const inputId of finding.input_finding_ids) {
+        filteredInputIds.add(inputId)
+      }
+    }
+    if (classified.failure) lifecycleFailures.push(classified.failure)
+  }
+  lifecycleFailures.sort((a, b) => compareStrings(a.finding_id, b.finding_id))
+  return {
+    ok: true,
+    value: {
+      findings,
+      filtered_finding_ids: [...filteredFindingIds].sort(compareStrings),
+      filtered_input_ids: [...filteredInputIds].sort(compareStrings),
+      lifecycle_failures: lifecycleFailures,
+      degraded: lifecycleFailures.length > 0,
+    },
+  }
+}
+function rejectFinalizeContext(path, reason) {
+  return { ok: false, rejection: { path, reason } }
+}
+function normalizeSelectionSurface(surface) {
+  if (surface === undefined) return
+  return [...surface].map(normalizeRepoRelativePath).sort(compareStrings)
+}
+function selectionSurfaceHasDuplicates(surface) {
+  if (surface === undefined) return false
+  const normalized = surface.map(normalizeRepoRelativePath)
+  return new Set(normalized).size !== normalized.length
+}
+function dispatchRecordsEqual(a, b) {
+  return (
+    a.persona === b.persona &&
+    a.dispatch_outcome === b.dispatch_outcome &&
+    JSON.stringify(normalizeSelectionSurface(a.selection_surface) ?? []) ===
+      JSON.stringify(normalizeSelectionSurface(b.selection_surface) ?? []) &&
+    a.selection_reason === b.selection_reason
+  )
+}
+var FINALIZE_CONTEXT_LOSS_DISPATCH_OUTCOMES = new Set([
+  'malformed',
+  'never_returned',
+  'validation_unavailable',
+])
+var FINALIZE_CONTEXT_LOSS_SEVERITIES = new Set(['P0', 'P1', 'unknown'])
+function checkNoDuplicateMergedFindingIds(mergedFindings) {
+  const seenFindingIds = new Set()
+  for (const [index, finding] of mergedFindings.entries()) {
+    if (seenFindingIds.has(finding.finding_id)) {
+      return rejectFinalizeContext(
+        formatReviewArtifactIssuePath([
+          'merge',
+          'merged_findings',
+          index,
+          'finding_id',
+        ]),
+        'duplicate merged finding ID',
+      )
+    }
+    seenFindingIds.add(finding.finding_id)
+  }
+  return { ok: true, value: seenFindingIds }
+}
+function checkSurvivorPartition(
+  mergedFindings,
+  survivingFindings,
+  survivingIndex,
+) {
+  const coveredInputIds = new Set()
+  const contributingByFindingId = new Map()
+  for (const [findingIndex, finding] of mergedFindings.entries()) {
+    const sortedIds = [...finding.input_finding_ids].sort(compareStrings)
+    const resolved = []
+    for (const [idIndex, inputId] of sortedIds.entries()) {
+      const survivor = survivingIndex.get(inputId)
+      if (!survivor) {
+        return rejectFinalizeContext(
+          formatReviewArtifactIssuePath([
+            'merge',
+            'merged_findings',
+            findingIndex,
+            'input_finding_ids',
+            idIndex,
+          ]),
+          'merged finding references unknown survivor',
+        )
+      }
+      if (coveredInputIds.has(inputId)) {
+        return rejectFinalizeContext(
+          formatReviewArtifactIssuePath([
+            'merge',
+            'merged_findings',
+            findingIndex,
+            'input_finding_ids',
+            idIndex,
+          ]),
+          'survivor claimed by multiple merged findings',
+        )
+      }
+      resolved.push(survivor)
+      coveredInputIds.add(inputId)
+    }
+    contributingByFindingId.set(finding.finding_id, resolved)
+  }
+  for (const [survivorIndex, survivor] of survivingFindings.entries()) {
+    if (!coveredInputIds.has(survivor.input_id)) {
+      return rejectFinalizeContext(
+        formatReviewArtifactIssuePath([
+          'prepared',
+          'surviving_findings',
+          survivorIndex,
+          'input_id',
+        ]),
+        'survivor missing from merge inputs',
+      )
+    }
+  }
+  return { ok: true, value: contributingByFindingId }
+}
+function validatorRequestMismatches(request, findingById, expectedFindingIds) {
+  const finding = findingById.get(request.finding_id)
+  return (
+    !finding ||
+    !expectedFindingIds.has(request.finding_id) ||
+    request.file !== finding.file ||
+    request.line !== finding.line
+  )
+}
+function checkValidatorRequestsResolve(validatorRequests, mergedFindings) {
+  const findingById = new Map(
+    mergedFindings.map((finding) => [finding.finding_id, finding]),
+  )
+  const expectedFindingIds = new Set(
+    mergedFindings
+      .filter((finding) => requiresValidatorRequest(finding))
+      .map((finding) => finding.finding_id),
+  )
+  const seenFindingIds = new Set()
+  for (const [index, request] of validatorRequests.entries()) {
+    const path = formatReviewArtifactIssuePath([
+      'merge',
+      'validator_requests',
+      index,
+      'finding_id',
+    ])
+    if (
+      seenFindingIds.has(request.finding_id) ||
+      validatorRequestMismatches(request, findingById, expectedFindingIds)
+    ) {
+      return {
+        path,
+        reason: 'validator request references unknown merged finding',
+      }
+    }
+    seenFindingIds.add(request.finding_id)
+  }
+  if (seenFindingIds.size !== expectedFindingIds.size) {
+    return {
+      path: formatReviewArtifactIssuePath(['merge', 'validator_requests']),
+      reason: 'validator request references unknown merged finding',
+    }
+  }
+  return
+}
+function checkDispatchRecordsJoin(dispatchRecords, selectedDispatches) {
+  if (dispatchRecords.length !== selectedDispatches.length) {
+    return rejectFinalizeContext(
+      formatReviewArtifactIssuePath(['dispatch_records']),
+      'dispatch record mismatch',
+    )
+  }
+  const selectedByPersona = new Map(
+    selectedDispatches.map((dispatch) => [dispatch.persona, dispatch]),
+  )
+  if (selectedByPersona.size !== selectedDispatches.length) {
+    return rejectFinalizeContext(
+      formatReviewArtifactIssuePath([
+        'parent_run_metadata',
+        'selected_dispatches',
+      ]),
+      'dispatch record mismatch',
+    )
+  }
+  const seenPersonas = new Set()
+  for (const [index, record] of dispatchRecords.entries()) {
+    const selected = selectedByPersona.get(record.persona)
+    if (seenPersonas.has(record.persona) || !selected) {
+      return rejectFinalizeContext(
+        formatReviewArtifactIssuePath(['dispatch_records', index]),
+        'dispatch record mismatch',
+      )
+    }
+    if (
+      selectionSurfaceHasDuplicates(record.selection_surface) ||
+      selectionSurfaceHasDuplicates(selected.selection_surface)
+    ) {
+      return rejectFinalizeContext(
+        formatReviewArtifactIssuePath([
+          'dispatch_records',
+          index,
+          'selection_surface',
+        ]),
+        'duplicate selection surface entry',
+      )
+    }
+    if (!dispatchRecordsEqual(record, selected)) {
+      return rejectFinalizeContext(
+        formatReviewArtifactIssuePath(['dispatch_records', index]),
+        'dispatch record mismatch',
+      )
+    }
+    seenPersonas.add(record.persona)
+  }
+  return { ok: true, value: selectedByPersona }
+}
+var SCREEN_RESULT_EXEMPT_DISPATCH_OUTCOMES = new Set([
+  'validation_unavailable',
+  'never_returned',
+])
+function checkScreenResultsJoin(
+  screenResults,
+  dispatchRecords,
+  selectedByPersona,
+) {
+  const screenByReviewer = new Map()
+  for (const [index, result] of screenResults.entries()) {
+    if (
+      screenByReviewer.has(result.reviewer) ||
+      !selectedByPersona.has(result.reviewer)
+    ) {
+      return rejectFinalizeContext(
+        formatReviewArtifactIssuePath(['screen_results', index, 'reviewer']),
+        'unexpected screen result for persona',
+      )
+    }
+    screenByReviewer.set(result.reviewer, result)
+  }
+  for (const [index, record] of dispatchRecords.entries()) {
+    const screenResult = screenByReviewer.get(record.persona)
+    if (!screenResult) {
+      if (SCREEN_RESULT_EXEMPT_DISPATCH_OUTCOMES.has(record.dispatch_outcome)) {
+        continue
+      }
+      return rejectFinalizeContext(
+        formatReviewArtifactIssuePath(['dispatch_records', index, 'persona']),
+        'screen result missing for selected persona',
+      )
+    }
+    if (screenResult.result.dispatch_outcome !== record.dispatch_outcome) {
+      return rejectFinalizeContext(
+        formatReviewArtifactIssuePath([
+          'dispatch_records',
+          index,
+          'dispatch_outcome',
+        ]),
+        'screen result outcome does not match dispatch record',
+      )
+    }
+  }
+  return { ok: true, value: screenByReviewer }
+}
+function mergedFindingFileDiverges(finding, contributingSurvivors) {
+  const normalizedFindingFile = normalizeRepoRelativePath(finding.file)
+  return contributingSurvivors.some(
+    (survivor) =>
+      normalizeRepoRelativePath(survivor.file) !== normalizedFindingFile,
+  )
+}
+function mergedFindingLineDiverges(finding, contributingSurvivors) {
+  return !contributingSurvivors.some(
+    (survivor) => survivor.line === finding.line,
+  )
+}
+function eligibleAgreementCreditClaim(finding) {
+  return finding.input_finding_ids.length >= 2
+    ? finding.agreement_credit
+    : undefined
+}
+function mergedFindingDivergesFromDerivation(
+  finding,
+  contributingByFindingId,
+  returnedReviewers,
+) {
+  const resolved = contributingByFindingId.get(finding.finding_id) ?? []
+  const contributing = toContributingTuple(
+    resolved.length >= 2 ? resolved : [...resolved, ...resolved],
+  )
+  const derivation = deriveMergedFindingFields({
+    contributing,
+    decision: {
+      line: finding.line,
+      eligible_agreement_credit: eligibleAgreementCreditClaim(finding),
+      proposed_route: {
+        autofix_class: finding.autofix_class,
+        owner: finding.owner,
+        requires_verification: finding.requires_verification,
+      },
+      route_narrowing_reason: 'carried route verification',
+    },
+    returned_reviewers: returnedReviewers,
+  })
+  return (
+    mergedFindingFileDiverges(finding, resolved) ||
+    mergedFindingLineDiverges(finding, resolved) ||
+    !derivation.ok ||
+    derivation.value.severity !== finding.severity ||
+    derivation.value.confidence !== finding.confidence ||
+    derivation.value.pre_existing !== finding.pre_existing ||
+    derivation.value.fingerprint !== finding.fingerprint ||
+    JSON.stringify(derivation.value.submitters) !==
+      JSON.stringify(finding.submitters) ||
+    JSON.stringify(derivation.value.agreement_credit) !==
+      JSON.stringify(finding.agreement_credit ?? []) ||
+    derivation.value.route.autofix_class !== finding.autofix_class ||
+    derivation.value.route.owner !== finding.owner ||
+    derivation.value.route.requires_verification !==
+      finding.requires_verification
+  )
+}
+function checkMergedFindingsMatchDerivation(
+  mergedFindings,
+  contributingByFindingId,
+  returnedReviewers,
+) {
+  for (const [index, finding] of mergedFindings.entries()) {
+    if (
+      mergedFindingDivergesFromDerivation(
+        finding,
+        contributingByFindingId,
+        returnedReviewers,
+      )
+    ) {
+      return {
+        path: formatReviewArtifactIssuePath([
+          'merge',
+          'merged_findings',
+          index,
+        ]),
+        reason: 'merged finding fields diverge from derivation',
+      }
+    }
+  }
+  return
+}
+function checkNoDuplicateConfidenceDispositions(confidenceDispositions) {
+  const seen = new Set()
+  for (const [index, entry] of confidenceDispositions.entries()) {
+    if (seen.has(entry.input_id)) {
+      return {
+        path: formatReviewArtifactIssuePath([
+          'prepared',
+          'confidence_dispositions',
+          index,
+          'input_id',
+        ]),
+        reason: 'duplicate confidence disposition',
+      }
+    }
+    seen.add(entry.input_id)
+  }
+  return
+}
+function checkConfidenceDispositionsResolveScreenedFindings(
+  prepared,
+  screenResults,
+) {
+  const screenedCounts = new Map()
+  const screenedByInputId = new Map()
+  for (const result of screenResults) {
+    for (const finding of result.result.admitted_findings) {
+      screenedCounts.set(
+        finding.input_id,
+        (screenedCounts.get(finding.input_id) ?? 0) + 1,
+      )
+      screenedByInputId.set(finding.input_id, {
+        reviewer: result.reviewer,
+        confidence: finding.confidence,
+        file: finding.file,
+        line: finding.line,
+        severity: finding.severity,
+      })
+    }
+  }
+  for (const [
+    index,
+    disposition,
+  ] of prepared.confidence_dispositions.entries()) {
+    if (screenedCounts.get(disposition.input_id) !== 1) {
+      return {
+        path: formatReviewArtifactIssuePath([
+          'prepared',
+          'confidence_dispositions',
+          index,
+          'input_id',
+        ]),
+        reason: 'confidence disposition references unscreened finding',
+      }
+    }
+  }
+  for (const [index, survivor] of prepared.surviving_findings.entries()) {
+    const screened = screenedByInputId.get(survivor.input_id)
+    if (screened === undefined) {
+      return {
+        path: formatReviewArtifactIssuePath([
+          'prepared',
+          'surviving_findings',
+          index,
+          'input_id',
+        ]),
+        reason: 'surviving finding references unscreened input',
+      }
+    }
+    if (
+      screened.reviewer !== survivor.reviewer ||
+      screened.confidence !== survivor.confidence ||
+      normalizeRepoRelativePath(screened.file) !==
+        normalizeRepoRelativePath(survivor.file) ||
+      screened.line !== survivor.line ||
+      screened.severity !== survivor.severity
+    ) {
+      return {
+        path: formatReviewArtifactIssuePath([
+          'prepared',
+          'surviving_findings',
+          index,
+        ]),
+        reason: 'surviving finding diverges from its screened finding',
+      }
+    }
+  }
+  return
+}
+function findUnavailableCitedReviewer(
+  finding,
+  findingIndex,
+  survivingIndex,
+  dispatchByPersona,
+) {
+  const citedReviewers = new Set()
+  for (const [idIndex, inputId] of finding.input_finding_ids.entries()) {
+    const survivor = survivingIndex.get(inputId)
+    if (!survivor) continue
+    citedReviewers.add(survivor.reviewer)
+    if (
+      dispatchByPersona.get(survivor.reviewer)?.dispatch_outcome ===
+      'validation_unavailable'
+    ) {
+      return {
+        citedReviewers,
+        rejection: {
+          path: formatReviewArtifactIssuePath([
+            'merge',
+            'merged_findings',
+            findingIndex,
+            'input_finding_ids',
+            idIndex,
+          ]),
+          reason: 'merged finding cites input from unavailable reviewer',
+        },
+      }
+    }
+  }
+  return { citedReviewers }
+}
+function findUnsupportedSubmitter(finding, findingIndex, citedReviewers) {
+  for (const [submitterIndex, submitter] of finding.submitters.entries()) {
+    if (!citedReviewers.has(submitter)) {
+      return {
+        path: formatReviewArtifactIssuePath([
+          'merge',
+          'merged_findings',
+          findingIndex,
+          'submitters',
+          submitterIndex,
+        ]),
+        reason: 'merged finding submitter not a cited reviewer',
+      }
+    }
+  }
+  return
+}
+function findOverlappingAgreementCredit(finding, findingIndex) {
+  const submitterSet = new Set(finding.submitters)
+  const agreementCredit = finding.agreement_credit ?? []
+  for (const [creditIndex, credit] of agreementCredit.entries()) {
+    if (submitterSet.has(credit)) {
+      return {
+        path: formatReviewArtifactIssuePath([
+          'merge',
+          'merged_findings',
+          findingIndex,
+          'agreement_credit',
+          creditIndex,
+        ]),
+        reason: 'merged finding agreement credit overlaps submitters',
+      }
+    }
+  }
+  return
+}
+function checkMergedFindingProvenance(
+  mergedFindings,
+  survivingIndex,
+  dispatchByPersona,
+) {
+  for (const [findingIndex, finding] of mergedFindings.entries()) {
+    const unavailable = findUnavailableCitedReviewer(
+      finding,
+      findingIndex,
+      survivingIndex,
+      dispatchByPersona,
+    )
+    if (unavailable.rejection) return unavailable.rejection
+    const unsupportedSubmitter = findUnsupportedSubmitter(
+      finding,
+      findingIndex,
+      unavailable.citedReviewers,
+    )
+    if (unsupportedSubmitter) return unsupportedSubmitter
+    const overlappingCredit = findOverlappingAgreementCredit(
+      finding,
+      findingIndex,
+    )
+    if (overlappingCredit) return overlappingCredit
+  }
+  return
+}
+function deriveRejectedPayloadWeights(screenResults) {
+  const sorted = [...screenResults].sort((a, b) =>
+    compareStrings(a.reviewer, b.reviewer),
+  )
+  const weights = []
+  for (const result of sorted) {
+    const summary = result.result.rejected_summary
+    if (summary) {
+      weights.push({ rejected_finding_count: summary.rejected_finding_count })
+    }
+  }
+  return weights
+}
+function deriveLostRiskCriticalPersonas(dispatchRecords, screenByReviewer) {
+  const riskCriticalPersonas = new Set(RISK_CRITICAL_PERSONAS)
+  const lostPersonas = []
+  for (const record of dispatchRecords) {
+    if (!riskCriticalPersonas.has(record.persona)) continue
+    const selectionSurface = record.selection_surface ?? []
+    if (FINALIZE_CONTEXT_LOSS_DISPATCH_OUTCOMES.has(record.dispatch_outcome)) {
+      lostPersonas.push({
+        persona: record.persona,
+        selection_surface: selectionSurface,
+      })
+      continue
+    }
+    const rejectedSeverities =
+      screenByReviewer.get(record.persona)?.result.rejected_summary
+        ?.rejected_severities ?? []
+    if (
+      rejectedSeverities.some((severity) =>
+        FINALIZE_CONTEXT_LOSS_SEVERITIES.has(severity),
+      )
+    ) {
+      lostPersonas.push({
+        persona: record.persona,
+        selection_surface: selectionSurface,
+      })
+    }
+  }
+  return [...lostPersonas].sort((a, b) => compareStrings(a.persona, b.persona))
+}
+function deriveFinalizeContext(input) {
+  if (input.parent_run_metadata.validation.status !== 'not_attempted') {
+    return rejectFinalizeContext(
+      formatReviewArtifactIssuePath([
+        'parent_run_metadata',
+        'validation',
+        'status',
+      ]),
+      'validation must be not_attempted at finalize',
+    )
+  }
+  const findingIds = checkNoDuplicateMergedFindingIds(
+    input.merge.merged_findings,
+  )
+  if (!findingIds.ok) return findingIds
+  const survivingIndex = buildSurvivingFindingIndex(input.prepared)
+  const partition = checkSurvivorPartition(
+    input.merge.merged_findings,
+    input.prepared.surviving_findings,
+    survivingIndex,
+  )
+  if (!partition.ok) return partition
+  const requestViolation = checkValidatorRequestsResolve(
+    input.merge.validator_requests,
+    input.merge.merged_findings,
+  )
+  if (requestViolation) return { ok: false, rejection: requestViolation }
+  const dispatchJoin = checkDispatchRecordsJoin(
+    input.dispatch_records,
+    input.parent_run_metadata.selected_dispatches,
+  )
+  if (!dispatchJoin.ok) return dispatchJoin
+  const screenJoin = checkScreenResultsJoin(
+    input.screen_results,
+    input.dispatch_records,
+    dispatchJoin.value,
+  )
+  if (!screenJoin.ok) return screenJoin
+  const returnedReviewers = deriveReturnedReviewers(input.prepared)
+  const derivationViolation = checkMergedFindingsMatchDerivation(
+    input.merge.merged_findings,
+    partition.value,
+    returnedReviewers,
+  )
+  if (derivationViolation) return { ok: false, rejection: derivationViolation }
+  const duplicateDispositionViolation = checkNoDuplicateConfidenceDispositions(
+    input.prepared.confidence_dispositions,
+  )
+  if (duplicateDispositionViolation) {
+    return { ok: false, rejection: duplicateDispositionViolation }
+  }
+  const dispositionJoinViolation =
+    checkConfidenceDispositionsResolveScreenedFindings(
+      input.prepared,
+      input.screen_results,
+    )
+  if (dispositionJoinViolation) {
+    return { ok: false, rejection: dispositionJoinViolation }
+  }
+  const provenanceViolation = checkMergedFindingProvenance(
+    input.merge.merged_findings,
+    survivingIndex,
+    dispatchJoin.value,
+  )
+  if (provenanceViolation) return { ok: false, rejection: provenanceViolation }
+  return {
+    ok: true,
+    value: {
+      rejected_payloads: deriveRejectedPayloadWeights(input.screen_results),
+      lost_risk_critical_personas: deriveLostRiskCriticalPersonas(
+        input.dispatch_records,
+        screenJoin.value,
+      ),
+    },
+  }
+}
+function deriveInputDispositions(
+  prepared,
+  reconciled,
+  reviewerIndex,
+  unavailablePersonas,
+) {
+  const filteredInputIds = new Set(reconciled.filtered_input_ids)
+  const findingByInputId = new Map()
+  for (const finding of reconciled.findings) {
+    for (const inputId of finding.input_finding_ids) {
+      findingByInputId.set(inputId, finding)
+    }
+  }
+  const dispositions = []
+  for (const [index, entry] of prepared.confidence_dispositions.entries()) {
+    const reviewer = reviewerIndex.get(entry.input_id)
+    if (reviewer !== undefined && unavailablePersonas.has(reviewer)) continue
+    if (entry.disposition === 'suppressed') {
+      dispositions.push({
+        input_id: entry.input_id,
+        disposition: 'suppressed',
+        reason: entry.reason,
+      })
+      continue
+    }
+    if (filteredInputIds.has(entry.input_id)) {
+      dispositions.push({ input_id: entry.input_id, disposition: 'filtered' })
+      continue
+    }
+    const finding = findingByInputId.get(entry.input_id)
+    if (finding === undefined) {
+      return {
+        ok: false,
+        rejection: {
+          path: formatReviewArtifactIssuePath([
+            'prepared',
+            'confidence_dispositions',
+            index,
+            'input_id',
+          ]),
+          reason: 'survivor missing from merged findings',
+        },
+      }
+    }
+    const isMerged = finding.input_finding_ids.length > 1
+    dispositions.push({
+      input_id: entry.input_id,
+      disposition: isMerged ? 'merged' : 'surviving',
+    })
+  }
+  return {
+    ok: true,
+    value: [...dispositions].sort((a, b) =>
+      compareStrings(a.input_id, b.input_id),
+    ),
+  }
+}
+function computeDispositionCounts(inputDispositions, rejectedPayloads) {
+  let surviving = 0
+  let merged = 0
+  let suppressed = 0
+  let filtered = 0
+  for (const entry of inputDispositions) {
+    if (entry.disposition === 'surviving') surviving += 1
+    else if (entry.disposition === 'merged') merged += 1
+    else if (entry.disposition === 'suppressed') suppressed += 1
+    else filtered += 1
+  }
+  const rejected = rejectedPayloads.reduce(
+    (total, payload) => total + payload.rejected_finding_count,
+    0,
+  )
+  return { surviving, merged, suppressed, filtered, rejected }
+}
+function routeForOwner(owner) {
+  if (owner === 'review-fixer') return 'fixer'
+  if (owner === 'release') return 'report_only'
+  return 'residual'
+}
+function partitionFindings(reconciled) {
+  const filteredFindingIds = new Set(reconciled.filtered_finding_ids)
+  const unconfirmedFindingIds = new Set(
+    reconciled.lifecycle_failures.map((failure) => failure.finding_id),
+  )
+  const preExistingFindings = []
+  const newFindings = []
+  const fixer = []
+  const residual = []
+  const reportOnly = []
+  for (const finding of reconciled.findings) {
+    if (filteredFindingIds.has(finding.finding_id)) continue
+    const unconfirmed = unconfirmedFindingIds.has(finding.finding_id)
+    const entry = { finding_id: finding.finding_id, unconfirmed }
+    if (finding.pre_existing) {
+      preExistingFindings.push(entry)
+      continue
+    }
+    newFindings.push(entry)
+    if (unconfirmed) continue
+    const route = routeForOwner(finding.owner)
+    if (route === 'fixer') fixer.push(entry)
+    else if (route === 'residual') residual.push(entry)
+    else reportOnly.push(entry)
+  }
+  const byFindingId = (a, b) => compareStrings(a.finding_id, b.finding_id)
+  return {
+    preExistingFindings: [...preExistingFindings].sort(byFindingId),
+    newFindings: [...newFindings].sort(byFindingId),
+    queues: {
+      fixer: [...fixer].sort(byFindingId),
+      residual: [...residual].sort(byFindingId),
+      report_only: [...reportOnly].sort(byFindingId),
+    },
+  }
+}
+function finalizeReviewDispositions(input) {
+  const reviewerIndex = buildAdmittedReviewerIndex(
+    input.prepared,
+    input.screen_results,
+  )
+  const unavailablePersonas = buildValidationUnavailablePersonas(
+    input.dispatch_records,
+  )
+  const inputDispositionsResult = deriveInputDispositions(
+    input.prepared,
+    input.reconciled,
+    reviewerIndex,
+    unavailablePersonas,
+  )
+  if (!inputDispositionsResult.ok) return inputDispositionsResult
+  const dispositionCounts = computeDispositionCounts(
+    inputDispositionsResult.value,
+    input.rejected_payloads,
+  )
+  const { preExistingFindings, newFindings, queues } = partitionFindings(
+    input.reconciled,
+  )
+  return {
+    ok: true,
+    value: {
+      input_dispositions: inputDispositionsResult.value,
+      disposition_counts: dispositionCounts,
+      pre_existing_findings: preExistingFindings,
+      new_findings: newFindings,
+      queues,
+    },
+  }
+}
+function buildSurvivingReviewerIndex(prepared) {
+  const index = new Map()
+  for (const finding of prepared.surviving_findings) {
+    index.set(finding.input_id, finding.reviewer)
+  }
+  return index
+}
+function buildRequestedUncertainFindingIds(reconciled) {
+  return new Set(
+    reconciled.lifecycle_failures.map((failure) => failure.finding_id),
+  )
+}
+function findingOwners(finding, survivingReviewerIndex) {
+  const owners = new Set()
+  for (const inputId of finding.input_finding_ids) {
+    const reviewer = survivingReviewerIndex.get(inputId)
+    if (reviewer !== undefined) owners.add(reviewer)
+  }
+  return owners
+}
+function isValidationBandEligible(finding, requestedUncertainFindingIds) {
+  if (finding.validated === true) return true
+  if (finding.validated === false) return false
+  return !requestedUncertainFindingIds.has(finding.finding_id)
+}
+function isEligibleRiskCoverageCandidate(
+  finding,
+  lostPersona,
+  normalizedSurface,
+  survivingReviewerIndex,
+  requestedUncertainFindingIds,
+) {
+  if (finding.validated === false) return false
+  if (!normalizedSurface.has(normalizeRepoRelativePath(finding.file))) {
+    return false
+  }
+  const owners = findingOwners(finding, survivingReviewerIndex)
+  const hasCrossPersonaOwner = [...owners].some(
+    (owner) => owner !== lostPersona,
+  )
+  if (!hasCrossPersonaOwner) return false
+  return isValidationBandEligible(finding, requestedUncertainFindingIds)
+}
+function citedInputIdForLostPersona(
+  finding,
+  lostPersona,
+  survivingReviewerIndex,
+) {
+  const crossPersonaInputIds = finding.input_finding_ids.filter((inputId) => {
+    const reviewer = survivingReviewerIndex.get(inputId)
+    return reviewer !== undefined && reviewer !== lostPersona
+  })
+  if (crossPersonaInputIds.length === 0) return
+  return [...crossPersonaInputIds].sort(compareStrings)[0]
+}
+function deriveCoverageForLostPersona(
+  lostPersona,
+  reconciled,
+  survivingReviewerIndex,
+  requestedUncertainFindingIds,
+) {
+  const normalizedSurface = new Set(
+    lostPersona.selection_surface.map(normalizeRepoRelativePath),
+  )
+  const eligible = reconciled.findings
+    .filter((finding) =>
+      isEligibleRiskCoverageCandidate(
+        finding,
+        lostPersona.persona,
+        normalizedSurface,
+        survivingReviewerIndex,
+        requestedUncertainFindingIds,
+      ),
+    )
+    .sort(compareMergedFindingAssembly)
+  for (const candidate of eligible) {
+    const citedInputId = citedInputIdForLostPersona(
+      candidate,
+      lostPersona.persona,
+      survivingReviewerIndex,
+    )
+    if (citedInputId !== undefined) {
+      return {
+        persona: lostPersona.persona,
+        satisfied: true,
+        finding_id: candidate.finding_id,
+        input_finding_id: citedInputId,
+      }
+    }
+  }
+  return { persona: lostPersona.persona, satisfied: false }
+}
+function deriveRiskCoverage(input) {
+  const survivingReviewerIndex = buildSurvivingReviewerIndex(input.prepared)
+  const requestedUncertainFindingIds = buildRequestedUncertainFindingIds(
+    input.reconciled,
+  )
+  return input.lost_risk_critical_personas
+    .map((lostPersona) =>
+      deriveCoverageForLostPersona(
+        lostPersona,
+        input.reconciled,
+        survivingReviewerIndex,
+        requestedUncertainFindingIds,
+      ),
+    )
+    .sort((a, b) => compareStrings(a.persona, b.persona))
+}
+function routePlanAssessment(input) {
+  const residualActionableWork = []
+  const advisoryOutputs = []
+  for (const result of input.results) {
+    if (result.kind === 'explicit_unmet_requirement') {
+      residualActionableWork.push(result.description)
+    } else {
+      advisoryOutputs.push(result.description)
+    }
+  }
+  residualActionableWork.sort(compareStrings)
+  advisoryOutputs.sort(compareStrings)
+  return {
+    residual_actionable_work: residualActionableWork,
+    advisory_outputs: advisoryOutputs,
+    gated_by_explicit_unmet_requirement: residualActionableWork.length > 0,
+  }
+}
+function deriveVerdict(planAssessment, riskCoverage, reconciled) {
+  const blockingReasons = []
+  for (const description of planAssessment.residual_actionable_work) {
+    blockingReasons.push({
+      kind: 'explicit_unmet_plan_requirement',
+      description,
+    })
+  }
+  for (const coverage of riskCoverage) {
+    if (!coverage.satisfied) {
+      blockingReasons.push({
+        kind: 'unsatisfied_risk_coverage',
+        persona: coverage.persona,
+      })
+    }
+  }
+  for (const failure of reconciled.lifecycle_failures) {
+    blockingReasons.push({
+      kind: 'degraded_validator_lifecycle',
+      finding_id: failure.finding_id,
+      outcome: failure.outcome,
+    })
+  }
+  return {
+    clean: blockingReasons.length === 0,
+    blocking_reasons: blockingReasons,
+  }
+}
+function runReviewPipeline(input) {
+  const reconciled = reconcileValidatorResults({
+    merge: input.merge,
+    validator_lifecycle_results: input.validator_lifecycle_results,
+  })
+  if (!reconciled.ok) return reconciled
+  const finalized = finalizeReviewDispositions({
+    prepared: input.prepared,
+    reconciled: reconciled.value,
+    rejected_payloads: input.rejected_payloads,
+    screen_results: input.screen_results,
+    dispatch_records: input.dispatch_records,
+  })
+  if (!finalized.ok) return finalized
+  const riskCoverage = deriveRiskCoverage({
+    lost_risk_critical_personas: input.lost_risk_critical_personas,
+    prepared: input.prepared,
+    reconciled: reconciled.value,
+  })
+  const planAssessment = routePlanAssessment(input.plan_assessment)
+  const verdict = deriveVerdict(planAssessment, riskCoverage, reconciled.value)
+  return {
+    ok: true,
+    value: {
+      reconciled: reconciled.value,
+      finalized: finalized.value,
+      risk_coverage: riskCoverage,
+      plan_assessment: planAssessment,
+      verdict,
+    },
+  }
+}
+var LEDGER_ADMITTED_REASON =
+  'This input finding passed synthesis and was carried into the run.'
+var LEDGER_FILTERED_FALLBACK_REASON =
+  'A validator disproved the synthesized finding this input contributed to.'
+function buildAdmittedReviewerIndex(prepared, screenResults) {
+  const index = new Map()
+  for (const finding of prepared.surviving_findings) {
+    index.set(finding.input_id, finding.reviewer)
+  }
+  for (const result of screenResults) {
+    for (const finding of result.result.admitted_findings) {
+      if (!index.has(finding.input_id)) {
+        index.set(finding.input_id, result.reviewer)
+      }
+    }
+  }
+  return index
+}
+function buildConfidenceReasonIndex(prepared) {
+  const index = new Map()
+  for (const entry of prepared.confidence_dispositions) {
+    if (entry.disposition === 'suppressed' && entry.reason !== undefined) {
+      index.set(entry.input_id, entry.reason)
+    }
+  }
+  return index
+}
+function buildFilteredReasonIndex(reconciled) {
+  const index = new Map()
+  for (const finding of reconciled.findings) {
+    if (
+      finding.validated !== false ||
+      finding.validation_reason === undefined
+    ) {
+      continue
+    }
+    for (const inputId of finding.input_finding_ids) {
+      index.set(inputId, finding.validation_reason)
+    }
+  }
+  return index
+}
+function buildValidationUnavailablePersonas(dispatchRecords) {
+  return new Set(
+    dispatchRecords
+      .filter((record) => record.dispatch_outcome === 'validation_unavailable')
+      .map((record) => record.persona),
+  )
+}
+function admittedLedgerReason(
+  inputId,
+  disposition,
+  confidenceReasons,
+  filteredReasons,
+) {
+  if (disposition === 'suppressed') {
+    return confidenceReasons.get(inputId) ?? CONFIDENCE_GATE_SUPPRESSED_REASON
+  }
+  if (disposition === 'filtered') {
+    return filteredReasons.get(inputId) ?? LEDGER_FILTERED_FALLBACK_REASON
+  }
+  return LEDGER_ADMITTED_REASON
+}
+function buildAdmittedLedgerRows(input, unavailablePersonas) {
+  const reviewerIndex = buildAdmittedReviewerIndex(
+    input.prepared,
+    input.screen_results,
+  )
+  const dispositionIndex = new Map(
+    input.finalized.input_dispositions.map((entry) => [entry.input_id, entry]),
+  )
+  const confidenceReasons = buildConfidenceReasonIndex(input.prepared)
+  const filteredReasons = buildFilteredReasonIndex(input.reconciled)
+  const rows = []
+  for (const entry of input.prepared.confidence_dispositions) {
+    const reviewer = reviewerIndex.get(entry.input_id)
+    if (reviewer === undefined) {
+      throw new Error(
+        'buildInputLedger: confidence disposition has no resolvable reviewer',
+      )
+    }
+    if (unavailablePersonas.has(reviewer)) continue
+    const finalDisposition = dispositionIndex.get(entry.input_id)?.disposition
+    if (finalDisposition === undefined) continue
+    rows.push({
+      record_type: 'admitted',
+      input_id: entry.input_id,
+      reviewer,
+      confidence: entry.confidence,
+      disposition: finalDisposition,
+      reason: admittedLedgerReason(
+        entry.input_id,
+        finalDisposition,
+        confidenceReasons,
+        filteredReasons,
+      ),
+    })
+  }
+  return [...rows].sort((a, b) => compareStrings(a.input_id, b.input_id))
+}
+function buildRejectedLedgerRows(screenResults, unavailablePersonas) {
+  const rows = []
+  for (const result of screenResults) {
+    if (unavailablePersonas.has(result.reviewer)) continue
+    const summary = result.result.rejected_summary
+    if (!summary) continue
+    rows.push({
+      record_type: 'rejected_summary',
+      reviewer: result.reviewer,
+      dispatch_outcome: summary.dispatch_outcome,
+      rejected_finding_count: summary.rejected_finding_count,
+      rejected_severities: summary.rejected_severities,
+      disposition: 'rejected',
+      reason: summary.reason,
+    })
+  }
+  return [...rows].sort((a, b) => compareStrings(a.reviewer, b.reviewer))
+}
+function buildInputLedger(input) {
+  const unavailablePersonas = buildValidationUnavailablePersonas(
+    input.dispatch_records,
+  )
+  return [
+    ...buildAdmittedLedgerRows(input, unavailablePersonas),
+    ...buildRejectedLedgerRows(input.screen_results, unavailablePersonas),
+  ]
+}
+function dedupeSortedStrings(values) {
+  return [...new Set(values)].sort(compareStrings)
+}
+function checkCoverageArrayBound(field, values) {
+  if (values.length <= MAX_PERSONAS) return
+  return {
+    path: formatReviewArtifactIssuePath(['coverage', field]),
+    reason: 'coverage array exceeds bound',
+  }
+}
+function buildReviewCoverage(input) {
+  const residualRisks = dedupeSortedStrings(
+    input.screen_results.flatMap((result) => result.result.residual_risks),
+  )
+  const testingGaps = dedupeSortedStrings(
+    input.screen_results.flatMap((result) => result.result.testing_gaps),
+  )
+  const failedReviewers = dedupeSortedStrings(
+    input.dispatch_records
+      .filter((record) =>
+        FINALIZE_CONTEXT_LOSS_DISPATCH_OUTCOMES.has(record.dispatch_outcome),
+      )
+      .map((record) => record.persona),
+  )
+  const validatorFailures = input.reconciled.lifecycle_failures.map(
+    (failure) => failure.reason,
+  )
+  const intentUncertainty = [...input.merge.disagreement_facts]
+  const bounded = [
+    ['residual_risks', residualRisks],
+    ['testing_gaps', testingGaps],
+    ['failed_reviewers', failedReviewers],
+    ['validator_failures', validatorFailures],
+    ['intent_uncertainty', intentUncertainty],
+  ]
+  for (const [field, values] of bounded) {
+    const violation = checkCoverageArrayBound(field, values)
+    if (violation) return { ok: false, rejection: violation }
+  }
+  return {
+    ok: true,
+    value: {
+      reviewers: input.dispatch_records.length,
+      validators: input.validator_lifecycle_results.length,
+      residual_risks: residualRisks,
+      testing_gaps: testingGaps,
+      failed_reviewers: failedReviewers,
+      validator_failures: validatorFailures,
+      intent_uncertainty: intentUncertainty,
+    },
+  }
+}
+function projectOneSynthesizedFinding(finding) {
+  return {
+    title: finding.title,
+    severity: finding.severity,
+    file: finding.file,
+    line: finding.line,
+    why_it_matters: finding.why_it_matters,
+    autofix_class: finding.autofix_class,
+    owner: finding.owner,
+    requires_verification: finding.requires_verification,
+    confidence: finding.confidence,
+    evidence: finding.evidence,
+    pre_existing: finding.pre_existing,
+    ...(finding.suggested_fix !== undefined
+      ? { suggested_fix: finding.suggested_fix }
+      : {}),
+    ...(finding.validated !== undefined
+      ? { validated: finding.validated }
+      : {}),
+    ...(finding.validation_reason !== undefined
+      ? { validation_reason: finding.validation_reason }
+      : {}),
+    input_finding_ids: finding.input_finding_ids,
+    provenance: {
+      fingerprint: finding.fingerprint,
+      submitters: finding.submitters,
+      agreement_credit: finding.agreement_credit ?? [],
+    },
+  }
+}
+function projectSynthesizedFindings(input) {
+  return input.findings.map((finding) => projectOneSynthesizedFinding(finding))
+}
+var ARTIFACT_NON_CLEAN_VERDICT =
+  'Review did not reach a clean verdict; see blocking reasons and coverage for detail.'
+function deriveArtifactRunStatus(
+  reconciledDegraded,
+  dispatchRecords,
+  lostRiskCriticalPersonas,
+) {
+  if (reconciledDegraded) return 'degraded'
+  if (lostRiskCriticalPersonas.length > 0) return 'degraded'
+  const hasFailedReviewer = dispatchRecords.some((record) =>
+    FINALIZE_CONTEXT_LOSS_DISPATCH_OUTCOMES.has(record.dispatch_outcome),
+  )
+  return hasFailedReviewer ? 'degraded' : 'completed'
+}
+function deriveArtifactVerdictText(
+  planAssessmentVerdict,
+  runVerdict,
+  runStatus,
+) {
+  if (runVerdict.clean && runStatus === 'completed') {
+    return planAssessmentVerdict
+  }
+  return ARTIFACT_NON_CLEAN_VERDICT
+}
+function buildScreenResultIndex(screenResults) {
+  const index = new Map()
+  for (const result of screenResults) {
+    index.set(result.reviewer, result)
+  }
+  return index
+}
+function buildDispatchEntry(record, screenByReviewer) {
+  const screenResult = screenByReviewer.get(record.persona)
+  const inputFindingCount =
+    record.dispatch_outcome === 'validation_unavailable'
+      ? 0
+      : (screenResult?.result.admitted_findings.length ?? 0)
+  const rejectionReason = screenResult?.result.rejected_summary?.reason
+  const selectionSurface = record.selection_surface
+  const selectionReason = record.selection_reason
+  return {
+    persona: record.persona,
+    dispatch_outcome: record.dispatch_outcome,
+    input_finding_count: inputFindingCount,
+    ...(rejectionReason !== undefined
+      ? { rejection_reason: rejectionReason }
+      : {}),
+    ...(selectionSurface !== undefined && selectionSurface.length > 0
+      ? { selection_surface: selectionSurface }
+      : {}),
+    ...(selectionReason !== undefined
+      ? { selection_reason: selectionReason }
+      : {}),
+  }
+}
+function buildArtifactDispatches(dispatchRecords, screenByReviewer) {
+  return [...dispatchRecords]
+    .map((record) => buildDispatchEntry(record, screenByReviewer))
+    .sort((a, b) => compareStrings(a.persona, b.persona))
+}
+function checkRiskCoverageSemantics(artifactCandidate) {
+  const coverage = artifactCandidate.risk_coverage
+  if (coverage === undefined) return { ok: true }
+  for (const [coverageIndex, entry] of coverage.entries()) {
+    if (!entry.satisfied || entry.input_finding_id === undefined) continue
+    const citedId = entry.input_finding_id
+    const dispatch = artifactCandidate.dispatches.find(
+      (record) => record.persona === entry.persona,
+    )
+    const normalizedSurface = new Set(
+      (dispatch?.selection_surface ?? []).map(normalizeRepoRelativePath),
+    )
+    const covered = artifactCandidate.findings.some((finding) => {
+      if (!finding.input_finding_ids.includes(citedId)) return false
+      const inValidationBand =
+        finding.severity === 'P0' ||
+        finding.severity === 'P1' ||
+        finding.requires_verification
+      const validationSatisfied = inValidationBand
+        ? finding.validated === true
+        : finding.validated !== false
+      if (!validationSatisfied) return false
+      return normalizedSurface.has(normalizeRepoRelativePath(finding.file))
+    })
+    if (!covered) {
+      return {
+        ok: false,
+        rejection: {
+          path: formatReviewArtifactIssuePath([
+            'risk_coverage',
+            coverageIndex,
+            'input_finding_id',
+          ]),
+          reason:
+            'satisfied risk coverage must cite a validated finding on the lost persona selection surface',
+        },
+      }
+    }
+  }
+  return { ok: true }
+}
+function checkDispositionCountsReconcileLedger(dispositionCounts, ledger) {
+  const admittedLedgerRowCount = ledger.filter(
+    (row) => row.record_type === 'admitted',
+  ).length
+  const dispositionAdmittedSum =
+    dispositionCounts.surviving +
+    dispositionCounts.merged +
+    dispositionCounts.suppressed +
+    dispositionCounts.filtered
+  if (dispositionAdmittedSum !== admittedLedgerRowCount) {
+    return {
+      ok: false,
+      rejection: {
+        path: formatReviewArtifactIssuePath(['disposition_counts']),
+        reason:
+          'disposition counts do not reconcile with the admitted input ledger',
+      },
+    }
+  }
+  return { ok: true }
+}
+function projectRiskCoverage(riskCoverage) {
+  if (riskCoverage.length === 0) return
+  return riskCoverage.map((entry) => ({
+    persona: entry.persona,
+    satisfied: entry.satisfied,
+    ...(entry.input_finding_id !== undefined
+      ? { input_finding_id: entry.input_finding_id }
+      : {}),
+  }))
+}
+function buildReportProjection(
+  verdictText,
+  findings,
+  appliedFixes,
+  pipelineOutput,
+  coverage,
+  riskCoverage,
+) {
+  return {
+    verdict: verdictText,
+    findings,
+    applied_fixes: appliedFixes,
+    residual_actionable_work:
+      pipelineOutput.plan_assessment.residual_actionable_work,
+    advisory_outputs: pipelineOutput.plan_assessment.advisory_outputs,
+    coverage,
+    input_dispositions: pipelineOutput.finalized.input_dispositions,
+    disposition_counts: pipelineOutput.finalized.disposition_counts,
+    queues: pipelineOutput.finalized.queues,
+    pre_existing_findings: pipelineOutput.finalized.pre_existing_findings,
+    ...(riskCoverage !== undefined ? { risk_coverage: riskCoverage } : {}),
+  }
+}
+function parseFinalizeOutput(output) {
+  const parsed = FinalizeOutputSchema.safeParse(output)
+  if (!parsed.success) {
+    const issue = parsed.error.issues[0]
+    return {
+      ok: false,
+      rejection: {
+        path: issue
+          ? formatReviewArtifactIssuePath(issue.path)
+          : JSON_ROOT_PATH,
+        reason: 'finalize output failed schema validation',
+      },
+    }
+  }
+  return { ok: true, value: parsed.data }
+}
+function finalizeReview(input) {
+  const context = deriveFinalizeContext({
+    merge: input.merge,
+    prepared: input.prepared,
+    screen_results: input.screen_results,
+    dispatch_records: input.dispatch_records,
+    parent_run_metadata: {
+      selected_dispatches: input.parent_run_metadata.selected_dispatches,
+      validation: input.parent_run_metadata.validation,
+    },
+  })
+  if (!context.ok) return context
+  const pipeline = runReviewPipeline({
+    merge: input.merge,
+    validator_lifecycle_results: input.validator_lifecycle_results,
+    prepared: input.prepared,
+    rejected_payloads: context.value.rejected_payloads,
+    lost_risk_critical_personas: context.value.lost_risk_critical_personas,
+    plan_assessment: input.plan_assessment,
+    screen_results: input.screen_results,
+    dispatch_records: input.dispatch_records,
+  })
+  if (!pipeline.ok) return pipeline
+  const coverage = buildReviewCoverage({
+    dispatch_records: input.dispatch_records,
+    validator_lifecycle_results: input.validator_lifecycle_results,
+    screen_results: input.screen_results,
+    reconciled: pipeline.value.reconciled,
+    merge: input.merge,
+  })
+  if (!coverage.ok) return coverage
+  const findings = projectSynthesizedFindings({
+    findings: pipeline.value.reconciled.findings,
+  })
+  const runStatus = deriveArtifactRunStatus(
+    pipeline.value.reconciled.degraded,
+    input.dispatch_records,
+    context.value.lost_risk_critical_personas,
+  )
+  const verdictText = deriveArtifactVerdictText(
+    input.plan_assessment.verdict,
+    pipeline.value.verdict,
+    runStatus,
+  )
+  const screenByReviewer = buildScreenResultIndex(input.screen_results)
+  const dispatches = buildArtifactDispatches(
+    input.dispatch_records,
+    screenByReviewer,
+  )
+  const riskCoverage = projectRiskCoverage(pipeline.value.risk_coverage)
+  const riskCoverageSemantics = checkRiskCoverageSemantics({
+    dispatches,
+    findings,
+    risk_coverage: riskCoverage,
+  })
+  if (!riskCoverageSemantics.ok) return riskCoverageSemantics
+  const report = buildReportProjection(
+    verdictText,
+    findings,
+    input.parent_run_metadata.applied_fixes,
+    pipeline.value,
+    coverage.value,
+    riskCoverage,
+  )
+  if (input.parent_run_metadata.mode === 'report-only') {
+    return parseFinalizeOutput({ kind: 'report_only', ...report })
+  }
+  const ledger = buildInputLedger({
+    prepared: input.prepared,
+    screen_results: input.screen_results,
+    dispatch_records: input.dispatch_records,
+    finalized: pipeline.value.finalized,
+    reconciled: pipeline.value.reconciled,
+  })
+  const dispositionReconciliation = checkDispositionCountsReconcileLedger(
+    pipeline.value.finalized.disposition_counts,
+    ledger,
+  )
+  if (!dispositionReconciliation.ok) return dispositionReconciliation
+  const artifact = {
+    schema_version: 1,
+    run_id: input.parent_run_metadata.run_id,
+    branch: input.parent_run_metadata.branch,
+    head_sha: input.parent_run_metadata.head_sha,
+    mode: input.parent_run_metadata.mode,
+    harness: input.parent_run_metadata.harness,
+    run_status: runStatus,
+    verdict: verdictText,
+    completed_at: input.parent_run_metadata.timestamps.completed_at,
+    dispatches,
+    input_findings: ledger,
+    findings,
+    disposition_counts: pipeline.value.finalized.disposition_counts,
+    applied_fixes: input.parent_run_metadata.applied_fixes,
+    residual_actionable_work:
+      pipeline.value.plan_assessment.residual_actionable_work,
+    advisory_outputs: pipeline.value.plan_assessment.advisory_outputs,
+    coverage: coverage.value,
+    validation: input.parent_run_metadata.validation,
+    ...(riskCoverage !== undefined ? { risk_coverage: riskCoverage } : {}),
+  }
+  const parsedArtifact = ReviewArtifactSchema.safeParse(artifact)
+  if (!parsedArtifact.success) {
+    const issue = parsedArtifact.error.issues[0]
+    return {
+      ok: false,
+      rejection: {
+        path: issue
+          ? formatReviewArtifactIssuePath(issue.path)
+          : JSON_ROOT_PATH,
+        reason: 'artifact failed schema validation',
+      },
+    }
+  }
+  return parseFinalizeOutput({
+    kind: 'writing',
+    artifact: parsedArtifact.data,
+    report,
+  })
+}
+
+// src/ce-review-validator.ts
+var CE_REVIEW_VALIDATOR_USAGE =
+  'Usage: node validate-review.mjs <return|artifact|screen|prepare|merge|finalize> [...]'
+var CE_REVIEW_SCREEN_USAGE =
+  'Usage: node validate-review.mjs screen --reviewer <name> --harness <opencode|pi|claude-code>'
+var CE_REVIEW_SCREEN_STDIN_TTY_MESSAGE =
+  'screen reads one raw reviewer return from stdin; interactive input is not supported'
+var CE_REVIEW_SCREEN_STDIN_READ_FAILED_MESSAGE =
+  'screen could not read the reviewer return from stdin'
+var CE_REVIEW_SCREEN_STDIN_OVERSIZED_MESSAGE =
+  'screen input exceeds the 1 MiB limit'
+var CE_REVIEW_SCREEN_STDIN_INVALID_UTF8_MESSAGE =
+  'screen input is not valid UTF-8'
+var CE_REVIEW_SCREEN_STDIN_EMPTY_MESSAGE = 'screen received empty stdin'
+var CE_REVIEW_SCREEN_REJECTED_MESSAGE = 'screen rejected the reviewer return'
+var CE_REVIEW_SCREEN_INTERNAL_ERROR_MESSAGE =
+  'ce-review-validator: internal error'
+var CE_REVIEW_PREPARE_USAGE = 'Usage: node validate-review.mjs prepare'
+var CE_REVIEW_PREPARE_STDIN_TTY_MESSAGE =
+  'prepare reads one aggregate JSON envelope from stdin; interactive input is not supported'
+var CE_REVIEW_PREPARE_STDIN_READ_FAILED_MESSAGE =
+  'prepare could not read the aggregate envelope from stdin'
+var CE_REVIEW_PREPARE_STDIN_OVERSIZED_MESSAGE =
+  'prepare input exceeds the aggregate byte cap'
+var CE_REVIEW_PREPARE_STDIN_INVALID_UTF8_MESSAGE =
+  'prepare input is not valid UTF-8'
+var CE_REVIEW_PREPARE_STDIN_EMPTY_MESSAGE = 'prepare received empty stdin'
+var CE_REVIEW_PREPARE_REJECTED_MESSAGE =
+  'prepare rejected the aggregate envelope'
+var CE_REVIEW_MERGE_USAGE = 'Usage: node validate-review.mjs merge'
+var CE_REVIEW_MERGE_STDIN_TTY_MESSAGE =
+  'merge reads one aggregate JSON envelope from stdin; interactive input is not supported'
+var CE_REVIEW_MERGE_STDIN_READ_FAILED_MESSAGE =
+  'merge could not read the aggregate envelope from stdin'
+var CE_REVIEW_MERGE_STDIN_OVERSIZED_MESSAGE =
+  'merge input exceeds the aggregate byte cap'
+var CE_REVIEW_MERGE_STDIN_INVALID_UTF8_MESSAGE =
+  'merge input is not valid UTF-8'
+var CE_REVIEW_MERGE_STDIN_EMPTY_MESSAGE = 'merge received empty stdin'
+var CE_REVIEW_MERGE_REJECTED_MESSAGE = 'merge rejected the aggregate envelope'
+var CE_REVIEW_FINALIZE_USAGE = 'Usage: node validate-review.mjs finalize'
+var CE_REVIEW_FINALIZE_STDIN_TTY_MESSAGE =
+  'finalize reads one aggregate JSON envelope from stdin; interactive input is not supported'
+var CE_REVIEW_FINALIZE_STDIN_READ_FAILED_MESSAGE =
+  'finalize could not read the aggregate envelope from stdin'
+var CE_REVIEW_FINALIZE_STDIN_OVERSIZED_MESSAGE =
+  'finalize input exceeds the aggregate byte cap'
+var CE_REVIEW_FINALIZE_STDIN_INVALID_UTF8_MESSAGE =
+  'finalize input is not valid UTF-8'
+var CE_REVIEW_FINALIZE_STDIN_EMPTY_MESSAGE = 'finalize received empty stdin'
+var CE_REVIEW_FINALIZE_REJECTED_MESSAGE =
+  'finalize rejected the aggregate envelope'
+var SCREEN_FLAGS = ['--reviewer', '--harness']
+function isScreenFlag(token) {
+  return SCREEN_FLAGS.includes(token)
+}
+function parseScreenFlags(argv) {
+  const values = new Map()
+  let index = 0
+  while (index < argv.length) {
+    const token = argv[index]
+    if (token === undefined) break
+    if (!isScreenFlag(token)) return { ok: false }
+    if (values.has(token)) return { ok: false }
+    const value = argv[index + 1]
+    if (value === undefined || value.startsWith('--')) return { ok: false }
+    values.set(token, value)
+    index += 2
+  }
+  const reviewer = values.get('--reviewer')
+  const rawHarness = values.get('--harness')
+  if (reviewer === undefined || rawHarness === undefined) return { ok: false }
+  const harnessParse = HarnessSchema.safeParse(rawHarness)
+  if (!harnessParse.success) return { ok: false }
+  const harness = harnessParse.data
+  if (!ScreenInputSchema.shape.expected_reviewer.safeParse(reviewer).success) {
+    return { ok: false }
+  }
+  return { harness, ok: true, reviewer }
+}
+function formatAggregateRejectionMessage(rejectedMessage, rejection) {
+  return `${rejectedMessage}: ${rejection.reason} at ${rejection.path}`
+}
+function runScreenSubcommand(options, outputSink, errorSink) {
+  const flags = parseScreenFlags(options.argv.slice(1))
+  if (!flags.ok) {
+    errorSink(CE_REVIEW_SCREEN_USAGE)
+    return 2
+  }
+  const fd = 0
+  const isTTY = options.isTTY ?? process.stdin.isTTY === true
+  if (isTTY) {
+    errorSink(CE_REVIEW_SCREEN_STDIN_TTY_MESSAGE)
+    return 2
+  }
+  const read = readBoundedStdin(fd, options.readChunk ?? defaultReadChunk)
+  if (read.status === 'read-error') {
+    errorSink(CE_REVIEW_SCREEN_STDIN_READ_FAILED_MESSAGE)
+    return 2
+  }
+  if (read.status === 'oversized') {
+    errorSink(CE_REVIEW_SCREEN_STDIN_OVERSIZED_MESSAGE)
+    return 1
+  }
+  let text
+  try {
+    text = new TextDecoder('utf-8', { fatal: true }).decode(read.buffer)
+  } catch {
+    errorSink(CE_REVIEW_SCREEN_STDIN_INVALID_UTF8_MESSAGE)
+    return 1
+  }
+  if (text.trim() === '') {
+    errorSink(CE_REVIEW_SCREEN_STDIN_EMPTY_MESSAGE)
+    return 2
+  }
+  const result = screenReviewReturn({
+    expected_reviewer: flags.reviewer,
+    invoking_harness: flags.harness,
+    raw_return: text,
+  })
+  if (result.dispatch_outcome === 'malformed') {
+    errorSink(
+      result.rejected_summary?.reason ?? CE_REVIEW_SCREEN_REJECTED_MESSAGE,
+    )
+    return 1
+  }
+  outputSink(JSON.stringify(result))
+  return 0
+}
+function runPrepareSubcommand(options, outputSink, errorSink) {
+  if (options.argv.slice(1).length > 0) {
+    errorSink(CE_REVIEW_PREPARE_USAGE)
+    return 2
+  }
+  const fd = 0
+  const isTTY = options.isTTY ?? process.stdin.isTTY === true
+  if (isTTY) {
+    errorSink(CE_REVIEW_PREPARE_STDIN_TTY_MESSAGE)
+    return 2
+  }
+  const read = readBoundedStdin(
+    fd,
+    options.readChunk ?? defaultReadChunk,
+    AGGREGATE_STDIN_BYTE_CAP,
+  )
+  if (read.status === 'read-error') {
+    errorSink(CE_REVIEW_PREPARE_STDIN_READ_FAILED_MESSAGE)
+    return 2
+  }
+  if (read.status === 'oversized') {
+    errorSink(CE_REVIEW_PREPARE_STDIN_OVERSIZED_MESSAGE)
+    return 1
+  }
+  let text
+  try {
+    text = new TextDecoder('utf-8', { fatal: true }).decode(read.buffer)
+  } catch {
+    errorSink(CE_REVIEW_PREPARE_STDIN_INVALID_UTF8_MESSAGE)
+    return 1
+  }
+  if (text.trim() === '') {
+    errorSink(CE_REVIEW_PREPARE_STDIN_EMPTY_MESSAGE)
+    return 2
+  }
+  const result = prepareReviewCandidates({ raw_input: text })
+  if (!result.ok) {
+    errorSink(
+      formatAggregateRejectionMessage(
+        CE_REVIEW_PREPARE_REJECTED_MESSAGE,
+        result.rejection,
+      ),
+    )
+    return 1
+  }
+  outputSink(JSON.stringify(result.value))
+  return 0
+}
+function runAggregateStdinSubcommand(options, outputSink, errorSink, spec) {
+  if (options.argv.slice(1).length > 0) {
+    errorSink(spec.usage)
+    return 2
+  }
+  const fd = 0
+  const isTTY = options.isTTY ?? process.stdin.isTTY === true
+  if (isTTY) {
+    errorSink(spec.ttyMessage)
+    return 2
+  }
+  const read = readBoundedStdin(
+    fd,
+    options.readChunk ?? defaultReadChunk,
+    AGGREGATE_STDIN_BYTE_CAP,
+  )
+  if (read.status === 'read-error') {
+    errorSink(spec.readFailedMessage)
+    return 2
+  }
+  if (read.status === 'oversized') {
+    errorSink(spec.oversizedMessage)
+    return 1
+  }
+  let text
+  try {
+    text = new TextDecoder('utf-8', { fatal: true }).decode(read.buffer)
+  } catch {
+    errorSink(spec.invalidUtf8Message)
+    return 1
+  }
+  if (text.trim() === '') {
+    errorSink(spec.emptyMessage)
+    return 2
+  }
+  let value
+  try {
+    value = JSON.parse(text)
+  } catch {
+    errorSink(spec.rejectedMessage)
+    return 1
+  }
+  const parsed = spec.schema.safeParse(value)
+  if (!parsed.success) {
+    const issue = parsed.error.issues[0]
+    errorSink(
+      issue
+        ? formatAggregateRejectionMessage(spec.rejectedMessage, {
+            path: formatReviewArtifactIssuePath(issue.path),
+            reason: issue.code,
+          })
+        : spec.rejectedMessage,
+    )
+    return 1
+  }
+  const result = spec.execute(parsed.data)
+  if (!result.ok) {
+    errorSink(
+      formatAggregateRejectionMessage(spec.rejectedMessage, result.rejection),
+    )
+    return 1
+  }
+  outputSink(JSON.stringify(result.value))
+  return 0
+}
+function runMergeSubcommand(options, outputSink, errorSink) {
+  return runAggregateStdinSubcommand(options, outputSink, errorSink, {
+    emptyMessage: CE_REVIEW_MERGE_STDIN_EMPTY_MESSAGE,
+    execute: (input) =>
+      applyReviewAdjudication({
+        prepared: input.prepared,
+        decisions: input.adjudication.decisions,
+      }),
+    invalidUtf8Message: CE_REVIEW_MERGE_STDIN_INVALID_UTF8_MESSAGE,
+    oversizedMessage: CE_REVIEW_MERGE_STDIN_OVERSIZED_MESSAGE,
+    readFailedMessage: CE_REVIEW_MERGE_STDIN_READ_FAILED_MESSAGE,
+    rejectedMessage: CE_REVIEW_MERGE_REJECTED_MESSAGE,
+    schema: MergeInputSchema,
+    ttyMessage: CE_REVIEW_MERGE_STDIN_TTY_MESSAGE,
+    usage: CE_REVIEW_MERGE_USAGE,
+  })
+}
+function runFinalizeSubcommand(options, outputSink, errorSink) {
+  return runAggregateStdinSubcommand(options, outputSink, errorSink, {
+    emptyMessage: CE_REVIEW_FINALIZE_STDIN_EMPTY_MESSAGE,
+    execute: (input) => finalizeReview(input),
+    invalidUtf8Message: CE_REVIEW_FINALIZE_STDIN_INVALID_UTF8_MESSAGE,
+    oversizedMessage: CE_REVIEW_FINALIZE_STDIN_OVERSIZED_MESSAGE,
+    readFailedMessage: CE_REVIEW_FINALIZE_STDIN_READ_FAILED_MESSAGE,
+    rejectedMessage: CE_REVIEW_FINALIZE_REJECTED_MESSAGE,
+    schema: FinalizeInputSchema,
+    ttyMessage: CE_REVIEW_FINALIZE_STDIN_TTY_MESSAGE,
+    usage: CE_REVIEW_FINALIZE_USAGE,
+  })
+}
+var processExceptionBoundaryInstalled = false
+var activeInvocation = {
+  errorSink: (message) => console.error(message),
+  phase: 'unknown',
+}
+function formatInternalErrorMessage(phase) {
+  return `ce-review-validator: internal error in ${phase}`
+}
+function installProcessExceptionBoundary() {
+  if (processExceptionBoundaryInstalled) return
+  processExceptionBoundaryInstalled = true
+  const handleFatal = () => {
+    activeInvocation.errorSink(
+      formatInternalErrorMessage(activeInvocation.phase),
+    )
+    process.exitCode = 1
+  }
+  process.on('unhandledRejection', handleFatal)
+  process.on('uncaughtException', handleFatal)
+}
+function runCeReviewValidator(options) {
+  const outputSink = options.outputSink ?? ((message) => console.log(message))
+  const errorSink = options.errorSink ?? ((message) => console.error(message))
+  const subcommand = options.argv[0]
+  activeInvocation = { errorSink, phase: subcommand ?? 'unknown' }
+  installProcessExceptionBoundary()
+  try {
+    if (subcommand === 'return') {
+      return runReviewReturnValidator({
+        argv: [
+          'systematic',
+          'validate-review-return',
+          ...options.argv.slice(1),
+        ],
+        isTTY: options.isTTY,
+        readChunk: options.readChunk,
+        outputSink,
+        errorSink,
+      })
+    }
+    if (subcommand === 'artifact') {
+      return runClaudeCodeValidator({
+        argv: options.argv.slice(1),
+        cwd: options.cwd,
+        outputSink,
+        errorSink,
+      })
+    }
+    if (subcommand === 'screen') {
+      return runScreenSubcommand(options, outputSink, errorSink)
+    }
+    if (subcommand === 'prepare') {
+      return runPrepareSubcommand(options, outputSink, errorSink)
+    }
+    if (subcommand === 'merge') {
+      return runMergeSubcommand(options, outputSink, errorSink)
+    }
+    if (subcommand === 'finalize') {
+      return runFinalizeSubcommand(options, outputSink, errorSink)
+    }
+    errorSink(CE_REVIEW_VALIDATOR_USAGE)
+    return 2
+  } catch {
+    errorSink(formatInternalErrorMessage(activeInvocation.phase))
+    return 1
+  }
+}
+function resolveRealPath(candidate) {
+  if (candidate === undefined) return
+  try {
+    return fs3.realpathSync(candidate)
+  } catch {
+    return
+  }
+}
+var entryPath = resolveRealPath(process.argv[1])
+var modulePath = resolveRealPath(fileURLToPath(import.meta.url))
+var isMainModule =
+  entryPath !== undefined &&
+  modulePath !== undefined &&
+  entryPath === modulePath
+if (isMainModule) {
+  process.exitCode = runCeReviewValidator({ argv: process.argv.slice(2) })
+}
+export {
+  CE_REVIEW_FINALIZE_REJECTED_MESSAGE,
+  CE_REVIEW_FINALIZE_STDIN_EMPTY_MESSAGE,
+  CE_REVIEW_FINALIZE_STDIN_INVALID_UTF8_MESSAGE,
+  CE_REVIEW_FINALIZE_STDIN_OVERSIZED_MESSAGE,
+  CE_REVIEW_FINALIZE_STDIN_READ_FAILED_MESSAGE,
+  CE_REVIEW_FINALIZE_STDIN_TTY_MESSAGE,
+  CE_REVIEW_FINALIZE_USAGE,
+  CE_REVIEW_MERGE_REJECTED_MESSAGE,
+  CE_REVIEW_MERGE_STDIN_EMPTY_MESSAGE,
+  CE_REVIEW_MERGE_STDIN_INVALID_UTF8_MESSAGE,
+  CE_REVIEW_MERGE_STDIN_OVERSIZED_MESSAGE,
+  CE_REVIEW_MERGE_STDIN_READ_FAILED_MESSAGE,
+  CE_REVIEW_MERGE_STDIN_TTY_MESSAGE,
+  CE_REVIEW_MERGE_USAGE,
+  CE_REVIEW_PREPARE_REJECTED_MESSAGE,
+  CE_REVIEW_PREPARE_STDIN_EMPTY_MESSAGE,
+  CE_REVIEW_PREPARE_STDIN_INVALID_UTF8_MESSAGE,
+  CE_REVIEW_PREPARE_STDIN_OVERSIZED_MESSAGE,
+  CE_REVIEW_PREPARE_STDIN_READ_FAILED_MESSAGE,
+  CE_REVIEW_PREPARE_STDIN_TTY_MESSAGE,
+  CE_REVIEW_PREPARE_USAGE,
+  CE_REVIEW_SCREEN_INTERNAL_ERROR_MESSAGE,
+  CE_REVIEW_SCREEN_REJECTED_MESSAGE,
+  CE_REVIEW_SCREEN_STDIN_EMPTY_MESSAGE,
+  CE_REVIEW_SCREEN_STDIN_INVALID_UTF8_MESSAGE,
+  CE_REVIEW_SCREEN_STDIN_OVERSIZED_MESSAGE,
+  CE_REVIEW_SCREEN_STDIN_READ_FAILED_MESSAGE,
+  CE_REVIEW_SCREEN_STDIN_TTY_MESSAGE,
+  CE_REVIEW_SCREEN_USAGE,
+  CE_REVIEW_VALIDATOR_USAGE,
+  runCeReviewValidator,
 }
-export { CE_REVIEW_VALIDATOR_USAGE, runCeReviewValidator }