opencode-swarm 7.157.1 → 7.158.1

package/dist/cli/{index-tt350s4g.js → index-ac8rwjsg.js}

@@ -6,7 +6,7 @@ import {
   resolveExecutableFromPath,
   runEvaluation,
   runExternalTool
-} from "./index-t0kxka8n.js";
+} from "./index-z54qw70y.js";
 import {
   finalizeShellAuditForClose,
   isPolicyProtectedPath,
@@ -15,13 +15,13 @@ import {
   protectedRoots,
   redactDecisionLineForArchive,
   stableCanonicalStringify
-} from "./index-r98wqjw4.js";
+} from "./index-ff8xjr1c.js";
 import {
   detectStraySwarmDirs,
   readDoctorArtifact,
   removeStraySwarmDir,
   runConfigDoctor
-} from "./index-b3cwazk2.js";
+} from "./index-86vvhe8m.js";
 import {
   MAX_TRANSIENT_RETRIES,
   archiveEvidence,
@@ -68,7 +68,7 @@ import {
   validateProjectRoot,
   validateSymlinkBoundary,
   validateTargetWithinRoot
-} from "./index-pbh1rmb9.js";
+} from "./index-7qvfkgyk.js";
 import {
   EvaluationTaskV1Schema,
   GateAuditManifestV1Schema,
@@ -85,7 +85,18 @@ import {
   saveGateAuditResult,
   savePromotionDecision,
   saveTaskSetSnapshot
-} from "./index-ngn6jmad.js";
+} from "./index-7s1hmrfh.js";
+import {
+  canonicalHash,
+  canonicalJson,
+  computeCandidateInputContentHash,
+  computeManifestContentHash,
+  computeTaskContentHash,
+  computeTaskInputContentHash,
+  computeTaskSetContentHash,
+  resolveContainedExistingPath,
+  sha256
+} from "./index-txdagbh7.js";
 import {
   loadDatabaseCtor
 } from "./index-134d35c1.js";
@@ -99,24 +110,34 @@ import {
   tool
 } from "./index-nj6rmyeh.js";
 import {
-  canonicalHash,
-  canonicalJson,
-  computeCandidateInputContentHash,
-  computeManifestContentHash,
-  computeTaskContentHash,
-  computeTaskInputContentHash,
-  computeTaskSetContentHash,
-  resolveContainedExistingPath,
-  sha256
-} from "./index-txdagbh7.js";
+  BUNDLED_PROJECT_SKILL_ROOT,
+  DEFAULT_SKILL_MIN_CONFIDENCE,
+  DEFAULT_SKILL_MIN_CONFIRMATIONS,
+  appendRejectedSkillEdit,
+  appendSkillChangelog,
+  autoApplyProposals,
+  bundledProjectSkillFileReference,
+  evaluateSkillChange,
+  findSkillsBySourceKnowledgeId,
+  findStaleSkillsBySourceKnowledgeId,
+  generateSkills,
+  isRejectedSkillContent,
+  listSkills,
+  parseDraftFrontmatter,
+  regenerateSkill,
+  retireOrMarkStale,
+  retireSkill,
+  selectCandidateEntries,
+  syncBundledProjectSkillsIfMissingAsync
+} from "./index-tc14d2zy.js";
 import {
   readRecentEscalations
-} from "./index-xttdbb6d.js";
+} from "./index-azx50qge.js";
 import {
   alreadyCuratedThisGeneration,
   claimNextScanBatch,
   resolveCohortId
-} from "./index-hq3m47kh.js";
+} from "./index-mfv7mfgg.js";
 import {
   CURATOR_INIT_PROMPT,
   CURATOR_PHASE_PROMPT,
@@ -140,7 +161,7 @@ import {
   listActive,
   subscribe,
   unsubscribe
-} from "./index-91ybfvy2.js";
+} from "./index-mc9qgkwd.js";
 import {
   clearWorktreeMergeStatus,
   getAllWorktreeMergeFailures,
@@ -152,33 +173,40 @@ import {
   listCoderSettlementWalStates,
   recoverCoderSettlement,
   recoverStaleCoderSettlements
-} from "./index-r4qxngnx.js";
+} from "./index-hrrzxz3q.js";
+import {
+  parsePorcelainV2Snapshot,
+  resolveCommitCountSince,
+  resolveCommitCountSinceAsync,
+  resolveCurrentGitHead,
+  resolveCurrentGitHeadAsync,
+  resolveCurrentLocalHeadRefAsync,
+  resolveCurrentUpstreamPushTarget,
+  resolveCurrentUpstreamPushTargetAsync,
+  resolveCurrentUpstreamRemoteRef,
+  resolveExactRemoteBranchHead,
+  resolveExactRemoteBranchHeadAsync,
+  resolveIsExactSingleChildCommit,
+  resolveIsExactSingleChildCommitAsync,
+  resolveIsWorkingTreeClean,
+  resolveIsWorkingTreeCleanAsync,
+  resolvePrFeedbackTrackingCandidatesAsync,
+  resolvePrReviewDiffStats,
+  resolvePrReviewDiffStatsAsync,
+  resolvePrWorkflowRevisionDigest,
+  resolvePrWorkflowRevisionDigestDetailed,
+  resolvePrWorkflowRevisionDigestDetailedAsync,
+  resolveRemoteRefsContainingHead,
+  resolveRemoteRefsContainingHeadAsync,
+  resolveRemoteUrlIdentity,
+  resolveRemoteUrlIdentityAsync,
+  switchPrFeedbackTrackingCandidateAsync
+} from "./index-3f7hqtgg.js";
 import {
   WORKTREE_LIFECYCLE_LOCK_FILE,
   recordWorktreeProvisioningOwner,
   removeWorktreeProvisioningOwner
-} from "./index-dwkrdpz2.js";
-import {
-  BUNDLED_PROJECT_SKILL_ROOT,
-  DEFAULT_SKILL_MIN_CONFIDENCE,
-  DEFAULT_SKILL_MIN_CONFIRMATIONS,
-  appendRejectedSkillEdit,
-  appendSkillChangelog,
-  autoApplyProposals,
-  bundledProjectSkillFileReference,
-  evaluateSkillChange,
-  findSkillsBySourceKnowledgeId,
-  findStaleSkillsBySourceKnowledgeId,
-  generateSkills,
-  isRejectedSkillContent,
-  listSkills,
-  parseDraftFrontmatter,
-  regenerateSkill,
-  retireOrMarkStale,
-  retireSkill,
-  selectCandidateEntries,
-  syncBundledProjectSkillsIfMissingAsync
-} from "./index-n9hecanw.js";
+} from "./index-8fqb0ynp.js";
 import {
   appendUnactionable,
   quarantineEntry,
@@ -189,11 +217,11 @@ import {
   validateActionableFields,
   validateLesson,
   validateSkillPath
-} from "./index-1vjjh2gp.js";
+} from "./index-tppnfxkm.js";
 import {
   authorizeCuration,
   buildConfigFingerprintInput
-} from "./index-gpf3cjre.js";
+} from "./index-pfnj5pvs.js";
 import {
   cohortConfigFingerprint
 } from "./index-rtry5xyf.js";
@@ -224,12 +252,12 @@ import {
   transitionTaskWorkflowEvidence,
   withTaskEvidenceTransaction,
   writeWorkflowWalFile
-} from "./index-ybvtfthv.js";
+} from "./index-2j07670d.js";
 import {
   makeWorktreeBranchName,
   provisionWorktree,
   removeWorktree
-} from "./index-e7m7g2f9.js";
+} from "./index-t8g88esk.js";
 import {
   DEFAULT_STALE_DELEGATION_TIMEOUT_MS,
   DELEGATION_COMPACTION_HIGH_WATER_BYTES,
@@ -244,46 +272,18 @@ import {
   scanBackgroundCoderReservationsForAdmission,
   scanDelegationsForRecovery,
   sweepStaleDelegations
-} from "./index-az2sga91.js";
+} from "./index-zy60xd05.js";
 import {
   compositeSessionKey,
   sessionKeySuffix
 } from "./index-ddszzne4.js";
-import {
-  parsePorcelainV2Snapshot,
-  resolveCommitCountSince,
-  resolveCommitCountSinceAsync,
-  resolveCurrentGitHead,
-  resolveCurrentGitHeadAsync,
-  resolveCurrentLocalHeadRefAsync,
-  resolveCurrentUpstreamPushTarget,
-  resolveCurrentUpstreamPushTargetAsync,
-  resolveCurrentUpstreamRemoteRef,
-  resolveExactRemoteBranchHead,
-  resolveExactRemoteBranchHeadAsync,
-  resolveIsExactSingleChildCommit,
-  resolveIsExactSingleChildCommitAsync,
-  resolveIsWorkingTreeClean,
-  resolveIsWorkingTreeCleanAsync,
-  resolvePrFeedbackTrackingCandidatesAsync,
-  resolvePrReviewDiffStats,
-  resolvePrReviewDiffStatsAsync,
-  resolvePrWorkflowRevisionDigest,
-  resolvePrWorkflowRevisionDigestDetailed,
-  resolvePrWorkflowRevisionDigestDetailedAsync,
-  resolveRemoteRefsContainingHead,
-  resolveRemoteRefsContainingHeadAsync,
-  resolveRemoteUrlIdentity,
-  resolveRemoteUrlIdentityAsync,
-  switchPrFeedbackTrackingCandidateAsync
-} from "./index-3f7hqtgg.js";
 import {
   MAX_PENDING_SCOPE_BINDINGS,
   canonicalWorkspaceIdentity,
   clearAllScopes,
   clearScopeBindingFromDisk,
   clearScopeBindings
-} from "./index-80qxscrc.js";
+} from "./index-dr2tfawg.js";
 import {
   appendLedgerEvent,
   computePlanHash,
@@ -298,7 +298,7 @@ import {
   readPlanEpochIdentity,
   replayFromLedgerWithStatus,
   takeSnapshotEvent
-} from "./index-pr6a7669.js";
+} from "./index-203fqkqk.js";
 import {
   CORE_EVENT_LOCKED,
   appendCoreEventSync,
@@ -357,7 +357,7 @@ import {
   transactFile,
   transactKnowledge,
   wordBigrams
-} from "./index-q24ffxx6.js";
+} from "./index-xscjecyq.js";
 import {
   MAX_EVENT_LOG_ENTRIES,
   _internals as _internals2,
@@ -373,10 +373,10 @@ import {
   recordKnowledgeEvent,
   recordPhaseCloseIntent,
   resolveKnowledgeEventsPath
-} from "./index-sdde1nvx.js";
+} from "./index-5erwyk1b.js";
 import {
   resolveWorktreeIsolationConfig
-} from "./index-n3362zjr.js";
+} from "./index-6x9jq0cd.js";
 import {
   RetrospectiveEvidenceSchema
 } from "./index-gprxjmm7.js";
