opencode-swarm 7.98.1 → 7.99.0

package/dist/cli/{index-zgba613y.js → index-hw8r3e5p.js}

@@ -23,7 +23,7 @@ import {
   validateActionability,
   validateActionableFields,
   validateLesson
-} from "./index-fjxjb66n.js";
+} from "./index-vwyjkzgs.js";
 import {
   appendKnowledge,
   appendRejectedLesson,
@@ -51,13 +51,13 @@ import {
   transactFile,
   transactKnowledge,
   writeLinkPointer
-} from "./index-hb10a2g8.js";
+} from "./index-f7nma02k.js";
 import {
   detectStraySwarmDirs,
   readDoctorArtifact,
   removeStraySwarmDir,
   runConfigDoctor
-} from "./index-zy22fg5h.js";
+} from "./index-svf2zjxs.js";
 import {
   AGENT_TOOL_MAP,
   ALL_SUBAGENT_NAMES,
@@ -70,7 +70,7 @@ import {
   TOOL_NAME_SET,
   resolveExternalSkillsConfig,
   stripKnownSwarmPrefix
-} from "./index-471qxz9g.js";
+} from "./index-7hnwnw5g.js";
 import {
   MAX_TRANSIENT_RETRIES,
   PlanSchema,
@@ -114,7 +114,7 @@ import {
   transientBackoff,
   validateProjectRoot,
   writeProjectedSpecSync
-} from "./index-4c5jpmn9.js";
+} from "./index-wwnjw0fb.js";
 import {
   _internals as _internals2,
   _internals1 as _internals3,
@@ -132,18 +132,18 @@ import {
 } from "./index-v4fcn4tr.js";
 import {
   atomicWriteFile
-} from "./index-kv4dd5c5.js";
+} from "./index-9b7qp18e.js";
 import {
   buildCorrelationId,
   listActive,
   subscribe,
   unsubscribe
-} from "./index-sf08zj91.js";
+} from "./index-5fxjagjt.js";
 import {
   readSwarmFileAsync,
   safeHook,
   validateSwarmPath
-} from "./index-gn8n22th.js";
+} from "./index-we94wkty.js";
 import {
   deepMerge
 } from "./index-p0arc26j.js";
@@ -156,7 +156,7 @@ import {
 import {
   require_proper_lockfile,
   tryAcquireLock
-} from "./index-91qtsbce.js";
+} from "./index-3naa2ajc.js";
 import {
   exports_external
 } from "./index-293f68mj.js";
