opencode-swarm 7.140.1 → 7.140.2

package/dist/cli/{index-7f72x6nv.js → index-n831qq2v.js}

@@ -16,13 +16,13 @@ import {
 } from "./index-1m1ksyqt.js";
 import {
   stableCanonicalStringify
-} from "./index-m9csth1h.js";
+} from "./index-x6mtyj6q.js";
 import {
   detectStraySwarmDirs,
   readDoctorArtifact,
   removeStraySwarmDir,
   runConfigDoctor
-} from "./index-acc18zrj.js";
+} from "./index-chx92bes.js";
 import {
   MAX_TRANSIENT_RETRIES,
   archiveEvidence,
@@ -122,15 +122,15 @@ import {
   retireSkill,
   selectCandidateEntries,
   syncBundledProjectSkillsIfMissingAsync
-} from "./index-yf6p4wc5.js";
+} from "./index-9txca231.js";
 import {
   readRecentEscalations
-} from "./index-r7tg8kjh.js";
+} from "./index-z6md3t8m.js";
 import {
   alreadyCuratedThisGeneration,
   claimNextScanBatch,
   resolveCohortId
-} from "./index-7nhrn9sy.js";
+} from "./index-yt3vz0e1.js";
 import {
   CURATOR_INIT_PROMPT,
   CURATOR_PHASE_PROMPT,
@@ -222,11 +222,11 @@ import {
   validateActionableFields,
   validateLesson,
   validateSkillPath
-} from "./index-hnprx6qv.js";
+} from "./index-1j5my2qy.js";
 import {
   authorizeCuration,
   buildConfigFingerprintInput
-} from "./index-a98msw3z.js";
+} from "./index-t59cdg48.js";
 import {
   cohortConfigFingerprint
 } from "./index-rtry5xyf.js";
@@ -259,7 +259,7 @@ import {
   transactFile,
   transactKnowledge,
   wordBigrams
-} from "./index-dbg3agxz.js";
+} from "./index-325zmfyj.js";
 import {
   MAX_EVENT_LOG_ENTRIES,
   _internals,
@@ -269,7 +269,7 @@ import {
   recordHiveKnowledgeEvent,
   recordKnowledgeEvent,
   resolveKnowledgeEventsPath
-} from "./index-wysn7pcz.js";
+} from "./index-jfp1bgt1.js";
 import {
   resolveHiveDataDir,
   resolveHiveEventsPath,
@@ -313,7 +313,7 @@ import {
   init_loader,
   loadPluginConfig,
   loadPluginConfigWithMeta
-} from "./index-0an7an2s.js";
+} from "./index-0tevsq1a.js";
 import {
   RetrospectiveEvidenceSchema
 } from "./index-gprxjmm7.js";
