@primeinc/swarm 0.57.8-beta.0 → 0.57.10-beta.0

package/dist/marketplace/index.js

@@ -12735,6 +12735,8 @@ __export(exports_dist, {
   pgliteExists: () => pgliteExists,
   parseMemoryJSONL: () => parseMemoryJSONL,
   parseJSONL: () => parseJSONL,
+  normalizeProjectKey: () => normalizeProjectKey,
+  normalizePath: () => normalize3,
   needsMigration: () => needsMigration,
   migrateToGlobal: () => migrateToGlobal,
   migrateProjectToGlobal: () => migrateProjectToGlobal,
@@ -12887,15 +12889,15 @@ __export(exports_dist, {
 });
 import { createRequire as createRequire2 } from "node:module";
 import { existsSync, readFileSync, statSync } from "node:fs";
-import { join as join8, resolve } from "node:path";
+import { join as join9, resolve } from "node:path";
 import { createClient } from "@libsql/client";
 import { existsSync as existsSync2 } from "node:fs";
-import { join as join9 } from "node:path";
+import { join as join10 } from "node:path";
 import { createClient as createClient2 } from "@libsql/client";
 import { createClient as createClient3 } from "@libsql/client";
 import { existsSync as existsSync3, renameSync } from "node:fs";
 import { homedir } from "node:os";
-import { join as join10 } from "node:path";
+import { join as join11 } from "node:path";
 import { createClient as createClient4 } from "@libsql/client";
 import { createHash } from "node:crypto";
 import { basename } from "node:path";
@@ -12904,23 +12906,28 @@ import { webcrypto as crypto2 } from "node:crypto";
 import { EventEmitter } from "node:events";
 import { existsSync as existsSync4, mkdirSync } from "node:fs";
 import { homedir as homedir2 } from "node:os";
-import { join as join12 } from "node:path";
+import { join as join13 } from "node:path";
 import { randomBytes } from "node:crypto";
+import { createRequire as createRequire22 } from "module";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+import path3 from "node:path";
+import path2 from "node:path";
 import { readFileSync as readFileSync2, existsSync as existsSync5 } from "node:fs";
-import { join as join13 } from "node:path";
+import { join as join14 } from "node:path";
 import { createHash as createHash2 } from "node:crypto";
 import { existsSync as existsSync6 } from "node:fs";
 import { readFile, writeFile } from "node:fs/promises";
 import { existsSync as existsSync7 } from "node:fs";
 import { homedir as homedir3 } from "node:os";
-import { join as join14 } from "node:path";
-import { existsSync as existsSync8, readFileSync as readFileSync3, writeFileSync } from "node:fs";
 import { join as join15 } from "node:path";
+import { existsSync as existsSync8, readFileSync as readFileSync3, writeFileSync } from "node:fs";
+import { join as join16 } from "node:path";
 import { createClient as createClient5 } from "@libsql/client";
 import { createClient as createClient6 } from "@libsql/client";
 import { createClient as createClient7 } from "@libsql/client";
 import { existsSync as existsSync9, readdirSync, renameSync as renameSync2 } from "node:fs";
-import { join as join16 } from "node:path";
+import { join as join17 } from "node:path";
 import { readFileSync as readFileSync4 } from "node:fs";
 import { EventEmitter as EventEmitter3 } from "node:events";
 import { EventEmitter as EventEmitter2 } from "node:events";
@@ -12935,7 +12942,7 @@ import { realpath as fsrealpath, lstat as lstat2, open, stat as stat2 } from "no
 import { type as osType } from "node:os";
 import * as sp from "node:path";
 import { promises as fs } from "node:fs";
-import * as path2 from "node:path";
+import * as path4 from "node:path";
 function pipe2(a, ab, bc, cd, de, ef, fg, gh, hi) {
   switch (arguments.length) {
     case 1:
@@ -23705,7 +23712,7 @@ function SortedSet(value9, ordA) {
   });
 }
 function isWorktree(path) {
-  const gitPath = join8(path, ".git");
+  const gitPath = join9(path, ".git");
   if (!existsSync(gitPath)) {
     return false;
   }
@@ -23720,7 +23727,7 @@ function getMainRepoPath(path) {
   if (!isWorktree(path)) {
     return path;
   }
-  const gitFilePath = join8(path, ".git");
+  const gitFilePath = join9(path, ".git");
   const gitFileContent = readFileSync(gitFilePath, "utf-8");
   const match43 = gitFileContent.match(/^gitdir:\s*(.+)$/m);
   if (!match43 || !match43[1]) {
@@ -24082,7 +24089,7 @@ function wrapPGlite(pglite) {
   };
 }
 function pgliteExists(path) {
-  const pgVersionPath = join9(path, "PG_VERSION");
+  const pgVersionPath = join10(path, "PG_VERSION");
   return existsSync2(pgVersionPath);
 }
 async function migratePGliteToLibSQL(options2) {
@@ -24889,22 +24896,42 @@ async function validateLibSQLStreamsSchema(db) {
     return false;
   }
 }
+function renameSyncWithRetry(oldPath, newPath, maxRetries = 5, initialDelayMs = 50) {
+  let lastError;
+  for (let attempt3 = 0;attempt3 < maxRetries; attempt3++) {
+    try {
+      renameSync(oldPath, newPath);
+      return;
+    } catch (err) {
+      lastError = err;
+      const isEBUSY = err instanceof Error && (err.message.includes("EBUSY") || err.code === "EBUSY");
+      if (!isEBUSY || attempt3 === maxRetries - 1) {
+        throw err;
+      }
+      const delay4 = initialDelayMs * Math.pow(2, attempt3);
+      const sharedBuffer = new SharedArrayBuffer(4);
+      const int322 = new Int32Array(sharedBuffer);
+      Atomics.wait(int322, 0, 0, delay4);
+    }
+  }
+  throw lastError;
+}
 function needsMigration(projectPath) {
-  const libsqlPath = join10(projectPath, ".opencode", "streams.db");
-  const pglitePath = join10(projectPath, ".opencode", "streams");
+  const libsqlPath = join11(projectPath, ".opencode", "streams.db");
+  const pglitePath = join11(projectPath, ".opencode", "streams");
   return existsSync3(libsqlPath) || existsSync3(pglitePath);
 }
 function getGlobalDbPath() {
-  return join10(homedir(), ".config", "swarm-tools", "swarm.db");
+  return join11(homedir(), ".config", "swarm-tools", "swarm.db");
 }
 function detectSourceType(projectPath) {
-  const libsqlPath = join10(projectPath, ".opencode", "streams.db");
-  const pglitePath = join10(projectPath, ".opencode", "streams");
+  const libsqlPath = join11(projectPath, ".opencode", "streams.db");
+  const pglitePath = join11(projectPath, ".opencode", "streams");
   if (existsSync3(libsqlPath)) {
     return "libsql";
   }
   if (existsSync3(pglitePath)) {
-    const pgVersionPath = join10(pglitePath, "PG_VERSION");
+    const pgVersionPath = join11(pglitePath, "PG_VERSION");
     if (existsSync3(pgVersionPath)) {
       return "pglite";
     }
@@ -24925,10 +24952,10 @@ async function migrateProjectToGlobal(projectPath, globalDbPath = getGlobalDbPat
   let stats;
   let sourcePath;
   if (sourceType === "libsql") {
-    sourcePath = join10(projectPath, ".opencode", "streams.db");
+    sourcePath = join11(projectPath, ".opencode", "streams.db");
     stats = await migrateLibSQLToGlobal(sourcePath, globalDb);
   } else {
-    sourcePath = join10(projectPath, ".opencode", "streams");
+    sourcePath = join11(projectPath, ".opencode", "streams");
     stats = await migratePGLiteToGlobal(sourcePath, globalDb);
   }
   globalDb.close();
@@ -25128,7 +25155,7 @@ async function migrateLocalDbToGlobal(localDbPath, globalDbPath) {
   }
   localDb.close();
   globalDb.close();
-  renameSync(localDbPath, migratedPath);
+  renameSyncWithRetry(localDbPath, migratedPath);
   return stats;
 }
 function backupOldDb(path) {
@@ -25137,7 +25164,7 @@ function backupOldDb(path) {
   }
   const timestamp = new Date().toISOString().replace(/:/g, "-");
   const backupPath = `${path}.backup-${timestamp}`;
-  renameSync(path, backupPath);
+  renameSyncWithRetry(path, backupPath);
   return backupPath;
 }
 async function migrateTable(sourceDb, globalDb, tableName, targetColumns, errors22) {
@@ -28632,9 +28659,30 @@ async function initSwarmAgent(options2) {
     taskDescription,
     dbOverride
   } = options2;
+  let uniqueName = agentName;
+  try {
+    const { getOrCreateAdapter: getOrCreateAdapter3 } = await Promise.resolve().then(() => (init_store_drizzle(), exports_store_drizzle));
+    const { toDrizzleDb: toDrizzleDb2 } = await Promise.resolve().then(() => (init_libsql_convenience(), exports_libsql_convenience));
+    const { agentsTable: agentsTable2 } = await Promise.resolve().then(() => (init_streams(), exports_streams));
+    const { and: and4, eq: eq2 } = await Promise.resolve().then(() => (init_drizzle_orm(), exports_drizzle_orm));
+    const adapter5 = await getOrCreateAdapter3(projectPath, dbOverride);
+    const db2 = toDrizzleDb2(adapter5);
+    let attempts = 0;
+    while (attempts < 10) {
+      const exists8 = await db2.select({ id: agentsTable2.id }).from(agentsTable2).where(and4(eq2(agentsTable2.project_key, projectPath), eq2(agentsTable2.name, uniqueName)));
+      if (exists8.length === 0)
+        break;
+      uniqueName = generateSwarmAgentName();
+      attempts++;
+    }
+    if (attempts >= 10) {
+      const short = Math.random().toString(36).slice(2, 6);
+      uniqueName = `${uniqueName}${short.charAt(0).toUpperCase()}${short.slice(1, 2)}`;
+    }
+  } catch (e) {}
   const event = createEvent("agent_registered", {
     project_key: projectPath,
-    agent_name: agentName,
+    agent_name: uniqueName,
     program,
     model,
     task_description: taskDescription
@@ -28642,7 +28690,7 @@ async function initSwarmAgent(options2) {
   await appendEvent(event, projectPath, dbOverride);
   return {
     projectKey: projectPath,
-    agentName
+    agentName: uniqueName
   };
 }
 async function sendSwarmMessage(options2) {
@@ -29489,11 +29537,11 @@ async function withTiming(operation, fn2) {
   }
 }
 function getDatabasePath2(projectPath) {
-  const globalDir = join12(homedir2(), ".config", "swarm-tools");
+  const globalDir = join13(homedir2(), ".config", "swarm-tools");
   if (!existsSync4(globalDir)) {
     mkdirSync(globalDir, { recursive: true });
   }
-  const globalDbPath = join12(globalDir, "swarm.db");
+  const globalDbPath = join13(globalDir, "swarm.db");
   if (projectPath) {
     const oldPaths = getOldProjectDbPaths(projectPath);
     if (existsSync4(oldPaths.libsql)) {
@@ -29506,10 +29554,10 @@ function getDatabasePath2(projectPath) {
 }
 function getOldProjectDbPaths(projectPath) {
   const mainRepoPath = getMainRepoPath(projectPath);
-  const localDir = join12(mainRepoPath, ".opencode");
+  const localDir = join13(mainRepoPath, ".opencode");
   return {
-    libsql: join12(localDir, "streams.db"),
-    pglite: join12(localDir, "streams")
+    libsql: join13(localDir, "streams.db"),
+    pglite: join13(localDir, "streams")
   };
 }
 function clearAdapterCache() {
@@ -30907,10 +30955,10 @@ function mergeDefs2(...defs) {
 function cloneDef2(schema) {
   return mergeDefs2(schema._zod.def);
 }
-function getElementAtPath2(obj, path22) {
-  if (!path22)
+function getElementAtPath2(obj, path42) {
+  if (!path42)
     return obj;
-  return path22.reduce((acc, key) => acc?.[key], obj);
+  return path42.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject2(promisesObj) {
   const keys15 = Object.keys(promisesObj);
@@ -31221,11 +31269,11 @@ function aborted2(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues2(path22, issues) {
+function prefixIssues2(path42, issues) {
   return issues.map((iss) => {
     var _a15;
     (_a15 = iss).path ?? (_a15.path = []);
-    iss.path.unshift(path22);
+    iss.path.unshift(path42);
     return iss;
   });
 }
@@ -31388,7 +31436,7 @@ function formatError2(error46, mapper = (issue22) => issue22.message) {
 }
 function treeifyError2(error46, mapper = (issue22) => issue22.message) {
   const result = { errors: [] };
-  const processError = (error52, path22 = []) => {
+  const processError = (error52, path42 = []) => {
     var _a15, _b15;
     for (const issue22 of error52.issues) {
       if (issue22.code === "invalid_union" && issue22.errors.length) {
@@ -31398,7 +31446,7 @@ function treeifyError2(error46, mapper = (issue22) => issue22.message) {
       } else if (issue22.code === "invalid_element") {
         processError({ issues: issue22.issues }, issue22.path);
       } else {
-        const fullpath = [...path22, ...issue22.path];
+        const fullpath = [...path42, ...issue22.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue22));
           continue;
@@ -31430,8 +31478,8 @@ function treeifyError2(error46, mapper = (issue22) => issue22.message) {
 }
 function toDotPath2(_path) {
   const segs = [];
-  const path22 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path22) {
+  const path42 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path42) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -34042,13 +34090,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path22 = ref.slice(1).split("/").filter(Boolean);
-  if (path22.length === 0) {
+  const path42 = ref.slice(1).split("/").filter(Boolean);
+  if (path42.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path22[0] === defsKey) {
-    const key = path22[1];
+  if (path42[0] === defsKey) {
+    const key = path42[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -34511,11 +34559,11 @@ class ParseStatus2 {
 }
 
 class ParseInputLazyPath2 {
-  constructor(parent, value10, path22, key) {
+  constructor(parent, value10, path42, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value10;
-    this._path = path22;
+    this._path = path42;
     this._key = key;
   }
   get path() {
@@ -39528,6 +39576,201 @@ function createMemoryAdapter(db2, config3) {
     }
   };
 }
+function detectEnvironment() {
+  if (cachedEnvironment !== null) {
+    return cachedEnvironment;
+  }
+  const platform = process.platform;
+  if (platform === "win32") {
+    cachedEnvironment = "windows";
+    return cachedEnvironment;
+  }
+  if (platform === "darwin") {
+    cachedEnvironment = "darwin";
+    return cachedEnvironment;
+  }
+  if (platform === "linux") {
+    if (process.env.WSL_DISTRO_NAME || process.env.WSLENV) {
+      cachedEnvironment = "wsl";
+      return cachedEnvironment;
+    }
+    const msystem = process.env.MSYSTEM;
+    if (msystem && (msystem.includes("MINGW") || msystem.includes("MSYS"))) {
+      cachedEnvironment = "git-bash";
+      return cachedEnvironment;
+    }
+    if (process.env.CYGWIN) {
+      cachedEnvironment = "cygwin";
+      return cachedEnvironment;
+    }
+    cachedEnvironment = "linux";
+    return cachedEnvironment;
+  }
+  cachedEnvironment = "linux";
+  return cachedEnvironment;
+}
+function isAbsolute2(inputPath) {
+  return path2.win32.isAbsolute(inputPath) || path2.posix.isAbsolute(inputPath);
+}
+function isUNC(inputPath) {
+  const normalized = inputPath.replace(/\\/g, "/");
+  if (normalized.length < 3) {
+    return false;
+  }
+  if (!normalized.startsWith("//")) {
+    return false;
+  }
+  if (normalized[2] === "/") {
+    return false;
+  }
+  const afterPrefix = normalized.substring(2);
+  const hasValidServerPart = /^[^\s\/]+/.test(afterPrefix);
+  return hasValidServerPart;
+}
+function isWSLMount(inputPath) {
+  const wslMountPattern = /^\/mnt\/[a-z](\/|$)/i;
+  return wslMountPattern.test(inputPath);
+}
+function isGitBashMount(inputPath) {
+  const gitBashPattern = /^\/[a-z]\//i;
+  return gitBashPattern.test(inputPath);
+}
+function hasDriveLetter(inputPath) {
+  const driveLetterPattern = /^[A-Za-z]:/;
+  return driveLetterPattern.test(inputPath);
+}
+function parseWSLUNC(inputPath) {
+  const normalized = inputPath.replace(/\\/g, "/");
+  const wslUNCPattern = /^\/\/(wsl\.localhost|wsl\$)\/([^/]+)(\/.*)?$/i;
+  const match44 = normalized.match(wslUNCPattern);
+  if (!match44) {
+    return null;
+  }
+  const distro = match44[2];
+  const restPath = match44[3] || "/";
+  return { distro, path: restPath };
+}
+function isDriveRelative(inputPath) {
+  if (inputPath.length < 3) {
+    return false;
+  }
+  const hasLetter = /^[A-Za-z]$/.test(inputPath[0]);
+  const hasColon = inputPath[1] === ":";
+  const notSlash = inputPath[2] !== "/" && inputPath[2] !== "\\";
+  return hasLetter && hasColon && notSlash;
+}
+function normalize3(inputPath, options2) {
+  if (inputPath === null || inputPath === undefined) {
+    throw new TypeError("Path cannot be null or undefined");
+  }
+  if (typeof inputPath !== "string") {
+    throw new TypeError(`Path must be a string, received ${typeof inputPath}`);
+  }
+  if (inputPath.length === 0) {
+    throw new TypeError("Path cannot be empty");
+  }
+  if (inputPath.includes("\x00")) {
+    throw new TypeError("Path cannot contain null bytes");
+  }
+  const env = options2?.env ?? detectEnvironment();
+  const wslUNCInfo = parseWSLUNC(inputPath);
+  if (wslUNCInfo) {
+    const currentDistro = process.env.WSL_DISTRO_NAME;
+    if (env === "wsl" && currentDistro && wslUNCInfo.distro.toLowerCase() === currentDistro.toLowerCase()) {
+      return path3.posix.normalize(wslUNCInfo.path);
+    }
+  }
+  let intermediate = inputPath.replace(/\\/g, "/");
+  const originalIsUNC = isUNC(intermediate);
+  if (isWSLMount(intermediate)) {
+    const driveLetter = intermediate.charAt(5).toLowerCase();
+    intermediate = `${driveLetter}:${intermediate.substring(6)}`;
+    if (intermediate.length === 2) {
+      intermediate = `${driveLetter}:/`;
+    }
+  } else if (isGitBashMount(intermediate)) {
+    const driveLetter = intermediate.charAt(1).toLowerCase();
+    intermediate = `${driveLetter}:${intermediate.substring(2)}`;
+  }
+  const hasWindowsDrive = hasDriveLetter(intermediate);
+  const isAbsolutePath = isAbsolute2(intermediate);
+  const driveRelative = isDriveRelative(intermediate);
+  if (!isAbsolutePath && !hasWindowsDrive) {
+    const basePath = options2?.basePath ?? process.cwd();
+    const normalizedBase = basePath.replace(/\\/g, "/");
+    if (hasDriveLetter(normalizedBase)) {
+      const drive = normalizedBase.substring(0, 2);
+      const baseRest = normalizedBase.substring(2) || "/";
+      const resolved = path3.posix.resolve(baseRest, intermediate);
+      intermediate = drive + resolved;
+    } else {
+      intermediate = path3.posix.resolve(normalizedBase, intermediate);
+    }
+  } else if (driveRelative) {
+    const pathDrive = intermediate.substring(0, 2).toLowerCase();
+    const pathRest = intermediate.substring(2);
+    const basePath = options2?.basePath ?? process.cwd();
+    const normalizedBase = basePath.replace(/\\/g, "/");
+    if (hasDriveLetter(normalizedBase)) {
+      const baseDrive = normalizedBase.substring(0, 2).toLowerCase();
+      if (baseDrive === pathDrive) {
+        const baseRest = normalizedBase.substring(2) || "/";
+        const resolved = path3.posix.resolve(baseRest, pathRest);
+        intermediate = pathDrive + resolved;
+      } else {
+        intermediate = pathDrive + "/" + pathRest;
+      }
+    } else {
+      intermediate = pathDrive + "/" + pathRest;
+    }
+  }
+  if (originalIsUNC || isUNC(intermediate)) {
+    const withoutPrefix = intermediate.substring(2);
+    const normalizedRest = path3.posix.normalize(withoutPrefix);
+    intermediate = "//" + normalizedRest;
+  } else if (hasWindowsDrive || hasDriveLetter(intermediate)) {
+    const drive = intermediate.substring(0, 2);
+    let rest = intermediate.substring(2);
+    if (!rest.startsWith("/")) {
+      rest = "/" + rest;
+    }
+    const normalizedRest = path3.posix.normalize(rest);
+    intermediate = drive + normalizedRest;
+  } else {
+    intermediate = path3.posix.normalize(intermediate);
+  }
+  const finalHasDrive = hasDriveLetter(intermediate);
+  const finalIsUNC = isUNC(intermediate);
+  if (finalHasDrive || finalIsUNC) {
+    intermediate = intermediate.toLowerCase();
+    const segments = intermediate.split("/");
+    const normalizedSegments = segments.map((segment, index2) => {
+      if (index2 === 0 || segment === "") {
+        return segment;
+      }
+      return segment.replace(/[\s.]+$/, "");
+    });
+    intermediate = normalizedSegments.join("/");
+  }
+  if (intermediate.length > 1 && intermediate.endsWith("/")) {
+    const isWindowsRoot = finalHasDrive && intermediate.length === 3;
+    const isPosixRoot = intermediate === "/";
+    const isUNCRoot = finalIsUNC && intermediate.split("/").filter(Boolean).length <= 2;
+    if (!isWindowsRoot && !isPosixRoot && !isUNCRoot) {
+      intermediate = intermediate.slice(0, -1);
+    }
+  }
+  if (finalHasDrive && intermediate.length === 2) {
+    intermediate = intermediate + "/";
+  }
+  return intermediate;
+}
+function normalizeProjectKey(projectPath) {
+  if (projectPath === undefined || projectPath === null || projectPath === "" || projectPath === "global" || projectPath === "__global__") {
+    return "global";
+  }
+  return normalize3(projectPath);
+}
 function createDurableStreamAdapter(swarmMail, projectKey) {
   return {
     async read(offset, limit) {
@@ -41067,15 +41310,15 @@ function generateBeadId(projectKey) {
 }
 function getProjectPrefix(projectKey) {
   try {
-    const packageJsonPath = join13(projectKey, "package.json");
+    const packageJsonPath = join14(projectKey, "package.json");
     if (!existsSync5(packageJsonPath)) {
       return "cell";
     }
-    const packageJson = JSON.parse(readFileSync2(packageJsonPath, "utf-8"));
-    if (!packageJson.name || typeof packageJson.name !== "string") {
+    const packageJson2 = JSON.parse(readFileSync2(packageJsonPath, "utf-8"));
+    if (!packageJson2.name || typeof packageJson2.name !== "string") {
       return "cell";
     }
-    return slugifyProjectName(packageJson.name);
+    return slugifyProjectName(packageJson2.name);
   } catch (error410) {
     return "cell";
   }
@@ -41282,7 +41525,7 @@ async function importSingleCell(adapter5, projectKey, cellExport, options2, resu
       closedAt
     ]);
     if (cellExport.status === "tombstone") {
-      await db2.query("UPDATE beads SET deleted_at = $1 WHERE id = $2", [Date.now(), cellExport.id]);
+      await db2.query("UPDATE cells SET status = $1, updated_at = $2 WHERE id = $3", ["closed", Date.now(), cellExport.id]);
     }
     result.created++;
   } else {
@@ -41297,7 +41540,7 @@ async function importSingleCell(adapter5, projectKey, cellExport, options2, resu
         await adapter5.closeCell(projectKey, cellExport.id, "imported");
       } else if (cellExport.status === "in_progress") {
         const db2 = await adapter5.getDatabase();
-        await db2.query("UPDATE beads SET status = $1, updated_at = $2 WHERE id = $3", ["in_progress", Date.now(), cellExport.id]);
+        await db2.query("UPDATE cells SET status = $1, updated_at = $2 WHERE id = $3", ["in_progress", Date.now(), cellExport.id]);
       }
     }
     result.updated++;
@@ -42018,14 +42261,14 @@ function buildOrderByClause(policy) {
   }
 }
 function getDefaultLegacyPath() {
-  return join14(homedir3(), ".semantic-memory", "memory");
+  return join15(homedir3(), ".semantic-memory", "memory");
 }
-function legacyDatabaseExists(path22) {
-  const dbPath = path22 || getDefaultLegacyPath();
+function legacyDatabaseExists(path42) {
+  const dbPath = path42 || getDefaultLegacyPath();
   if (!existsSync7(dbPath)) {
     return false;
   }
-  const pgVersionPath = join14(dbPath, "PG_VERSION");
+  const pgVersionPath = join15(dbPath, "PG_VERSION");
   return existsSync7(pgVersionPath);
 }
 async function migrateLegacyMemories(options2) {
@@ -42321,7 +42564,7 @@ async function importSingleMemory(db2, memoryExport, skipExisting, result) {
   result.created++;
 }
 async function syncMemories(db2, hivePath) {
-  const memoriesPath = join15(hivePath, "memories.jsonl");
+  const memoriesPath = join16(hivePath, "memories.jsonl");
   let importResult = { created: 0, skipped: 0, errors: [] };
   if (existsSync8(memoriesPath)) {
     const fileContent = readFileSync3(memoriesPath, "utf-8");
@@ -42398,9 +42641,9 @@ async function createInMemoryDb() {
   await initializeSchema(client);
   return db2;
 }
-async function getDb(path22) {
+async function getDb(path42) {
   if (!dbInstance) {
-    const url4 = path22 || ":memory:";
+    const url4 = path42 || ":memory:";
     clientInstance = createClient6({ url: url4 });
     dbInstance = drizzle(clientInstance, { schema: exports_schema });
     await initializeSchema(clientInstance);
@@ -42416,41 +42659,41 @@ async function closeDb() {
 }
 async function detectStrayDatabases(projectPath) {
   const strays = [];
-  const rootOpencodePath = join16(projectPath, ".opencode");
+  const rootOpencodePath = join17(projectPath, ".opencode");
   if (existsSync9(rootOpencodePath)) {
     const files = readdirSync(rootOpencodePath);
     for (const file22 of files) {
       if (file22.endsWith(".db") && !file22.includes(".migrated") && !file22.includes(".backup-")) {
         strays.push({
-          path: join16(rootOpencodePath, file22),
+          path: join17(rootOpencodePath, file22),
           location: "project-root"
         });
       }
     }
   }
-  const hivePath = join16(projectPath, ".hive");
+  const hivePath = join17(projectPath, ".hive");
   if (existsSync9(hivePath)) {
     const files = readdirSync(hivePath);
     for (const file22 of files) {
       if (file22.endsWith(".db") && !file22.includes(".migrated") && !file22.includes(".backup-")) {
         strays.push({
-          path: join16(hivePath, file22),
+          path: join17(hivePath, file22),
           location: "legacy-hive"
         });
       }
     }
   }
-  const packagesPath = join16(projectPath, "packages");
+  const packagesPath = join17(projectPath, "packages");
   if (existsSync9(packagesPath)) {
     const packages = readdirSync(packagesPath);
     for (const pkg of packages) {
-      const pkgOpencodePath = join16(packagesPath, pkg, ".opencode");
+      const pkgOpencodePath = join17(packagesPath, pkg, ".opencode");
       if (existsSync9(pkgOpencodePath)) {
         const files = readdirSync(pkgOpencodePath);
         for (const file22 of files) {
           if (file22.endsWith(".db") && !file22.includes(".migrated") && !file22.includes(".backup-")) {
             strays.push({
-              path: join16(pkgOpencodePath, file22),
+              path: join17(pkgOpencodePath, file22),
               location: "nested-package"
             });
           }
@@ -42732,8 +42975,8 @@ async function consolidateDatabases(projectPath, globalDbPath, options2 = {}) {
   return report;
 }
 function viewSessionLine(opts) {
-  const { path: path22, line = 1, context: context15 = 3 } = opts;
-  const content = readFileSync4(path22, "utf-8");
+  const { path: path42, line = 1, context: context15 = 3 } = opts;
+  const content = readFileSync4(path42, "utf-8");
   const lines = content.split(`
 `).filter((line2) => line2.trim() !== "");
   if (line < 1 || line > lines.length) {
@@ -42742,7 +42985,7 @@ function viewSessionLine(opts) {
   const startLine = Math.max(1, line - context15);
   const endLine = Math.min(lines.length, line + context15);
   const output = [];
-  output.push(`File: ${path22}`);
+  output.push(`File: ${path42}`);
   output.push(`Line: ${line}${context15 > 0 ? ` (context: ${context15})` : ""}`);
   output.push("----------------------------------------");
   for (let i = startLine;i <= endLine; i++) {
@@ -42771,16 +43014,16 @@ function readdirp(root, options2 = {}) {
   options2.root = root;
   return new ReaddirpStream(options2);
 }
-function createFsWatchInstance(path22, options2, listener, errHandler, emitRaw) {
+function createFsWatchInstance(path42, options2, listener, errHandler, emitRaw) {
   const handleEvent = (rawEvent, evPath) => {
-    listener(path22);
-    emitRaw(rawEvent, evPath, { watchedPath: path22 });
-    if (evPath && path22 !== evPath) {
-      fsWatchBroadcast(sp.resolve(path22, evPath), KEY_LISTENERS, sp.join(path22, evPath));
+    listener(path42);
+    emitRaw(rawEvent, evPath, { watchedPath: path42 });
+    if (evPath && path42 !== evPath) {
+      fsWatchBroadcast(sp.resolve(path42, evPath), KEY_LISTENERS, sp.join(path42, evPath));
     }
   };
   try {
-    return fs_watch(path22, {
+    return fs_watch(path42, {
       persistent: options2.persistent
     }, handleEvent);
   } catch (error51) {
@@ -42796,13 +43039,13 @@ class NodeFsHandler {
     this.fsw = fsW;
     this._boundHandleError = (error51) => fsW._handleError(error51);
   }
-  _watchWithNodeFs(path22, listener) {
+  _watchWithNodeFs(path42, listener) {
     const opts = this.fsw.options;
-    const directory = sp.dirname(path22);
-    const basename32 = sp.basename(path22);
+    const directory = sp.dirname(path42);
+    const basename32 = sp.basename(path42);
     const parent = this.fsw._getWatchedDir(directory);
     parent.add(basename32);
-    const absolutePath = sp.resolve(path22);
+    const absolutePath = sp.resolve(path42);
     const options2 = {
       persistent: opts.persistent
     };
@@ -42812,12 +43055,12 @@ class NodeFsHandler {
     if (opts.usePolling) {
       const enableBin = opts.interval !== opts.binaryInterval;
       options2.interval = enableBin && isBinaryPath(basename32) ? opts.binaryInterval : opts.interval;
-      closer = setFsWatchFileListener(path22, absolutePath, options2, {
+      closer = setFsWatchFileListener(path42, absolutePath, options2, {
         listener,
         rawEmitter: this.fsw._emitRaw
       });
     } else {
-      closer = setFsWatchListener(path22, absolutePath, options2, {
+      closer = setFsWatchListener(path42, absolutePath, options2, {
         listener,
         errHandler: this._boundHandleError,
         rawEmitter: this.fsw._emitRaw
@@ -42829,13 +43072,13 @@ class NodeFsHandler {
     if (this.fsw.closed) {
       return;
     }
-    const dirname22 = sp.dirname(file22);
+    const dirname32 = sp.dirname(file22);
     const basename32 = sp.basename(file22);
-    const parent = this.fsw._getWatchedDir(dirname22);
+    const parent = this.fsw._getWatchedDir(dirname32);
     let prevStats = stats;
     if (parent.has(basename32))
       return;
-    const listener = async (path22, newStats) => {
+    const listener = async (path42, newStats) => {
       if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file22, 5))
         return;
       if (!newStats || newStats.mtimeMs === 0) {
@@ -42849,16 +43092,16 @@ class NodeFsHandler {
             this.fsw._emit(EV.CHANGE, file22, newStats2);
           }
           if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
-            this.fsw._closeFile(path22);
+            this.fsw._closeFile(path42);
             prevStats = newStats2;
             const closer2 = this._watchWithNodeFs(file22, listener);
             if (closer2)
-              this.fsw._addPathCloser(path22, closer2);
+              this.fsw._addPathCloser(path42, closer2);
           } else {
             prevStats = newStats2;
           }
         } catch (error51) {
-          this.fsw._remove(dirname22, basename32);
+          this.fsw._remove(dirname32, basename32);
         }
       } else if (parent.has(basename32)) {
         const at5 = newStats.atimeMs;
@@ -42877,7 +43120,7 @@ class NodeFsHandler {
     }
     return closer;
   }
-  async _handleSymlink(entry, directory, path22, item) {
+  async _handleSymlink(entry, directory, path42, item) {
     if (this.fsw.closed) {
       return;
     }
@@ -42887,7 +43130,7 @@ class NodeFsHandler {
       this.fsw._incrReadyCount();
       let linkPath;
       try {
-        linkPath = await fsrealpath(path22);
+        linkPath = await fsrealpath(path42);
       } catch (e) {
         this.fsw._emitReady();
         return true;
@@ -42897,12 +43140,12 @@ class NodeFsHandler {
       if (dir3.has(item)) {
         if (this.fsw._symlinkPaths.get(full) !== linkPath) {
           this.fsw._symlinkPaths.set(full, linkPath);
-          this.fsw._emit(EV.CHANGE, path22, entry.stats);
+          this.fsw._emit(EV.CHANGE, path42, entry.stats);
         }
       } else {
         dir3.add(item);
         this.fsw._symlinkPaths.set(full, linkPath);
-        this.fsw._emit(EV.ADD, path22, entry.stats);
+        this.fsw._emit(EV.ADD, path42, entry.stats);
       }
       this.fsw._emitReady();
       return true;
@@ -42932,9 +43175,9 @@ class NodeFsHandler {
         return;
       }
       const item = entry.path;
-      let path22 = sp.join(directory, item);
+      let path42 = sp.join(directory, item);
       current2.add(item);
-      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path22, item)) {
+      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path42, item)) {
         return;
       }
       if (this.fsw.closed) {
@@ -42943,8 +43186,8 @@ class NodeFsHandler {
       }
       if (item === target || !target && !previous2.has(item)) {
         this.fsw._incrReadyCount();
-        path22 = sp.join(dir3, sp.relative(dir3, path22));
-        this._addToNodeFs(path22, initialAdd, wh, depth + 1);
+        path42 = sp.join(dir3, sp.relative(dir3, path42));
+        this._addToNodeFs(path42, initialAdd, wh, depth + 1);
       }
     }).on(EV.ERROR, this._boundHandleError);
     return new Promise((resolve4, reject3) => {
@@ -42993,13 +43236,13 @@ class NodeFsHandler {
     }
     return closer;
   }
-  async _addToNodeFs(path22, initialAdd, priorWh, depth, target) {
+  async _addToNodeFs(path42, initialAdd, priorWh, depth, target) {
     const ready = this.fsw._emitReady;
-    if (this.fsw._isIgnored(path22) || this.fsw.closed) {
+    if (this.fsw._isIgnored(path42) || this.fsw.closed) {
       ready();
       return false;
     }
-    const wh = this.fsw._getWatchHelpers(path22);
+    const wh = this.fsw._getWatchHelpers(path42);
     if (priorWh) {
       wh.filterPath = (entry) => priorWh.filterPath(entry);
       wh.filterDir = (entry) => priorWh.filterDir(entry);
@@ -43015,8 +43258,8 @@ class NodeFsHandler {
       const follow = this.fsw.options.followSymlinks;
       let closer;
       if (stats.isDirectory()) {
-        const absPath = sp.resolve(path22);
-        const targetPath = follow ? await fsrealpath(path22) : path22;
+        const absPath = sp.resolve(path42);
+        const targetPath = follow ? await fsrealpath(path42) : path42;
         if (this.fsw.closed)
           return;
         closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
@@ -43026,29 +43269,29 @@ class NodeFsHandler {
           this.fsw._symlinkPaths.set(absPath, targetPath);
         }
       } else if (stats.isSymbolicLink()) {
-        const targetPath = follow ? await fsrealpath(path22) : path22;
+        const targetPath = follow ? await fsrealpath(path42) : path42;
         if (this.fsw.closed)
           return;
         const parent = sp.dirname(wh.watchPath);
         this.fsw._getWatchedDir(parent).add(wh.watchPath);
         this.fsw._emit(EV.ADD, wh.watchPath, stats);
-        closer = await this._handleDir(parent, stats, initialAdd, depth, path22, wh, targetPath);
+        closer = await this._handleDir(parent, stats, initialAdd, depth, path42, wh, targetPath);
         if (this.fsw.closed)
           return;
         if (targetPath !== undefined) {
-          this.fsw._symlinkPaths.set(sp.resolve(path22), targetPath);
+          this.fsw._symlinkPaths.set(sp.resolve(path42), targetPath);
         }
       } else {
         closer = this._handleFile(wh.watchPath, stats, initialAdd);
       }
       ready();
       if (closer)
-        this.fsw._addPathCloser(path22, closer);
+        this.fsw._addPathCloser(path42, closer);
       return false;
     } catch (error51) {
       if (this.fsw._handleError(error51)) {
         ready();
-        return path22;
+        return path42;
       }
     }
   }
@@ -43079,24 +43322,24 @@ function createPattern(matcher) {
   }
   return () => false;
 }
-function normalizePath(path22) {
-  if (typeof path22 !== "string")
+function normalizePath(path42) {
+  if (typeof path42 !== "string")
     throw new Error("string expected");
-  path22 = sp2.normalize(path22);
-  path22 = path22.replace(/\\/g, "/");
+  path42 = sp2.normalize(path42);
+  path42 = path42.replace(/\\/g, "/");
   let prepend8 = false;
-  if (path22.startsWith("//"))
+  if (path42.startsWith("//"))
     prepend8 = true;
-  path22 = path22.replace(DOUBLE_SLASH_RE, "/");
+  path42 = path42.replace(DOUBLE_SLASH_RE, "/");
   if (prepend8)
-    path22 = "/" + path22;
-  return path22;
+    path42 = "/" + path42;
+  return path42;
 }
 function matchPatterns(patterns, testString, stats) {
-  const path22 = normalizePath(testString);
+  const path42 = normalizePath(testString);
   for (let index2 = 0;index2 < patterns.length; index2++) {
     const pattern2 = patterns[index2];
-    if (pattern2(path22, stats)) {
+    if (pattern2(path42, stats)) {
       return true;
     }
   }
@@ -43177,10 +43420,10 @@ class WatchHelper {
   dirParts;
   followSymlinks;
   statMethod;
-  constructor(path22, follow, fsw) {
+  constructor(path42, follow, fsw) {
     this.fsw = fsw;
-    const watchPath = path22;
-    this.path = path22 = path22.replace(REPLACER_RE, "");
+    const watchPath = path42;
+    this.path = path42 = path42.replace(REPLACER_RE, "");
     this.watchPath = watchPath;
     this.fullWatchPath = sp2.resolve(watchPath);
     this.dirParts = [];
@@ -43466,7 +43709,7 @@ class SessionIndexer {
     const files = [];
     const entries8 = await fs.readdir(dir3, { withFileTypes: true });
     for (const entry of entries8) {
-      const fullPath = path2.join(dir3, entry.name);
+      const fullPath = path4.join(dir3, entry.name);
       if (entry.isDirectory() && recursive) {
         const subFiles = await this.findJsonlFiles(fullPath, recursive);
         files.push(...subFiles);
@@ -44290,7 +44533,7 @@ var __create2, __getProtoOf2, __defProp2, __getOwnPropNames2, __getOwnPropDesc,
     next = b2;
   }
   return out;
-}, getOrder3, getEquivalence5, forEach2, dedupeWith, dedupe = (self) => dedupeWith(self, equivalence()), dedupeAdjacentWith2, dedupeAdjacent2, join4, mapAccum, cartesianWith2, cartesian2, Do3, bind4, bindTo4, let_4, init_Array, PreconditionFailure, init_PreconditionFailure, init_Pre, Nil, init_StreamHelpers, safeSymbolIterator, Stream, init_Stream, cloneMethod, init_symbols, safeObjectDefineProperty, init_Value, safeObjectAssign, ChainArbitrary, MapArbitrary, FilterArbitrary, NoShrinkArbitrary, NoBiasArbitrary, init_Arbitrary, untouchedApply, ApplySymbol, init_apply, SArray, SBigInt, SBigInt64Array, SBigUint64Array, SBoolean, SDate, SError, SFloat32Array, SFloat64Array, SInt8Array, SInt16Array, SInt32Array, SNumber, SString, SSet, SUint8Array, SUint8ClampedArray, SUint16Array, SUint32Array, SencodeURIComponent, SMap, SSymbol, untouchedForEach, untouchedIndexOf, untouchedJoin, untouchedMap, untouchedFilter, untouchedPush, untouchedPop, untouchedSplice, untouchedSlice, untouchedSort, untouchedEvery, untouchedGetTime, untouchedToISOString, untouchedAdd, untouchedHas, untouchedSet, untouchedGet, untouchedMapSet, untouchedMapGet, untouchedSplit, untouchedStartsWith, untouchedEndsWith, untouchedSubstring, untouchedToLowerCase, untouchedToUpperCase, untouchedPadStart, untouchedCharCodeAt, untouchedNormalize, untouchedReplace, untouchedNumberToString, untouchedHasOwnProperty, untouchedToString, init_globals, LazyIterableIterator, init_LazyIterableIterator, safeArrayIsArray, safeObjectDefineProperty2, TupleArbitrary, init_TupleArbitrary, init_tuple, safeMathLog, init_IRawProperty, globalParameters, init_GlobalParameters, UndefinedContextPlaceholder, init_NoUndefinedAsContext, init_AsyncProperty_generic, AlwaysShrinkableArbitrary, init_AlwaysShrinkableArbitrary, init_AsyncProperty, init_Property_generic, init_Property, MULTIPLIER = 214013, INCREMENT = 2531011, MASK = 4294967295, MASK_2, computeNextSeed = function(seed) {
+}, getOrder3, getEquivalence5, forEach2, dedupeWith, dedupe = (self) => dedupeWith(self, equivalence()), dedupeAdjacentWith2, dedupeAdjacent2, join22, mapAccum, cartesianWith2, cartesian2, Do3, bind4, bindTo4, let_4, init_Array, PreconditionFailure, init_PreconditionFailure, init_Pre, Nil, init_StreamHelpers, safeSymbolIterator, Stream, init_Stream, cloneMethod, init_symbols, safeObjectDefineProperty, init_Value, safeObjectAssign, ChainArbitrary, MapArbitrary, FilterArbitrary, NoShrinkArbitrary, NoBiasArbitrary, init_Arbitrary, untouchedApply, ApplySymbol, init_apply, SArray, SBigInt, SBigInt64Array, SBigUint64Array, SBoolean, SDate, SError, SFloat32Array, SFloat64Array, SInt8Array, SInt16Array, SInt32Array, SNumber, SString, SSet, SUint8Array, SUint8ClampedArray, SUint16Array, SUint32Array, SencodeURIComponent, SMap, SSymbol, untouchedForEach, untouchedIndexOf, untouchedJoin, untouchedMap, untouchedFilter, untouchedPush, untouchedPop, untouchedSplice, untouchedSlice, untouchedSort, untouchedEvery, untouchedGetTime, untouchedToISOString, untouchedAdd, untouchedHas, untouchedSet, untouchedGet, untouchedMapSet, untouchedMapGet, untouchedSplit, untouchedStartsWith, untouchedEndsWith, untouchedSubstring, untouchedToLowerCase, untouchedToUpperCase, untouchedPadStart, untouchedCharCodeAt, untouchedNormalize, untouchedReplace, untouchedNumberToString, untouchedHasOwnProperty, untouchedToString, init_globals, LazyIterableIterator, init_LazyIterableIterator, safeArrayIsArray, safeObjectDefineProperty2, TupleArbitrary, init_TupleArbitrary, init_tuple, safeMathLog, init_IRawProperty, globalParameters, init_GlobalParameters, UndefinedContextPlaceholder, init_NoUndefinedAsContext, init_AsyncProperty_generic, AlwaysShrinkableArbitrary, init_AlwaysShrinkableArbitrary, init_AsyncProperty, init_Property_generic, init_Property, MULTIPLIER = 214013, INCREMENT = 2531011, MASK = 4294967295, MASK_2, computeNextSeed = function(seed) {
   return seed * MULTIPLIER + INCREMENT & MASK;
 }, computeValueFromNextSeed = function(nextseed) {
   return (nextseed & MASK_2) >> 16;
@@ -45809,7 +46052,7 @@ schema (${ast._tag}): ${ast}`;
 }), unsafeFromNonEmptyArray = (self) => unsafeFromArray(self), unsafeGet4, append3, prepend3, take3, drop3, dropRight2, dropWhile2, prependAll3, appendAll3, filterMap5, filter5, filterMapWhile3, compact = (self) => filterMap5(self, identity), flatMap5, forEach3, flatten5, chunksOf3, intersection4, isEmpty2 = (self) => self.length === 0, isNonEmpty2 = (self) => self.length > 0, head3, unsafeHead2 = (self) => unsafeGet4(self, 0), headNonEmpty2, last2 = (self) => get5(self, self.length - 1), unsafeLast = (self) => unsafeGet4(self, self.length - 1), lastNonEmpty2, map7, mapAccum2, partition3, partitionMap4, separate3 = (self) => pipe2(separate2(toReadonlyArray(self)), ([l, r]) => [unsafeFromArray(l), unsafeFromArray(r)]), size3 = (self) => self.length, sort2, sortWith2, splitAt2, splitNonEmptyAt2, split2, splitWhere2, tail2 = (self) => self.length > 0 ? some3(drop3(self, 1)) : none2(), tailNonEmpty2 = (self) => drop3(self, 1), takeRight2, takeWhile3, union3, dedupe2 = (self) => unsafeFromArray(dedupe(toReadonlyArray(self))), dedupeAdjacent3 = (self) => unsafeFromArray(dedupeAdjacent2(self)), unzip2 = (self) => {
   const [left3, right3] = unzip(self);
   return [unsafeFromArray(left3), unsafeFromArray(right3)];
-}, zipWith5, zip3, remove3, removeOption2, modifyOption3, modify3, replace3, replaceOption3, makeBy3, range3 = (start, end) => start <= end ? makeBy3(end - start + 1, (i) => start + i) : of3(start), contains4, containsWith4, findFirst4, findFirstIndex2, findLast3, findLastIndex2, every5, some8, join22, reduce4, reduceRight2, differenceWith2 = (isEquivalent) => {
+}, zipWith5, zip3, remove3, removeOption2, modifyOption3, modify3, replace3, replaceOption3, makeBy3, range3 = (start, end) => start <= end ? makeBy3(end - start + 1, (i) => start + i) : of3(start), contains4, containsWith4, findFirst4, findFirstIndex2, findLast3, findLastIndex2, every5, some8, join32, reduce4, reduceRight2, differenceWith2 = (isEquivalent) => {
   return dual(2, (self, that) => unsafeFromArray(differenceWith(isEquivalent)(that, self)));
 }, difference3, init_Chunk, exports_Duration, TypeId8, bigint03, bigint24, bigint60, bigint1e3, bigint1e6, bigint1e9, DURATION_REGEX, decode3 = (input) => {
   if (isDuration(input)) {
@@ -47633,7 +47876,7 @@ ${prefix}}`;
   Object.defineProperty(error210, "toString", {
     enumerable: false,
     value() {
-      const path22 = pipe2(this.path, join4(options2.pathDelim));
+      const path22 = pipe2(this.path, join22(options2.pathDelim));
       return `(Invalid data at ${path22}: "${this.message}")`;
     }
   });
@@ -47648,7 +47891,7 @@ ${prefix}}`;
   Object.defineProperty(error210, "toString", {
     enumerable: false,
     value() {
-      const path22 = pipe2(this.path, join4(options2.pathDelim));
+      const path22 = pipe2(this.path, join22(options2.pathDelim));
       return `(Missing data at ${path22}: "${this.message}")`;
     }
   });
@@ -47664,7 +47907,7 @@ ${prefix}}`;
   Object.defineProperty(error210, "toString", {
     enumerable: false,
     value() {
-      const path22 = pipe2(this.path, join4(options2.pathDelim));
+      const path22 = pipe2(this.path, join22(options2.pathDelim));
       return `(Source unavailable at ${path22}: "${this.message}")`;
     }
   });
@@ -47679,7 +47922,7 @@ ${prefix}}`;
   Object.defineProperty(error210, "toString", {
     enumerable: false,
     value() {
-      const path22 = pipe2(this.path, join4(options2.pathDelim));
+      const path22 = pipe2(this.path, join22(options2.pathDelim));
       return `(Unsupported operation at ${path22}: "${this.message}")`;
     }
   });
@@ -47736,7 +47979,7 @@ ${prefix}}`;
     pathDelim: "_",
     seqDelim: ","
   }, options2);
-  const makePathString = (path) => pipe2(path, join4(pathDelim));
+  const makePathString = (path) => pipe2(path, join22(pathDelim));
   const unmakePathString = (pathString) => pathString.split(pathDelim);
   const getEnv = () => typeof process !== "undefined" && ("env" in process) && typeof process.env === "object" ? process.env : {};
   const load = (path, primitive, split3 = true) => {
@@ -47774,7 +48017,7 @@ ${prefix}}`;
     seqDelim: ",",
     pathDelim: "."
   }, config2);
-  const makePathString = (path) => pipe2(path, join4(pathDelim));
+  const makePathString = (path) => pipe2(path, join22(pathDelim));
   const unmakePathString = (pathString) => pathString.split(pathDelim);
   const mapWithIndexSplit = splitIndexInKeys(map16, (str2) => unmakePathString(str2), makePathString);
   const load = (path, primitive, split3 = true) => {
@@ -47892,7 +48135,7 @@ ${prefix}}`;
           return fail2(right3.left);
         }
         if (isRight2(left3) && isRight2(right3)) {
-          const path = pipe2(prefix, join4("."));
+          const path = pipe2(prefix, join22("."));
           const fail5 = fromFlatLoopFail(prefix, path);
           const [lefts, rights] = extend22(fail5, fail5, pipe2(left3.right, map6(right2)), pipe2(right3.right, map6(right2)));
           return pipe2(lefts, zip2(rights), forEachSequential(([left4, right4]) => pipe2(zip5(left4, right4), map14(([left5, right5]) => op.zip(left5, right5)))));
@@ -48953,7 +49196,7 @@ ${prefix}}`;
   const _fiber = {
     ...CommitPrototype,
     commit() {
-      return join32(this);
+      return join42(this);
     },
     ...fiberProto,
     id: () => none4,
@@ -48967,7 +49210,7 @@ ${prefix}}`;
 }, dump = (self) => map14(self.status, (status) => ({
   id: self.id(),
   status
-})), dumpAll = (fibers) => forEachSequential(fibers, dump), fail6 = (error210) => done5(fail4(error210)), failCause5 = (cause2) => done5(failCause3(cause2)), fromEffect = (effect) => map14(exit(effect), done5), id = (self) => self.id(), inheritAll = (self) => self.inheritAll, interrupted = (fiberId2) => done5(interrupt4(fiberId2)), interruptAll = (fibers) => flatMap12(fiberId, (fiberId2) => pipe2(fibers, interruptAllAs(fiberId2))), interruptAllAs, interruptAsFork, join32 = (self) => zipLeft2(flatten8(self.await), self.inheritAll), map18, mapEffect2, mapFiber, match13, _never2, never3, orElse5, orElseEither3, poll3 = (self) => self.poll, parseMs = (milliseconds) => {
+})), dumpAll = (fibers) => forEachSequential(fibers, dump), fail6 = (error210) => done5(fail4(error210)), failCause5 = (cause2) => done5(failCause3(cause2)), fromEffect = (effect) => map14(exit(effect), done5), id = (self) => self.id(), inheritAll = (self) => self.inheritAll, interrupted = (fiberId2) => done5(interrupt4(fiberId2)), interruptAll = (fibers) => flatMap12(fiberId, (fiberId2) => pipe2(fibers, interruptAllAs(fiberId2))), interruptAllAs, interruptAsFork, join42 = (self) => zipLeft2(flatten8(self.await), self.inheritAll), map18, mapEffect2, mapFiber, match13, _never2, never3, orElse5, orElseEither3, poll3 = (self) => self.poll, parseMs = (milliseconds) => {
   const roundTowardsZero = milliseconds > 0 ? Math.floor : Math.ceil;
   return {
     days: roundTowardsZero(milliseconds / 86400000),
@@ -50438,7 +50681,7 @@ ${prefix}}`;
       next2();
     }
   }));
-  return asVoid2(onExit(flatten8(restore(join32(processingFiber))), exitMatch({
+  return asVoid2(onExit(flatten8(restore(join42(processingFiber))), exitMatch({
     onFailure: (cause2) => {
       onInterruptSignal();
       const target2 = residual.length + 1;
@@ -50609,7 +50852,7 @@ ${prefix}}`;
   const _fiberAll = {
     ...CommitPrototype2,
     commit() {
-      return join32(this);
+      return join42(this);
     },
     [FiberTypeId]: fiberVariance2,
     id: () => fromIterable2(fibers).reduce((id2, fiber) => combine5(id2, fiber.id()), none4),
@@ -50639,7 +50882,7 @@ ${prefix}}`;
     interruptAsFork: (fiberId2) => forEachSequentialDiscard(fibers, (fiber) => fiber.interruptAsFork(fiberId2))
   };
   return _fiberAll;
-}, fiberInterruptFork = (self) => asVoid2(forkDaemon2(interruptFiber(self))), fiberJoinAll = (fibers) => join32(fiberAll(fibers)), fiberScoped = (self) => acquireRelease2(succeed(self), interruptFiber), raceWith, disconnect = (self) => uninterruptibleMask((restore) => fiberIdWith((fiberId2) => flatMap12(forkDaemon2(restore(self)), (fiber) => pipe2(restore(join32(fiber)), onInterrupt(() => pipe2(fiber, interruptAsFork(fiberId2))))))), race2, raceFibersWith, completeRace = (winner, loser, cont, ab, cb) => {
+}, fiberInterruptFork = (self) => asVoid2(forkDaemon2(interruptFiber(self))), fiberJoinAll = (fibers) => join42(fiberAll(fibers)), fiberScoped = (self) => acquireRelease2(succeed(self), interruptFiber), raceWith, disconnect = (self) => uninterruptibleMask((restore) => fiberIdWith((fiberId2) => flatMap12(forkDaemon2(restore(self)), (fiber) => pipe2(restore(join42(fiber)), onInterrupt(() => pipe2(fiber, interruptAsFork(fiberId2))))))), race2, raceFibersWith, completeRace = (winner, loser, cont, ab, cb) => {
   if (compareAndSet(true, false)(ab)) {
     cb(cont(winner, loser));
   }
@@ -50857,7 +51100,7 @@ ${prefix}}`;
       return end3 - time3 <= 0 ? some3(computeCachedValue(self, timeToLive, time3)) : none2();
     }
   }
-})), flatMap12((option4) => isNone2(option4) ? dieMessage("BUG: Effect.cachedInvalidate - please report an issue at https://github.com/Effect-TS/effect/issues") : restore(deferredAwait(option4.value[1]))))), invalidateCache = (cache) => set6(cache, none2()), ensuringChild, ensuringChildren, forkAll, forkIn2, forkScoped2 = (self) => scopeWith((scope3) => forkIn2(self, scope3)), fromFiber = (fiber) => join32(fiber), fromFiberEffect = (fiber) => suspend(() => flatMap12(fiber, join32)), memoKeySymbol, Key, cachedFunction = (f, eq) => {
+})), flatMap12((option4) => isNone2(option4) ? dieMessage("BUG: Effect.cachedInvalidate - please report an issue at https://github.com/Effect-TS/effect/issues") : restore(deferredAwait(option4.value[1]))))), invalidateCache = (cache) => set6(cache, none2()), ensuringChild, ensuringChildren, forkAll, forkIn2, forkScoped2 = (self) => scopeWith((scope3) => forkIn2(self, scope3)), fromFiber = (fiber) => join42(fiber), fromFiberEffect = (fiber) => suspend(() => flatMap12(fiber, join42)), memoKeySymbol, Key, cachedFunction = (f, eq) => {
   return pipe2(sync(() => empty23()), flatMap12(makeSynchronized), map14((ref) => (a) => pipe2(ref.modifyEffect((map23) => {
     const result = pipe2(map23, get9(new Key(a, eq)));
     if (isNone2(result)) {
@@ -50869,7 +51112,7 @@ ${prefix}}`;
   const ref = unsafeMake7(value2);
   const sem = unsafeMakeSemaphore(1);
   return new SynchronizedImpl(ref, sem.withPermits(1));
-}, updateSomeAndGetEffectSynchronized, zipFiber, zipLeftFiber, zipRightFiber, zipWithFiber, bindAll, init_circular, TypeId19, init_circular2, OP_EXTEND_SCOPE = "ExtendScope", OP_FOLD = "Fold", OP_FRESH = "Fresh", OP_FROM_EFFECT = "FromEffect", OP_SCOPED = "Scoped", OP_SUSPEND = "Suspend", OP_PROVIDE = "Provide", OP_PROVIDE_MERGE = "ProvideMerge", OP_MERGE_ALL = "MergeAll", OP_ZIP_WITH2 = "ZipWith", exports_Fiber, FiberTypeId2, RuntimeFiberTypeId2, Order8, isFiber2, isRuntimeFiber2, id2, _await3, awaitAll, children2, all10, done8, dump2, dumpAll2, fail9, failCause7, fromEffect3, getCurrentFiber2, inheritAll2, interrupt7, interrupted2, interruptAs, interruptAsFork2, interruptAll2, interruptAllAs2, interruptFork, join42, joinAll, map23, mapEffect3, mapFiber2, match15, never4, orElse6, orElseEither5, poll4, pretty4, roots2, unsafeRoots2, scoped2, status2, succeed9, void_7, zip11, zipLeft5, zipRight5, zipWith9, init_Fiber, makeDual = (f) => function() {
+}, updateSomeAndGetEffectSynchronized, zipFiber, zipLeftFiber, zipRightFiber, zipWithFiber, bindAll, init_circular, TypeId19, init_circular2, OP_EXTEND_SCOPE = "ExtendScope", OP_FOLD = "Fold", OP_FRESH = "Fresh", OP_FROM_EFFECT = "FromEffect", OP_SCOPED = "Scoped", OP_SUSPEND = "Suspend", OP_PROVIDE = "Provide", OP_PROVIDE_MERGE = "ProvideMerge", OP_MERGE_ALL = "MergeAll", OP_ZIP_WITH2 = "ZipWith", exports_Fiber, FiberTypeId2, RuntimeFiberTypeId2, Order8, isFiber2, isRuntimeFiber2, id2, _await3, awaitAll, children2, all10, done8, dump2, dumpAll2, fail9, failCause7, fromEffect3, getCurrentFiber2, inheritAll2, interrupt7, interrupted2, interruptAs, interruptAsFork2, interruptAll2, interruptAllAs2, interruptFork, join5, joinAll, map23, mapEffect3, mapFiber2, match15, never4, orElse6, orElseEither5, poll4, pretty4, roots2, unsafeRoots2, scoped2, status2, succeed9, void_7, zip11, zipLeft5, zipRight5, zipWith9, init_Fiber, makeDual = (f) => function() {
   if (arguments.length === 1) {
     const runtime3 = arguments[0];
     return (effect, ...args2) => f(runtime3, effect, ...args2);
@@ -54895,7 +55138,7 @@ ${prefix}}`;
   } else {
     reject2(squash(exit4.cause));
   }
-}))), join5 = (self) => _await(self.deferred), awaitEmpty = (self) => suspend4(() => {
+}))), join6 = (self) => _await(self.deferred), awaitEmpty = (self) => suspend4(() => {
   if (self.state._tag === "Closed" || self.state.fiber === undefined) {
     return _void3;
   }
@@ -54964,7 +55207,7 @@ ${prefix}}`;
   } else {
     reject2(squash(exit4.cause));
   }
-}))), size25 = (self) => sync8(() => self.state._tag === "Closed" ? 0 : size10(self.state.backing)), join6 = (self) => _await(self.deferred), awaitEmpty2 = (self) => whileLoop3({
+}))), size25 = (self) => sync8(() => self.state._tag === "Closed" ? 0 : size10(self.state.backing)), join7 = (self) => _await(self.deferred), awaitEmpty2 = (self) => whileLoop3({
   while: () => self.state._tag === "Open" && size10(self.state.backing) > 0,
   body: () => _await3(unsafeHead(self)[1]),
   step: constVoid
@@ -55021,7 +55264,7 @@ ${prefix}}`;
   } else {
     reject2(squash(exit4.cause));
   }
-}))), size26 = (self) => sync8(() => self.state._tag === "Closed" ? 0 : self.state.backing.size), join7 = (self) => _await(self.deferred), awaitEmpty3 = (self) => whileLoop3({
+}))), size26 = (self) => sync8(() => self.state._tag === "Closed" ? 0 : self.state.backing.size), join8 = (self) => _await(self.deferred), awaitEmpty3 = (self) => whileLoop3({
   while: () => self.state._tag === "Open" && self.state.backing.size > 0,
   body: () => _await3(unsafeHead(self)),
   step: constVoid
@@ -66814,8 +67057,8 @@ ${prefix}}`;
   }
   return { message };
 }, en_default3, init_en3, overrideErrorMap2, init_errors6, makeIssue2 = (params) => {
-  const { data, path: path22, errorMaps, issueData } = params;
-  const fullPath = [...path22, ...issueData.path || []];
+  const { data, path: path42, errorMaps, issueData } = params;
+  const fullPath = [...path42, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -68151,7 +68394,7 @@ ${prefix}}`;
     }
     return this._output;
   }
-}, JsonToSseTransformStream, uiMessageChunkSchema, originalGenerateId2, uiMessagesSchema, originalGenerateId3, originalGenerateId4, name142 = "AI_NoSuchProviderError", marker142, symbol142, _a142, init_dist6, exports_memory_operations, MemoryOperationSchema, init_memory_operations, exports_auto_tagger, AutoTagResultSchema, init_auto_tagger, exports_memory_linking, DEFAULT_CONFIG, init_memory_linking, exports_entity_extraction, EntitySchema, RelationshipSchema, ExtractionSchema, init_entity_extraction, init_adapter2, import_debug, log, CORS_HEADERS, HEARTBEAT_INTERVAL = 30000, checkpointFrequency, humanFeedback, recoverySuccess, scopeViolations, taskDuration, ANALYTICS_QUERIES, DEFAULT_TOMBSTONE_TTL_MS = 2592000000, MIN_TOMBSTONE_TTL_MS = 604800000, CLOCK_SKEW_GRACE_MS = 3600000, STATUS_TOMBSTONE = "tombstone", dbInstance, clientInstance, TABLE_COLUMNS, EntryTypes, defaultOptions2, RECURSIVE_ERROR_CODE = "READDIRP_RECURSIVE_ERROR", NORMAL_FLOW_ERRORS, ALL_TYPES, DIR_TYPES, FILE_TYPES, isNormalFlowError = (error51) => NORMAL_FLOW_ERRORS.has(error51.code), wantBigintFsStats, emptyFn = (_entryInfo) => true, normalizeFilter = (filter28) => {
+}, JsonToSseTransformStream, uiMessageChunkSchema, originalGenerateId2, uiMessagesSchema, originalGenerateId3, originalGenerateId4, name142 = "AI_NoSuchProviderError", marker142, symbol142, _a142, init_dist6, exports_memory_operations, MemoryOperationSchema, init_memory_operations, exports_auto_tagger, AutoTagResultSchema, init_auto_tagger, exports_memory_linking, DEFAULT_CONFIG, init_memory_linking, exports_entity_extraction, EntitySchema, RelationshipSchema, ExtractionSchema, init_entity_extraction, init_adapter2, __dirname2, require2, packageJson, SWARM_MAIL_VERSION, import_debug, log, cachedEnvironment = null, CORS_HEADERS, HEARTBEAT_INTERVAL = 30000, checkpointFrequency, humanFeedback, recoverySuccess, scopeViolations, taskDuration, ANALYTICS_QUERIES, DEFAULT_TOMBSTONE_TTL_MS = 2592000000, MIN_TOMBSTONE_TTL_MS = 604800000, CLOCK_SKEW_GRACE_MS = 3600000, STATUS_TOMBSTONE = "tombstone", dbInstance, clientInstance, TABLE_COLUMNS, EntryTypes, defaultOptions2, RECURSIVE_ERROR_CODE = "READDIRP_RECURSIVE_ERROR", NORMAL_FLOW_ERRORS, ALL_TYPES, DIR_TYPES, FILE_TYPES, isNormalFlowError = (error51) => NORMAL_FLOW_ERRORS.has(error51.code), wantBigintFsStats, emptyFn = (_entryInfo) => true, normalizeFilter = (filter28) => {
   if (filter28 === undefined)
     return emptyFn;
   if (typeof filter28 === "function")
@@ -68198,12 +68441,12 @@ ${prefix}}`;
   foreach(cont[listenerType], (listener) => {
     listener(val1, val2, val3);
   });
-}, setFsWatchListener = (path22, fullPath, options2, handlers) => {
+}, setFsWatchListener = (path42, fullPath, options2, handlers) => {
   const { listener, errHandler, rawEmitter } = handlers;
   let cont = FsWatchInstances.get(fullPath);
   let watcher;
   if (!options2.persistent) {
-    watcher = createFsWatchInstance(path22, options2, listener, errHandler, rawEmitter);
+    watcher = createFsWatchInstance(path42, options2, listener, errHandler, rawEmitter);
     if (!watcher)
       return;
     return watcher.close.bind(watcher);
@@ -68213,7 +68456,7 @@ ${prefix}}`;
     addAndConvert(cont, KEY_ERR, errHandler);
     addAndConvert(cont, KEY_RAW, rawEmitter);
   } else {
-    watcher = createFsWatchInstance(path22, options2, fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS), errHandler, fsWatchBroadcast.bind(null, fullPath, KEY_RAW));
+    watcher = createFsWatchInstance(path42, options2, fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS), errHandler, fsWatchBroadcast.bind(null, fullPath, KEY_RAW));
     if (!watcher)
       return;
     watcher.on(EV.ERROR, async (error51) => {
@@ -68222,7 +68465,7 @@ ${prefix}}`;
         cont.watcherUnusable = true;
       if (isWindows && error51.code === "EPERM") {
         try {
-          const fd = await open(path22, "r");
+          const fd = await open(path42, "r");
           await fd.close();
           broadcastErr(error51);
         } catch (err) {}
@@ -68250,7 +68493,7 @@ ${prefix}}`;
       Object.freeze(cont);
     }
   };
-}, FsWatchFileInstances, setFsWatchFileListener = (path22, fullPath, options2, handlers) => {
+}, FsWatchFileInstances, setFsWatchFileListener = (path42, fullPath, options2, handlers) => {
   const { listener, rawEmitter } = handlers;
   let cont = FsWatchFileInstances.get(fullPath);
   const copts = cont && cont.options;
@@ -68272,7 +68515,7 @@ ${prefix}}`;
         });
         const currmtime = curr.mtimeMs;
         if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
-          foreach(cont.listeners, (listener2) => listener2(path22, curr));
+          foreach(cont.listeners, (listener2) => listener2(path42, curr));
         }
       })
     };
@@ -68305,18 +68548,18 @@ ${prefix}}`;
     str2 = SLASH + str2;
   }
   return str2;
-}, normalizePathToUnix = (path22) => toUnix(sp2.normalize(toUnix(path22))), normalizeIgnored = (cwd = "") => (path22) => {
-  if (typeof path22 === "string") {
-    return normalizePathToUnix(sp2.isAbsolute(path22) ? path22 : sp2.join(cwd, path22));
+}, normalizePathToUnix = (path42) => toUnix(sp2.normalize(toUnix(path42))), normalizeIgnored = (cwd = "") => (path42) => {
+  if (typeof path42 === "string") {
+    return normalizePathToUnix(sp2.isAbsolute(path42) ? path42 : sp2.join(cwd, path42));
   } else {
-    return path22;
+    return path42;
   }
-}, getAbsolutePath = (path22, cwd) => {
-  if (sp2.isAbsolute(path22)) {
-    return path22;
+}, getAbsolutePath = (path42, cwd) => {
+  if (sp2.isAbsolute(path42)) {
+    return path42;
   }
-  return sp2.join(cwd, path22);
-}, EMPTY_SET, STAT_METHOD_F = "stat", STAT_METHOD_L = "lstat", FSWatcher, chokidar_default, FileWatcher, NormalizedMessageSchema, OpenCodeSwarmEventSchema, SWARM_MAIL_VERSION = "1.10.1";
+  return sp2.join(cwd, path42);
+}, EMPTY_SET, STAT_METHOD_F = "stat", STAT_METHOD_L = "lstat", FSWatcher, chokidar_default, FileWatcher, NormalizedMessageSchema, OpenCodeSwarmEventSchema;
 var init_dist2 = __esm(() => {
   __create2 = Object.create;
   __getProtoOf2 = Object.getPrototypeOf;
@@ -70833,7 +71076,7 @@ var init_dist2 = __esm(() => {
     length: () => length,
     lastNonEmpty: () => lastNonEmpty,
     last: () => last,
-    join: () => join4,
+    join: () => join22,
     isNonEmptyReadonlyArray: () => isNonEmptyReadonlyArray,
     isNonEmptyArray: () => isNonEmptyArray2,
     isEmptyReadonlyArray: () => isEmptyReadonlyArray,
@@ -71389,7 +71632,7 @@ var init_dist2 = __esm(() => {
       return out;
     });
     dedupeAdjacent2 = /* @__PURE__ */ dedupeAdjacentWith2(/* @__PURE__ */ equivalence());
-    join4 = /* @__PURE__ */ dual(2, (self, sep) => fromIterable2(self).join(sep));
+    join22 = /* @__PURE__ */ dual(2, (self, sep) => fromIterable2(self).join(sep));
     mapAccum = /* @__PURE__ */ dual(3, (self, s, f) => {
       let i = 0;
       let s1 = s;
@@ -77773,7 +78016,7 @@ var init_dist2 = __esm(() => {
     make: () => make9,
     lastNonEmpty: () => lastNonEmpty2,
     last: () => last2,
-    join: () => join22,
+    join: () => join32,
     isNonEmpty: () => isNonEmpty2,
     isEmpty: () => isEmpty2,
     isChunk: () => isChunk,
@@ -78166,7 +78409,7 @@ var init_dist2 = __esm(() => {
     findLastIndex2 = findLastIndex;
     every5 = /* @__PURE__ */ dual(2, (self, refinement) => fromIterable2(self).every(refinement));
     some8 = /* @__PURE__ */ dual(2, (self, predicate) => fromIterable2(self).some(predicate));
-    join22 = join4;
+    join32 = join22;
     reduce4 = reduce3;
     reduceRight2 = reduceRight;
     difference3 = /* @__PURE__ */ dual(2, (self, that) => unsafeFromArray(difference2(that, self)));
@@ -84214,7 +84457,7 @@ ${stack.split(`
       const _fiber = {
         ...CommitPrototype,
         commit() {
-          return join32(this);
+          return join42(this);
         },
         ...fiberProto,
         id: () => self.id(),
@@ -84249,7 +84492,7 @@ ${stack.split(`
     _never2 = {
       ...CommitPrototype,
       commit() {
-        return join32(this);
+        return join42(this);
       },
       ...fiberProto,
       id: () => none4,
@@ -84263,7 +84506,7 @@ ${stack.split(`
     orElse5 = /* @__PURE__ */ dual(2, (self, that) => ({
       ...CommitPrototype,
       commit() {
-        return join32(this);
+        return join42(this);
       },
       ...fiberProto,
       id: () => getOrElse6(self.id(), that.id()),
@@ -86098,7 +86341,7 @@ ${stack.split(`
         this.refreshRefCache();
       }
       commit() {
-        return join32(this);
+        return join42(this);
       }
       id() {
         return this._fiberId;
@@ -87030,11 +87273,11 @@ ${stack.split(`
     }));
     race2 = /* @__PURE__ */ dual(2, (self, that) => fiberIdWith((parentFiberId) => raceWith(self, that, {
       onSelfDone: (exit3, right3) => exitMatchEffect(exit3, {
-        onFailure: (cause2) => pipe2(join32(right3), mapErrorCause2((cause22) => parallel(cause2, cause22))),
+        onFailure: (cause2) => pipe2(join42(right3), mapErrorCause2((cause22) => parallel(cause2, cause22))),
         onSuccess: (value2) => pipe2(right3, interruptAsFiber(parentFiberId), as3(value2))
       }),
       onOtherDone: (exit3, left3) => exitMatchEffect(exit3, {
-        onFailure: (cause2) => pipe2(join32(left3), mapErrorCause2((cause22) => parallel(cause22, cause2))),
+        onFailure: (cause2) => pipe2(join42(left3), mapErrorCause2((cause22) => parallel(cause22, cause2))),
         onSuccess: (value2) => pipe2(left3, interruptAsFiber(parentFiberId), as3(value2))
       })
     })));
@@ -87982,7 +88225,7 @@ ${stack.split(`
     zipWithFiber = /* @__PURE__ */ dual(3, (self, that, f) => ({
       ...CommitPrototype2,
       commit() {
-        return join32(this);
+        return join42(this);
       },
       [FiberTypeId]: fiberVariance2,
       id: () => pipe2(self.id(), getOrElse6(that.id())),
@@ -88027,7 +88270,7 @@ ${stack.split(`
     mapEffect: () => mapEffect3,
     map: () => map23,
     joinAll: () => joinAll,
-    join: () => join42,
+    join: () => join5,
     isRuntimeFiber: () => isRuntimeFiber2,
     isFiber: () => isFiber2,
     interrupted: () => interrupted2,
@@ -88084,7 +88327,7 @@ ${stack.split(`
     interruptAll2 = interruptAll;
     interruptAllAs2 = interruptAllAs;
     interruptFork = fiberInterruptFork;
-    join42 = join32;
+    join5 = join42;
     joinAll = fiberJoinAll;
     map23 = map18;
     mapEffect3 = mapEffect2;
@@ -91788,8 +92031,8 @@ ${stack.split(`
           function go2(state) {
             switch (state._tag) {
               case OP_BOTH_RUNNING: {
-                const leftJoin = interruptible4(join42(state.left));
-                const rightJoin = interruptible4(join42(state.right));
+                const leftJoin = interruptible4(join5(state.left));
+                const rightJoin = interruptible4(join5(state.right));
                 return unwrap2(raceWith2(leftJoin, rightJoin, {
                   onSelfDone: (leftExit, rf) => zipRight7(interrupt7(rf), handleSide(leftExit, state.right, pullL)(options2.onSelfDone, BothRunning, (f) => LeftDone(f))),
                   onOtherDone: (rightExit, lf) => zipRight7(interrupt7(lf), handleSide(rightExit, state.left, pullR)(options2.onOtherDone, (left3, right3) => BothRunning(right3, left3), (f) => RightDone(f)))
@@ -93786,14 +94029,14 @@ ${stack.split(`
               }
             }
           })), unwrap2);
-          return unwrap2(raceWith2(join42(sinkFiber), join42(scheduleFiber), {
+          return unwrap2(raceWith2(join5(sinkFiber), join5(scheduleFiber), {
             onSelfDone: (sinkExit, _) => pipe2(interrupt7(scheduleFiber), zipRight7(pipe2(suspend4(() => sinkExit), map26(([leftovers, b]) => handleSide(leftovers, b, none2()))))),
             onOtherDone: (scheduleExit, _) => matchCauseEffect3(suspend4(() => scheduleExit), {
               onFailure: (cause3) => match(failureOrCause2(cause3), {
-                onLeft: () => pipe2(handoff, offer6(end3(ScheduleEnd)), forkDaemon3, zipRight7(pipe2(join42(sinkFiber), map26(([leftovers, b]) => handleSide(leftovers, b, none2()))))),
-                onRight: (cause4) => pipe2(handoff, offer6(halt(cause4)), forkDaemon3, zipRight7(pipe2(join42(sinkFiber), map26(([leftovers, b]) => handleSide(leftovers, b, none2())))))
+                onLeft: () => pipe2(handoff, offer6(end3(ScheduleEnd)), forkDaemon3, zipRight7(pipe2(join5(sinkFiber), map26(([leftovers, b]) => handleSide(leftovers, b, none2()))))),
+                onRight: (cause4) => pipe2(handoff, offer6(halt(cause4)), forkDaemon3, zipRight7(pipe2(join5(sinkFiber), map26(([leftovers, b]) => handleSide(leftovers, b, none2())))))
               }),
-              onSuccess: (c) => pipe2(handoff, offer6(end3(ScheduleEnd)), forkDaemon3, zipRight7(pipe2(join42(sinkFiber), map26(([leftovers, b]) => handleSide(leftovers, b, some3(c))))))
+              onSuccess: (c) => pipe2(handoff, offer6(end3(ScheduleEnd)), forkDaemon3, zipRight7(pipe2(join5(sinkFiber), map26(([leftovers, b]) => handleSide(leftovers, b, some3(c))))))
             })
           }));
         };
@@ -93993,7 +94236,7 @@ ${stack.split(`
             })));
           }
           case OP_PREVIOUS: {
-            return unwrap2(take10(handoff).pipe(forkIn3(scope6), flatMap18((handoffFiber) => raceWith2(join42(state.fiber), join42(handoffFiber), {
+            return unwrap2(take10(handoff).pipe(forkIn3(scope6), flatMap18((handoffFiber) => raceWith2(join5(state.fiber), join5(handoffFiber), {
               onSelfDone: (leftExit, current2) => match7(leftExit, {
                 onFailure: (cause3) => interrupt7(current2).pipe(as8(failCause12(cause3))),
                 onSuccess: (chunk4) => interrupt7(current2).pipe(zipRight7(succeed13(write(chunk4).pipe(flatMap20(() => consumer(current(handoffFiber)))))))
@@ -94009,7 +94252,7 @@ ${stack.split(`
                       return interrupt7(previous2).pipe(as8(failCause12(signal.cause)));
                     }
                     case OP_END: {
-                      return join42(previous2).pipe(map26((chunk4) => write(chunk4).pipe(zipRight8(void_8))));
+                      return join5(previous2).pipe(map26((chunk4) => write(chunk4).pipe(zipRight8(void_8))));
                     }
                   }
                 }
@@ -94017,7 +94260,7 @@ ${stack.split(`
             }))));
           }
           case OP_CURRENT: {
-            return unwrap2(join42(state.fiber).pipe(map26((signal) => {
+            return unwrap2(join5(state.fiber).pipe(map26((signal) => {
               switch (signal._tag) {
                 case OP_EMIT4: {
                   return unwrap2(enqueue(signal.elements));
@@ -95464,8 +95707,8 @@ ${stack.split(`
     zipLatestWith = /* @__PURE__ */ dual(3, (left3, right3, f) => {
       const pullNonEmpty = (pull) => pipe2(pull, flatMap18((chunk4) => isEmpty2(chunk4) ? pullNonEmpty(pull) : succeed13(chunk4)));
       return pipe2(toPull2(left3), map26(pullNonEmpty), zip12(pipe2(toPull2(right3), map26(pullNonEmpty))), flatMap18(([left4, right4]) => pipe2(fromEffectOption(raceWith2(left4, right4, {
-        onSelfDone: (leftDone, rightFiber) => pipe2(suspend4(() => leftDone), zipWith12(join42(rightFiber), (l, r) => [l, r, true])),
-        onOtherDone: (rightDone, leftFiber) => pipe2(suspend4(() => rightDone), zipWith12(join42(leftFiber), (l, r) => [r, l, false]))
+        onSelfDone: (leftDone, rightFiber) => pipe2(suspend4(() => leftDone), zipWith12(join5(rightFiber), (l, r) => [l, r, true])),
+        onOtherDone: (rightDone, leftFiber) => pipe2(suspend4(() => rightDone), zipWith12(join5(leftFiber), (l, r) => [r, l, false]))
       })), flatMap23(([l, r, leftFirst]) => pipe2(fromEffect9(make37([unsafeLast(l), unsafeLast(r)])), flatMap23((latest) => pipe2(fromChunk(leftFirst ? pipe2(r, map7((a2) => f(unsafeLast(l), a2))) : pipe2(l, map7((a) => f(a, unsafeLast(r))))), concat3(pipe2(repeatEffectOption(left4), mergeEither(repeatEffectOption(right4)), mapEffectSequential(match({
         onLeft: (leftChunk) => modify8(latest, ([_, rightLatest]) => [pipe2(leftChunk, map7((a) => f(a, rightLatest))), [unsafeLast(leftChunk), rightLatest]]),
         onRight: (rightChunk) => modify8(latest, ([leftLatest, _]) => [pipe2(rightChunk, map7((a2) => f(leftLatest, a2))), [leftLatest, unsafeLast(rightChunk)]])
@@ -96504,7 +96747,7 @@ ${stack.split(`
     makeRuntimePromise: () => makeRuntimePromise,
     makeRuntime: () => makeRuntime,
     make: () => make79,
-    join: () => join5,
+    join: () => join6,
     isFiberHandle: () => isFiberHandle,
     get: () => get18,
     clear: () => clear4,
@@ -96606,7 +96849,7 @@ ${stack.split(`
     makeRuntimePromise: () => makeRuntimePromise2,
     makeRuntime: () => makeRuntime2,
     make: () => make80,
-    join: () => join6,
+    join: () => join7,
     isFiberMap: () => isFiberMap,
     has: () => has10,
     get: () => get19,
@@ -96731,7 +96974,7 @@ ${stack.split(`
     makeRuntimePromise: () => makeRuntimePromise3,
     makeRuntime: () => makeRuntime3,
     make: () => make81,
-    join: () => join7,
+    join: () => join8,
     isFiberSet: () => isFiberSet,
     clear: () => clear6,
     awaitEmpty: () => awaitEmpty3,
@@ -110121,7 +110364,7 @@ ${stack.split(`
         return new SQL([new StringChunk(str2)]);
       }
       sql2.raw = raw;
-      function join11(chunks3, separator) {
+      function join12(chunks3, separator) {
         const result = [];
         for (const [i, chunk7] of chunks3.entries()) {
           if (i > 0 && separator !== undefined) {
@@ -110131,7 +110374,7 @@ ${stack.split(`
         }
         return new SQL(result);
       }
-      sql2.join = join11;
+      sql2.join = join12;
       function identifier2(value10) {
         return new Name(value10);
       }
@@ -111844,7 +112087,7 @@ ${stack.split(`
         return (table3, on) => {
           const baseTableName = this.tableName;
           const tableName = getTableLikeName(table3);
-          if (typeof tableName === "string" && this.config.joins?.some((join11) => join11.alias === tableName)) {
+          if (typeof tableName === "string" && this.config.joins?.some((join12) => join12.alias === tableName)) {
             throw new Error(`Alias "${tableName}" is already used in this query`);
           }
           if (!this.isPartialSelect) {
@@ -112237,7 +112480,7 @@ ${stack.split(`
       createJoin(joinType) {
         return (table3, on) => {
           const tableName = getTableLikeName(table3);
-          if (typeof tableName === "string" && this.config.joins.some((join11) => join11.alias === tableName)) {
+          if (typeof tableName === "string" && this.config.joins.some((join12) => join12.alias === tableName)) {
             throw new Error(`Alias "${tableName}" is already used in this query`);
           }
           if (typeof on === "function") {
@@ -114944,7 +115187,7 @@ ${stack.split(`
         return new SQL2([new StringChunk2(str2)]);
       }
       sql22.raw = raw;
-      function join11(chunks3, separator) {
+      function join12(chunks3, separator) {
         const result = [];
         for (const [i, chunk7] of chunks3.entries()) {
           if (i > 0 && separator !== undefined) {
@@ -114954,7 +115197,7 @@ ${stack.split(`
         }
         return new SQL2(result);
       }
-      sql22.join = join11;
+      sql22.join = join12;
       function identifier2(value10) {
         return new Name2(value10);
       }
@@ -119627,7 +119870,7 @@ ${stack.split(`
         return (table5, on) => {
           const baseTableName = this.tableName;
           const tableName = (0, import_utils13.getTableLikeName)(table5);
-          if (typeof tableName === "string" && this.config.joins?.some((join11) => join11.alias === tableName)) {
+          if (typeof tableName === "string" && this.config.joins?.some((join12) => join12.alias === tableName)) {
             throw new Error(`Alias "${tableName}" is already used in this query`);
           }
           if (!this.isPartialSelect) {
@@ -120272,7 +120515,7 @@ ${stack.split(`
       createJoin(joinType) {
         return (table5, on) => {
           const tableName = (0, import_utils13.getTableLikeName)(table5);
-          if (typeof tableName === "string" && this.config.joins.some((join11) => join11.alias === tableName)) {
+          if (typeof tableName === "string" && this.config.joins.some((join12) => join12.alias === tableName)) {
             throw new Error(`Alias "${tableName}" is already used in this query`);
           }
           if (typeof on === "function") {
@@ -120322,10 +120565,10 @@ ${stack.split(`
               const fromFields = this.getTableLikeFields(this.config.from);
               fields[tableName] = fromFields;
             }
-            for (const join11 of this.config.joins) {
-              const tableName2 = (0, import_utils13.getTableLikeName)(join11.table);
-              if (typeof tableName2 === "string" && !(0, import_entity47.is)(join11.table, import_sql18.SQL)) {
-                const fromFields = this.getTableLikeFields(join11.table);
+            for (const join12 of this.config.joins) {
+              const tableName2 = (0, import_utils13.getTableLikeName)(join12.table);
+              if (typeof tableName2 === "string" && !(0, import_entity47.is)(join12.table, import_sql18.SQL)) {
+                const fromFields = this.getTableLikeFields(join12.table);
                 fields[tableName2] = fromFields;
               }
             }
@@ -131076,19 +131319,19 @@ Error message: ${getErrorMessage3(cause3)}`,
       getUserDataDir: () => getUserDataDir
     });
     module.exports = __toCommonJS2(token_io_exports);
-    var import_path = __toESM22(__require2("path"));
+    var import_path2 = __toESM22(__require2("path"));
     var import_fs = __toESM22(__require2("fs"));
     var import_os = __toESM22(__require2("os"));
     var import_token_error = require_token_error();
     function findRootDir() {
       try {
         let dir3 = process.cwd();
-        while (dir3 !== import_path.default.dirname(dir3)) {
-          const pkgPath = import_path.default.join(dir3, ".vercel");
+        while (dir3 !== import_path2.default.dirname(dir3)) {
+          const pkgPath = import_path2.default.join(dir3, ".vercel");
           if (import_fs.default.existsSync(pkgPath)) {
             return dir3;
           }
-          dir3 = import_path.default.dirname(dir3);
+          dir3 = import_path2.default.dirname(dir3);
         }
       } catch (e) {
         throw new import_token_error.VercelOidcTokenError("Token refresh only supported in node server environments");
@@ -131101,9 +131344,9 @@ Error message: ${getErrorMessage3(cause3)}`,
       }
       switch (import_os.default.platform()) {
         case "darwin":
-          return import_path.default.join(import_os.default.homedir(), "Library/Application Support");
+          return import_path2.default.join(import_os.default.homedir(), "Library/Application Support");
         case "linux":
-          return import_path.default.join(import_os.default.homedir(), ".local/share");
+          return import_path2.default.join(import_os.default.homedir(), ".local/share");
         case "win32":
           if (process.env.LOCALAPPDATA) {
             return process.env.LOCALAPPDATA;
@@ -131148,7 +131391,7 @@ Error message: ${getErrorMessage3(cause3)}`,
       saveToken: () => saveToken
     });
     module.exports = __toCommonJS2(token_util_exports);
-    var path22 = __toESM22(__require2("path"));
+    var path42 = __toESM22(__require2("path"));
     var fs2 = __toESM22(__require2("fs"));
     var import_token_error = require_token_error();
     var import_token_io = require_token_io();
@@ -131158,14 +131401,14 @@ Error message: ${getErrorMessage3(cause3)}`,
       if (!dataDir) {
         return null;
       }
-      return path22.join(dataDir, vercelFolder);
+      return path42.join(dataDir, vercelFolder);
     }
     function getVercelCliToken() {
       const dataDir = getVercelDataDir();
       if (!dataDir) {
         return null;
       }
-      const tokenPath = path22.join(dataDir, "auth.json");
+      const tokenPath = path42.join(dataDir, "auth.json");
       if (!fs2.existsSync(tokenPath)) {
         return null;
       }
@@ -131208,7 +131451,7 @@ Error message: ${getErrorMessage3(cause3)}`,
         throw new import_token_error.VercelOidcTokenError("Unable to find root directory");
       }
       try {
-        const prjPath = path22.join(dir3, ".vercel", "project.json");
+        const prjPath = path42.join(dir3, ".vercel", "project.json");
         if (!fs2.existsSync(prjPath)) {
           throw new import_token_error.VercelOidcTokenError("project.json not found");
         }
@@ -131227,9 +131470,9 @@ Error message: ${getErrorMessage3(cause3)}`,
         if (!dir3) {
           throw new import_token_error.VercelOidcTokenError("Unable to find user data directory");
         }
-        const tokenPath = path22.join(dir3, "com.vercel.token", `${projectId}.json`);
+        const tokenPath = path42.join(dir3, "com.vercel.token", `${projectId}.json`);
         const tokenJson = JSON.stringify(token);
-        fs2.mkdirSync(path22.dirname(tokenPath), { mode: 504, recursive: true });
+        fs2.mkdirSync(path42.dirname(tokenPath), { mode: 504, recursive: true });
         fs2.writeFileSync(tokenPath, tokenJson);
         fs2.chmodSync(tokenPath, 432);
         return;
@@ -131243,7 +131486,7 @@ Error message: ${getErrorMessage3(cause3)}`,
         if (!dir3) {
           return null;
         }
-        const tokenPath = path22.join(dir3, "com.vercel.token", `${projectId}.json`);
+        const tokenPath = path42.join(dir3, "com.vercel.token", `${projectId}.json`);
         if (!fs2.existsSync(tokenPath)) {
           return null;
         }
@@ -134036,6 +134279,10 @@ Run 'npx vercel link' to link your project, then 'vc env pull' to fetch the toke
     init_ollama();
     init_pagination();
   });
+  __dirname2 = dirname(fileURLToPath(import.meta.url));
+  require2 = createRequire22(import.meta.url);
+  packageJson = require2(join(__dirname2, "..", "package.json"));
+  SWARM_MAIL_VERSION = packageJson.version;
   import_debug = __toESM2(require_src(), 1);
   log = {
     events: import_debug.default("swarm:events"),
@@ -134497,7 +134744,7 @@ Run 'npx vercel link' to link your project, then 'vc env pull' to fetch the toke
       this._directoryFilter = normalizeFilter(opts.directoryFilter);
       const statMethod = opts.lstat ? lstat : stat;
       if (wantBigintFsStats) {
-        this._stat = (path22) => statMethod(path22, { bigint: true });
+        this._stat = (path42) => statMethod(path42, { bigint: true });
       } else {
         this._stat = statMethod;
       }
@@ -134522,8 +134769,8 @@ Run 'npx vercel link' to link your project, then 'vc env pull' to fetch the toke
           const par2 = this.parent;
           const fil = par2 && par2.files;
           if (fil && fil.length > 0) {
-            const { path: path22, depth } = par2;
-            const slice2 = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path22));
+            const { path: path42, depth } = par2;
+            const slice2 = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path42));
             const awaited = await Promise.all(slice2);
             for (const entry of awaited) {
               if (!entry)
@@ -134563,20 +134810,20 @@ Run 'npx vercel link' to link your project, then 'vc env pull' to fetch the toke
         this.reading = false;
       }
     }
-    async _exploreDir(path22, depth) {
+    async _exploreDir(path42, depth) {
       let files;
       try {
-        files = await readdir(path22, this._rdOptions);
+        files = await readdir(path42, this._rdOptions);
       } catch (error51) {
         this._onError(error51);
       }
-      return { files, depth, path: path22 };
+      return { files, depth, path: path42 };
     }
-    async _formatEntry(dirent, path22) {
+    async _formatEntry(dirent, path42) {
       let entry;
       const basename22 = this._isDirent ? dirent.name : dirent;
       try {
-        const fullPath = presolve(pjoin(path22, basename22));
+        const fullPath = presolve(pjoin(path42, basename22));
         entry = { path: prelative(this._root, fullPath), fullPath, basename: basename22 };
         entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
       } catch (err) {
@@ -135025,20 +135272,20 @@ Run 'npx vercel link' to link your project, then 'vc env pull' to fetch the toke
       this._closePromise = undefined;
       let paths = unifyPaths(paths_);
       if (cwd) {
-        paths = paths.map((path22) => {
-          const absPath = getAbsolutePath(path22, cwd);
+        paths = paths.map((path42) => {
+          const absPath = getAbsolutePath(path42, cwd);
           return absPath;
         });
       }
-      paths.forEach((path22) => {
-        this._removeIgnoredPath(path22);
+      paths.forEach((path42) => {
+        this._removeIgnoredPath(path42);
       });
       this._userIgnored = undefined;
       if (!this._readyCount)
         this._readyCount = 0;
       this._readyCount += paths.length;
-      Promise.all(paths.map(async (path22) => {
-        const res = await this._nodeFsHandler._addToNodeFs(path22, !_internal, undefined, 0, _origAdd);
+      Promise.all(paths.map(async (path42) => {
+        const res = await this._nodeFsHandler._addToNodeFs(path42, !_internal, undefined, 0, _origAdd);
         if (res)
           this._emitReady();
         return res;
@@ -135057,17 +135304,17 @@ Run 'npx vercel link' to link your project, then 'vc env pull' to fetch the toke
         return this;
       const paths = unifyPaths(paths_);
       const { cwd } = this.options;
-      paths.forEach((path22) => {
-        if (!sp2.isAbsolute(path22) && !this._closers.has(path22)) {
+      paths.forEach((path42) => {
+        if (!sp2.isAbsolute(path42) && !this._closers.has(path42)) {
           if (cwd)
-            path22 = sp2.join(cwd, path22);
-          path22 = sp2.resolve(path22);
+            path42 = sp2.join(cwd, path42);
+          path42 = sp2.resolve(path42);
         }
-        this._closePath(path22);
-        this._addIgnoredPath(path22);
-        if (this._watched.has(path22)) {
+        this._closePath(path42);
+        this._addIgnoredPath(path42);
+        if (this._watched.has(path42)) {
           this._addIgnoredPath({
-            path: path22,
+            path: path42,
             recursive: true
           });
         }
@@ -135116,38 +135363,38 @@ Run 'npx vercel link' to link your project, then 'vc env pull' to fetch the toke
       if (event !== EVENTS.ERROR)
         this.emit(EVENTS.ALL, event, ...args2);
     }
-    async _emit(event, path22, stats) {
+    async _emit(event, path42, stats) {
       if (this.closed)
         return;
       const opts = this.options;
       if (isWindows)
-        path22 = sp2.normalize(path22);
+        path42 = sp2.normalize(path42);
       if (opts.cwd)
-        path22 = sp2.relative(opts.cwd, path22);
-      const args2 = [path22];
+        path42 = sp2.relative(opts.cwd, path42);
+      const args2 = [path42];
       if (stats != null)
         args2.push(stats);
       const awf = opts.awaitWriteFinish;
       let pw;
-      if (awf && (pw = this._pendingWrites.get(path22))) {
+      if (awf && (pw = this._pendingWrites.get(path42))) {
         pw.lastChange = new Date;
         return this;
       }
       if (opts.atomic) {
         if (event === EVENTS.UNLINK) {
-          this._pendingUnlinks.set(path22, [event, ...args2]);
+          this._pendingUnlinks.set(path42, [event, ...args2]);
           setTimeout(() => {
-            this._pendingUnlinks.forEach((entry, path3) => {
+            this._pendingUnlinks.forEach((entry, path5) => {
               this.emit(...entry);
               this.emit(EVENTS.ALL, ...entry);
-              this._pendingUnlinks.delete(path3);
+              this._pendingUnlinks.delete(path5);
             });
           }, typeof opts.atomic === "number" ? opts.atomic : 100);
           return this;
         }
-        if (event === EVENTS.ADD && this._pendingUnlinks.has(path22)) {
+        if (event === EVENTS.ADD && this._pendingUnlinks.has(path42)) {
           event = EVENTS.CHANGE;
-          this._pendingUnlinks.delete(path22);
+          this._pendingUnlinks.delete(path42);
         }
       }
       if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
@@ -135165,16 +135412,16 @@ Run 'npx vercel link' to link your project, then 'vc env pull' to fetch the toke
             this.emitWithAll(event, args2);
           }
         };
-        this._awaitWriteFinish(path22, awf.stabilityThreshold, event, awfEmit);
+        this._awaitWriteFinish(path42, awf.stabilityThreshold, event, awfEmit);
         return this;
       }
       if (event === EVENTS.CHANGE) {
-        const isThrottled = !this._throttle(EVENTS.CHANGE, path22, 50);
+        const isThrottled = !this._throttle(EVENTS.CHANGE, path42, 50);
         if (isThrottled)
           return this;
       }
       if (opts.alwaysStat && stats === undefined && (event === EVENTS.ADD || event === EVENTS.ADD_DIR || event === EVENTS.CHANGE)) {
-        const fullPath = opts.cwd ? sp2.join(opts.cwd, path22) : path22;
+        const fullPath = opts.cwd ? sp2.join(opts.cwd, path42) : path42;
         let stats2;
         try {
           stats2 = await stat3(fullPath);
@@ -135193,23 +135440,23 @@ Run 'npx vercel link' to link your project, then 'vc env pull' to fetch the toke
       }
       return error51 || this.closed;
     }
-    _throttle(actionType, path22, timeout6) {
+    _throttle(actionType, path42, timeout6) {
       if (!this._throttled.has(actionType)) {
         this._throttled.set(actionType, new Map);
       }
       const action = this._throttled.get(actionType);
       if (!action)
         throw new Error("invalid throttle");
-      const actionPath = action.get(path22);
+      const actionPath = action.get(path42);
       if (actionPath) {
         actionPath.count++;
         return false;
       }
       let timeoutObject;
       const clear8 = () => {
-        const item = action.get(path22);
+        const item = action.get(path42);
         const count10 = item ? item.count : 0;
-        action.delete(path22);
+        action.delete(path42);
         clearTimeout(timeoutObject);
         if (item)
           clearTimeout(item.timeoutObject);
@@ -135217,50 +135464,50 @@ Run 'npx vercel link' to link your project, then 'vc env pull' to fetch the toke
       };
       timeoutObject = setTimeout(clear8, timeout6);
       const thr = { timeoutObject, clear: clear8, count: 0 };
-      action.set(path22, thr);
+      action.set(path42, thr);
       return thr;
     }
     _incrReadyCount() {
       return this._readyCount++;
     }
-    _awaitWriteFinish(path22, threshold, event, awfEmit) {
+    _awaitWriteFinish(path42, threshold, event, awfEmit) {
       const awf = this.options.awaitWriteFinish;
       if (typeof awf !== "object")
         return;
       const pollInterval = awf.pollInterval;
       let timeoutHandler;
-      let fullPath = path22;
-      if (this.options.cwd && !sp2.isAbsolute(path22)) {
-        fullPath = sp2.join(this.options.cwd, path22);
+      let fullPath = path42;
+      if (this.options.cwd && !sp2.isAbsolute(path42)) {
+        fullPath = sp2.join(this.options.cwd, path42);
       }
       const now3 = new Date;
       const writes = this._pendingWrites;
       function awaitWriteFinishFn(prevStat) {
         statcb(fullPath, (err, curStat) => {
-          if (err || !writes.has(path22)) {
+          if (err || !writes.has(path42)) {
             if (err && err.code !== "ENOENT")
               awfEmit(err);
             return;
           }
           const now4 = Number(new Date);
           if (prevStat && curStat.size !== prevStat.size) {
-            writes.get(path22).lastChange = now4;
+            writes.get(path42).lastChange = now4;
           }
-          const pw = writes.get(path22);
+          const pw = writes.get(path42);
           const df = now4 - pw.lastChange;
           if (df >= threshold) {
-            writes.delete(path22);
+            writes.delete(path42);
             awfEmit(undefined, curStat);
           } else {
             timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
           }
         });
       }
-      if (!writes.has(path22)) {
-        writes.set(path22, {
+      if (!writes.has(path42)) {
+        writes.set(path42, {
           lastChange: now3,
           cancelWait: () => {
-            writes.delete(path22);
+            writes.delete(path42);
             clearTimeout(timeoutHandler);
             return event;
           }
@@ -135268,8 +135515,8 @@ Run 'npx vercel link' to link your project, then 'vc env pull' to fetch the toke
         timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval);
       }
     }
-    _isIgnored(path22, stats) {
-      if (this.options.atomic && DOT_RE.test(path22))
+    _isIgnored(path42, stats) {
+      if (this.options.atomic && DOT_RE.test(path42))
         return true;
       if (!this._userIgnored) {
         const { cwd } = this.options;
@@ -135279,13 +135526,13 @@ Run 'npx vercel link' to link your project, then 'vc env pull' to fetch the toke
         const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored2];
         this._userIgnored = anymatch(list, undefined);
       }
-      return this._userIgnored(path22, stats);
+      return this._userIgnored(path42, stats);
     }
-    _isntIgnored(path22, stat4) {
-      return !this._isIgnored(path22, stat4);
+    _isntIgnored(path42, stat4) {
+      return !this._isIgnored(path42, stat4);
     }
-    _getWatchHelpers(path22) {
-      return new WatchHelper(path22, this.options.followSymlinks, this);
+    _getWatchHelpers(path42) {
+      return new WatchHelper(path42, this.options.followSymlinks, this);
     }
     _getWatchedDir(directory) {
       const dir3 = sp2.resolve(directory);
@@ -135299,57 +135546,57 @@ Run 'npx vercel link' to link your project, then 'vc env pull' to fetch the toke
       return Boolean(Number(stats.mode) & 256);
     }
     _remove(directory, item, isDirectory) {
-      const path22 = sp2.join(directory, item);
-      const fullPath = sp2.resolve(path22);
-      isDirectory = isDirectory != null ? isDirectory : this._watched.has(path22) || this._watched.has(fullPath);
-      if (!this._throttle("remove", path22, 100))
+      const path42 = sp2.join(directory, item);
+      const fullPath = sp2.resolve(path42);
+      isDirectory = isDirectory != null ? isDirectory : this._watched.has(path42) || this._watched.has(fullPath);
+      if (!this._throttle("remove", path42, 100))
         return;
       if (!isDirectory && this._watched.size === 1) {
         this.add(directory, item, true);
       }
-      const wp = this._getWatchedDir(path22);
+      const wp = this._getWatchedDir(path42);
       const nestedDirectoryChildren = wp.getChildren();
-      nestedDirectoryChildren.forEach((nested7) => this._remove(path22, nested7));
+      nestedDirectoryChildren.forEach((nested7) => this._remove(path42, nested7));
       const parent = this._getWatchedDir(directory);
       const wasTracked = parent.has(item);
       parent.remove(item);
       if (this._symlinkPaths.has(fullPath)) {
         this._symlinkPaths.delete(fullPath);
       }
-      let relPath = path22;
+      let relPath = path42;
       if (this.options.cwd)
-        relPath = sp2.relative(this.options.cwd, path22);
+        relPath = sp2.relative(this.options.cwd, path42);
       if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
         const event = this._pendingWrites.get(relPath).cancelWait();
         if (event === EVENTS.ADD)
           return;
       }
-      this._watched.delete(path22);
+      this._watched.delete(path42);
       this._watched.delete(fullPath);
       const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
-      if (wasTracked && !this._isIgnored(path22))
-        this._emit(eventName, path22);
-      this._closePath(path22);
+      if (wasTracked && !this._isIgnored(path42))
+        this._emit(eventName, path42);
+      this._closePath(path42);
     }
-    _closePath(path22) {
-      this._closeFile(path22);
-      const dir3 = sp2.dirname(path22);
-      this._getWatchedDir(dir3).remove(sp2.basename(path22));
+    _closePath(path42) {
+      this._closeFile(path42);
+      const dir3 = sp2.dirname(path42);
+      this._getWatchedDir(dir3).remove(sp2.basename(path42));
     }
-    _closeFile(path22) {
-      const closers = this._closers.get(path22);
+    _closeFile(path42) {
+      const closers = this._closers.get(path42);
       if (!closers)
         return;
       closers.forEach((closer) => closer());
-      this._closers.delete(path22);
+      this._closers.delete(path42);
     }
-    _addPathCloser(path22, closer) {
+    _addPathCloser(path42, closer) {
       if (!closer)
         return;
-      let list = this._closers.get(path22);
+      let list = this._closers.get(path42);
       if (!list) {
         list = [];
-        this._closers.set(path22, list);
+        this._closers.set(path42, list);
       }
       list.push(closer);
     }
@@ -135397,9 +135644,9 @@ Run 'npx vercel link' to link your project, then 'vc env pull' to fetch the toke
           pollInterval: 50
         }
       });
-      this.watcher.on("add", (path22) => this.handleFileEvent(path22, "added"));
-      this.watcher.on("change", (path22) => this.handleFileEvent(path22, "changed"));
-      this.watcher.on("unlink", (path22) => this.handleFileEvent(path22, "unlinked"));
+      this.watcher.on("add", (path42) => this.handleFileEvent(path42, "added"));
+      this.watcher.on("change", (path42) => this.handleFileEvent(path42, "changed"));
+      this.watcher.on("unlink", (path42) => this.handleFileEvent(path42, "unlinked"));
       this.watcher.on("error", (error51) => {
         this.emit("error", error51);
       });
@@ -135421,20 +135668,20 @@ Run 'npx vercel link' to link your project, then 'vc env pull' to fetch the toke
       await this.watcher.close();
       this.watcher = null;
     }
-    handleFileEvent(path22, event) {
-      if (!path22.endsWith(".jsonl")) {
+    handleFileEvent(path42, event) {
+      if (!path42.endsWith(".jsonl")) {
         return;
       }
-      const existingTimer = this.debounceTimers.get(path22);
+      const existingTimer = this.debounceTimers.get(path42);
       if (existingTimer) {
         clearTimeout(existingTimer);
       }
       const timer4 = setTimeout(() => {
-        this.debounceTimers.delete(path22);
-        const fileEvent = { path: path22, event };
+        this.debounceTimers.delete(path42);
+        const fileEvent = { path: path42, event };
         this.emit(`file-${event}`, fileEvent);
       }, this.debounce);
-      this.debounceTimers.set(path22, timer4);
+      this.debounceTimers.set(path42, timer4);
     }
   };
   init_esm();
@@ -135547,7 +135794,7 @@ __export(exports_util3, {
   promiseAllObject: () => promiseAllObject3,
   primitiveTypes: () => primitiveTypes3,
   prefixIssues: () => prefixIssues3,
-  pick: () => pick7,
+  pick: () => pick9,
   partial: () => partial4,
   optionalKeys: () => optionalKeys3,
   omit: () => omit7,
@@ -135698,10 +135945,10 @@ function mergeDefs3(...defs) {
 function cloneDef3(schema) {
   return mergeDefs3(schema._zod.def);
 }
-function getElementAtPath3(obj, path3) {
-  if (!path3)
+function getElementAtPath3(obj, path6) {
+  if (!path6)
     return obj;
-  return path3.reduce((acc, key) => acc?.[key], obj);
+  return path6.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject3(promisesObj) {
   const keys15 = Object.keys(promisesObj);
@@ -135828,7 +136075,7 @@ function optionalKeys3(shape) {
     return shape[k]._zod.optin === "optional" && shape[k]._zod.optout === "optional";
   });
 }
-function pick7(schema, mask) {
+function pick9(schema, mask) {
   const currDef = schema._zod.def;
   const def = mergeDefs3(schema._zod.def, {
     get shape() {
@@ -135990,11 +136237,11 @@ function aborted3(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues3(path3, issues) {
+function prefixIssues3(path6, issues) {
   return issues.map((iss) => {
     var _a16;
     (_a16 = iss).path ?? (_a16.path = []);
-    iss.path.unshift(path3);
+    iss.path.unshift(path6);
     return iss;
   });
 }
@@ -136217,7 +136464,7 @@ function treeifyError3(error51, _mapper) {
     return issue4.message;
   };
   const result = { errors: [] };
-  const processError = (error53, path3 = []) => {
+  const processError = (error53, path6 = []) => {
     var _a16, _b16;
     for (const issue4 of error53.issues) {
       if (issue4.code === "invalid_union" && issue4.errors.length) {
@@ -136227,7 +136474,7 @@ function treeifyError3(error51, _mapper) {
       } else if (issue4.code === "invalid_element") {
         processError({ issues: issue4.issues }, issue4.path);
       } else {
-        const fullpath = [...path3, ...issue4.path];
+        const fullpath = [...path6, ...issue4.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue4));
           continue;
@@ -136259,8 +136506,8 @@ function treeifyError3(error51, _mapper) {
 }
 function toDotPath3(_path) {
   const segs = [];
-  const path3 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path3) {
+  const path6 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path6) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -148145,13 +148392,13 @@ __export(exports_eval_capture, {
 });
 import * as fs2 from "node:fs";
 import * as os from "node:os";
-import * as path3 from "node:path";
+import * as path8 from "node:path";
 function getEvalDataPath(projectPath) {
-  return path3.join(projectPath, DEFAULT_EVAL_DATA_PATH);
+  return path8.join(projectPath, DEFAULT_EVAL_DATA_PATH);
 }
 function ensureEvalDataDir(projectPath) {
   const evalPath = getEvalDataPath(projectPath);
-  const dir3 = path3.dirname(evalPath);
+  const dir3 = path8.dirname(evalPath);
   if (!fs2.existsSync(dir3)) {
     fs2.mkdirSync(dir3, { recursive: true });
   }
@@ -148325,10 +148572,10 @@ function getEvalDataStats(projectPath) {
   };
 }
 function getSessionDir() {
-  return process.env.SWARM_SESSIONS_DIR || path3.join(os.homedir(), ".config", "swarm-tools", "sessions");
+  return process.env.SWARM_SESSIONS_DIR || path8.join(os.homedir(), ".config", "swarm-tools", "sessions");
 }
 function getSessionPath(sessionId) {
-  return path3.join(getSessionDir(), `${sessionId}.jsonl`);
+  return path8.join(getSessionDir(), `${sessionId}.jsonl`);
 }
 function ensureSessionDir() {
   const sessionDir = getSessionDir();
@@ -153091,7 +153338,7 @@ WD9f
 
 // ../../node_modules/ioredis/built/utils/index.js
 var require_utils9 = __commonJS((exports) => {
-  var __dirname = "/home/runner/work/swarm-tools/swarm-tools/node_modules/ioredis/built/utils";
+  var __dirname = "/home/runner/work/swarm/swarm/node_modules/ioredis/built/utils";
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.noop = exports.defaults = exports.Debug = exports.getPackageMeta = exports.zipMap = exports.CONNECTION_CLOSED_ERROR_MSG = exports.shuffle = exports.sample = exports.resolveTLSProfile = exports.parseURL = exports.optimizeErrorStack = exports.toArg = exports.convertMapToArray = exports.convertObjectToArray = exports.timeout = exports.packObject = exports.isInt = exports.wrapMultiResult = exports.convertBufferToString = undefined;
   var fs_1 = __require("fs");
@@ -153321,7 +153568,7 @@ var require_utils9 = __commonJS((exports) => {
 
 // ../../node_modules/ioredis/built/Command.js
 var require_Command = __commonJS((exports) => {
-  var __dirname = "/home/runner/work/swarm-tools/swarm-tools/node_modules/ioredis/built";
+  var __dirname = "/home/runner/work/swarm/swarm/node_modules/ioredis/built";
   Object.defineProperty(exports, "__esModule", { value: true });
   var commands_1 = require_built();
   var calculateSlot = require_lib();
@@ -162360,15 +162607,15 @@ __export(exports_skills, {
 });
 import { readdir as readdir3, readFile as readFile2, stat as stat4, mkdir, writeFile as writeFile2, rm } from "fs/promises";
 import {
-  join as join23,
+  join as join25,
   basename as basename4,
-  dirname as dirname5,
+  dirname as dirname6,
   resolve as resolve4,
   relative as relative3,
-  isAbsolute as isAbsolute2,
+  isAbsolute as isAbsolute4,
   sep as sep2
 } from "path";
-import { fileURLToPath } from "url";
+import { fileURLToPath as fileURLToPath2 } from "url";
 function resolveGuidanceModel(model) {
   if (!model)
     return "unknown";
@@ -162473,19 +162720,19 @@ function validateSkillMetadata(raw, filePath) {
 }
 function getGlobalSkillsDir() {
   const home = process.env.HOME || process.env.USERPROFILE || "~";
-  return join23(home, ".config", "opencode", "skill");
+  return join25(home, ".config", "opencode", "skill");
 }
 function getClaudeGlobalSkillsDir() {
   const home = process.env.HOME || process.env.USERPROFILE || "~";
-  return join23(home, ".claude", "skills");
+  return join25(home, ".claude", "skills");
 }
 function getPackageSkillsDir() {
   try {
-    const currentFilePath = fileURLToPath(import.meta.url);
-    return join23(dirname5(currentFilePath), "..", "global-skills");
+    const currentFilePath = fileURLToPath2(import.meta.url);
+    return join25(dirname6(currentFilePath), "..", "global-skills");
   } catch {
     const currentDir = decodeURIComponent(new URL(".", import.meta.url).pathname);
-    return join23(currentDir, "..", "global-skills");
+    return join25(currentDir, "..", "global-skills");
   }
 }
 async function findSkillFiles(baseDir) {
@@ -162494,7 +162741,7 @@ async function findSkillFiles(baseDir) {
     const entries8 = await readdir3(baseDir, { withFileTypes: true });
     for (const entry of entries8) {
       if (entry.isDirectory()) {
-        const skillPath = join23(baseDir, entry.name, "SKILL.md");
+        const skillPath = join25(baseDir, entry.name, "SKILL.md");
         try {
           const s = await stat4(skillPath);
           if (s.isFile()) {
@@ -162508,7 +162755,7 @@ async function findSkillFiles(baseDir) {
 }
 async function findSkillScripts(skillDir) {
   const scripts = [];
-  const scriptsDir = join23(skillDir, "scripts");
+  const scriptsDir = join25(skillDir, "scripts");
   try {
     const entries8 = await readdir3(scriptsDir, { withFileTypes: true });
     for (const entry of entries8) {
@@ -162523,7 +162770,7 @@ async function loadSkill(skillPath) {
   const content = await readFile2(skillPath, "utf-8");
   const { metadata: rawMetadata, body } = parseFrontmatter(content);
   const metadata = validateSkillMetadata(rawMetadata, skillPath);
-  const directory = dirname5(skillPath);
+  const directory = dirname6(skillPath);
   const scripts = await findSkillScripts(directory);
   return {
     metadata,
@@ -162556,7 +162803,7 @@ async function discoverSkills(projectDir) {
     }
   }
   for (const relPath of PROJECT_SKILL_DIRECTORIES) {
-    await loadSkillsFromDir(join23(dir3, relPath));
+    await loadSkillsFromDir(join25(dir3, relPath));
   }
   await loadSkillsFromDir(getGlobalSkillsDir());
   await loadSkillsFromDir(getClaudeGlobalSkillsDir());
@@ -162957,7 +163204,7 @@ Scripts run in the skill's directory with the project directory as an argument.`
       if (!skill.scripts.includes(args2.script)) {
         return `Script '${args2.script}' not found in skill '${args2.skill}'. Available: ${skill.scripts.join(", ") || "none"}`;
       }
-      const scriptPath = join23(skill.directory, "scripts", args2.script);
+      const scriptPath = join25(skill.directory, "scripts", args2.script);
       const scriptArgs = args2.args || [];
       try {
         const TIMEOUT_MS = 60000;
@@ -163013,7 +163260,7 @@ Use this to access supplementary skill resources.`,
       if (!skill) {
         return `Skill '${args2.skill}' not found.`;
       }
-      if (isAbsolute2(args2.file)) {
+      if (isAbsolute4(args2.file)) {
         return "Invalid file path. Use a relative path.";
       }
       if (args2.file.includes("..")) {
@@ -163066,14 +163313,14 @@ Good skills have:
       const csoWarnings = validateCSOCompliance(args2.name, args2.description);
       let skillDir;
       if (args2.directory === "global") {
-        skillDir = join23(getGlobalSkillsDir(), args2.name);
+        skillDir = join25(getGlobalSkillsDir(), args2.name);
       } else if (args2.directory === "global-claude") {
-        skillDir = join23(getClaudeGlobalSkillsDir(), args2.name);
+        skillDir = join25(getClaudeGlobalSkillsDir(), args2.name);
       } else {
         const baseDir = args2.directory || DEFAULT_SKILLS_DIR;
-        skillDir = join23(skillsProjectDirectory, baseDir, args2.name);
+        skillDir = join25(skillsProjectDirectory, baseDir, args2.name);
       }
-      const skillPath = join23(skillDir, "SKILL.md");
+      const skillPath = join25(skillDir, "SKILL.md");
       try {
         await mkdir(skillDir, { recursive: true });
         const content = generateSkillContent(args2.name, args2.description, args2.body, { tags: args2.tags, tools: args2.tools });
@@ -163227,11 +163474,11 @@ executed with skills_execute. Use for:
       if (!skill) {
         return `Skill '${args2.skill}' not found.`;
       }
-      if (isAbsolute2(args2.script_name) || args2.script_name.includes("..") || args2.script_name.includes("/") || args2.script_name.includes("\\") || basename4(args2.script_name) !== args2.script_name) {
+      if (isAbsolute4(args2.script_name) || args2.script_name.includes("..") || args2.script_name.includes("/") || args2.script_name.includes("\\") || basename4(args2.script_name) !== args2.script_name) {
         return "Invalid script name. Use simple filenames without paths.";
       }
-      const scriptsDir = join23(skill.directory, "scripts");
-      const scriptPath = join23(scriptsDir, args2.script_name);
+      const scriptsDir = join25(skill.directory, "scripts");
+      const scriptPath = join25(scriptsDir, args2.script_name);
       try {
         await mkdir(scriptsDir, { recursive: true });
         await writeFile2(scriptPath, args2.content, {
@@ -163280,20 +163527,20 @@ Perfect for learning to create effective skills.`,
       }
       let skillDir;
       if (args2.directory === "global") {
-        skillDir = join23(getGlobalSkillsDir(), args2.name);
+        skillDir = join25(getGlobalSkillsDir(), args2.name);
       } else {
         const baseDir = args2.directory || DEFAULT_SKILLS_DIR;
-        skillDir = join23(skillsProjectDirectory, baseDir, args2.name);
+        skillDir = join25(skillsProjectDirectory, baseDir, args2.name);
       }
       const createdFiles = [];
       try {
         await mkdir(skillDir, { recursive: true });
-        const skillPath = join23(skillDir, "SKILL.md");
+        const skillPath = join25(skillDir, "SKILL.md");
         const skillContent = generateSkillTemplate(args2.name, args2.description);
         await writeFile2(skillPath, skillContent, "utf-8");
         createdFiles.push("SKILL.md");
         if (args2.include_example_script !== false) {
-          const scriptsDir = join23(skillDir, "scripts");
+          const scriptsDir = join25(skillDir, "scripts");
           await mkdir(scriptsDir, { recursive: true });
           const exampleScript = `#!/usr/bin/env bash
 # Example helper script for ${args2.name}
@@ -163307,15 +163554,15 @@ echo "Project directory: $1"
 
 # TODO: Add actual script logic
 `;
-          const scriptPath = join23(scriptsDir, "example.sh");
+          const scriptPath = join25(scriptsDir, "example.sh");
           await writeFile2(scriptPath, exampleScript, { mode: 493 });
           createdFiles.push("scripts/example.sh");
         }
         if (args2.include_reference !== false) {
-          const refsDir = join23(skillDir, "references");
+          const refsDir = join25(skillDir, "references");
           await mkdir(refsDir, { recursive: true });
           const refContent = generateReferenceTemplate(args2.name);
-          const refPath = join23(refsDir, "guide.md");
+          const refPath = join25(refsDir, "guide.md");
           await writeFile2(refPath, refContent, "utf-8");
           createdFiles.push("references/guide.md");
         }
@@ -165289,7 +165536,7 @@ var allocate3 = (n) => new Array(n), makeBy4, fromIterable34 = (collection) => A
     next6 = b2;
   }
   return out;
-}, getEquivalence11, dedupeWith2, dedupe3 = (self) => dedupeWith2(self, equivalence3()), join26;
+}, getEquivalence11, dedupeWith2, dedupe3 = (self) => dedupeWith2(self, equivalence3()), join27;
 var init_Array2 = __esm(() => {
   init_Either2();
   init_Equal2();
@@ -165440,7 +165687,7 @@ var init_Array2 = __esm(() => {
     }
     return [];
   });
-  join26 = /* @__PURE__ */ dual2(2, (self, sep5) => fromIterable34(self).join(sep5));
+  join27 = /* @__PURE__ */ dual2(2, (self, sep5) => fromIterable34(self).join(sep5));
 });
 
 // ../../node_modules/fast-check/lib/esm/fast-check-default.js
@@ -165478,17 +165725,17 @@ var getKeysForIndexSignature2 = (input, parameter) => {
     done17 = true;
     return a;
   };
-}, isNonEmpty11 = (x) => Array.isArray(x), isSingle2 = (x) => !Array.isArray(x), formatPathKey2 = (key) => `[${formatPropertyKey3(key)}]`, formatPath2 = (path4) => isNonEmpty11(path4) ? path4.map(formatPathKey2).join("") : formatPathKey2(path4);
+}, isNonEmpty11 = (x) => Array.isArray(x), isSingle2 = (x) => !Array.isArray(x), formatPathKey2 = (key) => `[${formatPropertyKey3(key)}]`, formatPath2 = (path6) => isNonEmpty11(path6) ? path6.map(formatPathKey2).join("") : formatPathKey2(path6);
 var init_util7 = __esm(() => {
   init_Inspectable2();
 });
 
 // ../../node_modules/effect/dist/esm/internal/schema/errors.js
-var getErrorMessage5 = (reason, details, path4, ast) => {
+var getErrorMessage5 = (reason, details, path6, ast) => {
   let out = reason;
-  if (path4 && isNonEmptyReadonlyArray2(path4)) {
+  if (path6 && isNonEmptyReadonlyArray2(path6)) {
     out += `
-at path: ${formatPath2(path4)}`;
+at path: ${formatPath2(path6)}`;
   }
   if (details !== undefined) {
     out += `
@@ -166501,7 +166748,7 @@ var TypeId48, BigDecimalProto2, isBigDecimal2 = (u) => hasProperty2(u, TypeId48)
   const o = make157(value10, scale2);
   o.normalized = o;
   return o;
-}, bigint06, bigint102, zero3, normalize3 = (self) => {
+}, bigint06, bigint102, zero3, normalize6 = (self) => {
   if (self.normalized === undefined) {
     if (self.value === bigint06) {
       self.normalized = zero3;
@@ -166525,7 +166772,7 @@ var TypeId48, BigDecimalProto2, isBigDecimal2 = (u) => hasProperty2(u, TypeId48)
   }
   return self.normalized;
 }, scale2, abs3 = (n) => n.value < bigint06 ? make157(-n.value, n.scale) : n, Equivalence11, equals8, format10 = (n) => {
-  const normalized = normalize3(n);
+  const normalized = normalize6(n);
   if (Math.abs(normalized.scale) >= 16) {
     return toExponential2(normalized);
   }
@@ -166553,7 +166800,7 @@ var TypeId48, BigDecimalProto2, isBigDecimal2 = (u) => hasProperty2(u, TypeId48)
   if (isZero3(n)) {
     return "0e+0";
   }
-  const normalized = normalize3(n);
+  const normalized = normalize6(n);
   const digits = `${abs3(normalized).value}`;
   const head14 = digits.slice(0, 1);
   const tail5 = digits.slice(1);
@@ -166576,7 +166823,7 @@ var init_BigDecimal2 = __esm(() => {
   BigDecimalProto2 = {
     [TypeId48]: TypeId48,
     [symbol19]() {
-      const normalized = normalize3(this);
+      const normalized = normalize6(this);
       return pipe4(hash7(normalized.value), combine20(number15(normalized.scale)), cached7(this));
     },
     [symbol21](that) {
@@ -171112,64 +171359,64 @@ var ConfigErrorSymbolKey2 = "effect/ConfigError", ConfigErrorTypeId3, proto18, A
     }
   });
   return error64;
-}, InvalidData3 = (path4, message, options2 = {
+}, InvalidData3 = (path6, message, options2 = {
   pathDelim: "."
 }) => {
   const error64 = Object.create(proto18);
   error64._op = OP_INVALID_DATA2;
-  error64.path = path4;
+  error64.path = path6;
   error64.message = message;
   Object.defineProperty(error64, "toString", {
     enumerable: false,
     value() {
-      const path6 = pipe4(this.path, join26(options2.pathDelim));
-      return `(Invalid data at ${path6}: "${this.message}")`;
+      const path10 = pipe4(this.path, join27(options2.pathDelim));
+      return `(Invalid data at ${path10}: "${this.message}")`;
     }
   });
   return error64;
-}, MissingData3 = (path4, message, options2 = {
+}, MissingData3 = (path6, message, options2 = {
   pathDelim: "."
 }) => {
   const error64 = Object.create(proto18);
   error64._op = OP_MISSING_DATA2;
-  error64.path = path4;
+  error64.path = path6;
   error64.message = message;
   Object.defineProperty(error64, "toString", {
     enumerable: false,
     value() {
-      const path6 = pipe4(this.path, join26(options2.pathDelim));
-      return `(Missing data at ${path6}: "${this.message}")`;
+      const path10 = pipe4(this.path, join27(options2.pathDelim));
+      return `(Missing data at ${path10}: "${this.message}")`;
     }
   });
   return error64;
-}, SourceUnavailable3 = (path4, message, cause3, options2 = {
+}, SourceUnavailable3 = (path6, message, cause3, options2 = {
   pathDelim: "."
 }) => {
   const error64 = Object.create(proto18);
   error64._op = OP_SOURCE_UNAVAILABLE2;
-  error64.path = path4;
+  error64.path = path6;
   error64.message = message;
   error64.cause = cause3;
   Object.defineProperty(error64, "toString", {
     enumerable: false,
     value() {
-      const path6 = pipe4(this.path, join26(options2.pathDelim));
-      return `(Source unavailable at ${path6}: "${this.message}")`;
+      const path10 = pipe4(this.path, join27(options2.pathDelim));
+      return `(Source unavailable at ${path10}: "${this.message}")`;
     }
   });
   return error64;
-}, Unsupported3 = (path4, message, options2 = {
+}, Unsupported3 = (path6, message, options2 = {
   pathDelim: "."
 }) => {
   const error64 = Object.create(proto18);
   error64._op = OP_UNSUPPORTED2;
-  error64.path = path4;
+  error64.path = path6;
   error64.message = message;
   Object.defineProperty(error64, "toString", {
     enumerable: false,
     value() {
-      const path6 = pipe4(this.path, join26(options2.pathDelim));
-      return `(Unsupported operation at ${path6}: "${this.message}")`;
+      const path10 = pipe4(this.path, join27(options2.pathDelim));
+      return `(Unsupported operation at ${path10}: "${this.message}")`;
     }
   });
   return error64;
@@ -171218,9 +171465,9 @@ var init_pathPatch2 = __esm(() => {
   empty81 = {
     _tag: "Empty"
   };
-  patch19 = /* @__PURE__ */ dual2(2, (path4, patch15) => {
+  patch19 = /* @__PURE__ */ dual2(2, (path6, patch15) => {
     let input = of12(patch15);
-    let output = path4;
+    let output = path6;
     while (isCons2(input)) {
       const patch20 = input.head;
       switch (patch20._tag) {
@@ -171271,7 +171518,7 @@ var concat5 = (l, r) => [...l, ...r], ConfigProviderSymbolKey2 = "effect/ConfigP
 }), makeFlat3 = (options2) => ({
   [FlatConfigProviderTypeId3]: FlatConfigProviderTypeId3,
   patch: options2.patch,
-  load: (path4, config4, split7 = true) => options2.load(path4, config4, split7),
+  load: (path6, config4, split7 = true) => options2.load(path6, config4, split7),
   enumerateChildren: options2.enumerateChildren
 }), fromFlat3 = (flat) => make175({
   load: (config4) => flatMap36(fromFlatLoop2(flat, empty63(), config4, false), (chunk7) => match47(head13(chunk7), {
@@ -171287,29 +171534,29 @@ var concat5 = (l, r) => [...l, ...r], ConfigProviderSymbolKey2 = "effect/ConfigP
     pathDelim: "_",
     seqDelim: ","
   }, options2);
-  const makePathString = (path4) => pipe4(path4, join26(pathDelim));
+  const makePathString = (path6) => pipe4(path6, join27(pathDelim));
   const unmakePathString = (pathString) => pathString.split(pathDelim);
   const getEnv = () => typeof process !== "undefined" && ("env" in process) && typeof process.env === "object" ? process.env : {};
-  const load = (path4, primitive3, split7 = true) => {
-    const pathString = makePathString(path4);
+  const load = (path6, primitive3, split7 = true) => {
+    const pathString = makePathString(path6);
     const current2 = getEnv();
     const valueOpt = pathString in current2 ? some25(current2[pathString]) : none17();
-    return pipe4(valueOpt, mapError16(() => MissingData3(path4, `Expected ${pathString} to exist in the process context`)), flatMap36((value10) => parsePrimitive2(value10, path4, primitive3, seqDelim, split7)));
+    return pipe4(valueOpt, mapError16(() => MissingData3(path6, `Expected ${pathString} to exist in the process context`)), flatMap36((value10) => parsePrimitive2(value10, path6, primitive3, seqDelim, split7)));
   };
-  const enumerateChildren = (path4) => sync23(() => {
+  const enumerateChildren = (path6) => sync23(() => {
     const current2 = getEnv();
     const keys16 = Object.keys(current2);
     const keyPaths = keys16.map((value10) => unmakePathString(value10.toUpperCase()));
     const filteredKeyPaths = keyPaths.filter((keyPath) => {
-      for (let i = 0;i < path4.length; i++) {
-        const pathComponent = pipe4(path4, unsafeGet14(i));
+      for (let i = 0;i < path6.length; i++) {
+        const pathComponent = pipe4(path6, unsafeGet14(i));
         const currentElement = keyPath[i];
         if (currentElement === undefined || pathComponent !== currentElement) {
           return false;
         }
       }
       return true;
-    }).flatMap((keyPath) => keyPath.slice(path4.length, path4.length + 1));
+    }).flatMap((keyPath) => keyPath.slice(path6.length, path6.length + 1));
     return fromIterable39(filteredKeyPaths);
   });
   return fromFlat3(makeFlat3({
@@ -171323,17 +171570,17 @@ var concat5 = (l, r) => [...l, ...r], ConfigProviderSymbolKey2 = "effect/ConfigP
   const leftExtension = concat5(left4, leftPad);
   const rightExtension = concat5(right4, rightPad);
   return [leftExtension, rightExtension];
-}, appendConfigPath2 = (path4, config4) => {
+}, appendConfigPath2 = (path6, config4) => {
   let op = config4;
   if (op._tag === "Nested") {
-    const out = path4.slice();
+    const out = path6.slice();
     while (op._tag === "Nested") {
       out.push(op.name);
       op = op.config;
     }
     return out;
   }
-  return path4;
+  return path6;
 }, fromFlatLoop2 = (flat, prefix, config4, split7) => {
   const op = config4;
   switch (op._tag) {
@@ -171408,8 +171655,8 @@ var concat5 = (l, r) => [...l, ...r], ConfigProviderSymbolKey2 = "effect/ConfigP
           return fail32(right4.left);
         }
         if (isRight7(left4) && isRight7(right4)) {
-          const path4 = pipe4(prefix, join26("."));
-          const fail31 = fromFlatLoopFail2(prefix, path4);
+          const path6 = pipe4(prefix, join27("."));
+          const fail31 = fromFlatLoopFail2(prefix, path6);
           const [lefts, rights] = extend8(fail31, fail31, pipe4(left4.right, map55(right5)), pipe4(right4.right, map55(right5)));
           return pipe4(lefts, zip27(rights), forEachSequential2(([left6, right6]) => pipe4(zip29(left6, right6), map61(([left7, right7]) => op.zip(left7, right7)))));
         }
@@ -171417,17 +171664,17 @@ var concat5 = (l, r) => [...l, ...r], ConfigProviderSymbolKey2 = "effect/ConfigP
       })))));
     }
   }
-}, fromFlatLoopFail2 = (prefix, path4) => (index2) => left5(MissingData3(prefix, `The element at index ${index2} in a sequence at path "${path4}" was missing`)), splitPathString2 = (text2, delim) => {
+}, fromFlatLoopFail2 = (prefix, path6) => (index2) => left5(MissingData3(prefix, `The element at index ${index2} in a sequence at path "${path6}" was missing`)), splitPathString2 = (text2, delim) => {
   const split7 = text2.split(new RegExp(`\\s*${escape5(delim)}\\s*`));
   return split7;
-}, parsePrimitive2 = (text2, path4, primitive3, delimiter, split7) => {
+}, parsePrimitive2 = (text2, path6, primitive3, delimiter, split7) => {
   if (!split7) {
     return pipe4(primitive3.parse(text2), mapBoth13({
-      onFailure: prefixed3(path4),
+      onFailure: prefixed3(path6),
       onSuccess: of9
     }));
   }
-  return pipe4(splitPathString2(text2, delimiter), forEachSequential2((char2) => primitive3.parse(char2.trim())), mapError16(prefixed3(path4)));
+  return pipe4(splitPathString2(text2, delimiter), forEachSequential2((char2) => primitive3.parse(char2.trim())), mapError16(prefixed3(path6)));
 }, transpose2 = (array11) => {
   return Object.keys(array11[0]).map((column) => array11.map((row) => row[column]));
 }, indicesFrom2 = (quotedIndices) => pipe4(forEachSequential2(quotedIndices, parseQuotedIndex2), mapBoth13({
@@ -173597,7 +173844,7 @@ var init_fiberScope2 = __esm(() => {
 });
 
 // ../../node_modules/effect/dist/esm/internal/fiber.js
-var FiberSymbolKey2 = "effect/Fiber", FiberTypeId3, fiberVariance5, fiberProto2, RuntimeFiberSymbolKey2 = "effect/Fiber", RuntimeFiberTypeId3, isRuntimeFiber3 = (self) => (RuntimeFiberTypeId3 in self), _await8 = (self) => self.await, inheritAll3 = (self) => self.inheritAll, interruptAllAs3, interruptAsFork3, join27 = (self) => zipLeft18(flatten26(self.await), self.inheritAll), _never4, currentFiberURI2 = "effect/FiberCurrent";
+var FiberSymbolKey2 = "effect/Fiber", FiberTypeId3, fiberVariance5, fiberProto2, RuntimeFiberSymbolKey2 = "effect/Fiber", RuntimeFiberTypeId3, isRuntimeFiber3 = (self) => (RuntimeFiberTypeId3 in self), _await8 = (self) => self.await, inheritAll3 = (self) => self.inheritAll, interruptAllAs3, interruptAsFork3, join28 = (self) => zipLeft18(flatten26(self.await), self.inheritAll), _never4, currentFiberURI2 = "effect/FiberCurrent";
 var init_fiber2 = __esm(() => {
   init_FiberId2();
   init_Function2();
@@ -173636,7 +173883,7 @@ var init_fiber2 = __esm(() => {
   _never4 = {
     ...CommitPrototype3,
     commit() {
-      return join27(this);
+      return join28(this);
     },
     ...fiberProto2,
     id: () => none19,
@@ -175311,7 +175558,7 @@ var fiberStarted3, fiberActive3, fiberSuccesses3, fiberFailures3, fiberLifetimes
       next6();
     }
   }));
-  return asVoid12(onExit4(flatten26(restore(join27(processingFiber))), exitMatch2({
+  return asVoid12(onExit4(flatten26(restore(join28(processingFiber))), exitMatch2({
     onFailure: (cause4) => {
       onInterruptSignal();
       const target2 = residual.length + 1;
@@ -175482,7 +175729,7 @@ var fiberStarted3, fiberActive3, fiberSuccesses3, fiberFailures3, fiberLifetimes
   const _fiberAll = {
     ...CommitPrototype5,
     commit() {
-      return join27(this);
+      return join28(this);
     },
     [FiberTypeId3]: fiberVariance5,
     id: () => fromIterable34(fibers2).reduce((id3, fiber) => combine23(id3, fiber.id()), none19),
@@ -175512,7 +175759,7 @@ var fiberStarted3, fiberActive3, fiberSuccesses3, fiberFailures3, fiberLifetimes
     interruptAsFork: (fiberId6) => forEachSequentialDiscard2(fibers2, (fiber) => fiber.interruptAsFork(fiberId6))
   };
   return _fiberAll;
-}, raceWith5, disconnect3 = (self) => uninterruptibleMask4((restore) => fiberIdWith3((fiberId6) => flatMap36(forkDaemon4(restore(self)), (fiber) => pipe4(restore(join27(fiber)), onInterrupt4(() => pipe4(fiber, interruptAsFork3(fiberId6))))))), race10, raceFibersWith2, completeRace2 = (winner, loser, cont, ab, cb) => {
+}, raceWith5, disconnect3 = (self) => uninterruptibleMask4((restore) => fiberIdWith3((fiberId6) => flatMap36(forkDaemon4(restore(self)), (fiber) => pipe4(restore(join28(fiber)), onInterrupt4(() => pipe4(fiber, interruptAsFork3(fiberId6))))))), race10, raceFibersWith2, completeRace2 = (winner, loser, cont, ab, cb) => {
   if (compareAndSet2(true, false)(ab)) {
     cb(cont(winner, loser));
   }
@@ -175748,7 +175995,7 @@ var init_fiberRuntime2 = __esm(() => {
       this.refreshRefCache();
     }
     commit() {
-      return join27(this);
+      return join28(this);
     }
     id() {
       return this._fiberId;
@@ -176662,11 +176909,11 @@ var init_fiberRuntime2 = __esm(() => {
   }));
   race10 = /* @__PURE__ */ dual2(2, (self, that) => fiberIdWith3((parentFiberId) => raceWith5(self, that, {
     onSelfDone: (exit5, right4) => exitMatchEffect2(exit5, {
-      onFailure: (cause4) => pipe4(join27(right4), mapErrorCause9((cause22) => parallel6(cause4, cause22))),
+      onFailure: (cause4) => pipe4(join28(right4), mapErrorCause9((cause22) => parallel6(cause4, cause22))),
       onSuccess: (value10) => pipe4(right4, interruptAsFiber2(parentFiberId), as18(value10))
     }),
     onOtherDone: (exit5, left4) => exitMatchEffect2(exit5, {
-      onFailure: (cause4) => pipe4(join27(left4), mapErrorCause9((cause22) => parallel6(cause22, cause4))),
+      onFailure: (cause4) => pipe4(join28(left4), mapErrorCause9((cause22) => parallel6(cause22, cause4))),
       onSuccess: (value10) => pipe4(left4, interruptAsFiber2(parentFiberId), as18(value10))
     })
   })));
@@ -177346,7 +177593,7 @@ var unsafeMakeSemaphore4 = (permits) => new Semaphore2(permits), makeSemaphore3
       return end8 - time6 <= 0 ? some25(computeCachedValue2(self, timeToLive, time6)) : none17();
     }
   }
-})), flatMap36((option12) => isNone7(option12) ? dieMessage11("BUG: Effect.cachedInvalidate - please report an issue at https://github.com/Effect-TS/effect/issues") : restore(deferredAwait2(option12.value[1]))))), invalidateCache2 = (cache) => set33(cache, none17()), ensuringChild3, ensuringChildren3, forkAll3, forkIn4, forkScoped4 = (self) => scopeWith3((scope7) => forkIn4(self, scope7)), fromFiber3 = (fiber) => join27(fiber), fromFiberEffect3 = (fiber) => suspend18(() => flatMap36(fiber, join27)), memoKeySymbol2, Key2, cachedFunction3 = (f, eq2) => {
+})), flatMap36((option12) => isNone7(option12) ? dieMessage11("BUG: Effect.cachedInvalidate - please report an issue at https://github.com/Effect-TS/effect/issues") : restore(deferredAwait2(option12.value[1]))))), invalidateCache2 = (cache) => set33(cache, none17()), ensuringChild3, ensuringChildren3, forkAll3, forkIn4, forkScoped4 = (self) => scopeWith3((scope7) => forkIn4(self, scope7)), fromFiber3 = (fiber) => join28(fiber), fromFiberEffect3 = (fiber) => suspend18(() => flatMap36(fiber, join28)), memoKeySymbol2, Key2, cachedFunction3 = (f, eq2) => {
   return pipe4(sync23(() => empty79()), flatMap36(makeSynchronized2), map61((ref) => (a) => pipe4(ref.modifyEffect((map51) => {
     const result = pipe4(map51, get57(new Key2(a, eq2)));
     if (isNone7(result)) {
@@ -179804,8 +180051,8 @@ class Pointer2 {
   actual;
   issue;
   _tag = "Pointer";
-  constructor(path4, actual, issue4) {
-    this.path = path4;
+  constructor(path6, actual, issue4) {
+    this.path = path6;
     this.actual = actual;
     this.issue = issue4;
   }
@@ -181700,14 +181947,14 @@ var init_memory2 = __esm(() => {
 
 // src/memory-tools.ts
 async function getMemoryAdapter(projectPath) {
-  const path4 = projectPath || process.cwd();
-  if (cachedAdapter && cachedProjectPath === path4) {
+  const path6 = projectPath || process.cwd();
+  if (cachedAdapter && cachedProjectPath === path6) {
     return cachedAdapter;
   }
-  const swarmMail = await getSwarmMailLibSQL(path4);
+  const swarmMail = await getSwarmMailLibSQL(path6);
   const dbAdapter = await swarmMail.getDatabase();
   cachedAdapter = await createMemoryAdapter2(dbAdapter);
-  cachedProjectPath = path4;
+  cachedProjectPath = path6;
   return cachedAdapter;
 }
 function resetMemoryCache() {
@@ -182527,17 +182774,17 @@ var require_visit = __commonJS((exports) => {
   visit.BREAK = BREAK;
   visit.SKIP = SKIP;
   visit.REMOVE = REMOVE;
-  function visit_(key, node, visitor, path4) {
-    const ctrl = callVisitor(key, node, visitor, path4);
+  function visit_(key, node, visitor, path6) {
+    const ctrl = callVisitor(key, node, visitor, path6);
     if (identity8.isNode(ctrl) || identity8.isPair(ctrl)) {
-      replaceNode(key, path4, ctrl);
-      return visit_(key, ctrl, visitor, path4);
+      replaceNode(key, path6, ctrl);
+      return visit_(key, ctrl, visitor, path6);
     }
     if (typeof ctrl !== "symbol") {
       if (identity8.isCollection(node)) {
-        path4 = Object.freeze(path4.concat(node));
+        path6 = Object.freeze(path6.concat(node));
         for (let i = 0;i < node.items.length; ++i) {
-          const ci = visit_(i, node.items[i], visitor, path4);
+          const ci = visit_(i, node.items[i], visitor, path6);
           if (typeof ci === "number")
             i = ci - 1;
           else if (ci === BREAK)
@@ -182548,13 +182795,13 @@ var require_visit = __commonJS((exports) => {
           }
         }
       } else if (identity8.isPair(node)) {
-        path4 = Object.freeze(path4.concat(node));
-        const ck = visit_("key", node.key, visitor, path4);
+        path6 = Object.freeze(path6.concat(node));
+        const ck = visit_("key", node.key, visitor, path6);
         if (ck === BREAK)
           return BREAK;
         else if (ck === REMOVE)
           node.key = null;
-        const cv = visit_("value", node.value, visitor, path4);
+        const cv = visit_("value", node.value, visitor, path6);
         if (cv === BREAK)
           return BREAK;
         else if (cv === REMOVE)
@@ -182575,17 +182822,17 @@ var require_visit = __commonJS((exports) => {
   visitAsync.BREAK = BREAK;
   visitAsync.SKIP = SKIP;
   visitAsync.REMOVE = REMOVE;
-  async function visitAsync_(key, node, visitor, path4) {
-    const ctrl = await callVisitor(key, node, visitor, path4);
+  async function visitAsync_(key, node, visitor, path6) {
+    const ctrl = await callVisitor(key, node, visitor, path6);
     if (identity8.isNode(ctrl) || identity8.isPair(ctrl)) {
-      replaceNode(key, path4, ctrl);
-      return visitAsync_(key, ctrl, visitor, path4);
+      replaceNode(key, path6, ctrl);
+      return visitAsync_(key, ctrl, visitor, path6);
     }
     if (typeof ctrl !== "symbol") {
       if (identity8.isCollection(node)) {
-        path4 = Object.freeze(path4.concat(node));
+        path6 = Object.freeze(path6.concat(node));
         for (let i = 0;i < node.items.length; ++i) {
-          const ci = await visitAsync_(i, node.items[i], visitor, path4);
+          const ci = await visitAsync_(i, node.items[i], visitor, path6);
           if (typeof ci === "number")
             i = ci - 1;
           else if (ci === BREAK)
@@ -182596,13 +182843,13 @@ var require_visit = __commonJS((exports) => {
           }
         }
       } else if (identity8.isPair(node)) {
-        path4 = Object.freeze(path4.concat(node));
-        const ck = await visitAsync_("key", node.key, visitor, path4);
+        path6 = Object.freeze(path6.concat(node));
+        const ck = await visitAsync_("key", node.key, visitor, path6);
         if (ck === BREAK)
           return BREAK;
         else if (ck === REMOVE)
           node.key = null;
-        const cv = await visitAsync_("value", node.value, visitor, path4);
+        const cv = await visitAsync_("value", node.value, visitor, path6);
         if (cv === BREAK)
           return BREAK;
         else if (cv === REMOVE)
@@ -182629,23 +182876,23 @@ var require_visit = __commonJS((exports) => {
     }
     return visitor;
   }
-  function callVisitor(key, node, visitor, path4) {
+  function callVisitor(key, node, visitor, path6) {
     if (typeof visitor === "function")
-      return visitor(key, node, path4);
+      return visitor(key, node, path6);
     if (identity8.isMap(node))
-      return visitor.Map?.(key, node, path4);
+      return visitor.Map?.(key, node, path6);
     if (identity8.isSeq(node))
-      return visitor.Seq?.(key, node, path4);
+      return visitor.Seq?.(key, node, path6);
     if (identity8.isPair(node))
-      return visitor.Pair?.(key, node, path4);
+      return visitor.Pair?.(key, node, path6);
     if (identity8.isScalar(node))
-      return visitor.Scalar?.(key, node, path4);
+      return visitor.Scalar?.(key, node, path6);
     if (identity8.isAlias(node))
-      return visitor.Alias?.(key, node, path4);
+      return visitor.Alias?.(key, node, path6);
     return;
   }
-  function replaceNode(key, path4, node) {
-    const parent = path4[path4.length - 1];
+  function replaceNode(key, path6, node) {
+    const parent = path6[path6.length - 1];
     if (identity8.isCollection(parent)) {
       parent.items[key] = node;
     } else if (identity8.isPair(parent)) {
@@ -183202,10 +183449,10 @@ var require_Collection = __commonJS((exports) => {
   var createNode = require_createNode();
   var identity8 = require_identity();
   var Node = require_Node();
-  function collectionFromPath(schema, path4, value10) {
+  function collectionFromPath(schema, path6, value10) {
     let v = value10;
-    for (let i = path4.length - 1;i >= 0; --i) {
-      const k = path4[i];
+    for (let i = path6.length - 1;i >= 0; --i) {
+      const k = path6[i];
       if (typeof k === "number" && Number.isInteger(k) && k >= 0) {
         const a = [];
         a[k] = v;
@@ -183224,7 +183471,7 @@ var require_Collection = __commonJS((exports) => {
       sourceObjects: new Map
     });
   }
-  var isEmptyPath = (path4) => path4 == null || typeof path4 === "object" && !!path4[Symbol.iterator]().next().done;
+  var isEmptyPath = (path6) => path6 == null || typeof path6 === "object" && !!path6[Symbol.iterator]().next().done;
 
   class Collection extends Node.NodeBase {
     constructor(type3, schema) {
@@ -183245,11 +183492,11 @@ var require_Collection = __commonJS((exports) => {
         copy5.range = this.range.slice();
       return copy5;
     }
-    addIn(path4, value10) {
-      if (isEmptyPath(path4))
+    addIn(path6, value10) {
+      if (isEmptyPath(path6))
         this.add(value10);
       else {
-        const [key, ...rest] = path4;
+        const [key, ...rest] = path6;
         const node = this.get(key, true);
         if (identity8.isCollection(node))
           node.addIn(rest, value10);
@@ -183259,8 +183506,8 @@ var require_Collection = __commonJS((exports) => {
           throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`);
       }
     }
-    deleteIn(path4) {
-      const [key, ...rest] = path4;
+    deleteIn(path6) {
+      const [key, ...rest] = path6;
       if (rest.length === 0)
         return this.delete(key);
       const node = this.get(key, true);
@@ -183269,8 +183516,8 @@ var require_Collection = __commonJS((exports) => {
       else
         throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`);
     }
-    getIn(path4, keepScalar) {
-      const [key, ...rest] = path4;
+    getIn(path6, keepScalar) {
+      const [key, ...rest] = path6;
       const node = this.get(key, true);
       if (rest.length === 0)
         return !keepScalar && identity8.isScalar(node) ? node.value : node;
@@ -183285,15 +183532,15 @@ var require_Collection = __commonJS((exports) => {
         return n == null || allowScalar && identity8.isScalar(n) && n.value == null && !n.commentBefore && !n.comment && !n.tag;
       });
     }
-    hasIn(path4) {
-      const [key, ...rest] = path4;
+    hasIn(path6) {
+      const [key, ...rest] = path6;
       if (rest.length === 0)
         return this.has(key);
       const node = this.get(key, true);
       return identity8.isCollection(node) ? node.hasIn(rest) : false;
     }
-    setIn(path4, value10) {
-      const [key, ...rest] = path4;
+    setIn(path6, value10) {
+      const [key, ...rest] = path6;
       if (rest.length === 0) {
         this.set(key, value10);
       } else {
@@ -185675,9 +185922,9 @@ var require_Document = __commonJS((exports) => {
       if (assertCollection(this.contents))
         this.contents.add(value10);
     }
-    addIn(path4, value10) {
+    addIn(path6, value10) {
       if (assertCollection(this.contents))
-        this.contents.addIn(path4, value10);
+        this.contents.addIn(path6, value10);
     }
     createAlias(node, name15) {
       if (!node.anchor) {
@@ -185726,30 +185973,30 @@ var require_Document = __commonJS((exports) => {
     delete(key) {
       return assertCollection(this.contents) ? this.contents.delete(key) : false;
     }
-    deleteIn(path4) {
-      if (Collection.isEmptyPath(path4)) {
+    deleteIn(path6) {
+      if (Collection.isEmptyPath(path6)) {
         if (this.contents == null)
           return false;
         this.contents = null;
         return true;
       }
-      return assertCollection(this.contents) ? this.contents.deleteIn(path4) : false;
+      return assertCollection(this.contents) ? this.contents.deleteIn(path6) : false;
     }
     get(key, keepScalar) {
       return identity8.isCollection(this.contents) ? this.contents.get(key, keepScalar) : undefined;
     }
-    getIn(path4, keepScalar) {
-      if (Collection.isEmptyPath(path4))
+    getIn(path6, keepScalar) {
+      if (Collection.isEmptyPath(path6))
         return !keepScalar && identity8.isScalar(this.contents) ? this.contents.value : this.contents;
-      return identity8.isCollection(this.contents) ? this.contents.getIn(path4, keepScalar) : undefined;
+      return identity8.isCollection(this.contents) ? this.contents.getIn(path6, keepScalar) : undefined;
     }
     has(key) {
       return identity8.isCollection(this.contents) ? this.contents.has(key) : false;
     }
-    hasIn(path4) {
-      if (Collection.isEmptyPath(path4))
+    hasIn(path6) {
+      if (Collection.isEmptyPath(path6))
         return this.contents !== undefined;
-      return identity8.isCollection(this.contents) ? this.contents.hasIn(path4) : false;
+      return identity8.isCollection(this.contents) ? this.contents.hasIn(path6) : false;
     }
     set(key, value10) {
       if (this.contents == null) {
@@ -185758,13 +186005,13 @@ var require_Document = __commonJS((exports) => {
         this.contents.set(key, value10);
       }
     }
-    setIn(path4, value10) {
-      if (Collection.isEmptyPath(path4)) {
+    setIn(path6, value10) {
+      if (Collection.isEmptyPath(path6)) {
         this.contents = value10;
       } else if (this.contents == null) {
-        this.contents = Collection.collectionFromPath(this.schema, Array.from(path4), value10);
+        this.contents = Collection.collectionFromPath(this.schema, Array.from(path6), value10);
       } else if (assertCollection(this.contents)) {
-        this.contents.setIn(path4, value10);
+        this.contents.setIn(path6, value10);
       }
     }
     setSchema(version4, options2 = {}) {
@@ -187653,9 +187900,9 @@ var require_cst_visit = __commonJS((exports) => {
   visit.BREAK = BREAK;
   visit.SKIP = SKIP;
   visit.REMOVE = REMOVE;
-  visit.itemAtPath = (cst, path4) => {
+  visit.itemAtPath = (cst, path6) => {
     let item = cst;
-    for (const [field, index2] of path4) {
+    for (const [field, index2] of path6) {
       const tok = item?.[field];
       if (tok && "items" in tok) {
         item = tok.items[index2];
@@ -187664,23 +187911,23 @@ var require_cst_visit = __commonJS((exports) => {
     }
     return item;
   };
-  visit.parentCollection = (cst, path4) => {
-    const parent = visit.itemAtPath(cst, path4.slice(0, -1));
-    const field = path4[path4.length - 1][0];
+  visit.parentCollection = (cst, path6) => {
+    const parent = visit.itemAtPath(cst, path6.slice(0, -1));
+    const field = path6[path6.length - 1][0];
     const coll = parent?.[field];
     if (coll && "items" in coll)
       return coll;
     throw new Error("Parent collection not found");
   };
-  function _visit(path4, item, visitor) {
-    let ctrl = visitor(item, path4);
+  function _visit(path6, item, visitor) {
+    let ctrl = visitor(item, path6);
     if (typeof ctrl === "symbol")
       return ctrl;
     for (const field of ["key", "value"]) {
       const token = item[field];
       if (token && "items" in token) {
         for (let i = 0;i < token.items.length; ++i) {
-          const ci = _visit(Object.freeze(path4.concat([[field, i]])), token.items[i], visitor);
+          const ci = _visit(Object.freeze(path6.concat([[field, i]])), token.items[i], visitor);
           if (typeof ci === "number")
             i = ci - 1;
           else if (ci === BREAK)
@@ -187691,10 +187938,10 @@ var require_cst_visit = __commonJS((exports) => {
           }
         }
         if (typeof ctrl === "function" && field === "key")
-          ctrl = ctrl(item, path4);
+          ctrl = ctrl(item, path6);
       }
     }
-    return typeof ctrl === "function" ? ctrl(item, path4) : ctrl;
+    return typeof ctrl === "function" ? ctrl(item, path6) : ctrl;
   }
   exports.visit = visit;
 });
@@ -189611,8 +189858,8 @@ var require_req = __commonJS((exports, module) => {
     if (req.originalUrl) {
       _req.url = req.originalUrl;
     } else {
-      const path4 = req.path;
-      _req.url = typeof path4 === "string" ? path4 : req.url ? req.url.path || req.url : undefined;
+      const path6 = req.path;
+      _req.url = typeof path6 === "string" ? path6 : req.url ? req.url.path || req.url : undefined;
     }
     if (req.query) {
       _req.query = req.query;
@@ -189768,14 +190015,14 @@ var require_redact = __commonJS((exports, module) => {
     }
     return obj;
   }
-  function parsePath(path4) {
+  function parsePath(path6) {
     const parts3 = [];
     let current2 = "";
     let inBrackets = false;
     let inQuotes = false;
     let quoteChar = "";
-    for (let i = 0;i < path4.length; i++) {
-      const char2 = path4[i];
+    for (let i = 0;i < path6.length; i++) {
+      const char2 = path6[i];
       if (!inBrackets && char2 === ".") {
         if (current2) {
           parts3.push(current2);
@@ -189906,10 +190153,10 @@ var require_redact = __commonJS((exports, module) => {
     return current2;
   }
   function redactPaths(obj, paths, censor, remove23 = false) {
-    for (const path4 of paths) {
-      const parts3 = parsePath(path4);
+    for (const path6 of paths) {
+      const parts3 = parsePath(path6);
       if (parts3.includes("*")) {
-        redactWildcardPath(obj, parts3, censor, path4, remove23);
+        redactWildcardPath(obj, parts3, censor, path6, remove23);
       } else {
         if (remove23) {
           removeKey(obj, parts3);
@@ -189996,8 +190243,8 @@ var require_redact = __commonJS((exports, module) => {
         }
       } else {
         if (afterWildcard.includes("*")) {
-          const wrappedCensor = typeof censor === "function" ? (value10, path4) => {
-            const fullPath = [...pathArray.slice(0, pathLength), ...path4];
+          const wrappedCensor = typeof censor === "function" ? (value10, path6) => {
+            const fullPath = [...pathArray.slice(0, pathLength), ...path6];
             return censor(value10, fullPath);
           } : censor;
           redactWildcardPath(current2, afterWildcard, wrappedCensor, originalPath, remove23);
@@ -190034,8 +190281,8 @@ var require_redact = __commonJS((exports, module) => {
       return null;
     }
     const pathStructure = new Map;
-    for (const path4 of pathsToClone) {
-      const parts3 = parsePath(path4);
+    for (const path6 of pathsToClone) {
+      const parts3 = parsePath(path6);
       let current2 = pathStructure;
       for (let i = 0;i < parts3.length; i++) {
         const part = parts3[i];
@@ -190087,24 +190334,24 @@ var require_redact = __commonJS((exports, module) => {
     }
     return cloneSelectively(obj, pathStructure);
   }
-  function validatePath(path4) {
-    if (typeof path4 !== "string") {
+  function validatePath(path6) {
+    if (typeof path6 !== "string") {
       throw new Error("Paths must be (non-empty) strings");
     }
-    if (path4 === "") {
+    if (path6 === "") {
       throw new Error("Invalid redaction path ()");
     }
-    if (path4.includes("..")) {
-      throw new Error(`Invalid redaction path (${path4})`);
+    if (path6.includes("..")) {
+      throw new Error(`Invalid redaction path (${path6})`);
     }
-    if (path4.includes(",")) {
-      throw new Error(`Invalid redaction path (${path4})`);
+    if (path6.includes(",")) {
+      throw new Error(`Invalid redaction path (${path6})`);
     }
     let bracketCount = 0;
     let inQuotes = false;
     let quoteChar = "";
-    for (let i = 0;i < path4.length; i++) {
-      const char2 = path4[i];
+    for (let i = 0;i < path6.length; i++) {
+      const char2 = path6[i];
       if ((char2 === '"' || char2 === "'") && bracketCount > 0) {
         if (!inQuotes) {
           inQuotes = true;
@@ -190118,20 +190365,20 @@ var require_redact = __commonJS((exports, module) => {
       } else if (char2 === "]" && !inQuotes) {
         bracketCount--;
         if (bracketCount < 0) {
-          throw new Error(`Invalid redaction path (${path4})`);
+          throw new Error(`Invalid redaction path (${path6})`);
         }
       }
     }
     if (bracketCount !== 0) {
-      throw new Error(`Invalid redaction path (${path4})`);
+      throw new Error(`Invalid redaction path (${path6})`);
     }
   }
   function validatePaths(paths) {
     if (!Array.isArray(paths)) {
       throw new TypeError("paths must be an array");
     }
-    for (const path4 of paths) {
-      validatePath(path4);
+    for (const path6 of paths) {
+      validatePath(path6);
     }
   }
   function slowRedact(options2 = {}) {
@@ -190293,8 +190540,8 @@ var require_redaction = __commonJS((exports, module) => {
       if (shape[k] === null) {
         o[k] = (value10) => topCensor(value10, [k]);
       } else {
-        const wrappedCensor = typeof censor === "function" ? (value10, path4) => {
-          return censor(value10, [k, ...path4]);
+        const wrappedCensor = typeof censor === "function" ? (value10, path6) => {
+          return censor(value10, [k, ...path6]);
         } : censor;
         o[k] = Redact({
           paths: shape[k],
@@ -190505,7 +190752,7 @@ var require_sonic_boom = __commonJS((exports, module) => {
   var fs3 = __require("fs");
   var EventEmitter4 = __require("events");
   var inherits = __require("util").inherits;
-  var path4 = __require("path");
+  var path6 = __require("path");
   var sleep8 = require_atomic_sleep();
   var assert6 = __require("assert");
   var BUSY_WRITE_TIMEOUT = 100;
@@ -190560,7 +190807,7 @@ var require_sonic_boom = __commonJS((exports, module) => {
     if (sonic.sync) {
       try {
         if (sonic.mkdir)
-          fs3.mkdirSync(path4.dirname(file4), { recursive: true });
+          fs3.mkdirSync(path6.dirname(file4), { recursive: true });
         const fd = fs3.openSync(file4, flags, mode);
         fileOpened(null, fd);
       } catch (err) {
@@ -190568,7 +190815,7 @@ var require_sonic_boom = __commonJS((exports, module) => {
         throw err;
       }
     } else if (sonic.mkdir) {
-      fs3.mkdir(path4.dirname(file4), { recursive: true }, (err) => {
+      fs3.mkdir(path6.dirname(file4), { recursive: true }, (err) => {
         if (err)
           return fileOpened(err);
         fs3.open(file4, flags, mode, fileOpened);
@@ -191294,11 +191541,11 @@ var require_indexes2 = __commonJS((exports, module) => {
 
 // ../../node_modules/thread-stream/index.js
 var require_thread_stream = __commonJS((exports, module) => {
-  var __dirname = "/home/runner/work/swarm-tools/swarm-tools/node_modules/thread-stream";
+  var __dirname = "/home/runner/work/swarm/swarm/node_modules/thread-stream";
   var { version: version4 } = require_package();
   var { EventEmitter: EventEmitter4 } = __require("events");
   var { Worker } = __require("worker_threads");
-  var { join: join18 } = __require("path");
+  var { join: join19 } = __require("path");
   var { pathToFileURL } = __require("url");
   var { wait } = require_wait();
   var {
@@ -191334,7 +191581,7 @@ var require_thread_stream = __commonJS((exports, module) => {
   function createWorker(stream2, opts) {
     const { filename, workerData } = opts;
     const bundlerOverrides = "__bundlerPathsOverrides" in globalThis ? globalThis.__bundlerPathsOverrides : {};
-    const toExecute = bundlerOverrides["thread-stream-worker"] || join18(__dirname, "lib", "worker.js");
+    const toExecute = bundlerOverrides["thread-stream-worker"] || join19(__dirname, "lib", "worker.js");
     const worker = new Worker(toExecute, {
       ...opts.workerOpts,
       trackUnmanagedFds: false,
@@ -191715,10 +191962,10 @@ var require_thread_stream = __commonJS((exports, module) => {
 
 // ../../node_modules/pino/lib/transport.js
 var require_transport = __commonJS((exports, module) => {
-  var __dirname = "/home/runner/work/swarm-tools/swarm-tools/node_modules/pino/lib";
+  var __dirname = "/home/runner/work/swarm/swarm/node_modules/pino/lib";
   var { createRequire: createRequire3 } = __require("module");
   var getCallers = require_caller();
-  var { join: join18, isAbsolute: isAbsolute3, sep: sep5 } = __require("node:path");
+  var { join: join19, isAbsolute: isAbsolute5, sep: sep5 } = __require("node:path");
   var sleep8 = require_atomic_sleep();
   var onExit5 = require_on_exit_leak_free();
   var ThreadStream = require_thread_stream();
@@ -191781,7 +192028,7 @@ var require_transport = __commonJS((exports, module) => {
       throw new Error("only one of target or targets can be specified");
     }
     if (targets) {
-      target = bundlerOverrides["pino-worker"] || join18(__dirname, "worker.js");
+      target = bundlerOverrides["pino-worker"] || join19(__dirname, "worker.js");
       options2.targets = targets.filter((dest) => dest.target).map((dest) => {
         return {
           ...dest,
@@ -191798,7 +192045,7 @@ var require_transport = __commonJS((exports, module) => {
         });
       });
     } else if (pipeline) {
-      target = bundlerOverrides["pino-worker"] || join18(__dirname, "worker.js");
+      target = bundlerOverrides["pino-worker"] || join19(__dirname, "worker.js");
       options2.pipelines = [pipeline.map((dest) => {
         return {
           ...dest,
@@ -191816,11 +192063,11 @@ var require_transport = __commonJS((exports, module) => {
     return buildStream(fixTarget(target), options2, worker, sync24);
     function fixTarget(origin) {
       origin = bundlerOverrides[origin] || origin;
-      if (isAbsolute3(origin) || origin.indexOf("file://") === 0) {
+      if (isAbsolute5(origin) || origin.indexOf("file://") === 0) {
         return origin;
       }
       if (origin === "pino/file") {
-        return join18(__dirname, "..", "file.js");
+        return join19(__dirname, "..", "file.js");
       }
       let fixTarget2;
       for (const filePath of callers) {
@@ -192758,7 +193005,7 @@ var require_safe_stable_stringify = __commonJS((exports, module) => {
             return circularValue;
           }
           let res = "";
-          let join18 = ",";
+          let join19 = ",";
           const originalIndentation = indentation;
           if (Array.isArray(value10)) {
             if (value10.length === 0) {
@@ -192772,7 +193019,7 @@ var require_safe_stable_stringify = __commonJS((exports, module) => {
               indentation += spacer;
               res += `
 ${indentation}`;
-              join18 = `,
+              join19 = `,
 ${indentation}`;
             }
             const maximumValuesToStringify = Math.min(value10.length, maximumBreadth);
@@ -192780,13 +193027,13 @@ ${indentation}`;
             for (;i < maximumValuesToStringify - 1; i++) {
               const tmp2 = stringifyFnReplacer(String(i), value10, stack, replacer, spacer, indentation);
               res += tmp2 !== undefined ? tmp2 : "null";
-              res += join18;
+              res += join19;
             }
             const tmp = stringifyFnReplacer(String(i), value10, stack, replacer, spacer, indentation);
             res += tmp !== undefined ? tmp : "null";
             if (value10.length - 1 > maximumBreadth) {
               const removedKeys = value10.length - maximumBreadth - 1;
-              res += `${join18}"... ${getItemCount(removedKeys)} not stringified"`;
+              res += `${join19}"... ${getItemCount(removedKeys)} not stringified"`;
             }
             if (spacer !== "") {
               res += `
@@ -192807,7 +193054,7 @@ ${originalIndentation}`;
           let separator = "";
           if (spacer !== "") {
             indentation += spacer;
-            join18 = `,
+            join19 = `,
 ${indentation}`;
             whitespace = " ";
           }
@@ -192821,13 +193068,13 @@ ${indentation}`;
             const tmp = stringifyFnReplacer(key2, value10, stack, replacer, spacer, indentation);
             if (tmp !== undefined) {
               res += `${separator}${strEscape(key2)}:${whitespace}${tmp}`;
-              separator = join18;
+              separator = join19;
             }
           }
           if (keyLength > maximumBreadth) {
             const removedKeys = keyLength - maximumBreadth;
             res += `${separator}"...":${whitespace}"${getItemCount(removedKeys)} not stringified"`;
-            separator = join18;
+            separator = join19;
           }
           if (spacer !== "" && separator.length > 1) {
             res = `
@@ -192867,7 +193114,7 @@ ${originalIndentation}`;
           }
           const originalIndentation = indentation;
           let res = "";
-          let join18 = ",";
+          let join19 = ",";
           if (Array.isArray(value10)) {
             if (value10.length === 0) {
               return "[]";
@@ -192880,7 +193127,7 @@ ${originalIndentation}`;
               indentation += spacer;
               res += `
 ${indentation}`;
-              join18 = `,
+              join19 = `,
 ${indentation}`;
             }
             const maximumValuesToStringify = Math.min(value10.length, maximumBreadth);
@@ -192888,13 +193135,13 @@ ${indentation}`;
             for (;i < maximumValuesToStringify - 1; i++) {
               const tmp2 = stringifyArrayReplacer(String(i), value10[i], stack, replacer, spacer, indentation);
               res += tmp2 !== undefined ? tmp2 : "null";
-              res += join18;
+              res += join19;
             }
             const tmp = stringifyArrayReplacer(String(i), value10[i], stack, replacer, spacer, indentation);
             res += tmp !== undefined ? tmp : "null";
             if (value10.length - 1 > maximumBreadth) {
               const removedKeys = value10.length - maximumBreadth - 1;
-              res += `${join18}"... ${getItemCount(removedKeys)} not stringified"`;
+              res += `${join19}"... ${getItemCount(removedKeys)} not stringified"`;
             }
             if (spacer !== "") {
               res += `
@@ -192907,7 +193154,7 @@ ${originalIndentation}`;
           let whitespace = "";
           if (spacer !== "") {
             indentation += spacer;
-            join18 = `,
+            join19 = `,
 ${indentation}`;
             whitespace = " ";
           }
@@ -192916,7 +193163,7 @@ ${indentation}`;
             const tmp = stringifyArrayReplacer(key2, value10[key2], stack, replacer, spacer, indentation);
             if (tmp !== undefined) {
               res += `${separator}${strEscape(key2)}:${whitespace}${tmp}`;
-              separator = join18;
+              separator = join19;
             }
           }
           if (spacer !== "" && separator.length > 1) {
@@ -193002,16 +193249,16 @@ ${originalIndentation}`;
             return '"[Object]"';
           }
           indentation += spacer;
-          const join18 = `,
+          const join19 = `,
 ${indentation}`;
           let res = "";
           let separator = "";
           let maximumPropertiesToStringify = Math.min(keyLength, maximumBreadth);
           if (isTypedArrayWithEntries(value10)) {
-            res += stringifyTypedArray(value10, join18, maximumBreadth);
+            res += stringifyTypedArray(value10, join19, maximumBreadth);
             keys16 = keys16.slice(value10.length);
             maximumPropertiesToStringify -= value10.length;
-            separator = join18;
+            separator = join19;
           }
           if (deterministic) {
             keys16 = sort4(keys16, comparator);
@@ -193022,13 +193269,13 @@ ${indentation}`;
             const tmp = stringifyIndent(key2, value10[key2], stack, spacer, indentation);
             if (tmp !== undefined) {
               res += `${separator}${strEscape(key2)}: ${tmp}`;
-              separator = join18;
+              separator = join19;
             }
           }
           if (keyLength > maximumBreadth) {
             const removedKeys = keyLength - maximumBreadth;
             res += `${separator}"...": "${getItemCount(removedKeys)} not stringified"`;
-            separator = join18;
+            separator = join19;
           }
           if (separator !== "") {
             res = `
@@ -193421,11 +193668,11 @@ var require_pino = __commonJS((exports, module) => {
     depthLimit: 5,
     edgeLimit: 100
   };
-  var normalize4 = createArgsNormalizer(defaultOptions3);
+  var normalize5 = createArgsNormalizer(defaultOptions3);
   var serializers = Object.assign(Object.create(null), stdSerializers);
   function pino(...args3) {
     const instance = {};
-    const { opts, stream: stream2 } = normalize4(instance, caller(), ...args3);
+    const { opts, stream: stream2 } = normalize5(instance, caller(), ...args3);
     if (opts.level && typeof opts.level === "string" && DEFAULT_LEVELS[opts.level.toLowerCase()] !== undefined)
       opts.level = opts.level.toLowerCase();
     const {
@@ -193550,37 +193797,406 @@ var require_pino = __commonJS((exports, module) => {
 init_dist();
 init_dist2();
 
-// src/utils/normalize-path.ts
-function normalizePath2(inputPath) {
-  if (!inputPath) {
-    return "";
+// ../cross-path/dist/normalize.js
+import path7 from "node:path";
+
+// ../cross-path/dist/detect.js
+var cachedEnvironment2 = null;
+function detectEnvironment2() {
+  if (cachedEnvironment2 !== null) {
+    return cachedEnvironment2;
   }
-  let normalized = convertBackslashes(inputPath);
-  normalized = sanitizeDriveLetter(normalized);
-  normalized = removeDoubleSlashes(normalized);
-  return normalized;
+  const platform = process.platform;
+  if (platform === "win32") {
+    cachedEnvironment2 = "windows";
+    return cachedEnvironment2;
+  }
+  if (platform === "darwin") {
+    cachedEnvironment2 = "darwin";
+    return cachedEnvironment2;
+  }
+  if (platform === "linux") {
+    if (process.env.WSL_DISTRO_NAME || process.env.WSLENV) {
+      cachedEnvironment2 = "wsl";
+      return cachedEnvironment2;
+    }
+    const msystem = process.env.MSYSTEM;
+    if (msystem && (msystem.includes("MINGW") || msystem.includes("MSYS"))) {
+      cachedEnvironment2 = "git-bash";
+      return cachedEnvironment2;
+    }
+    if (process.env.CYGWIN) {
+      cachedEnvironment2 = "cygwin";
+      return cachedEnvironment2;
+    }
+    cachedEnvironment2 = "linux";
+    return cachedEnvironment2;
+  }
+  cachedEnvironment2 = "linux";
+  return cachedEnvironment2;
+}
+
+// ../cross-path/dist/validate.js
+import path5 from "node:path";
+function isAbsolute3(inputPath) {
+  return path5.win32.isAbsolute(inputPath) || path5.posix.isAbsolute(inputPath);
+}
+function isUNC2(inputPath) {
+  const normalized = inputPath.replace(/\\/g, "/");
+  if (normalized.length < 3) {
+    return false;
+  }
+  if (!normalized.startsWith("//")) {
+    return false;
+  }
+  if (normalized[2] === "/") {
+    return false;
+  }
+  const afterPrefix = normalized.substring(2);
+  const hasValidServerPart = /^[^\s\/]+/.test(afterPrefix);
+  return hasValidServerPart;
+}
+function isWSLMount2(inputPath) {
+  const wslMountPattern = /^\/mnt\/[a-z](\/|$)/i;
+  return wslMountPattern.test(inputPath);
 }
-function convertBackslashes(path3) {
-  return path3.replace(/\\/g, "/");
+function isGitBashMount2(inputPath) {
+  const gitBashPattern = /^\/[a-z]\//i;
+  return gitBashPattern.test(inputPath);
 }
-function sanitizeDriveLetter(path3) {
-  return path3.replace(/^([A-Za-z]:)(?=[^/]|$)/, "$1/");
+function hasDriveLetter2(inputPath) {
+  const driveLetterPattern = /^[A-Za-z]:/;
+  return driveLetterPattern.test(inputPath);
+}
+function parseWSLUNC2(inputPath) {
+  const normalized = inputPath.replace(/\\/g, "/");
+  const wslUNCPattern = /^\/\/(wsl\.localhost|wsl\$)\/([^/]+)(\/.*)?$/i;
+  const match44 = normalized.match(wslUNCPattern);
+  if (!match44) {
+    return null;
+  }
+  const distro = match44[2];
+  const restPath = match44[3] || "/";
+  return { distro, path: restPath };
 }
-function removeDoubleSlashes(path3) {
-  const isUncPath = path3.startsWith("//") && path3[2] !== "/";
-  if (isUncPath) {
-    return "//" + path3.slice(2).replace(/\/+/g, "/");
+function isDriveRelative2(inputPath) {
+  if (inputPath.length < 3) {
+    return false;
+  }
+  const hasLetter = /^[A-Za-z]$/.test(inputPath[0]);
+  const hasColon = inputPath[1] === ":";
+  const notSlash = inputPath[2] !== "/" && inputPath[2] !== "\\";
+  return hasLetter && hasColon && notSlash;
+}
+
+// ../cross-path/dist/normalize.js
+function normalize4(inputPath, options2) {
+  if (inputPath === null || inputPath === undefined) {
+    throw new TypeError("Path cannot be null or undefined");
+  }
+  if (typeof inputPath !== "string") {
+    throw new TypeError(`Path must be a string, received ${typeof inputPath}`);
+  }
+  if (inputPath.length === 0) {
+    throw new TypeError("Path cannot be empty");
+  }
+  if (inputPath.includes("\x00")) {
+    throw new TypeError("Path cannot contain null bytes");
+  }
+  const env = options2?.env ?? detectEnvironment2();
+  const wslUNCInfo = parseWSLUNC2(inputPath);
+  if (wslUNCInfo) {
+    const currentDistro = process.env.WSL_DISTRO_NAME;
+    if (env === "wsl" && currentDistro && wslUNCInfo.distro.toLowerCase() === currentDistro.toLowerCase()) {
+      return path7.posix.normalize(wslUNCInfo.path);
+    }
+  }
+  let intermediate = inputPath.replace(/\\/g, "/");
+  const originalIsUNC = isUNC2(intermediate);
+  if (isWSLMount2(intermediate)) {
+    const driveLetter = intermediate.charAt(5).toLowerCase();
+    intermediate = `${driveLetter}:${intermediate.substring(6)}`;
+    if (intermediate.length === 2) {
+      intermediate = `${driveLetter}:/`;
+    }
+  } else if (isGitBashMount2(intermediate)) {
+    const driveLetter = intermediate.charAt(1).toLowerCase();
+    intermediate = `${driveLetter}:${intermediate.substring(2)}`;
+  }
+  const hasWindowsDrive = hasDriveLetter2(intermediate);
+  const isAbsolutePath = isAbsolute3(intermediate);
+  const driveRelative = isDriveRelative2(intermediate);
+  if (!isAbsolutePath && !hasWindowsDrive) {
+    const basePath = options2?.basePath ?? process.cwd();
+    const normalizedBase = basePath.replace(/\\/g, "/");
+    if (hasDriveLetter2(normalizedBase)) {
+      const drive = normalizedBase.substring(0, 2);
+      const baseRest = normalizedBase.substring(2) || "/";
+      const resolved = path7.posix.resolve(baseRest, intermediate);
+      intermediate = drive + resolved;
+    } else {
+      intermediate = path7.posix.resolve(normalizedBase, intermediate);
+    }
+  } else if (driveRelative) {
+    const pathDrive = intermediate.substring(0, 2).toLowerCase();
+    const pathRest = intermediate.substring(2);
+    const basePath = options2?.basePath ?? process.cwd();
+    const normalizedBase = basePath.replace(/\\/g, "/");
+    if (hasDriveLetter2(normalizedBase)) {
+      const baseDrive = normalizedBase.substring(0, 2).toLowerCase();
+      if (baseDrive === pathDrive) {
+        const baseRest = normalizedBase.substring(2) || "/";
+        const resolved = path7.posix.resolve(baseRest, pathRest);
+        intermediate = pathDrive + resolved;
+      } else {
+        intermediate = pathDrive + "/" + pathRest;
+      }
+    } else {
+      intermediate = pathDrive + "/" + pathRest;
+    }
+  }
+  if (originalIsUNC || isUNC2(intermediate)) {
+    const withoutPrefix = intermediate.substring(2);
+    const normalizedRest = path7.posix.normalize(withoutPrefix);
+    intermediate = "//" + normalizedRest;
+  } else if (hasWindowsDrive || hasDriveLetter2(intermediate)) {
+    const drive = intermediate.substring(0, 2);
+    let rest = intermediate.substring(2);
+    if (!rest.startsWith("/")) {
+      rest = "/" + rest;
+    }
+    const normalizedRest = path7.posix.normalize(rest);
+    intermediate = drive + normalizedRest;
   } else {
-    return path3.replace(/\/+/g, "/");
+    intermediate = path7.posix.normalize(intermediate);
+  }
+  const finalHasDrive = hasDriveLetter2(intermediate);
+  const finalIsUNC = isUNC2(intermediate);
+  if (finalHasDrive || finalIsUNC) {
+    intermediate = intermediate.toLowerCase();
+    const segments = intermediate.split("/");
+    const normalizedSegments = segments.map((segment, index2) => {
+      if (index2 === 0 || segment === "") {
+        return segment;
+      }
+      return segment.replace(/[\s.]+$/, "");
+    });
+    intermediate = normalizedSegments.join("/");
+  }
+  if (intermediate.length > 1 && intermediate.endsWith("/")) {
+    const isWindowsRoot = finalHasDrive && intermediate.length === 3;
+    const isPosixRoot = intermediate === "/";
+    const isUNCRoot = finalIsUNC && intermediate.split("/").filter(Boolean).length <= 2;
+    if (!isWindowsRoot && !isPosixRoot && !isUNCRoot) {
+      intermediate = intermediate.slice(0, -1);
+    }
+  }
+  if (finalHasDrive && intermediate.length === 2) {
+    intermediate = intermediate + "/";
+  }
+  return intermediate;
+}
+function normalizePaths(paths, options2) {
+  return paths.map((p) => normalize4(p, options2));
+}
+// src/utils/arg-normalizer.ts
+function toPlainObject(value10) {
+  if (typeof value10 === "string") {
+    try {
+      const parsed = JSON.parse(value10);
+      if (parsed && typeof parsed === "object")
+        return parsed;
+    } catch {
+      return { title: value10 };
+    }
   }
+  if (value10 && typeof value10 === "object")
+    return value10;
+  return {};
 }
-function normalizePaths(paths) {
-  return paths.map(normalizePath2);
+function coerceBoolean(v) {
+  if (typeof v === "boolean")
+    return v;
+  if (typeof v === "string") {
+    const s = v.trim().toLowerCase();
+    if (["true", "t", "1", "yes", "y"].includes(s))
+      return true;
+    if (["false", "f", "0", "no", "n"].includes(s))
+      return false;
+  }
+  if (typeof v === "number")
+    return v !== 0;
+  return;
+}
+function coerceNumber(v) {
+  if (typeof v === "number" && Number.isFinite(v))
+    return v;
+  if (typeof v === "string") {
+    const n = Number(v);
+    if (!Number.isNaN(n))
+      return n;
+  }
+  return;
+}
+function normalizeStatus(v) {
+  if (typeof v !== "string")
+    return;
+  const s = v.trim().toLowerCase().replace(/\s+/g, "_").replace(/-+/g, "_");
+  const allowed = new Set(["open", "in_progress", "blocked", "closed"]);
+  if (allowed.has(s))
+    return s;
+  return;
+}
+function normalizeType(v) {
+  if (typeof v !== "string")
+    return;
+  const s = v.trim().toLowerCase();
+  const allowed = new Set(["bug", "feature", "task", "epic", "chore"]);
+  if (allowed.has(s))
+    return s;
+  return;
+}
+function pick7(obj, keys15) {
+  const out = {};
+  for (const k of keys15)
+    if (k in obj)
+      out[k] = obj[k];
+  return out;
+}
+function aliasCommonKeys(obj) {
+  const out = { ...obj };
+  const move = (from, to) => {
+    if (out[from] !== undefined && out[to] === undefined) {
+      out[to] = out[from];
+      delete out[from];
+    }
+  };
+  move("cell_id", "id");
+  move("bead_id", "id");
+  move("beadId", "id");
+  move("parentId", "parent_id");
+  move("issue_type", "type");
+  move("issueType", "type");
+  move("kind", "type");
+  move("epicTitle", "epic_title");
+  move("epicDescription", "epic_description");
+  move("subTasks", "subtasks");
+  move("tasks", "subtasks");
+  move("items", "subtasks");
+  move("idSuffix", "id_suffix");
+  return out;
+}
+function normalizeCreateArgs(raw) {
+  const obj = aliasCommonKeys(toPlainObject(raw));
+  if (typeof raw === "string" && !obj.title)
+    obj.title = String(raw);
+  if (obj.priority !== undefined)
+    obj.priority = coerceNumber(obj.priority);
+  if (obj.type !== undefined)
+    obj.type = normalizeType(obj.type) ?? obj.type;
+  if (obj.parent_id !== undefined)
+    obj.parent_id = String(obj.parent_id);
+  return pick7(obj, ["title", "type", "priority", "description", "parent_id"]);
+}
+function normalizeUpdateArgs(raw) {
+  const obj = aliasCommonKeys(toPlainObject(raw));
+  if (obj.status !== undefined)
+    obj.status = normalizeStatus(obj.status) ?? obj.status;
+  if (obj.priority !== undefined)
+    obj.priority = coerceNumber(obj.priority);
+  if (obj.description !== undefined && obj.description != null)
+    obj.description = String(obj.description);
+  if (obj.id !== undefined)
+    obj.id = String(obj.id);
+  return pick7(obj, ["id", "status", "description", "priority"]);
+}
+function normalizeCloseArgs(raw) {
+  const obj = aliasCommonKeys(toPlainObject(raw));
+  if (obj.id !== undefined)
+    obj.id = String(obj.id);
+  if (obj.reason !== undefined)
+    obj.reason = String(obj.reason);
+  return pick7(obj, ["id", "reason"]);
+}
+function normalizeQueryArgs(raw) {
+  const obj = aliasCommonKeys(toPlainObject(raw));
+  if (obj.status !== undefined)
+    obj.status = normalizeStatus(obj.status) ?? obj.status;
+  if (obj.type !== undefined)
+    obj.type = normalizeType(obj.type) ?? obj.type;
+  if (obj.ready !== undefined)
+    obj.ready = coerceBoolean(obj.ready);
+  if (obj.parent_id !== undefined)
+    obj.parent_id = String(obj.parent_id);
+  if (obj.limit !== undefined)
+    obj.limit = coerceNumber(obj.limit);
+  return pick7(obj, ["status", "type", "ready", "parent_id", "limit"]);
+}
+function normalizeCellsArgs(raw) {
+  const obj = aliasCommonKeys(toPlainObject(raw));
+  if (obj.id !== undefined)
+    obj.id = String(obj.id);
+  if (obj.status !== undefined)
+    obj.status = normalizeStatus(obj.status) ?? obj.status;
+  if (obj.type !== undefined)
+    obj.type = normalizeType(obj.type) ?? obj.type;
+  if (obj.parent_id !== undefined)
+    obj.parent_id = String(obj.parent_id);
+  if (obj.ready !== undefined)
+    obj.ready = coerceBoolean(obj.ready);
+  if (obj.limit !== undefined)
+    obj.limit = coerceNumber(obj.limit);
+  return pick7(obj, ["id", "status", "type", "parent_id", "ready", "limit"]);
+}
+function normalizeEpicCreateArgs(raw) {
+  const obj0 = aliasCommonKeys(toPlainObject(raw));
+  const obj = { ...obj0 };
+  if (obj.subtasks !== undefined && !Array.isArray(obj.subtasks)) {
+    if (typeof obj.subtasks === "string")
+      obj.subtasks = obj.subtasks.split(/[,\n]/).map((s) => ({ title: s.trim() })).filter((x) => x.title);
+    else if (obj.subtasks && typeof obj.subtasks === "object")
+      obj.subtasks = [obj.subtasks];
+  }
+  if (Array.isArray(obj.subtasks)) {
+    obj.subtasks = obj.subtasks.map((st) => {
+      if (typeof st === "string")
+        return { title: st };
+      const s = aliasCommonKeys(toPlainObject(st));
+      if (s.priority !== undefined)
+        s.priority = coerceNumber(s.priority);
+      if (s.files && !Array.isArray(s.files))
+        s.files = [String(s.files)];
+      if (Array.isArray(s.files))
+        s.files = s.files.map((p) => String(p));
+      return pick7(s, ["title", "priority", "files", "id_suffix"]);
+    });
+  }
+  if (obj.epic_title === undefined && typeof raw === "string")
+    obj.epic_title = String(raw);
+  if (obj.epic_description !== undefined)
+    obj.epic_description = String(obj.epic_description);
+  return pick7(obj, ["epic_title", "epic_description", "epic_id", "subtasks", "strategy", "task", "project_key", "recovery_context"]);
+}
+function formatZodError(toolName, err, example) {
+  const issues = err.issues.map((i) => `- ${i.path.join(".") || "<root>"}: ${i.message}`).join(`
+`);
+  const guidance = `How to fix:
+1) Check field names (snake_case expected).
+2) Coercions allowed: booleans as 'true/false', numbers as strings, status 'in-progress' -> 'in_progress'.
+3) Remove unknown fields or typos.`;
+  const sample2 = example ? `
+
+Example:
+${example}` : "";
+  return `${toolName}: Invalid arguments.
+${issues}
+
+${guidance}${sample2}`;
 }
 
 // src/hive.ts
 import { existsSync as existsSync12, readFileSync as readFileSync7 } from "node:fs";
-import { join as join17 } from "node:path";
+import { join as join18 } from "node:path";
 
 // src/schemas/cell.ts
 init_zod3();
@@ -194263,6 +194879,25 @@ async function runGitCommand(args2) {
   const exitCode = await proc.exited;
   return { exitCode, stdout, stderr };
 }
+async function withRetry2(operation, retries2 = 3, delayMs = 100) {
+  let lastError;
+  for (let attempt3 = 0;attempt3 <= retries2; attempt3++) {
+    try {
+      return await operation();
+    } catch (err) {
+      lastError = err;
+      const message = err instanceof Error ? err.message : String(err);
+      if (attempt3 < retries2 && (message.includes("SQLITE_BUSY") || message.includes("SQLITE_BUSY_RECOVERY") || message.includes("database is locked"))) {
+        await new Promise((r) => setTimeout(r, delayMs * (attempt3 + 1)));
+        continue;
+      }
+      break;
+    }
+  }
+  if (lastError instanceof Error)
+    throw lastError;
+  throw new Error(String(lastError));
+}
 
 class HiveError extends Error {
   command;
@@ -194288,8 +194923,8 @@ class HiveValidationError extends Error {
 }
 var BeadValidationError = HiveValidationError;
 function checkBeadsMigrationNeeded(projectPath) {
-  const beadsDir = normalizePath2(join17(projectPath, ".beads"));
-  const hiveDir = normalizePath2(join17(projectPath, ".hive"));
+  const beadsDir = normalize4(join18(projectPath, ".beads"));
+  const hiveDir = normalize4(join18(projectPath, ".hive"));
   if (existsSync12(hiveDir)) {
     return { needed: false };
   }
@@ -194299,8 +194934,8 @@ function checkBeadsMigrationNeeded(projectPath) {
   return { needed: false };
 }
 async function migrateBeadsToHive(projectPath) {
-  const beadsDir = normalizePath2(join17(projectPath, ".beads"));
-  const hiveDir = normalizePath2(join17(projectPath, ".hive"));
+  const beadsDir = normalize4(join18(projectPath, ".beads"));
+  const hiveDir = normalize4(join18(projectPath, ".hive"));
   if (existsSync12(hiveDir)) {
     return {
       migrated: false,
@@ -194318,7 +194953,7 @@ async function migrateBeadsToHive(projectPath) {
   return { migrated: true };
 }
 function ensureHiveDirectory(projectPath) {
-  const hiveDir = normalizePath2(join17(projectPath, ".hive"));
+  const hiveDir = normalize4(join18(projectPath, ".hive"));
   if (!existsSync12(hiveDir)) {
     const { mkdirSync: mkdirSync3 } = __require("node:fs");
     mkdirSync3(hiveDir, { recursive: true });
@@ -194326,9 +194961,9 @@ function ensureHiveDirectory(projectPath) {
 }
 async function mergeHistoricBeads(projectPath) {
   const { readFileSync: readFileSync6, writeFileSync: writeFileSync3, existsSync: existsSync11 } = await import("node:fs");
-  const hiveDir = normalizePath2(join17(projectPath, ".hive"));
-  const basePath = normalizePath2(join17(hiveDir, "beads.base.jsonl"));
-  const issuesPath = normalizePath2(join17(hiveDir, "issues.jsonl"));
+  const hiveDir = normalize4(join18(projectPath, ".hive"));
+  const basePath = normalize4(join18(hiveDir, "beads.base.jsonl"));
+  const issuesPath = normalize4(join18(hiveDir, "issues.jsonl"));
   if (!existsSync11(basePath)) {
     return { merged: 0, skipped: 0 };
   }
@@ -194360,8 +194995,8 @@ async function mergeHistoricBeads(projectPath) {
   writeFileSync3(issuesPath, mergedContent, "utf-8");
   return { merged, skipped };
 }
-async function importJsonlToPGLite(projectPath) {
-  const jsonlPath = join17(projectPath, ".hive", "issues.jsonl");
+async function importJsonlToLibSQL(projectPath) {
+  const jsonlPath = join18(projectPath, ".hive", "issues.jsonl");
   if (!existsSync12(jsonlPath)) {
     return { imported: 0, updated: 0, errors: 0 };
   }
@@ -194428,6 +195063,7 @@ async function importJsonlToPGLite(projectPath) {
   }
   return { imported, updated, errors: errors6 };
 }
+var importJsonlToPGLite = importJsonlToLibSQL;
 var adapterCache2 = new Map;
 var exitHookRegistered = false;
 var exitHookRunning = false;
@@ -194483,8 +195119,8 @@ function clearHiveAdapterCache() {
   adapterCache2.clear();
 }
 async function autoMigrateFromJSONL(adapter5, projectKey) {
-  const jsonlPath = join17(projectKey, ".hive", "issues.jsonl");
-  const oldPath = join17(projectKey, ".hive", "issues.jsonl.old");
+  const jsonlPath = join18(projectKey, ".hive", "issues.jsonl");
+  const oldPath = join18(projectKey, ".hive", "issues.jsonl.old");
   if (!existsSync12(jsonlPath)) {
     return;
   }
@@ -194533,7 +195169,19 @@ var hive_create = tool({
     parent_id: tool.schema.string().optional().describe("Parent cell ID for epic children")
   },
   async execute(args2, ctx) {
-    const validated = CellCreateArgsSchema.parse(args2);
+    const normalized = normalizeCreateArgs(args2);
+    const parsed = CellCreateArgsSchema.safeParse(normalized);
+    if (!parsed.success) {
+      const message = formatZodError("hive_create", parsed.error, `{
+  "title": "Fix login bug",
+  "type": "bug",
+  "priority": 2,
+  "description": "Null check on session token",
+  "parent_id": "project-abc12"
+}`);
+      throw new HiveValidationError(message, parsed.error);
+    }
+    const validated = parsed.data;
     const projectKey = getHiveWorkingDirectory();
     const adapter5 = await getHiveAdapter(projectKey);
     try {
@@ -194589,7 +195237,20 @@ var hive_create_epic = tool({
     }).optional().describe("Recovery context from checkpoint compaction")
   },
   async execute(args2, ctx) {
-    const validated = EpicCreateArgsSchema.parse(args2);
+    const normalized = normalizeEpicCreateArgs(args2);
+    const parsed = EpicCreateArgsSchema.safeParse(normalized);
+    if (!parsed.success) {
+      const message = formatZodError("hive_create_epic", parsed.error, `{
+  "epic_title": "Ship new Auth",
+  "epic_description": "Auth overhaul with passwordless",
+  "subtasks": [
+    { "title": "DB migration", "priority": 1 },
+    { "title": "Add magic links", "priority": 2 }
+  ]
+}`);
+      throw new HiveValidationError(message, parsed.error);
+    }
+    const validated = parsed.data;
     const projectKey = getHiveWorkingDirectory();
     const adapter5 = await getHiveAdapter(projectKey);
     const created = [];
@@ -194612,12 +195273,21 @@ var hive_create_epic = tool({
         await adapter5.markDirty(projectKey, subtaskCell.id);
         created.push(subtaskCell);
       }
+      try {
+        const children3 = await adapter5.queryCells(projectKey, { parent_id: epic.id });
+        if (children3.length !== validated.subtasks.length) {
+          throw new Error(`Post-create validation failed: expected ${validated.subtasks.length} subtasks, found ${children3.length}`);
+        }
+      } catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        throw new Error(`Epic integrity check failed: ${msg}`);
+      }
       const result = {
         success: true,
         epic: formatCellForOutput(epic),
         subtasks: created.slice(1).map((c) => formatCellForOutput(c))
       };
-      const effectiveProjectKey = args2.project_key || projectKey;
+      const effectiveProjectKey = normalized.project_key || projectKey;
       try {
         const epicCreatedEvent = createEvent("epic_created", {
           project_key: effectiveProjectKey,
@@ -194635,16 +195305,16 @@ var hive_create_epic = tool({
         const event = createEvent("decomposition_generated", {
           project_key: effectiveProjectKey,
           epic_id: epic.id,
-          task: args2.task || validated.epic_title,
+          task: normalized.task || validated.epic_title,
           context: validated.epic_description,
-          strategy: args2.strategy || "feature-based",
+          strategy: normalized.strategy || "feature-based",
           epic_title: validated.epic_title,
           subtasks: validated.subtasks.map((st) => ({
             title: st.title,
             files: st.files || [],
             priority: st.priority
           })),
-          recovery_context: args2.recovery_context
+          recovery_context: normalized.recovery_context
         });
         await appendEvent(event, effectiveProjectKey);
       } catch (error64) {
@@ -194656,7 +195326,7 @@ var hive_create_epic = tool({
           project_key: effectiveProjectKey,
           epic_id: epic.id,
           epic_title: validated.epic_title,
-          strategy: args2.strategy || "feature-based",
+          strategy: normalized.strategy || "feature-based",
           subtask_count: validated.subtasks.length,
           total_files: totalFiles,
           coordinator_agent: "coordinator"
@@ -194681,10 +195351,10 @@ var hive_create_epic = tool({
           decision_type: "decomposition_complete",
           payload: {
             subtask_count: validated.subtasks.length,
-            strategy_used: args2.strategy || "feature-based",
+            strategy_used: normalized.strategy || "feature-based",
             files_per_subtask: filesPerSubtask,
             epic_title: validated.epic_title,
-            task: args2.task
+            task: normalized.task
           }
         });
       } catch (error64) {
@@ -194740,7 +195410,18 @@ var hive_query = tool({
     limit: tool.schema.number().optional().describe("Max results to return (default: 20)")
   },
   async execute(args2, ctx) {
-    const validated = CellQueryArgsSchema.parse(args2);
+    const normalized = normalizeQueryArgs(args2);
+    const parsed = CellQueryArgsSchema.safeParse(normalized);
+    if (!parsed.success) {
+      const message = formatZodError("hive_query", parsed.error, `{
+  "status": "in_progress",
+  "type": "task",
+  "parent_id": "project-abc12",
+  "limit": 10
+}`);
+      throw new HiveValidationError(message, parsed.error);
+    }
+    const validated = parsed.data;
     const projectKey = getHiveWorkingDirectory();
     const adapter5 = await getHiveAdapter(projectKey);
     try {
@@ -194773,20 +195454,32 @@ var hive_update = tool({
     priority: tool.schema.number().min(0).max(3).optional().describe("New priority")
   },
   async execute(args2, ctx) {
-    const validated = CellUpdateArgsSchema.parse(args2);
+    const normalized = normalizeUpdateArgs(args2);
+    const parsed = CellUpdateArgsSchema.safeParse(normalized);
+    if (!parsed.success) {
+      const message = formatZodError("hive_update", parsed.error, `{
+  "id": "project-abc12",
+  "status": "in_progress",
+  "priority": 1,
+  "description": "Ready for review"
+}`);
+      throw new HiveValidationError(message, parsed.error);
+    }
+    const validated = parsed.data;
     const projectKey = getHiveWorkingDirectory();
     const adapter5 = await getHiveAdapter(projectKey);
     try {
       const cellId = await resolvePartialId(adapter5, projectKey, validated.id) || validated.id;
       let cell;
-      if (validated.status) {
-        cell = await adapter5.changeCellStatus(projectKey, cellId, validated.status);
+      if (validated.status !== undefined) {
+        const newStatus = validated.status;
+        cell = await withRetry2(() => adapter5.changeCellStatus(projectKey, cellId, newStatus));
       }
       if (validated.description !== undefined || validated.priority !== undefined) {
-        cell = await adapter5.updateCell(projectKey, cellId, {
+        cell = await withRetry2(() => adapter5.updateCell(projectKey, cellId, {
           description: validated.description,
           priority: validated.priority
-        });
+        }));
       } else if (!validated.status) {
         const existingCell = await adapter5.getCell(projectKey, cellId);
         if (!existingCell) {
@@ -194833,14 +195526,23 @@ var hive_close = tool({
     reason: tool.schema.string().describe("Completion reason")
   },
   async execute(args2, ctx) {
-    const validated = CellCloseArgsSchema.parse(args2);
+    const normalized = normalizeCloseArgs(args2);
+    const parsed = CellCloseArgsSchema.safeParse(normalized);
+    if (!parsed.success) {
+      const message = formatZodError("hive_close", parsed.error, `{
+  "id": "project-abc12",
+  "reason": "Merged in main"
+}`);
+      throw new HiveValidationError(message, parsed.error);
+    }
+    const validated = parsed.data;
     const projectKey = getHiveWorkingDirectory();
     const adapter5 = await getHiveAdapter(projectKey);
     try {
       const cellId = await resolvePartialId(adapter5, projectKey, validated.id) || validated.id;
       const cellBeforeClose = await adapter5.getCell(projectKey, cellId);
       const isEpic = cellBeforeClose?.type === "epic";
-      const cell = await adapter5.closeCell(projectKey, cellId, validated.reason);
+      const cell = await withRetry2(() => adapter5.closeCell(projectKey, cellId, validated.reason));
       await adapter5.markDirty(projectKey, cellId);
       if (isEpic && cellBeforeClose) {
         try {
@@ -194961,7 +195663,7 @@ var hive_start = tool({
     const adapter5 = await getHiveAdapter(projectKey);
     try {
       const cellId = await resolvePartialId(adapter5, projectKey, args2.id) || args2.id;
-      const cell = await adapter5.changeCellStatus(projectKey, cellId, "in_progress");
+      const cell = await withRetry2(() => adapter5.changeCellStatus(projectKey, cellId, "in_progress"));
       await adapter5.markDirty(projectKey, cellId);
       try {
         const event = createEvent("cell_status_changed", {
@@ -195036,16 +195738,17 @@ PREFER THIS OVER hive_query when you need to:
   async execute(args2, ctx) {
     const projectKey = getHiveWorkingDirectory();
     const adapter5 = await getHiveAdapter(projectKey);
+    const normalized = normalizeCellsArgs(args2);
     try {
-      if (args2.id) {
-        const matchingCells = await findCellsByPartialId(adapter5, projectKey, args2.id);
+      if (normalized.id) {
+        const matchingCells = await findCellsByPartialId(adapter5, projectKey, normalized.id);
         if (matchingCells.length === 0) {
-          throw new HiveError(`No cell found matching ID '${args2.id}'`, "hive_cells");
+          throw new HiveError(`No cell found matching ID '${normalized.id}'`, "hive_cells");
         }
         const formatted2 = matchingCells.map((c) => formatCellForOutput(c));
         return JSON.stringify(formatted2, null, 2);
       }
-      if (args2.ready) {
+      if (normalized.ready) {
         const ready = await adapter5.getNextReadyCell(projectKey);
         if (!ready) {
           return JSON.stringify([], null, 2);
@@ -195054,10 +195757,10 @@ PREFER THIS OVER hive_query when you need to:
         return JSON.stringify([formatted2], null, 2);
       }
       const cells2 = await adapter5.queryCells(projectKey, {
-        status: args2.status,
-        type: args2.type,
-        parent_id: args2.parent_id,
-        limit: args2.limit || 20
+        status: normalized.status,
+        type: normalized.type,
+        parent_id: normalized.parent_id,
+        limit: normalized.limit || 20
       });
       const formatted = cells2.map((c) => formatCellForOutput(c));
       return JSON.stringify(formatted, null, 2);
@@ -195067,7 +195770,7 @@ PREFER THIS OVER hive_query when you need to:
       }
       const message = error64 instanceof Error ? error64.message : String(error64);
       if (message.includes("Bead not found") || message.includes("Cell not found")) {
-        throw new HiveError(`No cell found matching ID '${args2.id || "unknown"}'`, "hive_cells");
+        throw new HiveError(`No cell found matching ID '${normalized.id || "unknown"}'`, "hive_cells");
       }
       throw new HiveError(`Failed to query cells: ${message}`, "hive_cells");
     }
@@ -195105,7 +195808,7 @@ var hive_sync = tool({
     const flushResult = await withTimeout2(flushManager.flush(), TIMEOUT_MS, "flush hive");
     const swarmMail = await getSwarmMailLibSQL(projectKey);
     const db = await swarmMail.getDatabase();
-    const hivePath = join17(projectKey, ".hive");
+    const hivePath = join18(projectKey, ".hive");
     let memoriesSynced = 0;
     try {
       const memoryResult = await syncMemories(db, hivePath);
@@ -195136,6 +195839,14 @@ var hive_sync = tool({
       const remoteCheckResult2 = await runGitCommand(["remote"]);
       const hasRemote2 = remoteCheckResult2.stdout.trim() !== "";
       if (hasRemote2) {
+        await withTimeout2(runGitCommand(["fetch", "--all", "--prune"]), TIMEOUT_MS, "git fetch");
+        const upstreamResult = await runGitCommand([
+          "rev-parse",
+          "--abbrev-ref",
+          "--symbolic-full-name",
+          "@{u}"
+        ]);
+        const hasUpstream = upstreamResult.exitCode === 0;
         const statusResult = await runGitCommand(["status", "--porcelain"]);
         const hasUnstagedChanges = statusResult.stdout.trim() !== "";
         let didStash = false;
@@ -195146,9 +195857,13 @@ var hive_sync = tool({
           }
         }
         try {
-          const pullResult = await withTimeout2(runGitCommand(["pull", "--rebase"]), TIMEOUT_MS, "git pull --rebase");
-          if (pullResult.exitCode !== 0) {
-            throw new HiveError(`Failed to pull: ${pullResult.stderr}`, "git pull --rebase", pullResult.exitCode);
+          if (hasUpstream) {
+            const pullResult = await withTimeout2(runGitCommand(["pull", "--rebase"]), TIMEOUT_MS, "git pull --rebase");
+            if (pullResult.exitCode !== 0) {
+              throw new HiveError(`Failed to pull: ${pullResult.stderr}`, "git pull --rebase", pullResult.exitCode);
+            }
+          } else {
+            console.warn("[hive_sync] No upstream configured for current branch. Skipping pull.");
           }
         } finally {
           if (didStash) {
@@ -195677,14 +196392,14 @@ function formatToolAvailability(availability) {
 // src/rate-limiter.ts
 var import_ioredis = __toESM(require_built3(), 1);
 import { mkdirSync as mkdirSync3, existsSync as existsSync13 } from "node:fs";
-import { dirname as dirname4, join as join19 } from "node:path";
+import { dirname as dirname5, join as join20 } from "node:path";
 import { homedir as homedir6 } from "node:os";
 var sqliteAvailable = false;
 var createDatabase = null;
 try {
   if (typeof globalThis.Bun !== "undefined") {
     const bunSqlite = await import("bun:sqlite");
-    createDatabase = (path4) => new bunSqlite.Database(path4);
+    createDatabase = (path6) => new bunSqlite.Database(path6);
     sqliteAvailable = true;
   }
 } catch {
@@ -195792,7 +196507,7 @@ class SqliteRateLimiter {
     if (!sqliteAvailable || !createDatabase) {
       throw new Error("SQLite is not available in this runtime (requires Bun)");
     }
-    const dir3 = dirname4(dbPath);
+    const dir3 = dirname5(dbPath);
     if (!existsSync13(dir3)) {
       mkdirSync3(dir3, { recursive: true });
     }
@@ -195938,7 +196653,7 @@ async function createRateLimiter(options2) {
   const {
     backend,
     redisUrl = process.env.OPENCODE_RATE_LIMIT_REDIS_URL || "redis://localhost:6379",
-    sqlitePath = process.env.OPENCODE_RATE_LIMIT_SQLITE_PATH || join19(homedir6(), ".config", "opencode", "rate-limits.db")
+    sqlitePath = process.env.OPENCODE_RATE_LIMIT_SQLITE_PATH || join20(homedir6(), ".config", "opencode", "rate-limits.db")
   } = options2 || {};
   if (backend === "memory") {
     return new InMemoryRateLimiter;
@@ -196004,7 +196719,7 @@ import {
   writeFileSync as writeFileSync3,
   unlinkSync
 } from "fs";
-import { join as join20 } from "path";
+import { join as join21 } from "path";
 import { tmpdir } from "os";
 var AGENT_MAIL_URL = "http://127.0.0.1:8765";
 var MAX_INBOX_LIMIT3 = 5;
@@ -196028,16 +196743,16 @@ var RECOVERY_CONFIG = {
   restartCooldownMs: 1e4,
   enabled: process.env.OPENCODE_AGENT_MAIL_AUTO_RESTART !== "false"
 };
-var SESSION_STATE_DIR = process.env.SWARM_STATE_DIR || join20(tmpdir(), "swarm-sessions");
+var SESSION_STATE_DIR = process.env.SWARM_STATE_DIR || join21(tmpdir(), "swarm-sessions");
 function getSessionStatePath(sessionID) {
   const safeID = sessionID.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return join20(SESSION_STATE_DIR, `${safeID}.json`);
+  return join21(SESSION_STATE_DIR, `${safeID}.json`);
 }
 function loadSessionState(sessionID) {
-  const path4 = getSessionStatePath(sessionID);
+  const path6 = getSessionStatePath(sessionID);
   try {
-    if (existsSync14(path4)) {
-      const data = readFileSync8(path4, "utf-8");
+    if (existsSync14(path6)) {
+      const data = readFileSync8(path6, "utf-8");
       return JSON.parse(data);
     }
   } catch (error64) {
@@ -196050,8 +196765,8 @@ function saveSessionState(sessionID, state) {
     if (!existsSync14(SESSION_STATE_DIR)) {
       mkdirSync4(SESSION_STATE_DIR, { recursive: true });
     }
-    const path4 = getSessionStatePath(sessionID);
-    writeFileSync3(path4, JSON.stringify(state, null, 2));
+    const path6 = getSessionStatePath(sessionID);
+    writeFileSync3(path6, JSON.stringify(state, null, 2));
     return true;
   } catch (error64) {
     console.error(`[agent-mail] CRITICAL: Could not save session state: ${error64}`);
@@ -196192,11 +196907,11 @@ async function restartServer() {
       `${process.env.HOME}/mcp_agent_mail`
     ];
     let serverDir = null;
-    for (const path4 of possiblePaths) {
+    for (const path6 of possiblePaths) {
       try {
-        const stat4 = await Bun.file(`${path4}/pyproject.toml`).exists();
+        const stat4 = await Bun.file(`${path6}/pyproject.toml`).exists();
         if (stat4) {
-          serverDir = path4;
+          serverDir = path6;
           break;
         }
       } catch {
@@ -197083,7 +197798,7 @@ import {
   writeFileSync as writeFileSync4,
   unlinkSync as unlinkSync2
 } from "node:fs";
-import { join as join21 } from "node:path";
+import { join as join23 } from "node:path";
 import { tmpdir as tmpdir2 } from "node:os";
 var MAX_INBOX_LIMIT5 = 5;
 var swarmMailProjectDirectory = null;
@@ -197093,16 +197808,16 @@ function setSwarmMailProjectDirectory(directory) {
 function getSwarmMailProjectDirectory() {
   return swarmMailProjectDirectory ?? undefined;
 }
-var SESSION_STATE_DIR2 = process.env.SWARM_STATE_DIR || join21(tmpdir2(), "swarm-sessions");
+var SESSION_STATE_DIR2 = process.env.SWARM_STATE_DIR || join23(tmpdir2(), "swarm-sessions");
 function getSessionStatePath2(sessionID) {
   const safeID = sessionID.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return join21(SESSION_STATE_DIR2, `${safeID}.json`);
+  return join23(SESSION_STATE_DIR2, `${safeID}.json`);
 }
 function loadSessionState2(sessionID) {
-  const path4 = getSessionStatePath2(sessionID);
+  const path6 = getSessionStatePath2(sessionID);
   try {
-    if (existsSync15(path4)) {
-      const data = readFileSync9(path4, "utf-8");
+    if (existsSync15(path6)) {
+      const data = readFileSync9(path6, "utf-8");
       return JSON.parse(data);
     }
   } catch (error64) {
@@ -197115,8 +197830,8 @@ function saveSessionState2(sessionID, state) {
     if (!existsSync15(SESSION_STATE_DIR2)) {
       mkdirSync5(SESSION_STATE_DIR2, { recursive: true });
     }
-    const path4 = getSessionStatePath2(sessionID);
-    writeFileSync4(path4, JSON.stringify(state, null, 2));
+    const path6 = getSessionStatePath2(sessionID);
+    writeFileSync4(path6, JSON.stringify(state, null, 2));
     return true;
   } catch (error64) {
     console.warn(`[swarm-mail] Could not save session state: ${error64}`);
@@ -197124,10 +197839,10 @@ function saveSessionState2(sessionID, state) {
   }
 }
 function clearSessionState(sessionID) {
-  const path4 = getSessionStatePath2(sessionID);
+  const path6 = getSessionStatePath2(sessionID);
   try {
-    if (existsSync15(path4)) {
-      unlinkSync2(path4);
+    if (existsSync15(path6)) {
+      unlinkSync2(path6);
     }
   } catch {}
 }
@@ -197158,12 +197873,27 @@ var swarmmail_init = tool({
     const sessionID = ctx.sessionID || "default";
     const existingState = loadSessionState2(sessionID);
     if (existingState) {
-      return JSON.stringify({
-        agent_name: existingState.agentName,
-        project_key: existingState.projectKey,
-        message: `Session already initialized as ${existingState.agentName}`,
-        already_initialized: true
-      }, null, 2);
+      const requestedAgent = args2.agent_name;
+      const projectMismatch = existingState.projectKey !== projectPath;
+      const agentMismatch = Boolean(requestedAgent && requestedAgent !== existingState.agentName);
+      if (args2.force_reinit) {
+        clearSessionState(sessionID);
+      } else {
+        return JSON.stringify({
+          agent_name: existingState.agentName,
+          project_key: existingState.projectKey,
+          message: `Session already initialized as ${existingState.agentName}`,
+          already_initialized: true,
+          session_id: sessionID,
+          project_mismatch: projectMismatch || undefined,
+          agent_mismatch: agentMismatch || undefined,
+          note: projectMismatch || agentMismatch ? "To switch project/agent, call swarmmail_init again with force_reinit: true (or end the session)." : undefined,
+          requested: requestedAgent || args2.project_path ? {
+            agent_name: requestedAgent,
+            project_key: args2.project_path
+          } : undefined
+        }, null, 2);
+      }
     }
     try {
       const result = await initSwarmAgent({
@@ -197377,7 +198107,7 @@ var swarmmail_release = tool({
       } else if (args2.reservation_ids) {
         state.reservations = state.reservations.filter((id3) => !args2.reservation_ids.includes(id3));
       } else if (normalizedPaths) {
-        const releasedIds = currentReservations.filter((r) => normalizedPaths.includes(r.path_pattern)).map((r) => r.id);
+        const releasedIds = currentReservations.filter((r) => normalizedPaths.some((p) => p === r.path_pattern)).map((r) => r.id);
         state.reservations = state.reservations.filter((id3) => !releasedIds.includes(id3));
       }
       saveSessionState2(sessionID, state);
@@ -197550,8 +198280,8 @@ class JsonExtractionError extends Error {
 }
 function formatZodErrors(error64) {
   return error64.issues.map((issue4) => {
-    const path4 = issue4.path.length > 0 ? `${issue4.path.join(".")}: ` : "";
-    return `${path4}${issue4.message}`;
+    const path6 = issue4.path.length > 0 ? `${issue4.path.join(".")}: ` : "";
+    return `${path6}${issue4.message}`;
   });
 }
 var SCHEMA_REGISTRY = {
@@ -199711,11 +200441,11 @@ var qmarksTestNoExtDot2 = ([$0]) => {
   return (f) => f.length === len && f !== "." && f !== "..";
 };
 var defaultPlatform2 = typeof process === "object" && process ? typeof process.env === "object" && process.env && process.env.__MINIMATCH_TESTING_PLATFORM__ || process.platform : "posix";
-var path5 = {
+var path9 = {
   win32: { sep: "\\" },
   posix: { sep: "/" }
 };
-var sep3 = defaultPlatform2 === "win32" ? path5.win32.sep : path5.posix.sep;
+var sep3 = defaultPlatform2 === "win32" ? path9.win32.sep : path9.posix.sep;
 minimatch2.sep = sep3;
 var GLOBSTAR2 = Symbol("globstar **");
 minimatch2.GLOBSTAR = GLOBSTAR2;
@@ -199861,9 +200591,9 @@ class Minimatch2 {
     this.debug(this.pattern, this.globParts);
     let set28 = this.globParts.map((s, _, __) => {
       if (this.isWindows && this.windowsNoMagicRoot) {
-        const isUNC = s[0] === "" && s[1] === "" && (s[2] === "?" || !globMagic2.test(s[2])) && !globMagic2.test(s[3]);
+        const isUNC3 = s[0] === "" && s[1] === "" && (s[2] === "?" || !globMagic2.test(s[2])) && !globMagic2.test(s[3]);
         const isDrive = /^[a-z]:/i.test(s[0]);
-        if (isUNC) {
+        if (isUNC3) {
           return [...s.slice(0, 4), ...s.slice(4).map((ss) => this.parse(ss))];
         } else if (isDrive) {
           return [s[0], ...s.slice(1).map((ss) => this.parse(ss))];
@@ -200352,15 +201082,15 @@ init_skills();
 // src/swarm-worktree.ts
 init_dist();
 init_zod3();
-import { join as join25 } from "node:path";
+import { join as join26 } from "node:path";
 import { existsSync as existsSync16 } from "node:fs";
 var WORKTREE_DIR = ".swarm/worktrees";
 function getWorktreePath(projectPath, taskId) {
   const safeTaskId = taskId.replace(/[^a-zA-Z0-9.-]/g, "_");
-  return normalizePath2(join25(projectPath, WORKTREE_DIR, safeTaskId));
+  return normalize4(join26(projectPath, WORKTREE_DIR, safeTaskId));
 }
 function parseTaskIdFromPath(worktreePath) {
-  const normalized = normalizePath2(worktreePath);
+  const normalized = normalize4(worktreePath);
   const parts2 = normalized.split("/");
   const worktreesIdx = parts2.indexOf("worktrees");
   if (worktreesIdx >= 0 && worktreesIdx < parts2.length - 1) {
@@ -200368,18 +201098,18 @@ function parseTaskIdFromPath(worktreePath) {
   }
   return null;
 }
-async function isGitRepo(path4) {
-  const result = await Bun.$`git -C ${path4} rev-parse --git-dir`.quiet().nothrow();
+async function isGitRepo(path6) {
+  const result = await Bun.$`git -C ${path6} rev-parse --git-dir`.quiet().nothrow();
   return result.exitCode === 0;
 }
-async function hasUncommittedChanges(path4) {
-  const result = await Bun.$`git -C ${path4} status --porcelain`.quiet().nothrow();
+async function hasUncommittedChanges(path6) {
+  const result = await Bun.$`git -C ${path6} status --porcelain`.quiet().nothrow();
   if (result.exitCode !== 0)
     return true;
   return result.stdout.toString().trim().length > 0;
 }
-async function getCurrentCommit(path4) {
-  const result = await Bun.$`git -C ${path4} rev-parse HEAD`.quiet().nothrow();
+async function getCurrentCommit(path6) {
+  const result = await Bun.$`git -C ${path6} rev-parse HEAD`.quiet().nothrow();
   if (result.exitCode !== 0)
     return null;
   return result.stdout.toString().trim();
@@ -200392,7 +201122,7 @@ async function getWorktreeCommits(worktreePath, startCommit) {
 `).filter((c) => c.length > 0);
 }
 async function ensureWorktreeDir(projectPath) {
-  const worktreeDir = normalizePath2(join25(projectPath, WORKTREE_DIR));
+  const worktreeDir = normalize4(join26(projectPath, WORKTREE_DIR));
   await Bun.$`mkdir -p ${worktreeDir}`.quiet().nothrow();
 }
 var swarm_worktree_create = tool({
@@ -200529,7 +201259,7 @@ var swarm_worktree_cleanup = tool({
         return JSON.stringify(result3, null, 2);
       }
       const output = listResult.stdout.toString();
-      const worktreeDir = join25(args2.project_path, WORKTREE_DIR);
+      const worktreeDir = join26(args2.project_path, WORKTREE_DIR);
       const worktrees = output.split(`
 
 `).filter((block) => block.includes(worktreeDir)).map((block) => {
@@ -200594,7 +201324,7 @@ var swarm_worktree_list = tool({
       }, null, 2);
     }
     const output = listResult.stdout.toString();
-    const worktreeDir = join25(args2.project_path, WORKTREE_DIR);
+    const worktreeDir = join26(args2.project_path, WORKTREE_DIR);
     const worktrees = [];
     const blocks = output.split(`
 
@@ -200604,12 +201334,12 @@ var swarm_worktree_list = tool({
       const commitMatch = block.match(/^HEAD ([a-f0-9]+)$/m);
       const branchMatch = block.match(/^branch (.+)$/m);
       if (pathMatch && pathMatch[1].includes(worktreeDir)) {
-        const path4 = pathMatch[1];
-        const taskId = parseTaskIdFromPath(path4);
+        const path6 = pathMatch[1];
+        const taskId = parseTaskIdFromPath(path6);
         if (taskId) {
           worktrees.push({
             task_id: taskId,
-            path: path4,
+            path: path6,
             commit: commitMatch ? commitMatch[1] : "unknown",
             branch: branchMatch ? branchMatch[1] : undefined
           });
@@ -202775,7 +203505,7 @@ ${args2.files_context.map((f) => `- \`${f}\``).join(`
 *Learned from swarm execution on ${new Date().toISOString().split("T")[0]}*`;
       const { getSkill: getSkill2, invalidateSkillsCache: invalidateSkillsCache2 } = await Promise.resolve().then(() => (init_skills(), exports_skills));
       const { mkdir: mkdir2, writeFile: writeFile3 } = await import("node:fs/promises");
-      const { join: join18 } = await import("node:path");
+      const { join: join19 } = await import("node:path");
       const existing = await getSkill2(args2.skill_name);
       if (existing) {
         return JSON.stringify({
@@ -202786,8 +203516,8 @@ ${args2.files_context.map((f) => `- \`${f}\``).join(`
           suggestion: "Use skills_update to add to existing skill, or choose a different name"
         }, null, 2);
       }
-      const skillDir = join18(process.cwd(), ".opencode", "skills", args2.skill_name);
-      const skillPath = join18(skillDir, "SKILL.md");
+      const skillDir = join19(process.cwd(), ".opencode", "skills", args2.skill_name);
+      const skillPath = join19(skillDir, "SKILL.md");
       const frontmatter = [
         "---",
         `name: ${args2.skill_name}`,
@@ -204150,7 +204880,7 @@ var promptTools = {
 init_dist();
 import { existsSync as existsSync17 } from "node:fs";
 import { readFile as readFile3 } from "node:fs/promises";
-import { join as join28 } from "node:path";
+import { join as join29 } from "node:path";
 
 // ../../node_modules/yaml/dist/index.js
 var composer = require_composer();
@@ -204214,11 +204944,6 @@ var TOOL_DEFINITIONS = [
     name: "fetch",
     type: "mcp",
     capabilities: ["http-fetch", "markdown-conversion"]
-  },
-  {
-    name: "pdf-brain",
-    type: "mcp",
-    capabilities: ["knowledge-base-search", "internal-docs"]
   }
 ];
 function stripSemverConstraint(versionStr) {
@@ -204302,11 +205027,11 @@ async function parseYarnLockfile(lockfilePath, packages) {
 async function parsePackageJson(packageJsonPath, packages) {
   try {
     const content = await readFile3(packageJsonPath, "utf-8");
-    const packageJson = JSON.parse(content);
+    const packageJson2 = JSON.parse(content);
     const versions3 = [];
     const allDeps = {
-      ...packageJson.dependencies,
-      ...packageJson.devDependencies
+      ...packageJson2.dependencies,
+      ...packageJson2.devDependencies
     };
     for (const pkg of packages) {
       const constraint = allDeps[pkg];
@@ -204328,22 +205053,22 @@ async function parsePackageJson(packageJsonPath, packages) {
   }
 }
 async function getInstalledVersions(projectPath, packages, checkUpgrades = false) {
-  const npmLock = join28(projectPath, "package-lock.json");
+  const npmLock = join29(projectPath, "package-lock.json");
   let versions3 = [];
   if (existsSync17(npmLock)) {
     versions3 = await parseNpmLockfile(npmLock, packages);
   } else {
-    const pnpmLock = join28(projectPath, "pnpm-lock.yaml");
+    const pnpmLock = join29(projectPath, "pnpm-lock.yaml");
     if (existsSync17(pnpmLock)) {
       versions3 = await parsePnpmLockfile(pnpmLock, packages);
     } else {
-      const yarnLock = join28(projectPath, "yarn.lock");
+      const yarnLock = join29(projectPath, "yarn.lock");
       if (existsSync17(yarnLock)) {
         versions3 = await parseYarnLockfile(yarnLock, packages);
       } else {
-        const packageJson = join28(projectPath, "package.json");
-        if (existsSync17(packageJson)) {
-          versions3 = await parsePackageJson(packageJson, packages);
+        const packageJson2 = join29(projectPath, "package.json");
+        if (existsSync17(packageJson2)) {
+          versions3 = await parsePackageJson(packageJson2, packages);
         }
       }
     }
@@ -205651,28 +206376,28 @@ init_dist2();
 init_memory2();
 init_memory2();
 import * as os2 from "node:os";
-import * as path6 from "node:path";
-import { join as join30 } from "node:path";
+import * as path10 from "node:path";
+import { join as join31 } from "node:path";
 var cachedAdapter2 = null;
 var cachedIndexer = null;
 var cachedProjectPath2 = null;
 async function getMemoryAdapter2(projectPath) {
-  const path4 = projectPath || process.cwd();
-  if (cachedAdapter2 && cachedProjectPath2 === path4) {
+  const path6 = projectPath || process.cwd();
+  if (cachedAdapter2 && cachedProjectPath2 === path6) {
     return cachedAdapter2;
   }
-  const swarmMail = await getSwarmMailLibSQL(path4);
+  const swarmMail = await getSwarmMailLibSQL(path6);
   const dbAdapter = await swarmMail.getDatabase();
   cachedAdapter2 = await createMemoryAdapter2(dbAdapter);
-  cachedProjectPath2 = path4;
+  cachedProjectPath2 = path6;
   return cachedAdapter2;
 }
 async function getSessionIndexer(projectPath) {
-  const path4 = projectPath || process.cwd();
-  if (cachedIndexer && cachedProjectPath2 === path4) {
+  const path6 = projectPath || process.cwd();
+  if (cachedIndexer && cachedProjectPath2 === path6) {
     return cachedIndexer;
   }
-  const swarmMail = await getSwarmMailLibSQL(path4);
+  const swarmMail = await getSwarmMailLibSQL(path6);
   const dbAdapter = await swarmMail.getDatabase();
   const db = toSwarmDb(dbAdapter);
   const ollamaLayer = makeOllamaLive({
@@ -205680,7 +206405,7 @@ async function getSessionIndexer(projectPath) {
     ollamaModel: process.env.OLLAMA_MODEL || "mxbai-embed-large"
   });
   cachedIndexer = new SessionIndexer(db, ollamaLayer);
-  cachedProjectPath2 = path4;
+  cachedProjectPath2 = path6;
   return cachedIndexer;
 }
 var getHivemindAdapter = getMemoryAdapter2;
@@ -205696,11 +206421,11 @@ async function emitEvent(eventType, data) {
   } catch {}
 }
 var AGENT_DIRECTORIES = [
-  path6.join(os2.homedir(), ".config", "swarm-tools", "sessions"),
-  path6.join(os2.homedir(), ".opencode"),
-  path6.join(os2.homedir(), "Cursor", "User", "History"),
-  path6.join(os2.homedir(), ".local", "share", "Claude"),
-  path6.join(os2.homedir(), ".aider")
+  path10.join(os2.homedir(), ".config", "swarm-tools", "sessions"),
+  path10.join(os2.homedir(), ".opencode"),
+  path10.join(os2.homedir(), "Cursor", "User", "History"),
+  path10.join(os2.homedir(), ".local", "share", "Claude"),
+  path10.join(os2.homedir(), ".aider")
 ];
 var hivemind_store = tool({
   description: "Store a memory (learning, decision, pattern) with semantic embedding. Memories are searchable by semantic similarity and organized into collections. Use collection='default' for manual learnings.",
@@ -205859,7 +206584,7 @@ var hivemind_sync = tool({
       const projectPath = cachedProjectPath2 || process.cwd();
       const swarmMail = await getSwarmMailLibSQL(projectPath);
       const dbAdapter = await swarmMail.getDatabase();
-      const hiveDir = join30(projectPath, ".hive");
+      const hiveDir = join31(projectPath, ".hive");
       const result = await syncMemories(dbAdapter, hiveDir);
       await emitEvent("memories_synced", {
         imported: result.imported.created,
@@ -206753,9 +207478,9 @@ function getMetricsSummary(metrics) {
 // src/logger.ts
 var import_pino = __toESM(require_pino(), 1);
 import { mkdirSync as mkdirSync6, existsSync as existsSync18 } from "node:fs";
-import { join as join31 } from "node:path";
+import { join as join33 } from "node:path";
 import { homedir as homedir8 } from "node:os";
-var DEFAULT_LOG_DIR = join31(homedir8(), ".config", "swarm-tools", "logs");
+var DEFAULT_LOG_DIR = join33(homedir8(), ".config", "swarm-tools", "logs");
 function ensureLogDir(logDir) {
   if (!existsSync18(logDir)) {
     mkdirSync6(logDir, { recursive: true });
@@ -206774,7 +207499,7 @@ function getLogger(logDir = DEFAULT_LOG_DIR) {
   let logger;
   if (process.env.SWARM_LOG_FILE === "1") {
     ensureLogDir(logDir);
-    const logPath = join31(logDir, "swarm.log");
+    const logPath = join33(logDir, "swarm.log");
     logger = import_pino.default(baseConfig, import_pino.default.destination({ dest: logPath, sync: false }));
   } else {
     logger = import_pino.default(baseConfig);
@@ -206794,7 +207519,7 @@ function createChildLogger(module, logDir = DEFAULT_LOG_DIR) {
   let childLogger;
   if (process.env.SWARM_LOG_FILE === "1") {
     ensureLogDir(logDir);
-    const logPath = join31(logDir, `${module}.log`);
+    const logPath = join33(logDir, `${module}.log`);
     childLogger = import_pino.default(baseConfig, import_pino.default.destination({ dest: logPath, sync: false }));
   } else {
     childLogger = import_pino.default(baseConfig);
@@ -207672,17 +208397,17 @@ init_memory_tools();
 
 // src/eval-history.ts
 import * as fs3 from "node:fs";
-import * as path7 from "node:path";
+import * as path11 from "node:path";
 var DEFAULT_EVAL_HISTORY_PATH = ".opencode/eval-history.jsonl";
 var VARIANCE_THRESHOLD = 0.1;
 var BOOTSTRAP_THRESHOLD = 10;
 var STABILIZATION_THRESHOLD = 50;
 function getEvalHistoryPath(projectPath) {
-  return path7.join(projectPath, DEFAULT_EVAL_HISTORY_PATH);
+  return path11.join(projectPath, DEFAULT_EVAL_HISTORY_PATH);
 }
 function ensureEvalHistoryDir(projectPath) {
   const historyPath = getEvalHistoryPath(projectPath);
-  const dir3 = path7.dirname(historyPath);
+  const dir3 = path11.dirname(historyPath);
   if (!fs3.existsSync(dir3)) {
     fs3.mkdirSync(dir3, { recursive: true });
   }
@@ -208064,13 +208789,13 @@ init_dist();
 init_esm4();
 init_dist2();
 import * as os3 from "node:os";
-import * as path8 from "node:path";
+import * as path12 from "node:path";
 var AGENT_DIRECTORIES2 = [
-  path8.join(os3.homedir(), ".config", "swarm-tools", "sessions"),
-  path8.join(os3.homedir(), ".opencode"),
-  path8.join(os3.homedir(), "Cursor", "User", "History"),
-  path8.join(os3.homedir(), ".local", "share", "Claude"),
-  path8.join(os3.homedir(), ".aider")
+  path12.join(os3.homedir(), ".config", "swarm-tools", "sessions"),
+  path12.join(os3.homedir(), ".opencode"),
+  path12.join(os3.homedir(), "Cursor", "User", "History"),
+  path12.join(os3.homedir(), ".local", "share", "Claude"),
+  path12.join(os3.homedir(), ".aider")
 ];
 async function getSessionIndexer2() {
   const db = await getDb();
@@ -208627,6 +209352,7 @@ export {
   isAgentEvent,
   invalidateSkillsCache,
   importJsonlToPGLite,
+  importJsonlToLibSQL,
   ifToolAvailable,
   hive_update,
   hive_sync,