opencode-swarm 7.99.3 → 7.99.5

package/dist/index.js

@@ -69,7 +69,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "opencode-swarm",
-    version: "7.99.3",
+    version: "7.99.5",
     description: "Architect-centric agentic swarm plugin for OpenCode - hub-and-spoke orchestration with SME consultation, code generation, and QA review",
     main: "dist/index.js",
     types: "dist/index.d.ts",
@@ -20525,6 +20525,25 @@ async function getLatestLedgerHash(directory) {
     return "";
   }
 }
+async function surfaceLedgerStaleIfPersisted(directory, plan) {
+  const resolvedWorkspace = path13.resolve(directory);
+  if (!ledgerStaleWorkspaces.has(resolvedWorkspace)) {
+    return plan;
+  }
+  try {
+    const planHash = computePlanHash(plan);
+    const ledgerHash = await getLatestLedgerHash(directory);
+    if (ledgerHash !== "" && planHash === ledgerHash) {
+      ledgerStaleWorkspaces.delete(resolvedWorkspace);
+      return plan;
+    }
+  } catch {}
+  plan._ledgerReplayStale = true;
+  if (typeof plan._ledgerReplayStaleReason !== "string" || plan._ledgerReplayStaleReason.length === 0) {
+    plan._ledgerReplayStaleReason = "plan.json still hash-mismatches the ledger after a startup ledger-replay failure (replay could not be applied and no critic-approved snapshot was available). Run /swarm reset-session if this persists.";
+  }
+  return plan;
+}
 async function parsePlanJsonCached(directory) {
   const planJsonPath = path13.resolve(directory, ".swarm", "plan.json");
   return readCachedParsedFile(planJsonPath, PLAN_JSON_CACHE_NAMESPACE, () => readSwarmFileAsync(directory, "plan.json"), (planJsonContent) => {
@@ -20583,7 +20602,7 @@ async function isPlanMdInSync(directory, plan, cache) {
   if (normalizedActual === normalizedExpected) {
     return true;
   }
-  return normalizedActual.includes(normalizedExpected) || normalizedExpected.includes(normalizedActual.replace(/^#.*$/gm, "").trim());
+  return false;
 }
 async function regeneratePlanMarkdown(directory, plan) {
   const swarmDir = path13.resolve(directory, ".swarm");
@@ -20664,6 +20683,12 @@ async function loadPlan(directory, cache) {
                         return approved.plan;
                       }
                     } catch {}
+                    {
+                      const runtimeStale = validated;
+                      runtimeStale._ledgerReplayStale = true;
+                      runtimeStale._ledgerReplayStaleReason = `Ledger replay failed during hash-mismatch rebuild and no approved snapshot was available: ${replayError instanceof Error ? replayError.message : String(replayError)}`;
+                      ledgerStaleWorkspaces.add(resolvedWorkspace);
+                    }
                     warn(`[loadPlan] Ledger replay failed during hash-mismatch rebuild: ${replayError instanceof Error ? replayError.message : String(replayError)}. Returning stale plan.json. To recover: check .swarm/plan-export/SWARM_PLAN.md for a checkpoint, or run /swarm reset-session.`);
                   }
                 }
@@ -20708,7 +20733,7 @@ async function loadPlan(directory, cache) {
               } catch {}
             }
           }
-          return validated;
+          return await surfaceLedgerStaleIfPersisted(directory, validated);
         }
       } catch (error49) {
         warn(`[loadPlan] plan.json validation failed: ${error49 instanceof Error ? error49.message : String(error49)}. Attempting rebuild from ledger. If rebuild fails, check .swarm/plan-export/SWARM_PLAN.md for a checkpoint.`);
@@ -21646,7 +21671,7 @@ function migrateLegacyPlan(planContent, swarmId) {
   };
   return plan;
 }
