opencode-swarm 7.135.0 → 7.135.2

package/dist/cli/{index-crw4n55v.js → index-340chr1e.js}

@@ -5,13 +5,13 @@ import {
   getProfileForFile,
   isCommandAvailable,
   tool
-} from "./index-13xxjfhn.js";
+} from "./index-m0ynxkaa.js";
 import {
   detectStraySwarmDirs,
   readDoctorArtifact,
   removeStraySwarmDir,
   runConfigDoctor
-} from "./index-ctvnb76s.js";
+} from "./index-j92ser8n.js";
 import {
   EvaluationTaskV1Schema,
   GateAuditManifestV1Schema,
@@ -66,7 +66,7 @@ import {
   saveTaskSetSnapshot,
   transientBackoff,
   validateProjectRoot
-} from "./index-ens0gt38.js";
+} from "./index-7pnvf04s.js";
 import {
   withTimeout
 } from "./index-4905hd2m.js";
@@ -92,20 +92,20 @@ import {
   retireSkill,
   selectCandidateEntries,
   syncBundledProjectSkillsIfMissingAsync
-} from "./index-a4972t0f.js";
+} from "./index-qqkw794p.js";
 import {
   readRecentEscalations
-} from "./index-86wdrskb.js";
+} from "./index-ckdva4rs.js";
 import {
   alreadyCuratedThisGeneration,
   claimNextScanBatch,
   resolveCohortId
-} from "./index-vf6e8ame.js";
+} from "./index-b0eva00y.js";
 import {
   CURATOR_INIT_PROMPT,
   CURATOR_PHASE_PROMPT,
   READ_ONLY_LANE_GUIDANCE
-} from "./index-vxv732ex.js";
+} from "./index-dg1njnms.js";
 import {
   getGlobalEventBus
 } from "./index-c8s9a3zh.js";
@@ -123,7 +123,7 @@ import {
   listActive,
   subscribe,
   unsubscribe
-} from "./index-z085b4ka.js";
+} from "./index-3xbx305x.js";
 import {
   appendUnactionable,
   quarantineEntry,
@@ -133,11 +133,11 @@ import {
   validateActionability,
   validateActionableFields,
   validateLesson
-} from "./index-997d6p42.js";
+} from "./index-jgkjxpdh.js";
 import {
   authorizeCuration,
   buildConfigFingerprintInput
-} from "./index-g0raqavt.js";
+} from "./index-3m7kpnqf.js";
 import {
   cohortConfigFingerprint
 } from "./index-rtry5xyf.js";
@@ -170,7 +170,7 @@ import {
   transactFile,
   transactKnowledge,
   wordBigrams
-} from "./index-nrvs08pr.js";
+} from "./index-02cqjna3.js";
 import {
   MAX_EVENT_LOG_ENTRIES,
   _internals,
@@ -180,7 +180,7 @@ import {
   recordHiveKnowledgeEvent,
   recordKnowledgeEvent,
   resolveKnowledgeEventsPath
-} from "./index-x88w0cp5.js";
+} from "./index-8gw8p7yh.js";
 import {
   resolveHiveDataDir,
   resolveHiveEventsPath,
@@ -196,16 +196,16 @@ import {
   resolveLinkDir,
   sanitizeLinkId,
   writeLinkPointer
-} from "./index-yhba8swx.js";
+} from "./index-dzyjb33e.js";
 import {
   atomicWriteFile
-} from "./index-xg9repnx.js";
+} from "./index-ey29aap6.js";
 import {
   exports_loader,
   init_loader,
   loadPluginConfig,
   loadPluginConfigWithMeta
-} from "./index-e8w62fgs.js";
+} from "./index-9c3gf2wd.js";
 import {
   RetrospectiveEvidenceSchema
 } from "./index-k5jrywpr.js";
