opencode-swarm 7.32.3 → 7.33.1

package/dist/cli/index.js

@@ -34,7 +34,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "opencode-swarm",
-    version: "7.32.3",
+    version: "7.33.1",
     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",
@@ -14580,9 +14580,138 @@ function emit(event, data) {
     }
   } catch {}
 }
-var _writeStream = null, _listeners, _disabled = false;
+var _writeStream = null, _listeners, _disabled = false, telemetry, _internals2;
 var init_telemetry = __esm(() => {
   _listeners = [];
+  telemetry = {
+    sessionStarted(sessionId, agentName) {
+      _internals2.emit("session_started", { sessionId, agentName });
+    },
+    sessionEnded(sessionId, reason) {
+      _internals2.emit("session_ended", { sessionId, reason });
+    },
+    agentActivated(sessionId, agentName, oldName) {
+      _internals2.emit("agent_activated", { sessionId, agentName, oldName });
+    },
+    delegationBegin(sessionId, agentName, taskId) {
+      _internals2.emit("delegation_begin", { sessionId, agentName, taskId });
+    },
+    delegationEnd(sessionId, agentName, taskId, result) {
+      _internals2.emit("delegation_end", { sessionId, agentName, taskId, result });
+    },
+    taskStateChanged(sessionId, taskId, newState, oldState) {
+      _internals2.emit("task_state_changed", {
+        sessionId,
+        taskId,
+        newState,
+        oldState
+      });
+    },
+    gatePassed(sessionId, gate, taskId) {
+      _internals2.emit("gate_passed", { sessionId, gate, taskId });
+    },
+    gateParseError(taskId, error49) {
+      _internals2.emit("gate_parse_error", {
+        taskId,
+        errorName: error49.name,
+        errorMessage: error49.message.slice(0, 200)
+      });
+    },
+    gateFailed(sessionId, gate, taskId, reason) {
+      _internals2.emit("gate_failed", { sessionId, gate, taskId, reason });
+    },
+    phaseChanged(sessionId, oldPhase, newPhase) {
+      _internals2.emit("phase_changed", { sessionId, oldPhase, newPhase });
+    },
+    budgetUpdated(sessionId, budgetPct, agentName) {
+      _internals2.emit("budget_updated", { sessionId, budgetPct, agentName });
+    },
+    modelFallback(sessionId, agentName, fromModel, toModel, reason) {
+      _internals2.emit("model_fallback", {
+        sessionId,
+        agentName,
+        fromModel,
+        toModel,
+        reason
+      });
+    },
+    hardLimitHit(sessionId, agentName, limitType, value) {
+      _internals2.emit("hard_limit_hit", {
+        sessionId,
+        agentName,
+        limitType,
+        value
+      });
+    },
+    revisionLimitHit(sessionId, agentName) {
+      _internals2.emit("revision_limit_hit", { sessionId, agentName });
+    },
+    loopDetected(sessionId, agentName, loopType) {
+      _internals2.emit("loop_detected", { sessionId, agentName, loopType });
+    },
+    scopeViolation(sessionId, agentName, file2, reason) {
+      _internals2.emit("scope_violation", { sessionId, agentName, file: file2, reason });
+    },
+    qaSkipViolation(sessionId, agentName, skipCount) {
+      _internals2.emit("qa_skip_violation", { sessionId, agentName, skipCount });
+    },
+    heartbeat(sessionId) {
+      _internals2.emit("heartbeat", { sessionId });
+    },
+    turboModeChanged(sessionId, enabled, agentName) {
+      _internals2.emit("turbo_mode_changed", { sessionId, enabled, agentName });
+    },
+    autoOversightEscalation(sessionId, reason, interactionCount, deadlockCount, phase) {
+      _internals2.emit("auto_oversight_escalation", {
+        sessionId,
+        reason,
+        interactionCount,
+        deadlockCount,
+        phase
+      });
+    },
+    environmentDetected(sessionId, hostOS, shellFamily, executionMode) {
+      _internals2.emit("environment_detected", {
+        sessionId,
+        hostOS,
+        shellFamily,
+        executionMode
+      });
+    },
+    prmPatternDetected(sessionId, pattern, severity, category, stepRange) {
+      _internals2.emit("prm_pattern_detected", {
+        sessionId,
+        pattern,
+        severity,
+        category,
+        stepRange
+      });
+    },
+    prmCourseCorrectionInjected(sessionId, pattern, level) {
+      _internals2.emit("prm_course_correction_injected", {
+        sessionId,
+        pattern,
+        level
+      });
+    },
+    prmEscalationTriggered(sessionId, pattern, level, occurrenceCount) {
+      _internals2.emit("prm_escalation_triggered", {
+        sessionId,
+        pattern,
+        level,
+        occurrenceCount
+      });
+    },
+    prmHardStop(sessionId, pattern, level, occurrenceCount) {
+      _internals2.emit("prm_hard_stop", {
+        sessionId,
+        pattern,
+        level,
+        occurrenceCount
+      });
+    }
+  };
+  _internals2 = { telemetry, emit };
 });
 
 // src/utils/spec-hash.ts
@@ -14603,7 +14732,7 @@ async function computeSpecHash(directory) {
   return hash2;
 }
 async function isSpecStale(directory, plan) {
-  const currentHash = await _internals2.computeSpecHash(directory);
+  const currentHash = await _internals3.computeSpecHash(directory);
   if (!plan.specHash) {
     return { stale: false };
   }
@@ -14623,9 +14752,9 @@ async function isSpecStale(directory, plan) {
   }
   return { stale: false };
 }