-var PlanConcurrentModificationError, PlanTaskRemovalNotAcknowledgedError, startupLedgerCheckedWorkspaces, recoveryMutexes, PLAN_JSON_CACHE_NAMESPACE = "plan-json:validated:v1", _internals8, CAS_BACKOFF_START_MS = 5, CAS_BACKOFF_CAP_MS = 250, CAS_BACKOFF_JITTER = 0.25, CAS_MAX_RETRIES = 3;
+var PlanConcurrentModificationError, PlanTaskRemovalNotAcknowledgedError, startupLedgerCheckedWorkspaces, ledgerStaleWorkspaces, recoveryMutexes, PLAN_JSON_CACHE_NAMESPACE = "plan-json:validated:v1", _internals8, CAS_BACKOFF_START_MS = 5, CAS_BACKOFF_CAP_MS = 250, CAS_BACKOFF_JITTER = 0.25, CAS_MAX_RETRIES = 3;
 var init_manager = __esm(() => {
   init_plan_schema();
   init_branch();
@@ -21678,6 +21703,7 @@ var init_manager = __esm(() => {
     }
   };
   startupLedgerCheckedWorkspaces = new Set;
+  ledgerStaleWorkspaces = new Set;
   recoveryMutexes = new Map;
   _internals8 = {
     loadPlan,
@@ -47088,6 +47114,7 @@ var init_pr_subscriptions = __esm(() => {
 var exports_state = {};
 __export(exports_state, {
   updateAgentEventTime: () => updateAgentEventTime,
+  sweepStaleSessions: () => sweepStaleSessions,
   swarmState: () => swarmState,
   startAgentSession: () => startAgentSession,
   setSessionEnvironment: () => setSessionEnvironment,
@@ -47099,6 +47126,7 @@ __export(exports_state, {
   recordStageBCompletion: () => recordStageBCompletion,
   recordPhaseAgentDispatch: () => recordPhaseAgentDispatch,
   pruneOldWindows: () => pruneOldWindows,
+  maybeSweepStaleSessions: () => maybeSweepStaleSessions,
   isCouncilGateActive: () => isCouncilGateActive,
   hasBothStageBCompletions: () => hasBothStageBCompletions,
   hasActiveTurboMode: () => hasActiveTurboMode,
@@ -47144,6 +47172,7 @@ function resetSwarmState() {
   swarmState.pendingEvents = 0;
   swarmState.lastBudgetPct = 0;
   swarmState.agentSessions.clear();
+  _lastIdleSweepAtMs = 0;
   clearTrajectoryCache();
   clearTrajectoryStepCounters();
   swarmState.pendingRehydrations.clear();
@@ -47185,8 +47214,7 @@ function resetSwarmStatePreservingSingletons() {
   swarmState.specWriterAgentNames = preservedSpecWriterAgentNames;
   swarmState.generatedAgentNames = preservedGeneratedAgentNames;
 }
-function startAgentSession(sessionId, agentName, staleDurationMs = 7200000, directory) {
-  const now = Date.now();
+function sweepStaleSessions(staleDurationMs = STALE_SESSION_TTL_MS, now = Date.now()) {
   const staleIds = [];
   for (const [id, session] of swarmState.agentSessions) {
     if (now - session.lastToolCallTime > staleDurationMs) {
@@ -47195,7 +47223,20 @@ function startAgentSession(sessionId, agentName, staleDurationMs = 7200000, dire
   }
   for (const id of staleIds) {
     swarmState.agentSessions.delete(id);
+    swarmState.delegationChains.delete(id);
   }
+  return staleIds;
+}
+function maybeSweepStaleSessions(staleDurationMs = STALE_SESSION_TTL_MS, now = Date.now()) {
+  if (now - _lastIdleSweepAtMs < IDLE_SWEEP_COOLDOWN_MS) {
+    return [];
+  }
+  _lastIdleSweepAtMs = now;
+  return sweepStaleSessions(staleDurationMs, now);
+}
+function startAgentSession(sessionId, agentName, staleDurationMs = STALE_SESSION_TTL_MS, directory) {
+  const now = Date.now();
+  sweepStaleSessions(staleDurationMs, now);
   const sessionState = {
     agentName,
     lastToolCallTime: now,
@@ -47446,6 +47487,7 @@ function ensureAgentSession(sessionId, agentName, directory) {
       session.prSubscriptions = new Map;
     }
     session.lastToolCallTime = now;
+    maybeSweepStaleSessions();
     return session;
   }
   _internals25.startAgentSession(sessionId, agentName ?? "unknown", 7200000, directory);
@@ -47930,7 +47972,7 @@ async function rehydratePrSubscriptions(sessionID, directory) {
   }
   return map2;
 }
-var _rehydrationCache = null, _councilDisagreementWarned, STATE_ORDER, _toolAggregates, defaultRunContext, _runContexts, swarmState, MAX_TRACKED_CRITICAL_SHOWN = 500, MAX_TRACKED_KNOWLEDGE_ACKS = 5000, _internals25;
+var _rehydrationCache = null, _councilDisagreementWarned, STATE_ORDER, _toolAggregates, defaultRunContext, _runContexts, swarmState, STALE_SESSION_TTL_MS = 7200000, IDLE_SWEEP_COOLDOWN_MS = 60000, _lastIdleSweepAtMs = 0, MAX_TRACKED_CRITICAL_SHOWN = 500, MAX_TRACKED_KNOWLEDGE_ACKS = 5000, _internals25;
 var init_state2 = __esm(() => {
   init_constants();
   init_plan_schema();
@@ -76579,6 +76621,9 @@ var init_gate_bridge = __esm(() => {
 import { existsSync as existsSync35, mkdirSync as mkdirSync21, readFileSync as readFileSync19, writeFileSync as writeFileSync13 } from "node:fs";
 import { homedir as homedir8 } from "node:os";
 import { join as join52 } from "node:path";
+function isStrictSemver(value) {
+  return typeof value === "string" && STRICT_SEMVER.test(value);
+}
 function cacheDir() {
   const xdg = process.env.XDG_CACHE_HOME;
   const base = xdg && xdg.length > 0 ? xdg : join52(homedir8(), ".cache");
@@ -76633,14 +76678,32 @@ function compareVersions(a, b) {
 }
 async function fetchLatestVersion(signal) {
   try {
-    const res = await fetch(NPM_REGISTRY_URL, {
+    const res = await _internals43.fetch(NPM_REGISTRY_URL, {
       signal,
       headers: { Accept: "application/json" }
     });
     if (!res.ok)
       return null;
-    const body = await res.json();
-    return typeof body.version === "string" ? body.version : null;
+    const contentType = (res.headers.get("content-type") ?? "").toLowerCase();
+    if (!contentType.includes("json"))
+      return null;
+    const lengthHeader = res.headers.get("content-length");
+    if (lengthHeader) {
+      const advertised = Number.parseInt(lengthHeader, 10);
+      if (Number.isFinite(advertised) && advertised > MAX_RESPONSE_BYTES) {
+        return null;
+      }
+    }
+    const text = await res.text();
+    if (text.length > MAX_RESPONSE_BYTES)
+      return null;
+    let body;
+    try {
+      body = JSON.parse(text);
+    } catch {
+      return null;
+    }
+    return isStrictSemver(body.version) ? body.version : null;
   } catch {
     return null;
   }
@@ -76682,9 +76745,14 @@ function maybeWarn(runningVersion, npmLatest, emitWarning) {
     emitWarning(`[opencode-swarm] Update available: ${runningVersion} → ${npmLatest}. ` + "OpenCode caches plugins indefinitely. Run `bunx opencode-swarm update` to refresh.");
   }
 }
-var NPM_REGISTRY_URL = "https://registry.npmjs.org/opencode-swarm/latest", CHECK_INTERVAL_MS, FETCH_TIMEOUT_MS = 5000, _checkLatched = false;
+var NPM_REGISTRY_URL = "https://registry.npmjs.org/opencode-swarm/latest", CHECK_INTERVAL_MS, FETCH_TIMEOUT_MS = 5000, MAX_RESPONSE_BYTES, STRICT_SEMVER, _checkLatched = false, _internals43;
 var init_version_check = __esm(() => {
   CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000;
+  MAX_RESPONSE_BYTES = 256 * 1024;
+  STRICT_SEMVER = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-(?:0|[1-9]\d*|\d*[A-Za-z-][0-9A-Za-z-]*)(?:\.(?:0|[1-9]\d*|\d*[A-Za-z-][0-9A-Za-z-]*))*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
+  _internals43 = {
+    fetch: (input, init) => fetch(input, init)
+  };
 });
 
 // src/services/knowledge-diagnostics.ts
@@ -77482,9 +77550,9 @@ async function checkCurator(directory) {
 }
 async function getSandboxStatus() {
   try {
-    const capability = await _internals43.detectSandboxCapability();
+    const capability = await _internals44.detectSandboxCapability();
     const mechanism = capability.mechanism ?? "none";
-    const executor = await _internals43.getSandboxExecutor();
+    const executor = await _internals44.getSandboxExecutor();
     const hasExecutor = executor !== null;
     if (hasExecutor) {
       return {
@@ -77733,7 +77801,7 @@ async function handleDiagnoseCommand(directory, _args) {
   const diagnoseData = await getDiagnoseData(directory);
   return formatDiagnoseMarkdown(diagnoseData);
 }
-var version4, sandboxCapabilityProbe, _internals43;
+var version4, sandboxCapabilityProbe, _internals44;
 var init_diagnose_service = __esm(() => {
   init_package();
   init_cache_paths();
@@ -77750,7 +77818,7 @@ var init_diagnose_service = __esm(() => {
   init_warning_buffer();
   ({ version: version4 } = package_default);
   sandboxCapabilityProbe = new SandboxCapabilityProbe;
-  _internals43 = {
+  _internals44 = {
     detectSandboxCapability: () => sandboxCapabilityProbe.detect(),
     getSandboxExecutor: getExecutor
   };
@@ -77812,6 +77880,21 @@ function emitObjectTypeMismatch(key, value, findings) {
     });
   }
 }
+function emitWorktreeIsolationLayeringAdvisory(config3, findings) {
+  const parallelization = config3.parallelization;
+  const worktreePolicy = config3.worktree?.policy ?? "auto";
+  if (parallelization?.enabled === true && (parallelization.maxConcurrentTasks ?? 1) > 1 && worktreePolicy !== "disabled") {
+    findings.push({
+      id: "worktree-isolation-baseline-active",
+      title: "Worktree isolation is already active for standard parallel coders",
+      description: "Standard parallel coders already use baseline worktree isolation through the parallel execution profile plus top-level worktree.policy. Lean Turbo and Epic are additive strategies, not requirements for obtaining worktree isolation.",
+      severity: "warn",
+      path: "worktree.policy",
+      currentValue: worktreePolicy,
+      autoFixable: false
+    });
+  }
+}
 function getUserConfigDir3() {
   return process.env.XDG_CONFIG_HOME || path69.join(os15.homedir(), ".config");
 }
@@ -78372,6 +78455,14 @@ function validateConfigKey(path70, value) {
       emitObjectTypeMismatch("summaries", value, findings);
       break;
     }
+    case "auto_review": {
+      emitObjectTypeMismatch("auto_review", value, findings);
+      break;
+    }
+    case "repo_graph": {
+      emitObjectTypeMismatch("repo_graph", value, findings);
+      break;
+    }
     case "review_passes": {
       emitObjectTypeMismatch("review_passes", value, findings);
       break;
@@ -78448,6 +78539,10 @@ function validateConfigKey(path70, value) {
       emitObjectTypeMismatch("skill_improver", value, findings);
       break;
     }
+    case "skills": {
+      emitObjectTypeMismatch("skills", value, findings);
+      break;
+    }
     case "spec_writer": {
       emitObjectTypeMismatch("spec_writer", value, findings);
       break;
@@ -78633,6 +78728,7 @@ function walkConfigAndValidate(obj, path70, findings, visited = new WeakSet) {
 function runConfigDoctor(config3, directory) {
   const findings = [];
   walkConfigAndValidate(config3, "", findings);
+  emitWorktreeIsolationLayeringAdvisory(config3, findings);
   const summary = {
     info: findings.filter((f) => f.severity === "info").length,
     warn: findings.filter((f) => f.severity === "warn").length,
@@ -80140,7 +80236,7 @@ function isCommandAvailable(command) {
   const isWindows = process.platform === "win32";
   const cmd = isWindows ? `${command}.exe` : command;
   try {
-    const result = _internals44.spawnSyncImpl(isWindows ? ["where", cmd] : ["which", cmd], {
+    const result = _internals45.spawnSyncImpl(isWindows ? ["where", cmd] : ["which", cmd], {
       cwd: process.cwd(),
       stdin: "ignore",
       stdout: "ignore",
@@ -80290,7 +80386,7 @@ async function discoverBuildCommands(workingDir, options) {
   const scope = options?.scope ?? "all";
   const changedFiles = options?.changedFiles ?? [];
   const _filesToCheck = filterByScope(workingDir, scope, changedFiles);
-  const profileResult = await _internals44.discoverBuildCommandsFromProfiles(workingDir);
+  const profileResult = await _internals45.discoverBuildCommandsFromProfiles(workingDir);
   const profileCommands = profileResult.commands;
   const profileSkipped = profileResult.skipped;
   const coveredEcosystems = new Set;
@@ -80353,7 +80449,7 @@ function clearToolchainCache() {
 function getEcosystems() {
   return ECOSYSTEMS.map((e) => e.ecosystem);
 }
-var ECOSYSTEMS, PROFILE_TO_ECOSYSTEM_NAMES, toolchainCache, IS_COMMAND_AVAILABLE_TIMEOUT_MS = 3000, _internals44, build_discovery;
+var ECOSYSTEMS, PROFILE_TO_ECOSYSTEM_NAMES, toolchainCache, IS_COMMAND_AVAILABLE_TIMEOUT_MS = 3000, _internals45, build_discovery;
 var init_discovery = __esm(() => {
   init_dist();
   init_detector();
@@ -80471,7 +80567,7 @@ var init_discovery = __esm(() => {
     php: ["php-composer"]
   };
   toolchainCache = new Map;
-  _internals44 = {
+  _internals45 = {
     isCommandAvailable,
     discoverBuildCommandsFromProfiles,
     discoverBuildCommands,
@@ -81128,7 +81224,7 @@ async function handleEpicCommand(directory, args2, sessionID) {
   if (!sessionID || sessionID.trim() === "") {
     return "Error: No active session context. Epic Mode requires an active session. Use /swarm epic from within an OpenCode session.";
   }
-  const session = _internals45.ensureAgentSession(sessionID, undefined, directory);
+  const session = _internals46.ensureAgentSession(sessionID, undefined, directory);
   const arg0 = args2[0]?.toLowerCase();
   switch (arg0) {
     case "status":
@@ -81155,7 +81251,7 @@ Usage:
 }
 function enableAndAck(directory, sessionID, session) {
   try {
-    _internals45.enableEpicMode(directory, sessionID);
+    _internals46.enableEpicMode(directory, sessionID);
   } catch (err) {
     return `Error enabling Epic Mode: ${err instanceof Error ? err.message : String(err)}`;
   }
@@ -81171,7 +81267,7 @@ function enableAndAck(directory, sessionID, session) {
 }
 function disableAndAck(directory, sessionID, session) {
   try {
-    _internals45.disableEpicMode(directory, sessionID);
+    _internals46.disableEpicMode(directory, sessionID);
   } catch (err) {
     return `Error disabling Epic Mode: ${err instanceof Error ? err.message : String(err)}`;
   }
@@ -81180,12 +81276,12 @@ function disableAndAck(directory, sessionID, session) {
 }
 function renderStatus(directory, sessionID) {
   const lines = ["## Epic Mode — Status", ""];
-  if (_internals45.isStateUnreadable(directory)) {
+  if (_internals46.isStateUnreadable(directory)) {
     lines.push("**Epic Mode state is unreadable** (`.swarm/epic-state.json` is corrupt or has an unexpected shape). Status cannot be reported until the file is repaired or removed. The fail-closed marker means `epic_decide_phase` will refuse to compute a verdict in this state.");
     return lines.join(`
 `);
   }
-  const state = _internals45.loadEpicSessionState(directory, sessionID);
+  const state = _internals46.loadEpicSessionState(directory, sessionID);
   if (!state) {
     lines.push("Epic Mode has not been toggled for this session.");
     return lines.join(`
@@ -81237,7 +81333,7 @@ function formatGreenfieldDetail(input) {
 function renderLast(directory) {
   let records;
   try {
-    records = _internals45.readPromotionEvidence(directory);
+    records = _internals46.readPromotionEvidence(directory);
   } catch (err) {
     return `Error reading epic-promotions.jsonl: ${err instanceof Error ? err.message : String(err)}`;
   }
@@ -81292,7 +81388,7 @@ function renderLast(directory) {
 `);
 }
 function renderCalibration(directory) {
-  if (_internals45.isCalibrationStateUnreadable(directory)) {
+  if (_internals46.isCalibrationStateUnreadable(directory)) {
     return [
       "## Epic Mode — Calibration",
       "",
@@ -81304,11 +81400,11 @@ function renderCalibration(directory) {
   }
   let state;
   try {
-    state = _internals45.loadCalibrationState(directory);
+    state = _internals46.loadCalibrationState(directory);
   } catch (err) {
     return `Error reading calibration state: ${err instanceof Error ? err.message : String(err)}`;
   }
-  const { config: config3 } = _internals45.loadPluginConfigWithMeta(directory);
+  const { config: config3 } = _internals46.loadPluginConfigWithMeta(directory);
   const staticThreshold = config3.turbo?.epic?.mode?.activation_threshold ?? 0.3;
   const calibrationCfg = config3.turbo?.epic?.calibration;
   const loosenWindow = calibrationCfg?.loosen_window ?? 10;
@@ -81356,7 +81452,7 @@ function renderCalibration(directory) {
   lines.push("");
   let recentDivergent = [];
   try {
-    const all = _internals45.readDivergenceHistory(directory, { limit: 50 });
+    const all = _internals46.readDivergenceHistory(directory, { limit: 50 });
     recentDivergent = all.filter((r) => !r.isClean).slice(-5);
   } catch {}
   lines.push("### Recent divergent tasks (tightened the threshold)");
@@ -81373,11 +81469,11 @@ function renderCalibration(directory) {
 `);
 }
 async function renderDecide(directory) {
-  const plan = await _internals45.loadPlanJsonOnly(directory);
+  const plan = await _internals46.loadPlanJsonOnly(directory);
   if (!plan) {
     return "No plan found at `.swarm/plan.json`. Run `/swarm plan` first.";
   }
-  const { config: config3 } = _internals45.loadPluginConfigWithMeta(directory);
+  const { config: config3 } = _internals46.loadPluginConfigWithMeta(directory);
   const modeCfg = config3.turbo?.epic?.mode;
   const cochangeCfg = config3.turbo?.epic?.cochange;
   const activationThreshold = modeCfg?.activation_threshold ?? 0.3;
@@ -81387,20 +81483,20 @@ async function renderDecide(directory) {
   const tasks = [];
   for (const phase of plan.phases) {
     for (const task of phase.tasks) {
-      const scopeFiles = _internals45.readTaskScopes(directory, task.id);
+      const scopeFiles = _internals46.readTaskScopes(directory, task.id);
       const scope = scopeFiles ?? task.files_touched ?? [];
       tasks.push({ id: task.id, scope });
     }
   }
-  const { pairs, commitsObserved } = await _internals45.getCoChangeData(directory);
+  const { pairs, commitsObserved } = await _internals46.getCoChangeData(directory);
   const isGitProject = (() => {
     try {
-      return _internals45.isGitRepo(directory);
+      return _internals46.isGitRepo(directory);
     } catch {
       return false;
     }
   })();
-  const verdict = _internals45.decideEpicActivation(tasks, pairs, commitsObserved, {
+  const verdict = _internals46.decideEpicActivation(tasks, pairs, commitsObserved, {
     activationThreshold,
     minCommitsForSignal,
     cochangeNpmiThreshold,
@@ -81442,7 +81538,7 @@ function formatVerdict(verdict) {
   return lines.join(`
 `);
 }
-var _internals45;
+var _internals46;
 var init_epic = __esm(() => {
   init_config();
   init_branch();
@@ -81455,7 +81551,7 @@ var init_epic = __esm(() => {
   init_promotion_evidence();
   init_state();
   init_conflicts();
-  _internals45 = {
+  _internals46 = {
     loadPluginConfigWithMeta,
     loadPlanJsonOnly,
     getCoChangeData,
@@ -81480,7 +81576,7 @@ var exports_evidence_summary_service = {};
 __export(exports_evidence_summary_service, {
   isAutoSummaryEnabled: () => isAutoSummaryEnabled,
   buildEvidenceSummary: () => buildEvidenceSummary,
-  _internals: () => _internals46,
+  _internals: () => _internals47,
   REQUIRED_EVIDENCE_TYPES: () => REQUIRED_EVIDENCE_TYPES,
   EVIDENCE_SUMMARY_VERSION: () => EVIDENCE_SUMMARY_VERSION
 });
@@ -81518,7 +81614,7 @@ function getTaskStatus(task, bundle) {
   if (task?.status) {
     return task.status;
   }
-  const entries = _internals46.normalizeBundleEntries(bundle);
+  const entries = _internals47.normalizeBundleEntries(bundle);
   if (entries.length > 0) {
     return "completed";
   }
@@ -81544,7 +81640,7 @@ function evidenceCompleteFromEntries(entries) {
   };
 }
 function isEvidenceComplete(bundle) {
-  return evidenceCompleteFromEntries(_internals46.normalizeBundleEntries(bundle));
+  return evidenceCompleteFromEntries(_internals47.normalizeBundleEntries(bundle));
 }
 function getTaskBlockers(task, summary, status) {
   const blockers = [];
@@ -81564,9 +81660,9 @@ async function buildTaskSummary(directory, task, taskId) {
   const bundle = result.status === "found" ? result.bundle : null;
   const gateEvidence = await readDurableGateEvidence(directory, taskId);
   const phase = task?.phase ?? 0;
-  const status = _internals46.getTaskStatus(task, bundle);
-  const entries = mergeDurableGateEntriesFromEvidence(taskId, _internals46.normalizeBundleEntries(bundle), gateEvidence);
-  let evidenceCheck = _internals46.evidenceCompleteFromEntries(entries);
+  const status = _internals47.getTaskStatus(task, bundle);
+  const entries = mergeDurableGateEntriesFromEvidence(taskId, _internals47.normalizeBundleEntries(bundle), gateEvidence);
+  let evidenceCheck = _internals47.evidenceCompleteFromEntries(entries);
   if (gateEvidence) {
     const gateStatus = getDurableGateEvidenceStatus(gateEvidence);
     evidenceCheck = gateStatus.isComplete ? { isComplete: true, missingEvidence: [] } : {
@@ -81574,7 +81670,7 @@ async function buildTaskSummary(directory, task, taskId) {
       missingEvidence: gateStatus.missingGates.map((gate) => `gate:${gate}`)
     };
   }
-  const blockers = _internals46.getTaskBlockers(task, evidenceCheck, status);
+  const blockers = _internals47.getTaskBlockers(task, evidenceCheck, status);
   const hasReview = entries.some((e) => e.type === "review");
   const hasTest = entries.some((e) => e.type === "test");
   const hasApproval = entries.some((e) => e.type === "approval");
@@ -81603,12 +81699,12 @@ async function buildPhaseSummary(directory, phase) {
   const taskSummaries = [];
   const _taskMap = new Map(phase.tasks.map((t) => [t.id, t]));
   for (const task of phase.tasks) {
-    const summary = await _internals46.buildTaskSummary(directory, task, task.id);
+    const summary = await _internals47.buildTaskSummary(directory, task, task.id);
     taskSummaries.push(summary);
   }
   const extraTaskIds = taskIds.filter((id) => !phaseTaskIds.has(id));
   for (const taskId of extraTaskIds) {
-    const summary = await _internals46.buildTaskSummary(directory, undefined, taskId);
+    const summary = await _internals47.buildTaskSummary(directory, undefined, taskId);
     if (summary.phase === phase.id) {
       taskSummaries.push(summary);
     }
@@ -81709,7 +81805,7 @@ async function buildEvidenceSummary(directory, currentPhase) {
   let totalTasks = 0;
   let completedTasks = 0;
   for (const phase of phasesToProcess) {
-    const summary = await _internals46.buildPhaseSummary(directory, phase);
+    const summary = await _internals47.buildPhaseSummary(directory, phase);
     phaseSummaries.push(summary);
     totalTasks += summary.totalTasks;
     completedTasks += summary.completedTasks;
@@ -81731,7 +81827,7 @@ async function buildEvidenceSummary(directory, currentPhase) {
     overallBlockers,
     summaryText: ""
   };
-  artifact.summaryText = _internals46.generateSummaryText(artifact);
+  artifact.summaryText = _internals47.generateSummaryText(artifact);
   log("[EvidenceSummary] Summary built", {
     phases: phaseSummaries.length,
     totalTasks,
@@ -81750,7 +81846,7 @@ function isAutoSummaryEnabled(automationConfig) {
   }
   return automationConfig.capabilities?.evidence_auto_summaries === true;
 }
-var VALID_EVIDENCE_TYPES2, REQUIRED_EVIDENCE_TYPES, EVIDENCE_SUMMARY_VERSION = "1.0.0", _internals46;
+var VALID_EVIDENCE_TYPES2, REQUIRED_EVIDENCE_TYPES, EVIDENCE_SUMMARY_VERSION = "1.0.0", _internals47;
 var init_evidence_summary_service = __esm(() => {
   init_gate_bridge();
   init_manager2();
@@ -81765,7 +81861,7 @@ var init_evidence_summary_service = __esm(() => {
     "retrospective"
   ]);
   REQUIRED_EVIDENCE_TYPES = ["review", "test"];
-  _internals46 = {
+  _internals47 = {
     buildEvidenceSummary,
     isAutoSummaryEnabled,
     normalizeBundleEntries,
@@ -81821,7 +81917,7 @@ function getVerdictEmoji(verdict) {
   return getVerdictIcon(verdict);
 }
 async function getTaskEvidenceData(directory, taskId) {
-  const result = await _internals47.loadEvidence(directory, taskId);
+  const result = await _internals48.loadEvidence(directory, taskId);
   if (result.status !== "found") {
     return {
       hasEvidence: false,
@@ -81844,13 +81940,13 @@ async function getTaskEvidenceData(directory, taskId) {
   };
 }
 async function getEvidenceListData(directory) {
-  const taskIds = await _internals47.listEvidenceTaskIds(directory);
+  const taskIds = await _internals48.listEvidenceTaskIds(directory);
   if (taskIds.length === 0) {
     return { hasEvidence: false, tasks: [] };
   }
   const tasks = [];
   for (const taskId of taskIds) {
-    const result = await _internals47.loadEvidence(directory, taskId);
+    const result = await _internals48.loadEvidence(directory, taskId);
     if (result.status === "found") {
       tasks.push({
         taskId,
@@ -81964,10 +82060,10 @@ async function handleEvidenceSummaryCommand(directory) {
   return lines.join(`
 `);
 }
-var _internals47;
+var _internals48;
 var init_evidence_service = __esm(() => {
   init_manager2();
-  _internals47 = {
+  _internals48 = {
     loadEvidence,
     listEvidenceTaskIds
   };
@@ -82616,7 +82712,7 @@ function extractCurrentPhaseFromPlan2(plan) {
   if (!plan) {
     return { currentPhase: null, currentTask: null, incompleteTasks: [] };
   }
-  if (!_internals48.validatePlanPhases(plan)) {
+  if (!_internals49.validatePlanPhases(plan)) {
     return { currentPhase: null, currentTask: null, incompleteTasks: [] };
   }
   let currentPhase = null;
@@ -82758,9 +82854,9 @@ function extractPhaseMetrics(content) {
 async function getHandoffData(directory) {
   const now = new Date().toISOString();
   const sessionContent = await readSwarmFileAsync(directory, "session/state.json");
-  const sessionState = _internals48.parseSessionState(sessionContent);
+  const sessionState = _internals49.parseSessionState(sessionContent);
   const plan = await loadPlanJsonOnly(directory);
-  const planInfo = _internals48.extractCurrentPhaseFromPlan(plan);
+  const planInfo = _internals49.extractCurrentPhaseFromPlan(plan);
   if (!plan) {
     const planMdContent = await readSwarmFileAsync(directory, "plan.md");
     if (planMdContent) {
@@ -82779,8 +82875,8 @@ async function getHandoffData(directory) {
     }
   }
   const contextContent = await readSwarmFileAsync(directory, "context.md");
-  const recentDecisions = _internals48.extractDecisions(contextContent);
-  const rawPhaseMetrics = _internals48.extractPhaseMetrics(contextContent);
+  const recentDecisions = _internals49.extractDecisions(contextContent);
+  const rawPhaseMetrics = _internals49.extractPhaseMetrics(contextContent);
   const phaseMetrics = sanitizeString(rawPhaseMetrics, 1000);
   let delegationState = null;
   if (sessionState?.delegationState) {
@@ -82944,13 +83040,13 @@ ${lines.join(`
 `)}
 \`\`\``;
 }
-var RTL_OVERRIDE_PATTERN, MAX_TASK_ID_LENGTH = 100, MAX_DECISION_LENGTH = 500, MAX_INCOMPLETE_TASKS = 20, _internals48;
+var RTL_OVERRIDE_PATTERN, MAX_TASK_ID_LENGTH = 100, MAX_DECISION_LENGTH = 500, MAX_INCOMPLETE_TASKS = 20, _internals49;
 var init_handoff_service = __esm(() => {
   init_utils2();
   init_manager();
   init_utils();
   RTL_OVERRIDE_PATTERN = /[\u202e\u202d\u202c\u200f]/g;
-  _internals48 = {
+  _internals49 = {
     getHandoffData,
     formatHandoffMarkdown,
     formatContinuationPrompt,
@@ -83093,22 +83189,22 @@ async function writeSnapshot(directory, state) {
 }
 function createSnapshotWriterHook(directory) {
   return (_input, _output) => {
-    _writeInFlight = _writeInFlight.then(() => _internals49.writeSnapshot(directory, swarmState), () => _internals49.writeSnapshot(directory, swarmState));
+    _writeInFlight = _writeInFlight.then(() => _internals50.writeSnapshot(directory, swarmState), () => _internals50.writeSnapshot(directory, swarmState));
     return _writeInFlight;
   };
 }
 async function flushPendingSnapshot(directory) {
-  _writeInFlight = _writeInFlight.then(() => _internals49.writeSnapshot(directory, swarmState), () => _internals49.writeSnapshot(directory, swarmState));
+  _writeInFlight = _writeInFlight.then(() => _internals50.writeSnapshot(directory, swarmState), () => _internals50.writeSnapshot(directory, swarmState));
   await _writeInFlight;
 }
-var _writeInFlight, _internals49;
+var _writeInFlight, _internals50;
 var init_snapshot_writer = __esm(() => {
   init_utils2();
   init_state2();
   init_utils();
   init_bun_compat();
   _writeInFlight = Promise.resolve();
-  _internals49 = {
+  _internals50 = {
     writeSnapshot,
     createSnapshotWriterHook,
     flushPendingSnapshot
@@ -83428,7 +83524,7 @@ function validateAndSanitizeGithubUrl(rawUrl, resource) {
 }
 function detectGitRemote(cwd) {
   try {
-    const result = _internals50.spawnSync("git", ["remote", "get-url", "origin"], {
+    const result = _internals51.spawnSync("git", ["remote", "get-url", "origin"], {
       encoding: "utf-8",
       stdio: ["ignore", "pipe", "pipe"],
       timeout: 5000,
@@ -83473,7 +83569,7 @@ function parseGitRemoteUrl(remoteUrl) {
   }
   return null;
 }
-var MAX_URL_LEN = 2048, IPV4_PRIVATE, IPV4_LOOPBACK, IPV4_LINK_LOCAL, IPV4_PRIVATE_172, IPV4_PRIVATE_192, IPV4_ZERO_NETWORK, IPV6_LINK_LOCAL, IPV6_UNIQUE_LOCAL, _internals50;
+var MAX_URL_LEN = 2048, IPV4_PRIVATE, IPV4_LOOPBACK, IPV4_LINK_LOCAL, IPV4_PRIVATE_172, IPV4_PRIVATE_192, IPV4_ZERO_NETWORK, IPV6_LINK_LOCAL, IPV6_UNIQUE_LOCAL, _internals51;
 var init_url_security = __esm(() => {
   IPV4_PRIVATE = /^10\./;
   IPV4_LOOPBACK = /^127\./;
@@ -83483,7 +83579,7 @@ var init_url_security = __esm(() => {
   IPV4_ZERO_NETWORK = /^0\./;
   IPV6_LINK_LOCAL = /^fe80:/i;
   IPV6_UNIQUE_LOCAL = /^f[cd][0-9a-f]{2}:/i;
-  _internals50 = { spawnSync: spawnSync10 };
+  _internals51 = { spawnSync: spawnSync10 };
 });
 
 // src/commands/issue.ts
@@ -83619,7 +83715,7 @@ import * as path76 from "node:path";
 async function migrateKnowledgeToExternal(_directory, _config) {
   const externalSentinelPath = path76.join(_directory, ".swarm", ".knowledge-external-migrated");
   const contextPath = path76.join(_directory, ".swarm", "context.md");
-  if (_internals51.existsSync(externalSentinelPath)) {
+  if (_internals52.existsSync(externalSentinelPath)) {
     return {
       migrated: false,
       entriesMigrated: 0,
@@ -83628,7 +83724,7 @@ async function migrateKnowledgeToExternal(_directory, _config) {
       skippedReason: "external-sentinel-exists"
     };
   }
-  if (!_internals51.existsSync(contextPath)) {
+  if (!_internals52.existsSync(contextPath)) {
     return {
       migrated: false,
       entriesMigrated: 0,
@@ -83637,7 +83733,7 @@ async function migrateKnowledgeToExternal(_directory, _config) {
       skippedReason: "no-context-file"
     };
   }
-  const contextContent = await _internals51.readFile(contextPath, "utf-8");
+  const contextContent = await _internals52.readFile(contextPath, "utf-8");
   if (contextContent.trim().length === 0) {
     return {
       migrated: false,
@@ -83655,7 +83751,7 @@ async function migrateKnowledgeToExternal(_directory, _config) {
       entriesCount++;
     }
   }
-  await _internals51.writeSentinel(externalSentinelPath, entriesCount, entriesCount);
+  await _internals52.writeSentinel(externalSentinelPath, entriesCount, entriesCount);
   return {
     migrated: true,
     entriesMigrated: entriesCount,
@@ -83695,9 +83791,9 @@ async function migrateContextToKnowledge(directory, config3) {
       skippedReason: "empty-context"
     };
   }
-  const rawEntries = _internals51.parseContextMd(contextContent);
+  const rawEntries = _internals52.parseContextMd(contextContent);
   if (rawEntries.length === 0) {
-    await _internals51.writeSentinel(sentinelPath, 0, 0);
+    await _internals52.writeSentinel(sentinelPath, 0, 0);
     return {
       migrated: true,
       entriesMigrated: 0,
@@ -83708,10 +83804,10 @@ async function migrateContextToKnowledge(directory, config3) {
   const existing = await readKnowledge(knowledgePath);
   let migrated = 0;
   let dropped = 0;
-  const projectName = _internals51.inferProjectName(directory);
+  const projectName = _internals52.inferProjectName(directory);
   for (const raw of rawEntries) {
     if (config3.validation_enabled !== false) {
-      const category = raw.categoryHint ?? _internals51.inferCategoryFromText(raw.text);
+      const category = raw.categoryHint ?? _internals52.inferCategoryFromText(raw.text);
       const result = validateLesson(raw.text, existing.map((e) => e.lesson), {
         category,
         scope: "global",
@@ -83731,8 +83827,8 @@ async function migrateContextToKnowledge(directory, config3) {
     const entry = {
       id: randomUUID6(),
       tier: "swarm",
-      lesson: _internals51.truncateLesson(raw.text),
-      category: raw.categoryHint ?? _internals51.inferCategoryFromText(raw.text),
+      lesson: _internals52.truncateLesson(raw.text),
+      category: raw.categoryHint ?? _internals52.inferCategoryFromText(raw.text),
       tags: [...inferredTags, `migration:${raw.sourceSection}`],
       scope: "global",
       confidence: 0.3,
@@ -83755,7 +83851,7 @@ async function migrateContextToKnowledge(directory, config3) {
   if (migrated > 0) {
     await rewriteKnowledge(knowledgePath, existing);
   }
-  await _internals51.writeSentinel(sentinelPath, migrated, dropped);
+  await _internals52.writeSentinel(sentinelPath, migrated, dropped);
   log(`[knowledge-migrator] Migrated ${migrated} entries, dropped ${dropped}`);
   return {
     migrated: true,
@@ -83765,7 +83861,7 @@ async function migrateContextToKnowledge(directory, config3) {
   };
 }
 async function migrateHiveKnowledgeLegacy(config3) {
-  const legacyHivePath = _internals51.resolveLegacyHiveKnowledgePath();
+  const legacyHivePath = _internals52.resolveLegacyHiveKnowledgePath();
   const canonicalHivePath = resolveHiveKnowledgePath();
   const sentinelPath = path76.join(path76.dirname(canonicalHivePath), ".hive-knowledge-migrated");
   if (existsSync44(sentinelPath)) {
@@ -83788,7 +83884,7 @@ async function migrateHiveKnowledgeLegacy(config3) {
   }
   const legacyEntries = await readKnowledge(legacyHivePath);
   if (legacyEntries.length === 0) {
-    await _internals51.writeSentinel(sentinelPath, 0, 0);
+    await _internals52.writeSentinel(sentinelPath, 0, 0);
     return {
       migrated: true,
       entriesMigrated: 0,
@@ -83836,7 +83932,7 @@ async function migrateHiveKnowledgeLegacy(config3) {
       const newHiveEntry = {
         id: resolvedId,
         tier: "hive",
-        lesson: _internals51.truncateLesson(lesson),
+        lesson: _internals52.truncateLesson(lesson),
         category,
         tags: ["migration:legacy-hive"],
         scope: scopeTag,
@@ -83855,7 +83951,7 @@ async function migrateHiveKnowledgeLegacy(config3) {
         encounter_score: 1
       };
       try {
-        await _internals51.appendKnowledge(canonicalHivePath, newHiveEntry);
+        await _internals52.appendKnowledge(canonicalHivePath, newHiveEntry);
         existingHiveEntries.push(newHiveEntry);
         migrated++;
       } catch (appendError) {
@@ -83871,7 +83967,7 @@ async function migrateHiveKnowledgeLegacy(config3) {
       dropped++;
     }
   }
-  await _internals51.writeSentinel(sentinelPath, migrated, dropped);
+  await _internals52.writeSentinel(sentinelPath, migrated, dropped);
   log(`[knowledge-migrator] Migrated ${migrated} legacy hive entries, dropped ${dropped}`);
   return {
     migrated: true,
@@ -83882,7 +83978,7 @@ async function migrateHiveKnowledgeLegacy(config3) {
   };
 }
 function parseContextMd(content) {
-  const sections = _internals51.splitIntoSections(content);
+  const sections = _internals52.splitIntoSections(content);
   const entries = [];
   const seen = new Set;
   const sectionPatterns = [
@@ -83898,7 +83994,7 @@ function parseContextMd(content) {
     const match = sectionPatterns.find((sp) => sp.pattern.test(section.heading));
     if (!match)
       continue;
-    const bullets = _internals51.extractBullets(section.body);
+    const bullets = _internals52.extractBullets(section.body);
     for (const bullet of bullets) {
       if (bullet.length < 15)
         continue;
@@ -83907,9 +84003,9 @@ function parseContextMd(content) {
         continue;
       seen.add(normalized);
       entries.push({
-        text: _internals51.truncateLesson(bullet),
+        text: _internals52.truncateLesson(bullet),
         sourceSection: match.sourceSection,
-        categoryHint: _internals51.inferCategoryFromText(bullet)
+        categoryHint: _internals52.inferCategoryFromText(bullet)
       });
     }
   }
@@ -83999,8 +84095,8 @@ async function writeSentinel(sentinelPath, migrated, dropped) {
     schema_version: 1,
     migration_tool: "knowledge-migrator.ts"
   };
-  await _internals51.mkdir(path76.dirname(sentinelPath), { recursive: true });
-  await _internals51.writeFile(sentinelPath, JSON.stringify(sentinel, null, 2), "utf-8");
+  await _internals52.mkdir(path76.dirname(sentinelPath), { recursive: true });
+  await _internals52.writeFile(sentinelPath, JSON.stringify(sentinel, null, 2), "utf-8");
 }
 function resolveLegacyHiveKnowledgePath() {
   const platform = process.platform;
@@ -84015,12 +84111,12 @@ function resolveLegacyHiveKnowledgePath() {
   }
   return path76.join(dataDir, "hive-knowledge.jsonl");
 }
-var _internals51;
+var _internals52;
 var init_knowledge_migrator = __esm(() => {
   init_logger();
   init_knowledge_store();
   init_knowledge_validator();
-  _internals51 = {
+  _internals52 = {
     appendKnowledge,
     migrateContextToKnowledge,
     migrateKnowledgeToExternal,
@@ -84278,7 +84374,7 @@ function timeoutMessage(timeoutMs) {
 async function computeWithTimeout(directory, currentPhase, timeoutMs) {
   const controller = new AbortController;
   let timeout;
-  const metricsPromise = _internals52.computeLearningMetrics(directory, {
+  const metricsPromise = _internals53.computeLearningMetrics(directory, {
     currentPhase,
     signal: controller.signal
   });
@@ -84335,7 +84431,7 @@ ${JSON.stringify({
     return `Error computing learning metrics: ${message}. Run /swarm diagnose to check .swarm/ health.`;
   }
 }
-var DEFAULT_LEARNING_TIMEOUT_MS = 30000, MAX_LEARNING_TIMEOUT_MS = 300000, LearningMetricsTimeoutError, _internals52;
+var DEFAULT_LEARNING_TIMEOUT_MS = 30000, MAX_LEARNING_TIMEOUT_MS = 300000, LearningMetricsTimeoutError, _internals53;
 var init_learning = __esm(() => {
   init_learning_metrics();
   LearningMetricsTimeoutError = class LearningMetricsTimeoutError extends Error {
@@ -84346,7 +84442,7 @@ var init_learning = __esm(() => {
       this.name = "LearningMetricsTimeoutError";
     }
   };
-  _internals52 = {
+  _internals53 = {
     computeLearningMetrics
   };
 });
@@ -84639,7 +84735,7 @@ ${USAGE7}`;
   }
   let autonomy = parsed.autonomy;
   if (parsed.resume && !parsed.autonomyExplicit) {
-    const state = await _internals53.readLatestLoopState(_directory);
+    const state = await _internals54.readLatestLoopState(_directory);
     if (state?.autonomy && AUTONOMY_LEVELS.has(state.autonomy)) {
       autonomy = state.autonomy;
     }
@@ -84650,7 +84746,7 @@ ${USAGE7}`;
   }
   return `${header} ${objective}`;
 }
-var MAX_OBJECTIVE_LEN = 2000, DEPTHS2, AUTONOMY_LEVELS, DEFAULT_DEPTH2 = "standard", DEFAULT_AUTONOMY = "auto", DEFAULT_MAX_CYCLES = 3, MIN_MAX_CYCLES = 1, MAX_MAX_CYCLES = 5, _internals53, USAGE7 = `Usage: /swarm loop <objective> [--max-cycles 1..5] [--autonomy checkpoint|auto] [--depth standard|exhaustive] [--resume]
+var MAX_OBJECTIVE_LEN = 2000, DEPTHS2, AUTONOMY_LEVELS, DEFAULT_DEPTH2 = "standard", DEFAULT_AUTONOMY = "auto", DEFAULT_MAX_CYCLES = 3, MIN_MAX_CYCLES = 1, MAX_MAX_CYCLES = 5, _internals54, USAGE7 = `Usage: /swarm loop <objective> [--max-cycles 1..5] [--autonomy checkpoint|auto] [--depth standard|exhaustive] [--resume]
 
 Run a compound-engineering loop: brainstorm → plan → build → review → improve,
 iterating until the objective is met or a budget stop condition fires.
@@ -84671,7 +84767,7 @@ Flags:
 var init_loop = __esm(() => {
   DEPTHS2 = new Set(["standard", "exhaustive"]);
   AUTONOMY_LEVELS = new Set(["checkpoint", "auto"]);
-  _internals53 = {
+  _internals54 = {
     readLatestLoopState
   };
 });
@@ -89679,9 +89775,9 @@ var init_memory2 = __esm(() => {
 
 // src/services/plan-service.ts
 async function getPlanData(directory, phaseArg) {
-  const plan = await _internals54.loadPlanJsonOnly(directory);
+  const plan = await _internals55.loadPlanJsonOnly(directory);
   if (plan) {
-    const fullMarkdown = _internals54.derivePlanMarkdown(plan);
+    const fullMarkdown = _internals55.derivePlanMarkdown(plan);
     if (phaseArg === undefined || phaseArg === null || phaseArg === "") {
       return {
         hasPlan: true,
@@ -89724,7 +89820,7 @@ async function getPlanData(directory, phaseArg) {
       isLegacy: false
     };
   }
-  const planContent = await _internals54.readSwarmFileAsync(directory, "plan.md");
+  const planContent = await _internals55.readSwarmFileAsync(directory, "plan.md");
   if (!planContent) {
     return {
       hasPlan: false,
@@ -89820,11 +89916,11 @@ async function handlePlanCommand(directory, args2) {
   const planData = await getPlanData(directory, phaseArg);
   return formatPlanMarkdown(planData);
 }
-var _internals54;
+var _internals55;
 var init_plan_service = __esm(() => {
   init_utils2();
   init_manager();
-  _internals54 = {
+  _internals55 = {
     loadPlanJsonOnly,
     derivePlanMarkdown,
     readSwarmFileAsync
@@ -89845,10 +89941,10 @@ async function handlePostMortemCommand(directory, args2, options) {
     };
     if (options?.sessionID) {
       try {
-        pmOptions.llmDelegate = _internals55.createCuratorLLMDelegate(directory, "postmortem", options.sessionID);
+        pmOptions.llmDelegate = _internals56.createCuratorLLMDelegate(directory, "postmortem", options.sessionID);
       } catch {}
     }
-    const result = await _internals55.runCuratorPostMortem(directory, pmOptions);
+    const result = await _internals56.runCuratorPostMortem(directory, pmOptions);
     const lines = [];
     if (result.success) {
       lines.push("## Post-Mortem Report Generated");
@@ -89879,11 +89975,11 @@ async function handlePostMortemCommand(directory, args2, options) {
     return `Error running post-mortem: ${message}. Run /swarm diagnose to check .swarm/ health.`;
   }
 }
-var _internals55;
+var _internals56;
 var init_post_mortem = __esm(() => {
   init_curator_llm_factory();
   init_curator_postmortem();
-  _internals55 = {
+  _internals56 = {
     createCuratorLLMDelegate,
     runCuratorPostMortem
   };
@@ -90019,7 +90115,7 @@ function formatRelativeTime(epochMs) {
   return `${diffDays} day${diffDays === 1 ? "" : "s"} ago`;
 }
 async function handlePrMonitorStatusCommand(directory, _args, sessionID, source) {
-  const allActive = await _internals56.listActive(directory);
+  const allActive = await _internals57.listActive(directory);
   const allSessions = source === "cli";
   const subs = allSessions ? allActive : allActive.filter((record3) => record3.sessionID === sessionID);
   if (subs.length === 0) {
@@ -90052,10 +90148,10 @@ async function handlePrMonitorStatusCommand(directory, _args, sessionID, source)
   return lines.join(`
 `);
 }
-var _internals56;
+var _internals57;
 var init_pr_monitor_status = __esm(() => {
   init_pr_subscriptions();
-  _internals56 = {
+  _internals57 = {
     formatRelativeTime,
     listActive
   };
@@ -90169,7 +90265,7 @@ async function handlePrSubscribeCommand(directory, args2, sessionID) {
   const repoFullName = `${prInfo.owner}/${prInfo.repo}`;
   const prUrl = `https://github.com/${prInfo.owner}/${prInfo.repo}/pull/${prInfo.number}`;
   try {
-    const config3 = _internals57.loadPluginConfig(directory);
+    const config3 = _internals58.loadPluginConfig(directory);
     const prMonitorConfig = config3.pr_monitor;
     if (!prMonitorConfig?.enabled) {
       return [
@@ -90179,7 +90275,7 @@ async function handlePrSubscribeCommand(directory, args2, sessionID) {
       ].join(`
 `);
     }
-    await _internals57.subscribe(directory, {
+    await _internals58.subscribe(directory, {
       sessionID,
       prNumber: prInfo.number,
       repoFullName,
@@ -90203,12 +90299,12 @@ async function handlePrSubscribeCommand(directory, args2, sessionID) {
 `);
   }
 }
-var _internals57;
+var _internals58;
 var init_pr_subscribe = __esm(() => {
   init_pr_subscriptions();
   init_loader();
   init_pr_ref();
-  _internals57 = {
+  _internals58 = {
     loadPluginConfig,
     subscribe
   };
@@ -90232,9 +90328,9 @@ async function handlePrUnsubscribeCommand(directory, args2, sessionID) {
 `);
   }
   const refToken = rest[0];
-  const prInfo = _internals58.parsePrRef(refToken, directory);
+  const prInfo = _internals59.parsePrRef(refToken, directory);
   if (!prInfo) {
-    if (_internals58.looksLikePrRef(refToken)) {
+    if (_internals59.looksLikePrRef(refToken)) {
       return [
         `Error: Could not resolve PR reference from "${refToken}".`,
         "",
@@ -90255,8 +90351,8 @@ async function handlePrUnsubscribeCommand(directory, args2, sessionID) {
   const repoFullName = `${prInfo.owner}/${prInfo.repo}`;
   const prUrl = `https://github.com/${prInfo.owner}/${prInfo.repo}/pull/${prInfo.number}`;
   try {
-    const correlationId = _internals58.buildCorrelationId(sessionID, repoFullName, prInfo.number);
-    const result = await _internals58.unsubscribe(directory, correlationId);
+    const correlationId = _internals59.buildCorrelationId(sessionID, repoFullName, prInfo.number);
+    const result = await _internals59.unsubscribe(directory, correlationId);
     if (!result) {
       return [
         `Not subscribed to ${prUrl}`,
@@ -90283,11 +90379,11 @@ async function handlePrUnsubscribeCommand(directory, args2, sessionID) {
 `);
   }
 }
-var _internals58;
+var _internals59;
 var init_pr_unsubscribe = __esm(() => {
   init_pr_subscriptions();
   init_pr_ref();
-  _internals58 = {
+  _internals59 = {
     unsubscribe,
     buildCorrelationId,
     parsePrRef,
@@ -90743,7 +90839,7 @@ async function runAdditionalLint(linter, mode, cwd) {
     };
   }
 }
-var MAX_OUTPUT_BYTES = 512000, MAX_COMMAND_LENGTH = 500, lint, _internals59;
+var MAX_OUTPUT_BYTES = 512000, MAX_COMMAND_LENGTH = 500, lint, _internals60;
 var init_lint = __esm(() => {
   init_zod();
   init_discovery();
@@ -90775,15 +90871,15 @@ var init_lint = __esm(() => {
       }
       const { mode } = args2;
       const cwd = directory;
-      const linter = await _internals59.detectAvailableLinter(directory);
+      const linter = await _internals60.detectAvailableLinter(directory);
       if (linter) {
-        const result = await _internals59.runLint(linter, mode, directory);
+        const result = await _internals60.runLint(linter, mode, directory);
         return JSON.stringify(result, null, 2);
       }
-      const additionalLinter = _internals59.detectAdditionalLinter(cwd);
+      const additionalLinter = _internals60.detectAdditionalLinter(cwd);
       if (additionalLinter) {
         warn(`[lint] Using ${additionalLinter} linter for this project`);
-        const result = await _internals59.runAdditionalLint(additionalLinter, mode, cwd);
+        const result = await _internals60.runAdditionalLint(additionalLinter, mode, cwd);
         return JSON.stringify(result, null, 2);
       }
       const errorResult = {
@@ -90797,7 +90893,7 @@ For Rust: rustup component add clippy`
       return JSON.stringify(errorResult, null, 2);
     }
   });
-  _internals59 = {
+  _internals60 = {
     detectAvailableLinter,
     runLint,
     detectAdditionalLinter,
@@ -91111,7 +91207,7 @@ function findScannableFiles(dir, excludeExact, excludeGlobs, scanDir, visited, s
 }
 async function runSecretscan(directory) {
   try {
-    const result = await _internals60.secretscan.execute({ directory }, {});
+    const result = await _internals61.secretscan.execute({ directory }, {});
     const jsonStr = typeof result === "string" ? result : result.output;
     return JSON.parse(jsonStr);
   } catch (e) {
@@ -91126,7 +91222,7 @@ async function runSecretscan(directory) {
     return errorResult;
   }
 }
-var MAX_FILE_PATH_LENGTH = 500, MAX_FILE_SIZE_BYTES, MAX_FILES_SCANNED = 1000, MAX_FINDINGS = 100, MAX_OUTPUT_BYTES2 = 512000, MAX_LINE_LENGTH = 1e4, MAX_CONTENT_BYTES, BINARY_SIGNATURES, BINARY_PREFIX_BYTES = 4, BINARY_NULL_CHECK_BYTES = 8192, BINARY_NULL_THRESHOLD = 0.1, DEFAULT_EXCLUDE_DIRS, DEFAULT_EXCLUDE_EXTENSIONS, SECRET_PATTERNS2, O_NOFOLLOW, secretscan, _internals60;
+var MAX_FILE_PATH_LENGTH = 500, MAX_FILE_SIZE_BYTES, MAX_FILES_SCANNED = 1000, MAX_FINDINGS = 100, MAX_OUTPUT_BYTES2 = 512000, MAX_LINE_LENGTH = 1e4, MAX_CONTENT_BYTES, BINARY_SIGNATURES, BINARY_PREFIX_BYTES = 4, BINARY_NULL_CHECK_BYTES = 8192, BINARY_NULL_THRESHOLD = 0.1, DEFAULT_EXCLUDE_DIRS, DEFAULT_EXCLUDE_EXTENSIONS, SECRET_PATTERNS2, O_NOFOLLOW, secretscan, _internals61;
 var init_secretscan = __esm(() => {
   init_zod();
   init_path_security();
@@ -91498,7 +91594,7 @@ var init_secretscan = __esm(() => {
       }
     }
   });
-  _internals60 = {
+  _internals61 = {
     secretscan,
     runSecretscan
   };
@@ -92090,14 +92186,14 @@ function buildGoBackend() {
     selectEntryPoints
   };
 }
-var PROFILE_ID = "go", IMPORT_REGEX_SINGLE, IMPORT_REGEX_GROUP, IMPORT_REGEX_GROUP_LINE, _internals61;
+var PROFILE_ID = "go", IMPORT_REGEX_SINGLE, IMPORT_REGEX_GROUP, IMPORT_REGEX_GROUP_LINE, _internals62;
 var init_go = __esm(() => {
   init_default_backend();
   init_profiles();
   IMPORT_REGEX_SINGLE = /^\s*import\s+(?:[a-zA-Z_.][a-zA-Z0-9_]*\s+)?"([^"]+)"/gm;
   IMPORT_REGEX_GROUP = /^\s*import\s*\(([\s\S]*?)\)/gm;
   IMPORT_REGEX_GROUP_LINE = /(?:[a-zA-Z_.][a-zA-Z0-9_]*\s+)?"([^"]+)"/g;
-  _internals61 = { extractImports };
+  _internals62 = { extractImports };
 });
 
 // src/lang/backends/python.ts
@@ -92209,13 +92305,13 @@ function buildPythonBackend() {
     selectEntryPoints: selectEntryPoints2
   };
 }
-var PROFILE_ID2 = "python", IMPORT_REGEX_FROM_WITH_TARGETS, IMPORT_REGEX_IMPORT, _internals62;
+var PROFILE_ID2 = "python", IMPORT_REGEX_FROM_WITH_TARGETS, IMPORT_REGEX_IMPORT, _internals63;
 var init_python = __esm(() => {
   init_default_backend();
   init_profiles();
   IMPORT_REGEX_FROM_WITH_TARGETS = /^\s*from\s+(\.*[\w.]*)\s+import\s+(\([^)]*\)|[^\n#]+)/gm;
   IMPORT_REGEX_IMPORT = /^\s*import\s+([^\n#]+)/gm;
-  _internals62 = { extractImports: extractImports2 };
+  _internals63 = { extractImports: extractImports2 };
 });
 
 // src/test-impact/analyzer.ts
@@ -92439,7 +92535,7 @@ function addImpactEdgesForTestFile(testFile, content, impactMap) {
     return;
   }
   if (PYTHON_EXTENSIONS.has(ext)) {
-    const modules = _internals62.extractImports(testFile, content);
+    const modules = _internals63.extractImports(testFile, content);
     for (const mod of modules) {
       const resolved = resolvePythonImport(testDir, mod);
       if (resolved !== null)
@@ -92448,7 +92544,7 @@ function addImpactEdgesForTestFile(testFile, content, impactMap) {
     return;
   }
   if (GO_EXTENSIONS.has(ext)) {
-    const imports = _internals61.extractImports(testFile, content);
+    const imports = _internals62.extractImports(testFile, content);
     for (const importPath of imports) {
       const sourceFiles = resolveGoImport(testDir, importPath);
       for (const source of sourceFiles)
@@ -92475,8 +92571,8 @@ async function buildImpactMapInternal(cwd) {
   return impactMap;
 }
 async function buildImpactMap(cwd) {
-  const impactMap = await _internals63.buildImpactMapInternal(cwd);
-  await _internals63.saveImpactMap(cwd, impactMap);
+  const impactMap = await _internals64.buildImpactMapInternal(cwd);
+  await _internals64.saveImpactMap(cwd, impactMap);
   return impactMap;
 }
 async function loadImpactMap(cwd, options) {
@@ -92490,7 +92586,7 @@ async function loadImpactMap(cwd, options) {
         const hasValidValues = Object.values(map3).every((v) => Array.isArray(v) && v.every((item) => typeof item === "string"));
         if (hasValidValues) {
           const generatedAt = new Date(data.generatedAt).getTime();
-          if (!_internals63.isCacheStale(map3, generatedAt)) {
+          if (!_internals64.isCacheStale(map3, generatedAt)) {
             return map3;
           }
           if (options?.skipRebuild) {
@@ -92510,13 +92606,13 @@ async function loadImpactMap(cwd, options) {
   if (options?.skipRebuild) {
     return {};
   }
-  return _internals63.buildImpactMap(cwd);
+  return _internals64.buildImpactMap(cwd);
 }
 async function saveImpactMap(cwd, impactMap) {
   if (!path94.isAbsolute(cwd)) {
     throw new Error(`saveImpactMap requires an absolute project root path, got: "${cwd}"`);
   }
-  _internals63.validateProjectRoot(cwd);
+  _internals64.validateProjectRoot(cwd);
   const cacheDir2 = path94.join(cwd, ".swarm", "cache");
   const cachePath = path94.join(cacheDir2, "impact-map.json");
   if (!fs45.existsSync(cacheDir2)) {
@@ -92540,7 +92636,7 @@ async function analyzeImpact(changedFiles, cwd, budget) {
     };
   }
   const validFiles = changedFiles.filter((f) => typeof f === "string" && f.length > 0 && !f.includes("\x00"));
-  const impactMap = await _internals63.loadImpactMap(cwd);
+  const impactMap = await _internals64.loadImpactMap(cwd);
   const impactedTestsSet = new Set;
   const untestedFiles = [];
   let visitedCount = 0;
@@ -92625,7 +92721,7 @@ async function analyzeImpact(changedFiles, cwd, budget) {
     budgetExceeded
   };
 }
-var IMPORT_REGEX_ES, IMPORT_REGEX_REQUIRE, IMPORT_REGEX_REEXPORT, TS_EXTENSIONS, PYTHON_EXTENSIONS, GO_EXTENSIONS, EXTENSIONS_TO_TRY, goModuleCache, _internals63;
+var IMPORT_REGEX_ES, IMPORT_REGEX_REQUIRE, IMPORT_REGEX_REEXPORT, TS_EXTENSIONS, PYTHON_EXTENSIONS, GO_EXTENSIONS, EXTENSIONS_TO_TRY, goModuleCache, _internals64;
 var init_analyzer = __esm(() => {
   init_manager2();
   init_go();
@@ -92638,7 +92734,7 @@ var init_analyzer = __esm(() => {
   GO_EXTENSIONS = new Set([".go"]);
   EXTENSIONS_TO_TRY = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"];
   goModuleCache = new Map;
-  _internals63 = {
+  _internals64 = {
     validateProjectRoot,
     normalizePath: normalizePath2,
     isCacheStale,
@@ -93021,7 +93117,7 @@ function batchAppendTestRuns(records, workingDir) {
   }
   const historyPath = getHistoryPath(workingDir);
   const historyDir = path95.dirname(historyPath);
-  _internals64.validateProjectRoot(workingDir);
+  _internals65.validateProjectRoot(workingDir);
   if (!fs46.existsSync(historyDir)) {
     fs46.mkdirSync(historyDir, { recursive: true });
   }
@@ -93144,7 +93240,7 @@ function getAllHistory(workingDir) {
   records.sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
   return records;
 }
-var MAX_HISTORY_PER_TEST = 20, MAX_ERROR_LENGTH = 500, MAX_STACK_LENGTH = 200, MAX_CHANGED_FILES = 50, HISTORY_WRITE_LOCK_TIMEOUT_MS = 5000, HISTORY_WRITE_LOCK_STALE_MS = 60000, HISTORY_WRITE_LOCK_BACKOFF_MS = 10, DANGEROUS_PROPERTY_NAMES, _internals64;
+var MAX_HISTORY_PER_TEST = 20, MAX_ERROR_LENGTH = 500, MAX_STACK_LENGTH = 200, MAX_CHANGED_FILES = 50, HISTORY_WRITE_LOCK_TIMEOUT_MS = 5000, HISTORY_WRITE_LOCK_STALE_MS = 60000, HISTORY_WRITE_LOCK_BACKOFF_MS = 10, DANGEROUS_PROPERTY_NAMES, _internals65;
 var init_history_store = __esm(() => {
   init_manager2();
   DANGEROUS_PROPERTY_NAMES = new Set([
@@ -93152,7 +93248,7 @@ var init_history_store = __esm(() => {
     "constructor",
     "prototype"
   ]);
-  _internals64 = {
+  _internals65 = {
     validateProjectRoot
   };
 });
@@ -93191,7 +93287,7 @@ function resolveWorkingDirectory(workingDirectory, fallbackDirectory) {
       };
     }
   }
-  const rawPathParts = workingDirectory.split(path96.sep);
+  const rawPathParts = workingDirectory.split(/[\\/]/);
   if (rawPathParts.includes("..")) {
     return {
       success: false,
@@ -93402,7 +93498,7 @@ function readPackageJsonRaw(dir) {
   }
 }
 function readPackageJson(dir) {
-  return _internals65.readPackageJsonRaw(dir);
+  return _internals66.readPackageJsonRaw(dir);
 }
 function readPackageJsonTestScript(dir) {
   return readPackageJson(dir)?.scripts?.test ?? null;
@@ -93572,7 +93668,7 @@ function buildTypescriptBackend() {
     selectEntryPoints: selectEntryPoints3
   };
 }
-var PROFILE_ID4 = "typescript", IMPORT_REGEX_ES2, IMPORT_REGEX_BARE, IMPORT_REGEX_REQUIRE2, IMPORT_REGEX_DYNAMIC, IMPORT_REGEX_REEXPORT2, _internals65;
+var PROFILE_ID4 = "typescript", IMPORT_REGEX_ES2, IMPORT_REGEX_BARE, IMPORT_REGEX_REQUIRE2, IMPORT_REGEX_DYNAMIC, IMPORT_REGEX_REEXPORT2, _internals66;
 var init_typescript = __esm(() => {
   init_default_backend();
   init_profiles();
@@ -93581,7 +93677,7 @@ var init_typescript = __esm(() => {
   IMPORT_REGEX_REQUIRE2 = /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
   IMPORT_REGEX_DYNAMIC = /import\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
   IMPORT_REGEX_REEXPORT2 = /export\s+(?:\{[^}]*\}|\*)\s+from\s+['"]([^'"]+)['"]/g;
-  _internals65 = {
+  _internals66 = {
     readPackageJsonRaw,
     readPackageJsonTestScript,
     frameworkFromScriptsTest
@@ -93614,7 +93710,7 @@ __export(exports_dispatch, {
   pickedProfiles: () => pickedProfiles,
   pickBackend: () => pickBackend,
   clearDispatchCache: () => clearDispatchCache,
-  _internals: () => _internals66
+  _internals: () => _internals67
 });
 import * as fs50 from "node:fs";
 import * as path99 from "node:path";
@@ -93669,7 +93765,7 @@ function findManifestRoot(start) {
   return start;
 }
 function evictIfNeeded() {
-  if (cache2.size <= _internals66.cacheCapacity)
+  if (cache2.size <= _internals67.cacheCapacity)
     return;
   let oldestKey;
   let oldestOrder = Infinity;
@@ -93700,7 +93796,7 @@ async function pickBackend(dir) {
     evictIfNeeded();
     return null;
   }
-  const profiles = await _internals66.detectProjectLanguages(root);
+  const profiles = await _internals67.detectProjectLanguages(root);
   if (profiles.length === 0) {
     cache2.set(cacheKey, {
       hash: hash4,
@@ -93732,12 +93828,12 @@ function clearDispatchCache() {
   manifestRootCache.clear();
   insertCounter = 0;
 }
-var _internals66, cache2, insertCounter = 0, MANIFEST_FILES, _MANIFEST_SET, manifestRootCache;
+var _internals67, cache2, insertCounter = 0, MANIFEST_FILES, _MANIFEST_SET, manifestRootCache;
 var init_dispatch = __esm(() => {
   init_backends();
   init_detector();
   init_registry_backend();
-  _internals66 = {
+  _internals67 = {
     detectProjectLanguages,
     cacheCapacity: 64
   };
@@ -95593,9 +95689,9 @@ function getVersionFileVersion(dir) {
 async function runVersionCheck2(dir, _timeoutMs) {
   const startTime = Date.now();
   try {
-    const packageVersion = _internals67.getPackageVersion(dir);
-    const changelogVersion = _internals67.getChangelogVersion(dir);
-    const versionFileVersion = _internals67.getVersionFileVersion(dir);
+    const packageVersion = _internals68.getPackageVersion(dir);
+    const changelogVersion = _internals68.getChangelogVersion(dir);
+    const versionFileVersion = _internals68.getVersionFileVersion(dir);
     const versions3 = [];
     if (packageVersion)
       versions3.push(`package.json: ${packageVersion}`);
@@ -95959,7 +96055,7 @@ async function runPreflight(dir, phase, config3) {
   const reportId = `preflight-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
   let validatedDir;
   try {
-    validatedDir = _internals67.validateDirectoryPath(dir);
+    validatedDir = _internals68.validateDirectoryPath(dir);
   } catch (error93) {
     return {
       id: reportId,
@@ -95979,7 +96075,7 @@ async function runPreflight(dir, phase, config3) {
   }
   let validatedTimeout;
   try {
-    validatedTimeout = _internals67.validateTimeout(config3?.checkTimeoutMs, DEFAULT_CONFIG.checkTimeoutMs);
+    validatedTimeout = _internals68.validateTimeout(config3?.checkTimeoutMs, DEFAULT_CONFIG.checkTimeoutMs);
   } catch (error93) {
     return {
       id: reportId,
@@ -96020,12 +96116,12 @@ async function runPreflight(dir, phase, config3) {
   });
   const checks5 = [];
   log("[Preflight] Running lint check...");
-  const lintResult = await _internals67.runLintCheck(validatedDir, cfg.linter, cfg.checkTimeoutMs);
+  const lintResult = await _internals68.runLintCheck(validatedDir, cfg.linter, cfg.checkTimeoutMs);
   checks5.push(lintResult);
   log(`[Preflight] Lint check: ${lintResult.status} ${lintResult.message}`);
   if (!cfg.skipTests) {
     log("[Preflight] Running tests check...");
-    const testsResult = await _internals67.runTestsCheck(validatedDir, cfg.testScope, cfg.checkTimeoutMs);
+    const testsResult = await _internals68.runTestsCheck(validatedDir, cfg.testScope, cfg.checkTimeoutMs);
     checks5.push(testsResult);
     log(`[Preflight] Tests check: ${testsResult.status} ${testsResult.message}`);
   } else {
@@ -96037,7 +96133,7 @@ async function runPreflight(dir, phase, config3) {
   }
   if (!cfg.skipSecrets) {
     log("[Preflight] Running secrets check...");
-    const secretsResult = await _internals67.runSecretsCheck(validatedDir, cfg.checkTimeoutMs);
+    const secretsResult = await _internals68.runSecretsCheck(validatedDir, cfg.checkTimeoutMs);
     checks5.push(secretsResult);
     log(`[Preflight] Secrets check: ${secretsResult.status} ${secretsResult.message}`);
   } else {
@@ -96049,7 +96145,7 @@ async function runPreflight(dir, phase, config3) {
   }
   if (!cfg.skipEvidence) {
     log("[Preflight] Running evidence check...");
-    const evidenceResult = await _internals67.runEvidenceCheck(validatedDir);
+    const evidenceResult = await _internals68.runEvidenceCheck(validatedDir);
     checks5.push(evidenceResult);
     log(`[Preflight] Evidence check: ${evidenceResult.status} ${evidenceResult.message}`);
   } else {
@@ -96060,12 +96156,12 @@ async function runPreflight(dir, phase, config3) {
     });
   }
   log("[Preflight] Running requirement coverage check...");
-  const reqCoverageResult = await _internals67.runRequirementCoverageCheck(validatedDir, phase);
+  const reqCoverageResult = await _internals68.runRequirementCoverageCheck(validatedDir, phase);
   checks5.push(reqCoverageResult);
   log(`[Preflight] Requirement coverage check: ${reqCoverageResult.status} ${reqCoverageResult.message}`);
   if (!cfg.skipVersion) {
     log("[Preflight] Running version check...");
-    const versionResult = await _internals67.runVersionCheck(validatedDir, cfg.checkTimeoutMs);
+    const versionResult = await _internals68.runVersionCheck(validatedDir, cfg.checkTimeoutMs);
     checks5.push(versionResult);
     log(`[Preflight] Version check: ${versionResult.status} ${versionResult.message}`);
   } else {
@@ -96128,10 +96224,10 @@ function formatPreflightMarkdown(report) {
 async function handlePreflightCommand(directory, _args) {
   const plan = await loadPlan(directory);
   const phase = plan?.current_phase ?? 1;
-  const report = await _internals67.runPreflight(directory, phase);
-  return _internals67.formatPreflightMarkdown(report);
+  const report = await _internals68.runPreflight(directory, phase);
+  return _internals68.formatPreflightMarkdown(report);
 }
-var MIN_CHECK_TIMEOUT_MS = 5000, MAX_CHECK_TIMEOUT_MS = 300000, DEFAULT_CONFIG, _internals67;
+var MIN_CHECK_TIMEOUT_MS = 5000, MAX_CHECK_TIMEOUT_MS = 300000, DEFAULT_CONFIG, _internals68;
 var init_preflight_service = __esm(() => {
   init_gate_bridge();
   init_manager2();
@@ -96150,7 +96246,7 @@ var init_preflight_service = __esm(() => {
     testScope: "convention",
     linter: "biome"
   };
-  _internals67 = {
+  _internals68 = {
     runPreflight,
     formatPreflightMarkdown,
     handlePreflightCommand,
@@ -97977,7 +98073,7 @@ function resetPrmSessionState(session, sessionId) {
   session.prmTrajectoryStep = 0;
   session.replayArtifactPath = null;
   if (sessionId) {
-    _internals68.clearTrajectoryCache(sessionId);
+    _internals69.clearTrajectoryCache(sessionId);
   }
 }
 function createPrmHook(config3, directory) {
@@ -97986,26 +98082,26 @@ function createPrmHook(config3, directory) {
       return;
     }
     const { sessionID } = context;
-    const session = _internals68.getAgentSession(sessionID);
+    const session = _internals69.getAgentSession(sessionID);
     if (!session || !session.delegationActive) {
       return;
     }
     try {
-      const cachedTrajectory = _internals68.getInMemoryTrajectory(sessionID);
-      const trajectory = cachedTrajectory.length > 0 ? cachedTrajectory : await _internals68.readTrajectory(sessionID, directory);
-      const detectionResult = _internals68.detectPatterns(trajectory, config3, session.prmTrajectoryStep);
+      const cachedTrajectory = _internals69.getInMemoryTrajectory(sessionID);
+      const trajectory = cachedTrajectory.length > 0 ? cachedTrajectory : await _internals69.readTrajectory(sessionID, directory);
+      const detectionResult = _internals69.detectPatterns(trajectory, config3, session.prmTrajectoryStep);
       if (detectionResult.matches.length === 0) {
         return;
       }
       const sessionPrmState = session;
       let escalationTracker = sessionPrmState.prmEscalationTracker;
       if (!sessionPrmState.replayArtifactPath) {
-        sessionPrmState.replayArtifactPath = await _internals68.startReplayRecording(sessionID, directory);
+        sessionPrmState.replayArtifactPath = await _internals69.startReplayRecording(sessionID, directory);
       }
       const artifactPath = sessionPrmState.replayArtifactPath;
       if (!sessionPrmState.prmInitialized) {
         sessionPrmState.prmInitialized = true;
-        _internals68.cleanupOldTrajectoryFiles(directory).catch(() => {});
+        _internals69.cleanupOldTrajectoryFiles(directory).catch(() => {});
       }
       if (!escalationTracker) {
         const initialState = session.prmLastPatternDetected ? {
@@ -98020,8 +98116,8 @@ function createPrmHook(config3, directory) {
       }
       const previousEscalationLevel = session.prmEscalationLevel;
       for (const match of detectionResult.matches) {
-        const correction = _internals68.generateCourseCorrection(match, trajectory);
-        const formattedCorrection = _internals68.formatCourseCorrectionForInjection(correction);
+        const correction = _internals69.generateCourseCorrection(match, trajectory);
+        const formattedCorrection = _internals69.formatCourseCorrectionForInjection(correction);
         if (!session.pendingAdvisoryMessages) {
           session.pendingAdvisoryMessages = [];
         }
@@ -98037,10 +98133,10 @@ function createPrmHook(config3, directory) {
         session.prmEscalationLevel = escalationLevel;
         session.prmLastPatternDetected = match;
         session.prmHardStopPending = hardStopPending;
-        _internals68.telemetry.prmPatternDetected(sessionID, match.pattern, match.severity, match.category, match.stepRange);
-        _internals68.telemetry.prmCourseCorrectionInjected(sessionID, match.pattern, escalationLevel);
+        _internals69.telemetry.prmPatternDetected(sessionID, match.pattern, match.severity, match.category, match.stepRange);
+        _internals69.telemetry.prmCourseCorrectionInjected(sessionID, match.pattern, escalationLevel);
         if (artifactPath) {
-          await _internals68.recordReplayEntry(artifactPath, sessionID, {
+          await _internals69.recordReplayEntry(artifactPath, sessionID, {
             type: "pattern_detected",
             data: {
               pattern: match.pattern,
@@ -98055,7 +98151,7 @@ function createPrmHook(config3, directory) {
           });
         }
         if (artifactPath) {
-          await _internals68.recordReplayEntry(artifactPath, sessionID, {
+          await _internals69.recordReplayEntry(artifactPath, sessionID, {
             type: "course_correction",
             data: {
               pattern: correction.pattern,
@@ -98071,7 +98167,7 @@ function createPrmHook(config3, directory) {
       }
       escalationTracker.clearPendingCorrections();
       if (artifactPath && session.prmEscalationLevel > previousEscalationLevel) {
-        await _internals68.recordReplayEntry(artifactPath, sessionID, {
+        await _internals69.recordReplayEntry(artifactPath, sessionID, {
           type: "escalation",
           data: {
             previousLevel: previousEscalationLevel,
@@ -98081,7 +98177,7 @@ function createPrmHook(config3, directory) {
         });
       }
       if (artifactPath && session.prmHardStopPending && previousEscalationLevel < 3) {
-        await _internals68.recordReplayEntry(artifactPath, sessionID, {
+        await _internals69.recordReplayEntry(artifactPath, sessionID, {
           type: "hard_stop",
           data: {
             escalationLevel: session.prmEscalationLevel,
@@ -98098,7 +98194,7 @@ function createPrmHook(config3, directory) {
   }
   return { toolAfter };
 }
-var _internals68;
+var _internals69;
 var init_prm = __esm(() => {
   init_course_correction();
   init_escalation();
@@ -98110,7 +98206,7 @@ var init_prm = __esm(() => {
   init_pattern_detector();
   init_replay();
   init_trajectory_store();
-  _internals68 = {
+  _internals69 = {
     getAgentSession,
     readTrajectory,
     getInMemoryTrajectory,
@@ -99273,7 +99369,7 @@ async function getStatusData(directory, agents) {
 }
 function enrichWithLeanTurbo(status, directory) {
   const turboMode = hasActiveTurboMode();
-  const leanActive = _internals69.hasActiveLeanTurbo();
+  const leanActive = _internals70.hasActiveLeanTurbo();
   let turboStrategy = "off";
   if (leanActive) {
     turboStrategy = "lean";
@@ -99292,7 +99388,7 @@ function enrichWithLeanTurbo(status, directory) {
     }
   }
   if (leanSessionID) {
-    const runState = _internals69.loadLeanTurboRunState(directory, leanSessionID);
+    const runState = _internals70.loadLeanTurboRunState(directory, leanSessionID);
     if (runState) {
       status.leanTurboPhase = runState.phase;
       status.leanMaxParallelCoders = runState.maxParallelCoders;
@@ -99324,7 +99420,7 @@ function enrichWithLeanTurbo(status, directory) {
       }
     }
   }
-  status.fullAutoActive = _internals69.hasActiveFullAuto();
+  status.fullAutoActive = _internals70.hasActiveFullAuto();
   return status;
 }
 function formatStatusMarkdown(status) {
@@ -99452,7 +99548,7 @@ async function countProposals(directory) {
     return 0;
   }
 }
-var _internals69;
+var _internals70;
 var init_status_service = __esm(() => {
   init_extractors();
   init_knowledge_escalator();
@@ -99463,7 +99559,7 @@ var init_status_service = __esm(() => {
   init_state4();
   init_compaction_service();
   init_context_budget_service();
-  _internals69 = {
+  _internals70 = {
     loadLeanTurboRunState,
     hasActiveLeanTurbo,
     hasActiveFullAuto
@@ -99560,7 +99656,7 @@ async function handleTurboCommand(directory, args2, sessionID) {
   if (arg0 === "on") {
     let strategy = "standard";
     try {
-      const { config: config3 } = _internals70.loadPluginConfigWithMeta(directory);
+      const { config: config3 } = _internals71.loadPluginConfigWithMeta(directory);
       if (config3.turbo?.strategy === "lean") {
         strategy = "lean";
       }
@@ -99657,7 +99753,7 @@ function enableLeanTurbo(session, directory, sessionID) {
   let maxParallelCoders = 4;
   let conflictPolicy = "serialize";
   try {
-    const { config: config3 } = _internals70.loadPluginConfigWithMeta(directory);
+    const { config: config3 } = _internals71.loadPluginConfigWithMeta(directory);
     const leanConfig = config3.turbo?.lean;
     if (leanConfig) {
       maxParallelCoders = leanConfig.max_parallel_coders ?? 4;
@@ -99727,14 +99823,14 @@ function buildStatusMessage2(session, directory, sessionID) {
   ].join(`
 `);
 }
-var _internals70;
+var _internals71;
 var init_turbo = __esm(() => {
   init_config();
   init_state2();
   init_state();
   init_state4();
   init_logger();
-  _internals70 = {
+  _internals71 = {
     loadPluginConfigWithMeta
   };
 });
@@ -101625,7 +101721,7 @@ Subcommands:
       handler: (ctx) => handleModeCommandWithBundledSkills(ctx, handlePrReviewCommand),
       description: "Launch deep PR review with multi-lane analysis [url] [--council]",
       args: "<pr-url|owner/repo#N|N> [--council]",
-      details: "Launches a structured PR review: reconstructs PR intent via obligation extraction cascade, runs 6 parallel explorer lanes through the deterministic dispatch_lanes join barrier (correctness, security, dependencies, docs-intent-vs-actual, tests, performance-architecture), validates findings through independent reviewer confirmation, applies critic challenge to HIGH/CRITICAL findings, synthesizes structured report. --council variant fires adversarial multi-model review. Supports full GitHub URL, owner/repo#N shorthand, or bare PR number (resolves against origin remote).",
+      details: "Launches a structured PR review: reconstructs PR intent via obligation extraction cascade, launches all 6 fixed base explorer lanes through dispatch_lanes_async while the architect keeps doing non-dependent work, polls collect_lane_results incrementally, runs every triggered micro-lane, validates findings through independent reviewer confirmation, applies critic challenge to HIGH/CRITICAL findings, then synthesizes only after coverage is closed. If lane tools cannot close coverage, Task-tool dispatch is the final verified-equivalent fallback; if equivalence cannot be proven, the review is BLOCKED rather than degraded. --council variant fires adversarial multi-model review. Supports full GitHub URL, owner/repo#N shorthand, or bare PR number (resolves against origin remote).",
       category: "agent",
       toolPolicy: "none"
     },
@@ -102658,6 +102754,8 @@ If a tool modifies a file, it is a CODER tool. Delegate.
 2. ONE agent per message. Send, STOP, wait for response.
    Exception: Stage B reviewer/test_engineer gate agents for the SAME completed coder task may be dispatched together before waiting when both gates are required. This exception NEVER applies to coder delegations. Preserve ONE task per coder call.
    Separate parallel-mode exception (distinct from the Stage B exception above, and the ONLY case where more than one coder may be dispatched before waiting): when an active \`[PARALLEL EXECUTION PROFILE]\` directive is present in your context (parallelization_enabled=true), you MAY dispatch multiple {{AGENT_PREFIX}}coder agents in a single message — up to the stated max_concurrent_tasks — but ONLY for distinct, dependency-ready tasks whose declared file scopes do NOT overlap. Each coder still requires its own \`declare_scope\` call and carries exactly ONE task (Rule 3 still holds: never batch multiple objectives into one coder). Parallel coders each run in an isolated git worktree, so their writes never collide and are merged back automatically. If no \`[PARALLEL EXECUTION PROFILE]\` directive is present, dispatch coders one at a time.
+
+    > **WORKTREE ISOLATION IS BASELINE.** Standard parallel coders use isolated git worktrees by default; this is governed by the top-level \`worktree.policy\` setting (default \`auto\`) in \`PluginConfig\` — a sibling of \`parallelization:\`, not nested under it — and is active whenever the plan's \`parallelization_enabled=true\`. \`turbo.lean.worktree_isolation\` is a separate, Lean-Turbo-internal flag (default \`false\`); it is one possible SOURCE but NOT the recommended one. Do NOT recommend Lean Turbo (or Epic) SOLELY to obtain worktree isolation; recommend them only for what they add beyond baseline (Lean Turbo: lane planning, file locks, phase reviewer, integrated diff; Epic: co-change awareness + auto-decide). Lean Turbo users can also enable isolation via \`turbo.lean.worktree_isolation: true\`, but this is the secondary/legacy path — the recommended path is \`worktree.policy\`.
    Read-only advisory-lane exception (NON-BLOCKING; distinct from both exceptions above): the "Send, STOP, wait" rule governs MUTATION delegations (coder, and the test_engineer/reviewer Stage B completion gates). It does NOT govern read-only advisory exploration/review lanes. When you dispatch read-only advisory lanes — \`{{AGENT_PREFIX}}explorer\`, \`{{AGENT_PREFIX}}sme\`, \`{{AGENT_PREFIX}}researcher\`, the council members (\`council_generalist\`/\`council_skeptic\`/\`council_domain_expert\`), or an advisory \`{{AGENT_PREFIX}}critic\` lane — use the NON-BLOCKING path so you keep working while they run. Dispatch PROMPTLY: emit the \`dispatch_lanes_async\` call EARLY with compact lane prompts — do not accumulate long planning prose or build oversized inline prompts first, or the tool call can be truncated out of your message and the lanes never launch (a real failure mode on smaller models). The lane mechanism is a SINGLE \`dispatch_lanes_async\` call carrying all lane specs — NOT a per-agent Task/run-in-background pattern. Call \`dispatch_lanes_async\` with all lane specs in one call, record the returned \`batch_id\`, then IMMEDIATELY continue non-dependent architect work (refine the plan/obligation ledger, inspect metadata, prepare the synthesis/reviewer structure, run deterministic read-only tools). Poll incrementally with \`collect_lane_results\` without \`wait\` (or with \`wait: false\`) to harvest lanes as they settle; process completed lane output immediately while other lanes remain pending/running, then continue independent work between polls. Do NOT sit idle waiting on running lanes, and do NOT synthesize findings from still-running lanes. Join later by calling \`collect_lane_results\` with \`wait: true\` as the explicit barrier immediately before you synthesize. Use blocking \`dispatch_lanes\` only when \`dispatch_lanes_async\`/promptAsync is unavailable. Keep each lane prompt compact: send large shared context (PR diff, ledger, scope) ONCE via the \`common_prompt\` field, or have lanes read it from a file by absolute path, instead of inlining the same blob into every lane prompt — inlining large context into many lanes is what produces malformed or truncated tool-call JSON and forces clumsy file workarounds. This non-blocking exception applies ONLY to read-only advisory lanes; it NEVER applies to coder delegations, to the test_engineer/reviewer Stage B completion gates, or to the critic PLAN-review gate, which all still follow "Send, STOP, wait" (or the Stage B parallel-dispatch exception above).
 3. ONE task per {{AGENT_PREFIX}}coder call. Never batch.
 3a. PRE-DELEGATION SCOPE CALL (required): BEFORE every {{AGENT_PREFIX}}coder delegation, you MUST call \`declare_scope\` with { taskId, files } listing the exact file(s) this task will modify (including generated/lockfile paths). No \`declare_scope\` call → no coder delegation. See Rule 1a.
@@ -103263,6 +103361,7 @@ ACTION: Load skill file:.opencode/skills/pre-phase-briefing/SKILL.md immediately
 
 HARD CONSTRAINTS:
 - Complete the codebase reality report before spec finalization, plan generation, plan ingestion, declare_scope, or starting/resuming phase implementation. Dispatching the reality-check lanes asynchronously is allowed and preferred; settling all lanes before any of that downstream work is not optional.
+- When reality-check lanes are dispatched asynchronously, record the \`batch_id\`, keep doing non-dependent architect work, poll with \`collect_lane_results\` without \`wait\`, process settled lanes immediately, and use \`wait: true\` only when no independent work remains.
 
 ### MODE: COUNCIL
 Activates when the user invokes /swarm council or requests a council-style decision review.
@@ -103273,6 +103372,7 @@ ACTION: Load skill file:.opencode/skills/council/SKILL.md immediately. Follow th
 
 HARD CONSTRAINTS:
 - Provide research context up front and synthesize only from returned council member responses.
+- For async council lanes, record the \`batch_id\`, keep doing non-dependent architect work, poll with \`collect_lane_results\` without \`wait\`, process settled lanes immediately, and use \`wait: true\` only when no independent work remains.
 
 ### MODE: DEEP_DIVE
 Activates when: architect receives \`[MODE: DEEP_DIVE profile=X max_explorers=N output=X update_main=X allow_dirty=X] <scope>\` signal from the deep-dive command handler.
@@ -103289,6 +103389,7 @@ HARD CONSTRAINTS (apply regardless of skill load success):
 - No final finding may appear in the report without reviewer verification
 - Explorers generate candidate findings only — reviewers verify or reject
 - Critics challenge only HIGH/CRITICAL findings — do NOT waste cycles on lower severity
+- For async explorer waves, record the \`batch_id\`, keep doing non-dependent architect work, poll with \`collect_lane_results\` without \`wait\`, process settled lanes immediately, and use \`wait: true\` only when no independent work remains.
 
 ### MODE: LOOP
 Activates when: architect receives \`[MODE: LOOP max_cycles=N autonomy=checkpoint|auto depth=standard|exhaustive resume=true|false] <objective>\` signal from the loop command handler.
@@ -103322,6 +103423,8 @@ HARD CONSTRAINTS (apply regardless of skill load success):
 - Critics challenge only high-stakes / contested claims — do NOT waste cycles on well-supported ones
 - If council.general.enabled is false or no search API key is configured, surface that and STOP — do not produce ungrounded research
 
+- For async synthesis lanes, record the \`batch_id\`, keep doing non-dependent architect work, poll with \`collect_lane_results\` without \`wait\`, process settled lanes immediately, and use \`wait: true\` only when no independent work remains.
+
 ### MODE: CODEBASE_REVIEW
 Activates when: architect receives \`[MODE: CODEBASE_REVIEW mode=X output=X update_main=X allow_dirty=X tracks="..." continue_run="..."] scope="..."\` signal from the codebase-review command handler.
 
@@ -103341,6 +103444,8 @@ HARD CONSTRAINTS (apply regardless of skill load success):
 - Every repo-derived factual claim needs quote-grounded evidence with file path and line/range
 - Final report is forbidden until selected-track coverage is closed and final critic passes
 
+- For async inventory or candidate-generation lanes, record the \`batch_id\`, keep doing non-dependent architect work, poll with \`collect_lane_results\` without \`wait\`, process settled lanes immediately, and use \`wait: true\` only when no independent work remains.
+
 ### MODE: DESIGN_DOCS
 Activates when: architect receives \`[MODE: DESIGN_DOCS out=X lang=X update=X] <description>\` signal from the design-docs command handler (issue #1080).
 
@@ -103372,9 +103477,11 @@ HARD CONSTRAINTS (apply regardless of skill load success):
 - No finding may appear as CONFIRMED in the final report without reviewer validation provenance
 - Test execution, explorer lanes, reviewer dispatch, and critic challenge are all permitted within this mode
 - Quality is the only metric — 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 phase cannot complete, state the limitation explicitly and continue — do not silently skip it.
+- 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 PR BRANCH LOCALLY before launching explorer lanes: fetch the PR head ref if it is not present, verify the working tree is clean (git status --porcelain) and stash/abort if not, then check out the head branch. Explorers read the working-tree filesystem (Read/Glob/Grep), so without a checkout they read the base branch and produce invalid candidates. Always pass the base..head commit range in explorer delegations.
-- RUN THE TRIGGERED MICRO-LANES: after the base explorer lanes start, inspect the context pack risk triggers and launch every matching Swarm plugin micro-lane from the skill's risk-trigger map (launch only triggered lanes, never irrelevant ones). Do not skip micro-lanes that match the diff.
+- RUN ALL BASE LANES: the default PR_REVIEW path always launches the fixed six base check-type lanes from the skill (correctness, security, dependencies/deployment, docs/intent, tests, performance/architecture). Do not collapse, omit, or scale down the base lanes for a small, docs-only, or CI-only PR.
+- USE ASYNC DISPATCH WITHOUT IDLING: launch the base lanes with one \`dispatch_lanes_async\` call when available, record the \`batch_id\`, then keep doing non-dependent architect work while they run. Poll with \`collect_lane_results\` without \`wait\` (or \`wait: false\`) to process settled lanes and continue independent work between polls; use \`wait: true\` only as the final join when no independent work remains.
+- RUN THE TRIGGERED MICRO-LANES: after the base explorer lanes settle, inspect the context pack risk triggers and launch every matching Swarm plugin micro-lane from the skill's risk-trigger map (launch only triggered lanes, never irrelevant ones). Do not skip micro-lanes that match the diff; when multiple micro-lanes are needed, dispatch them with \`dispatch_lanes_async\` and the same non-idling incremental collection pattern.
 - 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
@@ -103389,6 +103496,7 @@ HARD CONSTRAINTS (apply regardless of skill load success):
 - CHECK OUT THE PR BRANCH LOCALLY before verifying feedback or making fixes: fetch the PR head ref if absent, verify the working tree is clean (git status --porcelain) and stash/abort if not, then check out the head branch. Feedback verification and fix validation require the PR branch in the working tree.
 - Do NOT run a fresh broad PR review — inspect adjacent code only as needed to verify reachability, dependencies, shared root causes, regression risk, or sibling changes for a confirmed item.
 - Treat every review comment, CI failure, bot summary, and pasted note as a CLAIM until source evidence proves it; classify each ledger item (CONFIRMED, DISPROVED, PRE_EXISTING, or NEEDS_USER_DECISION) and never silently drop, defer, or mark items out of scope.
+- For async verification lanes, record the \`batch_id\`, keep doing ledger-safe non-dependent architect work, poll with \`collect_lane_results\` without \`wait\`, process settled lanes immediately, and use \`wait: true\` only when no independent work remains.
 - Patch only confirmed items plus the tests/docs they require; report closure status for every ledger item including disproved ones.
 - 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.
@@ -106659,42 +106767,42 @@ var init_evidence_summary_integration = __esm(() => {
 var exports_pr_event_subscribers = {};
 __export(exports_pr_event_subscribers, {
   registerPrEventSubscribers: () => registerPrEventSubscribers,
-  _internals: () => _internals71
+  _internals: () => _internals72
 });
 function registerPrEventSubscribers(options) {
   const { directory, config: config3 } = options;
-  const bus = _internals71.getGlobalEventBus();
+  const bus = _internals72.getGlobalEventBus();
   const unsubscribers = [];
   for (const [eventType, configFlag] of Object.entries(EVENT_CONFIG_MAP)) {
     if (!config3[configFlag]) {
-      _internals71.log(`[pr-monitor] Skipping ${eventType} subscriber (disabled by config)`);
+      _internals72.log(`[pr-monitor] Skipping ${eventType} subscriber (disabled by config)`);
       continue;
     }
     const listener = async (event) => {
       try {
-        await _internals71.handlePrEvent(event, directory, config3);
+        await _internals72.handlePrEvent(event, directory, config3);
       } catch (err) {
-        _internals71.log(`[pr-monitor] Error handling ${eventType}`, {
+        _internals72.log(`[pr-monitor] Error handling ${eventType}`, {
           error: err instanceof Error ? err.message : String(err)
         });
       }
     };
     const unsub = bus.subscribe(eventType, listener);
     unsubscribers.push(unsub);
-    _internals71.log(`[pr-monitor] Registered subscriber for ${eventType}`);
+    _internals72.log(`[pr-monitor] Registered subscriber for ${eventType}`);
   }
   return () => {
     for (const unsub of unsubscribers) {
       unsub();
     }
-    _internals71.log("[pr-monitor] Unregistered all PR event subscribers");
+    _internals72.log("[pr-monitor] Unregistered all PR event subscribers");
   };
 }
 async function handlePrEvent(event, directory, config3) {
   const payload = event.payload;
   if (!payload?.prNumber || !payload?.repoFullName)
     return;
-  const subscriptions = await _internals71.listActive(directory);
+  const subscriptions = await _internals72.listActive(directory);
   const matching = subscriptions.filter((sub) => sub.prNumber === payload.prNumber && sub.repoFullName === payload.repoFullName);
   if (matching.length === 0)
     return;
@@ -106706,9 +106814,9 @@ async function handlePrEvent(event, directory, config3) {
     return `[MODE: PR_FEEDBACK pr="${safePrUrl}"]`;
   })() : null;
   for (const sub of matching) {
-    const session = _internals71.getAgentSession(sub.sessionID);
+    const session = _internals72.getAgentSession(sub.sessionID);
     if (!session) {
-      _internals71.log(`[pr-monitor] Session ${sub.sessionID} not found — skipping advisory delivery`);
+      _internals72.log(`[pr-monitor] Session ${sub.sessionID} not found — skipping advisory delivery`);
       continue;
     }
     session.pendingAdvisoryMessages ??= [];
@@ -106718,10 +106826,10 @@ async function handlePrEvent(event, directory, config3) {
       continue;
     }
     session.pendingAdvisoryMessages.push(message);
-    _internals71.log(`[pr-monitor] Delivered ${event.type} advisory to session ${sub.sessionID}`);
+    _internals72.log(`[pr-monitor] Delivered ${event.type} advisory to session ${sub.sessionID}`);
     if (modeSignal) {
       session.pendingAdvisoryMessages.push(modeSignal);
-      _internals71.log(`[pr-monitor] Injected PR_FEEDBACK mode signal for session ${sub.sessionID} (${event.type})`);
+      _internals72.log(`[pr-monitor] Injected PR_FEEDBACK mode signal for session ${sub.sessionID} (${event.type})`);
     }
   }
 }
@@ -106757,13 +106865,13 @@ function formatAdvisory(type, payload) {
       return null;
   }
 }
-var _internals71, AUTO_PR_FEEDBACK_EVENTS, EVENT_CONFIG_MAP;
+var _internals72, AUTO_PR_FEEDBACK_EVENTS, EVENT_CONFIG_MAP;
 var init_pr_event_subscribers = __esm(() => {
   init_state2();
   init_utils();
   init_event_bus();
   init_pr_subscriptions();
-  _internals71 = {
+  _internals72 = {
     handlePrEvent,
     getGlobalEventBus,
     listActive,
@@ -107750,7 +107858,7 @@ __export(exports_runtime, {
   getSupportedLanguages: () => getSupportedLanguages,
   getInitializedLanguages: () => getInitializedLanguages,
   clearParserCache: () => clearParserCache,
-  _internals: () => _internals80
+  _internals: () => _internals81
 });
 import { existsSync as existsSync75, statSync as statSync24 } from "node:fs";
 import * as path130 from "node:path";
@@ -107762,10 +107870,10 @@ async function initTreeSitter() {
       const thisDir = path130.dirname(fileURLToPath4(import.meta.url));
       const isSource = thisDir.replace(/\\/g, "/").endsWith("/src/lang");
       if (isSource) {
-        await _internals80.parserInit();
+        await _internals81.parserInit();
       } else {
         const grammarsDir = getGrammarsDirAbsolute();
-        await _internals80.parserInit({
+        await _internals81.parserInit({
           locateFile(scriptName) {
             return path130.join(grammarsDir, scriptName);
           }
@@ -107880,12 +107988,12 @@ function getInitializedLanguages() {
 function getSupportedLanguages() {
   return Object.keys(LANGUAGE_WASM_MAP);
 }
-var parserCache, inflightLoads, GRAMMAR_LOAD_TIMEOUT_MS = 1e4, initializedLanguages, treeSitterInitPromise = null, _internals80, LANGUAGE_WASM_MAP;
+var parserCache, inflightLoads, GRAMMAR_LOAD_TIMEOUT_MS = 1e4, initializedLanguages, treeSitterInitPromise = null, _internals81, LANGUAGE_WASM_MAP;
 var init_runtime = __esm(() => {
   parserCache = new Map;
   inflightLoads = new Map;
   initializedLanguages = new Set;
-  _internals80 = {
+  _internals81 = {
     parserInit: TreeSitterParser.init
   };
   LANGUAGE_WASM_MAP = {
@@ -108608,7 +108716,7 @@ async function updateRetrievalOutcome(directory, phaseInfo, phaseSucceeded) {
       return data;
     });
     for (const id of shownIds) {
-      await _internals83.recordKnowledgeEvent(directory, {
+      await _internals84.recordKnowledgeEvent(directory, {
         type: "outcome",
         knowledge_id: id,
         phase: phaseInfo,
@@ -108677,13 +108785,13 @@ function scoreDirectiveAgainstContext(entry, ctx) {
     score += 0.1;
   return { triggerHit, actionHit, agentHit, score: Math.min(1, score) };
 }
-var JACCARD_THRESHOLD2 = 0.6, HIVE_TIER_BOOST = 0.05, DEFAULT_SAME_PROJECT_PENALTY = -0.05, QUARANTINED_STATUS = "quarantined", _internals83;
+var JACCARD_THRESHOLD2 = 0.6, HIVE_TIER_BOOST = 0.05, DEFAULT_SAME_PROJECT_PENALTY = -0.05, QUARANTINED_STATUS = "quarantined", _internals84;
 var init_knowledge_reader = __esm(() => {
   init_task_file();
   init_logger();
   init_knowledge_events();
   init_knowledge_store();
-  _internals83 = {
+  _internals84 = {
     readMergedKnowledge,
     updateRetrievalOutcome,
     scoreDirectiveAgainstContext,
@@ -108983,9 +109091,9 @@ var init_search_knowledge = __esm(() => {
 var exports_knowledge_recall = {};
 __export(exports_knowledge_recall, {
   knowledge_recall: () => knowledge_recall,
-  _internals: () => _internals84
+  _internals: () => _internals85
 });
-var knowledge_recall, _internals84;
+var knowledge_recall, _internals85;
 var init_knowledge_recall = __esm(() => {
   init_zod();
   init_config();
@@ -109066,7 +109174,7 @@ var init_knowledge_recall = __esm(() => {
       return JSON.stringify(result);
     }
   });
-  _internals84 = {
+  _internals85 = {
     knowledge_recall
   };
 });
@@ -109121,7 +109229,7 @@ __export(exports_curator_drift, {
   runDeterministicDriftCheck: () => runDeterministicDriftCheck,
   readPriorDriftReports: () => readPriorDriftReports,
   buildDriftInjectionText: () => buildDriftInjectionText,
-  _internals: () => _internals88
+  _internals: () => _internals89
 });
 import * as fs87 from "node:fs";
 import * as path149 from "node:path";
@@ -109170,7 +109278,7 @@ async function runDeterministicDriftCheck(directory, phase, curatorResult, confi
   try {
     const planMd = await readSwarmFileAsync(directory, "plan.md");
     const specMd = readEffectiveSpecSync(directory)?.content ?? null;
-    const priorReports = await _internals88.readPriorDriftReports(directory);
+    const priorReports = await _internals89.readPriorDriftReports(directory);
     const complianceCount = curatorResult.compliance.length;
     const warningCompliance = curatorResult.compliance.filter((obs) => obs.severity === "warning");
     let alignment = "ALIGNED";
@@ -109233,7 +109341,7 @@ async function runDeterministicDriftCheck(directory, phase, curatorResult, confi
       scope_additions: [],
       injection_summary: injectionSummary
     };
-    const reportPath = await _internals88.writeDriftReport(directory, report);
+    const reportPath = await _internals89.writeDriftReport(directory, report);
     getGlobalEventBus().publish("curator.drift.completed", {
       phase,
       alignment,
@@ -109296,13 +109404,13 @@ function buildDriftInjectionText(report, maxChars) {
   }
   return text.slice(0, maxChars);
 }
-var DRIFT_REPORT_PREFIX = "drift-report-phase-", _internals88;
+var DRIFT_REPORT_PREFIX = "drift-report-phase-", _internals89;
 var init_curator_drift = __esm(() => {
   init_event_bus();
   init_effective_spec();
   init_logger();
   init_utils2();
-  _internals88 = {
+  _internals89 = {
     readPriorDriftReports,
     writeDriftReport,
     runDeterministicDriftCheck,
@@ -109314,7 +109422,7 @@ var init_curator_drift = __esm(() => {
 var exports_design_doc_drift = {};
 __export(exports_design_doc_drift, {
   runDesignDocDriftCheck: () => runDesignDocDriftCheck,
-  _internals: () => _internals118
+  _internals: () => _internals119
 });
 import * as fs124 from "node:fs";
 import * as path195 from "node:path";
@@ -109447,7 +109555,7 @@ async function runDesignDocDriftCheck(directory, phase, outDir) {
     return null;
   }
 }
-var DOC_DRIFT_REPORT_PREFIX = "doc-drift-phase-", MAX_TRACEABILITY_BYTES, DESIGN_DOC_FILES, TRACEABILITY_REL, _internals118;
+var DOC_DRIFT_REPORT_PREFIX = "doc-drift-phase-", MAX_TRACEABILITY_BYTES, DESIGN_DOC_FILES, TRACEABILITY_REL, _internals119;
 var init_design_doc_drift = __esm(() => {
   init_event_bus();
   init_effective_spec();
@@ -109462,7 +109570,7 @@ var init_design_doc_drift = __esm(() => {
     "idiom-notes": path195.join("reference", "idiom-notes.md")
   };
   TRACEABILITY_REL = path195.join("reference", "traceability.json");
-  _internals118 = {
+  _internals119 = {
     mtimeMsOrNull,
     resolveAnchorWithin,
     DESIGN_DOC_FILES
@@ -109473,7 +109581,7 @@ var init_design_doc_drift = __esm(() => {
 var exports_project_context = {};
 __export(exports_project_context, {
   buildProjectContext: () => buildProjectContext,
-  _internals: () => _internals136,
+  _internals: () => _internals137,
   LANG_BACKEND_DETECTION_TIMEOUT_MS: () => LANG_BACKEND_DETECTION_TIMEOUT_MS
 });
 import * as fs148 from "node:fs";
@@ -109557,7 +109665,7 @@ function selectLintCommand(backend, directory) {
   return null;
 }
 async function buildProjectContext(directory) {
-  const backend = await _internals136.pickBackend(directory);
+  const backend = await _internals137.pickBackend(directory);
   if (!backend)
     return null;
   const ctx = emptyProjectContext();
@@ -109596,17 +109704,17 @@ async function buildProjectContext(directory) {
   if (backend.prompts.reviewerChecklist.length > 0) {
     ctx.REVIEWER_CHECKLIST = bulletList(backend.prompts.reviewerChecklist);
   }
-  const profiles = _internals136.pickedProfiles(directory);
+  const profiles = _internals137.pickedProfiles(directory);
   if (profiles.length > 1) {
     ctx.PROJECT_CONTEXT_SECONDARY_LANGUAGES = profiles.slice(1).map((p) => p.id).join(", ");
   }
   return ctx;
 }
-var LANG_BACKEND_DETECTION_TIMEOUT_MS = 300, _internals136;
+var LANG_BACKEND_DETECTION_TIMEOUT_MS = 300, _internals137;
 var init_project_context = __esm(() => {
   init_dispatch();
   init_framework_detector();
-  _internals136 = {
+  _internals137 = {
     pickBackend,
     pickedProfiles
   };
@@ -110030,11 +110138,11 @@ async function ghExecAsync(args2, cwd) {
     });
   });
 }
-var _internals72 = { ghExec, ghExecAsync, spawnSyncWithTransientRetry };
+var _internals73 = { ghExec, ghExecAsync, spawnSyncWithTransientRetry };
 async function getPRStatus(prNumber, repoFullName, cwd) {
   let stdout;
   try {
-    stdout = await _internals72.ghExecAsync([
+    stdout = await _internals73.ghExecAsync([
       "pr",
       "view",
       String(prNumber),
@@ -110055,13 +110163,13 @@ async function getPRComments(prNumber, repoFullName, cwd, since) {
   let issueComments;
   let reviewComments;
   try {
-    const issueRaw = await _internals72.ghExecAsync(["api", issueCommentsPath], cwd);
+    const issueRaw = await _internals73.ghExecAsync(["api", issueCommentsPath], cwd);
     issueComments = JSON.parse(issueRaw);
   } catch (err) {
     throw new Error(`Failed to fetch issue comments for ${repoFullName}#${prNumber}: ${err instanceof Error ? err.message : String(err)}`);
   }
   try {
-    const reviewRaw = await _internals72.ghExecAsync(["api", reviewCommentsPath], cwd);
+    const reviewRaw = await _internals73.ghExecAsync(["api", reviewCommentsPath], cwd);
     reviewComments = JSON.parse(reviewRaw);
   } catch (err) {
     throw new Error(`Failed to fetch review comments for ${repoFullName}#${prNumber}: ${err instanceof Error ? err.message : String(err)}`);
@@ -110088,7 +110196,7 @@ async function getPRComments(prNumber, repoFullName, cwd, since) {
 async function getMergeState(prNumber, repoFullName, cwd) {
   let stdout;
   try {
-    stdout = await _internals72.ghExecAsync([
+    stdout = await _internals73.ghExecAsync([
       "pr",
       "view",
       String(prNumber),
@@ -110110,7 +110218,7 @@ async function getMergeState(prNumber, repoFullName, cwd) {
 async function getPRReviewState(prNumber, repoFullName, cwd) {
   let stdout;
   try {
-    stdout = await _internals72.ghExecAsync([
+    stdout = await _internals73.ghExecAsync([
       "pr",
       "view",
       String(prNumber),
@@ -110218,7 +110326,7 @@ class PrMonitorWorker {
   async executePollCycle() {
     log("[PrMonitorWorker] Poll cycle starting");
     try {
-      const activeSubs = await _internals73.listActive(this.directory);
+      const activeSubs = await _internals74.listActive(this.directory);
       if (activeSubs.length === 0) {
         log("[PrMonitorWorker] No active subscriptions");
         await this.runSweep();
@@ -110290,10 +110398,10 @@ class PrMonitorWorker {
     }
     try {
       const [statusResult, commentsResult, mergeResult, reviewResult] = await Promise.all([
-        _internals73.getPRStatus(sub.prNumber, sub.repoFullName, this.directory),
-        _internals73.getPRComments(sub.prNumber, sub.repoFullName, this.directory),
-        _internals73.getMergeState(sub.prNumber, sub.repoFullName, this.directory),
-        _internals73.getPRReviewState(sub.prNumber, sub.repoFullName, this.directory)
+        _internals74.getPRStatus(sub.prNumber, sub.repoFullName, this.directory),
+        _internals74.getPRComments(sub.prNumber, sub.repoFullName, this.directory),
+        _internals74.getMergeState(sub.prNumber, sub.repoFullName, this.directory),
+        _internals74.getPRReviewState(sub.prNumber, sub.repoFullName, this.directory)
       ]);
       if (isTimedOut?.()) {
         log("[PrMonitorWorker] Skipping late result — poll already timed out", {
@@ -110310,7 +110418,7 @@ class PrMonitorWorker {
       await this.applyChanges(sub, changes, isTimedOut);
       if (!isTimedOut?.()) {
         this.circuitBreakerMap.delete(correlationId);
-        await _internals73.updateSnapshot(this.directory, correlationId, {
+        await _internals74.updateSnapshot(this.directory, correlationId, {
           errorCount: 0,
           lastCheckedAt: Date.now()
         });
@@ -110511,7 +110619,7 @@ class PrMonitorWorker {
       this.mergedOrClosedKeys.add(`${sub.repoFullName}::${sub.prNumber}`);
     }
     if (changes.isMerged && this.config.auto_unsubscribe_on_merge) {
-      await _internals73.unsubscribe(this.directory, sub.correlationId);
+      await _internals74.unsubscribe(this.directory, sub.correlationId);
       this.reviewStateMap.delete(sub.correlationId);
       this.circuitBreakerMap.delete(sub.correlationId);
       log("[PrMonitorWorker] Auto-unsubscribed merged PR", {
@@ -110520,7 +110628,7 @@ class PrMonitorWorker {
       return;
     }
     if (changes.isClosed && this.config.auto_unsubscribe_on_close) {
-      await _internals73.unsubscribe(this.directory, sub.correlationId);
+      await _internals74.unsubscribe(this.directory, sub.correlationId);
       this.reviewStateMap.delete(sub.correlationId);
       this.circuitBreakerMap.delete(sub.correlationId);
       log("[PrMonitorWorker] Auto-unsubscribed closed PR", {
@@ -110532,7 +110640,7 @@ class PrMonitorWorker {
       log("[PrMonitorWorker] Skipping snapshot update — poll timed out before write", { correlationId: sub.correlationId });
       return;
     }
-    await _internals73.updateSnapshot(this.directory, sub.correlationId, changes.snapshotUpdates);
+    await _internals74.updateSnapshot(this.directory, sub.correlationId, changes.snapshotUpdates);
   }
   async handlePollError(sub, error93) {
     const correlationId = sub.correlationId;
@@ -110542,7 +110650,7 @@ class PrMonitorWorker {
       cooldownLevel: 0
     };
     cb.errorCount++;
-    await _internals73.updateSnapshot(this.directory, correlationId, {
+    await _internals74.updateSnapshot(this.directory, correlationId, {
       errorCount: cb.errorCount,
       lastCheckedAt: Date.now()
     });
@@ -110581,7 +110689,7 @@ class PrMonitorWorker {
       source: "pr-monitor-worker"
     };
     try {
-      const bus = _internals73.getGlobalEventBus();
+      const bus = _internals74.getGlobalEventBus();
       await bus.publish(type, payload, "pr-monitor-worker");
     } catch (err) {
       log("[PrMonitorWorker] Event publish failed", {
@@ -110599,7 +110707,7 @@ class PrMonitorWorker {
     if (this.config.cleanup_ttl_days > 0) {
       try {
         const keysToPass = this.mergedOrClosedKeys.size > 0 ? this.mergedOrClosedKeys : undefined;
-        await _internals73.sweepStale(this.directory, this.config.cleanup_ttl_days, keysToPass);
+        await _internals74.sweepStale(this.directory, this.config.cleanup_ttl_days, keysToPass);
       } catch (err) {
         log("[PrMonitorWorker] Sweep failed", {
           error: err instanceof Error ? err.message : String(err)
@@ -110623,7 +110731,7 @@ class PrMonitorWorker {
     }
   }
 }
-var _internals73 = {
+var _internals74 = {
   getPRStatus,
   getPRComments,
   getMergeState,
@@ -111094,7 +111202,7 @@ import * as path121 from "node:path";
 import * as crypto9 from "node:crypto";
 import * as fs65 from "node:fs";
 import * as path120 from "node:path";
-var _internals74 = {
+var _internals75 = {
   readFileSync: fs65.readFileSync,
   writeFileSync: fs65.writeFileSync,
   mkdirSync: fs65.mkdirSync,
@@ -111104,7 +111212,7 @@ var _internals74 = {
   createHash: crypto9.createHash.bind(crypto9)
 };
 function computeContentHash(content) {
-  return _internals74.createHash("sha256").update(content, "utf-8").digest("hex");
+  return _internals75.createHash("sha256").update(content, "utf-8").digest("hex");
 }
 function createEmptyContextMap() {
   return {
@@ -111119,10 +111227,10 @@ function createEmptyContextMap() {
 function loadContextMap(directory) {
   const filePath = path120.join(directory, ".swarm", "context-map.json");
   try {
-    if (!_internals74.existsSync(filePath)) {
+    if (!_internals75.existsSync(filePath)) {
       return null;
     }
-    const raw = _internals74.readFileSync(filePath, "utf-8");
+    const raw = _internals75.readFileSync(filePath, "utf-8");
     const parsed = JSON.parse(raw);
     if (typeof parsed !== "object" || parsed === null || parsed.schema_version !== 1) {
       return null;
@@ -111136,14 +111244,14 @@ function saveContextMap(map3, directory) {
   const swarmDir = path120.join(directory, ".swarm");
   const tmpPath = path120.join(swarmDir, "context-map.tmp");
   const finalPath = path120.join(swarmDir, "context-map.json");
-  _internals74.mkdirSync(swarmDir, { recursive: true });
+  _internals75.mkdirSync(swarmDir, { recursive: true });
   const updated = {
     ...map3,
     generated_at: new Date().toISOString()
   };
   const json3 = JSON.stringify(updated, null, 2);
-  _internals74.writeFileSync(tmpPath, json3, "utf-8");
-  _internals74.renameSync(tmpPath, finalPath);
+  _internals75.writeFileSync(tmpPath, json3, "utf-8");
+  _internals75.renameSync(tmpPath, finalPath);
 }
 function appendTaskHistory(map3, summary) {
   return {
@@ -111309,10 +111417,10 @@ function deriveFinalStatus(params) {
 }
 function readFileContent(absolutePath) {
   try {
-    if (!_internals75.existsSync(absolutePath)) {
+    if (!_internals76.existsSync(absolutePath)) {
       return null;
     }
-    return _internals75.readFileSync(absolutePath, "utf-8");
+    return _internals76.readFileSync(absolutePath, "utf-8");
   } catch {
     return null;
   }
@@ -111322,9 +111430,9 @@ function refreshFileEntry(relativePath, absolutePath, existingEntry) {
   if (content === null) {
     return null;
   }
-  return _internals75.extractFileSummary(relativePath, content, absolutePath, existingEntry);
+  return _internals76.extractFileSummary(relativePath, content, absolutePath, existingEntry);
 }
-var _internals75 = {
+var _internals76 = {
   loadContextMap,
   saveContextMap,
   createEmptyContextMap,
@@ -111343,10 +111451,10 @@ function extractEvidenceFindings(taskId, directory) {
   };
   try {
     const evidenceDir = path122.join(directory, ".swarm", "evidence", taskId);
-    if (!_internals75.existsSync(evidenceDir)) {
+    if (!_internals76.existsSync(evidenceDir)) {
       return result;
     }
-    const evidenceFiles = _internals75.readdirSync(evidenceDir);
+    const evidenceFiles = _internals76.readdirSync(evidenceDir);
     const targetFiles = [
       "evidence.json",
       "reviewer.json",
@@ -111438,20 +111546,20 @@ function extractEvidenceFindings(taskId, directory) {
 }
 function updateContextMapAfterAgent(params) {
   try {
-    let map3 = _internals75.loadContextMap(params.directory);
+    let map3 = _internals76.loadContextMap(params.directory);
     if (map3 === null) {
-      map3 = _internals75.createEmptyContextMap();
+      map3 = _internals76.createEmptyContextMap();
     }
     const root = path122.resolve(params.directory);
     const updatedFiles = {
       ...map3.files
     };
     const validFiles = [];
-    const realRoot = _internals75.realpathSync(root);
+    const realRoot = _internals76.realpathSync(root);
     for (const filePath of params.files_touched) {
       try {
         const resolved = path122.resolve(root, filePath);
-        const realResolved = _internals75.realpathSync(resolved);
+        const realResolved = _internals76.realpathSync(resolved);
         const relative20 = path122.relative(realRoot, realResolved);
         if (relative20.startsWith("..") || path122.isAbsolute(relative20)) {
           continue;
@@ -111489,7 +111597,7 @@ function updateContextMapAfterAgent(params) {
       reviewer_findings: reviewerFindings.length > 0 ? reviewerFindings : undefined,
       final_status: mergedRejectionReasons.length > 0 ? "rejected" : deriveFinalStatus(params)
     };
-    map3 = _internals75.appendTaskHistory(map3, taskSummary);
+    map3 = _internals76.appendTaskHistory(map3, taskSummary);
     if (params.decisions) {
       for (const entry of params.decisions) {
         const decision = {
@@ -111499,17 +111607,17 @@ function updateContextMapAfterAgent(params) {
           timestamp: new Date().toISOString(),
           task_id: params.task_id
         };
-        map3 = _internals75.appendDecision(map3, decision);
+        map3 = _internals76.appendDecision(map3, decision);
       }
     }
-    _internals75.saveContextMap(map3, params.directory);
+    _internals76.saveContextMap(map3, params.directory);
     return map3;
   } catch {
     try {
-      const fallback = _internals75.loadContextMap(params.directory) ?? _internals75.createEmptyContextMap();
+      const fallback = _internals76.loadContextMap(params.directory) ?? _internals76.createEmptyContextMap();
       return fallback;
     } catch {
-      return _internals75.createEmptyContextMap();
+      return _internals76.createEmptyContextMap();
     }
   }
 }
@@ -112840,7 +112948,7 @@ import * as path124 from "node:path";
 function estimateTokens3(content) {
   return Math.max(1, estimateTokens2(content));
 }
-var _internals76 = {
+var _internals77 = {
   loadContextMap,
   createEmptyContextMap,
   computeContentHash,
@@ -112908,14 +113016,14 @@ function buildReadPolicy(files, map3, directory, invalidateOnHashChange = true,
     const absolutePath = path124.join(directory, filePath);
     let currentContent;
     try {
-      if (_internals76.existsSync(absolutePath)) {
-        currentContent = _internals76.readFileSync(absolutePath, "utf-8");
+      if (_internals77.existsSync(absolutePath)) {
+        currentContent = _internals77.readFileSync(absolutePath, "utf-8");
       }
     } catch {}
     if (contentCache !== undefined) {
       contentCache.set(filePath, currentContent);
     }
-    if (currentContent === undefined || invalidateOnHashChange && _internals76.isFileStale(entry, currentContent)) {
+    if (currentContent === undefined || invalidateOnHashChange && _internals77.isFileStale(entry, currentContent)) {
       policy.push({
         file_path: filePath,
         trust_summary: false,
@@ -112990,7 +113098,7 @@ function pruneCapsuleContent(sections, tokenEstimate, maxTokens, estimateFn) {
 function buildCapsule(params) {
   const { task_id, agent_role, delegation_reason, directory } = params;
   const generatedAt = new Date().toISOString();
-  const map3 = _internals76.loadContextMap(directory) ?? _internals76.createEmptyContextMap();
+  const map3 = _internals77.loadContextMap(directory) ?? _internals77.createEmptyContextMap();
   let profile = DEFAULT_ROLE_PROFILES[agent_role];
   if (params.mode === "conservative") {
     profile = { ...profile, max_files: Math.ceil(profile.max_files * 1.5) };
@@ -113019,7 +113127,7 @@ function buildCapsule(params) {
       const shouldCheckStaleness = params.invalidate_on_hash_change !== false;
       if (shouldCheckStaleness) {
         const currentContent = contentCache.get(filePath);
-        if (currentContent === undefined || _internals76.isFileStale(entry, currentContent)) {
+        if (currentContent === undefined || _internals77.isFileStale(entry, currentContent)) {
           staleEntries++;
           fileSummaries.push(`- ${filePath} — ${entry.purpose || "No summary available"} (stale)`);
         } else {
@@ -113061,11 +113169,11 @@ function buildCapsule(params) {
   }
   const content = sections.join(`
 `);
-  let tokenEstimate = _internals76.estimateTokens(content);
+  let tokenEstimate = _internals77.estimateTokens(content);
   const maxCapsuleTokens = params.max_capsule_tokens ?? 2000;
   let prunedContent = content;
   if (tokenEstimate > maxCapsuleTokens) {
-    const { prunedSections, prunedTokenEstimate } = pruneCapsuleContent(sections, tokenEstimate, maxCapsuleTokens, _internals76.estimateTokens);
+    const { prunedSections, prunedTokenEstimate } = pruneCapsuleContent(sections, tokenEstimate, maxCapsuleTokens, _internals77.estimateTokens);
     prunedContent = prunedSections.join(`
 `);
     tokenEstimate = prunedTokenEstimate;
@@ -113101,7 +113209,7 @@ function buildCapsule(params) {
 // src/context-map/capsule-persistence.ts
 import * as fs71 from "node:fs";
 import * as path125 from "node:path";
-var _internals77 = {
+var _internals78 = {
   writeFileSync: fs71.writeFileSync,
   readFileSync: fs71.readFileSync,
   existsSync: fs71.existsSync,
@@ -113137,10 +113245,10 @@ function saveCapsule(capsule, directory) {
     const capsulesDir = path125.join(directory, ".swarm", "capsules");
     const finalPath = capsulePath(capsule.task_id, directory);
     const tmpPath = path125.join(capsulesDir, `capsule-${capsule.task_id}.tmp`);
-    _internals77.mkdirSync(capsulesDir, { recursive: true });
+    _internals78.mkdirSync(capsulesDir, { recursive: true });
     const json3 = JSON.stringify(capsule, null, 2);
-    _internals77.writeFileSync(tmpPath, json3, "utf-8");
-    _internals77.renameSync(tmpPath, finalPath);
+    _internals78.writeFileSync(tmpPath, json3, "utf-8");
+    _internals78.renameSync(tmpPath, finalPath);
     return {
       success: true,
       capsule_path: finalPath,
@@ -113168,7 +113276,7 @@ function saveCapsule(capsule, directory) {
 // src/context-map/telemetry.ts
 import * as fs72 from "node:fs";
 import * as path126 from "node:path";
-var _internals78 = {
+var _internals79 = {
   appendFileSync: fs72.appendFileSync,
   readFileSync: fs72.readFileSync,
   existsSync: fs72.existsSync,
@@ -113181,10 +113289,10 @@ function recordTelemetry(entry, directory) {
   const filePath = telemetryFilePath(directory);
   const swarmDir = path126.join(directory, ".swarm");
   try {
-    _internals78.mkdirSync(swarmDir, { recursive: true });
+    _internals79.mkdirSync(swarmDir, { recursive: true });
     const line = `${JSON.stringify(entry)}
 `;
-    _internals78.appendFileSync(filePath, line, "utf-8");
+    _internals79.appendFileSync(filePath, line, "utf-8");
     return true;
   } catch {
     return false;
@@ -113226,7 +113334,7 @@ function extractTaskGoal(taskId, directory) {
     return "";
   }
 }
-var _internals79 = {
+var _internals80 = {
   buildCapsule,
   recordTelemetry,
   saveCapsule,
@@ -113294,21 +113402,21 @@ async function injectCapsule(input, output, config3, directory) {
   const sessionID = input.sessionID;
   if (!sessionID)
     return;
-  const agentName = _internals79.getActiveAgent(sessionID);
+  const agentName = _internals80.getActiveAgent(sessionID);
   if (!agentName)
     return;
   const role = extractCapsuleRole(agentName);
   if (!role)
     return;
-  const taskId = _internals79.getCurrentTaskId(sessionID);
+  const taskId = _internals80.getCurrentTaskId(sessionID);
   const effectiveTaskId = taskId ?? "unknown";
-  const files = _internals79.readScopeFile(effectiveTaskId, directory);
+  const files = _internals80.readScopeFile(effectiveTaskId, directory);
   if (files.length === 0)
     return;
   const maxTokens = config3.context_map?.max_capsule_tokens;
-  const delegationReason = _internals79.resolveCapsuleDelegationReason(_internals79.getSession(sessionID), role, effectiveTaskId);
-  const taskGoal = _internals79.extractTaskGoal(effectiveTaskId, directory);
-  const { capsule, metadata } = _internals79.buildCapsule({
+  const delegationReason = _internals80.resolveCapsuleDelegationReason(_internals80.getSession(sessionID), role, effectiveTaskId);
+  const taskGoal = _internals80.extractTaskGoal(effectiveTaskId, directory);
+  const { capsule, metadata } = _internals80.buildCapsule({
     task_id: effectiveTaskId,
     agent_role: role,
     delegation_reason: delegationReason,
@@ -113324,7 +113432,7 @@ async function injectCapsule(input, output, config3, directory) {
     return;
   output.system.push(capsule.content);
   try {
-    _internals79.saveCapsule(capsule, directory);
+    _internals80.saveCapsule(capsule, directory);
   } catch {}
   const telemetryEntry = {
     timestamp: new Date().toISOString(),
@@ -113340,7 +113448,7 @@ async function injectCapsule(input, output, config3, directory) {
     success: metadata.success
   };
   try {
-    _internals79.recordTelemetry(telemetryEntry, directory);
+    _internals80.recordTelemetry(telemetryEntry, directory);
   } catch {}
 }
 
@@ -116432,7 +116540,7 @@ function validateGraphEdge(edge) {
 }
 
 // src/tools/repo-graph/builder.ts
-var _internals81 = {
+var _internals82 = {
   safeRealpathSync,
   extractTSSymbols,
   extractPythonSymbols,
@@ -116521,12 +116629,12 @@ function resolveModuleSpecifier(workspaceRoot, sourceFile, specifier) {
     if (specifier.startsWith(".")) {
       const sourceDir = path134.dirname(sourceFile);
       let resolved = path134.resolve(sourceDir, specifier);
-      const initialRealResolved = _internals81.safeRealpathSync(resolved, resolved);
+      const initialRealResolved = _internals82.safeRealpathSync(resolved, resolved);
       if (initialRealResolved === null) {
         return null;
       }
       let realResolved = initialRealResolved;
-      const realRoot = _internals81.safeRealpathSync(workspaceRoot, path134.normalize(workspaceRoot));
+      const realRoot = _internals82.safeRealpathSync(workspaceRoot, path134.normalize(workspaceRoot));
       if (realRoot === null) {
         return null;
       }
@@ -116550,7 +116658,7 @@ function resolveModuleSpecifier(workspaceRoot, sourceFile, specifier) {
           }
         }
         if (found) {
-          const foundRealPath = _internals81.safeRealpathSync(found, found);
+          const foundRealPath = _internals82.safeRealpathSync(found, found);
           if (foundRealPath === null) {
             return null;
           }
@@ -116931,7 +117039,7 @@ async function scanFileAsync(filePath, absoluteRoot, maxFileSize) {
     return { node: null, edges: [], symbolEdges: [] };
   }
   const grammarId = getLanguage(filePath);
-  const facts = await _internals81.extractFileSymbols(grammarId, content);
+  const facts = await _internals82.extractFileSymbols(grammarId, content);
   if (facts === null) {
     const moduleName2 = toModuleName(filePath, absoluteRoot);
     return {
@@ -116942,7 +117050,7 @@ async function scanFileAsync(filePath, absoluteRoot, maxFileSize) {
         imports: [],
         language: grammarId,
         mtime: fileStats.mtime.toISOString(),
-        ontology: _internals81.extractFileOntology({
+        ontology: _internals82.extractFileOntology({
           moduleName: moduleName2,
           filePath,
           content,
@@ -116975,7 +117083,7 @@ async function scanFileAsync(filePath, absoluteRoot, maxFileSize) {
     imports,
     language,
     mtime: fileStats.mtime.toISOString(),
-    ontology: _internals81.extractFileOntology({
+    ontology: _internals82.extractFileOntology({
       moduleName,
       filePath,
       content,
@@ -117848,7 +117956,7 @@ import * as fsPromises6 from "node:fs/promises";
 import * as path137 from "node:path";
 var WINDOWS_RENAME_MAX_RETRIES2 = 5;
 var WINDOWS_RENAME_RETRY_DELAY_MS2 = 100;
-var _internals82 = {
+var _internals83 = {
   safeRealpathSync,
   fsRename: fsPromises6.rename.bind(fsPromises6),
   retryDelayMs: WINDOWS_RENAME_RETRY_DELAY_MS2
@@ -118003,12 +118111,12 @@ async function saveGraph(workspace, graph, options) {
     throw new Error("Graph must have edges array");
   }
   const normalizedWorkspace = path137.normalize(workspace);
-  const realWorkspace = _internals82.safeRealpathSync(workspace, normalizedWorkspace);
+  const realWorkspace = _internals83.safeRealpathSync(workspace, normalizedWorkspace);
   if (realWorkspace === null) {
     throw new Error(`Workspace realpath security check failed (non-ENOENT): ${workspace}`);
   }
   const normalizedGraphRoot = path137.normalize(graph.workspaceRoot);
-  const realGraphRoot = _internals82.safeRealpathSync(graph.workspaceRoot, normalizedGraphRoot);
+  const realGraphRoot = _internals83.safeRealpathSync(graph.workspaceRoot, normalizedGraphRoot);
   if (realGraphRoot === null) {
     throw new Error(`Graph workspaceRoot realpath security check failed (non-ENOENT): ${graph.workspaceRoot}`);
   }
@@ -118046,7 +118154,7 @@ async function saveGraph(workspace, graph, options) {
     } else {
       for (let attempt = 0;attempt < WINDOWS_RENAME_MAX_RETRIES2; attempt++) {
         try {
-          await _internals82.fsRename(tempPath, graphPath);
+          await _internals83.fsRename(tempPath, graphPath);
           lastError = null;
           break;
         } catch (error93) {
@@ -118056,7 +118164,7 @@ async function saveGraph(workspace, graph, options) {
             break;
           }
           if (attempt < WINDOWS_RENAME_MAX_RETRIES2 - 1) {
-            await new Promise((resolve49) => setTimeout(resolve49, _internals82.retryDelayMs));
+            await new Promise((resolve49) => setTimeout(resolve49, _internals83.retryDelayMs));
           }
         }
       }
@@ -121758,7 +121866,7 @@ function resolveDefaultReviewerAgent(generatedAgentNames) {
 }
 async function compileReviewPackage(directory, phase, sessionID, requireDiffSummary) {
   const lanes = await listLaneEvidence(directory, phase);
-  const persisted = _internals85.readPersisted?.(directory) ?? null;
+  const persisted = _internals86.readPersisted?.(directory) ?? null;
   if (persisted) {
     let matchingRunState = null;
     for (const sessionState of Object.values(persisted.sessions)) {
@@ -121968,7 +122076,7 @@ Be specific and evidence-based. Do not approve a phase with unresolved degraded
     client.session.delete({ path: { id: sessionId } }).catch(() => {});
   }
 }
-var _internals85 = {
+var _internals86 = {
   compileReviewPackage,
   parseReviewerVerdict,
   writeReviewerEvidence,
@@ -121985,28 +122093,28 @@ async function dispatchPhaseReviewer(directory, phase, sessionID, config3) {
   };
   const generatedAgentNames = swarmState.generatedAgentNames;
   const agentName = mergedConfig.reviewerAgent || resolveDefaultReviewerAgent(generatedAgentNames);
-  const pkg = await _internals85.compileReviewPackage(directory, phase, sessionID, mergedConfig.requireDiffSummary);
+  const pkg = await _internals86.compileReviewPackage(directory, phase, sessionID, mergedConfig.requireDiffSummary);
   let responseText;
   try {
-    responseText = await _internals85.dispatchReviewerAgent(directory, pkg, agentName, mergedConfig.timeoutMs, sessionID);
+    responseText = await _internals86.dispatchReviewerAgent(directory, pkg, agentName, mergedConfig.timeoutMs, sessionID);
   } catch (error93) {
-    const evidencePath2 = await _internals85.writeReviewerEvidence(directory, phase, "REJECTED", error93 instanceof Error ? error93.message : String(error93));
+    const evidencePath2 = await _internals86.writeReviewerEvidence(directory, phase, "REJECTED", error93 instanceof Error ? error93.message : String(error93));
     return {
       verdict: "REJECTED",
       reason: `Reviewer dispatch failed: ${error93 instanceof Error ? error93.message : String(error93)}`,
       evidencePath: evidencePath2
     };
   }
-  const parsed = _internals85.parseReviewerVerdict(responseText);
+  const parsed = _internals86.parseReviewerVerdict(responseText);
   if (!parsed) {
-    const evidencePath2 = await _internals85.writeReviewerEvidence(directory, phase, "REJECTED", "Reviewer response could not be parsed");
+    const evidencePath2 = await _internals86.writeReviewerEvidence(directory, phase, "REJECTED", "Reviewer response could not be parsed");
     return {
       verdict: "REJECTED",
       reason: "Reviewer response could not be parsed",
       evidencePath: evidencePath2
     };
   }
-  const evidencePath = await _internals85.writeReviewerEvidence(directory, phase, parsed.verdict, parsed.reason);
+  const evidencePath = await _internals86.writeReviewerEvidence(directory, phase, parsed.verdict, parsed.reason);
   return {
     verdict: parsed.verdict,
     reason: parsed.reason,
@@ -122190,7 +122298,7 @@ async function runAutoReview(input) {
     phase
   };
   try {
-    const diffResult = await _internals86.computeExecutionDiff(directory, config3.max_diff_kb * 1024);
+    const diffResult = await _internals87.computeExecutionDiff(directory, config3.max_diff_kb * 1024);
     if (diffResult.status === "clean") {
       writeAutoReviewEvent(directory, {
         ...base,
@@ -122212,7 +122320,7 @@ async function runAutoReview(input) {
     const prompt = buildReviewPrompt(trigger, diff, taskId, phase);
     let transcript;
     try {
-      transcript = await _internals86.dispatchReviewer(directory, prompt, agentName, config3.timeout_ms, sessionID);
+      transcript = await _internals87.dispatchReviewer(directory, prompt, agentName, config3.timeout_ms, sessionID);
     } catch (err) {
       writeAutoReviewEvent(directory, {
         ...base,
@@ -122316,13 +122424,13 @@ function createAutoReviewHook(options) {
         if (inFlightSessions.has(sessionID))
           return;
         const last = lastDispatchBySession.get(sessionID) ?? 0;
-        if (_internals86.now() - last < COOLDOWN_MS)
+        if (_internals87.now() - last < COOLDOWN_MS)
           return;
         inFlightSessions.add(sessionID);
         lastDispatchBySession.delete(sessionID);
-        lastDispatchBySession.set(sessionID, _internals86.now());
+        lastDispatchBySession.set(sessionID, _internals87.now());
         evictCooldownMap();
-        _internals86.runAutoReview({
+        _internals87.runAutoReview({
           directory,
           sessionID,
           trigger,
@@ -122342,7 +122450,7 @@ function createAutoReviewHook(options) {
     }
   };
 }
-var _internals86 = {
+var _internals87 = {
   computeExecutionDiff,
   dispatchReviewer,
   runAutoReview,
@@ -122783,10 +122891,10 @@ async function getRunMemorySummary(directory) {
   if (entries.length === 0) {
     return null;
   }
-  const groups = _internals87.groupByTaskId(entries);
+  const groups = _internals88.groupByTaskId(entries);
   const summaries = [];
   for (const [taskId, taskEntries] of groups) {
-    const summary = _internals87.summarizeTask(taskId, taskEntries);
+    const summary = _internals88.summarizeTask(taskId, taskEntries);
     if (summary) {
       summaries.push(summary);
     }
@@ -122819,7 +122927,7 @@ Use this data to avoid repeating known failure patterns.`;
   }
   return prefix + summaryText + suffix;
 }
-var _internals87 = {
+var _internals88 = {
   generateTaskFingerprint,
   recordOutcome,
   getTaskHistory,
@@ -123008,7 +123116,7 @@ async function injectForDelegate(params) {
     currentTool: firstTool,
     mode: "delegation"
   };
-  const searchFn = params.searchFn ?? (_internals89.searchKnowledge === defaultSearchKnowledge ? searchKnowledge : _internals89.searchKnowledge);
+  const searchFn = params.searchFn ?? (_internals90.searchKnowledge === defaultSearchKnowledge ? searchKnowledge : _internals90.searchKnowledge);
   try {
     const search = await searchFn({
       directory,
@@ -123032,7 +123140,7 @@ async function injectForDelegate(params) {
         ranks[e.id] = idx + 1;
         scores[e.id] = e.finalScore;
       });
-      await _internals89.recordKnowledgeEvent(directory, {
+      await _internals90.recordKnowledgeEvent(directory, {
         type: "retrieved",
         trace_id: search.trace_id,
         session_id: sessionId ?? "unknown",
@@ -123239,7 +123347,7 @@ function createKnowledgeInjectorHook(directory, config3, modelLimitOverrides = {
       projectName,
       currentPhase: phaseDescription
     };
-    const searchFn = _internals89.searchKnowledge === defaultSearchKnowledge ? searchKnowledge : _internals89.searchKnowledge;
+    const searchFn = _internals90.searchKnowledge === defaultSearchKnowledge ? searchKnowledge : _internals90.searchKnowledge;
     const search = await searchFn({
       directory,
       config: config3,
@@ -123355,7 +123463,7 @@ ${freshPreamble}` : `<curator_briefing>${truncatedBriefing}</curator_briefing>`;
         ranks[id] = idx + 1;
         scores[id] = scoreById.get(id) ?? 0;
       });
-      await _internals89.recordKnowledgeEvent(directory, {
+      await _internals90.recordKnowledgeEvent(directory, {
         type: "retrieved",
         trace_id: search.trace_id,
         session_id: systemMsg?.info?.sessionID ?? "unknown",
@@ -123368,7 +123476,7 @@ ${freshPreamble}` : `<curator_briefing>${truncatedBriefing}</curator_briefing>`;
         ranks,
         scores
       });
-      _internals89.recordKnowledgeShown(directory, cachedShownIds, {
+      _internals90.recordKnowledgeShown(directory, cachedShownIds, {
         phase: phaseLabel,
         tool: retrievalCtx.currentTool,
         action: retrievalCtx.currentAction,
@@ -123378,7 +123486,7 @@ ${freshPreamble}` : `<curator_briefing>${truncatedBriefing}</curator_briefing>`;
     }
   });
 }
-var _internals89 = {
+var _internals90 = {
   searchKnowledge,
   recordKnowledgeEvent,
   recordKnowledgeShown
@@ -125377,7 +125485,7 @@ async function knowledgeApplicationGateBefore(directory, input, config3) {
     if (config3.mode === "enforce") {
       throw new Error("KNOWLEDGE_ENFORCE_GATE_DENY: missing sessionID on tool.execute.before; refusing to evaluate critical-directive ack state");
     }
-    _internals90.writeWarnEvent(directory, {
+    _internals91.writeWarnEvent(directory, {
       timestamp: new Date().toISOString(),
       event: "knowledge_application_gate_warn",
       tool: toolName,
@@ -125460,7 +125568,7 @@ async function knowledgeApplicationTransformScan(directory, output, sessionID) {
     }
   }
 }
-var _internals90 = {
+var _internals91 = {
   knowledgeApplicationGateBefore,
   knowledgeApplicationTransformScan,
   HIGH_RISK_TOOLS,
@@ -126694,7 +126802,7 @@ function timeoutKillSignal(platform) {
 }
 function killProcess(proc) {
   try {
-    proc?.kill(timeoutKillSignal(_internals91.platform()));
+    proc?.kill(timeoutKillSignal(_internals92.platform()));
   } catch {}
 }
 async function runExternalTool(options) {
@@ -126714,7 +126822,7 @@ async function runExternalTool(options) {
   let exitSettled = false;
   let settledExitCode = null;
   try {
-    proc = _internals91.bunSpawn([options.executable, ...options.args], {
+    proc = _internals92.bunSpawn([options.executable, ...options.args], {
       cwd: options.cwd,
       env: options.env,
       stdin: "ignore",
@@ -126782,7 +126890,7 @@ async function runExternalTool(options) {
     }
   }
 }
-var _internals91 = {
+var _internals92 = {
   bunSpawn,
   platform: () => process.platform
 };
@@ -126799,7 +126907,7 @@ var MAX_WORKFLOW_FILES = 500;
 var MAX_WORKFLOW_DIRS = 200;
 var MAX_WORKFLOW_DEPTH = 20;
 function resolveActionlintBinary() {
-  return _internals92.resolveExecutableFromPath(["actionlint"]);
+  return _internals93.resolveExecutableFromPath(["actionlint"]);
 }
 function normalizeRelativeWorkflowFile(file3, workspace) {
   if (!file3 || containsControlChars(file3) || containsPathTraversal(file3)) {
@@ -126913,7 +127021,7 @@ var actionlint_scan = createSwarmTool({
     const discovery = requestedFiles ? {
       files: requestedFiles.map((f) => normalizeRelativeWorkflowFile(f, directory)).filter((f) => Boolean(f)),
       truncated: false
-    } : _internals92.discoverWorkflowFiles(directory);
+    } : _internals93.discoverWorkflowFiles(directory);
     let files = discovery.files;
     if (requestedFiles && files.length !== requestedFiles.length) {
       return JSON.stringify({
@@ -126937,7 +127045,7 @@ var actionlint_scan = createSwarmTool({
         note: discoveryTruncated ? `Workflow discovery was truncated at ${MAX_WORKFLOW_FILES} files, ${MAX_WORKFLOW_DIRS} directories, or depth ${MAX_WORKFLOW_DEPTH}; result is incomplete.` : "No GitHub Actions workflow YAML files found"
       }, null, 2);
     }
-    const executable = _internals92.resolveActionlintBinary();
+    const executable = _internals93.resolveActionlintBinary();
     if (!executable) {
       return JSON.stringify({
         error: true,
@@ -126950,7 +127058,7 @@ var actionlint_scan = createSwarmTool({
       "{{json .}}",
       ...files.map((file3) => `./${file3}`)
     ];
-    const run = await _internals92.runExternalTool({
+    const run = await _internals93.runExternalTool({
       executable,
       args: lintArgs,
       cwd: directory,
@@ -126994,7 +127102,7 @@ var actionlint_scan = createSwarmTool({
     }, null, 2);
   }
 });
-var _internals92 = {
+var _internals93 = {
   resolveExecutableFromPath,
   resolveActionlintBinary,
   runExternalTool,
@@ -127841,7 +127949,7 @@ function splitGlobPatterns(value) {
   return value ? value.split(",").map((p) => p.trim()).filter(Boolean) : [];
 }
 function resolveAstGrepBinary() {
-  return _internals93.resolveExecutableFromPath(["ast-grep", "sg"]);
+  return _internals94.resolveExecutableFromPath(["ast-grep", "sg"]);
 }
 function toWorkspaceRelativePath(filePath, workspace) {
   try {
@@ -127973,7 +128081,7 @@ var ast_grep = createSwarmTool({
         message: "Workspace directory does not exist"
       }, null, 2);
     }
-    const executable = _internals93.resolveAstGrepBinary();
+    const executable = _internals94.resolveAstGrepBinary();
     if (!executable) {
       return JSON.stringify({
         error: true,
@@ -127999,7 +128107,7 @@ var ast_grep = createSwarmTool({
       sgArgs.push("--globs", `!${glob}`);
     }
     sgArgs.push(".");
-    const run = await _internals93.runExternalTool({
+    const run = await _internals94.runExternalTool({
       executable,
       args: sgArgs,
       cwd: directory,
@@ -128041,7 +128149,7 @@ var ast_grep = createSwarmTool({
     }, null, 2);
   }
 });
-var _internals93 = {
+var _internals94 = {
   resolveExecutableFromPath,
   resolveAstGrepBinary,
   runExternalTool,
@@ -129770,7 +129878,7 @@ init_model_limits();
 init_utils2();
 init_state2();
 init_create_tool();
-var _internals94 = {
+var _internals95 = {
   loadPluginConfig,
   fetchSessionMessages: async (sessionID, directory, limit = 100) => {
     if (!swarmState.opencodeClient?.session)
@@ -129819,13 +129927,13 @@ var context_status = createSwarmTool({
   description: "Report current context-window headroom for the active session. Returns tokens-used, model-limit, usage-percent, threshold-state (none/warn/critical), model name, and provider. Pure read-only — no state mutation, no warning injection. Works whether context_budget.enabled is true or false.",
   args: {},
   async execute(_args, directory, ctx) {
-    const config3 = _internals94.loadPluginConfig(directory);
+    const config3 = _internals95.loadPluginConfig(directory);
     const warnThreshold = config3.context_budget?.warn_threshold ?? 0.7;
     const criticalThreshold = config3.context_budget?.critical_threshold ?? 0.9;
     const modelLimitsConfig = config3.context_budget?.model_limits ?? {};
     let messages = [];
     if (ctx?.sessionID) {
-      const sessionMessages = await _internals94.fetchSessionMessages(ctx.sessionID, directory);
+      const sessionMessages = await _internals95.fetchSessionMessages(ctx.sessionID, directory);
       if (sessionMessages) {
         messages = sessionMessages;
       }
@@ -129866,7 +129974,7 @@ var VALID_TASK_ID = /^\d+\.\d+(\.\d+)*$/;
 var COUNCIL_GATE_NAME = "council";
 var COUNCIL_AGENT_ID = "architect";
 var EvidenceFileSchema = exports_external.record(exports_external.string(), exports_external.unknown());
-var _internals95 = {
+var _internals96 = {
   withTaskEvidenceLock
 };
 var FORBIDDEN_KEYS = new Set(["__proto__", "constructor", "prototype"]);
@@ -129901,7 +130009,7 @@ async function writeCouncilEvidence(workingDir, synthesis) {
   const dir = join131(workingDir, EVIDENCE_DIR2);
   mkdirSync42(dir, { recursive: true });
   const filePath = taskEvidencePath(workingDir, synthesis.taskId);
-  await _internals95.withTaskEvidenceLock(workingDir, synthesis.taskId, COUNCIL_AGENT_ID, async () => {
+  await _internals96.withTaskEvidenceLock(workingDir, synthesis.taskId, COUNCIL_AGENT_ID, async () => {
     const existingRoot = Object.create(null);
     if (existsSync95(filePath)) {
       try {
@@ -132421,7 +132529,7 @@ var CollectLaneResultsArgsSchema = exports_external.object({
   include_pending: exports_external.boolean().optional().describe("Include pending/running lanes in lane_results. Defaults to true for non-blocking polls and false for wait=true joins."),
   cancel_pending: exports_external.boolean().optional().describe("Abort and mark pending/running lanes cancelled")
 });
-var _internals96 = {
+var _internals97 = {
   getSessionOps: () => swarmState.opencodeClient?.session ?? null,
   getGeneratedAgentNames: () => swarmState.generatedAgentNames,
   createParallelDispatcher,
@@ -132445,7 +132553,7 @@ async function executeDispatchLanes(args2, directory, context = {}) {
       errors: duplicateLaneIds.map((id) => `Duplicate lane id: ${id}`)
     });
   }
-  const session = _internals96.getSessionOps();
+  const session = _internals97.getSessionOps();
   if (!session) {
     return failureResult({
       failure_class: "no_client",
@@ -132463,7 +132571,7 @@ async function executeDispatchLanes(args2, directory, context = {}) {
   const lanes = applyExplorerFormatSuffix(common.lanes);
   const maxConcurrent = Math.min(parsed.data.max_concurrent ?? lanes.length, lanes.length, MAX_LANES);
   const timeoutMs = parsed.data.timeout_ms ?? DEFAULT_TIMEOUT_MS3;
-  const dispatcher = _internals96.createParallelDispatcher({
+  const dispatcher = _internals97.createParallelDispatcher({
     enabled: true,
     maxConcurrentTasks: maxConcurrent,
     evidenceLockTimeoutMs: 0
@@ -132493,7 +132601,7 @@ async function executeDispatchLanesAsync(args2, directory, context = {}) {
       errors: duplicateLaneIds.map((id) => `Duplicate lane id: ${id}`)
     });
   }
-  const session = _internals96.getSessionOps();
+  const session = _internals97.getSessionOps();
   if (!session || typeof session.promptAsync !== "function") {
     return asyncFailureResult({
       failure_class: "no_client",
@@ -132519,7 +132627,7 @@ async function executeDispatchLanesAsync(args2, directory, context = {}) {
   }
   const maxConcurrent = Math.min(parsed.data.max_concurrent ?? lanes.length, lanes.length, MAX_LANES);
   const launchTimeoutMs = parsed.data.launch_timeout_ms ?? parsed.data.timeout_ms ?? DEFAULT_ASYNC_LAUNCH_TIMEOUT_MS;
-  const dispatcher = _internals96.createParallelDispatcher({
+  const dispatcher = _internals97.createParallelDispatcher({
     enabled: true,
     maxConcurrentTasks: maxConcurrent,
     evidenceLockTimeoutMs: 0
@@ -132567,7 +132675,7 @@ async function executeCollectLaneResults(args2, directory, context = {}) {
       errors: parsed.error.issues.map((issue3) => `${issue3.path.join(".")}: ${issue3.message}`)
     });
   }
-  const session = _internals96.getSessionOps();
+  const session = _internals97.getSessionOps();
   if (!session || typeof session.messages !== "function") {
     return collectFailureResult({
       failure_class: "no_client",
@@ -132576,7 +132684,7 @@ async function executeCollectLaneResults(args2, directory, context = {}) {
     });
   }
   const timeoutMs = parsed.data.timeout_ms ?? DEFAULT_COLLECT_TIMEOUT_MS;
-  const deadline = _internals96.now() + timeoutMs;
+  const deadline = _internals97.now() + timeoutMs;
   const batchFilter = context.sessionID !== undefined ? { parentSessionId: context.sessionID } : undefined;
   let records = findByBatchId(directory, parsed.data.batch_id, batchFilter);
   if (records.length === 0) {
@@ -132596,11 +132704,11 @@ async function executeCollectLaneResults(args2, directory, context = {}) {
       keepPolling = false;
       continue;
     }
-    if (_internals96.now() >= deadline) {
+    if (_internals97.now() >= deadline) {
       keepPolling = false;
       continue;
     }
-    await _internals96.sleep(Math.min(pollIntervalMs, Math.max(0, deadline - _internals96.now())));
+    await _internals97.sleep(Math.min(pollIntervalMs, Math.max(0, deadline - _internals97.now())));
     pollIntervalMs = nextCollectPollInterval(pollIntervalMs);
   }
   return buildCollectResult(parsed.data.batch_id, records, parsed.data.include_pending ?? parsed.data.wait !== true);
@@ -132829,7 +132937,7 @@ async function isLaneReadyForCollection(session, directory, sessionId) {
 async function sweepStaleAsyncLaneRecords(session, directory, records, staleTimeoutMs) {
   if (staleTimeoutMs <= 0)
     return;
-  const now = _internals96.now();
+  const now = _internals97.now();
   for (const record3 of records) {
     if (record3.status !== "pending" && record3.status !== "running" && record3.status !== "ingestion_error")
       continue;
@@ -133040,7 +133148,7 @@ function failedLane(lane, role, startedAt, error93, slotId, runId, sessionId) {
   };
 }
 function validateLaneAgent(agent, context) {
-  const generatedAgentNames = _internals96.getGeneratedAgentNames();
+  const generatedAgentNames = _internals97.getGeneratedAgentNames();
   const role = resolveGeneratedAgentRole(agent, generatedAgentNames);
   if (!isKnownCanonicalRole(role)) {
     return {
@@ -133191,7 +133299,7 @@ function applyCommonPrompt(lanes, commonPrompt) {
   return { ok: true, lanes: merged };
 }
 function applyExplorerFormatSuffix(lanes) {
-  const generatedAgentNames = _internals96.getGeneratedAgentNames();
+  const generatedAgentNames = _internals97.getGeneratedAgentNames();
   return lanes.map((lane) => {
     const role = resolveGeneratedAgentRole(lane.agent, generatedAgentNames);
     if (role !== "explorer")
@@ -133264,7 +133372,7 @@ function boundErrorString(text) {
   return `${text.slice(0, MAX_ERROR_CHARS)}${ERROR_TRUNCATION_SUFFIX}`;
 }
 function isoNow() {
-  return new Date(_internals96.now()).toISOString();
+  return new Date(_internals97.now()).toISOString();
 }
 function buildLaneSessionCreateArgs(directory, lane, context) {
   const parentID = context.sessionID?.trim();
@@ -133278,7 +133386,7 @@ function buildLaneSessionCreateArgs(directory, lane, context) {
   };
 }
 function makeBatchId() {
-  return `lanes-${_internals96.now().toString(36)}`;
+  return `lanes-${_internals97.now().toString(36)}`;
 }
 function promptHash(lane, directory, batchId) {
   return digestText2(JSON.stringify({
@@ -133571,7 +133679,7 @@ function buildIsUpstreamCommittedWithStatus(directory, options) {
   const max = options?.maxCommits ?? MAX_LOG_COMMITS;
   let subjects;
   try {
-    subjects = _internals97.readGitLogSubjects(directory, max);
+    subjects = _internals98.readGitLogSubjects(directory, max);
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     criticalWarn(`[epic:upstream-commits] git log scan failed (degrading to permissive predicate, the activation gate may flip fail-closed): ${msg}`);
@@ -133593,7 +133701,7 @@ function buildIsUpstreamCommittedWithStatus(directory, options) {
     gitFailed: false
   };
 }
-var _internals97 = {
+var _internals98 = {
   readGitLogSubjects: (cwd, max) => {
     return _internals4.gitExec(["log", "--no-merges", `--max-count=${max}`, "--pretty=%s"], cwd);
   }
@@ -133998,7 +134106,7 @@ function readPlanJson(directory) {
 }
 async function executeEpicPlanWaves(args2) {
   const { directory, phase, scopes } = args2;
-  const plan = _internals98.readPlanJson(directory);
+  const plan = _internals99.readPlanJson(directory);
   if (!plan) {
     return {
       success: false,
@@ -134051,7 +134159,7 @@ async function executeEpicPlanWaves(args2) {
   try {
     const tasksMissingScope = [];
     for (const task of pendingTasks) {
-      const declaredScope = _internals98.readTaskScopes(directory, task.id);
+      const declaredScope = _internals99.readTaskScopes(directory, task.id);
       const filesTouched = task.files_touched ?? [];
       const providedScope = scopes && task.id in scopes ? scopes[task.id] : null;
       if ((declaredScope === null || declaredScope.length === 0) && filesTouched.length === 0 && (providedScope === null || providedScope.length === 0)) {
@@ -134074,8 +134182,8 @@ async function executeEpicPlanWaves(args2) {
       };
     }
     let isUpstreamCommitted;
-    if (_internals98.isGitRepo(directory)) {
-      const evidence = _internals98.buildIsUpstreamCommittedWithStatus(directory);
+    if (_internals99.isGitRepo(directory)) {
+      const evidence = _internals99.buildIsUpstreamCommittedWithStatus(directory);
       if (evidence.gitFailed) {
         criticalWarn(`[epic_plan_waves] wave-planning blocked for directory=${directory} phase=${phase}: git log scan failed. Any prior promote verdict in .swarm/evidence/epic-promotions.jsonl for this phase is not backed by actual parallel execution.`);
         return {
@@ -134090,7 +134198,7 @@ async function executeEpicPlanWaves(args2) {
     }
     let leanConfig = { ...DEFAULT_LEAN_TURBO_CONFIG };
     try {
-      const loaded = await _internals98.loadPluginConfigWithMeta(directory);
+      const loaded = await _internals99.loadPluginConfigWithMeta(directory);
       const userLean = loaded?.config?.turbo?.lean;
       if (userLean) {
         leanConfig = { ...leanConfig, ...userLean };
@@ -134114,7 +134222,7 @@ async function executeEpicPlanWaves(args2) {
     };
   }
 }
-var _internals98 = {
+var _internals99 = {
   readPlanJson,
   readTaskScopes,
   isGitRepo: (cwd) => isGitRepo(cwd),
@@ -134146,7 +134254,7 @@ init_state2();
 init_divergence_recorder();
 init_logger();
 init_create_tool();
-var _internals99 = {
+var _internals100 = {
   hasActiveEpicMode,
   getAgentSession,
   readScopeFromDisk,
@@ -134155,7 +134263,7 @@ var _internals99 = {
 };
 async function findPhaseForTask(directory, taskId) {
   try {
-    const plan = await _internals99.loadPlanJsonOnly(directory);
+    const plan = await _internals100.loadPlanJsonOnly(directory);
     if (!plan)
       return;
     for (const phase of plan.phases) {
@@ -134168,20 +134276,20 @@ async function findPhaseForTask(directory, taskId) {
 }
 async function executeEpicRecordDivergence(args2) {
   const { directory, taskId, sessionID } = args2;
-  if (!_internals99.hasActiveEpicMode(sessionID)) {
+  if (!_internals100.hasActiveEpicMode(sessionID)) {
     return { success: true, reason: "epic-mode-not-active" };
   }
-  const session = _internals99.getAgentSession(sessionID);
+  const session = _internals100.getAgentSession(sessionID);
   if (!session) {
     return { success: true, reason: "no-session" };
   }
-  const declaredScope = _internals99.readScopeFromDisk(directory, taskId);
+  const declaredScope = _internals100.readScopeFromDisk(directory, taskId);
   if (declaredScope === null) {
     return { success: true, reason: "no-scope" };
   }
   const actualFiles = session.modifiedFilesThisCoderTask ?? [];
   const phaseNumber = await findPhaseForTask(directory, taskId);
-  const result = _internals99.recordTaskDivergence({
+  const result = _internals100.recordTaskDivergence({
     directory,
     sessionID,
     taskId,
@@ -134563,7 +134671,7 @@ init_state4();
 
 // src/turbo/lean/state-lock.ts
 init_file_locks();
-var _internals100 = { tryAcquireLock };
+var _internals101 = { tryAcquireLock };
 
 class TurboStateLockTimeoutError extends Error {
   directory;
@@ -134591,7 +134699,7 @@ async function withTurboStateLock(directory, sessionID, fn2, timeoutMs = 30000)
   while (true) {
     let result;
     try {
-      result = await _internals100.tryAcquireLock(directory, lockPath, agent, sessionID);
+      result = await _internals101.tryAcquireLock(directory, lockPath, agent, sessionID);
     } catch (acquireErr) {
       console.warn(`[lean-turbo] state lock acquisition error for ${sessionID} (${lockPath}), will retry: ${acquireErr instanceof Error ? acquireErr.message : String(acquireErr)}`);
     }
@@ -135338,7 +135446,7 @@ ${fileList}
 // src/tools/epic-run-phase.ts
 init_logger();
 init_create_tool();
-var _internals101 = {
+var _internals102 = {
   loadPluginConfigWithMeta,
   loadPlanJsonOnly,
   getCoChangeData,
@@ -135360,13 +135468,13 @@ var _internals101 = {
 };
 async function executeEpicDecidePhase(args2) {
   const { directory, phase, sessionID } = args2;
-  if (!_internals101.isEpicModeActive(directory, sessionID)) {
+  if (!_internals102.isEpicModeActive(directory, sessionID)) {
     return {
       success: false,
       reason: "epic-mode-not-active"
     };
   }
-  const plan = await _internals101.loadPlanJsonOnly(directory);
+  const plan = await _internals102.loadPlanJsonOnly(directory);
   if (plan === null) {
     return { success: false, reason: "no-plan" };
   }
@@ -135396,7 +135504,7 @@ async function executeEpicDecidePhase(args2) {
     }
     const tasksMissingScope = [];
     for (const task of pendingTasks) {
-      const declaredScope = _internals101.readTaskScopes(directory, task.id);
+      const declaredScope = _internals102.readTaskScopes(directory, task.id);
       const filesTouched = task.files_touched ?? [];
       if ((declaredScope === null || declaredScope.length === 0) && filesTouched.length === 0) {
         tasksMissingScope.push(task.id);
@@ -135416,7 +135524,7 @@ async function executeEpicDecidePhase(args2) {
       };
     }
   }
-  const { config: config3 } = _internals101.loadPluginConfigWithMeta(directory);
+  const { config: config3 } = _internals102.loadPluginConfigWithMeta(directory);
   const modeCfg = config3.turbo?.epic?.mode;
   const cochangeCfg = config3.turbo?.epic?.cochange;
   const calibrationCfg = config3.turbo?.epic?.calibration;
@@ -135429,14 +135537,14 @@ async function executeEpicDecidePhase(args2) {
   let extraHotModules = [];
   if (calibrationEnabled) {
     try {
-      const currentCalibration = _internals101.loadCalibrationState(directory);
+      const currentCalibration = _internals102.loadCalibrationState(directory);
       if (currentCalibration !== null) {
-        const history = _internals101.readDivergenceHistory(directory, {
+        const history = _internals102.readDivergenceHistory(directory, {
           maxBytes: Number.POSITIVE_INFINITY
         });
         const newRecords = history.slice(currentCalibration.processedRecords);
         if (newRecords.length > 0) {
-          const updated = _internals101.applyCalibration(currentCalibration, newRecords, {
+          const updated = _internals102.applyCalibration(currentCalibration, newRecords, {
             staticThreshold: staticActivationThreshold,
             floorThreshold: calibrationCfg?.floor_threshold,
             tightenStep: calibrationCfg?.tighten_step,
@@ -135445,17 +135553,17 @@ async function executeEpicDecidePhase(args2) {
           });
           let savedSuccessfully = false;
           try {
-            _internals101.saveCalibrationState(directory, updated);
+            _internals102.saveCalibrationState(directory, updated);
             savedSuccessfully = true;
           } catch (err) {
             criticalWarn(`[epic_run_phase] calibration persist failed; ignoring this run's calibration delta to avoid drift on next run: ${err instanceof Error ? err.message : String(err)}`);
           }
           const sourceForThisRun = savedSuccessfully ? updated : currentCalibration;
-          effectiveThreshold = _internals101.effectiveActivationThreshold(staticActivationThreshold, sourceForThisRun);
-          extraHotModules = _internals101.effectiveHotModules([], sourceForThisRun);
+          effectiveThreshold = _internals102.effectiveActivationThreshold(staticActivationThreshold, sourceForThisRun);
+          extraHotModules = _internals102.effectiveHotModules([], sourceForThisRun);
         } else {
-          effectiveThreshold = _internals101.effectiveActivationThreshold(staticActivationThreshold, currentCalibration);
-          extraHotModules = _internals101.effectiveHotModules([], currentCalibration);
+          effectiveThreshold = _internals102.effectiveActivationThreshold(staticActivationThreshold, currentCalibration);
+          extraHotModules = _internals102.effectiveHotModules([], currentCalibration);
         }
       }
     } catch (err) {
@@ -135471,14 +135579,14 @@ async function executeEpicDecidePhase(args2) {
     }
   }
   const tasks = rawTasks.map((task) => {
-    const scopeFiles = _internals101.readTaskScopes(directory, task.id);
+    const scopeFiles = _internals102.readTaskScopes(directory, task.id);
     const scope = scopeFiles ?? task.files_touched ?? [];
     return { id: task.id, scope };
   });
-  const { pairs, commitsObserved } = await _internals101.getCoChangeData(directory);
+  const { pairs, commitsObserved } = await _internals102.getCoChangeData(directory);
   const isGitProject = (() => {
     try {
-      return _internals101.isGitRepo(directory);
+      return _internals102.isGitRepo(directory);
     } catch {
       return false;
     }
@@ -135511,10 +135619,10 @@ async function executeEpicDecidePhase(args2) {
   const phantomDeps = [...phantomDepsSet];
   let isUpstreamCommitted;
   if (isGitProject) {
-    const evidence = _internals101.buildIsUpstreamCommittedWithStatus(directory);
+    const evidence = _internals102.buildIsUpstreamCommittedWithStatus(directory);
     isUpstreamCommitted = evidence.gitFailed ? () => false : evidence.predicate;
   }
-  const verdict = _internals101.decideEpicActivation(tasks, pairs, commitsObserved, {
+  const verdict = _internals102.decideEpicActivation(tasks, pairs, commitsObserved, {
     activationThreshold: effectiveThreshold,
     minCommitsForSignal,
     cochangeNpmiThreshold,
@@ -135526,7 +135634,7 @@ async function executeEpicDecidePhase(args2) {
     isUpstreamCommitted
   });
   try {
-    _internals101.appendPromotionEvidence(directory, {
+    _internals102.appendPromotionEvidence(directory, {
       timestamp: new Date().toISOString(),
       sessionID,
       phase,
@@ -135536,7 +135644,7 @@ async function executeEpicDecidePhase(args2) {
     warn(`[epic_run_phase] promotion-evidence append failed: ${err instanceof Error ? err.message : String(err)}`);
   }
   try {
-    _internals101.recordEpicDecision(directory, sessionID, {
+    _internals102.recordEpicDecision(directory, sessionID, {
       decidedAt: new Date().toISOString(),
       phase,
       decision: verdict.decision,
@@ -135833,7 +135941,7 @@ function candidateFilePath(storePath3, id) {
   }
   return path173.join(storePath3, `${id}.json`);
 }
-var _internals102 = {
+var _internals103 = {
   randomUUID: crypto12.randomUUID.bind(crypto12),
   fs: {
     mkdir: fs108.mkdir,
@@ -135846,11 +135954,11 @@ var _internals102 = {
 function createExternalSkillStore(directory, config3) {
   const storePath3 = path173.join(directory, ".swarm", "skills", "candidates");
   async function add2(candidate) {
-    const id = _internals102.randomUUID();
+    const id = _internals103.randomUUID();
     const full = { ...candidate, id };
     const filePath = path173.join(storePath3, `${id}.json`);
-    await _internals102.fs.mkdir(storePath3, { recursive: true });
-    await _internals102.atomicWriteFile(filePath, JSON.stringify(full, null, "\t"));
+    await _internals103.fs.mkdir(storePath3, { recursive: true });
+    await _internals103.atomicWriteFile(filePath, JSON.stringify(full, null, "\t"));
     return full;
   }
   async function get2(id) {
@@ -135860,7 +135968,7 @@ function createExternalSkillStore(directory, config3) {
     }
     let raw;
     try {
-      raw = await _internals102.fs.readFile(filePath, "utf-8");
+      raw = await _internals103.fs.readFile(filePath, "utf-8");
     } catch (err) {
       if (err.code === "ENOENT") {
         return null;
@@ -135876,7 +135984,7 @@ function createExternalSkillStore(directory, config3) {
   async function list(filter) {
     let entries;
     try {
-      entries = await _internals102.fs.readdir(storePath3);
+      entries = await _internals103.fs.readdir(storePath3);
     } catch (err) {
       if (err.code === "ENOENT") {
         return [];
@@ -135891,7 +135999,7 @@ function createExternalSkillStore(directory, config3) {
       const filePath = path173.join(storePath3, entry);
       let raw;
       try {
-        raw = await _internals102.fs.readFile(filePath, "utf-8");
+        raw = await _internals103.fs.readFile(filePath, "utf-8");
       } catch {
         continue;
       }
@@ -135958,7 +136066,7 @@ function createExternalSkillStore(directory, config3) {
         ...patch.evaluation_history
       ];
     }
-    await _internals102.atomicWriteFile(filePath, JSON.stringify(updated, null, "\t"));
+    await _internals103.atomicWriteFile(filePath, JSON.stringify(updated, null, "\t"));
     return updated;
   }
   async function deleteCandidate(id) {
@@ -135967,7 +136075,7 @@ function createExternalSkillStore(directory, config3) {
       return false;
     }
     try {
-      await _internals102.fs.unlink(filePath);
+      await _internals103.fs.unlink(filePath);
       return true;
     } catch (err) {
       if (err.code === "ENOENT") {
@@ -136005,7 +136113,7 @@ function createExternalSkillStore(directory, config3) {
 
 // src/tools/external-skill-delete.ts
 init_create_tool();
-var _internals103 = {
+var _internals104 = {
   loadConfig: (directory) => {
     const pluginConfig = loadPluginConfig(directory);
     return pluginConfig.external_skills;
@@ -136027,7 +136135,7 @@ var external_skill_delete = createSwarmTool({
     } catch {}
     let config3;
     try {
-      config3 = _internals103.loadConfig(directory);
+      config3 = _internals104.loadConfig(directory);
     } catch {
       return JSON.stringify({
         success: false,
@@ -136606,7 +136714,7 @@ function scanProvenanceIntegrity(candidate, trustLevel = "low", ttlDays) {
     });
   }
   fieldsScanned.push("fetched_at");
-  const now = new Date(_internals104.getTimestamp()).getTime();
+  const now = new Date(_internals105.getTimestamp()).getTime();
   const fetchedAtMs = new Date(candidate.fetched_at).getTime();
   if (Number.isNaN(fetchedAtMs)) {
     findings.push({
@@ -136670,7 +136778,7 @@ function scanProvenanceIntegrity(candidate, trustLevel = "low", ttlDays) {
     });
   }
   fieldsScanned.push("skill_body");
-  const computedHash = _internals104.computeSha256(candidate.skill_body);
+  const computedHash = _internals105.computeSha256(candidate.skill_body);
   if (computedHash !== candidate.sha256) {
     findings.push({
       pattern: "content_hash_mismatch",
@@ -136720,7 +136828,7 @@ function evaluateCandidate(candidate, options) {
     risk_flags: riskFlags
   };
 }
-var _internals104 = {
+var _internals105 = {
   getTimestamp: () => new Date().toISOString(),
   computeSha256: (content) => createHash22("sha256").update(content).digest("hex"),
   splitMarkdownCodeSegments,
@@ -136730,7 +136838,7 @@ var _internals104 = {
 
 // src/tools/external-skill-discover.ts
 init_create_tool();
-var _internals105 = {
+var _internals106 = {
   fetchContent: async (_url3, _timeoutMs) => {
     const parsed = new URL(_url3);
     if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
@@ -136891,7 +136999,7 @@ var external_skill_discover = createSwarmTool({
       resolvedContent = content;
     } else {
       try {
-        const fetched = await _internals105.fetchContent(resolvedUrl, config3.fetch_timeout_ms);
+        const fetched = await _internals106.fetchContent(resolvedUrl, config3.fetch_timeout_ms);
         if (fetched.finalUrl !== resolvedUrl && matchedSource && !isSubpathUrl(fetched.finalUrl, matchedSource.location)) {
           return JSON.stringify({
             success: false,
@@ -136913,14 +137021,14 @@ var external_skill_discover = createSwarmTool({
         error: `Content too large: ${resolvedContent.length} bytes exceeds max_bytes_per_candidate (${config3.max_bytes_per_candidate})`
       });
     }
-    const sha256 = _internals105.computeSha256(resolvedContent);
+    const sha256 = _internals106.computeSha256(resolvedContent);
     const candidate = {
-      id: _internals105.uuid(),
+      id: _internals106.uuid(),
       source_url: resolvedUrl,
       source_type: sourceType,
       publisher,
       sha256,
-      fetched_at: _internals105.getTimestamp(),
+      fetched_at: _internals106.getTimestamp(),
       skill_name: typeof skillName === "string" ? skillName : undefined,
       skill_description: typeof skillDescription === "string" ? skillDescription : undefined,
       skill_body: resolvedContent,
@@ -136938,7 +137046,7 @@ var external_skill_discover = createSwarmTool({
     candidate.evaluation_history = [
       {
         verdict: result.overall_verdict,
-        timestamp: _internals105.getTimestamp(),
+        timestamp: _internals106.getTimestamp(),
         actor: "system",
         reason: `Validation: ${result.gate_results.length} gates, ${result.all_findings.length} findings`,
         gate_results: result.gate_results.map((gr) => ({
@@ -136983,7 +137091,7 @@ var external_skill_discover = createSwarmTool({
 init_zod();
 init_loader();
 init_create_tool();
-var _internals106 = {
+var _internals107 = {
   loadConfig: (directory) => {
     const pluginConfig = loadPluginConfig(directory);
     return pluginConfig.external_skills;
@@ -137005,7 +137113,7 @@ var external_skill_inspect = createSwarmTool({
     } catch {}
     let config3;
     try {
-      config3 = _internals106.loadConfig(directory);
+      config3 = _internals107.loadConfig(directory);
     } catch {
       return JSON.stringify({
         success: false,
@@ -137047,7 +137155,7 @@ var external_skill_inspect = createSwarmTool({
 init_zod();
 init_loader();
 init_create_tool();
-var _internals107 = {
+var _internals108 = {
   loadConfig: (directory) => {
     const pluginConfig = loadPluginConfig(directory);
     return pluginConfig.external_skills;
@@ -137083,7 +137191,7 @@ var external_skill_list = createSwarmTool({
     } catch {}
     let config3;
     try {
-      config3 = _internals107.loadConfig(directory);
+      config3 = _internals108.loadConfig(directory);
     } catch {
       return JSON.stringify({
         success: false,
@@ -137136,7 +137244,7 @@ import { createHash as createHash24 } from "node:crypto";
 import * as fs109 from "node:fs/promises";
 import * as path174 from "node:path";
 init_create_tool();
-var _internals108 = {
+var _internals109 = {
   loadConfig: (directory) => {
     const pluginConfig = loadPluginConfig(directory);
     return pluginConfig.external_skills;
@@ -137206,7 +137314,7 @@ var external_skill_promote = createSwarmTool({
     } catch {}
     let config3;
     try {
-      config3 = _internals108.loadConfig(directory);
+      config3 = _internals109.loadConfig(directory);
     } catch {
       return JSON.stringify({
         success: false,
@@ -137276,8 +137384,8 @@ var external_skill_promote = createSwarmTool({
       }
       const targetDir = path174.join(directory, ".opencode", "skills", "generated", sanitizedSlug);
       const targetPath = path174.join(targetDir, "SKILL.md");
-      const timestamp = _internals108.getTimestamp();
-      const alreadyExists = await _internals108.fileExists(targetPath);
+      const timestamp = _internals109.getTimestamp();
+      const alreadyExists = await _internals109.fileExists(targetPath);
       if (alreadyExists) {
         return JSON.stringify({
           success: false,
@@ -137286,7 +137394,7 @@ var external_skill_promote = createSwarmTool({
       }
       const skillMarkdown = buildSkillMarkdown(candidate, sanitizedSlug, timestamp);
       try {
-        await _internals108.writeSkillFile(targetPath, skillMarkdown);
+        await _internals109.writeSkillFile(targetPath, skillMarkdown);
       } catch (writeErr) {
         const writeError = writeErr;
         if (writeError?.code === "EEXIST") {
@@ -137363,7 +137471,7 @@ var external_skill_promote = createSwarmTool({
 init_zod();
 init_loader();
 init_create_tool();
-var _internals109 = {
+var _internals110 = {
   loadConfig: (directory) => {
     const pluginConfig = loadPluginConfig(directory);
     return pluginConfig.external_skills;
@@ -137388,7 +137496,7 @@ var external_skill_reject = createSwarmTool({
     } catch {}
     let config3;
     try {
-      config3 = _internals109.loadConfig(directory);
+      config3 = _internals110.loadConfig(directory);
     } catch {
       return JSON.stringify({
         success: false,
@@ -137451,7 +137559,7 @@ init_zod();
 init_loader();
 import * as path175 from "node:path";
 init_create_tool();
-var _internals110 = {
+var _internals111 = {
   loadConfig: (directory) => {
     const pluginConfig = loadPluginConfig(directory);
     return pluginConfig.external_skills;
@@ -137502,7 +137610,7 @@ var external_skill_revoke = createSwarmTool({
     } catch {}
     let config3;
     try {
-      config3 = _internals110.loadConfig(directory);
+      config3 = _internals111.loadConfig(directory);
     } catch {
       return JSON.stringify({
         success: false,
@@ -137549,8 +137657,8 @@ var external_skill_revoke = createSwarmTool({
         });
       }
       const skillPath = path175.join(directory, ".opencode", "skills", "generated", slug, "SKILL.md");
-      const skillFileRemoved = await _internals110.retireSkillFile(skillPath);
-      const timestamp = _internals110.getTimestamp();
+      const skillFileRemoved = await _internals111.retireSkillFile(skillPath);
+      const timestamp = _internals111.getTimestamp();
       const historyEntry = {
         verdict: "revoked",
         timestamp,
@@ -138071,7 +138179,7 @@ var ISSUE_FIELD_ALLOWLIST = new Set([
   "updatedAt"
 ]);
 function resolveGhBinary() {
-  return _internals111.resolveExecutableFromPath(["gh"]);
+  return _internals112.resolveExecutableFromPath(["gh"]);
 }
 function normalizeRepo(value) {
   if (value === undefined || value === null || value === "")
@@ -138159,7 +138267,7 @@ var gh_evidence = createSwarmTool({
     if (!Array.isArray(fields)) {
       return JSON.stringify(fields, null, 2);
     }
-    const executable = _internals111.resolveGhBinary();
+    const executable = _internals112.resolveGhBinary();
     if (!executable) {
       return JSON.stringify({
         error: true,
@@ -138171,7 +138279,7 @@ var gh_evidence = createSwarmTool({
     if (repo) {
       ghArgs.push("--repo", repo);
     }
-    const run = await _internals111.runExternalTool({
+    const run = await _internals112.runExternalTool({
       executable,
       args: ghArgs,
       cwd: directory,
@@ -138222,7 +138330,7 @@ var gh_evidence = createSwarmTool({
     }, null, 2);
   }
 });
-var _internals111 = {
+var _internals112 = {
   resolveExecutableFromPath,
   resolveGhBinary,
   runExternalTool
@@ -140232,7 +140340,7 @@ init_zod();
 init_config();
 init_state2();
 init_create_tool();
-var _internals112 = {
+var _internals113 = {
   LeanTurboRunner,
   loadPluginConfigWithMeta
 };
@@ -140242,9 +140350,9 @@ async function executeLeanTurboRunPhase(args2) {
   let runError = null;
   let runner = null;
   try {
-    const { config: config3 } = _internals112.loadPluginConfigWithMeta(directory);
+    const { config: config3 } = _internals113.loadPluginConfigWithMeta(directory);
     const leanConfig = config3.turbo?.strategy === "lean" ? config3.turbo.lean : undefined;
-    runner = new _internals112.LeanTurboRunner({
+    runner = new _internals113.LeanTurboRunner({
       directory,
       sessionID,
       opencodeClient: swarmState.opencodeClient ?? null,
@@ -140580,7 +140688,7 @@ function isStaticallyEquivalent(originalCode, mutatedCode) {
   const strippedMutated = stripCode(mutatedCode);
   return strippedOriginal === strippedMutated;
 }
-var _internals113 = {
+var _internals114 = {
   isStaticallyEquivalent,
   checkEquivalence,
   batchCheckEquivalence
@@ -140620,7 +140728,7 @@ async function batchCheckEquivalence(patches, llmJudge) {
   const results = [];
   for (const { patch, originalCode, mutatedCode } of patches) {
     try {
-      const result = await _internals113.checkEquivalence(patch, originalCode, mutatedCode, llmJudge);
+      const result = await _internals114.checkEquivalence(patch, originalCode, mutatedCode, llmJudge);
       results.push(result);
     } catch (err) {
       results.push({
@@ -140680,7 +140788,7 @@ function validateTestCommand(testCommand) {
 var MUTATION_TIMEOUT_MS = 30000;
 var TOTAL_BUDGET_MS = 300000;
 var GIT_APPLY_TIMEOUT_MS = 5000;
-var _internals114 = {
+var _internals115 = {
   executeMutation,
   computeReport,
   executeMutationSuite,
@@ -140712,7 +140820,7 @@ async function executeMutation(patch, testCommand, testFiles, workingDir) {
       };
     }
     try {
-      const applyResult = _internals114.spawnSync("git", ["apply", "--", patchFile], {
+      const applyResult = _internals115.spawnSync("git", ["apply", "--", patchFile], {
         cwd: workingDir,
         timeout: GIT_APPLY_TIMEOUT_MS,
         stdio: "pipe"
@@ -140743,7 +140851,7 @@ async function executeMutation(patch, testCommand, testFiles, workingDir) {
     try {
       const safeTestFiles = testFiles.filter((f) => !f.startsWith("-"));
       const testArgs = safeTestFiles.length > 0 ? [...testCommand.slice(1), ...safeTestFiles] : testCommand.slice(1);
-      const spawnResult = _internals114.spawnSync(testCommand[0], testArgs, {
+      const spawnResult = _internals115.spawnSync(testCommand[0], testArgs, {
         cwd: workingDir,
         timeout: MUTATION_TIMEOUT_MS,
         stdio: "pipe"
@@ -140776,7 +140884,7 @@ async function executeMutation(patch, testCommand, testFiles, workingDir) {
   } finally {
     if (patchFile) {
       try {
-        const revertResult = _internals114.spawnSync("git", ["apply", "-R", "--", patchFile], {
+        const revertResult = _internals115.spawnSync("git", ["apply", "-R", "--", patchFile], {
           cwd: workingDir,
           timeout: GIT_APPLY_TIMEOUT_MS,
           stdio: "pipe"
@@ -140973,7 +141081,7 @@ async function executeMutationSuite(patches, testCommand, testFiles, workingDir,
 }
 
 // src/mutation/gate.ts
-var _internals115 = {
+var _internals116 = {
   evaluateMutationGate,
   buildTestImprovementPrompt,
   buildMessage
@@ -140994,8 +141102,8 @@ function evaluateMutationGate(report, passThreshold = PASS_THRESHOLD, warnThresh
   } else {
     verdict = "fail";
   }
-  const testImprovementPrompt = _internals115.buildTestImprovementPrompt(report, passThreshold, verdict);
-  const message = _internals115.buildMessage(verdict, adjustedKillRate, report.killed, report.totalMutants, report.equivalent, warnThreshold);
+  const testImprovementPrompt = _internals116.buildTestImprovementPrompt(report, passThreshold, verdict);
+  const message = _internals116.buildMessage(verdict, adjustedKillRate, report.killed, report.totalMutants, report.equivalent, warnThreshold);
   return {
     verdict,
     killRate: report.killRate,
@@ -141140,7 +141248,7 @@ var OSV_MAX_STDERR_BYTES = 256 * 1024;
 var DEFAULT_MAX_RESULTS3 = 200;
 var HARD_CAP_RESULTS3 = 2000;
 function resolveOsvScannerBinary() {
-  return _internals116.resolveExecutableFromPath(["osv-scanner"]);
+  return _internals117.resolveExecutableFromPath(["osv-scanner"]);
 }
 function normalizeScanPath(value, workspace) {
   const raw = typeof value === "string" && value.trim() ? value.trim() : ".";
@@ -141228,7 +141336,7 @@ var osv_scan = createSwarmTool({
       }, null, 2);
     }
     const maxResults = sanitizeMaxResults2(obj.max_results);
-    const executable = _internals116.resolveOsvScannerBinary();
+    const executable = _internals117.resolveOsvScannerBinary();
     if (!executable) {
       return JSON.stringify({
         error: true,
@@ -141238,7 +141346,7 @@ var osv_scan = createSwarmTool({
     }
     const target = scanPath === "." ? "." : `./${scanPath}`;
     const osvArgs = ["scan", "--format", "json", target];
-    const run = await _internals116.runExternalTool({
+    const run = await _internals117.runExternalTool({
       executable,
       args: osvArgs,
       cwd: directory,
@@ -141288,7 +141396,7 @@ var osv_scan = createSwarmTool({
     }, null, 2);
   }
 });
-var _internals116 = {
+var _internals117 = {
   resolveExecutableFromPath,
   resolveOsvScannerBinary,
   runExternalTool,
@@ -142092,6 +142200,7 @@ var parse_lane_candidates = createSwarmTool({
 // src/tools/phase-complete.ts
 init_zod();
 init_config();
+init_plan_schema();
 init_schema();
 init_manager2();
 init_task_file();
@@ -142986,7 +143095,7 @@ function listLaneEvidenceSync(directory, phase) {
   }
   return laneIds;
 }
-var _internals117 = {
+var _internals118 = {
   listActiveLocks,
   readPersisted: readPersisted3,
   readPlanJson: defaultReadPlanJson,
@@ -143047,7 +143156,7 @@ function verifyLeanTurboPhaseReady(directory, phase, sessionIDOrConfig, config3)
       reason: "Lean Turbo state unreadable or missing"
     };
   }
-  const persisted = _internals117.readPersisted(directory);
+  const persisted = _internals118.readPersisted(directory);
   if (!persisted) {
     return {
       ok: false,
@@ -143111,7 +143220,7 @@ function verifyLeanTurboPhaseReady(directory, phase, sessionIDOrConfig, config3)
     }
   }
   if (runState.lanes.length > 0) {
-    const evidenceLaneIds = new Set(_internals117.listLaneEvidenceSync(directory, phase));
+    const evidenceLaneIds = new Set(_internals118.listLaneEvidenceSync(directory, phase));
     for (const lane of runState.lanes) {
       if ((lane.status === "completed" || lane.status === "failed") && !evidenceLaneIds.has(lane.laneId)) {
         return {
@@ -143121,7 +143230,7 @@ function verifyLeanTurboPhaseReady(directory, phase, sessionIDOrConfig, config3)
       }
     }
   }
-  const activeLocks = _internals117.listActiveLocks(directory);
+  const activeLocks = _internals118.listActiveLocks(directory);
   const phaseLaneIds = new Set(laneIds);
   for (const lock of activeLocks) {
     if (lock.laneId && phaseLaneIds.has(lock.laneId)) {
@@ -143141,7 +143250,7 @@ function verifyLeanTurboPhaseReady(directory, phase, sessionIDOrConfig, config3)
   }
   const serialDegradedTasks = runState.degradedTasks.filter((dt) => !laneTaskIds.has(dt.taskId));
   if (serialDegradedTasks.length > 0) {
-    const plan = _internals117.readPlanJson(directory);
+    const plan = _internals118.readPlanJson(directory);
     if (!plan) {
       return {
         ok: false,
@@ -143185,7 +143294,7 @@ function verifyLeanTurboPhaseReady(directory, phase, sessionIDOrConfig, config3)
   }
   const serializedTasks = runState.serializedTasks;
   if (Array.isArray(serializedTasks) && serializedTasks.length > 0) {
-    const plan = _internals117.readPlanJson(directory);
+    const plan = _internals118.readPlanJson(directory);
     if (!plan) {
       return {
         ok: false,
@@ -143244,7 +143353,7 @@ function verifyLeanTurboPhaseReady(directory, phase, sessionIDOrConfig, config3)
   }
   let reviewerVerdict = runState.lastReviewerVerdict;
   if (!reviewerVerdict) {
-    const evidence = _internals117.readReviewerEvidence(directory, phase);
+    const evidence = _internals118.readReviewerEvidence(directory, phase);
     reviewerVerdict = evidence?.verdict ?? undefined;
   }
   if (mergedConfig.phase_reviewer) {
@@ -143257,7 +143366,7 @@ function verifyLeanTurboPhaseReady(directory, phase, sessionIDOrConfig, config3)
   }
   let criticVerdict = runState.lastCriticVerdict;
   if (!criticVerdict) {
-    const evidence = _internals117.readCriticEvidence(directory, phase);
+    const evidence = _internals118.readCriticEvidence(directory, phase);
     criticVerdict = evidence?.verdict ?? undefined;
   }
   if (mergedConfig.phase_critic) {
@@ -144243,6 +144352,29 @@ function collectCrossSessionDispatchedAgents(phaseReferenceTimestamp, callerSess
   }
   return { agents, contributorSessionIds };
 }
+async function fallbackWritePlanWithTrace(dir, planPath, candidate, phase, warnings) {
+  const validation2 = PlanSchema.safeParse(candidate);
+  if (!validation2.success) {
+    const detail = validation2.error.issues.slice(0, 5).map((issue3) => `${issue3.path.join(".") || "<root>"}: ${issue3.message}`).join("; ");
+    warn("[phase_complete] Last-resort plan.json write aborted — mutated plan failed PlanSchema validation:", detail);
+    warnings.push(`Warning: last-resort plan.json write skipped — mutated plan failed schema validation (${detail})`);
+    return false;
+  }
+  await atomicWriteFile(planPath, JSON.stringify(validation2.data, null, 2));
+  try {
+    const traceEvent = {
+      event: "phase_complete_fallback_write",
+      phase,
+      timestamp: new Date().toISOString()
+    };
+    const eventsPath = validateSwarmPath(dir, "events.jsonl");
+    fs125.appendFileSync(eventsPath, `${JSON.stringify(traceEvent)}
+`, "utf-8");
+  } catch (eventError) {
+    warnings.push(`Warning: failed to record phase_complete_fallback_write trace event: ${eventError instanceof Error ? eventError.message : String(eventError)}`);
+  }
+  return true;
+}
 function _getDelegationsSince(sessionID, sinceTimestamp) {
   const chain = swarmState.delegationChains.get(sessionID);
   if (!chain) {
@@ -144548,7 +144680,7 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
       phase_critic: leanConfig.phase_critic,
       integrated_diff_required: leanConfig.integrated_diff_required
     } : undefined;
-    const leanCheck = _internals117.verifyLeanTurboPhaseReady(dir, phase, sessionID, leanPhaseReadyConfig);
+    const leanCheck = _internals118.verifyLeanTurboPhaseReady(dir, phase, sessionID, leanPhaseReadyConfig);
     if (!leanCheck.ok) {
       return JSON.stringify({
         success: false,
@@ -144959,6 +145091,22 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
     }
     try {
       const plan = await loadPlan(dir);
+      const runtimePlan = plan;
+      if (runtimePlan?._ledgerReplayStale === true) {
+        const staleReason = runtimePlan._ledgerReplayStaleReason ?? "unknown reason";
+        return JSON.stringify({
+          success: false,
+          phase: args2.phase,
+          status: "incomplete",
+          message: `Plan write refused: plan.json is stale from a failed ledger replay (${staleReason}). Refusing to complete phase ${args2.phase} against a known-stale plan.`,
+          agentsDispatched,
+          agentsMissing,
+          warnings,
+          errors: [`Stale plan from failed ledger replay: ${staleReason}`],
+          recovery_guidance: "The ledger replay failed and no critic-approved snapshot was available, so loadPlan fell back to a stale plan.json. Do NOT retry blindly. Recover first: re-verify the plan (re-run completion verification), reset the session, or restore from the latest checkpoint under .swarm/plan-export/, then retry phase_complete.",
+          _ledgerReplayStaleReason: staleReason
+        });
+      }
       if (plan === null) {
         if (await ledgerExists(dir)) {
           try {
@@ -144985,7 +145133,7 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
           const phaseObj = plan2.phases.find((p) => p.id === phase);
           if (phaseObj) {
             phaseObj.status = "complete";
-            await atomicWriteFile(planPath, JSON.stringify(plan2, null, 2));
+            await fallbackWritePlanWithTrace(dir, planPath, plan2, phase, warnings);
           }
         } catch {}
       } else if (plan) {
@@ -145027,7 +145175,7 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
         const phaseObj = plan.phases.find((p) => p.id === phase);
         if (phaseObj) {
           phaseObj.status = "complete";
-          await atomicWriteFile(planPath, JSON.stringify(plan, null, 2));
+          await fallbackWritePlanWithTrace(dir, planPath, plan, phase, warnings);
         }
       } catch {}
     } finally {
@@ -146945,11 +147093,11 @@ var quality_budget = createSwarmTool({
     }).optional().describe("Quality budget thresholds")
   },
   async execute(args2, directory) {
-    const result = await _internals119.qualityBudget(args2, directory);
+    const result = await _internals120.qualityBudget(args2, directory);
     return JSON.stringify(result);
   }
 });
-var _internals119 = {
+var _internals120 = {
   qualityBudget
 };
 
@@ -147674,7 +147822,7 @@ var DEFAULT_RULES_DIR = ".swarm/semgrep-rules";
 var DEFAULT_TIMEOUT_MS4 = 30000;
 var MAX_OUTPUT_BYTES8 = 10 * 1024 * 1024;
 var KILL_GRACE_MS = 2000;
-var _internals120 = {
+var _internals121 = {
   isSemgrepAvailable,
   checkSemgrepAvailable,
   resetSemgrepCache,
@@ -147700,7 +147848,7 @@ function isSemgrepAvailable() {
   }
 }
 async function checkSemgrepAvailable() {
-  return _internals120.isSemgrepAvailable();
+  return _internals121.isSemgrepAvailable();
 }
 function resetSemgrepCache() {
   semgrepAvailableCache = null;
@@ -147886,12 +148034,12 @@ async function runSemgrep(options) {
   const timeoutMs = options.timeoutMs || DEFAULT_TIMEOUT_MS4;
   if (files.length === 0) {
     return {
-      available: _internals120.isSemgrepAvailable(),
+      available: _internals121.isSemgrepAvailable(),
       findings: [],
       engine: "tier_a"
     };
   }
-  if (!_internals120.isSemgrepAvailable()) {
+  if (!_internals121.isSemgrepAvailable()) {
     return {
       available: false,
       findings: [],
@@ -148058,7 +148206,7 @@ function assignOccurrenceIndices(findings, directory) {
     }
     const occIdx = countMap.get(baseKey) ?? 0;
     countMap.set(baseKey, occIdx + 1);
-    const fp = _internals121.fingerprintFinding(finding, directory, occIdx);
+    const fp = _internals122.fingerprintFinding(finding, directory, occIdx);
     return {
       finding,
       index: occIdx,
@@ -148127,7 +148275,7 @@ async function captureOrMergeBaseline(directory, phase, findings, engine, scanne
       }
     } catch {}
     const scannedRelFiles = new Set(scannedFiles.map((f) => normalizeFindingPath(directory, f)));
-    const indexed = _internals121.assignOccurrenceIndices(findings, directory);
+    const indexed = _internals122.assignOccurrenceIndices(findings, directory);
     if (existing && !opts?.force) {
       const prunedFingerprints = existing.fingerprints.filter((fp) => {
         const relFile = fp.slice(0, fp.indexOf("|"));
@@ -148267,7 +148415,7 @@ function loadBaseline(directory, phase) {
     };
   }
 }
-var _internals121 = {
+var _internals122 = {
   fingerprintFinding,
   assignOccurrenceIndices,
   captureOrMergeBaseline,
@@ -148677,11 +148825,11 @@ var sast_scan = createSwarmTool({
       capture_baseline: safeArgs.capture_baseline,
       phase: safeArgs.phase
     };
-    const result = await _internals122.sastScan(input, directory);
+    const result = await _internals123.sastScan(input, directory);
     return JSON.stringify(result, null, 2);
   }
 });
-var _internals122 = {
+var _internals123 = {
   sastScan,
   sast_scan
 };
@@ -152255,10 +152403,10 @@ function resolvePackagedRipgrep() {
   }
 }
 function resolveRipgrepBinary() {
-  return _internals123.resolvePackagedRipgrep() ?? _internals123.resolveExecutableFromPath(["rg"]);
+  return _internals124.resolvePackagedRipgrep() ?? _internals124.resolveExecutableFromPath(["rg"]);
 }
 async function ripgrepSearch(opts) {
-  const rgPath = _internals123.resolveRipgrepBinary();
+  const rgPath = _internals124.resolveRipgrepBinary();
   if (!rgPath) {
     return {
       error: true,
@@ -152281,7 +152429,7 @@ async function ripgrepSearch(opts) {
     args2.push("--fixed-strings");
   }
   args2.push("--", opts.query, ".");
-  const run = await _internals123.runExternalTool({
+  const run = await _internals124.runExternalTool({
     executable: rgPath,
     args: args2,
     cwd: opts.workspace,
@@ -152585,7 +152733,7 @@ var search = createSwarmTool({
       }, null, 2);
     }
     let result;
-    if (_internals123.resolveRipgrepBinary()) {
+    if (_internals124.resolveRipgrepBinary()) {
       result = await ripgrepSearch({
         query,
         mode,
@@ -152612,7 +152760,7 @@ var search = createSwarmTool({
     return JSON.stringify(result, null, 2);
   }
 });
-var _internals123 = {
+var _internals124 = {
   resolvePackagedRipgrep,
   resolveExecutableFromPath,
   resolveRipgrepBinary,
@@ -152973,18 +153121,18 @@ var run_stale_reconciliation = createSwarmTool({
     if (typeof directory !== "string" || !directory) {
       return JSON.stringify({ found: 0, skills: [] }, null, 2);
     }
-    const archivedIds = await _internals124.getArchivedKnowledgeIds(directory);
+    const archivedIds = await _internals125.getArchivedKnowledgeIds(directory);
     const archivedSet = new Set(archivedIds);
     const allKnownIds = new Set;
-    const swarmPath = _internals124.resolveSwarmKnowledgePath(directory);
-    const hivePath = _internals124.resolveHiveKnowledgePath();
+    const swarmPath = _internals125.resolveSwarmKnowledgePath(directory);
+    const hivePath = _internals125.resolveHiveKnowledgePath();
     try {
-      const swarmEntries = await _internals124.readKnowledge(swarmPath);
+      const swarmEntries = await _internals125.readKnowledge(swarmPath);
       for (const e of swarmEntries)
         allKnownIds.add(e.id);
     } catch {}
     try {
-      const hiveEntries = await _internals124.readKnowledge(hivePath);
+      const hiveEntries = await _internals125.readKnowledge(hivePath);
       for (const e of hiveEntries)
         allKnownIds.add(e.id);
     } catch {}
@@ -152993,9 +153141,9 @@ var run_stale_reconciliation = createSwarmTool({
       join166(directory, ".opencode", "skills", "generated"),
       join166(directory, ".swarm", "skills", "proposals")
     ]) {
-      if (!_internals124.existsSync(dir))
+      if (!_internals125.existsSync(dir))
         continue;
-      const entries = await _internals124.readdir(dir, { withFileTypes: true });
+      const entries = await _internals125.readdir(dir, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.isDirectory()) {
           skillEntries.push({
@@ -153016,10 +153164,10 @@ var run_stale_reconciliation = createSwarmTool({
     const results = [];
     for (const { slug, path: path210, isProposal } of skillEntries) {
       const skillMdPath = isProposal ? path210 : join166(path210, "SKILL.md");
-      if (!_internals124.existsSync(skillMdPath))
+      if (!_internals125.existsSync(skillMdPath))
         continue;
-      const content = await _internals124.readFile(skillMdPath, "utf-8");
-      const fm = _internals124.parseDraftFrontmatter(content);
+      const content = await _internals125.readFile(skillMdPath, "utf-8");
+      const fm = _internals125.parseDraftFrontmatter(content);
       const sourceIds = fm?.sourceKnowledgeIds ?? [];
       if (sourceIds.length === 0)
         continue;
@@ -153029,9 +153177,9 @@ var run_stale_reconciliation = createSwarmTool({
       if (args2.clear) {
         if (!isProposal) {
           const markerPath = join166(path210, "stale.marker");
-          if (_internals124.existsSync(markerPath)) {
+          if (_internals125.existsSync(markerPath)) {
             try {
-              await _internals124.clearSkillStale(path210);
+              await _internals125.clearSkillStale(path210);
               results.push({
                 slug,
                 reason: affected.join(", "),
@@ -153043,7 +153191,7 @@ var run_stale_reconciliation = createSwarmTool({
       } else {
         if (!isProposal) {
           try {
-            await _internals124.retireOrMarkStale(directory, path210, archivedSet);
+            await _internals125.retireOrMarkStale(directory, path210, archivedSet);
             results.push({
               slug,
               reason: affected.join(", "),
@@ -153056,7 +153204,7 @@ var run_stale_reconciliation = createSwarmTool({
     return JSON.stringify({ found: results.length, skills: results }, null, 2);
   }
 });
-var _internals124 = {
+var _internals125 = {
   run_stale_reconciliation,
   clearSkillStale,
   retireOrMarkStale,
@@ -154034,7 +154182,7 @@ var swarm_memory_propose = createSwarmTool({
     evidenceRefs: exports_external.array(exports_external.string().min(1).max(500)).max(20).optional().describe("Evidence refs such as files, commits, test outputs, or URLs")
   },
   execute: async (args2, directory, ctx) => {
-    const { config: config3 } = _internals125.loadPluginConfigWithMeta(directory);
+    const { config: config3 } = _internals126.loadPluginConfigWithMeta(directory);
     if (config3.memory?.enabled !== true) {
       return JSON.stringify({
         success: false,
@@ -154050,7 +154198,7 @@ var swarm_memory_propose = createSwarmTool({
       });
     }
     const agent = getContextAgent3(ctx);
-    const gateway = _internals125.createMemoryGateway({
+    const gateway = _internals126.createMemoryGateway({
       directory,
       sessionID: ctx?.sessionID,
       agentRole: agent,
@@ -154075,7 +154223,7 @@ var swarm_memory_propose = createSwarmTool({
     }
   }
 });
-var _internals125 = {
+var _internals126 = {
   loadPluginConfigWithMeta,
   createMemoryGateway
 };
@@ -154113,7 +154261,7 @@ var swarm_memory_recall = createSwarmTool({
     maxItems: exports_external.number().int().min(1).max(20).optional().describe("Maximum memories to return")
   },
   execute: async (args2, directory, ctx) => {
-    const { config: config3 } = _internals126.loadPluginConfigWithMeta(directory);
+    const { config: config3 } = _internals127.loadPluginConfigWithMeta(directory);
     if (config3.memory?.enabled !== true) {
       return JSON.stringify({
         success: false,
@@ -154129,7 +154277,7 @@ var swarm_memory_recall = createSwarmTool({
       });
     }
     const agent = getContextAgent4(ctx);
-    const gateway = _internals126.createMemoryGateway({
+    const gateway = _internals127.createMemoryGateway({
       directory,
       sessionID: ctx?.sessionID,
       agentRole: agent,
@@ -154162,7 +154310,7 @@ var RecallArgsSchema = exports_external.object({
   kinds: exports_external.array(exports_external.enum(MEMORY_KINDS2)).optional(),
   maxItems: exports_external.number().int().min(1).max(20).optional()
 });
-var _internals126 = {
+var _internals127 = {
   loadPluginConfigWithMeta,
   createMemoryGateway
 };
@@ -154688,7 +154836,7 @@ import * as path215 from "node:path";
 init_bun_compat();
 import * as fs140 from "node:fs";
 import * as path214 from "node:path";
-var _internals127 = { bunSpawn };
+var _internals128 = { bunSpawn };
 var _swarmGitExcludedChecked = false;
 function fileCoversSwarm(content) {
   for (const rawLine of content.split(`
@@ -154721,7 +154869,7 @@ async function ensureSwarmGitExcluded(directory, options = {}) {
       checkIgnoreExitCode
     ] = await Promise.all([
       (async () => {
-        const proc = _internals127.bunSpawn(["git", "-C", directory, "rev-parse", "--show-toplevel"], GIT_SPAWN_OPTIONS);
+        const proc = _internals128.bunSpawn(["git", "-C", directory, "rev-parse", "--show-toplevel"], GIT_SPAWN_OPTIONS);
         try {
           return await Promise.all([proc.exited, proc.stdout.text()]);
         } finally {
@@ -154731,7 +154879,7 @@ async function ensureSwarmGitExcluded(directory, options = {}) {
         }
       })(),
       (async () => {
-        const proc = _internals127.bunSpawn(["git", "-C", directory, "rev-parse", "--git-path", "info/exclude"], GIT_SPAWN_OPTIONS);
+        const proc = _internals128.bunSpawn(["git", "-C", directory, "rev-parse", "--git-path", "info/exclude"], GIT_SPAWN_OPTIONS);
         try {
           return await Promise.all([proc.exited, proc.stdout.text()]);
         } finally {
@@ -154741,7 +154889,7 @@ async function ensureSwarmGitExcluded(directory, options = {}) {
         }
       })(),
       (async () => {
-        const proc = _internals127.bunSpawn(["git", "-C", directory, "check-ignore", "-q", ".swarm/.gitkeep"], GIT_SPAWN_OPTIONS);
+        const proc = _internals128.bunSpawn(["git", "-C", directory, "check-ignore", "-q", ".swarm/.gitkeep"], GIT_SPAWN_OPTIONS);
         try {
           return await proc.exited;
         } finally {
@@ -154780,7 +154928,7 @@ async function ensureSwarmGitExcluded(directory, options = {}) {
         }
       } catch {}
     }
-    const trackedProc = _internals127.bunSpawn(["git", "-C", directory, "ls-files", "--", ".swarm"], GIT_SPAWN_OPTIONS);
+    const trackedProc = _internals128.bunSpawn(["git", "-C", directory, "ls-files", "--", ".swarm"], GIT_SPAWN_OPTIONS);
     let trackedExitCode;
     let trackedOutput;
     try {
@@ -154805,7 +154953,7 @@ async function ensureSwarmGitExcluded(directory, options = {}) {
 }
 
 // src/hooks/diff-scope.ts
-var _internals128 = { bunSpawn };
+var _internals129 = { bunSpawn };
 function getDeclaredScope(taskId, directory) {
   try {
     const planPath = path215.join(directory, ".swarm", "plan.json");
@@ -154840,7 +154988,7 @@ var GIT_DIFF_SPAWN_OPTIONS = {
 };
 async function getChangedFiles2(directory) {
   try {
-    const proc = _internals128.bunSpawn(["git", "diff", "--name-only", "HEAD~1"], {
+    const proc = _internals129.bunSpawn(["git", "diff", "--name-only", "HEAD~1"], {
       cwd: directory,
       ...GIT_DIFF_SPAWN_OPTIONS
     });
@@ -154857,7 +155005,7 @@ async function getChangedFiles2(directory) {
       return stdout.trim().split(`
 `).map((f) => f.trim()).filter((f) => f.length > 0);
     }
-    const proc2 = _internals128.bunSpawn(["git", "diff", "--name-only", "HEAD"], {
+    const proc2 = _internals129.bunSpawn(["git", "diff", "--name-only", "HEAD"], {
       cwd: directory,
       ...GIT_DIFF_SPAWN_OPTIONS
     });
@@ -154916,7 +155064,7 @@ init_telemetry();
 init_file_locks();
 import * as fs142 from "node:fs";
 import * as path216 from "node:path";
-var _internals129 = {
+var _internals130 = {
   listActiveLocks,
   verifyLeanTurboTaskCompletion
 };
@@ -155058,7 +155206,7 @@ function verifyLeanTurboTaskCompletion(directory, taskId, sessionID) {
       }
     };
   }
-  const activeLocks = _internals129.listActiveLocks(directory);
+  const activeLocks = _internals130.listActiveLocks(directory);
   const laneLocks = activeLocks.filter((lock) => lock.laneId === lane.laneId);
   if (laneLocks.length > 0) {
     return {
@@ -155125,10 +155273,11 @@ function verifyLeanTurboTaskCompletion(directory, taskId, sessionID) {
 init_task_id();
 init_create_tool();
 init_resolve_working_directory();
-var _internals130 = {
+var _internals131 = {
   tryAcquireLock,
   updateTaskStatus,
-  resolveWorkingDirectory
+  resolveWorkingDirectory,
+  loadPlan
 };
 var VALID_STATUSES2 = [
   "pending",
@@ -155222,7 +155371,7 @@ function checkReviewerGate(taskId, workingDirectory, stageBParallelEnabled = fal
     }
     let resolvedDir;
     if (fallbackDir) {
-      const resolveResult = _internals130.resolveWorkingDirectory(workingDirectory, fallbackDir);
+      const resolveResult = _internals131.resolveWorkingDirectory(workingDirectory, fallbackDir);
       if (resolveResult.success) {
         resolvedDir = resolveResult.directory;
       } else {
@@ -155569,7 +155718,7 @@ async function executeUpdateTaskStatus(args2, fallbackDir, ctx) {
     }
   }
   let directory;
-  const resolveResult = _internals130.resolveWorkingDirectory(args2.working_directory, fallbackDir);
+  const resolveResult = _internals131.resolveWorkingDirectory(args2.working_directory, fallbackDir);
   if (!resolveResult.success) {
     return {
       success: false,
@@ -155599,6 +155748,21 @@ async function executeUpdateTaskStatus(args2, fallbackDir, ctx) {
       };
     }
   }
+  let loadedPlan = null;
+  try {
+    loadedPlan = await _internals131.loadPlan(directory);
+  } catch {
+    loadedPlan = null;
+  }
+  if (loadedPlan?._ledgerReplayStale === true) {
+    const staleReason = loadedPlan._ledgerReplayStaleReason ?? "plan.json is stale relative to the authoritative ledger (.swarm/plan-ledger.jsonl)";
+    return {
+      success: false,
+      message: `Task status update refused: plan.json is stale relative to the ledger (ledger replay failed). ${staleReason}`,
+      errors: [staleReason],
+      recovery_guidance: "Plan state could not be reconciled with the authoritative ledger (.swarm/plan-ledger.jsonl). " + "Restore from a critic-approved snapshot or re-run plan recovery to rebuild plan.json from the ledger, then retry update_task_status."
+    };
+  }
   if (args2.status === "in_progress") {
     try {
       const evidencePath = path217.join(directory, ".swarm", "evidence", `${args2.task_id}.json`);
@@ -155662,7 +155826,7 @@ async function executeUpdateTaskStatus(args2, fallbackDir, ctx) {
   }
   let lockResult;
   try {
-    lockResult = await _internals130.tryAcquireLock(directory, planFilePath, agentName, lockTaskId);
+    lockResult = await _internals131.tryAcquireLock(directory, planFilePath, agentName, lockTaskId);
   } catch (error93) {
     return {
       success: false,
@@ -155681,7 +155845,7 @@ async function executeUpdateTaskStatus(args2, fallbackDir, ctx) {
     };
   }
   try {
-    const updatedPlan = await _internals130.updateTaskStatus(directory, args2.task_id, args2.status);
+    const updatedPlan = await _internals131.updateTaskStatus(directory, args2.task_id, args2.status);
     if (args2.status === "completed") {
       for (const [_sessionId, session] of swarmState.agentSessions) {
         if (!(session.taskWorkflowStates instanceof Map)) {
@@ -156336,7 +156500,7 @@ var web_fetch = createSwarmTool({
       };
       return JSON.stringify(fail, null, 2);
     }
-    const config3 = _internals131.loadPluginConfig(dirResult.directory);
+    const config3 = _internals132.loadPluginConfig(dirResult.directory);
     const generalConfig = config3.council?.general;
     if (!generalConfig || generalConfig.enabled !== true) {
       const fail = {
@@ -156346,7 +156510,7 @@ var web_fetch = createSwarmTool({
       };
       return JSON.stringify(fail, null, 2);
     }
-    const validated = await validateFetchUrl(parsed.data.url, _internals131.dnsLookup);
+    const validated = await validateFetchUrl(parsed.data.url, _internals132.dnsLookup);
     if (!validated.ok) {
       const fail = {
         success: false,
@@ -156357,7 +156521,7 @@ var web_fetch = createSwarmTool({
     }
     const maxBytes = parsed.data.max_bytes ?? DEFAULT_MAX_BYTES;
     const timeoutMs = parsed.data.timeout_ms ?? DEFAULT_TIMEOUT_MS5;
-    const result = await boundedFetch({ url: validated.url, address: validated.address }, maxBytes, timeoutMs, _internals131);
+    const result = await boundedFetch({ url: validated.url, address: validated.address }, maxBytes, timeoutMs, _internals132);
     if (!result.ok) {
       const fail = {
         success: false,
@@ -156392,7 +156556,7 @@ var web_fetch = createSwarmTool({
 });
 async function captureFetchEvidence(directory, url3, title, text) {
   try {
-    const written = await _internals131.writeEvidenceDocuments(directory, [
+    const written = await _internals132.writeEvidenceDocuments(directory, [
       {
         sourceType: "crawl",
         url: url3,
@@ -156413,7 +156577,7 @@ async function captureFetchEvidence(directory, url3, title, text) {
     };
   }
 }
-var _internals131 = {
+var _internals132 = {
   httpRequest: performHttpRequest,
   dnsLookup: lookup,
   loadPluginConfig,
@@ -156727,7 +156891,7 @@ var web_search = createSwarmTool({
 });
 async function captureSearchEvidence(directory, query, results) {
   try {
-    const written = await _internals132.writeEvidenceDocuments(directory, results.map((result) => ({
+    const written = await _internals133.writeEvidenceDocuments(directory, results.map((result) => ({
       sourceType: "web_search",
       query,
       title: result.title,
@@ -156755,7 +156919,7 @@ async function captureSearchEvidence(directory, query, results) {
     };
   }
 }
-var _internals132 = {
+var _internals133 = {
   writeEvidenceDocuments
 };
 
@@ -156963,7 +157127,7 @@ async function executeWriteDriftEvidence(args2, directory) {
       message: "Invalid summary: must be a non-empty string"
     }, null, 2);
   }
-  const normalizedVerdict = _internals133.normalizeVerdict2(args2.verdict);
+  const normalizedVerdict = _internals134.normalizeVerdict2(args2.verdict);
   const provenance = args2.provenanceAgentName || args2.provenanceSessionId ? {
     agent_name: args2.provenanceAgentName,
     session_id: args2.provenanceSessionId,
@@ -157060,7 +157224,7 @@ async function executeWriteDriftEvidence(args2, directory) {
     }, null, 2);
   }
 }
-var _internals133 = {
+var _internals134 = {
   normalizeVerdict2,
   VERDICT_SET_2,
   isAcceptedVerdict2
@@ -157323,7 +157487,7 @@ async function executeWriteHallucinationEvidence(args2, directory) {
       message: "Invalid summary: must be a non-empty string"
     }, null, 2);
   }
-  const normalizedVerdict = _internals134.normalizeVerdict2(args2.verdict);
+  const normalizedVerdict = _internals135.normalizeVerdict2(args2.verdict);
   const evidenceEntry = {
     type: "hallucination-verification",
     verdict: normalizedVerdict,
@@ -157366,7 +157530,7 @@ async function executeWriteHallucinationEvidence(args2, directory) {
     }, null, 2);
   }
 }
-var _internals134 = {
+var _internals135 = {
   normalizeVerdict2,
   VERDICT_SET_2,
   isAcceptedVerdict2
@@ -157447,7 +157611,7 @@ async function executeWriteMutationEvidence(args2, directory) {
       message: "Invalid summary: must be a non-empty string"
     }, null, 2);
   }
-  const normalizedVerdict = _internals135.normalizeVerdict4(args2.verdict);
+  const normalizedVerdict = _internals136.normalizeVerdict4(args2.verdict);
   const evidenceEntry = {
     type: "mutation-gate",
     verdict: normalizedVerdict,
@@ -157494,7 +157658,7 @@ async function executeWriteMutationEvidence(args2, directory) {
     }, null, 2);
   }
 }
-var _internals135 = {
+var _internals136 = {
   normalizeVerdict4,
   VERDICT_SET_4,
   isAcceptedVerdict4