@@ -166,7 +166,7 @@ import {
 } from "./index-b9v501fr.js";
 import {
   telemetry
-} from "./index-xchgryg4.js";
+} from "./index-vn263hqt.js";
 import {
   __esm,
   __export,
@@ -909,7 +909,7 @@ var init_executor = __esm(() => {
 // package.json
 var package_default = {
   name: "opencode-swarm",
-  version: "7.98.1",
+  version: "7.99.0",
   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",
@@ -3624,15 +3624,30 @@ function classifySwarmCommandToolUse(resolved) {
     }
   }
   if (canonicalKey === "benchmark") {
-    const allowedFlags = new Set(["--cumulative", "--ci-gate"]);
-    const invalid = args.filter((arg) => !allowedFlags.has(arg));
-    if (invalid.length > 0) {
+    for (let i = 0;i < args.length; i++) {
+      const arg = args[i];
+      if (arg === "--cumulative" || arg === "--ci-gate")
+        continue;
+      if (arg === "--max-cost-usd" && i + 1 < args.length && /^\d+(\.\d+)?$/.test(args[i + 1])) {
+        i++;
+        continue;
+      }
       return {
         allowed: false,
-        message: "Only `--cumulative` and `--ci-gate` are supported for `/swarm benchmark` through swarm_command."
+        message: "Only `--cumulative`, `--ci-gate`, and `--max-cost-usd <n>` are supported for `/swarm benchmark` through swarm_command."
       };
     }
   }
+  if (canonicalKey === "costs") {
+    if (args.length === 0)
+      return { allowed: true };
+    if (args.length === 1 && args[0] === "--json")
+      return { allowed: true };
+    return {
+      allowed: false,
+      message: "Usage through swarm_command: `/swarm costs` or `/swarm costs --json`."
+    };
+  }
   if (canonicalKey === "show-plan") {
     if (args.length > 1 || args[0] && !/^\d+$/.test(args[0])) {
       return {
@@ -5474,6 +5489,9 @@ function startAgentSession(sessionId, agentName, staleDurationMs = 7200000, dire
     swarmState.pendingRehydrations.add(rehydrationPromise);
   }
 }
+function endAgentSession(sessionId) {
+  swarmState.agentSessions.delete(sessionId);
+}
 function getAgentSession(sessionId) {
   return swarmState.agentSessions.get(sessionId);
 }
@@ -5978,7 +5996,7 @@ function hasActiveEpicMode(sessionID) {
 async function rehydratePrSubscriptions(sessionID, directory) {
   const map = new Map;
   try {
-    const { listActive: listActive2 } = await import("./pr-subscriptions-2565fpsc.js");
+    const { listActive: listActive2 } = await import("./pr-subscriptions-fqrzm0tv.js");
     const records = await listActive2(directory);
     for (const record of records) {
       if (record.sessionID !== sessionID)
@@ -6055,6 +6073,199 @@ async function handleAutoProceedCommand(_directory, args, sessionID) {
   }
 }
 
+// src/services/cost-accounting.ts
+import * as fs7 from "fs";
+import * as os6 from "os";
+import * as path12 from "path";
+function summarizeTelemetryCosts(directory) {
+  const summary = createEmptySummary();
+  for (const event of readTelemetryEvents(directory)) {
+    if (event.event !== "delegation_end")
+      continue;
+    addDelegationEvent(summary, event);
+  }
+  return finalizeSummary(summary);
+}
+function readTelemetryEvents(directory) {
+  const swarmDir = path12.join(directory, ".swarm");
+  const files = [
+    path12.join(swarmDir, "telemetry.jsonl.1"),
+    path12.join(swarmDir, "telemetry.jsonl")
+  ];
+  const tmpDir = fs7.mkdtempSync(path12.join(os6.tmpdir(), "telemetry-snapshot-"));
+  const snapshotFiles = [];
+  try {
+    for (const file of files) {
+      if (!fs7.existsSync(file))
+        continue;
+      const snap = path12.join(tmpDir, path12.basename(file));
+      try {
+        fs7.copyFileSync(file, snap);
+        snapshotFiles.push(snap);
+      } catch {}
+    }
+  } catch {}
+  const events = [];
+  for (const file of snapshotFiles) {
+    let content = "";
+    try {
+      content = fs7.readFileSync(file, "utf-8");
+    } catch {
+      continue;
+    }
+    for (const line of content.split(/\r?\n/)) {
+      const trimmed = line.trim();
+      if (!trimmed)
+        continue;
+      try {
+        const parsed = JSON.parse(trimmed);
+        if (isRecord(parsed))
+          events.push(parsed);
+      } catch {}
+    }
+  }
+  try {
+    for (const f of snapshotFiles) {
+      try {
+        fs7.unlinkSync(f);
+      } catch {}
+    }
+    fs7.rmdirSync(tmpDir);
+  } catch {}
+  return events;
+}
+function readNumber(record, keys) {
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "number" && Number.isFinite(value) && value >= 0)
+      return value;
+    if (typeof value === "string" && value.trim() !== "") {
+      const parsed = Number(value);
+      if (Number.isFinite(parsed) && parsed >= 0)
+        return parsed;
+    }
+  }
+  return null;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function createEmptySummary() {
+  return {
+    total_cost_usd: 0,
+    total_reported_usd: 0,
+    total_estimated_usd: 0,
+    total_input_tokens: 0,
+    total_output_tokens: 0,
+    total_reasoning_tokens: 0,
+    total_cache_tokens: 0,
+    delegations: 0,
+    unavailable_delegations: 0,
+    by_agent: [],
+    by_task: [],
+    by_gate: [],
+    by_retry: [],
+    by_source: {
+      reported: { delegations: 0, cost_usd: 0 },
+      estimated: { delegations: 0, cost_usd: 0 },
+      unavailable: { delegations: 0, cost_usd: 0 }
+    }
+  };
+}
+function addDelegationEvent(summary, event) {
+  const costSource = parseCostSource(event.cost_source);
+  const cost = readNumber(event, ["cost_usd"]) ?? 0;
+  const usage = {
+    tokens_input: readNumber(event, ["tokens_input"]) ?? 0,
+    tokens_output: readNumber(event, ["tokens_output"]) ?? 0,
+    tokens_reasoning: readNumber(event, ["tokens_reasoning"]) ?? 0,
+    tokens_cache: readNumber(event, ["tokens_cache"]) ?? 0
+  };
+  summary.delegations++;
+  summary.total_cost_usd += cost;
+  summary.total_input_tokens += usage.tokens_input;
+  summary.total_output_tokens += usage.tokens_output;
+  summary.total_reasoning_tokens += usage.tokens_reasoning;
+  summary.total_cache_tokens += usage.tokens_cache;
+  summary.by_source[costSource].delegations++;
+  summary.by_source[costSource].cost_usd += cost;
+  if (costSource === "reported")
+    summary.total_reported_usd += cost;
+  if (costSource === "estimated")
+    summary.total_estimated_usd += cost;
+  if (costSource === "unavailable")
+    summary.unavailable_delegations++;
+  addRow(summary.by_agent, String(event.agentName ?? event.agent ?? "unknown"), {
+    cost,
+    costSource,
+    usage
+  });
+  addRow(summary.by_task, String(event.taskId ?? event.task_id ?? "unknown"), {
+    cost,
+    costSource,
+    usage
+  });
+  addRow(summary.by_gate, String(event.gate ?? "unknown"), {
+    cost,
+    costSource,
+    usage
+  });
+  addRow(summary.by_retry, String(readNumber(event, ["retry_index", "retryIndex"]) ?? 0), {
+    cost,
+    costSource,
+    usage
+  });
+}
+function addRow(rows, name, input) {
+  let row = rows.find((candidate) => candidate.name === name);
+  if (!row) {
+    row = {
+      name,
+      delegations: 0,
+      cost_usd: 0,
+      input_tokens: 0,
+      output_tokens: 0,
+      reasoning_tokens: 0,
+      cache_tokens: 0,
+      unavailable_delegations: 0
+    };
+    rows.push(row);
+  }
+  row.delegations++;
+  row.cost_usd += input.cost;
+  row.input_tokens += input.usage.tokens_input;
+  row.output_tokens += input.usage.tokens_output;
+  row.reasoning_tokens += input.usage.tokens_reasoning;
+  row.cache_tokens += input.usage.tokens_cache;
+  if (input.costSource === "unavailable")
+    row.unavailable_delegations++;
+}
+function finalizeSummary(summary) {
+  summary.total_cost_usd = roundUsd(summary.total_cost_usd);
+  summary.total_reported_usd = roundUsd(summary.total_reported_usd);
+  summary.total_estimated_usd = roundUsd(summary.total_estimated_usd);
+  for (const source of Object.values(summary.by_source)) {
+    source.cost_usd = roundUsd(source.cost_usd);
+  }
+  for (const rows of [
+    summary.by_agent,
+    summary.by_task,
+    summary.by_gate,
+    summary.by_retry
+  ]) {
+    for (const row of rows)
+      row.cost_usd = roundUsd(row.cost_usd);
+    rows.sort((a, b) => b.cost_usd - a.cost_usd || b.delegations - a.delegations);
+  }
+  return summary;
+}
+function parseCostSource(value) {
+  return value === "reported" || value === "estimated" || value === "unavailable" ? value : "unavailable";
+}
+function roundUsd(value) {
+  return Math.round(value * 1e6) / 1e6;
+}
+
 // src/commands/benchmark.ts
 var CI = {
   review_pass_rate: 70,
@@ -6070,7 +6281,9 @@ async function handleBenchmarkCommand(directory, args) {
   let cumulative = args.includes("--cumulative");
   if (args.includes("--ci-gate"))
     cumulative = true;
+  const maxCostUsd = parseMaxCostUsd(args);
   const mode = cumulative ? "cumulative" : "in-memory";
+  const costSummary = cumulative ? summarizeTelemetryCosts(directory) : undefined;
   const agentMap = new Map;
   for (const [, s] of swarmState.agentSessions) {
     const e = agentMap.get(s.agentName) || {
@@ -6262,6 +6475,15 @@ async function handleBenchmarkCommand(directory, args) {
         passed: !hasQualityEvidence || testToCodeRatio >= CI.min_test_to_code_ratio
       }
     ];
+    if (maxCostUsd !== null) {
+      checks.push({
+        name: "Total cost",
+        value: costSummary?.total_cost_usd ?? 0,
+        threshold: maxCostUsd,
+        operator: "<=",
+        passed: (costSummary?.total_cost_usd ?? 0) <= maxCostUsd
+      });
+    }
     ciGate = { passed: checks.every((c) => c.passed), checks };
   }
   const lines = [
@@ -6313,16 +6535,23 @@ async function handleBenchmarkCommand(directory, args) {
     lines.push(`- Test-to-Code Ratio: ${qualityMetrics.testToCodeRatio}% (min: ${qualityMetrics.thresholds.minTestToCodeRatio}%) ${qualityMetrics.testToCodeRatio >= qualityMetrics.thresholds.minTestToCodeRatio ? "\u2705" : "\u274C"}`);
     lines.push("");
   }
+  if (costSummary) {
+    lines.push("### Cost Signals");
+    lines.push(`- Total tracked cost: $${costSummary.total_cost_usd.toFixed(6)} (${costSummary.delegations} delegations)`, `- Reported: $${costSummary.total_reported_usd.toFixed(6)}; estimated: $${costSummary.total_estimated_usd.toFixed(6)}; unavailable: ${costSummary.unavailable_delegations}`);
+    lines.push("");
+  }
   if (ciGate) {
     lines.push("### CI Gate", ciGate.passed ? "\u2705 PASSED" : "\u274C FAILED");
     for (const c of ciGate.checks) {
       let valueStr;
       if (c.name === "Complexity Delta" || c.name === "Public API Delta") {
         valueStr = `${c.value}`;
+      } else if (c.name === "Total cost") {
+        valueStr = `$${c.value.toFixed(6)}`;
       } else {
         valueStr = `${c.value}%`;
       }
-      const thresholdStr = c.name === "Complexity Delta" || c.name === "Public API Delta" ? `${c.threshold}` : `${c.threshold}%`;
+      const thresholdStr = c.name === "Complexity Delta" || c.name === "Public API Delta" ? `${c.threshold}` : c.name === "Total cost" ? `$${c.threshold.toFixed(6)}` : `${c.threshold}%`;
       lines.push(`- ${c.name}: ${valueStr} ${c.operator} ${thresholdStr} ${c.passed ? "\u2705" : "\u274C"}`);
     }
     lines.push("");
@@ -6363,6 +6592,18 @@ async function handleBenchmarkCommand(directory, args) {
       thresholds: qualityMetrics.thresholds,
       has_evidence: qualityMetrics.hasEvidence
     };
+  if (costSummary)
+    json.costs = {
+      total_cost_usd: costSummary.total_cost_usd,
+      total_reported_usd: costSummary.total_reported_usd,
+      total_estimated_usd: costSummary.total_estimated_usd,
+      total_input_tokens: costSummary.total_input_tokens,
+      total_output_tokens: costSummary.total_output_tokens,
+      total_reasoning_tokens: costSummary.total_reasoning_tokens,
+      total_cache_tokens: costSummary.total_cache_tokens,
+      delegations: costSummary.delegations,
+      unavailable_delegations: costSummary.unavailable_delegations
+    };
   if (ciGate)
     json.ci_gate = {
       passed: ciGate.passed,
@@ -6378,6 +6619,20 @@ async function handleBenchmarkCommand(directory, args) {
   return lines.join(`
 `);
 }
+function parseMaxCostUsd(args) {
+  const index = args.indexOf("--max-cost-usd");
+  if (index === -1)
+    return null;
+  const raw = args[index + 1];
+  if (!raw || raw.startsWith("--")) {
+    throw new Error("Invalid --max-cost-usd value: expected a non-negative number.");
+  }
+  const parsed = Number(raw);
+  if (!Number.isFinite(parsed) || parsed < 0) {
+    throw new Error("Invalid --max-cost-usd value: expected a non-negative number.");
+  }
+  return parsed;
+}
 
 // src/commands/brainstorm.ts
 function sanitizeTopic(raw) {
@@ -6399,8 +6654,8 @@ async function handleBrainstormCommand(_directory, args) {
 
 // src/tools/checkpoint.ts
 import * as child_process from "child_process";
-import * as fs7 from "fs";
-import * as path12 from "path";
+import * as fs8 from "fs";
+import * as path13 from "path";
 
 // src/tools/create-tool.ts
 function classifyToolError(error2) {
@@ -6487,13 +6742,13 @@ function validateLabel(label) {
   return null;
 }
 function getCheckpointLogPath(directory) {
-  return path12.join(directory, CHECKPOINT_LOG_PATH);
+  return path13.join(directory, CHECKPOINT_LOG_PATH);
 }
 function readCheckpointLog(directory) {
   const logPath = getCheckpointLogPath(directory);
   try {
-    if (fs7.existsSync(logPath)) {
-      const content = fs7.readFileSync(logPath, "utf-8");
+    if (fs8.existsSync(logPath)) {
+      const content = fs8.readFileSync(logPath, "utf-8");
       const parsed = JSON.parse(content);
       if (!parsed.checkpoints || !Array.isArray(parsed.checkpoints)) {
         return { version: 1, checkpoints: [] };
@@ -6505,13 +6760,13 @@ function readCheckpointLog(directory) {
 }
 function writeCheckpointLog(log2, directory) {
   const logPath = getCheckpointLogPath(directory);
-  const dir = path12.dirname(logPath);
-  if (!fs7.existsSync(dir)) {
-    fs7.mkdirSync(dir, { recursive: true });
+  const dir = path13.dirname(logPath);
+  if (!fs8.existsSync(dir)) {
+    fs8.mkdirSync(dir, { recursive: true });
   }
   const tempPath = `${logPath}.tmp`;
-  fs7.writeFileSync(tempPath, JSON.stringify(log2, null, 2), "utf-8");
-  fs7.renameSync(tempPath, logPath);
+  fs8.writeFileSync(tempPath, JSON.stringify(log2, null, 2), "utf-8");
+  fs8.renameSync(tempPath, logPath);
 }
 function gitExec(args, cwd) {
   for (let attempt = 0;attempt < MAX_TRANSIENT_RETRIES; attempt++) {
@@ -6542,10 +6797,10 @@ function gitExec(args, cwd) {
 }
 function appendRetentionEvent(directory, event) {
   try {
-    const eventsPath = path12.join(directory, ".swarm", "events.jsonl");
+    const eventsPath = path13.join(directory, ".swarm", "events.jsonl");
     const line = `${JSON.stringify({ ...event, timestamp: new Date().toISOString() })}
 `;
-    fs7.appendFileSync(eventsPath, line);
+    fs8.appendFileSync(eventsPath, line);
   } catch {}
 }
 function getCurrentSha(directory) {
@@ -6907,8 +7162,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 fs12 } from "fs";
-import path25 from "path";
+import { promises as fs13 } from "fs";
+import path26 from "path";
 
 // src/hooks/abort-utils.ts
 function isAbortError(err) {
@@ -7037,8 +7292,8 @@ function createCuratorLLMDelegate(directory, mode = "init", sessionId) {
 }
 
 // src/hooks/curator-postmortem.ts
-import { existsSync as existsSync5, readdirSync, readFileSync as readFileSync5 } from "fs";
-import * as path13 from "path";
+import { existsSync as existsSync6, readdirSync, readFileSync as readFileSync6 } from "fs";
+import * as path14 from "path";
 var MAX_INPUT_TEXT_CHARS = 500;
 var MAX_KNOWLEDGE_ENTRIES = 500;
 var MAX_PROPOSALS = 50;
@@ -7083,9 +7338,9 @@ async function collectKnowledgeSummary(directory) {
 }
 function readJsonlFile(filePath, maxLines) {
   try {
-    if (!existsSync5(filePath))
+    if (!existsSync6(filePath))
       return [];
-    const content = readFileSync5(filePath, "utf-8");
+    const content = readFileSync6(filePath, "utf-8");
     const results = [];
     const max = maxLines !== undefined && maxLines > 0 ? maxLines : Infinity;
     for (const line of content.split(`
@@ -7105,16 +7360,16 @@ function readJsonlFile(filePath, maxLines) {
 }
 function collectRetrospectives(directory) {
   const results = [];
-  const evidenceDir = path13.join(directory, ".swarm", "evidence");
+  const evidenceDir = path14.join(directory, ".swarm", "evidence");
   try {
-    if (!existsSync5(evidenceDir))
+    if (!existsSync6(evidenceDir))
       return results;
     const retroDirs = readdirSync(evidenceDir, { withFileTypes: true }).filter((e) => e.isDirectory() && e.name.startsWith("retro-")).slice(0, MAX_RETROSPECTIVES);
     for (const entry of retroDirs) {
-      const retroPath = path13.join(evidenceDir, entry.name, "evidence.json");
-      if (existsSync5(retroPath)) {
+      const retroPath = path14.join(evidenceDir, entry.name, "evidence.json");
+      if (existsSync6(retroPath)) {
         try {
-          results.push(readFileSync5(retroPath, "utf-8"));
+          results.push(readFileSync6(retroPath, "utf-8"));
         } catch {}
       }
     }
@@ -7123,14 +7378,14 @@ function collectRetrospectives(directory) {
 }
 function collectDriftReports(directory) {
   const results = [];
-  const swarmDir = path13.join(directory, ".swarm");
+  const swarmDir = path14.join(directory, ".swarm");
   try {
-    if (!existsSync5(swarmDir))
+    if (!existsSync6(swarmDir))
       return results;
     const driftFiles = readdirSync(swarmDir).filter((e) => e.startsWith("drift-report-phase-") && e.endsWith(".json")).slice(0, MAX_DRIFT_REPORTS);
     for (const entry of driftFiles) {
       try {
-        results.push(readFileSync5(path13.join(swarmDir, entry), "utf-8"));
+        results.push(readFileSync6(path14.join(swarmDir, entry), "utf-8"));
       } catch {}
     }
   } catch {}
@@ -7138,24 +7393,24 @@ function collectDriftReports(directory) {
 }
 function collectPendingProposals(directory) {
   const results = [];
-  const insightPath = path13.join(directory, ".swarm", "insight-candidates.jsonl");
-  if (existsSync5(insightPath)) {
+  const insightPath = path14.join(directory, ".swarm", "insight-candidates.jsonl");
+  if (existsSync6(insightPath)) {
     try {
       results.push({
         source: "insight-candidates",
-        content: readFileSync5(insightPath, "utf-8")
+        content: readFileSync6(insightPath, "utf-8")
       });
     } catch {}
   }
-  const proposalsDir = path13.join(directory, ".swarm", "skills", "proposals");
+  const proposalsDir = path14.join(directory, ".swarm", "skills", "proposals");
   try {
-    if (existsSync5(proposalsDir)) {
+    if (existsSync6(proposalsDir)) {
       const proposalFiles = readdirSync(proposalsDir).filter((e) => e.endsWith(".md") || e.endsWith(".json")).slice(0, MAX_PROPOSALS);
       for (const entry of proposalFiles) {
         try {
           results.push({
             source: `proposals/${entry}`,
-            content: readFileSync5(path13.join(proposalsDir, entry), "utf-8")
+            content: readFileSync6(path14.join(proposalsDir, entry), "utf-8")
           });
         } catch {}
       }
@@ -7165,9 +7420,9 @@ function collectPendingProposals(directory) {
 }
 function isReportValid(reportPath) {
   try {
-    if (!existsSync5(reportPath))
+    if (!existsSync6(reportPath))
       return false;
-    const content = readFileSync5(reportPath, "utf-8").trim();
+    const content = readFileSync6(reportPath, "utf-8").trim();
     if (content.length === 0)
       return false;
     if (!content.startsWith("# Post-Mortem Report:"))
@@ -7376,7 +7631,7 @@ async function runCuratorPostMortem(directory, options = {}) {
       warnings.push(`Pending proposals capped at ${MAX_PROPOSALS} (had ${proposals.length}); older entries truncated.`);
       proposals = proposals.slice(0, MAX_PROPOSALS);
     }
-    const unactionablePath = path13.join(resolveKnowledgeStoreDir(directory), "knowledge-unactionable.jsonl");
+    const unactionablePath = path14.join(resolveKnowledgeStoreDir(directory), "knowledge-unactionable.jsonl");
     let unactionable = readJsonlFile(unactionablePath, MAX_UNACTIONABLE);
     if (unactionable.length > MAX_UNACTIONABLE) {
       warnings.push(`Unactionable entries capped at ${MAX_UNACTIONABLE} (had ${unactionable.length}); older entries truncated.`);
@@ -7426,7 +7681,7 @@ ${llmOutput}`;
     }
     try {
       const { mkdirSync: mkdirSync6 } = await import("fs");
-      mkdirSync6(path13.dirname(reportPath), { recursive: true });
+      mkdirSync6(path14.dirname(reportPath), { recursive: true });
       await atomicWriteFile(reportPath, reportContent);
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
@@ -7474,7 +7729,7 @@ var _internals13 = {
 };
 
 // src/hooks/hive-promoter.ts
-import path16 from "path";
+import path17 from "path";
 
 // src/background/event-bus.ts
 class AutomationEventBus {
@@ -7978,9 +8233,9 @@ init_logger();
 
 // src/services/skill-improver-quota.ts
 var import_proper_lockfile2 = __toESM(require_proper_lockfile(), 1);
-import { existsSync as existsSync6 } from "fs";
+import { existsSync as existsSync7 } from "fs";
 import { mkdir as mkdir3, readFile as readFile3, rename, writeFile as writeFile2 } from "fs/promises";
-import * as path14 from "path";
+import * as path15 from "path";
 var LOCK_ACQUIRE_TIMEOUT_MS = 1e4;
 var LOCK_RETRY_OPTS = {
   retries: {
@@ -8009,7 +8264,7 @@ async function acquireLock(dir) {
 }
 function resolveQuotaPath(directory, scope = "skill-improver") {
   const fileName = scope === "knowledge-enrichment" ? "knowledge-enrichment-quota.json" : "skill-improver-quota.json";
-  return path14.join(directory, ".swarm", fileName);
+  return path15.join(directory, ".swarm", fileName);
 }
 function todayKey(window, now = new Date) {
   if (window === "utc") {
@@ -8021,7 +8276,7 @@ function todayKey(window, now = new Date) {
   return `${yr}-${m}-${d}`;
 }
 async function readState(filePath) {
-  if (!existsSync6(filePath))
+  if (!existsSync7(filePath))
     return null;
   try {
     const raw = await readFile3(filePath, "utf-8");
@@ -8035,7 +8290,7 @@ async function readState(filePath) {
   }
 }
 async function writeState(filePath, state) {
-  await mkdir3(path14.dirname(filePath), { recursive: true });
+  await mkdir3(path15.dirname(filePath), { recursive: true });
   const tmp = `${filePath}.tmp-${process.pid}`;
   await writeFile2(tmp, JSON.stringify(state, null, 2), "utf-8");
   await rename(tmp, filePath);
@@ -8058,10 +8313,10 @@ async function getQuotaState(directory, opts) {
 }
 async function reserveQuota(directory, opts) {
   const filePath = resolveQuotaPath(directory, opts.scope);
-  await mkdir3(path14.dirname(filePath), { recursive: true });
+  await mkdir3(path15.dirname(filePath), { recursive: true });
   let release = null;
   try {
-    release = await acquireLock(path14.dirname(filePath));
+    release = await acquireLock(path15.dirname(filePath));
     const state = await getQuotaState(directory, opts);
     if (state.calls_used + opts.nCalls > opts.maxCalls) {
       return {
@@ -8088,10 +8343,10 @@ async function reserveQuota(directory, opts) {
 }
 async function releaseQuota(directory, opts) {
   const filePath = resolveQuotaPath(directory, opts.scope);
-  await mkdir3(path14.dirname(filePath), { recursive: true });
+  await mkdir3(path15.dirname(filePath), { recursive: true });
   let release = null;
   try {
-    release = await acquireLock(path14.dirname(filePath));
+    release = await acquireLock(path15.dirname(filePath));
     const state = await getQuotaState(directory, opts);
     const next = {
       ...state,
@@ -8114,8 +8369,8 @@ init_logger();
 
 // src/hooks/skill-usage-log.ts
 import * as crypto3 from "crypto";
-import * as fs8 from "fs";
-import * as path15 from "path";
+import * as fs9 from "fs";
+import * as path16 from "path";
 function resolveLogPath(directory) {
   return validateSwarmPath(directory, "skill-usage.jsonl");
 }
@@ -8124,16 +8379,16 @@ function normalizeComplianceVerdict(verdict) {
 }
 var _internals14 = {
   generateId: () => crypto3.randomUUID(),
-  appendFileSync: fs8.appendFileSync.bind(fs8),
-  readFileSync: fs8.readFileSync.bind(fs8),
-  writeFileSync: fs8.writeFileSync.bind(fs8),
-  renameSync: fs8.renameSync.bind(fs8),
-  mkdirSync: fs8.mkdirSync.bind(fs8),
-  existsSync: fs8.existsSync.bind(fs8),
-  statSync: fs8.statSync.bind(fs8),
-  openSync: fs8.openSync.bind(fs8),
-  readSync: fs8.readSync.bind(fs8),
-  closeSync: fs8.closeSync.bind(fs8),
+  appendFileSync: fs9.appendFileSync.bind(fs9),
+  readFileSync: fs9.readFileSync.bind(fs9),
+  writeFileSync: fs9.writeFileSync.bind(fs9),
+  renameSync: fs9.renameSync.bind(fs9),
+  mkdirSync: fs9.mkdirSync.bind(fs9),
+  existsSync: fs9.existsSync.bind(fs9),
+  statSync: fs9.statSync.bind(fs9),
+  openSync: fs9.openSync.bind(fs9),
+  readSync: fs9.readSync.bind(fs9),
+  closeSync: fs9.closeSync.bind(fs9),
   pruneSkillUsageLog,
   resolveSourceKnowledgeIds,
   applySkillUsageFeedback,
@@ -8214,7 +8469,7 @@ function appendFeedbackAppliedMarker(directory, processedEntryIds) {
   if (processedEntryIds.length === 0)
     return;
   const resolved = resolveLogPath(directory);
-  const dir = path15.dirname(resolved);
+  const dir = path16.dirname(resolved);
   if (!_internals14.existsSync(dir)) {
     _internals14.mkdirSync(dir, { recursive: true });
   }
@@ -8259,7 +8514,7 @@ function appendSkillUsageEntry(directory, entry) {
     throw new Error("sessionID is required and must be a non-empty string");
   }
   const resolved = validateSwarmPath(directory, "skill-usage.jsonl");
-  const dir = path15.dirname(resolved);
+  const dir = path16.dirname(resolved);
   if (!_internals14.existsSync(dir)) {
     _internals14.mkdirSync(dir, { recursive: true });
   }
@@ -8435,8 +8690,8 @@ function pruneSkillUsageLog(directory, maxEntriesPerSkill = 500) {
   }
   if (entries.length === 0) {
     if (preservedMarkers.length > 0) {
-      const dir2 = path15.dirname(resolved);
-      const tmpPath2 = path15.join(dir2, `skill-usage-${Date.now()}.tmp`);
+      const dir2 = path16.dirname(resolved);
+      const tmpPath2 = path16.join(dir2, `skill-usage-${Date.now()}.tmp`);
       const content2 = preservedMarkers.join(`
 `).concat(preservedMarkers.length > 0 ? `
 ` : "");
@@ -8478,8 +8733,8 @@ function pruneSkillUsageLog(directory, maxEntriesPerSkill = 500) {
   if (pruned === 0) {
     return { pruned: 0, remaining: entries.length };
   }
-  const dir = path15.dirname(resolved);
-  const tmpPath = path15.join(dir, `skill-usage-${Date.now()}.tmp`);
+  const dir = path16.dirname(resolved);
+  const tmpPath = path16.join(dir, `skill-usage-${Date.now()}.tmp`);
   const entryLines = surviving.map((e) => JSON.stringify(e));
   const allLines = [...entryLines, ...preservedMarkers];
   const content = allLines.join(`
@@ -8508,9 +8763,9 @@ async function resolveSourceKnowledgeIds(directory, skillPath) {
     if (/\.\.[/\\]/.test(cleanPath)) {
       return [];
     }
-    const absolute = path15.normalize(path15.isAbsolute(cleanPath) ? cleanPath : path15.resolve(directory, cleanPath));
-    const baseDir = path15.normalize(path15.resolve(directory));
-    const isContained = process.platform === "win32" ? absolute.toLowerCase().startsWith((baseDir + path15.sep).toLowerCase()) : absolute.startsWith(baseDir + path15.sep);
+    const absolute = path16.normalize(path16.isAbsolute(cleanPath) ? cleanPath : path16.resolve(directory, cleanPath));
+    const baseDir = path16.normalize(path16.resolve(directory));
+    const isContained = process.platform === "win32" ? absolute.toLowerCase().startsWith((baseDir + path16.sep).toLowerCase()) : absolute.startsWith(baseDir + path16.sep);
     if (!isContained) {
       return [];
     }
@@ -8822,7 +9077,7 @@ async function promoteToHive(directory, lesson, category) {
     schema_version: 1,
     created_at: new Date().toISOString(),
     updated_at: new Date().toISOString(),
-    source_project: path16.basename(directory) || "unknown",
+    source_project: path17.basename(directory) || "unknown",
     encounter_score: 1
   };
   await appendKnowledge(resolveHiveKnowledgePath(), newHiveEntry);
@@ -8874,9 +9129,9 @@ async function promoteFromSwarm(directory, lessonId) {
 
 // src/hooks/knowledge-curator.ts
 import { createHash as createHash3 } from "crypto";
-import { existsSync as existsSync10 } from "fs";
+import { existsSync as existsSync11 } from "fs";
 import { appendFile as appendFile2, mkdir as mkdir5, readFile as readFile6, writeFile as writeFile5 } from "fs/promises";
-import * as path21 from "path";
+import * as path22 from "path";
 
 // src/services/synonym-map.ts
 var import_proper_lockfile3 = __toESM(require_proper_lockfile(), 1);
@@ -8888,7 +9143,7 @@ import {
   unlink as unlink2,
   writeFile as writeFile3
 } from "fs/promises";
-import * as path17 from "path";
+import * as path18 from "path";
 var SYNONYM_MAP_FILENAME = "synonym-map.json";
 var MAX_TOKEN_LENGTH = 64;
 var DEFAULT_MAX_PAIRS = 500;
@@ -9043,7 +9298,7 @@ async function readSynonymMap(directory, maxPairs = DEFAULT_MAX_PAIRS) {
   }
 }
 async function writeSynonymMapAtomic(filePath, map) {
-  await mkdir4(path17.dirname(filePath), { recursive: true });
+  await mkdir4(path18.dirname(filePath), { recursive: true });
   const tmp = `${filePath}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`;
   try {
     await writeFile3(tmp, JSON.stringify(map, null, 2), "utf-8");
@@ -9056,7 +9311,7 @@ async function writeSynonymMapAtomic(filePath, map) {
 }
 async function rebuildSynonymMap(directory, entries, maxPairs = DEFAULT_MAX_PAIRS) {
   const filePath = resolveSynonymMapPath(directory);
-  const dir = path17.dirname(filePath);
+  const dir = path18.dirname(filePath);
   await mkdir4(dir, { recursive: true });
   let release = null;
   try {
@@ -9119,19 +9374,19 @@ function reinforceSwarmKnowledgeEntry(entry, confirmation) {
 }
 
 // src/hooks/micro-reflector.ts
-import { existsSync as existsSync9 } from "fs";
+import { existsSync as existsSync10 } from "fs";
 import { readFile as readFile5, writeFile as writeFile4 } from "fs/promises";
-import * as path20 from "path";
+import * as path21 from "path";
 init_logger();
 
 // src/hooks/skill-propagation-gate.ts
-import * as fs10 from "fs";
-import * as path19 from "path";
+import * as fs11 from "fs";
+import * as path20 from "path";
 init_logger();
 
 // src/hooks/skill-scoring.ts
-import * as fs9 from "fs";
-import * as path18 from "path";
+import * as fs10 from "fs";
+import * as path19 from "path";
 var FREQUENCY_CAP = 10;
 var FREQUENCY_WEIGHT = 0.3;
 var COMPLIANCE_WEIGHT = 0.3;
@@ -9159,10 +9414,10 @@ var _internals15 = {
   computeTriggerMatchBoost: null
 };
 function extractSkillName(skillPath) {
-  const base = path18.basename(skillPath, path18.extname(skillPath));
+  const base = path19.basename(skillPath, path19.extname(skillPath));
   if (base !== "SKILL")
     return base;
-  const parent = path18.basename(path18.dirname(skillPath));
+  const parent = path19.basename(path19.dirname(skillPath));
   return parent;
 }
 function stripQuotes(value) {
@@ -9304,25 +9559,25 @@ function parseSkillFrontmatter(content, skillPath) {
   return meta;
 }
 function readFilePrefix(filePath) {
-  const fd = fs9.openSync(filePath, "r");
+  const fd = fs10.openSync(filePath, "r");
   try {
     const buffer = Buffer.alloc(SKILL_FRONTMATTER_READ_BYTES);
-    const bytesRead = fs9.readSync(fd, buffer, 0, SKILL_FRONTMATTER_READ_BYTES, 0);
+    const bytesRead = fs10.readSync(fd, buffer, 0, SKILL_FRONTMATTER_READ_BYTES, 0);
     return buffer.toString("utf-8", 0, bytesRead);
   } finally {
-    fs9.closeSync(fd);
+    fs10.closeSync(fd);
   }
 }
 function readSkillMetadata(skillPath, directory) {
   const normalizedPath = skillPath.replace(/^file:/, "").replace(/\\/g, "/");
   const fallback = parseSkillFrontmatter("", normalizedPath);
   try {
-    if (path18.isAbsolute(normalizedPath) || normalizedPath.split("/").includes("..")) {
+    if (path19.isAbsolute(normalizedPath) || normalizedPath.split("/").includes("..")) {
       return fallback;
     }
-    const root = path18.resolve(directory);
-    const absolutePath = path18.resolve(directory, normalizedPath);
-    if (absolutePath !== root && !absolutePath.startsWith(root + path18.sep)) {
+    const root = path19.resolve(directory);
+    const absolutePath = path19.resolve(directory, normalizedPath);
+    if (absolutePath !== root && !absolutePath.startsWith(root + path19.sep)) {
       return fallback;
     }
     const content = readFilePrefix(absolutePath);
@@ -9456,10 +9711,10 @@ function getSkillStats(skillPath, directory) {
   };
 }
 function formatSkillIndexWithContext(skills, directory) {
-  const usageLogPath = path18.join(directory, ".swarm", "skill-usage.jsonl");
+  const usageLogPath = path19.join(directory, ".swarm", "skill-usage.jsonl");
   let hasHistory = false;
   try {
-    const stat4 = fs9.statSync(usageLogPath);
+    const stat4 = fs10.statSync(usageLogPath);
     hasHistory = stat4.size > 0;
   } catch {}
   if (!hasHistory) {
@@ -9590,7 +9845,7 @@ function parseYamlValue(value) {
   return trimmed;
 }
 function loadRoutingSkills(directory, targetAgent) {
-  const routingPath = path19.join(directory, ".opencode", "skill-routing.yaml");
+  const routingPath = path20.join(directory, ".opencode", "skill-routing.yaml");
   if (!_internals16.existsSync(routingPath))
     return [];
   try {
@@ -9622,13 +9877,13 @@ var SKILL_SEARCH_ROOTS = [
 ];
 var MAX_SCORING_SESSION_ENTRIES = 500;
 var _internals16 = {
-  readdirSync: fs10.readdirSync.bind(fs10),
-  existsSync: fs10.existsSync.bind(fs10),
-  statSync: fs10.statSync.bind(fs10),
-  mkdirSync: fs10.mkdirSync.bind(fs10),
-  appendFileSync: fs10.appendFileSync.bind(fs10),
-  readFileSync: fs10.readFileSync.bind(fs10),
-  writeFileSync: fs10.writeFileSync.bind(fs10),
+  readdirSync: fs11.readdirSync.bind(fs11),
+  existsSync: fs11.existsSync.bind(fs11),
+  statSync: fs11.statSync.bind(fs11),
+  mkdirSync: fs11.mkdirSync.bind(fs11),
+  appendFileSync: fs11.appendFileSync.bind(fs11),
+  readFileSync: fs11.readFileSync.bind(fs11),
+  writeFileSync: fs11.writeFileSync.bind(fs11),
   skillPropagationGateBefore: null,
   skillPropagationTransformScan: null,
   SKILL_CAPABLE_AGENTS,
@@ -9650,7 +9905,7 @@ var _internals16 = {
 function discoverAvailableSkills(directory) {
   const results = [];
   for (const root of SKILL_SEARCH_ROOTS) {
-    const rootPath = path19.join(directory, root);
+    const rootPath = path20.join(directory, root);
     if (!_internals16.existsSync(rootPath))
       continue;
     let entries;
@@ -9662,13 +9917,13 @@ function discoverAvailableSkills(directory) {
     for (const entry of entries) {
       if (entry.startsWith("."))
         continue;
-      const skillDir = path19.join(rootPath, entry);
-      if (_internals16.existsSync(path19.join(skillDir, "retired.marker")) || _internals16.existsSync(path19.join(skillDir, "stale.marker")))
+      const skillDir = path20.join(rootPath, entry);
+      if (_internals16.existsSync(path20.join(skillDir, "retired.marker")) || _internals16.existsSync(path20.join(skillDir, "stale.marker")))
         continue;
-      const skillFile = path19.join(skillDir, "SKILL.md");
+      const skillFile = path20.join(skillDir, "SKILL.md");
       try {
         if (_internals16.statSync(skillDir).isDirectory() && _internals16.existsSync(skillFile)) {
-          results.push(path19.join(root, entry, "SKILL.md").replace(/\\/g, "/"));
+          results.push(path20.join(root, entry, "SKILL.md").replace(/\\/g, "/"));
         }
       } catch (err) {
         warn(`[skill-propagation-gate] failed to stat skill directory ${entry}: ${err instanceof Error ? err.message : String(err)}`);
@@ -9737,9 +9992,9 @@ function extractSkillsFieldFromPrompt(prompt) {
   return "";
 }
 function writeWarnEvent(directory, record) {
-  const filePath = path19.join(directory, ".swarm", "events.jsonl");
+  const filePath = path20.join(directory, ".swarm", "events.jsonl");
   try {
-    const dir = path19.dirname(filePath);
+    const dir = path20.dirname(filePath);
     if (!_internals16.existsSync(dir)) {
       _internals16.mkdirSync(dir, { recursive: true });
     }
@@ -9868,8 +10123,8 @@ async function skillPropagationGateBefore(directory, input, config) {
     if (routingPaths.length > 0) {
       const existingPaths = new Set(scored.map((s) => s.skillPath));
       for (const routingPath of routingPaths) {
-        const routedSkillDir = path19.dirname(path19.join(directory, routingPath));
-        if (_internals16.existsSync(path19.join(routedSkillDir, "retired.marker")) || _internals16.existsSync(path19.join(routedSkillDir, "stale.marker")))
+        const routedSkillDir = path20.dirname(path20.join(directory, routingPath));
+        if (_internals16.existsSync(path20.join(routedSkillDir, "retired.marker")) || _internals16.existsSync(path20.join(routedSkillDir, "stale.marker")))
           continue;
         if (!existingPaths.has(routingPath)) {
           scored.push({
@@ -9888,8 +10143,8 @@ async function skillPropagationGateBefore(directory, input, config) {
       let skillsForIndex = availableSkills;
       if (scoringSkipped) {
         skillsForIndex = [...availableSkills].sort((a, b) => {
-          const nameA = path19.basename(path19.dirname(a));
-          const nameB = path19.basename(path19.dirname(b));
+          const nameA = path20.basename(path20.dirname(a));
+          const nameB = path20.basename(path20.dirname(b));
           return nameA.localeCompare(nameB);
         });
       } else if (typeof scored !== "undefined" && scored.length > 0) {
@@ -9897,7 +10152,7 @@ async function skillPropagationGateBefore(directory, input, config) {
       }
       const formattedIndex = _internals16.formatSkillIndexWithContext(skillsForIndex, directory);
       if (formattedIndex.length > 0) {
-        const contextPath = path19.join(directory, ".swarm", "context.md");
+        const contextPath = path20.join(directory, ".swarm", "context.md");
         let existingContent = "";
         if (_internals16.existsSync(contextPath)) {
           existingContent = _internals16.readFileSync(contextPath, "utf-8");
@@ -9919,7 +10174,7 @@ ${newSection}`;
             updatedContent = existingContent + newSection;
           }
         }
-        const swarmDir = path19.dirname(contextPath);
+        const swarmDir = path20.dirname(contextPath);
         if (!_internals16.existsSync(swarmDir)) {
           _internals16.mkdirSync(swarmDir, { recursive: true });
         }
@@ -10145,9 +10400,9 @@ function resolveInsightCandidatesPath(directory) {
 }
 async function readTaskTrajectory(directory, taskId) {
   try {
-    const rel = path20.join("evidence", sanitizeTaskId(taskId), "trajectory.jsonl");
+    const rel = path21.join("evidence", sanitizeTaskId(taskId), "trajectory.jsonl");
     const filePath = validateSwarmPath(directory, rel);
-    if (!existsSync9(filePath))
+    if (!existsSync10(filePath))
       return [];
     const content = await readFile5(filePath, "utf-8");
     const out = [];
@@ -10203,7 +10458,7 @@ var WRITE_TOOLS = new Set([
   "apply_patch",
   "swarm_apply_patch"
 ]);
-function isRecord(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null;
 }
 function normalizePathField(value) {
@@ -10213,13 +10468,13 @@ function firstPathFromRecord(record) {
   return normalizePathField(record.path) ?? normalizePathField(record.filePath) ?? normalizePathField(record.file);
 }
 function normalizeWriteTrigger(input, output) {
-  if (!isRecord(input))
+  if (!isRecord2(input))
     return null;
   const toolName = typeof input.toolName === "string" ? input.toolName : typeof input.tool === "string" ? input.tool : null;
   if (!toolName || !WRITE_TOOLS.has(toolName))
     return null;
-  const inputArgs = isRecord(input.args) ? input.args : null;
-  const outputArgs = isRecord(output) && isRecord(output.args) ? output.args : null;
+  const inputArgs = isRecord2(input.args) ? input.args : null;
+  const outputArgs = isRecord2(output) && isRecord2(output.args) ? output.args : null;
   const filePath = firstPathFromRecord(input) ?? (inputArgs ? firstPathFromRecord(inputArgs) : null) ?? (outputArgs ? firstPathFromRecord(outputArgs) : null);
   if (!filePath)
     return null;
@@ -10575,8 +10830,8 @@ RETRY: your last output was missing ${result.missing.join("; ")}; produce valid
 }
 async function appendCuratorSkippedEvent(directory, record) {
   try {
-    const filePath = path21.join(directory, ".swarm", "events.jsonl");
-    await mkdir5(path21.dirname(filePath), { recursive: true });
+    const filePath = path22.join(directory, ".swarm", "events.jsonl");
+    await mkdir5(path22.dirname(filePath), { recursive: true });
     await appendFile2(filePath, `${JSON.stringify({
       timestamp: new Date().toISOString(),
       event: "curator_skipped",
@@ -10616,7 +10871,7 @@ function readInsightJsonl(content) {
 async function consumeInsightCandidates(directory, batchLimit = MESO_INSIGHT_BATCH_LIMIT) {
   try {
     const filePath = resolveInsightCandidatesPath(directory);
-    if (!existsSync10(filePath))
+    if (!existsSync11(filePath))
       return [];
     const consumed = [];
     await transactFile(filePath, async (p) => readInsightJsonl(await readFile6(p, "utf-8").catch(() => "")), async (p, data) => {
@@ -11029,8 +11284,8 @@ var _internals17 = {
 };
 
 // src/services/session-reflection.ts
-import { promises as fs11 } from "fs";
-import * as path22 from "path";
+import { promises as fs12 } from "fs";
+import * as path23 from "path";
 
 // src/hooks/skill-improver-llm-factory.ts
 function resolveSkillImproverAgentName(sessionId) {
@@ -11183,13 +11438,13 @@ async function gatherRetroLessonsAndTaxonomy(directory) {
   const lessons = [];
   const taxonomy = {};
   try {
-    const evidenceDir = path22.join(directory, ".swarm", "evidence");
-    const entries = await fs11.readdir(evidenceDir);
+    const evidenceDir = path23.join(directory, ".swarm", "evidence");
+    const entries = await fs12.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");
+      const evidencePath = path23.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 bundleEntries = parsed.entries ?? [parsed];
         for (const entry of bundleEntries) {
@@ -11216,14 +11471,14 @@ async function gatherRetroLessonsAndTaxonomy(directory) {
 async function gatherGateFailures(directory) {
   const failures = new Map;
   try {
-    const evidenceDir = path22.join(directory, ".swarm", "evidence");
-    const entries = await fs11.readdir(evidenceDir);
+    const evidenceDir = path23.join(directory, ".swarm", "evidence");
+    const entries = await fs12.readdir(evidenceDir);
     for (const entry of entries) {
       if (entry.startsWith("retro-"))
         continue;
-      const evidencePath = path22.join(evidenceDir, entry, "evidence.json");
+      const evidencePath = path23.join(evidenceDir, entry, "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 bundleEntries = parsed.entries ?? [parsed];
         for (const e of bundleEntries) {
@@ -11415,19 +11670,19 @@ async function writeSessionReflection(directory, result) {
   lines.push(result.architectReport);
   const content = lines.join(`
 `);
-  await fs11.writeFile(reflectionPath, content, "utf-8");
+  await fs12.writeFile(reflectionPath, content, "utf-8");
   return reflectionPath;
 }
 
 // src/services/skill-improver.ts
-import { existsSync as existsSync12 } from "fs";
+import { existsSync as existsSync13 } from "fs";
 import { mkdir as mkdir7, readFile as readFile7, rename as rename3, writeFile as writeFile7 } from "fs/promises";
-import * as path24 from "path";
+import * as path25 from "path";
 init_logger();
 
 // src/services/trajectory-cluster.ts
 import { mkdir as mkdir6, writeFile as writeFile6 } from "fs/promises";
-import * as path23 from "path";
+import * as path24 from "path";
 init_logger();
 var MACRO_TRAJECTORY_WINDOW = 200;
 var MOTIF_MIN_TASKS = 2;
@@ -11559,11 +11814,11 @@ async function writeMotifProposals(directory, opts = {}) {
     if (motifs.length === 0)
       return result;
     const max = opts.maxProposals ?? 10;
-    const proposalsDir = validateSwarmPath(directory, path23.join("skills", "proposals"));
+    const proposalsDir = validateSwarmPath(directory, path24.join("skills", "proposals"));
     await mkdir6(proposalsDir, { recursive: true });
     for (const motif of motifs.slice(0, max)) {
       const slug = `motif-${slugify(motif.signature)}`;
-      const filePath = path23.join(proposalsDir, `${slug}.md`);
+      const filePath = path24.join(proposalsDir, `${slug}.md`);
       await writeFile6(filePath, buildMotifProposal(motif), "utf-8");
       result.proposalsWritten.push(filePath);
     }
@@ -11704,11 +11959,11 @@ async function writeSuccessMotifProposals(directory, opts = {}) {
     if (motifs.length === 0)
       return result;
     const max = opts.maxProposals ?? 10;
-    const proposalsDir = validateSwarmPath(directory, path23.join("skills", "proposals"));
+    const proposalsDir = validateSwarmPath(directory, path24.join("skills", "proposals"));
     await mkdir6(proposalsDir, { recursive: true });
     for (const motif of motifs.slice(0, max)) {
       const slug = workflowSlug(motif.signature);
-      const filePath = path23.join(proposalsDir, `${slug}.md`);
+      const filePath = path24.join(proposalsDir, `${slug}.md`);
       await writeFile6(filePath, buildWorkflowProposal(motif), "utf-8");
       result.proposalsWritten.push(filePath);
     }
@@ -11720,14 +11975,14 @@ async function writeSuccessMotifProposals(directory, opts = {}) {
 }
 
 // src/services/unactionable-hardening.ts
-import { existsSync as existsSync11 } from "fs";
+import { existsSync as existsSync12 } from "fs";
 init_logger();
 var HARDENING_BATCH_LIMIT = 5;
 async function hardenUnactionableEntries(params) {
   const result = { hardened: 0, retired: 0, remaining: 0 };
   try {
     const queuePath = resolveUnactionablePath(params.directory);
-    if (!existsSync11(queuePath))
+    if (!existsSync12(queuePath))
       return result;
     const limit = params.batchLimit ?? HARDENING_BATCH_LIMIT;
     const dedupThreshold = params.dedupThreshold ?? 0.6;
@@ -11831,7 +12086,7 @@ function timestampSlug(d) {
   return d.toISOString().replace(/[:.]/g, "-");
 }
 async function atomicWrite(p, content) {
-  await mkdir7(path24.dirname(p), { recursive: true });
+  await mkdir7(path25.dirname(p), { recursive: true });
   const tmp = `${p}.tmp-${process.pid}-${Date.now()}`;
   await writeFile7(tmp, content, "utf-8");
   await rename3(tmp, p);
@@ -11839,7 +12094,7 @@ async function atomicWrite(p, content) {
 async function gatherInventory(directory) {
   const swarm = await readKnowledge(resolveSwarmKnowledgePath(directory));
   const hivePath = resolveHiveKnowledgePath();
-  const hive = existsSync12(hivePath) ? await readKnowledge(hivePath) : [];
+  const hive = existsSync13(hivePath) ? await readKnowledge(hivePath) : [];
   const archived = [...swarm, ...hive].filter((e) => e.status === "archived").length;
   const skills = await listSkills(directory);
   const knowledgeById = new Map([...swarm, ...hive].map((entry) => [entry.id, entry]));
@@ -12234,8 +12489,8 @@ async function runSkillImprover(req) {
     }
     throw err;
   }
-  const proposalDir = path24.join(req.directory, ".swarm", "skill-improver", "proposals");
-  const proposalFile = path24.join(proposalDir, `${timestampSlug(now)}.md`);
+  const proposalDir = path25.join(req.directory, ".swarm", "skill-improver", "proposals");
+  const proposalFile = path25.join(proposalDir, `${timestampSlug(now)}.md`);
   const finalBody = source === "llm" ? buildLLMProposalFrame({
     body,
     targets,
@@ -12718,20 +12973,20 @@ function countSessionKnowledgeEntries(entries, sessionStart, fallbackCount) {
 async function copyDirRecursiveWithFailures(src, dest) {
   let count = 0;
   const failures = [];
-  const entries = await fs12.readdir(src);
-  await fs12.mkdir(dest, { recursive: true });
+  const entries = await fs13.readdir(src);
+  await fs13.mkdir(dest, { recursive: true });
   for (const entry of entries) {
-    const srcEntry = path25.join(src, entry);
-    const destEntry = path25.join(dest, entry);
+    const srcEntry = path26.join(src, entry);
+    const destEntry = path26.join(dest, entry);
     try {
-      const stat4 = await fs12.stat(srcEntry);
+      const stat4 = await fs13.stat(srcEntry);
       if (stat4.isDirectory()) {
         const subResult = await copyDirRecursiveWithFailures(srcEntry, destEntry);
         count += subResult.copied;
         failures.push(...subResult.failures);
       } else {
         try {
-          await fs12.copyFile(srcEntry, destEntry);
+          await fs13.copyFile(srcEntry, destEntry);
           count++;
         } catch (err) {
           const errno = err?.code;
@@ -12906,20 +13161,20 @@ async function runFinalizeStage(ctx) {
       ctx.warnings.push(`Session retrospective write threw: ${retroError instanceof Error ? retroError.message : String(retroError)}`);
     }
   }
-  const lessonsFilePath = path25.join(ctx.swarmDir, "close-lessons.md");
+  const lessonsFilePath = path26.join(ctx.swarmDir, "close-lessons.md");
   try {
-    const lessonsText = await fs12.readFile(lessonsFilePath, "utf-8");
+    const lessonsText = await fs13.readFile(lessonsFilePath, "utf-8");
     ctx.explicitLessons = lessonsText.split(`
 `).map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#"));
   } catch {}
   try {
-    const evidenceDir = path25.join(ctx.swarmDir, "evidence");
-    const evidenceEntries = await fs12.readdir(evidenceDir);
+    const evidenceDir = path26.join(ctx.swarmDir, "evidence");
+    const evidenceEntries = await fs13.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 = path25.join(evidenceDir, retroDir, "evidence.json");
+      const evidencePath = path26.join(evidenceDir, retroDir, "evidence.json");
       try {
-        const content = await fs12.readFile(evidencePath, "utf-8");
+        const content = await fs13.readFile(evidencePath, "utf-8");
         const parsed = JSON.parse(content);
         const entries = parsed.entries ?? [parsed];
         for (const entry of entries) {
@@ -12963,7 +13218,7 @@ async function runFinalizeStage(ctx) {
     console.warn("[close-command] curateAndStoreSwarm error:", error2);
   }
   if (ctx.curationSucceeded && ctx.allLessons.length > 0) {
-    await fs12.unlink(lessonsFilePath).catch(() => {});
+    await fs13.unlink(lessonsFilePath).catch(() => {});
   }
   if (ctx.curationSucceeded) {
     if (ctx.config.hive_enabled === false) {} else {
@@ -13069,7 +13324,7 @@ async function runFinalizeStage(ctx) {
     }
   }
   try {
-    const { CuratorConfigSchema: CCS } = await import("./schema-mygkbbe9.js");
+    const { CuratorConfigSchema: CCS } = await import("./schema-nz638xc3.js");
     const { config: pmLoadedConfig } = _internals20.loadPluginConfigWithMeta(ctx.directory);
     const curatorCfg = CCS.parse(pmLoadedConfig.curator ?? {});
     if (curatorCfg.enabled && curatorCfg.postmortem_enabled) {
@@ -13099,7 +13354,7 @@ async function copySqliteSafe(srcPath, destPath) {
   let checkpointVerified = false;
   try {
     const result = spawnSync5("sqlite3", [srcPath, "PRAGMA wal_checkpoint(TRUNCATE);"], {
-      cwd: path25.dirname(srcPath),
+      cwd: path26.dirname(srcPath),
       encoding: "utf-8",
       stdio: ["ignore", "pipe", "pipe"],
       timeout: 1e4,
@@ -13110,7 +13365,7 @@ async function copySqliteSafe(srcPath, destPath) {
       const code = result.error.code;
       if (code === "ENOENT") {
         try {
-          await fs12.copyFile(srcPath, destPath);
+          await fs13.copyFile(srcPath, destPath);
           return {
             success: true,
             reason: "copied without WAL checkpoint (sqlite3 CLI unavailable)"
@@ -13149,7 +13404,7 @@ async function copySqliteSafe(srcPath, destPath) {
     };
   }
   try {
-    await fs12.copyFile(srcPath, destPath);
+    await fs13.copyFile(srcPath, destPath);
     if (checkpointVerified) {
       return { success: true };
     }
@@ -13167,9 +13422,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 = path25.join(ctx.swarmDir, "archive", `swarm-${ctx.timestamp}-${ctx.archiveSuffix}`);
+  ctx.archiveDir = path26.join(ctx.swarmDir, "archive", `swarm-${ctx.timestamp}-${ctx.archiveSuffix}`);
   try {
-    await fs12.mkdir(ctx.archiveDir, { recursive: true });
+    await fs13.mkdir(ctx.archiveDir, { recursive: true });
     const WAL_SIDECAR_FILES = new Set(["swarm.db-shm", "swarm.db-wal"]);
     const linkedKnowledgeShared = isLinked(ctx.directory);
     if (linkedKnowledgeShared) {
@@ -13182,8 +13437,8 @@ async function runArchiveStage(ctx) {
       if (linkedKnowledgeShared && KNOWLEDGE_FAMILY_ARTIFACTS.has(artifact)) {
         continue;
       }
-      const srcPath = path25.join(ctx.swarmDir, artifact);
-      const destPath = path25.join(ctx.archiveDir, artifact);
+      const srcPath = path26.join(ctx.swarmDir, artifact);
+      const destPath = path26.join(ctx.archiveDir, artifact);
       if (artifact === "swarm.db") {
         const result = await copySqliteSafe(srcPath, destPath);
         if (result.skipped) {} else if (result.success) {
@@ -13199,7 +13454,7 @@ async function runArchiveStage(ctx) {
         }
       } else {
         try {
-          await fs12.copyFile(srcPath, destPath);
+          await fs13.copyFile(srcPath, destPath);
           ctx.archivedFileCount++;
           if (ACTIVE_STATE_TO_CLEAN.includes(artifact)) {
             ctx.archivedActiveStateFiles.add(artifact);
@@ -13215,8 +13470,8 @@ async function runArchiveStage(ctx) {
       }
     }
     for (const dirName of ACTIVE_STATE_DIRS_TO_CLEAN) {
-      const srcDir = path25.join(ctx.swarmDir, dirName);
-      const destDir = path25.join(ctx.archiveDir, dirName);
+      const srcDir = path26.join(ctx.swarmDir, dirName);
+      const destDir = path26.join(ctx.archiveDir, dirName);
       try {
         const result = await copyDirRecursiveWithFailures(srcDir, destDir);
         ctx.archivedFileCount += result.copied;
@@ -13289,9 +13544,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 = path25.join(ctx.swarmDir, artifact);
+      const filePath = path26.join(ctx.swarmDir, artifact);
       try {
-        await fs12.unlink(filePath);
+        await fs13.unlink(filePath);
         cleanedFiles.push(artifact);
       } catch (err) {
         const errno = err?.code;
@@ -13308,18 +13563,18 @@ async function runCleanStage(ctx) {
     if (!ctx.archivedActiveStateDirs.has(dirName)) {
       continue;
     }
-    const dirPath = path25.join(ctx.swarmDir, dirName);
+    const dirPath = path26.join(ctx.swarmDir, dirName);
     try {
-      await fs12.rm(dirPath, { recursive: true, force: true });
+      await fs13.rm(dirPath, { recursive: true, force: true });
       cleanedFiles.push(`${dirName}/`);
     } catch {}
   }
   try {
-    const swarmFiles = await fs12.readdir(ctx.swarmDir);
+    const swarmFiles = await fs13.readdir(ctx.swarmDir);
     const configBackups = swarmFiles.filter((f) => f.startsWith("config-backup-") && f.endsWith(".json"));
     for (const backup of configBackups) {
       try {
-        await fs12.unlink(path25.join(ctx.swarmDir, backup));
+        await fs13.unlink(path26.join(ctx.swarmDir, backup));
         configBackupsRemoved++;
       } catch (err) {
         const errno = err?.code;
@@ -13332,7 +13587,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 fs12.unlink(path25.join(ctx.swarmDir, sibling));
+        await fs13.unlink(path26.join(ctx.swarmDir, sibling));
       } catch (err) {
         const errno = err?.code;
         if (errno === "ENOENT") {} else {
@@ -13350,16 +13605,16 @@ async function runCleanStage(ctx) {
   }
   let swarmPlanFilesRemoved = 0;
   const candidates = [
-    path25.join(ctx.directory, ".swarm", "plan-export", "SWARM_PLAN.json"),
-    path25.join(ctx.directory, ".swarm", "plan-export", "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")
+    path26.join(ctx.directory, ".swarm", "plan-export", "SWARM_PLAN.json"),
+    path26.join(ctx.directory, ".swarm", "plan-export", "SWARM_PLAN.md"),
+    path26.join(ctx.directory, ".swarm", "SWARM_PLAN.json"),
+    path26.join(ctx.directory, ".swarm", "SWARM_PLAN.md"),
+    path26.join(ctx.directory, "SWARM_PLAN.json"),
+    path26.join(ctx.directory, "SWARM_PLAN.md")
   ];
   for (const candidate of candidates) {
     try {
-      await fs12.unlink(candidate);
+      await fs13.unlink(candidate);
       swarmPlanFilesRemoved++;
     } catch (err) {
       if (err?.code !== "ENOENT") {
@@ -13369,11 +13624,11 @@ async function runCleanStage(ctx) {
   }
   let tmpFilesRemoved = 0;
   try {
-    const swarmFiles = await fs12.readdir(ctx.swarmDir);
+    const swarmFiles = await fs13.readdir(ctx.swarmDir);
     const tmpFiles = swarmFiles.filter((f) => f.startsWith(".tmp."));
     for (const tmp of tmpFiles) {
       try {
-        await fs12.unlink(path25.join(ctx.swarmDir, tmp));
+        await fs13.unlink(path26.join(ctx.swarmDir, tmp));
         tmpFilesRemoved++;
       } catch (err) {
         const errno = err?.code;
@@ -13394,7 +13649,7 @@ async function runCleanStage(ctx) {
     cleanedFiles.push(`${tmpFilesRemoved} .tmp.* file(s)`);
   }
   clearAllScopes(ctx.directory);
-  const contextPath = path25.join(ctx.swarmDir, "context.md");
+  const contextPath = path26.join(ctx.swarmDir, "context.md");
   const contextContent = [
     "# Context",
     "",
@@ -13406,9 +13661,9 @@ async function runCleanStage(ctx) {
     ""
   ].join(`
 `);
-  const contextTempPath = path25.join(path25.dirname(contextPath), `${path25.basename(contextPath)}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+  const contextTempPath = path26.join(path26.dirname(contextPath), `${path26.basename(contextPath)}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
   try {
-    await fs12.writeFile(contextTempPath, contextContent, "utf-8");
+    await fs13.writeFile(contextTempPath, contextContent, "utf-8");
     fsSync2.renameSync(contextTempPath, contextPath);
   } catch (error2) {
     try {
@@ -13470,7 +13725,7 @@ async function runAlignStage(ctx) {
   return { gitAlignResult, prunedBranches };
 }
 async function handleCloseCommand(directory, args, options = {}) {
-  const swarmDir = path25.join(directory, ".swarm");
+  const swarmDir = path26.join(directory, ".swarm");
   try {
     const stat4 = fsSync2.lstatSync(swarmDir);
     if (stat4.isSymbolicLink()) {
@@ -13484,18 +13739,18 @@ async function handleCloseCommand(directory, args, options = {}) {
   const planPath = validateSwarmPath(directory, "plan.json");
   let planExists = false;
   let planData = {
-    title: path25.basename(directory) || "Ad-hoc session",
+    title: path26.basename(directory) || "Ad-hoc session",
     phases: []
   };
   try {
-    const content = await fs12.readFile(planPath, "utf-8");
+    const content = await fs13.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 fs12.access(swarmDir).then(() => true).catch(() => false);
+    const swarmDirExists = await fs13.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.`;
     }
@@ -13509,15 +13764,15 @@ async function handleCloseCommand(directory, args, options = {}) {
   }
   try {
     if (!planExists) {
-      const archiveDir = path25.join(swarmDir, "archive");
+      const archiveDir = path26.join(swarmDir, "archive");
       try {
-        const archiveEntries = await fs12.readdir(archiveDir);
+        const archiveEntries = await fs13.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(path25.join(swarmDir, entry)));
+          ].some((entry) => fsSync2.existsSync(path26.join(swarmDir, entry)));
           if (!hasActiveState) {
             return `\u2705 Already finalized \u2014 nothing to do.
 
@@ -13640,9 +13895,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 = path25.join(path25.dirname(closeSummaryPath), `${path25.basename(closeSummaryPath)}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+    const closeSummaryTempPath = path26.join(path26.dirname(closeSummaryPath), `${path26.basename(closeSummaryPath)}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
     try {
-      await fs12.writeFile(closeSummaryTempPath, summaryContent, "utf-8");
+      await fs13.writeFile(closeSummaryTempPath, summaryContent, "utf-8");
       fsSync2.renameSync(closeSummaryTempPath, closeSummaryPath);
     } catch (error2) {
       try {
@@ -13652,6 +13907,10 @@ This project was already finalized in a previous /swarm close run. The plan has
       ctx.warnings.push(`Failed to write close-summary.md: ${msg}`);
       console.warn("[close-command] Failed to write close-summary.md:", error2);
     }
+    const sessionIdsToEnd = [...swarmState.agentSessions.keys()];
+    for (const sessionId of sessionIdsToEnd) {
+      _internals20.endAgentSession(sessionId);
+    }
     _internals20.resetSwarmStatePreservingSingletons();
     const retroWarnings = ctx.warnings.filter((w) => w.includes("Retrospective write") || w.includes("retrospective write") || w.includes("Session retrospective"));
     const otherWarnings = ctx.warnings.filter((w) => !w.includes("Retrospective write") && !w.includes("retrospective write") && !w.includes("Session retrospective"));
@@ -13744,7 +14003,8 @@ var _internals20 = {
   runCleanStage,
   runAlignStage,
   archiveEvidence,
-  closePlanTerminalState
+  closePlanTerminalState,
+  endAgentSession
 };
 
 // src/commands/codebase-review.ts
@@ -13977,15 +14237,15 @@ function buildStatusMessage(session, plan) {
 }
 
 // src/commands/config.ts
-import * as os6 from "os";
-import * as path26 from "path";
+import * as os7 from "os";
+import * as path27 from "path";
 function getUserConfigDir2() {
-  return process.env.XDG_CONFIG_HOME || path26.join(os6.homedir(), ".config");
+  return process.env.XDG_CONFIG_HOME || path27.join(os7.homedir(), ".config");
 }
 async function handleConfigCommand(directory, _args) {
   const config = loadPluginConfig(directory);
-  const userConfigPath = path26.join(getUserConfigDir2(), "opencode", "opencode-swarm.json");
-  const projectConfigPath = path26.join(directory, ".opencode", "opencode-swarm.json");
+  const userConfigPath = path27.join(getUserConfigDir2(), "opencode", "opencode-swarm.json");
+  const projectConfigPath = path27.join(directory, ".opencode", "opencode-swarm.json");
   const lines = [
     "## Swarm Configuration",
     "",
@@ -14003,9 +14263,9 @@ async function handleConfigCommand(directory, _args) {
 }
 
 // src/services/skill-consolidation.ts
-import { existsSync as existsSync14 } from "fs";
+import { existsSync as existsSync15 } from "fs";
 import { mkdir as mkdir8, readFile as readFile8, rename as rename4, writeFile as writeFile8 } from "fs/promises";
-import * as path27 from "path";
+import * as path28 from "path";
 
 // src/utils/timeout.ts
 async function withTimeout(promise, ms, timeoutError) {
@@ -14030,11 +14290,11 @@ var DEFAULT_CONSOLIDATION_MAX_CALLS_PER_RUN = 1;
 var CONSOLIDATION_RUN_TIMEOUT_MS = 5 * 60 * 1000;
 var runningByDirectory = new Map;
 function consolidationStatePath(directory) {
-  return path27.join(directory, ".swarm", "skill-improver", "consolidation-state.json");
+  return path28.join(directory, ".swarm", "skill-improver", "consolidation-state.json");
 }
 async function readState2(directory) {
   const filePath = consolidationStatePath(directory);
-  if (!existsSync14(filePath))
+  if (!existsSync15(filePath))
     return {};
   try {
     const parsed = JSON.parse(await readFile8(filePath, "utf-8"));
@@ -14046,7 +14306,7 @@ async function readState2(directory) {
   }
 }
 async function atomicWrite2(filePath, content) {
-  await mkdir8(path27.dirname(filePath), { recursive: true });
+  await mkdir8(path28.dirname(filePath), { recursive: true });
   const tmp = `${filePath}.tmp-${process.pid}-${Date.now()}`;
   await writeFile8(tmp, content, "utf-8");
   await rename4(tmp, filePath);
@@ -14126,7 +14386,7 @@ async function runSkillConsolidationInner(req) {
   };
 }
 async function runSkillConsolidation(req) {
-  const key = path27.resolve(req.directory);
+  const key = path28.resolve(req.directory);
   const existing = runningByDirectory.get(key);
   if (existing) {
     return {
@@ -14208,6 +14468,55 @@ async function handleConsolidateCommand(directory, args, options = {}) {
   }
 }
 
+// src/commands/costs.ts
+async function handleCostsCommand(directory, args) {
+  const summary = summarizeTelemetryCosts(directory);
+  const json = args.includes("--json");
+  if (json) {
+    return [
+      "[COSTS_JSON]",
+      JSON.stringify(summary, null, 2),
+      "[/COSTS_JSON]"
+    ].join(`
+`);
+  }
+  return renderCostSummary(summary);
+}
+function renderCostSummary(summary) {
+  const lines = [
+    "## Swarm Costs",
+    "",
+    `Total tracked cost: ${formatUsd(summary.total_cost_usd)}`,
+    `Delegations: ${summary.delegations}`,
+    `Tokens: input ${summary.total_input_tokens.toLocaleString()}, output ${summary.total_output_tokens.toLocaleString()}, reasoning ${summary.total_reasoning_tokens.toLocaleString()}, cache ${summary.total_cache_tokens.toLocaleString()}`,
+    `Cost source: reported ${formatUsd(summary.total_reported_usd)}, estimated ${formatUsd(summary.total_estimated_usd)}, unavailable ${summary.unavailable_delegations}`,
+    "",
+    "### By Agent"
+  ];
+  appendCostRows(lines, "Agent", summary.by_agent, "No delegation cost telemetry recorded.");
+  lines.push("", "### By Task");
+  appendCostRows(lines, "Task", summary.by_task, "No task cost telemetry recorded.");
+  lines.push("", "### By Gate");
+  appendCostRows(lines, "Gate", summary.by_gate, "No gate cost telemetry recorded.");
+  lines.push("", "### By Retry Loop");
+  appendCostRows(lines, "Retry", summary.by_retry, "No retry-loop cost telemetry recorded.");
+  return lines.join(`
+`);
+}
+function appendCostRows(lines, label, rows, emptyMessage) {
+  if (rows.length === 0) {
+    lines.push(emptyMessage);
+    return;
+  }
+  lines.push(`| ${label} | Delegations | Cost | Input | Output | Reasoning | Cache | Unavailable |`, "|------|-------------|------|-------|--------|-----------|-------|-------------|");
+  for (const row of rows) {
+    lines.push(`| ${row.name} | ${row.delegations} | ${formatUsd(row.cost_usd)} | ${row.input_tokens.toLocaleString()} | ${row.output_tokens.toLocaleString()} | ${row.reasoning_tokens.toLocaleString()} | ${row.cache_tokens.toLocaleString()} | ${row.unavailable_delegations} |`);
+  }
+}
+function formatUsd(value) {
+  return `$${value.toFixed(6)}`;
+}
+
 // src/commands/council.ts
 var MAX_QUESTION_LEN = 2000;
 function sanitizeQuestion(raw) {
@@ -14278,8 +14587,8 @@ async function handleCouncilCommand(_directory, args) {
 
 // src/commands/coupling.ts
 import { randomBytes } from "crypto";
-import * as fs13 from "fs";
-import * as path29 from "path";
+import * as fs14 from "fs";
+import * as path30 from "path";
 
 // src/turbo/epic/cochange-source.ts
 import * as child_process3 from "child_process";
@@ -14289,7 +14598,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 path28 from "path";
+import * as path29 from "path";
 import { promisify } from "util";
 function getExecFileAsync() {
   return promisify(child_process2.execFile);
@@ -14393,7 +14702,7 @@ async function scanSourceFiles(dir) {
   try {
     const entries = await readdir4(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path28.join(dir, entry.name);
+      const fullPath = path29.join(dir, entry.name);
       if (entry.isDirectory()) {
         if (skipDirs.has(entry.name)) {
           continue;
@@ -14401,7 +14710,7 @@ async function scanSourceFiles(dir) {
         const subFiles = await scanSourceFiles(fullPath);
         results.push(...subFiles);
       } else if (entry.isFile()) {
-        const ext = path28.extname(entry.name);
+        const ext = path29.extname(entry.name);
         if ([".ts", ".tsx", ".js", ".jsx", ".mjs"].includes(ext)) {
           results.push(fullPath);
         }
@@ -14423,8 +14732,8 @@ async function getStaticEdges(directory) {
           continue;
         }
         try {
-          const sourceDir = path28.dirname(sourceFile);
-          const resolvedPath = path28.resolve(sourceDir, importPath);
+          const sourceDir = path29.dirname(sourceFile);
+          const resolvedPath = path29.resolve(sourceDir, importPath);
           const extensions = [
             "",
             ".ts",
@@ -14449,8 +14758,8 @@ async function getStaticEdges(directory) {
           if (!targetFile) {
             continue;
           }
-          const relSource = path28.relative(directory, sourceFile).replace(/\\/g, "/");
-          const relTarget = path28.relative(directory, targetFile).replace(/\\/g, "/");
+          const relSource = path29.relative(directory, sourceFile).replace(/\\/g, "/");
+          const relTarget = path29.relative(directory, targetFile).replace(/\\/g, "/");
           const [key] = relSource < relTarget ? [`${relSource}::${relTarget}`, relSource, relTarget] : [`${relTarget}::${relSource}`, relTarget, relSource];
           edges.add(key);
         } catch {}
@@ -14462,7 +14771,7 @@ async function getStaticEdges(directory) {
 function isTestImplementationPair(fileA, fileB) {
   const testPatterns = [".test.ts", ".test.js", ".spec.ts", ".spec.js"];
   const getBaseName = (filePath) => {
-    const base = path28.basename(filePath);
+    const base = path29.basename(filePath);
     for (const pattern of testPatterns) {
       if (base.endsWith(pattern)) {
         return base.slice(0, -pattern.length);
@@ -14472,16 +14781,16 @@ function isTestImplementationPair(fileA, fileB) {
   };
   const baseA = getBaseName(fileA);
   const baseB = getBaseName(fileB);
-  return baseA === baseB && baseA !== path28.basename(fileA) && baseA !== path28.basename(fileB);
+  return baseA === baseB && baseA !== path29.basename(fileA) && baseA !== path29.basename(fileB);
 }
 function hasSharedPrefix(fileA, fileB) {
-  const dirA = path28.dirname(fileA);
-  const dirB = path28.dirname(fileB);
+  const dirA = path29.dirname(fileA);
+  const dirB = path29.dirname(fileB);
   if (dirA !== dirB) {
     return false;
   }
-  const baseA = path28.basename(fileA).replace(/\.(ts|js|tsx|jsx|mjs)$/, "");
-  const baseB = path28.basename(fileB).replace(/\.(ts|js|tsx|jsx|mjs)$/, "");
+  const baseA = path29.basename(fileA).replace(/\.(ts|js|tsx|jsx|mjs)$/, "");
+  const baseB = path29.basename(fileB).replace(/\.(ts|js|tsx|jsx|mjs)$/, "");
   if (baseA.startsWith(baseB) || baseB.startsWith(baseA)) {
     return true;
   }
@@ -14536,8 +14845,8 @@ function darkMatterToKnowledgeEntries(pairs, projectName) {
   const entries = [];
   const now = new Date().toISOString();
   for (const pair of pairs.slice(0, 10)) {
-    const baseA = path28.basename(pair.fileA);
-    const baseB = path28.basename(pair.fileB);
+    const baseA = path29.basename(pair.fileA);
+    const baseB = path29.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.`;
@@ -14963,17 +15272,17 @@ function parseArgs3(args) {
   return parsed;
 }
 function persistReportJson(directory, report) {
-  const epicDir = path29.join(directory, ".swarm", "epic");
-  fs13.mkdirSync(epicDir, { recursive: true });
-  const filePath = path29.join(epicDir, "coupling-report.json");
+  const epicDir = path30.join(directory, ".swarm", "epic");
+  fs14.mkdirSync(epicDir, { recursive: true });
+  const filePath = path30.join(epicDir, "coupling-report.json");
   const tmpPath = `${filePath}.tmp.${randomBytes(8).toString("hex")}`;
-  fs13.writeFileSync(tmpPath, `${JSON.stringify(report, null, 2)}
+  fs14.writeFileSync(tmpPath, `${JSON.stringify(report, null, 2)}
 `, "utf-8");
   try {
-    fs13.renameSync(tmpPath, filePath);
+    fs14.renameSync(tmpPath, filePath);
   } catch (err) {
     try {
-      fs13.unlinkSync(tmpPath);
+      fs14.unlinkSync(tmpPath);
     } catch {}
     throw err;
   }
@@ -15024,7 +15333,7 @@ Usage: /swarm coupling [--phase <n>] [--threshold <-1..1>] [--min-co-changes <n>
       persistStatus = {
         requested: true,
         written: true,
-        path: path29.relative(directory, writtenAt)
+        path: path30.relative(directory, writtenAt)
       };
     } catch (err) {
       persistStatus = {
@@ -15083,7 +15392,7 @@ function formatCurationSummary(summary) {
 }
 
 // src/commands/dark-matter.ts
-import path30 from "path";
+import path31 from "path";
 async function handleDarkMatterCommand(directory, args) {
   const options = {};
   for (let i = 0;i < args.length; i++) {
@@ -15115,7 +15424,7 @@ Ensure this is a git repository with commit history.`;
   const output = formatDarkMatterOutput(pairs);
   if (pairs.length > 0) {
     try {
-      const projectName = path30.basename(path30.resolve(directory));
+      const projectName = path31.basename(path31.resolve(directory));
       const entries = darkMatterToKnowledgeEntries(pairs, projectName);
       if (entries.length > 0) {
         const knowledgePath = resolveSwarmKnowledgePath(directory);
@@ -15481,50 +15790,50 @@ ${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 path32 from "path";
+import { existsSync as existsSync18, readdirSync as readdirSync3, readFileSync as readFileSync10, statSync as statSync6 } from "fs";
+import path33 from "path";
 import { fileURLToPath } from "url";
 
 // src/config/cache-paths.ts
-import * as os7 from "os";
-import * as path31 from "path";
+import * as os8 from "os";
+import * as path32 from "path";
 function getPluginConfigDir() {
-  return path31.join(process.env.XDG_CONFIG_HOME || path31.join(os7.homedir(), ".config"), "opencode");
+  return path32.join(process.env.XDG_CONFIG_HOME || path32.join(os8.homedir(), ".config"), "opencode");
 }
 function getPluginCachePaths() {
-  const cacheBase = process.env.XDG_CACHE_HOME || path31.join(os7.homedir(), ".cache");
+  const cacheBase = process.env.XDG_CACHE_HOME || path32.join(os8.homedir(), ".cache");
   const configDir = getPluginConfigDir();
   const paths = [
-    path31.join(cacheBase, "opencode", "node_modules", "opencode-swarm"),
-    path31.join(cacheBase, "opencode", "packages", "opencode-swarm@latest"),
-    path31.join(configDir, "node_modules", "opencode-swarm")
+    path32.join(cacheBase, "opencode", "node_modules", "opencode-swarm"),
+    path32.join(cacheBase, "opencode", "packages", "opencode-swarm@latest"),
+    path32.join(configDir, "node_modules", "opencode-swarm")
   ];
   if (process.platform === "darwin") {
-    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"));
+    const libCaches = path32.join(os8.homedir(), "Library", "Caches");
+    paths.push(path32.join(libCaches, "opencode", "node_modules", "opencode-swarm"), path32.join(libCaches, "opencode", "packages", "opencode-swarm@latest"));
   }
   if (process.platform === "win32") {
-    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"));
+    const localAppData = process.env.LOCALAPPDATA || path32.join(os8.homedir(), "AppData", "Local");
+    const appData = process.env.APPDATA || path32.join(os8.homedir(), "AppData", "Roaming");
+    paths.push(path32.join(localAppData, "opencode", "node_modules", "opencode-swarm"), path32.join(localAppData, "opencode", "packages", "opencode-swarm@latest"), path32.join(appData, "opencode", "node_modules", "opencode-swarm"));
   }
   return paths;
 }
 function getPluginLockFilePaths() {
-  const cacheBase = process.env.XDG_CACHE_HOME || path31.join(os7.homedir(), ".cache");
+  const cacheBase = process.env.XDG_CACHE_HOME || path32.join(os8.homedir(), ".cache");
   const configDir = getPluginConfigDir();
   const paths = [
-    path31.join(cacheBase, "opencode", "bun.lock"),
-    path31.join(cacheBase, "opencode", "bun.lockb"),
-    path31.join(configDir, "package-lock.json")
+    path32.join(cacheBase, "opencode", "bun.lock"),
+    path32.join(cacheBase, "opencode", "bun.lockb"),
+    path32.join(configDir, "package-lock.json")
   ];
   if (process.platform === "darwin") {
-    const libCaches = path31.join(os7.homedir(), "Library", "Caches");
-    paths.push(path31.join(libCaches, "opencode", "bun.lock"), path31.join(libCaches, "opencode", "bun.lockb"));
+    const libCaches = path32.join(os8.homedir(), "Library", "Caches");
+    paths.push(path32.join(libCaches, "opencode", "bun.lock"), path32.join(libCaches, "opencode", "bun.lockb"));
   }
   if (process.platform === "win32") {
-    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"));
+    const localAppData = process.env.LOCALAPPDATA || path32.join(os8.homedir(), "AppData", "Local");
+    paths.push(path32.join(localAppData, "opencode", "bun.lock"), path32.join(localAppData, "opencode", "bun.lockb"));
   }
   return paths;
 }
@@ -15534,28 +15843,28 @@ init_capability_probe();
 init_executor();
 
 // src/services/knowledge-diagnostics.ts
-import { existsSync as existsSync16 } from "fs";
+import { existsSync as existsSync17 } from "fs";
 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 { existsSync as existsSync16, mkdirSync as mkdirSync9, readFileSync as readFileSync9, writeFileSync as writeFileSync8 } from "fs";
 import { homedir as homedir4 } from "os";
-import { join as join26 } from "path";
+import { join as join27 } 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 : join26(homedir4(), ".cache");
-  return join26(base, "opencode-swarm");
+  const base = xdg && xdg.length > 0 ? xdg : join27(homedir4(), ".cache");
+  return join27(base, "opencode-swarm");
 }
 function cacheFile() {
-  return join26(cacheDir(), "version-check.json");
+  return join27(cacheDir(), "version-check.json");
 }
 function readVersionCache() {
   try {
-    const path32 = cacheFile();
-    if (!existsSync15(path32))
+    const path33 = cacheFile();
+    if (!existsSync16(path33))
       return null;
-    const raw = readFileSync8(path32, "utf-8");
+    const raw = readFileSync9(path33, "utf-8");
     const parsed = JSON.parse(raw);
     if (typeof parsed?.checkedAt !== "number")
       return null;
@@ -15594,7 +15903,7 @@ var SEVEN_DAYS_MS2 = 7 * 24 * 60 * 60 * 1000;
 var UNACTIONABLE_BACKLOG_WARN = 100;
 var INSIGHT_BACKLOG_WARN = 50;
 async function readRawLines(filePath) {
-  if (!existsSync16(filePath))
+  if (!existsSync17(filePath))
     return { entries: [], corrupt: 0 };
   const content = await readFile10(filePath, "utf-8");
   const entries = [];
@@ -15719,7 +16028,7 @@ async function computeKnowledgeDebug(directory) {
   };
 }
 async function safeJsonlCount(filePath) {
-  if (!filePath || !existsSync16(filePath))
+  if (!filePath || !existsSync17(filePath))
     return 0;
   try {
     const content = await readFile10(filePath, "utf-8");
@@ -16040,7 +16349,7 @@ async function checkConfigBackups(directory) {
 }
 async function checkGitRepository(directory) {
   try {
-    if (!existsSync17(directory) || !statSync6(directory).isDirectory()) {
+    if (!existsSync18(directory) || !statSync6(directory).isDirectory()) {
       return {
         name: "Git Repository",
         status: "\u274C",
@@ -16104,8 +16413,8 @@ async function checkSpecStaleness(directory, plan) {
   };
 }
 async function checkConfigParseability(directory) {
-  const configPath = path32.join(directory, ".opencode/opencode-swarm.json");
-  if (!existsSync17(configPath)) {
+  const configPath = path33.join(directory, ".opencode/opencode-swarm.json");
+  if (!existsSync18(configPath)) {
     return {
       name: "Config Parseability",
       status: "\u2705",
@@ -16113,7 +16422,7 @@ async function checkConfigParseability(directory) {
     };
   }
   try {
-    const content = readFileSync9(configPath, "utf-8");
+    const content = readFileSync10(configPath, "utf-8");
     JSON.parse(content);
     return {
       name: "Config Parseability",
@@ -16133,7 +16442,7 @@ function resolveGrammarDir(thisDir) {
   const normalized = thisDir.replace(/\\/g, "/");
   const isSource = normalized.endsWith("/src/services");
   const isCliBundle = normalized.endsWith("/cli");
-  return isSource || isCliBundle ? path32.join(thisDir, "..", "lang", "grammars") : path32.join(thisDir, "lang", "grammars");
+  return isSource || isCliBundle ? path33.join(thisDir, "..", "lang", "grammars") : path33.join(thisDir, "lang", "grammars");
 }
 async function checkGrammarWasmFiles() {
   const grammarFiles = [
@@ -16157,14 +16466,14 @@ async function checkGrammarWasmFiles() {
     "tree-sitter-ini.wasm",
     "tree-sitter-regex.wasm"
   ];
-  const thisDir = path32.dirname(fileURLToPath(import.meta.url));
+  const thisDir = path33.dirname(fileURLToPath(import.meta.url));
   const grammarDir = resolveGrammarDir(thisDir);
   const missing = [];
-  if (!existsSync17(path32.join(grammarDir, "tree-sitter.wasm"))) {
+  if (!existsSync18(path33.join(grammarDir, "tree-sitter.wasm"))) {
     missing.push("tree-sitter.wasm (core runtime)");
   }
   for (const file of grammarFiles) {
-    if (!existsSync17(path32.join(grammarDir, file))) {
+    if (!existsSync18(path33.join(grammarDir, file))) {
       missing.push(file);
     }
   }
@@ -16182,8 +16491,8 @@ async function checkGrammarWasmFiles() {
   };
 }
 async function checkCheckpointManifest(directory) {
-  const manifestPath = path32.join(directory, ".swarm/checkpoints.json");
-  if (!existsSync17(manifestPath)) {
+  const manifestPath = path33.join(directory, ".swarm/checkpoints.json");
+  if (!existsSync18(manifestPath)) {
     return {
       name: "Checkpoint Manifest",
       status: "\u2705",
@@ -16191,7 +16500,7 @@ async function checkCheckpointManifest(directory) {
     };
   }
   try {
-    const content = readFileSync9(manifestPath, "utf-8");
+    const content = readFileSync10(manifestPath, "utf-8");
     const parsed = JSON.parse(content);
     if (!parsed.checkpoints || !Array.isArray(parsed.checkpoints)) {
       return {
@@ -16234,8 +16543,8 @@ async function checkCheckpointManifest(directory) {
   }
 }
 async function checkEventStreamIntegrity(directory) {
-  const eventsPath = path32.join(directory, ".swarm/events.jsonl");
-  if (!existsSync17(eventsPath)) {
+  const eventsPath = path33.join(directory, ".swarm/events.jsonl");
+  if (!existsSync18(eventsPath)) {
     return {
       name: "Event Stream",
       status: "\u2705",
@@ -16243,7 +16552,7 @@ async function checkEventStreamIntegrity(directory) {
     };
   }
   try {
-    const content = readFileSync9(eventsPath, "utf-8");
+    const content = readFileSync10(eventsPath, "utf-8");
     const lines = content.split(`
 `).filter((line) => line.trim() !== "");
     let malformedCount = 0;
@@ -16275,8 +16584,8 @@ async function checkEventStreamIntegrity(directory) {
   }
 }
 async function checkSteeringDirectives(directory) {
-  const eventsPath = path32.join(directory, ".swarm/events.jsonl");
-  if (!existsSync17(eventsPath)) {
+  const eventsPath = path33.join(directory, ".swarm/events.jsonl");
+  if (!existsSync18(eventsPath)) {
     return {
       name: "Steering Directives",
       status: "\u2705",
@@ -16284,7 +16593,7 @@ async function checkSteeringDirectives(directory) {
     };
   }
   try {
-    const content = readFileSync9(eventsPath, "utf-8");
+    const content = readFileSync10(eventsPath, "utf-8");
     const lines = content.split(`
 `).filter((line) => line.trim() !== "");
     const directivesIssued = [];
@@ -16331,8 +16640,8 @@ async function checkCurator(directory) {
         detail: "Disabled (enable via curator.enabled)"
       };
     }
-    const summaryPath = path32.join(directory, ".swarm/curator-summary.json");
-    if (!existsSync17(summaryPath)) {
+    const summaryPath = path33.join(directory, ".swarm/curator-summary.json");
+    if (!existsSync18(summaryPath)) {
       return {
         name: "Curator",
         status: "\u2705",
@@ -16340,7 +16649,7 @@ async function checkCurator(directory) {
       };
     }
     try {
-      const content = readFileSync9(summaryPath, "utf-8");
+      const content = readFileSync10(summaryPath, "utf-8");
       const parsed = JSON.parse(content);
       if (typeof parsed.schema_version !== "number" || parsed.schema_version !== 1) {
         return {
@@ -16533,8 +16842,8 @@ async function getDiagnoseData(directory) {
   checks.push(await checkCurator(directory));
   checks.push(await checkKnowledgeHealth(directory));
   try {
-    const evidenceDir = path32.join(directory, ".swarm", "evidence");
-    const snapshotFiles = existsSync17(evidenceDir) ? readdirSync3(evidenceDir).filter((f) => f.startsWith("agent-tools-") && f.endsWith(".json")) : [];
+    const evidenceDir = path33.join(directory, ".swarm", "evidence");
+    const snapshotFiles = existsSync18(evidenceDir) ? readdirSync3(evidenceDir).filter((f) => f.startsWith("agent-tools-") && f.endsWith(".json")) : [];
     if (snapshotFiles.length > 0) {
       const latest = snapshotFiles.sort().pop();
       checks.push({
@@ -16567,13 +16876,13 @@ async function getDiagnoseData(directory) {
   const cacheRows = [];
   for (const cachePath of cachePaths) {
     try {
-      if (!existsSync17(cachePath)) {
+      if (!existsSync18(cachePath)) {
         cacheRows.push(`\u2B1C ${cachePath} \u2014 absent`);
         continue;
       }
-      const pkgJsonPath = path32.join(cachePath, "package.json");
+      const pkgJsonPath = path33.join(cachePath, "package.json");
       try {
-        const raw = readFileSync9(pkgJsonPath, "utf-8");
+        const raw = readFileSync10(pkgJsonPath, "utf-8");
         const parsed = JSON.parse(raw);
         const installedVersion = typeof parsed.version === "string" ? parsed.version : "?";
         cacheRows.push(`\u2705 ${cachePath} \u2014 v${installedVersion}`);
@@ -16792,7 +17101,7 @@ async function handleDoctorCommand(directory, args) {
   const result = runConfigDoctor(config, directory);
   let output;
   if (enableAutoFix && result.hasAutoFixableIssues) {
-    const { runConfigDoctorWithFixes } = await import("./config-doctor-7yrxfa6b.js");
+    const { runConfigDoctorWithFixes } = await import("./config-doctor-9fhfy6p7.js");
     const fixResult = await runConfigDoctorWithFixes(directory, config, true);
     output = formatDoctorMarkdown(fixResult.result);
   } else {
@@ -16942,10 +17251,10 @@ function decideEpicActivation(tasks, cochangePairs, commitsObserved, options) {
 
 // src/turbo/epic/calibration.ts
 init_logger();
-import * as fs14 from "fs";
-import * as path33 from "path";
+import * as fs15 from "fs";
+import * as path34 from "path";
 var STATE_FILE = "calibration.json";
-var STATE_REL_DIR = path33.join(".swarm", "epic");
+var STATE_REL_DIR = path34.join(".swarm", "epic");
 function nowISO() {
   return new Date().toISOString();
 }
@@ -16967,13 +17276,13 @@ function markUnreadable(directory, reason) {
   error(`[epic/calibration] state file unreadable for ${directory}: ${reason} \u2014 failing closed`);
 }
 function repairCalibrationUnreadable(directory) {
-  const filePath = path33.join(directory, STATE_REL_DIR, STATE_FILE);
-  if (!fs14.existsSync(filePath)) {
+  const filePath = path34.join(directory, STATE_REL_DIR, STATE_FILE);
+  if (!fs15.existsSync(filePath)) {
     stateUnreadableMap.delete(directory);
     return;
   }
   try {
-    const raw = fs14.readFileSync(filePath, "utf-8");
+    const raw = fs15.readFileSync(filePath, "utf-8");
     const parsed = JSON.parse(raw);
     if (!isValidCalibrationShape(parsed)) {
       stateUnreadableMap.set(directory, true);
@@ -16999,9 +17308,9 @@ function isValidCalibrationShape(candidate) {
   return true;
 }
 function ensureSwarmEpicDir(directory) {
-  const dir = path33.resolve(directory, STATE_REL_DIR);
-  if (!fs14.existsSync(dir)) {
-    fs14.mkdirSync(dir, { recursive: true });
+  const dir = path34.resolve(directory, STATE_REL_DIR);
+  if (!fs15.existsSync(dir)) {
+    fs15.mkdirSync(dir, { recursive: true });
   }
   return dir;
 }
@@ -17011,18 +17320,18 @@ function loadCalibrationState(directory) {
     if (stateUnreadableMap.get(directory))
       return null;
   }
-  const filePath = path33.join(directory, STATE_REL_DIR, STATE_FILE);
+  const filePath = path34.join(directory, STATE_REL_DIR, STATE_FILE);
   try {
-    if (!fs14.existsSync(filePath)) {
+    if (!fs15.existsSync(filePath)) {
       const seed = emptyCalibrationState();
       try {
         ensureSwarmEpicDir(directory);
-        fs14.writeFileSync(filePath, `${JSON.stringify(seed, null, 2)}
+        fs15.writeFileSync(filePath, `${JSON.stringify(seed, null, 2)}
 `, "utf-8");
       } catch {}
       return seed;
     }
-    const raw = fs14.readFileSync(filePath, "utf-8");
+    const raw = fs15.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})`);
@@ -17037,36 +17346,36 @@ function loadCalibrationState(directory) {
 
 // src/turbo/epic/divergence-recorder.ts
 init_logger();
-import * as fs15 from "fs";
-import * as path34 from "path";
-var EVIDENCE_REL_DIR = path34.join(".swarm", "epic");
+import * as fs16 from "fs";
+import * as path35 from "path";
+var EVIDENCE_REL_DIR = path35.join(".swarm", "epic");
 var EVIDENCE_FILE = "divergence.jsonl";
 var MAX_TAIL_BYTES2 = 16 * 1024 * 1024;
 function readDivergenceHistory(directory, options) {
-  const filePath = path34.join(directory, EVIDENCE_REL_DIR, EVIDENCE_FILE);
-  if (!fs15.existsSync(filePath)) {
+  const filePath = path35.join(directory, EVIDENCE_REL_DIR, EVIDENCE_FILE);
+  if (!fs16.existsSync(filePath)) {
     return [];
   }
   const maxBytes = options?.maxBytes ?? MAX_TAIL_BYTES2;
   let raw;
   let tailTruncated = false;
   try {
-    const stat5 = fs15.statSync(filePath);
+    const stat5 = fs16.statSync(filePath);
     if (Number.isFinite(maxBytes) && stat5.size > maxBytes) {
-      const fd = fs15.openSync(filePath, "r");
+      const fd = fs16.openSync(filePath, "r");
       try {
         const buf = Buffer.alloc(maxBytes);
         const offset = stat5.size - maxBytes;
-        fs15.readSync(fd, buf, 0, maxBytes, offset);
+        fs16.readSync(fd, buf, 0, maxBytes, offset);
         raw = buf.toString("utf-8");
         tailTruncated = true;
       } finally {
         try {
-          fs15.closeSync(fd);
+          fs16.closeSync(fd);
         } catch {}
       }
     } else {
-      raw = fs15.readFileSync(filePath, "utf-8");
+      raw = fs16.readFileSync(filePath, "utf-8");
     }
   } catch {
     return [];
@@ -17091,16 +17400,16 @@ function readDivergenceHistory(directory, options) {
 }
 
 // src/turbo/epic/promotion-evidence.ts
-import * as fs16 from "fs";
-import * as path35 from "path";
-var EVIDENCE_REL_DIR2 = path35.join(".swarm", "evidence");
+import * as fs17 from "fs";
+import * as path36 from "path";
+var EVIDENCE_REL_DIR2 = path36.join(".swarm", "evidence");
 var EVIDENCE_FILE2 = "epic-promotions.jsonl";
 function readPromotionEvidence(directory) {
-  const filePath = path35.join(directory, EVIDENCE_REL_DIR2, EVIDENCE_FILE2);
-  if (!fs16.existsSync(filePath)) {
+  const filePath = path36.join(directory, EVIDENCE_REL_DIR2, EVIDENCE_FILE2);
+  if (!fs17.existsSync(filePath)) {
     return [];
   }
-  const raw = fs16.readFileSync(filePath, "utf-8");
+  const raw = fs17.readFileSync(filePath, "utf-8");
   const lines = raw.split(`
 `).filter((l) => l.trim().length > 0);
   const records = [];
@@ -17605,7 +17914,7 @@ async function handleEvidenceCommand(directory, args) {
   return formatTaskEvidenceMarkdown(evidenceData);
 }
 async function handleEvidenceSummaryCommand(directory) {
-  const { buildEvidenceSummary } = await import("./evidence-summary-service-g4x5e3e3.js");
+  const { buildEvidenceSummary } = await import("./evidence-summary-service-4hs44n2c.js");
   const artifact = await buildEvidenceSummary(directory);
   if (!artifact) {
     return "No plan found. Run `/swarm plan` to check plan status.";
@@ -17669,8 +17978,8 @@ async function handleExportCommand(directory, _args) {
 }
 // src/full-auto/state.ts
 var import_proper_lockfile4 = __toESM(require_proper_lockfile(), 1);
-import * as fs17 from "fs";
-import * as path36 from "path";
+import * as fs18 from "fs";
+import * as path37 from "path";
 init_logger();
 var lockfile4 = import_proper_lockfile4.default;
 var STATE_FILE2 = "full-auto-state.json";
@@ -17678,9 +17987,9 @@ function nowISO2() {
   return new Date().toISOString();
 }
 function ensureSwarmDir(directory) {
-  const swarmDir = path36.resolve(directory, ".swarm");
-  if (!fs17.existsSync(swarmDir)) {
-    fs17.mkdirSync(swarmDir, { recursive: true });
+  const swarmDir = path37.resolve(directory, ".swarm");
+  if (!fs18.existsSync(swarmDir)) {
+    fs18.mkdirSync(swarmDir, { recursive: true });
   }
   return swarmDir;
 }
@@ -17738,7 +18047,7 @@ function withStateLock(directory, fn) {
   let release;
   try {
     const lockTarget = validateSwarmPath(directory, STATE_FILE2);
-    if (!fs17.existsSync(lockTarget)) {
+    if (!fs18.existsSync(lockTarget)) {
       ensureSwarmDir(directory);
       const seed = {
         version: 2,
@@ -17746,7 +18055,7 @@ function withStateLock(directory, fn) {
         oversightSequence: 0,
         sessions: {}
       };
-      fs17.writeFileSync(lockTarget, `${JSON.stringify(seed, null, 2)}
+      fs18.writeFileSync(lockTarget, `${JSON.stringify(seed, null, 2)}
 `, "utf-8");
     }
     release = lockfile4.lockSync(lockTarget, {
@@ -17796,7 +18105,7 @@ function readPersisted(directory) {
     const filePath = validateSwarmPath(directory, STATE_FILE2);
     let stats;
     try {
-      stats = fs17.statSync(filePath);
+      stats = fs18.statSync(filePath);
     } catch {
       clearStateUnreadable();
       readCache.delete(filePath);
@@ -17807,7 +18116,7 @@ function readPersisted(directory) {
       clearStateUnreadable();
       return structuredClone(cached.state);
     }
-    const raw = fs17.readFileSync(filePath, "utf-8");
+    const raw = fs18.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})`);
@@ -17832,8 +18141,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 (fs17.existsSync(bakPath)) {
-        const raw = fs17.readFileSync(bakPath, "utf-8");
+      if (fs18.existsSync(bakPath)) {
+        const raw = fs18.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`);
@@ -17873,23 +18182,23 @@ function writePersisted(directory, persisted) {
     throw new Error(`Full-Auto state persistence prepare failed: ${msg}`);
   }
   try {
-    if (fs17.existsSync(filePath)) {
-      fs17.copyFileSync(filePath, bakPath);
+    if (fs18.existsSync(filePath)) {
+      fs18.copyFileSync(filePath, bakPath);
     }
   } catch {}
   try {
-    fs17.writeFileSync(tmpPath, payload, "utf-8");
+    fs18.writeFileSync(tmpPath, payload, "utf-8");
     try {
-      const fd = fs17.openSync(tmpPath, "r+");
+      const fd = fs18.openSync(tmpPath, "r+");
       try {
-        fs17.fsyncSync(fd);
+        fs18.fsyncSync(fd);
       } finally {
-        fs17.closeSync(fd);
+        fs18.closeSync(fd);
       }
     } catch {}
-    fs17.renameSync(tmpPath, filePath);
+    fs18.renameSync(tmpPath, filePath);
     readCache.delete(filePath);
-    const readback = fs17.readFileSync(filePath, "utf-8");
+    const readback = fs18.readFileSync(filePath, "utf-8");
     const parsed = JSON.parse(readback);
     if (parsed?.version !== 2) {
       throw new Error("Round-trip readback returned wrong version");
@@ -18109,7 +18418,7 @@ function buildStatusReport(directory, sessionID, sessionFlag) {
 
 // src/commands/handoff.ts
 import crypto4 from "crypto";
-import { renameSync as renameSync9, unlinkSync as unlinkSync5 } from "fs";
+import { renameSync as renameSync9, unlinkSync as unlinkSync6 } from "fs";
 
 // src/services/handoff-service.ts
 var RTL_OVERRIDE_PATTERN = /[\u202e\u202d\u202c\u200f]/g;
@@ -18490,7 +18799,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 path37 from "path";
+import * as path38 from "path";
 var _writeInFlight = Promise.resolve();
 function serializeAgentSession(s) {
   const gateLog = {};
@@ -18597,7 +18906,7 @@ async function writeSnapshot(directory, state) {
     }
     const content = JSON.stringify(snapshot, null, 2);
     const resolvedPath = validateSwarmPath(directory, "session/state.json");
-    const dir = path37.dirname(resolvedPath);
+    const dir = path38.dirname(resolvedPath);
     mkdirSync14(dir, { recursive: true });
     const tempPath = `${resolvedPath}.tmp.${Date.now()}.${Math.random().toString(36).slice(2)}`;
     await bunWrite(tempPath, content);
@@ -18644,7 +18953,7 @@ async function handleHandoffCommand(directory, _args) {
       renameSync9(tempPath, resolvedPath);
     } catch (renameErr) {
       try {
-        unlinkSync5(tempPath);
+        unlinkSync6(tempPath);
       } catch {}
       throw renameErr;
     }
@@ -18656,7 +18965,7 @@ async function handleHandoffCommand(directory, _args) {
       renameSync9(promptTempPath, promptPath);
     } catch (renameErr) {
       try {
-        unlinkSync5(promptTempPath);
+        unlinkSync6(promptTempPath);
       } catch {}
       throw renameErr;
     }
@@ -19100,15 +19409,15 @@ ${USAGE6}`;
 }
 
 // src/commands/knowledge.ts
-import { join as join31 } from "path";
+import { join as join32 } from "path";
 
 // src/hooks/knowledge-migrator.ts
 init_logger();
 import { randomUUID as randomUUID4 } from "crypto";
-import { existsSync as existsSync22, readFileSync as readFileSync14 } from "fs";
+import { existsSync as existsSync23, readFileSync as readFileSync15 } from "fs";
 import { mkdir as mkdir9, readFile as readFile11, writeFile as writeFile9 } from "fs/promises";
-import * as os8 from "os";
-import * as path38 from "path";
+import * as os9 from "os";
+import * as path39 from "path";
 
 // src/hooks/knowledge-types.ts
 var KNOWLEDGE_SCHEMA_VERSION = 2;
@@ -19138,10 +19447,10 @@ var _internals30 = {
   resolveLegacyHiveKnowledgePath
 };
 async function migrateContextToKnowledge(directory, config) {
-  const sentinelPath = path38.join(directory, ".swarm", ".knowledge-migrated");
-  const contextPath = path38.join(directory, ".swarm", "context.md");
+  const sentinelPath = path39.join(directory, ".swarm", ".knowledge-migrated");
+  const contextPath = path39.join(directory, ".swarm", "context.md");
   const knowledgePath = resolveSwarmKnowledgePath(directory);
-  if (existsSync22(sentinelPath)) {
+  if (existsSync23(sentinelPath)) {
     return {
       migrated: false,
       entriesMigrated: 0,
@@ -19150,7 +19459,7 @@ async function migrateContextToKnowledge(directory, config) {
       skippedReason: "sentinel-exists"
     };
   }
-  if (!existsSync22(contextPath)) {
+  if (!existsSync23(contextPath)) {
     return {
       migrated: false,
       entriesMigrated: 0,
@@ -19241,8 +19550,8 @@ async function migrateContextToKnowledge(directory, config) {
 async function migrateHiveKnowledgeLegacy(config) {
   const legacyHivePath = _internals30.resolveLegacyHiveKnowledgePath();
   const canonicalHivePath = resolveHiveKnowledgePath();
-  const sentinelPath = path38.join(path38.dirname(canonicalHivePath), ".hive-knowledge-migrated");
-  if (existsSync22(sentinelPath)) {
+  const sentinelPath = path39.join(path39.dirname(canonicalHivePath), ".hive-knowledge-migrated");
+  if (existsSync23(sentinelPath)) {
     return {
       migrated: false,
       entriesMigrated: 0,
@@ -19251,7 +19560,7 @@ async function migrateHiveKnowledgeLegacy(config) {
       skippedReason: "sentinel-exists"
     };
   }
-  if (!existsSync22(legacyHivePath)) {
+  if (!existsSync23(legacyHivePath)) {
     return {
       migrated: false,
       entriesMigrated: 0,
@@ -19452,16 +19761,16 @@ function truncateLesson2(text) {
   return `${text.slice(0, 277)}...`;
 }
 function inferProjectName(directory) {
-  const packageJsonPath = path38.join(directory, "package.json");
-  if (existsSync22(packageJsonPath)) {
+  const packageJsonPath = path39.join(directory, "package.json");
+  if (existsSync23(packageJsonPath)) {
     try {
-      const pkg = JSON.parse(readFileSync14(packageJsonPath, "utf-8"));
+      const pkg = JSON.parse(readFileSync15(packageJsonPath, "utf-8"));
       if (pkg.name && typeof pkg.name === "string") {
         return pkg.name;
       }
     } catch {}
   }
-  return path38.basename(directory);
+  return path39.basename(directory);
 }
 async function writeSentinel(sentinelPath, migrated, dropped) {
   const sentinel = {
@@ -19473,21 +19782,21 @@ async function writeSentinel(sentinelPath, migrated, dropped) {
     schema_version: 1,
     migration_tool: "knowledge-migrator.ts"
   };
-  await mkdir9(path38.dirname(sentinelPath), { recursive: true });
+  await mkdir9(path39.dirname(sentinelPath), { recursive: true });
   await writeFile9(sentinelPath, JSON.stringify(sentinel, null, 2), "utf-8");
 }
 function resolveLegacyHiveKnowledgePath() {
   const platform = process.platform;
-  const home = process.env.HOME || os8.homedir();
+  const home = process.env.HOME || os9.homedir();
   let dataDir;
   if (platform === "win32") {
-    dataDir = path38.join(process.env.LOCALAPPDATA || path38.join(home, "AppData", "Local"), "opencode-swarm", "Data");
+    dataDir = path39.join(process.env.LOCALAPPDATA || path39.join(home, "AppData", "Local"), "opencode-swarm", "Data");
   } else if (platform === "darwin") {
-    dataDir = path38.join(home, "Library", "Application Support", "opencode-swarm");
+    dataDir = path39.join(home, "Library", "Application Support", "opencode-swarm");
   } else {
-    dataDir = path38.join(process.env.XDG_DATA_HOME || path38.join(home, ".local", "share"), "opencode-swarm");
+    dataDir = path39.join(process.env.XDG_DATA_HOME || path39.join(home, ".local", "share"), "opencode-swarm");
   }
-  return path38.join(dataDir, "hive-knowledge.jsonl");
+  return path39.join(dataDir, "hive-knowledge.jsonl");
 }
 
 // src/commands/knowledge.ts
@@ -19541,7 +19850,7 @@ async function handleKnowledgeRestoreCommand(directory, args) {
     return "Invalid entry ID. IDs must be 1-64 characters: letters, digits, hyphens, underscores only.";
   }
   try {
-    const quarantinePath = join31(resolveKnowledgeStoreDir(directory), "knowledge-quarantined.jsonl");
+    const quarantinePath = join32(resolveKnowledgeStoreDir(directory), "knowledge-quarantined.jsonl");
     const entries = await readKnowledge(quarantinePath);
     const resolved = resolveEntryByPrefix(entries, inputId);
     if ("error" in resolved) {
@@ -19792,15 +20101,15 @@ var _internals31 = {
 };
 
 // src/commands/link.ts
-import { existsSync as existsSync23 } from "fs";
-import * as path40 from "path";
+import { existsSync as existsSync24 } from "fs";
+import * as path41 from "path";
 
 // src/knowledge/identity.ts
 import * as child_process5 from "child_process";
 import { createHash as createHash4 } from "crypto";
-import * as path39 from "path";
+import * as path40 from "path";
 function deriveProjectHash(directory) {
-  const absolutePath = path39.resolve(directory);
+  const absolutePath = path40.resolve(directory);
   let hashInput;
   try {
     const remoteUrl = child_process5.execSync("git remote get-url origin", {
@@ -19820,18 +20129,18 @@ function deriveProjectHash(directory) {
 // src/commands/link.ts
 var DEDUP_THRESHOLD = 0.6;
 async function mergeLocalKnowledgeIntoLink(localSwarmDir, linkDir) {
-  const localPath = path40.join(localSwarmDir, "knowledge.jsonl");
-  const sharedPath = path40.join(linkDir, "knowledge.jsonl");
-  if (!existsSync23(localPath))
+  const localPath = path41.join(localSwarmDir, "knowledge.jsonl");
+  const sharedPath = path41.join(linkDir, "knowledge.jsonl");
+  if (!existsSync24(localPath))
     return { merged: 0, skipped: 0 };
   let merged = 0;
   let skipped = 0;
-  const { readFileSync: readFileSync15 } = await import("fs");
+  const { readFileSync: readFileSync16 } = await import("fs");
   let changed = false;
   await transactKnowledge(sharedPath, (sharedEntries) => {
     const localEntries = [];
     try {
-      const content = readFileSync15(localPath, "utf-8");
+      const content = readFileSync16(localPath, "utf-8");
       for (const line of content.split(`
 `)) {
         if (line.trim()) {
@@ -19919,7 +20228,7 @@ ${formatStatus(directory)}`;
   const linkDir = resolveLinkDir(linkId);
   let merge;
   try {
-    merge = await mergeLocalKnowledgeIntoLink(path40.join(directory, ".swarm"), linkDir);
+    merge = await mergeLocalKnowledgeIntoLink(path41.join(directory, ".swarm"), linkDir);
   } catch (error2) {
     return `\u274C Failed to merge local knowledge into the link store: ${error2 instanceof Error ? error2.message : String(error2)}`;
   }
@@ -20063,8 +20372,8 @@ ${USAGE7}`;
 }
 
 // src/commands/memory.ts
-import { existsSync as existsSync26 } from "fs";
-import * as path47 from "path";
+import { existsSync as existsSync27 } from "fs";
+import * as path48 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/memory/config.ts
@@ -20204,13 +20513,13 @@ class MemoryValidationError extends Error {
   }
 }
 // src/memory/evaluation.ts
-import * as fs18 from "fs/promises";
-import * as os9 from "os";
-import * as path45 from "path";
+import * as fs19 from "fs/promises";
+import * as os10 from "os";
+import * as path46 from "path";
 
 // src/memory/local-jsonl-provider.ts
 import { randomUUID as randomUUID5 } from "crypto";
-import { existsSync as existsSync24 } from "fs";
+import { existsSync as existsSync25 } from "fs";
 import {
   appendFile as appendFile3,
   mkdir as mkdir10,
@@ -20218,7 +20527,7 @@ import {
   rename as rename5,
   writeFile as writeFile10
 } from "fs/promises";
-import * as path41 from "path";
+import * as path42 from "path";
 
 // src/memory/schema.ts
 import { createHash as createHash5 } from "crypto";
@@ -21079,7 +21388,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, path41.join(storageDir, filename));
+    return validateSwarmPath(this.rootDirectory, path42.join(storageDir, filename));
   }
   async initialize() {
     if (this.initialized)
@@ -21406,7 +21715,7 @@ function validateLoadedProposals(values, config) {
   return { records, invalidCount };
 }
 async function readJsonl(filePath) {
-  if (!existsSync24(filePath))
+  if (!existsSync25(filePath))
     return [];
   const content = await readFile12(filePath, "utf-8");
   const records = [];
@@ -21462,12 +21771,12 @@ function parseRecallUsageEvent(event) {
   }
 }
 async function appendJsonl(filePath, value) {
-  await mkdir10(path41.dirname(filePath), { recursive: true });
+  await mkdir10(path42.dirname(filePath), { recursive: true });
   await appendFile3(filePath, `${JSON.stringify(value)}
 `, "utf-8");
 }
 async function writeJsonlAtomic(filePath, values) {
-  await mkdir10(path41.dirname(filePath), { recursive: true });
+  await mkdir10(path42.dirname(filePath), { recursive: true });
   const tmp = `${filePath}.tmp.${randomUUID5()}`;
   const content = values.map((value) => JSON.stringify(value)).join(`
 `) + (values.length > 0 ? `
@@ -21478,18 +21787,18 @@ async function writeJsonlAtomic(filePath, values) {
 
 // src/memory/provider-pool.ts
 import { realpathSync as realpathSync2 } from "fs";
-import * as path44 from "path";
+import * as path45 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 path43 from "path";
+import * as path44 from "path";
 
 // src/memory/jsonl-migration.ts
-import { existsSync as existsSync25, renameSync as renameSync10, unlinkSync as unlinkSync6 } from "fs";
+import { existsSync as existsSync26, renameSync as renameSync10, unlinkSync as unlinkSync7 } from "fs";
 import { copyFile as copyFile2, mkdir as mkdir11, readFile as readFile13, stat as stat5, writeFile as writeFile11 } from "fs/promises";
-import * as path42 from "path";
+import * as path43 from "path";
 var LEGACY_JSONL_MIGRATION_VERSION = 2;
 var LEGACY_JSONL_MIGRATION_NAME = "legacy_jsonl_import_complete";
 function resolveMemoryStorageDir(rootDirectory, config = {}) {
@@ -21505,8 +21814,8 @@ function resolveSqliteDatabasePath(rootDirectory, config = {}) {
 async function readLegacyJsonl(rootDirectory, config = {}) {
   const resolved = resolveConfig(config);
   const storageDir = resolveMemoryStorageDir(rootDirectory, resolved);
-  const memoryLoad = await readMemoryJsonl(path42.join(storageDir, "memories.jsonl"), resolved);
-  const proposalLoad = await readProposalJsonl(path42.join(storageDir, "proposals.jsonl"), resolved);
+  const memoryLoad = await readMemoryJsonl(path43.join(storageDir, "memories.jsonl"), resolved);
+  const proposalLoad = await readProposalJsonl(path43.join(storageDir, "proposals.jsonl"), resolved);
   return {
     memories: memoryLoad.records,
     proposals: proposalLoad.records,
@@ -21516,15 +21825,15 @@ async function readLegacyJsonl(rootDirectory, config = {}) {
 }
 async function backupLegacyJsonl(rootDirectory, config = {}) {
   const storageDir = resolveMemoryStorageDir(rootDirectory, config);
-  const backupDir = path42.join(storageDir, "backups");
+  const backupDir = path43.join(storageDir, "backups");
   await mkdir11(backupDir, { recursive: true });
   const results = [];
   for (const filename of ["memories.jsonl", "proposals.jsonl"]) {
-    const source = path42.join(storageDir, filename);
-    if (!existsSync25(source))
+    const source = path43.join(storageDir, filename);
+    if (!existsSync26(source))
       continue;
-    const backup = path42.join(backupDir, `${filename}.pre-sqlite-migration`);
-    if (existsSync25(backup)) {
+    const backup = path43.join(backupDir, `${filename}.pre-sqlite-migration`);
+    if (existsSync26(backup)) {
       results.push({ source, backup, created: false });
       continue;
     }
@@ -21534,51 +21843,51 @@ async function backupLegacyJsonl(rootDirectory, config = {}) {
   return results;
 }
 async function writeJsonlExport(rootDirectory, config, memories, proposals) {
-  const exportDir = path42.join(resolveMemoryStorageDir(rootDirectory, config), "export");
+  const exportDir = path43.join(resolveMemoryStorageDir(rootDirectory, config), "export");
   await mkdir11(exportDir, { recursive: true });
-  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)}`);
+  const memoriesPath = path43.join(exportDir, "memories.jsonl");
+  const proposalsPath = path43.join(exportDir, "proposals.jsonl");
+  const memoriesTempPath = path43.join(path43.dirname(memoriesPath), `${path43.basename(memoriesPath)}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
   try {
     await writeFile11(memoriesTempPath, toJsonl(memories), "utf-8");
     renameSync10(memoriesTempPath, memoriesPath);
   } catch (err) {
     try {
-      unlinkSync6(memoriesTempPath);
+      unlinkSync7(memoriesTempPath);
     } catch {}
     throw err;
   }
-  const proposalsTempPath = path42.join(path42.dirname(proposalsPath), `${path42.basename(proposalsPath)}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+  const proposalsTempPath = path43.join(path43.dirname(proposalsPath), `${path43.basename(proposalsPath)}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
   try {
     await writeFile11(proposalsTempPath, toJsonl(proposals), "utf-8");
     renameSync10(proposalsTempPath, proposalsPath);
   } catch (err) {
     try {
-      unlinkSync6(proposalsTempPath);
+      unlinkSync7(proposalsTempPath);
     } catch {}
     throw err;
   }
   return { directory: exportDir, memoriesPath, proposalsPath };
 }
 async function writeMigrationReport(rootDirectory, report, config = {}) {
-  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)}`);
+  const reportPath = path43.join(resolveMemoryStorageDir(rootDirectory, config), "migration-report.json");
+  await mkdir11(path43.dirname(reportPath), { recursive: true });
+  const reportTempPath = path43.join(path43.dirname(reportPath), `${path43.basename(reportPath)}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
   try {
     await writeFile11(reportTempPath, `${JSON.stringify(report, null, 2)}
 `, "utf-8");
     renameSync10(reportTempPath, reportPath);
   } catch (err) {
     try {
-      unlinkSync6(reportTempPath);
+      unlinkSync7(reportTempPath);
     } catch {}
     throw err;
   }
   return reportPath;
 }
 async function readMigrationReport(rootDirectory, config = {}) {
-  const reportPath = path42.join(resolveMemoryStorageDir(rootDirectory, config), "migration-report.json");
-  if (!existsSync25(reportPath))
+  const reportPath = path43.join(resolveMemoryStorageDir(rootDirectory, config), "migration-report.json");
+  if (!existsSync26(reportPath))
     return null;
   try {
     return JSON.parse(await readFile13(reportPath, "utf-8"));
@@ -21590,15 +21899,15 @@ async function getLegacyJsonlFileStatus(rootDirectory, config = {}) {
   const storageDir = resolveMemoryStorageDir(rootDirectory, config);
   const statuses = [];
   for (const file of ["memories.jsonl", "proposals.jsonl"]) {
-    const filePath = path42.join(storageDir, file);
+    const filePath = path43.join(storageDir, file);
     let sizeBytes = 0;
-    if (existsSync25(filePath)) {
+    if (existsSync26(filePath)) {
       sizeBytes = (await stat5(filePath)).size;
     }
     statuses.push({
       file,
       path: filePath,
-      exists: existsSync25(filePath),
+      exists: existsSync26(filePath),
       sizeBytes
     });
   }
@@ -21679,7 +21988,7 @@ async function readProposalJsonl(filePath, config) {
   return { records, invalidRows, totalRows: rows.totalRows };
 }
 async function readJsonlRows(filePath) {
-  if (!existsSync25(filePath)) {
+  if (!existsSync26(filePath)) {
     return { rows: [], invalidRows: [], totalRows: 0 };
   }
   const content = await readFile13(filePath, "utf-8");
@@ -21898,7 +22207,7 @@ class SQLiteMemoryProvider {
   }
   async doInitialize() {
     const dbPath = this.databasePath();
-    mkdirSync15(path43.dirname(dbPath), { recursive: true });
+    mkdirSync15(path44.dirname(dbPath), { recursive: true });
     const Db = loadDatabaseCtor2();
     this.db = new Db(dbPath);
     this.db.run("PRAGMA journal_mode = WAL;");
@@ -22927,7 +23236,7 @@ function resolvePoolKey(directory) {
   try {
     return realpathSync2(directory);
   } catch {
-    return path44.resolve(directory);
+    return path45.resolve(directory);
   }
 }
 
@@ -22999,7 +23308,7 @@ var DEFAULT_MODES = [
 ];
 var DEFAULT_TIMESTAMP = "2026-05-26T12:00:00.000Z";
 async function evaluateMemoryRecallFixtures(options) {
-  const fixtureDirectory = path45.resolve(options.fixtureDirectory);
+  const fixtureDirectory = path46.resolve(options.fixtureDirectory);
   const providers = options.providers ?? DEFAULT_PROVIDERS;
   const modes = options.modes ?? DEFAULT_MODES;
   const generatedAt = new Date().toISOString();
@@ -23008,7 +23317,7 @@ async function evaluateMemoryRecallFixtures(options) {
   for (const fixture of fixtures) {
     const materialized = materializeFixture(fixture);
     for (const providerName of providers) {
-      const tempRoot = await fs18.realpath(await fs18.mkdtemp(path45.join(os9.tmpdir(), "swarm-memory-eval-")));
+      const tempRoot = await fs19.realpath(await fs19.mkdtemp(path46.join(os10.tmpdir(), "swarm-memory-eval-")));
       const provider = createEvaluationProvider(providerName, tempRoot);
       try {
         await provider.initialize?.();
@@ -23032,7 +23341,7 @@ async function evaluateMemoryRecallFixtures(options) {
       } finally {
         await provider.close?.();
         if (!options.keepTempRoots) {
-          await fs18.rm(tempRoot, { recursive: true, force: true });
+          await fs19.rm(tempRoot, { recursive: true, force: true });
         }
       }
     }
@@ -23048,11 +23357,11 @@ async function evaluateMemoryRecallFixtures(options) {
   };
 }
 async function loadRecallEvaluationFixtures(fixtureDirectory) {
-  const entries = await fs18.readdir(fixtureDirectory, { withFileTypes: true });
+  const entries = await fs19.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 fs18.readFile(path45.join(fixtureDirectory, file), "utf-8");
+    const raw = await fs19.readFile(path46.join(fixtureDirectory, file), "utf-8");
     fixtures.push(validateFixture(JSON.parse(raw), file));
   }
   return fixtures;
@@ -23329,8 +23638,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 path46 from "path";
-var LOG_RELATIVE_PATH = path46.join("memory", "consolidation-log.jsonl");
+import * as path47 from "path";
+var LOG_RELATIVE_PATH = path47.join("memory", "consolidation-log.jsonl");
 async function readConsolidationLog(directory) {
   const filePath = validateSwarmPath(directory, LOG_RELATIVE_PATH);
   let raw;
@@ -23353,7 +23662,7 @@ async function readConsolidationLog(directory) {
 }
 
 // src/commands/memory.ts
-var PACKAGE_ROOT = path47.resolve(resolvePackageRootFromModule(fileURLToPath2(import.meta.url)));
+var PACKAGE_ROOT = path48.resolve(resolvePackageRootFromModule(fileURLToPath2(import.meta.url)));
 async function handleMemoryCommand(_directory, _args) {
   return [
     "## Swarm Memory",
@@ -23411,7 +23720,7 @@ async function handleMemoryStatusCommand(directory, _args) {
     `- Provider: \`${config.provider}\``,
     `- Storage: \`${storageDir}\``,
     `- SQLite path: \`${sqlitePath}\``,
-    `- SQLite database exists: \`${existsSync26(sqlitePath)}\``,
+    `- SQLite database exists: \`${existsSync27(sqlitePath)}\``,
     `- Automatic destructive cleanup: \`disabled\``,
     "",
     "### Legacy JSONL"
@@ -23651,7 +23960,7 @@ function resolveCommandMemoryConfig(directory) {
 }
 function parseEvaluateArgs(directory, args) {
   let json = false;
-  let fixtureDirectory = path47.join(PACKAGE_ROOT, "tests", "fixtures", "memory-recall");
+  let fixtureDirectory = path48.join(PACKAGE_ROOT, "tests", "fixtures", "memory-recall");
   for (let i = 0;i < args.length; i++) {
     const arg = args[i];
     if (arg === "--json") {
@@ -23665,10 +23974,10 @@ function parseEvaluateArgs(directory, args) {
           error: "Usage: /swarm memory evaluate [--json] [--fixtures <directory>]"
         };
       }
-      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;
+      const resolvedFixtures = path48.resolve(directory, next);
+      const canonical = path48.normalize(resolvedFixtures) + path48.sep;
+      const allowedRootA = path48.normalize(directory) + path48.sep;
+      const allowedRootB = path48.normalize(path48.join(PACKAGE_ROOT, "tests", "fixtures", "memory-recall")) + path48.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"
@@ -23707,15 +24016,15 @@ function parseMaintenanceArgs(args, options) {
   return { limit, confirm };
 }
 function resolvePackageRootFromModule(modulePath) {
-  const moduleDir = path47.dirname(modulePath);
-  const leaf = path47.basename(moduleDir);
+  const moduleDir = path48.dirname(modulePath);
+  const leaf = path48.basename(moduleDir);
   if (leaf === "commands" || leaf === "cli") {
-    return path47.resolve(moduleDir, "..", "..");
+    return path48.resolve(moduleDir, "..", "..");
   }
   if (leaf === "dist") {
-    return path47.resolve(moduleDir, "..");
+    return path48.resolve(moduleDir, "..");
   }
-  return path47.resolve(moduleDir, "..");
+  return path48.resolve(moduleDir, "..");
 }
 function formatMigrationResult(label, report) {
   if (!report) {
@@ -24409,12 +24718,12 @@ var _internals36 = {
 };
 
 // src/services/preflight-service.ts
-import * as fs25 from "fs";
-import * as path54 from "path";
+import * as fs26 from "fs";
+import * as path55 from "path";
 
 // src/tools/lint.ts
-import * as fs19 from "fs";
-import * as path48 from "path";
+import * as fs20 from "fs";
+import * as path49 from "path";
 
 // src/utils/path-security.ts
 function containsPathTraversal(str) {
@@ -24470,9 +24779,9 @@ function validateArgs(args) {
 }
 function getLinterCommand(linter, mode, projectDir) {
   const isWindows = process.platform === "win32";
-  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");
+  const binDir = path49.join(projectDir, "node_modules", ".bin");
+  const biomeBin = isWindows ? path49.join(binDir, "biome.EXE") : path49.join(binDir, "biome");
+  const eslintBin = isWindows ? path49.join(binDir, "eslint.cmd") : path49.join(binDir, "eslint");
   switch (linter) {
     case "biome":
       if (mode === "fix") {
@@ -24488,7 +24797,7 @@ function getLinterCommand(linter, mode, projectDir) {
 }
 function getAdditionalLinterCommand(linter, mode, cwd) {
   const gradlewName = process.platform === "win32" ? "gradlew.bat" : "gradlew";
-  const gradlew = fs19.existsSync(path48.join(cwd, gradlewName)) ? path48.join(cwd, gradlewName) : null;
+  const gradlew = fs20.existsSync(path49.join(cwd, gradlewName)) ? path49.join(cwd, gradlewName) : null;
   switch (linter) {
     case "ruff":
       return mode === "fix" ? ["ruff", "check", "--fix", "."] : ["ruff", "check", "."];
@@ -24522,12 +24831,12 @@ function getAdditionalLinterCommand(linter, mode, cwd) {
   }
 }
 function detectRuff(cwd) {
-  if (fs19.existsSync(path48.join(cwd, "ruff.toml")))
+  if (fs20.existsSync(path49.join(cwd, "ruff.toml")))
     return isCommandAvailable("ruff");
   try {
-    const pyproject = path48.join(cwd, "pyproject.toml");
-    if (fs19.existsSync(pyproject)) {
-      const content = fs19.readFileSync(pyproject, "utf-8");
+    const pyproject = path49.join(cwd, "pyproject.toml");
+    if (fs20.existsSync(pyproject)) {
+      const content = fs20.readFileSync(pyproject, "utf-8");
       if (content.includes("[tool.ruff]"))
         return isCommandAvailable("ruff");
     }
@@ -24535,21 +24844,21 @@ function detectRuff(cwd) {
   return false;
 }
 function detectClippy(cwd) {
-  return fs19.existsSync(path48.join(cwd, "Cargo.toml")) && isCommandAvailable("cargo");
+  return fs20.existsSync(path49.join(cwd, "Cargo.toml")) && isCommandAvailable("cargo");
 }
 function detectGolangciLint(cwd) {
-  return fs19.existsSync(path48.join(cwd, "go.mod")) && isCommandAvailable("golangci-lint");
+  return fs20.existsSync(path49.join(cwd, "go.mod")) && isCommandAvailable("golangci-lint");
 }
 function detectCheckstyle(cwd) {
-  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"));
+  const hasMaven = fs20.existsSync(path49.join(cwd, "pom.xml"));
+  const hasGradle = fs20.existsSync(path49.join(cwd, "build.gradle")) || fs20.existsSync(path49.join(cwd, "build.gradle.kts"));
+  const hasBinary = hasMaven && isCommandAvailable("mvn") || hasGradle && (fs20.existsSync(path49.join(cwd, "gradlew")) || isCommandAvailable("gradle"));
   return (hasMaven || hasGradle) && hasBinary;
 }
 function detectKtlint(cwd) {
-  const hasKotlin = fs19.existsSync(path48.join(cwd, "build.gradle.kts")) || fs19.existsSync(path48.join(cwd, "build.gradle")) || (() => {
+  const hasKotlin = fs20.existsSync(path49.join(cwd, "build.gradle.kts")) || fs20.existsSync(path49.join(cwd, "build.gradle")) || (() => {
     try {
-      return fs19.readdirSync(cwd).some((f) => f.endsWith(".kt") || f.endsWith(".kts"));
+      return fs20.readdirSync(cwd).some((f) => f.endsWith(".kt") || f.endsWith(".kts"));
     } catch {
       return false;
     }
@@ -24558,7 +24867,7 @@ function detectKtlint(cwd) {
 }
 function detectDotnetFormat(cwd) {
   try {
-    const files = fs19.readdirSync(cwd);
+    const files = fs20.readdirSync(cwd);
     const hasCsproj = files.some((f) => f.endsWith(".csproj") || f.endsWith(".sln"));
     return hasCsproj && isCommandAvailable("dotnet");
   } catch {
@@ -24566,14 +24875,14 @@ function detectDotnetFormat(cwd) {
   }
 }
 function detectCppcheck(cwd) {
-  if (fs19.existsSync(path48.join(cwd, "CMakeLists.txt"))) {
+  if (fs20.existsSync(path49.join(cwd, "CMakeLists.txt"))) {
     return isCommandAvailable("cppcheck");
   }
   try {
-    const dirsToCheck = [cwd, path48.join(cwd, "src")];
+    const dirsToCheck = [cwd, path49.join(cwd, "src")];
     const hasCpp = dirsToCheck.some((dir) => {
       try {
-        return fs19.readdirSync(dir).some((f) => /\.(c|cpp|cc|cxx|h|hpp)$/.test(f));
+        return fs20.readdirSync(dir).some((f) => /\.(c|cpp|cc|cxx|h|hpp)$/.test(f));
       } catch {
         return false;
       }
@@ -24584,13 +24893,13 @@ function detectCppcheck(cwd) {
   }
 }
 function detectSwiftlint(cwd) {
-  return fs19.existsSync(path48.join(cwd, "Package.swift")) && isCommandAvailable("swiftlint");
+  return fs20.existsSync(path49.join(cwd, "Package.swift")) && isCommandAvailable("swiftlint");
 }
 function detectDartAnalyze(cwd) {
-  return fs19.existsSync(path48.join(cwd, "pubspec.yaml")) && (isCommandAvailable("dart") || isCommandAvailable("flutter"));
+  return fs20.existsSync(path49.join(cwd, "pubspec.yaml")) && (isCommandAvailable("dart") || isCommandAvailable("flutter"));
 }
 function detectRubocop(cwd) {
-  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"));
+  return (fs20.existsSync(path49.join(cwd, "Gemfile")) || fs20.existsSync(path49.join(cwd, "gems.rb")) || fs20.existsSync(path49.join(cwd, ".rubocop.yml"))) && (isCommandAvailable("rubocop") || isCommandAvailable("bundle"));
 }
 function detectAdditionalLinter(cwd) {
   if (detectRuff(cwd))
@@ -24618,10 +24927,10 @@ function detectAdditionalLinter(cwd) {
 function findBinInAncestors(startDir, binName) {
   let dir = startDir;
   while (true) {
-    const candidate = path48.join(dir, "node_modules", ".bin", binName);
-    if (fs19.existsSync(candidate))
+    const candidate = path49.join(dir, "node_modules", ".bin", binName);
+    if (fs20.existsSync(candidate))
       return candidate;
-    const parent = path48.dirname(dir);
+    const parent = path49.dirname(dir);
     if (parent === dir)
       break;
     dir = parent;
@@ -24630,11 +24939,11 @@ function findBinInAncestors(startDir, binName) {
 }
 function findBinInEnvPath(binName) {
   const searchPath = process.env.PATH ?? "";
-  for (const dir of searchPath.split(path48.delimiter)) {
+  for (const dir of searchPath.split(path49.delimiter)) {
     if (!dir)
       continue;
-    const candidate = path48.join(dir, binName);
-    if (fs19.existsSync(candidate))
+    const candidate = path49.join(dir, binName);
+    if (fs20.existsSync(candidate))
       return candidate;
   }
   return null;
@@ -24642,17 +24951,17 @@ function findBinInEnvPath(binName) {
 async function detectAvailableLinter(directory) {
   if (!directory)
     return null;
-  if (!fs19.existsSync(directory))
+  if (!fs20.existsSync(directory))
     return null;
   const projectDir = directory;
   const isWindows = process.platform === "win32";
-  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 biomeBin = isWindows ? path49.join(projectDir, "node_modules", ".bin", "biome.EXE") : path49.join(projectDir, "node_modules", ".bin", "biome");
+  const eslintBin = isWindows ? path49.join(projectDir, "node_modules", ".bin", "eslint.cmd") : path49.join(projectDir, "node_modules", ".bin", "eslint");
   const localResult = await _detectAvailableLinter(projectDir, biomeBin, eslintBin);
   if (localResult)
     return localResult;
-  const biomeAncestor = findBinInAncestors(path48.dirname(projectDir), isWindows ? "biome.EXE" : "biome");
-  const eslintAncestor = findBinInAncestors(path48.dirname(projectDir), isWindows ? "eslint.cmd" : "eslint");
+  const biomeAncestor = findBinInAncestors(path49.dirname(projectDir), isWindows ? "biome.EXE" : "biome");
+  const eslintAncestor = findBinInAncestors(path49.dirname(projectDir), isWindows ? "eslint.cmd" : "eslint");
   if (biomeAncestor || eslintAncestor) {
     return _detectAvailableLinter(projectDir, biomeAncestor ?? biomeBin, eslintAncestor ?? eslintBin);
   }
@@ -24675,7 +24984,7 @@ async function _detectAvailableLinter(_projectDir, biomeBin, eslintBin) {
     const result = await Promise.race([biomeExit, timeout]);
     if (result === "timeout") {
       biomeProc.kill();
-    } else if (biomeProc.exitCode === 0 && fs19.existsSync(biomeBin)) {
+    } else if (biomeProc.exitCode === 0 && fs20.existsSync(biomeBin)) {
       return "biome";
     }
   } catch {}
@@ -24689,7 +24998,7 @@ async function _detectAvailableLinter(_projectDir, biomeBin, eslintBin) {
     const result = await Promise.race([eslintExit, timeout]);
     if (result === "timeout") {
       eslintProc.kill();
-    } else if (eslintProc.exitCode === 0 && fs19.existsSync(eslintBin)) {
+    } else if (eslintProc.exitCode === 0 && fs20.existsSync(eslintBin)) {
       return "eslint";
     }
   } catch {}
@@ -24865,8 +25174,8 @@ var _internals37 = {
 };
 
 // src/tools/secretscan.ts
-import * as fs20 from "fs";
-import * as path49 from "path";
+import * as fs21 from "fs";
+import * as path50 from "path";
 var MAX_FILE_PATH_LENGTH = 500;
 var MAX_FILE_SIZE_BYTES = 512 * 1024;
 var MAX_FILES_SCANNED = 1000;
@@ -25093,11 +25402,11 @@ function isGlobOrPathPattern(pattern) {
   return pattern.includes("/") || pattern.includes("\\") || /[*?[\]{}]/.test(pattern);
 }
 function loadSecretScanIgnore(scanDir) {
-  const ignorePath = path49.join(scanDir, ".secretscanignore");
+  const ignorePath = path50.join(scanDir, ".secretscanignore");
   try {
-    if (!fs20.existsSync(ignorePath))
+    if (!fs21.existsSync(ignorePath))
       return [];
-    const content = fs20.readFileSync(ignorePath, "utf8");
+    const content = fs21.readFileSync(ignorePath, "utf8");
     const patterns = [];
     for (const rawLine of content.split(/\r?\n/)) {
       const line = rawLine.trim();
@@ -25116,7 +25425,7 @@ function isExcluded(entry, relPath, exactNames, globPatterns) {
   if (exactNames.has(entry))
     return true;
   for (const pattern of globPatterns) {
-    if (path49.matchesGlob(relPath, pattern))
+    if (path50.matchesGlob(relPath, pattern))
       return true;
   }
   return false;
@@ -25137,7 +25446,7 @@ function validateDirectoryInput(dir) {
   return null;
 }
 function isBinaryFile(filePath, buffer) {
-  const ext = path49.extname(filePath).toLowerCase();
+  const ext = path50.extname(filePath).toLowerCase();
   if (DEFAULT_EXCLUDE_EXTENSIONS.has(ext)) {
     return true;
   }
@@ -25212,11 +25521,11 @@ function createRedactedContext(line, findings) {
   result += line.slice(lastEnd);
   return result;
 }
-var O_NOFOLLOW = process.platform !== "win32" ? fs20.constants.O_NOFOLLOW : undefined;
+var O_NOFOLLOW = process.platform !== "win32" ? fs21.constants.O_NOFOLLOW : undefined;
 function scanFileForSecrets(filePath) {
   const findings = [];
   try {
-    const lstat2 = fs20.lstatSync(filePath);
+    const lstat2 = fs21.lstatSync(filePath);
     if (lstat2.isSymbolicLink()) {
       return findings;
     }
@@ -25225,14 +25534,14 @@ function scanFileForSecrets(filePath) {
     }
     let buffer;
     if (O_NOFOLLOW !== undefined) {
-      const fd = fs20.openSync(filePath, "r", O_NOFOLLOW);
+      const fd = fs21.openSync(filePath, "r", O_NOFOLLOW);
       try {
-        buffer = fs20.readFileSync(fd);
+        buffer = fs21.readFileSync(fd);
       } finally {
-        fs20.closeSync(fd);
+        fs21.closeSync(fd);
       }
     } else {
-      buffer = fs20.readFileSync(filePath);
+      buffer = fs21.readFileSync(filePath);
     }
     if (isBinaryFile(filePath, buffer)) {
       return findings;
@@ -25274,9 +25583,9 @@ function isSymlinkLoop(realPath, visited) {
   return false;
 }
 function isPathWithinScope(realPath, scanDir) {
-  const resolvedScanDir = path49.resolve(scanDir);
-  const resolvedRealPath = path49.resolve(realPath);
-  return resolvedRealPath === resolvedScanDir || resolvedRealPath.startsWith(resolvedScanDir + path49.sep) || resolvedRealPath.startsWith(`${resolvedScanDir}/`) || resolvedRealPath.startsWith(`${resolvedScanDir}\\`);
+  const resolvedScanDir = path50.resolve(scanDir);
+  const resolvedRealPath = path50.resolve(realPath);
+  return resolvedRealPath === resolvedScanDir || resolvedRealPath.startsWith(resolvedScanDir + path50.sep) || resolvedRealPath.startsWith(`${resolvedScanDir}/`) || resolvedRealPath.startsWith(`${resolvedScanDir}\\`);
 }
 function findScannableFiles(dir, excludeExact, excludeGlobs, scanDir, visited, stats = {
   skippedDirs: 0,
@@ -25287,7 +25596,7 @@ function findScannableFiles(dir, excludeExact, excludeGlobs, scanDir, visited, s
   const files = [];
   let entries;
   try {
-    entries = fs20.readdirSync(dir);
+    entries = fs21.readdirSync(dir);
   } catch {
     stats.fileErrors++;
     return files;
@@ -25302,15 +25611,15 @@ function findScannableFiles(dir, excludeExact, excludeGlobs, scanDir, visited, s
     return a.localeCompare(b);
   });
   for (const entry of entries) {
-    const fullPath = path49.join(dir, entry);
-    const relPath = path49.relative(scanDir, fullPath).replace(/\\/g, "/");
+    const fullPath = path50.join(dir, entry);
+    const relPath = path50.relative(scanDir, fullPath).replace(/\\/g, "/");
     if (isExcluded(entry, relPath, excludeExact, excludeGlobs)) {
       stats.skippedDirs++;
       continue;
     }
     let lstat2;
     try {
-      lstat2 = fs20.lstatSync(fullPath);
+      lstat2 = fs21.lstatSync(fullPath);
     } catch {
       stats.fileErrors++;
       continue;
@@ -25322,7 +25631,7 @@ function findScannableFiles(dir, excludeExact, excludeGlobs, scanDir, visited, s
     if (lstat2.isDirectory()) {
       let realPath;
       try {
-        realPath = fs20.realpathSync(fullPath);
+        realPath = fs21.realpathSync(fullPath);
       } catch {
         stats.fileErrors++;
         continue;
@@ -25338,7 +25647,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 = path49.extname(fullPath).toLowerCase();
+      const ext = path50.extname(fullPath).toLowerCase();
       if (!DEFAULT_EXCLUDE_EXTENSIONS.has(ext)) {
         files.push(fullPath);
       } else {
@@ -25404,15 +25713,15 @@ var secretscan = createSwarmTool({
       }
     }
     try {
-      const _scanDirRaw = path49.resolve(directory);
+      const _scanDirRaw = path50.resolve(directory);
       const scanDir = (() => {
         try {
-          return fs20.realpathSync(_scanDirRaw);
+          return fs21.realpathSync(_scanDirRaw);
         } catch {
           return _scanDirRaw;
         }
       })();
-      if (!fs20.existsSync(scanDir)) {
+      if (!fs21.existsSync(scanDir)) {
         const errorResult = {
           error: "directory not found",
           scan_dir: directory,
@@ -25423,7 +25732,7 @@ var secretscan = createSwarmTool({
         };
         return JSON.stringify(errorResult, null, 2);
       }
-      const dirStat = fs20.statSync(scanDir);
+      const dirStat = fs21.statSync(scanDir);
       if (!dirStat.isDirectory()) {
         const errorResult = {
           error: "target must be a directory, not a file",
@@ -25474,7 +25783,7 @@ var secretscan = createSwarmTool({
           break;
         const fileFindings = scanFileForSecrets(filePath);
         try {
-          const stat6 = fs20.statSync(filePath);
+          const stat6 = fs21.statSync(filePath);
           if (stat6.size > MAX_FILE_SIZE_BYTES) {
             skippedFiles++;
             continue;
@@ -25566,12 +25875,12 @@ var _internals38 = {
 };
 
 // src/tools/test-runner.ts
-import * as fs24 from "fs";
-import * as path53 from "path";
+import * as fs25 from "fs";
+import * as path54 from "path";
 
 // src/test-impact/analyzer.ts
-import fs21 from "fs";
-import path50 from "path";
+import fs22 from "fs";
+import path51 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;
@@ -25598,7 +25907,7 @@ function sharedTrailingSegments(a, b) {
 function isCacheStale(impactMap, generatedAtMs) {
   for (const sourcePath of Object.keys(impactMap)) {
     try {
-      const stat6 = fs21.statSync(sourcePath);
+      const stat6 = fs22.statSync(sourcePath);
       if (stat6.mtimeMs > generatedAtMs) {
         return true;
       }
@@ -25612,15 +25921,15 @@ function resolveRelativeImport(fromDir, importPath) {
   if (!importPath.startsWith(".")) {
     return null;
   }
-  const resolved = path50.resolve(fromDir, importPath);
-  if (path50.extname(resolved)) {
-    if (fs21.existsSync(resolved) && fs21.statSync(resolved).isFile()) {
+  const resolved = path51.resolve(fromDir, importPath);
+  if (path51.extname(resolved)) {
+    if (fs22.existsSync(resolved) && fs22.statSync(resolved).isFile()) {
       return normalizePath2(resolved);
     }
   } else {
     for (const ext of EXTENSIONS_TO_TRY) {
       const withExt = resolved + ext;
-      if (fs21.existsSync(withExt) && fs21.statSync(withExt).isFile()) {
+      if (fs22.existsSync(withExt) && fs22.statSync(withExt).isFile()) {
         return normalizePath2(withExt);
       }
     }
@@ -25633,30 +25942,30 @@ function resolvePythonImport(fromDir, module) {
   const leadingDots = module.match(/^\.+/)?.[0].length ?? 0;
   let baseDir = fromDir;
   for (let i = 1;i < leadingDots; i++) {
-    baseDir = path50.dirname(baseDir);
+    baseDir = path51.dirname(baseDir);
   }
   const rest = module.slice(leadingDots);
   if (rest.length === 0) {
-    const initPath = path50.join(baseDir, "__init__.py");
-    if (fs21.existsSync(initPath) && fs21.statSync(initPath).isFile()) {
+    const initPath = path51.join(baseDir, "__init__.py");
+    if (fs22.existsSync(initPath) && fs22.statSync(initPath).isFile()) {
       return normalizePath2(initPath);
     }
     return null;
   }
-  const subpath = rest.replace(/\./g, path50.sep);
+  const subpath = rest.replace(/\./g, path51.sep);
   const candidates = [
-    `${path50.join(baseDir, subpath)}.py`,
-    path50.join(baseDir, subpath, "__init__.py")
+    `${path51.join(baseDir, subpath)}.py`,
+    path51.join(baseDir, subpath, "__init__.py")
   ];
   for (const c of candidates) {
-    if (fs21.existsSync(c) && fs21.statSync(c).isFile())
+    if (fs22.existsSync(c) && fs22.statSync(c).isFile())
       return normalizePath2(c);
   }
   return null;
 }
 var goModuleCache = new Map;
 function findGoModule(fromDir) {
-  const resolved = path50.resolve(fromDir);
+  const resolved = path51.resolve(fromDir);
   let cur = resolved;
   const walked = [];
   for (let i = 0;i < 16; i++) {
@@ -25668,8 +25977,8 @@ function findGoModule(fromDir) {
     }
     walked.push(cur);
     try {
-      const goMod = path50.join(cur, "go.mod");
-      const content = fs21.readFileSync(goMod, "utf-8");
+      const goMod = path51.join(cur, "go.mod");
+      const content = fs22.readFileSync(goMod, "utf-8");
       const moduleMatch = content.match(/^\s*module\s+"?([^"\s/]+(?:\/[^"\s]+)*)"?/m);
       if (moduleMatch) {
         const result = { moduleRoot: cur, modulePath: moduleMatch[1] };
@@ -25679,10 +25988,10 @@ function findGoModule(fromDir) {
       }
     } catch {}
     try {
-      fs21.accessSync(path50.join(cur, ".git"));
+      fs22.accessSync(path51.join(cur, ".git"));
       break;
     } catch {}
-    const parent = path50.dirname(cur);
+    const parent = path51.dirname(cur);
     if (parent === cur)
       break;
     cur = parent;
@@ -25694,20 +26003,20 @@ function findGoModule(fromDir) {
 function resolveGoImport(fromDir, importPath) {
   let dir = null;
   if (importPath.startsWith(".")) {
-    dir = path50.resolve(fromDir, importPath);
+    dir = path51.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 = path50.join(mod.moduleRoot, subpath);
+      dir = path51.join(mod.moduleRoot, subpath);
     }
   }
   if (dir === null)
     return [];
-  if (!fs21.existsSync(dir) || !fs21.statSync(dir).isDirectory())
+  if (!fs22.existsSync(dir) || !fs22.statSync(dir).isDirectory())
     return [];
   try {
-    return fs21.readdirSync(dir).filter((f) => f.endsWith(".go") && !f.endsWith("_test.go")).map((f) => normalizePath2(path50.join(dir, f)));
+    return fs22.readdirSync(dir).filter((f) => f.endsWith(".go") && !f.endsWith("_test.go")).map((f) => normalizePath2(path51.join(dir, f)));
   } catch {
     return [];
   }
@@ -25727,13 +26036,13 @@ function findTestFilesSync(cwd) {
   function walk(dir, visitedInodes) {
     let entries;
     try {
-      entries = fs21.readdirSync(dir, { withFileTypes: true });
+      entries = fs22.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
     let dirInode;
     try {
-      dirInode = fs21.statSync(dir).ino;
+      dirInode = fs22.statSync(dir).ino;
     } catch {
       return;
     }
@@ -25746,15 +26055,15 @@ function findTestFilesSync(cwd) {
     for (const entry of entries) {
       if (entry.isDirectory()) {
         if (!skipDirs.has(entry.name)) {
-          walk(path50.join(dir, entry.name), visitedInodes);
+          walk(path51.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(`${path50.sep}tests${path50.sep}`) && name.endsWith(".py");
+        const isPyTest = /^test_.+\.py$/.test(name) || /.+_test\.py$/.test(name) || dir.includes(`${path51.sep}tests${path51.sep}`) && name.endsWith(".py");
         const isGoTest = /.+_test\.go$/.test(name);
         if (isTsTest || isPyTest || isGoTest) {
-          testFiles.push(normalizePath2(path50.join(dir, entry.name)));
+          testFiles.push(normalizePath2(path51.join(dir, entry.name)));
         }
       }
     }
@@ -25779,8 +26088,8 @@ function extractImports(content) {
   ];
 }
 function addImpactEdgesForTestFile(testFile, content, impactMap) {
-  const ext = path50.extname(testFile).toLowerCase();
-  const testDir = path50.dirname(testFile);
+  const ext = path51.extname(testFile).toLowerCase();
+  const testDir = path51.dirname(testFile);
   function addEdge(source) {
     if (!impactMap[source])
       impactMap[source] = [];
@@ -25822,7 +26131,7 @@ async function buildImpactMapInternal(cwd) {
   for (const testFile of testFiles) {
     let content;
     try {
-      content = fs21.readFileSync(testFile, "utf-8");
+      content = fs22.readFileSync(testFile, "utf-8");
     } catch {
       continue;
     }
@@ -25853,10 +26162,10 @@ async function buildImpactMap(cwd) {
   return impactMap;
 }
 async function loadImpactMap(cwd, options) {
-  const cachePath = path50.join(cwd, ".swarm", "cache", "impact-map.json");
-  if (fs21.existsSync(cachePath)) {
+  const cachePath = path51.join(cwd, ".swarm", "cache", "impact-map.json");
+  if (fs22.existsSync(cachePath)) {
     try {
-      const content = fs21.readFileSync(cachePath, "utf-8");
+      const content = fs22.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;
@@ -25886,21 +26195,21 @@ async function loadImpactMap(cwd, options) {
   return _internals39.buildImpactMap(cwd);
 }
 async function saveImpactMap(cwd, impactMap) {
-  if (!path50.isAbsolute(cwd)) {
+  if (!path51.isAbsolute(cwd)) {
     throw new Error(`saveImpactMap requires an absolute project root path, got: "${cwd}"`);
   }
   _internals39.validateProjectRoot(cwd);
-  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 cacheDir2 = path51.join(cwd, ".swarm", "cache");
+  const cachePath = path51.join(cacheDir2, "impact-map.json");
+  if (!fs22.existsSync(cacheDir2)) {
+    fs22.mkdirSync(cacheDir2, { recursive: true });
   }
   const data = {
     generatedAt: new Date().toISOString(),
     fileCount: Object.keys(impactMap).length,
     map: impactMap
   };
-  fs21.writeFileSync(cachePath, JSON.stringify(data, null, 2), "utf-8");
+  fs22.writeFileSync(cachePath, JSON.stringify(data, null, 2), "utf-8");
 }
 async function analyzeImpact(changedFiles, cwd, budget) {
   if (!Array.isArray(changedFiles)) {
@@ -25923,7 +26232,7 @@ async function analyzeImpact(changedFiles, cwd, budget) {
       budgetExceeded = true;
       break;
     }
-    const normalizedChanged = normalizePath2(path50.resolve(changedFile));
+    const normalizedChanged = normalizePath2(path51.resolve(changedFile));
     const tests = impactMap[normalizedChanged];
     if (tests && tests.length > 0) {
       for (const test of tests) {
@@ -25937,13 +26246,13 @@ async function analyzeImpact(changedFiles, cwd, budget) {
       if (budgetExceeded)
         break;
     } else {
-      const changedDir = normalizePath2(path50.dirname(normalizedChanged));
-      const changedInputDir = normalizePath2(path50.dirname(changedFile));
+      const changedDir = normalizePath2(path51.dirname(normalizedChanged));
+      const changedInputDir = normalizePath2(path51.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(path50.dirname(sourceA));
-        const sourceDirB = normalizePath2(path50.dirname(sourceB));
+        const sourceDirA = normalizePath2(path51.dirname(sourceA));
+        const sourceDirB = normalizePath2(path51.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)
@@ -26269,8 +26578,8 @@ function detectFlakyTests(allHistory) {
 }
 
 // src/test-impact/history-store.ts
-import fs22 from "fs";
-import path51 from "path";
+import fs23 from "fs";
+import path52 from "path";
 var MAX_HISTORY_PER_TEST = 20;
 var MAX_ERROR_LENGTH = 500;
 var MAX_STACK_LENGTH = 200;
@@ -26282,10 +26591,10 @@ function getHistoryPath(workingDir) {
   if (!workingDir) {
     throw new Error("getHistoryPath requires a working directory \u2014 project root must be provided by the caller");
   }
-  if (!path51.isAbsolute(workingDir)) {
+  if (!path52.isAbsolute(workingDir)) {
     throw new Error(`getHistoryPath requires an absolute project root path, got: "${workingDir}"`);
   }
-  return path51.join(workingDir, ".swarm", "cache", "test-history.jsonl");
+  return path52.join(workingDir, ".swarm", "cache", "test-history.jsonl");
 }
 function sanitizeErrorMessage(errorMessage) {
   if (errorMessage === undefined) {
@@ -26377,10 +26686,10 @@ function batchAppendTestRuns(records, workingDir) {
     }
   }
   const historyPath = getHistoryPath(workingDir);
-  const historyDir = path51.dirname(historyPath);
+  const historyDir = path52.dirname(historyPath);
   _internals40.validateProjectRoot(workingDir);
-  if (!fs22.existsSync(historyDir)) {
-    fs22.mkdirSync(historyDir, { recursive: true });
+  if (!fs23.existsSync(historyDir)) {
+    fs23.mkdirSync(historyDir, { recursive: true });
   }
   withHistoryWriteLock(historyPath, () => {
     const existingRecords = readAllRecords(historyPath);
@@ -26414,13 +26723,13 @@ function batchAppendTestRuns(records, workingDir) {
 `)}
 `;
       const tempPath = `${historyPath}.tmp`;
-      fs22.writeFileSync(tempPath, content, "utf-8");
-      fs22.renameSync(tempPath, historyPath);
+      fs23.writeFileSync(tempPath, content, "utf-8");
+      fs23.renameSync(tempPath, historyPath);
     } catch (err) {
       try {
         const tempPath = `${historyPath}.tmp`;
-        if (fs22.existsSync(tempPath)) {
-          fs22.unlinkSync(tempPath);
+        if (fs23.existsSync(tempPath)) {
+          fs23.unlinkSync(tempPath);
         }
       } catch {}
       throw new Error(`Failed to write test history: ${err instanceof Error ? err.message : String(err)}`);
@@ -26432,7 +26741,7 @@ function withHistoryWriteLock(historyPath, fn) {
   const deadline = Date.now() + HISTORY_WRITE_LOCK_TIMEOUT_MS;
   while (true) {
     try {
-      fs22.mkdirSync(lockPath);
+      fs23.mkdirSync(lockPath);
       break;
     } catch (error2) {
       const code = error2 instanceof Error && "code" in error2 ? error2.code : undefined;
@@ -26443,9 +26752,9 @@ function withHistoryWriteLock(historyPath, fn) {
         throw new Error(`Timed out waiting for test history lock: ${historyPath}`);
       }
       try {
-        const lockStat = fs22.statSync(lockPath);
+        const lockStat = fs23.statSync(lockPath);
         if (Date.now() - lockStat.mtimeMs >= HISTORY_WRITE_LOCK_STALE_MS) {
-          fs22.rmSync(lockPath, { recursive: true, force: true });
+          fs23.rmSync(lockPath, { recursive: true, force: true });
           continue;
         }
       } catch {}
@@ -26460,7 +26769,7 @@ function withHistoryWriteLock(historyPath, fn) {
     return fn();
   } finally {
     try {
-      fs22.rmSync(lockPath, { recursive: true, force: true });
+      fs23.rmSync(lockPath, { recursive: true, force: true });
     } catch {}
   }
   function sleepSync(ms) {
@@ -26469,11 +26778,11 @@ function withHistoryWriteLock(historyPath, fn) {
   }
 }
 function readAllRecords(historyPath) {
-  if (!fs22.existsSync(historyPath)) {
+  if (!fs23.existsSync(historyPath)) {
     return [];
   }
   try {
-    const content = fs22.readFileSync(historyPath, "utf-8");
+    const content = fs23.readFileSync(historyPath, "utf-8");
     const lines = content.split(`
 `);
     const records = [];
@@ -26506,8 +26815,8 @@ var _internals40 = {
 };
 
 // src/tools/resolve-working-directory.ts
-import * as fs23 from "fs";
-import * as path52 from "path";
+import * as fs24 from "fs";
+import * as path53 from "path";
 function resolveWorkingDirectory(workingDirectory, fallbackDirectory) {
   if (workingDirectory == null || workingDirectory === "") {
     if (typeof fallbackDirectory !== "string" || fallbackDirectory === "") {
@@ -26539,18 +26848,18 @@ function resolveWorkingDirectory(workingDirectory, fallbackDirectory) {
       };
     }
   }
-  const rawPathParts = workingDirectory.split(path52.sep);
+  const rawPathParts = workingDirectory.split(path53.sep);
   if (rawPathParts.includes("..")) {
     return {
       success: false,
       message: "Invalid working_directory: path traversal sequences (..) are not allowed"
     };
   }
-  const normalizedDir = path52.normalize(workingDirectory);
-  const resolvedDir = path52.resolve(normalizedDir);
+  const normalizedDir = path53.normalize(workingDirectory);
+  const resolvedDir = path53.resolve(normalizedDir);
   let statResult;
   try {
-    statResult = fs23.statSync(resolvedDir);
+    statResult = fs24.statSync(resolvedDir);
   } catch {
     return {
       success: false,
@@ -26566,16 +26875,16 @@ function resolveWorkingDirectory(workingDirectory, fallbackDirectory) {
   if (typeof fallbackDirectory !== "string" || fallbackDirectory === "") {
     return { success: true, directory: resolvedDir };
   }
-  const resolvedFallback = path52.resolve(fallbackDirectory);
+  const resolvedFallback = path53.resolve(fallbackDirectory);
   let fallbackExists = false;
   try {
-    fs23.statSync(resolvedFallback);
+    fs24.statSync(resolvedFallback);
     fallbackExists = true;
   } catch {
     fallbackExists = false;
   }
   if (fallbackExists) {
-    const isSubdirectory = resolvedDir.startsWith(resolvedFallback + path52.sep);
+    const isSubdirectory = resolvedDir.startsWith(resolvedFallback + path53.sep);
     if (isSubdirectory) {
       return {
         success: false,
@@ -26598,7 +26907,7 @@ async function estimateFanOut(sourceFiles, cwd) {
     const impactMap = await loadImpactMap(cwd, { skipRebuild: true });
     const uniqueTestFiles = new Set;
     for (const sourceFile of sourceFiles) {
-      const resolvedPath = path53.resolve(cwd, sourceFile);
+      const resolvedPath = path54.resolve(cwd, sourceFile);
       const normalizedPath = resolvedPath.replace(/\\/g, "/");
       const testFiles = impactMap[normalizedPath];
       if (testFiles) {
@@ -26683,19 +26992,19 @@ function hasDevDependency(devDeps, ...patterns) {
   return hasPackageJsonDependency(devDeps, ...patterns);
 }
 function detectGoTest(cwd) {
-  return fs24.existsSync(path53.join(cwd, "go.mod")) && isCommandAvailable("go");
+  return fs25.existsSync(path54.join(cwd, "go.mod")) && isCommandAvailable("go");
 }
 function detectJavaMaven(cwd) {
-  return fs24.existsSync(path53.join(cwd, "pom.xml")) && isCommandAvailable("mvn");
+  return fs25.existsSync(path54.join(cwd, "pom.xml")) && isCommandAvailable("mvn");
 }
 function detectGradle(cwd) {
-  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"));
+  const hasBuildFile = fs25.existsSync(path54.join(cwd, "build.gradle")) || fs25.existsSync(path54.join(cwd, "build.gradle.kts"));
+  const hasGradlew = fs25.existsSync(path54.join(cwd, "gradlew")) || fs25.existsSync(path54.join(cwd, "gradlew.bat"));
   return hasBuildFile && (hasGradlew || isCommandAvailable("gradle"));
 }
 function detectDotnetTest(cwd) {
   try {
-    const files = fs24.readdirSync(cwd);
+    const files = fs25.readdirSync(cwd);
     const hasCsproj = files.some((f) => f.endsWith(".csproj"));
     return hasCsproj && isCommandAvailable("dotnet");
   } catch {
@@ -26703,25 +27012,25 @@ function detectDotnetTest(cwd) {
   }
 }
 function detectCTest(cwd) {
-  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"));
+  const hasSource = fs25.existsSync(path54.join(cwd, "CMakeLists.txt"));
+  const hasBuildCache = fs25.existsSync(path54.join(cwd, "CMakeCache.txt")) || fs25.existsSync(path54.join(cwd, "build", "CMakeCache.txt"));
   return (hasSource || hasBuildCache) && isCommandAvailable("ctest");
 }
 function detectSwiftTest(cwd) {
-  return fs24.existsSync(path53.join(cwd, "Package.swift")) && isCommandAvailable("swift");
+  return fs25.existsSync(path54.join(cwd, "Package.swift")) && isCommandAvailable("swift");
 }
 function detectDartTest(cwd) {
-  return fs24.existsSync(path53.join(cwd, "pubspec.yaml")) && (isCommandAvailable("dart") || isCommandAvailable("flutter"));
+  return fs25.existsSync(path54.join(cwd, "pubspec.yaml")) && (isCommandAvailable("dart") || isCommandAvailable("flutter"));
 }
 function detectRSpec(cwd) {
-  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 hasRSpecFile = fs25.existsSync(path54.join(cwd, ".rspec"));
+  const hasGemfile = fs25.existsSync(path54.join(cwd, "Gemfile"));
+  const hasSpecDir = fs25.existsSync(path54.join(cwd, "spec"));
   const hasRSpec = hasRSpecFile || hasGemfile && hasSpecDir;
   return hasRSpec && (isCommandAvailable("bundle") || isCommandAvailable("rspec"));
 }
 function detectMinitest(cwd) {
-  return fs24.existsSync(path53.join(cwd, "test")) && (fs24.existsSync(path53.join(cwd, "Gemfile")) || fs24.existsSync(path53.join(cwd, "Rakefile"))) && isCommandAvailable("ruby");
+  return fs25.existsSync(path54.join(cwd, "test")) && (fs25.existsSync(path54.join(cwd, "Gemfile")) || fs25.existsSync(path54.join(cwd, "Rakefile"))) && isCommandAvailable("ruby");
 }
 var DISPATCH_FRAMEWORK_MAP = {
   bun: "bun",
@@ -26806,9 +27115,9 @@ async function parseTestOutputViaDispatch(framework, output, baseDir) {
 async function detectTestFramework(cwd) {
   const baseDir = cwd;
   try {
-    const packageJsonPath = path53.join(baseDir, "package.json");
-    if (fs24.existsSync(packageJsonPath)) {
-      const content = fs24.readFileSync(packageJsonPath, "utf-8");
+    const packageJsonPath = path54.join(baseDir, "package.json");
+    if (fs25.existsSync(packageJsonPath)) {
+      const content = fs25.readFileSync(packageJsonPath, "utf-8");
       const pkg = JSON.parse(content);
       const _deps = pkg.dependencies || {};
       const devDeps = pkg.devDependencies || {};
@@ -26827,38 +27136,38 @@ async function detectTestFramework(cwd) {
         return "jest";
       if (hasDevDependency(devDeps, "mocha", "@types/mocha"))
         return "mocha";
-      if (fs24.existsSync(path53.join(baseDir, "bun.lockb")) || fs24.existsSync(path53.join(baseDir, "bun.lock"))) {
+      if (fs25.existsSync(path54.join(baseDir, "bun.lockb")) || fs25.existsSync(path54.join(baseDir, "bun.lock"))) {
         if (scripts.test?.includes("bun"))
           return "bun";
       }
     }
   } catch {}
   try {
-    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");
+    const pyprojectTomlPath = path54.join(baseDir, "pyproject.toml");
+    const setupCfgPath = path54.join(baseDir, "setup.cfg");
+    const requirementsTxtPath = path54.join(baseDir, "requirements.txt");
+    if (fs25.existsSync(pyprojectTomlPath)) {
+      const content = fs25.readFileSync(pyprojectTomlPath, "utf-8");
       if (content.includes("[tool.pytest"))
         return "pytest";
       if (content.includes("pytest"))
         return "pytest";
     }
-    if (fs24.existsSync(setupCfgPath)) {
-      const content = fs24.readFileSync(setupCfgPath, "utf-8");
+    if (fs25.existsSync(setupCfgPath)) {
+      const content = fs25.readFileSync(setupCfgPath, "utf-8");
       if (content.includes("[pytest]"))
         return "pytest";
     }
-    if (fs24.existsSync(requirementsTxtPath)) {
-      const content = fs24.readFileSync(requirementsTxtPath, "utf-8");
+    if (fs25.existsSync(requirementsTxtPath)) {
+      const content = fs25.readFileSync(requirementsTxtPath, "utf-8");
       if (content.includes("pytest"))
         return "pytest";
     }
   } catch {}
   try {
-    const cargoTomlPath = path53.join(baseDir, "Cargo.toml");
-    if (fs24.existsSync(cargoTomlPath)) {
-      const content = fs24.readFileSync(cargoTomlPath, "utf-8");
+    const cargoTomlPath = path54.join(baseDir, "Cargo.toml");
+    if (fs25.existsSync(cargoTomlPath)) {
+      const content = fs25.readFileSync(cargoTomlPath, "utf-8");
       if (content.includes("[dev-dependencies]")) {
         if (content.includes("tokio") || content.includes("mockall") || content.includes("pretty_assertions")) {
           return "cargo";
@@ -26867,10 +27176,10 @@ async function detectTestFramework(cwd) {
     }
   } catch {}
   try {
-    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)) {
+    const pesterConfigPath = path54.join(baseDir, "pester.config.ps1");
+    const pesterConfigJsonPath = path54.join(baseDir, "pester.config.ps1.json");
+    const pesterPs1Path = path54.join(baseDir, "tests.ps1");
+    if (fs25.existsSync(pesterConfigPath) || fs25.existsSync(pesterConfigJsonPath) || fs25.existsSync(pesterPs1Path)) {
       return "pester";
     }
   } catch {}
@@ -26912,12 +27221,12 @@ function isTestDirectoryPath(normalizedPath) {
   return normalizedPath.split("/").some((segment) => TEST_DIRECTORY_NAMES.includes(segment));
 }
 function resolveWorkspacePath(file, workingDir) {
-  return path53.isAbsolute(file) ? path53.resolve(file) : path53.resolve(workingDir, file);
+  return path54.isAbsolute(file) ? path54.resolve(file) : path54.resolve(workingDir, file);
 }
 function toWorkspaceOutputPath(absolutePath, workingDir, preferRelative) {
   if (!preferRelative)
     return absolutePath;
-  return path53.relative(workingDir, absolutePath);
+  return path54.relative(workingDir, absolutePath);
 }
 function dedupePush(target, value) {
   if (!target.includes(value)) {
@@ -26954,18 +27263,18 @@ function buildLanguageSpecificTestNames(nameWithoutExt, ext) {
   }
 }
 function getRepoLevelCandidateDirectories(workingDir, relativePath, ext) {
-  const relativeDir = path53.dirname(relativePath);
+  const relativeDir = path54.dirname(relativePath);
   const nestedRelativeDir = relativeDir === "." ? "" : relativeDir;
   const directories = TEST_DIRECTORY_NAMES.flatMap((dirName) => {
-    const rootDir = path53.join(workingDir, dirName);
-    return nestedRelativeDir ? [rootDir, path53.join(rootDir, nestedRelativeDir)] : [rootDir];
+    const rootDir = path54.join(workingDir, dirName);
+    return nestedRelativeDir ? [rootDir, path54.join(rootDir, nestedRelativeDir)] : [rootDir];
   });
   const normalizedRelativePath = relativePath.replace(/\\/g, "/");
   if (ext === ".java" && normalizedRelativePath.startsWith("src/main/java/")) {
-    directories.push(path53.join(workingDir, "src/test/java", path53.dirname(normalizedRelativePath.slice("src/main/java/".length))));
+    directories.push(path54.join(workingDir, "src/test/java", path54.dirname(normalizedRelativePath.slice("src/main/java/".length))));
   }
   if ((ext === ".kt" || ext === ".java") && normalizedRelativePath.startsWith("src/main/kotlin/")) {
-    directories.push(path53.join(workingDir, "src/test/kotlin", path53.dirname(normalizedRelativePath.slice("src/main/kotlin/".length))));
+    directories.push(path54.join(workingDir, "src/test/kotlin", path54.dirname(normalizedRelativePath.slice("src/main/kotlin/".length))));
   }
   return [...new Set(directories)];
 }
@@ -26973,19 +27282,19 @@ function hasCompoundTestExtension(filename) {
   const lower = filename.toLowerCase();
   return COMPOUND_TEST_EXTENSIONS.some((ext) => lower.endsWith(ext));
 }
-function isLanguageSpecificTestFile(basename9) {
-  const lower = basename9.toLowerCase();
+function isLanguageSpecificTestFile(basename10) {
+  const lower = basename10.toLowerCase();
   if (lower.endsWith("_test.go"))
     return true;
   if (lower.endsWith(".py") && (lower.startsWith("test_") || lower.endsWith("_test.py")))
     return true;
   if (lower.endsWith("_spec.rb"))
     return true;
-  if (lower.endsWith(".java") && (/^Test[A-Z]/.test(basename9) || basename9.endsWith("Test.java") || basename9.endsWith("Tests.java") || lower.endsWith("it.java")))
+  if (lower.endsWith(".java") && (/^Test[A-Z]/.test(basename10) || basename10.endsWith("Test.java") || basename10.endsWith("Tests.java") || lower.endsWith("it.java")))
     return true;
   if (lower.endsWith(".cs") && (lower.endsWith("test.cs") || lower.endsWith("tests.cs")))
     return true;
-  if (lower.endsWith(".kt") && (/^Test[A-Z]/.test(basename9) || lower.endsWith("test.kt") || lower.endsWith("tests.kt")))
+  if (lower.endsWith(".kt") && (/^Test[A-Z]/.test(basename10) || lower.endsWith("test.kt") || lower.endsWith("tests.kt")))
     return true;
   if (lower.endsWith(".tests.ps1"))
     return true;
@@ -26993,23 +27302,23 @@ function isLanguageSpecificTestFile(basename9) {
 }
 function isConventionTestFilePath(filePath) {
   const normalizedPath = filePath.replace(/\\/g, "/");
-  const basename9 = path53.basename(filePath);
-  return hasCompoundTestExtension(basename9) || basename9.includes(".spec.") || basename9.includes(".test.") || isLanguageSpecificTestFile(basename9) || isTestDirectoryPath(normalizedPath);
+  const basename10 = path54.basename(filePath);
+  return hasCompoundTestExtension(basename10) || basename10.includes(".spec.") || basename10.includes(".test.") || isLanguageSpecificTestFile(basename10) || isTestDirectoryPath(normalizedPath);
 }
 function getTestFilesFromConvention(sourceFiles, workingDir = process.cwd()) {
   const testFiles = [];
   for (const file of sourceFiles) {
     const absoluteFile = resolveWorkspacePath(file, workingDir);
-    const relativeFile = path53.relative(workingDir, absoluteFile);
-    const basename9 = path53.basename(absoluteFile);
-    const dirname25 = path53.dirname(absoluteFile);
-    const preferRelativeOutput = !path53.isAbsolute(file);
+    const relativeFile = path54.relative(workingDir, absoluteFile);
+    const basename10 = path54.basename(absoluteFile);
+    const dirname25 = path54.dirname(absoluteFile);
+    const preferRelativeOutput = !path54.isAbsolute(file);
     if (isConventionTestFilePath(relativeFile) || isConventionTestFilePath(file)) {
       dedupePush(testFiles, toWorkspaceOutputPath(absoluteFile, workingDir, preferRelativeOutput));
       continue;
     }
-    const nameWithoutExt = basename9.replace(/\.[^.]+$/, "");
-    const ext = path53.extname(basename9);
+    const nameWithoutExt = basename10.replace(/\.[^.]+$/, "");
+    const ext = path54.extname(basename10);
     const genericTestNames = [
       `${nameWithoutExt}.spec${ext}`,
       `${nameWithoutExt}.test${ext}`
@@ -27018,20 +27327,20 @@ function getTestFilesFromConvention(sourceFiles, workingDir = process.cwd()) {
     const colocatedCandidates = [
       ...genericTestNames,
       ...languageSpecificTestNames
-    ].map((candidateName) => path53.join(dirname25, candidateName));
+    ].map((candidateName) => path54.join(dirname25, candidateName));
     const testDirectoryNames = [
-      basename9,
+      basename10,
       ...genericTestNames,
       ...languageSpecificTestNames
     ];
     const repoLevelDirectories = getRepoLevelCandidateDirectories(workingDir, relativeFile, ext);
     const possibleTestFiles = [
       ...colocatedCandidates,
-      ...TEST_DIRECTORY_NAMES.flatMap((dirName) => testDirectoryNames.map((candidateName) => path53.join(dirname25, dirName, candidateName))),
-      ...repoLevelDirectories.flatMap((candidateDir) => testDirectoryNames.map((candidateName) => path53.join(candidateDir, candidateName)))
+      ...TEST_DIRECTORY_NAMES.flatMap((dirName) => testDirectoryNames.map((candidateName) => path54.join(dirname25, dirName, candidateName))),
+      ...repoLevelDirectories.flatMap((candidateDir) => testDirectoryNames.map((candidateName) => path54.join(candidateDir, candidateName)))
     ];
     for (const testFile of possibleTestFiles) {
-      if (fs24.existsSync(testFile)) {
+      if (fs25.existsSync(testFile)) {
         dedupePush(testFiles, toWorkspaceOutputPath(testFile, workingDir, preferRelativeOutput));
       }
     }
@@ -27048,8 +27357,8 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
   for (const testFile of candidateTestFiles) {
     try {
       const absoluteTestFile = resolveWorkspacePath(testFile, workingDir);
-      const content = fs24.readFileSync(absoluteTestFile, "utf-8");
-      const testDir = path53.dirname(absoluteTestFile);
+      const content = fs25.readFileSync(absoluteTestFile, "utf-8");
+      const testDir = path54.dirname(absoluteTestFile);
       const importRegex = /import\s+.*?\s+from\s+['"]([^'"]+)['"]/g;
       let match;
       match = importRegex.exec(content);
@@ -27057,8 +27366,8 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
         const importPath = match[1];
         let resolvedImport;
         if (importPath.startsWith(".")) {
-          resolvedImport = path53.resolve(testDir, importPath);
-          const existingExt = path53.extname(resolvedImport);
+          resolvedImport = path54.resolve(testDir, importPath);
+          const existingExt = path54.extname(resolvedImport);
           if (!existingExt) {
             for (const extToTry of [
               ".ts",
@@ -27069,7 +27378,7 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
               ".cjs"
             ]) {
               const withExt = resolvedImport + extToTry;
-              if (absoluteSourceFiles.includes(withExt) || fs24.existsSync(withExt)) {
+              if (absoluteSourceFiles.includes(withExt) || fs25.existsSync(withExt)) {
                 resolvedImport = withExt;
                 break;
               }
@@ -27078,12 +27387,12 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
         } else {
           continue;
         }
-        const importBasename = path53.basename(resolvedImport, path53.extname(resolvedImport));
-        const importDir = path53.dirname(resolvedImport);
+        const importBasename = path54.basename(resolvedImport, path54.extname(resolvedImport));
+        const importDir = path54.dirname(resolvedImport);
         for (const sourceFile of absoluteSourceFiles) {
-          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");
+          const sourceDir = path54.dirname(sourceFile);
+          const sourceBasename = path54.basename(sourceFile, path54.extname(sourceFile));
+          const isRelatedDir = importDir === sourceDir || importDir === path54.join(sourceDir, "__tests__") || importDir === path54.join(sourceDir, "tests") || importDir === path54.join(sourceDir, "test") || importDir === path54.join(sourceDir, "spec");
           if (resolvedImport === sourceFile || importBasename === sourceBasename && isRelatedDir) {
             dedupePush(testFiles, testFile);
             break;
@@ -27096,8 +27405,8 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
       while (match !== null) {
         const importPath = match[1];
         if (importPath.startsWith(".")) {
-          let resolvedImport = path53.resolve(testDir, importPath);
-          const existingExt = path53.extname(resolvedImport);
+          let resolvedImport = path54.resolve(testDir, importPath);
+          const existingExt = path54.extname(resolvedImport);
           if (!existingExt) {
             for (const extToTry of [
               ".ts",
@@ -27108,18 +27417,18 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
               ".cjs"
             ]) {
               const withExt = resolvedImport + extToTry;
-              if (absoluteSourceFiles.includes(withExt) || fs24.existsSync(withExt)) {
+              if (absoluteSourceFiles.includes(withExt) || fs25.existsSync(withExt)) {
                 resolvedImport = withExt;
                 break;
               }
             }
           }
-          const importDir = path53.dirname(resolvedImport);
-          const importBasename = path53.basename(resolvedImport, path53.extname(resolvedImport));
+          const importDir = path54.dirname(resolvedImport);
+          const importBasename = path54.basename(resolvedImport, path54.extname(resolvedImport));
           for (const sourceFile of absoluteSourceFiles) {
-            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");
+            const sourceDir = path54.dirname(sourceFile);
+            const sourceBasename = path54.basename(sourceFile, path54.extname(sourceFile));
+            const isRelatedDir = importDir === sourceDir || importDir === path54.join(sourceDir, "__tests__") || importDir === path54.join(sourceDir, "tests") || importDir === path54.join(sourceDir, "test") || importDir === path54.join(sourceDir, "spec");
             if (resolvedImport === sourceFile || importBasename === sourceBasename && isRelatedDir) {
               dedupePush(testFiles, testFile);
               break;
@@ -27239,8 +27548,8 @@ function buildTestCommand(framework, scope, files, coverage, baseDir, bail) {
       return ["mvn", "test"];
     case "gradle": {
       const isWindows = process.platform === "win32";
-      const hasGradlewBat = fs24.existsSync(path53.join(baseDir, "gradlew.bat"));
-      const hasGradlew = fs24.existsSync(path53.join(baseDir, "gradlew"));
+      const hasGradlewBat = fs25.existsSync(path54.join(baseDir, "gradlew.bat"));
+      const hasGradlew = fs25.existsSync(path54.join(baseDir, "gradlew"));
       if (hasGradlewBat && isWindows)
         return ["gradlew.bat", "test"];
       if (hasGradlew)
@@ -27257,7 +27566,7 @@ function buildTestCommand(framework, scope, files, coverage, baseDir, bail) {
         "cmake-build-release",
         "out"
       ];
-      const actualBuildDir = buildDirCandidates.find((d) => fs24.existsSync(path53.join(baseDir, d, "CMakeCache.txt"))) ?? "build";
+      const actualBuildDir = buildDirCandidates.find((d) => fs25.existsSync(path54.join(baseDir, d, "CMakeCache.txt"))) ?? "build";
       return ["ctest", "--test-dir", actualBuildDir];
     }
     case "swift-test":
@@ -27691,13 +28000,13 @@ async function runTests(framework, scope, files, coverage, timeout_ms, cwd, bail
     };
   }
   const startTime = Date.now();
-  const vitestJsonOutputPath = framework === "vitest" ? path53.join(cwd, ".swarm", "cache", "test-runner-vitest.json") : undefined;
+  const vitestJsonOutputPath = framework === "vitest" ? path54.join(cwd, ".swarm", "cache", "test-runner-vitest.json") : undefined;
   try {
     if (vitestJsonOutputPath) {
       try {
-        fs24.mkdirSync(path53.dirname(vitestJsonOutputPath), { recursive: true });
-        if (fs24.existsSync(vitestJsonOutputPath)) {
-          fs24.unlinkSync(vitestJsonOutputPath);
+        fs25.mkdirSync(path54.dirname(vitestJsonOutputPath), { recursive: true });
+        if (fs25.existsSync(vitestJsonOutputPath)) {
+          fs25.unlinkSync(vitestJsonOutputPath);
         }
       } catch {}
     }
@@ -27723,8 +28032,8 @@ async function runTests(framework, scope, files, coverage, timeout_ms, cwd, bail
     }
     if (vitestJsonOutputPath) {
       try {
-        if (fs24.existsSync(vitestJsonOutputPath)) {
-          const vitestJsonOutput = fs24.readFileSync(vitestJsonOutputPath, "utf-8");
+        if (fs25.existsSync(vitestJsonOutputPath)) {
+          const vitestJsonOutput = fs25.readFileSync(vitestJsonOutputPath, "utf-8");
           if (vitestJsonOutput.trim().length > 0) {
             output += (output ? `
 ` : "") + vitestJsonOutput;
@@ -27863,10 +28172,10 @@ var SKIP_DIRECTORIES = new Set([
 ]);
 function normalizeHistoryTestFile(testFile, workingDir) {
   const normalized = testFile.replace(/\\/g, "/");
-  if (!path53.isAbsolute(testFile))
+  if (!path54.isAbsolute(testFile))
     return normalized;
-  const relative8 = path53.relative(workingDir, testFile);
-  if (relative8.startsWith("..") || path53.isAbsolute(relative8)) {
+  const relative8 = path54.relative(workingDir, testFile);
+  if (relative8.startsWith("..") || path54.isAbsolute(relative8)) {
     return normalized;
   }
   return relative8.replace(/\\/g, "/");
@@ -28105,7 +28414,7 @@ var test_runner = createSwarmTool({
       const sourceFiles = args.files.filter((file) => {
         if (directTestFiles.includes(file))
           return false;
-        const ext = path53.extname(file).toLowerCase();
+        const ext = path54.extname(file).toLowerCase();
         return SOURCE_EXTENSIONS.has(ext);
       });
       const invalidFiles = args.files.filter((file) => !directTestFiles.includes(file) && !sourceFiles.includes(file));
@@ -28151,7 +28460,7 @@ var test_runner = createSwarmTool({
         if (isConventionTestFilePath(f)) {
           return false;
         }
-        const ext = path53.extname(f).toLowerCase();
+        const ext = path54.extname(f).toLowerCase();
         return SOURCE_EXTENSIONS.has(ext);
       });
       if (sourceFiles.length === 0) {
@@ -28201,7 +28510,7 @@ var test_runner = createSwarmTool({
         if (isConventionTestFilePath(f)) {
           return false;
         }
-        const ext = path53.extname(f).toLowerCase();
+        const ext = path54.extname(f).toLowerCase();
         return SOURCE_EXTENSIONS.has(ext);
       });
       if (sourceFiles.length === 0) {
@@ -28253,8 +28562,8 @@ var test_runner = createSwarmTool({
         }
         if (impactResult.impactedTests.length > 0) {
           testFiles = impactResult.impactedTests.map((absPath) => {
-            const relativePath = path53.relative(workingDir, absPath);
-            return path53.isAbsolute(relativePath) ? absPath : relativePath;
+            const relativePath = path54.relative(workingDir, absPath);
+            return path54.isAbsolute(relativePath) ? absPath : relativePath;
           });
         } else {
           graphFallbackReason = "no impacted tests found via impact analysis, falling back to graph";
@@ -28349,8 +28658,8 @@ function validateDirectoryPath(dir) {
   if (dir.includes("..")) {
     throw new Error("Directory path must not contain path traversal sequences");
   }
-  const normalized = path54.normalize(dir);
-  const absolutePath = path54.isAbsolute(normalized) ? normalized : path54.resolve(normalized);
+  const normalized = path55.normalize(dir);
+  const absolutePath = path55.isAbsolute(normalized) ? normalized : path55.resolve(normalized);
   return absolutePath;
 }
 function validateTimeout(timeoutMs, defaultValue) {
@@ -28373,9 +28682,9 @@ function validateTimeout(timeoutMs, defaultValue) {
 }
 function getPackageVersion(dir) {
   try {
-    const packagePath = path54.join(dir, "package.json");
-    if (fs25.existsSync(packagePath)) {
-      const content = fs25.readFileSync(packagePath, "utf-8");
+    const packagePath = path55.join(dir, "package.json");
+    if (fs26.existsSync(packagePath)) {
+      const content = fs26.readFileSync(packagePath, "utf-8");
       const pkg = JSON.parse(content);
       return pkg.version ?? null;
     }
@@ -28384,9 +28693,9 @@ function getPackageVersion(dir) {
 }
 function getChangelogVersion(dir) {
   try {
-    const changelogPath = path54.join(dir, "CHANGELOG.md");
-    if (fs25.existsSync(changelogPath)) {
-      const content = fs25.readFileSync(changelogPath, "utf-8");
+    const changelogPath = path55.join(dir, "CHANGELOG.md");
+    if (fs26.existsSync(changelogPath)) {
+      const content = fs26.readFileSync(changelogPath, "utf-8");
       const match = content.match(/^##\s*\[?(\d+\.\d+\.\d+)\]?/m);
       if (match) {
         return match[1];
@@ -28398,10 +28707,10 @@ function getChangelogVersion(dir) {
 function getVersionFileVersion(dir) {
   const possibleFiles = ["VERSION.txt", "version.txt", "VERSION", "version"];
   for (const file of possibleFiles) {
-    const filePath = path54.join(dir, file);
-    if (fs25.existsSync(filePath)) {
+    const filePath = path55.join(dir, file);
+    if (fs26.existsSync(filePath)) {
       try {
-        const content = fs25.readFileSync(filePath, "utf-8").trim();
+        const content = fs26.readFileSync(filePath, "utf-8").trim();
         const match = content.match(/(\d+\.\d+\.\d+)/);
         if (match) {
           return match[1];
@@ -29135,8 +29444,8 @@ async function handleQaGatesCommand(directory, args, sessionID) {
 }
 
 // src/commands/reset.ts
-import * as fs26 from "fs";
-import * as path55 from "path";
+import * as fs27 from "fs";
+import * as path56 from "path";
 
 // src/background/circuit-breaker.ts
 class CircuitBreaker {
@@ -29843,8 +30152,8 @@ async function handleResetCommand(directory, args) {
   for (const filename of filesToReset) {
     try {
       const resolvedPath = validateSwarmPath(directory, filename);
-      if (fs26.existsSync(resolvedPath)) {
-        fs26.unlinkSync(resolvedPath);
+      if (fs27.existsSync(resolvedPath)) {
+        fs27.unlinkSync(resolvedPath);
         results.push(`- \u2705 Deleted ${filename}`);
       } else {
         results.push(`- \u23ED\uFE0F ${filename} not found (skipped)`);
@@ -29855,9 +30164,9 @@ async function handleResetCommand(directory, args) {
   }
   for (const filename of ["SWARM_PLAN.md", "SWARM_PLAN.json"]) {
     try {
-      const rootPath = path55.join(directory, filename);
-      if (fs26.existsSync(rootPath)) {
-        fs26.unlinkSync(rootPath);
+      const rootPath = path56.join(directory, filename);
+      if (fs27.existsSync(rootPath)) {
+        fs27.unlinkSync(rootPath);
         results.push(`- \u2705 Deleted ${filename} (root)`);
       }
     } catch (err) {
@@ -29872,8 +30181,8 @@ async function handleResetCommand(directory, args) {
   }
   try {
     const summariesPath = validateSwarmPath(directory, "summaries");
-    if (fs26.existsSync(summariesPath)) {
-      fs26.rmSync(summariesPath, { recursive: true, force: true });
+    if (fs27.existsSync(summariesPath)) {
+      fs27.rmSync(summariesPath, { recursive: true, force: true });
       results.push("- \u2705 Deleted summaries/ directory");
     } else {
       results.push("- \u23ED\uFE0F summaries/ not found (skipped)");
@@ -29892,8 +30201,8 @@ async function handleResetCommand(directory, args) {
 }
 
 // src/commands/reset-session.ts
-import * as fs28 from "fs";
-import * as path57 from "path";
+import * as fs29 from "fs";
+import * as path58 from "path";
 
 // src/hooks/trajectory-logger.ts
 var callStartTimes = new Map;
@@ -30299,17 +30608,17 @@ function detectPatterns(trajectory, config, lastProcessedStep = 0) {
   };
 }
 // src/prm/replay.ts
-import { promises as fs27 } from "fs";
-import path56 from "path";
+import { promises as fs28 } from "fs";
+import path57 from "path";
 function isPathSafe(targetPath, basePath) {
-  const resolvedTarget = path56.resolve(targetPath);
-  const resolvedBase = path56.resolve(basePath);
-  const rel = path56.relative(resolvedBase, resolvedTarget);
-  return !rel.startsWith("..") && !path56.isAbsolute(rel);
+  const resolvedTarget = path57.resolve(targetPath);
+  const resolvedBase = path57.resolve(basePath);
+  const rel = path57.relative(resolvedBase, resolvedTarget);
+  return !rel.startsWith("..") && !path57.isAbsolute(rel);
 }
 function isWithinReplaysDir(targetPath) {
-  const resolved = path56.resolve(targetPath);
-  const parts = resolved.split(path56.sep);
+  const resolved = path57.resolve(targetPath);
+  const parts = resolved.split(path57.sep);
   for (let i = 0;i < parts.length - 1; i++) {
     if (parts[i] === ".swarm" && parts[i + 1] === "replays") {
       return true;
@@ -30322,15 +30631,15 @@ function sanitizeFilename(input) {
 }
 async function startReplayRecording(sessionID, directory) {
   try {
-    const replayDir = path56.join(directory, ".swarm", "replays");
+    const replayDir = path57.join(directory, ".swarm", "replays");
     const safeSessionID = sanitizeFilename(sessionID);
     const filename = `${safeSessionID}-${Date.now()}.jsonl`;
-    const filepath = path56.join(replayDir, filename);
+    const filepath = path57.join(replayDir, filename);
     if (!isPathSafe(filepath, replayDir)) {
       console.warn(`[replay] Invalid path detected - path traversal attempt blocked for session ${sessionID}`);
       return null;
     }
-    await fs27.mkdir(replayDir, { recursive: true });
+    await fs28.mkdir(replayDir, { recursive: true });
     return filepath;
   } catch (err) {
     console.warn(`[replay] Failed to start recording for session ${sessionID}: ${err}`);
@@ -30350,7 +30659,7 @@ async function recordReplayEntry(artifactPath, sessionID, entry) {
     };
     const line = `${JSON.stringify(fullEntry)}
 `;
-    await fs27.appendFile(artifactPath, line, "utf-8");
+    await fs28.appendFile(artifactPath, line, "utf-8");
   } catch (err) {
     console.warn(`[replay] Failed to record entry: ${err}`);
   }
@@ -30394,8 +30703,8 @@ async function handleResetSessionCommand(directory, _args) {
   const results = [];
   try {
     const statePath = validateSwarmPath(directory, "session/state.json");
-    if (fs28.existsSync(statePath)) {
-      fs28.unlinkSync(statePath);
+    if (fs29.existsSync(statePath)) {
+      fs29.unlinkSync(statePath);
       results.push("\u2705 Deleted .swarm/session/state.json");
     } else {
       results.push("\u23ED\uFE0F state.json not found (already clean)");
@@ -30403,11 +30712,11 @@ async function handleResetSessionCommand(directory, _args) {
   } catch {
     results.push("\u274C Failed to delete state.json");
   }
-  const sessionDir = path57.dirname(validateSwarmPath(directory, "session/state.json"));
+  const sessionDir = path58.dirname(validateSwarmPath(directory, "session/state.json"));
   let sessionFiles = [];
-  if (fs28.existsSync(sessionDir)) {
+  if (fs29.existsSync(sessionDir)) {
     try {
-      sessionFiles = fs28.readdirSync(sessionDir);
+      sessionFiles = fs29.readdirSync(sessionDir);
     } catch (err) {
       results.push(`\u274C Failed to read session directory: ${errorMessage(err)}`);
     }
@@ -30415,13 +30724,13 @@ async function handleResetSessionCommand(directory, _args) {
   for (const file of sessionFiles) {
     if (file === "state.json")
       continue;
-    const filePath = path57.join(sessionDir, file);
+    const filePath = path58.join(sessionDir, file);
     try {
-      if (!fs28.existsSync(filePath))
+      if (!fs29.existsSync(filePath))
         continue;
-      if (!fs28.lstatSync(filePath).isFile())
+      if (!fs29.lstatSync(filePath).isFile())
         continue;
-      fs28.unlinkSync(filePath);
+      fs29.unlinkSync(filePath);
       results.push(`\u2713 Deleted ${file}`);
     } catch (err) {
       results.push(`\u274C Failed to delete ${file}: ${errorMessage(err)}`);
@@ -30450,7 +30759,7 @@ async function handleResetSessionCommand(directory, _args) {
 }
 
 // src/summaries/manager.ts
-import * as path58 from "path";
+import * as path59 from "path";
 var SUMMARY_ID_REGEX = /^S\d+$/;
 function sanitizeSummaryId(id) {
   if (!id || id.length === 0) {
@@ -30474,7 +30783,7 @@ function sanitizeSummaryId(id) {
 }
 async function loadFullOutput(directory, id) {
   const sanitizedId = sanitizeSummaryId(id);
-  const relativePath = path58.join("summaries", `${sanitizedId}.json`);
+  const relativePath = path59.join("summaries", `${sanitizedId}.json`);
   validateSwarmPath(directory, relativePath);
   const content = await readSwarmFileAsync(directory, relativePath);
   if (content === null) {
@@ -30526,18 +30835,18 @@ ${error2 instanceof Error ? error2.message : String(error2)}`;
 }
 
 // src/commands/rollback.ts
-import * as fs29 from "fs";
-import * as path59 from "path";
+import * as fs30 from "fs";
+import * as path60 from "path";
 async function handleRollbackCommand(directory, args) {
   const phaseArg = args[0];
   if (!phaseArg) {
     const manifestPath2 = validateSwarmPath(directory, "checkpoints/manifest.json");
-    if (!fs29.existsSync(manifestPath2)) {
+    if (!fs30.existsSync(manifestPath2)) {
       return "No checkpoints found. Use `/swarm checkpoint` to create checkpoints.";
     }
     let manifest2;
     try {
-      manifest2 = JSON.parse(fs29.readFileSync(manifestPath2, "utf-8"));
+      manifest2 = JSON.parse(fs30.readFileSync(manifestPath2, "utf-8"));
     } catch {
       return "Error: Checkpoint manifest is corrupted. Delete .swarm/checkpoints/manifest.json and re-checkpoint.";
     }
@@ -30559,12 +30868,12 @@ async function handleRollbackCommand(directory, args) {
     return "Error: Phase number must be a positive integer.";
   }
   const manifestPath = validateSwarmPath(directory, "checkpoints/manifest.json");
-  if (!fs29.existsSync(manifestPath)) {
+  if (!fs30.existsSync(manifestPath)) {
     return `Error: No checkpoints found. Cannot rollback to phase ${targetPhase}.`;
   }
   let manifest;
   try {
-    manifest = JSON.parse(fs29.readFileSync(manifestPath, "utf-8"));
+    manifest = JSON.parse(fs30.readFileSync(manifestPath, "utf-8"));
   } catch {
     return `Error: Checkpoint manifest is corrupted. Delete .swarm/checkpoints/manifest.json and re-checkpoint.`;
   }
@@ -30574,10 +30883,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 (!fs29.existsSync(checkpointDir)) {
+  if (!fs30.existsSync(checkpointDir)) {
     return `Error: Checkpoint directory for phase ${targetPhase} does not exist.`;
   }
-  const checkpointFiles = fs29.readdirSync(checkpointDir);
+  const checkpointFiles = fs30.readdirSync(checkpointDir);
   if (checkpointFiles.length === 0) {
     return `Error: Checkpoint for phase ${targetPhase} is empty. Cannot rollback.`;
   }
@@ -30593,10 +30902,10 @@ async function handleRollbackCommand(directory, args) {
     if (EXCLUDE_FILES.has(file) || file.startsWith("plan-ledger.archived-")) {
       continue;
     }
-    const src = path59.join(checkpointDir, file);
-    const dest = path59.join(swarmDir, file);
+    const src = path60.join(checkpointDir, file);
+    const dest = path60.join(swarmDir, file);
     try {
-      fs29.cpSync(src, dest, { recursive: true, force: true });
+      fs30.cpSync(src, dest, { recursive: true, force: true });
       successes.push(file);
     } catch (error2) {
       failures.push({ file, error: error2.message });
@@ -30613,11 +30922,11 @@ async function handleRollbackCommand(directory, args) {
     ].join(`
 `);
   }
-  const existingLedgerPath = path59.join(swarmDir, "plan-ledger.jsonl");
+  const existingLedgerPath = path60.join(swarmDir, "plan-ledger.jsonl");
   let ledgerDeletionFailed = false;
-  if (fs29.existsSync(existingLedgerPath)) {
+  if (fs30.existsSync(existingLedgerPath)) {
     try {
-      fs29.unlinkSync(existingLedgerPath);
+      fs30.unlinkSync(existingLedgerPath);
     } catch (err) {
       ledgerDeletionFailed = true;
       const errMsg = err instanceof Error ? err.message : String(err);
@@ -30626,9 +30935,9 @@ async function handleRollbackCommand(directory, args) {
   }
   if (!ledgerDeletionFailed) {
     try {
-      const planJsonPath = path59.join(swarmDir, "plan.json");
-      if (fs29.existsSync(planJsonPath)) {
-        const planRaw = fs29.readFileSync(planJsonPath, "utf-8");
+      const planJsonPath = path60.join(swarmDir, "plan.json");
+      if (fs30.existsSync(planJsonPath)) {
+        const planRaw = fs30.readFileSync(planJsonPath, "utf-8");
         const plan = PlanSchema.parse(JSON.parse(planRaw));
         const planId = derivePlanId(plan);
         const planHash = computePlanHash(plan);
@@ -30656,7 +30965,7 @@ async function handleRollbackCommand(directory, args) {
     timestamp: new Date().toISOString()
   };
   try {
-    fs29.appendFileSync(eventsPath, `${JSON.stringify(rollbackEvent)}
+    fs30.appendFileSync(eventsPath, `${JSON.stringify(rollbackEvent)}
 `);
   } catch (error2) {
     console.error("Failed to write rollback event:", error2 instanceof Error ? error2.message : String(error2));
@@ -30838,7 +31147,7 @@ async function handleSddCommand(_directory, _args) {
 }
 
 // src/commands/simulate.ts
-import { renameSync as renameSync11, unlinkSync as unlinkSync11 } from "fs";
+import { renameSync as renameSync11, unlinkSync as unlinkSync12 } from "fs";
 async function handleSimulateCommand(directory, args) {
   const thresholdIndex = args.indexOf("--threshold");
   const minCommitsIndex = args.indexOf("--min-commits");
@@ -30886,17 +31195,17 @@ Ensure this is a git repository with commit history.`;
   const report = reportLines.filter(Boolean).join(`
 `);
   try {
-    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)}`);
+    const fs31 = await import("fs/promises");
+    const path61 = await import("path");
+    const reportPath = path61.join(directory, ".swarm", "simulate-report.md");
+    await fs31.mkdir(path61.dirname(reportPath), { recursive: true });
+    const reportTempPath = path61.join(path61.dirname(reportPath), `${path61.basename(reportPath)}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
     try {
-      await fs30.writeFile(reportTempPath, report, "utf-8");
+      await fs31.writeFile(reportTempPath, report, "utf-8");
       renameSync11(reportTempPath, reportPath);
     } catch (err) {
       try {
-        unlinkSync11(reportTempPath);
+        unlinkSync12(reportTempPath);
       } catch {}
       throw err;
     }
@@ -30919,20 +31228,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 path61 from "path";
+import * as path62 from "path";
 
 // src/turbo/lean/state.ts
 init_logger();
-import * as fs30 from "fs";
-import * as path60 from "path";
+import * as fs31 from "fs";
+import * as path61 from "path";
 var STATE_FILE3 = "turbo-state.json";
 function nowISO3() {
   return new Date().toISOString();
 }
 function ensureSwarmDir2(directory) {
-  const swarmDir = path60.resolve(directory, ".swarm");
-  if (!fs30.existsSync(swarmDir)) {
-    fs30.mkdirSync(swarmDir, { recursive: true });
+  const swarmDir = path61.resolve(directory, ".swarm");
+  if (!fs31.existsSync(swarmDir)) {
+    fs31.mkdirSync(swarmDir, { recursive: true });
   }
   return swarmDir;
 }
@@ -30975,17 +31284,17 @@ function markStateUnreadable2(directory, reason) {
 }
 function readPersisted2(directory) {
   try {
-    const filePath = path60.join(directory, ".swarm", STATE_FILE3);
-    if (!fs30.existsSync(filePath)) {
+    const filePath = path61.join(directory, ".swarm", STATE_FILE3);
+    if (!fs31.existsSync(filePath)) {
       const seed = emptyPersisted2();
       try {
         ensureSwarmDir2(directory);
-        fs30.writeFileSync(filePath, `${JSON.stringify(seed, null, 2)}
+        fs31.writeFileSync(filePath, `${JSON.stringify(seed, null, 2)}
 `, "utf-8");
       } catch {}
       return seed;
     }
-    const raw = fs30.readFileSync(filePath, "utf-8");
+    const raw = fs31.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})`);
@@ -31011,7 +31320,7 @@ function writePersisted2(directory, persisted) {
   let payload;
   try {
     ensureSwarmDir2(directory);
-    filePath = path60.join(directory, ".swarm", STATE_FILE3);
+    filePath = path61.join(directory, ".swarm", STATE_FILE3);
     tmpPath = `${filePath}.tmp.${Date.now()}`;
     persisted.updatedAt = nowISO3();
     payload = `${JSON.stringify(persisted, null, 2)}
@@ -31022,14 +31331,14 @@ function writePersisted2(directory, persisted) {
     throw new Error(`Lean Turbo state persistence prepare failed: ${msg}`);
   }
   try {
-    fs30.writeFileSync(tmpPath, payload, "utf-8");
-    fs30.renameSync(tmpPath, filePath);
+    fs31.writeFileSync(tmpPath, payload, "utf-8");
+    fs31.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 (fs30.existsSync(tmpPath)) {
-        fs30.unlinkSync(tmpPath);
+      if (fs31.existsSync(tmpPath)) {
+        fs31.unlinkSync(tmpPath);
       }
     } catch {}
     throw new Error(`Lean Turbo state persistence failed: ${msg}`);
@@ -31129,7 +31438,7 @@ var _internals43 = {
 };
 function readSpecStalenessSnapshot(directory) {
   try {
-    const p = path61.join(directory, ".swarm", "spec-staleness.json");
+    const p = path62.join(directory, ".swarm", "spec-staleness.json");
     if (!fsSync3.existsSync(p))
       return { stale: false };
     const raw = fsSync3.readFileSync(p, "utf-8");
@@ -31661,13 +31970,13 @@ function buildStatusMessage2(session, directory, sessionID) {
 }
 
 // src/commands/unlink.ts
-import { existsSync as existsSync36 } from "fs";
-import * as path62 from "path";
+import { existsSync as existsSync37 } from "fs";
+import * as path63 from "path";
 var DEDUP_THRESHOLD2 = 0.6;
 async function copySharedKnowledgeToLocal(linkDir, localSwarmDir) {
-  const sharedPath = path62.join(linkDir, "knowledge.jsonl");
-  const localPath = path62.join(localSwarmDir, "knowledge.jsonl");
-  if (!existsSync36(sharedPath))
+  const sharedPath = path63.join(linkDir, "knowledge.jsonl");
+  const localPath = path63.join(localSwarmDir, "knowledge.jsonl");
+  if (!existsSync37(sharedPath))
     return 0;
   const sharedEntries = await readKnowledge(sharedPath);
   if (sharedEntries.length === 0)
@@ -31701,7 +32010,7 @@ async function handleUnlinkCommand(directory, args) {
   let copied = 0;
   if (copyBack) {
     try {
-      copied = await copySharedKnowledgeToLocal(linkDir, path62.join(directory, ".swarm"));
+      copied = await copySharedKnowledgeToLocal(linkDir, path63.join(directory, ".swarm"));
     } catch (error2) {
       return `\u274C Failed to copy shared knowledge back to local: ${error2 instanceof Error ? error2.message : String(error2)}`;
     }
@@ -31856,7 +32165,7 @@ function buildDetailedHelp(commandName, entry) {
 async function handleHelpCommand(ctx) {
   const targetCommand = ctx.args.join(" ");
   if (!targetCommand) {
-    const { buildHelpText } = await import("./index-attgb1ma.js");
+    const { buildHelpText } = await import("./index-4pt2py5p.js");
     return buildHelpText();
   }
   const tokens = targetCommand.split(/\s+/);
@@ -31865,7 +32174,7 @@ async function handleHelpCommand(ctx) {
     return _internals45.buildDetailedHelp(resolved.key, resolved.entry);
   }
   const similar = _internals45.findSimilarCommands(targetCommand);
-  const { buildHelpText: fullHelp } = await import("./index-attgb1ma.js");
+  const { buildHelpText: fullHelp } = await import("./index-4pt2py5p.js");
   if (similar.length > 0) {
     return `Command '/swarm ${targetCommand}' not found.
 
@@ -31998,7 +32307,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail explain": {
     handler: async (ctx) => {
-      const { handleGuardrailExplain } = await import("./guardrail-explain-cm08h4mt.js");
+      const { handleGuardrailExplain } = await import("./guardrail-explain-ktm6szbm.js");
       return handleGuardrailExplain(ctx.directory, ctx.args);
     },
     description: "Dry-run: show what the guardrails would do to a command or write target (executes nothing)",
@@ -32008,7 +32317,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail-log": {
     handler: async (ctx) => {
-      const { handleGuardrailLog } = await import("./guardrail-log-53z1cf46.js");
+      const { handleGuardrailLog } = await import("./guardrail-log-ya49kpwn.js");
       return handleGuardrailLog(ctx.directory, ctx.args);
     },
     description: "Read the guardrail decision log (use --blocks-only for blocks)",
@@ -32033,8 +32342,15 @@ var COMMAND_REGISTRY = {
   },
   benchmark: {
     handler: (ctx) => handleBenchmarkCommand(ctx.directory, ctx.args),
-    description: "Show performance metrics [--cumulative] [--ci-gate]",
-    args: "--cumulative, --ci-gate",
+    description: "Show performance metrics [--cumulative] [--ci-gate] [--max-cost-usd <n>]",
+    args: "--cumulative, --ci-gate, --max-cost-usd <n>",
+    category: "diagnostics",
+    toolPolicy: "agent"
+  },
+  costs: {
+    handler: (ctx) => handleCostsCommand(ctx.directory, ctx.args),
+    description: "Show per-agent and per-task token/cost telemetry [--json]",
+    args: "--json",
     category: "diagnostics",
     toolPolicy: "agent"
   },
@@ -32769,24 +33085,24 @@ function validateAliases() {
       }
       aliasTargets.get(target).push(name);
       const visited = new Set;
-      const path63 = [];
+      const path64 = [];
       let current = target;
       while (current) {
         const currentEntry = COMMAND_REGISTRY[current];
         if (!currentEntry)
           break;
         if (visited.has(current)) {
-          const cycleStart = path63.indexOf(current);
+          const cycleStart = path64.indexOf(current);
           const fullChain = [
             name,
-            ...path63.slice(0, cycleStart > 0 ? cycleStart : path63.length),
+            ...path64.slice(0, cycleStart > 0 ? cycleStart : path64.length),
             current
           ].join(" \u2192 ");
           errors.push(`Circular alias detected: ${fullChain}`);
           break;
         }
         visited.add(current);
-        path63.push(current);
+        path64.push(current);
         current = currentEntry.aliasOf || "";
       }
     }
@@ -32952,4 +33268,4 @@ ${text}`;
   };
 }
 
-export { package_default, handleAcknowledgeSpecDriftCommand, handleAgentsCommand, handleAnalyzeCommand, handleArchiveCommand, DC_SAFE_TARGETS, dcNormalizeCommand, dcUnwrapWrappers, dcSplitSegments, dcValidateTargets, dcCheckJunctionCreation, dcExtractWindowsCmdTargets, dcExtractPowerShellTargets, normalizeSwarmCommandInput, canonicalCommandKey, formatCommandNotFound, executeSwarmCommand, SWARM_COMMAND_TOOL_COMMANDS, SWARM_COMMAND_TOOL_ALLOWLIST, HUMAN_ONLY_SWARM_COMMANDS, classifySwarmCommandToolUse, classifySwarmCommandChatFallbackUse, detectPosixWrites, detectWindowsWrites, resolveWriteTargets, handleAutoProceedCommand, handleBenchmarkCommand, handleBrainstormCommand, handleCheckpointCommand, handleClarifyCommand, handleCloseCommand, handleCodebaseReviewCommand, handleConcurrencyCommand, handleConfigCommand, handleConsolidateCommand, handleCouncilCommand, handleCurateCommand, handleDarkMatterCommand, handleDeepDiveCommand, handleDeepResearchCommand, getPluginConfigDir, getPluginCachePaths, getPluginLockFilePaths, handleDiagnoseCommand, handleDoctorCommand, handleEvidenceCommand, handleEvidenceSummaryCommand, handleExportCommand, handleFullAutoCommand, handleHandoffCommand, handleHistoryCommand, handleKnowledgeQuarantineCommand, handleKnowledgeRestoreCommand, handleKnowledgeMigrateCommand, handleKnowledgeListCommand, handleKnowledgeUnactionableCommand, handleKnowledgeRetryHardeningCommand, handleLearningCommand, handleLinkCommand, handleMemoryCommand, handleMemoryStatusCommand, handleMemoryMigrateCommand, handleMemoryImportCommand, handleMemoryExportCommand, handlePlanCommand, handlePreflightCommand, handlePromoteCommand, handleQaGatesCommand, handleResetCommand, handleResetSessionCommand, handleRetrieveCommand, handleRollbackCommand, handleSddStatusCommand, handleSddValidateCommand, handleSddProjectCommand, handleSddCommand, handleSimulateCommand, handleSpecifyCommand, handleStatusCommand, handleSyncPlanCommand, handleTurboCommand, handleUnlinkCommand, handleWriteRetroCommand, handleHelpCommand, COMMAND_REGISTRY, VALID_COMMANDS, _internals45 as _internals, resolveCommand };
+export { package_default, handleAcknowledgeSpecDriftCommand, handleAgentsCommand, handleAnalyzeCommand, handleArchiveCommand, DC_SAFE_TARGETS, dcNormalizeCommand, dcUnwrapWrappers, dcSplitSegments, dcValidateTargets, dcCheckJunctionCreation, dcExtractWindowsCmdTargets, dcExtractPowerShellTargets, normalizeSwarmCommandInput, canonicalCommandKey, formatCommandNotFound, executeSwarmCommand, SWARM_COMMAND_TOOL_COMMANDS, SWARM_COMMAND_TOOL_ALLOWLIST, HUMAN_ONLY_SWARM_COMMANDS, classifySwarmCommandToolUse, classifySwarmCommandChatFallbackUse, detectPosixWrites, detectWindowsWrites, resolveWriteTargets, handleAutoProceedCommand, handleBenchmarkCommand, handleBrainstormCommand, handleCheckpointCommand, handleClarifyCommand, handleCloseCommand, handleCodebaseReviewCommand, handleConcurrencyCommand, handleConfigCommand, handleConsolidateCommand, handleCostsCommand, handleCouncilCommand, handleCurateCommand, handleDarkMatterCommand, handleDeepDiveCommand, handleDeepResearchCommand, getPluginConfigDir, getPluginCachePaths, getPluginLockFilePaths, handleDiagnoseCommand, handleDoctorCommand, handleEvidenceCommand, handleEvidenceSummaryCommand, handleExportCommand, handleFullAutoCommand, handleHandoffCommand, handleHistoryCommand, handleKnowledgeQuarantineCommand, handleKnowledgeRestoreCommand, handleKnowledgeMigrateCommand, handleKnowledgeListCommand, handleKnowledgeUnactionableCommand, handleKnowledgeRetryHardeningCommand, handleLearningCommand, handleLinkCommand, handleMemoryCommand, handleMemoryStatusCommand, handleMemoryMigrateCommand, handleMemoryImportCommand, handleMemoryExportCommand, handlePlanCommand, handlePreflightCommand, handlePromoteCommand, handleQaGatesCommand, handleResetCommand, handleResetSessionCommand, handleRetrieveCommand, handleRollbackCommand, handleSddStatusCommand, handleSddValidateCommand, handleSddProjectCommand, handleSddCommand, handleSimulateCommand, handleSpecifyCommand, handleStatusCommand, handleSyncPlanCommand, handleTurboCommand, handleUnlinkCommand, handleWriteRetroCommand, handleHelpCommand, COMMAND_REGISTRY, VALID_COMMANDS, _internals45 as _internals, resolveCommand };