opencode-swarm 7.148.1 → 7.148.3

package/dist/cli/{index-kztxn1ww.js → index-7a41ca8k.js}

@@ -6,17 +6,17 @@ import {
   resolveExecutableFromPath,
   runEvaluation,
   runExternalTool
-} from "./index-kpgj4ha6.js";
+} from "./index-ebt47fnp.js";
 import {
   normalizeToolNameLowerCase,
   stableCanonicalStringify
-} from "./index-2bsnwcmp.js";
+} from "./index-et35gcph.js";
 import {
   detectStraySwarmDirs,
   readDoctorArtifact,
   removeStraySwarmDir,
   runConfigDoctor
-} from "./index-5wypz451.js";
+} from "./index-fp9d0e6f.js";
 import {
   MAX_TRANSIENT_RETRIES,
   archiveEvidence,
@@ -62,7 +62,7 @@ import {
   updateTaskStatus,
   validateProjectRoot,
   validateSymlinkBoundary
-} from "./index-t6ys1386.js";
+} from "./index-c9xfy8yj.js";
 import {
   EvaluationTaskV1Schema,
   GateAuditManifestV1Schema,
@@ -79,7 +79,7 @@ import {
   saveGateAuditResult,
   savePromotionDecision,
   saveTaskSetSnapshot
-} from "./index-fv5cc1rd.js";
+} from "./index-x4kgn37c.js";
 import {
   loadDatabaseCtor
 } from "./index-134d35c1.js";
@@ -105,12 +105,12 @@ import {
 } from "./index-y8552snf.js";
 import {
   readRecentEscalations
-} from "./index-q0gfmyzx.js";
+} from "./index-afwwz4py.js";
 import {
   alreadyCuratedThisGeneration,
   claimNextScanBatch,
   resolveCohortId
-} from "./index-81n4ky69.js";
+} from "./index-8y79znpe.js";
 import {
   CURATOR_INIT_PROMPT,
   CURATOR_PHASE_PROMPT,
@@ -180,7 +180,7 @@ import {
   retireSkill,
   selectCandidateEntries,
   syncBundledProjectSkillsIfMissingAsync
-} from "./index-hxqjf4me.js";
+} from "./index-xq8eydnk.js";
 import {
   appendUnactionable,
   quarantineEntry,
@@ -191,11 +191,11 @@ import {
   validateActionableFields,
   validateLesson,
   validateSkillPath
-} from "./index-dwg0z10h.js";
+} from "./index-8w63kj4x.js";
 import {
   authorizeCuration,
   buildConfigFingerprintInput
-} from "./index-jtnk7k6w.js";
+} from "./index-r9g7ymv2.js";
 import {
   cohortConfigFingerprint
 } from "./index-rtry5xyf.js";
@@ -215,7 +215,7 @@ import {
   findByBatchId,
   readDelegations,
   sweepStaleDelegations
-} from "./index-ch6sjm8q.js";
+} from "./index-092deqxs.js";
 import {
   WORKTREE_LIFECYCLE_LOCK_FILE,
   recordWorktreeProvisioningOwner,
@@ -248,18 +248,18 @@ import {
   transitionTaskWorkflowEvidence,
   withTaskEvidenceTransaction,
   writeWorkflowWalFile
-} from "./index-py2rsw1a.js";
+} from "./index-2d582j6q.js";
 import {
   provisionWorktree,
   removeWorktree
-} from "./index-mfhpk4c6.js";
+} from "./index-y8kppv1z.js";
 import {
   MAX_PENDING_SCOPE_BINDINGS,
   canonicalWorkspaceIdentity,
   clearAllScopes,
   clearScopeBindingFromDisk,
   clearScopeBindings
-} from "./index-c23yxr1s.js";
+} from "./index-harsx832.js";
 import {
   appendLedgerEvent,
   computePlanHash,
@@ -274,7 +274,7 @@ import {
   readPlanEpochIdentity,
   replayFromLedgerWithStatus,
   takeSnapshotEvent
-} from "./index-f115c8y6.js";
+} from "./index-8sz9t8s2.js";
 import {
   isPathWithinDeclaredScope,
   sanitizeDiagnosticText
@@ -326,7 +326,7 @@ import {
   transactFile,
   transactKnowledge,
   wordBigrams
-} from "./index-x46mmaep.js";
+} from "./index-3vescfdb.js";
 import {
   MAX_EVENT_LOG_ENTRIES,
   _internals as _internals2,
@@ -340,10 +340,10 @@ import {
   recordKnowledgeEvent,
   recordPhaseCloseIntent,
   resolveKnowledgeEventsPath
-} from "./index-w49v4xd6.js";
+} from "./index-dmbvep3q.js";
 import {
   resolveWorktreeIsolationConfig
-} from "./index-shm69en5.js";
+} from "./index-dh85aep3.js";
 import {
   RetrospectiveEvidenceSchema
 } from "./index-gprxjmm7.js";
