opencode-swarm 7.137.0 → 7.137.2

package/dist/cli/{index-92v63zzr.js → index-d735dzm7.js}

@@ -8,20 +8,21 @@ import {
 } from "./index-vm4xw9z3.js";
 import {
   captureWorkingTreeFingerprint,
+  createModelEvaluationExecutor,
   pLimit,
   resolveExecutableFromPath,
   runEvaluation,
   runExternalTool
-} from "./index-k3mezk96.js";
+} from "./index-b2s3t517.js";
 import {
   stableCanonicalStringify
-} from "./index-j6ewv2pe.js";
+} from "./index-aygnzd04.js";
 import {
   detectStraySwarmDirs,
   readDoctorArtifact,
   removeStraySwarmDir,
   runConfigDoctor
-} from "./index-91kk2e9j.js";
+} from "./index-rfrkt29c.js";
 import {
   MAX_TRANSIENT_RETRIES,
   archiveEvidence,
@@ -113,15 +114,15 @@ import {
   retireSkill,
   selectCandidateEntries,
   syncBundledProjectSkillsIfMissingAsync
-} from "./index-f24r6yqk.js";
+} from "./index-pwx989sa.js";
 import {
   readRecentEscalations
-} from "./index-d00q9kpq.js";
+} from "./index-02jqxmh8.js";
 import {
   alreadyCuratedThisGeneration,
   claimNextScanBatch,
   resolveCohortId
-} from "./index-wg98bsxz.js";
+} from "./index-kakb2jm0.js";
 import {
   CURATOR_INIT_PROMPT,
   CURATOR_PHASE_PROMPT,
@@ -174,11 +175,11 @@ import {
   validateActionableFields,
   validateLesson,
   validateSkillPath
-} from "./index-p124rnwb.js";
+} from "./index-jdqayy7h.js";
 import {
   authorizeCuration,
   buildConfigFingerprintInput
-} from "./index-mg26zd8x.js";
+} from "./index-s9at02fn.js";
 import {
   cohortConfigFingerprint
 } from "./index-rtry5xyf.js";
@@ -211,7 +212,7 @@ import {
   transactFile,
   transactKnowledge,
   wordBigrams
-} from "./index-fgkhpdc6.js";
+} from "./index-9casmxdt.js";
 import {
   MAX_EVENT_LOG_ENTRIES,
   _internals,
@@ -221,7 +222,7 @@ import {
   recordHiveKnowledgeEvent,
   recordKnowledgeEvent,
   resolveKnowledgeEventsPath
-} from "./index-72wzb81c.js";
+} from "./index-4t39wzzg.js";
 import {
   resolveHiveDataDir,
   resolveHiveEventsPath,
@@ -246,7 +247,7 @@ import {
   init_loader,
   loadPluginConfig,
   loadPluginConfigWithMeta
-} from "./index-pcwjz5de.js";
+} from "./index-1da1tvtn.js";
 import {
   RetrospectiveEvidenceSchema
 } from "./index-k5jrywpr.js";
@@ -262,7 +263,7 @@ import {
   package_default,
   resolveAutoReviewConfig,
   stripKnownSwarmPrefix
-} from "./index-mwdzkr6k.js";
+} from "./index-vyh2prxv.js";
 import {
   KNOWLEDGE_SCHEMA_VERSION,
   OUTCOME_BLOCK_THRESHOLD,
@@ -410,8 +411,28 @@ var CANDIDATE_FIELDS = {
     "confidence"
   ]
 };
