opencode-swarm 7.99.7 → 7.100.1

package/dist/cli/{index-wpnam1jh.js → index-qvdxzjqt.js}

@@ -57,7 +57,7 @@ import {
   readDoctorArtifact,
   removeStraySwarmDir,
   runConfigDoctor
-} from "./index-0d3pmjf9.js";
+} from "./index-rpb763g8.js";
 import {
   AGENT_TOOL_MAP,
   ALL_SUBAGENT_NAMES,
@@ -70,7 +70,7 @@ import {
   TOOL_NAME_SET,
   resolveExternalSkillsConfig,
   stripKnownSwarmPrefix
-} from "./index-7hnwnw5g.js";
+} from "./index-m0qshbr6.js";
 import {
   MAX_TRANSIENT_RETRIES,
   PlanSchema,
@@ -114,7 +114,7 @@ import {
   transientBackoff,
   validateProjectRoot,
   writeProjectedSpecSync
-} from "./index-y3x3gvy6.js";
+} from "./index-3emh7rny.js";
 import {
   _internals as _internals2,
   _internals1 as _internals3,
@@ -909,7 +909,7 @@ var init_executor = __esm(() => {
 // package.json
 var package_default = {
   name: "opencode-swarm",
-  version: "7.99.7",
+  version: "7.100.1",
   description: "Architect-centric agentic swarm plugin for OpenCode - hub-and-spoke orchestration with SME consultation, code generation, and QA review",
   main: "dist/index.js",
   types: "dist/index.d.ts",
@@ -13089,6 +13089,7 @@ var ACTIVE_STATE_TO_CLEAN = [
   "swarm.db-shm",
   "swarm.db-wal"
 ];
+var TERMINAL_STATE_FILES = ["plan.json", "plan-ledger.jsonl"];
 var KNOWLEDGE_FAMILY_ARTIFACTS = new Set([
   "knowledge.jsonl",
   "knowledge-rejected.jsonl"
@@ -13362,7 +13363,7 @@ async function runFinalizeStage(ctx) {
     }
   }
   try {
-    const { CuratorConfigSchema: CCS } = await import("./schema-nz638xc3.js");
+    const { CuratorConfigSchema: CCS } = await import("./schema-n7pd65qq.js");
     const { config: pmLoadedConfig } = _internals20.loadPluginConfigWithMeta(ctx.directory);
     const curatorCfg = CCS.parse(pmLoadedConfig.curator ?? {});
     if (curatorCfg.enabled && curatorCfg.postmortem_enabled) {
@@ -13579,6 +13580,10 @@ async function runCleanStage(ctx) {
       }
       if (!ctx.archivedActiveStateFiles.has(artifact)) {
         const reason = ctx.archiveFailureReasons?.get(artifact);
+        if (TERMINAL_STATE_FILES.includes(artifact)) {
+          ctx.warnings.push(reason ? `${artifact} was not archived (${reason}); removing it anyway to prevent CLOSED-plan resurrection next session \u2014 no archive copy retained.` : `${artifact} was not archived; removing it anyway to prevent CLOSED-plan resurrection next session \u2014 no archive copy retained.`);
+          continue;
+        }
         ctx.warnings.push(reason ? `Preserved ${artifact} because it was not successfully archived: ${reason}.` : `Preserved ${artifact} because it was not successfully archived.`);
         continue;
       }
@@ -13686,6 +13691,20 @@ async function runCleanStage(ctx) {
   if (tmpFilesRemoved > 0) {
     cleanedFiles.push(`${tmpFilesRemoved} .tmp.* file(s)`);
   }
+  for (const terminalFile of TERMINAL_STATE_FILES) {
+    try {
+      await fs13.unlink(path26.join(ctx.swarmDir, terminalFile));
+      if (!cleanedFiles.includes(terminalFile)) {
+        cleanedFiles.push(terminalFile);
+      }
+    } catch (err) {
+      const errno = err?.code;
+      if (errno === "ENOENT") {} else {
+        const reason = err instanceof Error ? err.message : String(err);
+        ctx.warnings.push(`Failed to remove terminal-state file ${terminalFile} [${errno ?? "unknown"}]: ${reason}`);
+      }
+    }
+  }
   clearAllScopes(ctx.directory);
   const contextPath = path26.join(ctx.swarmDir, "context.md");
   const contextContent = [
@@ -16153,6 +16172,15 @@ async function checkKnowledgeHealth(directory) {
 // src/services/diagnose-service.ts
 var { version: version2 } = package_default;
 var sandboxCapabilityProbe = new SandboxCapabilityProbe;
+var REQUIRED_CACHE_GRAMMAR_ASSETS = [
+  "tree-sitter.wasm",
+  "tree-sitter-javascript.wasm",
+  "tree-sitter-typescript.wasm"
+];
+function resolveCachePackageRoot(cachePath) {
+  const nestedPackageRoot = path33.join(cachePath, "node_modules", "opencode-swarm");
+  return existsSync18(nestedPackageRoot) ? nestedPackageRoot : cachePath;
+}
 var _internals24 = {
   detectSandboxCapability: () => sandboxCapabilityProbe.detect(),
   getSandboxExecutor: getExecutor
@@ -16933,14 +16961,21 @@ async function getDiagnoseData(directory) {
         cacheRows.push(`\u2B1C ${cachePath} \u2014 absent`);
         continue;
       }
-      const pkgJsonPath = path33.join(cachePath, "package.json");
+      const packageRoot = resolveCachePackageRoot(cachePath);
+      const cacheLabel = packageRoot === cachePath ? cachePath : `${cachePath} -> ${packageRoot}`;
+      const missingGrammarAssets = REQUIRED_CACHE_GRAMMAR_ASSETS.filter((file) => !existsSync18(path33.join(packageRoot, "dist", "lang", "grammars", file)));
+      const pkgJsonPath = path33.join(packageRoot, "package.json");
       try {
         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}`);
+        if (missingGrammarAssets.length > 0) {
+          cacheRows.push(`\u26A0\uFE0F ${cacheLabel} \u2014 v${installedVersion}, missing grammar assets: ${missingGrammarAssets.join(", ")}; run \`bunx opencode-swarm update\` and restart OpenCode`);
+          continue;
+        }
+        cacheRows.push(`\u2705 ${cacheLabel} \u2014 v${installedVersion}`);
       } catch {
-        cacheRows.push(`\u26A0\uFE0F ${cachePath} \u2014 present (package.json unreadable)`);
+        cacheRows.push(`\u26A0\uFE0F ${cacheLabel} \u2014 present (package.json unreadable)`);
       }
     } catch {
       cacheRows.push(`\u26A0\uFE0F ${cachePath} \u2014 status unknown (read error)`);
@@ -17154,7 +17189,7 @@ async function handleDoctorCommand(directory, args) {
   const result = runConfigDoctor(config, directory);
   let output;
   if (enableAutoFix && result.hasAutoFixableIssues) {
-    const { runConfigDoctorWithFixes } = await import("./config-doctor-1j77p1jy.js");
+    const { runConfigDoctorWithFixes } = await import("./config-doctor-g29kxhek.js");
     const fixResult = await runConfigDoctorWithFixes(directory, config, true);
     output = formatDoctorMarkdown(fixResult.result);
   } else {
@@ -17967,7 +18002,7 @@ async function handleEvidenceCommand(directory, args) {
   return formatTaskEvidenceMarkdown(evidenceData);
 }
 async function handleEvidenceSummaryCommand(directory) {
-  const { buildEvidenceSummary } = await import("./evidence-summary-service-ch74hb16.js");
+  const { buildEvidenceSummary } = await import("./evidence-summary-service-vgw9vw3n.js");
   const artifact = await buildEvidenceSummary(directory);
   if (!artifact) {
     return "No plan found. Run `/swarm plan` to check plan status.";
@@ -20521,7 +20556,7 @@ ${USAGE7}`;
 
 // src/commands/memory.ts
 import { existsSync as existsSync27 } from "fs";
-import * as path48 from "path";
+import * as path50 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/memory/config.ts
@@ -20556,6 +20591,24 @@ var DEFAULT_CONSOLIDATION_CONFIG = {
   autoApplyMinConfidence: 0.6,
   decayHalfLifeDays: { ...DEFAULT_DECAY_HALF_LIFE_DAYS }
 };
+var DEFAULT_EMBEDDINGS_CONFIG = {
+  enabled: false,
+  model: "Xenova/all-MiniLM-L6-v2",
+  dimension: 384,
+  cacheSize: 256
+};
+var DEFAULT_RETRIEVAL_CONFIG = {
+  rrfK: 60,
+  weights: {
+    lexical: 0.5,
+    dense: 0.4,
+    metadata: 0.1
+  },
+  rerank: {
+    enabled: false
+  },
+  latencyBudgetMs: 250
+};
 var DEFAULT_MEMORY_CONFIG = {
   enabled: false,
   provider: "sqlite",
@@ -20592,6 +20645,8 @@ var DEFAULT_MEMORY_CONFIG = {
     ...DEFAULT_CONSOLIDATION_CONFIG,
     decayHalfLifeDays: { ...DEFAULT_DECAY_HALF_LIFE_DAYS }
   },
+  embeddings: { ...DEFAULT_EMBEDDINGS_CONFIG },
+  retrieval: { ...DEFAULT_RETRIEVAL_CONFIG },
   hardDelete: false
 };
 var DURABLE_MEMORY_KINDS = new Set([
@@ -20648,6 +20703,22 @@ function resolveMemoryConfig(input) {
         ...DEFAULT_MEMORY_CONFIG.consolidation.decayHalfLifeDays,
         ...input?.consolidation?.decayHalfLifeDays ?? {}
       }
+    },
+    embeddings: {
+      ...DEFAULT_MEMORY_CONFIG.embeddings,
+      ...input?.embeddings ?? {}
+    },
+    retrieval: {
+      ...DEFAULT_MEMORY_CONFIG.retrieval,
+      ...input?.retrieval ?? {},
+      weights: {
+        ...DEFAULT_MEMORY_CONFIG.retrieval.weights,
+        ...input?.retrieval?.weights ?? {}
+      },
+      rerank: {
+        ...DEFAULT_MEMORY_CONFIG.retrieval.rerank,
+        ...input?.retrieval?.rerank ?? {}
+      }
     }
   };
 }
@@ -20662,8 +20733,8 @@ class MemoryValidationError extends Error {
 }
 // src/memory/evaluation.ts
 import * as fs19 from "fs/promises";
-import * as os10 from "os";
-import * as path46 from "path";
+import * as os12 from "os";
+import * as path48 from "path";
 
 // src/memory/local-jsonl-provider.ts
 import { randomUUID as randomUUID5 } from "crypto";
@@ -21935,18 +22006,372 @@ async function writeJsonlAtomic(filePath, values) {
 
 // src/memory/provider-pool.ts
 import { realpathSync as realpathSync2 } from "fs";
-import * as path45 from "path";
+import * as path47 from "path";
 
 // src/memory/sqlite-provider.ts
 import { randomUUID as randomUUID6 } from "crypto";
+import { mkdirSync as mkdirSync17 } from "fs";
+import { createRequire as createRequire4 } from "module";
+import * as path46 from "path";
+
+// src/memory/embeddings/cache.ts
+var DEFAULT_CACHE_SIZE = 256;
+function normalizeQuery(query) {
+  return query.toLowerCase().trim();
+}
+function compositeKey(modelVersion, normalizedQuery) {
+  return `${modelVersion}\x00${normalizedQuery}`;
+}
+
+class EmbeddingCache {
+  cache;
+  maxSize;
+  constructor(maxSize = DEFAULT_CACHE_SIZE) {
+    this.maxSize = maxSize;
+    this.cache = new Map;
+  }
+  get size() {
+    return this.cache.size;
+  }
+  get(modelVersion, query) {
+    const key = compositeKey(modelVersion, normalizeQuery(query));
+    const entry = this.cache.get(key);
+    if (entry !== undefined) {
+      this.cache.delete(key);
+      this.cache.set(key, entry);
+    }
+    return entry;
+  }
+  set(modelVersion, query, entry) {
+    const key = compositeKey(modelVersion, normalizeQuery(query));
+    if (this.cache.has(key)) {
+      this.cache.delete(key);
+    } else if (this.cache.size >= this.maxSize) {
+      const oldestKey = this.cache.keys().next().value;
+      if (oldestKey !== undefined) {
+        this.cache.delete(oldestKey);
+      }
+    }
+    if (this.cache.size < this.maxSize) {
+      this.cache.set(key, entry);
+    }
+  }
+  has(modelVersion, query) {
+    const key = compositeKey(modelVersion, normalizeQuery(query));
+    return this.cache.has(key);
+  }
+  clear() {
+    this.cache.clear();
+  }
+}
+
+// src/memory/embeddings/fusion.ts
+function fuseRankings(lexicalRankedIds, denseRankedIds, metadataRankedIds, weights, rrfK) {
+  const lexicalRanks = buildRankMap(lexicalRankedIds);
+  const denseRanks = buildRankMap(denseRankedIds);
+  const metadataRanks = buildRankMap(metadataRankedIds);
+  const allIds = new Set;
+  for (const id of lexicalRankedIds)
+    allIds.add(id);
+  for (const id of denseRankedIds)
+    allIds.add(id);
+  for (const id of metadataRankedIds)
+    allIds.add(id);
+  const candidates = [];
+  for (const id of allIds) {
+    const lexicalRank = lexicalRanks.get(id) ?? null;
+    const denseRank = denseRanks.get(id) ?? null;
+    const metadataRank = metadataRanks.get(id) ?? null;
+    const rawScore = (lexicalRank !== null ? weights.lexical * rrfTerm(lexicalRank, rrfK) : 0) + (denseRank !== null ? weights.dense * rrfTerm(denseRank, rrfK) : 0) + (metadataRank !== null ? weights.metadata * rrfTerm(metadataRank, rrfK) : 0);
+    candidates.push({
+      id,
+      fusedScore: rawScore,
+      lexicalRank,
+      denseRank,
+      metadataRank
+    });
+  }
+  return minMaxNormalise(candidates);
+}
+function buildRankMap(rankedIds) {
+  const map = new Map;
+  for (let i = 0;i < rankedIds.length; i++) {
+    map.set(rankedIds[i], i + 1);
+  }
+  return map;
+}
+function rrfTerm(rank, rrfK) {
+  return 1 / (rrfK + rank);
+}
+function minMaxNormalise(candidates) {
+  if (candidates.length === 0)
+    return candidates;
+  let min = Infinity;
+  let max = -Infinity;
+  for (const c of candidates) {
+    if (c.fusedScore < min)
+      min = c.fusedScore;
+    if (c.fusedScore > max)
+      max = c.fusedScore;
+  }
+  const range = max - min;
+  const normalised = [];
+  for (const c of candidates) {
+    const normalisedScore = range === 0 ? 1 : (c.fusedScore - min) / range;
+    normalised.push({
+      ...c,
+      fusedScore: normalisedScore
+    });
+  }
+  normalised.sort((a, b) => b.fusedScore - a.fusedScore || a.id.localeCompare(b.id));
+  return normalised;
+}
+
+// src/memory/embeddings/local-provider.ts
 import { mkdirSync as mkdirSync15 } from "fs";
 import { createRequire as createRequire2 } from "module";
+import * as os10 from "os";
+import * as path43 from "path";
+
+// src/memory/embeddings/types.ts
+class EmbeddingUnavailableError extends Error {
+  constructor(message) {
+    super(message ?? "Embedding provider is unavailable (dependency not installed or model failed to load)");
+    this.name = "EmbeddingUnavailableError";
+  }
+}
+
+class EmbeddingVersionMismatchError extends Error {
+  queryVersion;
+  storedVersion;
+  constructor(queryVersion, storedVersion) {
+    super(`Embedding version mismatch: query uses ${queryVersion} but stored vectors are ${storedVersion}. Rebuild the index or pin the model version.`);
+    this.name = "EmbeddingVersionMismatchError";
+    this.queryVersion = queryVersion;
+    this.storedVersion = storedVersion;
+  }
+}
+
+// src/memory/embeddings/local-provider.ts
+var _internals33 = {
+  resolveEmbeddingCacheDir() {
+    let base;
+    if (process.platform === "win32") {
+      base = process.env.LOCALAPPDATA || path43.join(os10.homedir(), "AppData", "Local");
+    } else if (process.platform === "darwin") {
+      base = path43.join(os10.homedir(), "Library", "Caches");
+    } else {
+      base = process.env.XDG_CACHE_HOME || path43.join(os10.homedir(), ".cache");
+    }
+    const resolved = path43.join(base, "opencode", "embeddings");
+    const segments = resolved.split(path43.sep);
+    if (segments.includes(".swarm")) {
+      const safeDefault = process.platform === "win32" ? path43.join(os10.homedir(), "AppData", "Local", "opencode", "embeddings") : process.platform === "darwin" ? path43.join(os10.homedir(), "Library", "Caches", "opencode", "embeddings") : path43.join(os10.homedir(), ".cache", "opencode", "embeddings");
+      warn("Embedding cache dir resolved under .swarm/ \u2014 falling back to safe default");
+      return safeDefault;
+    }
+    return resolved;
+  }
+};
+function resolveEmbeddingCacheDir() {
+  return _internals33.resolveEmbeddingCacheDir();
+}
+
+class LocalEmbeddingProvider {
+  modelName;
+  dimension;
+  modelVersion;
+  _available = false;
+  loadFailed = false;
+  pipeline = null;
+  static downloadNoticePrinted = false;
+  constructor(config) {
+    this.modelName = config.model;
+    this.dimension = config.dimension;
+    this.modelVersion = config.version ?? `${config.model}:${config.dimension}`;
+  }
+  get available() {
+    return this._available;
+  }
+  async ensurePipeline() {
+    if (this.loadFailed) {
+      return null;
+    }
+    if (this.pipeline)
+      return this.pipeline;
+    try {
+      const req = createRequire2(import.meta.url);
+      const transformers = req("@xenova/transformers");
+      if (!LocalEmbeddingProvider.downloadNoticePrinted) {
+        LocalEmbeddingProvider.downloadNoticePrinted = true;
+        console.log(`[opencode-swarm] Downloading embedding model "${this.modelName}" (~25 MB) \u2014 this happens once per process.`);
+      }
+      const cacheDir2 = resolveEmbeddingCacheDir();
+      mkdirSync15(cacheDir2, { recursive: true });
+      this.pipeline = await transformers.pipeline("feature-extraction", this.modelName, { cache_dir: cacheDir2 });
+      this._available = true;
+      return this.pipeline;
+    } catch (err) {
+      this.loadFailed = true;
+      this._available = false;
+      warn("Local embedding provider unavailable \u2014 falling back to lexical-only", {
+        reason: err instanceof Error ? err.message : String(err)
+      });
+      return null;
+    }
+  }
+  async embed(text) {
+    const pipeline = await this.ensurePipeline();
+    if (!pipeline) {
+      throw new EmbeddingUnavailableError("Embedding provider is unavailable (dependency not installed or model failed to load)");
+    }
+    const result = await pipeline(text, {
+      pooling: "mean",
+      normalize: true
+    });
+    return this.tensorToFloat32Array(result);
+  }
+  async embedBatch(texts) {
+    if (texts.length === 0)
+      return [];
+    const pipeline = await this.ensurePipeline();
+    if (!pipeline) {
+      throw new EmbeddingUnavailableError("Embedding provider is unavailable (dependency not installed or model failed to load)");
+    }
+    const result = await pipeline(texts, {
+      pooling: "mean",
+      normalize: true
+    });
+    if (Array.isArray(result)) {
+      return result.map((t) => this.tensorToFloat32Array(t));
+    }
+    return this.tensorToFloat32ArrayBatch(result);
+  }
+  tensorToFloat32Array(tensor) {
+    if (tensor instanceof Float32Array)
+      return tensor;
+    const obj = tensor;
+    if (obj?.data && obj.data instanceof Float32Array) {
+      return obj.data;
+    }
+    const entries = Object.entries(tensor);
+    for (const [, value] of entries) {
+      if (value instanceof Float32Array)
+        return value;
+    }
+    throw new Error(`Unexpected embedding tensor shape: ${JSON.stringify(tensor)}`);
+  }
+  tensorToFloat32ArrayBatch(tensor) {
+    const obj = tensor;
+    if (obj?.data && obj.data instanceof Float32Array && obj.dims && obj.dims.length >= 2) {
+      const batchSize = obj.dims[0];
+      const dim = obj.dims[1];
+      const result = [];
+      for (let i = 0;i < batchSize; i++) {
+        const offset = i * dim;
+        result.push(obj.data.slice(offset, offset + dim));
+      }
+      return result;
+    }
+    if (Array.isArray(tensor)) {
+      return tensor.map((t) => this.tensorToFloat32Array(t));
+    }
+    throw new Error(`Unexpected batch embedding tensor shape: ${JSON.stringify(tensor)}`);
+  }
+}
+
+// src/memory/embeddings/reranker.ts
+import { mkdirSync as mkdirSync16 } from "fs";
+import { createRequire as createRequire3 } from "module";
+import * as os11 from "os";
 import * as path44 from "path";
+function shouldRerank(previousRecallElapsedMs, latencyBudgetMs) {
+  return previousRecallElapsedMs <= latencyBudgetMs;
+}
+
+class CrossEncoderReranker {
+  options;
+  loadFailed = false;
+  _available = false;
+  pipeline = null;
+  constructor(options) {
+    this.options = options;
+  }
+  get available() {
+    return this._available;
+  }
+  async ensurePipeline() {
+    if (this.loadFailed)
+      return null;
+    if (this.pipeline)
+      return this.pipeline;
+    try {
+      const req = createRequire3(import.meta.url);
+      const transformers = req("@xenova/transformers");
+      const modelName = this.options.model ?? "Xenova/ms-marco-MiniLM-L-6-v2";
+      const cacheDir2 = resolveRerankerCacheDir();
+      mkdirSync16(cacheDir2, { recursive: true });
+      this.pipeline = await transformers.pipeline("text-classification", modelName, { cache_dir: cacheDir2 });
+      this._available = true;
+      return this.pipeline;
+    } catch (err) {
+      this.loadFailed = true;
+      this._available = false;
+      warn("Cross-encoder reranker unavailable \u2014 skipping rerank", {
+        reason: err instanceof Error ? err.message : String(err)
+      });
+      return null;
+    }
+  }
+  async rerank(candidates, query, topN) {
+    if (candidates.length === 0)
+      return candidates;
+    const pipeline = await this.ensurePipeline();
+    if (!pipeline)
+      return candidates;
+    try {
+      const inputs = candidates.map((c) => [query, c.text]);
+      const results = await pipeline(inputs, { truncation: true });
+      const scored = candidates.map((c, idx) => ({
+        ...c,
+        score: results[idx]?.score ?? 0
+      }));
+      scored.sort((a, b) => (b.score ?? 0) - (a.score ?? 0));
+      if (typeof topN === "number" && topN > 0) {
+        return scored.slice(0, topN);
+      }
+      return scored;
+    } catch (err) {
+      warn("Rerank scoring failed \u2014 returning original order", {
+        reason: err instanceof Error ? err.message : String(err)
+      });
+      return candidates;
+    }
+  }
+}
+function resolveRerankerCacheDir() {
+  let base;
+  if (process.platform === "win32") {
+    base = process.env.LOCALAPPDATA || path44.join(os11.homedir(), "AppData", "Local");
+  } else if (process.platform === "darwin") {
+    base = path44.join(os11.homedir(), "Library", "Caches");
+  } else {
+    base = process.env.XDG_CACHE_HOME || path44.join(os11.homedir(), ".cache");
+  }
+  const resolved = path44.join(base, "opencode", "embeddings");
+  const segments = resolved.split(path44.sep);
+  if (segments.includes(".swarm")) {
+    const safeDefault = process.platform === "win32" ? path44.join(os11.homedir(), "AppData", "Local", "opencode", "embeddings") : process.platform === "darwin" ? path44.join(os11.homedir(), "Library", "Caches", "opencode", "embeddings") : path44.join(os11.homedir(), ".cache", "opencode", "embeddings");
+    warn("Reranker cache dir resolved under .swarm/ \u2014 falling back to safe default");
+    return safeDefault;
+  }
+  return resolved;
+}
 
 // src/memory/jsonl-migration.ts
 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 path43 from "path";
+import * as path45 from "path";
 var LEGACY_JSONL_MIGRATION_VERSION = 2;
 var LEGACY_JSONL_MIGRATION_NAME = "legacy_jsonl_import_complete";
 function resolveMemoryStorageDir(rootDirectory, config = {}) {
@@ -21962,8 +22387,8 @@ function resolveSqliteDatabasePath(rootDirectory, config = {}) {
 async function readLegacyJsonl(rootDirectory, config = {}) {
   const resolved = resolveConfig(config);
   const storageDir = resolveMemoryStorageDir(rootDirectory, resolved);
-  const memoryLoad = await readMemoryJsonl(path43.join(storageDir, "memories.jsonl"), resolved);
-  const proposalLoad = await readProposalJsonl(path43.join(storageDir, "proposals.jsonl"), resolved);
+  const memoryLoad = await readMemoryJsonl(path45.join(storageDir, "memories.jsonl"), resolved);
+  const proposalLoad = await readProposalJsonl(path45.join(storageDir, "proposals.jsonl"), resolved);
   return {
     memories: memoryLoad.records,
     proposals: proposalLoad.records,
@@ -21973,14 +22398,14 @@ async function readLegacyJsonl(rootDirectory, config = {}) {
 }
 async function backupLegacyJsonl(rootDirectory, config = {}) {
   const storageDir = resolveMemoryStorageDir(rootDirectory, config);
-  const backupDir = path43.join(storageDir, "backups");
+  const backupDir = path45.join(storageDir, "backups");
   await mkdir11(backupDir, { recursive: true });
   const results = [];
   for (const filename of ["memories.jsonl", "proposals.jsonl"]) {
-    const source = path43.join(storageDir, filename);
+    const source = path45.join(storageDir, filename);
     if (!existsSync26(source))
       continue;
-    const backup = path43.join(backupDir, `${filename}.pre-sqlite-migration`);
+    const backup = path45.join(backupDir, `${filename}.pre-sqlite-migration`);
     if (existsSync26(backup)) {
       results.push({ source, backup, created: false });
       continue;
@@ -21991,11 +22416,11 @@ async function backupLegacyJsonl(rootDirectory, config = {}) {
   return results;
 }
 async function writeJsonlExport(rootDirectory, config, memories, proposals) {
-  const exportDir = path43.join(resolveMemoryStorageDir(rootDirectory, config), "export");
+  const exportDir = path45.join(resolveMemoryStorageDir(rootDirectory, config), "export");
   await mkdir11(exportDir, { recursive: true });
-  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)}`);
+  const memoriesPath = path45.join(exportDir, "memories.jsonl");
+  const proposalsPath = path45.join(exportDir, "proposals.jsonl");
+  const memoriesTempPath = path45.join(path45.dirname(memoriesPath), `${path45.basename(memoriesPath)}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
   try {
     await writeFile11(memoriesTempPath, toJsonl(memories), "utf-8");
     renameSync10(memoriesTempPath, memoriesPath);
@@ -22005,7 +22430,7 @@ async function writeJsonlExport(rootDirectory, config, memories, proposals) {
     } catch {}
     throw err;
   }
-  const proposalsTempPath = path43.join(path43.dirname(proposalsPath), `${path43.basename(proposalsPath)}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+  const proposalsTempPath = path45.join(path45.dirname(proposalsPath), `${path45.basename(proposalsPath)}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
   try {
     await writeFile11(proposalsTempPath, toJsonl(proposals), "utf-8");
     renameSync10(proposalsTempPath, proposalsPath);
@@ -22018,9 +22443,9 @@ async function writeJsonlExport(rootDirectory, config, memories, proposals) {
   return { directory: exportDir, memoriesPath, proposalsPath };
 }
 async function writeMigrationReport(rootDirectory, report, config = {}) {
-  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)}`);
+  const reportPath = path45.join(resolveMemoryStorageDir(rootDirectory, config), "migration-report.json");
+  await mkdir11(path45.dirname(reportPath), { recursive: true });
+  const reportTempPath = path45.join(path45.dirname(reportPath), `${path45.basename(reportPath)}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
   try {
     await writeFile11(reportTempPath, `${JSON.stringify(report, null, 2)}
 `, "utf-8");
@@ -22034,7 +22459,7 @@ async function writeMigrationReport(rootDirectory, report, config = {}) {
   return reportPath;
 }
 async function readMigrationReport(rootDirectory, config = {}) {
-  const reportPath = path43.join(resolveMemoryStorageDir(rootDirectory, config), "migration-report.json");
+  const reportPath = path45.join(resolveMemoryStorageDir(rootDirectory, config), "migration-report.json");
   if (!existsSync26(reportPath))
     return null;
   try {
@@ -22047,7 +22472,7 @@ async function getLegacyJsonlFileStatus(rootDirectory, config = {}) {
   const storageDir = resolveMemoryStorageDir(rootDirectory, config);
   const statuses = [];
   for (const file of ["memories.jsonl", "proposals.jsonl"]) {
-    const filePath = path43.join(storageDir, file);
+    const filePath = path45.join(storageDir, file);
     let sizeBytes = 0;
     if (existsSync26(filePath)) {
       sizeBytes = (await stat5(filePath)).size;
@@ -22171,7 +22596,7 @@ var _DatabaseCtor2 = null;
 function loadDatabaseCtor2() {
   if (_DatabaseCtor2)
     return _DatabaseCtor2;
-  const req = createRequire2(import.meta.url);
+  const req = createRequire4(import.meta.url);
   _DatabaseCtor2 = req("bun:sqlite").Database;
   return _DatabaseCtor2;
 }
@@ -22291,6 +22716,16 @@ var MIGRATIONS2 = [
 			CREATE INDEX IF NOT EXISTS idx_memory_recall_usage_timestamp
 				ON memory_recall_usage(timestamp DESC);
 		`
+  },
+  {
+    version: 6,
+    name: "create_embedding_config_table",
+    sql: `
+			CREATE TABLE IF NOT EXISTS embedding_config (
+				key TEXT PRIMARY KEY,
+				value TEXT
+			);
+		`
   }
 ];
 
@@ -22302,6 +22737,10 @@ class SQLiteMemoryProvider {
   initPromise = null;
   db = null;
   ftsAvailable = false;
+  vecAvailable = false;
+  embeddingProvider = null;
+  embeddingCache = null;
+  reranker = null;
   memories = new Map;
   proposals = new Map;
   lastAutomaticJsonlMigration = null;
@@ -22355,7 +22794,7 @@ class SQLiteMemoryProvider {
   }
   async doInitialize() {
     const dbPath = this.databasePath();
-    mkdirSync15(path44.dirname(dbPath), { recursive: true });
+    mkdirSync17(path46.dirname(dbPath), { recursive: true });
     const Db = loadDatabaseCtor2();
     this.db = new Db(dbPath);
     this.db.run("PRAGMA journal_mode = WAL;");
@@ -22366,6 +22805,29 @@ class SQLiteMemoryProvider {
     this.runMigrations();
     this.backfillScopeKeys();
     this.ftsAvailable = this.initializeFtsIndex();
+    this.initializeVecExtension();
+    if (this.config.embeddings.enabled && !this.embeddingProvider) {
+      try {
+        this.embeddingProvider = new LocalEmbeddingProvider({
+          model: this.config.embeddings.model,
+          dimension: this.config.embeddings.dimension,
+          version: this.config.embeddings.version
+        });
+      } catch (err) {
+        this.embeddingProvider = null;
+        warn("Failed to construct embedding provider \u2014 dense retrieval disabled", {
+          reason: err instanceof Error ? err.message : String(err)
+        });
+      }
+      try {
+        this.embeddingCache = new EmbeddingCache(this.config.embeddings.cacheSize);
+      } catch (err) {
+        this.embeddingCache = null;
+        warn("Failed to construct embedding cache \u2014 recall works without cache", {
+          reason: err instanceof Error ? err.message : String(err)
+        });
+      }
+    }
     this.lastAutomaticJsonlMigration = null;
     await this.migrateLegacyJsonlIfNeeded();
     const memoryLoad = this.loadMemories();
@@ -22392,6 +22854,7 @@ class SQLiteMemoryProvider {
     }, { rejectDurableSecrets: this.config.redaction.rejectDurableSecrets });
     this.memories.set(next.id, next);
     this.writeMemory(next);
+    await this.writeMemoryVec(next);
     await this.event("upsert", next.id);
     return next;
   }
@@ -22408,6 +22871,7 @@ class SQLiteMemoryProvider {
       this.memories.delete(id);
       this.requireDb().run("DELETE FROM memory_items WHERE id = ?", [id]);
       this.deleteMemoryFts(id);
+      this.deleteMemoryVec(id);
     } else {
       const tombstone = {
         ...existing,
@@ -22424,20 +22888,139 @@ class SQLiteMemoryProvider {
   }
   async recallWithDiagnostics(request) {
     await this.initialize();
+    if (!this.config.embeddings.enabled || !this.vecAvailable || !this.embeddingProvider) {
+      const scopedRecords2 = await this.list({
+        scopes: request.scopes,
+        kinds: request.kinds,
+        includeExpired: request.includeExpired,
+        limit: RECALL_CANDIDATE_LIMIT
+      });
+      const candidates = this.selectRecallCandidates(request, scopedRecords2);
+      const result = scoreMemoryRecordsWithDiagnostics(candidates.records, request);
+      const reranked = candidates.ftsOrder ? rerankWithFts(result.items, candidates.ftsOrder) : result.items;
+      return {
+        items: reranked.slice(0, request.maxItems),
+        diagnostics: {
+          ...result.diagnostics,
+          returnedCount: Math.min(reranked.length, request.maxItems)
+        }
+      };
+    }
+    const recallElapsedStart = Date.now();
     const scopedRecords = await this.list({
       scopes: request.scopes,
       kinds: request.kinds,
       includeExpired: request.includeExpired,
       limit: RECALL_CANDIDATE_LIMIT
     });
-    const candidates = this.selectRecallCandidates(request, scopedRecords);
-    const result = scoreMemoryRecordsWithDiagnostics(candidates.records, request);
-    const reranked = candidates.ftsOrder ? rerankWithFts(result.items, candidates.ftsOrder) : result.items;
+    const lexicalCandidates = this.selectRecallCandidates(request, scopedRecords);
+    const lexicalResult = scoreMemoryRecordsWithDiagnostics(lexicalCandidates.records, request);
+    const lexicalReranked = lexicalCandidates.ftsOrder ? rerankWithFts(lexicalResult.items, lexicalCandidates.ftsOrder) : lexicalResult.items;
+    const lexicalIds = lexicalReranked.map((item) => item.record.id);
+    let denseIds = [];
+    try {
+      const modelVersion = this.embeddingProvider.modelVersion;
+      const normalizedQuery = normalizeMemoryText(request.query).toLowerCase();
+      let queryEmbedding = this.embeddingCache?.get(modelVersion, normalizedQuery)?.vector ?? null;
+      if (queryEmbedding === null) {
+        queryEmbedding = await this.embeddingProvider.embed(normalizedQuery);
+        this.embeddingCache?.set(modelVersion, normalizedQuery, {
+          vector: queryEmbedding,
+          modelVersion,
+          queryHash: normalizedQuery
+        });
+      }
+      const denseRecords = await this.selectDenseCandidates(request, queryEmbedding);
+      denseIds = denseRecords.map((record) => record.id);
+    } catch (err) {
+      if (err instanceof EmbeddingVersionMismatchError || err instanceof EmbeddingUnavailableError) {
+        warn("Dense retrieval failed \u2014 falling back to lexical-only", {
+          reason: err instanceof Error ? err.message : String(err)
+        });
+      } else {
+        warn("Dense retrieval failed \u2014 falling back to lexical-only", {
+          reason: err instanceof Error ? err.message : String(err)
+        });
+      }
+      return {
+        items: lexicalReranked.slice(0, request.maxItems),
+        diagnostics: {
+          ...lexicalResult.diagnostics,
+          returnedCount: Math.min(lexicalReranked.length, request.maxItems)
+        }
+      };
+    }
+    const metadataIds = buildMetadataRankedIds(lexicalReranked, request);
+    const weights = this.config.retrieval.weights;
+    const rrfK = this.config.retrieval.rrfK;
+    const fused = fuseRankings(lexicalIds, denseIds, metadataIds, weights, rrfK);
+    const lexicalItemMap = new Map(lexicalReranked.map((item) => [item.record.id, item]));
+    const minScore = request.minScore ?? this.config.recall.minScore;
+    const fusedItems = [];
+    for (const candidate of fused) {
+      if (candidate.fusedScore < minScore)
+        continue;
+      const lexicalItem = lexicalItemMap.get(candidate.id);
+      if (lexicalItem) {
+        fusedItems.push({
+          record: lexicalItem.record,
+          score: candidate.fusedScore,
+          reason: `${lexicalItem.reason}, rrf_fused=${candidate.fusedScore.toFixed(4)}`,
+          signals: lexicalItem.signals
+        });
+      } else {
+        const record = this.memories.get(candidate.id);
+        if (record) {
+          fusedItems.push({
+            record,
+            score: candidate.fusedScore,
+            reason: `rrf_fused=${candidate.fusedScore.toFixed(4)}`,
+            signals: {
+              textOverlap: 0,
+              tagOverlap: 0,
+              fileOverlap: 0,
+              symbolOverlap: 0,
+              kindMatch: false,
+              scopeMatch: false
+            }
+          });
+        }
+      }
+    }
+    const previousRecallElapsedMs = Date.now() - recallElapsedStart;
+    let rerankedItems = fusedItems;
+    if (this.config.retrieval.rerank.enabled && shouldRerank(previousRecallElapsedMs, this.config.retrieval.latencyBudgetMs)) {
+      try {
+        if (!this.reranker) {
+          this.reranker = new CrossEncoderReranker({
+            model: this.config.retrieval.rerank.model
+          });
+        }
+        const topN = Math.min(20, fusedItems.length);
+        const rerankCandidates = fusedItems.slice(0, topN).map((item) => ({
+          id: item.record.id,
+          text: item.record.text,
+          score: item.score
+        }));
+        const rerankResult = await this.reranker.rerank(rerankCandidates, request.query, topN);
+        const topNPrefix = fusedItems.slice(0, topN);
+        const tail = fusedItems.slice(topN);
+        const rerankOrder = new Map(rerankResult.map((c, idx) => [c.id, idx]));
+        const reorderedTopN = [...topNPrefix].sort((a, b) => (rerankOrder.get(a.record.id) ?? 0) - (rerankOrder.get(b.record.id) ?? 0));
+        rerankedItems = [...reorderedTopN, ...tail];
+      } catch (err) {
+        warn("Rerank failed \u2014 returning fused order", {
+          reason: err instanceof Error ? err.message : String(err)
+        });
+        rerankedItems = fusedItems;
+      }
+    }
     return {
-      items: reranked.slice(0, request.maxItems),
+      items: rerankedItems.slice(0, request.maxItems),
       diagnostics: {
-        ...result.diagnostics,
-        returnedCount: Math.min(reranked.length, request.maxItems)
+        ...lexicalResult.diagnostics,
+        returnedCount: Math.min(rerankedItems.length, request.maxItems),
+        fusionActive: true
       }
     };
   }
@@ -22594,6 +23177,11 @@ class SQLiteMemoryProvider {
     for (const memory of result.memories) {
       this.memories.set(memory.id, memory);
     }
+    for (const memory of result.memories) {
+      if (memory.metadata.deleted !== true) {
+        await this.writeMemoryVec(memory);
+      }
+    }
     return result.change;
   }
   close() {
@@ -22606,6 +23194,46 @@ class SQLiteMemoryProvider {
     this.initPromise = null;
     this.lastAutomaticJsonlMigration = null;
   }
+  async rebuildEmbeddingIndex() {
+    await this.initialize();
+    if (!this.vecAvailable || !this.embeddingProvider) {
+      warn("rebuildEmbeddingIndex skipped \u2014 sqlite-vec or embedding provider not available");
+      return;
+    }
+    const currentVersion = this.embeddingProvider.modelVersion;
+    const durableRecords = Array.from(this.memories.values()).filter((record) => DURABLE_MEMORY_KINDS.has(record.kind) && record.metadata.deleted !== true && record.supersededBy === undefined && record.stability !== "ephemeral");
+    let successCount = 0;
+    let failureCount = 0;
+    const db = this.requireDb();
+    for (const record of durableRecords) {
+      try {
+        const normalizedText = normalizeMemoryText(record.text).toLowerCase();
+        if (normalizedText.length === 0)
+          continue;
+        const vector = await this.embeddingProvider.embed(normalizedText);
+        db.run("INSERT OR REPLACE INTO memory_items_vec (id, embedding) VALUES (?, ?)", [record.id, vector]);
+        successCount++;
+      } catch (err) {
+        const reason = err instanceof Error ? err.message : String(err);
+        warn("rebuildEmbeddingIndex: failed to embed record", {
+          id: record.id,
+          reason
+        });
+        failureCount++;
+      }
+    }
+    if (failureCount === 0) {
+      db.run("INSERT OR REPLACE INTO embedding_config (key, value) VALUES (?, ?)", ["model_version", currentVersion]);
+    }
+    this.embeddingCache?.clear();
+    if (failureCount > 0) {
+      warn("rebuildEmbeddingIndex completed with failures", {
+        successCount,
+        failureCount,
+        total: durableRecords.length
+      });
+    }
+  }
   async importJsonl() {
     const wasInitialized = this.initialized;
     await this.initialize();
@@ -22664,6 +23292,7 @@ class SQLiteMemoryProvider {
       for (const id of removeIds) {
         db.run("DELETE FROM memory_items WHERE id = ?", [id]);
         this.deleteMemoryFts(id);
+        this.deleteMemoryVec(id);
       }
       this.insertEvent("compact", "memory_items", "removed deleted, superseded, and expired scratch memories", JSON.stringify(result));
     });
@@ -22710,6 +23339,52 @@ class SQLiteMemoryProvider {
       return { records: scopedRecords, usedFts: false };
     }
   }
+  getStoredModelVersion() {
+    const row = this.requireDb().query(`SELECT value FROM embedding_config WHERE key = 'model_version' LIMIT 1`).get("model_version");
+    return row?.value ?? null;
+  }
+  async selectDenseCandidates(request, queryEmbedding) {
+    if (!this.config.embeddings.enabled || !this.vecAvailable || !this.embeddingProvider) {
+      return [];
+    }
+    const storedVersion = this.getStoredModelVersion();
+    const queryVersion = this.embeddingProvider.modelVersion;
+    if (storedVersion !== null && storedVersion !== queryVersion) {
+      throw new EmbeddingVersionMismatchError(queryVersion, storedVersion);
+    }
+    const k = Math.max(100, request.maxItems * 20);
+    const rows = this.requireDb().query(`SELECT id, distance FROM memory_items_vec WHERE embedding MATCH ? ORDER BY distance LIMIT ?`).all(queryEmbedding, k);
+    const scopeKeys = request.scopes?.map((s) => stableScopeKey(s)) ?? [];
+    const kinds = request.kinds ?? [];
+    const includeInactive = false;
+    const includeExpired = request.includeExpired ?? false;
+    const allowedIds = new Set;
+    for (const record of this.memories.values()) {
+      if (scopeKeys.length > 0 && !scopeKeys.includes(stableScopeKey(record.scope)))
+        continue;
+      if (kinds.length > 0 && !kinds.includes(record.kind))
+        continue;
+      if (!includeInactive && record.supersededBy)
+        continue;
+      if (!includeInactive && record.metadata.deleted === true)
+        continue;
+      if (!includeExpired && record.expiresAt) {
+        const expires = Date.parse(record.expiresAt);
+        if (Number.isFinite(expires) && expires <= Date.now())
+          continue;
+      }
+      allowedIds.add(record.id);
+    }
+    const results = [];
+    for (const row of rows) {
+      if (!allowedIds.has(row.id))
+        continue;
+      const record = this.memories.get(row.id);
+      if (record)
+        results.push(record);
+    }
+    return results;
+  }
   runMigrations() {
     const db = this.requireDb();
     db.run(`CREATE TABLE IF NOT EXISTS schema_migrations (
@@ -22782,6 +23457,26 @@ class SQLiteMemoryProvider {
       return false;
     }
   }
+  initializeVecExtension() {
+    const db = this.requireDb();
+    try {
+      const dimension = Math.max(1, Math.trunc(this.config.embeddings.dimension ?? 384));
+      const req = createRequire4(import.meta.url);
+      const pkgDir = path46.dirname(req.resolve("@sqlite/sqlite-vec/package.json"));
+      const ext = process.platform === "win32" ? ".dll" : process.platform === "darwin" ? ".dylib" : ".so";
+      const vec0Path = path46.join(pkgDir, `vec0${ext}`);
+      db.loadExtension(vec0Path);
+      db.run(`CREATE VIRTUAL TABLE IF NOT EXISTS memory_items_vec USING vec0(
+				id TEXT PRIMARY KEY, embedding FLOAT[${dimension}]
+			)`);
+      const modelVersion = this.config.embeddings.version ?? `${this.config.embeddings.model}:${dimension}`;
+      db.run("INSERT OR IGNORE INTO embedding_config (key, value) VALUES (?, ?)", ["model_version", modelVersion]);
+      this.vecAvailable = true;
+    } catch (err) {
+      this.vecAvailable = false;
+      warn("sqlite-vec extension not available \u2014 dense retrieval disabled", err);
+    }
+  }
   recreateFtsIndex() {
     const db = this.requireDb();
     const recreate = db.transaction(() => {
@@ -22893,6 +23588,34 @@ class SQLiteMemoryProvider {
       this.ftsAvailable = false;
     }
   }
+  async writeMemoryVec(record) {
+    if (!this.config.embeddings.enabled)
+      return;
+    if (!this.vecAvailable)
+      return;
+    if (!this.embeddingProvider)
+      return;
+    if (!DURABLE_MEMORY_KINDS.has(record.kind))
+      return;
+    if (record.stability === "ephemeral")
+      return;
+    const normalizedText = normalizeMemoryText(record.text).toLowerCase();
+    if (normalizedText.length === 0)
+      return;
+    try {
+      const vector = await this.embeddingProvider.embed(normalizedText);
+      this.requireDb().run("INSERT OR REPLACE INTO memory_items_vec (id, embedding) VALUES (?, ?)", [record.id, vector]);
+    } catch (err) {
+      const reason = err instanceof Error ? err.message : String(err);
+      if (err instanceof EmbeddingUnavailableError) {
+        warn("Embedding provider unavailable during write \u2014 skipping vector", {
+          reason
+        });
+      } else {
+        warn("Embedding computation failed \u2014 skipping vector", { reason });
+      }
+    }
+  }
   deleteMemoryFts(id) {
     if (!this.ftsAvailable)
       return;
@@ -22902,6 +23625,13 @@ class SQLiteMemoryProvider {
       this.ftsAvailable = false;
     }
   }
+  deleteMemoryVec(id) {
+    if (!this.vecAvailable)
+      return;
+    try {
+      this.requireDb().run("DELETE FROM memory_items_vec WHERE id = ?", [id]);
+    } catch {}
+  }
   writeProposal(proposal) {
     this.requireDb().run(`INSERT OR REPLACE INTO memory_proposals (
 				id,
@@ -23245,6 +23975,29 @@ function rerankWithFts(items, ftsOrder) {
     };
   }).sort((a, b) => b.score - a.score || a.record.id.localeCompare(b.record.id));
 }
+function buildMetadataRankedIds(lexicalItems, request) {
+  const scopeKeys = request.scopes?.map((s) => stableScopeKey(s)) ?? [];
+  const kinds = new Set(request.kinds ?? []);
+  const hasScopeFilter = scopeKeys.length > 0;
+  const hasKindFilter = kinds.size > 0;
+  const both = [];
+  const scopeOnly = [];
+  const kindOnly = [];
+  const neither = [];
+  for (const item of lexicalItems) {
+    const scopeMatch = !hasScopeFilter || scopeKeys.includes(stableScopeKey(item.record.scope));
+    const kindMatch = !hasKindFilter || kinds.has(item.record.kind);
+    if (scopeMatch && kindMatch)
+      both.push(item.record.id);
+    else if (scopeMatch)
+      scopeOnly.push(item.record.id);
+    else if (kindMatch)
+      kindOnly.push(item.record.id);
+    else
+      neither.push(item.record.id);
+  }
+  return [...both, ...scopeOnly, ...kindOnly, ...neither];
+}
 
 // src/memory/provider-pool.ts
 var MAX_POOL_SIZE = 16;
@@ -23384,7 +24137,7 @@ function resolvePoolKey(directory) {
   try {
     return realpathSync2(directory);
   } catch {
-    return path45.resolve(directory);
+    return path47.resolve(directory);
   }
 }
 
@@ -23456,7 +24209,7 @@ var DEFAULT_MODES = [
 ];
 var DEFAULT_TIMESTAMP = "2026-05-26T12:00:00.000Z";
 async function evaluateMemoryRecallFixtures(options) {
-  const fixtureDirectory = path46.resolve(options.fixtureDirectory);
+  const fixtureDirectory = path48.resolve(options.fixtureDirectory);
   const providers = options.providers ?? DEFAULT_PROVIDERS;
   const modes = options.modes ?? DEFAULT_MODES;
   const generatedAt = new Date().toISOString();
@@ -23465,7 +24218,7 @@ async function evaluateMemoryRecallFixtures(options) {
   for (const fixture of fixtures) {
     const materialized = materializeFixture(fixture);
     for (const providerName of providers) {
-      const tempRoot = await fs19.realpath(await fs19.mkdtemp(path46.join(os10.tmpdir(), "swarm-memory-eval-")));
+      const tempRoot = await fs19.realpath(await fs19.mkdtemp(path48.join(os12.tmpdir(), "swarm-memory-eval-")));
       const provider = createEvaluationProvider(providerName, tempRoot);
       try {
         await provider.initialize?.();
@@ -23509,7 +24262,7 @@ async function loadRecallEvaluationFixtures(fixtureDirectory) {
   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 fs19.readFile(path46.join(fixtureDirectory, file), "utf-8");
+    const raw = await fs19.readFile(path48.join(fixtureDirectory, file), "utf-8");
     fixtures.push(validateFixture(JSON.parse(raw), file));
   }
   return fixtures;
@@ -23786,8 +24539,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 path47 from "path";
-var LOG_RELATIVE_PATH = path47.join("memory", "consolidation-log.jsonl");
+import * as path49 from "path";
+var LOG_RELATIVE_PATH = path49.join("memory", "consolidation-log.jsonl");
 async function readConsolidationLog(directory) {
   const filePath = validateSwarmPath(directory, LOG_RELATIVE_PATH);
   let raw;
@@ -23810,7 +24563,7 @@ async function readConsolidationLog(directory) {
 }
 
 // src/commands/memory.ts
-var PACKAGE_ROOT = path48.resolve(resolvePackageRootFromModule(fileURLToPath2(import.meta.url)));
+var PACKAGE_ROOT = path50.resolve(resolvePackageRootFromModule(fileURLToPath2(import.meta.url)));
 async function handleMemoryCommand(_directory, _args) {
   return [
     "## Swarm Memory",
@@ -24108,7 +24861,7 @@ function resolveCommandMemoryConfig(directory) {
 }
 function parseEvaluateArgs(directory, args) {
   let json = false;
-  let fixtureDirectory = path48.join(PACKAGE_ROOT, "tests", "fixtures", "memory-recall");
+  let fixtureDirectory = path50.join(PACKAGE_ROOT, "tests", "fixtures", "memory-recall");
   for (let i = 0;i < args.length; i++) {
     const arg = args[i];
     if (arg === "--json") {
@@ -24122,10 +24875,10 @@ function parseEvaluateArgs(directory, args) {
           error: "Usage: /swarm memory evaluate [--json] [--fixtures <directory>]"
         };
       }
-      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;
+      const resolvedFixtures = path50.resolve(directory, next);
+      const canonical = path50.normalize(resolvedFixtures) + path50.sep;
+      const allowedRootA = path50.normalize(directory) + path50.sep;
+      const allowedRootB = path50.normalize(path50.join(PACKAGE_ROOT, "tests", "fixtures", "memory-recall")) + path50.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"
@@ -24164,15 +24917,15 @@ function parseMaintenanceArgs(args, options) {
   return { limit, confirm };
 }
 function resolvePackageRootFromModule(modulePath) {
-  const moduleDir = path48.dirname(modulePath);
-  const leaf = path48.basename(moduleDir);
+  const moduleDir = path50.dirname(modulePath);
+  const leaf = path50.basename(moduleDir);
   if (leaf === "commands" || leaf === "cli") {
-    return path48.resolve(moduleDir, "..", "..");
+    return path50.resolve(moduleDir, "..", "..");
   }
   if (leaf === "dist") {
-    return path48.resolve(moduleDir, "..");
+    return path50.resolve(moduleDir, "..");
   }
-  return path48.resolve(moduleDir, "..");
+  return path50.resolve(moduleDir, "..");
 }
 function formatMigrationResult(label, report) {
   if (!report) {
@@ -24289,15 +25042,15 @@ function truncate(value, maxLength) {
 }
 
 // src/services/plan-service.ts
-var _internals33 = {
+var _internals34 = {
   loadPlanJsonOnly,
   derivePlanMarkdown,
   readSwarmFileAsync
 };
 async function getPlanData(directory, phaseArg) {
-  const plan = await _internals33.loadPlanJsonOnly(directory);
+  const plan = await _internals34.loadPlanJsonOnly(directory);
   if (plan) {
-    const fullMarkdown = _internals33.derivePlanMarkdown(plan);
+    const fullMarkdown = _internals34.derivePlanMarkdown(plan);
     if (phaseArg === undefined || phaseArg === null || phaseArg === "") {
       return {
         hasPlan: true,
@@ -24340,7 +25093,7 @@ async function getPlanData(directory, phaseArg) {
       isLegacy: false
     };
   }
-  const planContent = await _internals33.readSwarmFileAsync(directory, "plan.md");
+  const planContent = await _internals34.readSwarmFileAsync(directory, "plan.md");
   if (!planContent) {
     return {
       hasPlan: false,
@@ -24437,7 +25190,7 @@ async function handlePlanCommand(directory, args) {
   return formatPlanMarkdown(planData);
 }
 // src/commands/post-mortem.ts
-var _internals34 = {
+var _internals35 = {
   createCuratorLLMDelegate,
   runCuratorPostMortem
 };
@@ -24449,10 +25202,10 @@ async function handlePostMortemCommand(directory, args, options) {
     };
     if (options?.sessionID) {
       try {
-        pmOptions.llmDelegate = _internals34.createCuratorLLMDelegate(directory, "postmortem", options.sessionID);
+        pmOptions.llmDelegate = _internals35.createCuratorLLMDelegate(directory, "postmortem", options.sessionID);
       } catch {}
     }
-    const result = await _internals34.runCuratorPostMortem(directory, pmOptions);
+    const result = await _internals35.runCuratorPostMortem(directory, pmOptions);
     const lines = [];
     if (result.success) {
       lines.push("## Post-Mortem Report Generated");
@@ -24607,12 +25360,12 @@ function formatRelativeTime(epochMs) {
   const diffDays = Math.floor(diffHours / 24);
   return `${diffDays} day${diffDays === 1 ? "" : "s"} ago`;
 }
-var _internals35 = {
+var _internals36 = {
   formatRelativeTime,
   listActive
 };
 async function handlePrMonitorStatusCommand(directory, _args, sessionID, source) {
-  const allActive = await _internals35.listActive(directory);
+  const allActive = await _internals36.listActive(directory);
   const allSessions = source === "cli";
   const subs = allSessions ? allActive : allActive.filter((record) => record.sessionID === sessionID);
   if (subs.length === 0) {
@@ -24750,7 +25503,7 @@ async function handlePrSubscribeCommand(directory, args, sessionID) {
   const repoFullName = `${prInfo.owner}/${prInfo.repo}`;
   const prUrl = `https://github.com/${prInfo.owner}/${prInfo.repo}/pull/${prInfo.number}`;
   try {
-    const config = _internals36.loadPluginConfig(directory);
+    const config = _internals37.loadPluginConfig(directory);
     const prMonitorConfig = config.pr_monitor;
     if (!prMonitorConfig?.enabled) {
       return [
@@ -24760,7 +25513,7 @@ async function handlePrSubscribeCommand(directory, args, sessionID) {
       ].join(`
 `);
     }
-    await _internals36.subscribe(directory, {
+    await _internals37.subscribe(directory, {
       sessionID,
       prNumber: prInfo.number,
       repoFullName,
@@ -24784,7 +25537,7 @@ async function handlePrSubscribeCommand(directory, args, sessionID) {
 `);
   }
 }
-var _internals36 = {
+var _internals37 = {
   loadPluginConfig,
   subscribe
 };
@@ -24807,9 +25560,9 @@ async function handlePrUnsubscribeCommand(directory, args, sessionID) {
 `);
   }
   const refToken = rest[0];
-  const prInfo = _internals37.parsePrRef(refToken, directory);
+  const prInfo = _internals38.parsePrRef(refToken, directory);
   if (!prInfo) {
-    if (_internals37.looksLikePrRef(refToken)) {
+    if (_internals38.looksLikePrRef(refToken)) {
       return [
         `Error: Could not resolve PR reference from "${refToken}".`,
         "",
@@ -24830,8 +25583,8 @@ async function handlePrUnsubscribeCommand(directory, args, sessionID) {
   const repoFullName = `${prInfo.owner}/${prInfo.repo}`;
   const prUrl = `https://github.com/${prInfo.owner}/${prInfo.repo}/pull/${prInfo.number}`;
   try {
-    const correlationId = _internals37.buildCorrelationId(sessionID, repoFullName, prInfo.number);
-    const result = await _internals37.unsubscribe(directory, correlationId);
+    const correlationId = _internals38.buildCorrelationId(sessionID, repoFullName, prInfo.number);
+    const result = await _internals38.unsubscribe(directory, correlationId);
     if (!result) {
       return [
         `Not subscribed to ${prUrl}`,
@@ -24858,7 +25611,7 @@ async function handlePrUnsubscribeCommand(directory, args, sessionID) {
 `);
   }
 }
-var _internals37 = {
+var _internals38 = {
   unsubscribe,
   buildCorrelationId,
   parsePrRef,
@@ -24867,11 +25620,11 @@ var _internals37 = {
 
 // src/services/preflight-service.ts
 import * as fs26 from "fs";
-import * as path55 from "path";
+import * as path57 from "path";
 
 // src/tools/lint.ts
 import * as fs20 from "fs";
-import * as path49 from "path";
+import * as path51 from "path";
 
 // src/utils/path-security.ts
 function containsPathTraversal(str) {
@@ -24927,9 +25680,9 @@ function validateArgs(args) {
 }
 function getLinterCommand(linter, mode, projectDir) {
   const isWindows = process.platform === "win32";
-  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");
+  const binDir = path51.join(projectDir, "node_modules", ".bin");
+  const biomeBin = isWindows ? path51.join(binDir, "biome.EXE") : path51.join(binDir, "biome");
+  const eslintBin = isWindows ? path51.join(binDir, "eslint.cmd") : path51.join(binDir, "eslint");
   switch (linter) {
     case "biome":
       if (mode === "fix") {
@@ -24945,7 +25698,7 @@ function getLinterCommand(linter, mode, projectDir) {
 }
 function getAdditionalLinterCommand(linter, mode, cwd) {
   const gradlewName = process.platform === "win32" ? "gradlew.bat" : "gradlew";
-  const gradlew = fs20.existsSync(path49.join(cwd, gradlewName)) ? path49.join(cwd, gradlewName) : null;
+  const gradlew = fs20.existsSync(path51.join(cwd, gradlewName)) ? path51.join(cwd, gradlewName) : null;
   switch (linter) {
     case "ruff":
       return mode === "fix" ? ["ruff", "check", "--fix", "."] : ["ruff", "check", "."];
@@ -24979,10 +25732,10 @@ function getAdditionalLinterCommand(linter, mode, cwd) {
   }
 }
 function detectRuff(cwd) {
-  if (fs20.existsSync(path49.join(cwd, "ruff.toml")))
+  if (fs20.existsSync(path51.join(cwd, "ruff.toml")))
     return isCommandAvailable("ruff");
   try {
-    const pyproject = path49.join(cwd, "pyproject.toml");
+    const pyproject = path51.join(cwd, "pyproject.toml");
     if (fs20.existsSync(pyproject)) {
       const content = fs20.readFileSync(pyproject, "utf-8");
       if (content.includes("[tool.ruff]"))
@@ -24992,19 +25745,19 @@ function detectRuff(cwd) {
   return false;
 }
 function detectClippy(cwd) {
-  return fs20.existsSync(path49.join(cwd, "Cargo.toml")) && isCommandAvailable("cargo");
+  return fs20.existsSync(path51.join(cwd, "Cargo.toml")) && isCommandAvailable("cargo");
 }
 function detectGolangciLint(cwd) {
-  return fs20.existsSync(path49.join(cwd, "go.mod")) && isCommandAvailable("golangci-lint");
+  return fs20.existsSync(path51.join(cwd, "go.mod")) && isCommandAvailable("golangci-lint");
 }
 function detectCheckstyle(cwd) {
-  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"));
+  const hasMaven = fs20.existsSync(path51.join(cwd, "pom.xml"));
+  const hasGradle = fs20.existsSync(path51.join(cwd, "build.gradle")) || fs20.existsSync(path51.join(cwd, "build.gradle.kts"));
+  const hasBinary = hasMaven && isCommandAvailable("mvn") || hasGradle && (fs20.existsSync(path51.join(cwd, "gradlew")) || isCommandAvailable("gradle"));
   return (hasMaven || hasGradle) && hasBinary;
 }
 function detectKtlint(cwd) {
-  const hasKotlin = fs20.existsSync(path49.join(cwd, "build.gradle.kts")) || fs20.existsSync(path49.join(cwd, "build.gradle")) || (() => {
+  const hasKotlin = fs20.existsSync(path51.join(cwd, "build.gradle.kts")) || fs20.existsSync(path51.join(cwd, "build.gradle")) || (() => {
     try {
       return fs20.readdirSync(cwd).some((f) => f.endsWith(".kt") || f.endsWith(".kts"));
     } catch {
@@ -25023,11 +25776,11 @@ function detectDotnetFormat(cwd) {
   }
 }
 function detectCppcheck(cwd) {
-  if (fs20.existsSync(path49.join(cwd, "CMakeLists.txt"))) {
+  if (fs20.existsSync(path51.join(cwd, "CMakeLists.txt"))) {
     return isCommandAvailable("cppcheck");
   }
   try {
-    const dirsToCheck = [cwd, path49.join(cwd, "src")];
+    const dirsToCheck = [cwd, path51.join(cwd, "src")];
     const hasCpp = dirsToCheck.some((dir) => {
       try {
         return fs20.readdirSync(dir).some((f) => /\.(c|cpp|cc|cxx|h|hpp)$/.test(f));
@@ -25041,13 +25794,13 @@ function detectCppcheck(cwd) {
   }
 }
 function detectSwiftlint(cwd) {
-  return fs20.existsSync(path49.join(cwd, "Package.swift")) && isCommandAvailable("swiftlint");
+  return fs20.existsSync(path51.join(cwd, "Package.swift")) && isCommandAvailable("swiftlint");
 }
 function detectDartAnalyze(cwd) {
-  return fs20.existsSync(path49.join(cwd, "pubspec.yaml")) && (isCommandAvailable("dart") || isCommandAvailable("flutter"));
+  return fs20.existsSync(path51.join(cwd, "pubspec.yaml")) && (isCommandAvailable("dart") || isCommandAvailable("flutter"));
 }
 function detectRubocop(cwd) {
-  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"));
+  return (fs20.existsSync(path51.join(cwd, "Gemfile")) || fs20.existsSync(path51.join(cwd, "gems.rb")) || fs20.existsSync(path51.join(cwd, ".rubocop.yml"))) && (isCommandAvailable("rubocop") || isCommandAvailable("bundle"));
 }
 function detectAdditionalLinter(cwd) {
   if (detectRuff(cwd))
@@ -25075,10 +25828,10 @@ function detectAdditionalLinter(cwd) {
 function findBinInAncestors(startDir, binName) {
   let dir = startDir;
   while (true) {
-    const candidate = path49.join(dir, "node_modules", ".bin", binName);
+    const candidate = path51.join(dir, "node_modules", ".bin", binName);
     if (fs20.existsSync(candidate))
       return candidate;
-    const parent = path49.dirname(dir);
+    const parent = path51.dirname(dir);
     if (parent === dir)
       break;
     dir = parent;
@@ -25087,10 +25840,10 @@ function findBinInAncestors(startDir, binName) {
 }
 function findBinInEnvPath(binName) {
   const searchPath = process.env.PATH ?? "";
-  for (const dir of searchPath.split(path49.delimiter)) {
+  for (const dir of searchPath.split(path51.delimiter)) {
     if (!dir)
       continue;
-    const candidate = path49.join(dir, binName);
+    const candidate = path51.join(dir, binName);
     if (fs20.existsSync(candidate))
       return candidate;
   }
@@ -25103,13 +25856,13 @@ async function detectAvailableLinter(directory) {
     return null;
   const projectDir = directory;
   const isWindows = process.platform === "win32";
-  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 biomeBin = isWindows ? path51.join(projectDir, "node_modules", ".bin", "biome.EXE") : path51.join(projectDir, "node_modules", ".bin", "biome");
+  const eslintBin = isWindows ? path51.join(projectDir, "node_modules", ".bin", "eslint.cmd") : path51.join(projectDir, "node_modules", ".bin", "eslint");
   const localResult = await _detectAvailableLinter(projectDir, biomeBin, eslintBin);
   if (localResult)
     return localResult;
-  const biomeAncestor = findBinInAncestors(path49.dirname(projectDir), isWindows ? "biome.EXE" : "biome");
-  const eslintAncestor = findBinInAncestors(path49.dirname(projectDir), isWindows ? "eslint.cmd" : "eslint");
+  const biomeAncestor = findBinInAncestors(path51.dirname(projectDir), isWindows ? "biome.EXE" : "biome");
+  const eslintAncestor = findBinInAncestors(path51.dirname(projectDir), isWindows ? "eslint.cmd" : "eslint");
   if (biomeAncestor || eslintAncestor) {
     return _detectAvailableLinter(projectDir, biomeAncestor ?? biomeBin, eslintAncestor ?? eslintBin);
   }
@@ -25292,15 +26045,15 @@ var lint = createSwarmTool({
     }
     const { mode } = args;
     const cwd = directory;
-    const linter = await _internals38.detectAvailableLinter(directory);
+    const linter = await _internals39.detectAvailableLinter(directory);
     if (linter) {
-      const result = await _internals38.runLint(linter, mode, directory);
+      const result = await _internals39.runLint(linter, mode, directory);
       return JSON.stringify(result, null, 2);
     }
-    const additionalLinter = _internals38.detectAdditionalLinter(cwd);
+    const additionalLinter = _internals39.detectAdditionalLinter(cwd);
     if (additionalLinter) {
       warn(`[lint] Using ${additionalLinter} linter for this project`);
-      const result = await _internals38.runAdditionalLint(additionalLinter, mode, cwd);
+      const result = await _internals39.runAdditionalLint(additionalLinter, mode, cwd);
       return JSON.stringify(result, null, 2);
     }
     const errorResult = {
@@ -25314,7 +26067,7 @@ For Rust: rustup component add clippy`
     return JSON.stringify(errorResult, null, 2);
   }
 });
-var _internals38 = {
+var _internals39 = {
   detectAvailableLinter,
   runLint,
   detectAdditionalLinter,
@@ -25323,7 +26076,7 @@ var _internals38 = {
 
 // src/tools/secretscan.ts
 import * as fs21 from "fs";
-import * as path50 from "path";
+import * as path52 from "path";
 var MAX_FILE_PATH_LENGTH = 500;
 var MAX_FILE_SIZE_BYTES = 512 * 1024;
 var MAX_FILES_SCANNED = 1000;
@@ -25550,7 +26303,7 @@ function isGlobOrPathPattern(pattern) {
   return pattern.includes("/") || pattern.includes("\\") || /[*?[\]{}]/.test(pattern);
 }
 function loadSecretScanIgnore(scanDir) {
-  const ignorePath = path50.join(scanDir, ".secretscanignore");
+  const ignorePath = path52.join(scanDir, ".secretscanignore");
   try {
     if (!fs21.existsSync(ignorePath))
       return [];
@@ -25573,7 +26326,7 @@ function isExcluded(entry, relPath, exactNames, globPatterns) {
   if (exactNames.has(entry))
     return true;
   for (const pattern of globPatterns) {
-    if (path50.matchesGlob(relPath, pattern))
+    if (path52.matchesGlob(relPath, pattern))
       return true;
   }
   return false;
@@ -25594,7 +26347,7 @@ function validateDirectoryInput(dir) {
   return null;
 }
 function isBinaryFile(filePath, buffer) {
-  const ext = path50.extname(filePath).toLowerCase();
+  const ext = path52.extname(filePath).toLowerCase();
   if (DEFAULT_EXCLUDE_EXTENSIONS.has(ext)) {
     return true;
   }
@@ -25731,9 +26484,9 @@ function isSymlinkLoop(realPath, visited) {
   return false;
 }
 function isPathWithinScope(realPath, scanDir) {
-  const resolvedScanDir = path50.resolve(scanDir);
-  const resolvedRealPath = path50.resolve(realPath);
-  return resolvedRealPath === resolvedScanDir || resolvedRealPath.startsWith(resolvedScanDir + path50.sep) || resolvedRealPath.startsWith(`${resolvedScanDir}/`) || resolvedRealPath.startsWith(`${resolvedScanDir}\\`);
+  const resolvedScanDir = path52.resolve(scanDir);
+  const resolvedRealPath = path52.resolve(realPath);
+  return resolvedRealPath === resolvedScanDir || resolvedRealPath.startsWith(resolvedScanDir + path52.sep) || resolvedRealPath.startsWith(`${resolvedScanDir}/`) || resolvedRealPath.startsWith(`${resolvedScanDir}\\`);
 }
 function findScannableFiles(dir, excludeExact, excludeGlobs, scanDir, visited, stats = {
   skippedDirs: 0,
@@ -25759,8 +26512,8 @@ function findScannableFiles(dir, excludeExact, excludeGlobs, scanDir, visited, s
     return a.localeCompare(b);
   });
   for (const entry of entries) {
-    const fullPath = path50.join(dir, entry);
-    const relPath = path50.relative(scanDir, fullPath).replace(/\\/g, "/");
+    const fullPath = path52.join(dir, entry);
+    const relPath = path52.relative(scanDir, fullPath).replace(/\\/g, "/");
     if (isExcluded(entry, relPath, excludeExact, excludeGlobs)) {
       stats.skippedDirs++;
       continue;
@@ -25795,7 +26548,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 = path50.extname(fullPath).toLowerCase();
+      const ext = path52.extname(fullPath).toLowerCase();
       if (!DEFAULT_EXCLUDE_EXTENSIONS.has(ext)) {
         files.push(fullPath);
       } else {
@@ -25861,7 +26614,7 @@ var secretscan = createSwarmTool({
       }
     }
     try {
-      const _scanDirRaw = path50.resolve(directory);
+      const _scanDirRaw = path52.resolve(directory);
       const scanDir = (() => {
         try {
           return fs21.realpathSync(_scanDirRaw);
@@ -26002,7 +26755,7 @@ var secretscan = createSwarmTool({
 });
 async function runSecretscan(directory) {
   try {
-    const result = await _internals39.secretscan.execute({ directory }, {});
+    const result = await _internals40.secretscan.execute({ directory }, {});
     const jsonStr = typeof result === "string" ? result : result.output;
     return JSON.parse(jsonStr);
   } catch (e) {
@@ -26017,18 +26770,18 @@ async function runSecretscan(directory) {
     return errorResult;
   }
 }
-var _internals39 = {
+var _internals40 = {
   secretscan,
   runSecretscan
 };
 
 // src/tools/test-runner.ts
 import * as fs25 from "fs";
-import * as path54 from "path";
+import * as path56 from "path";
 
 // src/test-impact/analyzer.ts
 import fs22 from "fs";
-import path51 from "path";
+import path53 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;
@@ -26069,8 +26822,8 @@ function resolveRelativeImport(fromDir, importPath) {
   if (!importPath.startsWith(".")) {
     return null;
   }
-  const resolved = path51.resolve(fromDir, importPath);
-  if (path51.extname(resolved)) {
+  const resolved = path53.resolve(fromDir, importPath);
+  if (path53.extname(resolved)) {
     if (fs22.existsSync(resolved) && fs22.statSync(resolved).isFile()) {
       return normalizePath2(resolved);
     }
@@ -26090,20 +26843,20 @@ function resolvePythonImport(fromDir, module) {
   const leadingDots = module.match(/^\.+/)?.[0].length ?? 0;
   let baseDir = fromDir;
   for (let i = 1;i < leadingDots; i++) {
-    baseDir = path51.dirname(baseDir);
+    baseDir = path53.dirname(baseDir);
   }
   const rest = module.slice(leadingDots);
   if (rest.length === 0) {
-    const initPath = path51.join(baseDir, "__init__.py");
+    const initPath = path53.join(baseDir, "__init__.py");
     if (fs22.existsSync(initPath) && fs22.statSync(initPath).isFile()) {
       return normalizePath2(initPath);
     }
     return null;
   }
-  const subpath = rest.replace(/\./g, path51.sep);
+  const subpath = rest.replace(/\./g, path53.sep);
   const candidates = [
-    `${path51.join(baseDir, subpath)}.py`,
-    path51.join(baseDir, subpath, "__init__.py")
+    `${path53.join(baseDir, subpath)}.py`,
+    path53.join(baseDir, subpath, "__init__.py")
   ];
   for (const c of candidates) {
     if (fs22.existsSync(c) && fs22.statSync(c).isFile())
@@ -26113,7 +26866,7 @@ function resolvePythonImport(fromDir, module) {
 }
 var goModuleCache = new Map;
 function findGoModule(fromDir) {
-  const resolved = path51.resolve(fromDir);
+  const resolved = path53.resolve(fromDir);
   let cur = resolved;
   const walked = [];
   for (let i = 0;i < 16; i++) {
@@ -26125,7 +26878,7 @@ function findGoModule(fromDir) {
     }
     walked.push(cur);
     try {
-      const goMod = path51.join(cur, "go.mod");
+      const goMod = path53.join(cur, "go.mod");
       const content = fs22.readFileSync(goMod, "utf-8");
       const moduleMatch = content.match(/^\s*module\s+"?([^"\s/]+(?:\/[^"\s]+)*)"?/m);
       if (moduleMatch) {
@@ -26136,10 +26889,10 @@ function findGoModule(fromDir) {
       }
     } catch {}
     try {
-      fs22.accessSync(path51.join(cur, ".git"));
+      fs22.accessSync(path53.join(cur, ".git"));
       break;
     } catch {}
-    const parent = path51.dirname(cur);
+    const parent = path53.dirname(cur);
     if (parent === cur)
       break;
     cur = parent;
@@ -26151,12 +26904,12 @@ function findGoModule(fromDir) {
 function resolveGoImport(fromDir, importPath) {
   let dir = null;
   if (importPath.startsWith(".")) {
-    dir = path51.resolve(fromDir, importPath);
+    dir = path53.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 = path51.join(mod.moduleRoot, subpath);
+      dir = path53.join(mod.moduleRoot, subpath);
     }
   }
   if (dir === null)
@@ -26164,7 +26917,7 @@ function resolveGoImport(fromDir, importPath) {
   if (!fs22.existsSync(dir) || !fs22.statSync(dir).isDirectory())
     return [];
   try {
-    return fs22.readdirSync(dir).filter((f) => f.endsWith(".go") && !f.endsWith("_test.go")).map((f) => normalizePath2(path51.join(dir, f)));
+    return fs22.readdirSync(dir).filter((f) => f.endsWith(".go") && !f.endsWith("_test.go")).map((f) => normalizePath2(path53.join(dir, f)));
   } catch {
     return [];
   }
@@ -26203,15 +26956,15 @@ function findTestFilesSync(cwd) {
     for (const entry of entries) {
       if (entry.isDirectory()) {
         if (!skipDirs.has(entry.name)) {
-          walk(path51.join(dir, entry.name), visitedInodes);
+          walk(path53.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(`${path51.sep}tests${path51.sep}`) && name.endsWith(".py");
+        const isPyTest = /^test_.+\.py$/.test(name) || /.+_test\.py$/.test(name) || dir.includes(`${path53.sep}tests${path53.sep}`) && name.endsWith(".py");
         const isGoTest = /.+_test\.go$/.test(name);
         if (isTsTest || isPyTest || isGoTest) {
-          testFiles.push(normalizePath2(path51.join(dir, entry.name)));
+          testFiles.push(normalizePath2(path53.join(dir, entry.name)));
         }
       }
     }
@@ -26236,8 +26989,8 @@ function extractImports(content) {
   ];
 }
 function addImpactEdgesForTestFile(testFile, content, impactMap) {
-  const ext = path51.extname(testFile).toLowerCase();
-  const testDir = path51.dirname(testFile);
+  const ext = path53.extname(testFile).toLowerCase();
+  const testDir = path53.dirname(testFile);
   function addEdge(source) {
     if (!impactMap[source])
       impactMap[source] = [];
@@ -26290,7 +27043,7 @@ async function buildImpactMapInternal(cwd) {
   }
   return impactMap;
 }
-var _internals40 = {
+var _internals41 = {
   validateProjectRoot,
   normalizePath: normalizePath2,
   isCacheStale,
@@ -26305,12 +27058,12 @@ var _internals40 = {
   _clearGoModuleCache
 };
 async function buildImpactMap(cwd) {
-  const impactMap = await _internals40.buildImpactMapInternal(cwd);
-  await _internals40.saveImpactMap(cwd, impactMap);
+  const impactMap = await _internals41.buildImpactMapInternal(cwd);
+  await _internals41.saveImpactMap(cwd, impactMap);
   return impactMap;
 }
 async function loadImpactMap(cwd, options) {
-  const cachePath = path51.join(cwd, ".swarm", "cache", "impact-map.json");
+  const cachePath = path53.join(cwd, ".swarm", "cache", "impact-map.json");
   if (fs22.existsSync(cachePath)) {
     try {
       const content = fs22.readFileSync(cachePath, "utf-8");
@@ -26320,7 +27073,7 @@ async function loadImpactMap(cwd, options) {
         const hasValidValues = Object.values(map).every((v) => Array.isArray(v) && v.every((item) => typeof item === "string"));
         if (hasValidValues) {
           const generatedAt = new Date(data.generatedAt).getTime();
-          if (!_internals40.isCacheStale(map, generatedAt)) {
+          if (!_internals41.isCacheStale(map, generatedAt)) {
             return map;
           }
           if (options?.skipRebuild) {
@@ -26340,15 +27093,15 @@ async function loadImpactMap(cwd, options) {
   if (options?.skipRebuild) {
     return {};
   }
-  return _internals40.buildImpactMap(cwd);
+  return _internals41.buildImpactMap(cwd);
 }
 async function saveImpactMap(cwd, impactMap) {
-  if (!path51.isAbsolute(cwd)) {
+  if (!path53.isAbsolute(cwd)) {
     throw new Error(`saveImpactMap requires an absolute project root path, got: "${cwd}"`);
   }
-  _internals40.validateProjectRoot(cwd);
-  const cacheDir2 = path51.join(cwd, ".swarm", "cache");
-  const cachePath = path51.join(cacheDir2, "impact-map.json");
+  _internals41.validateProjectRoot(cwd);
+  const cacheDir2 = path53.join(cwd, ".swarm", "cache");
+  const cachePath = path53.join(cacheDir2, "impact-map.json");
   if (!fs22.existsSync(cacheDir2)) {
     fs22.mkdirSync(cacheDir2, { recursive: true });
   }
@@ -26370,7 +27123,7 @@ async function analyzeImpact(changedFiles, cwd, budget) {
     };
   }
   const validFiles = changedFiles.filter((f) => typeof f === "string" && f.length > 0 && !f.includes("\x00"));
-  const impactMap = await _internals40.loadImpactMap(cwd);
+  const impactMap = await _internals41.loadImpactMap(cwd);
   const impactedTestsSet = new Set;
   const untestedFiles = [];
   let visitedCount = 0;
@@ -26380,7 +27133,7 @@ async function analyzeImpact(changedFiles, cwd, budget) {
       budgetExceeded = true;
       break;
     }
-    const normalizedChanged = normalizePath2(path51.resolve(changedFile));
+    const normalizedChanged = normalizePath2(path53.resolve(changedFile));
     const tests = impactMap[normalizedChanged];
     if (tests && tests.length > 0) {
       for (const test of tests) {
@@ -26394,13 +27147,13 @@ async function analyzeImpact(changedFiles, cwd, budget) {
       if (budgetExceeded)
         break;
     } else {
-      const changedDir = normalizePath2(path51.dirname(normalizedChanged));
-      const changedInputDir = normalizePath2(path51.dirname(changedFile));
+      const changedDir = normalizePath2(path53.dirname(normalizedChanged));
+      const changedInputDir = normalizePath2(path53.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(path51.dirname(sourceA));
-        const sourceDirB = normalizePath2(path51.dirname(sourceB));
+        const sourceDirA = normalizePath2(path53.dirname(sourceA));
+        const sourceDirB = normalizePath2(path53.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)
@@ -26727,7 +27480,7 @@ function detectFlakyTests(allHistory) {
 
 // src/test-impact/history-store.ts
 import fs23 from "fs";
-import path52 from "path";
+import path54 from "path";
 var MAX_HISTORY_PER_TEST = 20;
 var MAX_ERROR_LENGTH = 500;
 var MAX_STACK_LENGTH = 200;
@@ -26739,10 +27492,10 @@ function getHistoryPath(workingDir) {
   if (!workingDir) {
     throw new Error("getHistoryPath requires a working directory \u2014 project root must be provided by the caller");
   }
-  if (!path52.isAbsolute(workingDir)) {
+  if (!path54.isAbsolute(workingDir)) {
     throw new Error(`getHistoryPath requires an absolute project root path, got: "${workingDir}"`);
   }
-  return path52.join(workingDir, ".swarm", "cache", "test-history.jsonl");
+  return path54.join(workingDir, ".swarm", "cache", "test-history.jsonl");
 }
 function sanitizeErrorMessage(errorMessage) {
   if (errorMessage === undefined) {
@@ -26834,8 +27587,8 @@ function batchAppendTestRuns(records, workingDir) {
     }
   }
   const historyPath = getHistoryPath(workingDir);
-  const historyDir = path52.dirname(historyPath);
-  _internals41.validateProjectRoot(workingDir);
+  const historyDir = path54.dirname(historyPath);
+  _internals42.validateProjectRoot(workingDir);
   if (!fs23.existsSync(historyDir)) {
     fs23.mkdirSync(historyDir, { recursive: true });
   }
@@ -26958,13 +27711,13 @@ function getAllHistory(workingDir) {
   records.sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
   return records;
 }
-var _internals41 = {
+var _internals42 = {
   validateProjectRoot
 };
 
 // src/tools/resolve-working-directory.ts
 import * as fs24 from "fs";
-import * as path53 from "path";
+import * as path55 from "path";
 function resolveWorkingDirectory(workingDirectory, fallbackDirectory) {
   if (workingDirectory == null || workingDirectory === "") {
     if (typeof fallbackDirectory !== "string" || fallbackDirectory === "") {
@@ -27003,8 +27756,8 @@ function resolveWorkingDirectory(workingDirectory, fallbackDirectory) {
       message: "Invalid working_directory: path traversal sequences (..) are not allowed"
     };
   }
-  const normalizedDir = path53.normalize(workingDirectory);
-  const resolvedDir = path53.resolve(normalizedDir);
+  const normalizedDir = path55.normalize(workingDirectory);
+  const resolvedDir = path55.resolve(normalizedDir);
   let statResult;
   try {
     statResult = fs24.statSync(resolvedDir);
@@ -27023,7 +27776,7 @@ function resolveWorkingDirectory(workingDirectory, fallbackDirectory) {
   if (typeof fallbackDirectory !== "string" || fallbackDirectory === "") {
     return { success: true, directory: resolvedDir };
   }
-  const resolvedFallback = path53.resolve(fallbackDirectory);
+  const resolvedFallback = path55.resolve(fallbackDirectory);
   let fallbackExists = false;
   try {
     fs24.statSync(resolvedFallback);
@@ -27032,7 +27785,7 @@ function resolveWorkingDirectory(workingDirectory, fallbackDirectory) {
     fallbackExists = false;
   }
   if (fallbackExists) {
-    const isSubdirectory = resolvedDir.startsWith(resolvedFallback + path53.sep);
+    const isSubdirectory = resolvedDir.startsWith(resolvedFallback + path55.sep);
     if (isSubdirectory) {
       return {
         success: false,
@@ -27055,7 +27808,7 @@ async function estimateFanOut(sourceFiles, cwd) {
     const impactMap = await loadImpactMap(cwd, { skipRebuild: true });
     const uniqueTestFiles = new Set;
     for (const sourceFile of sourceFiles) {
-      const resolvedPath = path54.resolve(cwd, sourceFile);
+      const resolvedPath = path56.resolve(cwd, sourceFile);
       const normalizedPath = resolvedPath.replace(/\\/g, "/");
       const testFiles = impactMap[normalizedPath];
       if (testFiles) {
@@ -27140,14 +27893,14 @@ function hasDevDependency(devDeps, ...patterns) {
   return hasPackageJsonDependency(devDeps, ...patterns);
 }
 function detectGoTest(cwd) {
-  return fs25.existsSync(path54.join(cwd, "go.mod")) && isCommandAvailable("go");
+  return fs25.existsSync(path56.join(cwd, "go.mod")) && isCommandAvailable("go");
 }
 function detectJavaMaven(cwd) {
-  return fs25.existsSync(path54.join(cwd, "pom.xml")) && isCommandAvailable("mvn");
+  return fs25.existsSync(path56.join(cwd, "pom.xml")) && isCommandAvailable("mvn");
 }
 function detectGradle(cwd) {
-  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"));
+  const hasBuildFile = fs25.existsSync(path56.join(cwd, "build.gradle")) || fs25.existsSync(path56.join(cwd, "build.gradle.kts"));
+  const hasGradlew = fs25.existsSync(path56.join(cwd, "gradlew")) || fs25.existsSync(path56.join(cwd, "gradlew.bat"));
   return hasBuildFile && (hasGradlew || isCommandAvailable("gradle"));
 }
 function detectDotnetTest(cwd) {
@@ -27160,25 +27913,25 @@ function detectDotnetTest(cwd) {
   }
 }
 function detectCTest(cwd) {
-  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"));
+  const hasSource = fs25.existsSync(path56.join(cwd, "CMakeLists.txt"));
+  const hasBuildCache = fs25.existsSync(path56.join(cwd, "CMakeCache.txt")) || fs25.existsSync(path56.join(cwd, "build", "CMakeCache.txt"));
   return (hasSource || hasBuildCache) && isCommandAvailable("ctest");
 }
 function detectSwiftTest(cwd) {
-  return fs25.existsSync(path54.join(cwd, "Package.swift")) && isCommandAvailable("swift");
+  return fs25.existsSync(path56.join(cwd, "Package.swift")) && isCommandAvailable("swift");
 }
 function detectDartTest(cwd) {
-  return fs25.existsSync(path54.join(cwd, "pubspec.yaml")) && (isCommandAvailable("dart") || isCommandAvailable("flutter"));
+  return fs25.existsSync(path56.join(cwd, "pubspec.yaml")) && (isCommandAvailable("dart") || isCommandAvailable("flutter"));
 }
 function detectRSpec(cwd) {
-  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 hasRSpecFile = fs25.existsSync(path56.join(cwd, ".rspec"));
+  const hasGemfile = fs25.existsSync(path56.join(cwd, "Gemfile"));
+  const hasSpecDir = fs25.existsSync(path56.join(cwd, "spec"));
   const hasRSpec = hasRSpecFile || hasGemfile && hasSpecDir;
   return hasRSpec && (isCommandAvailable("bundle") || isCommandAvailable("rspec"));
 }
 function detectMinitest(cwd) {
-  return fs25.existsSync(path54.join(cwd, "test")) && (fs25.existsSync(path54.join(cwd, "Gemfile")) || fs25.existsSync(path54.join(cwd, "Rakefile"))) && isCommandAvailable("ruby");
+  return fs25.existsSync(path56.join(cwd, "test")) && (fs25.existsSync(path56.join(cwd, "Gemfile")) || fs25.existsSync(path56.join(cwd, "Rakefile"))) && isCommandAvailable("ruby");
 }
 var DISPATCH_FRAMEWORK_MAP = {
   bun: "bun",
@@ -27263,7 +28016,7 @@ async function parseTestOutputViaDispatch(framework, output, baseDir) {
 async function detectTestFramework(cwd) {
   const baseDir = cwd;
   try {
-    const packageJsonPath = path54.join(baseDir, "package.json");
+    const packageJsonPath = path56.join(baseDir, "package.json");
     if (fs25.existsSync(packageJsonPath)) {
       const content = fs25.readFileSync(packageJsonPath, "utf-8");
       const pkg = JSON.parse(content);
@@ -27284,16 +28037,16 @@ async function detectTestFramework(cwd) {
         return "jest";
       if (hasDevDependency(devDeps, "mocha", "@types/mocha"))
         return "mocha";
-      if (fs25.existsSync(path54.join(baseDir, "bun.lockb")) || fs25.existsSync(path54.join(baseDir, "bun.lock"))) {
+      if (fs25.existsSync(path56.join(baseDir, "bun.lockb")) || fs25.existsSync(path56.join(baseDir, "bun.lock"))) {
         if (scripts.test?.includes("bun"))
           return "bun";
       }
     }
   } catch {}
   try {
-    const pyprojectTomlPath = path54.join(baseDir, "pyproject.toml");
-    const setupCfgPath = path54.join(baseDir, "setup.cfg");
-    const requirementsTxtPath = path54.join(baseDir, "requirements.txt");
+    const pyprojectTomlPath = path56.join(baseDir, "pyproject.toml");
+    const setupCfgPath = path56.join(baseDir, "setup.cfg");
+    const requirementsTxtPath = path56.join(baseDir, "requirements.txt");
     if (fs25.existsSync(pyprojectTomlPath)) {
       const content = fs25.readFileSync(pyprojectTomlPath, "utf-8");
       if (content.includes("[tool.pytest"))
@@ -27313,7 +28066,7 @@ async function detectTestFramework(cwd) {
     }
   } catch {}
   try {
-    const cargoTomlPath = path54.join(baseDir, "Cargo.toml");
+    const cargoTomlPath = path56.join(baseDir, "Cargo.toml");
     if (fs25.existsSync(cargoTomlPath)) {
       const content = fs25.readFileSync(cargoTomlPath, "utf-8");
       if (content.includes("[dev-dependencies]")) {
@@ -27324,9 +28077,9 @@ async function detectTestFramework(cwd) {
     }
   } catch {}
   try {
-    const pesterConfigPath = path54.join(baseDir, "pester.config.ps1");
-    const pesterConfigJsonPath = path54.join(baseDir, "pester.config.ps1.json");
-    const pesterPs1Path = path54.join(baseDir, "tests.ps1");
+    const pesterConfigPath = path56.join(baseDir, "pester.config.ps1");
+    const pesterConfigJsonPath = path56.join(baseDir, "pester.config.ps1.json");
+    const pesterPs1Path = path56.join(baseDir, "tests.ps1");
     if (fs25.existsSync(pesterConfigPath) || fs25.existsSync(pesterConfigJsonPath) || fs25.existsSync(pesterPs1Path)) {
       return "pester";
     }
@@ -27369,12 +28122,12 @@ function isTestDirectoryPath(normalizedPath) {
   return normalizedPath.split("/").some((segment) => TEST_DIRECTORY_NAMES.includes(segment));
 }
 function resolveWorkspacePath(file, workingDir) {
-  return path54.isAbsolute(file) ? path54.resolve(file) : path54.resolve(workingDir, file);
+  return path56.isAbsolute(file) ? path56.resolve(file) : path56.resolve(workingDir, file);
 }
 function toWorkspaceOutputPath(absolutePath, workingDir, preferRelative) {
   if (!preferRelative)
     return absolutePath;
-  return path54.relative(workingDir, absolutePath);
+  return path56.relative(workingDir, absolutePath);
 }
 function dedupePush(target, value) {
   if (!target.includes(value)) {
@@ -27411,18 +28164,18 @@ function buildLanguageSpecificTestNames(nameWithoutExt, ext) {
   }
 }
 function getRepoLevelCandidateDirectories(workingDir, relativePath, ext) {
-  const relativeDir = path54.dirname(relativePath);
+  const relativeDir = path56.dirname(relativePath);
   const nestedRelativeDir = relativeDir === "." ? "" : relativeDir;
   const directories = TEST_DIRECTORY_NAMES.flatMap((dirName) => {
-    const rootDir = path54.join(workingDir, dirName);
-    return nestedRelativeDir ? [rootDir, path54.join(rootDir, nestedRelativeDir)] : [rootDir];
+    const rootDir = path56.join(workingDir, dirName);
+    return nestedRelativeDir ? [rootDir, path56.join(rootDir, nestedRelativeDir)] : [rootDir];
   });
   const normalizedRelativePath = relativePath.replace(/\\/g, "/");
   if (ext === ".java" && normalizedRelativePath.startsWith("src/main/java/")) {
-    directories.push(path54.join(workingDir, "src/test/java", path54.dirname(normalizedRelativePath.slice("src/main/java/".length))));
+    directories.push(path56.join(workingDir, "src/test/java", path56.dirname(normalizedRelativePath.slice("src/main/java/".length))));
   }
   if ((ext === ".kt" || ext === ".java") && normalizedRelativePath.startsWith("src/main/kotlin/")) {
-    directories.push(path54.join(workingDir, "src/test/kotlin", path54.dirname(normalizedRelativePath.slice("src/main/kotlin/".length))));
+    directories.push(path56.join(workingDir, "src/test/kotlin", path56.dirname(normalizedRelativePath.slice("src/main/kotlin/".length))));
   }
   return [...new Set(directories)];
 }
@@ -27450,23 +28203,23 @@ function isLanguageSpecificTestFile(basename10) {
 }
 function isConventionTestFilePath(filePath) {
   const normalizedPath = filePath.replace(/\\/g, "/");
-  const basename10 = path54.basename(filePath);
+  const basename10 = path56.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 = path54.relative(workingDir, absoluteFile);
-    const basename10 = path54.basename(absoluteFile);
-    const dirname25 = path54.dirname(absoluteFile);
-    const preferRelativeOutput = !path54.isAbsolute(file);
+    const relativeFile = path56.relative(workingDir, absoluteFile);
+    const basename10 = path56.basename(absoluteFile);
+    const dirname25 = path56.dirname(absoluteFile);
+    const preferRelativeOutput = !path56.isAbsolute(file);
     if (isConventionTestFilePath(relativeFile) || isConventionTestFilePath(file)) {
       dedupePush(testFiles, toWorkspaceOutputPath(absoluteFile, workingDir, preferRelativeOutput));
       continue;
     }
     const nameWithoutExt = basename10.replace(/\.[^.]+$/, "");
-    const ext = path54.extname(basename10);
+    const ext = path56.extname(basename10);
     const genericTestNames = [
       `${nameWithoutExt}.spec${ext}`,
       `${nameWithoutExt}.test${ext}`
@@ -27475,7 +28228,7 @@ function getTestFilesFromConvention(sourceFiles, workingDir = process.cwd()) {
     const colocatedCandidates = [
       ...genericTestNames,
       ...languageSpecificTestNames
-    ].map((candidateName) => path54.join(dirname25, candidateName));
+    ].map((candidateName) => path56.join(dirname25, candidateName));
     const testDirectoryNames = [
       basename10,
       ...genericTestNames,
@@ -27484,8 +28237,8 @@ function getTestFilesFromConvention(sourceFiles, workingDir = process.cwd()) {
     const repoLevelDirectories = getRepoLevelCandidateDirectories(workingDir, relativeFile, ext);
     const possibleTestFiles = [
       ...colocatedCandidates,
-      ...TEST_DIRECTORY_NAMES.flatMap((dirName) => testDirectoryNames.map((candidateName) => path54.join(dirname25, dirName, candidateName))),
-      ...repoLevelDirectories.flatMap((candidateDir) => testDirectoryNames.map((candidateName) => path54.join(candidateDir, candidateName)))
+      ...TEST_DIRECTORY_NAMES.flatMap((dirName) => testDirectoryNames.map((candidateName) => path56.join(dirname25, dirName, candidateName))),
+      ...repoLevelDirectories.flatMap((candidateDir) => testDirectoryNames.map((candidateName) => path56.join(candidateDir, candidateName)))
     ];
     for (const testFile of possibleTestFiles) {
       if (fs25.existsSync(testFile)) {
@@ -27506,7 +28259,7 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
     try {
       const absoluteTestFile = resolveWorkspacePath(testFile, workingDir);
       const content = fs25.readFileSync(absoluteTestFile, "utf-8");
-      const testDir = path54.dirname(absoluteTestFile);
+      const testDir = path56.dirname(absoluteTestFile);
       const importRegex = /import\s+.*?\s+from\s+['"]([^'"]+)['"]/g;
       let match;
       match = importRegex.exec(content);
@@ -27514,8 +28267,8 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
         const importPath = match[1];
         let resolvedImport;
         if (importPath.startsWith(".")) {
-          resolvedImport = path54.resolve(testDir, importPath);
-          const existingExt = path54.extname(resolvedImport);
+          resolvedImport = path56.resolve(testDir, importPath);
+          const existingExt = path56.extname(resolvedImport);
           if (!existingExt) {
             for (const extToTry of [
               ".ts",
@@ -27535,12 +28288,12 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
         } else {
           continue;
         }
-        const importBasename = path54.basename(resolvedImport, path54.extname(resolvedImport));
-        const importDir = path54.dirname(resolvedImport);
+        const importBasename = path56.basename(resolvedImport, path56.extname(resolvedImport));
+        const importDir = path56.dirname(resolvedImport);
         for (const sourceFile of absoluteSourceFiles) {
-          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");
+          const sourceDir = path56.dirname(sourceFile);
+          const sourceBasename = path56.basename(sourceFile, path56.extname(sourceFile));
+          const isRelatedDir = importDir === sourceDir || importDir === path56.join(sourceDir, "__tests__") || importDir === path56.join(sourceDir, "tests") || importDir === path56.join(sourceDir, "test") || importDir === path56.join(sourceDir, "spec");
           if (resolvedImport === sourceFile || importBasename === sourceBasename && isRelatedDir) {
             dedupePush(testFiles, testFile);
             break;
@@ -27553,8 +28306,8 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
       while (match !== null) {
         const importPath = match[1];
         if (importPath.startsWith(".")) {
-          let resolvedImport = path54.resolve(testDir, importPath);
-          const existingExt = path54.extname(resolvedImport);
+          let resolvedImport = path56.resolve(testDir, importPath);
+          const existingExt = path56.extname(resolvedImport);
           if (!existingExt) {
             for (const extToTry of [
               ".ts",
@@ -27571,12 +28324,12 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
               }
             }
           }
-          const importDir = path54.dirname(resolvedImport);
-          const importBasename = path54.basename(resolvedImport, path54.extname(resolvedImport));
+          const importDir = path56.dirname(resolvedImport);
+          const importBasename = path56.basename(resolvedImport, path56.extname(resolvedImport));
           for (const sourceFile of absoluteSourceFiles) {
-            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");
+            const sourceDir = path56.dirname(sourceFile);
+            const sourceBasename = path56.basename(sourceFile, path56.extname(sourceFile));
+            const isRelatedDir = importDir === sourceDir || importDir === path56.join(sourceDir, "__tests__") || importDir === path56.join(sourceDir, "tests") || importDir === path56.join(sourceDir, "test") || importDir === path56.join(sourceDir, "spec");
             if (resolvedImport === sourceFile || importBasename === sourceBasename && isRelatedDir) {
               dedupePush(testFiles, testFile);
               break;
@@ -27696,8 +28449,8 @@ function buildTestCommand(framework, scope, files, coverage, baseDir, bail) {
       return ["mvn", "test"];
     case "gradle": {
       const isWindows = process.platform === "win32";
-      const hasGradlewBat = fs25.existsSync(path54.join(baseDir, "gradlew.bat"));
-      const hasGradlew = fs25.existsSync(path54.join(baseDir, "gradlew"));
+      const hasGradlewBat = fs25.existsSync(path56.join(baseDir, "gradlew.bat"));
+      const hasGradlew = fs25.existsSync(path56.join(baseDir, "gradlew"));
       if (hasGradlewBat && isWindows)
         return ["gradlew.bat", "test"];
       if (hasGradlew)
@@ -27714,7 +28467,7 @@ function buildTestCommand(framework, scope, files, coverage, baseDir, bail) {
         "cmake-build-release",
         "out"
       ];
-      const actualBuildDir = buildDirCandidates.find((d) => fs25.existsSync(path54.join(baseDir, d, "CMakeCache.txt"))) ?? "build";
+      const actualBuildDir = buildDirCandidates.find((d) => fs25.existsSync(path56.join(baseDir, d, "CMakeCache.txt"))) ?? "build";
       return ["ctest", "--test-dir", actualBuildDir];
     }
     case "swift-test":
@@ -28148,11 +28901,11 @@ async function runTests(framework, scope, files, coverage, timeout_ms, cwd, bail
     };
   }
   const startTime = Date.now();
-  const vitestJsonOutputPath = framework === "vitest" ? path54.join(cwd, ".swarm", "cache", "test-runner-vitest.json") : undefined;
+  const vitestJsonOutputPath = framework === "vitest" ? path56.join(cwd, ".swarm", "cache", "test-runner-vitest.json") : undefined;
   try {
     if (vitestJsonOutputPath) {
       try {
-        fs25.mkdirSync(path54.dirname(vitestJsonOutputPath), { recursive: true });
+        fs25.mkdirSync(path56.dirname(vitestJsonOutputPath), { recursive: true });
         if (fs25.existsSync(vitestJsonOutputPath)) {
           fs25.unlinkSync(vitestJsonOutputPath);
         }
@@ -28320,10 +29073,10 @@ var SKIP_DIRECTORIES = new Set([
 ]);
 function normalizeHistoryTestFile(testFile, workingDir) {
   const normalized = testFile.replace(/\\/g, "/");
-  if (!path54.isAbsolute(testFile))
+  if (!path56.isAbsolute(testFile))
     return normalized;
-  const relative8 = path54.relative(workingDir, testFile);
-  if (relative8.startsWith("..") || path54.isAbsolute(relative8)) {
+  const relative8 = path56.relative(workingDir, testFile);
+  if (relative8.startsWith("..") || path56.isAbsolute(relative8)) {
     return normalized;
   }
   return relative8.replace(/\\/g, "/");
@@ -28562,7 +29315,7 @@ var test_runner = createSwarmTool({
       const sourceFiles = args.files.filter((file) => {
         if (directTestFiles.includes(file))
           return false;
-        const ext = path54.extname(file).toLowerCase();
+        const ext = path56.extname(file).toLowerCase();
         return SOURCE_EXTENSIONS.has(ext);
       });
       const invalidFiles = args.files.filter((file) => !directTestFiles.includes(file) && !sourceFiles.includes(file));
@@ -28608,7 +29361,7 @@ var test_runner = createSwarmTool({
         if (isConventionTestFilePath(f)) {
           return false;
         }
-        const ext = path54.extname(f).toLowerCase();
+        const ext = path56.extname(f).toLowerCase();
         return SOURCE_EXTENSIONS.has(ext);
       });
       if (sourceFiles.length === 0) {
@@ -28658,7 +29411,7 @@ var test_runner = createSwarmTool({
         if (isConventionTestFilePath(f)) {
           return false;
         }
-        const ext = path54.extname(f).toLowerCase();
+        const ext = path56.extname(f).toLowerCase();
         return SOURCE_EXTENSIONS.has(ext);
       });
       if (sourceFiles.length === 0) {
@@ -28710,8 +29463,8 @@ var test_runner = createSwarmTool({
         }
         if (impactResult.impactedTests.length > 0) {
           testFiles = impactResult.impactedTests.map((absPath) => {
-            const relativePath = path54.relative(workingDir, absPath);
-            return path54.isAbsolute(relativePath) ? absPath : relativePath;
+            const relativePath = path56.relative(workingDir, absPath);
+            return path56.isAbsolute(relativePath) ? absPath : relativePath;
           });
         } else {
           graphFallbackReason = "no impacted tests found via impact analysis, falling back to graph";
@@ -28806,8 +29559,8 @@ function validateDirectoryPath(dir) {
   if (dir.includes("..")) {
     throw new Error("Directory path must not contain path traversal sequences");
   }
-  const normalized = path55.normalize(dir);
-  const absolutePath = path55.isAbsolute(normalized) ? normalized : path55.resolve(normalized);
+  const normalized = path57.normalize(dir);
+  const absolutePath = path57.isAbsolute(normalized) ? normalized : path57.resolve(normalized);
   return absolutePath;
 }
 function validateTimeout(timeoutMs, defaultValue) {
@@ -28830,7 +29583,7 @@ function validateTimeout(timeoutMs, defaultValue) {
 }
 function getPackageVersion(dir) {
   try {
-    const packagePath = path55.join(dir, "package.json");
+    const packagePath = path57.join(dir, "package.json");
     if (fs26.existsSync(packagePath)) {
       const content = fs26.readFileSync(packagePath, "utf-8");
       const pkg = JSON.parse(content);
@@ -28841,7 +29594,7 @@ function getPackageVersion(dir) {
 }
 function getChangelogVersion(dir) {
   try {
-    const changelogPath = path55.join(dir, "CHANGELOG.md");
+    const changelogPath = path57.join(dir, "CHANGELOG.md");
     if (fs26.existsSync(changelogPath)) {
       const content = fs26.readFileSync(changelogPath, "utf-8");
       const match = content.match(/^##\s*\[?(\d+\.\d+\.\d+)\]?/m);
@@ -28855,7 +29608,7 @@ function getChangelogVersion(dir) {
 function getVersionFileVersion(dir) {
   const possibleFiles = ["VERSION.txt", "version.txt", "VERSION", "version"];
   for (const file of possibleFiles) {
-    const filePath = path55.join(dir, file);
+    const filePath = path57.join(dir, file);
     if (fs26.existsSync(filePath)) {
       try {
         const content = fs26.readFileSync(filePath, "utf-8").trim();
@@ -28871,9 +29624,9 @@ function getVersionFileVersion(dir) {
 async function runVersionCheck(dir, _timeoutMs) {
   const startTime = Date.now();
   try {
-    const packageVersion = _internals42.getPackageVersion(dir);
-    const changelogVersion = _internals42.getChangelogVersion(dir);
-    const versionFileVersion = _internals42.getVersionFileVersion(dir);
+    const packageVersion = _internals43.getPackageVersion(dir);
+    const changelogVersion = _internals43.getChangelogVersion(dir);
+    const versionFileVersion = _internals43.getVersionFileVersion(dir);
     const versions = [];
     if (packageVersion)
       versions.push(`package.json: ${packageVersion}`);
@@ -29237,7 +29990,7 @@ async function runPreflight(dir, phase, config) {
   const reportId = `preflight-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
   let validatedDir;
   try {
-    validatedDir = _internals42.validateDirectoryPath(dir);
+    validatedDir = _internals43.validateDirectoryPath(dir);
   } catch (error2) {
     return {
       id: reportId,
@@ -29257,7 +30010,7 @@ async function runPreflight(dir, phase, config) {
   }
   let validatedTimeout;
   try {
-    validatedTimeout = _internals42.validateTimeout(config?.checkTimeoutMs, DEFAULT_CONFIG.checkTimeoutMs);
+    validatedTimeout = _internals43.validateTimeout(config?.checkTimeoutMs, DEFAULT_CONFIG.checkTimeoutMs);
   } catch (error2) {
     return {
       id: reportId,
@@ -29298,12 +30051,12 @@ async function runPreflight(dir, phase, config) {
   });
   const checks = [];
   log("[Preflight] Running lint check...");
-  const lintResult = await _internals42.runLintCheck(validatedDir, cfg.linter, cfg.checkTimeoutMs);
+  const lintResult = await _internals43.runLintCheck(validatedDir, cfg.linter, cfg.checkTimeoutMs);
   checks.push(lintResult);
   log(`[Preflight] Lint check: ${lintResult.status} ${lintResult.message}`);
   if (!cfg.skipTests) {
     log("[Preflight] Running tests check...");
-    const testsResult = await _internals42.runTestsCheck(validatedDir, cfg.testScope, cfg.checkTimeoutMs);
+    const testsResult = await _internals43.runTestsCheck(validatedDir, cfg.testScope, cfg.checkTimeoutMs);
     checks.push(testsResult);
     log(`[Preflight] Tests check: ${testsResult.status} ${testsResult.message}`);
   } else {
@@ -29315,7 +30068,7 @@ async function runPreflight(dir, phase, config) {
   }
   if (!cfg.skipSecrets) {
     log("[Preflight] Running secrets check...");
-    const secretsResult = await _internals42.runSecretsCheck(validatedDir, cfg.checkTimeoutMs);
+    const secretsResult = await _internals43.runSecretsCheck(validatedDir, cfg.checkTimeoutMs);
     checks.push(secretsResult);
     log(`[Preflight] Secrets check: ${secretsResult.status} ${secretsResult.message}`);
   } else {
@@ -29327,7 +30080,7 @@ async function runPreflight(dir, phase, config) {
   }
   if (!cfg.skipEvidence) {
     log("[Preflight] Running evidence check...");
-    const evidenceResult = await _internals42.runEvidenceCheck(validatedDir);
+    const evidenceResult = await _internals43.runEvidenceCheck(validatedDir);
     checks.push(evidenceResult);
     log(`[Preflight] Evidence check: ${evidenceResult.status} ${evidenceResult.message}`);
   } else {
@@ -29338,12 +30091,12 @@ async function runPreflight(dir, phase, config) {
     });
   }
   log("[Preflight] Running requirement coverage check...");
-  const reqCoverageResult = await _internals42.runRequirementCoverageCheck(validatedDir, phase);
+  const reqCoverageResult = await _internals43.runRequirementCoverageCheck(validatedDir, phase);
   checks.push(reqCoverageResult);
   log(`[Preflight] Requirement coverage check: ${reqCoverageResult.status} ${reqCoverageResult.message}`);
   if (!cfg.skipVersion) {
     log("[Preflight] Running version check...");
-    const versionResult = await _internals42.runVersionCheck(validatedDir, cfg.checkTimeoutMs);
+    const versionResult = await _internals43.runVersionCheck(validatedDir, cfg.checkTimeoutMs);
     checks.push(versionResult);
     log(`[Preflight] Version check: ${versionResult.status} ${versionResult.message}`);
   } else {
@@ -29406,10 +30159,10 @@ function formatPreflightMarkdown(report) {
 async function handlePreflightCommand(directory, _args) {
   const plan = await loadPlan(directory);
   const phase = plan?.current_phase ?? 1;
-  const report = await _internals42.runPreflight(directory, phase);
-  return _internals42.formatPreflightMarkdown(report);
+  const report = await _internals43.runPreflight(directory, phase);
+  return _internals43.formatPreflightMarkdown(report);
 }
-var _internals42 = {
+var _internals43 = {
   runPreflight,
   formatPreflightMarkdown,
   handlePreflightCommand,
@@ -29593,7 +30346,7 @@ async function handleQaGatesCommand(directory, args, sessionID) {
 
 // src/commands/reset.ts
 import * as fs27 from "fs";
-import * as path56 from "path";
+import * as path58 from "path";
 
 // src/background/circuit-breaker.ts
 class CircuitBreaker {
@@ -30312,7 +31065,7 @@ async function handleResetCommand(directory, args) {
   }
   for (const filename of ["SWARM_PLAN.md", "SWARM_PLAN.json"]) {
     try {
-      const rootPath = path56.join(directory, filename);
+      const rootPath = path58.join(directory, filename);
       if (fs27.existsSync(rootPath)) {
         fs27.unlinkSync(rootPath);
         results.push(`- \u2705 Deleted ${filename} (root)`);
@@ -30350,7 +31103,7 @@ async function handleResetCommand(directory, args) {
 
 // src/commands/reset-session.ts
 import * as fs29 from "fs";
-import * as path58 from "path";
+import * as path60 from "path";
 
 // src/hooks/trajectory-logger.ts
 var callStartTimes = new Map;
@@ -30757,16 +31510,16 @@ function detectPatterns(trajectory, config, lastProcessedStep = 0) {
 }
 // src/prm/replay.ts
 import { promises as fs28 } from "fs";
-import path57 from "path";
+import path59 from "path";
 function isPathSafe(targetPath, basePath) {
-  const resolvedTarget = path57.resolve(targetPath);
-  const resolvedBase = path57.resolve(basePath);
-  const rel = path57.relative(resolvedBase, resolvedTarget);
-  return !rel.startsWith("..") && !path57.isAbsolute(rel);
+  const resolvedTarget = path59.resolve(targetPath);
+  const resolvedBase = path59.resolve(basePath);
+  const rel = path59.relative(resolvedBase, resolvedTarget);
+  return !rel.startsWith("..") && !path59.isAbsolute(rel);
 }
 function isWithinReplaysDir(targetPath) {
-  const resolved = path57.resolve(targetPath);
-  const parts = resolved.split(path57.sep);
+  const resolved = path59.resolve(targetPath);
+  const parts = resolved.split(path59.sep);
   for (let i = 0;i < parts.length - 1; i++) {
     if (parts[i] === ".swarm" && parts[i + 1] === "replays") {
       return true;
@@ -30779,10 +31532,10 @@ function sanitizeFilename(input) {
 }
 async function startReplayRecording(sessionID, directory) {
   try {
-    const replayDir = path57.join(directory, ".swarm", "replays");
+    const replayDir = path59.join(directory, ".swarm", "replays");
     const safeSessionID = sanitizeFilename(sessionID);
     const filename = `${safeSessionID}-${Date.now()}.jsonl`;
-    const filepath = path57.join(replayDir, filename);
+    const filepath = path59.join(replayDir, filename);
     if (!isPathSafe(filepath, replayDir)) {
       console.warn(`[replay] Invalid path detected - path traversal attempt blocked for session ${sessionID}`);
       return null;
@@ -30814,7 +31567,7 @@ async function recordReplayEntry(artifactPath, sessionID, entry) {
 }
 
 // src/prm/index.ts
-var _internals43 = {
+var _internals44 = {
   getAgentSession,
   readTrajectory,
   getInMemoryTrajectory,
@@ -30837,7 +31590,7 @@ function resetPrmSessionState(session, sessionId) {
   session.prmTrajectoryStep = 0;
   session.replayArtifactPath = null;
   if (sessionId) {
-    _internals43.clearTrajectoryCache(sessionId);
+    _internals44.clearTrajectoryCache(sessionId);
   }
 }
 
@@ -30860,7 +31613,7 @@ async function handleResetSessionCommand(directory, _args) {
   } catch {
     results.push("\u274C Failed to delete state.json");
   }
-  const sessionDir = path58.dirname(validateSwarmPath(directory, "session/state.json"));
+  const sessionDir = path60.dirname(validateSwarmPath(directory, "session/state.json"));
   let sessionFiles = [];
   if (fs29.existsSync(sessionDir)) {
     try {
@@ -30872,7 +31625,7 @@ async function handleResetSessionCommand(directory, _args) {
   for (const file of sessionFiles) {
     if (file === "state.json")
       continue;
-    const filePath = path58.join(sessionDir, file);
+    const filePath = path60.join(sessionDir, file);
     try {
       if (!fs29.existsSync(filePath))
         continue;
@@ -30907,7 +31660,7 @@ async function handleResetSessionCommand(directory, _args) {
 }
 
 // src/summaries/manager.ts
-import * as path59 from "path";
+import * as path61 from "path";
 var SUMMARY_ID_REGEX = /^S\d+$/;
 function sanitizeSummaryId(id) {
   if (!id || id.length === 0) {
@@ -30931,7 +31684,7 @@ function sanitizeSummaryId(id) {
 }
 async function loadFullOutput(directory, id) {
   const sanitizedId = sanitizeSummaryId(id);
-  const relativePath = path59.join("summaries", `${sanitizedId}.json`);
+  const relativePath = path61.join("summaries", `${sanitizedId}.json`);
   validateSwarmPath(directory, relativePath);
   const content = await readSwarmFileAsync(directory, relativePath);
   if (content === null) {
@@ -30984,7 +31737,7 @@ ${error2 instanceof Error ? error2.message : String(error2)}`;
 
 // src/commands/rollback.ts
 import * as fs30 from "fs";
-import * as path60 from "path";
+import * as path62 from "path";
 async function handleRollbackCommand(directory, args) {
   const phaseArg = args[0];
   if (!phaseArg) {
@@ -31050,8 +31803,8 @@ async function handleRollbackCommand(directory, args) {
     if (EXCLUDE_FILES.has(file) || file.startsWith("plan-ledger.archived-")) {
       continue;
     }
-    const src = path60.join(checkpointDir, file);
-    const dest = path60.join(swarmDir, file);
+    const src = path62.join(checkpointDir, file);
+    const dest = path62.join(swarmDir, file);
     try {
       fs30.cpSync(src, dest, { recursive: true, force: true });
       successes.push(file);
@@ -31070,7 +31823,7 @@ async function handleRollbackCommand(directory, args) {
     ].join(`
 `);
   }
-  const existingLedgerPath = path60.join(swarmDir, "plan-ledger.jsonl");
+  const existingLedgerPath = path62.join(swarmDir, "plan-ledger.jsonl");
   let ledgerDeletionFailed = false;
   if (fs30.existsSync(existingLedgerPath)) {
     try {
@@ -31083,7 +31836,7 @@ async function handleRollbackCommand(directory, args) {
   }
   if (!ledgerDeletionFailed) {
     try {
-      const planJsonPath = path60.join(swarmDir, "plan.json");
+      const planJsonPath = path62.join(swarmDir, "plan.json");
       if (fs30.existsSync(planJsonPath)) {
         const planRaw = fs30.readFileSync(planJsonPath, "utf-8");
         const plan = PlanSchema.parse(JSON.parse(planRaw));
@@ -31344,10 +32097,10 @@ Ensure this is a git repository with commit history.`;
 `);
   try {
     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)}`);
+    const path63 = await import("path");
+    const reportPath = path63.join(directory, ".swarm", "simulate-report.md");
+    await fs31.mkdir(path63.dirname(reportPath), { recursive: true });
+    const reportTempPath = path63.join(path63.dirname(reportPath), `${path63.basename(reportPath)}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
     try {
       await fs31.writeFile(reportTempPath, report, "utf-8");
       renameSync11(reportTempPath, reportPath);
@@ -31376,18 +32129,18 @@ async function handleSpecifyCommand(_directory, args) {
 // src/services/status-service.ts
 import * as fsSync3 from "fs";
 import { readFile as readFile16 } from "fs/promises";
-import * as path62 from "path";
+import * as path64 from "path";
 
 // src/turbo/lean/state.ts
 init_logger();
 import * as fs31 from "fs";
-import * as path61 from "path";
+import * as path63 from "path";
 var STATE_FILE3 = "turbo-state.json";
 function nowISO3() {
   return new Date().toISOString();
 }
 function ensureSwarmDir2(directory) {
-  const swarmDir = path61.resolve(directory, ".swarm");
+  const swarmDir = path63.resolve(directory, ".swarm");
   if (!fs31.existsSync(swarmDir)) {
     fs31.mkdirSync(swarmDir, { recursive: true });
   }
@@ -31432,7 +32185,7 @@ function markStateUnreadable2(directory, reason) {
 }
 function readPersisted2(directory) {
   try {
-    const filePath = path61.join(directory, ".swarm", STATE_FILE3);
+    const filePath = path63.join(directory, ".swarm", STATE_FILE3);
     if (!fs31.existsSync(filePath)) {
       const seed = emptyPersisted2();
       try {
@@ -31468,7 +32221,7 @@ function writePersisted2(directory, persisted) {
   let payload;
   try {
     ensureSwarmDir2(directory);
-    filePath = path61.join(directory, ".swarm", STATE_FILE3);
+    filePath = path63.join(directory, ".swarm", STATE_FILE3);
     tmpPath = `${filePath}.tmp.${Date.now()}`;
     persisted.updatedAt = nowISO3();
     payload = `${JSON.stringify(persisted, null, 2)}
@@ -31579,14 +32332,14 @@ var DEFAULT_CONTEXT_BUDGET_CONFIG = {
 };
 
 // src/services/status-service.ts
-var _internals44 = {
+var _internals45 = {
   loadLeanTurboRunState,
   hasActiveLeanTurbo,
   hasActiveFullAuto
 };
 function readSpecStalenessSnapshot(directory) {
   try {
-    const p = path62.join(directory, ".swarm", "spec-staleness.json");
+    const p = path64.join(directory, ".swarm", "spec-staleness.json");
     if (!fsSync3.existsSync(p))
       return { stale: false };
     const raw = fsSync3.readFileSync(p, "utf-8");
@@ -31684,7 +32437,7 @@ async function getStatusData(directory, agents) {
 }
 function enrichWithLeanTurbo(status, directory) {
   const turboMode = hasActiveTurboMode();
-  const leanActive = _internals44.hasActiveLeanTurbo();
+  const leanActive = _internals45.hasActiveLeanTurbo();
   let turboStrategy = "off";
   if (leanActive) {
     turboStrategy = "lean";
@@ -31703,7 +32456,7 @@ function enrichWithLeanTurbo(status, directory) {
     }
   }
   if (leanSessionID) {
-    const runState = _internals44.loadLeanTurboRunState(directory, leanSessionID);
+    const runState = _internals45.loadLeanTurboRunState(directory, leanSessionID);
     if (runState) {
       status.leanTurboPhase = runState.phase;
       status.leanMaxParallelCoders = runState.maxParallelCoders;
@@ -31735,7 +32488,7 @@ function enrichWithLeanTurbo(status, directory) {
       }
     }
   }
-  status.fullAutoActive = _internals44.hasActiveFullAuto();
+  status.fullAutoActive = _internals45.hasActiveFullAuto();
   return status;
 }
 function formatStatusMarkdown(status) {
@@ -31889,7 +32642,7 @@ No active swarm plan found. Nothing to sync.`;
 
 // src/commands/turbo.ts
 init_logger();
-var _internals45 = {
+var _internals46 = {
   loadPluginConfigWithMeta
 };
 async function handleTurboCommand(directory, args, sessionID) {
@@ -31949,7 +32702,7 @@ async function handleTurboCommand(directory, args, sessionID) {
   if (arg0 === "on") {
     let strategy = "standard";
     try {
-      const { config } = _internals45.loadPluginConfigWithMeta(directory);
+      const { config } = _internals46.loadPluginConfigWithMeta(directory);
       if (config.turbo?.strategy === "lean") {
         strategy = "lean";
       }
@@ -32046,7 +32799,7 @@ function enableLeanTurbo(session, directory, sessionID) {
   let maxParallelCoders = 4;
   let conflictPolicy = "serialize";
   try {
-    const { config } = _internals45.loadPluginConfigWithMeta(directory);
+    const { config } = _internals46.loadPluginConfigWithMeta(directory);
     const leanConfig = config.turbo?.lean;
     if (leanConfig) {
       maxParallelCoders = leanConfig.max_parallel_coders ?? 4;
@@ -32119,11 +32872,11 @@ function buildStatusMessage2(session, directory, sessionID) {
 
 // src/commands/unlink.ts
 import { existsSync as existsSync37 } from "fs";
-import * as path63 from "path";
+import * as path65 from "path";
 var DEDUP_THRESHOLD2 = 0.6;
 async function copySharedKnowledgeToLocal(linkDir, localSwarmDir) {
-  const sharedPath = path63.join(linkDir, "knowledge.jsonl");
-  const localPath = path63.join(localSwarmDir, "knowledge.jsonl");
+  const sharedPath = path65.join(linkDir, "knowledge.jsonl");
+  const localPath = path65.join(localSwarmDir, "knowledge.jsonl");
   if (!existsSync37(sharedPath))
     return 0;
   const sharedEntries = await readKnowledge(sharedPath);
@@ -32158,7 +32911,7 @@ async function handleUnlinkCommand(directory, args) {
   let copied = 0;
   if (copyBack) {
     try {
-      copied = await copySharedKnowledgeToLocal(linkDir, path63.join(directory, ".swarm"));
+      copied = await copySharedKnowledgeToLocal(linkDir, path65.join(directory, ".swarm"));
     } catch (error2) {
       return `\u274C Failed to copy shared knowledge back to local: ${error2 instanceof Error ? error2.message : String(error2)}`;
     }
@@ -32262,7 +33015,7 @@ function findSimilarCommands(query) {
   }
   const scored = VALID_COMMANDS.map((cmd) => {
     const cmdLower = cmd.toLowerCase();
-    const fullScore = _internals46.levenshteinDistance(q, cmdLower);
+    const fullScore = _internals47.levenshteinDistance(q, cmdLower);
     let tokenScore = Infinity;
     if (cmd.includes(" ") || cmd.includes("-")) {
       const qTokens = q.split(/[\s-]+/);
@@ -32275,7 +33028,7 @@ function findSimilarCommands(query) {
         for (const ct of cmdTokens) {
           if (ct.length === 0)
             continue;
-          const dist = _internals46.levenshteinDistance(qt, ct);
+          const dist = _internals47.levenshteinDistance(qt, ct);
           if (dist < minDist)
             minDist = dist;
         }
@@ -32285,7 +33038,7 @@ function findSimilarCommands(query) {
     }
     const dashStrippedQ = q.replace(/-/g, "");
     const dashStrippedCmd = cmdLower.replace(/-/g, "");
-    const dashScore = _internals46.levenshteinDistance(dashStrippedQ, dashStrippedCmd);
+    const dashScore = _internals47.levenshteinDistance(dashStrippedQ, dashStrippedCmd);
     const score = Math.min(fullScore, tokenScore, dashScore);
     return { cmd, score };
   });
@@ -32320,16 +33073,16 @@ function buildDetailedHelp(commandName, entry) {
 async function handleHelpCommand(ctx) {
   const targetCommand = ctx.args.join(" ");
   if (!targetCommand) {
-    const { buildHelpText } = await import("./index-sz3kw59p.js");
+    const { buildHelpText } = await import("./index-bcr2a549.js");
     return buildHelpText();
   }
   const tokens = targetCommand.split(/\s+/);
-  const resolved = _internals46.resolveCommand(tokens);
+  const resolved = _internals47.resolveCommand(tokens);
   if (resolved) {
-    return _internals46.buildDetailedHelp(resolved.key, resolved.entry);
+    return _internals47.buildDetailedHelp(resolved.key, resolved.entry);
   }
-  const similar = _internals46.findSimilarCommands(targetCommand);
-  const { buildHelpText: fullHelp } = await import("./index-sz3kw59p.js");
+  const similar = _internals47.findSimilarCommands(targetCommand);
+  const { buildHelpText: fullHelp } = await import("./index-bcr2a549.js");
   if (similar.length > 0) {
     return `Command '/swarm ${targetCommand}' not found.
 
@@ -32393,7 +33146,7 @@ var COMMAND_REGISTRY = {
     toolNoArgs: true
   },
   help: {
-    handler: (ctx) => _internals46.handleHelpCommand(ctx),
+    handler: (ctx) => _internals47.handleHelpCommand(ctx),
     description: "Show help for swarm commands",
     category: "core",
     args: "[command]",
@@ -32462,7 +33215,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail explain": {
     handler: async (ctx) => {
-      const { handleGuardrailExplain } = await import("./guardrail-explain-dkh5f7nf.js");
+      const { handleGuardrailExplain } = await import("./guardrail-explain-z37rtfz4.js");
       return handleGuardrailExplain(ctx.directory, ctx.args);
     },
     description: "Dry-run: show what the guardrails would do to a command or write target (executes nothing)",
@@ -32472,7 +33225,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail-log": {
     handler: async (ctx) => {
-      const { handleGuardrailLog } = await import("./guardrail-log-ya49kpwn.js");
+      const { handleGuardrailLog } = await import("./guardrail-log-ywajkn46.js");
       return handleGuardrailLog(ctx.directory, ctx.args);
     },
     description: "Read the guardrail decision log (use --blocks-only for blocks)",
@@ -33235,24 +33988,24 @@ function validateAliases() {
         continue;
       }
       const visited = new Set;
-      const path64 = [];
+      const path66 = [];
       let current = target;
       while (current) {
         const currentEntry = COMMAND_REGISTRY[current];
         if (!currentEntry)
           break;
         if (visited.has(current)) {
-          const cycleStart = path64.indexOf(current);
+          const cycleStart = path66.indexOf(current);
           const fullChain = [
             name,
-            ...path64.slice(0, cycleStart > 0 ? cycleStart : path64.length),
+            ...path66.slice(0, cycleStart > 0 ? cycleStart : path66.length),
             current
           ].join(" \u2192 ");
           errors.push(`Circular alias detected: ${fullChain}`);
           break;
         }
         visited.add(current);
-        path64.push(current);
+        path66.push(current);
         current = currentEntry.aliasOf || "";
       }
     }
@@ -33271,7 +34024,7 @@ function validateToolPolicy() {
   }
   return { valid: warnings.length === 0, warnings };
 }
-var _internals46 = {
+var _internals47 = {
   handleHelpCommand,
   validateAliases,
   validateToolPolicy,
@@ -33281,16 +34034,16 @@ var _internals46 = {
   findSimilarCommands,
   buildDetailedHelp
 };
-var validation = _internals46.validateAliases();
+var validation = _internals47.validateAliases();
 if (!validation.valid) {
   throw new Error(`COMMAND_REGISTRY alias validation failed:
 ${validation.errors.join(`
 `)}`);
 }
-_internals46.emitValidationWarnings("COMMAND_REGISTRY alias warnings", validation.warnings);
+_internals47.emitValidationWarnings("COMMAND_REGISTRY alias warnings", validation.warnings);
 try {
-  const toolPolicyValidation = _internals46.validateToolPolicy();
-  _internals46.emitValidationWarnings("COMMAND_REGISTRY toolPolicy warnings", toolPolicyValidation.warnings);
+  const toolPolicyValidation = _internals47.validateToolPolicy();
+  _internals47.emitValidationWarnings("COMMAND_REGISTRY toolPolicy warnings", toolPolicyValidation.warnings);
 } catch (e) {
   warn(`COMMAND_REGISTRY toolPolicy validation failed (non-fatal): ${e.message}`);
 }
@@ -33349,7 +34102,7 @@ function formatCommandNotFound(tokens) {
   const attemptedCommand = tokens[0] || "";
   const MAX_DISPLAY = 100;
   const displayCommand = attemptedCommand.length > MAX_DISPLAY ? `${attemptedCommand.slice(0, MAX_DISPLAY)}...` : attemptedCommand;
-  const similar = _internals46.findSimilarCommands(attemptedCommand);
+  const similar = _internals47.findSimilarCommands(attemptedCommand);
   const header = `Command \`/swarm ${displayCommand}\` not found.`;
   const suggestions = similar.length > 0 ? `Did you mean:
 ${similar.map((cmd) => `  - /swarm ${cmd}`).join(`
@@ -33406,4 +34159,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, 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, _internals46 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, _internals47 as _internals, resolveCommand };