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

package/dist/hive.js

@@ -112,7 +112,7 @@ __export(exports_util2, {
   promiseAllObject: () => promiseAllObject2,
   primitiveTypes: () => primitiveTypes2,
   prefixIssues: () => prefixIssues2,
-  pick: () => pick2,
+  pick: () => pick3,
   partial: () => partial2,
   optionalKeys: () => optionalKeys2,
   omit: () => omit2,
@@ -263,10 +263,10 @@ function mergeDefs2(...defs) {
 function cloneDef2(schema) {
   return mergeDefs2(schema._zod.def);
 }
-function getElementAtPath2(obj, path) {
-  if (!path)
+function getElementAtPath2(obj, path3) {
+  if (!path3)
     return obj;
-  return path.reduce((acc, key) => acc?.[key], obj);
+  return path3.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject2(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -393,7 +393,7 @@ function optionalKeys2(shape) {
     return shape[k]._zod.optin === "optional" && shape[k]._zod.optout === "optional";
   });
 }
-function pick2(schema, mask) {
+function pick3(schema, mask) {
   const currDef = schema._zod.def;
   const def = mergeDefs2(schema._zod.def, {
     get shape() {
@@ -555,11 +555,11 @@ function aborted2(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues2(path, issues) {
+function prefixIssues2(path3, issues) {
   return issues.map((iss) => {
     var _a;
     (_a = iss).path ?? (_a.path = []);
-    iss.path.unshift(path);
+    iss.path.unshift(path3);
     return iss;
   });
 }
@@ -782,7 +782,7 @@ function treeifyError2(error45, _mapper) {
     return issue3.message;
   };
   const result = { errors: [] };
-  const processError = (error46, path = []) => {
+  const processError = (error46, path3 = []) => {
     var _a, _b;
     for (const issue3 of error46.issues) {
       if (issue3.code === "invalid_union" && issue3.errors.length) {
@@ -792,7 +792,7 @@ function treeifyError2(error45, _mapper) {
       } else if (issue3.code === "invalid_element") {
         processError({ issues: issue3.issues }, issue3.path);
       } else {
-        const fullpath = [...path, ...issue3.path];
+        const fullpath = [...path3, ...issue3.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue3));
           continue;
@@ -824,8 +824,8 @@ function treeifyError2(error45, _mapper) {
 }
 function toDotPath2(_path) {
   const segs = [];
-  const path = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path) {
+  const path3 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path3) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -12710,14 +12710,14 @@ __export(exports_eval_capture, {
 });
 import * as fs from "node:fs";
 import * as os from "node:os";
-import * as path from "node:path";
+import * as path3 from "node:path";
 import { getSwarmMailLibSQL } from "swarm-mail";
 function getEvalDataPath(projectPath) {
-  return path.join(projectPath, DEFAULT_EVAL_DATA_PATH);
+  return path3.join(projectPath, DEFAULT_EVAL_DATA_PATH);
 }
 function ensureEvalDataDir(projectPath) {
   const evalPath = getEvalDataPath(projectPath);
-  const dir = path.dirname(evalPath);
+  const dir = path3.dirname(evalPath);
   if (!fs.existsSync(dir)) {
     fs.mkdirSync(dir, { recursive: true });
   }
@@ -12891,10 +12891,10 @@ function getEvalDataStats(projectPath) {
   };
 }
 function getSessionDir() {
-  return process.env.SWARM_SESSIONS_DIR || path.join(os.homedir(), ".config", "swarm-tools", "sessions");
+  return process.env.SWARM_SESSIONS_DIR || path3.join(os.homedir(), ".config", "swarm-tools", "sessions");
 }
 function getSessionPath(sessionId) {
-  return path.join(getSessionDir(), `${sessionId}.jsonl`);
+  return path3.join(getSessionDir(), `${sessionId}.jsonl`);
 }
 function ensureSessionDir() {
   const sessionDir = getSessionDir();
@@ -25594,29 +25594,398 @@ import {
   findCellsByPartialId
 } from "swarm-mail";
 
-// src/utils/normalize-path.ts
-function normalizePath(inputPath) {
-  if (!inputPath) {
-    return "";
-  }
-  let normalized = convertBackslashes(inputPath);
-  normalized = sanitizeDriveLetter(normalized);
-  normalized = removeDoubleSlashes(normalized);
-  return normalized;
-}
-function convertBackslashes(path) {
-  return path.replace(/\\/g, "/");
-}
-function sanitizeDriveLetter(path) {
-  return path.replace(/^([A-Za-z]:)(?=[^/]|$)/, "$1/");
-}
-function removeDoubleSlashes(path) {
-  const isUncPath = path.startsWith("//") && path[2] !== "/";
-  if (isUncPath) {
-    return "//" + path.slice(2).replace(/\/+/g, "/");
+// ../cross-path/dist/normalize.js
+import path2 from "node:path";
+
+// ../cross-path/dist/detect.js
+var cachedEnvironment = null;
+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;
+}
+
+// ../cross-path/dist/validate.js
+import path from "node:path";
+function isAbsolute(inputPath) {
+  return path.win32.isAbsolute(inputPath) || path.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 match = normalized.match(wslUNCPattern);
+  if (!match) {
+    return null;
+  }
+  const distro = match[2];
+  const restPath = match[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;
+}
+
+// ../cross-path/dist/normalize.js
+function normalize(inputPath, options) {
+  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 = options?.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 path2.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 = isAbsolute(intermediate);
+  const driveRelative = isDriveRelative(intermediate);
+  if (!isAbsolutePath && !hasWindowsDrive) {
+    const basePath = options?.basePath ?? process.cwd();
+    const normalizedBase = basePath.replace(/\\/g, "/");
+    if (hasDriveLetter(normalizedBase)) {
+      const drive = normalizedBase.substring(0, 2);
+      const baseRest = normalizedBase.substring(2) || "/";
+      const resolved = path2.posix.resolve(baseRest, intermediate);
+      intermediate = drive + resolved;
+    } else {
+      intermediate = path2.posix.resolve(normalizedBase, intermediate);
+    }
+  } else if (driveRelative) {
+    const pathDrive = intermediate.substring(0, 2).toLowerCase();
+    const pathRest = intermediate.substring(2);
+    const basePath = options?.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 = path2.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 = path2.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 = path2.posix.normalize(rest);
+    intermediate = drive + normalizedRest;
   } else {
-    return path.replace(/\/+/g, "/");
+    intermediate = path2.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, index) => {
+      if (index === 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;
+}
+// src/utils/arg-normalizer.ts
+function toPlainObject(value) {
+  if (typeof value === "string") {
+    try {
+      const parsed = JSON.parse(value);
+      if (parsed && typeof parsed === "object")
+        return parsed;
+    } catch {
+      return { title: value };
+    }
+  }
+  if (value && typeof value === "object")
+    return value;
+  return {};
+}
+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 pick2(obj, keys) {
+  const out = {};
+  for (const k of keys)
+    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 pick2(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 pick2(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 pick2(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 pick2(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 pick2(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 pick2(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 pick2(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 sample = example ? `
+
+Example:
+${example}` : "";
+  return `${toolName}: Invalid arguments.
+${issues}
+
+${guidance}${sample}`;
 }
 
 // src/hive.ts
@@ -26201,6 +26570,25 @@ async function runGitCommand(args) {
   const exitCode = await proc.exited;
   return { exitCode, stdout, stderr };
 }
+async function withRetry(operation, retries = 3, delayMs = 100) {
+  let lastError;
+  for (let attempt = 0;attempt <= retries; attempt++) {
+    try {
+      return await operation();
+    } catch (err) {
+      lastError = err;
+      const message = err instanceof Error ? err.message : String(err);
+      if (attempt < retries && (message.includes("SQLITE_BUSY") || message.includes("SQLITE_BUSY_RECOVERY") || message.includes("database is locked"))) {
+        await new Promise((r) => setTimeout(r, delayMs * (attempt + 1)));
+        continue;
+      }
+      break;
+    }
+  }
+  if (lastError instanceof Error)
+    throw lastError;
+  throw new Error(String(lastError));
+}
 
 class HiveError extends Error {
   command;
@@ -26226,8 +26614,8 @@ class HiveValidationError extends Error {
 }
 var BeadValidationError = HiveValidationError;
 function checkBeadsMigrationNeeded(projectPath) {
-  const beadsDir = normalizePath(join2(projectPath, ".beads"));
-  const hiveDir = normalizePath(join2(projectPath, ".hive"));
+  const beadsDir = normalize(join2(projectPath, ".beads"));
+  const hiveDir = normalize(join2(projectPath, ".hive"));
   if (existsSync2(hiveDir)) {
     return { needed: false };
   }
@@ -26237,8 +26625,8 @@ function checkBeadsMigrationNeeded(projectPath) {
   return { needed: false };
 }
 async function migrateBeadsToHive(projectPath) {
-  const beadsDir = normalizePath(join2(projectPath, ".beads"));
-  const hiveDir = normalizePath(join2(projectPath, ".hive"));
+  const beadsDir = normalize(join2(projectPath, ".beads"));
+  const hiveDir = normalize(join2(projectPath, ".hive"));
   if (existsSync2(hiveDir)) {
     return {
       migrated: false,
@@ -26256,7 +26644,7 @@ async function migrateBeadsToHive(projectPath) {
   return { migrated: true };
 }
 function ensureHiveDirectory(projectPath) {
-  const hiveDir = normalizePath(join2(projectPath, ".hive"));
+  const hiveDir = normalize(join2(projectPath, ".hive"));
   if (!existsSync2(hiveDir)) {
     const { mkdirSync: mkdirSync2 } = __require("node:fs");
     mkdirSync2(hiveDir, { recursive: true });
@@ -26264,9 +26652,9 @@ function ensureHiveDirectory(projectPath) {
 }
 async function mergeHistoricBeads(projectPath) {
   const { readFileSync: readFileSync3, writeFileSync: writeFileSync2, existsSync: existsSync3 } = await import("node:fs");
-  const hiveDir = normalizePath(join2(projectPath, ".hive"));
-  const basePath = normalizePath(join2(hiveDir, "beads.base.jsonl"));
-  const issuesPath = normalizePath(join2(hiveDir, "issues.jsonl"));
+  const hiveDir = normalize(join2(projectPath, ".hive"));
+  const basePath = normalize(join2(hiveDir, "beads.base.jsonl"));
+  const issuesPath = normalize(join2(hiveDir, "issues.jsonl"));
   if (!existsSync3(basePath)) {
     return { merged: 0, skipped: 0 };
   }
@@ -26298,7 +26686,7 @@ async function mergeHistoricBeads(projectPath) {
   writeFileSync2(issuesPath, mergedContent, "utf-8");
   return { merged, skipped };
 }
-async function importJsonlToPGLite(projectPath) {
+async function importJsonlToLibSQL(projectPath) {
   const jsonlPath = join2(projectPath, ".hive", "issues.jsonl");
   if (!existsSync2(jsonlPath)) {
     return { imported: 0, updated: 0, errors: 0 };
@@ -26366,6 +26754,7 @@ async function importJsonlToPGLite(projectPath) {
   }
   return { imported, updated, errors: errors5 };
 }
+var importJsonlToPGLite = importJsonlToLibSQL;
 var adapterCache = new Map;
 var exitHookRegistered = false;
 var exitHookRunning = false;
@@ -26471,7 +26860,19 @@ var hive_create = tool({
     parent_id: tool.schema.string().optional().describe("Parent cell ID for epic children")
   },
   async execute(args, ctx) {
-    const validated = CellCreateArgsSchema.parse(args);
+    const normalized = normalizeCreateArgs(args);
+    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 adapter = await getHiveAdapter(projectKey);
     try {
@@ -26527,7 +26928,20 @@ var hive_create_epic = tool({
     }).optional().describe("Recovery context from checkpoint compaction")
   },
   async execute(args, ctx) {
-    const validated = EpicCreateArgsSchema.parse(args);
+    const normalized = normalizeEpicCreateArgs(args);
+    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 adapter = await getHiveAdapter(projectKey);
     const created = [];
@@ -26550,12 +26964,21 @@ var hive_create_epic = tool({
         await adapter.markDirty(projectKey, subtaskCell.id);
         created.push(subtaskCell);
       }
+      try {
+        const children = await adapter.queryCells(projectKey, { parent_id: epic.id });
+        if (children.length !== validated.subtasks.length) {
+          throw new Error(`Post-create validation failed: expected ${validated.subtasks.length} subtasks, found ${children.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 = args.project_key || projectKey;
+      const effectiveProjectKey = normalized.project_key || projectKey;
       try {
         const epicCreatedEvent = createEvent("epic_created", {
           project_key: effectiveProjectKey,
@@ -26573,16 +26996,16 @@ var hive_create_epic = tool({
         const event = createEvent("decomposition_generated", {
           project_key: effectiveProjectKey,
           epic_id: epic.id,
-          task: args.task || validated.epic_title,
+          task: normalized.task || validated.epic_title,
           context: validated.epic_description,
-          strategy: args.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: args.recovery_context
+          recovery_context: normalized.recovery_context
         });
         await appendEvent(event, effectiveProjectKey);
       } catch (error89) {
@@ -26594,7 +27017,7 @@ var hive_create_epic = tool({
           project_key: effectiveProjectKey,
           epic_id: epic.id,
           epic_title: validated.epic_title,
-          strategy: args.strategy || "feature-based",
+          strategy: normalized.strategy || "feature-based",
           subtask_count: validated.subtasks.length,
           total_files: totalFiles,
           coordinator_agent: "coordinator"
@@ -26619,10 +27042,10 @@ var hive_create_epic = tool({
           decision_type: "decomposition_complete",
           payload: {
             subtask_count: validated.subtasks.length,
-            strategy_used: args.strategy || "feature-based",
+            strategy_used: normalized.strategy || "feature-based",
             files_per_subtask: filesPerSubtask,
             epic_title: validated.epic_title,
-            task: args.task
+            task: normalized.task
           }
         });
       } catch (error89) {
@@ -26678,7 +27101,18 @@ var hive_query = tool({
     limit: tool.schema.number().optional().describe("Max results to return (default: 20)")
   },
   async execute(args, ctx) {
-    const validated = CellQueryArgsSchema.parse(args);
+    const normalized = normalizeQueryArgs(args);
+    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 adapter = await getHiveAdapter(projectKey);
     try {
@@ -26711,20 +27145,32 @@ var hive_update = tool({
     priority: tool.schema.number().min(0).max(3).optional().describe("New priority")
   },
   async execute(args, ctx) {
-    const validated = CellUpdateArgsSchema.parse(args);
+    const normalized = normalizeUpdateArgs(args);
+    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 adapter = await getHiveAdapter(projectKey);
     try {
       const cellId = await resolvePartialId(adapter, projectKey, validated.id) || validated.id;
       let cell;
-      if (validated.status) {
-        cell = await adapter.changeCellStatus(projectKey, cellId, validated.status);
+      if (validated.status !== undefined) {
+        const newStatus = validated.status;
+        cell = await withRetry(() => adapter.changeCellStatus(projectKey, cellId, newStatus));
       }
       if (validated.description !== undefined || validated.priority !== undefined) {
-        cell = await adapter.updateCell(projectKey, cellId, {
+        cell = await withRetry(() => adapter.updateCell(projectKey, cellId, {
           description: validated.description,
           priority: validated.priority
-        });
+        }));
       } else if (!validated.status) {
         const existingCell = await adapter.getCell(projectKey, cellId);
         if (!existingCell) {
@@ -26771,14 +27217,23 @@ var hive_close = tool({
     reason: tool.schema.string().describe("Completion reason")
   },
   async execute(args, ctx) {
-    const validated = CellCloseArgsSchema.parse(args);
+    const normalized = normalizeCloseArgs(args);
+    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 adapter = await getHiveAdapter(projectKey);
     try {
       const cellId = await resolvePartialId(adapter, projectKey, validated.id) || validated.id;
       const cellBeforeClose = await adapter.getCell(projectKey, cellId);
       const isEpic = cellBeforeClose?.type === "epic";
-      const cell = await adapter.closeCell(projectKey, cellId, validated.reason);
+      const cell = await withRetry(() => adapter.closeCell(projectKey, cellId, validated.reason));
       await adapter.markDirty(projectKey, cellId);
       if (isEpic && cellBeforeClose) {
         try {
@@ -26899,7 +27354,7 @@ var hive_start = tool({
     const adapter = await getHiveAdapter(projectKey);
     try {
       const cellId = await resolvePartialId(adapter, projectKey, args.id) || args.id;
-      const cell = await adapter.changeCellStatus(projectKey, cellId, "in_progress");
+      const cell = await withRetry(() => adapter.changeCellStatus(projectKey, cellId, "in_progress"));
       await adapter.markDirty(projectKey, cellId);
       try {
         const event = createEvent("cell_status_changed", {
@@ -26974,16 +27429,17 @@ PREFER THIS OVER hive_query when you need to:
   async execute(args, ctx) {
     const projectKey = getHiveWorkingDirectory();
     const adapter = await getHiveAdapter(projectKey);
+    const normalized = normalizeCellsArgs(args);
     try {
-      if (args.id) {
-        const matchingCells = await findCellsByPartialId(adapter, projectKey, args.id);
+      if (normalized.id) {
+        const matchingCells = await findCellsByPartialId(adapter, projectKey, normalized.id);
         if (matchingCells.length === 0) {
-          throw new HiveError(`No cell found matching ID '${args.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 (args.ready) {
+      if (normalized.ready) {
         const ready = await adapter.getNextReadyCell(projectKey);
         if (!ready) {
           return JSON.stringify([], null, 2);
@@ -26992,10 +27448,10 @@ PREFER THIS OVER hive_query when you need to:
         return JSON.stringify([formatted2], null, 2);
       }
       const cells = await adapter.queryCells(projectKey, {
-        status: args.status,
-        type: args.type,
-        parent_id: args.parent_id,
-        limit: args.limit || 20
+        status: normalized.status,
+        type: normalized.type,
+        parent_id: normalized.parent_id,
+        limit: normalized.limit || 20
       });
       const formatted = cells.map((c) => formatCellForOutput(c));
       return JSON.stringify(formatted, null, 2);
@@ -27005,7 +27461,7 @@ PREFER THIS OVER hive_query when you need to:
       }
       const message = error89 instanceof Error ? error89.message : String(error89);
       if (message.includes("Bead not found") || message.includes("Cell not found")) {
-        throw new HiveError(`No cell found matching ID '${args.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");
     }
@@ -27074,6 +27530,14 @@ var hive_sync = tool({
       const remoteCheckResult2 = await runGitCommand(["remote"]);
       const hasRemote2 = remoteCheckResult2.stdout.trim() !== "";
       if (hasRemote2) {
+        await withTimeout(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;
@@ -27084,9 +27548,13 @@ var hive_sync = tool({
           }
         }
         try {
-          const pullResult = await withTimeout(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 withTimeout(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) {
@@ -27314,6 +27782,7 @@ export {
   migrateBeadsToHive,
   mergeHistoricBeads,
   importJsonlToPGLite,
+  importJsonlToLibSQL,
   hive_update,
   hive_sync,
   hive_start,