+var CANDIDATE_MARKER = "[CANDIDATE]";
+var CLEAN_MARKER = "[CLEAN]";
+function formatCandidateHeader(family) {
+  return [
+    CANDIDATE_MARKER,
+    ...CANDIDATE_FIELDS[family].map((name) => name === "file_line" ? "file:line" : name)
+  ].join(" | ");
+}
+function formatCleanTemplate(family) {
+  const laneField = family === "base_explorer" ? "lane" : "micro_lane";
+  return [CLEAN_MARKER, laneField, "coverage_scope", "evidence"].join(" | ");
+}
+var CANDIDATE_HEADERS = {
+  base_explorer: formatCandidateHeader("base_explorer"),
+  micro_lane: formatCandidateHeader("micro_lane")
+};
+var CLEAN_TEMPLATES = {
+  base_explorer: formatCleanTemplate("base_explorer"),
+  micro_lane: formatCleanTemplate("micro_lane")
+};
 function candidateHeaderFamily(fields) {
-  if (fields[0]?.trim() !== "[CANDIDATE]")
+  if (fields[0]?.trim() !== CANDIDATE_MARKER)
     return null;
   const normalized = fields.slice(1).map((field) => field.trim());
   for (const family of ["base_explorer", "micro_lane"]) {
@@ -1943,6 +1964,7 @@ var CHECKOUT_MUTATION_ACTION_TIMEOUT_MS = 5 * 60000;
 var MAX_CANDIDATE_ISSUES_PER_ARTIFACT = 8;
 var MAX_BASE_COVERAGE_DIAGNOSTICS = 8;
 var MAX_BASE_COVERAGE_DIAGNOSTIC_CHARS = 1000;
+var MAX_LANE_VALIDATION_VALUE_CHARS = 240;
 var WORKFLOW_GATE_DIR = "pr-workflow-gates";
 var trackedStatesByProjectSession = new Map;
 var pendingStateMutationsByProjectSession = new Map;
@@ -2434,7 +2456,7 @@ async function assertPrReviewBaseCoverageSettled(directory, sessionID, gateConte
   }
   const missing = PR_REVIEW_BASE_DIMENSION_IDS.filter((dimension) => !covered.has(dimension));
   if (missing.length > 0 || covered.size !== PR_REVIEW_BASE_DIMENSION_IDS.length) {
-    throw new Error(`BLOCKED: PR_REVIEW base coverage is incomplete; missing dimensions: ${missing.join(", ") || "(none)"}${malformedDiagnostics.length > 0 ? `; malformed candidate diagnostics: ${malformedDiagnostics.join(" | ")}` : ""}`);
+    throw new Error(`BLOCKED: PR_REVIEW base coverage is incomplete; missing dimensions: ${missing.join(", ") || "(none)"}${malformedDiagnostics.length > 0 ? `; first failed lane predicates: ${malformedDiagnostics.join(" | ")}` : ""}; valid dimensions: ${PR_REVIEW_BASE_DIMENSION_IDS.join(", ")}; expected candidate row: ${CANDIDATE_HEADERS.base_explorer}; expected clean row: ${CLEAN_TEMPLATES.base_explorer}`);
   }
   return state;
 }
@@ -2787,6 +2809,7 @@ async function transitionPrReviewToFeedback(directory, sessionID, request) {
 }
 var _test_exports = {
   minimumConsolidatedLaneCover,
+  analyzePrReviewBatchRecordIntegrity,
   MAX_COVER_UNIVERSE_BITS,
   workflowGateStateRelativePath,
   workflowGateStateLockRelativePath,
@@ -3356,47 +3379,169 @@ function derivePrReviewCriticInventoryForCoverageGate(directory, state, ctx, ori
   }
   return derivePrReviewCriticInventory(directory, state, ctx);
 }
-function recordsPassingBatchIntegrity(directory, state, batchId, expectedLanes, expectedMode, validatedAt, checkWorkflowLane = true, forbiddenSubagentSessionIds = new Set) {
-  const qualified = [];
-  const validatedAtMs = Date.parse(validatedAt);
-  if (!Number.isFinite(validatedAtMs))
-    return qualified;
-  const expectedByLaneId = new Map(expectedLanes.map((lane) => [lane.laneId, lane]));
-  if (expectedByLaneId.size !== expectedLanes.length)
-    return qualified;
-  const records = findByBatchId(directory, batchId, {
-    parentSessionId: state.sessionID
-  });
-  const recordCountByLaneId = new Map;
-  const recordCountBySubagentSessionId = new Map;
-  for (const record of records) {
-    if (!record.laneId || !expectedByLaneId.has(record.laneId))
-      continue;
-    recordCountByLaneId.set(record.laneId, (recordCountByLaneId.get(record.laneId) ?? 0) + 1);
-    const subagentSessionId = record.subagentSessionId?.trim();
-    if (subagentSessionId) {
-      recordCountBySubagentSessionId.set(subagentSessionId, (recordCountBySubagentSessionId.get(subagentSessionId) ?? 0) + 1);
+function boundedLaneValidationValue(value) {
+  let rendered;
+  try {
+    rendered = typeof value === "string" ? value : JSON.stringify(value);
+  } catch {
+    rendered = String(value);
+  }
+  const sanitized = [...rendered ?? String(value)].map((character) => {
+    const code = character.charCodeAt(0);
+    return code <= 31 || code === 127 ? " " : character;
+  }).join("").trim();
+  return sanitized.length <= MAX_LANE_VALIDATION_VALUE_CHARS ? sanitized : `${sanitized.slice(0, MAX_LANE_VALIDATION_VALUE_CHARS - 1)}\u2026`;
+}
+function failedLaneValidation(predicate, expected, actual) {
+  return {
+    ok: false,
+    failure: {
+      predicate,
+      expected: boundedLaneValidationValue(expected),
+      actual: boundedLaneValidationValue(actual)
     }
+  };
+}
+function formatPrReviewLaneValidationFailure(failure) {
+  return `predicate=${failure.predicate} expected=${JSON.stringify(failure.expected)} actual=${JSON.stringify(failure.actual)}`.slice(0, MAX_BASE_COVERAGE_DIAGNOSTIC_CHARS);
+}
+function analyzeLaneRecordResultIntegrity(args) {
+  const { record, result, expected } = args;
+  if (expected.checkWorkflowLane && record.workflowLane !== expected.workflowLane) {
+    return failedLaneValidation("record.workflow_lane", expected.workflowLane, record.workflowLane ?? "(missing)");
   }
-  for (const record of records) {
-    const expectedLane = record.laneId ? expectedByLaneId.get(record.laneId) : undefined;
-    const expectedWorkflowLane = expectedLane?.workflowLane;
-    const expectedOwnedLanes = expectedLane?.ownedWorkflowLanes?.length ? expectedLane.ownedWorkflowLanes : expectedWorkflowLane !== undefined ? [expectedWorkflowLane] : undefined;
+  if (expected.checkWorkflowLane && !ownedLaneSetsEqual(record.ownedWorkflowLanes, expected.ownedWorkflowLanes)) {
+    return failedLaneValidation("record.owned_workflow_lanes", expected.ownedWorkflowLanes, record.ownedWorkflowLanes ?? (record.workflowLane ? [record.workflowLane] : []));
+  }
+  if (record.mode !== expected.mode) {
+    return failedLaneValidation("record.mode", expected.mode, record.mode ?? "(missing)");
+  }
+  if (record.workspace?.prHeadSha !== expected.prHeadSha) {
+    return failedLaneValidation("record.pr_head_sha", expected.prHeadSha, record.workspace?.prHeadSha ?? "(missing)");
+  }
+  if (record.workspace?.gitHead !== expected.gitHead) {
+    return failedLaneValidation("record.git_head", expected.gitHead, record.workspace?.gitHead ?? "(missing)");
+  }
+  if (args.requireCompleted && record.status !== "completed") {
+    return failedLaneValidation("record.status", "completed", record.status);
+  }
+  if (result?.outputDegraded === true) {
+    return failedLaneValidation("result.output_degraded", "not true", true);
+  }
+  if (result?.transcriptIncomplete === true) {
+    return failedLaneValidation("result.transcript_incomplete", "not true", true);
+  }
+  if (result?.truncated === true) {
+    return failedLaneValidation("result.truncated", "not true", true);
+  }
+  if ((result?.chars ?? 0) <= 0) {
+    return failedLaneValidation("result.chars", "greater than 0", result?.chars ?? 0);
+  }
+  if (!result?.digest?.trim()) {
+    return failedLaneValidation("result.digest", "non-empty digest", result?.digest ?? "(missing)");
+  }
+  if (!result?.outputRef?.trim()) {
+    return failedLaneValidation("result.output_ref", "non-empty output ref", result?.outputRef ?? "(missing)");
+  }
+  return { ok: true };
+}
+function analyzePrReviewBatchRecordIntegrity(args) {
+  const validatedAtMs = Date.parse(args.validatedAt);
+  const expectedByLaneId = new Map(args.expectedLanes.map((lane) => [lane.laneId, lane]));
+  const batchFailure = !Number.isFinite(validatedAtMs) ? failedLaneValidation("batch.validated_at", "valid ISO timestamp", args.validatedAt) : expectedByLaneId.size !== args.expectedLanes.length ? failedLaneValidation("batch.expected_lane_unique", "unique expected lane ids", args.expectedLanes.map((lane) => lane.laneId)) : null;
+  const relevantRecords = args.records.filter((record) => record.laneId && expectedByLaneId.has(record.laneId));
+  const recordsByLaneId = new Map;
+  const recordCountBySubagentSessionId = new Map;
+  for (const record of relevantRecords) {
+    const laneRecords = recordsByLaneId.get(record.laneId) ?? [];
+    laneRecords.push(record);
+    recordsByLaneId.set(record.laneId, laneRecords);
+    const sessionId = record.subagentSessionId?.trim();
+    if (sessionId) {
+      recordCountBySubagentSessionId.set(sessionId, (recordCountBySubagentSessionId.get(sessionId) ?? 0) + 1);
+    }
+  }
+  return args.expectedLanes.map((expectedLane) => {
+    const expectedWorkflowLane = expectedLane.workflowLane;
+    const expectedOwnedLanes = expectedLane.ownedWorkflowLanes?.length ? expectedLane.ownedWorkflowLanes : [expectedWorkflowLane];
+    const failed = (failure) => ({
+      ok: false,
+      expectedLane,
+      expectedWorkflowLane,
+      expectedOwnedLanes,
+      failure
+    });
+    if (batchFailure && !batchFailure.ok)
+      return failed(batchFailure.failure);
+    const laneRecords = recordsByLaneId.get(expectedLane.laneId) ?? [];
+    if (laneRecords.length === 0) {
+      return failed(failedLaneValidation("record.missing", "exactly one record", 0).failure);
+    }
+    if (laneRecords.length !== 1) {
+      return failed(failedLaneValidation("record.duplicate_lane", "exactly one record", laneRecords.length).failure);
+    }
+    const record = laneRecords[0];
     const subagentSessionId = record.subagentSessionId?.trim();
-    if (expectedLane !== undefined && expectedWorkflowLane !== undefined && expectedOwnedLanes !== undefined && record.laneId !== undefined && recordCountByLaneId.get(record.laneId) === 1 && Boolean(subagentSessionId) && recordCountBySubagentSessionId.get(subagentSessionId) === 1 && !forbiddenSubagentSessionIds.has(subagentSessionId) && record.createdAt >= validatedAtMs && (!checkWorkflowLane || record.workflowLane === expectedWorkflowLane) && (!checkWorkflowLane || ownedLaneSetsEqual(record.ownedWorkflowLanes, expectedOwnedLanes)) && record.mode === expectedMode && record.workspace?.prHeadSha === state.prHeadSha && record.workspace?.gitHead === state.prHeadSha && record.status === "completed" && record.result?.outputDegraded !== true && record.result?.transcriptIncomplete !== true && record.result?.truncated !== true && (record.result?.chars ?? 0) > 0 && Boolean(record.result?.digest?.trim()) && Boolean(record.result?.outputRef?.trim())) {
-      qualified.push({
-        record,
-        expectedLane,
-        expectedWorkflowLane,
-        expectedOwnedLanes
-      });
+    if (!subagentSessionId) {
+      return failed(failedLaneValidation("record.subagent_session_id", "non-empty child session id", record.subagentSessionId ?? "(missing)").failure);
+    }
+    if (recordCountBySubagentSessionId.get(subagentSessionId) !== 1) {
+      return failed(failedLaneValidation("record.duplicate_subagent_session_id", "one record per child session", recordCountBySubagentSessionId.get(subagentSessionId)).failure);
+    }
+    if (args.forbiddenSubagentSessionIds.has(subagentSessionId)) {
+      return failed(failedLaneValidation("record.forbidden_subagent_session_id", "child session not reused from a forbidden phase", subagentSessionId).failure);
+    }
+    if (record.createdAt < validatedAtMs) {
+      return failed(failedLaneValidation("record.created_at", `at or after ${args.validatedAt}`, new Date(record.createdAt).toISOString()).failure);
+    }
+    const recordIntegrity = analyzeLaneRecordResultIntegrity({
+      record,
+      result: record.result,
+      expected: {
+        mode: args.expectedMode,
+        workflowLane: expectedWorkflowLane,
+        ownedWorkflowLanes: expectedOwnedLanes,
+        prHeadSha: args.expectedPrHeadSha ?? record.workspace?.prHeadSha ?? "",
+        gitHead: args.expectedPrHeadSha ?? record.workspace?.gitHead ?? "",
+        checkWorkflowLane: args.checkWorkflowLane
+      },
+      requireCompleted: true
+    });
+    if (!recordIntegrity.ok)
+      return failed(recordIntegrity.failure);
+    return {
+      ok: true,
+      record,
+      expectedLane,
+      expectedWorkflowLane,
+      expectedOwnedLanes
+    };
+  });
+}
+function recordsPassingBatchIntegrity(directory, state, batchId, expectedLanes, expectedMode, validatedAt, checkWorkflowLane = true, forbiddenSubagentSessionIds = new Set, diagnostics) {
+  const records = findByBatchId(directory, batchId, {
+    parentSessionId: state.sessionID
+  });
+  const analyses = analyzePrReviewBatchRecordIntegrity({
+    batchId,
+    expectedLanes,
+    expectedMode,
+    validatedAt,
+    checkWorkflowLane,
+    forbiddenSubagentSessionIds,
+    records,
+    expectedPrHeadSha: state.prHeadSha
+  });
+  for (const analysis of analyses) {
+    if (!analysis.ok && diagnostics && diagnostics.length < MAX_BASE_COVERAGE_DIAGNOSTICS) {
+      diagnostics.push(`batch=${batchId} lane=${analysis.expectedLane.laneId} workflow_lane=${analysis.expectedWorkflowLane}: ${formatPrReviewLaneValidationFailure(analysis.failure)}`.slice(0, MAX_BASE_COVERAGE_DIAGNOSTIC_CHARS));
     }
   }
-  return qualified;
+  return analyses.filter((analysis) => analysis.ok);
 }
 function successfulObligationsFromExactBatch(directory, state, batchId, expectedLanes, expectedMode, validatedAt, checkWorkflowLane = true, forbiddenSubagentSessionIds = new Set, expectedRevisionDigest, diagnostics, reviewerClaims) {
   const successful = new Set;
-  for (const qualified of recordsPassingBatchIntegrity(directory, state, batchId, expectedLanes, expectedMode, validatedAt, checkWorkflowLane, forbiddenSubagentSessionIds)) {
+  for (const qualified of recordsPassingBatchIntegrity(directory, state, batchId, expectedLanes, expectedMode, validatedAt, checkWorkflowLane, forbiddenSubagentSessionIds, diagnostics)) {
     if (workflowArtifactHasContractMarker(directory, state, qualified.record, expectedMode, qualified.expectedWorkflowLane, qualified.expectedLane.reviewItemIds, expectedRevisionDigest, qualified.expectedOwnedLanes, diagnostics, reviewerClaims)) {
       for (const obligation of qualified.expectedOwnedLanes) {
         successful.add(obligation);
@@ -3416,25 +3561,98 @@ function ownedLaneSetsEqual(recordOwned, expectedOwned) {
   }
   return recordOwned.every((owned) => expectedSet.has(owned));
 }
-function loadArtifactPassingLaneIntegrity(directory, state, record, expectedMode, expectedWorkflowLane, expectedRevisionDigest) {
+function analyzeLaneArtifactIntegrity(args) {
+  const { record, result, artifact, expected } = args;
+  if (!artifact) {
+    return failedLaneValidation("artifact.readable", "readable stored artifact", "missing or invalid");
+  }
+  if (artifact.ref !== result.outputRef?.trim()) {
+    return failedLaneValidation("artifact.ref", result.outputRef?.trim() ?? "(missing)", artifact.ref);
+  }
+  if (artifact.batchId !== record.batchId) {
+    return failedLaneValidation("artifact.batch_id", record.batchId ?? "(missing)", artifact.batchId);
+  }
+  if (artifact.laneId !== record.laneId) {
+    return failedLaneValidation("artifact.lane_id", record.laneId ?? "(missing)", artifact.laneId);
+  }
+  if (artifact.mode !== expected.mode) {
+    return failedLaneValidation("artifact.mode", expected.mode, artifact.mode ?? "(missing)");
+  }
+  if (artifact.sessionId !== record.subagentSessionId) {
+    return failedLaneValidation("artifact.session_id", record.subagentSessionId, artifact.sessionId ?? "(missing)");
+  }
+  if (artifact.parentSessionId !== record.parentSessionId) {
+    return failedLaneValidation("artifact.parent_session_id", record.parentSessionId, artifact.parentSessionId ?? "(missing)");
+  }
+  if (artifact.agent !== record.swarmPrefixedAgent) {
+    return failedLaneValidation("artifact.agent", record.swarmPrefixedAgent, artifact.agent);
+  }
+  if (artifact.role !== record.normalizedAgent) {
+    return failedLaneValidation("artifact.role", record.normalizedAgent, artifact.role);
+  }
+  if (artifact.source !== "collect_lane_results") {
+    return failedLaneValidation("artifact.source", "collect_lane_results", artifact.source);
+  }
+  if (artifact.workflowLane !== record.workflowLane) {
+    return failedLaneValidation("artifact.workflow_lane_record", record.workflowLane ?? "(missing)", artifact.workflowLane ?? "(missing)");
+  }
+  if (artifact.workflowLane !== expected.workflowLane) {
+    return failedLaneValidation("artifact.workflow_lane_expected", expected.workflowLane, artifact.workflowLane ?? "(missing)");
+  }
+  if (artifact.prHeadSha !== expected.prHeadSha) {
+    return failedLaneValidation("artifact.pr_head_sha", expected.prHeadSha, artifact.prHeadSha ?? "(missing)");
+  }
+  if (artifact.gitHead !== expected.gitHead) {
+    return failedLaneValidation("artifact.git_head", expected.gitHead, artifact.gitHead ?? "(missing)");
+  }
+  if (artifact.revisionDigest !== expected.revisionDigest) {
+    return failedLaneValidation("artifact.revision_digest", expected.revisionDigest, artifact.revisionDigest ?? "(missing)");
+  }
+  if (expected.reviewScope !== undefined && record.workspace?.scope !== expected.reviewScope) {
+    return failedLaneValidation("record.scope", expected.reviewScope, record.workspace?.scope ?? "(missing)");
+  }
+  if (expected.reviewScope !== undefined && artifact.scope !== expected.reviewScope) {
+    return failedLaneValidation("artifact.scope", expected.reviewScope, artifact.scope ?? "(missing)");
+  }
+  if (artifact.digest !== result.digest) {
+    return failedLaneValidation("artifact.digest", result.digest, artifact.digest);
+  }
+  if (artifact.chars !== result.chars) {
+    return failedLaneValidation("artifact.chars", result.chars, artifact.chars);
+  }
+  return { ok: true };
+}
+function loadArtifactPassingLaneIntegrity(directory, state, record, expectedMode, expectedWorkflowLane, expectedRevisionDigest, diagnostics) {
   const ref = record.result?.outputRef?.trim();
   if (!ref)
     return null;
   const loaded = readLaneOutput(directory, ref);
-  if (!loaded)
-    return null;
-  const artifact = loaded.artifact;
-  const recordPrHeadSha = record.workspace?.prHeadSha;
-  const recordGitHead = record.workspace?.gitHead;
+  const artifact = loaded?.artifact ?? null;
   const expectedReviewScope = state.mode === "PR_REVIEW" && state.prReviewBaseSha && state.prHeadSha ? `complete PR diff ${state.prReviewBaseSha}...${state.prHeadSha}` : undefined;
-  if (artifact.batchId !== record.batchId || artifact.laneId !== record.laneId || artifact.mode !== expectedMode || artifact.sessionId !== record.subagentSessionId || artifact.parentSessionId !== record.parentSessionId || artifact.agent !== record.swarmPrefixedAgent || artifact.role !== record.normalizedAgent || artifact.source !== "collect_lane_results" || artifact.workflowLane !== record.workflowLane || artifact.workflowLane !== expectedWorkflowLane || !recordPrHeadSha || artifact.prHeadSha !== recordPrHeadSha || !recordGitHead || artifact.gitHead !== recordGitHead || !expectedRevisionDigest || artifact.revisionDigest !== expectedRevisionDigest || expectedReviewScope !== undefined && (record.workspace?.scope !== expectedReviewScope || artifact.scope !== expectedReviewScope) || artifact.digest !== record.result?.digest || artifact.chars !== record.result?.chars) {
+  const integrity = analyzeLaneArtifactIntegrity({
+    record,
+    result: record.result,
+    artifact,
+    expected: {
+      mode: expectedMode,
+      workflowLane: expectedWorkflowLane,
+      prHeadSha: record.workspace?.prHeadSha ?? "",
+      gitHead: record.workspace?.gitHead ?? "",
+      revisionDigest: expectedRevisionDigest,
+      reviewScope: expectedReviewScope
+    }
+  });
+  if (!integrity.ok) {
+    if (diagnostics && diagnostics.length < MAX_BASE_COVERAGE_DIAGNOSTICS) {
+      diagnostics.push(`batch=${record.batchId ?? "(missing)"} lane=${record.laneId ?? "(missing)"} workflow_lane=${expectedWorkflowLane} output_ref=${ref}: ${formatPrReviewLaneValidationFailure(integrity.failure)}`.slice(0, MAX_BASE_COVERAGE_DIAGNOSTIC_CHARS));
+    }
     return null;
   }
   return artifact;
 }
 function workflowArtifactHasContractMarker(directory, state, record, expectedMode, expectedWorkflowLane, reviewItemIds, expectedRevisionDigest, ownedWorkflowLanes, diagnostics, reviewerClaims) {
   const ref = record.result?.outputRef?.trim();
-  const artifact = expectedRevisionDigest ? loadArtifactPassingLaneIntegrity(directory, state, record, expectedMode, expectedWorkflowLane, expectedRevisionDigest) : null;
+  const artifact = expectedRevisionDigest ? loadArtifactPassingLaneIntegrity(directory, state, record, expectedMode, expectedWorkflowLane, expectedRevisionDigest, diagnostics) : null;
   if (!artifact)
     return false;
   if (expectedMode === "swarm-pr-review:reviewer" || expectedMode === "swarm-pr-review:critic") {
@@ -3454,6 +3672,30 @@ function workflowArtifactHasContractMarker(directory, state, record, expectedMod
   if (feedbackVerdict) {
     return Boolean(reviewItemIds?.length && reviewItemIds.every((itemId) => artifactHasExactPositiveVerdictRow(artifact.text, feedbackVerdict[0], itemId, feedbackVerdict[1])));
   }
+  if (expectedMode === "swarm-pr-review:base" || expectedMode === "swarm-pr-review:micro") {
+    const reviewScope = state.mode === "PR_REVIEW" && state.prReviewBaseSha && state.prHeadSha ? `complete PR diff ${state.prReviewBaseSha}...${state.prHeadSha}` : undefined;
+    const validation = validatePrReviewDiscoveryLaneCompletion({
+      record,
+      result: record.result,
+      artifact,
+      expected: {
+        mode: expectedMode,
+        workflowLane: expectedWorkflowLane,
+        ownedWorkflowLanes,
+        prHeadSha: state.prHeadSha ?? "",
+        gitHead: state.prHeadSha ?? "",
+        revisionDigest: expectedRevisionDigest ?? "",
+        reviewScope
+      }
+    });
+    if (!validation.ok) {
+      if (diagnostics && diagnostics.length < MAX_BASE_COVERAGE_DIAGNOSTICS) {
+        diagnostics.push(`batch=${record.batchId ?? "(missing)"} lane=${record.laneId ?? "(missing)"} workflow_lane=${expectedWorkflowLane} output_ref=${ref}: ${formatPrReviewLaneValidationFailure(validation.failure)}`.slice(0, MAX_BASE_COVERAGE_DIAGNOSTIC_CHARS));
+      }
+      return false;
+    }
+    return true;
+  }
   const coveredLanes = ownedWorkflowLanes?.length ? ownedWorkflowLanes : [expectedWorkflowLane];
   const coverageAnalyses = coveredLanes.map((coveredLane) => ({
     coveredLane,
@@ -3491,7 +3733,12 @@ function analyzePrReviewDiscoveryArtifact(text, expectedWorkflowLane, ownedWorkf
   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`);
-    return { covered: false, evidence: null, issues };
+    return {
+      covered: false,
+      evidence: null,
+      issues,
+      failurePredicate: "discovery.header"
+    };
   }
   const parsed = parseCandidates({
     output_ref: "pr-workflow:discovery-artifact",
@@ -3525,7 +3772,12 @@ function analyzePrReviewDiscoveryArtifact(text, expectedWorkflowLane, ownedWorkf
     appendBoundedCandidateIssue(issues, `row ${detail.row_index + 1} field ${detail.field}: ${detail.message}`);
   }
   if (parsed.error || parsed.diagnostics.parse_error_details.length > 0) {
-    return { covered: false, evidence: null, issues };
+    return {
+      covered: false,
+      evidence: null,
+      issues,
+      failurePredicate: "discovery.row"
+    };
   }
   const matchingCandidate = parsed.candidates.find((candidate) => (candidate.lane ?? candidate.micro_lane) === expectedWorkflowLane);
   if (matchingCandidate) {
@@ -3551,7 +3803,67 @@ function analyzePrReviewDiscoveryArtifact(text, expectedWorkflowLane, ownedWorkf
       issues
     };
   }
-  return { covered: false, evidence: null, issues };
+  return {
+    covered: false,
+    evidence: null,
+    issues,
+    failurePredicate: "discovery.coverage"
+  };
+}
+function validatePrReviewDiscoveryLaneCompletion(input) {
+  const ownedWorkflowLanes = input.expected.ownedWorkflowLanes?.length ? [...input.expected.ownedWorkflowLanes] : [input.expected.workflowLane];
+  const recordIntegrity = analyzeLaneRecordResultIntegrity({
+    record: input.record,
+    result: input.result,
+    expected: {
+      mode: input.expected.mode,
+      workflowLane: input.expected.workflowLane,
+      ownedWorkflowLanes,
+      prHeadSha: input.expected.prHeadSha,
+      gitHead: input.expected.gitHead,
+      checkWorkflowLane: input.expected.checkWorkflowLane ?? true
+    },
+    requireCompleted: false
+  });
+  if (!recordIntegrity.ok)
+    return recordIntegrity;
+  const artifactIntegrity = analyzeLaneArtifactIntegrity({
+    record: input.record,
+    result: input.result,
+    artifact: input.artifact,
+    expected: {
+      mode: input.expected.mode,
+      workflowLane: input.expected.workflowLane,
+      prHeadSha: input.expected.prHeadSha,
+      gitHead: input.expected.gitHead,
+      revisionDigest: input.expected.revisionDigest,
+      reviewScope: input.expected.reviewScope
+    }
+  });
+  if (!artifactIntegrity.ok)
+    return artifactIntegrity;
+  const artifact = input.artifact;
+  const analyses = ownedWorkflowLanes.map((workflowLane) => ({
+    workflowLane,
+    analysis: analyzePrReviewDiscoveryArtifact(artifact.text, workflowLane, ownedWorkflowLanes)
+  }));
+  const failedCoverage = analyses.find(({ analysis }) => !analysis.covered);
+  if (failedCoverage) {
+    return failedLaneValidation(failedCoverage.analysis.failurePredicate ?? "discovery.coverage", `one valid ${input.expected.mode === "swarm-pr-review:base" ? "base_explorer" : "micro_lane"} [CANDIDATE] row or [CLEAN] attestation for ${failedCoverage.workflowLane}`, failedCoverage.analysis.issues.join("; ") || "no matching lane row");
+  }
+  if (ownedWorkflowLanes.length > 1) {
+    const seenEvidence = new Map;
+    for (const { workflowLane, analysis } of analyses) {
+      if (analysis.evidence === null)
+        continue;
+      const priorLane = seenEvidence.get(analysis.evidence);
+      if (priorLane) {
+        return failedLaneValidation("discovery.duplicate_evidence", "distinct evidence for every owned workflow lane", `${priorLane} and ${workflowLane} share evidence`);
+      }
+      seenEvidence.set(analysis.evidence, workflowLane);
+    }
+  }
+  return { ok: true };
 }
 function prReviewDiscoveryArtifactCoversLane(text, expectedWorkflowLane, ownedWorkflowLanes = [expectedWorkflowLane]) {
   return analyzePrReviewDiscoveryArtifact(text, expectedWorkflowLane, ownedWorkflowLanes).covered;
@@ -18157,7 +18469,7 @@ function planMerges(active, threshold, maxComparisons, maxMerges) {
   };
 }
 async function sweepActiveNearDuplicates(directory, options = {}) {
-  const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-aze9n64z.js");
+  const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-5k0csd2m.js");
   const { config } = loadPluginConfigWithMeta2(directory);
   const sweepConfig = config.learning?.dedup_sweep;
   if (sweepConfig?.enabled === false)
@@ -19750,7 +20062,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-a07hpmw6.js");
+        const skillModule = await import("./skill-generator-0q1jk6xd.js");
         for (const cand of skillCandidates) {
           if (cand.confidence < (config.min_skill_confidence ?? DEFAULT_SKILL_MIN_CONFIDENCE)) {
             continue;
@@ -20210,7 +20522,7 @@ async function applyCuratorKnowledgeUpdates(directory, recommendations, knowledg
     } catch {}
   }
   if (contradictedEntries.length > 0 && knowledgeConfig.contradiction_threshold_action === "quarantine") {
-    const { maybeQuarantineOnContradiction } = await import("./knowledge-escalator-9k0kbx6b.js");
+    const { maybeQuarantineOnContradiction } = await import("./knowledge-escalator-e9zk371p.js");
     for (const { id } of contradictedEntries) {
       try {
         await maybeQuarantineOnContradiction(directory, id, knowledgeConfig.contradiction_quarantine_threshold, knowledgeConfig.contradiction_quarantine_window_days);
@@ -21029,7 +21341,7 @@ async function runCuratorPostMortem(directory, options = {}) {
       warnings.push("Failed to collect knowledge summary.");
     }
     try {
-      const { getScanStatus } = await import("./scan-cursor-t212v00f.js");
+      const { getScanStatus } = await import("./scan-cursor-z4xpes5f.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.`);
@@ -21201,9 +21513,9 @@ var _internals24 = {
   verifyPostMortemKnowledgeActions,
   repairPostMortemActions,
   loadDefaultKnowledgeConfig: async (directory) => {
-    const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-11gyrec3.js");
+    const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-2dkw18zz.js");
     try {
-      const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-aze9n64z.js");
+      const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-5k0csd2m.js");
       const loaded = loadPluginConfigWithMeta2(directory);
       return KnowledgeConfigSchema2.parse(loaded.config.knowledge ?? {});
     } catch {
@@ -21211,11 +21523,11 @@ var _internals24 = {
     }
   },
   applyCuratorKnowledgeUpdates: async (directory, recommendations, knowledgeConfig, generation) => {
-    const { applyCuratorKnowledgeUpdates: applyCuratorKnowledgeUpdates2 } = await import("./curator-43xqs75k.js");
+    const { applyCuratorKnowledgeUpdates: applyCuratorKnowledgeUpdates2 } = await import("./curator-h1ea9skz.js");
     return applyCuratorKnowledgeUpdates2(directory, recommendations, knowledgeConfig, generation);
   },
   checkHivePromotions: async (entries, knowledgeConfig, directory) => {
-    const { checkHivePromotions } = await import("./hive-promoter-jt9ky0hn.js");
+    const { checkHivePromotions } = await import("./hive-promoter-qsymj94z.js");
     return checkHivePromotions(entries, knowledgeConfig, directory);
   },
   applyProposalTriage: async (directory, triage) => {
@@ -21224,7 +21536,7 @@ var _internals24 = {
       activateProposal,
       listSkills: listSkills2,
       sanitizeSlug
-    } = await import("./skill-generator-a07hpmw6.js");
+    } = await import("./skill-generator-0q1jk6xd.js");
     const result = {
       approved: [],
       rejected: [],
@@ -23851,9 +24163,9 @@ function hashContent(content) {
   return createHash9("sha1").update(content).digest("hex");
 }
 async function loadConfigForPolicyCurator(directory) {
-  const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-11gyrec3.js");
+  const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-2dkw18zz.js");
   try {
-    const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-aze9n64z.js");
+    const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-5k0csd2m.js");
     const { config: loadedConfig } = loadPluginConfigWithMeta2(directory);
     return KnowledgeConfigSchema2.parse(loadedConfig.knowledge ?? {});
   } catch {
@@ -26930,6 +27242,7 @@ var KNOWLEDGE_FAMILY_ARTIFACTS = new Set([
   "knowledge-rejected.jsonl"
 ]);
 var ACTIVE_STATE_DIRS_TO_CLEAN = [
+  "council",
   "evidence",
   "session",
   "scopes",
@@ -27198,7 +27511,7 @@ async function runFinalizeStage(ctx) {
     }
   }
   try {
-    const { CuratorConfigSchema: CCS } = await import("./schema-11gyrec3.js");
+    const { CuratorConfigSchema: CCS } = await import("./schema-2dkw18zz.js");
     const { config: pmLoadedConfig } = _internals34.loadPluginConfigWithMeta(ctx.directory);
     const curatorCfg = CCS.parse(pmLoadedConfig.curator ?? {});
     if (curatorCfg.enabled && curatorCfg.postmortem_enabled) {
@@ -29428,9 +29741,9 @@ var _internals39 = {
   loadPluginConfigWithMeta,
   loadCuratorDeps: async () => {
     const [{ CuratorConfigSchema }, curator, { createCuratorLLMDelegate: createCuratorLLMDelegate2 }] = await Promise.all([
-      import("./schema-11gyrec3.js"),
-      import("./curator-43xqs75k.js"),
-      import("./curator-llm-factory-8nywfdsh.js")
+      import("./schema-2dkw18zz.js"),
+      import("./curator-h1ea9skz.js"),
+      import("./curator-llm-factory-rk7pccwc.js")
     ]);
     return { CuratorConfigSchema, curator, createCuratorLLMDelegate: createCuratorLLMDelegate2 };
   }
@@ -30335,7 +30648,7 @@ async function computeCurationDiagnostics(directory, entries) {
   let scanCompleted = false;
   let scanRemaining = 0;
   try {
-    const { getScanStatus } = await import("./scan-cursor-t212v00f.js");
+    const { getScanStatus } = await import("./scan-cursor-z4xpes5f.js");
     const status = await getScanStatus(directory);
     scanGeneration = status.generation;
     scanCompleted = status.completed;
@@ -30345,17 +30658,17 @@ async function computeCurationDiagnostics(directory, entries) {
   try {
     const { isLinked: isLinked2 } = await import("./knowledge-link-t94b79qe.js");
     if (isLinked2(directory)) {
-      const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-11gyrec3.js");
+      const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-2dkw18zz.js");
       let config;
       try {
-        const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-aze9n64z.js");
+        const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-5k0csd2m.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-8tvs4pa0.js");
+      const { buildConfigFingerprintInput: buildConfigFingerprintInput2, readCohortConfigFingerprint } = await import("./curation-policy-xyradeax.js");
       const currentFp = cohortConfigFingerprint2(buildConfigFingerprintInput2(config));
       const cohortFp = await readCohortConfigFingerprint(directory);
       configMatch = cohortFp === null ? null : currentFp === cohortFp;
@@ -31566,7 +31879,7 @@ async function handleDoctorCommand(directory, args) {
   const result = runConfigDoctor(config, directory);
   let output;
   if (enableAutoFix && result.hasAutoFixableIssues) {
-    const { runConfigDoctorWithFixes } = await import("./config-doctor-vyx82nx2.js");
+    const { runConfigDoctorWithFixes } = await import("./config-doctor-xrbzq4r0.js");
     const fixResult = await runConfigDoctorWithFixes(directory, config, true, {
       applyLossy: true
     });
@@ -36407,13 +36720,14 @@ function errorCell(args) {
 function parseModelVerdict(text) {
   return ModelVerdictSchema.parse(JSON.parse(text.trim()));
 }
-function modelPrompt(task, instruction, variant) {
+function modelPrompt(task, instruction, variant, fixtureDir) {
   return [
     "You are executing a read-only production gate audit against a curated defect fixture.",
     `Defect id: ${task.id}`,
     `Category: ${task.category}`,
     variant === "defect" ? instruction : "This is a reviewed clean control. Report caught=false unless you find a concrete defect in the supplied implementation.",
-    "Inspect the files in the current isolated directory. Do not modify them.",
+    `Inspect ONLY the files under: ${fixtureDir}`,
+    "Do not modify them and do not inspect files outside that directory.",
     "Return exactly one JSON object and no markdown:",
     '{"v":1,"caught":true|false,"reason":"concise evidence"}'
   ].join(`
@@ -36691,11 +37005,11 @@ async function runCell(args) {
         });
       }
       const dispatch = await args.options.dispatcher({
-        directory: tempRoot,
+        sessionDirectory: args.options.projectRoot,
         agentName: args.gate === "reviewer" ? "reviewer" : "test_engineer",
         modelId: args.model,
         preferredSwarm: args.options.manifest.preferredSwarm,
-        prompt: modelPrompt(args.task, instruction, args.variant),
+        prompt: modelPrompt(args.task, instruction, args.variant, tempRoot),
         timeoutMs: Math.min(args.options.manifest.maxTimeMs, 120000),
         parentSessionId: args.options.parentSessionId,
         abortSignal: args.signal
@@ -51400,7 +51714,7 @@ Ensure this is a git repository with commit history.`;
 // src/commands/skill-opt.ts
 init_schema();
 import { copyFileSync as copyFileSync5, existsSync as existsSync57, mkdirSync as mkdirSync31, readFileSync as readFileSync43 } from "fs";
-import * as path99 from "path";
+import * as path100 from "path";
 
 // src/services/skill-optimizer/activation.ts
 import {
@@ -51860,7 +52174,117 @@ async function rollbackCandidate(input) {
 // src/services/skill-optimizer/controller.ts
 import { randomUUID as randomUUID11 } from "crypto";
 import { existsSync as existsSync55, mkdirSync as mkdirSync29, readFileSync as readFileSync42, writeFileSync as writeFileSync19 } from "fs";
-import * as path97 from "path";
+import * as path98 from "path";
+
+// src/evaluation/pr-review-recovery.ts
+import * as fs48 from "fs/promises";
+import * as path96 from "path";
+var PR_REVIEW_RECOVERY_BASE_SHA = "3811fe5981072c7fa541523e9f08430f18594590";
+var FIXTURE_ROOT = "evaluation-fixtures/pr-review-recovery";
+var BASELINE_MANIFEST_PATH = `${FIXTURE_ROOT}/baseline-manifest.json`;
+var BASELINE_PAYLOAD_PATH = `${FIXTURE_ROOT}/baseline/SKILL.md`;
+var CANDIDATE_PAYLOAD_PATH = ".opencode/skills/swarm-pr-review/SKILL.md";
+var INSTRUCTION_PATH = `${FIXTURE_ROOT}/instruction.md`;
+var ENVIRONMENT_PATH = `${FIXTURE_ROOT}/environment`;
+var SCORER_PATH = `${ENVIRONMENT_PATH}/score-recovery.cjs`;
+function parseBaselineManifest(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value) || Object.keys(value).sort().join("\x00") !== ["v", "sourceSha", "payloadPath", "sha256"].sort().join("\x00")) {
+    throw new Error("PR-review recovery baseline manifest is invalid");
+  }
+  const manifest = value;
+  if (manifest.v !== 1 || typeof manifest.sourceSha !== "string" || typeof manifest.payloadPath !== "string" || typeof manifest.sha256 !== "string") {
+    throw new Error("PR-review recovery baseline manifest is invalid");
+  }
+  return manifest;
+}
+async function candidate(packageRoot, input) {
+  return {
+    ...input,
+    contentHash: await computeCandidateInputContentHash(packageRoot, input)
+  };
+}
+async function task(packageRoot) {
+  const input = {
+    v: 1,
+    id: "pr-review-controller-recovery",
+    source: "curated",
+    split: "train",
+    category: "pr-review-recovery",
+    protected: true,
+    instructionPath: INSTRUCTION_PATH,
+    environment: { kind: "fixture", path: ENVIRONMENT_PATH },
+    scorer: {
+      kind: "project",
+      argv: [SCORER_PATH],
+      timeoutMs: 30000,
+      scoreRange: [0, 1]
+    },
+    provenance: {
+      origin: "https://github.com/ZaxbyHub/opencode-swarm/issues/2075",
+      license: "MIT"
+    }
+  };
+  return {
+    ...input,
+    contentHash: await computeTaskInputContentHash(packageRoot, input)
+  };
+}
+async function verifyBaseline(packageRoot, requestedSourceSha) {
+  if (requestedSourceSha !== PR_REVIEW_RECOVERY_BASE_SHA) {
+    throw new Error(`PR-review recovery baseline source SHA must be ${PR_REVIEW_RECOVERY_BASE_SHA}`);
+  }
+  const manifest = parseBaselineManifest(JSON.parse(await fs48.readFile(path96.join(packageRoot, BASELINE_MANIFEST_PATH), "utf8")));
+  if (manifest.sourceSha !== PR_REVIEW_RECOVERY_BASE_SHA || manifest.payloadPath !== BASELINE_PAYLOAD_PATH) {
+    throw new Error("PR-review recovery baseline source SHA is invalid");
+  }
+  const payload = await fs48.readFile(path96.join(packageRoot, manifest.payloadPath));
+  if (sha256(payload) !== manifest.sha256) {
+    throw new Error("PR-review recovery baseline payload hash is invalid");
+  }
+}
+async function evaluatePrReviewRecoveryV1(options) {
+  const packageRoot = path96.resolve(options.packageRoot ?? options.projectRoot);
+  await verifyBaseline(packageRoot, options.baselineSourceSha ?? PR_REVIEW_RECOVERY_BASE_SHA);
+  const model = options.model ?? "configured";
+  const baseline = await candidate(packageRoot, {
+    v: 1,
+    id: "pr-review-recovery-baseline",
+    kind: "baseline",
+    payloadPath: BASELINE_PAYLOAD_PATH,
+    model,
+    agent: "reviewer"
+  });
+  const current = await candidate(packageRoot, {
+    v: 1,
+    id: "pr-review-recovery-candidate",
+    kind: "skill",
+    payloadPath: CANDIDATE_PAYLOAD_PATH,
+    model,
+    agent: "reviewer"
+  });
+  const budgets = {
+    maxTasks: 1,
+    maxRepetitions: 1,
+    maxConcurrency: 1,
+    maxTaskTimeMs: 60000,
+    maxRetries: 0,
+    maxOutputBytes: 32 * 1024,
+    ...options.budgets
+  };
+  return runEvaluation({
+    projectRoot: options.projectRoot,
+    inputRoot: packageRoot,
+    tasks: [await task(packageRoot)],
+    baseline,
+    candidate: current,
+    split: "train",
+    seed: options.seed ?? "pr-review-recovery-v1",
+    models: [model],
+    budgets,
+    executor: createModelEvaluationExecutor(options.dispatcher, options.parentSessionId),
+    abortSignal: options.abortSignal
+  });
+}
 
 // src/evaluation/statistics.ts
 function normalize8(result) {
@@ -51881,16 +52305,16 @@ function collectPairs(candidateResults, referenceResults) {
     const referenceResult = references.get(resultKey(candidateResult));
     if (!referenceResult)
       continue;
-    const candidate = normalize8(candidateResult);
+    const candidate2 = normalize8(candidateResult);
     const reference = normalize8(referenceResult);
-    if (candidate === undefined || reference === undefined)
+    if (candidate2 === undefined || reference === undefined)
       continue;
     pairs.push({
       key: resultKey(candidateResult),
       category: candidateResult.category,
       protected: candidateResult.protected || referenceResult.protected,
       reference,
-      candidate,
+      candidate: candidate2,
       referenceResult,
       candidateResult
     });
@@ -52074,6 +52498,7 @@ async function evaluateCandidateV1(options) {
 }
 var evaluationV1 = Object.freeze(Object.assign((options) => evaluateCandidateV1(options), {
   evaluateCandidate: evaluateCandidateV1,
+  evaluatePrReviewRecovery: evaluatePrReviewRecoveryV1,
   runEvaluation,
   decidePromotion: (input) => decidePromotion(input),
   hashTaskInput: computeTaskInputContentHash,
@@ -52153,8 +52578,8 @@ ${section}`;
     }
   };
 }
-function enforceTrustRegion(candidate, budget) {
-  const v = candidate.diffSummary;
+function enforceTrustRegion(candidate2, budget) {
+  const v = candidate2.diffSummary;
   const breaches = [];
   if (v.changedLines > budget.maxChangedLines) {
     breaches.push(`changedLines ${v.changedLines} > ${budget.maxChangedLines}`);
@@ -52183,9 +52608,9 @@ function countChangedLines(a, b) {
   return changed;
 }
 function draftCandidate(inputs) {
-  const candidate = _internals78.draftDeterministic(inputs);
-  enforceTrustRegion(candidate, inputs.budget);
-  return candidate;
+  const candidate2 = _internals78.draftDeterministic(inputs);
+  enforceTrustRegion(candidate2, inputs.budget);
+  return candidate2;
 }
 
 // src/services/skill-optimizer/deterministic-seed.ts
@@ -52221,7 +52646,7 @@ async function deterministicSeed(input) {
 
 // src/services/skill-optimizer/smoke.ts
 import { existsSync as existsSync54, lstatSync as lstatSync10, readFileSync as readFileSync41, realpathSync as realpathSync9 } from "fs";
-import * as path96 from "path";
+import * as path97 from "path";
 
 // src/hooks/spawn-helper.ts
 import * as child_process9 from "child_process";
@@ -52230,7 +52655,7 @@ var _internals79 = {
   spawn: child_process9.spawn
 };
 function spawnAsync(command, cwd, timeoutMs) {
-  return new Promise((resolve32) => {
+  return new Promise((resolve33) => {
     try {
       const [rawCmd, ...args] = command;
       const cmd = process.platform === "win32" && WIN32_CMD_BINARIES.has(rawCmd) && !rawCmd.includes(".") ? `${rawCmd}.cmd` : rawCmd;
@@ -52277,24 +52702,24 @@ function spawnAsync(command, cwd, timeoutMs) {
         try {
           proc.kill();
         } catch {}
-        resolve32(null);
+        resolve33(null);
       }, timeoutMs);
       proc.on("close", (code) => {
         if (done)
           return;
         done = true;
         clearTimeout(timer);
-        resolve32({ exitCode: code ?? 1, stdout, stderr });
+        resolve33({ exitCode: code ?? 1, stdout, stderr });
       });
       proc.on("error", () => {
         if (done)
           return;
         done = true;
         clearTimeout(timer);
-        resolve32(null);
+        resolve33(null);
       });
     } catch {
-      resolve32(null);
+      resolve33(null);
     }
   });
 }
@@ -52310,8 +52735,8 @@ var _internals80 = {
     }
   },
   escapedRoot: (root, target) => {
-    const rel = path96.relative(path96.resolve(root), path96.resolve(target));
-    return rel.startsWith("..") || path96.isAbsolute(rel);
+    const rel = path97.relative(path97.resolve(root), path97.resolve(target));
+    return rel.startsWith("..") || path97.isAbsolute(rel);
   },
   realpath: (p) => realpathSync9(p),
   evaluateSkillChange,
@@ -52320,7 +52745,7 @@ var _internals80 = {
 };
 async function validateSkillSmoke(input) {
   const notes = [];
-  const repoRel = path96.join(".opencode", "skills", "generated", input.skillSlug, "SKILL.md");
+  const repoRel = path97.join(".opencode", "skills", "generated", input.skillSlug, "SKILL.md");
   if (!_internals80.validateSkillPath(repoRel)) {
     return {
       ok: false,
@@ -52328,7 +52753,7 @@ async function validateSkillSmoke(input) {
       notes: [`skill path not in an allowlisted root: ${repoRel}`]
     };
   }
-  const skillRoot = path96.join(input.directory, ".opencode", "skills", "generated", input.skillSlug);
+  const skillRoot = path97.join(input.directory, ".opencode", "skills", "generated", input.skillSlug);
   if (existsSync54(skillRoot)) {
     if (_internals80.isSymbolicLink(skillRoot)) {
       return {
@@ -52414,7 +52839,7 @@ function checkFrontmatter(content) {
   return null;
 }
 function readIncumbentContent(directory, skillSlug) {
-  const incumbent = path96.join(directory, ".opencode", "skills", "generated", skillSlug, "SKILL.md");
+  const incumbent = path97.join(directory, ".opencode", "skills", "generated", skillSlug, "SKILL.md");
   if (!existsSync54(incumbent))
     return "";
   try {
@@ -52425,16 +52850,16 @@ function readIncumbentContent(directory, skillSlug) {
 }
 
 // src/services/skill-optimizer/controller.ts
-var PROJECT_LOCK_PATH = path97.join(".swarm", "evolution", "skills", ".run.lock");
-var CONVERGENCE_FILE = path97.join(".swarm", "evolution", "skills", ".convergence.json");
+var PROJECT_LOCK_PATH = path98.join(".swarm", "evolution", "skills", ".run.lock");
+var CONVERGENCE_FILE = path98.join(".swarm", "evolution", "skills", ".convergence.json");
 async function prepareCandidatePayloads(inputRoot, candidateId2, skillSlug, baselineModel, candidateModel, baselineContent, candidateContent) {
-  const payloadSubdir = path97.join(inputRoot, "candidates", candidateId2);
+  const payloadSubdir = path98.join(inputRoot, "candidates", candidateId2);
   if (!existsSync55(payloadSubdir))
     mkdirSync29(payloadSubdir, { recursive: true });
-  const baselinePayloadRel = path97.join("candidates", candidateId2, "baseline.md");
-  const candidatePayloadRel = path97.join("candidates", candidateId2, "candidate.md");
-  writeFileSync19(path97.join(payloadSubdir, "baseline.md"), baselineContent, "utf8");
-  writeFileSync19(path97.join(payloadSubdir, "candidate.md"), candidateContent, "utf8");
+  const baselinePayloadRel = path98.join("candidates", candidateId2, "baseline.md");
+  const candidatePayloadRel = path98.join("candidates", candidateId2, "candidate.md");
+  writeFileSync19(path98.join(payloadSubdir, "baseline.md"), baselineContent, "utf8");
+  writeFileSync19(path98.join(payloadSubdir, "candidate.md"), candidateContent, "utf8");
   const { computeCandidateInputContentHash: computeCandidateInputContentHash2 } = await import("./hashing-mjwn6j4y.js");
   const baseline = {
     v: 1,
@@ -52444,7 +52869,7 @@ async function prepareCandidatePayloads(inputRoot, candidateId2, skillSlug, base
     model: baselineModel,
     contentHash: ""
   };
-  const candidate = {
+  const candidate2 = {
     v: 1,
     id: `${skillSlug}-candidate-${randomUUID11().slice(0, 8)}`,
     kind: "skill",
@@ -52453,8 +52878,8 @@ async function prepareCandidatePayloads(inputRoot, candidateId2, skillSlug, base
     contentHash: ""
   };
   baseline.contentHash = await computeCandidateInputContentHash2(inputRoot, baseline);
-  candidate.contentHash = await computeCandidateInputContentHash2(inputRoot, candidate);
-  return { baseline, candidate };
+  candidate2.contentHash = await computeCandidateInputContentHash2(inputRoot, candidate2);
+  return { baseline, candidate: candidate2 };
 }
 var _internals81 = {
   tryAcquireLock,
@@ -52475,7 +52900,7 @@ async function acquireProjectLock(directory) {
   };
 }
 async function acquireSkillLock(directory, skillSlug) {
-  const lockPath = path97.join(".swarm", "evolution", "skills", skillSlug, ".skill.lock");
+  const lockPath = path98.join(".swarm", "evolution", "skills", skillSlug, ".skill.lock");
   const result = await _internals81.tryAcquireLock(directory, lockPath, "skill-opt-controller", `skill-${skillSlug}`);
   if (!result.acquired)
     return null;
@@ -52540,7 +52965,7 @@ async function runRoundLocked(input, candidateId2) {
     budget: input.config,
     claimedTestTaskIds: input.claimedTestTaskIds ?? new Set
   });
-  const candidate = draftCandidate(generatorInputs);
+  const candidate2 = draftCandidate(generatorInputs);
   await recordTransition({
     directory: input.directory,
     skillSlug: input.skillSlug,
@@ -52549,16 +52974,16 @@ async function runRoundLocked(input, candidateId2) {
     eventType: "draft",
     actor: input.sessionId ?? "unknown",
     origin: input.origin,
-    reason: candidate.rationale,
+    reason: candidate2.rationale,
     contentHashBefore: baselineHash,
-    contentHashAfter: computeContentHash2(candidate.content),
+    contentHashAfter: computeContentHash2(candidate2.content),
     payload: {
-      metric: candidate.metric,
-      risks: candidate.risks,
-      diffSummary: candidate.diffSummary
+      metric: candidate2.metric,
+      risks: candidate2.risks,
+      diffSummary: candidate2.diffSummary
     }
   });
-  if (candidate.content === incumbent) {
+  if (candidate2.content === incumbent) {
     await recordTransition({
       directory: input.directory,
       skillSlug: input.skillSlug,
@@ -52569,7 +52994,7 @@ async function runRoundLocked(input, candidateId2) {
       origin: input.origin,
       reason: "drafted candidate is identical to baseline (convergence)",
       contentHashBefore: baselineHash,
-      contentHashAfter: computeContentHash2(candidate.content)
+      contentHashAfter: computeContentHash2(candidate2.content)
     });
     return {
       candidateId: candidateId2,
@@ -52578,7 +53003,7 @@ async function runRoundLocked(input, candidateId2) {
       stopReason: "equivalent-patch"
     };
   }
-  writeArtifact(input.directory, input.skillSlug, candidateId2, "candidate.md", candidate.content);
+  writeArtifact(input.directory, input.skillSlug, candidateId2, "candidate.md", candidate2.content);
   if (input.dryRun) {
     return {
       candidateId: candidateId2,
@@ -52590,7 +53015,7 @@ async function runRoundLocked(input, candidateId2) {
   const smoke = await validateSkillSmoke({
     directory: input.directory,
     skillSlug: input.skillSlug,
-    candidateContent: candidate.content,
+    candidateContent: candidate2.content,
     incumbentContent: incumbent
   });
   if (!smoke.ok) {
@@ -52604,7 +53029,7 @@ async function runRoundLocked(input, candidateId2) {
       origin: input.origin,
       reason: smoke.notes.join("; "),
       contentHashBefore: baselineHash,
-      contentHashAfter: computeContentHash2(candidate.content)
+      contentHashAfter: computeContentHash2(candidate2.content)
     });
     return {
       candidateId: candidateId2,
@@ -52623,7 +53048,7 @@ async function runRoundLocked(input, candidateId2) {
     origin: input.origin,
     reason: smoke.notes.join("; "),
     contentHashBefore: baselineHash,
-    contentHashAfter: computeContentHash2(candidate.content)
+    contentHashAfter: computeContentHash2(candidate2.content)
   });
   await recordTransition({
     directory: input.directory,
@@ -52635,9 +53060,9 @@ async function runRoundLocked(input, candidateId2) {
     origin: input.origin,
     reason: "PR1 validation via evaluateCandidateV1 (split:test)",
     contentHashBefore: baselineHash,
-    contentHashAfter: computeContentHash2(candidate.content)
+    contentHashAfter: computeContentHash2(candidate2.content)
   });
-  const decision = await runValidationWithTransientRetry(input, candidate.content, incumbent, candidateId2);
+  const decision = await runValidationWithTransientRetry(input, candidate2.content, incumbent, candidateId2);
   const toState = decision.status === "accept" ? "accepted_pending_approval" : decision.status === "reject" ? "rejected" : "inconclusive";
   await recordTransition({
     directory: input.directory,
@@ -52649,7 +53074,7 @@ async function runRoundLocked(input, candidateId2) {
     origin: input.origin,
     reason: decision.reasons.join("; "),
     contentHashBefore: baselineHash,
-    contentHashAfter: computeContentHash2(candidate.content),
+    contentHashAfter: computeContentHash2(candidate2.content),
     evidenceRefs: decision.runId ? [decision.runId] : [],
     payload: {
       deadband: decision.deadband,
@@ -52673,18 +53098,18 @@ async function runValidationWithTransientRetry(input, candidateContent, baseline
   while (true) {
     try {
       const evalInputRoot = input.inputRoot ?? input.directory;
-      const { baseline, candidate } = await _internals81.prepareCandidatePayloads(evalInputRoot, candidateId2, input.skillSlug, input.baselineModel, input.candidateModel, baselineContent, candidateContent);
+      const { baseline, candidate: candidate2 } = await _internals81.prepareCandidatePayloads(evalInputRoot, candidateId2, input.skillSlug, input.baselineModel, input.candidateModel, baselineContent, candidateContent);
       if (!input.dispatcher) {
         throw new Error("no evaluation dispatcher available (cannot run validation)");
       }
-      const { createModelEvaluationExecutor } = await import("./runner-d820ws7y.js");
-      const executor = createModelEvaluationExecutor(input.dispatcher, input.sessionId);
+      const { createModelEvaluationExecutor: createModelEvaluationExecutor2 } = await import("./runner-9rqc8y3m.js");
+      const executor = createModelEvaluationExecutor2(input.dispatcher, input.sessionId);
       const result = await _internals81.evaluateCandidateV1({
         projectRoot: input.directory,
         inputRoot: input.inputRoot ?? input.directory,
         tasks: input.validationTasks,
         baseline,
-        candidate,
+        candidate: candidate2,
         split: "test",
         seed: randomUUID11(),
         models: input.models,
@@ -52752,7 +53177,7 @@ async function runValidationWithTransientRetry(input, candidateContent, baseline
   }
 }
 function readConvergenceState(directory) {
-  const file = path97.join(directory, CONVERGENCE_FILE);
+  const file = path98.join(directory, CONVERGENCE_FILE);
   if (!existsSync55(file))
     return { nonImprovements: 0 };
   try {
@@ -52762,10 +53187,10 @@ function readConvergenceState(directory) {
   }
 }
 function writeConvergenceState(directory, nonImprovements) {
-  const dir = path97.dirname(path97.join(directory, CONVERGENCE_FILE));
+  const dir = path98.dirname(path98.join(directory, CONVERGENCE_FILE));
   if (!existsSync55(dir))
     mkdirSync29(dir, { recursive: true });
-  writeFileSync19(path97.join(directory, CONVERGENCE_FILE), JSON.stringify({ nonImprovements }), "utf8");
+  writeFileSync19(path98.join(directory, CONVERGENCE_FILE), JSON.stringify({ nonImprovements }), "utf8");
 }
 async function runOptimizationLoop(input) {
   const rounds = [];
@@ -52821,7 +53246,7 @@ async function runOptimizationLoop(input) {
 
 // src/services/skill-optimizer/skill-eval-tasks.ts
 import { existsSync as existsSync56, mkdirSync as mkdirSync30, writeFileSync as writeFileSync20 } from "fs";
-import * as path98 from "path";
+import * as path99 from "path";
 var DEFAULT_SKILL_EVAL_TASKS = [
   {
     id: "skill-eval-trigger-clarity",
@@ -52861,20 +53286,20 @@ function buildSkillEvalTasks(args) {
   const tasks = args.tasks ?? DEFAULT_SKILL_EVAL_TASKS;
   const result = [];
   for (const spec of tasks) {
-    const taskDir = path98.join(args.inputRoot, "skill-eval", spec.id);
+    const taskDir = path99.join(args.inputRoot, "skill-eval", spec.id);
     if (!existsSync56(taskDir))
       mkdirSync30(taskDir, { recursive: true });
-    const instructionPath = path98.join("skill-eval", spec.id, "instruction.md");
-    writeFileSync20(path98.join(args.inputRoot, instructionPath), `${spec.instruction}
+    const instructionPath = path99.join("skill-eval", spec.id, "instruction.md");
+    writeFileSync20(path99.join(args.inputRoot, instructionPath), `${spec.instruction}
 `, "utf8");
-    const envRelPath = path98.join("skill-eval", spec.id, "environment.md");
-    writeFileSync20(path98.join(args.inputRoot, envRelPath), spec.environmentBody, "utf8");
-    const phraseSpecPath = path98.join("skill-eval", spec.id, "phrase-spec.json");
-    writeFileSync20(path98.join(args.inputRoot, phraseSpecPath), JSON.stringify({
+    const envRelPath = path99.join("skill-eval", spec.id, "environment.md");
+    writeFileSync20(path99.join(args.inputRoot, envRelPath), spec.environmentBody, "utf8");
+    const phraseSpecPath = path99.join("skill-eval", spec.id, "phrase-spec.json");
+    writeFileSync20(path99.join(args.inputRoot, phraseSpecPath), JSON.stringify({
       required_phrases: spec.requiredPhrases,
       forbidden_phrases: spec.forbiddenPhrases
     }), "utf8");
-    const task = {
+    const task2 = {
       v: 1,
       id: spec.id,
       source: "curated",
@@ -52906,8 +53331,8 @@ function buildSkillEvalTasks(args) {
       },
       contentHash: ""
     };
-    task.contentHash = computeTaskContentHash(task);
-    result.push(task);
+    task2.contentHash = computeTaskContentHash(task2);
+    result.push(task2);
   }
   return result;
 }
@@ -52960,7 +53385,7 @@ ${JSON.stringify(result, null, 2)}
 }
 function readSkillOptConfigFromProject(directory) {
   try {
-    const cfgPath = path99.join(directory, "opencode.json");
+    const cfgPath = path100.join(directory, "opencode.json");
     if (!existsSync57(cfgPath))
       return { ...DEFAULT_SKILL_OPT_CONFIG };
     const raw = JSON.parse(readFileSync43(cfgPath, "utf8"));
@@ -53010,18 +53435,18 @@ async function handleSkillOptRun(directory, args, runtime = {}) {
     }, parsed.json);
   }
   const models = parsed.models.length > 0 ? parsed.models : ["default"];
-  const inputRoot = path99.join(directory, ".swarm", "evolution", "skills", "_eval-input");
+  const inputRoot = path100.join(directory, ".swarm", "evolution", "skills", "_eval-input");
   if (!existsSync57(inputRoot))
     mkdirSync31(inputRoot, { recursive: true });
-  const scorerDir = path99.join(inputRoot, "scoring");
+  const scorerDir = path100.join(inputRoot, "scoring");
   if (!existsSync57(scorerDir))
     mkdirSync31(scorerDir, { recursive: true });
-  const scorerSource = path99.join(directory, "evaluation-fixtures", "skill-eval", "scoring", "score-skill-eval.cjs");
-  const scorerDest = path99.join(scorerDir, "score-skill-eval.cjs");
+  const scorerSource = path100.join(directory, "evaluation-fixtures", "skill-eval", "scoring", "score-skill-eval.cjs");
+  const scorerDest = path100.join(scorerDir, "score-skill-eval.cjs");
   if (existsSync57(scorerSource)) {
     copyFileSync5(scorerSource, scorerDest);
   }
-  const scorerRelPath = path99.join("scoring", "score-skill-eval.cjs");
+  const scorerRelPath = path100.join("scoring", "score-skill-eval.cjs");
   const validationTasks = buildSkillEvalTasks({ inputRoot, scorerRelPath });
   const result = await runOptimizationLoop({
     directory,
@@ -53064,11 +53489,11 @@ async function handleSkillOptDiff(directory, args) {
   if (idError)
     return idError;
   const baseline = readArtifact(directory, parsed.skillSlug, parsed.candidateId, "baseline.md") ?? "";
-  const candidate = readArtifact(directory, parsed.skillSlug, parsed.candidateId, "candidate.md") ?? "";
+  const candidate2 = readArtifact(directory, parsed.skillSlug, parsed.candidateId, "candidate.md") ?? "";
   const replay = replayCandidate(directory, parsed.skillSlug, parsed.candidateId);
   const baselineLines = baseline.split(`
 `);
-  const candidateLines = candidate.split(`
+  const candidateLines = candidate2.split(`
 `);
   const max = Math.max(baselineLines.length, candidateLines.length);
   let added = 0;
@@ -53091,11 +53516,11 @@ async function handleSkillOptDiff(directory, args) {
     candidateId: parsed.candidateId,
     lastState: replay.state,
     baselineBytes: baseline.length,
-    candidateBytes: candidate.length,
+    candidateBytes: candidate2.length,
     linesAdded: added,
     linesRemoved: removed,
     baselinePreview: baseline.slice(0, 400),
-    candidatePreview: candidate.slice(0, 400),
+    candidatePreview: candidate2.slice(0, 400),
     truncated: replay.truncated
   }, parsed.json);
 }
@@ -53194,12 +53619,12 @@ async function handleSpecifyCommand(_directory, args) {
 init_loader();
 init_schema();
 import * as fsSync3 from "fs";
-import { readFile as readFile21 } from "fs/promises";
-import * as path102 from "path";
+import { readFile as readFile22 } from "fs/promises";
+import * as path103 from "path";
 
 // src/consensus/store.ts
 import { readdir as readdir5, unlink as unlink3 } from "fs/promises";
-import * as path100 from "path";
+import * as path101 from "path";
 
 // src/consensus/contracts.ts
 init_zod();
@@ -53370,10 +53795,10 @@ var SENTENCE_TERMINATOR_CLASS = "\\p{Sentence_Terminal}\\u2025\\u2026\\u22EF\\uF
 var SINGLE_SENTENCE_RE = new RegExp(`^[^${SENTENCE_TERMINATOR_CLASS}]*(?:[${SENTENCE_TERMINATOR_CLASS}]+["')]?)?$`, "u");
 
 // src/consensus/store.ts
-var CONSENSUS_RELATIVE_DIR = path100.join("evolution", "consensus");
+var CONSENSUS_RELATIVE_DIR = path101.join("evolution", "consensus");
 var REPORT_ID_RE = /^[A-Za-z0-9][A-Za-z0-9._-]{0,159}$/;
 function swarmPath(directory, ...segments) {
-  return path100.join(directory, ".swarm", ...segments);
+  return path101.join(directory, ".swarm", ...segments);
 }
 async function countConsensusReportFiles(directory) {
   const root = swarmPath(directory, CONSENSUS_RELATIVE_DIR);
@@ -53389,16 +53814,16 @@ async function countConsensusReportFiles(directory) {
 
 // src/turbo/lean/state.ts
 init_logger();
-import * as fs48 from "fs";
-import * as path101 from "path";
+import * as fs49 from "fs";
+import * as path102 from "path";
 var STATE_FILE3 = "turbo-state.json";
 function nowISO3() {
   return new Date().toISOString();
 }
 function ensureSwarmDir2(directory) {
-  const swarmDir = path101.resolve(directory, ".swarm");
-  if (!fs48.existsSync(swarmDir)) {
-    fs48.mkdirSync(swarmDir, { recursive: true });
+  const swarmDir = path102.resolve(directory, ".swarm");
+  if (!fs49.existsSync(swarmDir)) {
+    fs49.mkdirSync(swarmDir, { recursive: true });
   }
   return swarmDir;
 }
@@ -53441,17 +53866,17 @@ function markStateUnreadable2(directory, reason) {
 }
 function readPersisted2(directory) {
   try {
-    const filePath = path101.join(directory, ".swarm", STATE_FILE3);
-    if (!fs48.existsSync(filePath)) {
+    const filePath = path102.join(directory, ".swarm", STATE_FILE3);
+    if (!fs49.existsSync(filePath)) {
       const seed = emptyPersisted2();
       try {
         ensureSwarmDir2(directory);
-        fs48.writeFileSync(filePath, `${JSON.stringify(seed, null, 2)}
+        fs49.writeFileSync(filePath, `${JSON.stringify(seed, null, 2)}
 `, "utf-8");
       } catch {}
       return seed;
     }
-    const raw = fs48.readFileSync(filePath, "utf-8");
+    const raw = fs49.readFileSync(filePath, "utf-8");
     const parsed = JSON.parse(raw);
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed) || parsed.version !== 1 || !parsed.sessions || typeof parsed.sessions !== "object" || Array.isArray(parsed.sessions)) {
       markStateUnreadable2(directory, `malformed shape (version=${parsed?.version}, sessions type=${Array.isArray(parsed?.sessions) ? "array" : typeof parsed?.sessions})`);
@@ -53477,7 +53902,7 @@ function writePersisted2(directory, persisted) {
   let payload;
   try {
     ensureSwarmDir2(directory);
-    filePath = path101.join(directory, ".swarm", STATE_FILE3);
+    filePath = path102.join(directory, ".swarm", STATE_FILE3);
     tmpPath = `${filePath}.tmp.${Date.now()}`;
     persisted.updatedAt = nowISO3();
     payload = `${JSON.stringify(persisted, null, 2)}
@@ -53488,14 +53913,14 @@ function writePersisted2(directory, persisted) {
     throw new Error(`Lean Turbo state persistence prepare failed: ${msg}`);
   }
   try {
-    fs48.writeFileSync(tmpPath, payload, "utf-8");
-    fs48.renameSync(tmpPath, filePath);
+    fs49.writeFileSync(tmpPath, payload, "utf-8");
+    fs49.renameSync(tmpPath, filePath);
   } catch (error2) {
     const msg = error2 instanceof Error ? error2.message : String(error2);
     error(`[turbo/lean/state] Failed to persist ${STATE_FILE3} atomically: ${msg}`);
     try {
-      if (fs48.existsSync(tmpPath)) {
-        fs48.unlinkSync(tmpPath);
+      if (fs49.existsSync(tmpPath)) {
+        fs49.unlinkSync(tmpPath);
       }
     } catch {}
     throw new Error(`Lean Turbo state persistence failed: ${msg}`);
@@ -53598,7 +54023,7 @@ var _internals82 = {
 };
 function readSpecStalenessSnapshot(directory) {
   try {
-    const p = path102.join(directory, ".swarm", "spec-staleness.json");
+    const p = path103.join(directory, ".swarm", "spec-staleness.json");
     if (!fsSync3.existsSync(p))
       return { stale: false };
     const raw = fsSync3.readFileSync(p, "utf-8");
@@ -53634,9 +54059,9 @@ async function getStatusData(directory, agents, sessionId) {
     let completedTasks = 0;
     let totalTasks = 0;
     for (const phase of plan.phases) {
-      for (const task of phase.tasks) {
+      for (const task2 of phase.tasks) {
         totalTasks++;
-        if (task.status === "completed")
+        if (task2.status === "completed")
           completedTasks++;
       }
     }
@@ -53736,7 +54161,7 @@ async function getStatusData(directory, agents, sessionId) {
       const memoryConfig = MemoryConfigSchema.parse(loadPluginConfig(directory).memory ?? {});
       provider = memoryConfig.provider;
       if (memoryPointer) {
-        const cohortConfigPath = path102.join(resolveLinkDir(memoryPointer.linkId), "memory", "memory-cohort-config.json");
+        const cohortConfigPath = path103.join(resolveLinkDir(memoryPointer.linkId), "memory", "memory-cohort-config.json");
         if (fsSync3.existsSync(cohortConfigPath)) {
           const stored = JSON.parse(fsSync3.readFileSync(cohortConfigPath, "utf-8"));
           const versionCheck = classifyStoredFingerprintAlgorithmVersion(stored.algorithm_version);
@@ -54030,7 +54455,7 @@ async function safeLineCount(filePath) {
   try {
     if (!fsSync3.existsSync(filePath))
       return 0;
-    const content = await readFile21(filePath, "utf-8");
+    const content = await readFile22(filePath, "utf-8");
     let n = 0;
     for (const line of content.split(`
 `)) {
@@ -54314,7 +54739,7 @@ function buildStatusMessage2(session, directory, sessionID) {
 }
 
 // src/commands/unlink.ts
-import * as path103 from "path";
+import * as path104 from "path";
 async function handleUnlinkCommand(directory, args) {
   const pointer = readLinkPointer(directory);
   if (!pointer) {
@@ -54327,7 +54752,7 @@ async function handleUnlinkCommand(directory, args) {
   let familySummary = "";
   if (copyBack) {
     try {
-      const result = await migrateKnowledgeFamily(path103.join(directory, ".swarm"), linkDir);
+      const result = await migrateKnowledgeFamily(path104.join(directory, ".swarm"), linkDir);
       for (const m of result.perMember) {
         totalMerged += m.merged;
         totalSkipped += m.skipped;
@@ -54505,7 +54930,7 @@ function buildDetailedHelp(commandName, entry) {
 async function handleHelpCommand(ctx) {
   const targetCommand = ctx.args.join(" ");
   if (!targetCommand) {
-    const { buildHelpText } = await import("./index-j2ghsdzz.js");
+    const { buildHelpText } = await import("./index-p0kez6cn.js");
     return buildHelpText();
   }
   const tokens = targetCommand.split(/\s+/);
@@ -54514,7 +54939,7 @@ async function handleHelpCommand(ctx) {
     return _internals14.buildDetailedHelp(resolved.key, resolved.entry);
   }
   const similar = _internals14.findSimilarCommands(targetCommand);
-  const { buildHelpText: fullHelp } = await import("./index-j2ghsdzz.js");
+  const { buildHelpText: fullHelp } = await import("./index-p0kez6cn.js");
   if (similar.length > 0) {
     return `Command '/swarm ${targetCommand}' not found.
 
@@ -54691,7 +55116,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail explain": {
     handler: async (ctx) => {
-      const { handleGuardrailExplain } = await import("./guardrail-explain-8kkqz8tx.js");
+      const { handleGuardrailExplain } = await import("./guardrail-explain-sq1kcah3.js");
       return handleGuardrailExplain(ctx.directory, ctx.args);
     },
     description: "Dry-run: show what the guardrails would do to a command or write target (executes nothing)",
@@ -54701,7 +55126,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail-explain": {
     handler: async (ctx) => {
-      const { handleGuardrailExplain } = await import("./guardrail-explain-8kkqz8tx.js");
+      const { handleGuardrailExplain } = await import("./guardrail-explain-sq1kcah3.js");
       return handleGuardrailExplain(ctx.directory, ctx.args);
     },
     description: "Dry-run: show what the guardrails would do to a command or write target (executes nothing)",
@@ -54711,7 +55136,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail-log": {
     handler: async (ctx) => {
-      const { handleGuardrailLog } = await import("./guardrail-log-e2v9qw71.js");
+      const { handleGuardrailLog } = await import("./guardrail-log-7anp1z1n.js");
       return handleGuardrailLog(ctx.directory, ctx.args);
     },
     description: "Read the guardrail decision log (use --blocks-only for blocks)",
@@ -55656,24 +56081,24 @@ function validateAliases() {
         continue;
       }
       const visited = new Set;
-      const path104 = [];
+      const path105 = [];
       let current = target;
       while (current) {
         const currentEntry = COMMAND_REGISTRY[current];
         if (!currentEntry)
           break;
         if (visited.has(current)) {
-          const cycleStart = path104.indexOf(current);
+          const cycleStart = path105.indexOf(current);
           const fullChain = [
             name,
-            ...path104.slice(0, cycleStart > 0 ? cycleStart : path104.length),
+            ...path105.slice(0, cycleStart > 0 ? cycleStart : path105.length),
             current
           ].join(" \u2192 ");
           errors.push(`Circular alias detected: ${fullChain}`);
           break;
         }
         visited.add(current);
-        path104.push(current);
+        path105.push(current);
         current = currentEntry.aliasOf || "";
       }
     }