opencode-swarm 7.88.0 → 7.88.1

package/dist/cli/{index-jch711dq.js → index-4td9ef53.js}

@@ -899,7 +899,7 @@ var init_executor = __esm(() => {
 // package.json
 var package_default = {
   name: "opencode-swarm",
-  version: "7.88.0",
+  version: "7.88.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",
@@ -18335,7 +18335,7 @@ ${USAGE7}`;
 
 // src/commands/memory.ts
 import { existsSync as existsSync25 } from "fs";
-import * as path42 from "path";
+import * as path43 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/memory/config.ts
@@ -18367,7 +18367,8 @@ var DEFAULT_MEMORY_CONFIG = {
   },
   maintenance: {
     lowUtilityMaxConfidence: 0.45,
-    lowUtilityMinAgeDays: 30
+    lowUtilityMinAgeDays: 30,
+    autoCompactEveryNRecalls: 50
   },
   hardDelete: false
 };
@@ -18428,7 +18429,7 @@ class MemoryValidationError extends Error {
 // src/memory/evaluation.ts
 import * as fs17 from "fs/promises";
 import * as os9 from "os";
-import * as path41 from "path";
+import * as path42 from "path";
 
 // src/memory/local-jsonl-provider.ts
 import { randomUUID as randomUUID5 } from "crypto";
@@ -19669,6 +19670,10 @@ async function writeJsonlAtomic(filePath, values) {
   await rename5(tmp, filePath);
 }
 
+// src/memory/provider-pool.ts
+import { realpathSync as realpathSync2 } from "fs";
+import * as path41 from "path";
+
 // src/memory/sqlite-provider.ts
 import { randomUUID as randomUUID6 } from "crypto";
 import { mkdirSync as mkdirSync15 } from "fs";
@@ -19907,6 +19912,7 @@ function loadDatabaseCtor2() {
   _DatabaseCtor2 = req("bun:sqlite").Database;
   return _DatabaseCtor2;
 }
+var RECALL_CANDIDATE_LIMIT = 1000;
 var FTS_SCHEMA_MIGRATION_NAME = "create_memory_fts5_shadow_index";
 var FTS_TABLE_NAME = "memory_items_fts";
 var FTS_INDEX_COLUMNS = [
@@ -20004,6 +20010,24 @@ var MIGRATIONS2 = [
 				${ftsCreateColumnsSql()}
 			);
 		`
+  },
+  {
+    version: 4,
+    name: "create_meta_table",
+    sql: `
+			CREATE TABLE IF NOT EXISTS _meta (
+				key TEXT PRIMARY KEY,
+				value TEXT NOT NULL
+			);
+		`
+  },
+  {
+    version: 5,
+    name: "create_recall_usage_timestamp_index",
+    sql: `
+			CREATE INDEX IF NOT EXISTS idx_memory_recall_usage_timestamp
+				ON memory_recall_usage(timestamp DESC);
+		`
   }
 ];
 
@@ -20018,6 +20042,8 @@ class SQLiteMemoryProvider {
   memories = new Map;
   proposals = new Map;
   lastAutomaticJsonlMigration = null;
+  recallCountSinceLastCompaction = 0;
+  isCompacting = false;
   constructor(rootDirectory, config = {}) {
     this.rootDirectory = rootDirectory;
     this.config = {
@@ -20075,6 +20101,7 @@ class SQLiteMemoryProvider {
     this.db.run(`PRAGMA busy_timeout = ${busyTimeoutMs};`);
     this.db.run("PRAGMA foreign_keys = ON;");
     this.runMigrations();
+    this.backfillScopeKeys();
     this.ftsAvailable = this.initializeFtsIndex();
     this.lastAutomaticJsonlMigration = null;
     await this.migrateLegacyJsonlIfNeeded();
@@ -20137,7 +20164,8 @@ class SQLiteMemoryProvider {
     const scopedRecords = await this.list({
       scopes: request.scopes,
       kinds: request.kinds,
-      includeExpired: request.includeExpired
+      includeExpired: request.includeExpired,
+      limit: RECALL_CANDIDATE_LIMIT
     });
     const candidates = this.selectRecallCandidates(request, scopedRecords);
     const result = scoreMemoryRecordsWithDiagnostics(candidates.records, request);
@@ -20158,7 +20186,29 @@ class SQLiteMemoryProvider {
 				timestamp,
 				usage_json
 			) VALUES (?, ?, ?, ?)`, [randomUUID6(), event.bundleId, event.timestamp, JSON.stringify(event)]);
-    await this.event("recall", event.bundleId, JSON.stringify(event));
+    this.recallCountSinceLastCompaction++;
+    const threshold = this.config.maintenance?.autoCompactEveryNRecalls ?? 50;
+    if (threshold > 0 && this.recallCountSinceLastCompaction >= threshold && !this.isCompacting) {
+      this.recallCountSinceLastCompaction = 0;
+      this.isCompacting = true;
+      this.compactMaintenance({ dryRun: false }).then((result) => {
+        const rowsInspected = result.remaining + result.removedDeleted + result.removedSuperseded + result.removedExpiredScratch;
+        const rowsPurged = result.removedDeleted + result.removedSuperseded + result.removedExpiredScratch;
+        return this.insertEvent("compact_triggered", "memory_items", "auto compaction triggered", JSON.stringify({
+          trigger: "auto",
+          threshold,
+          rowsInspected,
+          rowsPurged,
+          timestamp: new Date().toISOString()
+        }));
+      }).catch((err) => {
+        if (process.env.OPENCODE_SWARM_DEBUG === "1") {
+          console.debug(`[memory] auto-compaction failed: ${err}`);
+        }
+      }).finally(() => {
+        this.isCompacting = false;
+      });
+    }
   }
   async listRecallUsage(filter = {}) {
     await this.initialize();
@@ -20182,12 +20232,46 @@ class SQLiteMemoryProvider {
   }
   async list(filter = {}) {
     await this.initialize();
-    let records = Array.from(this.memories.values());
+    const db = this.requireDb();
+    const conditions = [];
+    const params = [];
     if (filter.scopes && filter.scopes.length > 0) {
-      records = records.filter((record) => scopeAllowed(record.scope, filter.scopes ?? []));
+      const scopeKeys = filter.scopes.map((scope) => stableScopeKey(scope));
+      const placeholders = scopeKeys.map(() => "?").join(", ");
+      conditions.push(`scope_key IN (${placeholders})`);
+      params.push(...scopeKeys);
     }
     if (filter.kinds && filter.kinds.length > 0) {
-      records = records.filter((record) => filter.kinds?.includes(record.kind));
+      if (filter.kinds.length === 1) {
+        conditions.push("kind = ?");
+        params.push(filter.kinds[0]);
+      } else {
+        const placeholders = filter.kinds.map(() => "?").join(", ");
+        conditions.push(`kind IN (${placeholders})`);
+        params.push(...filter.kinds);
+      }
+    }
+    if (!filter.includeInactive) {
+      conditions.push("superseded_by IS NULL");
+      conditions.push("deleted = 0");
+    }
+    if (!filter.includeExpired) {
+      const nowIso = new Date().toISOString();
+      conditions.push("(expires_at IS NULL OR expires_at > ?)");
+      params.push(nowIso);
+    }
+    const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    let sql = `SELECT id, record_json FROM memory_items ${whereClause} ORDER BY updated_at DESC`;
+    if (typeof filter.limit === "number") {
+      sql += " LIMIT ?";
+      params.push(Math.trunc(filter.limit));
+    }
+    const rows = db.query(sql).all(...params);
+    let records = [];
+    for (const row of rows) {
+      const parsed = this.parseMemoryRow(row);
+      if (parsed)
+        records.push(parsed);
     }
     if (!filter.includeExpired) {
       const now = Date.now();
@@ -20198,11 +20282,7 @@ class SQLiteMemoryProvider {
         return !Number.isFinite(expires) || expires > now;
       });
     }
-    if (!filter.includeInactive) {
-      records = records.filter((record) => !record.supersededBy && record.metadata.deleted !== true);
-    }
-    records.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
-    return records.slice(0, filter.limit ?? records.length);
+    return records;
   }
   async createProposal(proposal) {
     await this.initialize();
@@ -20392,6 +20472,31 @@ class SQLiteMemoryProvider {
       apply();
     }
   }
+  backfillScopeKeys() {
+    const db = this.requireDb();
+    const metaRow = db.query("SELECT value FROM _meta WHERE key = 'scope_key_backfilled'").get("scope_key_backfilled");
+    if (metaRow?.value === "1")
+      return;
+    const rows = db.query("SELECT id, record_json, scope_key FROM memory_items").all();
+    let backfillCount = 0;
+    for (const row of rows) {
+      try {
+        const record = JSON.parse(row.record_json);
+        const canonicalKey = stableScopeKey(record.scope);
+        if (row.scope_key !== canonicalKey) {
+          db.run("UPDATE memory_items SET scope_key = ? WHERE id = ?", [
+            canonicalKey,
+            row.id
+          ]);
+          backfillCount++;
+        }
+      } catch {}
+    }
+    if (backfillCount > 0) {
+      this.insertEvent("migration", "backfill_scope_keys", `${backfillCount} memory item(s) scope_key backfilled to canonical form`);
+    }
+    db.run("INSERT OR REPLACE INTO _meta (key, value) VALUES ('scope_key_backfilled', '1')");
+  }
   initializeFtsIndex() {
     const db = this.requireDb();
     try {
@@ -20502,7 +20607,7 @@ class SQLiteMemoryProvider {
 				record_json
 			) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`, [
       record.id,
-      JSON.stringify(record.scope),
+      stableScopeKey(record.scope),
       record.kind,
       record.updatedAt,
       record.expiresAt ?? null,
@@ -20878,14 +20983,203 @@ function rerankWithFts(items, ftsOrder) {
   }).sort((a, b) => b.score - a.score || a.record.id.localeCompare(b.record.id));
 }
 
+// src/memory/provider-pool.ts
+var MAX_POOL_SIZE = 16;
+var POOLED_MARKER = Symbol("opencode-swarm-pooled-provider");
+var REAL_CLOSE = Symbol("opencode-swarm-real-close");
+var head = null;
+var tail = null;
+var entriesByKey = new Map;
+var deferredEntries = new Set;
+function markAsPooled(provider) {
+  const originalClose = provider.close;
+  provider.close = () => {
+    releaseProvider(provider);
+    return Promise.resolve();
+  };
+  provider[POOLED_MARKER] = true;
+  if (originalClose) {
+    provider[REAL_CLOSE] = originalClose;
+  }
+}
+function callRealClose(provider) {
+  const realClose = provider[REAL_CLOSE];
+  try {
+    realClose?.call(provider);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (process.env.OPENCODE_SWARM_DEBUG === "1") {
+      console.debug(`[provider-pool] real close failed: ${msg}`);
+    }
+  }
+}
+function isPooledProvider(provider) {
+  return POOLED_MARKER in provider;
+}
+function getOrCreateProvider(directory, config) {
+  const key = resolvePoolKey(directory);
+  const existing = entriesByKey.get(key);
+  if (existing) {
+    moveToHead(existing);
+    existing.refCount++;
+    return existing.provider;
+  }
+  for (const deferred of deferredEntries) {
+    if (deferred.key === key) {
+      deferredEntries.delete(deferred);
+      if (entriesByKey.size >= MAX_POOL_SIZE) {
+        evictLru();
+      }
+      deferred.prev = null;
+      deferred.next = head;
+      if (head)
+        head.prev = deferred;
+      head = deferred;
+      if (!tail)
+        tail = deferred;
+      entriesByKey.set(key, deferred);
+      deferred.refCount++;
+      return deferred.provider;
+    }
+  }
+  const provider = new SQLiteMemoryProvider(directory, config);
+  markAsPooled(provider);
+  if (entriesByKey.size >= MAX_POOL_SIZE) {
+    evictLru();
+  }
+  const entry = {
+    key,
+    provider,
+    refCount: 1,
+    prev: null,
+    next: head
+  };
+  if (head)
+    head.prev = entry;
+  head = entry;
+  if (!tail)
+    tail = entry;
+  entriesByKey.set(key, entry);
+  return provider;
+}
+function releaseProvider(provider) {
+  for (const [_key, entry] of entriesByKey) {
+    if (entry.provider === provider) {
+      entry.refCount = Math.max(0, entry.refCount - 1);
+      return;
+    }
+  }
+  for (const entry of deferredEntries) {
+    if (entry.provider === provider) {
+      entry.refCount--;
+      if (entry.refCount <= 0) {
+        deferredEntries.delete(entry);
+        callRealClose(provider);
+      }
+      return;
+    }
+  }
+  if (isPooledProvider(provider)) {
+    callRealClose(provider);
+  }
+}
+function evictLru() {
+  if (!tail)
+    return;
+  const evicted = tail;
+  entriesByKey.delete(evicted.key);
+  unlinkEntry(evicted);
+  if (evicted.refCount > 0) {
+    deferredEntries.add(evicted);
+  } else {
+    callRealClose(evicted.provider);
+  }
+}
+function moveToHead(entry) {
+  if (head === entry)
+    return;
+  unlinkEntry(entry);
+  entry.prev = null;
+  entry.next = head;
+  if (head)
+    head.prev = entry;
+  head = entry;
+  if (!tail)
+    tail = entry;
+}
+function unlinkEntry(entry) {
+  if (entry.prev)
+    entry.prev.next = entry.next;
+  if (entry.next)
+    entry.next.prev = entry.prev;
+  if (head === entry)
+    head = entry.next;
+  if (tail === entry)
+    tail = entry.prev;
+}
+function resolvePoolKey(directory) {
+  try {
+    return realpathSync2(directory);
+  } catch {
+    return path41.resolve(directory);
+  }
+}
+
 // src/memory/gateway.ts
 function createConfiguredMemoryProvider(directory, config) {
   if (config.provider === "sqlite") {
-    return new SQLiteMemoryProvider(directory, config);
+    return getOrCreateProvider(directory, config);
   }
   return new LocalJsonlMemoryProvider(directory, config);
 }
 var gitRemoteUrlCache = new Map;
+var RESERVED_IDENTIFIERS = new Set([
+  "const",
+  "let",
+  "var",
+  "function",
+  "class",
+  "interface",
+  "type",
+  "async",
+  "await",
+  "return",
+  "if",
+  "else",
+  "for",
+  "while",
+  "do",
+  "switch",
+  "case",
+  "break",
+  "continue",
+  "new",
+  "this",
+  "super",
+  "extends",
+  "implements",
+  "import",
+  "export",
+  "from",
+  "default",
+  "try",
+  "catch",
+  "finally",
+  "throw",
+  "typeof",
+  "instanceof",
+  "in",
+  "of",
+  "as",
+  "yield",
+  "static",
+  "get",
+  "set",
+  "readonly",
+  "public",
+  "private",
+  "protected"
+]);
 
 // src/memory/evaluation.ts
 var DEFAULT_PROVIDERS = [
@@ -20899,7 +21193,7 @@ var DEFAULT_MODES = [
 ];
 var DEFAULT_TIMESTAMP = "2026-05-26T12:00:00.000Z";
 async function evaluateMemoryRecallFixtures(options) {
-  const fixtureDirectory = path41.resolve(options.fixtureDirectory);
+  const fixtureDirectory = path42.resolve(options.fixtureDirectory);
   const providers = options.providers ?? DEFAULT_PROVIDERS;
   const modes = options.modes ?? DEFAULT_MODES;
   const generatedAt = new Date().toISOString();
@@ -20908,7 +21202,7 @@ async function evaluateMemoryRecallFixtures(options) {
   for (const fixture of fixtures) {
     const materialized = materializeFixture(fixture);
     for (const providerName of providers) {
-      const tempRoot = await fs17.realpath(await fs17.mkdtemp(path41.join(os9.tmpdir(), "swarm-memory-eval-")));
+      const tempRoot = await fs17.realpath(await fs17.mkdtemp(path42.join(os9.tmpdir(), "swarm-memory-eval-")));
       const provider = createEvaluationProvider(providerName, tempRoot);
       try {
         await provider.initialize?.();
@@ -20952,7 +21246,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 fs17.readFile(path41.join(fixtureDirectory, file), "utf-8");
+    const raw = await fs17.readFile(path42.join(fixtureDirectory, file), "utf-8");
     fixtures.push(validateFixture(JSON.parse(raw), file));
   }
   return fixtures;
@@ -21228,7 +21522,7 @@ var CuratorOutputMemoryDecisionSchema = exports_external.object({
   curatorMemoryDecisions: exports_external.array(CuratorMemoryDecisionSchema).max(20).optional()
 }).passthrough();
 // src/commands/memory.ts
-var PACKAGE_ROOT = path42.resolve(resolvePackageRootFromModule(fileURLToPath2(import.meta.url)));
+var PACKAGE_ROOT = path43.resolve(resolvePackageRootFromModule(fileURLToPath2(import.meta.url)));
 async function handleMemoryCommand(_directory, _args) {
   return [
     "## Swarm Memory",
@@ -21497,7 +21791,7 @@ function resolveCommandMemoryConfig(directory) {
 }
 function parseEvaluateArgs(directory, args) {
   let json = false;
-  let fixtureDirectory = path42.join(PACKAGE_ROOT, "tests", "fixtures", "memory-recall");
+  let fixtureDirectory = path43.join(PACKAGE_ROOT, "tests", "fixtures", "memory-recall");
   for (let i = 0;i < args.length; i++) {
     const arg = args[i];
     if (arg === "--json") {
@@ -21511,10 +21805,10 @@ function parseEvaluateArgs(directory, args) {
           error: "Usage: /swarm memory evaluate [--json] [--fixtures <directory>]"
         };
       }
-      const resolvedFixtures = path42.resolve(directory, next);
-      const canonical = path42.normalize(resolvedFixtures) + path42.sep;
-      const allowedRootA = path42.normalize(directory) + path42.sep;
-      const allowedRootB = path42.normalize(path42.join(PACKAGE_ROOT, "tests", "fixtures", "memory-recall")) + path42.sep;
+      const resolvedFixtures = path43.resolve(directory, next);
+      const canonical = path43.normalize(resolvedFixtures) + path43.sep;
+      const allowedRootA = path43.normalize(directory) + path43.sep;
+      const allowedRootB = path43.normalize(path43.join(PACKAGE_ROOT, "tests", "fixtures", "memory-recall")) + path43.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"
@@ -21553,15 +21847,15 @@ function parseMaintenanceArgs(args, options) {
   return { limit, confirm };
 }
 function resolvePackageRootFromModule(modulePath) {
-  const moduleDir = path42.dirname(modulePath);
-  const leaf = path42.basename(moduleDir);
+  const moduleDir = path43.dirname(modulePath);
+  const leaf = path43.basename(moduleDir);
   if (leaf === "commands" || leaf === "cli") {
-    return path42.resolve(moduleDir, "..", "..");
+    return path43.resolve(moduleDir, "..", "..");
   }
   if (leaf === "dist") {
-    return path42.resolve(moduleDir, "..");
+    return path43.resolve(moduleDir, "..");
   }
-  return path42.resolve(moduleDir, "..");
+  return path43.resolve(moduleDir, "..");
 }
 function formatMigrationResult(label, report) {
   if (!report) {
@@ -22243,11 +22537,11 @@ var _internals36 = {
 
 // src/services/preflight-service.ts
 import * as fs24 from "fs";
-import * as path49 from "path";
+import * as path50 from "path";
 
 // src/tools/lint.ts
 import * as fs18 from "fs";
-import * as path43 from "path";
+import * as path44 from "path";
 
 // src/utils/path-security.ts
 function containsPathTraversal(str) {
@@ -22303,9 +22597,9 @@ function validateArgs(args) {
 }
 function getLinterCommand(linter, mode, projectDir) {
   const isWindows = process.platform === "win32";
-  const binDir = path43.join(projectDir, "node_modules", ".bin");
-  const biomeBin = isWindows ? path43.join(binDir, "biome.EXE") : path43.join(binDir, "biome");
-  const eslintBin = isWindows ? path43.join(binDir, "eslint.cmd") : path43.join(binDir, "eslint");
+  const binDir = path44.join(projectDir, "node_modules", ".bin");
+  const biomeBin = isWindows ? path44.join(binDir, "biome.EXE") : path44.join(binDir, "biome");
+  const eslintBin = isWindows ? path44.join(binDir, "eslint.cmd") : path44.join(binDir, "eslint");
   switch (linter) {
     case "biome":
       if (mode === "fix") {
@@ -22321,7 +22615,7 @@ function getLinterCommand(linter, mode, projectDir) {
 }
 function getAdditionalLinterCommand(linter, mode, cwd) {
   const gradlewName = process.platform === "win32" ? "gradlew.bat" : "gradlew";
-  const gradlew = fs18.existsSync(path43.join(cwd, gradlewName)) ? path43.join(cwd, gradlewName) : null;
+  const gradlew = fs18.existsSync(path44.join(cwd, gradlewName)) ? path44.join(cwd, gradlewName) : null;
   switch (linter) {
     case "ruff":
       return mode === "fix" ? ["ruff", "check", "--fix", "."] : ["ruff", "check", "."];
@@ -22355,10 +22649,10 @@ function getAdditionalLinterCommand(linter, mode, cwd) {
   }
 }
 function detectRuff(cwd) {
-  if (fs18.existsSync(path43.join(cwd, "ruff.toml")))
+  if (fs18.existsSync(path44.join(cwd, "ruff.toml")))
     return isCommandAvailable("ruff");
   try {
-    const pyproject = path43.join(cwd, "pyproject.toml");
+    const pyproject = path44.join(cwd, "pyproject.toml");
     if (fs18.existsSync(pyproject)) {
       const content = fs18.readFileSync(pyproject, "utf-8");
       if (content.includes("[tool.ruff]"))
@@ -22368,19 +22662,19 @@ function detectRuff(cwd) {
   return false;
 }
 function detectClippy(cwd) {
-  return fs18.existsSync(path43.join(cwd, "Cargo.toml")) && isCommandAvailable("cargo");
+  return fs18.existsSync(path44.join(cwd, "Cargo.toml")) && isCommandAvailable("cargo");
 }
 function detectGolangciLint(cwd) {
-  return fs18.existsSync(path43.join(cwd, "go.mod")) && isCommandAvailable("golangci-lint");
+  return fs18.existsSync(path44.join(cwd, "go.mod")) && isCommandAvailable("golangci-lint");
 }
 function detectCheckstyle(cwd) {
-  const hasMaven = fs18.existsSync(path43.join(cwd, "pom.xml"));
-  const hasGradle = fs18.existsSync(path43.join(cwd, "build.gradle")) || fs18.existsSync(path43.join(cwd, "build.gradle.kts"));
-  const hasBinary = hasMaven && isCommandAvailable("mvn") || hasGradle && (fs18.existsSync(path43.join(cwd, "gradlew")) || isCommandAvailable("gradle"));
+  const hasMaven = fs18.existsSync(path44.join(cwd, "pom.xml"));
+  const hasGradle = fs18.existsSync(path44.join(cwd, "build.gradle")) || fs18.existsSync(path44.join(cwd, "build.gradle.kts"));
+  const hasBinary = hasMaven && isCommandAvailable("mvn") || hasGradle && (fs18.existsSync(path44.join(cwd, "gradlew")) || isCommandAvailable("gradle"));
   return (hasMaven || hasGradle) && hasBinary;
 }
 function detectKtlint(cwd) {
-  const hasKotlin = fs18.existsSync(path43.join(cwd, "build.gradle.kts")) || fs18.existsSync(path43.join(cwd, "build.gradle")) || (() => {
+  const hasKotlin = fs18.existsSync(path44.join(cwd, "build.gradle.kts")) || fs18.existsSync(path44.join(cwd, "build.gradle")) || (() => {
     try {
       return fs18.readdirSync(cwd).some((f) => f.endsWith(".kt") || f.endsWith(".kts"));
     } catch {
@@ -22399,11 +22693,11 @@ function detectDotnetFormat(cwd) {
   }
 }
 function detectCppcheck(cwd) {
-  if (fs18.existsSync(path43.join(cwd, "CMakeLists.txt"))) {
+  if (fs18.existsSync(path44.join(cwd, "CMakeLists.txt"))) {
     return isCommandAvailable("cppcheck");
   }
   try {
-    const dirsToCheck = [cwd, path43.join(cwd, "src")];
+    const dirsToCheck = [cwd, path44.join(cwd, "src")];
     const hasCpp = dirsToCheck.some((dir) => {
       try {
         return fs18.readdirSync(dir).some((f) => /\.(c|cpp|cc|cxx|h|hpp)$/.test(f));
@@ -22417,13 +22711,13 @@ function detectCppcheck(cwd) {
   }
 }
 function detectSwiftlint(cwd) {
-  return fs18.existsSync(path43.join(cwd, "Package.swift")) && isCommandAvailable("swiftlint");
+  return fs18.existsSync(path44.join(cwd, "Package.swift")) && isCommandAvailable("swiftlint");
 }
 function detectDartAnalyze(cwd) {
-  return fs18.existsSync(path43.join(cwd, "pubspec.yaml")) && (isCommandAvailable("dart") || isCommandAvailable("flutter"));
+  return fs18.existsSync(path44.join(cwd, "pubspec.yaml")) && (isCommandAvailable("dart") || isCommandAvailable("flutter"));
 }
 function detectRubocop(cwd) {
-  return (fs18.existsSync(path43.join(cwd, "Gemfile")) || fs18.existsSync(path43.join(cwd, "gems.rb")) || fs18.existsSync(path43.join(cwd, ".rubocop.yml"))) && (isCommandAvailable("rubocop") || isCommandAvailable("bundle"));
+  return (fs18.existsSync(path44.join(cwd, "Gemfile")) || fs18.existsSync(path44.join(cwd, "gems.rb")) || fs18.existsSync(path44.join(cwd, ".rubocop.yml"))) && (isCommandAvailable("rubocop") || isCommandAvailable("bundle"));
 }
 function detectAdditionalLinter(cwd) {
   if (detectRuff(cwd))
@@ -22451,10 +22745,10 @@ function detectAdditionalLinter(cwd) {
 function findBinInAncestors(startDir, binName) {
   let dir = startDir;
   while (true) {
-    const candidate = path43.join(dir, "node_modules", ".bin", binName);
+    const candidate = path44.join(dir, "node_modules", ".bin", binName);
     if (fs18.existsSync(candidate))
       return candidate;
-    const parent = path43.dirname(dir);
+    const parent = path44.dirname(dir);
     if (parent === dir)
       break;
     dir = parent;
@@ -22463,10 +22757,10 @@ function findBinInAncestors(startDir, binName) {
 }
 function findBinInEnvPath(binName) {
   const searchPath = process.env.PATH ?? "";
-  for (const dir of searchPath.split(path43.delimiter)) {
+  for (const dir of searchPath.split(path44.delimiter)) {
     if (!dir)
       continue;
-    const candidate = path43.join(dir, binName);
+    const candidate = path44.join(dir, binName);
     if (fs18.existsSync(candidate))
       return candidate;
   }
@@ -22479,13 +22773,13 @@ async function detectAvailableLinter(directory) {
     return null;
   const projectDir = directory;
   const isWindows = process.platform === "win32";
-  const biomeBin = isWindows ? path43.join(projectDir, "node_modules", ".bin", "biome.EXE") : path43.join(projectDir, "node_modules", ".bin", "biome");
-  const eslintBin = isWindows ? path43.join(projectDir, "node_modules", ".bin", "eslint.cmd") : path43.join(projectDir, "node_modules", ".bin", "eslint");
+  const biomeBin = isWindows ? path44.join(projectDir, "node_modules", ".bin", "biome.EXE") : path44.join(projectDir, "node_modules", ".bin", "biome");
+  const eslintBin = isWindows ? path44.join(projectDir, "node_modules", ".bin", "eslint.cmd") : path44.join(projectDir, "node_modules", ".bin", "eslint");
   const localResult = await _detectAvailableLinter(projectDir, biomeBin, eslintBin);
   if (localResult)
     return localResult;
-  const biomeAncestor = findBinInAncestors(path43.dirname(projectDir), isWindows ? "biome.EXE" : "biome");
-  const eslintAncestor = findBinInAncestors(path43.dirname(projectDir), isWindows ? "eslint.cmd" : "eslint");
+  const biomeAncestor = findBinInAncestors(path44.dirname(projectDir), isWindows ? "biome.EXE" : "biome");
+  const eslintAncestor = findBinInAncestors(path44.dirname(projectDir), isWindows ? "eslint.cmd" : "eslint");
   if (biomeAncestor || eslintAncestor) {
     return _detectAvailableLinter(projectDir, biomeAncestor ?? biomeBin, eslintAncestor ?? eslintBin);
   }
@@ -22504,7 +22798,7 @@ async function _detectAvailableLinter(_projectDir, biomeBin, eslintBin) {
       stderr: "pipe"
     });
     const biomeExit = biomeProc.exited;
-    const timeout = new Promise((resolve12) => setTimeout(() => resolve12("timeout"), DETECT_TIMEOUT));
+    const timeout = new Promise((resolve13) => setTimeout(() => resolve13("timeout"), DETECT_TIMEOUT));
     const result = await Promise.race([biomeExit, timeout]);
     if (result === "timeout") {
       biomeProc.kill();
@@ -22518,7 +22812,7 @@ async function _detectAvailableLinter(_projectDir, biomeBin, eslintBin) {
       stderr: "pipe"
     });
     const eslintExit = eslintProc.exited;
-    const timeout = new Promise((resolve12) => setTimeout(() => resolve12("timeout"), DETECT_TIMEOUT));
+    const timeout = new Promise((resolve13) => setTimeout(() => resolve13("timeout"), DETECT_TIMEOUT));
     const result = await Promise.race([eslintExit, timeout]);
     if (result === "timeout") {
       eslintProc.kill();
@@ -22699,7 +22993,7 @@ var _internals37 = {
 
 // src/tools/secretscan.ts
 import * as fs19 from "fs";
-import * as path44 from "path";
+import * as path45 from "path";
 var MAX_FILE_PATH_LENGTH = 500;
 var MAX_FILE_SIZE_BYTES = 512 * 1024;
 var MAX_FILES_SCANNED = 1000;
@@ -22926,7 +23220,7 @@ function isGlobOrPathPattern(pattern) {
   return pattern.includes("/") || pattern.includes("\\") || /[*?[\]{}]/.test(pattern);
 }
 function loadSecretScanIgnore(scanDir) {
-  const ignorePath = path44.join(scanDir, ".secretscanignore");
+  const ignorePath = path45.join(scanDir, ".secretscanignore");
   try {
     if (!fs19.existsSync(ignorePath))
       return [];
@@ -22949,7 +23243,7 @@ function isExcluded(entry, relPath, exactNames, globPatterns) {
   if (exactNames.has(entry))
     return true;
   for (const pattern of globPatterns) {
-    if (path44.matchesGlob(relPath, pattern))
+    if (path45.matchesGlob(relPath, pattern))
       return true;
   }
   return false;
@@ -22970,7 +23264,7 @@ function validateDirectoryInput(dir) {
   return null;
 }
 function isBinaryFile(filePath, buffer) {
-  const ext = path44.extname(filePath).toLowerCase();
+  const ext = path45.extname(filePath).toLowerCase();
   if (DEFAULT_EXCLUDE_EXTENSIONS.has(ext)) {
     return true;
   }
@@ -23107,9 +23401,9 @@ function isSymlinkLoop(realPath, visited) {
   return false;
 }
 function isPathWithinScope(realPath, scanDir) {
-  const resolvedScanDir = path44.resolve(scanDir);
-  const resolvedRealPath = path44.resolve(realPath);
-  return resolvedRealPath === resolvedScanDir || resolvedRealPath.startsWith(resolvedScanDir + path44.sep) || resolvedRealPath.startsWith(`${resolvedScanDir}/`) || resolvedRealPath.startsWith(`${resolvedScanDir}\\`);
+  const resolvedScanDir = path45.resolve(scanDir);
+  const resolvedRealPath = path45.resolve(realPath);
+  return resolvedRealPath === resolvedScanDir || resolvedRealPath.startsWith(resolvedScanDir + path45.sep) || resolvedRealPath.startsWith(`${resolvedScanDir}/`) || resolvedRealPath.startsWith(`${resolvedScanDir}\\`);
 }
 function findScannableFiles(dir, excludeExact, excludeGlobs, scanDir, visited, stats = {
   skippedDirs: 0,
@@ -23135,8 +23429,8 @@ function findScannableFiles(dir, excludeExact, excludeGlobs, scanDir, visited, s
     return a.localeCompare(b);
   });
   for (const entry of entries) {
-    const fullPath = path44.join(dir, entry);
-    const relPath = path44.relative(scanDir, fullPath).replace(/\\/g, "/");
+    const fullPath = path45.join(dir, entry);
+    const relPath = path45.relative(scanDir, fullPath).replace(/\\/g, "/");
     if (isExcluded(entry, relPath, excludeExact, excludeGlobs)) {
       stats.skippedDirs++;
       continue;
@@ -23171,7 +23465,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 = path44.extname(fullPath).toLowerCase();
+      const ext = path45.extname(fullPath).toLowerCase();
       if (!DEFAULT_EXCLUDE_EXTENSIONS.has(ext)) {
         files.push(fullPath);
       } else {
@@ -23237,7 +23531,7 @@ var secretscan = createSwarmTool({
       }
     }
     try {
-      const _scanDirRaw = path44.resolve(directory);
+      const _scanDirRaw = path45.resolve(directory);
       const scanDir = (() => {
         try {
           return fs19.realpathSync(_scanDirRaw);
@@ -23400,11 +23694,11 @@ var _internals38 = {
 
 // src/tools/test-runner.ts
 import * as fs23 from "fs";
-import * as path48 from "path";
+import * as path49 from "path";
 
 // src/test-impact/analyzer.ts
 import fs20 from "fs";
-import path45 from "path";
+import path46 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;
@@ -23445,8 +23739,8 @@ function resolveRelativeImport(fromDir, importPath) {
   if (!importPath.startsWith(".")) {
     return null;
   }
-  const resolved = path45.resolve(fromDir, importPath);
-  if (path45.extname(resolved)) {
+  const resolved = path46.resolve(fromDir, importPath);
+  if (path46.extname(resolved)) {
     if (fs20.existsSync(resolved) && fs20.statSync(resolved).isFile()) {
       return normalizePath2(resolved);
     }
@@ -23466,20 +23760,20 @@ function resolvePythonImport(fromDir, module) {
   const leadingDots = module.match(/^\.+/)?.[0].length ?? 0;
   let baseDir = fromDir;
   for (let i = 1;i < leadingDots; i++) {
-    baseDir = path45.dirname(baseDir);
+    baseDir = path46.dirname(baseDir);
   }
   const rest = module.slice(leadingDots);
   if (rest.length === 0) {
-    const initPath = path45.join(baseDir, "__init__.py");
+    const initPath = path46.join(baseDir, "__init__.py");
     if (fs20.existsSync(initPath) && fs20.statSync(initPath).isFile()) {
       return normalizePath2(initPath);
     }
     return null;
   }
-  const subpath = rest.replace(/\./g, path45.sep);
+  const subpath = rest.replace(/\./g, path46.sep);
   const candidates = [
-    `${path45.join(baseDir, subpath)}.py`,
-    path45.join(baseDir, subpath, "__init__.py")
+    `${path46.join(baseDir, subpath)}.py`,
+    path46.join(baseDir, subpath, "__init__.py")
   ];
   for (const c of candidates) {
     if (fs20.existsSync(c) && fs20.statSync(c).isFile())
@@ -23489,7 +23783,7 @@ function resolvePythonImport(fromDir, module) {
 }
 var goModuleCache = new Map;
 function findGoModule(fromDir) {
-  const resolved = path45.resolve(fromDir);
+  const resolved = path46.resolve(fromDir);
   let cur = resolved;
   const walked = [];
   for (let i = 0;i < 16; i++) {
@@ -23501,7 +23795,7 @@ function findGoModule(fromDir) {
     }
     walked.push(cur);
     try {
-      const goMod = path45.join(cur, "go.mod");
+      const goMod = path46.join(cur, "go.mod");
       const content = fs20.readFileSync(goMod, "utf-8");
       const moduleMatch = content.match(/^\s*module\s+"?([^"\s/]+(?:\/[^"\s]+)*)"?/m);
       if (moduleMatch) {
@@ -23512,10 +23806,10 @@ function findGoModule(fromDir) {
       }
     } catch {}
     try {
-      fs20.accessSync(path45.join(cur, ".git"));
+      fs20.accessSync(path46.join(cur, ".git"));
       break;
     } catch {}
-    const parent = path45.dirname(cur);
+    const parent = path46.dirname(cur);
     if (parent === cur)
       break;
     cur = parent;
@@ -23527,12 +23821,12 @@ function findGoModule(fromDir) {
 function resolveGoImport(fromDir, importPath) {
   let dir = null;
   if (importPath.startsWith(".")) {
-    dir = path45.resolve(fromDir, importPath);
+    dir = path46.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 = path45.join(mod.moduleRoot, subpath);
+      dir = path46.join(mod.moduleRoot, subpath);
     }
   }
   if (dir === null)
@@ -23540,7 +23834,7 @@ function resolveGoImport(fromDir, importPath) {
   if (!fs20.existsSync(dir) || !fs20.statSync(dir).isDirectory())
     return [];
   try {
-    return fs20.readdirSync(dir).filter((f) => f.endsWith(".go") && !f.endsWith("_test.go")).map((f) => normalizePath2(path45.join(dir, f)));
+    return fs20.readdirSync(dir).filter((f) => f.endsWith(".go") && !f.endsWith("_test.go")).map((f) => normalizePath2(path46.join(dir, f)));
   } catch {
     return [];
   }
@@ -23579,15 +23873,15 @@ function findTestFilesSync(cwd) {
     for (const entry of entries) {
       if (entry.isDirectory()) {
         if (!skipDirs.has(entry.name)) {
-          walk(path45.join(dir, entry.name), visitedInodes);
+          walk(path46.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(`${path45.sep}tests${path45.sep}`) && name.endsWith(".py");
+        const isPyTest = /^test_.+\.py$/.test(name) || /.+_test\.py$/.test(name) || dir.includes(`${path46.sep}tests${path46.sep}`) && name.endsWith(".py");
         const isGoTest = /.+_test\.go$/.test(name);
         if (isTsTest || isPyTest || isGoTest) {
-          testFiles.push(normalizePath2(path45.join(dir, entry.name)));
+          testFiles.push(normalizePath2(path46.join(dir, entry.name)));
         }
       }
     }
@@ -23612,8 +23906,8 @@ function extractImports(content) {
   ];
 }
 function addImpactEdgesForTestFile(testFile, content, impactMap) {
-  const ext = path45.extname(testFile).toLowerCase();
-  const testDir = path45.dirname(testFile);
+  const ext = path46.extname(testFile).toLowerCase();
+  const testDir = path46.dirname(testFile);
   function addEdge(source) {
     if (!impactMap[source])
       impactMap[source] = [];
@@ -23686,7 +23980,7 @@ async function buildImpactMap(cwd) {
   return impactMap;
 }
 async function loadImpactMap(cwd, options) {
-  const cachePath = path45.join(cwd, ".swarm", "cache", "impact-map.json");
+  const cachePath = path46.join(cwd, ".swarm", "cache", "impact-map.json");
   if (fs20.existsSync(cachePath)) {
     try {
       const content = fs20.readFileSync(cachePath, "utf-8");
@@ -23719,12 +24013,12 @@ async function loadImpactMap(cwd, options) {
   return _internals39.buildImpactMap(cwd);
 }
 async function saveImpactMap(cwd, impactMap) {
-  if (!path45.isAbsolute(cwd)) {
+  if (!path46.isAbsolute(cwd)) {
     throw new Error(`saveImpactMap requires an absolute project root path, got: "${cwd}"`);
   }
   _internals39.validateProjectRoot(cwd);
-  const cacheDir2 = path45.join(cwd, ".swarm", "cache");
-  const cachePath = path45.join(cacheDir2, "impact-map.json");
+  const cacheDir2 = path46.join(cwd, ".swarm", "cache");
+  const cachePath = path46.join(cacheDir2, "impact-map.json");
   if (!fs20.existsSync(cacheDir2)) {
     fs20.mkdirSync(cacheDir2, { recursive: true });
   }
@@ -23756,7 +24050,7 @@ async function analyzeImpact(changedFiles, cwd, budget) {
       budgetExceeded = true;
       break;
     }
-    const normalizedChanged = normalizePath2(path45.resolve(changedFile));
+    const normalizedChanged = normalizePath2(path46.resolve(changedFile));
     const tests = impactMap[normalizedChanged];
     if (tests && tests.length > 0) {
       for (const test of tests) {
@@ -23770,13 +24064,13 @@ async function analyzeImpact(changedFiles, cwd, budget) {
       if (budgetExceeded)
         break;
     } else {
-      const changedDir = normalizePath2(path45.dirname(normalizedChanged));
-      const changedInputDir = normalizePath2(path45.dirname(changedFile));
+      const changedDir = normalizePath2(path46.dirname(normalizedChanged));
+      const changedInputDir = normalizePath2(path46.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(path45.dirname(sourceA));
-        const sourceDirB = normalizePath2(path45.dirname(sourceB));
+        const sourceDirA = normalizePath2(path46.dirname(sourceA));
+        const sourceDirB = normalizePath2(path46.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)
@@ -24103,7 +24397,7 @@ function detectFlakyTests(allHistory) {
 
 // src/test-impact/history-store.ts
 import fs21 from "fs";
-import path46 from "path";
+import path47 from "path";
 var MAX_HISTORY_PER_TEST = 20;
 var MAX_ERROR_LENGTH = 500;
 var MAX_STACK_LENGTH = 200;
@@ -24115,10 +24409,10 @@ function getHistoryPath(workingDir) {
   if (!workingDir) {
     throw new Error("getHistoryPath requires a working directory \u2014 project root must be provided by the caller");
   }
-  if (!path46.isAbsolute(workingDir)) {
+  if (!path47.isAbsolute(workingDir)) {
     throw new Error(`getHistoryPath requires an absolute project root path, got: "${workingDir}"`);
   }
-  return path46.join(workingDir, ".swarm", "cache", "test-history.jsonl");
+  return path47.join(workingDir, ".swarm", "cache", "test-history.jsonl");
 }
 function sanitizeErrorMessage(errorMessage) {
   if (errorMessage === undefined) {
@@ -24210,7 +24504,7 @@ function batchAppendTestRuns(records, workingDir) {
     }
   }
   const historyPath = getHistoryPath(workingDir);
-  const historyDir = path46.dirname(historyPath);
+  const historyDir = path47.dirname(historyPath);
   _internals40.validateProjectRoot(workingDir);
   if (!fs21.existsSync(historyDir)) {
     fs21.mkdirSync(historyDir, { recursive: true });
@@ -24340,7 +24634,7 @@ var _internals40 = {
 
 // src/tools/resolve-working-directory.ts
 import * as fs22 from "fs";
-import * as path47 from "path";
+import * as path48 from "path";
 function resolveWorkingDirectory(workingDirectory, fallbackDirectory) {
   if (workingDirectory == null || workingDirectory === "") {
     if (typeof fallbackDirectory !== "string" || fallbackDirectory === "") {
@@ -24372,15 +24666,15 @@ function resolveWorkingDirectory(workingDirectory, fallbackDirectory) {
       };
     }
   }
-  const rawPathParts = workingDirectory.split(path47.sep);
+  const rawPathParts = workingDirectory.split(path48.sep);
   if (rawPathParts.includes("..")) {
     return {
       success: false,
       message: "Invalid working_directory: path traversal sequences (..) are not allowed"
     };
   }
-  const normalizedDir = path47.normalize(workingDirectory);
-  const resolvedDir = path47.resolve(normalizedDir);
+  const normalizedDir = path48.normalize(workingDirectory);
+  const resolvedDir = path48.resolve(normalizedDir);
   let statResult;
   try {
     statResult = fs22.statSync(resolvedDir);
@@ -24399,7 +24693,7 @@ function resolveWorkingDirectory(workingDirectory, fallbackDirectory) {
   if (typeof fallbackDirectory !== "string" || fallbackDirectory === "") {
     return { success: true, directory: resolvedDir };
   }
-  const resolvedFallback = path47.resolve(fallbackDirectory);
+  const resolvedFallback = path48.resolve(fallbackDirectory);
   let fallbackExists = false;
   try {
     fs22.statSync(resolvedFallback);
@@ -24408,7 +24702,7 @@ function resolveWorkingDirectory(workingDirectory, fallbackDirectory) {
     fallbackExists = false;
   }
   if (fallbackExists) {
-    const isSubdirectory = resolvedDir.startsWith(resolvedFallback + path47.sep);
+    const isSubdirectory = resolvedDir.startsWith(resolvedFallback + path48.sep);
     if (isSubdirectory) {
       return {
         success: false,
@@ -24431,7 +24725,7 @@ async function estimateFanOut(sourceFiles, cwd) {
     const impactMap = await loadImpactMap(cwd, { skipRebuild: true });
     const uniqueTestFiles = new Set;
     for (const sourceFile of sourceFiles) {
-      const resolvedPath = path48.resolve(cwd, sourceFile);
+      const resolvedPath = path49.resolve(cwd, sourceFile);
       const normalizedPath = resolvedPath.replace(/\\/g, "/");
       const testFiles = impactMap[normalizedPath];
       if (testFiles) {
@@ -24516,14 +24810,14 @@ function hasDevDependency(devDeps, ...patterns) {
   return hasPackageJsonDependency(devDeps, ...patterns);
 }
 function detectGoTest(cwd) {
-  return fs23.existsSync(path48.join(cwd, "go.mod")) && isCommandAvailable("go");
+  return fs23.existsSync(path49.join(cwd, "go.mod")) && isCommandAvailable("go");
 }
 function detectJavaMaven(cwd) {
-  return fs23.existsSync(path48.join(cwd, "pom.xml")) && isCommandAvailable("mvn");
+  return fs23.existsSync(path49.join(cwd, "pom.xml")) && isCommandAvailable("mvn");
 }
 function detectGradle(cwd) {
-  const hasBuildFile = fs23.existsSync(path48.join(cwd, "build.gradle")) || fs23.existsSync(path48.join(cwd, "build.gradle.kts"));
-  const hasGradlew = fs23.existsSync(path48.join(cwd, "gradlew")) || fs23.existsSync(path48.join(cwd, "gradlew.bat"));
+  const hasBuildFile = fs23.existsSync(path49.join(cwd, "build.gradle")) || fs23.existsSync(path49.join(cwd, "build.gradle.kts"));
+  const hasGradlew = fs23.existsSync(path49.join(cwd, "gradlew")) || fs23.existsSync(path49.join(cwd, "gradlew.bat"));
   return hasBuildFile && (hasGradlew || isCommandAvailable("gradle"));
 }
 function detectDotnetTest(cwd) {
@@ -24536,25 +24830,25 @@ function detectDotnetTest(cwd) {
   }
 }
 function detectCTest(cwd) {
-  const hasSource = fs23.existsSync(path48.join(cwd, "CMakeLists.txt"));
-  const hasBuildCache = fs23.existsSync(path48.join(cwd, "CMakeCache.txt")) || fs23.existsSync(path48.join(cwd, "build", "CMakeCache.txt"));
+  const hasSource = fs23.existsSync(path49.join(cwd, "CMakeLists.txt"));
+  const hasBuildCache = fs23.existsSync(path49.join(cwd, "CMakeCache.txt")) || fs23.existsSync(path49.join(cwd, "build", "CMakeCache.txt"));
   return (hasSource || hasBuildCache) && isCommandAvailable("ctest");
 }
 function detectSwiftTest(cwd) {
-  return fs23.existsSync(path48.join(cwd, "Package.swift")) && isCommandAvailable("swift");
+  return fs23.existsSync(path49.join(cwd, "Package.swift")) && isCommandAvailable("swift");
 }
 function detectDartTest(cwd) {
-  return fs23.existsSync(path48.join(cwd, "pubspec.yaml")) && (isCommandAvailable("dart") || isCommandAvailable("flutter"));
+  return fs23.existsSync(path49.join(cwd, "pubspec.yaml")) && (isCommandAvailable("dart") || isCommandAvailable("flutter"));
 }
 function detectRSpec(cwd) {
-  const hasRSpecFile = fs23.existsSync(path48.join(cwd, ".rspec"));
-  const hasGemfile = fs23.existsSync(path48.join(cwd, "Gemfile"));
-  const hasSpecDir = fs23.existsSync(path48.join(cwd, "spec"));
+  const hasRSpecFile = fs23.existsSync(path49.join(cwd, ".rspec"));
+  const hasGemfile = fs23.existsSync(path49.join(cwd, "Gemfile"));
+  const hasSpecDir = fs23.existsSync(path49.join(cwd, "spec"));
   const hasRSpec = hasRSpecFile || hasGemfile && hasSpecDir;
   return hasRSpec && (isCommandAvailable("bundle") || isCommandAvailable("rspec"));
 }
 function detectMinitest(cwd) {
-  return fs23.existsSync(path48.join(cwd, "test")) && (fs23.existsSync(path48.join(cwd, "Gemfile")) || fs23.existsSync(path48.join(cwd, "Rakefile"))) && isCommandAvailable("ruby");
+  return fs23.existsSync(path49.join(cwd, "test")) && (fs23.existsSync(path49.join(cwd, "Gemfile")) || fs23.existsSync(path49.join(cwd, "Rakefile"))) && isCommandAvailable("ruby");
 }
 var DISPATCH_FRAMEWORK_MAP = {
   bun: "bun",
@@ -24639,7 +24933,7 @@ async function parseTestOutputViaDispatch(framework, output, baseDir) {
 async function detectTestFramework(cwd) {
   const baseDir = cwd;
   try {
-    const packageJsonPath = path48.join(baseDir, "package.json");
+    const packageJsonPath = path49.join(baseDir, "package.json");
     if (fs23.existsSync(packageJsonPath)) {
       const content = fs23.readFileSync(packageJsonPath, "utf-8");
       const pkg = JSON.parse(content);
@@ -24660,16 +24954,16 @@ async function detectTestFramework(cwd) {
         return "jest";
       if (hasDevDependency(devDeps, "mocha", "@types/mocha"))
         return "mocha";
-      if (fs23.existsSync(path48.join(baseDir, "bun.lockb")) || fs23.existsSync(path48.join(baseDir, "bun.lock"))) {
+      if (fs23.existsSync(path49.join(baseDir, "bun.lockb")) || fs23.existsSync(path49.join(baseDir, "bun.lock"))) {
         if (scripts.test?.includes("bun"))
           return "bun";
       }
     }
   } catch {}
   try {
-    const pyprojectTomlPath = path48.join(baseDir, "pyproject.toml");
-    const setupCfgPath = path48.join(baseDir, "setup.cfg");
-    const requirementsTxtPath = path48.join(baseDir, "requirements.txt");
+    const pyprojectTomlPath = path49.join(baseDir, "pyproject.toml");
+    const setupCfgPath = path49.join(baseDir, "setup.cfg");
+    const requirementsTxtPath = path49.join(baseDir, "requirements.txt");
     if (fs23.existsSync(pyprojectTomlPath)) {
       const content = fs23.readFileSync(pyprojectTomlPath, "utf-8");
       if (content.includes("[tool.pytest"))
@@ -24689,7 +24983,7 @@ async function detectTestFramework(cwd) {
     }
   } catch {}
   try {
-    const cargoTomlPath = path48.join(baseDir, "Cargo.toml");
+    const cargoTomlPath = path49.join(baseDir, "Cargo.toml");
     if (fs23.existsSync(cargoTomlPath)) {
       const content = fs23.readFileSync(cargoTomlPath, "utf-8");
       if (content.includes("[dev-dependencies]")) {
@@ -24700,9 +24994,9 @@ async function detectTestFramework(cwd) {
     }
   } catch {}
   try {
-    const pesterConfigPath = path48.join(baseDir, "pester.config.ps1");
-    const pesterConfigJsonPath = path48.join(baseDir, "pester.config.ps1.json");
-    const pesterPs1Path = path48.join(baseDir, "tests.ps1");
+    const pesterConfigPath = path49.join(baseDir, "pester.config.ps1");
+    const pesterConfigJsonPath = path49.join(baseDir, "pester.config.ps1.json");
+    const pesterPs1Path = path49.join(baseDir, "tests.ps1");
     if (fs23.existsSync(pesterConfigPath) || fs23.existsSync(pesterConfigJsonPath) || fs23.existsSync(pesterPs1Path)) {
       return "pester";
     }
@@ -24745,12 +25039,12 @@ function isTestDirectoryPath(normalizedPath) {
   return normalizedPath.split("/").some((segment) => TEST_DIRECTORY_NAMES.includes(segment));
 }
 function resolveWorkspacePath(file, workingDir) {
-  return path48.isAbsolute(file) ? path48.resolve(file) : path48.resolve(workingDir, file);
+  return path49.isAbsolute(file) ? path49.resolve(file) : path49.resolve(workingDir, file);
 }
 function toWorkspaceOutputPath(absolutePath, workingDir, preferRelative) {
   if (!preferRelative)
     return absolutePath;
-  return path48.relative(workingDir, absolutePath);
+  return path49.relative(workingDir, absolutePath);
 }
 function dedupePush(target, value) {
   if (!target.includes(value)) {
@@ -24787,18 +25081,18 @@ function buildLanguageSpecificTestNames(nameWithoutExt, ext) {
   }
 }
 function getRepoLevelCandidateDirectories(workingDir, relativePath, ext) {
-  const relativeDir = path48.dirname(relativePath);
+  const relativeDir = path49.dirname(relativePath);
   const nestedRelativeDir = relativeDir === "." ? "" : relativeDir;
   const directories = TEST_DIRECTORY_NAMES.flatMap((dirName) => {
-    const rootDir = path48.join(workingDir, dirName);
-    return nestedRelativeDir ? [rootDir, path48.join(rootDir, nestedRelativeDir)] : [rootDir];
+    const rootDir = path49.join(workingDir, dirName);
+    return nestedRelativeDir ? [rootDir, path49.join(rootDir, nestedRelativeDir)] : [rootDir];
   });
   const normalizedRelativePath = relativePath.replace(/\\/g, "/");
   if (ext === ".java" && normalizedRelativePath.startsWith("src/main/java/")) {
-    directories.push(path48.join(workingDir, "src/test/java", path48.dirname(normalizedRelativePath.slice("src/main/java/".length))));
+    directories.push(path49.join(workingDir, "src/test/java", path49.dirname(normalizedRelativePath.slice("src/main/java/".length))));
   }
   if ((ext === ".kt" || ext === ".java") && normalizedRelativePath.startsWith("src/main/kotlin/")) {
-    directories.push(path48.join(workingDir, "src/test/kotlin", path48.dirname(normalizedRelativePath.slice("src/main/kotlin/".length))));
+    directories.push(path49.join(workingDir, "src/test/kotlin", path49.dirname(normalizedRelativePath.slice("src/main/kotlin/".length))));
   }
   return [...new Set(directories)];
 }
@@ -24826,23 +25120,23 @@ function isLanguageSpecificTestFile(basename9) {
 }
 function isConventionTestFilePath(filePath) {
   const normalizedPath = filePath.replace(/\\/g, "/");
-  const basename9 = path48.basename(filePath);
+  const basename9 = path49.basename(filePath);
   return hasCompoundTestExtension(basename9) || basename9.includes(".spec.") || basename9.includes(".test.") || isLanguageSpecificTestFile(basename9) || isTestDirectoryPath(normalizedPath);
 }
 function getTestFilesFromConvention(sourceFiles, workingDir = process.cwd()) {
   const testFiles = [];
   for (const file of sourceFiles) {
     const absoluteFile = resolveWorkspacePath(file, workingDir);
-    const relativeFile = path48.relative(workingDir, absoluteFile);
-    const basename9 = path48.basename(absoluteFile);
-    const dirname23 = path48.dirname(absoluteFile);
-    const preferRelativeOutput = !path48.isAbsolute(file);
+    const relativeFile = path49.relative(workingDir, absoluteFile);
+    const basename9 = path49.basename(absoluteFile);
+    const dirname23 = path49.dirname(absoluteFile);
+    const preferRelativeOutput = !path49.isAbsolute(file);
     if (isConventionTestFilePath(relativeFile) || isConventionTestFilePath(file)) {
       dedupePush(testFiles, toWorkspaceOutputPath(absoluteFile, workingDir, preferRelativeOutput));
       continue;
     }
     const nameWithoutExt = basename9.replace(/\.[^.]+$/, "");
-    const ext = path48.extname(basename9);
+    const ext = path49.extname(basename9);
     const genericTestNames = [
       `${nameWithoutExt}.spec${ext}`,
       `${nameWithoutExt}.test${ext}`
@@ -24851,7 +25145,7 @@ function getTestFilesFromConvention(sourceFiles, workingDir = process.cwd()) {
     const colocatedCandidates = [
       ...genericTestNames,
       ...languageSpecificTestNames
-    ].map((candidateName) => path48.join(dirname23, candidateName));
+    ].map((candidateName) => path49.join(dirname23, candidateName));
     const testDirectoryNames = [
       basename9,
       ...genericTestNames,
@@ -24860,8 +25154,8 @@ function getTestFilesFromConvention(sourceFiles, workingDir = process.cwd()) {
     const repoLevelDirectories = getRepoLevelCandidateDirectories(workingDir, relativeFile, ext);
     const possibleTestFiles = [
       ...colocatedCandidates,
-      ...TEST_DIRECTORY_NAMES.flatMap((dirName) => testDirectoryNames.map((candidateName) => path48.join(dirname23, dirName, candidateName))),
-      ...repoLevelDirectories.flatMap((candidateDir) => testDirectoryNames.map((candidateName) => path48.join(candidateDir, candidateName)))
+      ...TEST_DIRECTORY_NAMES.flatMap((dirName) => testDirectoryNames.map((candidateName) => path49.join(dirname23, dirName, candidateName))),
+      ...repoLevelDirectories.flatMap((candidateDir) => testDirectoryNames.map((candidateName) => path49.join(candidateDir, candidateName)))
     ];
     for (const testFile of possibleTestFiles) {
       if (fs23.existsSync(testFile)) {
@@ -24882,7 +25176,7 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
     try {
       const absoluteTestFile = resolveWorkspacePath(testFile, workingDir);
       const content = fs23.readFileSync(absoluteTestFile, "utf-8");
-      const testDir = path48.dirname(absoluteTestFile);
+      const testDir = path49.dirname(absoluteTestFile);
       const importRegex = /import\s+.*?\s+from\s+['"]([^'"]+)['"]/g;
       let match;
       match = importRegex.exec(content);
@@ -24890,8 +25184,8 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
         const importPath = match[1];
         let resolvedImport;
         if (importPath.startsWith(".")) {
-          resolvedImport = path48.resolve(testDir, importPath);
-          const existingExt = path48.extname(resolvedImport);
+          resolvedImport = path49.resolve(testDir, importPath);
+          const existingExt = path49.extname(resolvedImport);
           if (!existingExt) {
             for (const extToTry of [
               ".ts",
@@ -24911,12 +25205,12 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
         } else {
           continue;
         }
-        const importBasename = path48.basename(resolvedImport, path48.extname(resolvedImport));
-        const importDir = path48.dirname(resolvedImport);
+        const importBasename = path49.basename(resolvedImport, path49.extname(resolvedImport));
+        const importDir = path49.dirname(resolvedImport);
         for (const sourceFile of absoluteSourceFiles) {
-          const sourceDir = path48.dirname(sourceFile);
-          const sourceBasename = path48.basename(sourceFile, path48.extname(sourceFile));
-          const isRelatedDir = importDir === sourceDir || importDir === path48.join(sourceDir, "__tests__") || importDir === path48.join(sourceDir, "tests") || importDir === path48.join(sourceDir, "test") || importDir === path48.join(sourceDir, "spec");
+          const sourceDir = path49.dirname(sourceFile);
+          const sourceBasename = path49.basename(sourceFile, path49.extname(sourceFile));
+          const isRelatedDir = importDir === sourceDir || importDir === path49.join(sourceDir, "__tests__") || importDir === path49.join(sourceDir, "tests") || importDir === path49.join(sourceDir, "test") || importDir === path49.join(sourceDir, "spec");
           if (resolvedImport === sourceFile || importBasename === sourceBasename && isRelatedDir) {
             dedupePush(testFiles, testFile);
             break;
@@ -24929,8 +25223,8 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
       while (match !== null) {
         const importPath = match[1];
         if (importPath.startsWith(".")) {
-          let resolvedImport = path48.resolve(testDir, importPath);
-          const existingExt = path48.extname(resolvedImport);
+          let resolvedImport = path49.resolve(testDir, importPath);
+          const existingExt = path49.extname(resolvedImport);
           if (!existingExt) {
             for (const extToTry of [
               ".ts",
@@ -24947,12 +25241,12 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
               }
             }
           }
-          const importDir = path48.dirname(resolvedImport);
-          const importBasename = path48.basename(resolvedImport, path48.extname(resolvedImport));
+          const importDir = path49.dirname(resolvedImport);
+          const importBasename = path49.basename(resolvedImport, path49.extname(resolvedImport));
           for (const sourceFile of absoluteSourceFiles) {
-            const sourceDir = path48.dirname(sourceFile);
-            const sourceBasename = path48.basename(sourceFile, path48.extname(sourceFile));
-            const isRelatedDir = importDir === sourceDir || importDir === path48.join(sourceDir, "__tests__") || importDir === path48.join(sourceDir, "tests") || importDir === path48.join(sourceDir, "test") || importDir === path48.join(sourceDir, "spec");
+            const sourceDir = path49.dirname(sourceFile);
+            const sourceBasename = path49.basename(sourceFile, path49.extname(sourceFile));
+            const isRelatedDir = importDir === sourceDir || importDir === path49.join(sourceDir, "__tests__") || importDir === path49.join(sourceDir, "tests") || importDir === path49.join(sourceDir, "test") || importDir === path49.join(sourceDir, "spec");
             if (resolvedImport === sourceFile || importBasename === sourceBasename && isRelatedDir) {
               dedupePush(testFiles, testFile);
               break;
@@ -25072,8 +25366,8 @@ function buildTestCommand(framework, scope, files, coverage, baseDir, bail) {
       return ["mvn", "test"];
     case "gradle": {
       const isWindows = process.platform === "win32";
-      const hasGradlewBat = fs23.existsSync(path48.join(baseDir, "gradlew.bat"));
-      const hasGradlew = fs23.existsSync(path48.join(baseDir, "gradlew"));
+      const hasGradlewBat = fs23.existsSync(path49.join(baseDir, "gradlew.bat"));
+      const hasGradlew = fs23.existsSync(path49.join(baseDir, "gradlew"));
       if (hasGradlewBat && isWindows)
         return ["gradlew.bat", "test"];
       if (hasGradlew)
@@ -25090,7 +25384,7 @@ function buildTestCommand(framework, scope, files, coverage, baseDir, bail) {
         "cmake-build-release",
         "out"
       ];
-      const actualBuildDir = buildDirCandidates.find((d) => fs23.existsSync(path48.join(baseDir, d, "CMakeCache.txt"))) ?? "build";
+      const actualBuildDir = buildDirCandidates.find((d) => fs23.existsSync(path49.join(baseDir, d, "CMakeCache.txt"))) ?? "build";
       return ["ctest", "--test-dir", actualBuildDir];
     }
     case "swift-test":
@@ -25524,11 +25818,11 @@ async function runTests(framework, scope, files, coverage, timeout_ms, cwd, bail
     };
   }
   const startTime = Date.now();
-  const vitestJsonOutputPath = framework === "vitest" ? path48.join(cwd, ".swarm", "cache", "test-runner-vitest.json") : undefined;
+  const vitestJsonOutputPath = framework === "vitest" ? path49.join(cwd, ".swarm", "cache", "test-runner-vitest.json") : undefined;
   try {
     if (vitestJsonOutputPath) {
       try {
-        fs23.mkdirSync(path48.dirname(vitestJsonOutputPath), { recursive: true });
+        fs23.mkdirSync(path49.dirname(vitestJsonOutputPath), { recursive: true });
         if (fs23.existsSync(vitestJsonOutputPath)) {
           fs23.unlinkSync(vitestJsonOutputPath);
         }
@@ -25539,9 +25833,9 @@ async function runTests(framework, scope, files, coverage, timeout_ms, cwd, bail
       stderr: "pipe",
       cwd
     });
-    const timeoutPromise = new Promise((resolve15) => setTimeout(() => {
+    const timeoutPromise = new Promise((resolve16) => setTimeout(() => {
       proc.kill();
-      resolve15(-1);
+      resolve16(-1);
     }, timeout_ms));
     const [exitCode, stdoutResult, stderrResult] = await Promise.all([
       Promise.race([proc.exited, timeoutPromise]),
@@ -25696,10 +25990,10 @@ var SKIP_DIRECTORIES = new Set([
 ]);
 function normalizeHistoryTestFile(testFile, workingDir) {
   const normalized = testFile.replace(/\\/g, "/");
-  if (!path48.isAbsolute(testFile))
+  if (!path49.isAbsolute(testFile))
     return normalized;
-  const relative8 = path48.relative(workingDir, testFile);
-  if (relative8.startsWith("..") || path48.isAbsolute(relative8)) {
+  const relative8 = path49.relative(workingDir, testFile);
+  if (relative8.startsWith("..") || path49.isAbsolute(relative8)) {
     return normalized;
   }
   return relative8.replace(/\\/g, "/");
@@ -25938,7 +26232,7 @@ var test_runner = createSwarmTool({
       const sourceFiles = args.files.filter((file) => {
         if (directTestFiles.includes(file))
           return false;
-        const ext = path48.extname(file).toLowerCase();
+        const ext = path49.extname(file).toLowerCase();
         return SOURCE_EXTENSIONS.has(ext);
       });
       const invalidFiles = args.files.filter((file) => !directTestFiles.includes(file) && !sourceFiles.includes(file));
@@ -25984,7 +26278,7 @@ var test_runner = createSwarmTool({
         if (isConventionTestFilePath(f)) {
           return false;
         }
-        const ext = path48.extname(f).toLowerCase();
+        const ext = path49.extname(f).toLowerCase();
         return SOURCE_EXTENSIONS.has(ext);
       });
       if (sourceFiles.length === 0) {
@@ -26034,7 +26328,7 @@ var test_runner = createSwarmTool({
         if (isConventionTestFilePath(f)) {
           return false;
         }
-        const ext = path48.extname(f).toLowerCase();
+        const ext = path49.extname(f).toLowerCase();
         return SOURCE_EXTENSIONS.has(ext);
       });
       if (sourceFiles.length === 0) {
@@ -26086,8 +26380,8 @@ var test_runner = createSwarmTool({
         }
         if (impactResult.impactedTests.length > 0) {
           testFiles = impactResult.impactedTests.map((absPath) => {
-            const relativePath = path48.relative(workingDir, absPath);
-            return path48.isAbsolute(relativePath) ? absPath : relativePath;
+            const relativePath = path49.relative(workingDir, absPath);
+            return path49.isAbsolute(relativePath) ? absPath : relativePath;
           });
         } else {
           graphFallbackReason = "no impacted tests found via impact analysis, falling back to graph";
@@ -26182,8 +26476,8 @@ function validateDirectoryPath(dir) {
   if (dir.includes("..")) {
     throw new Error("Directory path must not contain path traversal sequences");
   }
-  const normalized = path49.normalize(dir);
-  const absolutePath = path49.isAbsolute(normalized) ? normalized : path49.resolve(normalized);
+  const normalized = path50.normalize(dir);
+  const absolutePath = path50.isAbsolute(normalized) ? normalized : path50.resolve(normalized);
   return absolutePath;
 }
 function validateTimeout(timeoutMs, defaultValue) {
@@ -26206,7 +26500,7 @@ function validateTimeout(timeoutMs, defaultValue) {
 }
 function getPackageVersion(dir) {
   try {
-    const packagePath = path49.join(dir, "package.json");
+    const packagePath = path50.join(dir, "package.json");
     if (fs24.existsSync(packagePath)) {
       const content = fs24.readFileSync(packagePath, "utf-8");
       const pkg = JSON.parse(content);
@@ -26217,7 +26511,7 @@ function getPackageVersion(dir) {
 }
 function getChangelogVersion(dir) {
   try {
-    const changelogPath = path49.join(dir, "CHANGELOG.md");
+    const changelogPath = path50.join(dir, "CHANGELOG.md");
     if (fs24.existsSync(changelogPath)) {
       const content = fs24.readFileSync(changelogPath, "utf-8");
       const match = content.match(/^##\s*\[?(\d+\.\d+\.\d+)\]?/m);
@@ -26231,7 +26525,7 @@ function getChangelogVersion(dir) {
 function getVersionFileVersion(dir) {
   const possibleFiles = ["VERSION.txt", "version.txt", "VERSION", "version"];
   for (const file of possibleFiles) {
-    const filePath = path49.join(dir, file);
+    const filePath = path50.join(dir, file);
     if (fs24.existsSync(filePath)) {
       try {
         const content = fs24.readFileSync(filePath, "utf-8").trim();
@@ -26969,7 +27263,7 @@ async function handleQaGatesCommand(directory, args, sessionID) {
 
 // src/commands/reset.ts
 import * as fs25 from "fs";
-import * as path50 from "path";
+import * as path51 from "path";
 
 // src/background/circuit-breaker.ts
 class CircuitBreaker {
@@ -27021,13 +27315,13 @@ class CircuitBreaker {
     if (this.config.callTimeoutMs <= 0) {
       return fn();
     }
-    return new Promise((resolve16, reject) => {
+    return new Promise((resolve17, reject) => {
       const timeout = setTimeout(() => {
         reject(new Error(`Call timeout after ${this.config.callTimeoutMs}ms`));
       }, this.config.callTimeoutMs);
       fn().then((result) => {
         clearTimeout(timeout);
-        resolve16(result);
+        resolve17(result);
       }).catch((error2) => {
         clearTimeout(timeout);
         reject(error2);
@@ -27311,7 +27605,7 @@ class AutomationQueue {
 
 // src/background/worker.ts
 function sleep(ms) {
-  return new Promise((resolve16) => setTimeout(resolve16, ms));
+  return new Promise((resolve17) => setTimeout(resolve17, ms));
 }
 
 class WorkerManager {
@@ -27686,7 +27980,7 @@ async function handleResetCommand(directory, args) {
   }
   for (const filename of ["SWARM_PLAN.md", "SWARM_PLAN.json"]) {
     try {
-      const rootPath = path50.join(directory, filename);
+      const rootPath = path51.join(directory, filename);
       if (fs25.existsSync(rootPath)) {
         fs25.unlinkSync(rootPath);
         results.push(`- \u2705 Deleted ${filename} (root)`);
@@ -27724,7 +28018,7 @@ async function handleResetCommand(directory, args) {
 
 // src/commands/reset-session.ts
 import * as fs27 from "fs";
-import * as path52 from "path";
+import * as path53 from "path";
 
 // src/hooks/trajectory-logger.ts
 var callStartTimes = new Map;
@@ -28131,16 +28425,16 @@ function detectPatterns(trajectory, config, lastProcessedStep = 0) {
 }
 // src/prm/replay.ts
 import { promises as fs26 } from "fs";
-import path51 from "path";
+import path52 from "path";
 function isPathSafe(targetPath, basePath) {
-  const resolvedTarget = path51.resolve(targetPath);
-  const resolvedBase = path51.resolve(basePath);
-  const rel = path51.relative(resolvedBase, resolvedTarget);
-  return !rel.startsWith("..") && !path51.isAbsolute(rel);
+  const resolvedTarget = path52.resolve(targetPath);
+  const resolvedBase = path52.resolve(basePath);
+  const rel = path52.relative(resolvedBase, resolvedTarget);
+  return !rel.startsWith("..") && !path52.isAbsolute(rel);
 }
 function isWithinReplaysDir(targetPath) {
-  const resolved = path51.resolve(targetPath);
-  const parts = resolved.split(path51.sep);
+  const resolved = path52.resolve(targetPath);
+  const parts = resolved.split(path52.sep);
   for (let i = 0;i < parts.length - 1; i++) {
     if (parts[i] === ".swarm" && parts[i + 1] === "replays") {
       return true;
@@ -28153,10 +28447,10 @@ function sanitizeFilename(input) {
 }
 async function startReplayRecording(sessionID, directory) {
   try {
-    const replayDir = path51.join(directory, ".swarm", "replays");
+    const replayDir = path52.join(directory, ".swarm", "replays");
     const safeSessionID = sanitizeFilename(sessionID);
     const filename = `${safeSessionID}-${Date.now()}.jsonl`;
-    const filepath = path51.join(replayDir, filename);
+    const filepath = path52.join(replayDir, filename);
     if (!isPathSafe(filepath, replayDir)) {
       console.warn(`[replay] Invalid path detected - path traversal attempt blocked for session ${sessionID}`);
       return null;
@@ -28234,7 +28528,7 @@ async function handleResetSessionCommand(directory, _args) {
   } catch {
     results.push("\u274C Failed to delete state.json");
   }
-  const sessionDir = path52.dirname(validateSwarmPath(directory, "session/state.json"));
+  const sessionDir = path53.dirname(validateSwarmPath(directory, "session/state.json"));
   let sessionFiles = [];
   if (fs27.existsSync(sessionDir)) {
     try {
@@ -28246,7 +28540,7 @@ async function handleResetSessionCommand(directory, _args) {
   for (const file of sessionFiles) {
     if (file === "state.json")
       continue;
-    const filePath = path52.join(sessionDir, file);
+    const filePath = path53.join(sessionDir, file);
     try {
       if (!fs27.existsSync(filePath))
         continue;
@@ -28281,7 +28575,7 @@ async function handleResetSessionCommand(directory, _args) {
 }
 
 // src/summaries/manager.ts
-import * as path53 from "path";
+import * as path54 from "path";
 var SUMMARY_ID_REGEX = /^S\d+$/;
 function sanitizeSummaryId(id) {
   if (!id || id.length === 0) {
@@ -28305,7 +28599,7 @@ function sanitizeSummaryId(id) {
 }
 async function loadFullOutput(directory, id) {
   const sanitizedId = sanitizeSummaryId(id);
-  const relativePath = path53.join("summaries", `${sanitizedId}.json`);
+  const relativePath = path54.join("summaries", `${sanitizedId}.json`);
   validateSwarmPath(directory, relativePath);
   const content = await readSwarmFileAsync(directory, relativePath);
   if (content === null) {
@@ -28358,7 +28652,7 @@ ${error2 instanceof Error ? error2.message : String(error2)}`;
 
 // src/commands/rollback.ts
 import * as fs28 from "fs";
-import * as path54 from "path";
+import * as path55 from "path";
 async function handleRollbackCommand(directory, args) {
   const phaseArg = args[0];
   if (!phaseArg) {
@@ -28424,8 +28718,8 @@ async function handleRollbackCommand(directory, args) {
     if (EXCLUDE_FILES.has(file) || file.startsWith("plan-ledger.archived-")) {
       continue;
     }
-    const src = path54.join(checkpointDir, file);
-    const dest = path54.join(swarmDir, file);
+    const src = path55.join(checkpointDir, file);
+    const dest = path55.join(swarmDir, file);
     try {
       fs28.cpSync(src, dest, { recursive: true, force: true });
       successes.push(file);
@@ -28444,7 +28738,7 @@ async function handleRollbackCommand(directory, args) {
     ].join(`
 `);
   }
-  const existingLedgerPath = path54.join(swarmDir, "plan-ledger.jsonl");
+  const existingLedgerPath = path55.join(swarmDir, "plan-ledger.jsonl");
   let ledgerDeletionFailed = false;
   if (fs28.existsSync(existingLedgerPath)) {
     try {
@@ -28457,7 +28751,7 @@ async function handleRollbackCommand(directory, args) {
   }
   if (!ledgerDeletionFailed) {
     try {
-      const planJsonPath = path54.join(swarmDir, "plan.json");
+      const planJsonPath = path55.join(swarmDir, "plan.json");
       if (fs28.existsSync(planJsonPath)) {
         const planRaw = fs28.readFileSync(planJsonPath, "utf-8");
         const plan = PlanSchema.parse(JSON.parse(planRaw));
@@ -28718,10 +29012,10 @@ Ensure this is a git repository with commit history.`;
 `);
   try {
     const fs29 = await import("fs/promises");
-    const path55 = await import("path");
-    const reportPath = path55.join(directory, ".swarm", "simulate-report.md");
-    await fs29.mkdir(path55.dirname(reportPath), { recursive: true });
-    const reportTempPath = path55.join(path55.dirname(reportPath), `${path55.basename(reportPath)}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+    const path56 = await import("path");
+    const reportPath = path56.join(directory, ".swarm", "simulate-report.md");
+    await fs29.mkdir(path56.dirname(reportPath), { recursive: true });
+    const reportTempPath = path56.join(path56.dirname(reportPath), `${path56.basename(reportPath)}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
     try {
       await fs29.writeFile(reportTempPath, report, "utf-8");
       renameSync11(reportTempPath, reportPath);
@@ -28750,18 +29044,18 @@ async function handleSpecifyCommand(_directory, args) {
 // src/services/status-service.ts
 import * as fsSync3 from "fs";
 import { readFile as readFile15 } from "fs/promises";
-import * as path56 from "path";
+import * as path57 from "path";
 
 // src/turbo/lean/state.ts
 init_logger();
 import * as fs29 from "fs";
-import * as path55 from "path";
+import * as path56 from "path";
 var STATE_FILE3 = "turbo-state.json";
 function nowISO3() {
   return new Date().toISOString();
 }
 function ensureSwarmDir2(directory) {
-  const swarmDir = path55.resolve(directory, ".swarm");
+  const swarmDir = path56.resolve(directory, ".swarm");
   if (!fs29.existsSync(swarmDir)) {
     fs29.mkdirSync(swarmDir, { recursive: true });
   }
@@ -28806,7 +29100,7 @@ function markStateUnreadable2(directory, reason) {
 }
 function readPersisted2(directory) {
   try {
-    const filePath = path55.join(directory, ".swarm", STATE_FILE3);
+    const filePath = path56.join(directory, ".swarm", STATE_FILE3);
     if (!fs29.existsSync(filePath)) {
       const seed = emptyPersisted2();
       try {
@@ -28842,7 +29136,7 @@ function writePersisted2(directory, persisted) {
   let payload;
   try {
     ensureSwarmDir2(directory);
-    filePath = path55.join(directory, ".swarm", STATE_FILE3);
+    filePath = path56.join(directory, ".swarm", STATE_FILE3);
     tmpPath = `${filePath}.tmp.${Date.now()}`;
     persisted.updatedAt = nowISO3();
     payload = `${JSON.stringify(persisted, null, 2)}
@@ -28960,7 +29254,7 @@ var _internals43 = {
 };
 function readSpecStalenessSnapshot(directory) {
   try {
-    const p = path56.join(directory, ".swarm", "spec-staleness.json");
+    const p = path57.join(directory, ".swarm", "spec-staleness.json");
     if (!fsSync3.existsSync(p))
       return { stale: false };
     const raw = fsSync3.readFileSync(p, "utf-8");
@@ -29627,7 +29921,7 @@ function buildDetailedHelp(commandName, entry) {
 async function handleHelpCommand(ctx) {
   const targetCommand = ctx.args.join(" ");
   if (!targetCommand) {
-    const { buildHelpText } = await import("./index-dkytd370.js");
+    const { buildHelpText } = await import("./index-sr7g2msm.js");
     return buildHelpText();
   }
   const tokens = targetCommand.split(/\s+/);
@@ -29636,7 +29930,7 @@ async function handleHelpCommand(ctx) {
     return _internals45.buildDetailedHelp(resolved.key, resolved.entry);
   }
   const similar = _internals45.findSimilarCommands(targetCommand);
-  const { buildHelpText: fullHelp } = await import("./index-dkytd370.js");
+  const { buildHelpText: fullHelp } = await import("./index-sr7g2msm.js");
   if (similar.length > 0) {
     return `Command '/swarm ${targetCommand}' not found.
 
@@ -29769,7 +30063,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail explain": {
     handler: async (ctx) => {
-      const { handleGuardrailExplain } = await import("./guardrail-explain-sw5bjxtk.js");
+      const { handleGuardrailExplain } = await import("./guardrail-explain-995zavv8.js");
       return handleGuardrailExplain(ctx.directory, ctx.args);
     },
     description: "Dry-run: show what the guardrails would do to a command or write target (executes nothing)",
@@ -30509,24 +30803,24 @@ function validateAliases() {
       }
       aliasTargets.get(target).push(name);
       const visited = new Set;
-      const path57 = [];
+      const path58 = [];
       let current = target;
       while (current) {
         const currentEntry = COMMAND_REGISTRY[current];
         if (!currentEntry)
           break;
         if (visited.has(current)) {
-          const cycleStart = path57.indexOf(current);
+          const cycleStart = path58.indexOf(current);
           const fullChain = [
             name,
-            ...path57.slice(0, cycleStart > 0 ? cycleStart : path57.length),
+            ...path58.slice(0, cycleStart > 0 ? cycleStart : path58.length),
             current
           ].join(" \u2192 ");
           errors.push(`Circular alias detected: ${fullChain}`);
           break;
         }
         visited.add(current);
-        path57.push(current);
+        path58.push(current);
         current = currentEntry.aliasOf || "";
       }
     }