opencode-swarm 7.162.0 → 7.162.1

package/dist/cli/index-w7ekntej.js

@@ -0,0 +1,643 @@
+// @bun
+import {
+  exports_external,
+  init_zod
+} from "./index-bpmtbmy9.js";
+
+// src/background/pr-review-contract.ts
+init_zod();
+import { createHash } from "crypto";
+
+// src/pr-review/critic-routing.ts
+function prReviewFindingRequiresCritic(input) {
+  if (input.classification !== "CONFIRMED")
+    return false;
+  const impact = input.risk_impact ?? "UNKNOWN";
+  const tags = input.risk_tags ?? [];
+  if (impact === "UNKNOWN")
+    return true;
+  if (input.severity === undefined)
+    return true;
+  if (input.severity === "CRITICAL" || input.severity === "HIGH")
+    return true;
+  if (input.severity === "MEDIUM") {
+    return impact === "HIGH_IMPACT" || tags.length > 0;
+  }
+  return false;
+}
+
+// src/background/pr-review-contract.ts
+var PR_REVIEW_REVIEWER_CLASSIFICATIONS = [
+  "CONFIRMED",
+  "DISPROVED",
+  "UNVERIFIED",
+  "PRE_EXISTING"
+];
+var PR_REVIEW_REVIEWER_EVIDENCE_TYPES = [
+  "STRUCTURALLY_PROVEN",
+  "EXECUTION_PROVEN",
+  "STATIC_TRACE_PROVEN",
+  "PLAUSIBLE_BUT_UNVERIFIED"
+];
+var PR_REVIEW_SEVERITIES = [
+  "CRITICAL",
+  "HIGH",
+  "MEDIUM",
+  "LOW",
+  "INFO",
+  "NONE"
+];
+var PR_REVIEW_CRITIC_STATUSES = [
+  "UPHELD",
+  "DOWNGRADED",
+  "DISPROVED",
+  "NEEDS_MORE_EVIDENCE"
+];
+var PR_REVIEW_FINDING_STATUSES = [
+  "PENDING",
+  "CONFIRMED",
+  "DISPROVED",
+  "PRE_EXISTING"
+];
+var PR_REVIEW_FINDING_ACTIONS = [
+  "route_to_reviewer",
+  "route_to_critic",
+  "report",
+  "suppress_with_reason",
+  "handoff_to_feedback"
+];
+var PR_REVIEW_ARTIFACT_BOUNDARIES = [
+  "post_explorer",
+  "post_reviewer",
+  "post_critic"
+];
+var PR_REVIEW_BASE_DIMENSION_IDS = [
+  "intent-architecture",
+  "correctness-state",
+  "tests-falsifiability",
+  "security-trust",
+  "reliability-performance",
+  "compatibility-delivery"
+];
+var PR_REVIEW_RISK_IMPACTS = [
+  "ORDINARY",
+  "HIGH_IMPACT",
+  "UNKNOWN"
+];
+var PR_REVIEW_RISK_TAGS = [
+  "SECURITY",
+  "AUTH_PERMISSIONS",
+  "STATE_INTEGRITY",
+  "WRITE_PATH",
+  "EVIDENCE_INTEGRITY",
+  "GIT",
+  "CONFIGURATION"
+];
+var PR_REVIEW_RESULT_LANE_MODES = [
+  "swarm-pr-review:base",
+  "swarm-pr-review:micro"
+];
+var PR_REVIEW_RESULT_OUTCOMES = [
+  "CLEAN",
+  "FINDINGS",
+  "INCOMPLETE"
+];
+var PR_REVIEW_RESULT_FINDING_SEVERITIES = [
+  "CRITICAL",
+  "HIGH",
+  "MEDIUM",
+  "LOW",
+  "INFO"
+];
+var PR_REVIEW_RESULT_UNRESOLVED_REASONS = [
+  "NOT_EXECUTED",
+  "PARTIAL_OUTPUT",
+  "CONTRACT_FAILURE",
+  "RESOURCE_LIMIT",
+  "DEADLINE_EXCEEDED",
+  "STALE_BINDING",
+  "PARENT_CANCELLED"
+];
+var MAX_PR_REVIEW_RESULT_OWNED_LANES = 11;
+var MAX_PR_REVIEW_RESULT_FINDINGS = 256;
+var MAX_PR_REVIEW_RESULT_RECEIPT_BYTES = 64 * 1024;
+function prReviewLegacyTranscriptCompatibilityEnabled(value) {
+  return value === true;
+}
+var PrReviewResultLaneIdSchema = exports_external.string().trim().min(1).max(120);
+var PrReviewResultChildSessionSchema = exports_external.string().trim().min(1).max(256);
+var PrReviewResultShaSchema = exports_external.string().trim().regex(/^[0-9a-f]{6,64}$/i);
+var PrReviewResultDigestSchema = exports_external.string().trim().regex(/^[0-9a-f]{64}$/i);
+function addDuplicateIssue(ctx, path, label, value) {
+  ctx.addIssue({
+    code: exports_external.ZodIssueCode.custom,
+    path,
+    message: `${label} must not contain duplicate value "${value}"`
+  });
+}
+function assertUniqueStrings(values, ctx, path, label) {
+  const seen = new Set;
+  for (const value of values) {
+    if (seen.has(value)) {
+      addDuplicateIssue(ctx, path, label, value);
+      return;
+    }
+    seen.add(value);
+  }
+}
+var PrReviewResultLocationSchema = exports_external.discriminatedUnion("kind", [
+  exports_external.object({
+    kind: exports_external.literal("local"),
+    file: exports_external.string().trim().min(1).max(4096),
+    line: exports_external.number().int().positive().max(1e6).optional(),
+    endLine: exports_external.number().int().positive().max(1e6).optional(),
+    column: exports_external.number().int().positive().max(1e4).optional(),
+    endColumn: exports_external.number().int().positive().max(1e4).optional()
+  }).strict().superRefine((value, ctx) => {
+    if (value.endLine !== undefined && value.line !== undefined && value.endLine < value.line) {
+      ctx.addIssue({
+        code: exports_external.ZodIssueCode.custom,
+        path: ["endLine"],
+        message: "endLine must be greater than or equal to line"
+      });
+    }
+    if (value.endColumn !== undefined && value.column !== undefined && value.endColumn < value.column) {
+      ctx.addIssue({
+        code: exports_external.ZodIssueCode.custom,
+        path: ["endColumn"],
+        message: "endColumn must be greater than or equal to column"
+      });
+    }
+  }),
+  exports_external.object({
+    kind: exports_external.literal("non_local"),
+    label: exports_external.string().trim().min(1).max(200),
+    detail: exports_external.string().trim().min(1).max(2000)
+  }).strict()
+]);
+var PrReviewResultFindingSchema = exports_external.object({
+  id: exports_external.string().trim().min(1).max(128),
+  workflowLane: PrReviewResultLaneIdSchema,
+  severity: exports_external.enum(PR_REVIEW_RESULT_FINDING_SEVERITIES),
+  riskImpact: exports_external.enum(PR_REVIEW_RISK_IMPACTS),
+  riskTags: exports_external.array(exports_external.enum(PR_REVIEW_RISK_TAGS)).max(PR_REVIEW_RISK_TAGS.length),
+  title: exports_external.string().trim().min(1).max(200),
+  body: exports_external.string().trim().min(1).max(4000),
+  evidence: exports_external.string().trim().min(1).max(4000),
+  location: PrReviewResultLocationSchema
+}).strict().superRefine((value, ctx) => {
+  assertUniqueStrings(value.riskTags, ctx, ["riskTags"], "riskTags");
+});
+var PrReviewCleanAttestationSchema = exports_external.object({
+  workflowLane: PrReviewResultLaneIdSchema,
+  coverageScope: exports_external.string().trim().min(12).max(2000),
+  evidence: exports_external.string().trim().min(20).max(4000)
+}).strict();
+var PrReviewUnresolvedLaneSchema = exports_external.object({
+  workflowLane: PrReviewResultLaneIdSchema,
+  reason: exports_external.enum(PR_REVIEW_RESULT_UNRESOLVED_REASONS),
+  detail: exports_external.string().trim().min(1).max(4000)
+}).strict();
+var PrReviewLaneResultEnvelopeSchema = exports_external.object({
+  schemaVersion: exports_external.literal(1),
+  outcome: exports_external.enum(PR_REVIEW_RESULT_OUTCOMES),
+  creditedLanes: exports_external.array(PrReviewResultLaneIdSchema).max(MAX_PR_REVIEW_RESULT_OWNED_LANES),
+  findings: exports_external.array(PrReviewResultFindingSchema).max(MAX_PR_REVIEW_RESULT_FINDINGS),
+  cleanAttestations: exports_external.array(PrReviewCleanAttestationSchema).max(MAX_PR_REVIEW_RESULT_OWNED_LANES),
+  unresolved: exports_external.array(PrReviewUnresolvedLaneSchema).max(MAX_PR_REVIEW_RESULT_OWNED_LANES)
+}).strict().superRefine((value, ctx) => {
+  assertUniqueStrings(value.creditedLanes, ctx, ["creditedLanes"], "creditedLanes");
+  const findingIds = value.findings.map((finding) => finding.id);
+  assertUniqueStrings(findingIds, ctx, ["findings"], "findings");
+  const findingLanes = value.findings.map((finding) => finding.workflowLane);
+  assertUniqueStrings(value.cleanAttestations.map((entry) => entry.workflowLane), ctx, ["cleanAttestations"], "cleanAttestations");
+  assertUniqueStrings(value.unresolved.map((entry) => entry.workflowLane), ctx, ["unresolved"], "unresolved");
+  for (const lane of findingLanes) {
+    if (value.cleanAttestations.some((entry) => entry.workflowLane === lane)) {
+      ctx.addIssue({
+        code: exports_external.ZodIssueCode.custom,
+        path: ["findings"],
+        message: `workflow lane "${lane}" cannot be both CLEAN and FINDINGS`
+      });
+      return;
+    }
+  }
+  const coveredLanes = new Set([
+    ...findingLanes,
+    ...value.cleanAttestations.map((entry) => entry.workflowLane)
+  ]);
+  for (const lane of value.creditedLanes) {
+    if (!coveredLanes.has(lane)) {
+      ctx.addIssue({
+        code: exports_external.ZodIssueCode.custom,
+        path: ["creditedLanes"],
+        message: `credited workflow lane "${lane}" must be backed by a finding or CLEAN attestation`
+      });
+      return;
+    }
+  }
+  for (const lane of coveredLanes) {
+    if (!value.creditedLanes.includes(lane)) {
+      ctx.addIssue({
+        code: exports_external.ZodIssueCode.custom,
+        path: ["creditedLanes"],
+        message: `covered workflow lane "${lane}" must appear in creditedLanes`
+      });
+      return;
+    }
+  }
+  for (const lane of value.unresolved.map((entry) => entry.workflowLane)) {
+    if (coveredLanes.has(lane)) {
+      ctx.addIssue({
+        code: exports_external.ZodIssueCode.custom,
+        path: ["unresolved"],
+        message: `workflow lane "${lane}" cannot be both credited and unresolved`
+      });
+      return;
+    }
+  }
+  const totalCovered = value.creditedLanes.length + value.unresolved.length;
+  if (totalCovered === 0) {
+    ctx.addIssue({
+      code: exports_external.ZodIssueCode.custom,
+      path: ["creditedLanes"],
+      message: "result envelope must cover at least one workflow lane"
+    });
+    return;
+  }
+  if (value.outcome === "CLEAN") {
+    if (value.findings.length > 0 || value.unresolved.length > 0) {
+      ctx.addIssue({
+        code: exports_external.ZodIssueCode.custom,
+        path: ["outcome"],
+        message: "CLEAN outcome cannot include findings or unresolved lanes"
+      });
+    }
+    if (value.cleanAttestations.length !== value.creditedLanes.length) {
+      ctx.addIssue({
+        code: exports_external.ZodIssueCode.custom,
+        path: ["cleanAttestations"],
+        message: "CLEAN outcome must attest every credited workflow lane exactly once"
+      });
+    }
+  }
+  if (value.outcome === "FINDINGS") {
+    if (value.findings.length === 0) {
+      ctx.addIssue({
+        code: exports_external.ZodIssueCode.custom,
+        path: ["findings"],
+        message: "FINDINGS outcome requires at least one finding"
+      });
+    }
+    if (value.unresolved.length > 0) {
+      ctx.addIssue({
+        code: exports_external.ZodIssueCode.custom,
+        path: ["unresolved"],
+        message: "FINDINGS outcome cannot include unresolved lanes"
+      });
+    }
+  }
+  if (value.outcome === "INCOMPLETE" && value.unresolved.length === 0) {
+    ctx.addIssue({
+      code: exports_external.ZodIssueCode.custom,
+      path: ["unresolved"],
+      message: "INCOMPLETE outcome requires at least one unresolved lane"
+    });
+  }
+});
+function serializedPrReviewResultReceiptBytes(value) {
+  return new TextEncoder().encode(JSON.stringify(value)).byteLength;
+}
+function prReviewLaneResultEnvelopeDigest(value) {
+  return createHash("sha256").update(JSON.stringify(value)).digest("hex");
+}
+var PrReviewResultReceiptSchema = exports_external.object({
+  schemaVersion: exports_external.literal(1),
+  mode: exports_external.enum(PR_REVIEW_RESULT_LANE_MODES),
+  workflowInstanceId: exports_external.string().trim().min(1).max(256),
+  workflowRevision: exports_external.number().int().nonnegative(),
+  batchId: exports_external.string().trim().min(1).max(120),
+  laneId: exports_external.string().trim().min(1).max(120),
+  workflowLane: PrReviewResultLaneIdSchema,
+  ownedWorkflowLanes: exports_external.array(PrReviewResultLaneIdSchema).min(1).max(MAX_PR_REVIEW_RESULT_OWNED_LANES),
+  baseSha: PrReviewResultShaSchema,
+  headSha: PrReviewResultShaSchema,
+  dispatchRevisionDigest: PrReviewResultDigestSchema,
+  childSessionId: PrReviewResultChildSessionSchema,
+  generation: exports_external.number().int().positive().max(1e6),
+  semanticEnvelopeDigest: PrReviewResultDigestSchema,
+  envelope: PrReviewLaneResultEnvelopeSchema
+}).strict().superRefine((value, ctx) => {
+  assertUniqueStrings(value.ownedWorkflowLanes, ctx, ["ownedWorkflowLanes"], "ownedWorkflowLanes");
+  if (!value.ownedWorkflowLanes.includes(value.workflowLane)) {
+    ctx.addIssue({
+      code: exports_external.ZodIssueCode.custom,
+      path: ["workflowLane"],
+      message: "workflowLane must be included in ownedWorkflowLanes"
+    });
+  }
+  const covered = new Set([
+    ...value.envelope.creditedLanes,
+    ...value.envelope.unresolved.map((entry) => entry.workflowLane)
+  ]);
+  if (covered.size !== value.ownedWorkflowLanes.length) {
+    ctx.addIssue({
+      code: exports_external.ZodIssueCode.custom,
+      path: ["envelope"],
+      message: "envelope credited and unresolved workflow lanes must exactly partition ownedWorkflowLanes"
+    });
+    return;
+  }
+  for (const lane of value.ownedWorkflowLanes) {
+    if (!covered.has(lane)) {
+      ctx.addIssue({
+        code: exports_external.ZodIssueCode.custom,
+        path: ["ownedWorkflowLanes"],
+        message: `owned workflow lane "${lane}" is missing from the envelope coverage`
+      });
+      return;
+    }
+  }
+  const expectedDigest = prReviewLaneResultEnvelopeDigest(value.envelope);
+  if (value.semanticEnvelopeDigest !== expectedDigest) {
+    ctx.addIssue({
+      code: exports_external.ZodIssueCode.custom,
+      path: ["semanticEnvelopeDigest"],
+      message: "semanticEnvelopeDigest must match the canonical envelope digest"
+    });
+  }
+  const bytes = serializedPrReviewResultReceiptBytes(value);
+  if (bytes > MAX_PR_REVIEW_RESULT_RECEIPT_BYTES) {
+    ctx.addIssue({
+      code: exports_external.ZodIssueCode.custom,
+      path: [],
+      message: `receipt exceeds the ${MAX_PR_REVIEW_RESULT_RECEIPT_BYTES}-byte bound`
+    });
+  }
+});
+var PR_REVIEW_FINDINGS_MAX_BYTES = 10 * 1024 * 1024;
+var PR_REVIEW_FINDINGS_WRITE_MAX_BYTES = 3 * 1024 * 1024;
+var PR_REVIEW_HANDOFF_MAX_BYTES = 128 * 1024;
+var PR_REVIEW_HANDOFF_WRITE_MAX_BYTES = 120 * 1024;
+var PR_REVIEW_DISCARDED_EXAMPLE_ITEM_ID = "discarded-id";
+function serializedPrReviewArtifactInputBytes(value) {
+  return new TextEncoder().encode(JSON.stringify(value)).byteLength;
+}
+var PrReviewRunIdSchema = exports_external.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/, "run_id must be a safe relative identifier");
+var PrReviewFindingSchema = exports_external.object({
+  finding_id: exports_external.string().trim().min(1).max(128),
+  status: exports_external.enum(PR_REVIEW_FINDING_STATUSES),
+  file_line: exports_external.string().trim().min(1).max(1000),
+  evidence: exports_external.string().trim().min(1).max(20000),
+  next_action: exports_external.enum(PR_REVIEW_FINDING_ACTIONS),
+  severity: exports_external.enum(PR_REVIEW_SEVERITIES).optional(),
+  category: exports_external.string().trim().min(1).max(128).optional(),
+  risk_impact: exports_external.enum(PR_REVIEW_RISK_IMPACTS).optional(),
+  risk_tags: exports_external.array(exports_external.enum(PR_REVIEW_RISK_TAGS)).max(PR_REVIEW_RISK_TAGS.length).optional()
+}).strict().superRefine((value, ctx) => {
+  if (value.status !== "CONFIRMED")
+    return;
+  if (value.risk_impact === undefined) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["risk_impact"],
+      message: "is required on every newly written CONFIRMED finding (issue #2383 typed critic routing)"
+    });
+  }
+  if (value.risk_tags === undefined) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["risk_tags"],
+      message: "is required on every newly written CONFIRMED finding (issue #2383 typed critic routing)"
+    });
+  }
+});
+var PrReviewHandoffSchema = exports_external.object({
+  pr_url: exports_external.string().url().max(2000),
+  finding_ids: exports_external.array(exports_external.string().trim().min(1).max(128)).min(1).max(1000),
+  summary: exports_external.string().trim().min(1).max(20000),
+  provenance: exports_external.array(exports_external.string().trim().min(1).max(4000)).min(1).max(1000)
+}).strict();
+var PrReviewPartialBaseCoverageSchema = exports_external.object({
+  unresolved_dimensions: exports_external.array(exports_external.enum(PR_REVIEW_BASE_DIMENSION_IDS)).min(1).max(PR_REVIEW_BASE_DIMENSION_IDS.length)
+}).strict().superRefine((value, ctx) => {
+  const seen = new Set;
+  for (const dimension of value.unresolved_dimensions) {
+    if (seen.has(dimension)) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["unresolved_dimensions"],
+        message: `must not contain duplicate dimension "${dimension}"`
+      });
+      return;
+    }
+    seen.add(dimension);
+  }
+});
+var WritePrReviewArtifactArgsSchema = exports_external.discriminatedUnion("kind", [
+  exports_external.object({
+    kind: exports_external.literal("findings"),
+    run_id: PrReviewRunIdSchema.optional(),
+    pr_head_sha: exports_external.string().trim().regex(/^[0-9a-f]{6,64}$/i),
+    boundary: exports_external.enum(PR_REVIEW_ARTIFACT_BOUNDARIES),
+    records: exports_external.array(PrReviewFindingSchema).min(1).max(1000),
+    partial_base_coverage: PrReviewPartialBaseCoverageSchema.optional()
+  }).strict(),
+  exports_external.object({
+    kind: exports_external.literal("handoff"),
+    run_id: PrReviewRunIdSchema.optional(),
+    pr_head_sha: exports_external.string().trim().regex(/^[0-9a-f]{6,64}$/i),
+    handoff: PrReviewHandoffSchema
+  }).strict()
+]).superRefine((value, ctx) => {
+  if (value.kind === "findings" && value.partial_base_coverage !== undefined && value.boundary !== "post_explorer") {
+    ctx.addIssue({
+      code: "custom",
+      path: ["partial_base_coverage"],
+      message: "is valid only for the post_explorer boundary"
+    });
+  }
+  const bytes = serializedPrReviewArtifactInputBytes(value);
+  const maxBytes = value.kind === "findings" ? PR_REVIEW_FINDINGS_WRITE_MAX_BYTES : PR_REVIEW_HANDOFF_WRITE_MAX_BYTES;
+  if (bytes > maxBytes) {
+    ctx.addIssue({
+      code: "custom",
+      path: [value.kind === "findings" ? "records" : "handoff"],
+      message: `serialized UTF-8 payload must be at most ${maxBytes} bytes (got ${bytes})`
+    });
+  }
+});
+var introducedByPrSchema = exports_external.string().regex(/^(?:introduced_by_pr\s*:\s*)?(?:YES|NO|UNKNOWN)$/i);
+var PrReviewRiskTagsFieldPattern = new RegExp(`^(?:(?:${PR_REVIEW_RISK_TAGS.join("|")})(?:,(?:${PR_REVIEW_RISK_TAGS.join("|")}))*)?$`);
+var PrReviewRiskTagsFieldSchema = exports_external.string().regex(PrReviewRiskTagsFieldPattern, `must be a comma-separated subset of the canonical risk tags (${PR_REVIEW_RISK_TAGS.join(", ")}), or empty`);
+var PR_REVIEW_REVIEWER_LEGACY_FIELD_COUNT = 10;
+function parsePrReviewRiskTagsField(field) {
+  const trimmed = field.trim();
+  if (!trimmed)
+    return [];
+  return trimmed.split(",").map((tag) => tag.trim());
+}
+var PrReviewReviewerVerdictFieldsSchema = exports_external.tuple([
+  exports_external.literal("[REVIEWED]"),
+  exports_external.string().min(1),
+  exports_external.enum(PR_REVIEW_REVIEWER_CLASSIFICATIONS),
+  exports_external.enum(PR_REVIEW_REVIEWER_EVIDENCE_TYPES),
+  exports_external.enum(PR_REVIEW_SEVERITIES),
+  introducedByPrSchema,
+  exports_external.string().min(1),
+  exports_external.string().min(8),
+  exports_external.string().min(5),
+  exports_external.string().min(3),
+  exports_external.enum(PR_REVIEW_RISK_IMPACTS),
+  PrReviewRiskTagsFieldSchema
+]).superRefine((fields, ctx) => {
+  if (fields[2] === "DISPROVED" && fields[4] !== "NONE") {
+    ctx.addIssue({
+      code: "custom",
+      path: [4],
+      message: "DISPROVED reviewer severity must be NONE"
+    });
+  }
+});
+var PrReviewCriticVerdictFieldsSchema = exports_external.tuple([
+  exports_external.literal("[CRITIC]"),
+  exports_external.string().min(1),
+  exports_external.enum(PR_REVIEW_CRITIC_STATUSES),
+  exports_external.enum(PR_REVIEW_SEVERITIES),
+  exports_external.string().min(6),
+  exports_external.string().min(6)
+]).superRefine((fields, ctx) => {
+  const status = fields[2];
+  const severity = fields[3];
+  if (status === "NEEDS_MORE_EVIDENCE") {
+    ctx.addIssue({
+      code: "custom",
+      path: [2],
+      message: "NEEDS_MORE_EVIDENCE is not a terminal transport verdict"
+    });
+  }
+  if (status === "DISPROVED" && severity !== "NONE") {
+    ctx.addIssue({
+      code: "custom",
+      path: [3],
+      message: "DISPROVED critic severity must be NONE"
+    });
+  }
+  if (status === "UPHELD" && !["CRITICAL", "HIGH", "MEDIUM"].includes(severity)) {
+    ctx.addIssue({
+      code: "custom",
+      path: [3],
+      message: "UPHELD critic severity must be CRITICAL, HIGH, or MEDIUM"
+    });
+  }
+  if (status === "DOWNGRADED" && severity === "CRITICAL") {
+    ctx.addIssue({
+      code: "custom",
+      path: [3],
+      message: "DOWNGRADED critic severity cannot be CRITICAL"
+    });
+  }
+});
+var PR_REVIEW_VERDICT_ROW_DESCRIPTORS = {
+  reviewer: {
+    marker: "[REVIEWED]",
+    fieldCount: 12,
+    fieldRoles: [
+      "marker",
+      "item_id",
+      "classification",
+      "evidence_type",
+      "severity",
+      "introduced_by_pr",
+      "file:line",
+      "rationale",
+      "probe",
+      "reviewer_notes",
+      "risk_impact",
+      "risk_tags"
+    ],
+    schema: PrReviewReviewerVerdictFieldsSchema
+  },
+  critic: {
+    marker: "[CRITIC]",
+    fieldCount: 6,
+    fieldRoles: [
+      "marker",
+      "item_id",
+      "status",
+      "severity",
+      "rationale",
+      "required_change"
+    ],
+    schema: PrReviewCriticVerdictFieldsSchema
+  }
+};
+function parsePrReviewVerdictRow(line, kind) {
+  const descriptor = PR_REVIEW_VERDICT_ROW_DESCRIPTORS[kind];
+  const fields = [];
+  let current = "";
+  let usedCanonicalEscape = false;
+  for (let index = 0;index < line.length; index++) {
+    const char = line[index];
+    if (char === "\\") {
+      const next = line[index + 1];
+      if (next === "\\") {
+        current += "\\";
+        usedCanonicalEscape = true;
+        index++;
+        continue;
+      }
+      if (next === "|") {
+        current += "|";
+        usedCanonicalEscape = true;
+        index++;
+        continue;
+      }
+      if (next === "n") {
+        current += `
+`;
+        usedCanonicalEscape = true;
+        index++;
+        continue;
+      }
+      if (next === "r") {
+        current += "\r";
+        usedCanonicalEscape = true;
+        index++;
+        continue;
+      }
+      current += "\\";
+      continue;
+    }
+    if (char === "|") {
+      fields.push(current.trim());
+      current = "";
+      continue;
+    }
+    current += char;
+  }
+  fields.push(current.trim());
+  if (fields[0] !== descriptor.marker)
+    return null;
+  if (kind === "reviewer" && fields.length === PR_REVIEW_REVIEWER_LEGACY_FIELD_COUNT) {
+    fields.push("UNKNOWN", "");
+  }
+  if (fields.length > descriptor.fieldCount) {
+    const retained = fields.slice(0, descriptor.fieldCount - 1);
+    retained.push(fields.slice(descriptor.fieldCount - 1).join("|"));
+    return {
+      marker: descriptor.marker,
+      fields: retained,
+      recoveredOverflow: true,
+      overflowClass: fields.length === descriptor.fieldCount + 1 && fields[fields.length - 1] === "" ? "legacy-fidelity-safe" : "legacy-lossy"
+    };
+  }
+  return {
+    marker: descriptor.marker,
+    fields,
+    recoveredOverflow: false,
+    overflowClass: fields.length === descriptor.fieldCount ? usedCanonicalEscape ? "canonical" : "legacy-fidelity-safe" : "legacy-lossy"
+  };
+}
+
+export { prReviewFindingRequiresCritic, PR_REVIEW_BASE_DIMENSION_IDS, PR_REVIEW_RISK_IMPACTS, PR_REVIEW_RISK_TAGS, prReviewLegacyTranscriptCompatibilityEnabled, PrReviewResultReceiptSchema, PR_REVIEW_FINDINGS_MAX_BYTES, PR_REVIEW_HANDOFF_MAX_BYTES, PR_REVIEW_DISCARDED_EXAMPLE_ITEM_ID, PrReviewRunIdSchema, parsePrReviewRiskTagsField, PrReviewReviewerVerdictFieldsSchema, PrReviewCriticVerdictFieldsSchema, parsePrReviewVerdictRow };

package/dist/cli/{index-pde4zn7j.js → index-wvfgkms6.js}

@@ -4,7 +4,7 @@ import {
   PlanSchema,
   TaskStatusSchema,
   init_loader
-} from "./index-tnj464kq.js";
+} from "./index-cjjcey0h.js";
 import {
   assertProjectRoot,
   withEvidenceLock