@@ -345,7 +345,7 @@ import {
   package_default,
   resolveAutoReviewConfig,
   stripKnownSwarmPrefix
-} from "./index-jq7n7w9y.js";
+} from "./index-bmmzfrc7.js";
 import {
   AGENT_TOOL_MAP,
   ALL_AGENT_NAMES,
@@ -357,7 +357,7 @@ import {
   init_agent_names,
   init_constants,
   init_tool_metadata
-} from "./index-v1d4qz8y.js";
+} from "./index-n408rw7n.js";
 import {
   KNOWLEDGE_SCHEMA_VERSION,
   OUTCOME_BLOCK_THRESHOLD,
@@ -509,6 +509,122 @@ function removeCandidateCodeFences(text) {
   return lines.join(`
 `);
 }
+function parseClosedMarkdownFences(text) {
+  const lines = text.split(/\r?\n/);
+  const blocks = [];
+  const fencedLineIndexes = new Set;
+  let openingLine = -1;
+  let openingWidth = 0;
+  for (let index = 0;index < lines.length; index += 1) {
+    const line = lines[index];
+    if (openingLine < 0) {
+      const opening = line.match(/^\s{0,3}(`{3,})([^`]*)$/);
+      if (!opening)
+        continue;
+      openingLine = index;
+      openingWidth = opening[1].length;
+      continue;
+    }
+    const closing = line.match(/^\s{0,3}(`{3,})\s*$/);
+    if (!closing || closing[1].length < openingWidth)
+      continue;
+    const content = lines.slice(openingLine + 1, index);
+    blocks.push({ openingLine, closingLine: index, content });
+    for (let fenced = openingLine;fenced <= index; fenced += 1) {
+      fencedLineIndexes.add(fenced);
+    }
+    openingLine = -1;
+    openingWidth = 0;
+  }
+  if (openingLine >= 0)
+    return null;
+  return {
+    lines,
+    blocks,
+    unfencedLines: lines.filter((_, index) => !fencedLineIndexes.has(index))
+  };
+}
+function lineCarriesCandidateProtocol(line) {
+  const fields = splitPipeFields(line.trim()).map((field) => field.trim());
+  return fields[0] === CANDIDATE_MARKER || fields[0] === CLEAN_MARKER || candidateHeaderFamily(fields) !== null;
+}
+function lastUnescapedPipeIndex(line) {
+  let last = -1;
+  for (let index = 0;index < line.length; index += 1) {
+    if (line[index] === "\\" && line[index + 1] === "|") {
+      index += 1;
+      continue;
+    }
+    if (line[index] === "|")
+      last = index;
+  }
+  return last;
+}
+function repairRedundantCleanConfidenceLine(line, family) {
+  const fields = splitPipeFields(line).map((field) => field.trim());
+  if (fields.length !== CLEAN_FIELD_COUNT + 1 || fields[0] !== CLEAN_MARKER || !isCandidateConfidence(fields[CLEAN_FIELD_COUNT]) || !analyzeCleanFields(fields.slice(0, CLEAN_FIELD_COUNT), family).valid) {
+    return { line, repaired: false };
+  }
+  const delimiter = lastUnescapedPipeIndex(line);
+  if (delimiter < 0)
+    return { line, repaired: false };
+  return { line: line.slice(0, delimiter).trimEnd(), repaired: true };
+}
+function repairRedundantCleanConfidence(text, family) {
+  let repaired = false;
+  const lines = text.split(/\r?\n/).map((line) => {
+    const result = repairRedundantCleanConfidenceLine(line, family);
+    repaired ||= result.repaired;
+    return result.line;
+  });
+  return { text: lines.join(`
+`), repaired };
+}
+function isStrictProtocolDataLine(line, family) {
+  const clean = repairRedundantCleanConfidenceLine(line, family).line;
+  const fields = splitPipeFields(clean).map((field) => field.trim());
+  if (fields[0] === CLEAN_MARKER) {
+    return analyzeCleanFields(fields, family).valid;
+  }
+  if (fields[0] === CANDIDATE_MARKER) {
+    return analyzeCandidateFields(fields.slice(1), family).valid;
+  }
+  return analyzeCandidateFields(fields, family).valid;
+}
+function recoverTerminalProtocolFence(rawText, family) {
+  const parsed = parseClosedMarkdownFences(rawText);
+  if (!parsed || parsed.blocks.length === 0)
+    return null;
+  if (parsed.unfencedLines.some(lineCarriesCandidateProtocol))
+    return null;
+  let lastNonblankLine = parsed.lines.length - 1;
+  while (lastNonblankLine >= 0 && parsed.lines[lastNonblankLine].trim().length === 0) {
+    lastNonblankLine -= 1;
+  }
+  const terminal = parsed.blocks.at(-1);
+  if (terminal.closingLine !== lastNonblankLine)
+    return null;
+  if (parsed.blocks.slice(0, -1).some((block) => block.content.some(lineCarriesCandidateProtocol))) {
+    return null;
+  }
+  const content = terminal.content.slice().map((line) => line.trimEnd());
+  while (content[0]?.trim() === "")
+    content.shift();
+  while (content.at(-1)?.trim() === "")
+    content.pop();
+  if (content[0]?.trim() !== CANDIDATE_HEADERS[family])
+    return null;
+  const rows = content.slice(1).filter((line) => line.trim() !== "");
+  if (rows.length === 0 || !rows.every((line) => isStrictProtocolDataLine(line, family))) {
+    return null;
+  }
+  const outside = parsed.unfencedLines.join(`
+`).trimEnd();
+  const protocol = content.join(`
+`);
+  return outside ? `${outside}
+${protocol}` : protocol;
+}
 function declaredCanonicalFamilies(source) {
   const families = [];
   for (const line of source.split(/\r?\n/)) {
@@ -519,16 +635,23 @@ function declaredCanonicalFamilies(source) {
   return families;
 }
 function normalizeCandidateArtifact(rawText, fallbackFamily) {
-  const text = removeCandidateCodeFences(rawText);
+  const repairKinds = [];
+  const recoveredFence = recoverTerminalProtocolFence(rawText, fallbackFamily);
+  if (recoveredFence !== null)
+    repairKinds.push("terminal-protocol-fence");
+  const cleanRepair = repairRedundantCleanConfidence(recoveredFence ?? removeCandidateCodeFences(rawText), fallbackFamily);
+  if (cleanRepair.repaired)
+    repairKinds.push("redundant-clean-confidence");
+  const text = cleanRepair.text;
   const header = selectCandidateHeader(text.split(/\r?\n/));
   if (header?.markerBearing && header.family !== null) {
-    return { text, synthesizedHeader: false };
+    return { text, synthesizedHeader: false, repairKinds };
   }
   if (declaredCanonicalFamilies(text).length > 0) {
-    return { text, synthesizedHeader: false };
+    return { text, synthesizedHeader: false, repairKinds };
   }
   if (declaredCanonicalFamilies(rawText).some((family) => family !== fallbackFamily)) {
-    return { text, synthesizedHeader: false };
+    return { text, synthesizedHeader: false, repairKinds };
   }
   const lines = text.split(/\r?\n/);
   const hasSalvageableRow = lines.some((line) => {
@@ -540,11 +663,12 @@ function normalizeCandidateArtifact(rawText, fallbackFamily) {
     return analyzeCleanFields(fields, fallbackFamily).valid;
   });
   if (!hasSalvageableRow)
-    return { text, synthesizedHeader: false };
+    return { text, synthesizedHeader: false, repairKinds };
   const firstSalvageableIndex = lines.findIndex((line) => {
     const marker = splitPipeFields(line)[0]?.trim();
     return marker === CANDIDATE_MARKER || marker === CLEAN_MARKER;
   });
+  repairKinds.push("synthesized-header");
   return {
     text: [
       ...lines.slice(0, firstSalvageableIndex),
@@ -552,7 +676,8 @@ function normalizeCandidateArtifact(rawText, fallbackFamily) {
       ...lines.slice(firstSalvageableIndex)
     ].join(`
 `),
-    synthesizedHeader: true
+    synthesizedHeader: true,
+    repairKinds
   };
 }
 function analyzeCandidateLaneContext(context) {
@@ -1914,7 +2039,7 @@ async function activeOperations(gitDir) {
   }));
   return checks.filter((value) => value !== null);
 }
-async function classifyPrWorkflowGitState(directory) {
+async function classifyPrWorkflowGitState(directory, options = {}) {
   const [statusResult, rootResult, gitDirResult] = await Promise.all([
     _internals4.runGitCapture(directory, [
       "status",
@@ -1937,16 +2062,25 @@ async function classifyPrWorkflowGitState(directory) {
   }
   const worktreeRoot = rootResult.stdout.trim();
   const gitDir = gitDirResult.stdout.trim();
-  const parsed = parsePorcelainV2Snapshot(statusResult.stdout);
-  if (!worktreeRoot || !gitDir || !parsed) {
+  const parsedRaw = parsePorcelainV2Snapshot(statusResult.stdout);
+  if (!worktreeRoot || !gitDir || !parsedRaw) {
     return {
       kind: "indeterminate",
       code: "GIT_STATE_INDETERMINATE",
       retryable: false,
       requiredAction: "Resolve the malformed or incomplete Git status before starting the PR workflow.",
-      evidence: evidence(parsed, worktreeRoot || null, gitDir || null, [], "Git returned an incomplete status snapshot")
+      evidence: evidence(parsedRaw, worktreeRoot || null, gitDir || null, [], "Git returned an incomplete status snapshot")
     };
   }
+  const ignoredPaths = new Set((options.ignoredPaths ?? []).map((value) => value.replace(/\\/g, "/")));
+  const keepPath = (value) => !ignoredPaths.has(value.replace(/\\/g, "/"));
+  const parsed = {
+    ...parsedRaw,
+    dirtyTrackedPaths: parsedRaw.dirtyTrackedPaths.filter(keepPath),
+    untrackedPaths: parsedRaw.untrackedPaths.filter(keepPath),
+    unmergedPaths: parsedRaw.unmergedPaths.filter(keepPath),
+    dirtySubmodulePaths: parsedRaw.dirtySubmodulePaths.filter(keepPath)
+  };
   let operations;
   try {
     operations = await _internals4.activeOperations(path2.resolve(gitDir));
@@ -2059,6 +2193,7 @@ var STATE_MUTATION_LOCK_RETRY_DELAY_MS = 10;
 var STATE_MUTATION_LOCK_UNINITIALIZED_STALE_MS = 30000;
 var MAX_COMPLETED_CHECKOUT_LOCK_OWNERS = 64;
 var CHECKOUT_MUTATION_ACTION_TIMEOUT_MS = 5 * 60000;
+var MAX_PR_WORKFLOW_GATE_DIRECTORY_ENTRIES = MAX_TRACKED_SESSIONS * 2 + 1;
 var MAX_CANDIDATE_ISSUES_PER_ARTIFACT = 8;
 var MAX_BASE_COVERAGE_DIAGNOSTICS = 8;
 var MAX_BASE_COVERAGE_DIAGNOSTIC_CHARS = 1000;
@@ -2257,57 +2392,66 @@ function formatCheckoutRecoveryBlock(state) {
 }
 async function activatePrWorkflow(directory, sessionID, mode, options = {}) {
   const normalizedSessionID = normalizeSessionID(sessionID);
-  const existing = await readPrWorkflowGateState(directory, normalizedSessionID);
-  if (existing?.mode === mode) {
-    let activeState = existing;
-    if (mode === "PR_FEEDBACK" && options.prUrl) {
-      const requestedTarget = canonicalGitHubPrUrl(options.prUrl);
-      if (!requestedTarget) {
-        throw new Error("BLOCKED: PR_FEEDBACK target must be a canonical GitHub PR URL");
-      }
-      const existingTarget = existing.prFeedbackTargetUrl ? canonicalGitHubPrUrl(existing.prFeedbackTargetUrl) : null;
-      if (existingTarget && requestedTarget !== existingTarget) {
-        throw new Error(`BLOCKED: active PR_FEEDBACK targets a different GitHub pull request`);
-      }
-      if (!existingTarget) {
-        activeState = {
-          ...existing,
-          prFeedbackTargetUrl: options.prUrl,
-          updatedAt: isoNow()
-        };
-        await persistState(directory, activeState);
+  const initiallyActive = await readPrWorkflowGateState(directory, normalizedSessionID);
+  const checkoutPreflight = !initiallyActive && options.requireCheckoutPreflight ? await _test_exports.classifyPrWorkflowGitStateAsync(directory) : null;
+  return withPrWorkflowCheckoutMutationLock(directory, async () => withSessionStateMutation(directory, normalizedSessionID, async () => {
+    let existing = await readPrWorkflowGateStateFromDisk(directory, normalizedSessionID);
+    if (existing?.mode === mode) {
+      if (mode === "PR_FEEDBACK" && options.prUrl) {
+        const requestedTarget = canonicalGitHubPrUrl(options.prUrl);
+        if (!requestedTarget) {
+          throw new Error("BLOCKED: PR_FEEDBACK target must be a canonical GitHub PR URL");
+        }
+        const existingTarget = existing.prFeedbackTargetUrl ? canonicalGitHubPrUrl(existing.prFeedbackTargetUrl) : null;
+        if (existingTarget && requestedTarget !== existingTarget) {
+          throw new Error(`BLOCKED: active PR_FEEDBACK targets a different GitHub pull request`);
+        }
+        if (!existingTarget) {
+          existing = await writeStateWhileLocked(directory, {
+            ...existing,
+            prFeedbackTargetUrl: options.prUrl,
+            updatedAt: isoNow()
+          });
+        }
       }
+      return options.prHeadSha ? bindPrWorkflowHeadWhileLocked(directory, normalizedSessionID, options.prHeadSha) : existing;
     }
-    return options.prHeadSha ? bindPrWorkflowHead(directory, normalizedSessionID, options.prHeadSha) : activeState;
-  }
-  if (existing) {
-    throw new Error(`BLOCKED: session "${normalizedSessionID}" already has an active ${existing.mode} workflow; complete it before starting ${mode}`);
-  }
-  if (options.requireCheckoutPreflight) {
-    const checkoutState = await classifyPrWorkflowGitState(directory);
-    if (checkoutState.kind === "recovery-required" || checkoutState.kind === "indeterminate") {
-      throw new Error(formatCheckoutRecoveryBlock(checkoutState));
+    if (existing) {
+      throw new Error(`BLOCKED: session "${normalizedSessionID}" already has an active ${existing.mode} workflow; complete it before starting ${mode}`);
     }
-  }
-  const initialHead = options.prHeadSha ? await assertCurrentCheckoutHead(directory, options.prHeadSha, mode) : undefined;
-  const timestamp = isoNow();
-  const feedbackTargetUrl = mode === "PR_FEEDBACK" && options.prUrl ? canonicalGitHubPrUrl(options.prUrl) ? options.prUrl : null : undefined;
-  if (feedbackTargetUrl === null) {
-    throw new Error("BLOCKED: PR_FEEDBACK target must be a canonical GitHub PR URL");
-  }
-  const nextState = {
-    schemaVersion: GATE_SCHEMA_VERSION,
-    revision: 0,
-    workflowInstanceId: randomUUID(),
-    sessionID: normalizedSessionID,
-    mode,
-    activatedAt: timestamp,
-    updatedAt: timestamp,
-    ...initialHead ? { prHeadSha: initialHead } : {},
-    ...feedbackTargetUrl ? { prFeedbackTargetUrl: feedbackTargetUrl } : {}
-  };
-  await persistState(directory, nextState);
-  return nextState;
+    if (options.requireCheckoutPreflight) {
+      if (!checkoutPreflight) {
+        throw new Error("BLOCKED: PR workflow gate state changed during checkout preflight; retry activation against the current project state");
+      }
+      const lockedCheckoutPreflight = await _test_exports.classifyPrWorkflowGitStateAsync(directory, {
+        ignoredPaths: [
+          path3.join(".swarm", workflowCheckoutMutationLockRelativePath()),
+          path3.join(".swarm", workflowGateStateLockRelativePath(normalizedSessionID))
+        ]
+      });
+      if (lockedCheckoutPreflight.kind === "recovery-required" || lockedCheckoutPreflight.kind === "indeterminate") {
+        throw new Error(formatCheckoutRecoveryBlock(lockedCheckoutPreflight));
+      }
+    }
+    const initialHead = options.prHeadSha ? await assertCurrentCheckoutHead(directory, options.prHeadSha, mode) : undefined;
+    const timestamp = isoNow();
+    const feedbackTargetUrl = mode === "PR_FEEDBACK" && options.prUrl ? canonicalGitHubPrUrl(options.prUrl) ? options.prUrl : null : undefined;
+    if (feedbackTargetUrl === null) {
+      throw new Error("BLOCKED: PR_FEEDBACK target must be a canonical GitHub PR URL");
+    }
+    const nextState = {
+      schemaVersion: GATE_SCHEMA_VERSION,
+      revision: 0,
+      workflowInstanceId: randomUUID(),
+      sessionID: normalizedSessionID,
+      mode,
+      activatedAt: timestamp,
+      updatedAt: timestamp,
+      ...initialHead ? { prHeadSha: initialHead } : {},
+      ...feedbackTargetUrl ? { prFeedbackTargetUrl: feedbackTargetUrl } : {}
+    };
+    return writeStateWhileLocked(directory, nextState);
+  }));
 }
 async function readPrWorkflowGateState(directory, sessionID) {
   const normalizedSessionID = normalizeSessionID(sessionID);
@@ -2353,9 +2497,6 @@ async function abortPrWorkflow(directory, sessionID, options = { kind: "recovery
     const laneIds = openLanes.map((record) => record.laneId ?? record.subagentSessionId ?? "unknown").filter(Boolean).slice(0, 10).join(", ");
     throw new Error(`BLOCKED: ${state.mode} abort refused while ${openLanes.length} PR workflow lane(s) are still in flight (lane ids: ${laneIds}). Collect their results or let them settle before aborting.`);
   }
-  if (options.kind === "recovery" && state.prHeadSha && !state.checkoutRecovery) {
-    throw new Error(`BLOCKED: recovery abort of a bound ${state.mode} (pr_head_sha ${state.prHeadSha}) requires a controller-recorded terminal recovery condition (checkoutRecovery). Binding succeeded, so "checkout unreachable" no longer justifies a recovery abort \u2014 complete the workflow, resolve the Git recovery state, or use the user-authorized force abort (/swarm abort-pr-workflow) to override.`);
-  }
   const sanitizedReason = typeof options.reason === "string" && options.reason.trim().length > 0 ? options.reason.trim().slice(0, 500) : undefined;
   if (sanitizedReason === undefined) {
     throw new Error(`BLOCKED: ${state.mode} abort requires a non-empty reason (recorded to the audit trail).`);
@@ -2383,47 +2524,45 @@ async function abortPrWorkflow(directory, sessionID, options = { kind: "recovery
     openLanes: openLanes.length
   };
 }
-async function bindPrWorkflowHead(directory, sessionID, prHeadSha) {
+async function bindPrWorkflowHeadWhileLocked(directory, normalizedSessionID, prHeadSha) {
   const normalizedHead = normalizePrHeadSha(prHeadSha);
-  return withPrWorkflowCheckoutMutationLock(directory, async () => withSessionStateMutation(directory, normalizeSessionID(sessionID), async () => {
-    const state = await readPrWorkflowGateStateFromDisk(directory, normalizeSessionID(sessionID));
-    if (!state) {
-      throw new Error(`BLOCKED: no active PR workflow gate for session "${normalizeSessionID(sessionID)}". ` + "The gate must be activated before the PR head can be bound.");
-    }
-    await assertCurrentCheckoutHead(directory, normalizedHead, state.mode);
-    if (state.prHeadSha && state.prHeadSha !== normalizedHead) {
-      throw new Error(`BLOCKED: active ${state.mode} workflow is bound to PR head "${state.prHeadSha}"; received "${normalizedHead}"`);
-    }
-    if (!state.prHeadSha) {
-      await assertPrReviewCleanCheckout(directory, state.mode);
-    }
-    if (!state.prHeadSha && state.mode === "PR_FEEDBACK") {
+  const state = await readPrWorkflowGateStateFromDisk(directory, normalizedSessionID);
+  if (!state) {
+    throw new Error(`BLOCKED: no active PR workflow gate for session "${normalizedSessionID}". ` + "The gate must be activated before the PR head can be bound.");
+  }
+  await assertCurrentCheckoutHead(directory, normalizedHead, state.mode);
+  if (state.prHeadSha && state.prHeadSha !== normalizedHead) {
+    throw new Error(`BLOCKED: active ${state.mode} workflow is bound to PR head "${state.prHeadSha}"; received "${normalizedHead}"`);
+  }
+  if (!state.prHeadSha) {
+    await assertPrReviewCleanCheckout(directory, state.mode);
+  }
+  if (!state.prHeadSha && state.mode === "PR_FEEDBACK") {
+    await assertPrFeedbackTrackingCheckout(directory, normalizedHead);
+  }
+  if (state.prHeadSha === normalizedHead) {
+    if (state.mode === "PR_FEEDBACK") {
       await assertPrFeedbackTrackingCheckout(directory, normalizedHead);
     }
-    if (state.prHeadSha === normalizedHead) {
-      if (state.mode === "PR_FEEDBACK") {
-        await assertPrFeedbackTrackingCheckout(directory, normalizedHead);
-      }
-      return state;
-    }
-    const nextState = {
-      ...state,
-      prHeadSha: normalizedHead,
-      checkoutRecovery: undefined,
-      updatedAt: isoNow()
-    };
-    await _test_exports.beforePrFeedbackTrackingPersist?.();
-    return writeStateWhileLocked(directory, nextState);
-  }));
+    return state;
+  }
+  const nextState = {
+    ...state,
+    prHeadSha: normalizedHead,
+    checkoutRecovery: undefined,
+    updatedAt: isoNow()
+  };
+  await _test_exports.beforePrFeedbackTrackingPersist?.();
+  return writeStateWhileLocked(directory, nextState);
 }
 async function assertCurrentCheckoutHead(directory, expectedHead, mode = "PR_REVIEW") {
   const normalizedExpected = normalizePrHeadSha(expectedHead);
   const currentHead = (await _test_exports.resolveCurrentGitHeadAsync(directory))?.trim();
   if (!currentHead) {
-    throw new Error(`BLOCKED: cannot resolve the current Git HEAD in "${directory}" to verify against PR head "${normalizedExpected}". ` + `This means Git could not resolve HEAD (the working directory may not be a Git repository, ` + `HEAD may be unborn, the commit object may be missing in a shallow clone, the Git binary may not be on PATH, ` + `or the bounded Git invocation may have timed out). ` + `Verify with: git -C "${directory}" rev-parse --verify HEAD^{commit}`);
+    throw new Error(`BLOCKED: cannot resolve the current Git HEAD in "${directory}" to verify against PR head "${normalizedExpected}". ` + `This means Git could not resolve HEAD (the working directory may not be a Git repository, ` + `HEAD may be unborn, the commit object may be missing in a shallow clone, the Git binary may not be on PATH, ` + `or the bounded Git invocation may have timed out). ` + `Verify with two separate standalone commands. First run: git -C "${directory}" rev-parse --verify HEAD^0. Then run: git -C "${directory}" cat-file -t HEAD (which must print commit).`);
   }
   if (currentHead.toLowerCase() !== normalizedExpected.toLowerCase()) {
-    const remediation = mode === "PR_FEEDBACK" ? "Check out the intended local tracking branch at that exact head (for example with a safe standalone `gh pr checkout <number-or-url>` or `git switch -c <local> --track <remote>/<branch>`), then retry the bind. Do not create a new detached feedback checkout." : `Run these bare, standalone commands from that directory: if the commit is not present locally, \`git fetch origin <pr-head-ref>\`; then \`git switch --detach ${normalizedExpected}\`. Do not prefix the switch with \`git -C\`; the read-only shell classifier refuses \`git -C ... switch\`.`;
+    const remediation = mode === "PR_FEEDBACK" ? "Check out the intended local tracking branch at that exact head (for example with a safe standalone `gh pr checkout <number-or-url>` or `git switch -c <local> --track <remote>/<branch>`), then retry the bind. Do not create a new detached feedback checkout." : `Run bare, standalone commands from that directory. If the commit is not present locally, first run \`git fetch origin <pr-head-ref>\`. Then run \`git switch --detach ${normalizedExpected}\`. Do not prefix the switch with \`git -C\`; the read-only shell classifier refuses \`git -C ... switch\`.`;
     throw new Error(`BLOCKED: current checkout HEAD "${currentHead}" does not match PR head "${normalizedExpected}" ` + `(working directory: "${directory}"). ${remediation}`);
   }
   return normalizedExpected;
@@ -2945,6 +3084,7 @@ var _test_exports = {
     _test_exports.openCheckoutLock = openCheckoutLockFile;
     _test_exports.removeCheckoutLock = removeCheckoutLockFile;
     _test_exports.checkoutMutationActionTimeoutMs = CHECKOUT_MUTATION_ACTION_TIMEOUT_MS;
+    _test_exports.classifyPrWorkflowGitStateAsync = classifyPrWorkflowGitState;
   },
   beforeTerminalClear: undefined,
   beforePrFeedbackTransitionLock: undefined,
@@ -2960,6 +3100,7 @@ var _test_exports = {
   openCheckoutLock: openCheckoutLockFile,
   removeCheckoutLock: removeCheckoutLockFile,
   checkoutMutationActionTimeoutMs: CHECKOUT_MUTATION_ACTION_TIMEOUT_MS,
+  classifyPrWorkflowGitStateAsync: classifyPrWorkflowGitState,
   resolveCurrentGitHead,
   resolveCurrentGitHeadAsync,
   resolveCurrentUpstreamPushTarget,
@@ -3072,8 +3213,128 @@ var PR_REVIEW_READ_ONLY_TOOL_NAMES = new Set([
   "webfetch",
   "websearch"
 ]);
+var PR_WORKFLOW_CD_PREFIX_PATTERN = /^cd\s+(?:\/d\s+)?(?:"[A-Za-z0-9 _.\\/:~+-]+"|'[A-Za-z0-9 _.\\/:~+-]+'|[A-Za-z0-9_.\\/:~+-]+)\s*&&\s*/i;
+var PR_WORKFLOW_TRAILING_STDERR_MERGE_PATTERN = /\s+2>&1\s*$/;
+var PR_WORKFLOW_MAX_CD_PREFIX_STRIPS = 3;
+function normalizePrWorkflowShellCommand(command) {
+  let normalized = command.trim();
+  const withoutTrailingMerge = normalized.replace(PR_WORKFLOW_TRAILING_STDERR_MERGE_PATTERN, "");
+  if (withoutTrailingMerge !== normalized)
+    normalized = withoutTrailingMerge.trim();
+  let strippedCdPrefix = false;
+  for (let index = 0;index < PR_WORKFLOW_MAX_CD_PREFIX_STRIPS; index += 1) {
+    const next = normalized.replace(PR_WORKFLOW_CD_PREFIX_PATTERN, "");
+    if (next === normalized)
+      break;
+    normalized = next.trim();
+    strippedCdPrefix = true;
+  }
+  return { normalized, strippedCdPrefix };
+}
+function classifyPrWorkflowShellSyntax(command) {
+  const { normalized: inner } = normalizePrWorkflowShellCommand(command);
+  const compact = inner.replace(/\s+/g, " ").trim();
+  if (!compact)
+    return { unsafe: true, reason: "compound-syntax" };
+  if (/\$\(|@\(/.test(inner)) {
+    return { unsafe: true, reason: "command-substitution" };
+  }
+  if (/\\"|\^"/.test(inner)) {
+    return { unsafe: true, reason: "ambiguous-escaped-quote" };
+  }
+  if (/[\r\n;&<>`]/.test(inner)) {
+    return { unsafe: true, reason: "compound-syntax" };
+  }
+  const tokens = [];
+  let current = "";
+  let quoted = false;
+  let quote = null;
+  let pipeIsDoubleQuoted = true;
+  const flush = () => {
+    if (current.length > 0 || quoted) {
+      tokens.push({ value: current, quoted, pipeIsDoubleQuoted });
+    }
+    current = "";
+    quoted = false;
+    quote = null;
+    pipeIsDoubleQuoted = true;
+  };
+  for (let index = 0;index < inner.length; index += 1) {
+    const ch = inner[index];
+    if (quote === null) {
+      if (/\s/.test(ch)) {
+        flush();
+        continue;
+      }
+      if (ch === "'" || ch === '"') {
+        quoted = true;
+        quote = ch;
+        continue;
+      }
+      if (ch === ";" || ch === "<" || ch === ">" || ch === "`" || ch === "|") {
+        return { unsafe: true, reason: "compound-syntax" };
+      }
+      if (ch === "$" && inner[index + 1] === "(") {
+        return { unsafe: true, reason: "command-substitution" };
+      }
+      if (ch === "@" && inner[index + 1] === "(") {
+        return { unsafe: true, reason: "command-substitution" };
+      }
+      current += ch;
+      continue;
+    }
+    if (quote === "'") {
+      if (ch === "'") {
+        quote = null;
+        continue;
+      }
+      if (ch === "|")
+        pipeIsDoubleQuoted = false;
+      current += ch;
+      continue;
+    }
+    if (ch === '"') {
+      quote = null;
+      continue;
+    }
+    if (ch === "\\" && inner[index + 1] === '"') {
+      return { unsafe: true, reason: "ambiguous-escaped-quote" };
+    }
+    if (ch === "`") {
+      return { unsafe: true, reason: "command-substitution" };
+    }
+    if (ch === "$" && inner[index + 1] === "(") {
+      return { unsafe: true, reason: "command-substitution" };
+    }
+    if (ch === "@" && inner[index + 1] === "(") {
+      return { unsafe: true, reason: "command-substitution" };
+    }
+    current += ch;
+  }
+  if (quote !== null) {
+    return { unsafe: true, reason: "unmatched-quote" };
+  }
+  flush();
+  const pipeTokens = tokens.filter((token) => token.value.includes("|"));
+  if (pipeTokens.length === 0)
+    return { unsafe: false, reason: null };
+  if (pipeTokens.length !== 1 || !pipeTokens[0].quoted || !pipeTokens[0].pipeIsDoubleQuoted) {
+    return { unsafe: true, reason: "gh-api-jq-pipe" };
+  }
+  const quotedPipeToken = pipeTokens[0];
+  if (!/^gh\s+api(?:\s|$)/i.test(compact)) {
+    return { unsafe: true, reason: "gh-api-jq-pipe" };
+  }
+  for (let index = 0;index < tokens.length; index += 1) {
+    const token = tokens[index];
+    if (token.value === "--jq" && tokens[index + 1] === quotedPipeToken) {
+      return { unsafe: false, reason: null };
+    }
+  }
+  return { unsafe: true, reason: "gh-api-jq-pipe" };
+}
 function hasUnsafeShellControlSyntax(command) {
-  return /[;&|<>`\r\n]/.test(command) || /\$\(/.test(command);
+  return classifyPrWorkflowShellSyntax(command).unsafe;
 }
 function isSafeStandaloneGitCommit(command) {
   if (hasUnsafeShellControlSyntax(command))
@@ -3850,7 +4111,8 @@ function analyzePrReviewDiscoveryArtifact(text, expectedWorkflowLane, ownedWorkf
   const issues = [];
   const normalized = normalizeCandidateArtifact(text, fallbackFamily);
   const canonicalText = normalized.text;
-  const salvaged = normalized.synthesizedHeader;
+  const repairKinds = normalized.repairKinds;
+  const salvaged = repairKinds.length > 0;
   const header = selectCandidateHeader(canonicalText.split(/\r?\n/));
   if (header === null || !header.markerBearing || header.family !== fallbackFamily) {
     appendBoundedCandidateIssue(issues, `field header: expected one exact canonical ${fallbackFamily} [CANDIDATE] header before discovery rows`);
@@ -3859,6 +4121,7 @@ function analyzePrReviewDiscoveryArtifact(text, expectedWorkflowLane, ownedWorkf
       evidence: null,
       issues,
       salvaged,
+      repairKinds,
       failurePredicate: "discovery.header"
     };
   }
@@ -3902,6 +4165,7 @@ function analyzePrReviewDiscoveryArtifact(text, expectedWorkflowLane, ownedWorkf
       evidence: null,
       issues,
       salvaged,
+      repairKinds,
       failurePredicate: "discovery.row"
     };
   }
@@ -3919,7 +4183,8 @@ function analyzePrReviewDiscoveryArtifact(text, expectedWorkflowLane, ownedWorkf
         matchingCandidate.confidence
       ].join("\x00"),
       issues,
-      salvaged
+      salvaged,
+      repairKinds
     };
   }
   const clean = parsed.clean_attestation;
@@ -3928,7 +4193,8 @@ function analyzePrReviewDiscoveryArtifact(text, expectedWorkflowLane, ownedWorkf
       covered: true,
       evidence: `${clean.coverage_scope}\x00${clean.evidence}`,
       issues,
-      salvaged
+      salvaged,
+      repairKinds
     };
   }
   return {
@@ -3936,6 +4202,7 @@ function analyzePrReviewDiscoveryArtifact(text, expectedWorkflowLane, ownedWorkf
     evidence: null,
     issues,
     salvaged,
+    repairKinds,
     failurePredicate: hasParseFailure ? "discovery.row" : "discovery.coverage"
   };
 }
@@ -3983,7 +4250,7 @@ function validatePrReviewDiscoveryLaneCompletion(input) {
     if (!analysis.salvaged && analysis.issues.length === 0)
       continue;
     salvagedLanes.push(workflowLane);
-    const reason = analysis.salvaged ? `canonical ${resolvePrReviewRowFamily(workflowLane, input.expected.mode)} header was absent and was synthesized from valid marker rows` : "one or more rows were dropped as malformed or out-of-ownership";
+    const reason = analysis.repairKinds.length > 0 ? `structural repairs applied: ${analysis.repairKinds.join(", ")}` : "one or more rows were dropped as malformed or out-of-ownership";
     warn(`[pr-workflow-gate] discovery artifact salvaged: batch=${input.record.batchId ?? "(missing)"} lane=${input.record.laneId ?? "(missing)"} workflow_lane=${workflowLane} \u2014 ${reason}; retained coverage from the valid rows. Dropped-row diagnostics: ${analysis.issues.join("; ") || "(none)"}`);
   }
   const failedCoverage = analyses.find(({ analysis }) => !analysis.covered);
@@ -4131,13 +4398,6 @@ function pipeFields(line) {
     return [];
   return line.split("|").map((field) => field.trim());
 }
-async function persistState(directory, state) {
-  const validated = PrWorkflowGateStateSchema.parse(state);
-  await withSessionStateMutation(directory, validated.sessionID, async () => {
-    const nextState = await writeStateWhileLocked(directory, validated);
-    Object.assign(state, nextState);
-  });
-}
 async function writeStateWhileLocked(directory, state, options = {}) {
   const validated = PrWorkflowGateStateSchema.parse(state);
   const current = await readPrWorkflowGateStateFromDisk(directory, validated.sessionID);
@@ -4537,6 +4797,9 @@ function isProcessAlive(pid) {
 }
 async function readPrWorkflowGateStateFromDisk(directory, sessionID) {
   const filePath = workflowGateStatePath(directory, sessionID);
+  return readPrWorkflowGateStateFileFromDisk(filePath, sessionID);
+}
+async function readPrWorkflowGateStateFileFromDisk(filePath, stateLabel) {
   let raw;
   try {
     raw = await fsp2.readFile(filePath, "utf-8");
@@ -4549,11 +4812,11 @@ async function readPrWorkflowGateStateFromDisk(directory, sessionID) {
   try {
     parsedJson = JSON.parse(raw);
   } catch {
-    throw new Error(`BLOCKED: PR workflow gate state for session "${sessionID}" is not valid JSON`);
+    throw new Error(`BLOCKED: PR workflow gate state for session "${stateLabel}" is not valid JSON`);
   }
   const parsed = PrWorkflowGateStateSchema.safeParse(parsedJson);
   if (!parsed.success) {
-    throw new Error(`BLOCKED: PR workflow gate state for session "${sessionID}" is invalid`);
+    throw new Error(`BLOCKED: PR workflow gate state for session "${stateLabel}" is invalid`);
   }
   return parsed.data;
 }
@@ -4724,9 +4987,9 @@ var USAGE = [
   "Usage: /swarm abort-pr-workflow [PR_REVIEW|PR_FEEDBACK] <reason...>",
   "",
   "Clear an active PR_REVIEW or PR_FEEDBACK mechanical gate for the current session",
-  "and stop the auto-resume loop. This is the human-only FORCE escape hatch: it may",
-  "clear a BOUND gate (one whose PR head was successfully checked out) without a",
-  "recovery condition, which the agent's own recovery abort is refused for. Use when",
+  "and stop the auto-resume loop. This is the human-only FORCE escape hatch, usable",
+  "even when the architect cannot call its audited recovery abort. Both paths may clear",
+  "a BOUND gate after lanes settle; the force path does not require agent cooperation. Use when",
   "a PR review or feedback workflow is unrecoverably stuck (e.g. the working tree",
   "cannot reach the PR head, a compound shell command was rejected, or the wake",
   "budget is suspended).",
@@ -4766,7 +5029,7 @@ ${USAGE}`;
       ...knownMode ? { expectedMode: knownMode } : {}
     });
     const headLine = summary.prHeadSha ? ` (was bound to PR head ${summary.prHeadSha})` : " (was not bound to a PR head)";
-    return `Aborted active ${summary.mode} mechanical gate for session ${sessionID}${headLine} (force). The durable gate state has been cleared and the auto-resume loop will stop. An audit event was appended to .swarm/events.jsonl.`;
+    return `Aborted active ${summary.mode} mechanical gate for session ${sessionID}${headLine} (force). The durable gate state has been cleared and the auto-resume loop will stop. An audit event was appended to .swarm/events.jsonl. If checkout preparation preserved changes, continue with prepare_pr_workflow_checkout operation=restore (or follow the preserved receipt manually).`;
   } catch (error2) {
     const message = error2 instanceof Error ? error2.message : String(error2);
     return `Error: ${message}
@@ -14569,8 +14832,8 @@ function dcValidateTargets(targets, cwd) {
     const lstatBlock = dcLstatAncestorWalk(filesystemTarget, cwd);
     if (lstatBlock)
       return lstatBlock;
-    const basename5 = path23.basename(filesystemTarget);
-    if (dcPathComponents(t).length === 1 && DC_SAFE_TARGETS.has(basename5)) {
+    const basename6 = path23.basename(filesystemTarget);
+    if (dcPathComponents(t).length === 1 && DC_SAFE_TARGETS.has(basename6)) {
       continue;
     }
     if (DC_FS_ROOTS.has(t) || DC_FS_ROOTS.has(t.replace(/\//g, "\\"))) {
@@ -14656,8 +14919,8 @@ function dcEvaluateRecursiveDeleteTargets(input) {
         reason: `BLOCKED: Recursive delete target "${safeTarget}" is not strictly contained by the workspace.`
       };
     }
-    const basename5 = path23.basename(resolved);
-    if (!DC_SAFE_TARGETS.has(basename5)) {
+    const basename6 = path23.basename(resolved);
+    if (!DC_SAFE_TARGETS.has(basename6)) {
       return {
         allowed: false,
         code: "DESTRUCTIVE_TARGET_NOT_SAFE_ARTIFACT",
@@ -22007,7 +22270,7 @@ function planMerges(active, threshold, maxComparisons, maxMerges) {
   };
 }
 async function sweepActiveNearDuplicates(directory, options = {}) {
-  const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-hgrzjhsf.js");
+  const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-vjqe1z2w.js");
   const { config } = loadPluginConfigWithMeta2(directory);
   const sweepConfig = config.learning?.dedup_sweep;
   if (sweepConfig?.enabled === false)
@@ -23091,7 +23354,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-a48t83hf.js");
+        const skillModule = await import("./skill-generator-bvph9d98.js");
         for (const cand of skillCandidates) {
           if (cand.confidence < (config.min_skill_confidence ?? DEFAULT_SKILL_MIN_CONFIDENCE)) {
             continue;
@@ -23551,7 +23814,7 @@ async function applyCuratorKnowledgeUpdates(directory, recommendations, knowledg
     } catch {}
   }
   if (contradictedEntries.length > 0 && knowledgeConfig.contradiction_threshold_action === "quarantine") {
-    const { maybeQuarantineOnContradiction } = await import("./knowledge-escalator-twwz5a0d.js");
+    const { maybeQuarantineOnContradiction } = await import("./knowledge-escalator-58tw74js.js");
     for (const { id } of contradictedEntries) {
       try {
         await maybeQuarantineOnContradiction(directory, id, knowledgeConfig.contradiction_quarantine_threshold, knowledgeConfig.contradiction_quarantine_window_days);
@@ -24370,7 +24633,7 @@ async function runCuratorPostMortem(directory, options = {}) {
       warnings.push("Failed to collect knowledge summary.");
     }
     try {
-      const { getScanStatus } = await import("./scan-cursor-acsjpv2n.js");
+      const { getScanStatus } = await import("./scan-cursor-7tqsvbp8.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.`);
@@ -24542,9 +24805,9 @@ var _internals28 = {
   verifyPostMortemKnowledgeActions,
   repairPostMortemActions,
   loadDefaultKnowledgeConfig: async (directory) => {
-    const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-4dy7emnw.js");
+    const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-b046zss2.js");
     try {
-      const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-hgrzjhsf.js");
+      const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-vjqe1z2w.js");
       const loaded = loadPluginConfigWithMeta2(directory);
       return KnowledgeConfigSchema2.parse(loaded.config.knowledge ?? {});
     } catch {
@@ -24552,11 +24815,11 @@ var _internals28 = {
     }
   },
   applyCuratorKnowledgeUpdates: async (directory, recommendations, knowledgeConfig, generation) => {
-    const { applyCuratorKnowledgeUpdates: applyCuratorKnowledgeUpdates2 } = await import("./curator-b7f6nt8h.js");
+    const { applyCuratorKnowledgeUpdates: applyCuratorKnowledgeUpdates2 } = await import("./curator-zp5qq24c.js");
     return applyCuratorKnowledgeUpdates2(directory, recommendations, knowledgeConfig, generation);
   },
   checkHivePromotions: async (entries, knowledgeConfig, directory) => {
-    const { checkHivePromotions } = await import("./hive-promoter-61sjdrgt.js");
+    const { checkHivePromotions } = await import("./hive-promoter-0yg3gxg6.js");
     return checkHivePromotions(entries, knowledgeConfig, directory);
   },
   applyProposalTriage: async (directory, triage) => {
@@ -24565,7 +24828,7 @@ var _internals28 = {
       activateProposal,
       listSkills: listSkills2,
       sanitizeSlug
-    } = await import("./skill-generator-a48t83hf.js");
+    } = await import("./skill-generator-bvph9d98.js");
     const result = {
       approved: [],
       rejected: [],
@@ -25790,9 +26053,9 @@ function hashContent(content) {
   return createHash9("sha1").update(content).digest("hex");
 }
 async function loadConfigForPolicyCurator(directory) {
-  const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-4dy7emnw.js");
+  const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-b046zss2.js");
   try {
-    const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-hgrzjhsf.js");
+    const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-vjqe1z2w.js");
     const { config: loadedConfig } = loadPluginConfigWithMeta2(directory);
     return KnowledgeConfigSchema2.parse(loadedConfig.knowledge ?? {});
   } catch {
@@ -29801,7 +30064,7 @@ async function runFinalizeStage(ctx) {
     }
   }
   try {
-    const { CuratorConfigSchema: CCS } = await import("./schema-4dy7emnw.js");
+    const { CuratorConfigSchema: CCS } = await import("./schema-b046zss2.js");
     const { config: pmLoadedConfig } = _internals39.loadPluginConfigWithMeta(ctx.directory);
     const curatorCfg = CCS.parse(pmLoadedConfig.curator ?? {});
     if (curatorCfg.enabled && curatorCfg.postmortem_enabled) {
@@ -32074,9 +32337,9 @@ var _internals44 = {
   loadPluginConfigWithMeta,
   loadCuratorDeps: async () => {
     const [{ CuratorConfigSchema }, curator, { createCuratorLLMDelegate: createCuratorLLMDelegate2 }] = await Promise.all([
-      import("./schema-4dy7emnw.js"),
-      import("./curator-b7f6nt8h.js"),
-      import("./curator-llm-factory-0mkbw2hg.js")
+      import("./schema-b046zss2.js"),
+      import("./curator-zp5qq24c.js"),
+      import("./curator-llm-factory-pr4bdfqw.js")
     ]);
     return { CuratorConfigSchema, curator, createCuratorLLMDelegate: createCuratorLLMDelegate2 };
   }
@@ -32981,7 +33244,7 @@ async function computeCurationDiagnostics(directory, entries) {
   let scanCompleted = false;
   let scanRemaining = 0;
   try {
-    const { getScanStatus } = await import("./scan-cursor-acsjpv2n.js");
+    const { getScanStatus } = await import("./scan-cursor-7tqsvbp8.js");
     const status = await getScanStatus(directory);
     scanGeneration = status.generation;
     scanCompleted = status.completed;
@@ -32991,17 +33254,17 @@ async function computeCurationDiagnostics(directory, entries) {
   try {
     const { isLinked: isLinked2 } = await import("./knowledge-link-q46k9adx.js");
     if (isLinked2(directory)) {
-      const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-4dy7emnw.js");
+      const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-b046zss2.js");
       let config;
       try {
-        const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-hgrzjhsf.js");
+        const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-vjqe1z2w.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-bn7g8n40.js");
+      const { buildConfigFingerprintInput: buildConfigFingerprintInput2, readCohortConfigFingerprint } = await import("./curation-policy-7n6t8he4.js");
       const currentFp = cohortConfigFingerprint2(buildConfigFingerprintInput2(config));
       const cohortFp = await readCohortConfigFingerprint(directory);
       configMatch = cohortFp === null ? null : currentFp === cohortFp;
@@ -34212,7 +34475,7 @@ async function handleDoctorCommand(directory, args) {
   const result = runConfigDoctor(config, directory);
   let output;
   if (enableAutoFix && result.hasAutoFixableIssues) {
-    const { runConfigDoctorWithFixes } = await import("./config-doctor-0b5z13vq.js");
+    const { runConfigDoctorWithFixes } = await import("./config-doctor-shc0n4q1.js");
     const fixResult = await runConfigDoctorWithFixes(directory, config, true, {
       applyLossy: true
     });
@@ -36366,7 +36629,7 @@ function countCodeLines(content) {
   return lines.length;
 }
 function isTestFile(filePath) {
-  const basename11 = path61.basename(filePath);
+  const basename12 = path61.basename(filePath);
   const _ext = path61.extname(filePath).toLowerCase();
   const testPatterns = [
     ".test.",
@@ -36382,7 +36645,7 @@ function isTestFile(filePath) {
     ".spec.jsx"
   ];
   for (const pattern of testPatterns) {
-    if (basename11.includes(pattern)) {
+    if (basename12.includes(pattern)) {
       return true;
     }
   }
@@ -45860,8 +46123,8 @@ function toSafeRelativePath(rootDir, targetPath) {
   if (!relative11 || relative11 === ".")
     return ".";
   if (relative11.startsWith("..") || path78.isAbsolute(relative11)) {
-    const basename16 = path78.basename(targetPath).replace(/\\/g, "/");
-    return basename16 || ".";
+    const basename17 = path78.basename(targetPath).replace(/\\/g, "/");
+    return basename17 || ".";
   }
   return relative11;
 }
@@ -47717,21 +47980,21 @@ function hasCompoundTestExtension(filename) {
   const lower = filename.toLowerCase();
   return COMPOUND_TEST_EXTENSIONS.some((ext) => lower.endsWith(ext));
 }
-function isLanguageSpecificTestFile(basename17) {
-  const lower = basename17.toLowerCase();
+function isLanguageSpecificTestFile(basename18) {
+  const lower = basename18.toLowerCase();
   if (lower.endsWith("_test.go"))
     return true;
   if (lower.endsWith(".py") && (lower.startsWith("test_") || lower.endsWith("_test.py")))
     return true;
   if (lower.endsWith("_spec.rb"))
     return true;
-  if (lower.endsWith(".java") && (/^Test[A-Z]/.test(basename17) || basename17.endsWith("Test.java") || basename17.endsWith("Tests.java") || lower.endsWith("it.java")))
+  if (lower.endsWith(".java") && (/^Test[A-Z]/.test(basename18) || basename18.endsWith("Test.java") || basename18.endsWith("Tests.java") || lower.endsWith("it.java")))
     return true;
   if (lower.endsWith(".cs") && (lower.endsWith("test.cs") || lower.endsWith("tests.cs")))
     return true;
-  if (lower.endsWith(".kt") && (/^Test[A-Z]/.test(basename17) || lower.endsWith("test.kt") || lower.endsWith("tests.kt")))
+  if (lower.endsWith(".kt") && (/^Test[A-Z]/.test(basename18) || lower.endsWith("test.kt") || lower.endsWith("tests.kt")))
     return true;
-  if (lower.endsWith(".php") && (/^Test[A-Z]/.test(basename17) || basename17.endsWith("Test.php") || basename17.endsWith("Tests.php")))
+  if (lower.endsWith(".php") && (/^Test[A-Z]/.test(basename18) || basename18.endsWith("Test.php") || basename18.endsWith("Tests.php")))
     return true;
   if (lower.endsWith(".tests.ps1"))
     return true;
@@ -47739,23 +48002,23 @@ function isLanguageSpecificTestFile(basename17) {
 }
 function isConventionTestFilePath(filePath) {
   const normalizedPath = filePath.replace(/\\/g, "/");
-  const basename17 = path82.basename(filePath);
-  return hasCompoundTestExtension(basename17) || basename17.includes(".spec.") || basename17.includes(".test.") || isLanguageSpecificTestFile(basename17) || isTestDirectoryPath(normalizedPath);
+  const basename18 = path82.basename(filePath);
+  return hasCompoundTestExtension(basename18) || basename18.includes(".spec.") || basename18.includes(".test.") || isLanguageSpecificTestFile(basename18) || isTestDirectoryPath(normalizedPath);
 }
 function getTestFilesFromConvention(sourceFiles, workingDir = process.cwd()) {
   const testFiles = [];
   for (const file of sourceFiles) {
     const absoluteFile = resolveWorkspacePath(file, workingDir);
     const relativeFile = path82.relative(workingDir, absoluteFile);
-    const basename17 = path82.basename(absoluteFile);
+    const basename18 = path82.basename(absoluteFile);
     const dirname30 = path82.dirname(absoluteFile);
     const preferRelativeOutput = !path82.isAbsolute(file);
     if (isConventionTestFilePath(relativeFile) || isConventionTestFilePath(file)) {
       dedupePush(testFiles, toWorkspaceOutputPath(absoluteFile, workingDir, preferRelativeOutput));
       continue;
     }
-    const nameWithoutExt = basename17.replace(/\.[^.]+$/, "");
-    const ext = path82.extname(basename17);
+    const nameWithoutExt = basename18.replace(/\.[^.]+$/, "");
+    const ext = path82.extname(basename18);
     const genericTestNames = [
       `${nameWithoutExt}.spec${ext}`,
       `${nameWithoutExt}.test${ext}`
@@ -47766,7 +48029,7 @@ function getTestFilesFromConvention(sourceFiles, workingDir = process.cwd()) {
       ...languageSpecificTestNames
     ].map((candidateName) => path82.join(dirname30, candidateName));
     const testDirectoryNames = [
-      basename17,
+      basename18,
       ...genericTestNames,
       ...languageSpecificTestNames
     ];
@@ -57551,7 +57814,7 @@ function buildDetailedHelp(commandName, entry) {
 async function handleHelpCommand(ctx) {
   const targetCommand = ctx.args.join(" ");
   if (!targetCommand) {
-    const { buildHelpText } = await import("./index-ff7b0cr5.js");
+    const { buildHelpText } = await import("./index-4rje8dc0.js");
     return buildHelpText();
   }
   const tokens = targetCommand.split(/\s+/);
@@ -57560,7 +57823,7 @@ async function handleHelpCommand(ctx) {
     return _internals18.buildDetailedHelp(resolved.key, resolved.entry);
   }
   const similar = _internals18.findSimilarCommands(targetCommand);
-  const { buildHelpText: fullHelp } = await import("./index-ff7b0cr5.js");
+  const { buildHelpText: fullHelp } = await import("./index-4rje8dc0.js");
   if (similar.length > 0) {
     return `Command '/swarm ${targetCommand}' not found.
 
@@ -57737,7 +58000,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail explain": {
     handler: async (ctx) => {
-      const { handleGuardrailExplain } = await import("./guardrail-explain-p2htdqkz.js");
+      const { handleGuardrailExplain } = await import("./guardrail-explain-thddj6jv.js");
       return handleGuardrailExplain(ctx.directory, ctx.args);
     },
     description: "Dry-run: show what the guardrails would do to a command or write target (executes nothing)",
@@ -57747,7 +58010,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail-explain": {
     handler: async (ctx) => {
-      const { handleGuardrailExplain } = await import("./guardrail-explain-p2htdqkz.js");
+      const { handleGuardrailExplain } = await import("./guardrail-explain-thddj6jv.js");
       return handleGuardrailExplain(ctx.directory, ctx.args);
     },
     description: "Dry-run: show what the guardrails would do to a command or write target (executes nothing)",
@@ -57757,7 +58020,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail-log": {
     handler: async (ctx) => {
-      const { handleGuardrailLog } = await import("./guardrail-log-rqt9wrzw.js");
+      const { handleGuardrailLog } = await import("./guardrail-log-w8fmxe1x.js");
       return handleGuardrailLog(ctx.directory, ctx.args);
     },
     description: "Read the guardrail decision log (use --blocks-only for blocks)",
@@ -58203,7 +58466,7 @@ Subcommands:
     handler: (ctx) => handleAbortPrWorkflowCommand(ctx.directory, ctx.args, ctx.sessionID),
     description: "Clear a stuck PR_REVIEW/PR_FEEDBACK mechanical gate and stop the auto-resume loop [mode] [reason]",
     args: "[PR_REVIEW|PR_FEEDBACK] [reason...]",
-    details: "Human-only escape hatch for an unrecoverable PR_REVIEW or PR_FEEDBACK mechanical gate. When the architect cannot reach complete_pr_workflow \u2014 for example a compound `git fetch && git checkout` was rejected as read-only shell syntax, the PR head cannot be fetched, or the working tree is on the wrong branch \u2014 running this clears the durable gate state for the current session and stops the auto-resume loop without depending on the trapped model. The agent itself cannot run this command; it must call the abort_pr_workflow tool (or ask you to run this command). Both paths funnel into the same fail-closed abortPrWorkflow hook, which refuses while the workflow is armed for publication or while PR workflow lanes are still in flight. An audit event is appended to .swarm/events.jsonl.",
+    details: "Human-only escape hatch for an unrecoverable PR_REVIEW or PR_FEEDBACK mechanical gate. When the architect cannot reach complete_pr_workflow \u2014 for example a compound `git fetch && git checkout` was rejected as read-only shell syntax, the PR head cannot be fetched, or the working tree is on the wrong branch \u2014 running this clears the durable gate state for the current session and stops the auto-resume loop without depending on the trapped model. The agent itself cannot run this command; it must call the abort_pr_workflow tool (or ask you to run this command). Both paths funnel into the same fail-closed abortPrWorkflow hook, which refuses while the workflow is armed for publication or while PR workflow lanes are still in flight. When checkout preparation preserved a stash, the result instructs the caller to run prepare_pr_workflow_checkout operation=restore after the clear. An audit event is appended to .swarm/events.jsonl.",
     category: "utility",
     toolPolicy: "restricted"
   },
@@ -59646,15 +59909,15 @@ HARD CONSTRAINTS (apply regardless of skill load success):
 - 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.
-- 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 \`git cat-file -e <full_pr_head_sha>^{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.
+- 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 always launches exactly six repository-agnostic base check-type lanes from the skill. Use \`mode: "swarm-pr-review:base"\` and the exact six \`workflow_lane\` identifiers. The runtime rejects partial, duplicate, or mislabelled waves. Do not collapse, omit, or scale down the base lanes for a small, docs-only, or CI-only PR.
-- RETRY STRUCTURALLY: retry only failed base obligations in later \`swarm-pr-review:base\` async batches with the same exact \`pr_head_sha\`. Blocking \`dispatch_lanes\` and direct Task explorer/reviewer/critic dispatch are not provenance-equivalent and are rejected.
+- RETRY STRUCTURALLY: retry only failed base obligations in later \`swarm-pr-review:base\` async batches with the same exact \`pr_head_sha\`. Blocking \`dispatch_lanes\` and direct Task explorer/reviewer/critic dispatch are not provenance-equivalent and are rejected. After the second failed retry, 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 and exhausted retries, then call \`prepare_pr_workflow_checkout\` with \`operation: "restore"\` before reporting the blocker.
 - USE ASYNC DISPATCH WITHOUT IDLING: launch the base lanes with one \`dispatch_lanes_async\` call when available, record the \`batch_id\`, then keep doing non-dependent architect work while they run. Poll with \`collect_lane_results\` without \`wait\` (or \`wait: false\`) to process settled lanes and continue independent work between polls; use \`wait: true\` only as the final join when no independent work remains.
 - 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.
-- ABORT IF UNRECOVERABLE: if the PR head cannot be fetched/checked out (the working tree stays on the wrong branch), a compound \`git fetch && git checkout\` keeps being rejected as read-only shell syntax (run them as TWO separate standalone commands first), or the merge-base bind is unreachable for any reason, call \`abort_pr_workflow\` with \`mode: "PR_REVIEW"\`, \`kind: "recovery"\`, and a one-line \`reason\` instead of looping. The tool refuses while PR workflow lanes are in flight (collect their results first) AND refuses a recovery abort of a bound review (pr_head_sha set) unless a controller-recorded terminal recovery condition (checkoutRecovery) exists \u2014 binding succeeded, so "checkout unreachable" no longer justifies recovery. Aborting clears the durable gate and stops the auto-resume loop; the user can force-clear a bound gate via \`/swarm abort-pr-workflow\`. Do NOT abort as a shortcut to avoid coverage obligations \u2014 only when the bind/checkout path is genuinely unreachable.
+- 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.
+- 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.
 
 ### MODE: PR_FEEDBACK
@@ -59682,7 +59945,7 @@ HARD CONSTRAINTS (apply regardless of skill load success):
 - DO NOT PUBLISH EARLY: commits, pushes, PR comments/updates, review-thread mutations, and other remote writes remain blocked until every ordered feedback gate settles positively on the same revision digest.
 - After every local gate passes, create the reviewed commit with one standalone \`git commit\`, then call \`complete_pr_workflow\` once. It requires a clean index/worktree and a non-merge direct child whose sole parent is the immutable intake head before binding that post-commit HEAD and arming publication. Push only with \`git push <bound-remote> <bound-commit>:refs/heads/<bound-branch>\`; the literal bound commit and exact bound branch are required, and force flags, wrappers, aliases, fetch-based local-ref forgery, extra refspecs, \`git -C\`, and other remote writes fail closed. Perform read-only remote checks, then call \`complete_pr_workflow\` a second time with the same immutable verification \`pr_head_sha\`; the second call clears only after both the actual remote ref and its local tracking ref resolve to the exact bound commit. Only then perform any explicitly authorized PR comment/body/thread writes.
 - Patch only confirmed items plus the tests/docs they require; report closure status for every ledger item including disproved ones.
-- ABORT IF UNRECOVERABLE (pre-armed only): if the PR head cannot be fetched/checked out or the verification bind is unreachable for any reason, call \`abort_pr_workflow\` with \`mode: "PR_FEEDBACK"\`, \`kind: "recovery"\`, and a one-line \`reason\` instead of looping (the same bound-recovery refusal applies: a recovery abort of a bound gate requires a checkoutRecovery terminal condition). The tool refuses while PR workflow lanes are in flight (collect their results first) AND refuses once \`prFeedbackReadyToPublish\` is armed \u2014 after arming, you MUST complete the workflow with \`complete_pr_workflow\` (or push the bound commit first); aborting an armed gate would drop the immutable-commit binding and leave a half-published commit. Do NOT abort as a shortcut to skip the mechanical gates \u2014 only when the bind/verification path is genuinely unreachable.
+- ABORT IF UNRECOVERABLE (pre-armed only): if the PR head cannot be fetched/checked out, the verification bind is unreachable, or bounded recovery is exhausted, call \`abort_pr_workflow\` with \`mode: "PR_FEEDBACK"\`, \`kind: "recovery"\`, and a one-line \`reason\` instead of looping. The tool accepts unbound and bound workflows, refuses while PR workflow lanes are in flight (collect their results first), and refuses once \`prFeedbackReadyToPublish\` is armed \u2014 after arming, you MUST complete the workflow with \`complete_pr_workflow\` (or push the bound commit first); aborting an armed gate would drop the immutable-commit binding and leave a half-published commit. Do NOT abort while useful bounded recovery work remains.
 - Do NOT resolve or mark GitHub review threads resolved unless the user explicitly instructs it.
 - Honor any free-text instructions that follow the closing bracket of the signal as additional scope, without dropping any ledger item.
 - Quality is the only metric \u2014 there is no speed, efficiency, or time exception; time, tokens, and agent dispatches are irrelevant to correctness