@@ -353,7 +353,7 @@ import {
   init_loader,
   loadPluginConfig,
   loadPluginConfigWithMeta
-} from "./index-k5ze5v89.js";
+} from "./index-08d3pb9a.js";
 import {
   DEFAULT_SKILL_OPT_CONFIG,
   FALLBACK_MODELS_MAX,
@@ -367,7 +367,7 @@ import {
   package_default,
   resolveAutoReviewConfig,
   stripKnownSwarmPrefix
-} from "./index-qwzpsh3w.js";
+} from "./index-65jw48eb.js";
 import {
   AGENT_TOOL_MAP,
   ALL_AGENT_NAMES,
@@ -419,10 +419,10 @@ import {
   resolveLinkDir,
   sanitizeLinkId,
   writeLinkPointer
-} from "./index-qzstn430.js";
+} from "./index-m5z2fgs4.js";
 import {
   atomicWriteFile
-} from "./index-shazb5b6.js";
+} from "./index-2zz8b0rb.js";
 import {
   KNOWLEDGE_SCHEMA_VERSION,
   OUTCOME_BLOCK_THRESHOLD,
@@ -434,7 +434,7 @@ import {
   atomicWriteSwarmFileSync,
   matchTempGrammar,
   parseTargetBasename
-} from "./index-3yh2e5ca.js";
+} from "./index-zpn3wqvp.js";
 import {
   assertProjectRoot,
   hasExplicitProjectBoundary,
@@ -5604,7 +5604,7 @@ async function cleanupRecoveredWorktree(directory, descriptor) {
     awaitingMergeByCallID,
     cleanupStandardWorktreeForCallId,
     standardWorktreeByCallID
-  } = await import("./worktree-isolation-yj7ssh24.js");
+  } = await import("./worktree-isolation-vg6g00mq.js");
   standardWorktreeByCallID.delete(descriptor.callID);
   if (hasResidue)
     awaitingMergeByCallID.set(descriptor.callID, {
@@ -5706,7 +5706,7 @@ async function recoverCoderSettlement(directory, taskId) {
           awaitingMergeByCallID,
           finishStandardWorktreeDispatch,
           standardWorktreeByCallID
-        } = await import("./worktree-isolation-yj7ssh24.js");
+        } = await import("./worktree-isolation-vg6g00mq.js");
         const descriptor = wal.worktree;
         const reconstructedDispatch = {
           callID: descriptor.callID,
@@ -6370,7 +6370,7 @@ async function commitTaskTerminalUnderPlanLock(options) {
 // src/hooks/pr-workflow-gate.ts
 init_zod();
 import { createHash as createHash5, randomUUID as randomUUID3 } from "crypto";
-import { readFileSync as readFileSync5 } from "fs";
+import { readFileSync as readFileSync5, statSync as statSync5 } from "fs";
 import * as fsp2 from "fs/promises";
 import * as path12 from "path";
 
@@ -7663,6 +7663,258 @@ function digestText(text) {
   return createHash4("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 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)
+  }).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) => {
+  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 = [
@@ -7734,6 +7986,7 @@ var PR_REVIEW_TRIGGER_DEFINITIONS = [
   }
 ];
 var PR_REVIEW_REQUIRED_TRIGGER_IDS = PR_REVIEW_TRIGGER_DEFINITIONS.map((definition) => definition.id);
+var PR_REVIEW_TRIGGER_RECEIPT_MAX_BYTES = 2 * 1024 * 1024;
 var TriggerIdSchema = exports_external.enum(PR_REVIEW_REQUIRED_TRIGGER_IDS, { error: "unknown PR_REVIEW trigger_id" });
 var TriggerEvidenceSchema = exports_external.string().trim().min(1).max(4000);
 var PrReviewInlineTriggerRowSchema = exports_external.discriminatedUnion("result", [
@@ -8488,6 +8741,7 @@ var PrWorkflowGateStateSchema = exports_external.object({
   prReviewBatchCoherence: exports_external.record(exports_external.string().min(1), PrReviewBatchCoherenceRecordSchema).refine((entries) => Object.keys(entries).length <= MAX_WORKFLOW_BATCHES, `prReviewBatchCoherence may not exceed ${MAX_WORKFLOW_BATCHES} entries`).optional(),
   prReviewRetiredReviewerSessionIds: exports_external.array(exports_external.string().min(1)).max(MAX_RETIRED_REVIEWER_SESSION_IDS).optional(),
   prReviewRetiredConsolidatedLanes: exports_external.array(exports_external.string().min(1)).max(MAX_RETIRED_CONSOLIDATED_LANES).optional(),
+  prReviewReservedRunId: exports_external.string().min(1).optional(),
   prReviewArtifactRunId: exports_external.string().min(1).optional(),
   prReviewFindingsPath: exports_external.string().min(1).optional(),
   prReviewArtifactBoundaries: exports_external.array(exports_external.enum(["post_explorer", "post_reviewer", "post_critic"])).max(3).optional(),
@@ -9140,8 +9394,8 @@ async function assertPrReviewValidationSettled(directory, sessionID, phase, gate
   return state;
 }
 var PR_REVIEW_HANDOFF_RELATIVE_PATH_PATTERN = /^pr-review\/([A-Za-z0-9][A-Za-z0-9._-]{0,127})\/feedback-handoff\.json$/;
-var PR_REVIEW_HANDOFF_MAX_BYTES = 128 * 1024;
-var PR_REVIEW_FINDINGS_MAX_BYTES = 10 * 1024 * 1024;
+var PR_REVIEW_FEEDBACK_CONSENT_MAX_BYTES = 64 * 1024;
+var PR_REVIEW_RUN_RESERVATION_MAX_BYTES = 16 * 1024;
 var PrReviewFeedbackHandoffArtifactSchema = exports_external.object({
   schema_version: exports_external.literal(1),
   run_id: exports_external.string().min(1).max(128),
@@ -9152,6 +9406,28 @@ var PrReviewFeedbackHandoffArtifactSchema = exports_external.object({
   summary: exports_external.string().min(1).max(20000),
   provenance: exports_external.array(exports_external.string().min(1).max(4000)).min(1).max(1000)
 }).strict();
+var PrReviewRunReservationSchema = exports_external.object({
+  schema_version: exports_external.literal(1),
+  session_id: exports_external.string().min(1),
+  workflow_instance_id: exports_external.string().min(1),
+  run_id: exports_external.string().min(1).max(128),
+  reserved_at: exports_external.string().datetime()
+}).strict();
+var PrReviewFeedbackConsentSchema = exports_external.object({
+  schema_version: exports_external.literal(1),
+  state: exports_external.enum(["offered", "confirmed"]),
+  session_id: exports_external.string().min(1),
+  source_workflow_instance_id: exports_external.string().min(1),
+  run_id: exports_external.string().min(1).max(128),
+  handoff_path: exports_external.string().min(1).max(512),
+  handoff_digest: exports_external.string().regex(/^[a-f0-9]{64}$/),
+  pr_url: exports_external.string().url().max(2000),
+  pr_head_sha: exports_external.string().regex(/^[0-9a-f]{6,64}$/i),
+  finding_ids_digest: exports_external.string().regex(/^[a-f0-9]{64}$/),
+  confirmation_command: exports_external.string().min(1).max(4000),
+  offered_at: exports_external.string().datetime(),
+  confirmed_at: exports_external.string().datetime().optional()
+}).strict();
 function normalizePrReviewFeedbackHandoffPath(handoffPath) {
   const normalized = handoffPath.trim().replace(/\\/g, "/");
   const relative3 = normalized.startsWith(".swarm/") ? normalized.slice(".swarm/".length) : normalized;
@@ -9160,6 +9436,13 @@ function normalizePrReviewFeedbackHandoffPath(handoffPath) {
     return null;
   return { runId: matched[1], relativePath: relative3 };
 }
+function buildAcceptedPrFeedbackContinuationCommands(confirmationCommand, relativeHandoffPath, requestedPrUrl) {
+  const commands = new Set([confirmationCommand]);
+  if (!requestedPrUrl) {
+    commands.add(`/swarm pr-feedback continue from .swarm/${relativeHandoffPath}`);
+  }
+  return commands;
+}
 async function readBoundedSwarmRegularFile(directory, relativePath, maxBytes, label) {
   const absPath = validateSwarmPath(directory, relativePath);
   const swarmRoot = path12.resolve(directory, ".swarm");
@@ -9225,6 +9508,68 @@ function normalizeComparableFsPath(value) {
   const normalized = path12.normalize(path12.resolve(value));
   return process.platform === "win32" ? normalized.toLowerCase() : normalized;
 }
+function prReviewRunReservationRelativePath(runId) {
+  return `pr-review/${runId}/run-reservation.json`;
+}
+function prReviewFeedbackConsentRelativePath(runId) {
+  return `pr-review/${runId}/feedback-consent.json`;
+}
+function hashPrReviewFindingIds(ids) {
+  return createHash5("sha256").update([...new Set(ids)].sort().join("\x00"), "utf8").digest("hex");
+}
+async function readPrReviewRunReservation(directory, runId) {
+  try {
+    const raw = await readBoundedSwarmRegularFile(directory, prReviewRunReservationRelativePath(runId), PR_REVIEW_RUN_RESERVATION_MAX_BYTES, "PR_REVIEW run reservation");
+    const parsed = PrReviewRunReservationSchema.safeParse(JSON.parse(raw));
+    if (!parsed.success) {
+      throw new Error("BLOCKED: PR_REVIEW run reservation is invalid");
+    }
+    return parsed.data;
+  } catch (error2) {
+    const message = error2 instanceof Error ? error2.message : String(error2);
+    if (message.includes("does not exist"))
+      return null;
+    throw error2;
+  }
+}
+async function readPrReviewFeedbackConsent(directory, runId) {
+  try {
+    const raw = await readBoundedSwarmRegularFile(directory, prReviewFeedbackConsentRelativePath(runId), PR_REVIEW_FEEDBACK_CONSENT_MAX_BYTES, "PR_REVIEW feedback consent artifact");
+    const parsed = PrReviewFeedbackConsentSchema.safeParse(JSON.parse(raw));
+    if (!parsed.success) {
+      throw new Error("BLOCKED: PR_REVIEW feedback consent artifact is invalid");
+    }
+    return parsed.data;
+  } catch (error2) {
+    const message = error2 instanceof Error ? error2.message : String(error2);
+    if (message.includes("does not exist"))
+      return null;
+    throw error2;
+  }
+}
+async function writePrReviewFeedbackConsent(directory, record) {
+  const relativePath = prReviewFeedbackConsentRelativePath(record.run_id);
+  const absolutePath = validateSwarmPath(directory, relativePath);
+  if (record.state === "confirmed") {
+    await writeAtomicJson(directory, absolutePath, record);
+    return;
+  }
+  const parent = path12.dirname(absolutePath);
+  const tempPath = path12.join(parent, `.feedback-consent.${randomUUID3()}.tmp`);
+  await fsp2.mkdir(parent, { recursive: true });
+  try {
+    await fsp2.writeFile(tempPath, `${JSON.stringify(record, null, 2)}
+`, {
+      encoding: "utf8",
+      flag: "wx"
+    });
+    await fsp2.link(tempPath, absolutePath);
+  } finally {
+    await fsp2.rm(tempPath, { force: true }).catch(() => {
+      return;
+    });
+  }
+}
 async function readPrReviewFeedbackHandoffArtifact(directory, relativePath) {
   const raw = await readBoundedSwarmRegularFile(directory, relativePath, PR_REVIEW_HANDOFF_MAX_BYTES, "PR_REVIEW feedback handoff artifact");
   let parsedJson;
@@ -9297,6 +9642,11 @@ function canonicalGitHubPrUrl(value) {
     return null;
   }
 }
+function assertMatchingPrReviewFeedbackConsent(record, input) {
+  if (record.session_id !== input.sessionID || record.run_id !== input.runId || record.handoff_path !== input.handoffPath || record.handoff_digest !== input.handoffDigest || canonicalGitHubPrUrl(record.pr_url) !== canonicalGitHubPrUrl(input.prUrl) || record.pr_head_sha.toLowerCase() !== input.prHeadSha.toLowerCase() || record.finding_ids_digest !== input.findingIdsDigest || record.source_workflow_instance_id !== input.sourceWorkflowInstanceId) {
+    throw new Error("BLOCKED: PR_REVIEW feedback consent artifact does not match the requested handoff; remove the stale sidecar or repeat the exact continuation offer");
+  }
+}
 function workflowIdentity(state) {
   return state.workflowInstanceId ?? `legacy-${createHash5("sha256").update(`${state.sessionID}\x00${state.mode}\x00${state.activatedAt}`).digest("hex").slice(0, 32)}`;
 }
@@ -9376,6 +9726,7 @@ async function transitionPrReviewToFeedback(directory, sessionID, request) {
     return preliminary;
   }
   let sourceIdentity;
+  let expectedConsentSourceIdentity;
   let sourceRevision = 0;
   let provenance;
   if (preliminary) {
@@ -9391,17 +9742,39 @@ async function transitionPrReviewToFeedback(directory, sessionID, request) {
       throw new Error("BLOCKED: PR_REVIEW feedback handoff finding IDs do not match the authoritative final findings ledger");
     }
     sourceIdentity = workflowIdentity(ready);
+    expectedConsentSourceIdentity = sourceIdentity;
     sourceRevision = ready.revision;
     provenance = "active-review-v1";
   } else {
-    if (!request.prUrl) {
-      throw new Error("BLOCKED: continuing a completed PR_REVIEW requires an explicit GitHub PR URL");
+    const reservation = await readPrReviewRunReservation(directory, request.runId);
+    if (!reservation || reservation.session_id !== normalizedSessionID || reservation.run_id !== request.runId) {
+      throw new Error("BLOCKED: completed PR_REVIEW continuation requires the matching durable run reservation for this session");
     }
-    sourceIdentity = `external-${preliminaryRead.digest.slice(0, 32)}`;
+    expectedConsentSourceIdentity = reservation.workflow_instance_id;
+    sourceIdentity = expectedConsentSourceIdentity;
     provenance = "external-v1";
   }
+  const consent = await readPrReviewFeedbackConsent(directory, request.runId);
+  if (!consent) {
+    throw new Error("BLOCKED: PR_FEEDBACK continuation requires explicit confirmation; repeat the exact continuation command first");
+  }
+  assertMatchingPrReviewFeedbackConsent(consent, {
+    sessionID: normalizedSessionID,
+    runId: request.runId,
+    handoffPath: normalizedHandoff.relativePath,
+    handoffDigest: preliminaryRead.digest,
+    prUrl: artifact.pr_url,
+    prHeadSha: artifact.pr_head_sha,
+    findingIdsDigest: hashPrReviewFindingIds(artifact.finding_ids),
+    sourceWorkflowInstanceId: expectedConsentSourceIdentity
+  });
+  const exactCommand = request.exactCommand?.trim();
+  const acceptedContinuationCommands = buildAcceptedPrFeedbackContinuationCommands(consent.confirmation_command, normalizedHandoff.relativePath, request.prUrl);
+  if (request.confirmedByUser !== true || !exactCommand || !acceptedContinuationCommands.has(exactCommand)) {
+    throw new Error(`BLOCKED: PR_FEEDBACK continuation requires explicit confirmation with the offered command: ${consent.confirmation_command}`);
+  }
   await _test_exports2.beforePrFeedbackTransitionLock?.();
-  return withSessionStateMutation(directory, normalizedSessionID, async () => {
+  return withPrWorkflowCheckoutMutationLock(directory, () => withSessionStateMutation(directory, normalizedSessionID, async () => {
     const current = await readPrWorkflowGateStateFromDisk(directory, normalizedSessionID);
     if (current?.mode === "PR_FEEDBACK") {
       assertSamePrFeedbackHandoff(current, normalizedHandoff.relativePath, preliminaryRead, request.prUrl);
@@ -9414,6 +9787,12 @@ async function transitionPrReviewToFeedback(directory, sessionID, request) {
     } else if (current) {
       throw new Error("BLOCKED: another PR workflow became active while validating the external handoff");
     }
+    if (provenance === "external-v1") {
+      const lockedReservation = await readPrReviewRunReservation(directory, request.runId);
+      if (!lockedReservation || lockedReservation.session_id !== normalizedSessionID || lockedReservation.workflow_instance_id !== expectedConsentSourceIdentity) {
+        throw new Error("BLOCKED: PR_REVIEW run reservation changed during external feedback transition");
+      }
+    }
     const lockedRead = await readPrReviewFeedbackHandoffArtifact(directory, normalizedHandoff.relativePath);
     if (lockedRead.digest !== preliminaryRead.digest) {
       throw new Error("BLOCKED: PR_REVIEW feedback handoff artifact changed during transition");
@@ -9421,6 +9800,30 @@ async function transitionPrReviewToFeedback(directory, sessionID, request) {
     if (artifactPr !== canonicalGitHubPrUrl(lockedRead.artifact.pr_url) || lockedRead.artifact.run_id !== request.runId || lockedRead.artifact.pr_head_sha.toLowerCase() !== artifact.pr_head_sha.toLowerCase() || !sameHandoffIds(lockedRead.artifact.finding_ids, artifact.finding_ids)) {
       throw new Error("BLOCKED: PR_REVIEW feedback handoff artifact changed during transition");
     }
+    const lockedConsent = await readPrReviewFeedbackConsent(directory, request.runId);
+    if (!lockedConsent) {
+      throw new Error("BLOCKED: PR_REVIEW feedback consent artifact disappeared during transition");
+    }
+    assertMatchingPrReviewFeedbackConsent(lockedConsent, {
+      sessionID: normalizedSessionID,
+      runId: request.runId,
+      handoffPath: normalizedHandoff.relativePath,
+      handoffDigest: lockedRead.digest,
+      prUrl: lockedRead.artifact.pr_url,
+      prHeadSha: lockedRead.artifact.pr_head_sha,
+      findingIdsDigest: hashPrReviewFindingIds(lockedRead.artifact.finding_ids),
+      sourceWorkflowInstanceId: expectedConsentSourceIdentity
+    });
+    if (!buildAcceptedPrFeedbackContinuationCommands(lockedConsent.confirmation_command, normalizedHandoff.relativePath, request.prUrl).has(exactCommand)) {
+      throw new Error("BLOCKED: PR_FEEDBACK continuation command changed during transition");
+    }
+    if (lockedConsent.state === "offered") {
+      await writePrReviewFeedbackConsent(directory, {
+        ...lockedConsent,
+        state: "confirmed",
+        confirmed_at: isoNow()
+      });
+    }
     const timestamp = isoNow();
     const nextState = {
       schemaVersion: GATE_SCHEMA_VERSION,
@@ -9445,7 +9848,7 @@ async function transitionPrReviewToFeedback(directory, sessionID, request) {
     return writeStateWhileLocked(directory, nextState, {
       replaceWorkflowInstanceId: provenance === "active-review-v1" ? current?.workflowInstanceId : undefined
     });
-  });
+  }));
 }
 var _test_exports2 = {
   minimumConsolidatedLaneCover,
@@ -9455,6 +9858,7 @@ var _test_exports2 = {
   parseCanonicalCandidateRows,
   resolvePrReviewRowFamily,
   pipeFieldsCapped,
+  indexVerdictRows,
   reviewerVerdictRowDigest,
   workflowGateStateRelativePath,
   workflowGateStateLockRelativePath,
@@ -9895,6 +10299,10 @@ function derivePrReviewCandidateInventory(directory, state, ctx) {
     const triggerPath = validateSwarmPath(directory, state.prReviewTriggerEvalPath);
     let triggerArtifact;
     try {
+      const triggerStat = statSync5(triggerPath);
+      if (!triggerStat.isFile() || triggerStat.size > PR_REVIEW_TRIGGER_RECEIPT_MAX_BYTES) {
+        throw new Error("trigger evaluation artifact exceeds its read bound");
+      }
       triggerArtifact = JSON.parse(readFileSync5(triggerPath, "utf-8"));
     } catch {
       throw new Error("BLOCKED: PR_REVIEW trigger evaluation artifact is missing or invalid");
@@ -10549,7 +10957,7 @@ function workflowArtifactHasContractMarker(directory, state, record, expectedMod
   }
   return true;
 }
-function analyzePrReviewDiscoveryArtifact(text, expectedWorkflowLane, ownedWorkflowLanes = [expectedWorkflowLane], mode) {
+function analyzePrReviewDiscoveryArtifact(text, expectedWorkflowLane, ownedWorkflowLanes = [expectedWorkflowLane], mode, acceptPartial = false) {
   const fallbackFamily = resolvePrReviewRowFamily(expectedWorkflowLane, mode);
   const issues = [];
   const normalized = normalizeCandidateArtifact(text, fallbackFamily);
@@ -10583,7 +10991,7 @@ function analyzePrReviewDiscoveryArtifact(text, expectedWorkflowLane, ownedWorkf
     source: "collect_lane_results",
     produced_at: "1970-01-01T00:00:00.000Z"
   }, {
-    accept_partial: false,
+    accept_partial: acceptPartial,
     accept_degraded: false,
     degraded: false,
     row_format_version: 1,
@@ -10701,7 +11109,7 @@ function validatePrReviewDiscoveryLaneCompletion(input) {
   const artifact = input.artifact;
   const analyses = ownedWorkflowLanes.map((workflowLane) => ({
     workflowLane,
-    analysis: analyzePrReviewDiscoveryArtifact(artifact.text, workflowLane, ownedWorkflowLanes, input.expected.mode)
+    analysis: analyzePrReviewDiscoveryArtifact(artifact.text, workflowLane, ownedWorkflowLanes, input.expected.mode, input.result.transcriptIncomplete === true)
   }));
   const salvagedLanes = [];
   const recoveries = [];
@@ -10782,26 +11190,6 @@ function prReviewDiscoveryArtifactCoversLane(text, expectedWorkflowLane, ownedWo
 function extractLaneCoverageEvidenceText(text, expectedWorkflowLane, ownedWorkflowLanes = [expectedWorkflowLane], mode) {
   return analyzePrReviewDiscoveryArtifact(text, expectedWorkflowLane, ownedWorkflowLanes, mode).evidence;
 }
-var REVIEWER_CLASSIFICATIONS = new Set([
-  "CONFIRMED",
-  "DISPROVED",
-  "UNVERIFIED",
-  "PRE_EXISTING"
-]);
-var REVIEWER_EVIDENCE_TYPES = new Set([
-  "STRUCTURALLY_PROVEN",
-  "EXECUTION_PROVEN",
-  "STATIC_TRACE_PROVEN",
-  "PLAUSIBLE_BUT_UNVERIFIED"
-]);
-var REVIEW_SEVERITIES = new Set([
-  "CRITICAL",
-  "HIGH",
-  "MEDIUM",
-  "LOW",
-  "INFO",
-  "NONE"
-]);
 var REVIEW_SEVERITY_RANK = new Map([
   ["NONE", 0],
   ["INFO", 1],
@@ -10810,12 +11198,6 @@ var REVIEW_SEVERITY_RANK = new Map([
   ["HIGH", 4],
   ["CRITICAL", 5]
 ]);
-var CRITIC_STATUSES = new Set([
-  "UPHELD",
-  "DOWNGRADED",
-  "DISPROVED",
-  "NEEDS_MORE_EVIDENCE"
-]);
 var FEEDBACK_CLASSIFICATIONS = new Set([
   "CONFIRMED",
   "PARTIAL",
@@ -10830,13 +11212,25 @@ var FEEDBACK_NO_CHANGE_CLASSIFICATIONS = new Set([
   "NEEDS_MORE_EVIDENCE",
   "NEEDS_USER_DECISION"
 ]);
-function indexVerdictRows(text, marker, fieldCount) {
+function indexVerdictRows(text, marker) {
   const markerRows = [];
   const rowsByItemId = new Map;
+  const recoveries = [];
   for (const line of text.split(/\r?\n/)) {
-    const fields = pipeFieldsCapped(line, fieldCount);
-    if (fields[0] !== marker)
+    const row = parsePrReviewVerdictRow(line, marker === "[REVIEWED]" ? "reviewer" : "critic");
+    if (!row)
       continue;
+    const fields = row.fields;
+    if (row.recoveredOverflow) {
+      const recovery = row.overflowClass;
+      const itemId2 = fields[1] ?? "(missing)";
+      recoveries.push({ marker, itemId: itemId2, recovery });
+      warn("PR_REVIEW recovered a legacy verdict row with unescaped pipe overflow", {
+        marker,
+        itemId: itemId2,
+        recovery
+      });
+    }
     markerRows.push(fields);
     const itemId = fields[1] ?? "";
     const rows = rowsByItemId.get(itemId);
@@ -10845,19 +11239,11 @@ function indexVerdictRows(text, marker, fieldCount) {
     else
       rowsByItemId.set(itemId, [fields]);
   }
-  return { markerRows, rowsByItemId };
+  return { markerRows, rowsByItemId, recoveries };
 }
 function validateReviewerVerdictFields(fields) {
-  if (fields.length !== 10 || !fields.slice(1).every(Boolean))
-    return null;
-  const introduced = fields[5].replace(/^introduced_by_pr\s*:\s*/i, "").toUpperCase();
-  if (!REVIEWER_CLASSIFICATIONS.has(fields[2]) || !REVIEWER_EVIDENCE_TYPES.has(fields[3]) || !REVIEW_SEVERITIES.has(fields[4]) || !["YES", "NO", "UNKNOWN"].includes(introduced))
-    return null;
-  if (fields[2] === "DISPROVED" && fields[4] !== "NONE")
-    return null;
-  if (fields[7].length < 8 || fields[8].length < 5 || fields[9].length < 3)
-    return null;
-  return fields;
+  const parsed = PrReviewReviewerVerdictFieldsSchema.safeParse(fields);
+  return parsed.success ? [...parsed.data] : null;
 }
 function reviewerVerdictRowDigest(fields) {
   return createHash5("sha256").update(fields.join("\x00")).digest("hex");
@@ -10868,8 +11254,10 @@ function parseLaneItemVerdicts(text, itemIds, phase, reviewerClaims) {
 function parsePrReviewVerdictRows(text, itemIds, phase, reviewerClaims) {
   const parsed = new Map;
   const marker = phase === "reviewer" ? "[REVIEWED]" : "[CRITIC]";
-  const { markerRows, rowsByItemId } = indexVerdictRows(text, marker, phase === "reviewer" ? 10 : 6);
+  const { markerRows, rowsByItemId, recoveries } = indexVerdictRows(text, marker);
   for (const itemId of itemIds) {
+    if (itemId === PR_REVIEW_DISCARDED_EXAMPLE_ITEM_ID)
+      continue;
     if (phase === "reviewer") {
       const rows2 = rowsByItemId.get(itemId);
       const fields = rows2?.length === 1 ? validateReviewerVerdictFields(rows2[0]) : null;
@@ -10891,12 +11279,12 @@ function parsePrReviewVerdictRows(text, itemIds, phase, reviewerClaims) {
       severity: verdict.severity
     });
   }
-  return { markerRows, parsed };
+  return { markerRows, parsed, recoveries };
 }
 function analyzePrReviewVerdictRowContract(text, itemIds, phase, reviewerClaims) {
   const marker = phase === "reviewer" ? "[REVIEWED]" : "[CRITIC]";
   const assigned = new Set(itemIds);
-  const { markerRows, parsed } = parsePrReviewVerdictRows(text, itemIds, phase, reviewerClaims);
+  const { markerRows, parsed, recoveries } = parsePrReviewVerdictRows(text, itemIds, phase, reviewerClaims);
   const observedIds = markerRows.map((fields) => fields[1] || "(missing)");
   const unexpectedIds = [
     ...new Set(observedIds.filter((itemId) => !assigned.has(itemId)))
@@ -10910,7 +11298,8 @@ function analyzePrReviewVerdictRowContract(text, itemIds, phase, reviewerClaims)
       observedIds,
       invalidOrMissingIds,
       unexpectedIds
-    })
+    }),
+    recoveries
   };
 }
 function verdictRowIdsMatchExactly(markerRows, itemIds) {
@@ -10935,35 +11324,27 @@ function verdictRowsContainOnlyAssignedIds(markerRows, itemIds) {
   return markerRows.every((fields) => assigned.has(fields[1] ?? ""));
 }
 function parseCriticVerdict(text, itemId, reviewerSeverity) {
-  const rows = indexVerdictRows(text, "[CRITIC]", 6).rowsByItemId.get(itemId);
+  const rows = indexVerdictRows(text, "[CRITIC]").rowsByItemId.get(itemId);
   if (!rows || rows.length !== 1)
     return null;
   return validateCriticVerdictFields(rows[0], reviewerSeverity);
 }
 function validateCriticVerdictFields(fields, reviewerSeverity) {
-  if (fields.length !== 6 || !fields.slice(1).every(Boolean) || !CRITIC_STATUSES.has(fields[2]) || !REVIEW_SEVERITIES.has(fields[3]))
-    return null;
-  if (fields[2] === "NEEDS_MORE_EVIDENCE")
-    return null;
-  if (fields[2] === "DISPROVED" && fields[3] !== "NONE")
-    return null;
-  if (fields[2] === "UPHELD" && !["CRITICAL", "HIGH", "MEDIUM"].includes(fields[3]))
-    return null;
-  if (fields[2] === "DOWNGRADED" && fields[3] === "CRITICAL")
+  const parsed = PrReviewCriticVerdictFieldsSchema.safeParse(fields);
+  if (!parsed.success)
     return null;
+  const verdict = parsed.data;
   if (reviewerSeverity) {
     const reviewerRank = REVIEW_SEVERITY_RANK.get(reviewerSeverity);
-    const criticRank = REVIEW_SEVERITY_RANK.get(fields[3]);
+    const criticRank = REVIEW_SEVERITY_RANK.get(verdict[3]);
     if (reviewerRank === undefined || criticRank === undefined)
       return null;
-    if (fields[2] === "UPHELD" && criticRank !== reviewerRank)
+    if (verdict[2] === "UPHELD" && criticRank !== reviewerRank)
       return null;
-    if (fields[2] === "DOWNGRADED" && criticRank >= reviewerRank)
+    if (verdict[2] === "DOWNGRADED" && criticRank >= reviewerRank)
       return null;
   }
-  if (fields[4].length < 6 || fields[5].length < 6)
-    return null;
-  return { status: fields[2], severity: fields[3] };
+  return { status: verdict[2], severity: verdict[3] };
 }
 function artifactHasExactPositiveVerdictRow(text, marker, itemId, positiveVerdict) {
   const rows = text.split(/\r?\n/).map((line) => pipeFieldsCapped(line, 4)).filter((fields) => fields[0] === marker && fields[1] === itemId);
@@ -17362,7 +17743,7 @@ function buildPromotedExternalInputFromSkill(directory, skillSlug, usage, ageDay
 
 // src/services/skill-reviser.ts
 init_logger();
-import { readFile as readFile9, rename as rename3, writeFile as writeFile4 } from "fs/promises";
+import { readFile as readFile9, rename as rename3, writeFile as writeFile5 } from "fs/promises";
 var REVISION_VIOLATION_THRESHOLD = 0.15;
 var MAX_REVISION_CALLS_PER_PHASE = 3;
 var DEFAULT_MAX_CALLS = 10;
@@ -17505,7 +17886,7 @@ async function reviseSkill(params) {
         };
       }
       const tmpPath = `${params.skillPath}.tmp-${process.pid}-${Date.now()}`;
-      await writeFile4(tmpPath, revised, "utf-8");
+      await writeFile5(tmpPath, revised, "utf-8");
       await rename3(tmpPath, params.skillPath);
       const newVersion = params.currentVersion + 1;
       const entry = {
@@ -17582,7 +17963,7 @@ async function reviseSkill(params) {
       };
     }
     const tmpPath = `${params.skillPath}.tmp-${process.pid}-${Date.now()}`;
-    await writeFile4(tmpPath, `${finalOutput}
+    await writeFile5(tmpPath, `${finalOutput}
 `, "utf-8");
     await rename3(tmpPath, params.skillPath);
     const newVersion = expectedVersion;
@@ -18001,7 +18382,7 @@ function planMerges(active, threshold, maxComparisons, maxMerges) {
   };
 }
 async function sweepActiveNearDuplicates(directory, options = {}) {
-  const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-627mz27c.js");
+  const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-hwfs0ze1.js");
   const { config } = loadPluginConfigWithMeta2(directory);
   const sweepConfig = config.learning?.dedup_sweep;
   if (sweepConfig?.enabled === false)
@@ -19119,7 +19500,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-r3knfwrp.js");
+        const skillModule = await import("./skill-generator-z70bhhx9.js");
         for (const cand of skillCandidates) {
           if (cand.confidence < (config.min_skill_confidence ?? DEFAULT_SKILL_MIN_CONFIDENCE)) {
             continue;
@@ -19591,7 +19972,7 @@ async function applyCuratorKnowledgeUpdates(directory, recommendations, knowledg
     } catch {}
   }
   if (contradictedEntries.length > 0 && knowledgeConfig.contradiction_threshold_action === "quarantine") {
-    const { maybeQuarantineOnContradiction } = await import("./knowledge-escalator-21n4ztqx.js");
+    const { maybeQuarantineOnContradiction } = await import("./knowledge-escalator-jxpz0mv5.js");
     for (const { id } of contradictedEntries) {
       try {
         await maybeQuarantineOnContradiction(directory, id, knowledgeConfig.contradiction_quarantine_threshold, knowledgeConfig.contradiction_quarantine_window_days);
@@ -20410,7 +20791,7 @@ async function runCuratorPostMortem(directory, options = {}) {
       warnings.push("Failed to collect knowledge summary.");
     }
     try {
-      const { getScanStatus } = await import("./scan-cursor-zn2qf06a.js");
+      const { getScanStatus } = await import("./scan-cursor-7xbrxm2c.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.`);
@@ -20582,9 +20963,9 @@ var _internals26 = {
   verifyPostMortemKnowledgeActions,
   repairPostMortemActions,
   loadDefaultKnowledgeConfig: async (directory) => {
-    const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-ynwy7abm.js");
+    const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-gcjdpfr9.js");
     try {
-      const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-627mz27c.js");
+      const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-hwfs0ze1.js");
       const loaded = loadPluginConfigWithMeta2(directory);
       return KnowledgeConfigSchema2.parse(loaded.config.knowledge ?? {});
     } catch {
@@ -20592,11 +20973,11 @@ var _internals26 = {
     }
   },
   applyCuratorKnowledgeUpdates: async (directory, recommendations, knowledgeConfig, generation) => {
-    const { applyCuratorKnowledgeUpdates: applyCuratorKnowledgeUpdates2 } = await import("./curator-2jhdfjqg.js");
+    const { applyCuratorKnowledgeUpdates: applyCuratorKnowledgeUpdates2 } = await import("./curator-bsr0xx05.js");
     return applyCuratorKnowledgeUpdates2(directory, recommendations, knowledgeConfig, generation);
   },
   checkHivePromotions: async (entries, knowledgeConfig, directory) => {
-    const { checkHivePromotions } = await import("./hive-promoter-w4batwr6.js");
+    const { checkHivePromotions } = await import("./hive-promoter-w7cr6qym.js");
     return checkHivePromotions(entries, knowledgeConfig, directory);
   },
   applyProposalTriage: async (directory, triage) => {
@@ -20605,7 +20986,7 @@ var _internals26 = {
       activateProposal,
       listSkills: listSkills2,
       sanitizeSlug
-    } = await import("./skill-generator-r3knfwrp.js");
+    } = await import("./skill-generator-z70bhhx9.js");
     const result = {
       approved: [],
       rejected: [],
@@ -21707,7 +22088,7 @@ import {
   mkdir as mkdir10,
   readFile as readFile11,
   realpath as realpath3,
-  writeFile as writeFile6
+  writeFile as writeFile7
 } from "fs/promises";
 import * as path28 from "path";
 
@@ -21719,7 +22100,7 @@ import {
   rename as rename4,
   stat as stat3,
   unlink as unlink3,
-  writeFile as writeFile5
+  writeFile as writeFile6
 } from "fs/promises";
 import * as path27 from "path";
 var SYNONYM_MAP_FILENAME = "synonym-map.json";
@@ -21879,7 +22260,7 @@ async function writeSynonymMapAtomic(filePath, map) {
   await mkdir9(path27.dirname(filePath), { recursive: true });
   const tmp = `${filePath}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`;
   try {
-    await writeFile5(tmp, JSON.stringify(map, null, 2), "utf-8");
+    await writeFile6(tmp, JSON.stringify(map, null, 2), "utf-8");
     await rename4(tmp, filePath);
   } finally {
     try {
@@ -21941,9 +22322,9 @@ function hashContent(content) {
   return createHash10("sha1").update(content).digest("hex");
 }
 async function loadConfigForPolicyCurator(directory) {
-  const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-ynwy7abm.js");
+  const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-gcjdpfr9.js");
   try {
-    const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-627mz27c.js");
+    const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-hwfs0ze1.js");
     const { config: loadedConfig } = loadPluginConfigWithMeta2(directory);
     return KnowledgeConfigSchema2.parse(loadedConfig.knowledge ?? {});
   } catch {
@@ -22469,7 +22850,7 @@ async function consumeInsightCandidates(directory, batchLimit = MESO_INSIGHT_BAT
       const body = data.length === 0 ? "" : `${data.map((c) => JSON.stringify(c)).join(`
 `)}
 `;
-      await writeFile6(p, body, "utf-8");
+      await writeFile7(p, body, "utf-8");
     }, (all) => {
       if (all.length === 0)
         return null;
@@ -24327,7 +24708,7 @@ import {
   readFile as readFile12,
   rename as rename5,
   truncate,
-  writeFile as writeFile7
+  writeFile as writeFile8
 } from "fs/promises";
 import * as path31 from "path";
 
@@ -25779,7 +26160,7 @@ async function writeJsonlAtomic(filePath, values) {
   const content = values.map((value) => JSON.stringify(value)).join(`
 `) + (values.length > 0 ? `
 ` : "");
-  await writeFile7(tmp, content, "utf-8");
+  await writeFile8(tmp, content, "utf-8");
   await rename5(tmp, filePath);
 }
 async function repairIncompleteJsonlTail(filePath) {
@@ -25804,7 +26185,7 @@ import {
   existsSync as existsSync19,
   mkdirSync as mkdirSync11,
   readFileSync as readFileSync15,
-  statSync as statSync9,
+  statSync as statSync10,
   writeFileSync as writeFileSync9
 } from "fs";
 import { createRequire as createRequire3 } from "module";
@@ -26166,7 +26547,7 @@ function resolveRerankerCacheDir() {
 
 // src/memory/jsonl-migration.ts
 import { existsSync as existsSync18, renameSync as renameSync7, unlinkSync as unlinkSync6 } from "fs";
-import { copyFile, mkdir as mkdir12, readFile as readFile13, stat as stat4, writeFile as writeFile8 } from "fs/promises";
+import { copyFile, mkdir as mkdir12, readFile as readFile13, stat as stat4, writeFile as writeFile9 } from "fs/promises";
 import * as path34 from "path";
 var LEGACY_JSONL_MIGRATION_VERSION = 2;
 var LEGACY_JSONL_MIGRATION_NAME = "legacy_jsonl_import_complete";
@@ -26232,7 +26613,7 @@ async function writeJsonlExport(rootDirectory, config, memories, proposals, outc
   const outcomesPath = path34.join(exportDir, "outcome-events.jsonl");
   const memoriesTempPath = path34.join(path34.dirname(memoriesPath), `${path34.basename(memoriesPath)}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
   try {
-    await writeFile8(memoriesTempPath, toJsonl(memories), "utf-8");
+    await writeFile9(memoriesTempPath, toJsonl(memories), "utf-8");
     renameSync7(memoriesTempPath, memoriesPath);
   } catch (err) {
     try {
@@ -26242,7 +26623,7 @@ async function writeJsonlExport(rootDirectory, config, memories, proposals, outc
   }
   const proposalsTempPath = path34.join(path34.dirname(proposalsPath), `${path34.basename(proposalsPath)}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
   try {
-    await writeFile8(proposalsTempPath, toJsonl(proposals), "utf-8");
+    await writeFile9(proposalsTempPath, toJsonl(proposals), "utf-8");
     renameSync7(proposalsTempPath, proposalsPath);
   } catch (err) {
     try {
@@ -26252,7 +26633,7 @@ async function writeJsonlExport(rootDirectory, config, memories, proposals, outc
   }
   const outcomesTempPath = path34.join(path34.dirname(outcomesPath), `${path34.basename(outcomesPath)}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
   try {
-    await writeFile8(outcomesTempPath, toJsonl(outcomeEvents), "utf-8");
+    await writeFile9(outcomesTempPath, toJsonl(outcomeEvents), "utf-8");
     renameSync7(outcomesTempPath, outcomesPath);
   } catch (err) {
     try {
@@ -26267,7 +26648,7 @@ async function writeMigrationReport(rootDirectory, report, config = {}) {
   await mkdir12(path34.dirname(reportPath), { recursive: true });
   const reportTempPath = path34.join(path34.dirname(reportPath), `${path34.basename(reportPath)}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
   try {
-    await writeFile8(reportTempPath, `${JSON.stringify(report, null, 2)}
+    await writeFile9(reportTempPath, `${JSON.stringify(report, null, 2)}
 `, "utf-8");
     renameSync7(reportTempPath, reportPath);
   } catch (err) {
@@ -27488,13 +27869,13 @@ class SQLiteMemoryProvider {
       }
       try {
         const wal = `${dbPath}-wal`;
-        const st = statSync9(wal);
+        const st = statSync10(wal);
         if (st.size > 0)
           walPath2 = wal;
       } catch {}
       try {
         const shm = `${dbPath}-shm`;
-        const st = statSync9(shm);
+        const st = statSync10(shm);
         if (st.size > 0)
           shmPath = shm;
       } catch {}
@@ -28965,7 +29346,7 @@ init_logger();
 import * as path38 from "path";
 
 // src/memory/memory-link.ts
-import { existsSync as existsSync20, mkdirSync as mkdirSync12, readFileSync as readFileSync16, rmSync as rmSync2, statSync as statSync10 } from "fs";
+import { existsSync as existsSync20, mkdirSync as mkdirSync12, readFileSync as readFileSync16, rmSync as rmSync2, statSync as statSync11 } from "fs";
 import * as path37 from "path";
 init_logger();
 var MEMORY_LINK_POINTER_FILENAME = "memory-link.json";
@@ -29025,7 +29406,7 @@ var _resolutionCache = new Map;
 function pointerStatFingerprint(directory) {
   const pointerPath = resolveMemoryLinkPointerPath(directory);
   try {
-    const st = statSync10(pointerPath);
+    const st = statSync11(pointerPath);
     return `${st.mtimeMs}:${st.ctimeMs}:${st.size}`;
   } catch {
     return null;
@@ -30272,7 +30653,7 @@ import * as path41 from "path";
 init_logger();
 
 // src/services/trajectory-cluster.ts
-import { mkdir as mkdir13, writeFile as writeFile9 } from "fs/promises";
+import { mkdir as mkdir13, writeFile as writeFile10 } from "fs/promises";
 import * as path40 from "path";
 init_logger();
 var MACRO_TRAJECTORY_WINDOW = 200;
@@ -30450,7 +30831,7 @@ async function writeMotifProposals(directory, opts = {}) {
         continue;
       const slug = `motif-${slugify(motif.signature)}`;
       const filePath = path40.join(proposalsDir, `${slug}.md`);
-      await writeFile9(filePath, buildMotifProposal(motif, {
+      await writeFile10(filePath, buildMotifProposal(motif, {
         fingerprint: decision.fingerprint,
         producedAt
       }), "utf-8");
@@ -30640,7 +31021,7 @@ async function writeSuccessMotifProposals(directory, opts = {}) {
         continue;
       const slug = workflowSlug(motif.signature);
       const filePath = path40.join(proposalsDir, `${slug}.md`);
-      await writeFile9(filePath, buildWorkflowProposal(motif, {
+      await writeFile10(filePath, buildWorkflowProposal(motif, {
         fingerprint: decision.fingerprint,
         producedAt
       }), "utf-8");
@@ -33139,7 +33520,7 @@ async function runFinalizeStage(ctx) {
     }
   }
   try {
-    const { CuratorConfigSchema: CCS } = await import("./schema-ynwy7abm.js");
+    const { CuratorConfigSchema: CCS } = await import("./schema-gcjdpfr9.js");
     const { config: pmLoadedConfig } = _internals41.loadPluginConfigWithMeta(ctx.directory);
     const curatorCfg = CCS.parse(pmLoadedConfig.curator ?? {});
     if (curatorCfg.enabled && curatorCfg.postmortem_enabled) {
@@ -34621,7 +35002,7 @@ import { promisify as promisify2 } from "util";
 init_zod();
 import * as child_process3 from "child_process";
 import { randomUUID as randomUUID8 } from "crypto";
-import { readdir as readdir3, readFile as readFile16, stat as stat5 } from "fs/promises";
+import { readdir as readdir4, readFile as readFile16, stat as stat5 } from "fs/promises";
 import * as path49 from "path";
 import { promisify } from "util";
 function getExecFileAsync() {
@@ -34724,7 +35105,7 @@ async function scanSourceFiles(dir) {
   const results = [];
   const skipDirs = new Set(["node_modules", ".swarm", "dist", "build"]);
   try {
-    const entries = await readdir3(dir, { withFileTypes: true });
+    const entries = await readdir4(dir, { withFileTypes: true });
     for (const entry of entries) {
       const fullPath = path49.join(dir, entry.name);
       if (entry.isDirectory()) {
@@ -35332,9 +35713,9 @@ var _internals45 = {
   loadPluginConfigWithMeta,
   loadCuratorDeps: async () => {
     const [{ CuratorConfigSchema }, curator, { createCuratorLLMDelegate: createCuratorLLMDelegate2 }] = await Promise.all([
-      import("./schema-ynwy7abm.js"),
-      import("./curator-2jhdfjqg.js"),
-      import("./curator-llm-factory-y43mx297.js")
+      import("./schema-gcjdpfr9.js"),
+      import("./curator-bsr0xx05.js"),
+      import("./curator-llm-factory-sdxsn88r.js")
     ]);
     return { CuratorConfigSchema, curator, createCuratorLLMDelegate: createCuratorLLMDelegate2 };
   }
@@ -35834,7 +36215,7 @@ ${USAGE8}`;
 // src/services/diagnose-service.ts
 init_package();
 import * as child_process5 from "child_process";
-import { existsSync as existsSync32, readdirSync as readdirSync6, readFileSync as readFileSync22, statSync as statSync12 } from "fs";
+import { existsSync as existsSync32, readdirSync as readdirSync6, readFileSync as readFileSync22, statSync as statSync13 } from "fs";
 import * as path53 from "path";
 import { fileURLToPath } from "url";
 
@@ -36324,7 +36705,7 @@ async function computeCurationDiagnostics(directory, entries) {
   let scanCompleted = false;
   let scanRemaining = 0;
   try {
-    const { getScanStatus } = await import("./scan-cursor-zn2qf06a.js");
+    const { getScanStatus } = await import("./scan-cursor-7xbrxm2c.js");
     const status = await getScanStatus(directory);
     scanGeneration = status.generation;
     scanCompleted = status.completed;
@@ -36332,19 +36713,19 @@ async function computeCurationDiagnostics(directory, entries) {
   } catch {}
   let configMatch = null;
   try {
-    const { isLinked: isLinked2 } = await import("./knowledge-link-vgxe7gz9.js");
+    const { isLinked: isLinked2 } = await import("./knowledge-link-5dctq0ax.js");
     if (isLinked2(directory)) {
-      const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-ynwy7abm.js");
+      const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-gcjdpfr9.js");
       let config;
       try {
-        const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-627mz27c.js");
+        const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-hwfs0ze1.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-166wdjs4.js");
+      const { buildConfigFingerprintInput: buildConfigFingerprintInput2, readCohortConfigFingerprint } = await import("./curation-policy-hkdghd3a.js");
       const currentFp = cohortConfigFingerprint2(buildConfigFingerprintInput2(config));
       const cohortFp = await readCohortConfigFingerprint(directory);
       configMatch = cohortFp === null ? null : currentFp === cohortFp;
@@ -36751,7 +37132,7 @@ async function checkConfigBackups(directory) {
 }
 async function checkGitRepository(directory) {
   try {
-    if (!existsSync32(directory) || !statSync12(directory).isDirectory()) {
+    if (!existsSync32(directory) || !statSync13(directory).isDirectory()) {
       return {
         name: "Git Repository",
         status: "\u274C",
@@ -37648,7 +38029,7 @@ async function handleDoctorCommand(directory, args) {
   const result = runConfigDoctor(config, directory);
   let output;
   if (enableAutoFix && result.hasAutoFixableIssues) {
-    const { runConfigDoctorWithFixes } = await import("./config-doctor-w6zphy4w.js");
+    const { runConfigDoctorWithFixes } = await import("./config-doctor-q3fw9744.js");
     const fixResult = await runConfigDoctorWithFixes(directory, config, true, {
       applyLossy: true
     });
@@ -38588,7 +38969,7 @@ async function handleEvidenceCommand(directory, args) {
   return formatTaskEvidenceMarkdown(evidenceData);
 }
 async function handleEvidenceSummaryCommand(directory) {
-  const { buildEvidenceSummary } = await import("./evidence-summary-service-7qpganmn.js");
+  const { buildEvidenceSummary } = await import("./evidence-summary-service-rk5exnrk.js");
   const artifact = await buildEvidenceSummary(directory);
   if (!artifact) {
     return "No plan found. Run `/swarm plan` to check plan status.";
@@ -44777,12 +45158,12 @@ import {
   chmod,
   copyFile as copyFile2,
   mkdir as mkdir16,
-  readdir as readdir4,
+  readdir as readdir5,
   readFile as readFile18,
   realpath as realpath4,
   rm as rm2,
   stat as stat6,
-  writeFile as writeFile10
+  writeFile as writeFile11
 } from "fs/promises";
 import * as path66 from "path";
 var HIVE_QUARANTINE_TOKEN_TTL_MS = 15 * 60 * 1000;
@@ -45574,11 +45955,11 @@ function emitMaintenanceTelemetry(payload) {
 var _internals60 = {
   emit,
   readFile: readFile18,
-  writeFile: writeFile10,
+  writeFile: writeFile11,
   copyFile: copyFile2,
   mkdir: mkdir16,
   stat: stat6,
-  readdir: readdir4,
+  readdir: readdir5,
   resolveHiveDataDir,
   resolveHiveKnowledgePath,
   transactHiveStore,
@@ -45898,7 +46279,7 @@ init_schema();
 init_logger();
 import { randomUUID as randomUUID10 } from "crypto";
 import { existsSync as existsSync41, readFileSync as readFileSync32 } from "fs";
-import { mkdir as mkdir17, readFile as readFile19, writeFile as writeFile11 } from "fs/promises";
+import { mkdir as mkdir17, readFile as readFile19, writeFile as writeFile12 } from "fs/promises";
 import * as os9 from "os";
 import * as path68 from "path";
 init_knowledge_types();
@@ -45966,7 +46347,7 @@ var _internals62 = {
   readFileSync: readFileSync32,
   readFile: readFile19,
   mkdir: mkdir17,
-  writeFile: writeFile11
+  writeFile: writeFile12
 };
 async function migrateContextToKnowledge(directory, config) {
   const sentinelPath = path68.join(directory, ".swarm", ".knowledge-migrated");
@@ -46779,7 +47160,7 @@ var _internals63 = {
 };
 
 // src/commands/link.ts
-import { mkdir as mkdir19, writeFile as writeFile12 } from "fs/promises";
+import { mkdir as mkdir19, writeFile as writeFile13 } from "fs/promises";
 import * as path70 from "path";
 init_schema();
 
@@ -47239,7 +47620,7 @@ ${formatStatus(directory)}`;
     const config = KnowledgeConfigSchema.parse(loadedConfig.knowledge ?? {});
     const fingerprint = cohortConfigFingerprint(buildConfigFingerprintInput(config));
     await mkdir19(linkDir, { recursive: true });
-    await writeFile12(path70.join(linkDir, "cohort-config.json"), JSON.stringify({ fingerprint, updated_at: new Date().toISOString() }, null, 2), "utf-8");
+    await writeFile13(path70.join(linkDir, "cohort-config.json"), JSON.stringify({ fingerprint, updated_at: new Date().toISOString() }, null, 2), "utf-8");
   } catch {}
   const relinkNote = existing ? `
 (Re-linked from previous link "${existing.linkId}".)` : "";
@@ -47265,7 +47646,7 @@ var MIN_MAX_CYCLES = 1;
 var MAX_MAX_CYCLES = 5;
 async function readLatestLoopState(directory) {
   try {
-    const { readdirSync: readdirSync9, statSync: statSync16, readFileSync: readFileSync34 } = await import("fs");
+    const { readdirSync: readdirSync9, statSync: statSync17, readFileSync: readFileSync34 } = await import("fs");
     const loopDir = `${directory}/.swarm/loop`;
     let latestMtime = 0;
     let latestPath = null;
@@ -47276,7 +47657,7 @@ async function readLatestLoopState(directory) {
           continue;
         const statePath = `${loopDir}/${entry.name}/state.json`;
         try {
-          const mtime = statSync16(statePath).mtimeMs;
+          const mtime = statSync17(statePath).mtimeMs;
           if (mtime > latestMtime) {
             latestMtime = mtime;
             latestPath = statePath;
@@ -47905,7 +48286,7 @@ import {
   openSync as openSync11,
   readSync as readSync7,
   realpathSync as realpathSync8,
-  statSync as statSync17
+  statSync as statSync18
 } from "fs";
 var import_proper_lockfile8 = __toESM(require_proper_lockfile(), 1);
 
@@ -52626,7 +53007,7 @@ function truncate2(value, maxLength) {
 }
 
 // src/commands/memory-link.ts
-import { mkdir as mkdir23, writeFile as writeFile14 } from "fs/promises";
+import { mkdir as mkdir23, writeFile as writeFile15 } from "fs/promises";
 import * as path79 from "path";
 init_schema();
 
@@ -53111,7 +53492,7 @@ ${formatStatus2(directory)}`;
     await mkdir23(cohortRoot.cohortRoot, { recursive: true });
     const fingerprintInput = buildMemoryCohortFingerprintInput(memoryConfig);
     const fingerprint = computeMemoryCohortFingerprint(fingerprintInput);
-    await writeFile14(path79.join(cohortRoot.cohortRoot, "memory-cohort-config.json"), JSON.stringify({
+    await writeFile15(path79.join(cohortRoot.cohortRoot, "memory-cohort-config.json"), JSON.stringify({
       fingerprint,
       algorithm_version: FINGERPRINT_ALGORITHM_VERSION,
       config: fingerprintInput,
@@ -60251,7 +60632,7 @@ async function handleQaGatesCommand(directory, args, sessionID) {
 }
 
 // src/workflow/stage-a-repair.ts
-import { appendFile as appendFile10, mkdir as mkdir24, readdir as readdir7 } from "fs/promises";
+import { appendFile as appendFile10, mkdir as mkdir24, readdir as readdir8 } from "fs/promises";
 import { dirname as dirname38 } from "path";
 init_logger();
 var MAX_STAGE_A_REPAIR_SCAN = 200;
@@ -60326,7 +60707,7 @@ async function repairWedgedStageA(directory, options) {
   let entries;
   try {
     const evidenceDir = validateSwarmPath(directory, "evidence");
-    entries = await readdir7(evidenceDir);
+    entries = await readdir8(evidenceDir);
   } catch {
     return { results: [], truncated: false };
   }
@@ -66569,7 +66950,7 @@ import {
   openSync as openSync18,
   readFileSync as readFileSync42,
   renameSync as renameSync15,
-  statSync as statSync21,
+  statSync as statSync22,
   unlinkSync as unlinkSync20,
   writeFileSync as writeFileSync17,
   writeFileSync as writeFileSyncAsync
@@ -66659,7 +67040,7 @@ var _internals90 = {
   renameSync: renameSync15,
   unlinkSync: unlinkSync20,
   existsSync: existsSync56,
-  statSync: statSync21
+  statSync: statSync22
 };
 async function appendEvent2(directory, eventInput) {
   assertProjectRoot(directory);
@@ -67940,7 +68321,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-rarzeth8.js");
+      const { createModelEvaluationExecutor: createModelEvaluationExecutor2 } = await import("./runner-9g2pcg10.js");
       const executor = createModelEvaluationExecutor2(input.dispatcher, input.sessionId);
       const result = await _internals95.evaluateCandidateV1({
         projectRoot: input.directory,
@@ -68462,7 +68843,7 @@ init_loader();
 init_schema();
 
 // src/consensus/store.ts
-import { readdir as readdir8, unlink as unlink6 } from "fs/promises";
+import { readdir as readdir9, unlink as unlink6 } from "fs/promises";
 import * as path107 from "path";
 
 // src/consensus/contracts.ts
@@ -68642,7 +69023,7 @@ function swarmPath(directory, ...segments) {
 async function countConsensusReportFiles(directory) {
   const root = swarmPath(directory, CONSENSUS_RELATIVE_DIR);
   try {
-    const entries = await readdir8(root, { withFileTypes: true });
+    const entries = await readdir9(root, { withFileTypes: true });
     return entries.filter((entry) => entry.isFile() && entry.name.endsWith(".json") && REPORT_ID_RE.test(entry.name.slice(0, -".json".length))).length;
   } catch (error2) {
     if (error2.code === "ENOENT")
@@ -69385,8 +69766,8 @@ async function countProposals(directory) {
     const proposalsDir = validateSwarmPath(directory, "skills/proposals");
     if (!fsSync3.existsSync(proposalsDir))
       return 0;
-    const { readdir: readdir9 } = await import("fs/promises");
-    const entries = await readdir9(proposalsDir);
+    const { readdir: readdir10 } = await import("fs/promises");
+    const entries = await readdir10(proposalsDir);
     return entries.filter((f) => f.endsWith(".md")).length;
   } catch {
     return 0;
@@ -69846,7 +70227,7 @@ function buildDetailedHelp(commandName, entry) {
 async function handleHelpCommand(ctx) {
   const targetCommand = ctx.args.join(" ");
   if (!targetCommand) {
-    const { buildHelpText } = await import("./index-s3s2egzn.js");
+    const { buildHelpText } = await import("./index-kn36sxj0.js");
     return buildHelpText();
   }
   const tokens = targetCommand.split(/\s+/);
@@ -69855,7 +70236,7 @@ async function handleHelpCommand(ctx) {
     return _internals98.buildDetailedHelp(resolved.key, resolved.entry);
   }
   const similar = _internals98.findSimilarCommands(targetCommand);
-  const { buildHelpText: fullHelp } = await import("./index-s3s2egzn.js");
+  const { buildHelpText: fullHelp } = await import("./index-kn36sxj0.js");
   if (similar.length > 0) {
     return `Command '/swarm ${targetCommand}' not found.
 
@@ -69896,10 +70277,13 @@ async function handlePrFeedbackCommandWithTransition(ctx) {
     return handlePrFeedbackCommand(ctx.directory, ctx.args);
   }
   if (parsed.continuation) {
+    const exactCommand = parsed.prUrl ? `/swarm pr-feedback ${parsed.prUrl} continue from ${parsed.continuation.handoffPath}` : `/swarm pr-feedback continue from ${parsed.continuation.handoffPath}`;
     await transitionPrReviewToFeedback(ctx.directory, ctx.sessionID, {
       runId: parsed.continuation.runId,
       handoffPath: parsed.continuation.handoffPath,
-      prUrl: parsed.prUrl
+      prUrl: parsed.prUrl,
+      exactCommand,
+      confirmedByUser: true
     });
   } else {
     await activatePrWorkflow(ctx.directory, ctx.sessionID, "PR_FEEDBACK", {
@@ -70032,7 +70416,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail explain": {
     handler: async (ctx) => {
-      const { handleGuardrailExplain } = await import("./guardrail-explain-76sy950j.js");
+      const { handleGuardrailExplain } = await import("./guardrail-explain-fnnka0vt.js");
       return handleGuardrailExplain(ctx.directory, ctx.args);
     },
     description: "Dry-run: show what the guardrails would do to a command or write target (executes nothing)",
@@ -70042,7 +70426,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail reset": {
     handler: async (ctx) => {
-      const { handleGuardrailReset } = await import("./guardrail-reset-tkkg0bfz.js");
+      const { handleGuardrailReset } = await import("./guardrail-reset-kk1rdmm0.js");
       return handleGuardrailReset(ctx.args, ctx.sessionID);
     },
     description: "Reset one exact active invocation/action circuit after repair",
@@ -70051,7 +70435,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail-explain": {
     handler: async (ctx) => {
-      const { handleGuardrailExplain } = await import("./guardrail-explain-76sy950j.js");
+      const { handleGuardrailExplain } = await import("./guardrail-explain-fnnka0vt.js");
       return handleGuardrailExplain(ctx.directory, ctx.args);
     },
     description: "Dry-run: show what the guardrails would do to a command or write target (executes nothing)",
@@ -70061,7 +70445,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail-reset": {
     handler: async (ctx) => {
-      const { handleGuardrailReset } = await import("./guardrail-reset-tkkg0bfz.js");
+      const { handleGuardrailReset } = await import("./guardrail-reset-kk1rdmm0.js");
       return handleGuardrailReset(ctx.args, ctx.sessionID);
     },
     description: "Reset one exact active invocation/action circuit after repair",
@@ -70071,7 +70455,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail-log": {
     handler: async (ctx) => {
-      const { handleGuardrailLog } = await import("./guardrail-log-pm0w6ney.js");
+      const { handleGuardrailLog } = await import("./guardrail-log-gsx9kj51.js");
       return handleGuardrailLog(ctx.directory, ctx.args);
     },
     description: "Read the guardrail decision log (use --blocks-only for blocks)",
@@ -76914,7 +77298,7 @@ function isLaneOwnedByCurrentSession(branchName, expectedSessionId) {
   return extracted === expectedSessionId;
 }
 async function inspectStandardWorktreeCollisionOwnership(identity) {
-  const collisionOwnership = await import("./worktree-collision-ownership-29md3k1n.js");
+  const collisionOwnership = await import("./worktree-collision-ownership-e0p490vw.js");
   return collisionOwnership.inspectStandardWorktreeCollisionOwnership(identity);
 }
 async function precreateStandardWorktreeSession(args) {
@@ -77062,7 +77446,7 @@ async function precreateStandardWorktreeSession(args) {
   const laneProfile = computeLaneRuntimeProfile(worktreeConfig.runtime_isolation, laneIndex, provisionResult.worktreePath);
   if (laneProfile) {
     try {
-      const { writeLaneProfileToDiskReal } = await import("./core-65qyqw2f.js");
+      const { writeLaneProfileToDiskReal } = await import("./core-y72nw57z.js");
       await writeLaneProfileToDiskReal(provisionResult.worktreePath, laneProfile.laneIndex, laneProfile.envOverrides);
     } catch {}
   }
@@ -77720,7 +78104,7 @@ async function finishStandardWorktreeDispatch(directory, dispatch, config, callI
       }
       clearWorktreeMergeStatus(statusKey);
       try {
-        const { removeLaneProfileFromDiskReal } = await import("./core-65qyqw2f.js");
+        const { removeLaneProfileFromDiskReal } = await import("./core-y72nw57z.js");
         await removeLaneProfileFromDiskReal(dispatch.handle.worktreePath, dispatch.laneIndex);
       } catch {}
       const state = serializationStateBySessionID.get(dispatch.parentSessionID);