-var _internals2;
+var _internals3;
 var init_spec_hash = __esm(() => {
-  _internals2 = {
+  _internals3 = {
     computeSpecHash,
     isSpecStale
   };
@@ -14815,6 +14944,32 @@ async function appendLedgerEvent(directory, eventInput, options) {
   fs.renameSync(tempPath, ledgerPath);
   return event;
 }
+async function takeSnapshotWithRetry(directory, plan, options) {
+  const MAX_RETRIES = 3;
+  const TOTAL_ATTEMPTS = 1 + MAX_RETRIES;
+  const telemetrySource = options?.source ?? "save_plan_tool";
+  const snapshotOptions = { planHashAfter: options?.planHashAfter };
+  let lastError;
+  for (let attempt = 1;attempt <= TOTAL_ATTEMPTS; attempt++) {
+    try {
+      await takeSnapshotEvent(directory, plan, snapshotOptions);
+      return;
+    } catch (err) {
+      lastError = err instanceof Error ? err : new Error(String(err));
+      if (attempt < TOTAL_ATTEMPTS) {
+        await new Promise((r) => setTimeout(r, 10 * 2 ** (attempt - 1)));
+      }
+    }
+  }
+  console.warn(`[takeSnapshotWithRetry] Snapshot failed after ${MAX_RETRIES} retries (${TOTAL_ATTEMPTS} attempts): ${lastError.message}`);
+  try {
+    emit("snapshot_failed", {
+      error: lastError.message,
+      retries: MAX_RETRIES,
+      source: telemetrySource
+    });
+  } catch {}
+}
 async function takeSnapshotEvent(directory, plan, options) {
   const payloadHash = computePlanHash(plan);
   const snapshotPayload = {
@@ -15048,6 +15203,7 @@ async function loadLastApprovedPlan(directory, expectedPlanId) {
 var LEDGER_SCHEMA_VERSION = "1.1.0", LEDGER_FILENAME = "plan-ledger.jsonl", PLAN_JSON_FILENAME = "plan.json", LedgerStaleWriterError;
 var init_ledger = __esm(() => {
   init_plan_schema();
+  init_telemetry();
   LedgerStaleWriterError = class LedgerStaleWriterError extends Error {
     constructor(message) {
       super(message);
@@ -15219,7 +15375,7 @@ async function loadPlan(directory) {
         const inSync = await isPlanMdInSync(directory, validated);
         if (!inSync) {
           try {
-            await _internals3.regeneratePlanMarkdown(directory, validated);
+            await _internals4.regeneratePlanMarkdown(directory, validated);
           } catch (regenError) {
             warn(`Failed to regenerate plan.md: ${regenError instanceof Error ? regenError.message : String(regenError)}. Proceeding with plan.json only.`);
           }
@@ -15241,7 +15397,9 @@ async function loadPlan(directory) {
                 try {
                   const rebuilt = await replayFromLedger(directory);
                   if (rebuilt) {
-                    await rebuildPlan(directory, rebuilt);
+                    await rebuildPlan(directory, rebuilt, {
+                      reason: "ledger_hash_mismatch_recovery"
+                    });
                     warn("[loadPlan] Rebuilt plan from ledger. Checkpoint available at .swarm/SWARM_PLAN.md if it exists.");
                     return rebuilt;
                   }
@@ -15249,7 +15407,9 @@ async function loadPlan(directory) {
                   try {
                     const approved = await loadLastApprovedPlan(directory, currentPlanId);
                     if (approved) {
-                      await rebuildPlan(directory, approved.plan);
+                      await rebuildPlan(directory, approved.plan, {
+                        reason: "approved_snapshot_fallback"
+                      });
                       try {
                         await takeSnapshotEvent(directory, approved.plan, {
                           source: "recovery_from_approved_snapshot",
@@ -15326,7 +15486,9 @@ async function loadPlan(directory) {
           } else if (catchFirstEvent !== null && rawPlanId !== null) {
             const rebuilt = await replayFromLedger(directory);
             if (rebuilt) {
-              await rebuildPlan(directory, rebuilt);
+              await rebuildPlan(directory, rebuilt, {
+                reason: "validation_failure_recovery"
+              });
               warn("[loadPlan] Rebuilt plan from ledger after validation failure. Projection was stale.");
               return rebuilt;
             }
@@ -15358,7 +15520,7 @@ async function loadPlan(directory) {
     const existingMutex = recoveryMutexes.get(resolvedDir);
     if (existingMutex) {
       await existingMutex;
-      const postRecoveryPlan = await _internals3.loadPlanJsonOnly(directory);
+      const postRecoveryPlan = await _internals4.loadPlanJsonOnly(directory);
       if (postRecoveryPlan)
         return postRecoveryPlan;
     }
@@ -15418,7 +15580,7 @@ async function loadPlan(directory) {
   return null;
 }
 async function savePlanWithAutoAcknowledgedRemovals(directory, plan, source, reason, options) {
-  const existing = await _internals3.loadPlanJsonOnly(directory);
+  const existing = await _internals4.loadPlanJsonOnly(directory);
   const newIds = new Set;
   for (const phase of plan.phases) {
     for (const task of phase.tasks)
@@ -15446,7 +15608,7 @@ async function savePlan(directory, plan, options) {
   const validated = PlanSchema.parse(plan);
   if (options?.preserveCompletedStatuses !== false) {
     try {
-      const currentPlan2 = await _internals3.loadPlanJsonOnly(directory);
+      const currentPlan2 = await _internals4.loadPlanJsonOnly(directory);
       if (currentPlan2) {
         const completedTaskIds = new Set;
         for (const phase of currentPlan2.phases) {
@@ -15479,7 +15641,7 @@ async function savePlan(directory, plan, options) {
       phase.status = "pending";
     }
   }
-  const currentPlan = await _internals3.loadPlanJsonOnly(directory);
+  const currentPlan = await _internals4.loadPlanJsonOnly(directory);
   const planId = derivePlanId(validated);
   const planHashForInit = computePlanHash(validated);
   if (!await ledgerExists(directory)) {
@@ -15624,7 +15786,7 @@ async function savePlan(directory, plan, options) {
             expectedHash: currentHash,
             planHashAfter: hashAfter,
             verifyValid: async () => {
-              const onDisk = await _internals3.loadPlanJsonOnly(directory);
+              const onDisk = await _internals4.loadPlanJsonOnly(directory);
               if (!onDisk)
                 return true;
               for (const p of onDisk.phases) {
@@ -15662,7 +15824,7 @@ async function savePlan(directory, plan, options) {
               expectedHash: currentHash,
               planHashAfter: hashAfter,
               verifyValid: async () => {
-                const onDisk = await _internals3.loadPlanJsonOnly(directory);
+                const onDisk = await _internals4.loadPlanJsonOnly(directory);
                 if (!onDisk)
                   return true;
                 for (const p of onDisk.phases) {
@@ -15687,12 +15849,9 @@ async function savePlan(directory, plan, options) {
   const SNAPSHOT_INTERVAL = 50;
   const latestSeq = await getLatestLedgerSeq(directory);
   if (latestSeq > 0 && latestSeq % SNAPSHOT_INTERVAL === 0) {
-    await takeSnapshotEvent(directory, validated, {
-      planHashAfter: hashAfter
-    }).catch((err) => {
-      if (process.env.DEBUG_SWARM) {
-        warn(`[savePlan] Periodic snapshot write failed (non-fatal): ${err instanceof Error ? err.message : String(err)}`);
-      }
+    await takeSnapshotWithRetry(directory, validated, {
+      planHashAfter: hashAfter,
+      source: "savePlan_manager"
     });
   }
   const swarmDir = path4.resolve(directory, ".swarm");
@@ -15706,6 +15865,17 @@ async function savePlan(directory, plan, options) {
       unlinkSync(tempPath);
     } catch {}
   }
+  try {
+    const markerPath = path4.join(swarmDir, ".plan-write-marker");
+    const inProgressMarker = JSON.stringify({
+      source: "plan_manager",
+      timestamp: new Date().toISOString(),
+      phases_count: validated.phases.length,
+      tasks_count: validated.phases.reduce((sum, p) => sum + p.tasks.length, 0),
+      in_progress: true
+    });
+    await bunWrite(markerPath, inProgressMarker);
+  } catch {}
   try {
     const contentHash = computePlanContentHash(validated);
     const markdown = derivePlanMarkdown(validated);
@@ -15739,41 +15909,146 @@ ${markdown}`;
       source: "plan_manager",
       timestamp: new Date().toISOString(),
       phases_count: validated.phases.length,
-      tasks_count: tasksCount
+      tasks_count: tasksCount,
+      in_progress: false
     });
     await bunWrite(markerPath, marker);
   } catch {}
 }
-async function rebuildPlan(directory, plan) {
+async function rebuildPlan(directory, plan, options) {
   const targetPlan = plan ?? await replayFromLedger(directory);
   if (!targetPlan)
     return null;
   const swarmDir = path4.join(directory, ".swarm");
   const planPath = path4.join(swarmDir, "plan.json");
   const mdPath = path4.join(swarmDir, "plan.md");
-  const tempPlanPath = path4.join(swarmDir, `plan.json.rebuild.${Date.now()}`);
+  const tempPlanPath = path4.join(swarmDir, `plan.json.rebuild.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
   await bunWrite(tempPlanPath, JSON.stringify(targetPlan, null, 2));
   renameSync2(tempPlanPath, planPath);
-  const contentHash = computePlanContentHash(targetPlan);
-  const markdown = derivePlanMarkdown(targetPlan);
-  const markdownWithHash = `<!-- PLAN_HASH: ${contentHash} -->
-${markdown}`;
-  const tempMdPath = path4.join(swarmDir, `plan.md.rebuild.${Date.now()}`);
-  await bunWrite(tempMdPath, markdownWithHash);
-  renameSync2(tempMdPath, mdPath);
   try {
     const markerPath = path4.join(swarmDir, ".plan-write-marker");
-    const tasksCount = targetPlan.phases.reduce((sum, phase) => sum + phase.tasks.length, 0);
-    const marker = JSON.stringify({
+    const inProgressMarker = JSON.stringify({
       source: "plan_manager",
       timestamp: new Date().toISOString(),
       phases_count: targetPlan.phases.length,
-      tasks_count: tasksCount
+      tasks_count: targetPlan.phases.reduce((sum, phase) => sum + phase.tasks.length, 0),
+      in_progress: true
     });
-    await bunWrite(markerPath, marker);
+    await bunWrite(markerPath, inProgressMarker);
+  } catch {}
+  try {
+    const contentHash = computePlanContentHash(targetPlan);
+    const markdown = derivePlanMarkdown(targetPlan);
+    const markdownWithHash = `<!-- PLAN_HASH: ${contentHash} -->
+${markdown}`;
+    const tempMdPath = path4.join(swarmDir, `plan.md.rebuild.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+    await bunWrite(tempMdPath, markdownWithHash);
+    renameSync2(tempMdPath, mdPath);
+  } finally {
+    try {
+      const markerPath = path4.join(swarmDir, ".plan-write-marker");
+      const tasksCount = targetPlan.phases.reduce((sum, phase) => sum + phase.tasks.length, 0);
+      const marker = JSON.stringify({
+        source: "plan_manager",
+        timestamp: new Date().toISOString(),
+        phases_count: targetPlan.phases.length,
+        tasks_count: tasksCount,
+        in_progress: false
+      });
+      await bunWrite(markerPath, marker);
+    } catch {}
+  }
+  try {
+    const planId = derivePlanId(targetPlan);
+    const planHashAfter = computePlanHash(targetPlan);
+    await appendLedgerEvent(directory, {
+      event_type: "plan_rebuilt",
+      source: "rebuildPlan",
+      plan_id: planId,
+      payload: {
+        reason: options?.reason ?? "ledger_replay_recovery",
+        phases_count: targetPlan.phases.length,
+        tasks_count: targetPlan.phases.reduce((sum, p) => sum + p.tasks.length, 0)
+      }
+    }, { planHashAfter });
   } catch {}
   return targetPlan;
 }
+async function closePlanTerminalState(directory, plan, options) {
+  const planId = derivePlanId(plan);
+  const validated = PlanSchema.parse(plan);
+  const hashAfter = computePlanHash(validated);
+  for (const taskId of options.closedTaskIds) {
+    let taskPhaseId;
+    for (const phase of validated.phases) {
+      if (phase.tasks.some((t) => t.id === taskId)) {
+        taskPhaseId = phase.id;
+        break;
+      }
+    }
+    const fromStatus = options.originalStatuses?.get(taskId) ?? "in_progress";
+    await appendLedgerEvent(directory, {
+      plan_id: planId,
+      event_type: "task_status_changed",
+      task_id: taskId,
+      phase_id: taskPhaseId,
+      from_status: fromStatus,
+      to_status: "closed",
+      source: "close_terminal"
+    }, { planHashAfter: hashAfter });
+  }
+  for (const phaseId of options.closedPhaseIds) {
+    await appendLedgerEvent(directory, {
+      plan_id: planId,
+      event_type: "phase_completed",
+      phase_id: phaseId,
+      source: "close_terminal"
+    }, { planHashAfter: hashAfter });
+  }
+  await takeSnapshotEvent(directory, validated, {
+    planHashAfter: hashAfter,
+    source: "close_terminal"
+  });
+  const swarmDir = path4.join(directory, ".swarm");
+  const planPath = path4.join(swarmDir, "plan.json");
+  const tempPlanPath = path4.join(swarmDir, `plan.json.close.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+  await bunWrite(tempPlanPath, JSON.stringify(validated, null, 2));
+  renameSync2(tempPlanPath, planPath);
+  try {
+    const markerPath = path4.join(swarmDir, ".plan-write-marker");
+    const inProgressMarker = JSON.stringify({
+      source: "plan_manager_close",
+      timestamp: new Date().toISOString(),
+      phases_count: validated.phases.length,
+      tasks_count: validated.phases.reduce((sum, phase) => sum + phase.tasks.length, 0),
+      in_progress: true
+    });
+    await bunWrite(markerPath, inProgressMarker);
+  } catch {}
+  try {
+    const mdPath = path4.join(swarmDir, "plan.md");
+    const contentHash = computePlanContentHash(validated);
+    const markdown = derivePlanMarkdown(validated);
+    const markdownWithHash = `<!-- PLAN_HASH: ${contentHash} -->
+${markdown}`;
+    const mdTempPath = path4.join(swarmDir, `plan.md.close.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+    await bunWrite(mdTempPath, markdownWithHash);
+    renameSync2(mdTempPath, mdPath);
+  } finally {
+    try {
+      const markerPath = path4.join(swarmDir, ".plan-write-marker");
+      const tasksCount = validated.phases.reduce((sum, phase) => sum + phase.tasks.length, 0);
+      const marker = JSON.stringify({
+        source: "plan_manager_close",
+        timestamp: new Date().toISOString(),
+        phases_count: validated.phases.length,
+        tasks_count: tasksCount,
+        in_progress: false
+      });
+      await bunWrite(markerPath, marker);
+    } catch {}
+  }
+}
 function derivePlanMarkdown(plan) {
   const statusMap = {
     pending: "PENDING",
@@ -16042,7 +16317,7 @@ function migrateLegacyPlan(planContent, swarmId) {
   };
   return plan;
 }
-var PlanConcurrentModificationError, PlanTaskRemovalNotAcknowledgedError, startupLedgerCheckedWorkspaces, recoveryMutexes, _internals3, CAS_BACKOFF_START_MS = 5, CAS_BACKOFF_CAP_MS = 250, CAS_BACKOFF_JITTER = 0.25, CAS_MAX_RETRIES = 3;
+var PlanConcurrentModificationError, PlanTaskRemovalNotAcknowledgedError, startupLedgerCheckedWorkspaces, recoveryMutexes, _internals4, 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_utils2();
@@ -16068,7 +16343,7 @@ var init_manager = __esm(() => {
   };
   startupLedgerCheckedWorkspaces = new Set;
   recoveryMutexes = new Map;
-  _internals3 = {
+  _internals4 = {
     loadPlan,
     loadPlanJsonOnly,
     regeneratePlanMarkdown
@@ -17326,8 +17601,12 @@ var init_schema = __esm(() => {
   });
   MemoryConfigSchema = exports_external.object({
     enabled: exports_external.boolean().default(false),
-    provider: exports_external.literal("local-jsonl").default("local-jsonl"),
+    provider: exports_external.enum(["local-jsonl", "sqlite"]).default("local-jsonl"),
     storageDir: exports_external.string().default(".swarm/memory"),
+    sqlite: exports_external.object({
+      path: exports_external.string().default(".swarm/memory/memory.db"),
+      busyTimeoutMs: exports_external.number().int().min(0).max(60000).default(5000)
+    }).default({ path: ".swarm/memory/memory.db", busyTimeoutMs: 5000 }),
     recall: exports_external.object({
       defaultMaxItems: exports_external.number().int().min(1).max(20).default(8),
       defaultTokenBudget: exports_external.number().int().min(100).max(5000).default(1200),
@@ -19759,11 +20038,11 @@ async function tryAcquireLock(directory, filePath, agent, taskId) {
   };
   return { acquired: true, lock };
 }
-var import_proper_lockfile, LOCKS_DIR = ".swarm/locks", LOCK_TIMEOUT_MS, _internals4;
+var import_proper_lockfile, LOCKS_DIR = ".swarm/locks", LOCK_TIMEOUT_MS, _internals5;
 var init_file_locks = __esm(() => {
   import_proper_lockfile = __toESM(require_proper_lockfile(), 1);
   LOCK_TIMEOUT_MS = 5 * 60 * 1000;
-  _internals4 = {
+  _internals5 = {
     tryAcquireLock,
     writeFile: fs3.promises.writeFile
   };
@@ -19863,6 +20142,19 @@ function checkUnsafeChars(taskId) {
   }
   return;
 }
+function isStrictTaskId(taskId) {
+  if (!taskId)
+    return false;
+  const unsafeMsg = checkUnsafeChars(taskId);
+  if (unsafeMsg)
+    return false;
+  return STRICT_TASK_ID_PATTERN.test(taskId);
+}
+function assertStrictTaskId(taskId) {
+  if (!isStrictTaskId(taskId)) {
+    throw new Error(`Invalid taskId: "${taskId}". Must match N.M or N.M.P (e.g. "1.1", "1.2.3").`);
+  }
+}
 function sanitizeTaskId(taskId) {
   const unsafeMsg = checkUnsafeChars(taskId);
   if (unsafeMsg) {
@@ -19943,7 +20235,7 @@ function validateProjectRoot(directory) {
   }
 }
 async function saveEvidence(directory, taskId, evidence) {
-  _internals5.validateProjectRoot(directory);
+  _internals6.validateProjectRoot(directory);
   const sanitizedTaskId = sanitizeTaskId2(taskId);
   const relativePath = path7.join("evidence", sanitizedTaskId, "evidence.json");
   validateSwarmPath(directory, relativePath);
@@ -20044,7 +20336,7 @@ async function loadEvidence(directory, taskId) {
     return { status: "invalid_schema", errors: ["Invalid JSON"] };
   }
   if (isFlatRetrospective(parsed)) {
-    const wrappedBundle = _internals5.wrapFlatRetrospective(parsed, sanitizedTaskId);
+    const wrappedBundle = _internals6.wrapFlatRetrospective(parsed, sanitizedTaskId);
     try {
       const validated = EvidenceBundleSchema.parse(wrappedBundle);
       try {
@@ -20140,14 +20432,14 @@ async function checkRequirementCoverage(phase, directory) {
   }
 }
 async function archiveEvidence(directory, maxAgeDays, maxBundles) {
-  const taskIds = await _internals5.listEvidenceTaskIds(directory);
+  const taskIds = await _internals6.listEvidenceTaskIds(directory);
   const cutoffDate = new Date;
   cutoffDate.setDate(cutoffDate.getDate() - maxAgeDays);
   const cutoffIso = cutoffDate.toISOString();
   const archived = [];
   const remainingBundles = [];
   for (const taskId of taskIds) {
-    const result = await _internals5.loadEvidence(directory, taskId);
+    const result = await _internals6.loadEvidence(directory, taskId);
     if (result.status !== "found") {
       continue;
     }
@@ -20175,7 +20467,7 @@ async function archiveEvidence(directory, maxAgeDays, maxBundles) {
   }
   return archived;
 }
-var VALID_EVIDENCE_TYPES, sanitizeTaskId2, MAX_DEPTH = 20, PROJECT_INDICATORS, LEGACY_TASK_COMPLEXITY_MAP, _internals5;
+var VALID_EVIDENCE_TYPES, sanitizeTaskId2, MAX_DEPTH = 20, PROJECT_INDICATORS, LEGACY_TASK_COMPLEXITY_MAP, _internals6;
 var init_manager2 = __esm(() => {
   init_zod();
   init_evidence_schema();
@@ -20218,7 +20510,7 @@ var init_manager2 = __esm(() => {
     medium: "moderate",
     high: "complex"
   };
-  _internals5 = {
+  _internals6 = {
     wrapFlatRetrospective,
     loadEvidence,
     listEvidenceTaskIds,
@@ -20430,7 +20722,7 @@ function getProfile(directory, planId) {
   return row ? rowToProfile(row) : null;
 }
 function getOrCreateProfile(directory, planId, projectType) {
-  const existing = _internals6.getProfile(directory, planId);
+  const existing = _internals7.getProfile(directory, planId);
   if (existing)
     return existing;
   const db = getProjectDb(directory);
@@ -20446,14 +20738,14 @@ function getOrCreateProfile(directory, planId, projectType) {
       throw err;
     }
   }
-  const after = _internals6.getProfile(directory, planId);
+  const after = _internals7.getProfile(directory, planId);
   if (!after) {
     throw new Error(`Failed to create or load QA gate profile for plan_id=${planId}`);
   }
   return after;
 }
 function setGates(directory, planId, gates) {
-  const current = _internals6.getProfile(directory, planId);
+  const current = _internals7.getProfile(directory, planId);
   if (!current) {
     throw new Error(`No QA gate profile found for plan_id=${planId} \u2014 call getOrCreateProfile first`);
   }
@@ -20477,7 +20769,7 @@ function setGates(directory, planId, gates) {
     JSON.stringify(merged),
     planId
   ]);
-  const updated = _internals6.getProfile(directory, planId);
+  const updated = _internals7.getProfile(directory, planId);
   if (!updated) {
     throw new Error(`Failed to re-read QA gate profile after update for plan_id=${planId}`);
   }
@@ -20499,10 +20791,10 @@ function getEffectiveGates(profile, sessionOverrides) {
   }
   return merged;
 }
-var _internals6, DEFAULT_QA_GATES;
+var _internals7, DEFAULT_QA_GATES;
 var init_qa_gate_profile = __esm(() => {
   init_project_db();
-  _internals6 = {
+  _internals7 = {
     getProfile,
     getOrCreateProfile,
     setGates,
@@ -34950,7 +35242,7 @@ function resetToRemoteBranch(cwd, options) {
   const prunedBranches = [];
   try {
     const currentBranch = getCurrentBranch(cwd);
-    const defaultRemoteBranch = _internals7.detectDefaultRemoteBranch(cwd);
+    const defaultRemoteBranch = _internals8.detectDefaultRemoteBranch(cwd);
     if (!defaultRemoteBranch) {
       return {
         success: false,
@@ -35132,7 +35424,7 @@ function resetToRemoteBranch(cwd, options) {
 function resetToMainAfterMerge(cwd, options) {
   const warnings = [];
   try {
-    const defaultBranch = _internals7.detectDefaultRemoteBranch(cwd);
+    const defaultBranch = _internals8.detectDefaultRemoteBranch(cwd);
     if (!defaultBranch) {
       return {
         success: false,
@@ -35159,7 +35451,7 @@ function resetToMainAfterMerge(cwd, options) {
     }
     if (currentBranch === defaultBranch) {
       try {
-        const logOutput = _internals7.gitExec(["log", `${targetBranch}..HEAD`, "--oneline"], cwd);
+        const logOutput = _internals8.gitExec(["log", `${targetBranch}..HEAD`, "--oneline"], cwd);
         if (logOutput.trim().length > 0) {
           return {
             success: false,
@@ -35174,11 +35466,11 @@ function resetToMainAfterMerge(cwd, options) {
       } catch {}
     } else {
       try {
-        _internals7.gitExec(["rev-parse", "--abbrev-ref", `${currentBranch}@{upstream}`], cwd);
+        _internals8.gitExec(["rev-parse", "--abbrev-ref", `${currentBranch}@{upstream}`], cwd);
       } catch {
         try {
-          const localSha = _internals7.gitExec(["rev-parse", "HEAD"], cwd).trim();
-          const remoteSha = _internals7.gitExec(["rev-parse", targetBranch], cwd).trim();
+          const localSha = _internals8.gitExec(["rev-parse", "HEAD"], cwd).trim();
+          const remoteSha = _internals8.gitExec(["rev-parse", targetBranch], cwd).trim();
           if (localSha !== remoteSha) {
             return {
               success: false,
@@ -35204,7 +35496,7 @@ function resetToMainAfterMerge(cwd, options) {
       }
     }
     try {
-      _internals7.gitExec(["fetch", "--prune", "origin"], cwd);
+      _internals8.gitExec(["fetch", "--prune", "origin"], cwd);
     } catch (err) {
       return {
         success: false,
@@ -35220,7 +35512,7 @@ function resetToMainAfterMerge(cwd, options) {
     let switchedBranch = false;
     if (currentBranch !== defaultBranch) {
       try {
-        _internals7.gitExec(["checkout", defaultBranch], cwd);
+        _internals8.gitExec(["checkout", defaultBranch], cwd);
         switchedBranch = true;
       } catch (err) {
         return {
@@ -35235,7 +35527,7 @@ function resetToMainAfterMerge(cwd, options) {
       }
     }
     try {
-      _internals7.gitExec(["reset", "--hard", targetBranch], cwd);
+      _internals8.gitExec(["reset", "--hard", targetBranch], cwd);
     } catch (err) {
       return {
         success: false,
@@ -35256,7 +35548,7 @@ function resetToMainAfterMerge(cwd, options) {
           while (Date.now() < endTime) {}
         }
         try {
-          _internals7.gitExec(["checkout", "--", "."], cwd);
+          _internals8.gitExec(["checkout", "--", "."], cwd);
           discardSucceeded = true;
           break;
         } catch {}
@@ -35267,18 +35559,18 @@ function resetToMainAfterMerge(cwd, options) {
       changesDiscarded = discardSucceeded;
     }
     try {
-      _internals7.gitExec(["clean", "-fd"], cwd);
+      _internals8.gitExec(["clean", "-fd"], cwd);
     } catch {
       warnings.push("Could not clean untracked files");
     }
     let branchDeleted = false;
     if (switchedBranch && previousBranch !== defaultBranch) {
       try {
-        const mergedOutput = _internals7.gitExec(["branch", "--merged", defaultBranch], cwd);
+        const mergedOutput = _internals8.gitExec(["branch", "--merged", defaultBranch], cwd);
         const isMerged = mergedOutput.split(`
 `).some((line) => line.trim() === previousBranch || line.trim() === `* ${previousBranch}`);
         if (isMerged) {
-          _internals7.gitExec(["branch", "-d", previousBranch], cwd);
+          _internals8.gitExec(["branch", "-d", previousBranch], cwd);
           branchDeleted = true;
         } else {
           warnings.push(`Branch ${previousBranch} is not merged into ${defaultBranch} \u2014 keeping it`);
@@ -35289,7 +35581,7 @@ function resetToMainAfterMerge(cwd, options) {
     }
     if (options?.pruneBranches) {
       try {
-        const mergedOutput = _internals7.gitExec(["branch", "--merged", defaultBranch], cwd);
+        const mergedOutput = _internals8.gitExec(["branch", "--merged", defaultBranch], cwd);
         const mergedLines = mergedOutput.split(`
 `);
         for (const line of mergedLines) {
@@ -35298,7 +35590,7 @@ function resetToMainAfterMerge(cwd, options) {
             continue;
           }
           try {
-            _internals7.gitExec(["branch", "-d", trimmedLine], cwd);
+            _internals8.gitExec(["branch", "-d", trimmedLine], cwd);
           } catch {
             warnings.push(`Could not prune branch: ${trimmedLine}`);
           }
@@ -35328,10 +35620,10 @@ function resetToMainAfterMerge(cwd, options) {
     };
   }
 }
-var GIT_TIMEOUT_MS2 = 30000, _internals7;
+var GIT_TIMEOUT_MS2 = 30000, _internals8;
 var init_branch = __esm(() => {
   init_logger();
-  _internals7 = {
+  _internals8 = {
     gitExec: gitExec2,
     detectDefaultRemoteBranch,
     getDefaultBaseBranch,
@@ -36525,7 +36817,7 @@ async function curateAndStoreSwarm(lessons, projectName, phaseInfo, directory, c
     existingEntries.push(entry);
   }
   await enforceKnowledgeCap(knowledgePath, config3.swarm_max_entries);
-  await _internals8.runAutoPromotion(directory, config3);
+  await _internals9.runAutoPromotion(directory, config3);
   return { stored, skipped, rejected };
 }
 async function runAutoPromotion(directory, config3) {
@@ -36606,7 +36898,7 @@ function createKnowledgeCuratorHook(directory, config3) {
       });
       const projectName2 = evidenceData.project_name ?? "unknown";
       const phaseNumber2 = typeof evidenceData.phase_number === "number" ? evidenceData.phase_number : 1;
-      await _internals8.curateAndStoreSwarm(lessons, projectName2, { phase_number: phaseNumber2 }, directory, config3);
+      await _internals9.curateAndStoreSwarm(lessons, projectName2, { phase_number: phaseNumber2 }, directory, config3);
       return;
     }
     const planContent = await readSwarmFileAsync(directory, "plan.md");
@@ -36628,17 +36920,17 @@ function createKnowledgeCuratorHook(directory, config3) {
     const projectName = projectNameMatch ? projectNameMatch[1].trim() : "unknown";
     const phaseMatch = /^Phase:\s*(\d+)/m.exec(planContent);
     const phaseNumber = phaseMatch ? parseInt(phaseMatch[1], 10) : 1;
-    await _internals8.curateAndStoreSwarm(normalLessons, projectName, { phase_number: phaseNumber }, directory, config3);
+    await _internals9.curateAndStoreSwarm(normalLessons, projectName, { phase_number: phaseNumber }, directory, config3);
   };
   return safeHook(handler);
 }
-var seenRetroSections, _internals8;
+var seenRetroSections, _internals9;
 var init_knowledge_curator = __esm(() => {
   init_knowledge_store();
   init_knowledge_validator();
   init_utils2();
   seenRetroSections = new Map;
-  _internals8 = {
+  _internals9 = {
     isWriteToEvidenceFile,
     curateAndStoreSwarm,
     runAutoPromotion,
@@ -37845,7 +38137,7 @@ async function executeWriteRetro(args, directory) {
     }, null, 2);
   }
 }
-var write_retro, _internals9;
+var write_retro, _internals10;
 var init_write_retro = __esm(() => {
   init_zod();
   init_evidence_schema();
@@ -37892,13 +38184,13 @@ var init_write_retro = __esm(() => {
           task_id: args.task_id !== undefined ? String(args.task_id) : undefined,
           metadata: args.metadata
         };
-        return await _internals9.executeWriteRetro(writeRetroArgs, directory);
+        return await _internals10.executeWriteRetro(writeRetroArgs, directory);
       } catch {
         return JSON.stringify({ success: false, phase: rawPhase, message: "Invalid arguments" }, null, 2);
       }
     }
   });
-  _internals9 = {
+  _internals10 = {
     executeWriteRetro,
     write_retro
   };
@@ -38189,6 +38481,12 @@ async function handleCloseCommand(directory, args, options = {}) {
     }
   }
   if (planExists) {
+    const originalStatuses = new Map;
+    for (const phase of planData.phases ?? []) {
+      for (const task of phase.tasks ?? []) {
+        originalStatuses.set(task.id, task.status);
+      }
+    }
     const guaranteeResult = guaranteeAllPlansComplete(planData);
     for (const phaseId of guaranteeResult.closedPhaseIds) {
       if (!closedPhases.includes(phaseId)) {
@@ -38202,11 +38500,15 @@ async function handleCloseCommand(directory, args, options = {}) {
     }
     if (!planAlreadyDone || guaranteeResult.closedPhaseIds.length > 0 || guaranteeResult.closedTaskIds.length > 0) {
       try {
-        await fs7.writeFile(planPath, JSON.stringify(planData, null, 2), "utf-8");
+        await closePlanTerminalState(directory, planData, {
+          closedPhaseIds: guaranteeResult.closedPhaseIds,
+          closedTaskIds: guaranteeResult.closedTaskIds,
+          originalStatuses
+        });
       } catch (error93) {
         const msg = error93 instanceof Error ? error93.message : String(error93);
-        warnings.push(`Failed to persist terminal plan.json state: ${msg}`);
-        console.warn("[close-command] Failed to write plan.json:", error93);
+        warnings.push(`Failed to persist terminal plan state: ${msg}`);
+        console.warn("[close-command] Failed to write terminal plan state:", error93);
       }
     }
   }
@@ -38494,6 +38796,7 @@ var init_close = __esm(() => {
   init_knowledge_curator();
   init_knowledge_store();
   init_utils2();
+  init_manager();
   init_scope_persistence();
   init_skill_improver();
   init_state();
@@ -38902,9 +39205,9 @@ async function detectDarkMatter(directory, options) {
   } catch {
     return [];
   }
-  const commitMap = await _internals10.parseGitLog(directory, maxCommitsToAnalyze);
-  const matrix = _internals10.buildCoChangeMatrix(commitMap);
-  const staticEdges = await _internals10.getStaticEdges(directory);
+  const commitMap = await _internals11.parseGitLog(directory, maxCommitsToAnalyze);
+  const matrix = _internals11.buildCoChangeMatrix(commitMap);
+  const staticEdges = await _internals11.getStaticEdges(directory);
   const results = [];
   for (const entry of matrix.values()) {
     const key = `${entry.fileA}::${entry.fileB}`;
@@ -38984,7 +39287,7 @@ ${rows}
 These pairs likely share an architectural concern invisible to static analysis.
 Consider adding explicit documentation or extracting the shared concern.`;
 }
-var co_change_analyzer, _internals10;
+var co_change_analyzer, _internals11;
 var init_co_change_analyzer = __esm(() => {
   init_zod();
   init_create_tool();
@@ -39016,11 +39319,11 @@ var init_co_change_analyzer = __esm(() => {
         npmiThreshold,
         maxCommitsToAnalyze
       };
-      const pairs = await _internals10.detectDarkMatter(directory, options);
-      return _internals10.formatDarkMatterOutput(pairs);
+      const pairs = await _internals11.detectDarkMatter(directory, options);
+      return _internals11.formatDarkMatterOutput(pairs);
     }
   });
-  _internals10 = {
+  _internals11 = {
     parseGitLog,
     buildCoChangeMatrix,
     getStaticEdges,
@@ -39051,7 +39354,7 @@ async function handleDarkMatterCommand(directory, args) {
   }
   let pairs;
   try {
-    pairs = await _internals10.detectDarkMatter(directory, options);
+    pairs = await _internals11.detectDarkMatter(directory, options);
   } catch (err) {
     const errMsg = err instanceof Error ? err.message : String(err);
     return `## Dark Matter Analysis Failed
@@ -39243,24 +39546,213 @@ function getPluginLockFilePaths() {
 }
 var init_cache_paths = () => {};
 
+// src/evidence/task-file.ts
+import * as path21 from "path";
+function taskEvidenceRelPath(taskId) {
+  return path21.join("evidence", `${taskId}.json`);
+}
+function taskEvidencePath(directory, taskId) {
+  return path21.join(directory, ".swarm", taskEvidenceRelPath(taskId));
+}
+var init_task_file = __esm(() => {
+  init_bun_compat();
+  init_lock();
+});
+
+// src/gate-evidence.ts
+import { mkdirSync as mkdirSync7, readFileSync as readFileSync6 } from "fs";
+function isValidTaskId(taskId) {
+  return isStrictTaskId(taskId);
+}
+function assertValidTaskId(taskId) {
+  assertStrictTaskId(taskId);
+}
+function getEvidencePath(directory, taskId) {
+  assertValidTaskId(taskId);
+  return taskEvidencePath(directory, taskId);
+}
+function readExisting(evidencePath, taskId) {
+  try {
+    const raw = readFileSync6(evidencePath, "utf-8");
+    return TaskEvidenceSchema.parse(JSON.parse(raw));
+  } catch (error93) {
+    if (error93.code === "ENOENT")
+      return null;
+    telemetry.gateParseError(taskId, error93);
+    throw error93;
+  }
+}
+async function readTaskEvidence(directory, taskId) {
+  try {
+    assertValidTaskId(taskId);
+    return readExisting(getEvidencePath(directory, taskId), taskId);
+  } catch {
+    return null;
+  }
+}
+function readTaskEvidenceRaw(directory, taskId) {
+  assertValidTaskId(taskId);
+  const evidencePath = getEvidencePath(directory, taskId);
+  try {
+    const raw = readFileSync6(evidencePath, "utf-8");
+    return TaskEvidenceSchema.parse(JSON.parse(raw));
+  } catch (error93) {
+    if (error93.code === "ENOENT")
+      return null;
+    throw error93;
+  }
+}
+var GateEvidenceSchema, TaskEvidenceSchema;
+var init_gate_evidence = __esm(() => {
+  init_zod();
+  init_task_file();
+  init_telemetry();
+  init_task_id();
+  GateEvidenceSchema = exports_external.object({
+    sessionId: exports_external.string(),
+    timestamp: exports_external.string(),
+    agent: exports_external.string()
+  }).passthrough();
+  TaskEvidenceSchema = exports_external.object({
+    taskId: exports_external.string(),
+    required_gates: exports_external.array(exports_external.string()).default([]),
+    gates: exports_external.record(exports_external.string(), GateEvidenceSchema),
+    turbo: exports_external.boolean().optional()
+  });
+});
+
+// src/evidence/gate-bridge.ts
+async function readDurableGateEvidence(directory, taskId) {
+  try {
+    return await readTaskEvidence(directory, taskId);
+  } catch {
+    return null;
+  }
+}
+function getDurableGateEvidenceStatus(evidence) {
+  if (!evidence?.gates || typeof evidence.gates !== "object") {
+    return {
+      isComplete: false,
+      missingGates: [],
+      evidenceExists: evidence != null,
+      invalid: false
+    };
+  }
+  if (!Array.isArray(evidence.required_gates) || evidence.required_gates.length === 0) {
+    return {
+      isComplete: false,
+      missingGates: ["required_gates"],
+      evidenceExists: true,
+      invalid: false
+    };
+  }
+  const missingGates = evidence.required_gates.filter((gate) => evidence.gates[gate] == null);
+  return {
+    isComplete: missingGates.length === 0,
+    missingGates,
+    evidenceExists: true,
+    invalid: false
+  };
+}
+async function getDurableGateEvidenceStatusForTask(directory, taskId) {
+  if (!isValidTaskId(taskId)) {
+    return {
+      isComplete: false,
+      missingGates: [],
+      evidenceExists: false,
+      invalid: false
+    };
+  }
+  try {
+    return getDurableGateEvidenceStatus(readTaskEvidenceRaw(directory, taskId));
+  } catch {
+    return {
+      isComplete: false,
+      missingGates: ["invalid_gate_evidence"],
+      evidenceExists: true,
+      invalid: true
+    };
+  }
+}
+function gateEvidenceToEntry(taskId, gate, type, evidence) {
+  const gateRecord = evidence.gates[gate];
+  if (!gateRecord) {
+    return null;
+  }
+  const base = {
+    task_id: taskId,
+    timestamp: gateRecord.timestamp,
+    agent: gateRecord.agent || gate,
+    verdict: "pass",
+    summary: `Gate evidence recorded by ${gate}`,
+    metadata: { source: "durable_gate_evidence", gate }
+  };
+  if (type === "review") {
+    return {
+      ...base,
+      type,
+      risk: "low",
+      issues: []
+    };
+  }
+  if (type === "approval") {
+    return {
+      ...base,
+      type
+    };
+  }
+  return {
+    ...base,
+    type,
+    tests_passed: 0,
+    tests_failed: 0,
+    failures: []
+  };
+}
+function mergeDurableGateEntriesFromEvidence(taskId, entries, evidence) {
+  if (!evidence?.gates) {
+    return entries;
+  }
+  const merged = [...entries];
+  for (const gate of Object.keys(evidence.gates).sort()) {
+    const type = GATE_EVIDENCE_TYPE_BY_GATE[gate] ?? "approval";
+    if ((type === "review" || type === "test") && merged.some((entry2) => entry2.type === type)) {
+      continue;
+    }
+    const entry = gateEvidenceToEntry(taskId, gate, type, evidence);
+    if (entry) {
+      merged.push(entry);
+    }
+  }
+  return merged;
+}
+var GATE_EVIDENCE_TYPE_BY_GATE;
+var init_gate_bridge = __esm(() => {
+  init_gate_evidence();
+  GATE_EVIDENCE_TYPE_BY_GATE = {
+    reviewer: "review",
+    test_engineer: "test"
+  };
+});
+
 // src/services/version-check.ts
-import { existsSync as existsSync11, mkdirSync as mkdirSync7, readFileSync as readFileSync6, writeFileSync as writeFileSync4 } from "fs";
+import { existsSync as existsSync11, mkdirSync as mkdirSync8, readFileSync as readFileSync7, writeFileSync as writeFileSync4 } from "fs";
 import { homedir as homedir5 } from "os";
-import { join as join19 } from "path";
+import { join as join20 } from "path";
 function cacheDir() {
   const xdg = process.env.XDG_CACHE_HOME;
-  const base = xdg && xdg.length > 0 ? xdg : join19(homedir5(), ".cache");
-  return join19(base, "opencode-swarm");
+  const base = xdg && xdg.length > 0 ? xdg : join20(homedir5(), ".cache");
+  return join20(base, "opencode-swarm");
 }
 function cacheFile() {
-  return join19(cacheDir(), "version-check.json");
+  return join20(cacheDir(), "version-check.json");
 }
 function readVersionCache() {
   try {
-    const path21 = cacheFile();
-    if (!existsSync11(path21))
+    const path22 = cacheFile();
+    if (!existsSync11(path22))
       return null;
-    const raw = readFileSync6(path21, "utf-8");
+    const raw = readFileSync7(path22, "utf-8");
     const parsed = JSON.parse(raw);
     if (typeof parsed?.checkedAt !== "number")
       return null;
@@ -39299,8 +39791,8 @@ var init_version_check = __esm(() => {
 
 // src/services/diagnose-service.ts
 import * as child_process4 from "child_process";
-import { existsSync as existsSync12, readdirSync as readdirSync4, readFileSync as readFileSync7, statSync as statSync6 } from "fs";
-import path21 from "path";
+import { existsSync as existsSync12, readdirSync as readdirSync4, readFileSync as readFileSync8, statSync as statSync6 } from "fs";
+import path22 from "path";
 import { fileURLToPath } from "url";
 function validateTaskDag(plan) {
   const allTaskIds = new Set;
@@ -39332,7 +39824,21 @@ async function checkEvidenceCompleteness(directory, plan) {
   }
   if (completedTaskIds.length > 0) {
     const evidenceTaskIds = new Set(await listEvidenceTaskIds(directory));
-    const missingEvidence = completedTaskIds.filter((id) => !evidenceTaskIds.has(id));
+    const missingEvidence = [];
+    for (const id of completedTaskIds) {
+      const gateStatus = await getDurableGateEvidenceStatusForTask(directory, id);
+      if (gateStatus.isComplete) {
+        continue;
+      }
+      if (gateStatus.evidenceExists && gateStatus.missingGates.length > 0) {
+        missingEvidence.push(id);
+        continue;
+      }
+      if (evidenceTaskIds.has(id)) {
+        continue;
+      }
+      missingEvidence.push(id);
+    }
     if (missingEvidence.length === 0) {
       return {
         name: "Evidence",
@@ -39597,7 +40103,7 @@ async function checkSpecStaleness(directory, plan) {
   };
 }
 async function checkConfigParseability(directory) {
-  const configPath = path21.join(directory, ".opencode/opencode-swarm.json");
+  const configPath = path22.join(directory, ".opencode/opencode-swarm.json");
   if (!existsSync12(configPath)) {
     return {
       name: "Config Parseability",
@@ -39606,7 +40112,7 @@ async function checkConfigParseability(directory) {
     };
   }
   try {
-    const content = readFileSync7(configPath, "utf-8");
+    const content = readFileSync8(configPath, "utf-8");
     JSON.parse(content);
     return {
       name: "Config Parseability",
@@ -39626,7 +40132,7 @@ function resolveGrammarDir(thisDir) {
   const normalized = thisDir.replace(/\\/g, "/");
   const isSource = normalized.endsWith("/src/services");
   const isCliBundle = normalized.endsWith("/cli");
-  return isSource || isCliBundle ? path21.join(thisDir, "..", "lang", "grammars") : path21.join(thisDir, "lang", "grammars");
+  return isSource || isCliBundle ? path22.join(thisDir, "..", "lang", "grammars") : path22.join(thisDir, "lang", "grammars");
 }
 async function checkGrammarWasmFiles() {
   const grammarFiles = [
@@ -39650,14 +40156,14 @@ async function checkGrammarWasmFiles() {
     "tree-sitter-ini.wasm",
     "tree-sitter-regex.wasm"
   ];
-  const thisDir = path21.dirname(fileURLToPath(import.meta.url));
+  const thisDir = path22.dirname(fileURLToPath(import.meta.url));
   const grammarDir = resolveGrammarDir(thisDir);
   const missing = [];
-  if (!existsSync12(path21.join(grammarDir, "tree-sitter.wasm"))) {
+  if (!existsSync12(path22.join(grammarDir, "tree-sitter.wasm"))) {
     missing.push("tree-sitter.wasm (core runtime)");
   }
   for (const file3 of grammarFiles) {
-    if (!existsSync12(path21.join(grammarDir, file3))) {
+    if (!existsSync12(path22.join(grammarDir, file3))) {
       missing.push(file3);
     }
   }
@@ -39675,7 +40181,7 @@ async function checkGrammarWasmFiles() {
   };
 }
 async function checkCheckpointManifest(directory) {
-  const manifestPath = path21.join(directory, ".swarm/checkpoints.json");
+  const manifestPath = path22.join(directory, ".swarm/checkpoints.json");
   if (!existsSync12(manifestPath)) {
     return {
       name: "Checkpoint Manifest",
@@ -39684,7 +40190,7 @@ async function checkCheckpointManifest(directory) {
     };
   }
   try {
-    const content = readFileSync7(manifestPath, "utf-8");
+    const content = readFileSync8(manifestPath, "utf-8");
     const parsed = JSON.parse(content);
     if (!parsed.checkpoints || !Array.isArray(parsed.checkpoints)) {
       return {
@@ -39727,7 +40233,7 @@ async function checkCheckpointManifest(directory) {
   }
 }
 async function checkEventStreamIntegrity(directory) {
-  const eventsPath = path21.join(directory, ".swarm/events.jsonl");
+  const eventsPath = path22.join(directory, ".swarm/events.jsonl");
   if (!existsSync12(eventsPath)) {
     return {
       name: "Event Stream",
@@ -39736,7 +40242,7 @@ async function checkEventStreamIntegrity(directory) {
     };
   }
   try {
-    const content = readFileSync7(eventsPath, "utf-8");
+    const content = readFileSync8(eventsPath, "utf-8");
     const lines = content.split(`
 `).filter((line) => line.trim() !== "");
     let malformedCount = 0;
@@ -39768,7 +40274,7 @@ async function checkEventStreamIntegrity(directory) {
   }
 }
 async function checkSteeringDirectives(directory) {
-  const eventsPath = path21.join(directory, ".swarm/events.jsonl");
+  const eventsPath = path22.join(directory, ".swarm/events.jsonl");
   if (!existsSync12(eventsPath)) {
     return {
       name: "Steering Directives",
@@ -39777,7 +40283,7 @@ async function checkSteeringDirectives(directory) {
     };
   }
   try {
-    const content = readFileSync7(eventsPath, "utf-8");
+    const content = readFileSync8(eventsPath, "utf-8");
     const lines = content.split(`
 `).filter((line) => line.trim() !== "");
     const directivesIssued = [];
@@ -39824,7 +40330,7 @@ async function checkCurator(directory) {
         detail: "Disabled (enable via curator.enabled)"
       };
     }
-    const summaryPath = path21.join(directory, ".swarm/curator-summary.json");
+    const summaryPath = path22.join(directory, ".swarm/curator-summary.json");
     if (!existsSync12(summaryPath)) {
       return {
         name: "Curator",
@@ -39833,7 +40339,7 @@ async function checkCurator(directory) {
       };
     }
     try {
-      const content = readFileSync7(summaryPath, "utf-8");
+      const content = readFileSync8(summaryPath, "utf-8");
       const parsed = JSON.parse(content);
       if (typeof parsed.schema_version !== "number" || parsed.schema_version !== 1) {
         return {
@@ -39990,7 +40496,7 @@ async function getDiagnoseData(directory) {
   checks5.push(await checkSteeringDirectives(directory));
   checks5.push(await checkCurator(directory));
   try {
-    const evidenceDir = path21.join(directory, ".swarm", "evidence");
+    const evidenceDir = path22.join(directory, ".swarm", "evidence");
     const snapshotFiles = existsSync12(evidenceDir) ? readdirSync4(evidenceDir).filter((f) => f.startsWith("agent-tools-") && f.endsWith(".json")) : [];
     if (snapshotFiles.length > 0) {
       const latest = snapshotFiles.sort().pop();
@@ -40028,9 +40534,9 @@ async function getDiagnoseData(directory) {
         cacheRows.push(`\u2B1C ${cachePath} \u2014 absent`);
         continue;
       }
-      const pkgJsonPath = path21.join(cachePath, "package.json");
+      const pkgJsonPath = path22.join(cachePath, "package.json");
       try {
-        const raw = readFileSync7(pkgJsonPath, "utf-8");
+        const raw = readFileSync8(pkgJsonPath, "utf-8");
         const parsed = JSON.parse(raw);
         const installedVersion = typeof parsed.version === "string" ? parsed.version : "?";
         cacheRows.push(`\u2705 ${cachePath} \u2014 v${installedVersion}`);
@@ -40087,6 +40593,7 @@ var init_diagnose_service = __esm(() => {
   init_package();
   init_cache_paths();
   init_loader();
+  init_gate_bridge();
   init_manager2();
   init_utils2();
   init_manager();
@@ -40118,13 +40625,13 @@ __export(exports_config_doctor, {
 import * as crypto3 from "crypto";
 import * as fs8 from "fs";
 import * as os6 from "os";
-import * as path22 from "path";
+import * as path23 from "path";
 function getUserConfigDir3() {
-  return process.env.XDG_CONFIG_HOME || path22.join(os6.homedir(), ".config");
+  return process.env.XDG_CONFIG_HOME || path23.join(os6.homedir(), ".config");
 }
 function getConfigPaths(directory) {
-  const userConfigPath = path22.join(getUserConfigDir3(), "opencode", "opencode-swarm.json");
-  const projectConfigPath = path22.join(directory, ".opencode", "opencode-swarm.json");
+  const userConfigPath = path23.join(getUserConfigDir3(), "opencode", "opencode-swarm.json");
+  const projectConfigPath = path23.join(directory, ".opencode", "opencode-swarm.json");
   return { userConfigPath, projectConfigPath };
 }
 function computeHash(content) {
@@ -40149,9 +40656,9 @@ function isValidConfigPath(configPath, directory) {
   const normalizedUser = userConfigPath.replace(/\\/g, "/");
   const normalizedProject = projectConfigPath.replace(/\\/g, "/");
   try {
-    const resolvedConfig = path22.resolve(configPath);
-    const resolvedUser = path22.resolve(normalizedUser);
-    const resolvedProject = path22.resolve(normalizedProject);
+    const resolvedConfig = path23.resolve(configPath);
+    const resolvedUser = path23.resolve(normalizedUser);
+    const resolvedProject = path23.resolve(normalizedProject);
     return resolvedConfig === resolvedUser || resolvedConfig === resolvedProject;
   } catch {
     return false;
@@ -40191,12 +40698,12 @@ function createConfigBackup(directory) {
   };
 }
 function writeBackupArtifact(directory, backup) {
-  const swarmDir = path22.join(directory, ".swarm");
+  const swarmDir = path23.join(directory, ".swarm");
   if (!fs8.existsSync(swarmDir)) {
     fs8.mkdirSync(swarmDir, { recursive: true });
   }
   const backupFilename = `config-backup-${backup.createdAt}.json`;
-  const backupPath = path22.join(swarmDir, backupFilename);
+  const backupPath = path23.join(swarmDir, backupFilename);
   const artifact = {
     createdAt: backup.createdAt,
     configPath: backup.configPath,
@@ -40226,7 +40733,7 @@ function restoreFromBackup(backupPath, directory) {
       return null;
     }
     const targetPath = artifact.configPath;
-    const targetDir = path22.dirname(targetPath);
+    const targetDir = path23.dirname(targetPath);
     if (!fs8.existsSync(targetDir)) {
       fs8.mkdirSync(targetDir, { recursive: true });
     }
@@ -40257,9 +40764,9 @@ function readConfigFromFile(directory) {
     return null;
   }
 }
-function validateConfigKey(path23, value, _config) {
+function validateConfigKey(path24, value, _config) {
   const findings = [];
-  switch (path23) {
+  switch (path24) {
     case "agents": {
       if (value !== undefined) {
         findings.push({
@@ -40496,27 +41003,27 @@ function validateConfigKey(path23, value, _config) {
   }
   return findings;
 }
-function walkConfigAndValidate(obj, path23, config3, findings) {
+function walkConfigAndValidate(obj, path24, config3, findings) {
   if (obj === null || obj === undefined) {
     return;
   }
-  if (path23 && typeof obj === "object" && !Array.isArray(obj)) {
-    const keyFindings = validateConfigKey(path23, obj, config3);
+  if (path24 && typeof obj === "object" && !Array.isArray(obj)) {
+    const keyFindings = validateConfigKey(path24, obj, config3);
     findings.push(...keyFindings);
   }
   if (typeof obj !== "object") {
-    const keyFindings = validateConfigKey(path23, obj, config3);
+    const keyFindings = validateConfigKey(path24, obj, config3);
     findings.push(...keyFindings);
     return;
   }
   if (Array.isArray(obj)) {
     obj.forEach((item, index) => {
-      walkConfigAndValidate(item, `${path23}[${index}]`, config3, findings);
+      walkConfigAndValidate(item, `${path24}[${index}]`, config3, findings);
     });
     return;
   }
   for (const [key, value] of Object.entries(obj)) {
-    const newPath = path23 ? `${path23}.${key}` : key;
+    const newPath = path24 ? `${path24}.${key}` : key;
     walkConfigAndValidate(value, newPath, config3, findings);
   }
 }
@@ -40636,7 +41143,7 @@ function applySafeAutoFixes(directory, result) {
     }
   }
   if (appliedFixes.length > 0) {
-    const configDir = path22.dirname(configPath);
+    const configDir = path23.dirname(configPath);
     if (!fs8.existsSync(configDir)) {
       fs8.mkdirSync(configDir, { recursive: true });
     }
@@ -40646,12 +41153,12 @@ function applySafeAutoFixes(directory, result) {
   return { appliedFixes, updatedConfigPath };
 }
 function writeDoctorArtifact(directory, result) {
-  const swarmDir = path22.join(directory, ".swarm");
+  const swarmDir = path23.join(directory, ".swarm");
   if (!fs8.existsSync(swarmDir)) {
     fs8.mkdirSync(swarmDir, { recursive: true });
   }
   const artifactFilename = "config-doctor.json";
-  const artifactPath = path22.join(swarmDir, artifactFilename);
+  const artifactPath = path23.join(swarmDir, artifactFilename);
   const guiOutput = {
     timestamp: result.timestamp,
     summary: result.summary,
@@ -40747,17 +41254,17 @@ function detectStraySwarmDirs(projectRoot) {
       if (!entry.isDirectory())
         continue;
       const name = entry.name;
-      const fullPath = path22.join(dir, name);
+      const fullPath = path23.join(dir, name);
       if (SKIP_DIRS.has(name))
         continue;
-      const gitPath = path22.join(fullPath, ".git");
+      const gitPath = path23.join(fullPath, ".git");
       try {
         const gitStat = fs8.statSync(gitPath);
         if (gitStat.isFile() || gitStat.isDirectory())
           continue;
       } catch {}
       if (name === ".swarm") {
-        const parentDir = path22.dirname(fullPath);
+        const parentDir = path23.dirname(fullPath);
         if (parentDir === projectRoot)
           continue;
         let contents = [];
@@ -40767,7 +41274,7 @@ function detectStraySwarmDirs(projectRoot) {
           contents = ["<unreadable>"];
         }
         findings.push({
-          path: path22.relative(projectRoot, fullPath).replace(/\\/g, "/"),
+          path: path23.relative(projectRoot, fullPath).replace(/\\/g, "/"),
           absolutePath: fullPath,
           contents: contents.slice(0, MAX_CONTENTS_ENTRIES),
           totalEntries: contents.length
@@ -40785,21 +41292,21 @@ function removeStraySwarmDir(projectRoot, strayPath) {
   let canonicalStray;
   try {
     canonicalRoot = fs8.realpathSync(projectRoot);
-    canonicalStray = fs8.realpathSync(path22.isAbsolute(strayPath) ? strayPath : path22.resolve(projectRoot, strayPath));
+    canonicalStray = fs8.realpathSync(path23.isAbsolute(strayPath) ? strayPath : path23.resolve(projectRoot, strayPath));
   } catch (err) {
     return {
       success: false,
       message: `Failed to resolve paths: ${err instanceof Error ? err.message : String(err)}`
     };
   }
-  const rootSwarm = path22.join(canonicalRoot, ".swarm");
+  const rootSwarm = path23.join(canonicalRoot, ".swarm");
   if (canonicalStray === rootSwarm || canonicalStray === canonicalRoot) {
     return {
       success: false,
       message: "Refusing to remove root .swarm/ directory"
     };
   }
-  if (!canonicalStray.startsWith(canonicalRoot + path22.sep)) {
+  if (!canonicalStray.startsWith(canonicalRoot + path23.sep)) {
     return {
       success: false,
       message: "Path is outside project root \u2014 refusing to remove"
@@ -41888,7 +42395,7 @@ var init_profiles = __esm(() => {
 
 // src/lang/detector.ts
 import { access as access3, readdir as readdir2 } from "fs/promises";
-import { extname as extname2, join as join21 } from "path";
+import { extname as extname2, join as join22 } from "path";
 async function detectProjectLanguages(projectDir) {
   const detected = new Set;
   async function scanDir(dir) {
@@ -41904,7 +42411,7 @@ async function detectProjectLanguages(projectDir) {
         if (detectFile.includes("*") || detectFile.includes("?"))
           continue;
         try {
-          await access3(join21(dir, detectFile));
+          await access3(join22(dir, detectFile));
           detected.add(profile.id);
           break;
         } catch {}
@@ -41925,7 +42432,7 @@ async function detectProjectLanguages(projectDir) {
     const topEntries = await readdir2(projectDir, { withFileTypes: true });
     for (const entry of topEntries) {
       if (entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "node_modules") {
-        await scanDir(join21(projectDir, entry.name));
+        await scanDir(join22(projectDir, entry.name));
       }
     }
   } catch {}
@@ -41944,7 +42451,7 @@ var init_detector = __esm(() => {
 
 // src/build/discovery.ts
 import * as fs9 from "fs";
-import * as path23 from "path";
+import * as path24 from "path";
 function isCommandAvailable(command) {
   if (toolchainCache.has(command)) {
     return toolchainCache.get(command);
@@ -41952,7 +42459,7 @@ function isCommandAvailable(command) {
   const isWindows = process.platform === "win32";
   const cmd = isWindows ? `${command}.exe` : command;
   try {
-    const result = _internals11.spawnSyncImpl(isWindows ? ["where", cmd] : ["which", cmd], {
+    const result = _internals12.spawnSyncImpl(isWindows ? ["where", cmd] : ["which", cmd], {
       cwd: process.cwd(),
       stdin: "ignore",
       stdout: "ignore",
@@ -41979,11 +42486,11 @@ function findBuildFiles(workingDir, patterns) {
         const regex = simpleGlobToRegex(pattern);
         const matches = files.filter((f) => regex.test(f));
         if (matches.length > 0) {
-          return path23.join(dir, matches[0]);
+          return path24.join(dir, matches[0]);
         }
       } catch {}
     } else {
-      const filePath = path23.join(workingDir, pattern);
+      const filePath = path24.join(workingDir, pattern);
       if (fs9.existsSync(filePath)) {
         return filePath;
       }
@@ -41992,7 +42499,7 @@ function findBuildFiles(workingDir, patterns) {
   return null;
 }
 function getRepoDefinedScripts(workingDir, scripts) {
-  const packageJsonPath = path23.join(workingDir, "package.json");
+  const packageJsonPath = path24.join(workingDir, "package.json");
   if (!fs9.existsSync(packageJsonPath)) {
     return [];
   }
@@ -42033,7 +42540,7 @@ function findAllBuildFiles(workingDir) {
         const regex = simpleGlobToRegex(pattern);
         findFilesRecursive(workingDir, regex, allBuildFiles);
       } else {
-        const filePath = path23.join(workingDir, pattern);
+        const filePath = path24.join(workingDir, pattern);
         if (fs9.existsSync(filePath)) {
           allBuildFiles.add(filePath);
         }
@@ -42046,7 +42553,7 @@ function findFilesRecursive(dir, regex, results) {
   try {
     const entries = fs9.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path23.join(dir, entry.name);
+      const fullPath = path24.join(dir, entry.name);
       if (entry.isDirectory() && !["node_modules", ".git", "dist", "build", "target"].includes(entry.name)) {
         findFilesRecursive(fullPath, regex, results);
       } else if (entry.isFile() && regex.test(entry.name)) {
@@ -42069,7 +42576,7 @@ async function discoverBuildCommandsFromProfiles(workingDir) {
     let foundCommand = false;
     for (const cmd of sortedCommands) {
       if (cmd.detectFile) {
-        const detectFilePath = path23.join(workingDir, cmd.detectFile);
+        const detectFilePath = path24.join(workingDir, cmd.detectFile);
         if (!fs9.existsSync(detectFilePath)) {
           continue;
         }
@@ -42102,7 +42609,7 @@ async function discoverBuildCommands(workingDir, options) {
   const scope = options?.scope ?? "all";
   const changedFiles = options?.changedFiles ?? [];
   const _filesToCheck = filterByScope(workingDir, scope, changedFiles);
-  const profileResult = await _internals11.discoverBuildCommandsFromProfiles(workingDir);
+  const profileResult = await _internals12.discoverBuildCommandsFromProfiles(workingDir);
   const profileCommands = profileResult.commands;
   const profileSkipped = profileResult.skipped;
   const coveredEcosystems = new Set;
@@ -42165,7 +42672,7 @@ function clearToolchainCache() {
 function getEcosystems() {
   return ECOSYSTEMS.map((e) => e.ecosystem);
 }
-var ECOSYSTEMS, PROFILE_TO_ECOSYSTEM_NAMES, toolchainCache, IS_COMMAND_AVAILABLE_TIMEOUT_MS = 3000, _internals11, build_discovery;
+var ECOSYSTEMS, PROFILE_TO_ECOSYSTEM_NAMES, toolchainCache, IS_COMMAND_AVAILABLE_TIMEOUT_MS = 3000, _internals12, build_discovery;
 var init_discovery = __esm(() => {
   init_dist();
   init_detector();
@@ -42283,7 +42790,7 @@ var init_discovery = __esm(() => {
     php: ["php-composer"]
   };
   toolchainCache = new Map;
-  _internals11 = {
+  _internals12 = {
     isCommandAvailable,
     discoverBuildCommandsFromProfiles,
     discoverBuildCommands,
@@ -42310,7 +42817,7 @@ var init_discovery = __esm(() => {
 
 // src/services/tool-doctor.ts
 import * as fs10 from "fs";
-import * as path24 from "path";
+import * as path25 from "path";
 function extractRegisteredToolKeys(indexPath) {
   const registeredKeys = new Set;
   try {
@@ -42365,8 +42872,8 @@ function checkBinaryReadiness() {
 }
 function runToolDoctor(_directory, pluginRoot) {
   const findings = [];
-  const resolvedPluginRoot = pluginRoot ?? path24.resolve(import.meta.dir, "..", "..");
-  const indexPath = path24.join(resolvedPluginRoot, "src", "index.ts");
+  const resolvedPluginRoot = pluginRoot ?? path25.resolve(import.meta.dir, "..", "..");
+  const indexPath = path25.join(resolvedPluginRoot, "src", "index.ts");
   if (!fs10.existsSync(indexPath)) {
     return {
       findings: [
@@ -42586,7 +43093,7 @@ var exports_evidence_summary_service = {};
 __export(exports_evidence_summary_service, {
   isAutoSummaryEnabled: () => isAutoSummaryEnabled,
   buildEvidenceSummary: () => buildEvidenceSummary,
-  _internals: () => _internals12,
+  _internals: () => _internals13,
   REQUIRED_EVIDENCE_TYPES: () => REQUIRED_EVIDENCE_TYPES,
   EVIDENCE_SUMMARY_VERSION: () => EVIDENCE_SUMMARY_VERSION
 });
@@ -42624,14 +43131,13 @@ function getTaskStatus(task, bundle) {
   if (task?.status) {
     return task.status;
   }
-  const entries = _internals12.normalizeBundleEntries(bundle);
+  const entries = _internals13.normalizeBundleEntries(bundle);
   if (entries.length > 0) {
     return "completed";
   }
   return "pending";
 }
-function isEvidenceComplete(bundle) {
-  const entries = _internals12.normalizeBundleEntries(bundle);
+function evidenceCompleteFromEntries(entries) {
   if (entries.length === 0) {
     return {
       isComplete: false,
@@ -42650,6 +43156,9 @@ function isEvidenceComplete(bundle) {
     missingEvidence: missing
   };
 }
+function isEvidenceComplete(bundle) {
+  return evidenceCompleteFromEntries(_internals13.normalizeBundleEntries(bundle));
+}
 function getTaskBlockers(task, summary, status) {
   const blockers = [];
   if (task?.blocked_reason) {
@@ -42666,11 +43175,19 @@ function getTaskBlockers(task, summary, status) {
 async function buildTaskSummary(directory, task, taskId) {
   const result = await loadEvidence(directory, taskId);
   const bundle = result.status === "found" ? result.bundle : null;
+  const gateEvidence = await readDurableGateEvidence(directory, taskId);
   const phase = task?.phase ?? 0;
-  const status = _internals12.getTaskStatus(task, bundle);
-  const evidenceCheck = _internals12.isEvidenceComplete(bundle);
-  const blockers = _internals12.getTaskBlockers(task, evidenceCheck, status);
-  const entries = _internals12.normalizeBundleEntries(bundle);
+  const status = _internals13.getTaskStatus(task, bundle);
+  const entries = mergeDurableGateEntriesFromEvidence(taskId, _internals13.normalizeBundleEntries(bundle), gateEvidence);
+  let evidenceCheck = _internals13.evidenceCompleteFromEntries(entries);
+  if (gateEvidence) {
+    const gateStatus = getDurableGateEvidenceStatus(gateEvidence);
+    evidenceCheck = gateStatus.isComplete ? { isComplete: true, missingEvidence: [] } : {
+      isComplete: false,
+      missingEvidence: gateStatus.missingGates.map((gate) => `gate:${gate}`)
+    };
+  }
+  const blockers = _internals13.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");
@@ -42699,12 +43216,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 _internals12.buildTaskSummary(directory, task, task.id);
+    const summary = await _internals13.buildTaskSummary(directory, task, task.id);
     taskSummaries.push(summary);
   }
   const extraTaskIds = taskIds.filter((id) => !phaseTaskIds.has(id));
   for (const taskId of extraTaskIds) {
-    const summary = await _internals12.buildTaskSummary(directory, undefined, taskId);
+    const summary = await _internals13.buildTaskSummary(directory, undefined, taskId);
     if (summary.phase === phase.id) {
       taskSummaries.push(summary);
     }
@@ -42805,7 +43322,7 @@ async function buildEvidenceSummary(directory, currentPhase) {
   let totalTasks = 0;
   let completedTasks = 0;
   for (const phase of phasesToProcess) {
-    const summary = await _internals12.buildPhaseSummary(directory, phase);
+    const summary = await _internals13.buildPhaseSummary(directory, phase);
     phaseSummaries.push(summary);
     totalTasks += summary.totalTasks;
     completedTasks += summary.completedTasks;
@@ -42827,7 +43344,7 @@ async function buildEvidenceSummary(directory, currentPhase) {
     overallBlockers,
     summaryText: ""
   };
-  artifact.summaryText = _internals12.generateSummaryText(artifact);
+  artifact.summaryText = _internals13.generateSummaryText(artifact);
   log("[EvidenceSummary] Summary built", {
     phases: phaseSummaries.length,
     totalTasks,
@@ -42846,8 +43363,9 @@ function isAutoSummaryEnabled(automationConfig) {
   }
   return automationConfig.capabilities?.evidence_auto_summaries === true;
 }
-var VALID_EVIDENCE_TYPES2, REQUIRED_EVIDENCE_TYPES, EVIDENCE_SUMMARY_VERSION = "1.0.0", _internals12;
+var VALID_EVIDENCE_TYPES2, REQUIRED_EVIDENCE_TYPES, EVIDENCE_SUMMARY_VERSION = "1.0.0", _internals13;
 var init_evidence_summary_service = __esm(() => {
+  init_gate_bridge();
   init_manager2();
   init_manager();
   init_utils();
@@ -42860,11 +43378,12 @@ var init_evidence_summary_service = __esm(() => {
     "retrospective"
   ]);
   REQUIRED_EVIDENCE_TYPES = ["review", "test"];
-  _internals12 = {
+  _internals13 = {
     buildEvidenceSummary,
     isAutoSummaryEnabled,
     normalizeBundleEntries,
     getTaskStatus,
+    evidenceCompleteFromEntries,
     isEvidenceComplete,
     getTaskBlockers,
     buildTaskSummary,
@@ -42915,7 +43434,7 @@ function getVerdictEmoji(verdict) {
   return getVerdictIcon(verdict);
 }
 async function getTaskEvidenceData(directory, taskId) {
-  const result = await _internals13.loadEvidence(directory, taskId);
+  const result = await _internals14.loadEvidence(directory, taskId);
   if (result.status !== "found") {
     return {
       hasEvidence: false,
@@ -42938,13 +43457,13 @@ async function getTaskEvidenceData(directory, taskId) {
   };
 }
 async function getEvidenceListData(directory) {
-  const taskIds = await _internals13.listEvidenceTaskIds(directory);
+  const taskIds = await _internals14.listEvidenceTaskIds(directory);
   if (taskIds.length === 0) {
     return { hasEvidence: false, tasks: [] };
   }
   const tasks = [];
   for (const taskId of taskIds) {
-    const result = await _internals13.loadEvidence(directory, taskId);
+    const result = await _internals14.loadEvidence(directory, taskId);
     if (result.status === "found") {
       tasks.push({
         taskId,
@@ -43058,10 +43577,10 @@ async function handleEvidenceSummaryCommand(directory) {
   return lines.join(`
 `);
 }
-var _internals13;
+var _internals14;
 var init_evidence_service = __esm(() => {
   init_manager2();
-  _internals13 = {
+  _internals14 = {
     loadEvidence,
     listEvidenceTaskIds
   };
@@ -43112,12 +43631,12 @@ var init_export = __esm(() => {
 
 // src/full-auto/state.ts
 import * as fs11 from "fs";
-import * as path25 from "path";
+import * as path26 from "path";
 function nowISO() {
   return new Date().toISOString();
 }
 function ensureSwarmDir(directory) {
-  const swarmDir = path25.resolve(directory, ".swarm");
+  const swarmDir = path26.resolve(directory, ".swarm");
   if (!fs11.existsSync(swarmDir)) {
     fs11.mkdirSync(swarmDir, { recursive: true });
   }
@@ -43468,7 +43987,7 @@ function extractCurrentPhaseFromPlan2(plan) {
   if (!plan) {
     return { currentPhase: null, currentTask: null, incompleteTasks: [] };
   }
-  if (!_internals14.validatePlanPhases(plan)) {
+  if (!_internals15.validatePlanPhases(plan)) {
     return { currentPhase: null, currentTask: null, incompleteTasks: [] };
   }
   let currentPhase = null;
@@ -43610,9 +44129,9 @@ function extractPhaseMetrics(content) {
 async function getHandoffData(directory) {
   const now = new Date().toISOString();
   const sessionContent = await readSwarmFileAsync(directory, "session/state.json");
-  const sessionState = _internals14.parseSessionState(sessionContent);
+  const sessionState = _internals15.parseSessionState(sessionContent);
   const plan = await loadPlanJsonOnly(directory);
-  const planInfo = _internals14.extractCurrentPhaseFromPlan(plan);
+  const planInfo = _internals15.extractCurrentPhaseFromPlan(plan);
   if (!plan) {
     const planMdContent = await readSwarmFileAsync(directory, "plan.md");
     if (planMdContent) {
@@ -43631,8 +44150,8 @@ async function getHandoffData(directory) {
     }
   }
   const contextContent = await readSwarmFileAsync(directory, "context.md");
-  const recentDecisions = _internals14.extractDecisions(contextContent);
-  const rawPhaseMetrics = _internals14.extractPhaseMetrics(contextContent);
+  const recentDecisions = _internals15.extractDecisions(contextContent);
+  const rawPhaseMetrics = _internals15.extractPhaseMetrics(contextContent);
   const phaseMetrics = sanitizeString(rawPhaseMetrics, 1000);
   let delegationState = null;
   if (sessionState?.delegationState) {
@@ -43796,13 +44315,13 @@ ${lines.join(`
 `)}
 \`\`\``;
 }
-var RTL_OVERRIDE_PATTERN, MAX_TASK_ID_LENGTH = 100, MAX_DECISION_LENGTH = 500, MAX_INCOMPLETE_TASKS = 20, _internals14;
+var RTL_OVERRIDE_PATTERN, MAX_TASK_ID_LENGTH = 100, MAX_DECISION_LENGTH = 500, MAX_INCOMPLETE_TASKS = 20, _internals15;
 var init_handoff_service = __esm(() => {
   init_utils2();
   init_manager();
   init_utils();
   RTL_OVERRIDE_PATTERN = /[\u202e\u202d\u202c\u200f]/g;
-  _internals14 = {
+  _internals15 = {
     getHandoffData,
     formatHandoffMarkdown,
     formatContinuationPrompt,
@@ -43817,8 +44336,8 @@ var init_handoff_service = __esm(() => {
 });
 
 // src/session/snapshot-writer.ts
-import { closeSync as closeSync3, fsyncSync as fsyncSync2, mkdirSync as mkdirSync10, openSync as openSync3, renameSync as renameSync6 } from "fs";
-import * as path26 from "path";
+import { closeSync as closeSync3, fsyncSync as fsyncSync2, mkdirSync as mkdirSync11, openSync as openSync3, renameSync as renameSync6 } from "fs";
+import * as path27 from "path";
 function serializeAgentSession(s) {
   const gateLog = {};
   const rawGateLog = s.gateLog ?? new Map;
@@ -43915,8 +44434,8 @@ async function writeSnapshot(directory, state) {
     }
     const content = JSON.stringify(snapshot, null, 2);
     const resolvedPath = validateSwarmPath(directory, "session/state.json");
-    const dir = path26.dirname(resolvedPath);
-    mkdirSync10(dir, { recursive: true });
+    const dir = path27.dirname(resolvedPath);
+    mkdirSync11(dir, { recursive: true });
     const tempPath = `${resolvedPath}.tmp.${Date.now()}.${Math.random().toString(36).slice(2)}`;
     await bunWrite(tempPath, content);
     try {
@@ -43936,22 +44455,22 @@ async function writeSnapshot(directory, state) {
 }
 function createSnapshotWriterHook(directory) {
   return (_input, _output) => {
-    _writeInFlight = _writeInFlight.then(() => _internals15.writeSnapshot(directory, swarmState), () => _internals15.writeSnapshot(directory, swarmState));
+    _writeInFlight = _writeInFlight.then(() => _internals16.writeSnapshot(directory, swarmState), () => _internals16.writeSnapshot(directory, swarmState));
     return _writeInFlight;
   };
 }
 async function flushPendingSnapshot(directory) {
-  _writeInFlight = _writeInFlight.then(() => _internals15.writeSnapshot(directory, swarmState), () => _internals15.writeSnapshot(directory, swarmState));
+  _writeInFlight = _writeInFlight.then(() => _internals16.writeSnapshot(directory, swarmState), () => _internals16.writeSnapshot(directory, swarmState));
   await _writeInFlight;
 }
-var _writeInFlight, _internals15;
+var _writeInFlight, _internals16;
 var init_snapshot_writer = __esm(() => {
   init_utils2();
   init_state();
   init_utils();
   init_bun_compat();
   _writeInFlight = Promise.resolve();
-  _internals15 = {
+  _internals16 = {
     writeSnapshot,
     createSnapshotWriterHook,
     flushPendingSnapshot
@@ -44372,9 +44891,9 @@ var init_issue = __esm(() => {
 
 // src/hooks/knowledge-migrator.ts
 import { randomUUID as randomUUID2 } from "crypto";
-import { existsSync as existsSync17, readFileSync as readFileSync12 } from "fs";
+import { existsSync as existsSync17, readFileSync as readFileSync13 } from "fs";
 import { mkdir as mkdir7, readFile as readFile7, writeFile as writeFile8 } from "fs/promises";
-import * as path27 from "path";
+import * as path28 from "path";
 async function migrateKnowledgeToExternal(_directory, _config) {
   return {
     migrated: false,
@@ -44385,8 +44904,8 @@ async function migrateKnowledgeToExternal(_directory, _config) {
   };
 }
 async function migrateContextToKnowledge(directory, config3) {
-  const sentinelPath = path27.join(directory, ".swarm", ".knowledge-migrated");
-  const contextPath = path27.join(directory, ".swarm", "context.md");
+  const sentinelPath = path28.join(directory, ".swarm", ".knowledge-migrated");
+  const contextPath = path28.join(directory, ".swarm", "context.md");
   const knowledgePath = resolveSwarmKnowledgePath(directory);
   if (existsSync17(sentinelPath)) {
     return {
@@ -44416,9 +44935,9 @@ async function migrateContextToKnowledge(directory, config3) {
       skippedReason: "empty-context"
     };
   }
-  const rawEntries = _internals16.parseContextMd(contextContent);
+  const rawEntries = _internals17.parseContextMd(contextContent);
   if (rawEntries.length === 0) {
-    await _internals16.writeSentinel(sentinelPath, 0, 0);
+    await _internals17.writeSentinel(sentinelPath, 0, 0);
     return {
       migrated: true,
       entriesMigrated: 0,
@@ -44429,10 +44948,10 @@ async function migrateContextToKnowledge(directory, config3) {
   const existing = await readKnowledge(knowledgePath);
   let migrated = 0;
   let dropped = 0;
-  const projectName = _internals16.inferProjectName(directory);
+  const projectName = _internals17.inferProjectName(directory);
   for (const raw of rawEntries) {
     if (config3.validation_enabled !== false) {
-      const category = raw.categoryHint ?? _internals16.inferCategoryFromText(raw.text);
+      const category = raw.categoryHint ?? _internals17.inferCategoryFromText(raw.text);
       const result = validateLesson(raw.text, existing.map((e) => e.lesson), {
         category,
         scope: "global",
@@ -44452,8 +44971,8 @@ async function migrateContextToKnowledge(directory, config3) {
     const entry = {
       id: randomUUID2(),
       tier: "swarm",
-      lesson: _internals16.truncateLesson(raw.text),
-      category: raw.categoryHint ?? _internals16.inferCategoryFromText(raw.text),
+      lesson: _internals17.truncateLesson(raw.text),
+      category: raw.categoryHint ?? _internals17.inferCategoryFromText(raw.text),
       tags: [...inferredTags, `migration:${raw.sourceSection}`],
       scope: "global",
       confidence: 0.3,
@@ -44476,7 +44995,7 @@ async function migrateContextToKnowledge(directory, config3) {
   if (migrated > 0) {
     await rewriteKnowledge(knowledgePath, existing);
   }
-  await _internals16.writeSentinel(sentinelPath, migrated, dropped);
+  await _internals17.writeSentinel(sentinelPath, migrated, dropped);
   log(`[knowledge-migrator] Migrated ${migrated} entries, dropped ${dropped}`);
   return {
     migrated: true,
@@ -44486,7 +45005,7 @@ async function migrateContextToKnowledge(directory, config3) {
   };
 }
 function parseContextMd(content) {
-  const sections = _internals16.splitIntoSections(content);
+  const sections = _internals17.splitIntoSections(content);
   const entries = [];
   const seen = new Set;
   const sectionPatterns = [
@@ -44502,7 +45021,7 @@ function parseContextMd(content) {
     const match = sectionPatterns.find((sp) => sp.pattern.test(section.heading));
     if (!match)
       continue;
-    const bullets = _internals16.extractBullets(section.body);
+    const bullets = _internals17.extractBullets(section.body);
     for (const bullet of bullets) {
       if (bullet.length < 15)
         continue;
@@ -44511,9 +45030,9 @@ function parseContextMd(content) {
         continue;
       seen.add(normalized);
       entries.push({
-        text: _internals16.truncateLesson(bullet),
+        text: _internals17.truncateLesson(bullet),
         sourceSection: match.sourceSection,
-        categoryHint: _internals16.inferCategoryFromText(bullet)
+        categoryHint: _internals17.inferCategoryFromText(bullet)
       });
     }
   }
@@ -44582,16 +45101,16 @@ function truncateLesson(text) {
   return `${text.slice(0, 277)}...`;
 }
 function inferProjectName(directory) {
-  const packageJsonPath = path27.join(directory, "package.json");
+  const packageJsonPath = path28.join(directory, "package.json");
   if (existsSync17(packageJsonPath)) {
     try {
-      const pkg = JSON.parse(readFileSync12(packageJsonPath, "utf-8"));
+      const pkg = JSON.parse(readFileSync13(packageJsonPath, "utf-8"));
       if (pkg.name && typeof pkg.name === "string") {
         return pkg.name;
       }
     } catch {}
   }
-  return path27.basename(directory);
+  return path28.basename(directory);
 }
 async function writeSentinel(sentinelPath, migrated, dropped) {
   const sentinel = {
@@ -44603,15 +45122,15 @@ async function writeSentinel(sentinelPath, migrated, dropped) {
     schema_version: 1,
     migration_tool: "knowledge-migrator.ts"
   };
-  await mkdir7(path27.dirname(sentinelPath), { recursive: true });
+  await mkdir7(path28.dirname(sentinelPath), { recursive: true });
   await writeFile8(sentinelPath, JSON.stringify(sentinel, null, 2), "utf-8");
 }
-var _internals16;
+var _internals17;
 var init_knowledge_migrator = __esm(() => {
   init_logger();
   init_knowledge_store();
   init_knowledge_validator();
-  _internals16 = {
+  _internals17 = {
     migrateContextToKnowledge,
     migrateKnowledgeToExternal,
     parseContextMd,
@@ -44625,7 +45144,7 @@ var init_knowledge_migrator = __esm(() => {
 });
 
 // src/commands/knowledge.ts
-import { join as join25 } from "path";
+import { join as join26 } from "path";
 function resolveEntryByPrefix(entries, inputId) {
   const exact = entries.find((e) => e.id === inputId);
   if (exact)
@@ -44676,7 +45195,7 @@ async function handleKnowledgeRestoreCommand(directory, args) {
     return "Invalid entry ID. IDs must be 1-64 characters: letters, digits, hyphens, underscores only.";
   }
   try {
-    const quarantinePath = join25(directory, ".swarm", "knowledge-quarantined.jsonl");
+    const quarantinePath = join26(directory, ".swarm", "knowledge-quarantined.jsonl");
     const entries = await readKnowledge(quarantinePath);
     const resolved = resolveEntryByPrefix(entries, inputId);
     if ("error" in resolved) {
@@ -44748,9 +45267,9 @@ var init_knowledge = __esm(() => {
 
 // src/services/plan-service.ts
 async function getPlanData(directory, phaseArg) {
-  const plan = await _internals17.loadPlanJsonOnly(directory);
+  const plan = await _internals18.loadPlanJsonOnly(directory);
   if (plan) {
-    const fullMarkdown = _internals17.derivePlanMarkdown(plan);
+    const fullMarkdown = _internals18.derivePlanMarkdown(plan);
     if (phaseArg === undefined || phaseArg === null || phaseArg === "") {
       return {
         hasPlan: true,
@@ -44793,7 +45312,7 @@ async function getPlanData(directory, phaseArg) {
       isLegacy: false
     };
   }
-  const planContent = await _internals17.readSwarmFileAsync(directory, "plan.md");
+  const planContent = await _internals18.readSwarmFileAsync(directory, "plan.md");
   if (!planContent) {
     return {
       hasPlan: false,
@@ -44889,11 +45408,11 @@ async function handlePlanCommand(directory, args) {
   const planData = await getPlanData(directory, phaseArg);
   return formatPlanMarkdown(planData);
 }
-var _internals17;
+var _internals18;
 var init_plan_service = __esm(() => {
   init_utils2();
   init_manager();
-  _internals17 = {
+  _internals18 = {
     loadPlanJsonOnly,
     derivePlanMarkdown,
     readSwarmFileAsync
@@ -45131,7 +45650,7 @@ var init_path_security = () => {};
 
 // src/tools/lint.ts
 import * as fs12 from "fs";
-import * as path28 from "path";
+import * as path29 from "path";
 function validateArgs(args) {
   if (typeof args !== "object" || args === null)
     return false;
@@ -45142,9 +45661,9 @@ function validateArgs(args) {
 }
 function getLinterCommand(linter, mode, projectDir) {
   const isWindows = process.platform === "win32";
-  const binDir = path28.join(projectDir, "node_modules", ".bin");
-  const biomeBin = isWindows ? path28.join(binDir, "biome.EXE") : path28.join(binDir, "biome");
-  const eslintBin = isWindows ? path28.join(binDir, "eslint.cmd") : path28.join(binDir, "eslint");
+  const binDir = path29.join(projectDir, "node_modules", ".bin");
+  const biomeBin = isWindows ? path29.join(binDir, "biome.EXE") : path29.join(binDir, "biome");
+  const eslintBin = isWindows ? path29.join(binDir, "eslint.cmd") : path29.join(binDir, "eslint");
   switch (linter) {
     case "biome":
       if (mode === "fix") {
@@ -45160,7 +45679,7 @@ function getLinterCommand(linter, mode, projectDir) {
 }
 function getAdditionalLinterCommand(linter, mode, cwd) {
   const gradlewName = process.platform === "win32" ? "gradlew.bat" : "gradlew";
-  const gradlew = fs12.existsSync(path28.join(cwd, gradlewName)) ? path28.join(cwd, gradlewName) : null;
+  const gradlew = fs12.existsSync(path29.join(cwd, gradlewName)) ? path29.join(cwd, gradlewName) : null;
   switch (linter) {
     case "ruff":
       return mode === "fix" ? ["ruff", "check", "--fix", "."] : ["ruff", "check", "."];
@@ -45194,10 +45713,10 @@ function getAdditionalLinterCommand(linter, mode, cwd) {
   }
 }
 function detectRuff(cwd) {
-  if (fs12.existsSync(path28.join(cwd, "ruff.toml")))
+  if (fs12.existsSync(path29.join(cwd, "ruff.toml")))
     return isCommandAvailable("ruff");
   try {
-    const pyproject = path28.join(cwd, "pyproject.toml");
+    const pyproject = path29.join(cwd, "pyproject.toml");
     if (fs12.existsSync(pyproject)) {
       const content = fs12.readFileSync(pyproject, "utf-8");
       if (content.includes("[tool.ruff]"))
@@ -45207,19 +45726,19 @@ function detectRuff(cwd) {
   return false;
 }
 function detectClippy(cwd) {
-  return fs12.existsSync(path28.join(cwd, "Cargo.toml")) && isCommandAvailable("cargo");
+  return fs12.existsSync(path29.join(cwd, "Cargo.toml")) && isCommandAvailable("cargo");
 }
 function detectGolangciLint(cwd) {
-  return fs12.existsSync(path28.join(cwd, "go.mod")) && isCommandAvailable("golangci-lint");
+  return fs12.existsSync(path29.join(cwd, "go.mod")) && isCommandAvailable("golangci-lint");
 }
 function detectCheckstyle(cwd) {
-  const hasMaven = fs12.existsSync(path28.join(cwd, "pom.xml"));
-  const hasGradle = fs12.existsSync(path28.join(cwd, "build.gradle")) || fs12.existsSync(path28.join(cwd, "build.gradle.kts"));
-  const hasBinary = hasMaven && isCommandAvailable("mvn") || hasGradle && (fs12.existsSync(path28.join(cwd, "gradlew")) || isCommandAvailable("gradle"));
+  const hasMaven = fs12.existsSync(path29.join(cwd, "pom.xml"));
+  const hasGradle = fs12.existsSync(path29.join(cwd, "build.gradle")) || fs12.existsSync(path29.join(cwd, "build.gradle.kts"));
+  const hasBinary = hasMaven && isCommandAvailable("mvn") || hasGradle && (fs12.existsSync(path29.join(cwd, "gradlew")) || isCommandAvailable("gradle"));
   return (hasMaven || hasGradle) && hasBinary;
 }
 function detectKtlint(cwd) {
-  const hasKotlin = fs12.existsSync(path28.join(cwd, "build.gradle.kts")) || fs12.existsSync(path28.join(cwd, "build.gradle")) || (() => {
+  const hasKotlin = fs12.existsSync(path29.join(cwd, "build.gradle.kts")) || fs12.existsSync(path29.join(cwd, "build.gradle")) || (() => {
     try {
       return fs12.readdirSync(cwd).some((f) => f.endsWith(".kt") || f.endsWith(".kts"));
     } catch {
@@ -45238,11 +45757,11 @@ function detectDotnetFormat(cwd) {
   }
 }
 function detectCppcheck(cwd) {
-  if (fs12.existsSync(path28.join(cwd, "CMakeLists.txt"))) {
+  if (fs12.existsSync(path29.join(cwd, "CMakeLists.txt"))) {
     return isCommandAvailable("cppcheck");
   }
   try {
-    const dirsToCheck = [cwd, path28.join(cwd, "src")];
+    const dirsToCheck = [cwd, path29.join(cwd, "src")];
     const hasCpp = dirsToCheck.some((dir) => {
       try {
         return fs12.readdirSync(dir).some((f) => /\.(c|cpp|cc|cxx|h|hpp)$/.test(f));
@@ -45256,13 +45775,13 @@ function detectCppcheck(cwd) {
   }
 }
 function detectSwiftlint(cwd) {
-  return fs12.existsSync(path28.join(cwd, "Package.swift")) && isCommandAvailable("swiftlint");
+  return fs12.existsSync(path29.join(cwd, "Package.swift")) && isCommandAvailable("swiftlint");
 }
 function detectDartAnalyze(cwd) {
-  return fs12.existsSync(path28.join(cwd, "pubspec.yaml")) && (isCommandAvailable("dart") || isCommandAvailable("flutter"));
+  return fs12.existsSync(path29.join(cwd, "pubspec.yaml")) && (isCommandAvailable("dart") || isCommandAvailable("flutter"));
 }
 function detectRubocop(cwd) {
-  return (fs12.existsSync(path28.join(cwd, "Gemfile")) || fs12.existsSync(path28.join(cwd, "gems.rb")) || fs12.existsSync(path28.join(cwd, ".rubocop.yml"))) && (isCommandAvailable("rubocop") || isCommandAvailable("bundle"));
+  return (fs12.existsSync(path29.join(cwd, "Gemfile")) || fs12.existsSync(path29.join(cwd, "gems.rb")) || fs12.existsSync(path29.join(cwd, ".rubocop.yml"))) && (isCommandAvailable("rubocop") || isCommandAvailable("bundle"));
 }
 function detectAdditionalLinter(cwd) {
   if (detectRuff(cwd))
@@ -45290,10 +45809,10 @@ function detectAdditionalLinter(cwd) {
 function findBinInAncestors(startDir, binName) {
   let dir = startDir;
   while (true) {
-    const candidate = path28.join(dir, "node_modules", ".bin", binName);
+    const candidate = path29.join(dir, "node_modules", ".bin", binName);
     if (fs12.existsSync(candidate))
       return candidate;
-    const parent = path28.dirname(dir);
+    const parent = path29.dirname(dir);
     if (parent === dir)
       break;
     dir = parent;
@@ -45302,10 +45821,10 @@ function findBinInAncestors(startDir, binName) {
 }
 function findBinInEnvPath(binName) {
   const searchPath = process.env.PATH ?? "";
-  for (const dir of searchPath.split(path28.delimiter)) {
+  for (const dir of searchPath.split(path29.delimiter)) {
     if (!dir)
       continue;
-    const candidate = path28.join(dir, binName);
+    const candidate = path29.join(dir, binName);
     if (fs12.existsSync(candidate))
       return candidate;
   }
@@ -45318,13 +45837,13 @@ async function detectAvailableLinter(directory) {
     return null;
   const projectDir = directory;
   const isWindows = process.platform === "win32";
-  const biomeBin = isWindows ? path28.join(projectDir, "node_modules", ".bin", "biome.EXE") : path28.join(projectDir, "node_modules", ".bin", "biome");
-  const eslintBin = isWindows ? path28.join(projectDir, "node_modules", ".bin", "eslint.cmd") : path28.join(projectDir, "node_modules", ".bin", "eslint");
+  const biomeBin = isWindows ? path29.join(projectDir, "node_modules", ".bin", "biome.EXE") : path29.join(projectDir, "node_modules", ".bin", "biome");
+  const eslintBin = isWindows ? path29.join(projectDir, "node_modules", ".bin", "eslint.cmd") : path29.join(projectDir, "node_modules", ".bin", "eslint");
   const localResult = await _detectAvailableLinter(projectDir, biomeBin, eslintBin);
   if (localResult)
     return localResult;
-  const biomeAncestor = findBinInAncestors(path28.dirname(projectDir), isWindows ? "biome.EXE" : "biome");
-  const eslintAncestor = findBinInAncestors(path28.dirname(projectDir), isWindows ? "eslint.cmd" : "eslint");
+  const biomeAncestor = findBinInAncestors(path29.dirname(projectDir), isWindows ? "biome.EXE" : "biome");
+  const eslintAncestor = findBinInAncestors(path29.dirname(projectDir), isWindows ? "eslint.cmd" : "eslint");
   if (biomeAncestor || eslintAncestor) {
     return _detectAvailableLinter(projectDir, biomeAncestor ?? biomeBin, eslintAncestor ?? eslintBin);
   }
@@ -45483,7 +46002,7 @@ async function runAdditionalLint(linter, mode, cwd) {
     };
   }
 }
-var MAX_OUTPUT_BYTES = 512000, MAX_COMMAND_LENGTH = 500, lint, _internals18;
+var MAX_OUTPUT_BYTES = 512000, MAX_COMMAND_LENGTH = 500, lint, _internals19;
 var init_lint = __esm(() => {
   init_zod();
   init_discovery();
@@ -45515,15 +46034,15 @@ var init_lint = __esm(() => {
       }
       const { mode } = args;
       const cwd = directory;
-      const linter = await _internals18.detectAvailableLinter(directory);
+      const linter = await _internals19.detectAvailableLinter(directory);
       if (linter) {
-        const result = await _internals18.runLint(linter, mode, directory);
+        const result = await _internals19.runLint(linter, mode, directory);
         return JSON.stringify(result, null, 2);
       }
-      const additionalLinter = _internals18.detectAdditionalLinter(cwd);
+      const additionalLinter = _internals19.detectAdditionalLinter(cwd);
       if (additionalLinter) {
         warn(`[lint] Using ${additionalLinter} linter for this project`);
-        const result = await _internals18.runAdditionalLint(additionalLinter, mode, cwd);
+        const result = await _internals19.runAdditionalLint(additionalLinter, mode, cwd);
         return JSON.stringify(result, null, 2);
       }
       const errorResult = {
@@ -45537,7 +46056,7 @@ For Rust: rustup component add clippy`
       return JSON.stringify(errorResult, null, 2);
     }
   });
-  _internals18 = {
+  _internals19 = {
     detectAvailableLinter,
     runLint,
     detectAdditionalLinter,
@@ -45547,7 +46066,7 @@ For Rust: rustup component add clippy`
 
 // src/tools/secretscan.ts
 import * as fs13 from "fs";
-import * as path29 from "path";
+import * as path30 from "path";
 function calculateShannonEntropy(str) {
   if (str.length === 0)
     return 0;
@@ -45595,7 +46114,7 @@ function isGlobOrPathPattern(pattern) {
   return pattern.includes("/") || pattern.includes("\\") || /[*?[\]{}]/.test(pattern);
 }
 function loadSecretScanIgnore(scanDir) {
-  const ignorePath = path29.join(scanDir, ".secretscanignore");
+  const ignorePath = path30.join(scanDir, ".secretscanignore");
   try {
     if (!fs13.existsSync(ignorePath))
       return [];
@@ -45618,7 +46137,7 @@ function isExcluded(entry, relPath, exactNames, globPatterns) {
   if (exactNames.has(entry))
     return true;
   for (const pattern of globPatterns) {
-    if (path29.matchesGlob(relPath, pattern))
+    if (path30.matchesGlob(relPath, pattern))
       return true;
   }
   return false;
@@ -45639,7 +46158,7 @@ function validateDirectoryInput(dir) {
   return null;
 }
 function isBinaryFile(filePath, buffer) {
-  const ext = path29.extname(filePath).toLowerCase();
+  const ext = path30.extname(filePath).toLowerCase();
   if (DEFAULT_EXCLUDE_EXTENSIONS.has(ext)) {
     return true;
   }
@@ -45775,9 +46294,9 @@ function isSymlinkLoop(realPath, visited) {
   return false;
 }
 function isPathWithinScope(realPath, scanDir) {
-  const resolvedScanDir = path29.resolve(scanDir);
-  const resolvedRealPath = path29.resolve(realPath);
-  return resolvedRealPath === resolvedScanDir || resolvedRealPath.startsWith(resolvedScanDir + path29.sep) || resolvedRealPath.startsWith(`${resolvedScanDir}/`) || resolvedRealPath.startsWith(`${resolvedScanDir}\\`);
+  const resolvedScanDir = path30.resolve(scanDir);
+  const resolvedRealPath = path30.resolve(realPath);
+  return resolvedRealPath === resolvedScanDir || resolvedRealPath.startsWith(resolvedScanDir + path30.sep) || resolvedRealPath.startsWith(`${resolvedScanDir}/`) || resolvedRealPath.startsWith(`${resolvedScanDir}\\`);
 }
 function findScannableFiles(dir, excludeExact, excludeGlobs, scanDir, visited, stats = {
   skippedDirs: 0,
@@ -45803,8 +46322,8 @@ function findScannableFiles(dir, excludeExact, excludeGlobs, scanDir, visited, s
     return a.localeCompare(b);
   });
   for (const entry of entries) {
-    const fullPath = path29.join(dir, entry);
-    const relPath = path29.relative(scanDir, fullPath).replace(/\\/g, "/");
+    const fullPath = path30.join(dir, entry);
+    const relPath = path30.relative(scanDir, fullPath).replace(/\\/g, "/");
     if (isExcluded(entry, relPath, excludeExact, excludeGlobs)) {
       stats.skippedDirs++;
       continue;
@@ -45839,7 +46358,7 @@ function findScannableFiles(dir, excludeExact, excludeGlobs, scanDir, visited, s
       const subFiles = findScannableFiles(fullPath, excludeExact, excludeGlobs, scanDir, visited, stats);
       files.push(...subFiles);
     } else if (lstat.isFile()) {
-      const ext = path29.extname(fullPath).toLowerCase();
+      const ext = path30.extname(fullPath).toLowerCase();
       if (!DEFAULT_EXCLUDE_EXTENSIONS.has(ext)) {
         files.push(fullPath);
       } else {
@@ -45851,7 +46370,7 @@ function findScannableFiles(dir, excludeExact, excludeGlobs, scanDir, visited, s
 }
 async function runSecretscan(directory) {
   try {
-    const result = await _internals19.secretscan.execute({ directory }, {});
+    const result = await _internals20.secretscan.execute({ directory }, {});
     const jsonStr = typeof result === "string" ? result : result.output;
     return JSON.parse(jsonStr);
   } catch (e) {
@@ -45866,7 +46385,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_PATTERNS, O_NOFOLLOW, secretscan, _internals19;
+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_PATTERNS, O_NOFOLLOW, secretscan, _internals20;
 var init_secretscan = __esm(() => {
   init_zod();
   init_path_security();
@@ -46099,7 +46618,7 @@ var init_secretscan = __esm(() => {
         }
       }
       try {
-        const _scanDirRaw = path29.resolve(directory);
+        const _scanDirRaw = path30.resolve(directory);
         const scanDir = (() => {
           try {
             return fs13.realpathSync(_scanDirRaw);
@@ -46238,7 +46757,7 @@ var init_secretscan = __esm(() => {
       }
     }
   });
-  _internals19 = {
+  _internals20 = {
     secretscan,
     runSecretscan
   };
@@ -46246,7 +46765,7 @@ var init_secretscan = __esm(() => {
 
 // src/lang/default-backend.ts
 import * as fs14 from "fs";
-import * as path30 from "path";
+import * as path31 from "path";
 function detectFileExists(dir, pattern) {
   if (pattern.includes("*") || pattern.includes("?")) {
     try {
@@ -46258,7 +46777,7 @@ function detectFileExists(dir, pattern) {
     }
   }
   try {
-    fs14.accessSync(path30.join(dir, pattern));
+    fs14.accessSync(path31.join(dir, pattern));
     return true;
   } catch {
     return false;
@@ -46386,8 +46905,8 @@ function defaultBuildTestCommand(profile, framework, files, dir = ".", opts = {}
       return ["mvn", "test"];
     case "gradle": {
       const isWindows = process.platform === "win32";
-      const hasGradlewBat = fs14.existsSync(path30.join(dir, "gradlew.bat"));
-      const hasGradlew = fs14.existsSync(path30.join(dir, "gradlew"));
+      const hasGradlewBat = fs14.existsSync(path31.join(dir, "gradlew.bat"));
+      const hasGradlew = fs14.existsSync(path31.join(dir, "gradlew"));
       if (hasGradlewBat && isWindows)
         return ["gradlew.bat", "test"];
       if (hasGradlew)
@@ -46404,7 +46923,7 @@ function defaultBuildTestCommand(profile, framework, files, dir = ".", opts = {}
         "cmake-build-release",
         "out"
       ];
-      const actualBuildDir = buildDirCandidates.find((d) => fs14.existsSync(path30.join(dir, d, "CMakeCache.txt"))) ?? "build";
+      const actualBuildDir = buildDirCandidates.find((d) => fs14.existsSync(path31.join(dir, d, "CMakeCache.txt"))) ?? "build";
       return ["ctest", "--test-dir", actualBuildDir];
     }
     case "swift-test":
@@ -46691,17 +47210,17 @@ async function defaultSelectBuildCommand(profile, dir) {
   return null;
 }
 async function defaultTestFilesFor(profile, sourceFile, dir) {
-  const ext = path30.extname(sourceFile);
+  const ext = path31.extname(sourceFile);
   if (!profile.extensions.includes(ext))
     return [];
-  const base = path30.basename(sourceFile, ext);
-  const rel = path30.relative(dir, sourceFile);
-  const relDir = path30.dirname(rel);
+  const base = path31.basename(sourceFile, ext);
+  const rel = path31.relative(dir, sourceFile);
+  const relDir = path31.dirname(rel);
   const stripSrc = relDir.replace(/^src(\/|\\)/, "");
   const candidates = new Set;
   for (const tDir of ["tests", "test", "__tests__", "spec"]) {
     for (const suffix of ["", "_test", ".test", "_spec", ".spec"]) {
-      candidates.add(path30.join(dir, tDir, stripSrc, `${base}${suffix}${ext}`));
+      candidates.add(path31.join(dir, tDir, stripSrc, `${base}${suffix}${ext}`));
     }
   }
   const existing = [];
@@ -46742,7 +47261,7 @@ var init_default_backend = __esm(() => {
 
 // src/lang/backends/go.ts
 import * as fs15 from "fs";
-import * as path31 from "path";
+import * as path32 from "path";
 function extractImports(_sourceFile, source) {
   const out = new Set;
   IMPORT_REGEX_SINGLE.lastIndex = 0;
@@ -46768,7 +47287,7 @@ function extractImports(_sourceFile, source) {
 async function selectFramework(dir) {
   let content;
   try {
-    content = fs15.readFileSync(path31.join(dir, "go.mod"), "utf-8");
+    content = fs15.readFileSync(path32.join(dir, "go.mod"), "utf-8");
   } catch {
     return null;
   }
@@ -46789,16 +47308,16 @@ async function selectFramework(dir) {
 async function selectEntryPoints(dir) {
   const points = [];
   try {
-    fs15.accessSync(path31.join(dir, "main.go"));
+    fs15.accessSync(path32.join(dir, "main.go"));
     points.push("main.go");
   } catch {}
   try {
-    const cmdDir = path31.join(dir, "cmd");
+    const cmdDir = path32.join(dir, "cmd");
     const subdirs = fs15.readdirSync(cmdDir, { withFileTypes: true }).filter((d) => d.isDirectory());
     for (const sub of subdirs) {
-      const main = path31.join("cmd", sub.name, "main.go");
+      const main = path32.join("cmd", sub.name, "main.go");
       try {
-        fs15.accessSync(path31.join(dir, main));
+        fs15.accessSync(path32.join(dir, main));
         points.push(main);
       } catch {}
     }
@@ -46817,19 +47336,19 @@ function buildGoBackend() {
     selectEntryPoints
   };
 }
-var PROFILE_ID = "go", IMPORT_REGEX_SINGLE, IMPORT_REGEX_GROUP, IMPORT_REGEX_GROUP_LINE, _internals20;
+var PROFILE_ID = "go", IMPORT_REGEX_SINGLE, IMPORT_REGEX_GROUP, IMPORT_REGEX_GROUP_LINE, _internals21;
 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;
-  _internals20 = { extractImports };
+  _internals21 = { extractImports };
 });
 
 // src/lang/backends/python.ts
 import * as fs16 from "fs";
-import * as path32 from "path";
+import * as path33 from "path";
 function parseImportTargets(rawTargets) {
   const cleaned = rawTargets.replace(/[()]/g, "").split(`
 `).map((line) => line.replace(/#.*$/, "").replace(/\\\s*$/, "")).join(" ");
@@ -46889,7 +47408,7 @@ async function selectFramework2(dir) {
   ];
   for (const candidate of ["pyproject.toml", "requirements.txt", "setup.py"]) {
     try {
-      const content = fs16.readFileSync(path32.join(dir, candidate), "utf-8");
+      const content = fs16.readFileSync(path33.join(dir, candidate), "utf-8");
       const lower = content.toLowerCase();
       for (const [pkg, name] of candidates) {
         if (lower.includes(pkg)) {
@@ -46903,7 +47422,7 @@ async function selectFramework2(dir) {
 async function selectEntryPoints2(dir) {
   const points = new Set;
   try {
-    const content = fs16.readFileSync(path32.join(dir, "pyproject.toml"), "utf-8");
+    const content = fs16.readFileSync(path33.join(dir, "pyproject.toml"), "utf-8");
     const scriptsBlock = content.match(/\[project\.scripts\][\s\S]*?(?=\n\[|$)/);
     if (scriptsBlock) {
       for (const line of scriptsBlock[0].split(`
@@ -46918,7 +47437,7 @@ async function selectEntryPoints2(dir) {
   } catch {}
   for (const name of ["manage.py", "main.py", "app.py", "__main__.py"]) {
     try {
-      fs16.accessSync(path32.join(dir, name));
+      fs16.accessSync(path33.join(dir, name));
       points.add(name);
     } catch {}
   }
@@ -46936,18 +47455,18 @@ function buildPythonBackend() {
     selectEntryPoints: selectEntryPoints2
   };
 }
-var PROFILE_ID2 = "python", IMPORT_REGEX_FROM_WITH_TARGETS, IMPORT_REGEX_IMPORT, _internals21;
+var PROFILE_ID2 = "python", IMPORT_REGEX_FROM_WITH_TARGETS, IMPORT_REGEX_IMPORT, _internals22;
 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;
-  _internals21 = { extractImports: extractImports2 };
+  _internals22 = { extractImports: extractImports2 };
 });
 
 // src/test-impact/analyzer.ts
 import fs17 from "fs";
-import path33 from "path";
+import path34 from "path";
 function normalizePath(p) {
   return p.replace(/\\/g, "/");
 }
@@ -46968,8 +47487,8 @@ function resolveRelativeImport(fromDir, importPath) {
   if (!importPath.startsWith(".")) {
     return null;
   }
-  const resolved = path33.resolve(fromDir, importPath);
-  if (path33.extname(resolved)) {
+  const resolved = path34.resolve(fromDir, importPath);
+  if (path34.extname(resolved)) {
     if (fs17.existsSync(resolved) && fs17.statSync(resolved).isFile()) {
       return normalizePath(resolved);
     }
@@ -46989,20 +47508,20 @@ function resolvePythonImport(fromDir, module) {
   const leadingDots = module.match(/^\.+/)?.[0].length ?? 0;
   let baseDir = fromDir;
   for (let i = 1;i < leadingDots; i++) {
-    baseDir = path33.dirname(baseDir);
+    baseDir = path34.dirname(baseDir);
   }
   const rest = module.slice(leadingDots);
   if (rest.length === 0) {
-    const initPath = path33.join(baseDir, "__init__.py");
+    const initPath = path34.join(baseDir, "__init__.py");
     if (fs17.existsSync(initPath) && fs17.statSync(initPath).isFile()) {
       return normalizePath(initPath);
     }
     return null;
   }
-  const subpath = rest.replace(/\./g, path33.sep);
+  const subpath = rest.replace(/\./g, path34.sep);
   const candidates = [
-    `${path33.join(baseDir, subpath)}.py`,
-    path33.join(baseDir, subpath, "__init__.py")
+    `${path34.join(baseDir, subpath)}.py`,
+    path34.join(baseDir, subpath, "__init__.py")
   ];
   for (const c of candidates) {
     if (fs17.existsSync(c) && fs17.statSync(c).isFile())
@@ -47011,7 +47530,7 @@ function resolvePythonImport(fromDir, module) {
   return null;
 }
 function findGoModule(fromDir) {
-  const resolved = path33.resolve(fromDir);
+  const resolved = path34.resolve(fromDir);
   let cur = resolved;
   const walked = [];
   for (let i = 0;i < 16; i++) {
@@ -47023,7 +47542,7 @@ function findGoModule(fromDir) {
     }
     walked.push(cur);
     try {
-      const goMod = path33.join(cur, "go.mod");
+      const goMod = path34.join(cur, "go.mod");
       const content = fs17.readFileSync(goMod, "utf-8");
       const moduleMatch = content.match(/^\s*module\s+"?([^"\s/]+(?:\/[^"\s]+)*)"?/m);
       if (moduleMatch) {
@@ -47034,10 +47553,10 @@ function findGoModule(fromDir) {
       }
     } catch {}
     try {
-      fs17.accessSync(path33.join(cur, ".git"));
+      fs17.accessSync(path34.join(cur, ".git"));
       break;
     } catch {}
-    const parent = path33.dirname(cur);
+    const parent = path34.dirname(cur);
     if (parent === cur)
       break;
     cur = parent;
@@ -47049,12 +47568,12 @@ function findGoModule(fromDir) {
 function resolveGoImport(fromDir, importPath) {
   let dir = null;
   if (importPath.startsWith(".")) {
-    dir = path33.resolve(fromDir, importPath);
+    dir = path34.resolve(fromDir, importPath);
   } else {
     const mod = findGoModule(fromDir);
     if (mod && (importPath === mod.modulePath || importPath.startsWith(`${mod.modulePath}/`))) {
       const subpath = importPath.slice(mod.modulePath.length);
-      dir = path33.join(mod.moduleRoot, subpath);
+      dir = path34.join(mod.moduleRoot, subpath);
     }
   }
   if (dir === null)
@@ -47062,7 +47581,7 @@ function resolveGoImport(fromDir, importPath) {
   if (!fs17.existsSync(dir) || !fs17.statSync(dir).isDirectory())
     return [];
   try {
-    return fs17.readdirSync(dir).filter((f) => f.endsWith(".go") && !f.endsWith("_test.go")).map((f) => normalizePath(path33.join(dir, f)));
+    return fs17.readdirSync(dir).filter((f) => f.endsWith(".go") && !f.endsWith("_test.go")).map((f) => normalizePath(path34.join(dir, f)));
   } catch {
     return [];
   }
@@ -47101,15 +47620,15 @@ function findTestFilesSync(cwd) {
     for (const entry of entries) {
       if (entry.isDirectory()) {
         if (!skipDirs.has(entry.name)) {
-          walk(path33.join(dir, entry.name), visitedInodes);
+          walk(path34.join(dir, entry.name), visitedInodes);
         }
       } else if (entry.isFile()) {
         const name = entry.name;
         const isTsTest = /\.(test|spec)\.(ts|tsx|js|jsx)$/.test(name) || dir.includes("__tests__") && /\.(ts|tsx|js|jsx)$/.test(name);
-        const isPyTest = /^test_.+\.py$/.test(name) || /.+_test\.py$/.test(name) || dir.includes(`${path33.sep}tests${path33.sep}`) && name.endsWith(".py");
+        const isPyTest = /^test_.+\.py$/.test(name) || /.+_test\.py$/.test(name) || dir.includes(`${path34.sep}tests${path34.sep}`) && name.endsWith(".py");
         const isGoTest = /.+_test\.go$/.test(name);
         if (isTsTest || isPyTest || isGoTest) {
-          testFiles.push(normalizePath(path33.join(dir, entry.name)));
+          testFiles.push(normalizePath(path34.join(dir, entry.name)));
         }
       }
     }
@@ -47134,8 +47653,8 @@ function extractImports3(content) {
   ];
 }
 function addImpactEdgesForTestFile(testFile, content, impactMap) {
-  const ext = path33.extname(testFile).toLowerCase();
-  const testDir = path33.dirname(testFile);
+  const ext = path34.extname(testFile).toLowerCase();
+  const testDir = path34.dirname(testFile);
   function addEdge(source) {
     if (!impactMap[source])
       impactMap[source] = [];
@@ -47153,7 +47672,7 @@ function addImpactEdgesForTestFile(testFile, content, impactMap) {
     return;
   }
   if (PYTHON_EXTENSIONS.has(ext)) {
-    const modules = _internals21.extractImports(testFile, content);
+    const modules = _internals22.extractImports(testFile, content);
     for (const mod of modules) {
       const resolved = resolvePythonImport(testDir, mod);
       if (resolved !== null)
@@ -47162,7 +47681,7 @@ function addImpactEdgesForTestFile(testFile, content, impactMap) {
     return;
   }
   if (GO_EXTENSIONS.has(ext)) {
-    const imports = _internals20.extractImports(testFile, content);
+    const imports = _internals21.extractImports(testFile, content);
     for (const importPath of imports) {
       const sourceFiles = resolveGoImport(testDir, importPath);
       for (const source of sourceFiles)
@@ -47189,12 +47708,12 @@ async function buildImpactMapInternal(cwd) {
   return impactMap;
 }
 async function buildImpactMap(cwd) {
-  const impactMap = await _internals22.buildImpactMapInternal(cwd);
-  await _internals22.saveImpactMap(cwd, impactMap);
+  const impactMap = await _internals23.buildImpactMapInternal(cwd);
+  await _internals23.saveImpactMap(cwd, impactMap);
   return impactMap;
 }
 async function loadImpactMap(cwd, options) {
-  const cachePath = path33.join(cwd, ".swarm", "cache", "impact-map.json");
+  const cachePath = path34.join(cwd, ".swarm", "cache", "impact-map.json");
   if (fs17.existsSync(cachePath)) {
     try {
       const content = fs17.readFileSync(cachePath, "utf-8");
@@ -47204,7 +47723,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 (!_internals22.isCacheStale(map3, generatedAt)) {
+          if (!_internals23.isCacheStale(map3, generatedAt)) {
             return map3;
           }
           if (options?.skipRebuild) {
@@ -47224,15 +47743,15 @@ async function loadImpactMap(cwd, options) {
   if (options?.skipRebuild) {
     return {};
   }
-  return _internals22.buildImpactMap(cwd);
+  return _internals23.buildImpactMap(cwd);
 }
 async function saveImpactMap(cwd, impactMap) {
-  if (!path33.isAbsolute(cwd)) {
+  if (!path34.isAbsolute(cwd)) {
     throw new Error(`saveImpactMap requires an absolute project root path, got: "${cwd}"`);
   }
-  _internals22.validateProjectRoot(cwd);
-  const cacheDir2 = path33.join(cwd, ".swarm", "cache");
-  const cachePath = path33.join(cacheDir2, "impact-map.json");
+  _internals23.validateProjectRoot(cwd);
+  const cacheDir2 = path34.join(cwd, ".swarm", "cache");
+  const cachePath = path34.join(cacheDir2, "impact-map.json");
   if (!fs17.existsSync(cacheDir2)) {
     fs17.mkdirSync(cacheDir2, { recursive: true });
   }
@@ -47254,7 +47773,7 @@ async function analyzeImpact(changedFiles, cwd, budget) {
     };
   }
   const validFiles = changedFiles.filter((f) => typeof f === "string" && f.length > 0 && !f.includes("\x00"));
-  const impactMap = await _internals22.loadImpactMap(cwd);
+  const impactMap = await _internals23.loadImpactMap(cwd);
   const impactedTestsSet = new Set;
   const untestedFiles = [];
   let visitedCount = 0;
@@ -47264,7 +47783,7 @@ async function analyzeImpact(changedFiles, cwd, budget) {
       budgetExceeded = true;
       break;
     }
-    const normalizedChanged = normalizePath(path33.resolve(changedFile));
+    const normalizedChanged = normalizePath(path34.resolve(changedFile));
     const tests = impactMap[normalizedChanged];
     if (tests && tests.length > 0) {
       for (const test of tests) {
@@ -47321,7 +47840,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, _internals22;
+var IMPORT_REGEX_ES, IMPORT_REGEX_REQUIRE, IMPORT_REGEX_REEXPORT, TS_EXTENSIONS, PYTHON_EXTENSIONS, GO_EXTENSIONS, EXTENSIONS_TO_TRY, goModuleCache, _internals23;
 var init_analyzer = __esm(() => {
   init_manager2();
   init_go();
@@ -47334,7 +47853,7 @@ var init_analyzer = __esm(() => {
   GO_EXTENSIONS = new Set([".go"]);
   EXTENSIONS_TO_TRY = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"];
   goModuleCache = new Map;
-  _internals22 = {
+  _internals23 = {
     validateProjectRoot,
     normalizePath,
     isCacheStale,
@@ -47557,15 +48076,15 @@ var FLAKY_THRESHOLD = 0.3, MIN_RUNS_FOR_QUARANTINE = 5, MAX_HISTORY_RUNS = 20;
 
 // src/test-impact/history-store.ts
 import fs18 from "fs";
-import path34 from "path";
+import path35 from "path";
 function getHistoryPath(workingDir) {
   if (!workingDir) {
     throw new Error("getHistoryPath requires a working directory \u2014 project root must be provided by the caller");
   }
-  if (!path34.isAbsolute(workingDir)) {
+  if (!path35.isAbsolute(workingDir)) {
     throw new Error(`getHistoryPath requires an absolute project root path, got: "${workingDir}"`);
   }
-  return path34.join(workingDir, ".swarm", "cache", "test-history.jsonl");
+  return path35.join(workingDir, ".swarm", "cache", "test-history.jsonl");
 }
 function sanitizeErrorMessage(errorMessage) {
   if (errorMessage === undefined) {
@@ -47652,8 +48171,8 @@ function batchAppendTestRuns(records, workingDir) {
     }
   }
   const historyPath = getHistoryPath(workingDir);
-  const historyDir = path34.dirname(historyPath);
-  _internals23.validateProjectRoot(workingDir);
+  const historyDir = path35.dirname(historyPath);
+  _internals24.validateProjectRoot(workingDir);
   if (!fs18.existsSync(historyDir)) {
     fs18.mkdirSync(historyDir, { recursive: true });
   }
@@ -47733,7 +48252,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, DANGEROUS_PROPERTY_NAMES, _internals23;
+var MAX_HISTORY_PER_TEST = 20, MAX_ERROR_LENGTH = 500, MAX_STACK_LENGTH = 200, MAX_CHANGED_FILES = 50, DANGEROUS_PROPERTY_NAMES, _internals24;
 var init_history_store = __esm(() => {
   init_manager2();
   DANGEROUS_PROPERTY_NAMES = new Set([
@@ -47741,14 +48260,14 @@ var init_history_store = __esm(() => {
     "constructor",
     "prototype"
   ]);
-  _internals23 = {
+  _internals24 = {
     validateProjectRoot
   };
 });
 
 // src/tools/resolve-working-directory.ts
 import * as fs19 from "fs";
-import * as path35 from "path";
+import * as path36 from "path";
 function resolveWorkingDirectory(workingDirectory, fallbackDirectory) {
   if (workingDirectory == null || workingDirectory === "") {
     return { success: true, directory: fallbackDirectory };
@@ -47768,15 +48287,15 @@ function resolveWorkingDirectory(workingDirectory, fallbackDirectory) {
       };
     }
   }
-  const normalizedDir = path35.normalize(workingDirectory);
-  const pathParts = normalizedDir.split(path35.sep);
+  const normalizedDir = path36.normalize(workingDirectory);
+  const pathParts = normalizedDir.split(path36.sep);
   if (pathParts.includes("..")) {
     return {
       success: false,
       message: "Invalid working_directory: path traversal sequences (..) are not allowed"
     };
   }
-  const resolvedDir = path35.resolve(normalizedDir);
+  const resolvedDir = path36.resolve(normalizedDir);
   let statResult;
   try {
     statResult = fs19.statSync(resolvedDir);
@@ -47792,7 +48311,7 @@ function resolveWorkingDirectory(workingDirectory, fallbackDirectory) {
       message: `Invalid working_directory: path "${resolvedDir}" is not a directory`
     };
   }
-  const resolvedFallback = path35.resolve(fallbackDirectory);
+  const resolvedFallback = path36.resolve(fallbackDirectory);
   let fallbackExists = false;
   try {
     fs19.statSync(resolvedFallback);
@@ -47802,7 +48321,7 @@ function resolveWorkingDirectory(workingDirectory, fallbackDirectory) {
   }
   if (workingDirectory != null && workingDirectory !== "") {
     if (fallbackExists) {
-      const isSubdirectory = resolvedDir.startsWith(resolvedFallback + path35.sep);
+      const isSubdirectory = resolvedDir.startsWith(resolvedFallback + path36.sep);
       if (isSubdirectory) {
         return {
           success: false,
@@ -47857,17 +48376,17 @@ var init_registry_backend = __esm(() => {
 
 // src/lang/backends/typescript.ts
 import * as fs20 from "fs";
-import * as path36 from "path";
+import * as path37 from "path";
 function readPackageJsonRaw(dir) {
   try {
-    const content = fs20.readFileSync(path36.join(dir, "package.json"), "utf-8");
+    const content = fs20.readFileSync(path37.join(dir, "package.json"), "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
   }
 }
 function readPackageJson(dir) {
-  return _internals24.readPackageJsonRaw(dir);
+  return _internals25.readPackageJsonRaw(dir);
 }
 function readPackageJsonTestScript(dir) {
   return readPackageJson(dir)?.scripts?.test ?? null;
@@ -48037,7 +48556,7 @@ function buildTypescriptBackend() {
     selectEntryPoints: selectEntryPoints3
   };
 }
-var PROFILE_ID3 = "typescript", IMPORT_REGEX_ES2, IMPORT_REGEX_BARE, IMPORT_REGEX_REQUIRE2, IMPORT_REGEX_DYNAMIC, IMPORT_REGEX_REEXPORT2, _internals24;
+var PROFILE_ID3 = "typescript", IMPORT_REGEX_ES2, IMPORT_REGEX_BARE, IMPORT_REGEX_REQUIRE2, IMPORT_REGEX_DYNAMIC, IMPORT_REGEX_REEXPORT2, _internals25;
 var init_typescript = __esm(() => {
   init_default_backend();
   init_profiles();
@@ -48046,7 +48565,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;
-  _internals24 = {
+  _internals25 = {
     readPackageJsonRaw,
     readPackageJsonTestScript,
     frameworkFromScriptsTest
@@ -48077,10 +48596,10 @@ __export(exports_dispatch, {
   pickedProfiles: () => pickedProfiles,
   pickBackend: () => pickBackend,
   clearDispatchCache: () => clearDispatchCache,
-  _internals: () => _internals25
+  _internals: () => _internals26
 });
 import * as fs21 from "fs";
-import * as path37 from "path";
+import * as path38 from "path";
 function safeReaddirSet(dir) {
   try {
     return new Set(fs21.readdirSync(dir));
@@ -48097,14 +48616,14 @@ function manifestHash(dir) {
     if (!entries.has(name))
       continue;
     try {
-      const stat3 = fs21.statSync(path37.join(dir, name));
+      const stat3 = fs21.statSync(path38.join(dir, name));
       parts.push(`${name}:${stat3.size}:${stat3.mtimeMs}:${stat3.ino}`);
     } catch {}
   }
   return parts.join("|");
 }
 function findManifestRoot(start) {
-  const resolved = path37.resolve(start);
+  const resolved = path38.resolve(start);
   const cached3 = manifestRootCache.get(resolved);
   if (cached3 !== undefined)
     return cached3;
@@ -48123,7 +48642,7 @@ function findManifestRoot(start) {
         return cur;
       }
     }
-    const parent = path37.dirname(cur);
+    const parent = path38.dirname(cur);
     if (parent === cur)
       break;
     cur = parent;
@@ -48132,7 +48651,7 @@ function findManifestRoot(start) {
   return start;
 }
 function evictIfNeeded() {
-  if (cache.size <= _internals25.cacheCapacity)
+  if (cache.size <= _internals26.cacheCapacity)
     return;
   let oldestKey;
   let oldestOrder = Infinity;
@@ -48163,7 +48682,7 @@ async function pickBackend(dir) {
     evictIfNeeded();
     return null;
   }
-  const profiles = await _internals25.detectProjectLanguages(root);
+  const profiles = await _internals26.detectProjectLanguages(root);
   if (profiles.length === 0) {
     cache.set(cacheKey, {
       hash: hash3,
@@ -48195,12 +48714,12 @@ function clearDispatchCache() {
   manifestRootCache.clear();
   insertCounter = 0;
 }
-var _internals25, cache, insertCounter = 0, MANIFEST_FILES, _MANIFEST_SET, manifestRootCache;
+var _internals26, cache, insertCounter = 0, MANIFEST_FILES, _MANIFEST_SET, manifestRootCache;
 var init_dispatch = __esm(() => {
   init_backends();
   init_detector();
   init_registry_backend();
-  _internals25 = {
+  _internals26 = {
     detectProjectLanguages,
     cacheCapacity: 64
   };
@@ -48233,13 +48752,13 @@ var init_dispatch = __esm(() => {
 
 // src/tools/test-runner.ts
 import * as fs22 from "fs";
-import * as path38 from "path";
+import * as path39 from "path";
 async function estimateFanOut(sourceFiles, cwd) {
   try {
     const impactMap = await loadImpactMap(cwd, { skipRebuild: true });
     const uniqueTestFiles = new Set;
     for (const sourceFile of sourceFiles) {
-      const resolvedPath = path38.resolve(cwd, sourceFile);
+      const resolvedPath = path39.resolve(cwd, sourceFile);
       const normalizedPath = resolvedPath.replace(/\\/g, "/");
       const testFiles = impactMap[normalizedPath];
       if (testFiles) {
@@ -48317,14 +48836,14 @@ function hasDevDependency(devDeps, ...patterns) {
   return hasPackageJsonDependency(devDeps, ...patterns);
 }
 function detectGoTest(cwd) {
-  return fs22.existsSync(path38.join(cwd, "go.mod")) && isCommandAvailable("go");
+  return fs22.existsSync(path39.join(cwd, "go.mod")) && isCommandAvailable("go");
 }
 function detectJavaMaven(cwd) {
-  return fs22.existsSync(path38.join(cwd, "pom.xml")) && isCommandAvailable("mvn");
+  return fs22.existsSync(path39.join(cwd, "pom.xml")) && isCommandAvailable("mvn");
 }
 function detectGradle(cwd) {
-  const hasBuildFile = fs22.existsSync(path38.join(cwd, "build.gradle")) || fs22.existsSync(path38.join(cwd, "build.gradle.kts"));
-  const hasGradlew = fs22.existsSync(path38.join(cwd, "gradlew")) || fs22.existsSync(path38.join(cwd, "gradlew.bat"));
+  const hasBuildFile = fs22.existsSync(path39.join(cwd, "build.gradle")) || fs22.existsSync(path39.join(cwd, "build.gradle.kts"));
+  const hasGradlew = fs22.existsSync(path39.join(cwd, "gradlew")) || fs22.existsSync(path39.join(cwd, "gradlew.bat"));
   return hasBuildFile && (hasGradlew || isCommandAvailable("gradle"));
 }
 function detectDotnetTest(cwd) {
@@ -48337,25 +48856,25 @@ function detectDotnetTest(cwd) {
   }
 }
 function detectCTest(cwd) {
-  const hasSource = fs22.existsSync(path38.join(cwd, "CMakeLists.txt"));
-  const hasBuildCache = fs22.existsSync(path38.join(cwd, "CMakeCache.txt")) || fs22.existsSync(path38.join(cwd, "build", "CMakeCache.txt"));
+  const hasSource = fs22.existsSync(path39.join(cwd, "CMakeLists.txt"));
+  const hasBuildCache = fs22.existsSync(path39.join(cwd, "CMakeCache.txt")) || fs22.existsSync(path39.join(cwd, "build", "CMakeCache.txt"));
   return (hasSource || hasBuildCache) && isCommandAvailable("ctest");
 }
 function detectSwiftTest(cwd) {
-  return fs22.existsSync(path38.join(cwd, "Package.swift")) && isCommandAvailable("swift");
+  return fs22.existsSync(path39.join(cwd, "Package.swift")) && isCommandAvailable("swift");
 }
 function detectDartTest(cwd) {
-  return fs22.existsSync(path38.join(cwd, "pubspec.yaml")) && (isCommandAvailable("dart") || isCommandAvailable("flutter"));
+  return fs22.existsSync(path39.join(cwd, "pubspec.yaml")) && (isCommandAvailable("dart") || isCommandAvailable("flutter"));
 }
 function detectRSpec(cwd) {
-  const hasRSpecFile = fs22.existsSync(path38.join(cwd, ".rspec"));
-  const hasGemfile = fs22.existsSync(path38.join(cwd, "Gemfile"));
-  const hasSpecDir = fs22.existsSync(path38.join(cwd, "spec"));
+  const hasRSpecFile = fs22.existsSync(path39.join(cwd, ".rspec"));
+  const hasGemfile = fs22.existsSync(path39.join(cwd, "Gemfile"));
+  const hasSpecDir = fs22.existsSync(path39.join(cwd, "spec"));
   const hasRSpec = hasRSpecFile || hasGemfile && hasSpecDir;
   return hasRSpec && (isCommandAvailable("bundle") || isCommandAvailable("rspec"));
 }
 function detectMinitest(cwd) {
-  return fs22.existsSync(path38.join(cwd, "test")) && (fs22.existsSync(path38.join(cwd, "Gemfile")) || fs22.existsSync(path38.join(cwd, "Rakefile"))) && isCommandAvailable("ruby");
+  return fs22.existsSync(path39.join(cwd, "test")) && (fs22.existsSync(path39.join(cwd, "Gemfile")) || fs22.existsSync(path39.join(cwd, "Rakefile"))) && isCommandAvailable("ruby");
 }
 async function detectTestFrameworkViaDispatch(cwd) {
   try {
@@ -48417,7 +48936,7 @@ async function parseTestOutputViaDispatch(framework, output, baseDir) {
 async function detectTestFramework(cwd) {
   const baseDir = cwd;
   try {
-    const packageJsonPath = path38.join(baseDir, "package.json");
+    const packageJsonPath = path39.join(baseDir, "package.json");
     if (fs22.existsSync(packageJsonPath)) {
       const content = fs22.readFileSync(packageJsonPath, "utf-8");
       const pkg = JSON.parse(content);
@@ -48438,16 +48957,16 @@ async function detectTestFramework(cwd) {
         return "jest";
       if (hasDevDependency(devDeps, "mocha", "@types/mocha"))
         return "mocha";
-      if (fs22.existsSync(path38.join(baseDir, "bun.lockb")) || fs22.existsSync(path38.join(baseDir, "bun.lock"))) {
+      if (fs22.existsSync(path39.join(baseDir, "bun.lockb")) || fs22.existsSync(path39.join(baseDir, "bun.lock"))) {
         if (scripts.test?.includes("bun"))
           return "bun";
       }
     }
   } catch {}
   try {
-    const pyprojectTomlPath = path38.join(baseDir, "pyproject.toml");
-    const setupCfgPath = path38.join(baseDir, "setup.cfg");
-    const requirementsTxtPath = path38.join(baseDir, "requirements.txt");
+    const pyprojectTomlPath = path39.join(baseDir, "pyproject.toml");
+    const setupCfgPath = path39.join(baseDir, "setup.cfg");
+    const requirementsTxtPath = path39.join(baseDir, "requirements.txt");
     if (fs22.existsSync(pyprojectTomlPath)) {
       const content = fs22.readFileSync(pyprojectTomlPath, "utf-8");
       if (content.includes("[tool.pytest"))
@@ -48467,7 +48986,7 @@ async function detectTestFramework(cwd) {
     }
   } catch {}
   try {
-    const cargoTomlPath = path38.join(baseDir, "Cargo.toml");
+    const cargoTomlPath = path39.join(baseDir, "Cargo.toml");
     if (fs22.existsSync(cargoTomlPath)) {
       const content = fs22.readFileSync(cargoTomlPath, "utf-8");
       if (content.includes("[dev-dependencies]")) {
@@ -48478,9 +48997,9 @@ async function detectTestFramework(cwd) {
     }
   } catch {}
   try {
-    const pesterConfigPath = path38.join(baseDir, "pester.config.ps1");
-    const pesterConfigJsonPath = path38.join(baseDir, "pester.config.ps1.json");
-    const pesterPs1Path = path38.join(baseDir, "tests.ps1");
+    const pesterConfigPath = path39.join(baseDir, "pester.config.ps1");
+    const pesterConfigJsonPath = path39.join(baseDir, "pester.config.ps1.json");
+    const pesterPs1Path = path39.join(baseDir, "tests.ps1");
     if (fs22.existsSync(pesterConfigPath) || fs22.existsSync(pesterConfigJsonPath) || fs22.existsSync(pesterPs1Path)) {
       return "pester";
     }
@@ -48509,12 +49028,12 @@ function isTestDirectoryPath(normalizedPath) {
   return normalizedPath.split("/").some((segment) => TEST_DIRECTORY_NAMES.includes(segment));
 }
 function resolveWorkspacePath(file3, workingDir) {
-  return path38.isAbsolute(file3) ? path38.resolve(file3) : path38.resolve(workingDir, file3);
+  return path39.isAbsolute(file3) ? path39.resolve(file3) : path39.resolve(workingDir, file3);
 }
 function toWorkspaceOutputPath(absolutePath, workingDir, preferRelative) {
   if (!preferRelative)
     return absolutePath;
-  return path38.relative(workingDir, absolutePath);
+  return path39.relative(workingDir, absolutePath);
 }
 function dedupePush(target, value) {
   if (!target.includes(value)) {
@@ -48551,18 +49070,18 @@ function buildLanguageSpecificTestNames(nameWithoutExt, ext) {
   }
 }
 function getRepoLevelCandidateDirectories(workingDir, relativePath, ext) {
-  const relativeDir = path38.dirname(relativePath);
+  const relativeDir = path39.dirname(relativePath);
   const nestedRelativeDir = relativeDir === "." ? "" : relativeDir;
   const directories = TEST_DIRECTORY_NAMES.flatMap((dirName) => {
-    const rootDir = path38.join(workingDir, dirName);
-    return nestedRelativeDir ? [rootDir, path38.join(rootDir, nestedRelativeDir)] : [rootDir];
+    const rootDir = path39.join(workingDir, dirName);
+    return nestedRelativeDir ? [rootDir, path39.join(rootDir, nestedRelativeDir)] : [rootDir];
   });
   const normalizedRelativePath = relativePath.replace(/\\/g, "/");
   if (ext === ".java" && normalizedRelativePath.startsWith("src/main/java/")) {
-    directories.push(path38.join(workingDir, "src/test/java", path38.dirname(normalizedRelativePath.slice("src/main/java/".length))));
+    directories.push(path39.join(workingDir, "src/test/java", path39.dirname(normalizedRelativePath.slice("src/main/java/".length))));
   }
   if ((ext === ".kt" || ext === ".java") && normalizedRelativePath.startsWith("src/main/kotlin/")) {
-    directories.push(path38.join(workingDir, "src/test/kotlin", path38.dirname(normalizedRelativePath.slice("src/main/kotlin/".length))));
+    directories.push(path39.join(workingDir, "src/test/kotlin", path39.dirname(normalizedRelativePath.slice("src/main/kotlin/".length))));
   }
   return [...new Set(directories)];
 }
@@ -48590,23 +49109,23 @@ function isLanguageSpecificTestFile(basename6) {
 }
 function isConventionTestFilePath(filePath) {
   const normalizedPath = filePath.replace(/\\/g, "/");
-  const basename6 = path38.basename(filePath);
+  const basename6 = path39.basename(filePath);
   return hasCompoundTestExtension(basename6) || basename6.includes(".spec.") || basename6.includes(".test.") || isLanguageSpecificTestFile(basename6) || isTestDirectoryPath(normalizedPath);
 }
 function getTestFilesFromConvention(sourceFiles, workingDir = process.cwd()) {
   const testFiles = [];
   for (const file3 of sourceFiles) {
     const absoluteFile = resolveWorkspacePath(file3, workingDir);
-    const relativeFile = path38.relative(workingDir, absoluteFile);
-    const basename6 = path38.basename(absoluteFile);
-    const dirname17 = path38.dirname(absoluteFile);
-    const preferRelativeOutput = !path38.isAbsolute(file3);
+    const relativeFile = path39.relative(workingDir, absoluteFile);
+    const basename6 = path39.basename(absoluteFile);
+    const dirname17 = path39.dirname(absoluteFile);
+    const preferRelativeOutput = !path39.isAbsolute(file3);
     if (isConventionTestFilePath(relativeFile) || isConventionTestFilePath(file3)) {
       dedupePush(testFiles, toWorkspaceOutputPath(absoluteFile, workingDir, preferRelativeOutput));
       continue;
     }
     const nameWithoutExt = basename6.replace(/\.[^.]+$/, "");
-    const ext = path38.extname(basename6);
+    const ext = path39.extname(basename6);
     const genericTestNames = [
       `${nameWithoutExt}.spec${ext}`,
       `${nameWithoutExt}.test${ext}`
@@ -48615,7 +49134,7 @@ function getTestFilesFromConvention(sourceFiles, workingDir = process.cwd()) {
     const colocatedCandidates = [
       ...genericTestNames,
       ...languageSpecificTestNames
-    ].map((candidateName) => path38.join(dirname17, candidateName));
+    ].map((candidateName) => path39.join(dirname17, candidateName));
     const testDirectoryNames = [
       basename6,
       ...genericTestNames,
@@ -48624,8 +49143,8 @@ function getTestFilesFromConvention(sourceFiles, workingDir = process.cwd()) {
     const repoLevelDirectories = getRepoLevelCandidateDirectories(workingDir, relativeFile, ext);
     const possibleTestFiles = [
       ...colocatedCandidates,
-      ...TEST_DIRECTORY_NAMES.flatMap((dirName) => testDirectoryNames.map((candidateName) => path38.join(dirname17, dirName, candidateName))),
-      ...repoLevelDirectories.flatMap((candidateDir) => testDirectoryNames.map((candidateName) => path38.join(candidateDir, candidateName)))
+      ...TEST_DIRECTORY_NAMES.flatMap((dirName) => testDirectoryNames.map((candidateName) => path39.join(dirname17, dirName, candidateName))),
+      ...repoLevelDirectories.flatMap((candidateDir) => testDirectoryNames.map((candidateName) => path39.join(candidateDir, candidateName)))
     ];
     for (const testFile of possibleTestFiles) {
       if (fs22.existsSync(testFile)) {
@@ -48646,7 +49165,7 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
     try {
       const absoluteTestFile = resolveWorkspacePath(testFile, workingDir);
       const content = fs22.readFileSync(absoluteTestFile, "utf-8");
-      const testDir = path38.dirname(absoluteTestFile);
+      const testDir = path39.dirname(absoluteTestFile);
       const importRegex = /import\s+.*?\s+from\s+['"]([^'"]+)['"]/g;
       let match;
       match = importRegex.exec(content);
@@ -48654,8 +49173,8 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
         const importPath = match[1];
         let resolvedImport;
         if (importPath.startsWith(".")) {
-          resolvedImport = path38.resolve(testDir, importPath);
-          const existingExt = path38.extname(resolvedImport);
+          resolvedImport = path39.resolve(testDir, importPath);
+          const existingExt = path39.extname(resolvedImport);
           if (!existingExt) {
             for (const extToTry of [
               ".ts",
@@ -48675,12 +49194,12 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
         } else {
           continue;
         }
-        const importBasename = path38.basename(resolvedImport, path38.extname(resolvedImport));
-        const importDir = path38.dirname(resolvedImport);
+        const importBasename = path39.basename(resolvedImport, path39.extname(resolvedImport));
+        const importDir = path39.dirname(resolvedImport);
         for (const sourceFile of absoluteSourceFiles) {
-          const sourceDir = path38.dirname(sourceFile);
-          const sourceBasename = path38.basename(sourceFile, path38.extname(sourceFile));
-          const isRelatedDir = importDir === sourceDir || importDir === path38.join(sourceDir, "__tests__") || importDir === path38.join(sourceDir, "tests") || importDir === path38.join(sourceDir, "test") || importDir === path38.join(sourceDir, "spec");
+          const sourceDir = path39.dirname(sourceFile);
+          const sourceBasename = path39.basename(sourceFile, path39.extname(sourceFile));
+          const isRelatedDir = importDir === sourceDir || importDir === path39.join(sourceDir, "__tests__") || importDir === path39.join(sourceDir, "tests") || importDir === path39.join(sourceDir, "test") || importDir === path39.join(sourceDir, "spec");
           if (resolvedImport === sourceFile || importBasename === sourceBasename && isRelatedDir) {
             dedupePush(testFiles, testFile);
             break;
@@ -48693,8 +49212,8 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
       while (match !== null) {
         const importPath = match[1];
         if (importPath.startsWith(".")) {
-          let resolvedImport = path38.resolve(testDir, importPath);
-          const existingExt = path38.extname(resolvedImport);
+          let resolvedImport = path39.resolve(testDir, importPath);
+          const existingExt = path39.extname(resolvedImport);
           if (!existingExt) {
             for (const extToTry of [
               ".ts",
@@ -48711,12 +49230,12 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
               }
             }
           }
-          const importDir = path38.dirname(resolvedImport);
-          const importBasename = path38.basename(resolvedImport, path38.extname(resolvedImport));
+          const importDir = path39.dirname(resolvedImport);
+          const importBasename = path39.basename(resolvedImport, path39.extname(resolvedImport));
           for (const sourceFile of absoluteSourceFiles) {
-            const sourceDir = path38.dirname(sourceFile);
-            const sourceBasename = path38.basename(sourceFile, path38.extname(sourceFile));
-            const isRelatedDir = importDir === sourceDir || importDir === path38.join(sourceDir, "__tests__") || importDir === path38.join(sourceDir, "tests") || importDir === path38.join(sourceDir, "test") || importDir === path38.join(sourceDir, "spec");
+            const sourceDir = path39.dirname(sourceFile);
+            const sourceBasename = path39.basename(sourceFile, path39.extname(sourceFile));
+            const isRelatedDir = importDir === sourceDir || importDir === path39.join(sourceDir, "__tests__") || importDir === path39.join(sourceDir, "tests") || importDir === path39.join(sourceDir, "test") || importDir === path39.join(sourceDir, "spec");
             if (resolvedImport === sourceFile || importBasename === sourceBasename && isRelatedDir) {
               dedupePush(testFiles, testFile);
               break;
@@ -48826,8 +49345,8 @@ function buildTestCommand2(framework, scope, files, coverage, baseDir) {
       return ["mvn", "test"];
     case "gradle": {
       const isWindows = process.platform === "win32";
-      const hasGradlewBat = fs22.existsSync(path38.join(baseDir, "gradlew.bat"));
-      const hasGradlew = fs22.existsSync(path38.join(baseDir, "gradlew"));
+      const hasGradlewBat = fs22.existsSync(path39.join(baseDir, "gradlew.bat"));
+      const hasGradlew = fs22.existsSync(path39.join(baseDir, "gradlew"));
       if (hasGradlewBat && isWindows)
         return ["gradlew.bat", "test"];
       if (hasGradlew)
@@ -48844,7 +49363,7 @@ function buildTestCommand2(framework, scope, files, coverage, baseDir) {
         "cmake-build-release",
         "out"
       ];
-      const actualBuildDir = buildDirCandidates.find((d) => fs22.existsSync(path38.join(baseDir, d, "CMakeCache.txt"))) ?? "build";
+      const actualBuildDir = buildDirCandidates.find((d) => fs22.existsSync(path39.join(baseDir, d, "CMakeCache.txt"))) ?? "build";
       return ["ctest", "--test-dir", actualBuildDir];
     }
     case "swift-test":
@@ -49276,11 +49795,11 @@ async function runTests(framework, scope, files, coverage, timeout_ms, cwd) {
     };
   }
   const startTime = Date.now();
-  const vitestJsonOutputPath = framework === "vitest" ? path38.join(cwd, ".swarm", "cache", "test-runner-vitest.json") : undefined;
+  const vitestJsonOutputPath = framework === "vitest" ? path39.join(cwd, ".swarm", "cache", "test-runner-vitest.json") : undefined;
   try {
     if (vitestJsonOutputPath) {
       try {
-        fs22.mkdirSync(path38.dirname(vitestJsonOutputPath), { recursive: true });
+        fs22.mkdirSync(path39.dirname(vitestJsonOutputPath), { recursive: true });
         if (fs22.existsSync(vitestJsonOutputPath)) {
           fs22.unlinkSync(vitestJsonOutputPath);
         }
@@ -49396,10 +49915,10 @@ async function runTests(framework, scope, files, coverage, timeout_ms, cwd) {
 }
 function normalizeHistoryTestFile(testFile, workingDir) {
   const normalized = testFile.replace(/\\/g, "/");
-  if (!path38.isAbsolute(testFile))
+  if (!path39.isAbsolute(testFile))
     return normalized;
-  const relative9 = path38.relative(workingDir, testFile);
-  if (relative9.startsWith("..") || path38.isAbsolute(relative9)) {
+  const relative9 = path39.relative(workingDir, testFile);
+  if (relative9.startsWith("..") || path39.isAbsolute(relative9)) {
     return normalized;
   }
   return relative9.replace(/\\/g, "/");
@@ -49737,7 +50256,7 @@ var init_test_runner = __esm(() => {
         const sourceFiles = args.files.filter((file3) => {
           if (directTestFiles.includes(file3))
             return false;
-          const ext = path38.extname(file3).toLowerCase();
+          const ext = path39.extname(file3).toLowerCase();
           return SOURCE_EXTENSIONS.has(ext);
         });
         const invalidFiles = args.files.filter((file3) => !directTestFiles.includes(file3) && !sourceFiles.includes(file3));
@@ -49783,7 +50302,7 @@ var init_test_runner = __esm(() => {
           if (isConventionTestFilePath(f)) {
             return false;
           }
-          const ext = path38.extname(f).toLowerCase();
+          const ext = path39.extname(f).toLowerCase();
           return SOURCE_EXTENSIONS.has(ext);
         });
         if (sourceFiles.length === 0) {
@@ -49833,7 +50352,7 @@ var init_test_runner = __esm(() => {
           if (isConventionTestFilePath(f)) {
             return false;
           }
-          const ext = path38.extname(f).toLowerCase();
+          const ext = path39.extname(f).toLowerCase();
           return SOURCE_EXTENSIONS.has(ext);
         });
         if (sourceFiles.length === 0) {
@@ -49885,8 +50404,8 @@ var init_test_runner = __esm(() => {
           }
           if (impactResult.impactedTests.length > 0) {
             testFiles = impactResult.impactedTests.map((absPath) => {
-              const relativePath = path38.relative(workingDir, absPath);
-              return path38.isAbsolute(relativePath) ? absPath : relativePath;
+              const relativePath = path39.relative(workingDir, absPath);
+              return path39.isAbsolute(relativePath) ? absPath : relativePath;
             });
           } else {
             graphFallbackReason = "no impacted tests found via impact analysis, falling back to graph";
@@ -49962,7 +50481,7 @@ var init_test_runner = __esm(() => {
 
 // src/services/preflight-service.ts
 import * as fs23 from "fs";
-import * as path39 from "path";
+import * as path40 from "path";
 function validateDirectoryPath(dir) {
   if (!dir || typeof dir !== "string") {
     throw new Error("Directory path is required");
@@ -49970,8 +50489,8 @@ function validateDirectoryPath(dir) {
   if (dir.includes("..")) {
     throw new Error("Directory path must not contain path traversal sequences");
   }
-  const normalized = path39.normalize(dir);
-  const absolutePath = path39.isAbsolute(normalized) ? normalized : path39.resolve(normalized);
+  const normalized = path40.normalize(dir);
+  const absolutePath = path40.isAbsolute(normalized) ? normalized : path40.resolve(normalized);
   return absolutePath;
 }
 function validateTimeout(timeoutMs, defaultValue) {
@@ -49994,7 +50513,7 @@ function validateTimeout(timeoutMs, defaultValue) {
 }
 function getPackageVersion(dir) {
   try {
-    const packagePath = path39.join(dir, "package.json");
+    const packagePath = path40.join(dir, "package.json");
     if (fs23.existsSync(packagePath)) {
       const content = fs23.readFileSync(packagePath, "utf-8");
       const pkg = JSON.parse(content);
@@ -50005,7 +50524,7 @@ function getPackageVersion(dir) {
 }
 function getChangelogVersion(dir) {
   try {
-    const changelogPath = path39.join(dir, "CHANGELOG.md");
+    const changelogPath = path40.join(dir, "CHANGELOG.md");
     if (fs23.existsSync(changelogPath)) {
       const content = fs23.readFileSync(changelogPath, "utf-8");
       const match = content.match(/^##\s*\[?(\d+\.\d+\.\d+)\]?/m);
@@ -50019,7 +50538,7 @@ function getChangelogVersion(dir) {
 function getVersionFileVersion(dir) {
   const possibleFiles = ["VERSION.txt", "version.txt", "VERSION", "version"];
   for (const file3 of possibleFiles) {
-    const filePath = path39.join(dir, file3);
+    const filePath = path40.join(dir, file3);
     if (fs23.existsSync(filePath)) {
       try {
         const content = fs23.readFileSync(filePath, "utf-8").trim();
@@ -50035,9 +50554,9 @@ function getVersionFileVersion(dir) {
 async function runVersionCheck(dir, _timeoutMs) {
   const startTime = Date.now();
   try {
-    const packageVersion = _internals26.getPackageVersion(dir);
-    const changelogVersion = _internals26.getChangelogVersion(dir);
-    const versionFileVersion = _internals26.getVersionFileVersion(dir);
+    const packageVersion = _internals27.getPackageVersion(dir);
+    const changelogVersion = _internals27.getChangelogVersion(dir);
+    const versionFileVersion = _internals27.getVersionFileVersion(dir);
     const versions3 = [];
     if (packageVersion)
       versions3.push(`package.json: ${packageVersion}`);
@@ -50309,7 +50828,22 @@ async function runEvidenceCheck(dir) {
       };
     }
     const evidenceTaskIds = new Set(await listEvidenceTaskIds(dir));
-    const missingEvidence = completedTaskIds.filter((id) => !evidenceTaskIds.has(id));
+    const missingEvidence = [];
+    for (const id of completedTaskIds) {
+      const gateStatus = await getDurableGateEvidenceStatusForTask(dir, id);
+      if (gateStatus.isComplete) {
+        continue;
+      }
+      if (gateStatus.evidenceExists && gateStatus.missingGates.length > 0) {
+        missingEvidence.push(id);
+        continue;
+      }
+      if (evidenceTaskIds.has(id)) {
+        continue;
+      }
+      missingEvidence.push(id);
+    }
+    const completedWithEvidence = completedTaskIds.length - missingEvidence.length;
     if (missingEvidence.length > 0) {
       return {
         type: "evidence",
@@ -50317,7 +50851,7 @@ async function runEvidenceCheck(dir) {
         message: `${missingEvidence.length} completed task(s) missing evidence`,
         details: {
           totalCompleted: completedTaskIds.length,
-          totalWithEvidence: evidenceTaskIds.size,
+          totalWithEvidence: completedWithEvidence,
           missingTasks: missingEvidence.slice(0, 10),
           missingCount: missingEvidence.length
         },
@@ -50330,7 +50864,7 @@ async function runEvidenceCheck(dir) {
       message: `All ${completedTaskIds.length} completed tasks have evidence`,
       details: {
         totalCompleted: completedTaskIds.length,
-        totalWithEvidence: evidenceTaskIds.size
+        totalWithEvidence: completedWithEvidence
       },
       durationMs: Date.now() - startTime
     };
@@ -50346,7 +50880,7 @@ async function runEvidenceCheck(dir) {
 async function runRequirementCoverageCheck(dir, currentPhase) {
   const startTime = Date.now();
   try {
-    const specPath = path39.join(dir, ".swarm", "spec.md");
+    const specPath = path40.join(dir, ".swarm", "spec.md");
     if (!fs23.existsSync(specPath)) {
       return {
         type: "req_coverage",
@@ -50387,7 +50921,7 @@ async function runPreflight(dir, phase, config3) {
   const reportId = `preflight-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
   let validatedDir;
   try {
-    validatedDir = _internals26.validateDirectoryPath(dir);
+    validatedDir = _internals27.validateDirectoryPath(dir);
   } catch (error93) {
     return {
       id: reportId,
@@ -50407,7 +50941,7 @@ async function runPreflight(dir, phase, config3) {
   }
   let validatedTimeout;
   try {
-    validatedTimeout = _internals26.validateTimeout(config3?.checkTimeoutMs, DEFAULT_CONFIG.checkTimeoutMs);
+    validatedTimeout = _internals27.validateTimeout(config3?.checkTimeoutMs, DEFAULT_CONFIG.checkTimeoutMs);
   } catch (error93) {
     return {
       id: reportId,
@@ -50448,12 +50982,12 @@ async function runPreflight(dir, phase, config3) {
   });
   const checks5 = [];
   log("[Preflight] Running lint check...");
-  const lintResult = await _internals26.runLintCheck(validatedDir, cfg.linter, cfg.checkTimeoutMs);
+  const lintResult = await _internals27.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 _internals26.runTestsCheck(validatedDir, cfg.testScope, cfg.checkTimeoutMs);
+    const testsResult = await _internals27.runTestsCheck(validatedDir, cfg.testScope, cfg.checkTimeoutMs);
     checks5.push(testsResult);
     log(`[Preflight] Tests check: ${testsResult.status} ${testsResult.message}`);
   } else {
@@ -50465,7 +50999,7 @@ async function runPreflight(dir, phase, config3) {
   }
   if (!cfg.skipSecrets) {
     log("[Preflight] Running secrets check...");
-    const secretsResult = await _internals26.runSecretsCheck(validatedDir, cfg.checkTimeoutMs);
+    const secretsResult = await _internals27.runSecretsCheck(validatedDir, cfg.checkTimeoutMs);
     checks5.push(secretsResult);
     log(`[Preflight] Secrets check: ${secretsResult.status} ${secretsResult.message}`);
   } else {
@@ -50477,7 +51011,7 @@ async function runPreflight(dir, phase, config3) {
   }
   if (!cfg.skipEvidence) {
     log("[Preflight] Running evidence check...");
-    const evidenceResult = await _internals26.runEvidenceCheck(validatedDir);
+    const evidenceResult = await _internals27.runEvidenceCheck(validatedDir);
     checks5.push(evidenceResult);
     log(`[Preflight] Evidence check: ${evidenceResult.status} ${evidenceResult.message}`);
   } else {
@@ -50488,12 +51022,12 @@ async function runPreflight(dir, phase, config3) {
     });
   }
   log("[Preflight] Running requirement coverage check...");
-  const reqCoverageResult = await _internals26.runRequirementCoverageCheck(validatedDir, phase);
+  const reqCoverageResult = await _internals27.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 _internals26.runVersionCheck(validatedDir, cfg.checkTimeoutMs);
+    const versionResult = await _internals27.runVersionCheck(validatedDir, cfg.checkTimeoutMs);
     checks5.push(versionResult);
     log(`[Preflight] Version check: ${versionResult.status} ${versionResult.message}`);
   } else {
@@ -50556,11 +51090,12 @@ function formatPreflightMarkdown(report) {
 async function handlePreflightCommand(directory, _args) {
   const plan = await loadPlan(directory);
   const phase = plan?.current_phase ?? 1;
-  const report = await _internals26.runPreflight(directory, phase);
-  return _internals26.formatPreflightMarkdown(report);
+  const report = await _internals27.runPreflight(directory, phase);
+  return _internals27.formatPreflightMarkdown(report);
 }
-var MIN_CHECK_TIMEOUT_MS = 5000, MAX_CHECK_TIMEOUT_MS = 300000, DEFAULT_CONFIG, _internals26;
+var MIN_CHECK_TIMEOUT_MS = 5000, MAX_CHECK_TIMEOUT_MS = 300000, DEFAULT_CONFIG, _internals27;
 var init_preflight_service = __esm(() => {
+  init_gate_bridge();
   init_manager2();
   init_manager();
   init_lint();
@@ -50576,7 +51111,7 @@ var init_preflight_service = __esm(() => {
     testScope: "convention",
     linter: "biome"
   };
-  _internals26 = {
+  _internals27 = {
     runPreflight,
     formatPreflightMarkdown,
     handlePreflightCommand,
@@ -51463,7 +51998,7 @@ var init_manager3 = __esm(() => {
 
 // src/commands/reset.ts
 import * as fs24 from "fs";
-import * as path40 from "path";
+import * as path41 from "path";
 async function handleResetCommand(directory, args) {
   const hasConfirm = args.includes("--confirm");
   if (!hasConfirm) {
@@ -51503,7 +52038,7 @@ async function handleResetCommand(directory, args) {
   }
   for (const filename of ["SWARM_PLAN.md", "SWARM_PLAN.json"]) {
     try {
-      const rootPath = path40.join(directory, filename);
+      const rootPath = path41.join(directory, filename);
       if (fs24.existsSync(rootPath)) {
         fs24.unlinkSync(rootPath);
         results.push(`- \u2705 Deleted ${filename} (root)`);
@@ -51543,7 +52078,7 @@ var init_reset = __esm(() => {
 
 // src/commands/reset-session.ts
 import * as fs25 from "fs";
-import * as path41 from "path";
+import * as path42 from "path";
 async function handleResetSessionCommand(directory, _args) {
   const results = [];
   try {
@@ -51558,13 +52093,13 @@ async function handleResetSessionCommand(directory, _args) {
     results.push("\u274C Failed to delete state.json");
   }
   try {
-    const sessionDir = path41.dirname(validateSwarmPath(directory, "session/state.json"));
+    const sessionDir = path42.dirname(validateSwarmPath(directory, "session/state.json"));
     if (fs25.existsSync(sessionDir)) {
       const files = fs25.readdirSync(sessionDir);
       const otherFiles = files.filter((f) => f !== "state.json");
       let deletedCount = 0;
       for (const file3 of otherFiles) {
-        const filePath = path41.join(sessionDir, file3);
+        const filePath = path42.join(sessionDir, file3);
         if (fs25.lstatSync(filePath).isFile()) {
           fs25.unlinkSync(filePath);
           deletedCount++;
@@ -51596,7 +52131,7 @@ var init_reset_session = __esm(() => {
 });
 
 // src/summaries/manager.ts
-import * as path42 from "path";
+import * as path43 from "path";
 function sanitizeSummaryId(id) {
   if (!id || id.length === 0) {
     throw new Error("Invalid summary ID: empty string");
@@ -51619,7 +52154,7 @@ function sanitizeSummaryId(id) {
 }
 async function loadFullOutput(directory, id) {
   const sanitizedId = sanitizeSummaryId(id);
-  const relativePath = path42.join("summaries", `${sanitizedId}.json`);
+  const relativePath = path43.join("summaries", `${sanitizedId}.json`);
   validateSwarmPath(directory, relativePath);
   const content = await readSwarmFileAsync(directory, relativePath);
   if (content === null) {
@@ -51682,7 +52217,7 @@ var init_retrieve = __esm(() => {
 
 // src/commands/rollback.ts
 import * as fs26 from "fs";
-import * as path43 from "path";
+import * as path44 from "path";
 async function handleRollbackCommand(directory, args) {
   const phaseArg = args[0];
   if (!phaseArg) {
@@ -51747,8 +52282,8 @@ async function handleRollbackCommand(directory, args) {
     if (EXCLUDE_FILES.has(file3) || file3.startsWith("plan-ledger.archived-")) {
       continue;
     }
-    const src = path43.join(checkpointDir, file3);
-    const dest = path43.join(swarmDir, file3);
+    const src = path44.join(checkpointDir, file3);
+    const dest = path44.join(swarmDir, file3);
     try {
       fs26.cpSync(src, dest, { recursive: true, force: true });
       successes.push(file3);
@@ -51767,12 +52302,12 @@ async function handleRollbackCommand(directory, args) {
     ].join(`
 `);
   }
-  const existingLedgerPath = path43.join(swarmDir, "plan-ledger.jsonl");
+  const existingLedgerPath = path44.join(swarmDir, "plan-ledger.jsonl");
   if (fs26.existsSync(existingLedgerPath)) {
     fs26.unlinkSync(existingLedgerPath);
   }
   try {
-    const planJsonPath = path43.join(swarmDir, "plan.json");
+    const planJsonPath = path44.join(swarmDir, "plan.json");
     if (fs26.existsSync(planJsonPath)) {
       const planRaw = fs26.readFileSync(planJsonPath, "utf-8");
       const plan = PlanSchema.parse(JSON.parse(planRaw));
@@ -51833,7 +52368,7 @@ async function handleSimulateCommand(directory, args) {
   }
   let darkMatterPairs;
   try {
-    darkMatterPairs = await _internals10.detectDarkMatter(directory, options);
+    darkMatterPairs = await _internals11.detectDarkMatter(directory, options);
   } catch (err) {
     const errMsg = err instanceof Error ? err.message : String(err);
     return `## Simulate Report
@@ -51863,9 +52398,9 @@ Ensure this is a git repository with commit history.`;
 `);
   try {
     const fs27 = await import("fs/promises");
-    const path44 = await import("path");
-    const reportPath = path44.join(directory, ".swarm", "simulate-report.md");
-    await fs27.mkdir(path44.dirname(reportPath), { recursive: true });
+    const path45 = await import("path");
+    const reportPath = path45.join(directory, ".swarm", "simulate-report.md");
+    await fs27.mkdir(path45.dirname(reportPath), { recursive: true });
     await fs27.writeFile(reportPath, report, "utf-8");
   } catch (err) {
     const writeErr = err instanceof Error ? err.message : String(err);
@@ -51889,12 +52424,12 @@ async function handleSpecifyCommand(_directory, args) {
 
 // src/turbo/lean/state.ts
 import * as fs27 from "fs";
-import * as path44 from "path";
+import * as path45 from "path";
 function nowISO2() {
   return new Date().toISOString();
 }
 function ensureSwarmDir2(directory) {
-  const swarmDir = path44.resolve(directory, ".swarm");
+  const swarmDir = path45.resolve(directory, ".swarm");
   if (!fs27.existsSync(swarmDir)) {
     fs27.mkdirSync(swarmDir, { recursive: true });
   }
@@ -51938,7 +52473,7 @@ function markStateUnreadable2(directory, reason) {
 }
 function readPersisted2(directory) {
   try {
-    const filePath = path44.join(directory, ".swarm", STATE_FILE2);
+    const filePath = path45.join(directory, ".swarm", STATE_FILE2);
     if (!fs27.existsSync(filePath)) {
       const seed = emptyPersisted2();
       try {
@@ -51974,7 +52509,7 @@ function writePersisted2(directory, persisted) {
   let payload;
   try {
     ensureSwarmDir2(directory);
-    filePath = path44.join(directory, ".swarm", STATE_FILE2);
+    filePath = path45.join(directory, ".swarm", STATE_FILE2);
     tmpPath = `${filePath}.tmp.${Date.now()}`;
     persisted.updatedAt = nowISO2();
     payload = `${JSON.stringify(persisted, null, 2)}
@@ -52101,10 +52636,10 @@ var init_context_budget_service = __esm(() => {
 
 // src/services/status-service.ts
 import * as fsSync2 from "fs";
-import * as path45 from "path";
+import * as path46 from "path";
 function readSpecStalenessSnapshot(directory) {
   try {
-    const p = path45.join(directory, ".swarm", "spec-staleness.json");
+    const p = path46.join(directory, ".swarm", "spec-staleness.json");
     if (!fsSync2.existsSync(p))
       return { stale: false };
     const raw = fsSync2.readFileSync(p, "utf-8");
@@ -52198,7 +52733,7 @@ async function getStatusData(directory, agents) {
 }
 function enrichWithLeanTurbo(status, directory) {
   const turboMode = hasActiveTurboMode();
-  const leanActive = _internals27.hasActiveLeanTurbo();
+  const leanActive = _internals28.hasActiveLeanTurbo();
   let turboStrategy = "off";
   if (leanActive) {
     turboStrategy = "lean";
@@ -52217,7 +52752,7 @@ function enrichWithLeanTurbo(status, directory) {
     }
   }
   if (leanSessionID) {
-    const runState = _internals27.loadLeanTurboRunState(directory, leanSessionID);
+    const runState = _internals28.loadLeanTurboRunState(directory, leanSessionID);
     if (runState) {
       status.leanTurboPhase = runState.phase;
       status.leanMaxParallelCoders = runState.maxParallelCoders;
@@ -52249,7 +52784,7 @@ function enrichWithLeanTurbo(status, directory) {
       }
     }
   }
-  status.fullAutoActive = _internals27.hasActiveFullAuto();
+  status.fullAutoActive = _internals28.hasActiveFullAuto();
   return status;
 }
 function formatStatusMarkdown(status) {
@@ -52331,7 +52866,7 @@ async function handleStatusCommand(directory, agents) {
   }
   return formatStatusMarkdown(statusData);
 }
-var _internals27;
+var _internals28;
 var init_status_service = __esm(() => {
   init_extractors();
   init_utils2();
@@ -52340,7 +52875,7 @@ var init_status_service = __esm(() => {
   init_state3();
   init_compaction_service();
   init_context_budget_service();
-  _internals27 = {
+  _internals28 = {
     loadLeanTurboRunState,
     hasActiveLeanTurbo,
     hasActiveFullAuto
@@ -52431,7 +52966,7 @@ async function handleTurboCommand(directory, args, sessionID) {
   if (arg0 === "on") {
     let strategy = "standard";
     try {
-      const { config: config3 } = _internals28.loadPluginConfigWithMeta(directory);
+      const { config: config3 } = _internals29.loadPluginConfigWithMeta(directory);
       if (config3.turbo?.strategy === "lean") {
         strategy = "lean";
       }
@@ -52486,7 +53021,7 @@ function enableLeanTurbo(session, directory, sessionID) {
   let maxParallelCoders = 4;
   let conflictPolicy = "serialize";
   try {
-    const { config: config3 } = _internals28.loadPluginConfigWithMeta(directory);
+    const { config: config3 } = _internals29.loadPluginConfigWithMeta(directory);
     const leanConfig = config3.turbo?.lean;
     if (leanConfig) {
       maxParallelCoders = leanConfig.max_parallel_coders ?? 4;
@@ -52556,13 +53091,13 @@ function buildStatusMessage(session, directory, sessionID) {
   ].join(`
 `);
 }
-var _internals28;
+var _internals29;
 var init_turbo = __esm(() => {
   init_config();
   init_state();
   init_state3();
   init_logger();
-  _internals28 = {
+  _internals29 = {
     loadPluginConfigWithMeta
   };
 });
@@ -52630,7 +53165,7 @@ var init_write_retro2 = __esm(() => {
 
 // src/commands/command-dispatch.ts
 import fs28 from "fs";
-import path46 from "path";
+import path47 from "path";
 function normalizeSwarmCommandInput(command, argumentText) {
   if (command !== "swarm" && !command.startsWith("swarm-")) {
     return { isSwarmCommand: false, tokens: [] };
@@ -52655,7 +53190,7 @@ function formatCommandNotFound(tokens) {
   const attemptedCommand = tokens[0] || "";
   const MAX_DISPLAY = 100;
   const displayCommand = attemptedCommand.length > MAX_DISPLAY ? `${attemptedCommand.slice(0, MAX_DISPLAY)}...` : attemptedCommand;
-  const similar = _internals29.findSimilarCommands(attemptedCommand);
+  const similar = _internals30.findSimilarCommands(attemptedCommand);
   const header = `Command \`/swarm ${displayCommand}\` not found.`;
   const suggestions = similar.length > 0 ? `Did you mean:
 ${similar.map((cmd) => `  - /swarm ${cmd}`).join(`
@@ -52666,9 +53201,9 @@ ${similar.map((cmd) => `  - /swarm ${cmd}`).join(`
 `);
 }
 function maybeMarkFirstRun(directory) {
-  const sentinelPath = path46.join(directory, ".swarm", ".first-run-complete");
+  const sentinelPath = path47.join(directory, ".swarm", ".first-run-complete");
   try {
-    const swarmDir = path46.join(directory, ".swarm");
+    const swarmDir = path47.join(directory, ".swarm");
     fs28.mkdirSync(swarmDir, { recursive: true });
     fs28.writeFileSync(sentinelPath, `first-run-complete: ${new Date().toISOString()}
 `, { flag: "wx" });
@@ -53104,7 +53639,7 @@ async function buildSwarmCommandPrompt(args) {
     activeAgentName,
     registeredAgents
   } = args;
-  const resolved = _internals29.resolveCommand(tokens);
+  const resolved = _internals30.resolveCommand(tokens);
   if (!resolved) {
     if (tokens.length === 0) {
       return buildHelpText();
@@ -53255,7 +53790,7 @@ function findSimilarCommands(query) {
   }
   const scored = VALID_COMMANDS.map((cmd) => {
     const cmdLower = cmd.toLowerCase();
-    const fullScore = _internals29.levenshteinDistance(q, cmdLower);
+    const fullScore = _internals30.levenshteinDistance(q, cmdLower);
     let tokenScore = Infinity;
     if (cmd.includes(" ") || cmd.includes("-")) {
       const qTokens = q.split(/[\s-]+/);
@@ -53268,7 +53803,7 @@ function findSimilarCommands(query) {
         for (const ct of cmdTokens) {
           if (ct.length === 0)
             continue;
-          const dist = _internals29.levenshteinDistance(qt, ct);
+          const dist = _internals30.levenshteinDistance(qt, ct);
           if (dist < minDist)
             minDist = dist;
         }
@@ -53278,7 +53813,7 @@ function findSimilarCommands(query) {
     }
     const dashStrippedQ = q.replace(/-/g, "");
     const dashStrippedCmd = cmdLower.replace(/-/g, "");
-    const dashScore = _internals29.levenshteinDistance(dashStrippedQ, dashStrippedCmd);
+    const dashScore = _internals30.levenshteinDistance(dashStrippedQ, dashStrippedCmd);
     const score = Math.min(fullScore, tokenScore, dashScore);
     return { cmd, score };
   });
@@ -53310,11 +53845,11 @@ async function handleHelpCommand(ctx) {
     return buildHelpText2();
   }
   const tokens = targetCommand.split(/\s+/);
-  const resolved = _internals29.resolveCommand(tokens);
+  const resolved = _internals30.resolveCommand(tokens);
   if (resolved) {
-    return _internals29.buildDetailedHelp(resolved.key, resolved.entry);
+    return _internals30.buildDetailedHelp(resolved.key, resolved.entry);
   }
-  const similar = _internals29.findSimilarCommands(targetCommand);
+  const similar = _internals30.findSimilarCommands(targetCommand);
   const { buildHelpText: fullHelp } = await Promise.resolve().then(() => (init_commands(), exports_commands));
   if (similar.length > 0) {
     return `Command '/swarm ${targetCommand}' not found.
@@ -53350,24 +53885,24 @@ function validateAliases() {
       }
       aliasTargets.get(target).push(name);
       const visited = new Set;
-      const path47 = [];
+      const path48 = [];
       let current = target;
       while (current) {
         const currentEntry = COMMAND_REGISTRY[current];
         if (!currentEntry)
           break;
         if (visited.has(current)) {
-          const cycleStart = path47.indexOf(current);
+          const cycleStart = path48.indexOf(current);
           const fullChain = [
             name,
-            ...path47.slice(0, cycleStart > 0 ? cycleStart : path47.length),
+            ...path48.slice(0, cycleStart > 0 ? cycleStart : path48.length),
             current
           ].join(" \u2192 ");
           errors5.push(`Circular alias detected: ${fullChain}`);
           break;
         }
         visited.add(current);
-        path47.push(current);
+        path48.push(current);
         current = currentEntry.aliasOf || "";
       }
     }
@@ -53408,7 +53943,7 @@ function resolveCommand(tokens) {
   }
   return null;
 }
-var COMMAND_REGISTRY, VALID_COMMANDS, _internals29, validation;
+var COMMAND_REGISTRY, VALID_COMMANDS, _internals30, validation;
 var init_registry = __esm(() => {
   init_acknowledge_spec_drift();
   init_agents();
@@ -53478,7 +54013,7 @@ var init_registry = __esm(() => {
       clashesWithNativeCcCommand: "/agents"
     },
     help: {
-      handler: (ctx) => _internals29.handleHelpCommand(ctx),
+      handler: (ctx) => _internals30.handleHelpCommand(ctx),
       description: "Show help for swarm commands",
       category: "core",
       args: "[command]",
@@ -53850,7 +54385,7 @@ Subcommands:
     }
   };
   VALID_COMMANDS = Object.keys(COMMAND_REGISTRY);
-  _internals29 = {
+  _internals30 = {
     handleHelpCommand,
     validateAliases,
     resolveCommand,
@@ -53858,7 +54393,7 @@ Subcommands:
     findSimilarCommands,
     buildDetailedHelp
   };
-  validation = _internals29.validateAliases();
+  validation = _internals30.validateAliases();
   if (!validation.valid) {
     throw new Error(`COMMAND_REGISTRY alias validation failed:
 ${validation.errors.join(`
@@ -53878,53 +54413,53 @@ init_cache_paths();
 init_constants();
 import * as fs29 from "fs";
 import * as os7 from "os";
-import * as path47 from "path";
+import * as path48 from "path";
 var { version: version4 } = package_default;
 var CONFIG_DIR = getPluginConfigDir();
-var OPENCODE_CONFIG_PATH = path47.join(CONFIG_DIR, "opencode.json");
-var PLUGIN_CONFIG_PATH = path47.join(CONFIG_DIR, "opencode-swarm.json");
-var PROMPTS_DIR = path47.join(CONFIG_DIR, "opencode-swarm");
+var OPENCODE_CONFIG_PATH = path48.join(CONFIG_DIR, "opencode.json");
+var PLUGIN_CONFIG_PATH = path48.join(CONFIG_DIR, "opencode-swarm.json");
+var PROMPTS_DIR = path48.join(CONFIG_DIR, "opencode-swarm");
 var OPENCODE_PLUGIN_CACHE_PATHS = getPluginCachePaths();
 var OPENCODE_PLUGIN_LOCK_FILE_PATHS = getPluginLockFilePaths();
 function isSafeCachePath(p) {
-  const resolved = path47.resolve(p);
-  const home = path47.resolve(os7.homedir());
+  const resolved = path48.resolve(p);
+  const home = path48.resolve(os7.homedir());
   if (resolved === "/" || resolved === home || resolved.length <= home.length) {
     return false;
   }
-  const segments = resolved.split(path47.sep).filter((s) => s.length > 0);
+  const segments = resolved.split(path48.sep).filter((s) => s.length > 0);
   if (segments.length < 4) {
     return false;
   }
-  const leaf = path47.basename(resolved);
+  const leaf = path48.basename(resolved);
   if (leaf !== "opencode-swarm@latest" && leaf !== "opencode-swarm") {
     return false;
   }
-  const parent = path47.basename(path47.dirname(resolved));
+  const parent = path48.basename(path48.dirname(resolved));
   if (parent !== "packages" && parent !== "node_modules") {
     return false;
   }
-  const grandparent = path47.basename(path47.dirname(path47.dirname(resolved)));
+  const grandparent = path48.basename(path48.dirname(path48.dirname(resolved)));
   if (grandparent !== "opencode") {
     return false;
   }
   return true;
 }
 function isSafeLockFilePath(p) {
-  const resolved = path47.resolve(p);
-  const home = path47.resolve(os7.homedir());
+  const resolved = path48.resolve(p);
+  const home = path48.resolve(os7.homedir());
   if (resolved === "/" || resolved === home || resolved.length <= home.length) {
     return false;
   }
-  const segments = resolved.split(path47.sep).filter((s) => s.length > 0);
+  const segments = resolved.split(path48.sep).filter((s) => s.length > 0);
   if (segments.length < 4) {
     return false;
   }
-  const leaf = path47.basename(resolved);
+  const leaf = path48.basename(resolved);
   if (leaf !== "bun.lock" && leaf !== "bun.lockb" && leaf !== "package-lock.json") {
     return false;
   }
-  const parent = path47.basename(path47.dirname(resolved));
+  const parent = path48.basename(path48.dirname(resolved));
   if (parent !== "opencode") {
     return false;
   }
@@ -53950,8 +54485,8 @@ function saveJson(filepath, data) {
 }
 function writeProjectConfigIfMissing(cwd) {
   try {
-    const opencodeDir = path47.join(cwd, ".opencode");
-    const projectConfigPath = path47.join(opencodeDir, "opencode-swarm.json");
+    const opencodeDir = path48.join(cwd, ".opencode");
+    const projectConfigPath = path48.join(opencodeDir, "opencode-swarm.json");
     if (fs29.existsSync(projectConfigPath)) {
       return;
     }
@@ -53968,7 +54503,7 @@ async function install() {
 `);
   ensureDir(CONFIG_DIR);
   ensureDir(PROMPTS_DIR);
-  const LEGACY_CONFIG_PATH = path47.join(CONFIG_DIR, "config.json");
+  const LEGACY_CONFIG_PATH = path48.join(CONFIG_DIR, "config.json");
   let opencodeConfig = loadJson(OPENCODE_CONFIG_PATH);
   if (!opencodeConfig) {
     const legacyConfig = loadJson(LEGACY_CONFIG_PATH);