@@ -399,7 +399,7 @@ import {
   init_loader,
   loadPluginConfig,
   loadPluginConfigWithMeta
-} from "./index-gg70afs7.js";
+} from "./index-jz216dhj.js";
 import {
   DEFAULT_HARNESS_EVOLUTION_CONFIG,
   DEFAULT_PR_REVIEW_RESILIENCE_CONFIG,
@@ -415,7 +415,17 @@ import {
   package_default,
   resolveAutoReviewConfig,
   stripKnownSwarmPrefix
-} from "./index-14awxpgt.js";
+} from "./index-mt6qjp4c.js";
+import {
+  init_git_executable,
+  resolveGitExecutable,
+  resolveGitExecutableAsync
+} from "./index-9e6fdz2h.js";
+import {
+  advisoryWarn,
+  getDeferredWarnings,
+  init_warning_buffer
+} from "./index-4rhhvd1a.js";
 import {
   AGENT_TOOL_MAP,
   ALL_AGENT_NAMES,
@@ -429,17 +439,7 @@ import {
   init_agent_names,
   init_constants,
   init_tool_metadata
-} from "./index-9r7gp6cp.js";
-import {
-  init_git_executable,
-  resolveGitExecutable,
-  resolveGitExecutableAsync
-} from "./index-9e6fdz2h.js";
-import {
-  advisoryWarn,
-  getDeferredWarnings,
-  init_warning_buffer
-} from "./index-4rhhvd1a.js";
+} from "./index-yt75r1er.js";
 import {
   resolveHiveDataDir,
   resolveHiveEventsPath,
@@ -455,10 +455,10 @@ import {
   resolveLinkDir,
   sanitizeLinkId,
   writeLinkPointer
-} from "./index-b5xm177r.js";
+} from "./index-5zgf140g.js";
 import {
   atomicWriteFile
-} from "./index-xe6zbfps.js";
+} from "./index-h52hs4e9.js";
 import {
   KNOWLEDGE_SCHEMA_VERSION,
   OUTCOME_BLOCK_THRESHOLD,
@@ -470,7 +470,7 @@ import {
   atomicWriteSwarmFileSync,
   matchTempGrammar,
   parseTargetBasename
-} from "./index-6sbx96v6.js";
+} from "./index-zcmwwp1x.js";
 import {
   assertProjectRoot,
   hasExplicitProjectBoundary,
@@ -6924,6 +6924,355 @@ import { readFileSync as readFileSync5, statSync as statSync5 } from "fs";
 import * as fsp2 from "fs/promises";
 import * as path12 from "path";
 
+// src/background/pr-review-contract.ts
+init_zod();
+var PR_REVIEW_REVIEWER_CLASSIFICATIONS = [
+  "CONFIRMED",
+  "DISPROVED",
+  "UNVERIFIED",
+  "PRE_EXISTING"
+];
+var PR_REVIEW_REVIEWER_EVIDENCE_TYPES = [
+  "STRUCTURALLY_PROVEN",
+  "EXECUTION_PROVEN",
+  "STATIC_TRACE_PROVEN",
+  "PLAUSIBLE_BUT_UNVERIFIED"
+];
+var PR_REVIEW_SEVERITIES = [
+  "CRITICAL",
+  "HIGH",
+  "MEDIUM",
+  "LOW",
+  "INFO",
+  "NONE"
+];
+var PR_REVIEW_CRITIC_STATUSES = [
+  "UPHELD",
+  "DOWNGRADED",
+  "DISPROVED",
+  "NEEDS_MORE_EVIDENCE"
+];
+var PR_REVIEW_FINDING_STATUSES = [
+  "PENDING",
+  "CONFIRMED",
+  "DISPROVED",
+  "PRE_EXISTING"
+];
+var PR_REVIEW_FINDING_ACTIONS = [
+  "route_to_reviewer",
+  "route_to_critic",
+  "report",
+  "suppress_with_reason",
+  "handoff_to_feedback"
+];
+var PR_REVIEW_ARTIFACT_BOUNDARIES = [
+  "post_explorer",
+  "post_reviewer",
+  "post_critic"
+];
+var PR_REVIEW_BASE_DIMENSION_IDS = [
+  "intent-architecture",
+  "correctness-state",
+  "tests-falsifiability",
+  "security-trust",
+  "reliability-performance",
+  "compatibility-delivery"
+];
+var PR_REVIEW_RISK_IMPACTS = [
+  "ORDINARY",
+  "HIGH_IMPACT",
+  "UNKNOWN"
+];
+var PR_REVIEW_RISK_TAGS = [
+  "SECURITY",
+  "AUTH_PERMISSIONS",
+  "STATE_INTEGRITY",
+  "WRITE_PATH",
+  "EVIDENCE_INTEGRITY",
+  "GIT",
+  "CONFIGURATION"
+];
+var PR_REVIEW_FINDINGS_MAX_BYTES = 10 * 1024 * 1024;
+var PR_REVIEW_FINDINGS_WRITE_MAX_BYTES = 3 * 1024 * 1024;
+var PR_REVIEW_HANDOFF_MAX_BYTES = 128 * 1024;
+var PR_REVIEW_HANDOFF_WRITE_MAX_BYTES = 120 * 1024;
+var PR_REVIEW_DISCARDED_EXAMPLE_ITEM_ID = "discarded-id";
+function serializedPrReviewArtifactInputBytes(value) {
+  return new TextEncoder().encode(JSON.stringify(value)).byteLength;
+}
+var PrReviewRunIdSchema = exports_external.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/, "run_id must be a safe relative identifier");
+var PrReviewFindingSchema = exports_external.object({
+  finding_id: exports_external.string().trim().min(1).max(128),
+  status: exports_external.enum(PR_REVIEW_FINDING_STATUSES),
+  file_line: exports_external.string().trim().min(1).max(1000),
+  evidence: exports_external.string().trim().min(1).max(20000),
+  next_action: exports_external.enum(PR_REVIEW_FINDING_ACTIONS),
+  severity: exports_external.enum(PR_REVIEW_SEVERITIES).optional(),
+  category: exports_external.string().trim().min(1).max(128).optional(),
+  risk_impact: exports_external.enum(PR_REVIEW_RISK_IMPACTS).optional(),
+  risk_tags: exports_external.array(exports_external.enum(PR_REVIEW_RISK_TAGS)).max(PR_REVIEW_RISK_TAGS.length).optional()
+}).strict().superRefine((value, ctx) => {
+  if (value.status !== "CONFIRMED")
+    return;
+  if (value.risk_impact === undefined) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["risk_impact"],
+      message: "is required on every newly written CONFIRMED finding (issue #2383 typed critic routing)"
+    });
+  }
+  if (value.risk_tags === undefined) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["risk_tags"],
+      message: "is required on every newly written CONFIRMED finding (issue #2383 typed critic routing)"
+    });
+  }
+});
+function prReviewFindingRequiresCritic(input) {
+  if (input.classification !== "CONFIRMED")
+    return false;
+  const impact = input.risk_impact ?? "UNKNOWN";
+  const tags = input.risk_tags ?? [];
+  if (impact === "UNKNOWN")
+    return true;
+  if (input.severity === undefined)
+    return true;
+  if (input.severity === "CRITICAL" || input.severity === "HIGH")
+    return true;
+  if (input.severity === "MEDIUM") {
+    return impact === "HIGH_IMPACT" || tags.length > 0;
+  }
+  return false;
+}
+var PrReviewHandoffSchema = exports_external.object({
+  pr_url: exports_external.string().url().max(2000),
+  finding_ids: exports_external.array(exports_external.string().trim().min(1).max(128)).min(1).max(1000),
+  summary: exports_external.string().trim().min(1).max(20000),
+  provenance: exports_external.array(exports_external.string().trim().min(1).max(4000)).min(1).max(1000)
+}).strict();
+var PrReviewPartialBaseCoverageSchema = exports_external.object({
+  unresolved_dimensions: exports_external.array(exports_external.enum(PR_REVIEW_BASE_DIMENSION_IDS)).min(1).max(PR_REVIEW_BASE_DIMENSION_IDS.length)
+}).strict().superRefine((value, ctx) => {
+  const seen = new Set;
+  for (const dimension of value.unresolved_dimensions) {
+    if (seen.has(dimension)) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["unresolved_dimensions"],
+        message: `must not contain duplicate dimension "${dimension}"`
+      });
+      return;
+    }
+    seen.add(dimension);
+  }
+});
+var WritePrReviewArtifactArgsSchema = exports_external.discriminatedUnion("kind", [
+  exports_external.object({
+    kind: exports_external.literal("findings"),
+    run_id: PrReviewRunIdSchema.optional(),
+    pr_head_sha: exports_external.string().trim().regex(/^[0-9a-f]{6,64}$/i),
+    boundary: exports_external.enum(PR_REVIEW_ARTIFACT_BOUNDARIES),
+    records: exports_external.array(PrReviewFindingSchema).min(1).max(1000),
+    partial_base_coverage: PrReviewPartialBaseCoverageSchema.optional()
+  }).strict(),
+  exports_external.object({
+    kind: exports_external.literal("handoff"),
+    run_id: PrReviewRunIdSchema.optional(),
+    pr_head_sha: exports_external.string().trim().regex(/^[0-9a-f]{6,64}$/i),
+    handoff: PrReviewHandoffSchema
+  }).strict()
+]).superRefine((value, ctx) => {
+  if (value.kind === "findings" && value.partial_base_coverage !== undefined && value.boundary !== "post_explorer") {
+    ctx.addIssue({
+      code: "custom",
+      path: ["partial_base_coverage"],
+      message: "is valid only for the post_explorer boundary"
+    });
+  }
+  const bytes = serializedPrReviewArtifactInputBytes(value);
+  const maxBytes = value.kind === "findings" ? PR_REVIEW_FINDINGS_WRITE_MAX_BYTES : PR_REVIEW_HANDOFF_WRITE_MAX_BYTES;
+  if (bytes > maxBytes) {
+    ctx.addIssue({
+      code: "custom",
+      path: [value.kind === "findings" ? "records" : "handoff"],
+      message: `serialized UTF-8 payload must be at most ${maxBytes} bytes (got ${bytes})`
+    });
+  }
+});
+var introducedByPrSchema = exports_external.string().regex(/^(?:introduced_by_pr\s*:\s*)?(?:YES|NO|UNKNOWN)$/i);
+var PrReviewRiskTagsFieldPattern = new RegExp(`^(?:(?:${PR_REVIEW_RISK_TAGS.join("|")})(?:,(?:${PR_REVIEW_RISK_TAGS.join("|")}))*)?$`);
+var PrReviewRiskTagsFieldSchema = exports_external.string().regex(PrReviewRiskTagsFieldPattern, `must be a comma-separated subset of the canonical risk tags (${PR_REVIEW_RISK_TAGS.join(", ")}), or empty`);
+var PR_REVIEW_REVIEWER_LEGACY_FIELD_COUNT = 10;
+function parsePrReviewRiskTagsField(field) {
+  const trimmed = field.trim();
+  if (!trimmed)
+    return [];
+  return trimmed.split(",").map((tag) => tag.trim());
+}
+var PrReviewReviewerVerdictFieldsSchema = exports_external.tuple([
+  exports_external.literal("[REVIEWED]"),
+  exports_external.string().min(1),
+  exports_external.enum(PR_REVIEW_REVIEWER_CLASSIFICATIONS),
+  exports_external.enum(PR_REVIEW_REVIEWER_EVIDENCE_TYPES),
+  exports_external.enum(PR_REVIEW_SEVERITIES),
+  introducedByPrSchema,
+  exports_external.string().min(1),
+  exports_external.string().min(8),
+  exports_external.string().min(5),
+  exports_external.string().min(3),
+  exports_external.enum(PR_REVIEW_RISK_IMPACTS),
+  PrReviewRiskTagsFieldSchema
+]).superRefine((fields, ctx) => {
+  if (fields[2] === "DISPROVED" && fields[4] !== "NONE") {
+    ctx.addIssue({
+      code: "custom",
+      path: [4],
+      message: "DISPROVED reviewer severity must be NONE"
+    });
+  }
+});
+var PrReviewCriticVerdictFieldsSchema = exports_external.tuple([
+  exports_external.literal("[CRITIC]"),
+  exports_external.string().min(1),
+  exports_external.enum(PR_REVIEW_CRITIC_STATUSES),
+  exports_external.enum(PR_REVIEW_SEVERITIES),
+  exports_external.string().min(6),
+  exports_external.string().min(6)
+]).superRefine((fields, ctx) => {
+  const status = fields[2];
+  const severity = fields[3];
+  if (status === "NEEDS_MORE_EVIDENCE") {
+    ctx.addIssue({
+      code: "custom",
+      path: [2],
+      message: "NEEDS_MORE_EVIDENCE is not a terminal transport verdict"
+    });
+  }
+  if (status === "DISPROVED" && severity !== "NONE") {
+    ctx.addIssue({
+      code: "custom",
+      path: [3],
+      message: "DISPROVED critic severity must be NONE"
+    });
+  }
+  if (status === "UPHELD" && !["CRITICAL", "HIGH", "MEDIUM"].includes(severity)) {
+    ctx.addIssue({
+      code: "custom",
+      path: [3],
+      message: "UPHELD critic severity must be CRITICAL, HIGH, or MEDIUM"
+    });
+  }
+  if (status === "DOWNGRADED" && severity === "CRITICAL") {
+    ctx.addIssue({
+      code: "custom",
+      path: [3],
+      message: "DOWNGRADED critic severity cannot be CRITICAL"
+    });
+  }
+});
+var PR_REVIEW_VERDICT_ROW_DESCRIPTORS = {
+  reviewer: {
+    marker: "[REVIEWED]",
+    fieldCount: 12,
+    fieldRoles: [
+      "marker",
+      "item_id",
+      "classification",
+      "evidence_type",
+      "severity",
+      "introduced_by_pr",
+      "file:line",
+      "rationale",
+      "probe",
+      "reviewer_notes",
+      "risk_impact",
+      "risk_tags"
+    ],
+    schema: PrReviewReviewerVerdictFieldsSchema
+  },
+  critic: {
+    marker: "[CRITIC]",
+    fieldCount: 6,
+    fieldRoles: [
+      "marker",
+      "item_id",
+      "status",
+      "severity",
+      "rationale",
+      "required_change"
+    ],
+    schema: PrReviewCriticVerdictFieldsSchema
+  }
+};
+function parsePrReviewVerdictRow(line, kind) {
+  const descriptor = PR_REVIEW_VERDICT_ROW_DESCRIPTORS[kind];
+  const fields = [];
+  let current = "";
+  let usedCanonicalEscape = false;
+  for (let index = 0;index < line.length; index++) {
+    const char = line[index];
+    if (char === "\\") {
+      const next = line[index + 1];
+      if (next === "\\") {
+        current += "\\";
+        usedCanonicalEscape = true;
+        index++;
+        continue;
+      }
+      if (next === "|") {
+        current += "|";
+        usedCanonicalEscape = true;
+        index++;
+        continue;
+      }
+      if (next === "n") {
+        current += `
+`;
+        usedCanonicalEscape = true;
+        index++;
+        continue;
+      }
+      if (next === "r") {
+        current += "\r";
+        usedCanonicalEscape = true;
+        index++;
+        continue;
+      }
+      current += "\\";
+      continue;
+    }
+    if (char === "|") {
+      fields.push(current.trim());
+      current = "";
+      continue;
+    }
+    current += char;
+  }
+  fields.push(current.trim());
+  if (fields[0] !== descriptor.marker)
+    return null;
+  if (kind === "reviewer" && fields.length === PR_REVIEW_REVIEWER_LEGACY_FIELD_COUNT) {
+    fields.push("UNKNOWN", "");
+  }
+  if (fields.length > descriptor.fieldCount) {
+    const retained = fields.slice(0, descriptor.fieldCount - 1);
+    retained.push(fields.slice(descriptor.fieldCount - 1).join("|"));
+    return {
+      marker: descriptor.marker,
+      fields: retained,
+      recoveredOverflow: true,
+      overflowClass: fields.length === descriptor.fieldCount + 1 && fields[fields.length - 1] === "" ? "legacy-fidelity-safe" : "legacy-lossy"
+    };
+  }
+  return {
+    marker: descriptor.marker,
+    fields,
+    recoveredOverflow: false,
+    overflowClass: fields.length === descriptor.fieldCount ? usedCanonicalEscape ? "canonical" : "legacy-fidelity-safe" : "legacy-lossy"
+  };
+}
+
 // src/background/candidate-contract.ts
 var CANDIDATE_SEVERITIES = [
   "INFO",
@@ -6934,7 +7283,8 @@ var CANDIDATE_SEVERITIES = [
 ];
 var FINDINGS_SEVERITIES = [...CANDIDATE_SEVERITIES, "NONE"];
 var CANDIDATE_CONFIDENCES = ["HIGH", "MEDIUM", "LOW"];
-var CANDIDATE_FIELD_COUNT = 9;
+var CANDIDATE_FIELD_COUNT = 11;
+var CANDIDATE_LEGACY_FIELD_COUNT = 9;
 var CLEAN_FIELD_COUNT = 4;
 var CLEAN_COVERAGE_SCOPE_MIN_CHARS = 12;
 var CLEAN_EVIDENCE_MIN_CHARS = 20;
@@ -6949,7 +7299,9 @@ var CANDIDATE_FIELDS = {
     "claim",
     "evidence_summary",
     "impact_context",
-    "confidence"
+    "confidence",
+    "risk_impact",
+    "risk_tags"
   ],
   micro_lane: [
     "candidate_id",
@@ -6960,9 +7312,15 @@ var CANDIDATE_FIELDS = {
     "claim",
     "invariant_violated",
     "evidence_summary",
-    "confidence"
+    "confidence",
+    "risk_impact",
+    "risk_tags"
   ]
 };
+var CANDIDATE_REQUIRED_FIELDS = {
+  base_explorer: CANDIDATE_FIELDS.base_explorer.filter((field) => field !== "risk_impact" && field !== "risk_tags"),
+  micro_lane: CANDIDATE_FIELDS.micro_lane.filter((field) => field !== "risk_impact" && field !== "risk_tags")
+};
 var CANDIDATE_MARKER = "[CANDIDATE]";
 var CLEAN_MARKER = "[CLEAN]";
 function formatCandidateHeader(family) {
@@ -7186,22 +7544,19 @@ function repairCandidateEvidencePipes(text, family) {
   let repaired = false;
   const lines = text.split(/\r?\n/).map((line) => {
     const fields = splitPipeFields(line);
-    if (fields[0]?.trim() !== CANDIDATE_MARKER || fields.length <= CANDIDATE_FIELD_COUNT + 1 || fields.length > CANDIDATE_FIELD_COUNT + 17 || !isCandidateConfidence(fields.at(-1)?.trim())) {
+    const tailLength = family === "base_explorer" ? 4 : 3;
+    if (fields[0]?.trim() !== CANDIDATE_MARKER || fields.length <= CANDIDATE_FIELD_COUNT + 1 || fields.length > CANDIDATE_FIELD_COUNT + 17 || !isCandidateConfidence(fields.at(-3)?.trim())) {
       return line;
     }
     const normalized = fields.map(escapeCandidateField);
-    const overflowEvidence = family === "base_explorer" ? normalized.slice(7, -2) : normalized.slice(8, -1);
+    const overflowEvidence = normalized.slice(family === "base_explorer" ? 7 : 8, -tailLength);
     if (overflowEvidence.length < 3 || overflowEvidence.some((fragment) => fragment.length < 4)) {
       return line;
     }
-    const rebuilt = family === "base_explorer" ? [
-      ...normalized.slice(0, 7),
+    const rebuilt = [
+      ...normalized.slice(0, family === "base_explorer" ? 7 : 8),
       overflowEvidence.join(" \\| "),
-      ...normalized.slice(-2)
-    ] : [
-      ...normalized.slice(0, 8),
-      overflowEvidence.join(" \\| "),
-      normalized.at(-1) ?? ""
+      ...normalized.slice(-tailLength)
     ];
     if (rebuilt.length !== CANDIDATE_FIELD_COUNT + 1)
       return line;
@@ -7484,7 +7839,7 @@ function analyzeCandidateFields(fields, family) {
     const name = names[index];
     const value = trimmed[index]?.trim() || null;
     values[name] = value;
-    if (value === null) {
+    if (value === null && name !== "risk_impact" && name !== "risk_tags") {
       issues.push({
         field: name,
         message: `Missing required field: ${name}`
@@ -7505,6 +7860,24 @@ function analyzeCandidateFields(fields, family) {
       message: `Invalid confidence: ${candidateDiagnosticPreview(confidence)}; expected ${CANDIDATE_CONFIDENCES.join("|")}`
     });
   }
+  const riskImpact = values.risk_impact;
+  if (riskImpact !== null && !PR_REVIEW_RISK_IMPACTS.includes(riskImpact)) {
+    issues.push({
+      field: "risk_impact",
+      message: `Invalid risk_impact: ${candidateDiagnosticPreview(riskImpact)}; expected ${PR_REVIEW_RISK_IMPACTS.join("|")}`
+    });
+  }
+  const riskTags = values.risk_tags;
+  if (riskTags !== null) {
+    const parsedTags = parsePrReviewRiskTagsField(riskTags);
+    const known = new Set(PR_REVIEW_RISK_TAGS);
+    if (riskTags !== "" && (parsedTags.length === 0 || parsedTags.some((tag) => !known.has(tag)))) {
+      issues.push({
+        field: "risk_tags",
+        message: `Invalid risk_tags: ${candidateDiagnosticPreview(riskTags)}; expected a comma-separated subset of ${PR_REVIEW_RISK_TAGS.join("|")}, or empty`
+      });
+    }
+  }
   return {
     valid: issues.length === 0,
     issues,
@@ -7671,7 +8044,9 @@ var SidecarCandidateCommon = {
   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)
+  confidence: exports_external.enum(CANDIDATE_CONFIDENCES),
+  risk_impact: exports_external.enum(PR_REVIEW_RISK_IMPACTS).optional(),
+  risk_tags: exports_external.array(exports_external.enum(PR_REVIEW_RISK_TAGS)).optional()
 };
 var SidecarCandidateSchema = exports_external.discriminatedUnion("row_format_family", [
   exports_external.object({
@@ -7765,7 +8140,7 @@ function mapFields(fields, family) {
   return result;
 }
 function getRequiredFields(family) {
-  return CANDIDATE_FIELDS[family];
+  return CANDIDATE_REQUIRED_FIELDS[family];
 }
 function assertNonNullCandidateId(value) {
   if (value === null || value === "") {
@@ -7993,6 +8368,9 @@ function parseText(input, flags) {
     if (hadCandidateMarker) {
       fields = fields.slice(1);
     }
+    if (fields.length === CANDIDATE_LEGACY_FIELD_COUNT) {
+      fields = [...fields, "UNKNOWN", ""];
+    }
     if (fields.length < CANDIDATE_FIELD_COUNT) {
       if (isCandidateLookingShortRow(fields, flags, hadCandidateMarker)) {
         parseErrorDetails.push({
@@ -8120,7 +8498,9 @@ ${trimmed}`;
       evidence_summary: mapped.evidence_summary,
       impact_context: mapped.impact_context,
       invariant_violated: mapped.invariant_violated,
-      confidence: mapped.confidence
+      confidence: mapped.confidence,
+      risk_impact: mapped.risk_impact ?? "UNKNOWN",
+      risk_tags: mapped.risk_tags ? parsePrReviewRiskTagsField(mapped.risk_tags) : []
     };
     const cid = candidate.candidate_id;
     idCounts.set(cid, (idCounts.get(cid) ?? 0) + 1);
@@ -8284,276 +8664,6 @@ function digestText(text) {
   return createHash5("sha256").update(text).digest("hex");
 }
 
-// src/background/pr-review-contract.ts
-init_zod();
-var PR_REVIEW_REVIEWER_CLASSIFICATIONS = [
-  "CONFIRMED",
-  "DISPROVED",
-  "UNVERIFIED",
-  "PRE_EXISTING"
-];
-var PR_REVIEW_REVIEWER_EVIDENCE_TYPES = [
-  "STRUCTURALLY_PROVEN",
-  "EXECUTION_PROVEN",
-  "STATIC_TRACE_PROVEN",
-  "PLAUSIBLE_BUT_UNVERIFIED"
-];
-var PR_REVIEW_SEVERITIES = [
-  "CRITICAL",
-  "HIGH",
-  "MEDIUM",
-  "LOW",
-  "INFO",
-  "NONE"
-];
-var PR_REVIEW_CRITIC_STATUSES = [
-  "UPHELD",
-  "DOWNGRADED",
-  "DISPROVED",
-  "NEEDS_MORE_EVIDENCE"
-];
-var PR_REVIEW_FINDING_STATUSES = [
-  "PENDING",
-  "CONFIRMED",
-  "DISPROVED",
-  "PRE_EXISTING"
-];
-var PR_REVIEW_FINDING_ACTIONS = [
-  "route_to_reviewer",
-  "route_to_critic",
-  "report",
-  "suppress_with_reason",
-  "handoff_to_feedback"
-];
-var PR_REVIEW_ARTIFACT_BOUNDARIES = [
-  "post_explorer",
-  "post_reviewer",
-  "post_critic"
-];
-var PR_REVIEW_FINDINGS_MAX_BYTES = 10 * 1024 * 1024;
-var PR_REVIEW_FINDINGS_WRITE_MAX_BYTES = 3 * 1024 * 1024;
-var PR_REVIEW_HANDOFF_MAX_BYTES = 128 * 1024;
-var PR_REVIEW_HANDOFF_WRITE_MAX_BYTES = 120 * 1024;
-var PR_REVIEW_DISCARDED_EXAMPLE_ITEM_ID = "discarded-id";
-function serializedPrReviewArtifactInputBytes(value) {
-  return new TextEncoder().encode(JSON.stringify(value)).byteLength;
-}
-var PrReviewRunIdSchema = exports_external.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/, "run_id must be a safe relative identifier");
-var PrReviewFindingSchema = exports_external.object({
-  finding_id: exports_external.string().trim().min(1).max(128),
-  status: exports_external.enum(PR_REVIEW_FINDING_STATUSES),
-  file_line: exports_external.string().trim().min(1).max(1000),
-  evidence: exports_external.string().trim().min(1).max(20000),
-  next_action: exports_external.enum(PR_REVIEW_FINDING_ACTIONS),
-  severity: exports_external.enum(PR_REVIEW_SEVERITIES).optional(),
-  category: exports_external.string().trim().min(1).max(128).optional()
-}).strict();
-var PrReviewHandoffSchema = exports_external.object({
-  pr_url: exports_external.string().url().max(2000),
-  finding_ids: exports_external.array(exports_external.string().trim().min(1).max(128)).min(1).max(1000),
-  summary: exports_external.string().trim().min(1).max(20000),
-  provenance: exports_external.array(exports_external.string().trim().min(1).max(4000)).min(1).max(1000)
-}).strict();
-var PrReviewPartialBaseCoverageSchema = exports_external.object({
-  missing_dimension: exports_external.enum([
-    "intent-architecture",
-    "correctness-state",
-    "tests-falsifiability",
-    "security-trust",
-    "reliability-performance",
-    "compatibility-delivery"
-  ])
-}).strict();
-var WritePrReviewArtifactArgsSchema = exports_external.discriminatedUnion("kind", [
-  exports_external.object({
-    kind: exports_external.literal("findings"),
-    run_id: PrReviewRunIdSchema.optional(),
-    pr_head_sha: exports_external.string().trim().regex(/^[0-9a-f]{6,64}$/i),
-    boundary: exports_external.enum(PR_REVIEW_ARTIFACT_BOUNDARIES),
-    records: exports_external.array(PrReviewFindingSchema).min(1).max(1000),
-    partial_base_coverage: PrReviewPartialBaseCoverageSchema.optional()
-  }).strict(),
-  exports_external.object({
-    kind: exports_external.literal("handoff"),
-    run_id: PrReviewRunIdSchema.optional(),
-    pr_head_sha: exports_external.string().trim().regex(/^[0-9a-f]{6,64}$/i),
-    handoff: PrReviewHandoffSchema
-  }).strict()
-]).superRefine((value, ctx) => {
-  if (value.kind === "findings" && value.partial_base_coverage !== undefined && value.boundary !== "post_explorer") {
-    ctx.addIssue({
-      code: "custom",
-      path: ["partial_base_coverage"],
-      message: "is valid only for the post_explorer boundary"
-    });
-  }
-  const bytes = serializedPrReviewArtifactInputBytes(value);
-  const maxBytes = value.kind === "findings" ? PR_REVIEW_FINDINGS_WRITE_MAX_BYTES : PR_REVIEW_HANDOFF_WRITE_MAX_BYTES;
-  if (bytes > maxBytes) {
-    ctx.addIssue({
-      code: "custom",
-      path: [value.kind === "findings" ? "records" : "handoff"],
-      message: `serialized UTF-8 payload must be at most ${maxBytes} bytes (got ${bytes})`
-    });
-  }
-});
-var introducedByPrSchema = exports_external.string().regex(/^(?:introduced_by_pr\s*:\s*)?(?:YES|NO|UNKNOWN)$/i);
-var PrReviewReviewerVerdictFieldsSchema = exports_external.tuple([
-  exports_external.literal("[REVIEWED]"),
-  exports_external.string().min(1),
-  exports_external.enum(PR_REVIEW_REVIEWER_CLASSIFICATIONS),
-  exports_external.enum(PR_REVIEW_REVIEWER_EVIDENCE_TYPES),
-  exports_external.enum(PR_REVIEW_SEVERITIES),
-  introducedByPrSchema,
-  exports_external.string().min(1),
-  exports_external.string().min(8),
-  exports_external.string().min(5),
-  exports_external.string().min(3)
-]).superRefine((fields, ctx) => {
-  if (fields[2] === "DISPROVED" && fields[4] !== "NONE") {
-    ctx.addIssue({
-      code: "custom",
-      path: [4],
-      message: "DISPROVED reviewer severity must be NONE"
-    });
-  }
-});
-var PrReviewCriticVerdictFieldsSchema = exports_external.tuple([
-  exports_external.literal("[CRITIC]"),
-  exports_external.string().min(1),
-  exports_external.enum(PR_REVIEW_CRITIC_STATUSES),
-  exports_external.enum(PR_REVIEW_SEVERITIES),
-  exports_external.string().min(6),
-  exports_external.string().min(6)
-]).superRefine((fields, ctx) => {
-  const status = fields[2];
-  const severity = fields[3];
-  if (status === "NEEDS_MORE_EVIDENCE") {
-    ctx.addIssue({
-      code: "custom",
-      path: [2],
-      message: "NEEDS_MORE_EVIDENCE is not a terminal transport verdict"
-    });
-  }
-  if (status === "DISPROVED" && severity !== "NONE") {
-    ctx.addIssue({
-      code: "custom",
-      path: [3],
-      message: "DISPROVED critic severity must be NONE"
-    });
-  }
-  if (status === "UPHELD" && !["CRITICAL", "HIGH", "MEDIUM"].includes(severity)) {
-    ctx.addIssue({
-      code: "custom",
-      path: [3],
-      message: "UPHELD critic severity must be CRITICAL, HIGH, or MEDIUM"
-    });
-  }
-  if (status === "DOWNGRADED" && severity === "CRITICAL") {
-    ctx.addIssue({
-      code: "custom",
-      path: [3],
-      message: "DOWNGRADED critic severity cannot be CRITICAL"
-    });
-  }
-});
-var PR_REVIEW_VERDICT_ROW_DESCRIPTORS = {
-  reviewer: {
-    marker: "[REVIEWED]",
-    fieldCount: 10,
-    fieldRoles: [
-      "marker",
-      "item_id",
-      "classification",
-      "evidence_type",
-      "severity",
-      "introduced_by_pr",
-      "file:line",
-      "rationale",
-      "probe",
-      "reviewer_notes"
-    ],
-    schema: PrReviewReviewerVerdictFieldsSchema
-  },
-  critic: {
-    marker: "[CRITIC]",
-    fieldCount: 6,
-    fieldRoles: [
-      "marker",
-      "item_id",
-      "status",
-      "severity",
-      "rationale",
-      "required_change"
-    ],
-    schema: PrReviewCriticVerdictFieldsSchema
-  }
-};
-function parsePrReviewVerdictRow(line, kind) {
-  const descriptor = PR_REVIEW_VERDICT_ROW_DESCRIPTORS[kind];
-  const fields = [];
-  let current = "";
-  let usedCanonicalEscape = false;
-  for (let index = 0;index < line.length; index++) {
-    const char = line[index];
-    if (char === "\\") {
-      const next = line[index + 1];
-      if (next === "\\") {
-        current += "\\";
-        usedCanonicalEscape = true;
-        index++;
-        continue;
-      }
-      if (next === "|") {
-        current += "|";
-        usedCanonicalEscape = true;
-        index++;
-        continue;
-      }
-      if (next === "n") {
-        current += `
-`;
-        usedCanonicalEscape = true;
-        index++;
-        continue;
-      }
-      if (next === "r") {
-        current += "\r";
-        usedCanonicalEscape = true;
-        index++;
-        continue;
-      }
-      current += "\\";
-      continue;
-    }
-    if (char === "|") {
-      fields.push(current.trim());
-      current = "";
-      continue;
-    }
-    current += char;
-  }
-  fields.push(current.trim());
-  if (fields[0] !== descriptor.marker)
-    return null;
-  if (fields.length > descriptor.fieldCount) {
-    const retained = fields.slice(0, descriptor.fieldCount - 1);
-    retained.push(fields.slice(descriptor.fieldCount - 1).join("|"));
-    return {
-      marker: descriptor.marker,
-      fields: retained,
-      recoveredOverflow: true,
-      overflowClass: fields.length === descriptor.fieldCount + 1 && fields[fields.length - 1] === "" ? "legacy-fidelity-safe" : "legacy-lossy"
-    };
-  }
-  return {
-    marker: descriptor.marker,
-    fields,
-    recoveredOverflow: false,
-    overflowClass: fields.length === descriptor.fieldCount ? usedCanonicalEscape ? "canonical" : "legacy-fidelity-safe" : "legacy-lossy"
-  };
-}
-
 // src/background/pr-review-trigger-contract.ts
 init_zod();
 var PR_REVIEW_TRIGGER_DEFINITIONS = [
@@ -9315,14 +9425,6 @@ function classifyPrReviewCircuitSignal(record) {
 }
 
 // src/hooks/pr-workflow-gate.ts
-var PR_REVIEW_BASE_DIMENSION_IDS = [
-  "intent-architecture",
-  "correctness-state",
-  "tests-falsifiability",
-  "security-trust",
-  "reliability-performance",
-  "compatibility-delivery"
-];
 var PR_REVIEW_REQUIRED_MICRO_LANE_IDS = PR_REVIEW_REQUIRED_TRIGGER_IDS;
 var PR_REVIEW_BASE_LANE_FLOORS = {
   S: 1,
@@ -9365,14 +9467,7 @@ 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",
-  "tests-falsifiability",
-  "security-trust",
-  "reliability-performance",
-  "compatibility-delivery"
-]);
+var PrReviewBaseDimensionIdSchema = exports_external.enum(PR_REVIEW_BASE_DIMENSION_IDS);
 var PrReviewBaseDispatchRecordSchema = exports_external.object({
   batchId: exports_external.string().min(1),
   lanes: exports_external.array(exports_external.object({
@@ -9404,7 +9499,65 @@ var PrReviewResilienceStateRecordSchema = exports_external.object({
   attempts: exports_external.array(PrReviewResilienceAttemptRecordSchema).max(3),
   circuit: PrReviewCircuitRecordSchema.optional()
 }).strict();
-var PrReviewPartialBaseCoverageRecordSchema = exports_external.object({
+var PR_REVIEW_FAILURE_CLASS_SAFE_DETAILS = {
+  contract: "lane failed its output contract after the bounded retry budget was exhausted",
+  resource: "lane exhausted its resource budget before producing valid output",
+  deadline: "lane passed its collection deadline without valid terminal output"
+};
+var PrReviewUnresolvedDimensionRecordSchema = exports_external.object({
+  dimension: exports_external.enum(PR_REVIEW_BASE_DIMENSION_IDS),
+  terminalState: exports_external.enum(["FAILED", "CANCELLED", "NOT_LAUNCHED"]),
+  reasonKind: exports_external.enum(["lane_failure", "cancelled", "not_launched"]),
+  failureClass: exports_external.enum(["contract", "resource", "deadline"]).optional(),
+  terminalEventId: exports_external.string().min(1).max(256).optional(),
+  batchId: exports_external.string().min(1).max(128).optional(),
+  laneId: exports_external.string().min(1).max(128).optional(),
+  safeDetail: exports_external.string().max(200).optional()
+}).strict().superRefine((value, ctx) => {
+  if (value.terminalState === "FAILED" && value.reasonKind !== "lane_failure") {
+    ctx.addIssue({
+      code: "custom",
+      path: ["reasonKind"],
+      message: 'FAILED dimensions must use reasonKind "lane_failure"'
+    });
+  }
+  if (value.terminalState === "CANCELLED" && value.reasonKind !== "cancelled" || value.terminalState === "NOT_LAUNCHED" && value.reasonKind !== "not_launched") {
+    ctx.addIssue({
+      code: "custom",
+      path: ["reasonKind"],
+      message: `reasonKind must match terminalState "${value.terminalState}"`
+    });
+  }
+  if (value.terminalState !== "FAILED" && (value.failureClass !== undefined || value.terminalEventId !== undefined)) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["failureClass"],
+      message: "failureClass/terminalEventId are legal only on FAILED dimensions"
+    });
+  }
+});
+var PrReviewPartialBaseCoverageRecordV2Schema = exports_external.object({
+  schemaVersion: exports_external.literal(2),
+  runId: exports_external.string().min(1).max(128),
+  prHeadSha: exports_external.string().regex(/^[0-9a-f]{6,64}$/i),
+  revisionDigest: exports_external.string().min(1).max(256),
+  unresolvedDimensions: exports_external.array(PrReviewUnresolvedDimensionRecordSchema).min(1).max(PR_REVIEW_BASE_DIMENSION_IDS.length),
+  admittedAt: exports_external.string().datetime()
+}).strict().superRefine((value, ctx) => {
+  const seen = new Set;
+  for (const entry of value.unresolvedDimensions) {
+    if (seen.has(entry.dimension)) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["unresolvedDimensions"],
+        message: `must not contain duplicate dimension "${entry.dimension}"`
+      });
+      return;
+    }
+    seen.add(entry.dimension);
+  }
+});
+var PrReviewPartialBaseCoverageRecordV1Schema = exports_external.object({
   runId: exports_external.string().min(1).max(128),
   prHeadSha: exports_external.string().regex(/^[0-9a-f]{6,64}$/i),
   revisionDigest: exports_external.string().min(1).max(256),
@@ -9413,6 +9566,37 @@ var PrReviewPartialBaseCoverageRecordSchema = exports_external.object({
   terminalEventId: exports_external.string().min(1).max(256),
   admittedAt: exports_external.string().datetime()
 }).strict();
+var PrReviewPartialBaseCoverageRecordSchema = exports_external.union([
+  PrReviewPartialBaseCoverageRecordV2Schema,
+  PrReviewPartialBaseCoverageRecordV1Schema
+]);
+var PrReviewDimensionCancellationRecordSchema = exports_external.object({
+  reason: exports_external.string().min(1).max(500),
+  cancelledAt: exports_external.string().datetime(),
+  source: exports_external.literal("armed_recovery")
+}).strict();
+function normalizePrReviewPartialBaseCoverageRecord(record) {
+  if ("missingDimension" in record) {
+    return {
+      schemaVersion: 2,
+      runId: record.runId,
+      prHeadSha: record.prHeadSha,
+      revisionDigest: record.revisionDigest,
+      unresolvedDimensions: [
+        {
+          dimension: record.missingDimension,
+          terminalState: "FAILED",
+          reasonKind: "lane_failure",
+          failureClass: record.failureClass,
+          terminalEventId: record.terminalEventId,
+          safeDetail: PR_REVIEW_FAILURE_CLASS_SAFE_DETAILS[record.failureClass]
+        }
+      ],
+      admittedAt: record.admittedAt
+    };
+  }
+  return record;
+}
 var PrFeedbackLaneOwnershipSchema = exports_external.object({
   laneId: exports_external.string().min(1),
   ownedItemIds: exports_external.array(exports_external.string().min(1)).min(1)
@@ -9659,6 +9843,7 @@ var PrWorkflowGateStateSchema = exports_external.object({
   prReviewPartialBaseCoverage: PrReviewPartialBaseCoverageRecordSchema.optional(),
   prReviewCoverageDisclosurePath: exports_external.string().min(1).max(512).optional(),
   prReviewCoverageDisclosureDigest: exports_external.string().regex(/^[0-9a-f]{64}$/).optional(),
+  prReviewDimensionCancellations: exports_external.record(exports_external.enum(PR_REVIEW_BASE_DIMENSION_IDS), PrReviewDimensionCancellationRecordSchema).optional(),
   prReviewArtifactBoundaries: exports_external.array(exports_external.enum(["post_explorer", "post_reviewer", "post_critic"])).max(3).optional(),
   prReviewHandoffPath: exports_external.string().min(1).optional(),
   prReviewHandoffRequired: exports_external.boolean().optional(),
@@ -9674,6 +9859,13 @@ var PrWorkflowGateStateSchema = exports_external.object({
   prFeedbackGateBatches: exports_external.array(PrFeedbackGateBatchRecordSchema).max(MAX_WORKFLOW_BATCHES).optional(),
   prFeedbackReadyToPublish: PrFeedbackReadyToPublishRecordSchema.optional(),
   prFeedbackPublication: PrFeedbackPublicationStateSchema.optional(),
+  prFeedbackArmedRecovery: exports_external.object({
+    recoveredAt: exports_external.string().datetime(),
+    prHeadSha: exports_external.string().regex(/^[0-9a-f]{6,64}$/i),
+    revisionDigest: exports_external.string().min(1).max(256),
+    generation: exports_external.number().int().nonnegative(),
+    reason: exports_external.string().min(1).max(500)
+  }).strict().optional(),
   prFeedbackRebindCount: exports_external.number().int().nonnegative().optional(),
   prFeedbackScopes: exports_external.array(PrFeedbackScopeDeclarationRecordSchema).max(MAX_WORKFLOW_BATCHES).optional()
 }).passthrough();
@@ -10238,6 +10430,111 @@ var TERMINAL_FAILED_DELEGATION_STATUSES = new Set([
   "cancelled",
   "stale"
 ]);
+function summarizePrReviewBaseDimensionAttempts(directory, state, revisionDigest) {
+  const successful = new Set;
+  const inFlight = new Set;
+  const contractFailed = new Set;
+  const contractRetried = new Set(state.prReviewContractRetryDimensions ?? []);
+  const dedicatedSuccessful = new Set;
+  const terminallyFailed = new Set;
+  for (const batch of state.prReviewBaseDispatches ?? []) {
+    const batchSuccessful = successfulObligationsFromExactBatch(directory, state, batch.batchId, batch.lanes, "swarm-pr-review:base", batch.validatedAt, true, new Set, revisionDigest);
+    for (const obligation of batchSuccessful) {
+      successful.add(obligation);
+    }
+    for (const lane of batch.lanes) {
+      if ((lane.ownedWorkflowLanes?.length ?? 1) !== 1)
+        continue;
+      const dimension = lane.ownedWorkflowLanes?.[0] ?? lane.workflowLane;
+      if (batchSuccessful.has(dimension))
+        dedicatedSuccessful.add(dimension);
+    }
+    const semanticallyValidLaneIds = new Set(recordsPassingBatchIntegrity(directory, state, batch.batchId, batch.lanes, "swarm-pr-review:base", batch.validatedAt).filter((qualified) => hasRevisionIndependentDiscoverySemantics(directory, qualified)).map((qualified) => qualified.record.laneId));
+    const records = findByBatchId(directory, batch.batchId, {
+      parentSessionId: state.sessionID
+    });
+    for (const lane of batch.lanes) {
+      if (semanticallyValidLaneIds.has(lane.laneId))
+        continue;
+      const laneRecords = records.filter((record) => record.laneId === lane.laneId);
+      if (laneRecords.length === 0) {
+        continue;
+      }
+      if (!laneRecords.every((record) => TERMINAL_FAILED_DELEGATION_STATUSES.has(record.status))) {
+        for (const dimension of lane.ownedWorkflowLanes?.length ? lane.ownedWorkflowLanes : [lane.workflowLane]) {
+          inFlight.add(dimension);
+        }
+        continue;
+      }
+      for (const dimension of lane.ownedWorkflowLanes?.length ? lane.ownedWorkflowLanes : [lane.workflowLane]) {
+        terminallyFailed.add(dimension);
+        if (laneRecords.at(-1)?.result?.workflowLaneFailureClass === "contract") {
+          contractFailed.add(dimension);
+        }
+      }
+    }
+  }
+  return {
+    successful,
+    inFlight,
+    contractFailed,
+    contractRetried,
+    dedicatedSuccessful,
+    terminallyFailed
+  };
+}
+function hasRevisionIndependentDiscoverySemantics(directory, qualified) {
+  const ref = qualified.record.result?.outputRef?.trim();
+  if (!ref)
+    return false;
+  const artifact = readLaneOutput(directory, ref)?.artifact ?? null;
+  if (!artifact?.revisionDigest?.trim())
+    return false;
+  return validatePrReviewDiscoveryLaneCompletion({
+    record: qualified.record,
+    result: qualified.record.result,
+    artifact,
+    expected: {
+      mode: "swarm-pr-review:base",
+      workflowLane: qualified.expectedWorkflowLane,
+      ownedWorkflowLanes: qualified.expectedOwnedLanes,
+      prHeadSha: qualified.record.workspace?.prHeadSha ?? "",
+      gitHead: qualified.record.workspace?.gitHead ?? "",
+      revisionDigest: artifact.revisionDigest,
+      reviewScope: qualified.record.workspace?.scope ?? undefined
+    }
+  }).ok;
+}
+function latestTypedFailureForBaseDimension(directory, state, dimension) {
+  let latest = null;
+  for (const batch of state.prReviewBaseDispatches ?? []) {
+    for (const lane of batch.lanes) {
+      const owned = lane.ownedWorkflowLanes?.length ? lane.ownedWorkflowLanes : [lane.workflowLane];
+      if (!owned.includes(dimension))
+        continue;
+      for (const record of findByBatchId(directory, batch.batchId, {
+        parentSessionId: state.sessionID
+      }).filter((candidate) => candidate.laneId === lane.laneId)) {
+        const terminal = record.terminalResult;
+        const result = terminal?.result ?? record.result;
+        const failureClass = result?.workflowLaneFailureClass;
+        if (!terminal || !failureClass || terminal.status === "completed")
+          continue;
+        const candidate = {
+          failureClass,
+          terminalEventId: terminal.eventId,
+          recordedAt: terminal.recordedAt,
+          batchId: batch.batchId,
+          laneId: lane.laneId
+        };
+        if (latest === null || candidate.recordedAt > latest.recordedAt || candidate.recordedAt === latest.recordedAt && candidate.terminalEventId.localeCompare(latest.terminalEventId) > 0) {
+          latest = candidate;
+        }
+      }
+    }
+  }
+  return latest;
+}
 var MAX_COVER_UNIVERSE_BITS = 12;
 function minimumConsolidatedLaneCover(sets) {
   const bitOf = new Map;
@@ -10291,6 +10588,78 @@ var PR_REVIEW_COVERAGE_DISCLOSURE_MAX_BYTES = 4096;
 function coverageDisclosureRelativePath(runId) {
   return path12.join("pr-review", runId, "coverage-disclosure.json");
 }
+function derivePrReviewDimensionSettlement(directory, state, revisionDigest) {
+  const attempts = summarizePrReviewBaseDimensionAttempts(directory, state, revisionDigest);
+  const cancellations = state.prReviewDimensionCancellations ?? {};
+  const dispatched = new Set;
+  for (const batch of state.prReviewBaseDispatches ?? []) {
+    const records = findByBatchId(directory, batch.batchId, {
+      parentSessionId: state.sessionID
+    });
+    for (const lane of batch.lanes) {
+      if (!records.some((record) => record.laneId === lane.laneId))
+        continue;
+      for (const dimension of lane.ownedWorkflowLanes?.length ? lane.ownedWorkflowLanes : [lane.workflowLane]) {
+        dispatched.add(dimension);
+      }
+    }
+  }
+  const coveredDimensions = [];
+  const unresolvedDimensions = [];
+  const liveDimensions = [];
+  for (const dimension of PR_REVIEW_BASE_DIMENSION_IDS) {
+    if (attempts.successful.has(dimension)) {
+      coveredDimensions.push(dimension);
+      continue;
+    }
+    if (attempts.inFlight.has(dimension)) {
+      liveDimensions.push(dimension);
+      continue;
+    }
+    const cancellation = cancellations[dimension];
+    if (cancellation) {
+      unresolvedDimensions.push({
+        dimension,
+        terminalState: "CANCELLED",
+        reasonKind: "cancelled",
+        safeDetail: `explicitly cancelled by the audited armed-recovery operation at ${cancellation.cancelledAt}`
+      });
+      continue;
+    }
+    const latestFailure = latestTypedFailureForBaseDimension(directory, state, dimension);
+    if (attempts.terminallyFailed.has(dimension)) {
+      unresolvedDimensions.push({
+        dimension,
+        terminalState: "FAILED",
+        reasonKind: "lane_failure",
+        failureClass: latestFailure?.failureClass,
+        terminalEventId: latestFailure?.terminalEventId,
+        batchId: latestFailure?.batchId,
+        laneId: latestFailure?.laneId,
+        safeDetail: latestFailure ? PR_REVIEW_FAILURE_CLASS_SAFE_DETAILS[latestFailure.failureClass] : "lane terminated without a typed failure class"
+      });
+      continue;
+    }
+    if (dispatched.has(dimension)) {
+      liveDimensions.push(dimension);
+      continue;
+    }
+    unresolvedDimensions.push({
+      dimension,
+      terminalState: "NOT_LAUNCHED",
+      reasonKind: "not_launched",
+      safeDetail: "no lane for this dimension was ever dispatched"
+    });
+  }
+  const kind = coveredDimensions.length === PR_REVIEW_BASE_DIMENSION_IDS.length ? "COMPLETE" : coveredDimensions.length > 0 ? "PARTIAL" : "NO_COVERAGE";
+  return {
+    kind,
+    coveredDimensions,
+    unresolvedDimensions,
+    liveDimensions,
+    allLaunchedTerminal: liveDimensions.length === 0
+  };
+}
 async function readAndVerifyCoverageDisclosure(directory, state) {
   const record = state.prReviewPartialBaseCoverage;
   const relativePath = state.prReviewCoverageDisclosurePath;
@@ -10319,7 +10688,7 @@ async function readAndVerifyCoverageDisclosure(directory, state) {
   if (!parsed.success || JSON.stringify(parsed.data) !== JSON.stringify(record)) {
     throw new Error("BLOCKED: PR_REVIEW partial base coverage disclosure does not match durable state");
   }
-  return record;
+  return normalizePrReviewPartialBaseCoverageRecord(parsed.data);
 }
 async function assertPrReviewBaseCoverageSettled(directory, sessionID, gateContext) {
   const state = await requireBoundState(directory, sessionID, "PR_REVIEW");
@@ -10328,23 +10697,21 @@ async function assertPrReviewBaseCoverageSettled(directory, sessionID, gateConte
     throw new Error("BLOCKED: PR_REVIEW requires at least one base batch");
   }
   const ctx = gateContext ?? await createPrReviewGateContext(directory, state);
-  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, true, new Set, ctx.revisionDigest, 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) {
-    const disclosure = await readAndVerifyCoverageDisclosure(directory, state);
-    if (disclosure && missing.length === 1 && covered.size === PR_REVIEW_BASE_DIMENSION_IDS.length - 1 && disclosure.missingDimension === missing[0] && disclosure.prHeadSha === state.prHeadSha && disclosure.revisionDigest === ctx.revisionDigest && disclosure.runId === (state.prReviewArtifactRunId ?? state.prReviewReservedRunId)) {
-      return state;
-    }
-    throw new Error(`BLOCKED: PR_REVIEW base coverage is incomplete; missing dimensions: ${missing.join(", ") || "(none)"}${malformedDiagnostics.length > 0 ? `; first failed lane predicates: ${malformedDiagnostics.join(" | ")}` : ""}; valid dimensions: ${PR_REVIEW_BASE_DIMENSION_IDS.join(", ")}; expected candidate row: ${CANDIDATE_HEADERS.base_explorer}; expected clean row: ${CLEAN_TEMPLATES.base_explorer}`);
+  const settlement = derivePrReviewDimensionSettlement(directory, state, ctx.revisionDigest);
+  if (settlement.kind === "COMPLETE") {
+    return { state, settlement };
   }
-  return state;
+  if (settlement.liveDimensions.length > 0) {
+    throw new Error(`BLOCKED: PR_REVIEW base coverage is incomplete and still has live lanes for: ${settlement.liveDimensions.join(", ")}. Completion is allowed only once every launched lane is terminal or explicitly cancelled.`);
+  }
+  const disclosure = await readAndVerifyCoverageDisclosure(directory, state);
+  const disclosureIds = (disclosure?.unresolvedDimensions ?? []).map((entry) => entry.dimension);
+  const derivedIds = settlement.unresolvedDimensions.map((entry) => entry.dimension);
+  if (disclosure && JSON.stringify(disclosureIds) === JSON.stringify(derivedIds) && JSON.stringify(disclosure?.unresolvedDimensions) === JSON.stringify(settlement.unresolvedDimensions) && disclosure.prHeadSha === state.prHeadSha && disclosure.revisionDigest === ctx.revisionDigest && disclosure.runId === (state.prReviewArtifactRunId ?? state.prReviewReservedRunId)) {
+    return { state, settlement };
+  }
+  const reason = disclosure === null ? "no terminal settlement disclosure is admitted; settle via write_pr_review_artifact partial_base_coverage.unresolved_dimensions" : disclosureIds.join(",") !== derivedIds.join(",") ? `the admitted disclosure [${disclosureIds.join(", ")}] no longer matches the derived terminal settlement [${derivedIds.join(", ")}] \u2014 later evidence invalidated it; the disclosure is immutable, so re-run the affected dimensions or restart the review` : "the admitted disclosure no longer matches the derived per-dimension terminal evidence";
+  throw new Error(`BLOCKED: PR_REVIEW base coverage is ${settlement.kind} (${settlement.coveredDimensions.length}/${PR_REVIEW_BASE_DIMENSION_IDS.length} dimensions covered; unresolved: ${derivedIds.join(", ") || "(none)"}); ${reason}`);
 }
 async function assertPrReviewValidationSettled(directory, sessionID, phase, gateContext) {
   const state = await requireBoundState(directory, sessionID, "PR_REVIEW");
@@ -11557,7 +11924,7 @@ async function assertPrReviewTerminalReady(directory, sessionID) {
     throw new Error(`BLOCKED: PR_REVIEW transition has ${laneSettlement.openLanes} unsettled PR workflow lane(s)` + describePrWorkflowLaneProbe(laneSettlement));
   }
   const ctx = await createPrReviewGateContext(directory, state);
-  await assertPrReviewBaseCoverageSettled(directory, sessionID, ctx);
+  const { settlement } = await assertPrReviewBaseCoverageSettled(directory, sessionID, ctx);
   if (!state.prReviewTriggerEvalPath) {
     throw new Error("BLOCKED: PR_REVIEW transition requires a persisted trigger evaluation artifact");
   }
@@ -11585,7 +11952,7 @@ async function assertPrReviewTerminalReady(directory, sessionID) {
   if (state.prReviewHandoffRequired && !state.prReviewHandoffPath) {
     throw new Error("BLOCKED: PR_REVIEW actionable findings require a persisted feedback handoff artifact");
   }
-  return state;
+  return { state, settlement };
 }
 async function transitionPrReviewToFeedback(directory, sessionID, request) {
   const normalizedSessionID = normalizeSessionID(sessionID);
@@ -11616,7 +11983,7 @@ async function transitionPrReviewToFeedback(directory, sessionID, request) {
     if (preliminary.mode !== "PR_REVIEW") {
       throw wrongModeError(preliminary, "PR_REVIEW");
     }
-    const ready = await assertPrReviewTerminalReady(directory, normalizedSessionID);
+    const ready = (await assertPrReviewTerminalReady(directory, normalizedSessionID)).state;
     if (workflowIdentity(ready) !== workflowIdentity(preliminary) || ready.revision !== preliminary.revision || ready.mode !== "PR_REVIEW" || ready.prReviewHandoffPath !== normalizedHandoff.relativePath || ready.prReviewArtifactRunId !== request.runId || !ready.prHeadSha || ready.prHeadSha.toLowerCase() !== artifact.pr_head_sha.toLowerCase() || canonicalGitHubPrUrl(artifact.pr_url) !== canonicalGitHubPrUrl(request.prUrl ?? artifact.pr_url)) {
       throw new Error("BLOCKED: PR_REVIEW feedback handoff does not match the terminal active review state");
     }
@@ -11733,6 +12100,21 @@ async function transitionPrReviewToFeedback(directory, sessionID, request) {
     });
   }));
 }
+async function readPrReviewReentryBindingContext(directory, sessionID) {
+  const state = await readPrWorkflowGateStateFromDisk(directory, normalizeSessionID(sessionID));
+  if (!state || state.mode !== "PR_REVIEW" || !state.prHeadSha)
+    return null;
+  const ctx = await createPrReviewGateContext(directory, state);
+  return {
+    prHeadSha: state.prHeadSha,
+    revisionDigest: ctx.revisionDigest,
+    generation: state.revision,
+    ...state.workflowInstanceId ? { workflowInstanceId: state.workflowInstanceId } : {},
+    ...state.prReviewArtifactRunId ?? state.prReviewReservedRunId ? {
+      runId: state.prReviewArtifactRunId ?? state.prReviewReservedRunId ?? undefined
+    } : {}
+  };
+}
 var _test_exports2 = {
   classifyPrReviewCircuitSignal,
   minimumConsolidatedLaneCover,
@@ -12483,7 +12865,12 @@ function authoritativeReviewerClaims(directory, state, ctx) {
 }
 function derivePrReviewCriticInventory(directory, state, ctx) {
   const verdicts = authoritativeReviewerVerdictsForGate(directory, state, ctx, "derivePrReviewCriticInventory");
-  return [...verdicts.entries()].filter(([, verdict]) => verdict.classification === "CONFIRMED" && ["CRITICAL", "HIGH", "MEDIUM"].includes(verdict.severity)).map(([itemId]) => itemId).sort();
+  return [...verdicts.entries()].filter(([, verdict]) => prReviewFindingRequiresCritic({
+    classification: verdict.classification,
+    severity: verdict.severity,
+    risk_impact: verdict.riskImpact,
+    risk_tags: verdict.riskTags
+  })).map(([itemId]) => itemId).sort();
 }
 function deriveLatestPrReviewCriticVerdicts(directory, state, ctx) {
   const composed = composePrReviewPhaseVerdicts(directory, state, "critic", ctx);
@@ -12497,7 +12884,12 @@ function deriveLatestPrReviewCriticVerdicts(directory, state, ctx) {
 function deriveLatestPrReviewReviewerVerdicts(directory, state, ctx) {
   return new Map([...authoritativeReviewerClaims(directory, state, ctx)].map(([itemId, claim]) => [
     itemId,
-    { classification: claim.classification, severity: claim.severity }
+    {
+      classification: claim.classification,
+      severity: claim.severity,
+      riskImpact: claim.riskImpact,
+      riskTags: claim.riskTags
+    }
   ]));
 }
 function assertSettledPhaseHasAuthoritativeVerdicts(phase, composed, authoritative, origin) {
@@ -13179,6 +13571,8 @@ function parsePrReviewVerdictRows(text, itemIds, phase, reviewerClaims) {
       parsed.set(itemId, {
         classification: fields[2],
         severity: fields[4],
+        riskImpact: fields[10],
+        riskTags: parsePrReviewRiskTagsField(fields[11] ?? ""),
         rowDigest: reviewerVerdictRowDigest(fields)
       });
       continue;
@@ -20646,7 +21040,7 @@ function planMerges(active, threshold, maxComparisons, maxMerges) {
   };
 }
 async function sweepActiveNearDuplicates(directory, options = {}) {
-  const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-qy6rcnjg.js");
+  const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-ygxb3jw4.js");
   const { config } = loadPluginConfigWithMeta2(directory);
   const sweepConfig = config.learning?.dedup_sweep;
   if (sweepConfig?.enabled === false)
@@ -21776,7 +22170,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-7cxf53ye.js");
+        const skillModule = await import("./skill-generator-v2jkgp63.js");
         for (const cand of skillCandidates) {
           if (cand.confidence < (config.min_skill_confidence ?? DEFAULT_SKILL_MIN_CONFIDENCE)) {
             continue;
@@ -22248,7 +22642,7 @@ async function applyCuratorKnowledgeUpdates(directory, recommendations, knowledg
     } catch {}
   }
   if (contradictedEntries.length > 0 && knowledgeConfig.contradiction_threshold_action === "quarantine") {
-    const { maybeQuarantineOnContradiction } = await import("./knowledge-escalator-wrpk82b9.js");
+    const { maybeQuarantineOnContradiction } = await import("./knowledge-escalator-9py5r6c9.js");
     for (const { id } of contradictedEntries) {
       try {
         await maybeQuarantineOnContradiction(directory, id, knowledgeConfig.contradiction_quarantine_threshold, knowledgeConfig.contradiction_quarantine_window_days);
@@ -23067,7 +23461,7 @@ async function runCuratorPostMortem(directory, options = {}) {
       warnings.push("Failed to collect knowledge summary.");
     }
     try {
-      const { getScanStatus } = await import("./scan-cursor-7s1bz7ew.js");
+      const { getScanStatus } = await import("./scan-cursor-59yj7tp9.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.`);
@@ -23239,9 +23633,9 @@ var _internals27 = {
   verifyPostMortemKnowledgeActions,
   repairPostMortemActions,
   loadDefaultKnowledgeConfig: async (directory) => {
-    const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-78pdxc8f.js");
+    const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-8a7fyp87.js");
     try {
-      const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-qy6rcnjg.js");
+      const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-ygxb3jw4.js");
       const loaded = loadPluginConfigWithMeta2(directory);
       return KnowledgeConfigSchema2.parse(loaded.config.knowledge ?? {});
     } catch {
@@ -23249,11 +23643,11 @@ var _internals27 = {
     }
   },
   applyCuratorKnowledgeUpdates: async (directory, recommendations, knowledgeConfig, generation) => {
-    const { applyCuratorKnowledgeUpdates: applyCuratorKnowledgeUpdates2 } = await import("./curator-fdj5ftfz.js");
+    const { applyCuratorKnowledgeUpdates: applyCuratorKnowledgeUpdates2 } = await import("./curator-yawrnk3t.js");
     return applyCuratorKnowledgeUpdates2(directory, recommendations, knowledgeConfig, generation);
   },
   checkHivePromotions: async (entries, knowledgeConfig, directory) => {
-    const { checkHivePromotions } = await import("./hive-promoter-e0zrkgns.js");
+    const { checkHivePromotions } = await import("./hive-promoter-d661k3qq.js");
     return checkHivePromotions(entries, knowledgeConfig, directory);
   },
   applyProposalTriage: async (directory, triage) => {
@@ -23262,7 +23656,7 @@ var _internals27 = {
       activateProposal,
       listSkills: listSkills2,
       sanitizeSlug
-    } = await import("./skill-generator-7cxf53ye.js");
+    } = await import("./skill-generator-v2jkgp63.js");
     const result = {
       approved: [],
       rejected: [],
@@ -24592,9 +24986,9 @@ function hashContent(content) {
   return createHash13("sha1").update(content).digest("hex");
 }
 async function loadConfigForPolicyCurator(directory) {
-  const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-78pdxc8f.js");
+  const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-8a7fyp87.js");
   try {
-    const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-qy6rcnjg.js");
+    const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-ygxb3jw4.js");
     const { config: loadedConfig } = loadPluginConfigWithMeta2(directory);
     return KnowledgeConfigSchema2.parse(loadedConfig.knowledge ?? {});
   } catch {
@@ -36782,7 +37176,7 @@ async function runFinalizeStage(ctx) {
     }
   }
   try {
-    const { CuratorConfigSchema: CCS } = await import("./schema-78pdxc8f.js");
+    const { CuratorConfigSchema: CCS } = await import("./schema-8a7fyp87.js");
     const { config: pmLoadedConfig } = _internals41.loadPluginConfigWithMeta(ctx.directory);
     const curatorCfg = CCS.parse(pmLoadedConfig.curator ?? {});
     if (curatorCfg.enabled && curatorCfg.postmortem_enabled) {
@@ -39001,9 +39395,9 @@ var _internals45 = {
   loadPluginConfigWithMeta,
   loadCuratorDeps: async () => {
     const [{ CuratorConfigSchema }, curator, { createCuratorLLMDelegate: createCuratorLLMDelegate2 }] = await Promise.all([
-      import("./schema-78pdxc8f.js"),
-      import("./curator-fdj5ftfz.js"),
-      import("./curator-llm-factory-rtkeb1y1.js")
+      import("./schema-8a7fyp87.js"),
+      import("./curator-yawrnk3t.js"),
+      import("./curator-llm-factory-21vqqvn3.js")
     ]);
     return { CuratorConfigSchema, curator, createCuratorLLMDelegate: createCuratorLLMDelegate2 };
   }
@@ -40012,7 +40406,7 @@ async function computeCurationDiagnostics(directory, entries) {
   let scanCompleted = false;
   let scanRemaining = 0;
   try {
-    const { getScanStatus } = await import("./scan-cursor-7s1bz7ew.js");
+    const { getScanStatus } = await import("./scan-cursor-59yj7tp9.js");
     const status = await getScanStatus(directory);
     scanGeneration = status.generation;
     scanCompleted = status.completed;
@@ -40020,19 +40414,19 @@ async function computeCurationDiagnostics(directory, entries) {
   } catch {}
   let configMatch = null;
   try {
-    const { isLinked: isLinked2 } = await import("./knowledge-link-z9cchqdj.js");
+    const { isLinked: isLinked2 } = await import("./knowledge-link-cj2abbae.js");
     if (isLinked2(directory)) {
-      const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-78pdxc8f.js");
+      const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-8a7fyp87.js");
       let config;
       try {
-        const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-qy6rcnjg.js");
+        const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-ygxb3jw4.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-72qx868r.js");
+      const { buildConfigFingerprintInput: buildConfigFingerprintInput2, readCohortConfigFingerprint } = await import("./curation-policy-vn3m5nq2.js");
       const currentFp = cohortConfigFingerprint2(buildConfigFingerprintInput2(config));
       const cohortFp = await readCohortConfigFingerprint(directory);
       configMatch = cohortFp === null ? null : currentFp === cohortFp;
@@ -41345,7 +41739,7 @@ async function handleDoctorCommand(directory, args) {
   const result = runConfigDoctor(config, directory);
   let output;
   if (enableAutoFix && result.hasAutoFixableIssues) {
-    const { runConfigDoctorWithFixes } = await import("./config-doctor-9rsk8ags.js");
+    const { runConfigDoctorWithFixes } = await import("./config-doctor-hs0x10ty.js");
     const fixResult = await runConfigDoctorWithFixes(directory, config, true, {
       applyLossy: true
     });
@@ -41383,7 +41777,7 @@ async function handleDoctorCommand(directory, args) {
 `;
   }
   try {
-    const { runModelPreflight } = await import("./model-preflight-cv9kvw8h.js");
+    const { runModelPreflight } = await import("./model-preflight-w85ecyxh.js");
     const preflight = await runModelPreflight(config, swarmState.opencodeClient);
     if (preflight.catalogAvailable) {
       const unresolved = preflight.resolutions.filter((resolution) => resolution.status === "unresolved");
@@ -42285,7 +42679,7 @@ async function handleEvidenceCommand(directory, args) {
   return formatTaskEvidenceMarkdown(evidenceData);
 }
 async function handleEvidenceSummaryCommand(directory) {
-  const { buildEvidenceSummary } = await import("./evidence-summary-service-bhqvx9qe.js");
+  const { buildEvidenceSummary } = await import("./evidence-summary-service-kmc92b95.js");
   const artifact = await buildEvidenceSummary(directory);
   if (!artifact) {
     return "No plan found. Run `/swarm plan` to check plan status.";
@@ -77347,7 +77741,7 @@ async function runValidationWithTransientRetry(input, candidateContent, baseline
       if (!input.dispatcher) {
         throw new Error("no evaluation dispatcher available (cannot run validation)");
       }
-      const { createModelEvaluationExecutor: createModelEvaluationExecutor2 } = await import("./runner-eagt6gf8.js");
+      const { createModelEvaluationExecutor: createModelEvaluationExecutor2 } = await import("./runner-sj5sf36c.js");
       const executor = createModelEvaluationExecutor2(input.dispatcher, input.sessionId);
       const result = await withProtectedSetIntegrity([evalInputRoot, ...protectedRoots(input.directory)], () => _internals97.evaluateCandidateV1({
         projectRoot: input.directory,
@@ -79392,7 +79786,7 @@ function buildDetailedHelp(commandName, entry) {
 async function handleHelpCommand(ctx) {
   const targetCommand = ctx.args.join(" ");
   if (!targetCommand) {
-    const { buildHelpText } = await import("./index-w7s5vgb6.js");
+    const { buildHelpText } = await import("./index-4wy9kzjg.js");
     return buildHelpText();
   }
   const tokens = targetCommand.split(/\s+/);
@@ -79401,7 +79795,7 @@ async function handleHelpCommand(ctx) {
     return _internals100.buildDetailedHelp(resolved.key, resolved.entry);
   }
   const similar = _internals100.findSimilarCommands(targetCommand);
-  const { buildHelpText: fullHelp } = await import("./index-w7s5vgb6.js");
+  const { buildHelpText: fullHelp } = await import("./index-4wy9kzjg.js");
   if (similar.length > 0) {
     return `Command '/swarm ${targetCommand}' not found.
 
@@ -79732,7 +80126,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail explain": {
     handler: async (ctx) => {
-      const { handleGuardrailExplain } = await import("./guardrail-explain-17me709w.js");
+      const { handleGuardrailExplain } = await import("./guardrail-explain-7xrdp18c.js");
       return handleGuardrailExplain(ctx.directory, ctx.args);
     },
     description: "Dry-run: show what the guardrails would do to a command or write target (executes nothing)",
@@ -79742,7 +80136,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail reset": {
     handler: async (ctx) => {
-      const { handleGuardrailReset } = await import("./guardrail-reset-5n76tj7e.js");
+      const { handleGuardrailReset } = await import("./guardrail-reset-0ks08s0t.js");
       return handleGuardrailReset(ctx.args, ctx.sessionID);
     },
     description: "Reset one exact active invocation/action circuit after repair",
@@ -79751,7 +80145,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail-explain": {
     handler: async (ctx) => {
-      const { handleGuardrailExplain } = await import("./guardrail-explain-17me709w.js");
+      const { handleGuardrailExplain } = await import("./guardrail-explain-7xrdp18c.js");
       return handleGuardrailExplain(ctx.directory, ctx.args);
     },
     description: "Dry-run: show what the guardrails would do to a command or write target (executes nothing)",
@@ -79761,7 +80155,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail-reset": {
     handler: async (ctx) => {
-      const { handleGuardrailReset } = await import("./guardrail-reset-5n76tj7e.js");
+      const { handleGuardrailReset } = await import("./guardrail-reset-0ks08s0t.js");
       return handleGuardrailReset(ctx.args, ctx.sessionID);
     },
     description: "Reset one exact active invocation/action circuit after repair",
@@ -79771,7 +80165,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail-log": {
     handler: async (ctx) => {
-      const { handleGuardrailLog } = await import("./guardrail-log-te4a5fmn.js");
+      const { handleGuardrailLog } = await import("./guardrail-log-f16sdc3p.js");
       return handleGuardrailLog(ctx.directory, ctx.args);
     },
     description: "Read the guardrail decision log (use --blocks-only for blocks)",
@@ -81710,16 +82104,16 @@ HARD CONSTRAINTS (apply regardless of skill load success):
 - No finding may appear as CONFIRMED in the final report without reviewer validation provenance
 - Test execution, explorer lanes, reviewer dispatch, and critic challenge are all permitted within this mode
 - Quality is the only metric \u2014 there is no speed, efficiency, or time exception; time, tokens, and agent dispatches are irrelevant to correctness
-- FOLLOW THE SKILL EXACTLY: execute every phase of the loaded SKILL.md in order with no shortcuts, no phase-skipping, and no premature synthesis. If a required coverage phase cannot complete, apply the skill's coverage gate (retry or verified equivalent alternative). If the gap still cannot be closed, stop and surface the lane failure to the user as BLOCKED; do not produce a degraded review, partial verdict, or final synthesis.
+- FOLLOW THE SKILL EXACTLY: execute every phase of the loaded SKILL.md in order with no shortcuts, no phase-skipping, and no premature synthesis. If a required coverage phase cannot complete, apply the skill's coverage gate (retry or verified equivalent alternative). If the gap still cannot be closed after every launched lane is terminal or explicitly cancelled, settle N-of-6 truthfully (issue #2383): PARTIAL coverage completes with verdict REQUEST_CHANGES or INCOMPLETE over the covered dimensions' validated findings, and zero coverage completes as an INCOMPLETE operational report \u2014 never a fabricated full review and never an APPROVE.
 - CHECK OUT THE EXACT PR HEAD LOCALLY before dispatching explorer lanes: resolve the authoritative full PR head SHA, verify the working tree is clean (git status --porcelain), and if it is dirty call \`prepare_pr_workflow_checkout\` before checkout \u2014 either with no \`paths\` to auto-discover and preserve every dirty and untracked change in one auditable stash, or with an explicit exact dirty tracked path set. It returns the stash OID and recovery command; an already-clean tree is a no-op. Do NOT run \`git stash\` through shell. Then use standalone commands: fetch the PR head, verify it portably with \`git rev-parse --verify <full_pr_head_sha>^0\` followed by \`git cat-file -t <full_pr_head_sha>\` (which must print \`commit\`), run \`git switch --detach <full_pr_head_sha>\`, confirm HEAD equals that SHA, and bind it through the PR-review controller. Do not use \`--track FETCH_HEAD\`. Explorers read the working-tree filesystem (Read/Glob/Grep), so without this checkout they read the base branch and produce invalid candidates. Always pass the base..head commit range in explorer delegations. Under Profile A, do not create a scratch context-pack file after the gate activates: put bounded shared scope, obligations, and deterministic signals in \`common_prompt\`; every lane must inspect the exact bound diff itself.
 - Treat the controller Git-state result as final for the attempt: \`clean\` proceeds; \`stashable\` permits one preparation call; \`recovery-required\` or \`indeterminate\` means report the typed \`required_action\`, abort/clear any already-active gate, and STOP unless \`retryable: true\`. Never loop on stash against an unmerged index or in-progress Git operation.
 - RUN ALL BASE LANES: the default PR_REVIEW path covers all six repository-agnostic base dimensions from the skill on every PR. Use \`mode: "swarm-pr-review:base"\`, the exact \`workflow_lane\` identifiers, and the exact bound \`pr_head_sha\`. \`pr_review_resilience\` is DISABLED by default, so the legacy one-wave base dispatch is the default path at every depth tier \u2014 do not emit \`pr_review_wave_stage\` or \`pr_review_wave_attempt\` unless a project has explicitly enabled it. Only when a project explicitly sets \`pr_review_resilience.enabled: true\` must depth tier M/L stage attempt 0 as one singleton \`pr_review_wave_stage: "canary"\` batch followed by a \`"fanout"\` batch whose combined canary+fanout ownership partitions all six dimensions exactly once; tier L still requires six singleton combined lanes, and tier S keeps the legacy one-wave path regardless. The runtime rejects omitted stage metadata, partial, duplicate, mislabelled, or structurally invalid waves.
 - RETRY STRUCTURALLY: retry only unresolved failed base obligations in later \`swarm-pr-review:base\` async batches with the same exact \`pr_head_sha\`. Under staged resilience, attempts are numbered by \`pr_review_wave_attempt\`: attempt 0 plus at most two retry attempts (1 and 2), each with one singleton canary batch and then its matching fanout batch when obligations remain. Blocking \`dispatch_lanes\` and direct Task explorer/reviewer/critic dispatch are not provenance-equivalent and are rejected. If the runtime returns typed \`retry_exhausted\` or \`circuit_open\`, or if the second retry still cannot close coverage, collect every lane to settlement, do not probe downstream writers or micro lanes, call \`abort_pr_workflow\` with \`mode: "PR_REVIEW"\`, \`kind: "recovery"\`, and a non-empty one-line \`reason\` naming the failed lane or correlated failure and exhausted retries, then call \`prepare_pr_workflow_checkout\` with \`operation: "restore"\` before reporting the blocker.
-- RECOVER CONTRACT FAILURES EXPLICITLY: when collection reports \`workflow_lane_failure_class: "contract"\`, retry that one singleton base dimension once with \`pr_review_contract_retry: true\`; this retry is outside staged \`pr_review_wave_attempt\` accounting and cannot be combined with stage metadata. If exactly five base dimensions settle successfully and one dimension remains terminally failed with a typed \`contract\` or \`resource\` class, the \`post_explorer\` findings write may explicitly submit \`partial_base_coverage: { missing_dimension: "<exact lane>" }\`. Never infer or omit this disclosure: the runtime verifies five-of-six, persists an immutable coverage receipt, and rejects any other partial shape.
+- RECOVER CONTRACT FAILURES EXPLICITLY: when collection reports \`workflow_lane_failure_class: "contract"\`, retry that one singleton base dimension once with \`pr_review_contract_retry: true\`; this retry is outside staged \`pr_review_wave_attempt\` accounting and cannot be combined with stage metadata. When fewer than six base dimensions settle but every launched lane is terminal or explicitly cancelled, the \`post_explorer\` findings write may explicitly submit \`partial_base_coverage: { unresolved_dimensions: [<exactly the uncovered dimensions>] }\` (issue #2383 N-of-6 settlement). Never infer or omit dimensions from this disclosure: the runtime derives each dimension's terminal state from lane evidence, persists an immutable coverage receipt, and rejects any declaration that does not exactly match the derived settlement.
 - USE ASYNC DISPATCH WITHOUT IDLING: each admissible base wave uses one \`dispatch_lanes_async\` call. With enabled tier-M/L staged resilience, this means one singleton canary call followed by one unresolved-only fanout call after canary admission; it never means one legacy call carrying the whole initial base wave. Record each \`batch_id\`, then keep doing non-dependent architect work while its lanes 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.
 - 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. The first micro dispatch MUST pass the complete exact eleven-row \`trigger_evaluation\`, which freezes it for this session; any subsequent same-session micro batch may omit it and reuse the frozen ledger, while an explicitly supplied copy must remain exactly identical. 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. When completion reports checkout restoration is required, call \`prepare_pr_workflow_checkout\` with \`operation: "restore"\` before returning to the user.
+- COMPLETE EXPLICITLY: after final artifacts and synthesis, call \`complete_pr_workflow\` with \`mode: "PR_REVIEW"\`, the bound \`pr_head_sha\`, and the terminal \`report_verdict\` the coverage kind allows (issue #2383): COMPLETE may APPROVE, REQUEST_CHANGES, or INCOMPLETE; PARTIAL only REQUEST_CHANGES or INCOMPLETE; NO_COVERAGE must be INCOMPLETE and skips the findings ladder entirely. Never leave the session trapped in a stale workflow gate. When completion reports checkout restoration is required, call \`prepare_pr_workflow_checkout\` with \`operation: "restore"\` before returning to the user. For a publication-armed workflow whose exact publication cannot proceed, \`abort_pr_workflow\` with \`kind: "armed_recovery"\` plus the armed-recovery identity fields is the audited escape that preserves validated work.
 - 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), the merge-base bind is unreachable, or the bounded lane retries above are exhausted, call \`abort_pr_workflow\` with \`mode: "PR_REVIEW"\`, \`kind: "recovery"\`, and a one-line \`reason\` instead of looping. The tool accepts unbound and bound workflows but 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 force-clear via \`/swarm abort-pr-workflow\`. Do NOT abort while useful bounded recovery work remains.
 - Honor any free-text instructions that follow the closing bracket of the signal as additional reviewer focus, without weakening the validation ladder above.
 
@@ -82474,6 +82868,12 @@ Use these definitions precisely \u2014 do not inflate severity:
 - LOW: Code smell, readability concern, or minor optimization opportunity. Optional.
 - INFO: Suggestion for future improvement. Not a blocker.
 
+## TYPED RISK METADATA (issue #2383)
+Every CONFIRMED verdict row must also classify typed risk, which drives critic routing:
+- risk_impact: ORDINARY (routine code path) | HIGH_IMPACT (core data flow, state, money, auth, or blast radius across subsystems) | UNKNOWN (use HONESTLY when you cannot assess impact \u2014 UNKNOWN always routes the finding to a critic; never guess ORDINARY to avoid routing, and never let file paths, keywords, or dimension names decide for you).
+- risk_tags (comma-separated, any that apply): SECURITY, AUTH_PERMISSIONS, STATE_INTEGRITY, WRITE_PATH, EVIDENCE_INTEGRITY, GIT, CONFIGURATION. Empty means none apply.
+Routing effect: CRITICAL/HIGH always route to critic; a MEDIUM routes only when HIGH_IMPACT or it carries any tag; an ORDINARY MEDIUM with no tags does not.
+
 CALIBRATION RULE \u2014 If you find NO issues, state this explicitly:
 "NO ISSUES FOUND \u2014 Reviewed [N] changed functions. Preconditions verified for: [list]. Edge cases considered: [list]. No logic errors, security concerns, or contract changes detected."
 A blank APPROVED without reasoning is NOT acceptable \u2014 it indicates you did not actually review.
@@ -85758,7 +86158,7 @@ function getDisplayFinalPromptPressure() {
 async function rehydratePrSubscriptions(sessionID, directory) {
   const map = new Map;
   try {
-    const { listActive: listActive2 } = await import("./pr-subscriptions-76vg2xya.js");
+    const { listActive: listActive2 } = await import("./pr-subscriptions-j9j70bmd.js");
     const records = await listActive2(directory);
     for (const record of records) {
       if (record.sessionID !== sessionID)
@@ -86204,7 +86604,7 @@ function isLaneOwnedByCurrentSession(branchName, expectedSessionId) {
   return extracted === expectedSessionId;
 }
 async function inspectStandardWorktreeCollisionOwnership(identity) {
-  const collisionOwnership = await import("./worktree-collision-ownership-ry7xnaae.js");
+  const collisionOwnership = await import("./worktree-collision-ownership-6x03w8h7.js");
   return collisionOwnership.inspectStandardWorktreeCollisionOwnership(identity);
 }
 async function runRecoveryGit(directory, args, timeoutMs = 15000) {
@@ -86613,7 +87013,7 @@ async function precreateStandardWorktreeSession(args) {
   const laneProfile = computeLaneRuntimeProfile(worktreeConfig.runtime_isolation, laneIndex, handle.worktreePath);
   if (laneProfile) {
     try {
-      const { writeLaneProfileToDiskReal } = await import("./core-7zwdc0sk.js");
+      const { writeLaneProfileToDiskReal } = await import("./core-a42bexs1.js");
       await writeLaneProfileToDiskReal(handle.worktreePath, laneProfile.laneIndex, laneProfile.envOverrides);
     } catch {}
   }
@@ -87538,7 +87938,7 @@ async function finishStandardWorktreeDispatch(directory, dispatch, config, callI
       }
       clearWorktreeMergeStatus(statusKey);
       try {
-        const { removeLaneProfileFromDiskReal } = await import("./core-7zwdc0sk.js");
+        const { removeLaneProfileFromDiskReal } = await import("./core-a42bexs1.js");
         await removeLaneProfileFromDiskReal(dispatch.handle.worktreePath, dispatch.laneIndex);
       } catch {}
       const state = serializationStateBySessionID.get(dispatch.parentSessionID);
@@ -87741,4 +88141,4 @@ var _internals102 = {
   resolveGitExecutable
 };
 
-export { resetActionCircuitExternally, getBlockingActionCircuit, dcNormalizeCommand, dcUnwrapWrappers, dcSplitSegments, dcExtractRecursiveRmTargets, dcEvaluateRecursiveDeleteTargets, dcCheckJunctionCreation, dcExtractWindowsCmdTargets, dcExtractPowerShellTargets, getSharedClassifierGuardrailBlock, classifyCommand, normalizeSwarmCommandInput, canonicalCommandKey, formatCommandNotFound, executeSwarmCommand, SWARM_COMMAND_TOOL_COMMANDS, SWARM_COMMAND_TOOL_ALLOWLIST, HUMAN_ONLY_SWARM_COMMANDS, classifySwarmCommandToolUse, classifySwarmCommandChatFallbackUse, detectPosixWrites, detectWindowsWrites, resolveWriteTargets, getAgentSession, parseLeanLaneIndex, computeLaneRuntimeProfile, MAX_TRACKED_STANDARD_WORKTREE_CALLS, awaitingMergeByCallID, standardWorktreeByCallID, standardWorktreeSerializationSessions, getStandardWorktreeDegradationReason, resetStandardWorktreeIsolationState, checkStandardWorktreeSerializationRelease, sanitizeWorktreeTaskId, preProvisionCollisionCheck, isLaneOwnedByCurrentSession, precreateStandardWorktreeSession, preserveBackgroundWorktreeOwnershipForCallId, preserveDirtyWorktreeForCallId, preserveDirtyWorktreeAtPath, cleanupStandardWorktreeForCallId, abortStandardWorktreeDispatch, finishStandardWorktreeDispatch, readLaneEnvFileFromDisk, _internals102 as _internals, handleAcknowledgeSpecDriftCommand, handleAgentsCommand, handleAnalyzeCommand, handleApproveWriteCommand, handleArchiveCommand, handleAutoProceedCommand, handleBenchmarkCommand, handleBrainstormCommand, handleCheckpointCommand, handleCiSimulateCommand, handleClarifyCommand, createCuratorLLMDelegate, _internals26 as _internals1, normalizeRecommendationEntryIdToken, parseKnowledgeRecommendations, parseKnowledgeRecommendationsWithDiagnostics, parseStructuredCuratorBlocks, readCuratorSummary, writeCuratorSummary, appendCuratorRecommendation, mergeCuratorPhaseSummary, filterPhaseEvents, checkPhaseCompliance, runCuratorInit, runCuratorPhase, applyCuratorKnowledgeUpdates, isHiveEligible, countDistinctProjects, checkHivePromotions, _internals30 as _internals2, createHivePromoterHook, promoteToHive, promoteFromSwarm, safeRealpathSync, handleCloseCommand, handleCodebaseReviewCommand, handleConcurrencyCommand, handleConfigCommand, handleConsolidateCommand, handleCostsCommand, handleCouncilCommand, handleCurateCommand, handleDarkMatterCommand, handleDeepDiveCommand, handleDeepResearchCommand, getPluginConfigDir, getPluginCachePaths, getPluginLockFilePaths, VERSION_PINNED_LEAF, discoverVersionPinnedCachePaths, readCachePackageVersion, handleDiagnoseCommand, handleDoctorCommand, handleEvidenceCommand, handleEvidenceSummaryCommand, handleExportCommand, handleFullAutoCommand, handleGateAuditCommand, handleGateStatsCommand, handleHandoffCommand, handleBlueprintValidateCommand, handleBlueprintCurrentCommand, handleBlueprintHistoryCommand, handleBlueprintDiffCommand, handleBlueprintExportCommand, handleHarnessCandidateValidateCommand, handleHarnessCandidateShowCommand, handleHarnessCandidateDiffCommand, handleHistoryCommand, handleKnowledgeQuarantineCommand, handleKnowledgeRestoreCommand, handleKnowledgeMigrateCommand, handleKnowledgeListCommand, handleKnowledgeUnactionableCommand, handleKnowledgeRetryHardeningCommand, handleLearningCommand, handleLinkCommand, handleMemoryCommand, handleMemoryStatusCommand, handleMemoryValueLogCommand, handleMemoryMigrateCommand, handleMemoryImportCommand, handleMemoryExportCommand, handlePlanCommand, handlePreflightCommand, handlePromoteCommand, handleQaGatesCommand, handleRecoverCommand, handleResetCommand, handleResetSessionCommand, handleRetrieveCommand, handleReviewCommand, handleRollbackCommand, handleSddStatusCommand, handleSddValidateCommand, handleSddProjectCommand, handleSddCommand, handleSimulateCommand, handleSpecifyCommand, handleStatusCommand, handleSyncPlanCommand, handleTurboCommand, handleUnlinkCommand, handleWriteRetroCommand, handleHelpCommand, COMMAND_REGISTRY, VALID_COMMANDS, _internals100 as _internals3, resolveCommand };
+export { PrReviewRunIdSchema, resetActionCircuitExternally, getBlockingActionCircuit, dcNormalizeCommand, dcUnwrapWrappers, dcSplitSegments, dcExtractRecursiveRmTargets, dcEvaluateRecursiveDeleteTargets, dcCheckJunctionCreation, dcExtractWindowsCmdTargets, dcExtractPowerShellTargets, getSharedClassifierGuardrailBlock, classifyCommand, normalizeSwarmCommandInput, canonicalCommandKey, formatCommandNotFound, executeSwarmCommand, SWARM_COMMAND_TOOL_COMMANDS, SWARM_COMMAND_TOOL_ALLOWLIST, HUMAN_ONLY_SWARM_COMMANDS, classifySwarmCommandToolUse, classifySwarmCommandChatFallbackUse, detectPosixWrites, detectWindowsWrites, resolveWriteTargets, getAgentSession, parseLeanLaneIndex, computeLaneRuntimeProfile, MAX_TRACKED_STANDARD_WORKTREE_CALLS, awaitingMergeByCallID, standardWorktreeByCallID, standardWorktreeSerializationSessions, getStandardWorktreeDegradationReason, resetStandardWorktreeIsolationState, checkStandardWorktreeSerializationRelease, sanitizeWorktreeTaskId, preProvisionCollisionCheck, isLaneOwnedByCurrentSession, precreateStandardWorktreeSession, preserveBackgroundWorktreeOwnershipForCallId, preserveDirtyWorktreeForCallId, preserveDirtyWorktreeAtPath, cleanupStandardWorktreeForCallId, abortStandardWorktreeDispatch, finishStandardWorktreeDispatch, readLaneEnvFileFromDisk, _internals102 as _internals, readPrReviewReentryBindingContext, prWorkflowSessionFileStem, handleAcknowledgeSpecDriftCommand, handleAgentsCommand, handleAnalyzeCommand, handleApproveWriteCommand, handleArchiveCommand, handleAutoProceedCommand, handleBenchmarkCommand, handleBrainstormCommand, handleCheckpointCommand, handleCiSimulateCommand, handleClarifyCommand, createCuratorLLMDelegate, _internals26 as _internals1, normalizeRecommendationEntryIdToken, parseKnowledgeRecommendations, parseKnowledgeRecommendationsWithDiagnostics, parseStructuredCuratorBlocks, readCuratorSummary, writeCuratorSummary, appendCuratorRecommendation, mergeCuratorPhaseSummary, filterPhaseEvents, checkPhaseCompliance, runCuratorInit, runCuratorPhase, applyCuratorKnowledgeUpdates, isHiveEligible, countDistinctProjects, checkHivePromotions, _internals30 as _internals2, createHivePromoterHook, promoteToHive, promoteFromSwarm, safeRealpathSync, handleCloseCommand, handleCodebaseReviewCommand, handleConcurrencyCommand, handleConfigCommand, handleConsolidateCommand, handleCostsCommand, handleCouncilCommand, handleCurateCommand, handleDarkMatterCommand, handleDeepDiveCommand, handleDeepResearchCommand, getPluginConfigDir, getPluginCachePaths, getPluginLockFilePaths, VERSION_PINNED_LEAF, discoverVersionPinnedCachePaths, readCachePackageVersion, handleDiagnoseCommand, handleDoctorCommand, handleEvidenceCommand, handleEvidenceSummaryCommand, handleExportCommand, handleFullAutoCommand, handleGateAuditCommand, handleGateStatsCommand, handleHandoffCommand, handleBlueprintValidateCommand, handleBlueprintCurrentCommand, handleBlueprintHistoryCommand, handleBlueprintDiffCommand, handleBlueprintExportCommand, handleHarnessCandidateValidateCommand, handleHarnessCandidateShowCommand, handleHarnessCandidateDiffCommand, handleHistoryCommand, handleKnowledgeQuarantineCommand, handleKnowledgeRestoreCommand, handleKnowledgeMigrateCommand, handleKnowledgeListCommand, handleKnowledgeUnactionableCommand, handleKnowledgeRetryHardeningCommand, handleLearningCommand, handleLinkCommand, handleMemoryCommand, handleMemoryStatusCommand, handleMemoryValueLogCommand, handleMemoryMigrateCommand, handleMemoryImportCommand, handleMemoryExportCommand, handlePlanCommand, handlePreflightCommand, handlePromoteCommand, handleQaGatesCommand, handleRecoverCommand, handleResetCommand, handleResetSessionCommand, handleRetrieveCommand, handleReviewCommand, handleRollbackCommand, handleSddStatusCommand, handleSddValidateCommand, handleSddProjectCommand, handleSddCommand, handleSimulateCommand, handleSpecifyCommand, handleStatusCommand, handleSyncPlanCommand, handleTurboCommand, handleUnlinkCommand, handleWriteRetroCommand, handleHelpCommand, COMMAND_REGISTRY, VALID_COMMANDS, _internals100 as _internals3, resolveCommand };