opencode-swarm 7.92.0 → 7.93.1

package/dist/cli/{index-dy1qpyh3.js → index-mv27v975.js}

@@ -906,7 +906,7 @@ var init_executor = __esm(() => {
 // package.json
 var package_default = {
   name: "opencode-swarm",
-  version: "7.92.0",
+  version: "7.93.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",
@@ -5785,8 +5785,8 @@ async function handleClarifyCommand(_directory, args) {
 // src/commands/close.ts
 import { spawnSync as spawnSync5 } from "child_process";
 import * as fsSync2 from "fs";
-import { promises as fs11 } from "fs";
-import path24 from "path";
+import { promises as fs12 } from "fs";
+import path25 from "path";
 
 // src/hooks/abort-utils.ts
 function isAbortError(err) {
@@ -9903,10 +9903,9 @@ var _internals17 = {
   MAX_TRACKED_RETRO_SECTIONS
 };
 
-// src/services/skill-improver.ts
-import { existsSync as existsSync12 } from "fs";
-import { mkdir as mkdir7, readFile as readFile7, rename as rename3, writeFile as writeFile7 } from "fs/promises";
-import * as path23 from "path";
+// src/services/session-reflection.ts
+import { promises as fs11 } from "fs";
+import * as path22 from "path";
 
 // src/hooks/skill-improver-llm-factory.ts
 function resolveSkillImproverAgentName(sessionId) {
@@ -10014,12 +10013,296 @@ ${userInput}` : userInput;
   };
 }
 
+// src/services/session-reflection.ts
+function gatherToolProblems(toolAggregates) {
+  let totalCalls = 0;
+  let totalFailures = 0;
+  const problems = [];
+  for (const [, agg] of toolAggregates) {
+    totalCalls += agg.count;
+    totalFailures += agg.failureCount;
+    if (agg.failureCount > 0 && agg.count > 0) {
+      const failureRate = agg.failureCount / agg.count;
+      if (failureRate > 0.2 || agg.failureCount > 2) {
+        problems.push({
+          tool: agg.tool,
+          failureCount: agg.failureCount,
+          totalCalls: agg.count,
+          failureRate: Math.round(failureRate * 100) / 100,
+          avgDurationMs: Math.round(agg.totalDuration / agg.count)
+        });
+      }
+    }
+  }
+  problems.sort((a, b) => b.failureCount - a.failureCount);
+  return { problems, totalCalls, totalFailures };
+}
+function gatherAgentDispatches(agentSessions) {
+  const agentCounts = new Map;
+  for (const [, session] of agentSessions) {
+    const name = session.agentName;
+    const existing = agentCounts.get(name) ?? { count: 0 };
+    existing.count++;
+    if (session.lastDelegationReason) {
+      existing.lastReason = session.lastDelegationReason;
+    }
+    agentCounts.set(name, existing);
+  }
+  return [...agentCounts.entries()].map(([agent, data]) => ({
+    agent,
+    delegationCount: data.count,
+    lastDelegationReason: data.lastReason
+  })).sort((a, b) => b.delegationCount - a.delegationCount);
+}
+async function gatherRetroLessonsAndTaxonomy(directory) {
+  const lessons = [];
+  const taxonomy = {};
+  try {
+    const evidenceDir = path22.join(directory, ".swarm", "evidence");
+    const entries = await fs11.readdir(evidenceDir);
+    const retroDirs = entries.filter((e) => e.startsWith("retro-")).sort((a, b) => a.localeCompare(b, undefined, { numeric: true }));
+    for (const retroDir of retroDirs) {
+      const evidencePath = path22.join(evidenceDir, retroDir, "evidence.json");
+      try {
+        const content = await fs11.readFile(evidencePath, "utf-8");
+        const parsed = JSON.parse(content);
+        const bundleEntries = parsed.entries ?? [parsed];
+        for (const entry of bundleEntries) {
+          if (Array.isArray(entry.lessons_learned)) {
+            for (const lesson of entry.lessons_learned) {
+              if (typeof lesson === "string" && lesson.trim().length > 0) {
+                lessons.push(lesson.trim());
+              }
+            }
+          }
+          if (entry.error_taxonomy && typeof entry.error_taxonomy === "object") {
+            for (const [key, val] of Object.entries(entry.error_taxonomy)) {
+              if (typeof val === "number") {
+                taxonomy[key] = (taxonomy[key] ?? 0) + val;
+              }
+            }
+          }
+        }
+      } catch {}
+    }
+  } catch {}
+  return { lessons: [...new Set(lessons)], taxonomy };
+}
+async function gatherGateFailures(directory) {
+  const failures = new Map;
+  try {
+    const evidenceDir = path22.join(directory, ".swarm", "evidence");
+    const entries = await fs11.readdir(evidenceDir);
+    for (const entry of entries) {
+      if (entry.startsWith("retro-"))
+        continue;
+      const evidencePath = path22.join(evidenceDir, entry, "evidence.json");
+      try {
+        const content = await fs11.readFile(evidencePath, "utf-8");
+        const parsed = JSON.parse(content);
+        const bundleEntries = parsed.entries ?? [parsed];
+        for (const e of bundleEntries) {
+          if (e.verdict === "fail" || e.verdict === "REJECT") {
+            const gate = e.agent ?? e.type ?? "unknown";
+            const taskId = entry;
+            const key = `${gate}:${taskId}`;
+            const existing = failures.get(key) ?? {
+              gate,
+              taskId,
+              count: 0
+            };
+            existing.count++;
+            failures.set(key, existing);
+          }
+        }
+      } catch {}
+    }
+  } catch {}
+  return [...failures.values()].sort((a, b) => b.count - a.count);
+}
+function buildReflectionDataSummary(data) {
+  const lines = [];
+  lines.push("SESSION DATA SNAPSHOT");
+  lines.push(`Total tool calls: ${data.totalToolCalls}`);
+  lines.push(`Total tool failures: ${data.totalToolFailures}`);
+  if (data.totalToolCalls > 0) {
+    lines.push(`Overall failure rate: ${Math.round(data.totalToolFailures / data.totalToolCalls * 100)}%`);
+  }
+  lines.push("");
+  if (data.toolProblems.length > 0) {
+    lines.push("TOOL PROBLEMS (tools with >20% failure rate or >2 failures):");
+    for (const p of data.toolProblems) {
+      lines.push(`  - ${p.tool}: ${p.failureCount}/${p.totalCalls} failures (${Math.round(p.failureRate * 100)}%), avg ${p.avgDurationMs}ms`);
+    }
+    lines.push("");
+  }
+  if (data.agentDispatches.length > 0) {
+    lines.push("AGENT DISPATCHES:");
+    for (const a of data.agentDispatches) {
+      const reason = a.lastDelegationReason ? ` (last reason: ${a.lastDelegationReason})` : "";
+      lines.push(`  - ${a.agent}: ${a.delegationCount} delegation(s)${reason}`);
+    }
+    lines.push("");
+  }
+  if (data.gateFailures.length > 0) {
+    lines.push("GATE FAILURES:");
+    for (const gf of data.gateFailures) {
+      lines.push(`  - ${gf.gate} on task ${gf.taskId}: ${gf.count} failure(s)`);
+    }
+    lines.push("");
+  }
+  const taxonomyEntries = Object.entries(data.errorTaxonomy).sort((a, b) => b[1] - a[1]);
+  if (taxonomyEntries.length > 0) {
+    lines.push("ERROR TAXONOMY (from phase retrospectives):");
+    for (const [category, count] of taxonomyEntries) {
+      lines.push(`  - ${category}: ${count}`);
+    }
+    lines.push("");
+  }
+  if (data.lessonsFromRetros.length > 0) {
+    lines.push("LESSONS FROM RETROSPECTIVES:");
+    for (const lesson of data.lessonsFromRetros) {
+      lines.push(`  - ${lesson}`);
+    }
+    lines.push("");
+  }
+  return lines.join(`
+`);
+}
+var REFLECTION_SYSTEM_PROMPT = `You are the architect reviewing a completed swarm session. Your job is to analyze what happened and produce a concise, actionable report for the human operator.
+
+You have been given the full session telemetry: tool call statistics, agent dispatches, gate failures, error taxonomy, and lessons from phase retrospectives.
+
+Your report MUST include these sections (omit a section only if there is genuinely nothing to say):
+
+## Problems Encountered
+What went wrong during this session? Tool failures, repeated gate rejections, error patterns. Be specific \u2014 name the tools, the error categories, the tasks affected. If nothing went wrong, say so clearly.
+
+## Tools That Didn't Work
+Which tools had high failure rates or were slow? What was the likely cause? What should the operator or the swarm do differently next time?
+
+## Skill Recommendations
+Based on everything that happened in this session, should any existing skills be updated or new skills be created? Be specific: name the skill, describe the change, and explain why. Consider:
+- Patterns that repeated across multiple tasks or phases
+- Workarounds the agents had to use
+- Knowledge gaps the agents exposed
+- Conventions the session revealed that aren't captured in any skill
+
+## Process Improvements
+What should the swarm do differently next time? Dispatch patterns, gate configurations, agent routing, phase structure \u2014 anything the architect should learn from this session.
+
+Keep the report under 3000 characters. Be direct. No filler. Every sentence should be actionable or provide specific evidence. If the session was clean with no issues, say so in 2-3 sentences and skip the detailed sections.`;
+function buildDeterministicReport(data) {
+  const lines = [];
+  lines.push("## Problems Encountered");
+  lines.push("");
+  if (data.totalToolFailures === 0 && data.gateFailures.length === 0) {
+    lines.push("No tool failures or gate rejections recorded this session.");
+    lines.push("");
+  } else {
+    if (data.totalToolFailures > 0) {
+      const rate = data.totalToolCalls > 0 ? Math.round(data.totalToolFailures / data.totalToolCalls * 100) : 0;
+      lines.push(`${data.totalToolFailures} tool failure(s) across ${data.totalToolCalls} calls (${rate}% failure rate).`);
+    }
+    if (data.gateFailures.length > 0) {
+      lines.push(`${data.gateFailures.length} gate failure(s) recorded:`);
+      for (const gf of data.gateFailures.slice(0, 5)) {
+        lines.push(`- ${gf.gate} on task ${gf.taskId} (${gf.count}x)`);
+      }
+    }
+    const taxonomyEntries = Object.entries(data.errorTaxonomy).sort((a, b) => b[1] - a[1]);
+    if (taxonomyEntries.length > 0) {
+      lines.push("");
+      lines.push("Error patterns:");
+      for (const [cat, count] of taxonomyEntries) {
+        lines.push(`- ${cat}: ${count} occurrence(s)`);
+      }
+    }
+    lines.push("");
+  }
+  if (data.toolProblems.length > 0) {
+    lines.push("## Tools That Didn't Work");
+    lines.push("");
+    for (const p of data.toolProblems) {
+      lines.push(`- **${p.tool}**: ${p.failureCount}/${p.totalCalls} failures (${Math.round(p.failureRate * 100)}%), avg ${p.avgDurationMs}ms per call`);
+    }
+    lines.push("");
+  }
+  if (data.lessonsFromRetros.length > 0) {
+    lines.push("## Skill Recommendations");
+    lines.push("");
+    lines.push("The following lessons were captured during the session. Review them for skill creation/update opportunities:");
+    for (const lesson of data.lessonsFromRetros) {
+      lines.push(`- ${lesson}`);
+    }
+    lines.push("");
+  }
+  lines.push("## Process Improvements");
+  lines.push("");
+  if (data.totalToolFailures === 0 && data.gateFailures.length === 0 && data.lessonsFromRetros.length === 0) {
+    lines.push("Session completed without notable issues.");
+  } else {
+    lines.push("_Deterministic fallback: no LLM client available for deep analysis. Review the data above manually._");
+  }
+  lines.push("");
+  return lines.join(`
+`);
+}
+async function runSessionReflection(input) {
+  const { problems, totalCalls, totalFailures } = gatherToolProblems(input.toolAggregates);
+  const agentDispatches = gatherAgentDispatches(input.agentSessions);
+  const { lessons, taxonomy } = await gatherRetroLessonsAndTaxonomy(input.directory);
+  const gateFailures = await gatherGateFailures(input.directory);
+  const data = {
+    timestamp: new Date().toISOString(),
+    totalToolCalls: totalCalls,
+    totalToolFailures: totalFailures,
+    toolProblems: problems,
+    agentDispatches,
+    gateFailures,
+    lessonsFromRetros: lessons,
+    errorTaxonomy: taxonomy
+  };
+  const delegate = input.delegate ?? createSkillImproverLLMDelegate(input.directory, input.sessionId);
+  if (delegate && !input.signal?.aborted) {
+    try {
+      const dataSummary = buildReflectionDataSummary(data);
+      const report = await delegate(REFLECTION_SYSTEM_PROMPT, dataSummary, input.signal);
+      if (report && report.trim().length > 0) {
+        return { data, architectReport: report.trim(), source: "llm" };
+      }
+    } catch {}
+  }
+  return {
+    data,
+    architectReport: buildDeterministicReport(data),
+    source: "deterministic"
+  };
+}
+async function writeSessionReflection(directory, result) {
+  const reflectionPath = validateSwarmPath(directory, "session-reflection.md");
+  const lines = [];
+  lines.push("# Session Reflection");
+  lines.push("");
+  lines.push(`Generated: ${result.data.timestamp}`);
+  lines.push(`Source: ${result.source}`);
+  lines.push("");
+  lines.push(result.architectReport);
+  const content = lines.join(`
+`);
+  await fs11.writeFile(reflectionPath, content, "utf-8");
+  return reflectionPath;
+}
+
 // src/services/skill-improver.ts
+import { existsSync as existsSync12 } from "fs";
+import { mkdir as mkdir7, readFile as readFile7, rename as rename3, writeFile as writeFile7 } from "fs/promises";
+import * as path24 from "path";
 init_logger();
 
 // src/services/trajectory-cluster.ts
 import { mkdir as mkdir6, writeFile as writeFile6 } from "fs/promises";
-import * as path22 from "path";
+import * as path23 from "path";
 init_logger();
 var MACRO_TRAJECTORY_WINDOW = 200;
 var MOTIF_MIN_TASKS = 2;
@@ -10151,11 +10434,11 @@ async function writeMotifProposals(directory, opts = {}) {
     if (motifs.length === 0)
       return result;
     const max = opts.maxProposals ?? 10;
-    const proposalsDir = validateSwarmPath(directory, path22.join("skills", "proposals"));
+    const proposalsDir = validateSwarmPath(directory, path23.join("skills", "proposals"));
     await mkdir6(proposalsDir, { recursive: true });
     for (const motif of motifs.slice(0, max)) {
       const slug = `motif-${slugify(motif.signature)}`;
-      const filePath = path22.join(proposalsDir, `${slug}.md`);
+      const filePath = path23.join(proposalsDir, `${slug}.md`);
       await writeFile6(filePath, buildMotifProposal(motif), "utf-8");
       result.proposalsWritten.push(filePath);
     }
@@ -10296,11 +10579,11 @@ async function writeSuccessMotifProposals(directory, opts = {}) {
     if (motifs.length === 0)
       return result;
     const max = opts.maxProposals ?? 10;
-    const proposalsDir = validateSwarmPath(directory, path22.join("skills", "proposals"));
+    const proposalsDir = validateSwarmPath(directory, path23.join("skills", "proposals"));
     await mkdir6(proposalsDir, { recursive: true });
     for (const motif of motifs.slice(0, max)) {
       const slug = workflowSlug(motif.signature);
-      const filePath = path22.join(proposalsDir, `${slug}.md`);
+      const filePath = path23.join(proposalsDir, `${slug}.md`);
       await writeFile6(filePath, buildWorkflowProposal(motif), "utf-8");
       result.proposalsWritten.push(filePath);
     }
@@ -10423,7 +10706,7 @@ function timestampSlug(d) {
   return d.toISOString().replace(/[:.]/g, "-");
 }
 async function atomicWrite(p, content) {
-  await mkdir7(path23.dirname(p), { recursive: true });
+  await mkdir7(path24.dirname(p), { recursive: true });
   const tmp = `${p}.tmp-${process.pid}-${Date.now()}`;
   await writeFile7(tmp, content, "utf-8");
   await rename3(tmp, p);
@@ -10826,8 +11109,8 @@ async function runSkillImprover(req) {
     }
     throw err;
   }
-  const proposalDir = path23.join(req.directory, ".swarm", "skill-improver", "proposals");
-  const proposalFile = path23.join(proposalDir, `${timestampSlug(now)}.md`);
+  const proposalDir = path24.join(req.directory, ".swarm", "skill-improver", "proposals");
+  const proposalFile = path24.join(proposalDir, `${timestampSlug(now)}.md`);
   const finalBody = source === "llm" ? buildLLMProposalFrame({
     body,
     targets,
@@ -11250,6 +11533,27 @@ var _internals19 = {
 
 // src/commands/close.ts
 var CLOSE_SKILL_REVIEW_TIMEOUT_MS = 120000;
+var CLOSE_REFLECTION_TIMEOUT_MS = 90000;
+async function runAbortableReflection(input, timeoutMs) {
+  const controller = new AbortController;
+  let timeout;
+  const reflectionPromise = runSessionReflection({
+    ...input,
+    signal: controller.signal
+  });
+  const timeoutPromise = new Promise((_, reject) => {
+    timeout = setTimeout(() => {
+      reject(new Error(`session_reflection exceeded ${timeoutMs}ms budget`));
+      controller.abort();
+    }, timeoutMs);
+  });
+  try {
+    return await Promise.race([reflectionPromise, timeoutPromise]);
+  } finally {
+    if (timeout)
+      clearTimeout(timeout);
+  }
+}
 async function runAbortableSkillReview(req, timeoutMs) {
   const controller = new AbortController;
   let timeout;
@@ -11289,20 +11593,20 @@ function countSessionKnowledgeEntries(entries, sessionStart, fallbackCount) {
 async function copyDirRecursiveWithFailures(src, dest) {
   let count = 0;
   const failures = [];
-  const entries = await fs11.readdir(src);
-  await fs11.mkdir(dest, { recursive: true });
+  const entries = await fs12.readdir(src);
+  await fs12.mkdir(dest, { recursive: true });
   for (const entry of entries) {
-    const srcEntry = path24.join(src, entry);
-    const destEntry = path24.join(dest, entry);
+    const srcEntry = path25.join(src, entry);
+    const destEntry = path25.join(dest, entry);
     try {
-      const stat4 = await fs11.stat(srcEntry);
+      const stat4 = await fs12.stat(srcEntry);
       if (stat4.isDirectory()) {
         const subResult = await copyDirRecursiveWithFailures(srcEntry, destEntry);
         count += subResult.copied;
         failures.push(...subResult.failures);
       } else {
         try {
-          await fs11.copyFile(srcEntry, destEntry);
+          await fs12.copyFile(srcEntry, destEntry);
           count++;
         } catch (err) {
           const errno = err?.code;
@@ -11345,6 +11649,7 @@ var ARCHIVE_ARTIFACTS = [
   "swarm.db-shm",
   "swarm.db-wal",
   "close-summary.md",
+  "session-reflection.md",
   "spec.md"
 ];
 var ACTIVE_STATE_TO_CLEAN = [
@@ -11361,6 +11666,7 @@ var ACTIVE_STATE_TO_CLEAN = [
   "doc-manifest.json",
   "dark-matter.md",
   "telemetry.jsonl",
+  "session-reflection.md",
   "swarm.db",
   "swarm.db-shm",
   "swarm.db-wal"
@@ -11475,20 +11781,20 @@ async function runFinalizeStage(ctx) {
       ctx.warnings.push(`Session retrospective write threw: ${retroError instanceof Error ? retroError.message : String(retroError)}`);
     }
   }
-  const lessonsFilePath = path24.join(ctx.swarmDir, "close-lessons.md");
+  const lessonsFilePath = path25.join(ctx.swarmDir, "close-lessons.md");
   try {
-    const lessonsText = await fs11.readFile(lessonsFilePath, "utf-8");
+    const lessonsText = await fs12.readFile(lessonsFilePath, "utf-8");
     ctx.explicitLessons = lessonsText.split(`
 `).map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#"));
   } catch {}
   try {
-    const evidenceDir = path24.join(ctx.swarmDir, "evidence");
-    const evidenceEntries = await fs11.readdir(evidenceDir);
+    const evidenceDir = path25.join(ctx.swarmDir, "evidence");
+    const evidenceEntries = await fs12.readdir(evidenceDir);
     const retroDirs = evidenceEntries.filter((e) => e.startsWith("retro-")).sort((a, b) => a.localeCompare(b, undefined, { numeric: true }));
     for (const retroDir of retroDirs) {
-      const evidencePath = path24.join(evidenceDir, retroDir, "evidence.json");
+      const evidencePath = path25.join(evidenceDir, retroDir, "evidence.json");
       try {
-        const content = await fs11.readFile(evidencePath, "utf-8");
+        const content = await fs12.readFile(evidencePath, "utf-8");
         const parsed = JSON.parse(content);
         const entries = parsed.entries ?? [parsed];
         for (const entry of entries) {
@@ -11532,7 +11838,7 @@ async function runFinalizeStage(ctx) {
     console.warn("[close-command] curateAndStoreSwarm error:", error2);
   }
   if (ctx.curationSucceeded && ctx.allLessons.length > 0) {
-    await fs11.unlink(lessonsFilePath).catch(() => {});
+    await fs12.unlink(lessonsFilePath).catch(() => {});
   }
   if (ctx.curationSucceeded) {
     if (ctx.config.hive_enabled === false) {} else {
@@ -11587,6 +11893,18 @@ async function runFinalizeStage(ctx) {
       ctx.warnings.push(ctx.skillReviewSummary);
     }
   }
+  try {
+    ctx.sessionReflection = await runAbortableReflection({
+      directory: ctx.directory,
+      toolAggregates: swarmState.toolAggregates,
+      agentSessions: swarmState.agentSessions,
+      sessionId: ctx.options.sessionID
+    }, CLOSE_REFLECTION_TIMEOUT_MS);
+    await writeSessionReflection(ctx.directory, ctx.sessionReflection);
+  } catch (reflectionErr) {
+    const msg = reflectionErr instanceof Error ? reflectionErr.message : String(reflectionErr);
+    ctx.warnings.push(`Session reflection failed: ${msg}`);
+  }
   if (ctx.planExists) {
     ctx.originalStatuses = new Map;
     for (const phase of ctx.planData.phases ?? []) {
@@ -11656,7 +11974,7 @@ async function copySqliteSafe(srcPath, destPath) {
   let checkpointVerified = false;
   try {
     const result = spawnSync5("sqlite3", [srcPath, "PRAGMA wal_checkpoint(TRUNCATE);"], {
-      cwd: path24.dirname(srcPath),
+      cwd: path25.dirname(srcPath),
       encoding: "utf-8",
       stdio: ["ignore", "pipe", "pipe"],
       timeout: 1e4,
@@ -11667,7 +11985,7 @@ async function copySqliteSafe(srcPath, destPath) {
       const code = result.error.code;
       if (code === "ENOENT") {
         try {
-          await fs11.copyFile(srcPath, destPath);
+          await fs12.copyFile(srcPath, destPath);
           return {
             success: true,
             reason: "copied without WAL checkpoint (sqlite3 CLI unavailable)"
@@ -11706,7 +12024,7 @@ async function copySqliteSafe(srcPath, destPath) {
     };
   }
   try {
-    await fs11.copyFile(srcPath, destPath);
+    await fs12.copyFile(srcPath, destPath);
     if (checkpointVerified) {
       return { success: true };
     }
@@ -11724,9 +12042,9 @@ async function copySqliteSafe(srcPath, destPath) {
 async function runArchiveStage(ctx) {
   ctx.timestamp = new Date().toISOString().replace(/[:.]/g, "-");
   ctx.archiveSuffix = Math.random().toString(36).slice(2, 8);
-  ctx.archiveDir = path24.join(ctx.swarmDir, "archive", `swarm-${ctx.timestamp}-${ctx.archiveSuffix}`);
+  ctx.archiveDir = path25.join(ctx.swarmDir, "archive", `swarm-${ctx.timestamp}-${ctx.archiveSuffix}`);
   try {
-    await fs11.mkdir(ctx.archiveDir, { recursive: true });
+    await fs12.mkdir(ctx.archiveDir, { recursive: true });
     const WAL_SIDECAR_FILES = new Set(["swarm.db-shm", "swarm.db-wal"]);
     const linkedKnowledgeShared = isLinked(ctx.directory);
     if (linkedKnowledgeShared) {
@@ -11739,8 +12057,8 @@ async function runArchiveStage(ctx) {
       if (linkedKnowledgeShared && KNOWLEDGE_FAMILY_ARTIFACTS.has(artifact)) {
         continue;
       }
-      const srcPath = path24.join(ctx.swarmDir, artifact);
-      const destPath = path24.join(ctx.archiveDir, artifact);
+      const srcPath = path25.join(ctx.swarmDir, artifact);
+      const destPath = path25.join(ctx.archiveDir, artifact);
       if (artifact === "swarm.db") {
         const result = await copySqliteSafe(srcPath, destPath);
         if (result.skipped) {} else if (result.success) {
@@ -11756,7 +12074,7 @@ async function runArchiveStage(ctx) {
         }
       } else {
         try {
-          await fs11.copyFile(srcPath, destPath);
+          await fs12.copyFile(srcPath, destPath);
           ctx.archivedFileCount++;
           if (ACTIVE_STATE_TO_CLEAN.includes(artifact)) {
             ctx.archivedActiveStateFiles.add(artifact);
@@ -11772,8 +12090,8 @@ async function runArchiveStage(ctx) {
       }
     }
     for (const dirName of ACTIVE_STATE_DIRS_TO_CLEAN) {
-      const srcDir = path24.join(ctx.swarmDir, dirName);
-      const destDir = path24.join(ctx.archiveDir, dirName);
+      const srcDir = path25.join(ctx.swarmDir, dirName);
+      const destDir = path25.join(ctx.archiveDir, dirName);
       try {
         const result = await copyDirRecursiveWithFailures(srcDir, destDir);
         ctx.archivedFileCount += result.copied;
@@ -11846,9 +12164,9 @@ async function runCleanStage(ctx) {
         ctx.warnings.push(reason ? `Preserved ${artifact} because it was not successfully archived: ${reason}.` : `Preserved ${artifact} because it was not successfully archived.`);
         continue;
       }
-      const filePath = path24.join(ctx.swarmDir, artifact);
+      const filePath = path25.join(ctx.swarmDir, artifact);
       try {
-        await fs11.unlink(filePath);
+        await fs12.unlink(filePath);
         cleanedFiles.push(artifact);
       } catch (err) {
         const errno = err?.code;
@@ -11865,18 +12183,18 @@ async function runCleanStage(ctx) {
     if (!ctx.archivedActiveStateDirs.has(dirName)) {
       continue;
     }
-    const dirPath = path24.join(ctx.swarmDir, dirName);
+    const dirPath = path25.join(ctx.swarmDir, dirName);
     try {
-      await fs11.rm(dirPath, { recursive: true, force: true });
+      await fs12.rm(dirPath, { recursive: true, force: true });
       cleanedFiles.push(`${dirName}/`);
     } catch {}
   }
   try {
-    const swarmFiles = await fs11.readdir(ctx.swarmDir);
+    const swarmFiles = await fs12.readdir(ctx.swarmDir);
     const configBackups = swarmFiles.filter((f) => f.startsWith("config-backup-") && f.endsWith(".json"));
     for (const backup of configBackups) {
       try {
-        await fs11.unlink(path24.join(ctx.swarmDir, backup));
+        await fs12.unlink(path25.join(ctx.swarmDir, backup));
         configBackupsRemoved++;
       } catch (err) {
         const errno = err?.code;
@@ -11889,7 +12207,7 @@ async function runCleanStage(ctx) {
     const ledgerSiblings = swarmFiles.filter((f) => (f.startsWith("plan-ledger.archived-") || f.startsWith("plan-ledger.backup-")) && f.endsWith(".jsonl"));
     for (const sibling of ledgerSiblings) {
       try {
-        await fs11.unlink(path24.join(ctx.swarmDir, sibling));
+        await fs12.unlink(path25.join(ctx.swarmDir, sibling));
       } catch (err) {
         const errno = err?.code;
         if (errno === "ENOENT") {} else {
@@ -11907,14 +12225,14 @@ async function runCleanStage(ctx) {
   }
   let swarmPlanFilesRemoved = 0;
   const candidates = [
-    path24.join(ctx.directory, ".swarm", "SWARM_PLAN.json"),
-    path24.join(ctx.directory, ".swarm", "SWARM_PLAN.md"),
-    path24.join(ctx.directory, "SWARM_PLAN.json"),
-    path24.join(ctx.directory, "SWARM_PLAN.md")
+    path25.join(ctx.directory, ".swarm", "SWARM_PLAN.json"),
+    path25.join(ctx.directory, ".swarm", "SWARM_PLAN.md"),
+    path25.join(ctx.directory, "SWARM_PLAN.json"),
+    path25.join(ctx.directory, "SWARM_PLAN.md")
   ];
   for (const candidate of candidates) {
     try {
-      await fs11.unlink(candidate);
+      await fs12.unlink(candidate);
       swarmPlanFilesRemoved++;
     } catch (err) {
       if (err?.code !== "ENOENT") {
@@ -11924,11 +12242,11 @@ async function runCleanStage(ctx) {
   }
   let tmpFilesRemoved = 0;
   try {
-    const swarmFiles = await fs11.readdir(ctx.swarmDir);
+    const swarmFiles = await fs12.readdir(ctx.swarmDir);
     const tmpFiles = swarmFiles.filter((f) => f.startsWith(".tmp."));
     for (const tmp of tmpFiles) {
       try {
-        await fs11.unlink(path24.join(ctx.swarmDir, tmp));
+        await fs12.unlink(path25.join(ctx.swarmDir, tmp));
         tmpFilesRemoved++;
       } catch (err) {
         const errno = err?.code;
@@ -11949,7 +12267,7 @@ async function runCleanStage(ctx) {
     cleanedFiles.push(`${tmpFilesRemoved} .tmp.* file(s)`);
   }
   clearAllScopes(ctx.directory);
-  const contextPath = path24.join(ctx.swarmDir, "context.md");
+  const contextPath = path25.join(ctx.swarmDir, "context.md");
   const contextContent = [
     "# Context",
     "",
@@ -11961,9 +12279,9 @@ async function runCleanStage(ctx) {
     ""
   ].join(`
 `);
-  const contextTempPath = path24.join(path24.dirname(contextPath), `${path24.basename(contextPath)}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+  const contextTempPath = path25.join(path25.dirname(contextPath), `${path25.basename(contextPath)}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
   try {
-    await fs11.writeFile(contextTempPath, contextContent, "utf-8");
+    await fs12.writeFile(contextTempPath, contextContent, "utf-8");
     fsSync2.renameSync(contextTempPath, contextPath);
   } catch (error2) {
     try {
@@ -12025,7 +12343,7 @@ async function runAlignStage(ctx) {
   return { gitAlignResult, prunedBranches };
 }
 async function handleCloseCommand(directory, args, options = {}) {
-  const swarmDir = path24.join(directory, ".swarm");
+  const swarmDir = path25.join(directory, ".swarm");
   try {
     const stat4 = fsSync2.lstatSync(swarmDir);
     if (stat4.isSymbolicLink()) {
@@ -12039,18 +12357,18 @@ async function handleCloseCommand(directory, args, options = {}) {
   const planPath = validateSwarmPath(directory, "plan.json");
   let planExists = false;
   let planData = {
-    title: path24.basename(directory) || "Ad-hoc session",
+    title: path25.basename(directory) || "Ad-hoc session",
     phases: []
   };
   try {
-    const content = await fs11.readFile(planPath, "utf-8");
+    const content = await fs12.readFile(planPath, "utf-8");
     planData = JSON.parse(content);
     planExists = true;
   } catch (error2) {
     if (error2?.code !== "ENOENT") {
       return `\u274C Failed to read plan.json: ${error2 instanceof Error ? error2.message : String(error2)}`;
     }
-    const swarmDirExists = await fs11.access(swarmDir).then(() => true).catch(() => false);
+    const swarmDirExists = await fs12.access(swarmDir).then(() => true).catch(() => false);
     if (!swarmDirExists) {
       return `\u274C No .swarm/ directory found in ${directory}. Run /swarm close from the project root, or run /swarm plan first.`;
     }
@@ -12064,15 +12382,15 @@ async function handleCloseCommand(directory, args, options = {}) {
   }
   try {
     if (!planExists) {
-      const archiveDir = path24.join(swarmDir, "archive");
+      const archiveDir = path25.join(swarmDir, "archive");
       try {
-        const archiveEntries = await fs11.readdir(archiveDir);
+        const archiveEntries = await fs12.readdir(archiveDir);
         const hasArchiveBundle = archiveEntries.some((entry) => entry.startsWith("swarm-"));
         if (hasArchiveBundle) {
           const hasActiveState = [
             ...ACTIVE_STATE_TO_CLEAN,
             ...ACTIVE_STATE_DIRS_TO_CLEAN
-          ].some((entry) => fsSync2.existsSync(path24.join(swarmDir, entry)));
+          ].some((entry) => fsSync2.existsSync(path25.join(swarmDir, entry)));
           if (!hasActiveState) {
             return `\u2705 Already finalized \u2014 nothing to do.
 
@@ -12116,6 +12434,7 @@ This project was already finalized in a previous /swarm close run. The plan has
       knowledgeSkillHint: "",
       skillReviewSummary: "",
       postMortemSummary: "",
+      sessionReflection: undefined,
       hivePromoted: 0,
       sessionKnowledgeCreated: 0,
       fallbackKnowledgeCreated: 0,
@@ -12165,6 +12484,12 @@ This project was already finalized in a previous /swarm close run. The plan has
         "## Skill Review",
         ctx.skillReviewSummary || "Skill review completed without details."
       ] : [],
+      ...ctx.sessionReflection ? [
+        "",
+        `## Session Reflection (${ctx.sessionReflection.source})`,
+        "",
+        ctx.sessionReflection.architectReport
+      ] : [],
       "",
       "## Local Repo State",
       ...gitAlignResult ? [`- **Git:** ${gitAlignResult}`] : ["- Git alignment skipped"],
@@ -12188,9 +12513,9 @@ This project was already finalized in a previous /swarm close run. The plan has
       ...ctx.warnings.length > 0 ? ["## Warnings", ...ctx.warnings.map((w) => `- ${w}`), ""] : []
     ].join(`
 `);
-    const closeSummaryTempPath = path24.join(path24.dirname(closeSummaryPath), `${path24.basename(closeSummaryPath)}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+    const closeSummaryTempPath = path25.join(path25.dirname(closeSummaryPath), `${path25.basename(closeSummaryPath)}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
     try {
-      await fs11.writeFile(closeSummaryTempPath, summaryContent, "utf-8");
+      await fs12.writeFile(closeSummaryTempPath, summaryContent, "utf-8");
       fsSync2.renameSync(closeSummaryTempPath, closeSummaryPath);
     } catch (error2) {
       try {
@@ -12230,16 +12555,30 @@ ${otherWarnings.map((w) => `- ${w}`).join(`
     const postMortemOutput = ctx.postMortemSummary ? `
 
 **Post-Mortem:** ${ctx.postMortemSummary}` : "";
+    let reflectionOutput = "";
+    if (ctx.sessionReflection) {
+      const d = ctx.sessionReflection.data;
+      const hasSignals = d.totalToolFailures > 0 || d.gateFailures.length > 0 || d.lessonsFromRetros.length > 0 || Object.keys(d.errorTaxonomy).length > 0 || d.agentDispatches.length > 0;
+      if (hasSignals) {
+        reflectionOutput = `
+
+---
+
+**Architect Session Review** (${ctx.sessionReflection.source}):
+
+${ctx.sessionReflection.architectReport}`;
+      }
+    }
     if (ctx.planAlreadyDone) {
       return `\u2705 Session finalized. Plan was already in a terminal state \u2014 cleanup and archive applied.
 
 **Archive:** ${ctx.archiveResult}
-**Git:** ${gitAlignResult}${lessonSummary}${knowledgeHintSummary}${skillReviewOutput}${postMortemOutput}${warningMsg}`;
+**Git:** ${gitAlignResult}${lessonSummary}${knowledgeHintSummary}${skillReviewOutput}${postMortemOutput}${reflectionOutput}${warningMsg}`;
     }
     return `\u2705 Swarm finalized. ${ctx.closedPhases.length} phase(s) closed, ${ctx.closedTasks.length} incomplete task(s) marked closed.
 
 **Archive:** ${ctx.archiveResult}
-**Git:** ${gitAlignResult}${lessonSummary}${knowledgeHintSummary}${skillReviewOutput}${postMortemOutput}${warningMsg}`;
+**Git:** ${gitAlignResult}${lessonSummary}${knowledgeHintSummary}${skillReviewOutput}${postMortemOutput}${reflectionOutput}${warningMsg}`;
   } finally {
     if (finalizeLock.release) {
       try {
@@ -12259,6 +12598,7 @@ var _internals20 = {
   ACTIVE_STATE_DIRS_TO_CLEAN,
   countSessionKnowledgeEntries,
   CLOSE_SKILL_REVIEW_TIMEOUT_MS,
+  CLOSE_REFLECTION_TIMEOUT_MS,
   guaranteeAllPlansComplete,
   getGitRepositoryStatus,
   resetToMainAfterMerge,
@@ -12511,14 +12851,14 @@ function buildStatusMessage(session, plan) {
 
 // src/commands/config.ts
 import * as os6 from "os";
-import * as path25 from "path";
+import * as path26 from "path";
 function getUserConfigDir2() {
-  return process.env.XDG_CONFIG_HOME || path25.join(os6.homedir(), ".config");
+  return process.env.XDG_CONFIG_HOME || path26.join(os6.homedir(), ".config");
 }
 async function handleConfigCommand(directory, _args) {
   const config = loadPluginConfig(directory);
-  const userConfigPath = path25.join(getUserConfigDir2(), "opencode", "opencode-swarm.json");
-  const projectConfigPath = path25.join(directory, ".opencode", "opencode-swarm.json");
+  const userConfigPath = path26.join(getUserConfigDir2(), "opencode", "opencode-swarm.json");
+  const projectConfigPath = path26.join(directory, ".opencode", "opencode-swarm.json");
   const lines = [
     "## Swarm Configuration",
     "",
@@ -12538,7 +12878,7 @@ async function handleConfigCommand(directory, _args) {
 // src/services/skill-consolidation.ts
 import { existsSync as existsSync14 } from "fs";
 import { mkdir as mkdir8, readFile as readFile8, rename as rename4, writeFile as writeFile8 } from "fs/promises";
-import * as path26 from "path";
+import * as path27 from "path";
 
 // src/utils/timeout.ts
 async function withTimeout(promise, ms, timeoutError) {
@@ -12563,7 +12903,7 @@ var DEFAULT_CONSOLIDATION_MAX_CALLS_PER_RUN = 1;
 var CONSOLIDATION_RUN_TIMEOUT_MS = 5 * 60 * 1000;
 var runningByDirectory = new Map;
 function consolidationStatePath(directory) {
-  return path26.join(directory, ".swarm", "skill-improver", "consolidation-state.json");
+  return path27.join(directory, ".swarm", "skill-improver", "consolidation-state.json");
 }
 async function readState2(directory) {
   const filePath = consolidationStatePath(directory);
@@ -12579,7 +12919,7 @@ async function readState2(directory) {
   }
 }
 async function atomicWrite2(filePath, content) {
-  await mkdir8(path26.dirname(filePath), { recursive: true });
+  await mkdir8(path27.dirname(filePath), { recursive: true });
   const tmp = `${filePath}.tmp-${process.pid}-${Date.now()}`;
   await writeFile8(tmp, content, "utf-8");
   await rename4(tmp, filePath);
@@ -12659,7 +12999,7 @@ async function runSkillConsolidationInner(req) {
   };
 }
 async function runSkillConsolidation(req) {
-  const key = path26.resolve(req.directory);
+  const key = path27.resolve(req.directory);
   const existing = runningByDirectory.get(key);
   if (existing) {
     return {
@@ -12811,8 +13151,8 @@ async function handleCouncilCommand(_directory, args) {
 
 // src/commands/coupling.ts
 import { randomBytes } from "crypto";
-import * as fs12 from "fs";
-import * as path28 from "path";
+import * as fs13 from "fs";
+import * as path29 from "path";
 
 // src/turbo/epic/cochange-source.ts
 import * as child_process3 from "child_process";
@@ -12822,7 +13162,7 @@ import { promisify as promisify2 } from "util";
 import * as child_process2 from "child_process";
 import { randomUUID as randomUUID3 } from "crypto";
 import { readdir as readdir4, readFile as readFile9, stat as stat4 } from "fs/promises";
-import * as path27 from "path";
+import * as path28 from "path";
 import { promisify } from "util";
 function getExecFileAsync() {
   return promisify(child_process2.execFile);
@@ -12926,7 +13266,7 @@ async function scanSourceFiles(dir) {
   try {
     const entries = await readdir4(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path27.join(dir, entry.name);
+      const fullPath = path28.join(dir, entry.name);
       if (entry.isDirectory()) {
         if (skipDirs.has(entry.name)) {
           continue;
@@ -12934,7 +13274,7 @@ async function scanSourceFiles(dir) {
         const subFiles = await scanSourceFiles(fullPath);
         results.push(...subFiles);
       } else if (entry.isFile()) {
-        const ext = path27.extname(entry.name);
+        const ext = path28.extname(entry.name);
         if ([".ts", ".tsx", ".js", ".jsx", ".mjs"].includes(ext)) {
           results.push(fullPath);
         }
@@ -12956,8 +13296,8 @@ async function getStaticEdges(directory) {
           continue;
         }
         try {
-          const sourceDir = path27.dirname(sourceFile);
-          const resolvedPath = path27.resolve(sourceDir, importPath);
+          const sourceDir = path28.dirname(sourceFile);
+          const resolvedPath = path28.resolve(sourceDir, importPath);
           const extensions = [
             "",
             ".ts",
@@ -12982,8 +13322,8 @@ async function getStaticEdges(directory) {
           if (!targetFile) {
             continue;
           }
-          const relSource = path27.relative(directory, sourceFile).replace(/\\/g, "/");
-          const relTarget = path27.relative(directory, targetFile).replace(/\\/g, "/");
+          const relSource = path28.relative(directory, sourceFile).replace(/\\/g, "/");
+          const relTarget = path28.relative(directory, targetFile).replace(/\\/g, "/");
           const [key] = relSource < relTarget ? [`${relSource}::${relTarget}`, relSource, relTarget] : [`${relTarget}::${relSource}`, relTarget, relSource];
           edges.add(key);
         } catch {}
@@ -12995,7 +13335,7 @@ async function getStaticEdges(directory) {
 function isTestImplementationPair(fileA, fileB) {
   const testPatterns = [".test.ts", ".test.js", ".spec.ts", ".spec.js"];
   const getBaseName = (filePath) => {
-    const base = path27.basename(filePath);
+    const base = path28.basename(filePath);
     for (const pattern of testPatterns) {
       if (base.endsWith(pattern)) {
         return base.slice(0, -pattern.length);
@@ -13005,16 +13345,16 @@ function isTestImplementationPair(fileA, fileB) {
   };
   const baseA = getBaseName(fileA);
   const baseB = getBaseName(fileB);
-  return baseA === baseB && baseA !== path27.basename(fileA) && baseA !== path27.basename(fileB);
+  return baseA === baseB && baseA !== path28.basename(fileA) && baseA !== path28.basename(fileB);
 }
 function hasSharedPrefix(fileA, fileB) {
-  const dirA = path27.dirname(fileA);
-  const dirB = path27.dirname(fileB);
+  const dirA = path28.dirname(fileA);
+  const dirB = path28.dirname(fileB);
   if (dirA !== dirB) {
     return false;
   }
-  const baseA = path27.basename(fileA).replace(/\.(ts|js|tsx|jsx|mjs)$/, "");
-  const baseB = path27.basename(fileB).replace(/\.(ts|js|tsx|jsx|mjs)$/, "");
+  const baseA = path28.basename(fileA).replace(/\.(ts|js|tsx|jsx|mjs)$/, "");
+  const baseB = path28.basename(fileB).replace(/\.(ts|js|tsx|jsx|mjs)$/, "");
   if (baseA.startsWith(baseB) || baseB.startsWith(baseA)) {
     return true;
   }
@@ -13069,8 +13409,8 @@ function darkMatterToKnowledgeEntries(pairs, projectName) {
   const entries = [];
   const now = new Date().toISOString();
   for (const pair of pairs.slice(0, 10)) {
-    const baseA = path27.basename(pair.fileA);
-    const baseB = path27.basename(pair.fileB);
+    const baseA = path28.basename(pair.fileA);
+    const baseB = path28.basename(pair.fileB);
     let lesson = `Files ${pair.fileA} and ${pair.fileB} co-change with NPMI=${pair.npmi.toFixed(3)} but have no import relationship. This hidden coupling suggests a shared architectural concern \u2014 changes to one likely require changes to the other.`;
     if (lesson.length > 280) {
       lesson = `Files ${baseA} and ${baseB} co-change with NPMI=${pair.npmi.toFixed(3)} but have no import relationship. This hidden coupling suggests a shared architectural concern \u2014 changes to one likely require changes to the other.`;
@@ -13496,17 +13836,17 @@ function parseArgs3(args) {
   return parsed;
 }
 function persistReportJson(directory, report) {
-  const epicDir = path28.join(directory, ".swarm", "epic");
-  fs12.mkdirSync(epicDir, { recursive: true });
-  const filePath = path28.join(epicDir, "coupling-report.json");
+  const epicDir = path29.join(directory, ".swarm", "epic");
+  fs13.mkdirSync(epicDir, { recursive: true });
+  const filePath = path29.join(epicDir, "coupling-report.json");
   const tmpPath = `${filePath}.tmp.${randomBytes(8).toString("hex")}`;
-  fs12.writeFileSync(tmpPath, `${JSON.stringify(report, null, 2)}
+  fs13.writeFileSync(tmpPath, `${JSON.stringify(report, null, 2)}
 `, "utf-8");
   try {
-    fs12.renameSync(tmpPath, filePath);
+    fs13.renameSync(tmpPath, filePath);
   } catch (err) {
     try {
-      fs12.unlinkSync(tmpPath);
+      fs13.unlinkSync(tmpPath);
     } catch {}
     throw err;
   }
@@ -13557,7 +13897,7 @@ Usage: /swarm coupling [--phase <n>] [--threshold <-1..1>] [--min-co-changes <n>
       persistStatus = {
         requested: true,
         written: true,
-        path: path28.relative(directory, writtenAt)
+        path: path29.relative(directory, writtenAt)
       };
     } catch (err) {
       persistStatus = {
@@ -13616,7 +13956,7 @@ function formatCurationSummary(summary) {
 }
 
 // src/commands/dark-matter.ts
-import path29 from "path";
+import path30 from "path";
 async function handleDarkMatterCommand(directory, args) {
   const options = {};
   for (let i = 0;i < args.length; i++) {
@@ -13648,7 +13988,7 @@ Ensure this is a git repository with commit history.`;
   const output = formatDarkMatterOutput(pairs);
   if (pairs.length > 0) {
     try {
-      const projectName = path29.basename(path29.resolve(directory));
+      const projectName = path30.basename(path30.resolve(directory));
       const entries = darkMatterToKnowledgeEntries(pairs, projectName);
       if (entries.length > 0) {
         const knowledgePath = resolveSwarmKnowledgePath(directory);
@@ -14015,49 +14355,49 @@ ${USAGE5}`;
 // src/services/diagnose-service.ts
 import * as child_process4 from "child_process";
 import { existsSync as existsSync17, readdirSync as readdirSync3, readFileSync as readFileSync9, statSync as statSync6 } from "fs";
-import path31 from "path";
+import path32 from "path";
 import { fileURLToPath } from "url";
 
 // src/config/cache-paths.ts
 import * as os7 from "os";
-import * as path30 from "path";
+import * as path31 from "path";
 function getPluginConfigDir() {
-  return path30.join(process.env.XDG_CONFIG_HOME || path30.join(os7.homedir(), ".config"), "opencode");
+  return path31.join(process.env.XDG_CONFIG_HOME || path31.join(os7.homedir(), ".config"), "opencode");
 }
 function getPluginCachePaths() {
-  const cacheBase = process.env.XDG_CACHE_HOME || path30.join(os7.homedir(), ".cache");
+  const cacheBase = process.env.XDG_CACHE_HOME || path31.join(os7.homedir(), ".cache");
   const configDir = getPluginConfigDir();
   const paths = [
-    path30.join(cacheBase, "opencode", "node_modules", "opencode-swarm"),
-    path30.join(cacheBase, "opencode", "packages", "opencode-swarm@latest"),
-    path30.join(configDir, "node_modules", "opencode-swarm")
+    path31.join(cacheBase, "opencode", "node_modules", "opencode-swarm"),
+    path31.join(cacheBase, "opencode", "packages", "opencode-swarm@latest"),
+    path31.join(configDir, "node_modules", "opencode-swarm")
   ];
   if (process.platform === "darwin") {
-    const libCaches = path30.join(os7.homedir(), "Library", "Caches");
-    paths.push(path30.join(libCaches, "opencode", "node_modules", "opencode-swarm"), path30.join(libCaches, "opencode", "packages", "opencode-swarm@latest"));
+    const libCaches = path31.join(os7.homedir(), "Library", "Caches");
+    paths.push(path31.join(libCaches, "opencode", "node_modules", "opencode-swarm"), path31.join(libCaches, "opencode", "packages", "opencode-swarm@latest"));
   }
   if (process.platform === "win32") {
-    const localAppData = process.env.LOCALAPPDATA || path30.join(os7.homedir(), "AppData", "Local");
-    const appData = process.env.APPDATA || path30.join(os7.homedir(), "AppData", "Roaming");
-    paths.push(path30.join(localAppData, "opencode", "node_modules", "opencode-swarm"), path30.join(localAppData, "opencode", "packages", "opencode-swarm@latest"), path30.join(appData, "opencode", "node_modules", "opencode-swarm"));
+    const localAppData = process.env.LOCALAPPDATA || path31.join(os7.homedir(), "AppData", "Local");
+    const appData = process.env.APPDATA || path31.join(os7.homedir(), "AppData", "Roaming");
+    paths.push(path31.join(localAppData, "opencode", "node_modules", "opencode-swarm"), path31.join(localAppData, "opencode", "packages", "opencode-swarm@latest"), path31.join(appData, "opencode", "node_modules", "opencode-swarm"));
   }
   return paths;
 }
 function getPluginLockFilePaths() {
-  const cacheBase = process.env.XDG_CACHE_HOME || path30.join(os7.homedir(), ".cache");
+  const cacheBase = process.env.XDG_CACHE_HOME || path31.join(os7.homedir(), ".cache");
   const configDir = getPluginConfigDir();
   const paths = [
-    path30.join(cacheBase, "opencode", "bun.lock"),
-    path30.join(cacheBase, "opencode", "bun.lockb"),
-    path30.join(configDir, "package-lock.json")
+    path31.join(cacheBase, "opencode", "bun.lock"),
+    path31.join(cacheBase, "opencode", "bun.lockb"),
+    path31.join(configDir, "package-lock.json")
   ];
   if (process.platform === "darwin") {
-    const libCaches = path30.join(os7.homedir(), "Library", "Caches");
-    paths.push(path30.join(libCaches, "opencode", "bun.lock"), path30.join(libCaches, "opencode", "bun.lockb"));
+    const libCaches = path31.join(os7.homedir(), "Library", "Caches");
+    paths.push(path31.join(libCaches, "opencode", "bun.lock"), path31.join(libCaches, "opencode", "bun.lockb"));
   }
   if (process.platform === "win32") {
-    const localAppData = process.env.LOCALAPPDATA || path30.join(os7.homedir(), "AppData", "Local");
-    paths.push(path30.join(localAppData, "opencode", "bun.lock"), path30.join(localAppData, "opencode", "bun.lockb"));
+    const localAppData = process.env.LOCALAPPDATA || path31.join(os7.homedir(), "AppData", "Local");
+    paths.push(path31.join(localAppData, "opencode", "bun.lock"), path31.join(localAppData, "opencode", "bun.lockb"));
   }
   return paths;
 }
@@ -14073,22 +14413,22 @@ import { readFile as readFile10 } from "fs/promises";
 // src/services/version-check.ts
 import { existsSync as existsSync15, mkdirSync as mkdirSync9, readFileSync as readFileSync8, writeFileSync as writeFileSync8 } from "fs";
 import { homedir as homedir4 } from "os";
-import { join as join25 } from "path";
+import { join as join26 } from "path";
 var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000;
 function cacheDir() {
   const xdg = process.env.XDG_CACHE_HOME;
-  const base = xdg && xdg.length > 0 ? xdg : join25(homedir4(), ".cache");
-  return join25(base, "opencode-swarm");
+  const base = xdg && xdg.length > 0 ? xdg : join26(homedir4(), ".cache");
+  return join26(base, "opencode-swarm");
 }
 function cacheFile() {
-  return join25(cacheDir(), "version-check.json");
+  return join26(cacheDir(), "version-check.json");
 }
 function readVersionCache() {
   try {
-    const path31 = cacheFile();
-    if (!existsSync15(path31))
+    const path32 = cacheFile();
+    if (!existsSync15(path32))
       return null;
-    const raw = readFileSync8(path31, "utf-8");
+    const raw = readFileSync8(path32, "utf-8");
     const parsed = JSON.parse(raw);
     if (typeof parsed?.checkedAt !== "number")
       return null;
@@ -14637,7 +14977,7 @@ async function checkSpecStaleness(directory, plan) {
   };
 }
 async function checkConfigParseability(directory) {
-  const configPath = path31.join(directory, ".opencode/opencode-swarm.json");
+  const configPath = path32.join(directory, ".opencode/opencode-swarm.json");
   if (!existsSync17(configPath)) {
     return {
       name: "Config Parseability",
@@ -14666,7 +15006,7 @@ function resolveGrammarDir(thisDir) {
   const normalized = thisDir.replace(/\\/g, "/");
   const isSource = normalized.endsWith("/src/services");
   const isCliBundle = normalized.endsWith("/cli");
-  return isSource || isCliBundle ? path31.join(thisDir, "..", "lang", "grammars") : path31.join(thisDir, "lang", "grammars");
+  return isSource || isCliBundle ? path32.join(thisDir, "..", "lang", "grammars") : path32.join(thisDir, "lang", "grammars");
 }
 async function checkGrammarWasmFiles() {
   const grammarFiles = [
@@ -14690,14 +15030,14 @@ async function checkGrammarWasmFiles() {
     "tree-sitter-ini.wasm",
     "tree-sitter-regex.wasm"
   ];
-  const thisDir = path31.dirname(fileURLToPath(import.meta.url));
+  const thisDir = path32.dirname(fileURLToPath(import.meta.url));
   const grammarDir = resolveGrammarDir(thisDir);
   const missing = [];
-  if (!existsSync17(path31.join(grammarDir, "tree-sitter.wasm"))) {
+  if (!existsSync17(path32.join(grammarDir, "tree-sitter.wasm"))) {
     missing.push("tree-sitter.wasm (core runtime)");
   }
   for (const file of grammarFiles) {
-    if (!existsSync17(path31.join(grammarDir, file))) {
+    if (!existsSync17(path32.join(grammarDir, file))) {
       missing.push(file);
     }
   }
@@ -14715,7 +15055,7 @@ async function checkGrammarWasmFiles() {
   };
 }
 async function checkCheckpointManifest(directory) {
-  const manifestPath = path31.join(directory, ".swarm/checkpoints.json");
+  const manifestPath = path32.join(directory, ".swarm/checkpoints.json");
   if (!existsSync17(manifestPath)) {
     return {
       name: "Checkpoint Manifest",
@@ -14767,7 +15107,7 @@ async function checkCheckpointManifest(directory) {
   }
 }
 async function checkEventStreamIntegrity(directory) {
-  const eventsPath = path31.join(directory, ".swarm/events.jsonl");
+  const eventsPath = path32.join(directory, ".swarm/events.jsonl");
   if (!existsSync17(eventsPath)) {
     return {
       name: "Event Stream",
@@ -14808,7 +15148,7 @@ async function checkEventStreamIntegrity(directory) {
   }
 }
 async function checkSteeringDirectives(directory) {
-  const eventsPath = path31.join(directory, ".swarm/events.jsonl");
+  const eventsPath = path32.join(directory, ".swarm/events.jsonl");
   if (!existsSync17(eventsPath)) {
     return {
       name: "Steering Directives",
@@ -14864,7 +15204,7 @@ async function checkCurator(directory) {
         detail: "Disabled (enable via curator.enabled)"
       };
     }
-    const summaryPath = path31.join(directory, ".swarm/curator-summary.json");
+    const summaryPath = path32.join(directory, ".swarm/curator-summary.json");
     if (!existsSync17(summaryPath)) {
       return {
         name: "Curator",
@@ -15066,7 +15406,7 @@ async function getDiagnoseData(directory) {
   checks.push(await checkCurator(directory));
   checks.push(await checkKnowledgeHealth(directory));
   try {
-    const evidenceDir = path31.join(directory, ".swarm", "evidence");
+    const evidenceDir = path32.join(directory, ".swarm", "evidence");
     const snapshotFiles = existsSync17(evidenceDir) ? readdirSync3(evidenceDir).filter((f) => f.startsWith("agent-tools-") && f.endsWith(".json")) : [];
     if (snapshotFiles.length > 0) {
       const latest = snapshotFiles.sort().pop();
@@ -15104,7 +15444,7 @@ async function getDiagnoseData(directory) {
         cacheRows.push(`\u2B1C ${cachePath} \u2014 absent`);
         continue;
       }
-      const pkgJsonPath = path31.join(cachePath, "package.json");
+      const pkgJsonPath = path32.join(cachePath, "package.json");
       try {
         const raw = readFileSync9(pkgJsonPath, "utf-8");
         const parsed = JSON.parse(raw);
@@ -15475,10 +15815,10 @@ function decideEpicActivation(tasks, cochangePairs, commitsObserved, options) {
 
 // src/turbo/epic/calibration.ts
 init_logger();
-import * as fs13 from "fs";
-import * as path32 from "path";
+import * as fs14 from "fs";
+import * as path33 from "path";
 var STATE_FILE = "calibration.json";
-var STATE_REL_DIR = path32.join(".swarm", "epic");
+var STATE_REL_DIR = path33.join(".swarm", "epic");
 function nowISO() {
   return new Date().toISOString();
 }
@@ -15500,13 +15840,13 @@ function markUnreadable(directory, reason) {
   error(`[epic/calibration] state file unreadable for ${directory}: ${reason} \u2014 failing closed`);
 }
 function repairCalibrationUnreadable(directory) {
-  const filePath = path32.join(directory, STATE_REL_DIR, STATE_FILE);
-  if (!fs13.existsSync(filePath)) {
+  const filePath = path33.join(directory, STATE_REL_DIR, STATE_FILE);
+  if (!fs14.existsSync(filePath)) {
     stateUnreadableMap.delete(directory);
     return;
   }
   try {
-    const raw = fs13.readFileSync(filePath, "utf-8");
+    const raw = fs14.readFileSync(filePath, "utf-8");
     const parsed = JSON.parse(raw);
     if (!isValidCalibrationShape(parsed)) {
       stateUnreadableMap.set(directory, true);
@@ -15532,9 +15872,9 @@ function isValidCalibrationShape(candidate) {
   return true;
 }
 function ensureSwarmEpicDir(directory) {
-  const dir = path32.resolve(directory, STATE_REL_DIR);
-  if (!fs13.existsSync(dir)) {
-    fs13.mkdirSync(dir, { recursive: true });
+  const dir = path33.resolve(directory, STATE_REL_DIR);
+  if (!fs14.existsSync(dir)) {
+    fs14.mkdirSync(dir, { recursive: true });
   }
   return dir;
 }
@@ -15544,18 +15884,18 @@ function loadCalibrationState(directory) {
     if (stateUnreadableMap.get(directory))
       return null;
   }
-  const filePath = path32.join(directory, STATE_REL_DIR, STATE_FILE);
+  const filePath = path33.join(directory, STATE_REL_DIR, STATE_FILE);
   try {
-    if (!fs13.existsSync(filePath)) {
+    if (!fs14.existsSync(filePath)) {
       const seed = emptyCalibrationState();
       try {
         ensureSwarmEpicDir(directory);
-        fs13.writeFileSync(filePath, `${JSON.stringify(seed, null, 2)}
+        fs14.writeFileSync(filePath, `${JSON.stringify(seed, null, 2)}
 `, "utf-8");
       } catch {}
       return seed;
     }
-    const raw = fs13.readFileSync(filePath, "utf-8");
+    const raw = fs14.readFileSync(filePath, "utf-8");
     const parsed = JSON.parse(raw);
     if (!isValidCalibrationShape(parsed)) {
       markUnreadable(directory, `malformed shape (version=${parsed?.version}, hotModuleAdditions type=${Array.isArray(parsed?.hotModuleAdditions) ? "array" : typeof parsed?.hotModuleAdditions})`);
@@ -15570,36 +15910,36 @@ function loadCalibrationState(directory) {
 
 // src/turbo/epic/divergence-recorder.ts
 init_logger();
-import * as fs14 from "fs";
-import * as path33 from "path";
-var EVIDENCE_REL_DIR = path33.join(".swarm", "epic");
+import * as fs15 from "fs";
+import * as path34 from "path";
+var EVIDENCE_REL_DIR = path34.join(".swarm", "epic");
 var EVIDENCE_FILE = "divergence.jsonl";
 var MAX_TAIL_BYTES2 = 16 * 1024 * 1024;
 function readDivergenceHistory(directory, options) {
-  const filePath = path33.join(directory, EVIDENCE_REL_DIR, EVIDENCE_FILE);
-  if (!fs14.existsSync(filePath)) {
+  const filePath = path34.join(directory, EVIDENCE_REL_DIR, EVIDENCE_FILE);
+  if (!fs15.existsSync(filePath)) {
     return [];
   }
   const maxBytes = options?.maxBytes ?? MAX_TAIL_BYTES2;
   let raw;
   let tailTruncated = false;
   try {
-    const stat5 = fs14.statSync(filePath);
+    const stat5 = fs15.statSync(filePath);
     if (Number.isFinite(maxBytes) && stat5.size > maxBytes) {
-      const fd = fs14.openSync(filePath, "r");
+      const fd = fs15.openSync(filePath, "r");
       try {
         const buf = Buffer.alloc(maxBytes);
         const offset = stat5.size - maxBytes;
-        fs14.readSync(fd, buf, 0, maxBytes, offset);
+        fs15.readSync(fd, buf, 0, maxBytes, offset);
         raw = buf.toString("utf-8");
         tailTruncated = true;
       } finally {
         try {
-          fs14.closeSync(fd);
+          fs15.closeSync(fd);
         } catch {}
       }
     } else {
-      raw = fs14.readFileSync(filePath, "utf-8");
+      raw = fs15.readFileSync(filePath, "utf-8");
     }
   } catch {
     return [];
@@ -15624,16 +15964,16 @@ function readDivergenceHistory(directory, options) {
 }
 
 // src/turbo/epic/promotion-evidence.ts
-import * as fs15 from "fs";
-import * as path34 from "path";
-var EVIDENCE_REL_DIR2 = path34.join(".swarm", "evidence");
+import * as fs16 from "fs";
+import * as path35 from "path";
+var EVIDENCE_REL_DIR2 = path35.join(".swarm", "evidence");
 var EVIDENCE_FILE2 = "epic-promotions.jsonl";
 function readPromotionEvidence(directory) {
-  const filePath = path34.join(directory, EVIDENCE_REL_DIR2, EVIDENCE_FILE2);
-  if (!fs15.existsSync(filePath)) {
+  const filePath = path35.join(directory, EVIDENCE_REL_DIR2, EVIDENCE_FILE2);
+  if (!fs16.existsSync(filePath)) {
     return [];
   }
-  const raw = fs15.readFileSync(filePath, "utf-8");
+  const raw = fs16.readFileSync(filePath, "utf-8");
   const lines = raw.split(`
 `).filter((l) => l.trim().length > 0);
   const records = [];
@@ -16202,8 +16542,8 @@ async function handleExportCommand(directory, _args) {
 }
 // src/full-auto/state.ts
 var import_proper_lockfile4 = __toESM(require_proper_lockfile(), 1);
-import * as fs16 from "fs";
-import * as path35 from "path";
+import * as fs17 from "fs";
+import * as path36 from "path";
 init_logger();
 var lockfile4 = import_proper_lockfile4.default;
 var STATE_FILE2 = "full-auto-state.json";
@@ -16211,9 +16551,9 @@ function nowISO2() {
   return new Date().toISOString();
 }
 function ensureSwarmDir(directory) {
-  const swarmDir = path35.resolve(directory, ".swarm");
-  if (!fs16.existsSync(swarmDir)) {
-    fs16.mkdirSync(swarmDir, { recursive: true });
+  const swarmDir = path36.resolve(directory, ".swarm");
+  if (!fs17.existsSync(swarmDir)) {
+    fs17.mkdirSync(swarmDir, { recursive: true });
   }
   return swarmDir;
 }
@@ -16271,7 +16611,7 @@ function withStateLock(directory, fn) {
   let release;
   try {
     const lockTarget = validateSwarmPath(directory, STATE_FILE2);
-    if (!fs16.existsSync(lockTarget)) {
+    if (!fs17.existsSync(lockTarget)) {
       ensureSwarmDir(directory);
       const seed = {
         version: 2,
@@ -16279,7 +16619,7 @@ function withStateLock(directory, fn) {
         oversightSequence: 0,
         sessions: {}
       };
-      fs16.writeFileSync(lockTarget, `${JSON.stringify(seed, null, 2)}
+      fs17.writeFileSync(lockTarget, `${JSON.stringify(seed, null, 2)}
 `, "utf-8");
     }
     release = lockfile4.lockSync(lockTarget, {
@@ -16329,7 +16669,7 @@ function readPersisted(directory) {
     const filePath = validateSwarmPath(directory, STATE_FILE2);
     let stats;
     try {
-      stats = fs16.statSync(filePath);
+      stats = fs17.statSync(filePath);
     } catch {
       clearStateUnreadable();
       readCache.delete(filePath);
@@ -16340,7 +16680,7 @@ function readPersisted(directory) {
       clearStateUnreadable();
       return structuredClone(cached.state);
     }
-    const raw = fs16.readFileSync(filePath, "utf-8");
+    const raw = fs17.readFileSync(filePath, "utf-8");
     const parsed = JSON.parse(raw);
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed) || parsed.version !== 2 || !parsed.sessions || typeof parsed.sessions !== "object" || Array.isArray(parsed.sessions)) {
       markStateUnreadable(`malformed shape (version=${parsed?.version}, sessions type=${Array.isArray(parsed?.sessions) ? "array" : typeof parsed?.sessions})`);
@@ -16365,8 +16705,8 @@ function readPersisted(directory) {
     error(`[full-auto/state] Failed to read ${STATE_FILE2}: ${reason} \u2014 attempting .bak recovery`);
     try {
       const bakPath = validateSwarmPath(directory, `${STATE_FILE2}.bak`);
-      if (fs16.existsSync(bakPath)) {
-        const raw = fs16.readFileSync(bakPath, "utf-8");
+      if (fs17.existsSync(bakPath)) {
+        const raw = fs17.readFileSync(bakPath, "utf-8");
         const parsed = JSON.parse(raw);
         if (parsed?.version === 2 && parsed.sessions && !Array.isArray(parsed.sessions)) {
           warn(`[full-auto/state] Recovered from ${STATE_FILE2}.bak`);
@@ -16406,23 +16746,23 @@ function writePersisted(directory, persisted) {
     throw new Error(`Full-Auto state persistence prepare failed: ${msg}`);
   }
   try {
-    if (fs16.existsSync(filePath)) {
-      fs16.copyFileSync(filePath, bakPath);
+    if (fs17.existsSync(filePath)) {
+      fs17.copyFileSync(filePath, bakPath);
     }
   } catch {}
   try {
-    fs16.writeFileSync(tmpPath, payload, "utf-8");
+    fs17.writeFileSync(tmpPath, payload, "utf-8");
     try {
-      const fd = fs16.openSync(tmpPath, "r+");
+      const fd = fs17.openSync(tmpPath, "r+");
       try {
-        fs16.fsyncSync(fd);
+        fs17.fsyncSync(fd);
       } finally {
-        fs16.closeSync(fd);
+        fs17.closeSync(fd);
       }
     } catch {}
-    fs16.renameSync(tmpPath, filePath);
+    fs17.renameSync(tmpPath, filePath);
     readCache.delete(filePath);
-    const readback = fs16.readFileSync(filePath, "utf-8");
+    const readback = fs17.readFileSync(filePath, "utf-8");
     const parsed = JSON.parse(readback);
     if (parsed?.version !== 2) {
       throw new Error("Round-trip readback returned wrong version");
@@ -17023,7 +17363,7 @@ var _internals27 = {
 
 // src/session/snapshot-writer.ts
 import { closeSync as closeSync6, fsyncSync as fsyncSync2, mkdirSync as mkdirSync14, openSync as openSync6, renameSync as renameSync8 } from "fs";
-import * as path36 from "path";
+import * as path37 from "path";
 var _writeInFlight = Promise.resolve();
 function serializeAgentSession(s) {
   const gateLog = {};
@@ -17130,7 +17470,7 @@ async function writeSnapshot(directory, state) {
     }
     const content = JSON.stringify(snapshot, null, 2);
     const resolvedPath = validateSwarmPath(directory, "session/state.json");
-    const dir = path36.dirname(resolvedPath);
+    const dir = path37.dirname(resolvedPath);
     mkdirSync14(dir, { recursive: true });
     const tempPath = `${resolvedPath}.tmp.${Date.now()}.${Math.random().toString(36).slice(2)}`;
     await bunWrite(tempPath, content);
@@ -17633,7 +17973,7 @@ ${USAGE6}`;
 }
 
 // src/commands/knowledge.ts
-import { join as join30 } from "path";
+import { join as join31 } from "path";
 
 // src/hooks/knowledge-migrator.ts
 init_logger();
@@ -17641,7 +17981,7 @@ import { randomUUID as randomUUID4 } from "crypto";
 import { existsSync as existsSync22, readFileSync as readFileSync14 } from "fs";
 import { mkdir as mkdir9, readFile as readFile11, writeFile as writeFile9 } from "fs/promises";
 import * as os8 from "os";
-import * as path37 from "path";
+import * as path38 from "path";
 
 // src/hooks/knowledge-types.ts
 var KNOWLEDGE_SCHEMA_VERSION = 2;
@@ -17671,8 +18011,8 @@ var _internals30 = {
   resolveLegacyHiveKnowledgePath
 };
 async function migrateContextToKnowledge(directory, config) {
-  const sentinelPath = path37.join(directory, ".swarm", ".knowledge-migrated");
-  const contextPath = path37.join(directory, ".swarm", "context.md");
+  const sentinelPath = path38.join(directory, ".swarm", ".knowledge-migrated");
+  const contextPath = path38.join(directory, ".swarm", "context.md");
   const knowledgePath = resolveSwarmKnowledgePath(directory);
   if (existsSync22(sentinelPath)) {
     return {
@@ -17774,7 +18114,7 @@ async function migrateContextToKnowledge(directory, config) {
 async function migrateHiveKnowledgeLegacy(config) {
   const legacyHivePath = _internals30.resolveLegacyHiveKnowledgePath();
   const canonicalHivePath = resolveHiveKnowledgePath();
-  const sentinelPath = path37.join(path37.dirname(canonicalHivePath), ".hive-knowledge-migrated");
+  const sentinelPath = path38.join(path38.dirname(canonicalHivePath), ".hive-knowledge-migrated");
   if (existsSync22(sentinelPath)) {
     return {
       migrated: false,
@@ -17985,7 +18325,7 @@ function truncateLesson2(text) {
   return `${text.slice(0, 277)}...`;
 }
 function inferProjectName(directory) {
-  const packageJsonPath = path37.join(directory, "package.json");
+  const packageJsonPath = path38.join(directory, "package.json");
   if (existsSync22(packageJsonPath)) {
     try {
       const pkg = JSON.parse(readFileSync14(packageJsonPath, "utf-8"));
@@ -17994,7 +18334,7 @@ function inferProjectName(directory) {
       }
     } catch {}
   }
-  return path37.basename(directory);
+  return path38.basename(directory);
 }
 async function writeSentinel(sentinelPath, migrated, dropped) {
   const sentinel = {
@@ -18006,7 +18346,7 @@ async function writeSentinel(sentinelPath, migrated, dropped) {
     schema_version: 1,
     migration_tool: "knowledge-migrator.ts"
   };
-  await mkdir9(path37.dirname(sentinelPath), { recursive: true });
+  await mkdir9(path38.dirname(sentinelPath), { recursive: true });
   await writeFile9(sentinelPath, JSON.stringify(sentinel, null, 2), "utf-8");
 }
 function resolveLegacyHiveKnowledgePath() {
@@ -18014,13 +18354,13 @@ function resolveLegacyHiveKnowledgePath() {
   const home = process.env.HOME || os8.homedir();
   let dataDir;
   if (platform === "win32") {
-    dataDir = path37.join(process.env.LOCALAPPDATA || path37.join(home, "AppData", "Local"), "opencode-swarm", "Data");
+    dataDir = path38.join(process.env.LOCALAPPDATA || path38.join(home, "AppData", "Local"), "opencode-swarm", "Data");
   } else if (platform === "darwin") {
-    dataDir = path37.join(home, "Library", "Application Support", "opencode-swarm");
+    dataDir = path38.join(home, "Library", "Application Support", "opencode-swarm");
   } else {
-    dataDir = path37.join(process.env.XDG_DATA_HOME || path37.join(home, ".local", "share"), "opencode-swarm");
+    dataDir = path38.join(process.env.XDG_DATA_HOME || path38.join(home, ".local", "share"), "opencode-swarm");
   }
-  return path37.join(dataDir, "hive-knowledge.jsonl");
+  return path38.join(dataDir, "hive-knowledge.jsonl");
 }
 
 // src/commands/knowledge.ts
@@ -18074,7 +18414,7 @@ async function handleKnowledgeRestoreCommand(directory, args) {
     return "Invalid entry ID. IDs must be 1-64 characters: letters, digits, hyphens, underscores only.";
   }
   try {
-    const quarantinePath = join30(resolveKnowledgeStoreDir(directory), "knowledge-quarantined.jsonl");
+    const quarantinePath = join31(resolveKnowledgeStoreDir(directory), "knowledge-quarantined.jsonl");
     const entries = await readKnowledge(quarantinePath);
     const resolved = resolveEntryByPrefix(entries, inputId);
     if ("error" in resolved) {
@@ -18326,14 +18666,14 @@ var _internals31 = {
 
 // src/commands/link.ts
 import { existsSync as existsSync23 } from "fs";
-import * as path39 from "path";
+import * as path40 from "path";
 
 // src/knowledge/identity.ts
 import * as child_process5 from "child_process";
 import { createHash as createHash4 } from "crypto";
-import * as path38 from "path";
+import * as path39 from "path";
 function deriveProjectHash(directory) {
-  const absolutePath = path38.resolve(directory);
+  const absolutePath = path39.resolve(directory);
   let hashInput;
   try {
     const remoteUrl = child_process5.execSync("git remote get-url origin", {
@@ -18353,8 +18693,8 @@ function deriveProjectHash(directory) {
 // src/commands/link.ts
 var DEDUP_THRESHOLD = 0.6;
 async function mergeLocalKnowledgeIntoLink(localSwarmDir, linkDir) {
-  const localPath = path39.join(localSwarmDir, "knowledge.jsonl");
-  const sharedPath = path39.join(linkDir, "knowledge.jsonl");
+  const localPath = path40.join(localSwarmDir, "knowledge.jsonl");
+  const sharedPath = path40.join(linkDir, "knowledge.jsonl");
   if (!existsSync23(localPath))
     return { merged: 0, skipped: 0 };
   let merged = 0;
@@ -18452,7 +18792,7 @@ ${formatStatus(directory)}`;
   const linkDir = resolveLinkDir(linkId);
   let merge;
   try {
-    merge = await mergeLocalKnowledgeIntoLink(path39.join(directory, ".swarm"), linkDir);
+    merge = await mergeLocalKnowledgeIntoLink(path40.join(directory, ".swarm"), linkDir);
   } catch (error2) {
     return `\u274C Failed to merge local knowledge into the link store: ${error2 instanceof Error ? error2.message : String(error2)}`;
   }
@@ -18597,7 +18937,7 @@ ${USAGE7}`;
 
 // src/commands/memory.ts
 import { existsSync as existsSync26 } from "fs";
-import * as path46 from "path";
+import * as path47 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/memory/config.ts
@@ -18737,9 +19077,9 @@ class MemoryValidationError extends Error {
   }
 }
 // src/memory/evaluation.ts
-import * as fs17 from "fs/promises";
+import * as fs18 from "fs/promises";
 import * as os9 from "os";
-import * as path44 from "path";
+import * as path45 from "path";
 
 // src/memory/local-jsonl-provider.ts
 import { randomUUID as randomUUID5 } from "crypto";
@@ -18751,7 +19091,7 @@ import {
   rename as rename5,
   writeFile as writeFile10
 } from "fs/promises";
-import * as path40 from "path";
+import * as path41 from "path";
 
 // src/memory/schema.ts
 import { createHash as createHash5 } from "crypto";
@@ -19612,7 +19952,7 @@ class LocalJsonlMemoryProvider {
   pathFor(file) {
     const storageDir = this.config.storageDir.replace(/^\.swarm[/\\]?/, "");
     const filename = file === "memories" ? "memories.jsonl" : file === "proposals" ? "proposals.jsonl" : "audit.jsonl";
-    return validateSwarmPath(this.rootDirectory, path40.join(storageDir, filename));
+    return validateSwarmPath(this.rootDirectory, path41.join(storageDir, filename));
   }
   async initialize() {
     if (this.initialized)
@@ -19995,12 +20335,12 @@ function parseRecallUsageEvent(event) {
   }
 }
 async function appendJsonl(filePath, value) {
-  await mkdir10(path40.dirname(filePath), { recursive: true });
+  await mkdir10(path41.dirname(filePath), { recursive: true });
   await appendFile3(filePath, `${JSON.stringify(value)}
 `, "utf-8");
 }
 async function writeJsonlAtomic(filePath, values) {
-  await mkdir10(path40.dirname(filePath), { recursive: true });
+  await mkdir10(path41.dirname(filePath), { recursive: true });
   const tmp = `${filePath}.tmp.${randomUUID5()}`;
   const content = values.map((value) => JSON.stringify(value)).join(`
 `) + (values.length > 0 ? `
@@ -20011,18 +20351,18 @@ async function writeJsonlAtomic(filePath, values) {
 
 // src/memory/provider-pool.ts
 import { realpathSync as realpathSync2 } from "fs";
-import * as path43 from "path";
+import * as path44 from "path";
 
 // src/memory/sqlite-provider.ts
 import { randomUUID as randomUUID6 } from "crypto";
 import { mkdirSync as mkdirSync15 } from "fs";
 import { createRequire as createRequire2 } from "module";
-import * as path42 from "path";
+import * as path43 from "path";
 
 // src/memory/jsonl-migration.ts
 import { existsSync as existsSync25, renameSync as renameSync10, unlinkSync as unlinkSync6 } from "fs";
 import { copyFile as copyFile2, mkdir as mkdir11, readFile as readFile13, stat as stat5, writeFile as writeFile11 } from "fs/promises";
-import * as path41 from "path";
+import * as path42 from "path";
 var LEGACY_JSONL_MIGRATION_VERSION = 2;
 var LEGACY_JSONL_MIGRATION_NAME = "legacy_jsonl_import_complete";
 function resolveMemoryStorageDir(rootDirectory, config = {}) {
@@ -20038,8 +20378,8 @@ function resolveSqliteDatabasePath(rootDirectory, config = {}) {
 async function readLegacyJsonl(rootDirectory, config = {}) {
   const resolved = resolveConfig(config);
   const storageDir = resolveMemoryStorageDir(rootDirectory, resolved);
-  const memoryLoad = await readMemoryJsonl(path41.join(storageDir, "memories.jsonl"), resolved);
-  const proposalLoad = await readProposalJsonl(path41.join(storageDir, "proposals.jsonl"), resolved);
+  const memoryLoad = await readMemoryJsonl(path42.join(storageDir, "memories.jsonl"), resolved);
+  const proposalLoad = await readProposalJsonl(path42.join(storageDir, "proposals.jsonl"), resolved);
   return {
     memories: memoryLoad.records,
     proposals: proposalLoad.records,
@@ -20049,14 +20389,14 @@ async function readLegacyJsonl(rootDirectory, config = {}) {
 }
 async function backupLegacyJsonl(rootDirectory, config = {}) {
   const storageDir = resolveMemoryStorageDir(rootDirectory, config);
-  const backupDir = path41.join(storageDir, "backups");
+  const backupDir = path42.join(storageDir, "backups");
   await mkdir11(backupDir, { recursive: true });
   const results = [];
   for (const filename of ["memories.jsonl", "proposals.jsonl"]) {
-    const source = path41.join(storageDir, filename);
+    const source = path42.join(storageDir, filename);
     if (!existsSync25(source))
       continue;
-    const backup = path41.join(backupDir, `${filename}.pre-sqlite-migration`);
+    const backup = path42.join(backupDir, `${filename}.pre-sqlite-migration`);
     if (existsSync25(backup)) {
       results.push({ source, backup, created: false });
       continue;
@@ -20067,11 +20407,11 @@ async function backupLegacyJsonl(rootDirectory, config = {}) {
   return results;
 }
 async function writeJsonlExport(rootDirectory, config, memories, proposals) {
-  const exportDir = path41.join(resolveMemoryStorageDir(rootDirectory, config), "export");
+  const exportDir = path42.join(resolveMemoryStorageDir(rootDirectory, config), "export");
   await mkdir11(exportDir, { recursive: true });
-  const memoriesPath = path41.join(exportDir, "memories.jsonl");
-  const proposalsPath = path41.join(exportDir, "proposals.jsonl");
-  const memoriesTempPath = path41.join(path41.dirname(memoriesPath), `${path41.basename(memoriesPath)}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+  const memoriesPath = path42.join(exportDir, "memories.jsonl");
+  const proposalsPath = path42.join(exportDir, "proposals.jsonl");
+  const memoriesTempPath = path42.join(path42.dirname(memoriesPath), `${path42.basename(memoriesPath)}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
   try {
     await writeFile11(memoriesTempPath, toJsonl(memories), "utf-8");
     renameSync10(memoriesTempPath, memoriesPath);
@@ -20081,7 +20421,7 @@ async function writeJsonlExport(rootDirectory, config, memories, proposals) {
     } catch {}
     throw err;
   }
-  const proposalsTempPath = path41.join(path41.dirname(proposalsPath), `${path41.basename(proposalsPath)}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+  const proposalsTempPath = path42.join(path42.dirname(proposalsPath), `${path42.basename(proposalsPath)}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
   try {
     await writeFile11(proposalsTempPath, toJsonl(proposals), "utf-8");
     renameSync10(proposalsTempPath, proposalsPath);
@@ -20094,9 +20434,9 @@ async function writeJsonlExport(rootDirectory, config, memories, proposals) {
   return { directory: exportDir, memoriesPath, proposalsPath };
 }
 async function writeMigrationReport(rootDirectory, report, config = {}) {
-  const reportPath = path41.join(resolveMemoryStorageDir(rootDirectory, config), "migration-report.json");
-  await mkdir11(path41.dirname(reportPath), { recursive: true });
-  const reportTempPath = path41.join(path41.dirname(reportPath), `${path41.basename(reportPath)}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+  const reportPath = path42.join(resolveMemoryStorageDir(rootDirectory, config), "migration-report.json");
+  await mkdir11(path42.dirname(reportPath), { recursive: true });
+  const reportTempPath = path42.join(path42.dirname(reportPath), `${path42.basename(reportPath)}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
   try {
     await writeFile11(reportTempPath, `${JSON.stringify(report, null, 2)}
 `, "utf-8");
@@ -20110,7 +20450,7 @@ async function writeMigrationReport(rootDirectory, report, config = {}) {
   return reportPath;
 }
 async function readMigrationReport(rootDirectory, config = {}) {
-  const reportPath = path41.join(resolveMemoryStorageDir(rootDirectory, config), "migration-report.json");
+  const reportPath = path42.join(resolveMemoryStorageDir(rootDirectory, config), "migration-report.json");
   if (!existsSync25(reportPath))
     return null;
   try {
@@ -20123,7 +20463,7 @@ async function getLegacyJsonlFileStatus(rootDirectory, config = {}) {
   const storageDir = resolveMemoryStorageDir(rootDirectory, config);
   const statuses = [];
   for (const file of ["memories.jsonl", "proposals.jsonl"]) {
-    const filePath = path41.join(storageDir, file);
+    const filePath = path42.join(storageDir, file);
     let sizeBytes = 0;
     if (existsSync25(filePath)) {
       sizeBytes = (await stat5(filePath)).size;
@@ -20431,7 +20771,7 @@ class SQLiteMemoryProvider {
   }
   async doInitialize() {
     const dbPath = this.databasePath();
-    mkdirSync15(path42.dirname(dbPath), { recursive: true });
+    mkdirSync15(path43.dirname(dbPath), { recursive: true });
     const Db = loadDatabaseCtor2();
     this.db = new Db(dbPath);
     this.db.run("PRAGMA journal_mode = WAL;");
@@ -21460,7 +21800,7 @@ function resolvePoolKey(directory) {
   try {
     return realpathSync2(directory);
   } catch {
-    return path43.resolve(directory);
+    return path44.resolve(directory);
   }
 }
 
@@ -21532,7 +21872,7 @@ var DEFAULT_MODES = [
 ];
 var DEFAULT_TIMESTAMP = "2026-05-26T12:00:00.000Z";
 async function evaluateMemoryRecallFixtures(options) {
-  const fixtureDirectory = path44.resolve(options.fixtureDirectory);
+  const fixtureDirectory = path45.resolve(options.fixtureDirectory);
   const providers = options.providers ?? DEFAULT_PROVIDERS;
   const modes = options.modes ?? DEFAULT_MODES;
   const generatedAt = new Date().toISOString();
@@ -21541,7 +21881,7 @@ async function evaluateMemoryRecallFixtures(options) {
   for (const fixture of fixtures) {
     const materialized = materializeFixture(fixture);
     for (const providerName of providers) {
-      const tempRoot = await fs17.realpath(await fs17.mkdtemp(path44.join(os9.tmpdir(), "swarm-memory-eval-")));
+      const tempRoot = await fs18.realpath(await fs18.mkdtemp(path45.join(os9.tmpdir(), "swarm-memory-eval-")));
       const provider = createEvaluationProvider(providerName, tempRoot);
       try {
         await provider.initialize?.();
@@ -21565,7 +21905,7 @@ async function evaluateMemoryRecallFixtures(options) {
       } finally {
         await provider.close?.();
         if (!options.keepTempRoots) {
-          await fs17.rm(tempRoot, { recursive: true, force: true });
+          await fs18.rm(tempRoot, { recursive: true, force: true });
         }
       }
     }
@@ -21581,11 +21921,11 @@ async function evaluateMemoryRecallFixtures(options) {
   };
 }
 async function loadRecallEvaluationFixtures(fixtureDirectory) {
-  const entries = await fs17.readdir(fixtureDirectory, { withFileTypes: true });
+  const entries = await fs18.readdir(fixtureDirectory, { withFileTypes: true });
   const files = entries.filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => entry.name).sort((a, b) => a.localeCompare(b));
   const fixtures = [];
   for (const file of files) {
-    const raw = await fs17.readFile(path44.join(fixtureDirectory, file), "utf-8");
+    const raw = await fs18.readFile(path45.join(fixtureDirectory, file), "utf-8");
     fixtures.push(validateFixture(JSON.parse(raw), file));
   }
   return fixtures;
@@ -21862,8 +22202,8 @@ var CuratorOutputMemoryDecisionSchema = exports_external.object({
 }).passthrough();
 // src/memory/consolidation-log.ts
 import { appendFile as appendFile4, mkdir as mkdir12, readFile as readFile15 } from "fs/promises";
-import * as path45 from "path";
-var LOG_RELATIVE_PATH = path45.join("memory", "consolidation-log.jsonl");
+import * as path46 from "path";
+var LOG_RELATIVE_PATH = path46.join("memory", "consolidation-log.jsonl");
 async function readConsolidationLog(directory) {
   const filePath = validateSwarmPath(directory, LOG_RELATIVE_PATH);
   let raw;
@@ -21886,7 +22226,7 @@ async function readConsolidationLog(directory) {
 }
 
 // src/commands/memory.ts
-var PACKAGE_ROOT = path46.resolve(resolvePackageRootFromModule(fileURLToPath2(import.meta.url)));
+var PACKAGE_ROOT = path47.resolve(resolvePackageRootFromModule(fileURLToPath2(import.meta.url)));
 async function handleMemoryCommand(_directory, _args) {
   return [
     "## Swarm Memory",
@@ -22184,7 +22524,7 @@ function resolveCommandMemoryConfig(directory) {
 }
 function parseEvaluateArgs(directory, args) {
   let json = false;
-  let fixtureDirectory = path46.join(PACKAGE_ROOT, "tests", "fixtures", "memory-recall");
+  let fixtureDirectory = path47.join(PACKAGE_ROOT, "tests", "fixtures", "memory-recall");
   for (let i = 0;i < args.length; i++) {
     const arg = args[i];
     if (arg === "--json") {
@@ -22198,10 +22538,10 @@ function parseEvaluateArgs(directory, args) {
           error: "Usage: /swarm memory evaluate [--json] [--fixtures <directory>]"
         };
       }
-      const resolvedFixtures = path46.resolve(directory, next);
-      const canonical = path46.normalize(resolvedFixtures) + path46.sep;
-      const allowedRootA = path46.normalize(directory) + path46.sep;
-      const allowedRootB = path46.normalize(path46.join(PACKAGE_ROOT, "tests", "fixtures", "memory-recall")) + path46.sep;
+      const resolvedFixtures = path47.resolve(directory, next);
+      const canonical = path47.normalize(resolvedFixtures) + path47.sep;
+      const allowedRootA = path47.normalize(directory) + path47.sep;
+      const allowedRootB = path47.normalize(path47.join(PACKAGE_ROOT, "tests", "fixtures", "memory-recall")) + path47.sep;
       if (!canonical.startsWith(allowedRootA) && !canonical.startsWith(allowedRootB)) {
         return {
           error: "--fixtures <directory> must resolve under the project directory or the bundled tests/fixtures/memory-recall directory"
@@ -22240,15 +22580,15 @@ function parseMaintenanceArgs(args, options) {
   return { limit, confirm };
 }
 function resolvePackageRootFromModule(modulePath) {
-  const moduleDir = path46.dirname(modulePath);
-  const leaf = path46.basename(moduleDir);
+  const moduleDir = path47.dirname(modulePath);
+  const leaf = path47.basename(moduleDir);
   if (leaf === "commands" || leaf === "cli") {
-    return path46.resolve(moduleDir, "..", "..");
+    return path47.resolve(moduleDir, "..", "..");
   }
   if (leaf === "dist") {
-    return path46.resolve(moduleDir, "..");
+    return path47.resolve(moduleDir, "..");
   }
-  return path46.resolve(moduleDir, "..");
+  return path47.resolve(moduleDir, "..");
 }
 function formatMigrationResult(label, report) {
   if (!report) {
@@ -22942,12 +23282,12 @@ var _internals36 = {
 };
 
 // src/services/preflight-service.ts
-import * as fs24 from "fs";
-import * as path53 from "path";
+import * as fs25 from "fs";
+import * as path54 from "path";
 
 // src/tools/lint.ts
-import * as fs18 from "fs";
-import * as path47 from "path";
+import * as fs19 from "fs";
+import * as path48 from "path";
 
 // src/utils/path-security.ts
 function containsPathTraversal(str) {
@@ -23003,9 +23343,9 @@ function validateArgs(args) {
 }
 function getLinterCommand(linter, mode, projectDir) {
   const isWindows = process.platform === "win32";
-  const binDir = path47.join(projectDir, "node_modules", ".bin");
-  const biomeBin = isWindows ? path47.join(binDir, "biome.EXE") : path47.join(binDir, "biome");
-  const eslintBin = isWindows ? path47.join(binDir, "eslint.cmd") : path47.join(binDir, "eslint");
+  const binDir = path48.join(projectDir, "node_modules", ".bin");
+  const biomeBin = isWindows ? path48.join(binDir, "biome.EXE") : path48.join(binDir, "biome");
+  const eslintBin = isWindows ? path48.join(binDir, "eslint.cmd") : path48.join(binDir, "eslint");
   switch (linter) {
     case "biome":
       if (mode === "fix") {
@@ -23021,7 +23361,7 @@ function getLinterCommand(linter, mode, projectDir) {
 }
 function getAdditionalLinterCommand(linter, mode, cwd) {
   const gradlewName = process.platform === "win32" ? "gradlew.bat" : "gradlew";
-  const gradlew = fs18.existsSync(path47.join(cwd, gradlewName)) ? path47.join(cwd, gradlewName) : null;
+  const gradlew = fs19.existsSync(path48.join(cwd, gradlewName)) ? path48.join(cwd, gradlewName) : null;
   switch (linter) {
     case "ruff":
       return mode === "fix" ? ["ruff", "check", "--fix", "."] : ["ruff", "check", "."];
@@ -23055,12 +23395,12 @@ function getAdditionalLinterCommand(linter, mode, cwd) {
   }
 }
 function detectRuff(cwd) {
-  if (fs18.existsSync(path47.join(cwd, "ruff.toml")))
+  if (fs19.existsSync(path48.join(cwd, "ruff.toml")))
     return isCommandAvailable("ruff");
   try {
-    const pyproject = path47.join(cwd, "pyproject.toml");
-    if (fs18.existsSync(pyproject)) {
-      const content = fs18.readFileSync(pyproject, "utf-8");
+    const pyproject = path48.join(cwd, "pyproject.toml");
+    if (fs19.existsSync(pyproject)) {
+      const content = fs19.readFileSync(pyproject, "utf-8");
       if (content.includes("[tool.ruff]"))
         return isCommandAvailable("ruff");
     }
@@ -23068,21 +23408,21 @@ function detectRuff(cwd) {
   return false;
 }
 function detectClippy(cwd) {
-  return fs18.existsSync(path47.join(cwd, "Cargo.toml")) && isCommandAvailable("cargo");
+  return fs19.existsSync(path48.join(cwd, "Cargo.toml")) && isCommandAvailable("cargo");
 }
 function detectGolangciLint(cwd) {
-  return fs18.existsSync(path47.join(cwd, "go.mod")) && isCommandAvailable("golangci-lint");
+  return fs19.existsSync(path48.join(cwd, "go.mod")) && isCommandAvailable("golangci-lint");
 }
 function detectCheckstyle(cwd) {
-  const hasMaven = fs18.existsSync(path47.join(cwd, "pom.xml"));
-  const hasGradle = fs18.existsSync(path47.join(cwd, "build.gradle")) || fs18.existsSync(path47.join(cwd, "build.gradle.kts"));
-  const hasBinary = hasMaven && isCommandAvailable("mvn") || hasGradle && (fs18.existsSync(path47.join(cwd, "gradlew")) || isCommandAvailable("gradle"));
+  const hasMaven = fs19.existsSync(path48.join(cwd, "pom.xml"));
+  const hasGradle = fs19.existsSync(path48.join(cwd, "build.gradle")) || fs19.existsSync(path48.join(cwd, "build.gradle.kts"));
+  const hasBinary = hasMaven && isCommandAvailable("mvn") || hasGradle && (fs19.existsSync(path48.join(cwd, "gradlew")) || isCommandAvailable("gradle"));
   return (hasMaven || hasGradle) && hasBinary;
 }
 function detectKtlint(cwd) {
-  const hasKotlin = fs18.existsSync(path47.join(cwd, "build.gradle.kts")) || fs18.existsSync(path47.join(cwd, "build.gradle")) || (() => {
+  const hasKotlin = fs19.existsSync(path48.join(cwd, "build.gradle.kts")) || fs19.existsSync(path48.join(cwd, "build.gradle")) || (() => {
     try {
-      return fs18.readdirSync(cwd).some((f) => f.endsWith(".kt") || f.endsWith(".kts"));
+      return fs19.readdirSync(cwd).some((f) => f.endsWith(".kt") || f.endsWith(".kts"));
     } catch {
       return false;
     }
@@ -23091,7 +23431,7 @@ function detectKtlint(cwd) {
 }
 function detectDotnetFormat(cwd) {
   try {
-    const files = fs18.readdirSync(cwd);
+    const files = fs19.readdirSync(cwd);
     const hasCsproj = files.some((f) => f.endsWith(".csproj") || f.endsWith(".sln"));
     return hasCsproj && isCommandAvailable("dotnet");
   } catch {
@@ -23099,14 +23439,14 @@ function detectDotnetFormat(cwd) {
   }
 }
 function detectCppcheck(cwd) {
-  if (fs18.existsSync(path47.join(cwd, "CMakeLists.txt"))) {
+  if (fs19.existsSync(path48.join(cwd, "CMakeLists.txt"))) {
     return isCommandAvailable("cppcheck");
   }
   try {
-    const dirsToCheck = [cwd, path47.join(cwd, "src")];
+    const dirsToCheck = [cwd, path48.join(cwd, "src")];
     const hasCpp = dirsToCheck.some((dir) => {
       try {
-        return fs18.readdirSync(dir).some((f) => /\.(c|cpp|cc|cxx|h|hpp)$/.test(f));
+        return fs19.readdirSync(dir).some((f) => /\.(c|cpp|cc|cxx|h|hpp)$/.test(f));
       } catch {
         return false;
       }
@@ -23117,13 +23457,13 @@ function detectCppcheck(cwd) {
   }
 }
 function detectSwiftlint(cwd) {
-  return fs18.existsSync(path47.join(cwd, "Package.swift")) && isCommandAvailable("swiftlint");
+  return fs19.existsSync(path48.join(cwd, "Package.swift")) && isCommandAvailable("swiftlint");
 }
 function detectDartAnalyze(cwd) {
-  return fs18.existsSync(path47.join(cwd, "pubspec.yaml")) && (isCommandAvailable("dart") || isCommandAvailable("flutter"));
+  return fs19.existsSync(path48.join(cwd, "pubspec.yaml")) && (isCommandAvailable("dart") || isCommandAvailable("flutter"));
 }
 function detectRubocop(cwd) {
-  return (fs18.existsSync(path47.join(cwd, "Gemfile")) || fs18.existsSync(path47.join(cwd, "gems.rb")) || fs18.existsSync(path47.join(cwd, ".rubocop.yml"))) && (isCommandAvailable("rubocop") || isCommandAvailable("bundle"));
+  return (fs19.existsSync(path48.join(cwd, "Gemfile")) || fs19.existsSync(path48.join(cwd, "gems.rb")) || fs19.existsSync(path48.join(cwd, ".rubocop.yml"))) && (isCommandAvailable("rubocop") || isCommandAvailable("bundle"));
 }
 function detectAdditionalLinter(cwd) {
   if (detectRuff(cwd))
@@ -23151,10 +23491,10 @@ function detectAdditionalLinter(cwd) {
 function findBinInAncestors(startDir, binName) {
   let dir = startDir;
   while (true) {
-    const candidate = path47.join(dir, "node_modules", ".bin", binName);
-    if (fs18.existsSync(candidate))
+    const candidate = path48.join(dir, "node_modules", ".bin", binName);
+    if (fs19.existsSync(candidate))
       return candidate;
-    const parent = path47.dirname(dir);
+    const parent = path48.dirname(dir);
     if (parent === dir)
       break;
     dir = parent;
@@ -23163,11 +23503,11 @@ function findBinInAncestors(startDir, binName) {
 }
 function findBinInEnvPath(binName) {
   const searchPath = process.env.PATH ?? "";
-  for (const dir of searchPath.split(path47.delimiter)) {
+  for (const dir of searchPath.split(path48.delimiter)) {
     if (!dir)
       continue;
-    const candidate = path47.join(dir, binName);
-    if (fs18.existsSync(candidate))
+    const candidate = path48.join(dir, binName);
+    if (fs19.existsSync(candidate))
       return candidate;
   }
   return null;
@@ -23175,17 +23515,17 @@ function findBinInEnvPath(binName) {
 async function detectAvailableLinter(directory) {
   if (!directory)
     return null;
-  if (!fs18.existsSync(directory))
+  if (!fs19.existsSync(directory))
     return null;
   const projectDir = directory;
   const isWindows = process.platform === "win32";
-  const biomeBin = isWindows ? path47.join(projectDir, "node_modules", ".bin", "biome.EXE") : path47.join(projectDir, "node_modules", ".bin", "biome");
-  const eslintBin = isWindows ? path47.join(projectDir, "node_modules", ".bin", "eslint.cmd") : path47.join(projectDir, "node_modules", ".bin", "eslint");
+  const biomeBin = isWindows ? path48.join(projectDir, "node_modules", ".bin", "biome.EXE") : path48.join(projectDir, "node_modules", ".bin", "biome");
+  const eslintBin = isWindows ? path48.join(projectDir, "node_modules", ".bin", "eslint.cmd") : path48.join(projectDir, "node_modules", ".bin", "eslint");
   const localResult = await _detectAvailableLinter(projectDir, biomeBin, eslintBin);
   if (localResult)
     return localResult;
-  const biomeAncestor = findBinInAncestors(path47.dirname(projectDir), isWindows ? "biome.EXE" : "biome");
-  const eslintAncestor = findBinInAncestors(path47.dirname(projectDir), isWindows ? "eslint.cmd" : "eslint");
+  const biomeAncestor = findBinInAncestors(path48.dirname(projectDir), isWindows ? "biome.EXE" : "biome");
+  const eslintAncestor = findBinInAncestors(path48.dirname(projectDir), isWindows ? "eslint.cmd" : "eslint");
   if (biomeAncestor || eslintAncestor) {
     return _detectAvailableLinter(projectDir, biomeAncestor ?? biomeBin, eslintAncestor ?? eslintBin);
   }
@@ -23208,7 +23548,7 @@ async function _detectAvailableLinter(_projectDir, biomeBin, eslintBin) {
     const result = await Promise.race([biomeExit, timeout]);
     if (result === "timeout") {
       biomeProc.kill();
-    } else if (biomeProc.exitCode === 0 && fs18.existsSync(biomeBin)) {
+    } else if (biomeProc.exitCode === 0 && fs19.existsSync(biomeBin)) {
       return "biome";
     }
   } catch {}
@@ -23222,7 +23562,7 @@ async function _detectAvailableLinter(_projectDir, biomeBin, eslintBin) {
     const result = await Promise.race([eslintExit, timeout]);
     if (result === "timeout") {
       eslintProc.kill();
-    } else if (eslintProc.exitCode === 0 && fs18.existsSync(eslintBin)) {
+    } else if (eslintProc.exitCode === 0 && fs19.existsSync(eslintBin)) {
       return "eslint";
     }
   } catch {}
@@ -23398,8 +23738,8 @@ var _internals37 = {
 };
 
 // src/tools/secretscan.ts
-import * as fs19 from "fs";
-import * as path48 from "path";
+import * as fs20 from "fs";
+import * as path49 from "path";
 var MAX_FILE_PATH_LENGTH = 500;
 var MAX_FILE_SIZE_BYTES = 512 * 1024;
 var MAX_FILES_SCANNED = 1000;
@@ -23626,11 +23966,11 @@ function isGlobOrPathPattern(pattern) {
   return pattern.includes("/") || pattern.includes("\\") || /[*?[\]{}]/.test(pattern);
 }
 function loadSecretScanIgnore(scanDir) {
-  const ignorePath = path48.join(scanDir, ".secretscanignore");
+  const ignorePath = path49.join(scanDir, ".secretscanignore");
   try {
-    if (!fs19.existsSync(ignorePath))
+    if (!fs20.existsSync(ignorePath))
       return [];
-    const content = fs19.readFileSync(ignorePath, "utf8");
+    const content = fs20.readFileSync(ignorePath, "utf8");
     const patterns = [];
     for (const rawLine of content.split(/\r?\n/)) {
       const line = rawLine.trim();
@@ -23649,7 +23989,7 @@ function isExcluded(entry, relPath, exactNames, globPatterns) {
   if (exactNames.has(entry))
     return true;
   for (const pattern of globPatterns) {
-    if (path48.matchesGlob(relPath, pattern))
+    if (path49.matchesGlob(relPath, pattern))
       return true;
   }
   return false;
@@ -23670,7 +24010,7 @@ function validateDirectoryInput(dir) {
   return null;
 }
 function isBinaryFile(filePath, buffer) {
-  const ext = path48.extname(filePath).toLowerCase();
+  const ext = path49.extname(filePath).toLowerCase();
   if (DEFAULT_EXCLUDE_EXTENSIONS.has(ext)) {
     return true;
   }
@@ -23745,11 +24085,11 @@ function createRedactedContext(line, findings) {
   result += line.slice(lastEnd);
   return result;
 }
-var O_NOFOLLOW = process.platform !== "win32" ? fs19.constants.O_NOFOLLOW : undefined;
+var O_NOFOLLOW = process.platform !== "win32" ? fs20.constants.O_NOFOLLOW : undefined;
 function scanFileForSecrets(filePath) {
   const findings = [];
   try {
-    const lstat2 = fs19.lstatSync(filePath);
+    const lstat2 = fs20.lstatSync(filePath);
     if (lstat2.isSymbolicLink()) {
       return findings;
     }
@@ -23758,14 +24098,14 @@ function scanFileForSecrets(filePath) {
     }
     let buffer;
     if (O_NOFOLLOW !== undefined) {
-      const fd = fs19.openSync(filePath, "r", O_NOFOLLOW);
+      const fd = fs20.openSync(filePath, "r", O_NOFOLLOW);
       try {
-        buffer = fs19.readFileSync(fd);
+        buffer = fs20.readFileSync(fd);
       } finally {
-        fs19.closeSync(fd);
+        fs20.closeSync(fd);
       }
     } else {
-      buffer = fs19.readFileSync(filePath);
+      buffer = fs20.readFileSync(filePath);
     }
     if (isBinaryFile(filePath, buffer)) {
       return findings;
@@ -23807,9 +24147,9 @@ function isSymlinkLoop(realPath, visited) {
   return false;
 }
 function isPathWithinScope(realPath, scanDir) {
-  const resolvedScanDir = path48.resolve(scanDir);
-  const resolvedRealPath = path48.resolve(realPath);
-  return resolvedRealPath === resolvedScanDir || resolvedRealPath.startsWith(resolvedScanDir + path48.sep) || resolvedRealPath.startsWith(`${resolvedScanDir}/`) || resolvedRealPath.startsWith(`${resolvedScanDir}\\`);
+  const resolvedScanDir = path49.resolve(scanDir);
+  const resolvedRealPath = path49.resolve(realPath);
+  return resolvedRealPath === resolvedScanDir || resolvedRealPath.startsWith(resolvedScanDir + path49.sep) || resolvedRealPath.startsWith(`${resolvedScanDir}/`) || resolvedRealPath.startsWith(`${resolvedScanDir}\\`);
 }
 function findScannableFiles(dir, excludeExact, excludeGlobs, scanDir, visited, stats = {
   skippedDirs: 0,
@@ -23820,7 +24160,7 @@ function findScannableFiles(dir, excludeExact, excludeGlobs, scanDir, visited, s
   const files = [];
   let entries;
   try {
-    entries = fs19.readdirSync(dir);
+    entries = fs20.readdirSync(dir);
   } catch {
     stats.fileErrors++;
     return files;
@@ -23835,15 +24175,15 @@ function findScannableFiles(dir, excludeExact, excludeGlobs, scanDir, visited, s
     return a.localeCompare(b);
   });
   for (const entry of entries) {
-    const fullPath = path48.join(dir, entry);
-    const relPath = path48.relative(scanDir, fullPath).replace(/\\/g, "/");
+    const fullPath = path49.join(dir, entry);
+    const relPath = path49.relative(scanDir, fullPath).replace(/\\/g, "/");
     if (isExcluded(entry, relPath, excludeExact, excludeGlobs)) {
       stats.skippedDirs++;
       continue;
     }
     let lstat2;
     try {
-      lstat2 = fs19.lstatSync(fullPath);
+      lstat2 = fs20.lstatSync(fullPath);
     } catch {
       stats.fileErrors++;
       continue;
@@ -23855,7 +24195,7 @@ function findScannableFiles(dir, excludeExact, excludeGlobs, scanDir, visited, s
     if (lstat2.isDirectory()) {
       let realPath;
       try {
-        realPath = fs19.realpathSync(fullPath);
+        realPath = fs20.realpathSync(fullPath);
       } catch {
         stats.fileErrors++;
         continue;
@@ -23871,7 +24211,7 @@ function findScannableFiles(dir, excludeExact, excludeGlobs, scanDir, visited, s
       const subFiles = findScannableFiles(fullPath, excludeExact, excludeGlobs, scanDir, visited, stats);
       files.push(...subFiles);
     } else if (lstat2.isFile()) {
-      const ext = path48.extname(fullPath).toLowerCase();
+      const ext = path49.extname(fullPath).toLowerCase();
       if (!DEFAULT_EXCLUDE_EXTENSIONS.has(ext)) {
         files.push(fullPath);
       } else {
@@ -23937,15 +24277,15 @@ var secretscan = createSwarmTool({
       }
     }
     try {
-      const _scanDirRaw = path48.resolve(directory);
+      const _scanDirRaw = path49.resolve(directory);
       const scanDir = (() => {
         try {
-          return fs19.realpathSync(_scanDirRaw);
+          return fs20.realpathSync(_scanDirRaw);
         } catch {
           return _scanDirRaw;
         }
       })();
-      if (!fs19.existsSync(scanDir)) {
+      if (!fs20.existsSync(scanDir)) {
         const errorResult = {
           error: "directory not found",
           scan_dir: directory,
@@ -23956,7 +24296,7 @@ var secretscan = createSwarmTool({
         };
         return JSON.stringify(errorResult, null, 2);
       }
-      const dirStat = fs19.statSync(scanDir);
+      const dirStat = fs20.statSync(scanDir);
       if (!dirStat.isDirectory()) {
         const errorResult = {
           error: "target must be a directory, not a file",
@@ -24007,7 +24347,7 @@ var secretscan = createSwarmTool({
           break;
         const fileFindings = scanFileForSecrets(filePath);
         try {
-          const stat6 = fs19.statSync(filePath);
+          const stat6 = fs20.statSync(filePath);
           if (stat6.size > MAX_FILE_SIZE_BYTES) {
             skippedFiles++;
             continue;
@@ -24099,12 +24439,12 @@ var _internals38 = {
 };
 
 // src/tools/test-runner.ts
-import * as fs23 from "fs";
-import * as path52 from "path";
+import * as fs24 from "fs";
+import * as path53 from "path";
 
 // src/test-impact/analyzer.ts
-import fs20 from "fs";
-import path49 from "path";
+import fs21 from "fs";
+import path50 from "path";
 var IMPORT_REGEX_ES = /import\s+[\s\S]*?\s+from\s+['"]([^'"]+)['"]/g;
 var IMPORT_REGEX_REQUIRE = /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
 var IMPORT_REGEX_REEXPORT = /export\s+(?:\{[^}]*\}|\*)\s+from\s+['"]([^'"]+)['"]/g;
@@ -24131,7 +24471,7 @@ function sharedTrailingSegments(a, b) {
 function isCacheStale(impactMap, generatedAtMs) {
   for (const sourcePath of Object.keys(impactMap)) {
     try {
-      const stat6 = fs20.statSync(sourcePath);
+      const stat6 = fs21.statSync(sourcePath);
       if (stat6.mtimeMs > generatedAtMs) {
         return true;
       }
@@ -24145,15 +24485,15 @@ function resolveRelativeImport(fromDir, importPath) {
   if (!importPath.startsWith(".")) {
     return null;
   }
-  const resolved = path49.resolve(fromDir, importPath);
-  if (path49.extname(resolved)) {
-    if (fs20.existsSync(resolved) && fs20.statSync(resolved).isFile()) {
+  const resolved = path50.resolve(fromDir, importPath);
+  if (path50.extname(resolved)) {
+    if (fs21.existsSync(resolved) && fs21.statSync(resolved).isFile()) {
       return normalizePath2(resolved);
     }
   } else {
     for (const ext of EXTENSIONS_TO_TRY) {
       const withExt = resolved + ext;
-      if (fs20.existsSync(withExt) && fs20.statSync(withExt).isFile()) {
+      if (fs21.existsSync(withExt) && fs21.statSync(withExt).isFile()) {
         return normalizePath2(withExt);
       }
     }
@@ -24166,30 +24506,30 @@ function resolvePythonImport(fromDir, module) {
   const leadingDots = module.match(/^\.+/)?.[0].length ?? 0;
   let baseDir = fromDir;
   for (let i = 1;i < leadingDots; i++) {
-    baseDir = path49.dirname(baseDir);
+    baseDir = path50.dirname(baseDir);
   }
   const rest = module.slice(leadingDots);
   if (rest.length === 0) {
-    const initPath = path49.join(baseDir, "__init__.py");
-    if (fs20.existsSync(initPath) && fs20.statSync(initPath).isFile()) {
+    const initPath = path50.join(baseDir, "__init__.py");
+    if (fs21.existsSync(initPath) && fs21.statSync(initPath).isFile()) {
       return normalizePath2(initPath);
     }
     return null;
   }
-  const subpath = rest.replace(/\./g, path49.sep);
+  const subpath = rest.replace(/\./g, path50.sep);
   const candidates = [
-    `${path49.join(baseDir, subpath)}.py`,
-    path49.join(baseDir, subpath, "__init__.py")
+    `${path50.join(baseDir, subpath)}.py`,
+    path50.join(baseDir, subpath, "__init__.py")
   ];
   for (const c of candidates) {
-    if (fs20.existsSync(c) && fs20.statSync(c).isFile())
+    if (fs21.existsSync(c) && fs21.statSync(c).isFile())
       return normalizePath2(c);
   }
   return null;
 }
 var goModuleCache = new Map;
 function findGoModule(fromDir) {
-  const resolved = path49.resolve(fromDir);
+  const resolved = path50.resolve(fromDir);
   let cur = resolved;
   const walked = [];
   for (let i = 0;i < 16; i++) {
@@ -24201,8 +24541,8 @@ function findGoModule(fromDir) {
     }
     walked.push(cur);
     try {
-      const goMod = path49.join(cur, "go.mod");
-      const content = fs20.readFileSync(goMod, "utf-8");
+      const goMod = path50.join(cur, "go.mod");
+      const content = fs21.readFileSync(goMod, "utf-8");
       const moduleMatch = content.match(/^\s*module\s+"?([^"\s/]+(?:\/[^"\s]+)*)"?/m);
       if (moduleMatch) {
         const result = { moduleRoot: cur, modulePath: moduleMatch[1] };
@@ -24212,10 +24552,10 @@ function findGoModule(fromDir) {
       }
     } catch {}
     try {
-      fs20.accessSync(path49.join(cur, ".git"));
+      fs21.accessSync(path50.join(cur, ".git"));
       break;
     } catch {}
-    const parent = path49.dirname(cur);
+    const parent = path50.dirname(cur);
     if (parent === cur)
       break;
     cur = parent;
@@ -24227,20 +24567,20 @@ function findGoModule(fromDir) {
 function resolveGoImport(fromDir, importPath) {
   let dir = null;
   if (importPath.startsWith(".")) {
-    dir = path49.resolve(fromDir, importPath);
+    dir = path50.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 = path49.join(mod.moduleRoot, subpath);
+      dir = path50.join(mod.moduleRoot, subpath);
     }
   }
   if (dir === null)
     return [];
-  if (!fs20.existsSync(dir) || !fs20.statSync(dir).isDirectory())
+  if (!fs21.existsSync(dir) || !fs21.statSync(dir).isDirectory())
     return [];
   try {
-    return fs20.readdirSync(dir).filter((f) => f.endsWith(".go") && !f.endsWith("_test.go")).map((f) => normalizePath2(path49.join(dir, f)));
+    return fs21.readdirSync(dir).filter((f) => f.endsWith(".go") && !f.endsWith("_test.go")).map((f) => normalizePath2(path50.join(dir, f)));
   } catch {
     return [];
   }
@@ -24260,13 +24600,13 @@ function findTestFilesSync(cwd) {
   function walk(dir, visitedInodes) {
     let entries;
     try {
-      entries = fs20.readdirSync(dir, { withFileTypes: true });
+      entries = fs21.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
     let dirInode;
     try {
-      dirInode = fs20.statSync(dir).ino;
+      dirInode = fs21.statSync(dir).ino;
     } catch {
       return;
     }
@@ -24279,15 +24619,15 @@ function findTestFilesSync(cwd) {
     for (const entry of entries) {
       if (entry.isDirectory()) {
         if (!skipDirs.has(entry.name)) {
-          walk(path49.join(dir, entry.name), visitedInodes);
+          walk(path50.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(`${path49.sep}tests${path49.sep}`) && name.endsWith(".py");
+        const isPyTest = /^test_.+\.py$/.test(name) || /.+_test\.py$/.test(name) || dir.includes(`${path50.sep}tests${path50.sep}`) && name.endsWith(".py");
         const isGoTest = /.+_test\.go$/.test(name);
         if (isTsTest || isPyTest || isGoTest) {
-          testFiles.push(normalizePath2(path49.join(dir, entry.name)));
+          testFiles.push(normalizePath2(path50.join(dir, entry.name)));
         }
       }
     }
@@ -24312,8 +24652,8 @@ function extractImports(content) {
   ];
 }
 function addImpactEdgesForTestFile(testFile, content, impactMap) {
-  const ext = path49.extname(testFile).toLowerCase();
-  const testDir = path49.dirname(testFile);
+  const ext = path50.extname(testFile).toLowerCase();
+  const testDir = path50.dirname(testFile);
   function addEdge(source) {
     if (!impactMap[source])
       impactMap[source] = [];
@@ -24355,7 +24695,7 @@ async function buildImpactMapInternal(cwd) {
   for (const testFile of testFiles) {
     let content;
     try {
-      content = fs20.readFileSync(testFile, "utf-8");
+      content = fs21.readFileSync(testFile, "utf-8");
     } catch {
       continue;
     }
@@ -24386,10 +24726,10 @@ async function buildImpactMap(cwd) {
   return impactMap;
 }
 async function loadImpactMap(cwd, options) {
-  const cachePath = path49.join(cwd, ".swarm", "cache", "impact-map.json");
-  if (fs20.existsSync(cachePath)) {
+  const cachePath = path50.join(cwd, ".swarm", "cache", "impact-map.json");
+  if (fs21.existsSync(cachePath)) {
     try {
-      const content = fs20.readFileSync(cachePath, "utf-8");
+      const content = fs21.readFileSync(cachePath, "utf-8");
       const data = JSON.parse(content);
       if (data.map !== null && typeof data.map === "object" && !Array.isArray(data.map)) {
         const map = data.map;
@@ -24419,21 +24759,21 @@ async function loadImpactMap(cwd, options) {
   return _internals39.buildImpactMap(cwd);
 }
 async function saveImpactMap(cwd, impactMap) {
-  if (!path49.isAbsolute(cwd)) {
+  if (!path50.isAbsolute(cwd)) {
     throw new Error(`saveImpactMap requires an absolute project root path, got: "${cwd}"`);
   }
   _internals39.validateProjectRoot(cwd);
-  const cacheDir2 = path49.join(cwd, ".swarm", "cache");
-  const cachePath = path49.join(cacheDir2, "impact-map.json");
-  if (!fs20.existsSync(cacheDir2)) {
-    fs20.mkdirSync(cacheDir2, { recursive: true });
+  const cacheDir2 = path50.join(cwd, ".swarm", "cache");
+  const cachePath = path50.join(cacheDir2, "impact-map.json");
+  if (!fs21.existsSync(cacheDir2)) {
+    fs21.mkdirSync(cacheDir2, { recursive: true });
   }
   const data = {
     generatedAt: new Date().toISOString(),
     fileCount: Object.keys(impactMap).length,
     map: impactMap
   };
-  fs20.writeFileSync(cachePath, JSON.stringify(data, null, 2), "utf-8");
+  fs21.writeFileSync(cachePath, JSON.stringify(data, null, 2), "utf-8");
 }
 async function analyzeImpact(changedFiles, cwd, budget) {
   if (!Array.isArray(changedFiles)) {
@@ -24456,7 +24796,7 @@ async function analyzeImpact(changedFiles, cwd, budget) {
       budgetExceeded = true;
       break;
     }
-    const normalizedChanged = normalizePath2(path49.resolve(changedFile));
+    const normalizedChanged = normalizePath2(path50.resolve(changedFile));
     const tests = impactMap[normalizedChanged];
     if (tests && tests.length > 0) {
       for (const test of tests) {
@@ -24470,13 +24810,13 @@ async function analyzeImpact(changedFiles, cwd, budget) {
       if (budgetExceeded)
         break;
     } else {
-      const changedDir = normalizePath2(path49.dirname(normalizedChanged));
-      const changedInputDir = normalizePath2(path49.dirname(changedFile));
+      const changedDir = normalizePath2(path50.dirname(normalizedChanged));
+      const changedInputDir = normalizePath2(path50.dirname(changedFile));
       const suffixMatches = Object.entries(impactMap).filter(([sourcePath]) => {
         return sourcePath.endsWith(changedFile) || changedFile.endsWith(sourcePath) || sourcePath.endsWith(normalizedChanged) || normalizedChanged.endsWith(sourcePath);
       }).sort(([sourceA], [sourceB]) => {
-        const sourceDirA = normalizePath2(path49.dirname(sourceA));
-        const sourceDirB = normalizePath2(path49.dirname(sourceB));
+        const sourceDirA = normalizePath2(path50.dirname(sourceA));
+        const sourceDirB = normalizePath2(path50.dirname(sourceB));
         const exactA = sourceDirA === changedDir || changedInputDir !== "." && (sourceDirA === changedInputDir || sourceDirA.endsWith(`/${changedInputDir}`));
         const exactB = sourceDirB === changedDir || changedInputDir !== "." && (sourceDirB === changedInputDir || sourceDirB.endsWith(`/${changedInputDir}`));
         if (exactA !== exactB)
@@ -24802,8 +25142,8 @@ function detectFlakyTests(allHistory) {
 }
 
 // src/test-impact/history-store.ts
-import fs21 from "fs";
-import path50 from "path";
+import fs22 from "fs";
+import path51 from "path";
 var MAX_HISTORY_PER_TEST = 20;
 var MAX_ERROR_LENGTH = 500;
 var MAX_STACK_LENGTH = 200;
@@ -24815,10 +25155,10 @@ function getHistoryPath(workingDir) {
   if (!workingDir) {
     throw new Error("getHistoryPath requires a working directory \u2014 project root must be provided by the caller");
   }
-  if (!path50.isAbsolute(workingDir)) {
+  if (!path51.isAbsolute(workingDir)) {
     throw new Error(`getHistoryPath requires an absolute project root path, got: "${workingDir}"`);
   }
-  return path50.join(workingDir, ".swarm", "cache", "test-history.jsonl");
+  return path51.join(workingDir, ".swarm", "cache", "test-history.jsonl");
 }
 function sanitizeErrorMessage(errorMessage) {
   if (errorMessage === undefined) {
@@ -24910,10 +25250,10 @@ function batchAppendTestRuns(records, workingDir) {
     }
   }
   const historyPath = getHistoryPath(workingDir);
-  const historyDir = path50.dirname(historyPath);
+  const historyDir = path51.dirname(historyPath);
   _internals40.validateProjectRoot(workingDir);
-  if (!fs21.existsSync(historyDir)) {
-    fs21.mkdirSync(historyDir, { recursive: true });
+  if (!fs22.existsSync(historyDir)) {
+    fs22.mkdirSync(historyDir, { recursive: true });
   }
   withHistoryWriteLock(historyPath, () => {
     const existingRecords = readAllRecords(historyPath);
@@ -24947,13 +25287,13 @@ function batchAppendTestRuns(records, workingDir) {
 `)}
 `;
       const tempPath = `${historyPath}.tmp`;
-      fs21.writeFileSync(tempPath, content, "utf-8");
-      fs21.renameSync(tempPath, historyPath);
+      fs22.writeFileSync(tempPath, content, "utf-8");
+      fs22.renameSync(tempPath, historyPath);
     } catch (err) {
       try {
         const tempPath = `${historyPath}.tmp`;
-        if (fs21.existsSync(tempPath)) {
-          fs21.unlinkSync(tempPath);
+        if (fs22.existsSync(tempPath)) {
+          fs22.unlinkSync(tempPath);
         }
       } catch {}
       throw new Error(`Failed to write test history: ${err instanceof Error ? err.message : String(err)}`);
@@ -24965,7 +25305,7 @@ function withHistoryWriteLock(historyPath, fn) {
   const deadline = Date.now() + HISTORY_WRITE_LOCK_TIMEOUT_MS;
   while (true) {
     try {
-      fs21.mkdirSync(lockPath);
+      fs22.mkdirSync(lockPath);
       break;
     } catch (error2) {
       const code = error2 instanceof Error && "code" in error2 ? error2.code : undefined;
@@ -24976,9 +25316,9 @@ function withHistoryWriteLock(historyPath, fn) {
         throw new Error(`Timed out waiting for test history lock: ${historyPath}`);
       }
       try {
-        const lockStat = fs21.statSync(lockPath);
+        const lockStat = fs22.statSync(lockPath);
         if (Date.now() - lockStat.mtimeMs >= HISTORY_WRITE_LOCK_STALE_MS) {
-          fs21.rmSync(lockPath, { recursive: true, force: true });
+          fs22.rmSync(lockPath, { recursive: true, force: true });
           continue;
         }
       } catch {}
@@ -24993,7 +25333,7 @@ function withHistoryWriteLock(historyPath, fn) {
     return fn();
   } finally {
     try {
-      fs21.rmSync(lockPath, { recursive: true, force: true });
+      fs22.rmSync(lockPath, { recursive: true, force: true });
     } catch {}
   }
   function sleepSync(ms) {
@@ -25002,11 +25342,11 @@ function withHistoryWriteLock(historyPath, fn) {
   }
 }
 function readAllRecords(historyPath) {
-  if (!fs21.existsSync(historyPath)) {
+  if (!fs22.existsSync(historyPath)) {
     return [];
   }
   try {
-    const content = fs21.readFileSync(historyPath, "utf-8");
+    const content = fs22.readFileSync(historyPath, "utf-8");
     const lines = content.split(`
 `);
     const records = [];
@@ -25039,8 +25379,8 @@ var _internals40 = {
 };
 
 // src/tools/resolve-working-directory.ts
-import * as fs22 from "fs";
-import * as path51 from "path";
+import * as fs23 from "fs";
+import * as path52 from "path";
 function resolveWorkingDirectory(workingDirectory, fallbackDirectory) {
   if (workingDirectory == null || workingDirectory === "") {
     if (typeof fallbackDirectory !== "string" || fallbackDirectory === "") {
@@ -25072,18 +25412,18 @@ function resolveWorkingDirectory(workingDirectory, fallbackDirectory) {
       };
     }
   }
-  const rawPathParts = workingDirectory.split(path51.sep);
+  const rawPathParts = workingDirectory.split(path52.sep);
   if (rawPathParts.includes("..")) {
     return {
       success: false,
       message: "Invalid working_directory: path traversal sequences (..) are not allowed"
     };
   }
-  const normalizedDir = path51.normalize(workingDirectory);
-  const resolvedDir = path51.resolve(normalizedDir);
+  const normalizedDir = path52.normalize(workingDirectory);
+  const resolvedDir = path52.resolve(normalizedDir);
   let statResult;
   try {
-    statResult = fs22.statSync(resolvedDir);
+    statResult = fs23.statSync(resolvedDir);
   } catch {
     return {
       success: false,
@@ -25099,16 +25439,16 @@ function resolveWorkingDirectory(workingDirectory, fallbackDirectory) {
   if (typeof fallbackDirectory !== "string" || fallbackDirectory === "") {
     return { success: true, directory: resolvedDir };
   }
-  const resolvedFallback = path51.resolve(fallbackDirectory);
+  const resolvedFallback = path52.resolve(fallbackDirectory);
   let fallbackExists = false;
   try {
-    fs22.statSync(resolvedFallback);
+    fs23.statSync(resolvedFallback);
     fallbackExists = true;
   } catch {
     fallbackExists = false;
   }
   if (fallbackExists) {
-    const isSubdirectory = resolvedDir.startsWith(resolvedFallback + path51.sep);
+    const isSubdirectory = resolvedDir.startsWith(resolvedFallback + path52.sep);
     if (isSubdirectory) {
       return {
         success: false,
@@ -25131,7 +25471,7 @@ async function estimateFanOut(sourceFiles, cwd) {
     const impactMap = await loadImpactMap(cwd, { skipRebuild: true });
     const uniqueTestFiles = new Set;
     for (const sourceFile of sourceFiles) {
-      const resolvedPath = path52.resolve(cwd, sourceFile);
+      const resolvedPath = path53.resolve(cwd, sourceFile);
       const normalizedPath = resolvedPath.replace(/\\/g, "/");
       const testFiles = impactMap[normalizedPath];
       if (testFiles) {
@@ -25216,19 +25556,19 @@ function hasDevDependency(devDeps, ...patterns) {
   return hasPackageJsonDependency(devDeps, ...patterns);
 }
 function detectGoTest(cwd) {
-  return fs23.existsSync(path52.join(cwd, "go.mod")) && isCommandAvailable("go");
+  return fs24.existsSync(path53.join(cwd, "go.mod")) && isCommandAvailable("go");
 }
 function detectJavaMaven(cwd) {
-  return fs23.existsSync(path52.join(cwd, "pom.xml")) && isCommandAvailable("mvn");
+  return fs24.existsSync(path53.join(cwd, "pom.xml")) && isCommandAvailable("mvn");
 }
 function detectGradle(cwd) {
-  const hasBuildFile = fs23.existsSync(path52.join(cwd, "build.gradle")) || fs23.existsSync(path52.join(cwd, "build.gradle.kts"));
-  const hasGradlew = fs23.existsSync(path52.join(cwd, "gradlew")) || fs23.existsSync(path52.join(cwd, "gradlew.bat"));
+  const hasBuildFile = fs24.existsSync(path53.join(cwd, "build.gradle")) || fs24.existsSync(path53.join(cwd, "build.gradle.kts"));
+  const hasGradlew = fs24.existsSync(path53.join(cwd, "gradlew")) || fs24.existsSync(path53.join(cwd, "gradlew.bat"));
   return hasBuildFile && (hasGradlew || isCommandAvailable("gradle"));
 }
 function detectDotnetTest(cwd) {
   try {
-    const files = fs23.readdirSync(cwd);
+    const files = fs24.readdirSync(cwd);
     const hasCsproj = files.some((f) => f.endsWith(".csproj"));
     return hasCsproj && isCommandAvailable("dotnet");
   } catch {
@@ -25236,25 +25576,25 @@ function detectDotnetTest(cwd) {
   }
 }
 function detectCTest(cwd) {
-  const hasSource = fs23.existsSync(path52.join(cwd, "CMakeLists.txt"));
-  const hasBuildCache = fs23.existsSync(path52.join(cwd, "CMakeCache.txt")) || fs23.existsSync(path52.join(cwd, "build", "CMakeCache.txt"));
+  const hasSource = fs24.existsSync(path53.join(cwd, "CMakeLists.txt"));
+  const hasBuildCache = fs24.existsSync(path53.join(cwd, "CMakeCache.txt")) || fs24.existsSync(path53.join(cwd, "build", "CMakeCache.txt"));
   return (hasSource || hasBuildCache) && isCommandAvailable("ctest");
 }
 function detectSwiftTest(cwd) {
-  return fs23.existsSync(path52.join(cwd, "Package.swift")) && isCommandAvailable("swift");
+  return fs24.existsSync(path53.join(cwd, "Package.swift")) && isCommandAvailable("swift");
 }
 function detectDartTest(cwd) {
-  return fs23.existsSync(path52.join(cwd, "pubspec.yaml")) && (isCommandAvailable("dart") || isCommandAvailable("flutter"));
+  return fs24.existsSync(path53.join(cwd, "pubspec.yaml")) && (isCommandAvailable("dart") || isCommandAvailable("flutter"));
 }
 function detectRSpec(cwd) {
-  const hasRSpecFile = fs23.existsSync(path52.join(cwd, ".rspec"));
-  const hasGemfile = fs23.existsSync(path52.join(cwd, "Gemfile"));
-  const hasSpecDir = fs23.existsSync(path52.join(cwd, "spec"));
+  const hasRSpecFile = fs24.existsSync(path53.join(cwd, ".rspec"));
+  const hasGemfile = fs24.existsSync(path53.join(cwd, "Gemfile"));
+  const hasSpecDir = fs24.existsSync(path53.join(cwd, "spec"));
   const hasRSpec = hasRSpecFile || hasGemfile && hasSpecDir;
   return hasRSpec && (isCommandAvailable("bundle") || isCommandAvailable("rspec"));
 }
 function detectMinitest(cwd) {
-  return fs23.existsSync(path52.join(cwd, "test")) && (fs23.existsSync(path52.join(cwd, "Gemfile")) || fs23.existsSync(path52.join(cwd, "Rakefile"))) && isCommandAvailable("ruby");
+  return fs24.existsSync(path53.join(cwd, "test")) && (fs24.existsSync(path53.join(cwd, "Gemfile")) || fs24.existsSync(path53.join(cwd, "Rakefile"))) && isCommandAvailable("ruby");
 }
 var DISPATCH_FRAMEWORK_MAP = {
   bun: "bun",
@@ -25339,9 +25679,9 @@ async function parseTestOutputViaDispatch(framework, output, baseDir) {
 async function detectTestFramework(cwd) {
   const baseDir = cwd;
   try {
-    const packageJsonPath = path52.join(baseDir, "package.json");
-    if (fs23.existsSync(packageJsonPath)) {
-      const content = fs23.readFileSync(packageJsonPath, "utf-8");
+    const packageJsonPath = path53.join(baseDir, "package.json");
+    if (fs24.existsSync(packageJsonPath)) {
+      const content = fs24.readFileSync(packageJsonPath, "utf-8");
       const pkg = JSON.parse(content);
       const _deps = pkg.dependencies || {};
       const devDeps = pkg.devDependencies || {};
@@ -25360,38 +25700,38 @@ async function detectTestFramework(cwd) {
         return "jest";
       if (hasDevDependency(devDeps, "mocha", "@types/mocha"))
         return "mocha";
-      if (fs23.existsSync(path52.join(baseDir, "bun.lockb")) || fs23.existsSync(path52.join(baseDir, "bun.lock"))) {
+      if (fs24.existsSync(path53.join(baseDir, "bun.lockb")) || fs24.existsSync(path53.join(baseDir, "bun.lock"))) {
         if (scripts.test?.includes("bun"))
           return "bun";
       }
     }
   } catch {}
   try {
-    const pyprojectTomlPath = path52.join(baseDir, "pyproject.toml");
-    const setupCfgPath = path52.join(baseDir, "setup.cfg");
-    const requirementsTxtPath = path52.join(baseDir, "requirements.txt");
-    if (fs23.existsSync(pyprojectTomlPath)) {
-      const content = fs23.readFileSync(pyprojectTomlPath, "utf-8");
+    const pyprojectTomlPath = path53.join(baseDir, "pyproject.toml");
+    const setupCfgPath = path53.join(baseDir, "setup.cfg");
+    const requirementsTxtPath = path53.join(baseDir, "requirements.txt");
+    if (fs24.existsSync(pyprojectTomlPath)) {
+      const content = fs24.readFileSync(pyprojectTomlPath, "utf-8");
       if (content.includes("[tool.pytest"))
         return "pytest";
       if (content.includes("pytest"))
         return "pytest";
     }
-    if (fs23.existsSync(setupCfgPath)) {
-      const content = fs23.readFileSync(setupCfgPath, "utf-8");
+    if (fs24.existsSync(setupCfgPath)) {
+      const content = fs24.readFileSync(setupCfgPath, "utf-8");
       if (content.includes("[pytest]"))
         return "pytest";
     }
-    if (fs23.existsSync(requirementsTxtPath)) {
-      const content = fs23.readFileSync(requirementsTxtPath, "utf-8");
+    if (fs24.existsSync(requirementsTxtPath)) {
+      const content = fs24.readFileSync(requirementsTxtPath, "utf-8");
       if (content.includes("pytest"))
         return "pytest";
     }
   } catch {}
   try {
-    const cargoTomlPath = path52.join(baseDir, "Cargo.toml");
-    if (fs23.existsSync(cargoTomlPath)) {
-      const content = fs23.readFileSync(cargoTomlPath, "utf-8");
+    const cargoTomlPath = path53.join(baseDir, "Cargo.toml");
+    if (fs24.existsSync(cargoTomlPath)) {
+      const content = fs24.readFileSync(cargoTomlPath, "utf-8");
       if (content.includes("[dev-dependencies]")) {
         if (content.includes("tokio") || content.includes("mockall") || content.includes("pretty_assertions")) {
           return "cargo";
@@ -25400,10 +25740,10 @@ async function detectTestFramework(cwd) {
     }
   } catch {}
   try {
-    const pesterConfigPath = path52.join(baseDir, "pester.config.ps1");
-    const pesterConfigJsonPath = path52.join(baseDir, "pester.config.ps1.json");
-    const pesterPs1Path = path52.join(baseDir, "tests.ps1");
-    if (fs23.existsSync(pesterConfigPath) || fs23.existsSync(pesterConfigJsonPath) || fs23.existsSync(pesterPs1Path)) {
+    const pesterConfigPath = path53.join(baseDir, "pester.config.ps1");
+    const pesterConfigJsonPath = path53.join(baseDir, "pester.config.ps1.json");
+    const pesterPs1Path = path53.join(baseDir, "tests.ps1");
+    if (fs24.existsSync(pesterConfigPath) || fs24.existsSync(pesterConfigJsonPath) || fs24.existsSync(pesterPs1Path)) {
       return "pester";
     }
   } catch {}
@@ -25445,12 +25785,12 @@ function isTestDirectoryPath(normalizedPath) {
   return normalizedPath.split("/").some((segment) => TEST_DIRECTORY_NAMES.includes(segment));
 }
 function resolveWorkspacePath(file, workingDir) {
-  return path52.isAbsolute(file) ? path52.resolve(file) : path52.resolve(workingDir, file);
+  return path53.isAbsolute(file) ? path53.resolve(file) : path53.resolve(workingDir, file);
 }
 function toWorkspaceOutputPath(absolutePath, workingDir, preferRelative) {
   if (!preferRelative)
     return absolutePath;
-  return path52.relative(workingDir, absolutePath);
+  return path53.relative(workingDir, absolutePath);
 }
 function dedupePush(target, value) {
   if (!target.includes(value)) {
@@ -25487,18 +25827,18 @@ function buildLanguageSpecificTestNames(nameWithoutExt, ext) {
   }
 }
 function getRepoLevelCandidateDirectories(workingDir, relativePath, ext) {
-  const relativeDir = path52.dirname(relativePath);
+  const relativeDir = path53.dirname(relativePath);
   const nestedRelativeDir = relativeDir === "." ? "" : relativeDir;
   const directories = TEST_DIRECTORY_NAMES.flatMap((dirName) => {
-    const rootDir = path52.join(workingDir, dirName);
-    return nestedRelativeDir ? [rootDir, path52.join(rootDir, nestedRelativeDir)] : [rootDir];
+    const rootDir = path53.join(workingDir, dirName);
+    return nestedRelativeDir ? [rootDir, path53.join(rootDir, nestedRelativeDir)] : [rootDir];
   });
   const normalizedRelativePath = relativePath.replace(/\\/g, "/");
   if (ext === ".java" && normalizedRelativePath.startsWith("src/main/java/")) {
-    directories.push(path52.join(workingDir, "src/test/java", path52.dirname(normalizedRelativePath.slice("src/main/java/".length))));
+    directories.push(path53.join(workingDir, "src/test/java", path53.dirname(normalizedRelativePath.slice("src/main/java/".length))));
   }
   if ((ext === ".kt" || ext === ".java") && normalizedRelativePath.startsWith("src/main/kotlin/")) {
-    directories.push(path52.join(workingDir, "src/test/kotlin", path52.dirname(normalizedRelativePath.slice("src/main/kotlin/".length))));
+    directories.push(path53.join(workingDir, "src/test/kotlin", path53.dirname(normalizedRelativePath.slice("src/main/kotlin/".length))));
   }
   return [...new Set(directories)];
 }
@@ -25526,23 +25866,23 @@ function isLanguageSpecificTestFile(basename9) {
 }
 function isConventionTestFilePath(filePath) {
   const normalizedPath = filePath.replace(/\\/g, "/");
-  const basename9 = path52.basename(filePath);
+  const basename9 = path53.basename(filePath);
   return hasCompoundTestExtension(basename9) || basename9.includes(".spec.") || basename9.includes(".test.") || isLanguageSpecificTestFile(basename9) || isTestDirectoryPath(normalizedPath);
 }
 function getTestFilesFromConvention(sourceFiles, workingDir = process.cwd()) {
   const testFiles = [];
   for (const file of sourceFiles) {
     const absoluteFile = resolveWorkspacePath(file, workingDir);
-    const relativeFile = path52.relative(workingDir, absoluteFile);
-    const basename9 = path52.basename(absoluteFile);
-    const dirname25 = path52.dirname(absoluteFile);
-    const preferRelativeOutput = !path52.isAbsolute(file);
+    const relativeFile = path53.relative(workingDir, absoluteFile);
+    const basename9 = path53.basename(absoluteFile);
+    const dirname25 = path53.dirname(absoluteFile);
+    const preferRelativeOutput = !path53.isAbsolute(file);
     if (isConventionTestFilePath(relativeFile) || isConventionTestFilePath(file)) {
       dedupePush(testFiles, toWorkspaceOutputPath(absoluteFile, workingDir, preferRelativeOutput));
       continue;
     }
     const nameWithoutExt = basename9.replace(/\.[^.]+$/, "");
-    const ext = path52.extname(basename9);
+    const ext = path53.extname(basename9);
     const genericTestNames = [
       `${nameWithoutExt}.spec${ext}`,
       `${nameWithoutExt}.test${ext}`
@@ -25551,7 +25891,7 @@ function getTestFilesFromConvention(sourceFiles, workingDir = process.cwd()) {
     const colocatedCandidates = [
       ...genericTestNames,
       ...languageSpecificTestNames
-    ].map((candidateName) => path52.join(dirname25, candidateName));
+    ].map((candidateName) => path53.join(dirname25, candidateName));
     const testDirectoryNames = [
       basename9,
       ...genericTestNames,
@@ -25560,11 +25900,11 @@ function getTestFilesFromConvention(sourceFiles, workingDir = process.cwd()) {
     const repoLevelDirectories = getRepoLevelCandidateDirectories(workingDir, relativeFile, ext);
     const possibleTestFiles = [
       ...colocatedCandidates,
-      ...TEST_DIRECTORY_NAMES.flatMap((dirName) => testDirectoryNames.map((candidateName) => path52.join(dirname25, dirName, candidateName))),
-      ...repoLevelDirectories.flatMap((candidateDir) => testDirectoryNames.map((candidateName) => path52.join(candidateDir, candidateName)))
+      ...TEST_DIRECTORY_NAMES.flatMap((dirName) => testDirectoryNames.map((candidateName) => path53.join(dirname25, dirName, candidateName))),
+      ...repoLevelDirectories.flatMap((candidateDir) => testDirectoryNames.map((candidateName) => path53.join(candidateDir, candidateName)))
     ];
     for (const testFile of possibleTestFiles) {
-      if (fs23.existsSync(testFile)) {
+      if (fs24.existsSync(testFile)) {
         dedupePush(testFiles, toWorkspaceOutputPath(testFile, workingDir, preferRelativeOutput));
       }
     }
@@ -25581,8 +25921,8 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
   for (const testFile of candidateTestFiles) {
     try {
       const absoluteTestFile = resolveWorkspacePath(testFile, workingDir);
-      const content = fs23.readFileSync(absoluteTestFile, "utf-8");
-      const testDir = path52.dirname(absoluteTestFile);
+      const content = fs24.readFileSync(absoluteTestFile, "utf-8");
+      const testDir = path53.dirname(absoluteTestFile);
       const importRegex = /import\s+.*?\s+from\s+['"]([^'"]+)['"]/g;
       let match;
       match = importRegex.exec(content);
@@ -25590,8 +25930,8 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
         const importPath = match[1];
         let resolvedImport;
         if (importPath.startsWith(".")) {
-          resolvedImport = path52.resolve(testDir, importPath);
-          const existingExt = path52.extname(resolvedImport);
+          resolvedImport = path53.resolve(testDir, importPath);
+          const existingExt = path53.extname(resolvedImport);
           if (!existingExt) {
             for (const extToTry of [
               ".ts",
@@ -25602,7 +25942,7 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
               ".cjs"
             ]) {
               const withExt = resolvedImport + extToTry;
-              if (absoluteSourceFiles.includes(withExt) || fs23.existsSync(withExt)) {
+              if (absoluteSourceFiles.includes(withExt) || fs24.existsSync(withExt)) {
                 resolvedImport = withExt;
                 break;
               }
@@ -25611,12 +25951,12 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
         } else {
           continue;
         }
-        const importBasename = path52.basename(resolvedImport, path52.extname(resolvedImport));
-        const importDir = path52.dirname(resolvedImport);
+        const importBasename = path53.basename(resolvedImport, path53.extname(resolvedImport));
+        const importDir = path53.dirname(resolvedImport);
         for (const sourceFile of absoluteSourceFiles) {
-          const sourceDir = path52.dirname(sourceFile);
-          const sourceBasename = path52.basename(sourceFile, path52.extname(sourceFile));
-          const isRelatedDir = importDir === sourceDir || importDir === path52.join(sourceDir, "__tests__") || importDir === path52.join(sourceDir, "tests") || importDir === path52.join(sourceDir, "test") || importDir === path52.join(sourceDir, "spec");
+          const sourceDir = path53.dirname(sourceFile);
+          const sourceBasename = path53.basename(sourceFile, path53.extname(sourceFile));
+          const isRelatedDir = importDir === sourceDir || importDir === path53.join(sourceDir, "__tests__") || importDir === path53.join(sourceDir, "tests") || importDir === path53.join(sourceDir, "test") || importDir === path53.join(sourceDir, "spec");
           if (resolvedImport === sourceFile || importBasename === sourceBasename && isRelatedDir) {
             dedupePush(testFiles, testFile);
             break;
@@ -25629,8 +25969,8 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
       while (match !== null) {
         const importPath = match[1];
         if (importPath.startsWith(".")) {
-          let resolvedImport = path52.resolve(testDir, importPath);
-          const existingExt = path52.extname(resolvedImport);
+          let resolvedImport = path53.resolve(testDir, importPath);
+          const existingExt = path53.extname(resolvedImport);
           if (!existingExt) {
             for (const extToTry of [
               ".ts",
@@ -25641,18 +25981,18 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
               ".cjs"
             ]) {
               const withExt = resolvedImport + extToTry;
-              if (absoluteSourceFiles.includes(withExt) || fs23.existsSync(withExt)) {
+              if (absoluteSourceFiles.includes(withExt) || fs24.existsSync(withExt)) {
                 resolvedImport = withExt;
                 break;
               }
             }
           }
-          const importDir = path52.dirname(resolvedImport);
-          const importBasename = path52.basename(resolvedImport, path52.extname(resolvedImport));
+          const importDir = path53.dirname(resolvedImport);
+          const importBasename = path53.basename(resolvedImport, path53.extname(resolvedImport));
           for (const sourceFile of absoluteSourceFiles) {
-            const sourceDir = path52.dirname(sourceFile);
-            const sourceBasename = path52.basename(sourceFile, path52.extname(sourceFile));
-            const isRelatedDir = importDir === sourceDir || importDir === path52.join(sourceDir, "__tests__") || importDir === path52.join(sourceDir, "tests") || importDir === path52.join(sourceDir, "test") || importDir === path52.join(sourceDir, "spec");
+            const sourceDir = path53.dirname(sourceFile);
+            const sourceBasename = path53.basename(sourceFile, path53.extname(sourceFile));
+            const isRelatedDir = importDir === sourceDir || importDir === path53.join(sourceDir, "__tests__") || importDir === path53.join(sourceDir, "tests") || importDir === path53.join(sourceDir, "test") || importDir === path53.join(sourceDir, "spec");
             if (resolvedImport === sourceFile || importBasename === sourceBasename && isRelatedDir) {
               dedupePush(testFiles, testFile);
               break;
@@ -25772,8 +26112,8 @@ function buildTestCommand(framework, scope, files, coverage, baseDir, bail) {
       return ["mvn", "test"];
     case "gradle": {
       const isWindows = process.platform === "win32";
-      const hasGradlewBat = fs23.existsSync(path52.join(baseDir, "gradlew.bat"));
-      const hasGradlew = fs23.existsSync(path52.join(baseDir, "gradlew"));
+      const hasGradlewBat = fs24.existsSync(path53.join(baseDir, "gradlew.bat"));
+      const hasGradlew = fs24.existsSync(path53.join(baseDir, "gradlew"));
       if (hasGradlewBat && isWindows)
         return ["gradlew.bat", "test"];
       if (hasGradlew)
@@ -25790,7 +26130,7 @@ function buildTestCommand(framework, scope, files, coverage, baseDir, bail) {
         "cmake-build-release",
         "out"
       ];
-      const actualBuildDir = buildDirCandidates.find((d) => fs23.existsSync(path52.join(baseDir, d, "CMakeCache.txt"))) ?? "build";
+      const actualBuildDir = buildDirCandidates.find((d) => fs24.existsSync(path53.join(baseDir, d, "CMakeCache.txt"))) ?? "build";
       return ["ctest", "--test-dir", actualBuildDir];
     }
     case "swift-test":
@@ -26224,13 +26564,13 @@ async function runTests(framework, scope, files, coverage, timeout_ms, cwd, bail
     };
   }
   const startTime = Date.now();
-  const vitestJsonOutputPath = framework === "vitest" ? path52.join(cwd, ".swarm", "cache", "test-runner-vitest.json") : undefined;
+  const vitestJsonOutputPath = framework === "vitest" ? path53.join(cwd, ".swarm", "cache", "test-runner-vitest.json") : undefined;
   try {
     if (vitestJsonOutputPath) {
       try {
-        fs23.mkdirSync(path52.dirname(vitestJsonOutputPath), { recursive: true });
-        if (fs23.existsSync(vitestJsonOutputPath)) {
-          fs23.unlinkSync(vitestJsonOutputPath);
+        fs24.mkdirSync(path53.dirname(vitestJsonOutputPath), { recursive: true });
+        if (fs24.existsSync(vitestJsonOutputPath)) {
+          fs24.unlinkSync(vitestJsonOutputPath);
         }
       } catch {}
     }
@@ -26256,8 +26596,8 @@ async function runTests(framework, scope, files, coverage, timeout_ms, cwd, bail
     }
     if (vitestJsonOutputPath) {
       try {
-        if (fs23.existsSync(vitestJsonOutputPath)) {
-          const vitestJsonOutput = fs23.readFileSync(vitestJsonOutputPath, "utf-8");
+        if (fs24.existsSync(vitestJsonOutputPath)) {
+          const vitestJsonOutput = fs24.readFileSync(vitestJsonOutputPath, "utf-8");
           if (vitestJsonOutput.trim().length > 0) {
             output += (output ? `
 ` : "") + vitestJsonOutput;
@@ -26396,10 +26736,10 @@ var SKIP_DIRECTORIES = new Set([
 ]);
 function normalizeHistoryTestFile(testFile, workingDir) {
   const normalized = testFile.replace(/\\/g, "/");
-  if (!path52.isAbsolute(testFile))
+  if (!path53.isAbsolute(testFile))
     return normalized;
-  const relative8 = path52.relative(workingDir, testFile);
-  if (relative8.startsWith("..") || path52.isAbsolute(relative8)) {
+  const relative8 = path53.relative(workingDir, testFile);
+  if (relative8.startsWith("..") || path53.isAbsolute(relative8)) {
     return normalized;
   }
   return relative8.replace(/\\/g, "/");
@@ -26638,7 +26978,7 @@ var test_runner = createSwarmTool({
       const sourceFiles = args.files.filter((file) => {
         if (directTestFiles.includes(file))
           return false;
-        const ext = path52.extname(file).toLowerCase();
+        const ext = path53.extname(file).toLowerCase();
         return SOURCE_EXTENSIONS.has(ext);
       });
       const invalidFiles = args.files.filter((file) => !directTestFiles.includes(file) && !sourceFiles.includes(file));
@@ -26684,7 +27024,7 @@ var test_runner = createSwarmTool({
         if (isConventionTestFilePath(f)) {
           return false;
         }
-        const ext = path52.extname(f).toLowerCase();
+        const ext = path53.extname(f).toLowerCase();
         return SOURCE_EXTENSIONS.has(ext);
       });
       if (sourceFiles.length === 0) {
@@ -26734,7 +27074,7 @@ var test_runner = createSwarmTool({
         if (isConventionTestFilePath(f)) {
           return false;
         }
-        const ext = path52.extname(f).toLowerCase();
+        const ext = path53.extname(f).toLowerCase();
         return SOURCE_EXTENSIONS.has(ext);
       });
       if (sourceFiles.length === 0) {
@@ -26786,8 +27126,8 @@ var test_runner = createSwarmTool({
         }
         if (impactResult.impactedTests.length > 0) {
           testFiles = impactResult.impactedTests.map((absPath) => {
-            const relativePath = path52.relative(workingDir, absPath);
-            return path52.isAbsolute(relativePath) ? absPath : relativePath;
+            const relativePath = path53.relative(workingDir, absPath);
+            return path53.isAbsolute(relativePath) ? absPath : relativePath;
           });
         } else {
           graphFallbackReason = "no impacted tests found via impact analysis, falling back to graph";
@@ -26882,8 +27222,8 @@ function validateDirectoryPath(dir) {
   if (dir.includes("..")) {
     throw new Error("Directory path must not contain path traversal sequences");
   }
-  const normalized = path53.normalize(dir);
-  const absolutePath = path53.isAbsolute(normalized) ? normalized : path53.resolve(normalized);
+  const normalized = path54.normalize(dir);
+  const absolutePath = path54.isAbsolute(normalized) ? normalized : path54.resolve(normalized);
   return absolutePath;
 }
 function validateTimeout(timeoutMs, defaultValue) {
@@ -26906,9 +27246,9 @@ function validateTimeout(timeoutMs, defaultValue) {
 }
 function getPackageVersion(dir) {
   try {
-    const packagePath = path53.join(dir, "package.json");
-    if (fs24.existsSync(packagePath)) {
-      const content = fs24.readFileSync(packagePath, "utf-8");
+    const packagePath = path54.join(dir, "package.json");
+    if (fs25.existsSync(packagePath)) {
+      const content = fs25.readFileSync(packagePath, "utf-8");
       const pkg = JSON.parse(content);
       return pkg.version ?? null;
     }
@@ -26917,9 +27257,9 @@ function getPackageVersion(dir) {
 }
 function getChangelogVersion(dir) {
   try {
-    const changelogPath = path53.join(dir, "CHANGELOG.md");
-    if (fs24.existsSync(changelogPath)) {
-      const content = fs24.readFileSync(changelogPath, "utf-8");
+    const changelogPath = path54.join(dir, "CHANGELOG.md");
+    if (fs25.existsSync(changelogPath)) {
+      const content = fs25.readFileSync(changelogPath, "utf-8");
       const match = content.match(/^##\s*\[?(\d+\.\d+\.\d+)\]?/m);
       if (match) {
         return match[1];
@@ -26931,10 +27271,10 @@ function getChangelogVersion(dir) {
 function getVersionFileVersion(dir) {
   const possibleFiles = ["VERSION.txt", "version.txt", "VERSION", "version"];
   for (const file of possibleFiles) {
-    const filePath = path53.join(dir, file);
-    if (fs24.existsSync(filePath)) {
+    const filePath = path54.join(dir, file);
+    if (fs25.existsSync(filePath)) {
       try {
-        const content = fs24.readFileSync(filePath, "utf-8").trim();
+        const content = fs25.readFileSync(filePath, "utf-8").trim();
         const match = content.match(/(\d+\.\d+\.\d+)/);
         if (match) {
           return match[1];
@@ -27668,8 +28008,8 @@ async function handleQaGatesCommand(directory, args, sessionID) {
 }
 
 // src/commands/reset.ts
-import * as fs25 from "fs";
-import * as path54 from "path";
+import * as fs26 from "fs";
+import * as path55 from "path";
 
 // src/background/circuit-breaker.ts
 class CircuitBreaker {
@@ -28374,8 +28714,8 @@ async function handleResetCommand(directory, args) {
   for (const filename of filesToReset) {
     try {
       const resolvedPath = validateSwarmPath(directory, filename);
-      if (fs25.existsSync(resolvedPath)) {
-        fs25.unlinkSync(resolvedPath);
+      if (fs26.existsSync(resolvedPath)) {
+        fs26.unlinkSync(resolvedPath);
         results.push(`- \u2705 Deleted ${filename}`);
       } else {
         results.push(`- \u23ED\uFE0F ${filename} not found (skipped)`);
@@ -28386,9 +28726,9 @@ async function handleResetCommand(directory, args) {
   }
   for (const filename of ["SWARM_PLAN.md", "SWARM_PLAN.json"]) {
     try {
-      const rootPath = path54.join(directory, filename);
-      if (fs25.existsSync(rootPath)) {
-        fs25.unlinkSync(rootPath);
+      const rootPath = path55.join(directory, filename);
+      if (fs26.existsSync(rootPath)) {
+        fs26.unlinkSync(rootPath);
         results.push(`- \u2705 Deleted ${filename} (root)`);
       }
     } catch (err) {
@@ -28403,8 +28743,8 @@ async function handleResetCommand(directory, args) {
   }
   try {
     const summariesPath = validateSwarmPath(directory, "summaries");
-    if (fs25.existsSync(summariesPath)) {
-      fs25.rmSync(summariesPath, { recursive: true, force: true });
+    if (fs26.existsSync(summariesPath)) {
+      fs26.rmSync(summariesPath, { recursive: true, force: true });
       results.push("- \u2705 Deleted summaries/ directory");
     } else {
       results.push("- \u23ED\uFE0F summaries/ not found (skipped)");
@@ -28423,8 +28763,8 @@ async function handleResetCommand(directory, args) {
 }
 
 // src/commands/reset-session.ts
-import * as fs27 from "fs";
-import * as path56 from "path";
+import * as fs28 from "fs";
+import * as path57 from "path";
 
 // src/hooks/trajectory-logger.ts
 var callStartTimes = new Map;
@@ -28830,17 +29170,17 @@ function detectPatterns(trajectory, config, lastProcessedStep = 0) {
   };
 }
 // src/prm/replay.ts
-import { promises as fs26 } from "fs";
-import path55 from "path";
+import { promises as fs27 } from "fs";
+import path56 from "path";
 function isPathSafe(targetPath, basePath) {
-  const resolvedTarget = path55.resolve(targetPath);
-  const resolvedBase = path55.resolve(basePath);
-  const rel = path55.relative(resolvedBase, resolvedTarget);
-  return !rel.startsWith("..") && !path55.isAbsolute(rel);
+  const resolvedTarget = path56.resolve(targetPath);
+  const resolvedBase = path56.resolve(basePath);
+  const rel = path56.relative(resolvedBase, resolvedTarget);
+  return !rel.startsWith("..") && !path56.isAbsolute(rel);
 }
 function isWithinReplaysDir(targetPath) {
-  const resolved = path55.resolve(targetPath);
-  const parts = resolved.split(path55.sep);
+  const resolved = path56.resolve(targetPath);
+  const parts = resolved.split(path56.sep);
   for (let i = 0;i < parts.length - 1; i++) {
     if (parts[i] === ".swarm" && parts[i + 1] === "replays") {
       return true;
@@ -28853,15 +29193,15 @@ function sanitizeFilename(input) {
 }
 async function startReplayRecording(sessionID, directory) {
   try {
-    const replayDir = path55.join(directory, ".swarm", "replays");
+    const replayDir = path56.join(directory, ".swarm", "replays");
     const safeSessionID = sanitizeFilename(sessionID);
     const filename = `${safeSessionID}-${Date.now()}.jsonl`;
-    const filepath = path55.join(replayDir, filename);
+    const filepath = path56.join(replayDir, filename);
     if (!isPathSafe(filepath, replayDir)) {
       console.warn(`[replay] Invalid path detected - path traversal attempt blocked for session ${sessionID}`);
       return null;
     }
-    await fs26.mkdir(replayDir, { recursive: true });
+    await fs27.mkdir(replayDir, { recursive: true });
     return filepath;
   } catch (err) {
     console.warn(`[replay] Failed to start recording for session ${sessionID}: ${err}`);
@@ -28881,7 +29221,7 @@ async function recordReplayEntry(artifactPath, sessionID, entry) {
     };
     const line = `${JSON.stringify(fullEntry)}
 `;
-    await fs26.appendFile(artifactPath, line, "utf-8");
+    await fs27.appendFile(artifactPath, line, "utf-8");
   } catch (err) {
     console.warn(`[replay] Failed to record entry: ${err}`);
   }
@@ -28925,8 +29265,8 @@ async function handleResetSessionCommand(directory, _args) {
   const results = [];
   try {
     const statePath = validateSwarmPath(directory, "session/state.json");
-    if (fs27.existsSync(statePath)) {
-      fs27.unlinkSync(statePath);
+    if (fs28.existsSync(statePath)) {
+      fs28.unlinkSync(statePath);
       results.push("\u2705 Deleted .swarm/session/state.json");
     } else {
       results.push("\u23ED\uFE0F state.json not found (already clean)");
@@ -28934,11 +29274,11 @@ async function handleResetSessionCommand(directory, _args) {
   } catch {
     results.push("\u274C Failed to delete state.json");
   }
-  const sessionDir = path56.dirname(validateSwarmPath(directory, "session/state.json"));
+  const sessionDir = path57.dirname(validateSwarmPath(directory, "session/state.json"));
   let sessionFiles = [];
-  if (fs27.existsSync(sessionDir)) {
+  if (fs28.existsSync(sessionDir)) {
     try {
-      sessionFiles = fs27.readdirSync(sessionDir);
+      sessionFiles = fs28.readdirSync(sessionDir);
     } catch (err) {
       results.push(`\u274C Failed to read session directory: ${errorMessage(err)}`);
     }
@@ -28946,13 +29286,13 @@ async function handleResetSessionCommand(directory, _args) {
   for (const file of sessionFiles) {
     if (file === "state.json")
       continue;
-    const filePath = path56.join(sessionDir, file);
+    const filePath = path57.join(sessionDir, file);
     try {
-      if (!fs27.existsSync(filePath))
+      if (!fs28.existsSync(filePath))
         continue;
-      if (!fs27.lstatSync(filePath).isFile())
+      if (!fs28.lstatSync(filePath).isFile())
         continue;
-      fs27.unlinkSync(filePath);
+      fs28.unlinkSync(filePath);
       results.push(`\u2713 Deleted ${file}`);
     } catch (err) {
       results.push(`\u274C Failed to delete ${file}: ${errorMessage(err)}`);
@@ -28981,7 +29321,7 @@ async function handleResetSessionCommand(directory, _args) {
 }
 
 // src/summaries/manager.ts
-import * as path57 from "path";
+import * as path58 from "path";
 var SUMMARY_ID_REGEX = /^S\d+$/;
 function sanitizeSummaryId(id) {
   if (!id || id.length === 0) {
@@ -29005,7 +29345,7 @@ function sanitizeSummaryId(id) {
 }
 async function loadFullOutput(directory, id) {
   const sanitizedId = sanitizeSummaryId(id);
-  const relativePath = path57.join("summaries", `${sanitizedId}.json`);
+  const relativePath = path58.join("summaries", `${sanitizedId}.json`);
   validateSwarmPath(directory, relativePath);
   const content = await readSwarmFileAsync(directory, relativePath);
   if (content === null) {
@@ -29057,18 +29397,18 @@ ${error2 instanceof Error ? error2.message : String(error2)}`;
 }
 
 // src/commands/rollback.ts
-import * as fs28 from "fs";
-import * as path58 from "path";
+import * as fs29 from "fs";
+import * as path59 from "path";
 async function handleRollbackCommand(directory, args) {
   const phaseArg = args[0];
   if (!phaseArg) {
     const manifestPath2 = validateSwarmPath(directory, "checkpoints/manifest.json");
-    if (!fs28.existsSync(manifestPath2)) {
+    if (!fs29.existsSync(manifestPath2)) {
       return "No checkpoints found. Use `/swarm checkpoint` to create checkpoints.";
     }
     let manifest2;
     try {
-      manifest2 = JSON.parse(fs28.readFileSync(manifestPath2, "utf-8"));
+      manifest2 = JSON.parse(fs29.readFileSync(manifestPath2, "utf-8"));
     } catch {
       return "Error: Checkpoint manifest is corrupted. Delete .swarm/checkpoints/manifest.json and re-checkpoint.";
     }
@@ -29090,12 +29430,12 @@ async function handleRollbackCommand(directory, args) {
     return "Error: Phase number must be a positive integer.";
   }
   const manifestPath = validateSwarmPath(directory, "checkpoints/manifest.json");
-  if (!fs28.existsSync(manifestPath)) {
+  if (!fs29.existsSync(manifestPath)) {
     return `Error: No checkpoints found. Cannot rollback to phase ${targetPhase}.`;
   }
   let manifest;
   try {
-    manifest = JSON.parse(fs28.readFileSync(manifestPath, "utf-8"));
+    manifest = JSON.parse(fs29.readFileSync(manifestPath, "utf-8"));
   } catch {
     return `Error: Checkpoint manifest is corrupted. Delete .swarm/checkpoints/manifest.json and re-checkpoint.`;
   }
@@ -29105,10 +29445,10 @@ async function handleRollbackCommand(directory, args) {
     return `Error: Checkpoint for phase ${targetPhase} not found. Available phases: ${available}`;
   }
   const checkpointDir = validateSwarmPath(directory, `checkpoints/phase-${targetPhase}`);
-  if (!fs28.existsSync(checkpointDir)) {
+  if (!fs29.existsSync(checkpointDir)) {
     return `Error: Checkpoint directory for phase ${targetPhase} does not exist.`;
   }
-  const checkpointFiles = fs28.readdirSync(checkpointDir);
+  const checkpointFiles = fs29.readdirSync(checkpointDir);
   if (checkpointFiles.length === 0) {
     return `Error: Checkpoint for phase ${targetPhase} is empty. Cannot rollback.`;
   }
@@ -29124,10 +29464,10 @@ async function handleRollbackCommand(directory, args) {
     if (EXCLUDE_FILES.has(file) || file.startsWith("plan-ledger.archived-")) {
       continue;
     }
-    const src = path58.join(checkpointDir, file);
-    const dest = path58.join(swarmDir, file);
+    const src = path59.join(checkpointDir, file);
+    const dest = path59.join(swarmDir, file);
     try {
-      fs28.cpSync(src, dest, { recursive: true, force: true });
+      fs29.cpSync(src, dest, { recursive: true, force: true });
       successes.push(file);
     } catch (error2) {
       failures.push({ file, error: error2.message });
@@ -29144,11 +29484,11 @@ async function handleRollbackCommand(directory, args) {
     ].join(`
 `);
   }
-  const existingLedgerPath = path58.join(swarmDir, "plan-ledger.jsonl");
+  const existingLedgerPath = path59.join(swarmDir, "plan-ledger.jsonl");
   let ledgerDeletionFailed = false;
-  if (fs28.existsSync(existingLedgerPath)) {
+  if (fs29.existsSync(existingLedgerPath)) {
     try {
-      fs28.unlinkSync(existingLedgerPath);
+      fs29.unlinkSync(existingLedgerPath);
     } catch (err) {
       ledgerDeletionFailed = true;
       const errMsg = err instanceof Error ? err.message : String(err);
@@ -29157,9 +29497,9 @@ async function handleRollbackCommand(directory, args) {
   }
   if (!ledgerDeletionFailed) {
     try {
-      const planJsonPath = path58.join(swarmDir, "plan.json");
-      if (fs28.existsSync(planJsonPath)) {
-        const planRaw = fs28.readFileSync(planJsonPath, "utf-8");
+      const planJsonPath = path59.join(swarmDir, "plan.json");
+      if (fs29.existsSync(planJsonPath)) {
+        const planRaw = fs29.readFileSync(planJsonPath, "utf-8");
         const plan = PlanSchema.parse(JSON.parse(planRaw));
         const planId = derivePlanId(plan);
         const planHash = computePlanHash(plan);
@@ -29187,7 +29527,7 @@ async function handleRollbackCommand(directory, args) {
     timestamp: new Date().toISOString()
   };
   try {
-    fs28.appendFileSync(eventsPath, `${JSON.stringify(rollbackEvent)}
+    fs29.appendFileSync(eventsPath, `${JSON.stringify(rollbackEvent)}
 `);
   } catch (error2) {
     console.error("Failed to write rollback event:", error2 instanceof Error ? error2.message : String(error2));
@@ -29417,13 +29757,13 @@ Ensure this is a git repository with commit history.`;
   const report = reportLines.filter(Boolean).join(`
 `);
   try {
-    const fs29 = await import("fs/promises");
-    const path59 = await import("path");
-    const reportPath = path59.join(directory, ".swarm", "simulate-report.md");
-    await fs29.mkdir(path59.dirname(reportPath), { recursive: true });
-    const reportTempPath = path59.join(path59.dirname(reportPath), `${path59.basename(reportPath)}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+    const fs30 = await import("fs/promises");
+    const path60 = await import("path");
+    const reportPath = path60.join(directory, ".swarm", "simulate-report.md");
+    await fs30.mkdir(path60.dirname(reportPath), { recursive: true });
+    const reportTempPath = path60.join(path60.dirname(reportPath), `${path60.basename(reportPath)}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
     try {
-      await fs29.writeFile(reportTempPath, report, "utf-8");
+      await fs30.writeFile(reportTempPath, report, "utf-8");
       renameSync11(reportTempPath, reportPath);
     } catch (err) {
       try {
@@ -29450,20 +29790,20 @@ async function handleSpecifyCommand(_directory, args) {
 // src/services/status-service.ts
 import * as fsSync3 from "fs";
 import { readFile as readFile16 } from "fs/promises";
-import * as path60 from "path";
+import * as path61 from "path";
 
 // src/turbo/lean/state.ts
 init_logger();
-import * as fs29 from "fs";
-import * as path59 from "path";
+import * as fs30 from "fs";
+import * as path60 from "path";
 var STATE_FILE3 = "turbo-state.json";
 function nowISO3() {
   return new Date().toISOString();
 }
 function ensureSwarmDir2(directory) {
-  const swarmDir = path59.resolve(directory, ".swarm");
-  if (!fs29.existsSync(swarmDir)) {
-    fs29.mkdirSync(swarmDir, { recursive: true });
+  const swarmDir = path60.resolve(directory, ".swarm");
+  if (!fs30.existsSync(swarmDir)) {
+    fs30.mkdirSync(swarmDir, { recursive: true });
   }
   return swarmDir;
 }
@@ -29506,17 +29846,17 @@ function markStateUnreadable2(directory, reason) {
 }
 function readPersisted2(directory) {
   try {
-    const filePath = path59.join(directory, ".swarm", STATE_FILE3);
-    if (!fs29.existsSync(filePath)) {
+    const filePath = path60.join(directory, ".swarm", STATE_FILE3);
+    if (!fs30.existsSync(filePath)) {
       const seed = emptyPersisted2();
       try {
         ensureSwarmDir2(directory);
-        fs29.writeFileSync(filePath, `${JSON.stringify(seed, null, 2)}
+        fs30.writeFileSync(filePath, `${JSON.stringify(seed, null, 2)}
 `, "utf-8");
       } catch {}
       return seed;
     }
-    const raw = fs29.readFileSync(filePath, "utf-8");
+    const raw = fs30.readFileSync(filePath, "utf-8");
     const parsed = JSON.parse(raw);
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed) || parsed.version !== 1 || !parsed.sessions || typeof parsed.sessions !== "object" || Array.isArray(parsed.sessions)) {
       markStateUnreadable2(directory, `malformed shape (version=${parsed?.version}, sessions type=${Array.isArray(parsed?.sessions) ? "array" : typeof parsed?.sessions})`);
@@ -29542,7 +29882,7 @@ function writePersisted2(directory, persisted) {
   let payload;
   try {
     ensureSwarmDir2(directory);
-    filePath = path59.join(directory, ".swarm", STATE_FILE3);
+    filePath = path60.join(directory, ".swarm", STATE_FILE3);
     tmpPath = `${filePath}.tmp.${Date.now()}`;
     persisted.updatedAt = nowISO3();
     payload = `${JSON.stringify(persisted, null, 2)}
@@ -29553,14 +29893,14 @@ function writePersisted2(directory, persisted) {
     throw new Error(`Lean Turbo state persistence prepare failed: ${msg}`);
   }
   try {
-    fs29.writeFileSync(tmpPath, payload, "utf-8");
-    fs29.renameSync(tmpPath, filePath);
+    fs30.writeFileSync(tmpPath, payload, "utf-8");
+    fs30.renameSync(tmpPath, filePath);
   } catch (error2) {
     const msg = error2 instanceof Error ? error2.message : String(error2);
     error(`[turbo/lean/state] Failed to persist ${STATE_FILE3} atomically: ${msg}`);
     try {
-      if (fs29.existsSync(tmpPath)) {
-        fs29.unlinkSync(tmpPath);
+      if (fs30.existsSync(tmpPath)) {
+        fs30.unlinkSync(tmpPath);
       }
     } catch {}
     throw new Error(`Lean Turbo state persistence failed: ${msg}`);
@@ -29660,7 +30000,7 @@ var _internals43 = {
 };
 function readSpecStalenessSnapshot(directory) {
   try {
-    const p = path60.join(directory, ".swarm", "spec-staleness.json");
+    const p = path61.join(directory, ".swarm", "spec-staleness.json");
     if (!fsSync3.existsSync(p))
       return { stale: false };
     const raw = fsSync3.readFileSync(p, "utf-8");
@@ -30193,11 +30533,11 @@ function buildStatusMessage2(session, directory, sessionID) {
 
 // src/commands/unlink.ts
 import { existsSync as existsSync36 } from "fs";
-import * as path61 from "path";
+import * as path62 from "path";
 var DEDUP_THRESHOLD2 = 0.6;
 async function copySharedKnowledgeToLocal(linkDir, localSwarmDir) {
-  const sharedPath = path61.join(linkDir, "knowledge.jsonl");
-  const localPath = path61.join(localSwarmDir, "knowledge.jsonl");
+  const sharedPath = path62.join(linkDir, "knowledge.jsonl");
+  const localPath = path62.join(localSwarmDir, "knowledge.jsonl");
   if (!existsSync36(sharedPath))
     return 0;
   const sharedEntries = await readKnowledge(sharedPath);
@@ -30232,7 +30572,7 @@ async function handleUnlinkCommand(directory, args) {
   let copied = 0;
   if (copyBack) {
     try {
-      copied = await copySharedKnowledgeToLocal(linkDir, path61.join(directory, ".swarm"));
+      copied = await copySharedKnowledgeToLocal(linkDir, path62.join(directory, ".swarm"));
     } catch (error2) {
       return `\u274C Failed to copy shared knowledge back to local: ${error2 instanceof Error ? error2.message : String(error2)}`;
     }
@@ -30387,7 +30727,7 @@ function buildDetailedHelp(commandName, entry) {
 async function handleHelpCommand(ctx) {
   const targetCommand = ctx.args.join(" ");
   if (!targetCommand) {
-    const { buildHelpText } = await import("./index-ary5jkky.js");
+    const { buildHelpText } = await import("./index-dy6zs70b.js");
     return buildHelpText();
   }
   const tokens = targetCommand.split(/\s+/);
@@ -30396,7 +30736,7 @@ async function handleHelpCommand(ctx) {
     return _internals45.buildDetailedHelp(resolved.key, resolved.entry);
   }
   const similar = _internals45.findSimilarCommands(targetCommand);
-  const { buildHelpText: fullHelp } = await import("./index-ary5jkky.js");
+  const { buildHelpText: fullHelp } = await import("./index-dy6zs70b.js");
   if (similar.length > 0) {
     return `Command '/swarm ${targetCommand}' not found.
 
@@ -30529,7 +30869,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail explain": {
     handler: async (ctx) => {
-      const { handleGuardrailExplain } = await import("./guardrail-explain-ygfy1qg9.js");
+      const { handleGuardrailExplain } = await import("./guardrail-explain-bjsc2ydm.js");
       return handleGuardrailExplain(ctx.directory, ctx.args);
     },
     description: "Dry-run: show what the guardrails would do to a command or write target (executes nothing)",
@@ -31300,24 +31640,24 @@ function validateAliases() {
       }
       aliasTargets.get(target).push(name);
       const visited = new Set;
-      const path62 = [];
+      const path63 = [];
       let current = target;
       while (current) {
         const currentEntry = COMMAND_REGISTRY[current];
         if (!currentEntry)
           break;
         if (visited.has(current)) {
-          const cycleStart = path62.indexOf(current);
+          const cycleStart = path63.indexOf(current);
           const fullChain = [
             name,
-            ...path62.slice(0, cycleStart > 0 ? cycleStart : path62.length),
+            ...path63.slice(0, cycleStart > 0 ? cycleStart : path63.length),
             current
           ].join(" \u2192 ");
           errors.push(`Circular alias detected: ${fullChain}`);
           break;
         }
         visited.add(current);
-        path62.push(current);
+        path63.push(current);
         current = currentEntry.aliasOf || "";
       }
     }