@@ -228,7 +228,7 @@ import {
   package_default,
   resolveAutoReviewConfig,
   stripKnownSwarmPrefix
-} from "./index-337r9pkr.js";
+} from "./index-j0kte6gd.js";
 import {
   KNOWLEDGE_SCHEMA_VERSION,
   OUTCOME_BLOCK_THRESHOLD,
@@ -244,7 +244,7 @@ import {
   clearAllScopes,
   clearScopeBindingFromDisk,
   clearScopeBindings
-} from "./index-ny93srnd.js";
+} from "./index-vg3yx648.js";
 import {
   appendLedgerEvent,
   computePlanHash,
@@ -266,12 +266,12 @@ import {
 import {
   findByBatchId,
   readDelegations
-} from "./index-7an2qn0s.js";
+} from "./index-hdy2nd5h.js";
 import {
   readSwarmFileAsync,
   safeHook,
   validateSwarmPath
-} from "./index-2ghkk9ve.js";
+} from "./index-bfd4xfpp.js";
 import {
   tryAcquireLock,
   withEvidenceLock
@@ -287,11 +287,6 @@ import {
   exports_external,
   init_zod
 } from "./index-bpmtbmy9.js";
-import {
-  bunSpawn,
-  bunWrite,
-  mergeEnvForChild
-} from "./index-qe3v54nb.js";
 import {
   criticalWarn,
   error,
@@ -314,12 +309,19 @@ import {
   resolveIsExactSingleChildCommitAsync,
   resolveIsWorkingTreeClean,
   resolveIsWorkingTreeCleanAsync,
+  resolvePrFeedbackTrackingCandidatesAsync,
   resolvePrReviewDiffStats,
   resolvePrReviewDiffStatsAsync,
   resolvePrWorkflowRevisionDigest,
   resolveRemoteRefsContainingHead,
-  resolveRemoteRefsContainingHeadAsync
-} from "./index-3nasn371.js";
+  resolveRemoteRefsContainingHeadAsync,
+  switchPrFeedbackTrackingCandidateAsync
+} from "./index-y6a7gjtj.js";
+import {
+  bunSpawn,
+  bunWrite,
+  mergeEnvForChild
+} from "./index-y111zefa.js";
 import {
   __require,
   __toCommonJS,
@@ -338,6 +340,914 @@ init_zod();
 import * as fsp2 from "fs/promises";
 import * as path4 from "path";
 
+// src/background/candidate-contract.ts
+var CANDIDATE_SEVERITIES = [
+  "INFO",
+  "LOW",
+  "MEDIUM",
+  "HIGH",
+  "CRITICAL"
+];
+var CANDIDATE_CONFIDENCES = ["HIGH", "MEDIUM", "LOW"];
+var CANDIDATE_FIELD_COUNT = 9;
+var CLEAN_FIELD_COUNT = 4;
+var CLEAN_COVERAGE_SCOPE_MIN_CHARS = 12;
+var CLEAN_EVIDENCE_MIN_CHARS = 20;
+var CANDIDATE_DIAGNOSTIC_PREVIEW_CHARS = 160;
+var CANDIDATE_FIELDS = {
+  base_explorer: [
+    "candidate_id",
+    "lane",
+    "severity",
+    "category",
+    "file_line",
+    "claim",
+    "evidence_summary",
+    "impact_context",
+    "confidence"
+  ],
+  micro_lane: [
+    "candidate_id",
+    "micro_lane",
+    "severity",
+    "category",
+    "file_line",
+    "claim",
+    "invariant_violated",
+    "evidence_summary",
+    "confidence"
+  ]
+};
+function candidateHeaderFamily(fields) {
+  if (fields[0]?.trim() !== "[CANDIDATE]")
+    return null;
+  const normalized = fields.slice(1).map((field) => field.trim());
+  for (const family of ["base_explorer", "micro_lane"]) {
+    const canonicalHeaderFields = CANDIDATE_FIELDS[family].map((name) => name === "file_line" ? "file:line" : name);
+    if (normalized.length === canonicalHeaderFields.length && canonicalHeaderFields.every((name, index) => normalized[index] === name)) {
+      return family;
+    }
+  }
+  return null;
+}
+function removeCandidateCodeFences(text) {
+  const lines = [];
+  let inFence = false;
+  for (const rawLine of text.split(`
+`)) {
+    if (rawLine.trimStart().startsWith("```")) {
+      inFence = !inFence;
+      continue;
+    }
+    if (!inFence)
+      lines.push(rawLine);
+  }
+  return lines.join(`
+`);
+}
+function analyzeCandidateLaneContext(context) {
+  const issues = [];
+  const baseBound = Boolean(context.expected_lane || context.expected_lanes);
+  const microBound = Boolean(context.expected_micro_lane || context.expected_micro_lanes);
+  if (context.expected_lanes) {
+    if (!context.expected_lane) {
+      issues.push({
+        field: "expected_lane",
+        message: "expected_lane is required when expected_lanes is supplied"
+      });
+    }
+    if (new Set(context.expected_lanes).size !== context.expected_lanes.length) {
+      issues.push({
+        field: "expected_lanes",
+        message: "expected_lanes must contain unique lane identities"
+      });
+    }
+    if (context.expected_lane && !context.expected_lanes.includes(context.expected_lane)) {
+      issues.push({
+        field: "expected_lanes",
+        message: "expected_lanes must contain expected_lane"
+      });
+    }
+  }
+  if (context.expected_micro_lanes) {
+    if (!context.expected_micro_lane) {
+      issues.push({
+        field: "expected_micro_lane",
+        message: "expected_micro_lane is required when expected_micro_lanes is supplied"
+      });
+    }
+    if (new Set(context.expected_micro_lanes).size !== context.expected_micro_lanes.length) {
+      issues.push({
+        field: "expected_micro_lanes",
+        message: "expected_micro_lanes must contain unique lane identities"
+      });
+    }
+    if (context.expected_micro_lane && !context.expected_micro_lanes.includes(context.expected_micro_lane)) {
+      issues.push({
+        field: "expected_micro_lanes",
+        message: "expected_micro_lanes must contain expected_micro_lane"
+      });
+    }
+  }
+  if (!context.expected_family && baseBound && microBound) {
+    issues.push({
+      field: "expected_family",
+      message: "base and micro ownership fields cannot be combined without one expected_family"
+    });
+  } else if (context.expected_family === "base_explorer" && microBound) {
+    issues.push({
+      field: "expected_family",
+      message: "base_explorer ownership cannot include expected_micro_lane fields"
+    });
+  } else if (context.expected_family === "micro_lane" && baseBound) {
+    issues.push({
+      field: "expected_family",
+      message: "micro_lane ownership cannot include expected_lane fields"
+    });
+  } else if (!context.expected_family && baseBound) {
+    issues.push({
+      field: "expected_family",
+      message: "base ownership fields require expected_family base_explorer"
+    });
+  } else if (!context.expected_family && microBound) {
+    issues.push({
+      field: "expected_family",
+      message: "micro ownership fields require expected_family micro_lane"
+    });
+  }
+  return issues;
+}
+function splitPipeFields(line) {
+  const fields = [];
+  let current = "";
+  for (let index = 0;index < line.length; index++) {
+    const char = line[index];
+    if (char === "\\" && index + 1 < line.length && line[index + 1] === "|") {
+      current += "|";
+      index++;
+      continue;
+    }
+    if (char === "|") {
+      fields.push(current);
+      current = "";
+      continue;
+    }
+    current += char;
+  }
+  fields.push(current);
+  return fields;
+}
+function candidateDiagnosticPreview(value) {
+  const normalized = value.replace(/[\r\n\t]+/g, " ").trim();
+  if (normalized.length <= CANDIDATE_DIAGNOSTIC_PREVIEW_CHARS)
+    return normalized;
+  return `${normalized.slice(0, CANDIDATE_DIAGNOSTIC_PREVIEW_CHARS)}...`;
+}
+function isCandidateSeverity(value) {
+  return value !== null && value !== undefined && CANDIDATE_SEVERITIES.includes(value);
+}
+function isCandidateConfidence(value) {
+  return value !== null && value !== undefined && CANDIDATE_CONFIDENCES.includes(value);
+}
+function isCandidateLookingShortRow(fields, _context, explicitCandidateMarker = false) {
+  if (explicitCandidateMarker || fields[0]?.trim() === "[CANDIDATE]")
+    return true;
+  return fields.length >= 2;
+}
+function analyzeCandidateFields(fields, family) {
+  const names = CANDIDATE_FIELDS[family];
+  const trimmed = fields.map((field) => field.trim());
+  const values = {};
+  const issues = [];
+  if (trimmed.length !== CANDIDATE_FIELD_COUNT) {
+    issues.push({
+      field: "row",
+      message: `Expected exactly ${CANDIDATE_FIELD_COUNT} candidate fields, received ${trimmed.length}`
+    });
+  }
+  for (let index = 0;index < names.length; index++) {
+    const name = names[index];
+    const value = trimmed[index]?.trim() || null;
+    values[name] = value;
+    if (value === null) {
+      issues.push({
+        field: name,
+        message: `Missing required field: ${name}`
+      });
+    }
+  }
+  const severity = values.severity;
+  if (severity !== null && !isCandidateSeverity(severity)) {
+    issues.push({
+      field: "severity",
+      message: `Invalid severity: ${candidateDiagnosticPreview(severity)}; expected ${CANDIDATE_SEVERITIES.join("|")}`
+    });
+  }
+  const confidence = values.confidence;
+  if (confidence !== null && !isCandidateConfidence(confidence)) {
+    issues.push({
+      field: "confidence",
+      message: `Invalid confidence: ${candidateDiagnosticPreview(confidence)}; expected ${CANDIDATE_CONFIDENCES.join("|")}`
+    });
+  }
+  return {
+    valid: issues.length === 0,
+    issues,
+    values,
+    candidateId: values.candidate_id,
+    workflowLane: family === "base_explorer" ? values.lane : values.micro_lane
+  };
+}
+function analyzeCleanFields(fields, family, expectedLane) {
+  const trimmed = fields.map((field) => field.trim());
+  const issues = [];
+  const laneField = family === "base_explorer" ? "lane" : "micro_lane";
+  if (trimmed.length !== CLEAN_FIELD_COUNT) {
+    issues.push({
+      field: "row",
+      message: `Expected exactly ${CLEAN_FIELD_COUNT - 1} CLEAN fields after [CLEAN], received ${Math.max(0, trimmed.length - 1)}`
+    });
+  }
+  if (trimmed[0] !== "[CLEAN]") {
+    issues.push({ field: "row", message: "CLEAN row must begin with [CLEAN]" });
+  }
+  const lane = trimmed[1] || null;
+  const coverageScope = trimmed[2] || null;
+  const evidence = trimmed[3] || null;
+  if (lane === null) {
+    issues.push({
+      field: laneField,
+      message: `Missing required field: ${laneField}`
+    });
+  } else if (expectedLane !== undefined && lane !== expectedLane) {
+    issues.push({
+      field: laneField,
+      message: `Expected ${laneField} ${candidateDiagnosticPreview(expectedLane)}, received ${candidateDiagnosticPreview(lane)}`
+    });
+  }
+  if (coverageScope === null) {
+    issues.push({
+      field: "coverage_scope",
+      message: "Missing required field: coverage_scope"
+    });
+  } else if (coverageScope.length < CLEAN_COVERAGE_SCOPE_MIN_CHARS) {
+    issues.push({
+      field: "coverage_scope",
+      message: `coverage_scope must contain at least ${CLEAN_COVERAGE_SCOPE_MIN_CHARS} characters`
+    });
+  }
+  if (evidence === null) {
+    issues.push({
+      field: "evidence",
+      message: "Missing required field: evidence"
+    });
+  } else if (evidence.length < CLEAN_EVIDENCE_MIN_CHARS) {
+    issues.push({
+      field: "evidence",
+      message: `evidence must contain at least ${CLEAN_EVIDENCE_MIN_CHARS} characters`
+    });
+  }
+  return {
+    valid: issues.length === 0,
+    issues,
+    lane,
+    coverageScope,
+    evidence
+  };
+}
+
+// src/background/candidate-parser.ts
+init_zod();
+
+// src/background/candidate-sidecar-store.ts
+init_zod();
+var import_proper_lockfile = __toESM(require_proper_lockfile(), 1);
+var SidecarEnvelopeSchema = exports_external.object({
+  record_type: exports_external.literal("invocation"),
+  source_output_ref: exports_external.string().min(1),
+  source_batch_id: exports_external.string().min(1),
+  source_lane_id: exports_external.string().min(1),
+  source_agent: exports_external.string().min(1),
+  source_digest: exports_external.string().regex(/^[a-f0-9]{64}$/),
+  row_format_version: exports_external.number().int().nonnegative(),
+  producer: exports_external.string().optional(),
+  produced_at: exports_external.string().min(1),
+  record_version: exports_external.object({
+    major: exports_external.number().int().nonnegative(),
+    minor: exports_external.number().int().nonnegative()
+  }),
+  sessionId: exports_external.string().min(1).optional(),
+  parentSessionId: exports_external.string().min(1).optional(),
+  format_families_detected: exports_external.array(exports_external.string()),
+  candidate_count: exports_external.number().int().nonnegative(),
+  parse_errors: exports_external.number().int().nonnegative(),
+  malformed_rows: exports_external.number().int().nonnegative(),
+  clean_attestation_count: exports_external.number().int().nonnegative().optional()
+}).strict();
+var SidecarCleanAttestationSchema = exports_external.discriminatedUnion("row_format_family", [
+  exports_external.object({
+    record_type: exports_external.literal("clean_attestation"),
+    row_format_family: exports_external.literal("base_explorer"),
+    row_format_version: exports_external.number().int().nonnegative(),
+    record_version: exports_external.object({
+      major: exports_external.number().int().nonnegative(),
+      minor: exports_external.number().int().nonnegative()
+    }),
+    source_output_ref: exports_external.string().min(1),
+    source_batch_id: exports_external.string().min(1),
+    source_lane_id: exports_external.string().min(1),
+    source_agent: exports_external.string().min(1),
+    source_digest: exports_external.string().regex(/^[a-f0-9]{64}$/),
+    extracted_from_partial_source: exports_external.literal(false),
+    sessionId: exports_external.string().min(1).optional(),
+    parentSessionId: exports_external.string().min(1).optional(),
+    producer: exports_external.string().optional(),
+    lane: exports_external.string().min(1),
+    coverage_scope: exports_external.string().min(CLEAN_COVERAGE_SCOPE_MIN_CHARS),
+    evidence: exports_external.string().min(CLEAN_EVIDENCE_MIN_CHARS)
+  }).strict(),
+  exports_external.object({
+    record_type: exports_external.literal("clean_attestation"),
+    row_format_family: exports_external.literal("micro_lane"),
+    row_format_version: exports_external.number().int().nonnegative(),
+    record_version: exports_external.object({
+      major: exports_external.number().int().nonnegative(),
+      minor: exports_external.number().int().nonnegative()
+    }),
+    source_output_ref: exports_external.string().min(1),
+    source_batch_id: exports_external.string().min(1),
+    source_lane_id: exports_external.string().min(1),
+    source_agent: exports_external.string().min(1),
+    source_digest: exports_external.string().regex(/^[a-f0-9]{64}$/),
+    extracted_from_partial_source: exports_external.literal(false),
+    sessionId: exports_external.string().min(1).optional(),
+    parentSessionId: exports_external.string().min(1).optional(),
+    producer: exports_external.string().optional(),
+    micro_lane: exports_external.string().min(1),
+    coverage_scope: exports_external.string().min(CLEAN_COVERAGE_SCOPE_MIN_CHARS),
+    evidence: exports_external.string().min(CLEAN_EVIDENCE_MIN_CHARS)
+  }).strict()
+]);
+var SidecarCandidateCommon = {
+  record_type: exports_external.literal("candidate"),
+  row_format_version: exports_external.number().int().nonnegative(),
+  record_version: exports_external.object({
+    major: exports_external.number().int().nonnegative(),
+    minor: exports_external.number().int().nonnegative()
+  }),
+  source_output_ref: exports_external.string().min(1),
+  source_batch_id: exports_external.string().min(1),
+  source_lane_id: exports_external.string().min(1),
+  source_agent: exports_external.string().min(1),
+  source_digest: exports_external.string().regex(/^[a-f0-9]{64}$/),
+  sessionId: exports_external.string().min(1).optional(),
+  parentSessionId: exports_external.string().min(1).optional(),
+  producer: exports_external.string().optional(),
+  extracted_from_partial_source: exports_external.boolean(),
+  candidate_id: exports_external.string().min(1),
+  severity: exports_external.enum(CANDIDATE_SEVERITIES),
+  category: exports_external.string().min(1),
+  file_line: exports_external.string().min(1),
+  claim: exports_external.string().min(1),
+  evidence_summary: exports_external.string().min(1),
+  confidence: exports_external.enum(CANDIDATE_CONFIDENCES)
+};
+var SidecarCandidateSchema = exports_external.discriminatedUnion("row_format_family", [
+  exports_external.object({
+    ...SidecarCandidateCommon,
+    row_format_family: exports_external.literal("base_explorer"),
+    lane: exports_external.string().min(1),
+    micro_lane: exports_external.null(),
+    impact_context: exports_external.string().min(1),
+    invariant_violated: exports_external.null()
+  }).strict(),
+  exports_external.object({
+    ...SidecarCandidateCommon,
+    row_format_family: exports_external.literal("micro_lane"),
+    lane: exports_external.null(),
+    micro_lane: exports_external.string().min(1),
+    impact_context: exports_external.null(),
+    invariant_violated: exports_external.string().min(1)
+  }).strict()
+]);
+
+// src/background/candidate-parser.ts
+var ArtifactInputSchema = exports_external.object({
+  output_ref: exports_external.string().min(1, "output_ref must be a non-empty string"),
+  batchId: exports_external.string().min(1, "batchId must be a non-empty string"),
+  laneId: exports_external.string().min(1, "laneId must be a non-empty string"),
+  agent: exports_external.string().min(1, "agent must be a non-empty string"),
+  role: exports_external.string().min(1, "role must be a non-empty string"),
+  sessionId: exports_external.string().min(1).optional(),
+  parentSessionId: exports_external.string().min(1).optional(),
+  digest: exports_external.string().regex(/^[a-f0-9]{64}$/, "digest must be a SHA-256 hex string"),
+  text: exports_external.string(),
+  transcriptIncomplete: exports_external.boolean().optional(),
+  artifact_status: exports_external.enum(["ok", "ref-not-found", "artifact-corrupted"]),
+  source: exports_external.enum(["dispatch_lanes", "collect_lane_results"]),
+  produced_at: exports_external.string().min(1, "produced_at must be a non-empty string")
+}).strict();
+var ParseFlagsSchema = exports_external.object({
+  accept_partial: exports_external.boolean(),
+  accept_degraded: exports_external.boolean(),
+  degraded: exports_external.boolean(),
+  row_format_version: exports_external.number().int().nonnegative(),
+  producer: exports_external.string().optional(),
+  expected_family: exports_external.enum(["base_explorer", "micro_lane"]).optional(),
+  expected_lane: exports_external.string().trim().min(1).max(120).optional(),
+  expected_lanes: exports_external.array(exports_external.string().trim().min(1).max(120)).min(1).max(11).optional(),
+  expected_micro_lane: exports_external.string().trim().min(1).max(120).optional(),
+  expected_micro_lanes: exports_external.array(exports_external.string().trim().min(1).max(120)).min(1).max(11).optional()
+}).strict().superRefine((value, context) => {
+  for (const issue of analyzeCandidateLaneContext(value)) {
+    context.addIssue({
+      code: exports_external.ZodIssueCode.custom,
+      path: [issue.field],
+      message: issue.message
+    });
+  }
+});
+var RECORD_VERSION = { major: 1, minor: 1 };
+
+class UnknownFormatFamilyError extends Error {
+  constructor() {
+    super("Unknown format family: neither impact_context nor invariant_violated present");
+    this.name = "UnknownFormatFamilyError";
+  }
+}
+function detectRowFormatFamily(rowFields) {
+  const trimmed = rowFields.map((f) => f.trim());
+  const hasImpactContext = trimmed.length > 7 && trimmed[7] !== "";
+  const hasInvariantViolated = trimmed.length > 6 && trimmed[6] !== "";
+  if (hasImpactContext && !hasInvariantViolated)
+    return "base_explorer";
+  if (hasInvariantViolated && !hasImpactContext)
+    return "micro_lane";
+  if (hasImpactContext && hasInvariantViolated)
+    return "base_explorer";
+  throw new UnknownFormatFamilyError;
+}
+function mapFields(fields, family) {
+  const trimmed = fields.map((f) => f.trim());
+  const names = CANDIDATE_FIELDS[family];
+  const result = {};
+  for (let i = 0;i < names.length; i++) {
+    result[names[i]] = i < trimmed.length && trimmed[i] !== "" ? trimmed[i] : null;
+  }
+  if (family === "base_explorer") {
+    result.micro_lane = null;
+    result.invariant_violated = null;
+  } else {
+    result.lane = null;
+    result.impact_context = null;
+  }
+  return result;
+}
+function getRequiredFields(family) {
+  return CANDIDATE_FIELDS[family];
+}
+function assertNonNullCandidateId(value) {
+  if (value === null || value === "") {
+    throw new Error("Invariant violation: null/empty candidate_id reached candidate builder");
+  }
+}
+function buildInvocationEnvelope(input, flags, formatFamiliesDetected, candidateCount, parseErrors, malformedRows, cleanAttestationCount = 0) {
+  return {
+    record_type: "invocation",
+    source_output_ref: input.output_ref,
+    source_batch_id: input.batchId,
+    source_lane_id: input.laneId,
+    source_agent: input.agent,
+    source_digest: input.digest,
+    row_format_version: flags.row_format_version,
+    sessionId: input.sessionId,
+    parentSessionId: input.parentSessionId,
+    ...flags.producer ? { producer: flags.producer } : {},
+    produced_at: input.produced_at,
+    record_version: RECORD_VERSION,
+    format_families_detected: formatFamiliesDetected,
+    candidate_count: candidateCount,
+    parse_errors: parseErrors,
+    malformed_rows: malformedRows,
+    clean_attestation_count: cleanAttestationCount
+  };
+}
+function buildEmptyDiagnostics(input, flags) {
+  return {
+    candidate_count: 0,
+    parse_errors: 0,
+    parse_error_details: [],
+    malformed_rows: 0,
+    duplicate_id_count: 0,
+    duplicate_id_warnings: [],
+    degraded_source_count: flags.degraded ? 1 : 0,
+    incomplete_source_count: input.transcriptIncomplete ? 1 : 0,
+    format_families_detected: [],
+    clean_attestation_count: 0
+  };
+}
+function refusalResult(errorCode, errorMessage, input, flags) {
+  const envelope = buildInvocationEnvelope(input, flags, [], 0, 0, 0);
+  return {
+    error: errorMessage,
+    error_code: errorCode,
+    candidates: [],
+    invocation_envelope: envelope,
+    diagnostics: buildEmptyDiagnostics(input, flags)
+  };
+}
+function detectFormatMismatchHint(text) {
+  if (text.trim() === "")
+    return;
+  const severityPattern = /\b(CRITICAL|HIGH|MEDIUM|LOW|INFO)\b/;
+  const fileLinePattern = /\b\S+\.[a-z]{1,4}:\d+\b/;
+  const hasSeverity = severityPattern.test(text);
+  const textForFileLine = text.replace(/\b\w+:\/\/\S*/g, "");
+  const hasFileLine = fileLinePattern.test(textForFileLine);
+  if (hasSeverity && hasFileLine) {
+    return "Lane output contains severity keywords and file:line references but no parseable [CANDIDATE] rows. The explorer may have emitted findings in prose format instead of pipe-delimited candidate rows.";
+  }
+  if (hasSeverity) {
+    return "Lane output contains severity keywords but no parseable [CANDIDATE] rows. The explorer may have emitted findings in an unstructured format.";
+  }
+  return;
+}
+function emptyTextResult(input, flags) {
+  const envelope = buildInvocationEnvelope(input, flags, [], 0, 0, 0);
+  const diagnostics = buildEmptyDiagnostics(input, flags);
+  const hint = detectFormatMismatchHint(input.text);
+  if (hint) {
+    diagnostics.format_mismatch_hint = hint;
+  }
+  return {
+    candidates: [],
+    invocation_envelope: envelope,
+    diagnostics
+  };
+}
+function parseCandidates(input, flags) {
+  const inputParse = ArtifactInputSchema.safeParse(input);
+  if (!inputParse.success) {
+    throw new Error(`Invalid ArtifactInput: ${inputParse.error.issues.map((issue) => issue.message).join(", ")}`);
+  }
+  const flagsParse = ParseFlagsSchema.safeParse(flags);
+  if (!flagsParse.success) {
+    throw new Error(`Invalid ParseFlags: ${flagsParse.error.issues.map((issue) => issue.message).join(", ")}`);
+  }
+  const validatedInput = inputParse.data;
+  const validatedFlags = flagsParse.data;
+  if (validatedInput.artifact_status === "ref-not-found") {
+    return refusalResult("ref-not-found", "Artifact reference not found in store", validatedInput, validatedFlags);
+  }
+  if (validatedInput.artifact_status === "artifact-corrupted") {
+    return refusalResult("artifact-corrupted", "Artifact data is corrupted", validatedInput, validatedFlags);
+  }
+  if (validatedFlags.degraded && !validatedFlags.accept_degraded) {
+    return refusalResult("degraded-source-refused", "Degraded source refused by caller", validatedInput, validatedFlags);
+  }
+  if (validatedInput.transcriptIncomplete === true && !validatedFlags.accept_partial) {
+    return refusalResult("partial-source-refused", "Partial transcript refused by caller", validatedInput, validatedFlags);
+  }
+  if (validatedInput.text.trim() === "") {
+    return emptyTextResult(validatedInput, validatedFlags);
+  }
+  return parseText(validatedInput, validatedFlags);
+}
+function parseText(input, flags) {
+  const cleanedText = removeCandidateCodeFences(input.text);
+  const lines = cleanedText.split(`
+`);
+  let headerIndex = -1;
+  let headerFields = [];
+  for (let i = 0;i < lines.length; i++) {
+    const trimmed = lines[i].trim();
+    if (trimmed === "")
+      continue;
+    const fields = splitPipeFields(trimmed);
+    if (fields.length >= 2 && fields.some((f) => f.trim() !== "")) {
+      headerIndex = i;
+      headerFields = fields.map((f) => f.trim());
+      break;
+    }
+  }
+  if (headerIndex === -1) {
+    return emptyTextResult(input, flags);
+  }
+  const headerFamily = candidateHeaderFamily(headerFields) ?? undefined;
+  if (headerFields[0] === "[CANDIDATE]" && headerFamily === undefined) {
+    return refusalResult("invalid-candidate-header", "Candidate output must begin with one exact canonical base or micro [CANDIDATE] header", input, flags);
+  }
+  if (flags.expected_family !== undefined && headerFamily !== undefined && flags.expected_family !== headerFamily) {
+    return refusalResult("expected-family-mismatch", `Expected ${flags.expected_family} rows but header declares ${headerFamily}`, input, flags);
+  }
+  const parseErrorDetails = [];
+  const candidates = [];
+  const idCounts = new Map;
+  const idFirstRows = new Map;
+  const formatFamiliesDetected = new Set;
+  let malformedRows = 0;
+  let currentCandidate = null;
+  let pendingClean;
+  let cleanErrorCode;
+  let cleanErrorMessage;
+  for (let i = headerIndex + 1;i < lines.length; i++) {
+    const rawLine = lines[i];
+    const trimmed = rawLine.trim();
+    if (trimmed === "")
+      continue;
+    let fields = splitPipeFields(trimmed);
+    if (fields[0]?.trim() === "[CLEAN]") {
+      const cleanFamily = flags.expected_family ?? headerFamily;
+      const cleanFields = fields.map((field) => field.trim());
+      const cleanLane = cleanFamily === "micro_lane" ? flags.expected_micro_lane : flags.expected_lane;
+      const cleanLanes = cleanFamily === "micro_lane" ? flags.expected_micro_lanes ?? (flags.expected_micro_lane ? [flags.expected_micro_lane] : undefined) : flags.expected_lanes ?? (flags.expected_lane ? [flags.expected_lane] : undefined);
+      if (cleanFamily !== undefined && cleanFields.length === 4 && cleanLane !== undefined && cleanFields[1] !== cleanLane && (cleanLanes ?? [cleanLane]).includes(cleanFields[1])) {
+        continue;
+      }
+      const cleanAnalysis = cleanFamily ? analyzeCleanFields(cleanFields, cleanFamily, cleanLane) : undefined;
+      if (pendingClean !== undefined) {
+        cleanErrorCode = "invalid-clean-attestation";
+        cleanErrorMessage = "Only one CLEAN attestation is allowed per artifact";
+      } else if (!cleanFamily || !cleanAnalysis) {
+        cleanErrorCode = "invalid-clean-attestation";
+        cleanErrorMessage = "CLEAN attestation is valid only for base_explorer or micro_lane output";
+      } else if (!cleanAnalysis.valid) {
+        cleanErrorCode = cleanAnalysis.issues.some((issue) => ["lane", "micro_lane"].includes(issue.field)) ? cleanFamily === "base_explorer" ? "expected-lane-mismatch" : "expected-micro-lane-mismatch" : "invalid-clean-attestation";
+        cleanErrorMessage = cleanAnalysis.issues.map((issue) => `${issue.field}: ${issue.message}`).join("; ");
+      } else if (cleanFamily === "base_explorer") {
+        pendingClean = {
+          record_type: "clean_attestation",
+          row_format_family: "base_explorer",
+          row_format_version: flags.row_format_version,
+          record_version: RECORD_VERSION,
+          source_output_ref: input.output_ref,
+          source_batch_id: input.batchId,
+          source_lane_id: input.laneId,
+          source_agent: input.agent,
+          source_digest: input.digest,
+          extracted_from_partial_source: false,
+          sessionId: input.sessionId,
+          parentSessionId: input.parentSessionId,
+          producer: flags.producer,
+          lane: cleanAnalysis.lane,
+          coverage_scope: cleanAnalysis.coverageScope,
+          evidence: cleanAnalysis.evidence
+        };
+      } else {
+        pendingClean = {
+          record_type: "clean_attestation",
+          row_format_family: "micro_lane",
+          row_format_version: flags.row_format_version,
+          record_version: RECORD_VERSION,
+          source_output_ref: input.output_ref,
+          source_batch_id: input.batchId,
+          source_lane_id: input.laneId,
+          source_agent: input.agent,
+          source_digest: input.digest,
+          extracted_from_partial_source: false,
+          sessionId: input.sessionId,
+          parentSessionId: input.parentSessionId,
+          producer: flags.producer,
+          micro_lane: cleanAnalysis.lane,
+          coverage_scope: cleanAnalysis.coverageScope,
+          evidence: cleanAnalysis.evidence
+        };
+      }
+      if (cleanErrorCode) {
+        parseErrorDetails.push({
+          row_index: i,
+          field: "clean_attestation",
+          message: cleanErrorMessage ?? "Invalid CLEAN attestation"
+        });
+        malformedRows++;
+        continue;
+      }
+      if (flags.degraded || input.transcriptIncomplete === true) {
+        cleanErrorCode = "untrusted-clean-attestation";
+        cleanErrorMessage = "CLEAN attestation cannot come from a degraded or partial artifact";
+        parseErrorDetails.push({
+          row_index: i,
+          field: "clean_attestation",
+          message: cleanErrorMessage
+        });
+        malformedRows++;
+        continue;
+      }
+      continue;
+    }
+    const hadCandidateMarker = fields[0]?.trim() === "[CANDIDATE]";
+    if (hadCandidateMarker) {
+      fields = fields.slice(1);
+    }
+    if (fields.length < CANDIDATE_FIELD_COUNT) {
+      if (isCandidateLookingShortRow(fields, flags, hadCandidateMarker)) {
+        parseErrorDetails.push({
+          row_index: i,
+          field: "row",
+          message: "Structurally short [CANDIDATE] row must be a full candidate or CLEAN attestation, not continuation text"
+        });
+        malformedRows++;
+        continue;
+      }
+      if (currentCandidate) {
+        const prev = currentCandidate.evidence_summary ?? "";
+        currentCandidate.evidence_summary = `${prev}
+${trimmed}`;
+      } else {
+        malformedRows++;
+      }
+      continue;
+    }
+    const rowFields = fields.slice(0, CANDIDATE_FIELD_COUNT);
+    let rowFamily;
+    if (flags.expected_family ?? headerFamily) {
+      rowFamily = flags.expected_family ?? headerFamily;
+    } else {
+      try {
+        rowFamily = detectRowFormatFamily(rowFields);
+      } catch (e) {
+        if (e instanceof UnknownFormatFamilyError) {
+          malformedRows++;
+          continue;
+        }
+        throw e;
+      }
+    }
+    const rowHasImpact = rowFields[7].trim() !== "";
+    const rowHasInvariant = rowFields[6].trim() !== "";
+    if (rowHasImpact && rowHasInvariant && rowFamily === "base_explorer" && flags.expected_family === undefined && headerFamily === undefined) {
+      parseErrorDetails.push({
+        row_index: i,
+        field: "row",
+        message: "Both format-family discriminators present; defaulting to base_explorer"
+      });
+    }
+    const mapped = mapFields(rowFields, rowFamily);
+    if (rowFamily === "base_explorer" && flags.expected_lane !== undefined && mapped.lane !== flags.expected_lane) {
+      if (mapped.lane !== null && (flags.expected_lanes ?? [flags.expected_lane]).includes(mapped.lane)) {
+        continue;
+      }
+      parseErrorDetails.push({
+        row_index: i,
+        field: "lane",
+        message: `Expected lane ${candidateDiagnosticPreview(flags.expected_lane)}, received ${candidateDiagnosticPreview(mapped.lane ?? "<missing>")}`
+      });
+      malformedRows++;
+      continue;
+    }
+    if (rowFamily === "micro_lane" && flags.expected_micro_lane !== undefined && mapped.micro_lane !== flags.expected_micro_lane) {
+      if (mapped.micro_lane !== null && (flags.expected_micro_lanes ?? [flags.expected_micro_lane]).includes(mapped.micro_lane)) {
+        continue;
+      }
+      parseErrorDetails.push({
+        row_index: i,
+        field: "micro_lane",
+        message: `Expected micro_lane ${candidateDiagnosticPreview(flags.expected_micro_lane)}, received ${candidateDiagnosticPreview(mapped.micro_lane ?? "<missing>")}`
+      });
+      malformedRows++;
+      continue;
+    }
+    const semanticAnalysis = analyzeCandidateFields(fields, rowFamily);
+    if (!semanticAnalysis.valid) {
+      for (const issue of semanticAnalysis.issues) {
+        parseErrorDetails.push({
+          row_index: i,
+          field: issue.field,
+          message: issue.message
+        });
+      }
+      malformedRows++;
+      continue;
+    }
+    const requiredFields = rowFamily === "base_explorer" ? getRequiredFields("base_explorer") : getRequiredFields("micro_lane");
+    let rowMalformed = false;
+    for (const field of requiredFields) {
+      const value = mapped[field];
+      if (field === "candidate_id") {
+        if (value === null || value === "") {
+          rowMalformed = true;
+          break;
+        }
+      } else if (value === null) {
+        parseErrorDetails.push({
+          row_index: i,
+          field,
+          message: `Missing required field: ${field}`
+        });
+      }
+    }
+    if (rowMalformed) {
+      malformedRows++;
+      continue;
+    }
+    assertNonNullCandidateId(mapped.candidate_id);
+    const candidateId = mapped.candidate_id;
+    const candidate = {
+      record_type: "candidate",
+      row_format_family: rowFamily,
+      row_format_version: flags.row_format_version,
+      record_version: RECORD_VERSION,
+      source_output_ref: input.output_ref,
+      source_batch_id: input.batchId,
+      source_lane_id: input.laneId,
+      source_agent: input.agent,
+      source_digest: input.digest,
+      sessionId: input.sessionId,
+      parentSessionId: input.parentSessionId,
+      producer: flags.producer,
+      extracted_from_partial_source: !!(input.transcriptIncomplete || flags.degraded),
+      candidate_id: candidateId,
+      lane: mapped.lane,
+      micro_lane: mapped.micro_lane,
+      severity: mapped.severity,
+      category: mapped.category,
+      file_line: mapped.file_line,
+      claim: mapped.claim,
+      evidence_summary: mapped.evidence_summary,
+      impact_context: mapped.impact_context,
+      invariant_violated: mapped.invariant_violated,
+      confidence: mapped.confidence
+    };
+    const cid = candidate.candidate_id;
+    idCounts.set(cid, (idCounts.get(cid) ?? 0) + 1);
+    if (!idFirstRows.has(cid)) {
+      idFirstRows.set(cid, i);
+    }
+    formatFamiliesDetected.add(rowFamily);
+    candidates.push(candidate);
+    currentCandidate = candidate;
+  }
+  const duplicateIdWarnings = [];
+  let duplicateIdCount = 0;
+  for (const [id, count] of idCounts) {
+    if (count > 1) {
+      duplicateIdCount++;
+      duplicateIdWarnings.push({
+        candidate_id: candidateDiagnosticPreview(id),
+        occurrences: count
+      });
+      parseErrorDetails.push({
+        row_index: idFirstRows.get(id) ?? -1,
+        field: "candidate_id",
+        message: `Duplicate candidate_id: "${candidateDiagnosticPreview(id)}" appears ${count} times`
+      });
+    }
+  }
+  if (pendingClean && candidates.length > 0) {
+    cleanErrorCode = "conflicting-clean-attestation";
+    cleanErrorMessage = "CLEAN attestation cannot appear with candidate rows";
+    parseErrorDetails.push({
+      row_index: headerIndex,
+      field: "clean_attestation",
+      message: cleanErrorMessage
+    });
+  }
+  if (pendingClean && !cleanErrorCode && (malformedRows > 0 || parseErrorDetails.length > 0)) {
+    cleanErrorCode = "untrusted-clean-attestation";
+    cleanErrorMessage = "CLEAN attestation requires zero malformed rows and zero parse errors";
+    parseErrorDetails.push({
+      row_index: headerIndex,
+      field: "clean_attestation",
+      message: cleanErrorMessage
+    });
+  }
+  const cleanAttestation = pendingClean && !cleanErrorCode && candidates.length === 0 ? pendingClean : undefined;
+  if (cleanAttestation) {
+    formatFamiliesDetected.add(cleanAttestation.row_format_family);
+  }
+  const acceptedCandidates = cleanErrorCode ? [] : candidates;
+  const parseErrors = parseErrorDetails.length;
+  const envelope = buildInvocationEnvelope(input, flags, Array.from(formatFamiliesDetected), acceptedCandidates.length, parseErrors, malformedRows, cleanAttestation ? 1 : 0);
+  const diagnostics = {
+    candidate_count: acceptedCandidates.length,
+    parse_errors: parseErrors,
+    parse_error_details: parseErrorDetails,
+    malformed_rows: malformedRows,
+    duplicate_id_count: duplicateIdCount,
+    duplicate_id_warnings: duplicateIdWarnings,
+    degraded_source_count: flags.degraded ? 1 : 0,
+    incomplete_source_count: input.transcriptIncomplete ? 1 : 0,
+    format_families_detected: Array.from(formatFamiliesDetected),
+    clean_attestation_count: cleanAttestation ? 1 : 0
+  };
+  if (acceptedCandidates.length === 0 && !cleanAttestation) {
+    const hint = detectFormatMismatchHint(input.text);
+    if (hint) {
+      diagnostics.format_mismatch_hint = hint;
+    }
+  }
+  return {
+    ...cleanErrorCode ? {
+      error: cleanErrorMessage ?? "Invalid CLEAN attestation",
+      error_code: cleanErrorCode
+    } : {},
+    candidates: acceptedCandidates,
+    ...cleanAttestation ? { clean_attestation: cleanAttestation } : {},
+    invocation_envelope: envelope,
+    diagnostics
+  };
+}
+
 // src/background/lane-output-store.ts
 init_zod();
 import { createHash } from "crypto";
@@ -418,6 +1328,167 @@ function digestText(text) {
   return createHash("sha256").update(text).digest("hex");
 }
 
+// src/background/pr-review-trigger-contract.ts
+init_zod();
+var PR_REVIEW_TRIGGER_DEFINITIONS = [
+  {
+    id: "auth-identity-secrets",
+    scope: "universal",
+    trigger_row: "authentication, authorization, identity, sessions, permissions, secrets, cryptography",
+    micro_lane: "Identity and secret boundaries"
+  },
+  {
+    id: "untrusted-input-boundaries",
+    scope: "universal",
+    trigger_row: "parsing, serialization, queries, templates/rendering, file or network input/output",
+    micro_lane: "Untrusted input and sink analysis"
+  },
+  {
+    id: "subprocess-platform",
+    scope: "universal",
+    trigger_row: "subprocesses, shell commands, filesystem operations, OS/runtime-specific code",
+    micro_lane: "Subprocess and platform safety"
+  },
+  {
+    id: "concurrency-state",
+    scope: "universal",
+    trigger_row: "queues, caches, retries, transactions, locks, state machines, async coordination",
+    micro_lane: "Concurrency and state transitions"
+  },
+  {
+    id: "dependencies-build-release",
+    scope: "universal",
+    trigger_row: "dependency manifests, lockfiles, installers, build scripts, CI, packaging, deployment",
+    micro_lane: "Dependency and delivery integrity"
+  },
+  {
+    id: "api-schema-migrations",
+    scope: "universal",
+    trigger_row: "public API, wire/schema/config/storage formats, migrations, feature flags",
+    micro_lane: "Compatibility and migration safety"
+  },
+  {
+    id: "test-infrastructure",
+    scope: "universal",
+    trigger_row: "tests, mocks, fixtures, harnesses, coverage, CI matrices",
+    micro_lane: "Test validity and isolation"
+  },
+  {
+    id: "ui-accessibility-i18n",
+    scope: "universal",
+    trigger_row: "user interfaces, interaction flows, rendering, accessibility, localization",
+    micro_lane: "UI and human-interface quality"
+  },
+  {
+    id: "privacy-observability",
+    scope: "universal",
+    trigger_row: "telemetry, logs, analytics, traces, retention, diagnostics",
+    micro_lane: "Privacy and observability safety"
+  },
+  {
+    id: "generated-provenance",
+    scope: "universal",
+    trigger_row: "generated, vendored, binary, model-produced, codegen or checked-in build artifacts",
+    micro_lane: "Generated artifact provenance"
+  },
+  {
+    id: "unclassified-risk",
+    scope: "universal",
+    trigger_row: "any changed artifact or behavior not confidently classified by the rows above",
+    micro_lane: "Unclassified high-risk fallback"
+  }
+];
+var PR_REVIEW_REQUIRED_TRIGGER_IDS = PR_REVIEW_TRIGGER_DEFINITIONS.map((definition) => definition.id);
+var TriggerIdSchema = exports_external.enum(PR_REVIEW_REQUIRED_TRIGGER_IDS, { error: "unknown PR_REVIEW trigger_id" });
+var TriggerEvidenceSchema = exports_external.string().trim().min(1).max(4000);
+var PrReviewInlineTriggerRowSchema = exports_external.discriminatedUnion("result", [
+  exports_external.object({
+    trigger_id: TriggerIdSchema,
+    result: exports_external.literal("MATCHED"),
+    evidence: TriggerEvidenceSchema
+  }).strict(),
+  exports_external.object({
+    trigger_id: TriggerIdSchema,
+    result: exports_external.literal("NOT_TRIGGERED"),
+    evidence: TriggerEvidenceSchema
+  }).strict()
+]);
+var PrReviewPersistedInputRowSchema = exports_external.discriminatedUnion("result", [
+  exports_external.object({
+    trigger_id: TriggerIdSchema,
+    result: exports_external.literal("MATCHED"),
+    evidence: TriggerEvidenceSchema,
+    source_batch_id: exports_external.string().trim().min(1),
+    source_lane_id: exports_external.string().trim().min(1)
+  }).strict(),
+  exports_external.object({
+    trigger_id: TriggerIdSchema,
+    result: exports_external.literal("NOT_TRIGGERED"),
+    evidence: TriggerEvidenceSchema
+  }).strict()
+]);
+var TriggerDefinitionFieldShape = {
+  scope: exports_external.literal("universal"),
+  trigger_row: exports_external.string().trim().min(1),
+  micro_lane: exports_external.string().trim().min(1)
+};
+var V2MatchedRowSchema = exports_external.object({
+  trigger_id: TriggerIdSchema,
+  ...TriggerDefinitionFieldShape,
+  result: exports_external.literal("MATCHED"),
+  evidence: TriggerEvidenceSchema,
+  source_batch_id: exports_external.string().trim().min(1),
+  source_lane_id: exports_external.string().trim().min(1)
+}).strict();
+var V2NotTriggeredRowSchema = exports_external.object({
+  trigger_id: TriggerIdSchema,
+  ...TriggerDefinitionFieldShape,
+  result: exports_external.literal("NOT_TRIGGERED"),
+  evidence: TriggerEvidenceSchema
+}).strict();
+var V2RowSchema = exports_external.union([V2MatchedRowSchema, V2NotTriggeredRowSchema]);
+var ReceiptEnvelopeSchema = exports_external.object({
+  run_id: exports_external.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/),
+  pr_head_sha: exports_external.string().trim().regex(/^[0-9a-f]{6,64}$/i),
+  base_ref: exports_external.string().trim().regex(/^(?!-)[A-Za-z0-9][A-Za-z0-9._/-]{0,255}$/),
+  base_sha: exports_external.string().trim().regex(/^[0-9a-f]{6,64}$/i),
+  evaluated_at: exports_external.string().datetime(),
+  dispatched_micro_lane_count: exports_external.number().int().min(1)
+});
+var V2ReceiptSchema = ReceiptEnvelopeSchema.extend({
+  schema_version: exports_external.literal(2),
+  trigger_count: exports_external.number().int().min(0),
+  matched_count: exports_external.number().int().min(0),
+  not_triggered_count: exports_external.number().int().min(0),
+  no_match_count: exports_external.number().int().min(0),
+  rows: exports_external.array(V2RowSchema)
+}).strict();
+var LegacyRowFieldShape = {
+  trigger_id: TriggerIdSchema,
+  result: exports_external.literal("MATCHED"),
+  evidence: TriggerEvidenceSchema,
+  source_batch_id: exports_external.string().trim().min(1),
+  source_lane_id: exports_external.string().trim().min(1)
+};
+var LegacyBasicRowSchema = exports_external.object(LegacyRowFieldShape).strict();
+var LegacyFullRowSchema = exports_external.object({
+  trigger_id: TriggerIdSchema,
+  ...TriggerDefinitionFieldShape,
+  result: exports_external.literal("MATCHED"),
+  evidence: TriggerEvidenceSchema,
+  source_batch_id: exports_external.string().trim().min(1),
+  source_lane_id: exports_external.string().trim().min(1)
+}).strict();
+var LegacyRowSchema = exports_external.union([LegacyBasicRowSchema, LegacyFullRowSchema]);
+var V1ReceiptSchema = ReceiptEnvelopeSchema.extend({
+  schema_version: exports_external.literal(1),
+  trigger_count: exports_external.number().int().min(0),
+  matched_count: exports_external.number().int().min(0),
+  no_match_count: exports_external.number().int().min(0),
+  rows: exports_external.array(LegacyRowSchema)
+}).strict();
+var UnversionedRowOnlyReceiptSchema = exports_external.object({ rows: exports_external.array(exports_external.unknown()) }).strict();
+
 // src/hooks/pr-workflow-gate.ts
 init_constants();
 init_schema();
@@ -843,19 +1914,7 @@ var PR_REVIEW_BASE_DIMENSION_IDS = [
   "reliability-performance",
   "compatibility-delivery"
 ];
-var PR_REVIEW_REQUIRED_MICRO_LANE_IDS = [
-  "auth-identity-secrets",
-  "untrusted-input-boundaries",
-  "subprocess-platform",
-  "concurrency-state",
-  "dependencies-build-release",
-  "api-schema-migrations",
-  "test-infrastructure",
-  "ui-accessibility-i18n",
-  "privacy-observability",
-  "generated-provenance",
-  "unclassified-risk"
-];
+var PR_REVIEW_REQUIRED_MICRO_LANE_IDS = PR_REVIEW_REQUIRED_TRIGGER_IDS;
 var PR_REVIEW_BASE_LANE_FLOORS = {
   S: 1,
   M: 3,
@@ -874,9 +1933,16 @@ var RENAME_RETRY_DELAY_MS = 10;
 var STATE_MUTATION_LOCK_MAX_ATTEMPTS = 50;
 var STATE_MUTATION_LOCK_RETRY_DELAY_MS = 10;
 var STATE_MUTATION_LOCK_UNINITIALIZED_STALE_MS = 30000;
+var MAX_COMPLETED_CHECKOUT_LOCK_OWNERS = 64;
+var CHECKOUT_MUTATION_ACTION_TIMEOUT_MS = 5 * 60000;
+var MAX_CANDIDATE_ISSUES_PER_ARTIFACT = 8;
+var MAX_BASE_COVERAGE_DIAGNOSTICS = 8;
+var MAX_BASE_COVERAGE_DIAGNOSTIC_CHARS = 1000;
 var WORKFLOW_GATE_DIR = "pr-workflow-gates";
 var trackedStatesByProjectSession = new Map;
 var pendingStateMutationsByProjectSession = new Map;
+var pendingCheckoutMutationsByProject = new Map;
+var completedCheckoutLockOwners = new Map;
 var PrReviewBaseDimensionIdSchema = exports_external.enum([
   "intent-architecture",
   "correctness-state",
@@ -1027,6 +2093,7 @@ var PrWorkflowGateStateSchema = exports_external.object({
   }).strict().optional(),
   prReviewBaseDispatches: exports_external.array(PrReviewBaseDispatchRecordSchema).max(MAX_WORKFLOW_BATCHES).optional(),
   prReviewBaseDispatch: PrReviewBaseDispatchRecordSchema.optional(),
+  prReviewTriggerLedger: exports_external.array(PrReviewInlineTriggerRowSchema).length(PR_REVIEW_REQUIRED_TRIGGER_IDS.length).optional(),
   prReviewTriggerEvalPath: exports_external.string().min(1).optional(),
   prReviewValidationBatches: exports_external.array(PrReviewValidationBatchRecordSchema).max(MAX_WORKFLOW_BATCHES).optional(),
   prReviewArtifactRunId: exports_external.string().min(1).optional(),
@@ -1088,7 +2155,7 @@ async function activatePrWorkflow(directory, sessionID, mode, options = {}) {
       throw new Error(formatCheckoutRecoveryBlock(checkoutState));
     }
   }
-  const initialHead = options.prHeadSha ? await assertCurrentCheckoutHead(directory, options.prHeadSha) : undefined;
+  const initialHead = options.prHeadSha ? await assertCurrentCheckoutHead(directory, options.prHeadSha, mode) : undefined;
   const timestamp = isoNow();
   const feedbackTargetUrl = mode === "PR_FEEDBACK" && options.prUrl ? canonicalGitHubPrUrl(options.prUrl) ? options.prUrl : null : undefined;
   if (feedbackTargetUrl === null) {
@@ -1175,35 +2242,46 @@ async function abortPrWorkflow(directory, sessionID, options = {}) {
   };
 }
 async function bindPrWorkflowHead(directory, sessionID, prHeadSha) {
-  const state = await requireAnyActiveState(directory, sessionID);
   const normalizedHead = normalizePrHeadSha(prHeadSha);
-  await assertCurrentCheckoutHead(directory, normalizedHead);
-  if (!state.prHeadSha)
-    await assertPrReviewCleanCheckout(directory, state.mode);
-  if (!state.prHeadSha && state.mode === "PR_FEEDBACK") {
-    await assertPrFeedbackTrackingCheckout(directory, normalizedHead);
-  }
-  if (state.prHeadSha && state.prHeadSha !== normalizedHead) {
-    throw new Error(`BLOCKED: active ${state.mode} workflow is bound to PR head "${state.prHeadSha}"; received "${normalizedHead}"`);
-  }
-  if (state.prHeadSha === normalizedHead)
-    return state;
-  const nextState = {
-    ...state,
-    prHeadSha: normalizedHead,
-    updatedAt: isoNow()
-  };
-  await persistState(directory, nextState);
-  return nextState;
+  return withPrWorkflowCheckoutMutationLock(directory, async () => withSessionStateMutation(directory, normalizeSessionID(sessionID), async () => {
+    const state = await readPrWorkflowGateStateFromDisk(directory, normalizeSessionID(sessionID));
+    if (!state) {
+      throw new Error(`BLOCKED: no active PR workflow gate for session "${normalizeSessionID(sessionID)}". ` + "The gate must be activated before the PR head can be bound.");
+    }
+    await assertCurrentCheckoutHead(directory, normalizedHead, state.mode);
+    if (state.prHeadSha && state.prHeadSha !== normalizedHead) {
+      throw new Error(`BLOCKED: active ${state.mode} workflow is bound to PR head "${state.prHeadSha}"; received "${normalizedHead}"`);
+    }
+    if (!state.prHeadSha) {
+      await assertPrReviewCleanCheckout(directory, state.mode);
+    }
+    if (!state.prHeadSha && state.mode === "PR_FEEDBACK") {
+      await assertPrFeedbackTrackingCheckout(directory, normalizedHead);
+    }
+    if (state.prHeadSha === normalizedHead) {
+      if (state.mode === "PR_FEEDBACK") {
+        await assertPrFeedbackTrackingCheckout(directory, normalizedHead);
+      }
+      return state;
+    }
+    const nextState = {
+      ...state,
+      prHeadSha: normalizedHead,
+      updatedAt: isoNow()
+    };
+    await _test_exports.beforePrFeedbackTrackingPersist?.();
+    return writeStateWhileLocked(directory, nextState);
+  }));
 }
-async function assertCurrentCheckoutHead(directory, expectedHead) {
+async function assertCurrentCheckoutHead(directory, expectedHead, mode = "PR_REVIEW") {
   const normalizedExpected = normalizePrHeadSha(expectedHead);
   const currentHead = (await _test_exports.resolveCurrentGitHeadAsync(directory))?.trim();
   if (!currentHead) {
     throw new Error(`BLOCKED: cannot resolve the current Git HEAD in "${directory}" to verify against PR head "${normalizedExpected}". ` + `This means Git could not resolve HEAD (the working directory may not be a Git repository, ` + `HEAD may be unborn, the commit object may be missing in a shallow clone, the Git binary may not be on PATH, ` + `or the bounded Git invocation may have timed out). ` + `Verify with: git -C "${directory}" rev-parse --verify HEAD^{commit}`);
   }
   if (currentHead.toLowerCase() !== normalizedExpected.toLowerCase()) {
-    throw new Error(`BLOCKED: current checkout HEAD "${currentHead}" does not match PR head "${normalizedExpected}" ` + `(working directory: "${directory}"). ` + `Run these bare, standalone commands from that directory: if the commit is not present locally, ` + `\`git fetch origin <pr-head-ref>\`; then \`git switch --detach ${normalizedExpected}\`. ` + `Do not prefix the switch with \`git -C\`; the read-only shell classifier refuses \`git -C ... switch\`.`);
+    const remediation = mode === "PR_FEEDBACK" ? "Check out the intended local tracking branch at that exact head (for example with a safe standalone `gh pr checkout <number-or-url>` or `git switch -c <local> --track <remote>/<branch>`), then retry the bind. Do not create a new detached feedback checkout." : `Run these bare, standalone commands from that directory: if the commit is not present locally, \`git fetch origin <pr-head-ref>\`; then \`git switch --detach ${normalizedExpected}\`. Do not prefix the switch with \`git -C\`; the read-only shell classifier refuses \`git -C ... switch\`.`;
+    throw new Error(`BLOCKED: current checkout HEAD "${currentHead}" does not match PR head "${normalizedExpected}" ` + `(working directory: "${directory}"). ${remediation}`);
   }
   return normalizedExpected;
 }
@@ -1213,13 +2291,62 @@ async function assertPrReviewCleanCheckout(directory, mode = "PR_REVIEW") {
   }
 }
 async function assertPrFeedbackTrackingCheckout(directory, prHeadSha) {
-  const upstream = await _test_exports.resolveCurrentUpstreamPushTargetAsync(directory);
-  if (!upstream) {
-    throw new Error("BLOCKED: PR_FEEDBACK requires a current local branch bound to an exact remote name, remote branch ref, and remote-tracking ref before the first head bind; detached or non-tracking checkouts are not allowed");
+  const currentHead = (await _test_exports.resolveCurrentGitHeadAsync(directory))?.trim();
+  if (!currentHead) {
+    throw new Error("BLOCKED: PR_FEEDBACK requires a resolved exact Git HEAD before first head bind");
   }
+  if (currentHead.toLowerCase() !== prHeadSha.toLowerCase()) {
+    throw new Error(`BLOCKED: PR_FEEDBACK exact head changed before attach; expected ${prHeadSha}, received ${currentHead}`);
+  }
+  const currentUpstream = await _test_exports.resolveCurrentUpstreamPushTargetAsync(directory);
   const matchingRemoteRefs = await _test_exports.resolveRemoteRefsContainingHeadAsync(directory, prHeadSha);
-  if (!matchingRemoteRefs?.includes(upstream.remoteTrackingRef)) {
-    throw new Error(`BLOCKED: PR_FEEDBACK upstream "${upstream.remoteTrackingRef}" must point to the exact intake PR head "${prHeadSha}" before the first head bind`);
+  if (currentUpstream) {
+    if (matchingRemoteRefs === null) {
+      throw new Error("BLOCKED: PR_FEEDBACK could not verify the current upstream against the exact intake PR head; the bounded Git query failed or timed out");
+    }
+    if (matchingRemoteRefs.includes(currentUpstream.remoteTrackingRef))
+      return;
+    throw new Error(`BLOCKED: PR_FEEDBACK current upstream "${currentUpstream.remoteTrackingRef}" must point to the exact intake PR head "${prHeadSha}"; refusing to replace an existing tracking relationship`);
+  }
+  const candidates = await resolvePrFeedbackTrackingCandidatesAsync(directory, prHeadSha);
+  if (!candidates) {
+    throw new Error(`BLOCKED: PR_FEEDBACK could not inspect tracked branches for exact PR head "${prHeadSha}"; the bounded Git query failed or timed out`);
+  }
+  const { local: localCandidates, remote: remoteCandidates } = candidates;
+  if (localCandidates.length === 1) {
+    await _test_exports.beforePrFeedbackTrackingSwitch?.();
+    if (!await switchPrFeedbackTrackingCandidateAsync(directory, localCandidates[0])) {
+      throw new Error(`BLOCKED: PR_FEEDBACK could not attach exact local tracked branch "${localCandidates[0].branchName}"; it may be checked out in another linked worktree or the bounded Git switch failed`);
+    }
+  } else if (localCandidates.length > 1) {
+    throw new Error(`BLOCKED: PR_FEEDBACK exact head "${prHeadSha}" matches multiple local tracked branches: ${localCandidates.map((candidate) => candidate.branchName).join(", ")}`);
+  } else {
+    if (remoteCandidates.length === 1) {
+      await _test_exports.beforePrFeedbackTrackingSwitch?.();
+      if (!await switchPrFeedbackTrackingCandidateAsync(directory, remoteCandidates[0])) {
+        throw new Error(`BLOCKED: PR_FEEDBACK could not attach exact remote-tracking branch "${remoteCandidates[0].remoteTrackingRef}"; the bounded Git switch failed or timed out`);
+      }
+    } else if (remoteCandidates.length > 1) {
+      throw new Error(`BLOCKED: PR_FEEDBACK exact head "${prHeadSha}" matches multiple remote-tracking refs: ${remoteCandidates.map((candidate) => candidate.remoteTrackingRef).join(", ")}`);
+    } else {
+      throw new Error("BLOCKED: PR_FEEDBACK requires a current local branch or exact remote-tracking ref that points to the intake PR head before the first bind");
+    }
+  }
+  await _test_exports.afterPrFeedbackTrackingSwitch?.();
+  const attachedHead = (await _test_exports.resolveCurrentGitHeadAsync(directory))?.trim();
+  if (attachedHead?.toLowerCase() !== prHeadSha.toLowerCase()) {
+    throw new Error(`BLOCKED: PR_FEEDBACK exact head changed after attach; expected ${prHeadSha}, received ${attachedHead ?? "(unresolved)"}`);
+  }
+  if (await _test_exports.resolveIsWorkingTreeCleanAsync(directory) !== true) {
+    throw new Error("BLOCKED: PR_FEEDBACK requires a clean working tree after checkout attachment");
+  }
+  const attachedUpstream = await _test_exports.resolveCurrentUpstreamPushTargetAsync(directory);
+  if (!attachedUpstream) {
+    throw new Error("BLOCKED: PR_FEEDBACK could not resolve the attached branch upstream after checkout promotion");
+  }
+  const attachedRemoteRefs = await _test_exports.resolveRemoteRefsContainingHeadAsync(directory, prHeadSha);
+  if (!attachedRemoteRefs?.includes(attachedUpstream.remoteTrackingRef)) {
+    throw new Error(`BLOCKED: PR_FEEDBACK upstream "${attachedUpstream.remoteTrackingRef}" must point to the exact intake PR head "${prHeadSha}" before the first head bind`);
   }
 }
 async function assertPrReviewBaseCoverageSettled(directory, sessionID) {
@@ -1229,15 +2356,16 @@ async function assertPrReviewBaseCoverageSettled(directory, sessionID) {
     throw new Error("BLOCKED: PR_REVIEW requires at least one base batch");
   }
   const covered = new Set;
+  const malformedDiagnostics = [];
   for (const batch of batches) {
-    const successful = successfulObligationsFromExactBatch(directory, state, batch.batchId, batch.lanes, "swarm-pr-review:base", batch.validatedAt);
+    const successful = successfulObligationsFromExactBatch(directory, state, batch.batchId, batch.lanes, "swarm-pr-review:base", batch.validatedAt, true, new Set, undefined, malformedDiagnostics);
     for (const obligation of successful) {
       covered.add(obligation);
     }
   }
   const missing = PR_REVIEW_BASE_DIMENSION_IDS.filter((dimension) => !covered.has(dimension));
   if (missing.length > 0 || covered.size !== PR_REVIEW_BASE_DIMENSION_IDS.length) {
-    throw new Error(`BLOCKED: PR_REVIEW base coverage is incomplete; missing dimensions: ${missing.join(", ") || "(none)"}`);
+    throw new Error(`BLOCKED: PR_REVIEW base coverage is incomplete; missing dimensions: ${missing.join(", ") || "(none)"}${malformedDiagnostics.length > 0 ? `; malformed candidate diagnostics: ${malformedDiagnostics.join(" | ")}` : ""}`);
   }
   return state;
 }
@@ -1607,24 +2735,42 @@ async function transitionPrReviewToFeedback(directory, sessionID, request) {
 var _test_exports = {
   workflowGateStateRelativePath,
   workflowGateStateLockRelativePath,
+  workflowCheckoutMutationLockRelativePath,
+  withPrWorkflowCheckoutMutationLock,
   resetTrackedStateCache: () => {
     trackedStatesByProjectSession.clear();
     pendingStateMutationsByProjectSession.clear();
+    pendingCheckoutMutationsByProject.clear();
+    completedCheckoutLockOwners.clear();
     _test_exports.beforeTerminalClear = undefined;
     _test_exports.beforePrFeedbackTransitionLock = undefined;
+    _test_exports.beforePrFeedbackTrackingSwitch = undefined;
+    _test_exports.afterPrFeedbackTrackingSwitch = undefined;
+    _test_exports.beforePrFeedbackTrackingPersist = undefined;
     _test_exports.beforeBoundedSwarmFileOpen = undefined;
     _test_exports.beforeSessionStateLockWrite = undefined;
+    _test_exports.beforeCheckoutLockWrite = undefined;
     _test_exports.beforeSafeDirectoryCreate = undefined;
     _test_exports.beforeAtomicTempWrite = undefined;
     _test_exports.beforeAtomicRename = undefined;
+    _test_exports.openCheckoutLock = openCheckoutLockFile;
+    _test_exports.removeCheckoutLock = removeCheckoutLockFile;
+    _test_exports.checkoutMutationActionTimeoutMs = CHECKOUT_MUTATION_ACTION_TIMEOUT_MS;
   },
   beforeTerminalClear: undefined,
   beforePrFeedbackTransitionLock: undefined,
+  beforePrFeedbackTrackingSwitch: undefined,
+  afterPrFeedbackTrackingSwitch: undefined,
+  beforePrFeedbackTrackingPersist: undefined,
   beforeBoundedSwarmFileOpen: undefined,
   beforeSessionStateLockWrite: undefined,
+  beforeCheckoutLockWrite: undefined,
   beforeSafeDirectoryCreate: undefined,
   beforeAtomicTempWrite: undefined,
   beforeAtomicRename: undefined,
+  openCheckoutLock: openCheckoutLockFile,
+  removeCheckoutLock: removeCheckoutLockFile,
+  checkoutMutationActionTimeoutMs: CHECKOUT_MUTATION_ACTION_TIMEOUT_MS,
   resolveCurrentGitHead,
   resolveCurrentGitHeadAsync,
   resolveCurrentUpstreamPushTarget,
@@ -1665,7 +2811,7 @@ async function requireBoundState(directory, sessionID, expectedMode) {
     throw new Error(`BLOCKED: active ${expectedMode} workflow is not bound to a PR head`);
   }
   if (expectedMode === "PR_REVIEW") {
-    await assertCurrentCheckoutHead(directory, state.prHeadSha);
+    await assertCurrentCheckoutHead(directory, state.prHeadSha, "PR_REVIEW");
     await assertPrReviewCleanCheckout(directory);
   }
   return state;
@@ -1727,6 +2873,15 @@ function normalizePrHeadSha(prHeadSha) {
 function sameStringArray(left, right) {
   return left.length === right.length && left.every((value, index) => value === right[index]);
 }
+function appendBoundedCandidateIssue(issues, message) {
+  if (issues.length < MAX_CANDIDATE_ISSUES_PER_ARTIFACT - 1) {
+    issues.push(message.slice(0, MAX_BASE_COVERAGE_DIAGNOSTIC_CHARS));
+    return;
+  }
+  if (issues.length === MAX_CANDIDATE_ISSUES_PER_ARTIFACT - 1) {
+    issues.push("additional malformed candidate diagnostics omitted");
+  }
+}
 function derivePrReviewCriticInventory(directory, state) {
   const verdicts = deriveLatestPrReviewReviewerVerdicts(directory, state);
   return [...verdicts.entries()].filter(([, verdict]) => verdict.classification === "CONFIRMED" && ["CRITICAL", "HIGH", "MEDIUM"].includes(verdict.severity)).map(([itemId]) => itemId).sort();
@@ -1760,7 +2915,7 @@ function deriveLatestPrReviewReviewerVerdicts(directory, state) {
   }
   return new Map;
 }
-function successfulObligationsFromExactBatch(directory, state, batchId, expectedLanes, expectedMode, validatedAt, checkWorkflowLane = true, forbiddenSubagentSessionIds = new Set, expectedRevisionDigest) {
+function successfulObligationsFromExactBatch(directory, state, batchId, expectedLanes, expectedMode, validatedAt, checkWorkflowLane = true, forbiddenSubagentSessionIds = new Set, expectedRevisionDigest, diagnostics) {
   const records = findByBatchId(directory, batchId, {
     parentSessionId: state.sessionID
   });
@@ -1787,7 +2942,7 @@ function successfulObligationsFromExactBatch(directory, state, batchId, expected
     const expectedWorkflowLane = expectedLane?.workflowLane;
     const expectedOwnedLanes = expectedLane?.ownedWorkflowLanes?.length ? expectedLane.ownedWorkflowLanes : expectedWorkflowLane !== undefined ? [expectedWorkflowLane] : undefined;
     const subagentSessionId = record.subagentSessionId?.trim();
-    if (expectedWorkflowLane !== undefined && expectedOwnedLanes !== undefined && record.laneId !== undefined && recordCountByLaneId.get(record.laneId) === 1 && Boolean(subagentSessionId) && recordCountBySubagentSessionId.get(subagentSessionId) === 1 && !forbiddenSubagentSessionIds.has(subagentSessionId) && record.createdAt >= validatedAtMs && (!checkWorkflowLane || record.workflowLane === expectedWorkflowLane) && (!checkWorkflowLane || ownedLaneSetsEqual(record.ownedWorkflowLanes, expectedOwnedLanes)) && record.mode === expectedMode && record.workspace?.prHeadSha === state.prHeadSha && record.workspace?.gitHead === state.prHeadSha && record.status === "completed" && record.result?.outputDegraded !== true && record.result?.transcriptIncomplete !== true && record.result?.truncated !== true && (record.result?.chars ?? 0) > 0 && Boolean(record.result?.digest?.trim()) && Boolean(record.result?.outputRef?.trim()) && workflowArtifactHasContractMarker(directory, state, record, expectedMode, expectedWorkflowLane, expectedLane?.reviewItemIds, expectedRevisionDigest, expectedOwnedLanes)) {
+    if (expectedWorkflowLane !== undefined && expectedOwnedLanes !== undefined && record.laneId !== undefined && recordCountByLaneId.get(record.laneId) === 1 && Boolean(subagentSessionId) && recordCountBySubagentSessionId.get(subagentSessionId) === 1 && !forbiddenSubagentSessionIds.has(subagentSessionId) && record.createdAt >= validatedAtMs && (!checkWorkflowLane || record.workflowLane === expectedWorkflowLane) && (!checkWorkflowLane || ownedLaneSetsEqual(record.ownedWorkflowLanes, expectedOwnedLanes)) && record.mode === expectedMode && record.workspace?.prHeadSha === state.prHeadSha && record.workspace?.gitHead === state.prHeadSha && record.status === "completed" && record.result?.outputDegraded !== true && record.result?.transcriptIncomplete !== true && record.result?.truncated !== true && (record.result?.chars ?? 0) > 0 && Boolean(record.result?.digest?.trim()) && Boolean(record.result?.outputRef?.trim()) && workflowArtifactHasContractMarker(directory, state, record, expectedMode, expectedWorkflowLane, expectedLane?.reviewItemIds, expectedRevisionDigest, expectedOwnedLanes, diagnostics)) {
       for (const obligation of expectedOwnedLanes) {
         successful.add(obligation);
       }
@@ -1806,7 +2961,7 @@ function ownedLaneSetsEqual(recordOwned, expectedOwned) {
   }
   return recordOwned.every((owned) => expectedSet.has(owned));
 }
-function workflowArtifactHasContractMarker(directory, state, record, expectedMode, expectedWorkflowLane, reviewItemIds, expectedRevisionDigest, ownedWorkflowLanes) {
+function workflowArtifactHasContractMarker(directory, state, record, expectedMode, expectedWorkflowLane, reviewItemIds, expectedRevisionDigest, ownedWorkflowLanes, diagnostics) {
   const ref = record.result?.outputRef?.trim();
   if (!ref)
     return false;
@@ -1841,13 +2996,25 @@ function workflowArtifactHasContractMarker(directory, state, record, expectedMod
     return Boolean(reviewItemIds?.length && reviewItemIds.every((itemId) => artifactHasExactPositiveVerdictRow(artifact.text, feedbackVerdict[0], itemId, feedbackVerdict[1])));
   }
   const coveredLanes = ownedWorkflowLanes?.length ? ownedWorkflowLanes : [expectedWorkflowLane];
-  if (!coveredLanes.every((coveredLane) => prReviewDiscoveryArtifactCoversLane(artifact.text, coveredLane))) {
+  const coverageAnalyses = coveredLanes.map((coveredLane) => ({
+    coveredLane,
+    analysis: analyzePrReviewDiscoveryArtifact(artifact.text, coveredLane, coveredLanes)
+  }));
+  if (coverageAnalyses.some(({ analysis }) => !analysis.covered)) {
+    for (const { coveredLane, analysis } of coverageAnalyses) {
+      if (analysis.covered || analysis.issues.length === 0)
+        continue;
+      if (diagnostics && diagnostics.length < MAX_BASE_COVERAGE_DIAGNOSTICS) {
+        const diagnostic = `batch=${record.batchId ?? "(missing)"} lane=${record.laneId ?? "(missing)"} workflow_lane=${coveredLane} output_ref=${ref} digest=${record.result?.digest ?? "(missing)"}: ${analysis.issues.join("; ")}`;
+        diagnostics.push(diagnostic.slice(0, MAX_BASE_COVERAGE_DIAGNOSTIC_CHARS));
+      }
+    }
     return false;
   }
   if (coveredLanes.length > 1) {
     const seenEvidence = new Map;
     for (const coveredLane of coveredLanes) {
-      const evidence2 = extractLaneCoverageEvidenceText(artifact.text, coveredLane);
+      const evidence2 = extractLaneCoverageEvidenceText(artifact.text, coveredLane, coveredLanes);
       if (evidence2 === null)
         continue;
       const priorLane = seenEvidence.get(evidence2);
@@ -1858,51 +3025,78 @@ function workflowArtifactHasContractMarker(directory, state, record, expectedMod
   }
   return true;
 }
-function prReviewDiscoveryArtifactCoversLane(text, expectedWorkflowLane) {
-  const lines = text.split(/\r?\n/);
-  let candidateHeaderSeen = false;
-  for (const line of lines) {
-    const fields = pipeFields(line);
-    if (fields.length === 0)
-      continue;
-    if (fields[0] === "[CLEAN]" && fields.length >= 4 && fields[1] === expectedWorkflowLane && fields.slice(1, 4).every(Boolean) && fields[2].length >= 12 && fields[3].length >= 20)
-      return true;
-    if (fields[0] === "[CANDIDATE]") {
-      if (fields[1]?.toLowerCase() === "candidate_id") {
-        candidateHeaderSeen = true;
-        continue;
-      }
-      if (fields.length >= 10 && fields[2] === expectedWorkflowLane && fields.slice(1, 10).every(Boolean))
-        return true;
-      continue;
+function analyzePrReviewDiscoveryArtifact(text, expectedWorkflowLane, ownedWorkflowLanes = [expectedWorkflowLane]) {
+  const fallbackFamily = PR_REVIEW_BASE_DIMENSION_IDS.includes(expectedWorkflowLane) ? "base_explorer" : "micro_lane";
+  const issues = [];
+  const canonicalText = removeCandidateCodeFences(text);
+  const firstTabularFields = canonicalText.split(/\r?\n/).map((line) => splitPipeFields(line).map((field) => field.trim())).find((fields) => fields.length >= 2 && fields.some((field) => field.length > 0));
+  const headerFamily = firstTabularFields ? candidateHeaderFamily(firstTabularFields) : null;
+  if (headerFamily !== fallbackFamily) {
+    appendBoundedCandidateIssue(issues, `field header: expected one exact canonical ${fallbackFamily} [CANDIDATE] header before discovery rows`);
+    return { covered: false, evidence: null, issues };
+  }
+  const parsed = parseCandidates({
+    output_ref: "pr-workflow:discovery-artifact",
+    batchId: "pr-workflow",
+    laneId: expectedWorkflowLane,
+    agent: "explorer",
+    role: "explorer",
+    digest: "0".repeat(64),
+    text: canonicalText,
+    artifact_status: "ok",
+    source: "collect_lane_results",
+    produced_at: "1970-01-01T00:00:00.000Z"
+  }, {
+    accept_partial: false,
+    accept_degraded: false,
+    degraded: false,
+    row_format_version: 1,
+    producer: "swarm-pr-review",
+    expected_family: fallbackFamily,
+    ...fallbackFamily === "base_explorer" ? {
+      expected_lane: expectedWorkflowLane,
+      expected_lanes: [...ownedWorkflowLanes]
+    } : {
+      expected_micro_lane: expectedWorkflowLane,
+      expected_micro_lanes: [...ownedWorkflowLanes]
     }
-    if (candidateHeaderSeen && fields.length >= 9 && fields[0]?.toLowerCase() !== "candidate_id" && fields[1] === expectedWorkflowLane && fields.slice(0, 9).every(Boolean))
-      return true;
+  });
+  if (parsed.error)
+    appendBoundedCandidateIssue(issues, parsed.error);
+  for (const detail of parsed.diagnostics.parse_error_details) {
+    appendBoundedCandidateIssue(issues, `row ${detail.row_index + 1} field ${detail.field}: ${detail.message}`);
   }
-  return false;
-}
-function extractLaneCoverageEvidenceText(text, expectedWorkflowLane) {
-  const lines = text.split(/\r?\n/);
-  let candidateHeaderSeen = false;
-  for (const line of lines) {
-    const fields = pipeFields(line);
-    if (fields.length === 0)
-      continue;
-    if (fields[0] === "[CLEAN]" && fields.length >= 4 && fields[1] === expectedWorkflowLane && fields.slice(1, 4).every(Boolean) && fields[2].length >= 12 && fields[3].length >= 20)
-      return `${fields[2]}\x00${fields[3]}`;
-    if (fields[0] === "[CANDIDATE]") {
-      if (fields[1]?.toLowerCase() === "candidate_id") {
-        candidateHeaderSeen = true;
-        continue;
-      }
-      if (fields.length >= 10 && fields[2] === expectedWorkflowLane && fields.slice(1, 10).every(Boolean))
-        return fields.slice(3, 10).join("\x00");
-      continue;
-    }
-    if (candidateHeaderSeen && fields.length >= 9 && fields[0]?.toLowerCase() !== "candidate_id" && fields[1] === expectedWorkflowLane && fields.slice(0, 9).every(Boolean))
-      return fields.slice(2, 9).join("\x00");
+  if (parsed.error || parsed.diagnostics.parse_error_details.length > 0) {
+    return { covered: false, evidence: null, issues };
   }
-  return null;
+  const matchingCandidate = parsed.candidates.find((candidate) => (candidate.lane ?? candidate.micro_lane) === expectedWorkflowLane);
+  if (matchingCandidate) {
+    return {
+      covered: true,
+      evidence: [
+        matchingCandidate.severity,
+        matchingCandidate.category,
+        matchingCandidate.file_line,
+        matchingCandidate.claim,
+        matchingCandidate.evidence_summary,
+        matchingCandidate.impact_context ?? matchingCandidate.invariant_violated,
+        matchingCandidate.confidence
+      ].join("\x00"),
+      issues
+    };
+  }
+  const clean = parsed.clean_attestation;
+  if (clean && (clean.row_format_family === "base_explorer" ? clean.lane : clean.micro_lane) === expectedWorkflowLane) {
+    return {
+      covered: true,
+      evidence: `${clean.coverage_scope}\x00${clean.evidence}`,
+      issues
+    };
+  }
+  return { covered: false, evidence: null, issues };
+}
+function extractLaneCoverageEvidenceText(text, expectedWorkflowLane, ownedWorkflowLanes = [expectedWorkflowLane]) {
+  return analyzePrReviewDiscoveryArtifact(text, expectedWorkflowLane, ownedWorkflowLanes).evidence;
 }
 var REVIEWER_CLASSIFICATIONS = new Set([
   "CONFIRMED",
@@ -2023,6 +3217,258 @@ async function writeStateWhileLocked(directory, state, options = {}) {
   rememberState(directory, nextState);
   return nextState;
 }
+function workflowCheckoutMutationLockRelativePath() {
+  return path4.join(WORKFLOW_GATE_DIR, "checkout.lock");
+}
+function workflowCheckoutMutationLockPath(directory) {
+  return validateSwarmPath(directory, workflowCheckoutMutationLockRelativePath());
+}
+function openCheckoutLockFile(lockPath) {
+  return fsp2.open(lockPath, "wx");
+}
+function removeCheckoutLockFile(lockPath) {
+  return fsp2.rm(lockPath);
+}
+function checkoutMutationProjectKey(directory) {
+  return normalizeComparableFsPath(directory);
+}
+
+class PrWorkflowCheckoutMutationTimeoutError extends Error {
+  phase;
+  code = "PR_WORKFLOW_CHECKOUT_MUTATION_TIMEOUT";
+  retryable = false;
+  constructor(phase) {
+    super(phase === "queue" ? "BLOCKED: timed out waiting for the active PR workflow checkout mutation; the existing owner still holds serialization and must settle before retrying" : "BLOCKED: PR workflow checkout mutation exceeded its execution deadline; serialization remains held until the in-flight action actually settles");
+    this.phase = phase;
+    this.name = "PrWorkflowCheckoutMutationTimeoutError";
+  }
+}
+async function withCheckoutMutationDeadline(promise, phase) {
+  let timeout;
+  try {
+    return await Promise.race([
+      promise,
+      new Promise((resolve3) => {
+        timeout = setTimeout(() => {
+          resolve3({
+            status: "timeout",
+            error: new PrWorkflowCheckoutMutationTimeoutError(phase)
+          });
+        }, _test_exports.checkoutMutationActionTimeoutMs);
+      })
+    ]);
+  } finally {
+    if (timeout)
+      clearTimeout(timeout);
+  }
+}
+async function withPrWorkflowCheckoutMutationLock(directory, action) {
+  const key = checkoutMutationProjectKey(directory);
+  const previous = pendingCheckoutMutationsByProject.get(key) ?? Promise.resolve();
+  let release;
+  const current = new Promise((resolve3) => {
+    release = resolve3;
+  });
+  const queued = previous.then(() => current);
+  pendingCheckoutMutationsByProject.set(key, queued);
+  const previousResult = await withCheckoutMutationDeadline(previous.then(() => ({ status: "ready" })), "queue");
+  if (previousResult.status === "timeout") {
+    release();
+    queued.then(() => {
+      if (pendingCheckoutMutationsByProject.get(key) === queued) {
+        pendingCheckoutMutationsByProject.delete(key);
+      }
+    });
+    throw previousResult.error;
+  }
+  let lock;
+  try {
+    lock = await acquireCheckoutMutationLock(directory);
+  } catch (error2) {
+    release();
+    if (pendingCheckoutMutationsByProject.get(key) === queued) {
+      pendingCheckoutMutationsByProject.delete(key);
+    }
+    throw error2;
+  }
+  const actionOutcome = Promise.resolve().then(action).then((value) => ({ status: "fulfilled", value }), (error2) => ({ status: "rejected", error: error2 }));
+  const outcome = await withCheckoutMutationDeadline(actionOutcome, "action");
+  if (outcome.status === "timeout") {
+    actionOutcome.then(async () => {
+      try {
+        await releaseCheckoutMutationLock(lock);
+      } catch {} finally {
+        release();
+        if (pendingCheckoutMutationsByProject.get(key) === queued) {
+          pendingCheckoutMutationsByProject.delete(key);
+        }
+      }
+    });
+    throw outcome.error;
+  }
+  try {
+    if (outcome.status === "rejected")
+      throw outcome.error;
+    return outcome.value;
+  } finally {
+    try {
+      await releaseCheckoutMutationLock(lock);
+    } finally {
+      release();
+      if (pendingCheckoutMutationsByProject.get(key) === queued) {
+        pendingCheckoutMutationsByProject.delete(key);
+      }
+    }
+  }
+}
+async function acquireCheckoutMutationLock(directory) {
+  const lockPath = workflowCheckoutMutationLockPath(directory);
+  const verifiedParent = await ensurePrWorkflowSafeParentDirectory(directory, lockPath);
+  for (let attempt = 0;attempt < STATE_MUTATION_LOCK_MAX_ATTEMPTS; attempt++) {
+    try {
+      const handle = await _test_exports.openCheckoutLock(lockPath);
+      const lock = {
+        ownerToken: randomUUID(),
+        pid: process.pid,
+        createdAtMs: _test_exports.nowMs()
+      };
+      let lockIdentity;
+      let writeError;
+      try {
+        const openedStat = await handle.stat({ bigint: true });
+        lockIdentity = { dev: openedStat.dev, ino: openedStat.ino };
+        lockIdentity = await assertOpenedSwarmFileIdentity(directory, lockPath, handle, verifiedParent, "PR workflow checkout mutation lock");
+        await _test_exports.beforeCheckoutLockWrite?.();
+        await handle.writeFile(JSON.stringify(lock), "utf-8");
+      } catch (error2) {
+        writeError = error2;
+      } finally {
+        await handle.close().catch(() => {
+          return;
+        });
+      }
+      if (writeError) {
+        if (lockIdentity) {
+          await removeCheckoutMutationLockByIdentity(directory, lockPath, lockIdentity, verifiedParent);
+        }
+        throw writeError;
+      }
+      return { path: lockPath, ownerToken: lock.ownerToken };
+    } catch (error2) {
+      if (error2.code !== "EEXIST")
+        throw error2;
+      if (await reclaimAbandonedCheckoutMutationLock(lockPath))
+        continue;
+      if (attempt < STATE_MUTATION_LOCK_MAX_ATTEMPTS - 1) {
+        await delay(STATE_MUTATION_LOCK_RETRY_DELAY_MS);
+      }
+    }
+  }
+  throw new Error("BLOCKED: PR workflow checkout mutation is being handled by another process; retry after that checkout settles");
+}
+async function releaseCheckoutMutationLock(lock) {
+  let lastError;
+  for (let attempt = 0;attempt < WINDOWS_RENAME_MAX_RETRIES; attempt++) {
+    try {
+      if (await removeCheckoutMutationLockIfOwned(lock.path, lock.ownerToken)) {
+        completedCheckoutLockOwners.delete(lock.path);
+        return;
+      }
+      lastError = new Error("PR workflow checkout mutation lock ownership changed before release");
+    } catch (error2) {
+      lastError = error2;
+    }
+    if (attempt < WINDOWS_RENAME_MAX_RETRIES - 1) {
+      await delay(RENAME_RETRY_DELAY_MS);
+    }
+  }
+  rememberCompletedCheckoutLockOwner(lock.path, lock.ownerToken);
+  throw lastError instanceof Error ? lastError : new Error("PR workflow checkout mutation lock release failed");
+}
+async function reclaimAbandonedCheckoutMutationLock(lockPath) {
+  const lock = await readCheckoutMutationLock(lockPath);
+  if (lock) {
+    if (lock.pid === process.pid && completedCheckoutLockOwners.get(lockPath) === lock.ownerToken) {
+      const removed = await removeCheckoutMutationLockIfOwned(lockPath, lock.ownerToken);
+      if (removed)
+        completedCheckoutLockOwners.delete(lockPath);
+      return removed;
+    }
+    if (_test_exports.isProcessAlive(lock.pid))
+      return false;
+    return removeCheckoutMutationLockIfOwned(lockPath, lock.ownerToken);
+  }
+  try {
+    const stat2 = await fsp2.stat(lockPath);
+    if (_test_exports.nowMs() - stat2.mtimeMs < STATE_MUTATION_LOCK_UNINITIALIZED_STALE_MS) {
+      return false;
+    }
+    await fsp2.rm(lockPath, { force: true });
+    return true;
+  } catch (error2) {
+    if (error2.code === "ENOENT")
+      return true;
+    throw error2;
+  }
+}
+async function readCheckoutMutationLock(lockPath) {
+  let raw;
+  try {
+    raw = await fsp2.readFile(lockPath, "utf-8");
+  } catch (error2) {
+    if (error2.code === "ENOENT")
+      return null;
+    throw error2;
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed === "object" && parsed !== null && typeof parsed.ownerToken === "string" && parsed.ownerToken.length > 0 && typeof parsed.pid === "number" && Number.isInteger(parsed.pid) && parsed.pid > 0 && typeof parsed.createdAtMs === "number" && Number.isFinite(parsed.createdAtMs)) {
+      return parsed;
+    }
+  } catch {}
+  return null;
+}
+async function removeCheckoutMutationLockIfOwned(lockPath, ownerToken) {
+  const lock = await readCheckoutMutationLock(lockPath);
+  if (!lock || lock.ownerToken !== ownerToken)
+    return false;
+  try {
+    await _test_exports.removeCheckoutLock(lockPath);
+    return true;
+  } catch (error2) {
+    if (error2.code === "ENOENT")
+      return false;
+    throw error2;
+  }
+}
+async function removeCheckoutMutationLockByIdentity(directory, lockPath, identity, verifiedParent) {
+  let lastError;
+  for (let attempt = 0;attempt < WINDOWS_RENAME_MAX_RETRIES; attempt++) {
+    try {
+      await assertClosedSwarmFileIdentity(directory, lockPath, identity, verifiedParent, "PR workflow checkout mutation lock");
+      await _test_exports.removeCheckoutLock(lockPath);
+      return;
+    } catch (error2) {
+      if (error2.code === "ENOENT")
+        return;
+      lastError = error2;
+      if (attempt < WINDOWS_RENAME_MAX_RETRIES - 1) {
+        await delay(RENAME_RETRY_DELAY_MS);
+      }
+    }
+  }
+  throw lastError instanceof Error ? lastError : new Error("PR workflow checkout mutation lock cleanup failed");
+}
+function rememberCompletedCheckoutLockOwner(lockPath, ownerToken) {
+  completedCheckoutLockOwners.delete(lockPath);
+  completedCheckoutLockOwners.set(lockPath, ownerToken);
+  while (completedCheckoutLockOwners.size > MAX_COMPLETED_CHECKOUT_LOCK_OWNERS) {
+    const oldest = completedCheckoutLockOwners.keys().next().value;
+    if (oldest === undefined)
+      break;
+    completedCheckoutLockOwners.delete(oldest);
+  }
+}
 async function withSessionStateMutation(directory, sessionID, action) {
   const key = stateCacheKey(directory, sessionID);
   const previous = pendingStateMutationsByProjectSession.get(key) ?? Promise.resolve();
@@ -12311,7 +13757,7 @@ function hasActiveEpicMode(sessionID) {
 async function rehydratePrSubscriptions(sessionID, directory) {
   const map = new Map;
   try {
-    const { listActive: listActive2 } = await import("./pr-subscriptions-29j794kd.js");
+    const { listActive: listActive2 } = await import("./pr-subscriptions-v5xd3j6d.js");
     const records = await listActive2(directory);
     for (const record of records) {
       if (record.sessionID !== sessionID)
@@ -15187,7 +16633,7 @@ init_logger();
 import { readFile as readFile9, rename as rename4, writeFile as writeFile5 } from "fs/promises";
 
 // src/services/skill-improver-quota.ts
-var import_proper_lockfile = __toESM(require_proper_lockfile(), 1);
+var import_proper_lockfile2 = __toESM(require_proper_lockfile(), 1);
 import { existsSync as existsSync12 } from "fs";
 import { mkdir as mkdir7, readFile as readFile8, rename as rename3, writeFile as writeFile4 } from "fs/promises";
 import * as path27 from "path";
@@ -15202,7 +16648,7 @@ var LOCK_RETRY_OPTS = {
   stale: 5000
 };
 async function acquireLock(dir) {
-  const acquire = import_proper_lockfile.default.lock(dir, LOCK_RETRY_OPTS);
+  const acquire = import_proper_lockfile2.default.lock(dir, LOCK_RETRY_OPTS);
   let timer;
   const timeout = new Promise((_, reject) => {
     timer = setTimeout(() => {
@@ -15958,7 +17404,7 @@ function planMerges(active, threshold, maxComparisons, maxMerges) {
   };
 }
 async function sweepActiveNearDuplicates(directory, options = {}) {
-  const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-q9mq5tv3.js");
+  const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-g3meqrsg.js");
   const { config } = loadPluginConfigWithMeta2(directory);
   const sweepConfig = config.learning?.dedup_sweep;
   if (sweepConfig?.enabled === false)
@@ -17551,7 +18997,7 @@ async function runCuratorPhase(directory, phase, agentsDispatched, config, knowl
     }
     if (config.skill_generation_enabled === true && skillCandidates.length > 0) {
       try {
-        const skillModule = await import("./skill-generator-02q1qdf0.js");
+        const skillModule = await import("./skill-generator-54xbjgak.js");
         for (const cand of skillCandidates) {
           if (cand.confidence < (config.min_skill_confidence ?? DEFAULT_SKILL_MIN_CONFIDENCE)) {
             continue;
@@ -17952,7 +19398,7 @@ async function applyCuratorKnowledgeUpdates(directory, recommendations, knowledg
     } catch {}
   }
   if (contradictedEntries.length > 0 && knowledgeConfig.contradiction_threshold_action === "quarantine") {
-    const { maybeQuarantineOnContradiction } = await import("./knowledge-escalator-d76a090n.js");
+    const { maybeQuarantineOnContradiction } = await import("./knowledge-escalator-w7by1m8m.js");
     for (const { id } of contradictedEntries) {
       try {
         await maybeQuarantineOnContradiction(directory, id, knowledgeConfig.contradiction_quarantine_threshold, knowledgeConfig.contradiction_quarantine_window_days);
@@ -18760,7 +20206,7 @@ async function runCuratorPostMortem(directory, options = {}) {
       warnings.push("Failed to collect knowledge summary.");
     }
     try {
-      const { getScanStatus } = await import("./scan-cursor-stztfv7d.js");
+      const { getScanStatus } = await import("./scan-cursor-1q1zmt4b.js");
       const scanStatus = await getScanStatus(directory);
       if (scanStatus.remaining_estimate > 0) {
         warnings.push(`Fair scan: reviewed ${knowledgeSummary.length} entries this sweep (generation ${scanStatus.generation}); ${scanStatus.remaining_estimate} more eligible entries will be visited in future curation sweeps.`);
@@ -18802,7 +20248,7 @@ async function runCuratorPostMortem(directory, options = {}) {
     let actionResult;
     if (options.llmDelegate) {
       try {
-        const { CURATOR_POSTMORTEM_PROMPT } = await import("./explorer-jp0nen03.js");
+        const { CURATOR_POSTMORTEM_PROMPT } = await import("./explorer-15gqzxh8.js");
         const userInput = assembleLLMInput(effectivePlanId, scope, options.sessionID, planSummary, knowledgeSummary, curatorDigest, proposals, unactionable, retrospectives, driftReports);
         const ac = new AbortController;
         const timer = setTimeout(() => ac.abort(), options.llmTimeoutMs ?? 300000);
@@ -18932,9 +20378,9 @@ var _internals24 = {
   verifyPostMortemKnowledgeActions,
   repairPostMortemActions,
   loadDefaultKnowledgeConfig: async (directory) => {
-    const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-tbq2srrh.js");
+    const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-8mtsfspm.js");
     try {
-      const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-q9mq5tv3.js");
+      const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-g3meqrsg.js");
       const loaded = loadPluginConfigWithMeta2(directory);
       return KnowledgeConfigSchema2.parse(loaded.config.knowledge ?? {});
     } catch {
@@ -18942,11 +20388,11 @@ var _internals24 = {
     }
   },
   applyCuratorKnowledgeUpdates: async (directory, recommendations, knowledgeConfig, generation) => {
-    const { applyCuratorKnowledgeUpdates: applyCuratorKnowledgeUpdates2 } = await import("./curator-yc06cmnz.js");
+    const { applyCuratorKnowledgeUpdates: applyCuratorKnowledgeUpdates2 } = await import("./curator-r1s2mwf2.js");
     return applyCuratorKnowledgeUpdates2(directory, recommendations, knowledgeConfig, generation);
   },
   checkHivePromotions: async (entries, knowledgeConfig, directory) => {
-    const { checkHivePromotions } = await import("./hive-promoter-7s3gzajy.js");
+    const { checkHivePromotions } = await import("./hive-promoter-586dhndj.js");
     return checkHivePromotions(entries, knowledgeConfig, directory);
   },
   applyProposalTriage: async (directory, triage) => {
@@ -18955,7 +20401,7 @@ var _internals24 = {
       activateProposal,
       listSkills: listSkills2,
       sanitizeSlug
-    } = await import("./skill-generator-02q1qdf0.js");
+    } = await import("./skill-generator-54xbjgak.js");
     const result = {
       approved: [],
       rejected: [],
@@ -18997,7 +20443,7 @@ var _internals24 = {
     return result;
   },
   readPriorDriftReports: async (directory) => {
-    const { readPriorDriftReports } = await import("./curator-drift-9q6f85bm.js");
+    const { readPriorDriftReports } = await import("./curator-drift-2ta83hss.js");
     return readPriorDriftReports(directory);
   },
   readSwarmKnowledge: (directory) => readKnowledge(resolveSwarmKnowledgePath(directory))
@@ -19094,7 +20540,7 @@ function failedGateNames(decision) {
 }
 
 // src/hooks/hive-transaction.ts
-var import_proper_lockfile2 = __toESM(require_proper_lockfile(), 1);
+var import_proper_lockfile3 = __toESM(require_proper_lockfile(), 1);
 import { appendFile as appendFile4, mkdir as mkdir8 } from "fs/promises";
 import * as path32 from "path";
 init_logger();
@@ -19194,7 +20640,7 @@ async function trimHiveEventsUnderLock(eventsPath) {
 `);
 }
 var _internals25 = {
-  lockfile: import_proper_lockfile2.default,
+  lockfile: import_proper_lockfile3.default,
   readKnowledge,
   atomicWriteFile,
   selectKnowledgeCapSurvivors,
@@ -19951,7 +21397,7 @@ import {
 import * as path38 from "path";
 
 // src/services/synonym-map.ts
-var import_proper_lockfile3 = __toESM(require_proper_lockfile(), 1);
+var import_proper_lockfile4 = __toESM(require_proper_lockfile(), 1);
 import {
   mkdir as mkdir10,
   readFile as readFile11,
@@ -20132,7 +21578,7 @@ async function rebuildSynonymMap(directory, entries, maxPairs = DEFAULT_MAX_PAIR
   await mkdir10(dir, { recursive: true });
   let release = null;
   try {
-    release = await import_proper_lockfile3.default.lock(dir, {
+    release = await import_proper_lockfile4.default.lock(dir, {
       retries: { retries: 5, minTimeout: 100, maxTimeout: 500 },
       stale: 5000
     });
@@ -21582,9 +23028,9 @@ function hashContent(content) {
   return createHash9("sha1").update(content).digest("hex");
 }
 async function loadConfigForPolicyCurator(directory) {
-  const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-tbq2srrh.js");
+  const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-8mtsfspm.js");
   try {
-    const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-q9mq5tv3.js");
+    const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-g3meqrsg.js");
     const { config: loadedConfig } = loadPluginConfigWithMeta2(directory);
     return KnowledgeConfigSchema2.parse(loadedConfig.knowledge ?? {});
   } catch {
@@ -24929,7 +26375,7 @@ async function runFinalizeStage(ctx) {
     }
   }
   try {
-    const { CuratorConfigSchema: CCS } = await import("./schema-tbq2srrh.js");
+    const { CuratorConfigSchema: CCS } = await import("./schema-8mtsfspm.js");
     const { config: pmLoadedConfig } = _internals34.loadPluginConfigWithMeta(ctx.directory);
     const curatorCfg = CCS.parse(pmLoadedConfig.curator ?? {});
     if (curatorCfg.enabled && curatorCfg.postmortem_enabled) {
@@ -27159,9 +28605,9 @@ var _internals39 = {
   loadPluginConfigWithMeta,
   loadCuratorDeps: async () => {
     const [{ CuratorConfigSchema }, curator, { createCuratorLLMDelegate: createCuratorLLMDelegate2 }] = await Promise.all([
-      import("./schema-tbq2srrh.js"),
-      import("./curator-yc06cmnz.js"),
-      import("./curator-llm-factory-4mat6cq5.js")
+      import("./schema-8mtsfspm.js"),
+      import("./curator-r1s2mwf2.js"),
+      import("./curator-llm-factory-9983528d.js")
     ]);
     return { CuratorConfigSchema, curator, createCuratorLLMDelegate: createCuratorLLMDelegate2 };
   }
@@ -28062,7 +29508,7 @@ async function computeCurationDiagnostics(directory, entries) {
   let scanCompleted = false;
   let scanRemaining = 0;
   try {
-    const { getScanStatus } = await import("./scan-cursor-stztfv7d.js");
+    const { getScanStatus } = await import("./scan-cursor-1q1zmt4b.js");
     const status = await getScanStatus(directory);
     scanGeneration = status.generation;
     scanCompleted = status.completed;
@@ -28070,19 +29516,19 @@ async function computeCurationDiagnostics(directory, entries) {
   } catch {}
   let configMatch = null;
   try {
-    const { isLinked: isLinked2 } = await import("./knowledge-link-etrfntkd.js");
+    const { isLinked: isLinked2 } = await import("./knowledge-link-mm1w967j.js");
     if (isLinked2(directory)) {
-      const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-tbq2srrh.js");
+      const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-8mtsfspm.js");
       let config;
       try {
-        const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-q9mq5tv3.js");
+        const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-g3meqrsg.js");
         const loaded = loadPluginConfigWithMeta2(directory);
         config = KnowledgeConfigSchema2.parse(loaded.config.knowledge ?? {});
       } catch {
         config = KnowledgeConfigSchema2.parse({});
       }
       const { cohortConfigFingerprint: cohortConfigFingerprint2 } = await import("./config-fingerprint-v22xh5a2.js");
-      const { buildConfigFingerprintInput: buildConfigFingerprintInput2, readCohortConfigFingerprint } = await import("./curation-policy-xg9zw0ep.js");
+      const { buildConfigFingerprintInput: buildConfigFingerprintInput2, readCohortConfigFingerprint } = await import("./curation-policy-b2caf3v3.js");
       const currentFp = cohortConfigFingerprint2(buildConfigFingerprintInput2(config));
       const cohortFp = await readCohortConfigFingerprint(directory);
       configMatch = cohortFp === null ? null : currentFp === cohortFp;
@@ -29293,7 +30739,7 @@ async function handleDoctorCommand(directory, args) {
   const result = runConfigDoctor(config, directory);
   let output;
   if (enableAutoFix && result.hasAutoFixableIssues) {
-    const { runConfigDoctorWithFixes } = await import("./config-doctor-j1x63x87.js");
+    const { runConfigDoctorWithFixes } = await import("./config-doctor-pj3yvxdb.js");
     const fixResult = await runConfigDoctorWithFixes(directory, config, true, {
       applyLossy: true
     });
@@ -30130,7 +31576,7 @@ async function handleEvidenceCommand(directory, args) {
   return formatTaskEvidenceMarkdown(evidenceData);
 }
 async function handleEvidenceSummaryCommand(directory) {
-  const { buildEvidenceSummary } = await import("./evidence-summary-service-0cczdmjv.js");
+  const { buildEvidenceSummary } = await import("./evidence-summary-service-feby8ny0.js");
   const artifact = await buildEvidenceSummary(directory);
   if (!artifact) {
     return "No plan found. Run `/swarm plan` to check plan status.";
@@ -30193,11 +31639,11 @@ async function handleExportCommand(directory, _args) {
   return formatExportMarkdown(exportData);
 }
 // src/full-auto/state.ts
-var import_proper_lockfile4 = __toESM(require_proper_lockfile(), 1);
+var import_proper_lockfile5 = __toESM(require_proper_lockfile(), 1);
 import * as fs21 from "fs";
 import * as path55 from "path";
 init_logger();
-var lockfile4 = import_proper_lockfile4.default;
+var lockfile5 = import_proper_lockfile5.default;
 var STATE_FILE2 = "full-auto-state.json";
 function nowISO2() {
   return new Date().toISOString();
@@ -30275,7 +31721,7 @@ function withStateLock(directory, fn) {
       fs21.writeFileSync(lockTarget, `${JSON.stringify(seed, null, 2)}
 `, "utf-8");
     }
-    release = lockfile4.lockSync(lockTarget, {
+    release = lockfile5.lockSync(lockTarget, {
       retries: { retries: 5, minTimeout: 5, maxTimeout: 50 },
       stale: 5000
     });
@@ -37007,7 +38453,7 @@ import * as path69 from "path";
 init_schema();
 
 // src/knowledge/family-migration.ts
-var import_proper_lockfile5 = __toESM(require_proper_lockfile(), 1);
+var import_proper_lockfile6 = __toESM(require_proper_lockfile(), 1);
 import { existsSync as existsSync38, readFileSync as readFileSync29 } from "fs";
 import { mkdir as mkdir16 } from "fs/promises";
 import * as path68 from "path";
@@ -37295,7 +38741,7 @@ async function snapshotSourceFamily(storeDir) {
     await mkdir16(storeDir, { recursive: true });
   } catch {}
   try {
-    release = await import_proper_lockfile5.default.lock(storeDir, {
+    release = await import_proper_lockfile6.default.lock(storeDir, {
       ...MIGRATION_LOCK_RETRIES,
       stale: MIGRATION_LOCK_STALE_MS
     });
@@ -37314,7 +38760,7 @@ async function migrateKnowledgeFamily(destinationDir, sourceDir) {
   await mkdir16(destinationDir, { recursive: true });
   let destRelease = null;
   try {
-    destRelease = await import_proper_lockfile5.default.lock(destinationDir, {
+    destRelease = await import_proper_lockfile6.default.lock(destinationDir, {
       ...MIGRATION_LOCK_RETRIES,
       stale: MIGRATION_LOCK_STALE_MS
     });
@@ -38703,7 +40149,7 @@ import * as path74 from "path";
 init_schema();
 
 // src/memory/memory-family-migration.ts
-var import_proper_lockfile6 = __toESM(require_proper_lockfile(), 1);
+var import_proper_lockfile7 = __toESM(require_proper_lockfile(), 1);
 import { copyFileSync as copyFileSync4, existsSync as existsSync40, readFileSync as readFileSync30, unlinkSync as unlinkSync12 } from "fs";
 import { mkdir as mkdir19, rename as rename9 } from "fs/promises";
 import * as path73 from "path";
@@ -38928,7 +40374,7 @@ async function migrateMemoryFamily(destRoot, sourceRoot) {
   await mkdir19(destStoragePath, { recursive: true });
   let destRelease = null;
   try {
-    destRelease = await import_proper_lockfile6.default.lock(destStoragePath, {
+    destRelease = await import_proper_lockfile7.default.lock(destStoragePath, {
       ...MIGRATION_LOCK_RETRIES,
       stale: MIGRATION_LOCK_STALE_MS
     });
@@ -42148,7 +43594,7 @@ var DISPATCH_FRAMEWORK_MAP = {
 };
 async function detectTestFrameworkViaDispatch(cwd) {
   try {
-    const { pickBackend } = await import("./dispatch-gxbeb2ps.js");
+    const { pickBackend } = await import("./dispatch-wtk6dxky.js");
     const backend = await pickBackend(cwd);
     if (!backend?.selectTestFramework)
       return "none";
@@ -42164,7 +43610,7 @@ async function buildTestCommandViaDispatch(framework, scope, files, coverage, ba
   if (framework === "none")
     return null;
   try {
-    const { pickBackend } = await import("./dispatch-gxbeb2ps.js");
+    const { pickBackend } = await import("./dispatch-wtk6dxky.js");
     const backend = await pickBackend(baseDir);
     if (backend?.buildTestCommand) {
       const cmd = backend.buildTestCommand(framework, files, baseDir, {
@@ -42184,7 +43630,7 @@ async function parseTestOutputViaDispatch(framework, output, baseDir) {
   if (framework === "none")
     return null;
   try {
-    const { pickBackend } = await import("./dispatch-gxbeb2ps.js");
+    const { pickBackend } = await import("./dispatch-wtk6dxky.js");
     const backend = await pickBackend(baseDir);
     if (!backend?.parseTestOutput)
       return null;
@@ -50713,7 +52159,7 @@ function buildDetailedHelp(commandName, entry) {
 async function handleHelpCommand(ctx) {
   const targetCommand = ctx.args.join(" ");
   if (!targetCommand) {
-    const { buildHelpText } = await import("./index-96b78s7p.js");
+    const { buildHelpText } = await import("./index-cwdy5vw9.js");
     return buildHelpText();
   }
   const tokens = targetCommand.split(/\s+/);
@@ -50722,7 +52168,7 @@ async function handleHelpCommand(ctx) {
     return _internals12.buildDetailedHelp(resolved.key, resolved.entry);
   }
   const similar = _internals12.findSimilarCommands(targetCommand);
-  const { buildHelpText: fullHelp } = await import("./index-96b78s7p.js");
+  const { buildHelpText: fullHelp } = await import("./index-cwdy5vw9.js");
   if (similar.length > 0) {
     return `Command '/swarm ${targetCommand}' not found.
 
@@ -50899,7 +52345,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail explain": {
     handler: async (ctx) => {
-      const { handleGuardrailExplain } = await import("./guardrail-explain-zmbxwh3s.js");
+      const { handleGuardrailExplain } = await import("./guardrail-explain-pwxvg5n0.js");
       return handleGuardrailExplain(ctx.directory, ctx.args);
     },
     description: "Dry-run: show what the guardrails would do to a command or write target (executes nothing)",
@@ -50909,7 +52355,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail-explain": {
     handler: async (ctx) => {
-      const { handleGuardrailExplain } = await import("./guardrail-explain-zmbxwh3s.js");
+      const { handleGuardrailExplain } = await import("./guardrail-explain-pwxvg5n0.js");
       return handleGuardrailExplain(ctx.directory, ctx.args);
     },
     description: "Dry-run: show what the guardrails would do to a command or write target (executes nothing)",
@@ -50919,7 +52365,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail-log": {
     handler: async (ctx) => {
-      const { handleGuardrailLog } = await import("./guardrail-log-7egxrxap.js");
+      const { handleGuardrailLog } = await import("./guardrail-log-yzpz8b7t.js");
       return handleGuardrailLog(ctx.directory, ctx.args);
     },
     description: "Read the guardrail decision log (use --blocks-only for blocks)",
@@ -51292,7 +52738,7 @@ Subcommands:
     handler: (ctx) => handleModeCommandWithBundledSkills(ctx, handlePrReviewCommand, "PR_REVIEW"),
     description: "Launch deep PR review with multi-lane analysis [url] [--council]",
     args: "<pr-url|owner/repo#N|N> [--council]",
-    details: "Launches a structured PR review: reconstructs PR intent via obligation extraction cascade, computes a depth tier (S/M/L) from the bound merge-base diff, launches the base explorer wave through dispatch_lanes_async (all 6 review dimensions covered on every PR \u2014 six singleton lanes at tier L, consolidated owned_workflow_lanes partitions at tiers S/M) while the architect keeps doing non-dependent work, polls collect_lane_results incrementally, evaluates all 11 mandatory repository-agnostic risk families without applicability waivers (dedicated micro-lanes at tier L, consolidated sweeps at S/M), validates findings through independent reviewer confirmation, applies critic challenge to HIGH/CRITICAL findings, then synthesizes only after coverage is closed. Failed obligations retry through the same structured async mode and exact PR head; blocking or direct-Task dispatch is not provenance-equivalent, so unclosed coverage leaves the review BLOCKED rather than degraded. --council variant fires adversarial multi-model review. Supports full GitHub URL, owner/repo#N shorthand, or bare PR number (resolves against origin remote).",
+    details: "Launches a structured PR review: preserves dirty state, verifies and binds an exact detached PR head, reconstructs PR intent via obligation extraction cascade, computes a depth tier (S/M/L) from the bound merge-base diff, launches the base explorer wave through dispatch_lanes_async (all 6 review dimensions covered on every PR \u2014 six singleton lanes at tier L, consolidated owned_workflow_lanes partitions at tiers S/M) while the architect keeps doing non-dependent work, and polls collect_lane_results incrementally. It evaluates an exact 11-row repository-agnostic risk-family ledger, records applicable rows as MATCHED and concretely inapplicable rows as provenance-free NOT_TRIGGERED, always keeps unclassified-risk MATCHED, and dispatches micro work only for MATCHED families (dedicated lanes at tier L, consolidated sweeps at S/M). It then validates findings through independent reviewer confirmation, applies critic challenge to HIGH/CRITICAL findings, and synthesizes only after matched coverage is closed. Failed obligations retry through the same structured async mode and exact PR head; blocking or direct-Task dispatch is not provenance-equivalent, so unclosed matched coverage leaves the review BLOCKED rather than degraded. --council variant fires adversarial multi-model review. Supports full GitHub URL, owner/repo#N shorthand, or bare PR number (resolves against origin remote).",
     category: "agent",
     toolPolicy: "none"
   },
@@ -52717,7 +54163,7 @@ HARD CONSTRAINTS (apply regardless of skill load success):
 - RUN ALL BASE LANES: the default PR_REVIEW path always launches exactly six repository-agnostic base check-type lanes from the skill. Use \`mode: "swarm-pr-review:base"\` and the exact six \`workflow_lane\` identifiers. The runtime rejects partial, duplicate, or mislabelled waves. Do not collapse, omit, or scale down the base lanes for a small, docs-only, or CI-only PR.
 - RETRY STRUCTURALLY: retry only failed base obligations in later \`swarm-pr-review:base\` async batches with the same exact \`pr_head_sha\`. Blocking \`dispatch_lanes\` and direct Task explorer/reviewer/critic dispatch are not provenance-equivalent and are rejected.
 - USE ASYNC DISPATCH WITHOUT IDLING: launch the base lanes with one \`dispatch_lanes_async\` call when available, record the \`batch_id\`, then keep doing non-dependent architect work while they run. Poll with \`collect_lane_results\` without \`wait\` (or \`wait: false\`) to process settled lanes and continue independent work between polls; use \`wait: true\` only as the final join when no independent work remains.
-- RUN ALL MICRO-LANES: after the base explorer lanes settle, focus every repository-agnostic row from the exact diff/context pack and launch all 11 micro-lanes with \`mode: "swarm-pr-review:micro"\`, the complete all-\`MATCHED\` \`trigger_evaluation\`, and each trigger ID as \`workflow_lane\`. Keyword or path heuristics cannot waive a row. Missing any micro-lane is a BLOCKED coverage gap, not a speed optimization; split the lanes across bounded \`dispatch_lanes_async\` batches and use the same non-idling incremental collection pattern.
+- EVALUATE ALL RISK FAMILIES: after the base explorer lanes settle, evaluate every repository-agnostic trigger row against the exact diff/context pack. Record applicable families as \`MATCHED\` and inapplicable families as provenance-free \`NOT_TRIGGERED\` with concrete absence evidence; \`unclassified-risk\` always remains \`MATCHED\`. Launch \`swarm-pr-review:micro\` lanes only for the \`MATCHED\` IDs, pass the complete exact eleven-row \`trigger_evaluation\` to every batch, and use each dispatched trigger ID as \`workflow_lane\`. Missing an evaluation row or a matched-family attestation is BLOCKED; a \`NOT_TRIGGERED\` family must not create a micro artifact.
 - RUN HEAD-BOUND VALIDATION: dispatch independent reviewers with \`mode: "swarm-pr-review:reviewer"\` and critics with \`mode: "swarm-pr-review:critic"\`, unique \`workflow_lane\` obligations, role-correct agents, and the same exact \`pr_head_sha\`. Critic dispatch is blocked until all declared reviewer obligations have successful artifacts.
 - COMPLETE EXPLICITLY: after final artifacts and synthesis, call \`complete_pr_workflow\` with \`mode: "PR_REVIEW"\` and the bound \`pr_head_sha\`; never leave the session trapped in a stale workflow gate.
 - ABORT IF UNRECOVERABLE: if the PR head cannot be fetched/checked out (the working tree stays on the wrong branch), a compound \`git fetch && git checkout\` keeps being rejected as read-only shell syntax (run them as TWO separate standalone commands first), or the merge-base bind is unreachable for any reason, call \`abort_pr_workflow\` with \`mode: "PR_REVIEW"\` and a one-line \`reason\` instead of looping. The tool refuses while PR workflow lanes are in flight (collect their results first). Aborting clears the durable gate and stops the auto-resume loop; the user can also run \`/swarm abort-pr-workflow\`. Do NOT abort as a shortcut to avoid coverage obligations \u2014 only when the bind/checkout path is genuinely unreachable.
@@ -52739,7 +54185,7 @@ ACTION: Load skill ${bundledProjectSkillFileReference("swarm-pr-feedback")} imme
 
 HARD CONSTRAINTS (apply regardless of skill load success):
 - FOLLOW THE SKILL EXACTLY: build the complete feedback ledger from all available sources before editing, and execute every phase in order with no shortcuts.
-- CHECK OUT THE PR BRANCH LOCALLY before dispatching feedback lanes, verifying feedback, or making fixes: fetch the PR head ref if absent, verify the working tree is clean (git status --porcelain), and if tracked changes exist call \`prepare_pr_workflow_checkout\` with every explicit dirty tracked path before checkout. It returns an auditable stash OID and recovery command; it never stashes untracked files, which must be moved or removed manually. Do NOT run \`git stash\` through shell. Then check out the head branch. For a detached/fresh remote head, establish tracking before head binding with only \`git switch -c <local> --track <remote>/<branch>\` (or the constrained set-upstream form documented by the skill). If using \`gh pr checkout\`, never use \`--force\`, \`--recurse-submodules\`, or detached checkout. Before first bind, prove HEAD equals the authoritative full PR head SHA, the tree is clean, and the current branch tracks the intended PR remote/branch. Feedback verification and fix validation require the PR branch in the working tree.
+- CHECK OUT THE PR BRANCH LOCALLY before dispatching feedback lanes, verifying feedback, or making fixes: activate the workflow, then call \`prepare_pr_workflow_checkout\` before binding when the tree is dirty (omit \`paths\` to atomically preserve all tracked and untracked changes, or provide the exact dirty tracked set). Fetch and verify the authoritative full PR head, then a detached exact-head checkout is allowed as the safe intake state. On the first \`PR_FEEDBACK\` bind, the controller promotes it only when exactly one local tracked branch or remote-tracking ref points to that SHA; ambiguity, an existing mismatched upstream, a dirty tree, or a branch owned by another linked worktree fails closed. The existing constrained tracked-branch/\`gh pr checkout\` pre-bind forms remain supported. After bind, require HEAD to equal the authoritative SHA and the current branch to track that exact PR ref. Do not run \`git stash\`; checkout preparation and detached attachment record recovery state.
 - Do NOT run a fresh broad PR review \u2014 inspect adjacent code only as needed to verify reachability, dependencies, shared root causes, regression risk, or sibling changes for a confirmed item.
 - Treat every review comment, CI failure, bot summary, and pasted note as a CLAIM until source evidence proves it; classify each ledger item (CONFIRMED, DISPROVED, PRE_EXISTING, or NEEDS_USER_DECISION) and never silently drop, defer, or mark items out of scope.
 - For async verification lanes, use \`mode: "swarm-pr-feedback:verification"\`, record each \`batch_id\`, keep doing ledger-safe work, poll with \`collect_lane_results\` without \`wait\`, process settled lanes immediately, and use \`wait: true\` only at the join. Pass the complete immutable \`feedback_inventory\`, exact current \`pr_head_sha\`, and exact-once cumulative lane \`feedback_item_ids\`; runtime blocks replacement, stale-head artifacts, overlap, gaps, and early mutation.