@askexenow/exe-os 0.9.255 → 0.9.259

package/dist/{chunk-JGEGEOVP.js → chunk-COKTAJUZ.js}

@@ -1,7 +1,7 @@
 import {
   getCurrentSessionScope,
   strictSessionScopeFilter
-} from "./chunk-CS267UMH.js";
+} from "./chunk-5LDTCWYX.js";
 import {
   getProjectName
 } from "./chunk-OPU3NYOO.js";

package/dist/{chunk-MRZE5IOP.js → chunk-CXOX7TRG.js}

@@ -1,6 +1,6 @@
 import {
   loadEmployeesSync
-} from "./chunk-5U7WB4YG.js";
+} from "./chunk-WVBZ3QBR.js";
 
 // src/adapters/mcp-http-config.ts
 import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";

package/dist/{chunk-6LFFIEDM.js → chunk-DU64OESH.js}

@@ -1,6 +1,6 @@
 import {
   recordOrchestrationEventBestEffort
-} from "./chunk-USLVSLQ5.js";
+} from "./chunk-VDCPKJUQ.js";
 
 // src/lib/worktree.ts
 import { execSync } from "child_process";

package/dist/{chunk-LYIUESG2.js → chunk-DYURFBPS.js}

@@ -3,10 +3,10 @@ import {
   buildRawVisibilityFilter,
   buildWikiScopeFilter,
   searchMemories
-} from "./chunk-PSQNT5DS.js";
+} from "./chunk-AQS2B3HC.js";
 import {
   getClient
-} from "./chunk-5U7WB4YG.js";
+} from "./chunk-WVBZ3QBR.js";
 
 // src/lib/hybrid-search.ts
 var RRF_K = 60;
@@ -288,7 +288,7 @@ async function hybridSearch(queryText, agentId, options) {
   let rerankerAvailable = false;
   if (process.env.EXE_IS_DAEMON === "1") {
     try {
-      const { isRerankerAvailable } = await import("./reranker-SRJL4IWB.js");
+      const { isRerankerAvailable } = await import("./reranker-DN2A3H6O.js");
       rerankerAvailable = isRerankerAvailable();
     } catch {
     }
@@ -343,7 +343,7 @@ async function hybridSearch(queryText, agentId, options) {
     ]).catch(() => []),
     includeStructuredCards ? (async () => {
       try {
-        const { searchMemoryCards } = await import("./memory-cards-3SFXU6IP.js");
+        const { searchMemoryCards } = await import("./memory-cards-ZOOPC2WF.js");
         return await searchMemoryCards(effectiveQuery, agentId, fetchOptions);
       } catch {
         return [];
@@ -352,7 +352,7 @@ async function hybridSearch(queryText, agentId, options) {
     // Reflection insights: patterns, contradictions, summaries across sessions
     includeStructuredCards ? (async () => {
       try {
-        const { searchReflections } = await import("./memory-reflection-YPP2JC2S.js");
+        const { searchReflections } = await import("./memory-reflection-GSGXAGXV.js");
         const insights = await searchReflections(effectiveQuery, agentId, 5);
         return insights.map((ins) => ({
           id: ins.id,
@@ -428,7 +428,7 @@ async function hybridSearch(queryText, agentId, options) {
   let entityBoostRan = false;
   if (merged.length > 0) {
     try {
-      const { applyEntityBoost } = await import("./entity-boost-RTYXAOWV.js");
+      const { applyEntityBoost } = await import("./entity-boost-OAB2PZQP.js");
       const boosted = await applyEntityBoost(merged, effectiveQuery, getClient());
       merged = boosted.results;
       graphContextMap = boosted.graphContext;
@@ -452,7 +452,7 @@ async function hybridSearch(queryText, agentId, options) {
     try {
       let rerankedRecords;
       if (graphContextMap.size > 0) {
-        const { rerankWithContext } = await import("./reranker-SRJL4IWB.js");
+        const { rerankWithContext } = await import("./reranker-DN2A3H6O.js");
         const candidates = merged.map((m) => ({
           text: m.raw_text,
           context: graphContextMap.get(m.id)
@@ -460,7 +460,7 @@ async function hybridSearch(queryText, agentId, options) {
         const scored = await rerankWithContext(effectiveQuery, candidates, rerankReturnLimit);
         rerankedRecords = scored.map((s) => merged[s.index]);
       } else {
-        const { rerank } = await import("./reranker-SRJL4IWB.js");
+        const { rerank } = await import("./reranker-DN2A3H6O.js");
         rerankedRecords = await rerank(effectiveQuery, merged, rerankReturnLimit);
       }
       if (rerankedRecords.length > 0) {
@@ -785,7 +785,7 @@ async function lightweightSearch(queryText, agentId, options) {
   }
   if (results.length >= 2) {
     try {
-      const { recordCoActivations } = await import("./co-activation-AIVMI5U2.js");
+      const { recordCoActivations } = await import("./co-activation-UNVL5JCP.js");
       const ids = results.slice(0, 10).map((r) => r.id);
       void recordCoActivations(ids);
     } catch {
@@ -793,7 +793,7 @@ async function lightweightSearch(queryText, agentId, options) {
   }
   if (options?.includeStructuredCards !== true) return results;
   try {
-    const { searchMemoryCards } = await import("./memory-cards-3SFXU6IP.js");
+    const { searchMemoryCards } = await import("./memory-cards-ZOOPC2WF.js");
     const cardResults = await searchMemoryCards(queryText, agentId, options);
     if (cardResults.length > 0) {
       return rrfMergeMulti([results, cardResults], limit, RRF_K, [1, 0.85]);

package/dist/{chunk-X3SS45PO.js → chunk-FPXZY3FY.js}

@@ -1,6 +1,6 @@
 import {
   getGlobalProceduresBlock
-} from "./chunk-FTNNNAMH.js";
+} from "./chunk-5JYCTIQD.js";
 
 // src/lib/employee-templates.ts
 var BASE_OPERATING_PROCEDURES = `

package/dist/{chunk-TVTRMINO.js → chunk-FUGZF7VR.js}

@@ -1,6 +1,6 @@
 import {
   getClient
-} from "./chunk-5U7WB4YG.js";
+} from "./chunk-WVBZ3QBR.js";
 
 // src/lib/token-spend.ts
 import { readdir, stat } from "fs/promises";

package/dist/{chunk-O7SFCX5B.js → chunk-GB4FI66P.js}

@@ -1,9 +1,9 @@
 import {
   getActiveAgent
-} from "./chunk-VGWQBI76.js";
+} from "./chunk-GBR4MAAK.js";
 import {
   listTasks
-} from "./chunk-CS267UMH.js";
+} from "./chunk-5LDTCWYX.js";
 
 // src/mcp/tools/list-tasks.ts
 import { z } from "zod";

package/dist/{chunk-VGWQBI76.js → chunk-GBR4MAAK.js}

@@ -9,7 +9,7 @@ import {
   getCoordinatorEmployee,
   getEmployee,
   loadEmployeesSync
-} from "./chunk-5U7WB4YG.js";
+} from "./chunk-WVBZ3QBR.js";
 import {
   EXE_AI_DIR
 } from "./chunk-VXIMSRTO.js";

package/dist/chunk-GH4LVBQM.js

@@ -0,0 +1,371 @@
+import {
+  getGitRoot,
+  isWorktreeDirty
+} from "./chunk-DU64OESH.js";
+
+// src/lib/worktree-sweep.ts
+import { execSync } from "child_process";
+import { existsSync, readdirSync, readFileSync } from "fs";
+import path from "path";
+function isWorktreeUnpushed(wtPath, branch) {
+  if (!branch) return false;
+  try {
+    const remote = execSync(`git -C "${wtPath}" rev-parse --abbrev-ref "${branch}@{upstream}" 2>/dev/null`, { encoding: "utf-8" }).trim();
+    if (!remote) return true;
+    const ahead = execSync(`git -C "${wtPath}" rev-list "${remote}..${branch}" --count 2>/dev/null`, { encoding: "utf-8" }).trim();
+    return parseInt(ahead, 10) > 0;
+  } catch {
+    try {
+      const ahead = execSync(`git -C "${wtPath}" rev-list "main..${branch}" --count 2>/dev/null || git -C "${wtPath}" rev-list "master..${branch}" --count 2>/dev/null`, { encoding: "utf-8" }).trim();
+      return parseInt(ahead, 10) > 0;
+    } catch {
+      return true;
+    }
+  }
+}
+var REPO_ALIASES = {
+  "exe-crm": ["openclaw", "exe-crm"],
+  "exe-wiki": ["ink", "exe-wiki"]
+};
+function discoverRepoPaths() {
+  const roots = [];
+  let exeOsRoot = null;
+  let dir = path.dirname(new URL(import.meta.url).pathname);
+  for (let i = 0; i < 5; i++) {
+    const pkgPath = path.join(dir, "package.json");
+    if (existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+        if (pkg.name === "@askexenow/exe-os") {
+          exeOsRoot = dir;
+          break;
+        }
+      } catch {
+      }
+    }
+    dir = path.dirname(dir);
+  }
+  if (!exeOsRoot) {
+    exeOsRoot = process.cwd();
+  }
+  roots.push(exeOsRoot);
+  const parentDir = path.dirname(exeOsRoot);
+  try {
+    const siblings = readdirSync(parentDir);
+    for (const sibling of siblings) {
+      if (sibling.startsWith(".")) continue;
+      const siblingPath = path.join(parentDir, sibling);
+      if (siblingPath === exeOsRoot) continue;
+      const root = getGitRoot(siblingPath);
+      if (root && !roots.includes(root)) {
+        roots.push(root);
+      }
+    }
+  } catch {
+  }
+  for (const aliases of Object.values(REPO_ALIASES)) {
+    for (const alias of aliases) {
+      const aliasPath = path.join(parentDir, alias);
+      if (existsSync(aliasPath)) {
+        const root = getGitRoot(aliasPath);
+        if (root && !roots.includes(root)) {
+          roots.push(root);
+        }
+      }
+    }
+  }
+  return roots;
+}
+var GIT_TIMEOUT_MS = 1e4;
+function listWorktrees(repoRoot) {
+  try {
+    const output = execSync("git worktree list --porcelain", {
+      cwd: repoRoot,
+      encoding: "utf8",
+      timeout: GIT_TIMEOUT_MS,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    const worktrees = [];
+    let currentPath = "";
+    for (const line of output.split("\n")) {
+      if (line.startsWith("worktree ")) {
+        currentPath = line.slice("worktree ".length);
+      } else if (line.startsWith("branch ") && currentPath) {
+        const branch = line.slice("branch refs/heads/".length);
+        worktrees.push({ path: currentPath, branch });
+        currentPath = "";
+      }
+    }
+    return worktrees;
+  } catch {
+    return [];
+  }
+}
+function detectMainBranch(repoRoot) {
+  for (const candidate of ["main", "master"]) {
+    try {
+      execSync(`git rev-parse --verify "refs/heads/${candidate}"`, {
+        cwd: repoRoot,
+        encoding: "utf8",
+        timeout: GIT_TIMEOUT_MS,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      return candidate;
+    } catch {
+    }
+  }
+  return null;
+}
+function isBranchMerged(repoRoot, branch, into) {
+  try {
+    const merged = execSync(`git branch --merged "${into}"`, {
+      cwd: repoRoot,
+      encoding: "utf8",
+      timeout: GIT_TIMEOUT_MS,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return merged.split("\n").map((l) => l.replace(/^[*+]?\s+/, "").trim()).includes(branch);
+  } catch {
+    return false;
+  }
+}
+function hasLiveTmuxSession(agentName) {
+  try {
+    const sessions = execSync("tmux list-sessions -F '#S' 2>/dev/null", {
+      encoding: "utf8",
+      timeout: 5e3,
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    if (!sessions) return false;
+    for (const session of sessions.split("\n")) {
+      const agentPart = session.split("-")[0];
+      if (!agentPart) continue;
+      const baseName = agentPart.replace(/\d+$/, "");
+      if (baseName === agentName || agentPart === agentName) return true;
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+function removeWorktree(repoRoot, wtPath) {
+  try {
+    execSync(`git worktree remove ${JSON.stringify(wtPath)} --force`, {
+      cwd: repoRoot,
+      encoding: "utf8",
+      timeout: GIT_TIMEOUT_MS,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function deleteBranch(repoRoot, branch) {
+  try {
+    execSync(`git branch -D ${JSON.stringify(branch)}`, {
+      cwd: repoRoot,
+      encoding: "utf8",
+      timeout: GIT_TIMEOUT_MS,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function deleteRemoteBranch(repoRoot, branch) {
+  try {
+    execSync(`git push origin --delete ${JSON.stringify(branch)}`, {
+      cwd: repoRoot,
+      encoding: "utf8",
+      timeout: 15e3,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function pruneWorktreeRegistry(repoRoot) {
+  try {
+    execSync("git worktree prune", {
+      cwd: repoRoot,
+      encoding: "utf8",
+      timeout: GIT_TIMEOUT_MS,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+  } catch {
+  }
+}
+function clearStashes(repoRoot) {
+  try {
+    const stashList = execSync("git stash list", {
+      cwd: repoRoot,
+      encoding: "utf8",
+      timeout: GIT_TIMEOUT_MS,
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    if (!stashList) return 0;
+    const count = stashList.split("\n").length;
+    execSync("git stash clear", {
+      cwd: repoRoot,
+      encoding: "utf8",
+      timeout: GIT_TIMEOUT_MS,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return count;
+  } catch {
+    return 0;
+  }
+}
+function parseAgentName(wtPath) {
+  const dirName = path.basename(wtPath);
+  if (!dirName) return null;
+  return dirName.replace(/\d+$/, "") || dirName;
+}
+async function sweepWorktrees(options = {}) {
+  const dryRun = options.dryRun ?? false;
+  const repoPaths = options.repoPaths ?? discoverRepoPaths();
+  const result = {
+    reposScanned: 0,
+    removed: [],
+    branchesDeleted: [],
+    stashesCleared: 0,
+    skipped: [],
+    errors: []
+  };
+  for (const repoPath of repoPaths) {
+    const repoRoot = getGitRoot(repoPath);
+    if (!repoRoot) continue;
+    result.reposScanned++;
+    const repoName = path.basename(repoRoot);
+    const mainBranch = detectMainBranch(repoRoot);
+    if (!dryRun) {
+      pruneWorktreeRegistry(repoRoot);
+    }
+    const worktrees = listWorktrees(repoRoot);
+    for (const wt of worktrees) {
+      if (!wt.path.includes("/.worktrees/")) continue;
+      const agentName = parseAgentName(wt.path);
+      const wtName = path.basename(wt.path);
+      if (agentName && hasLiveTmuxSession(agentName)) {
+        result.skipped.push({
+          repo: repoName,
+          worktree: wtName,
+          branch: wt.branch,
+          reason: "live tmux session"
+        });
+        continue;
+      }
+      if (existsSync(wt.path) && isWorktreeDirty(wt.path)) {
+        result.skipped.push({
+          repo: repoName,
+          worktree: wtName,
+          branch: wt.branch,
+          reason: "uncommitted changes"
+        });
+        continue;
+      }
+      if (existsSync(wt.path) && isWorktreeUnpushed(wt.path, wt.branch)) {
+        result.skipped.push({
+          repo: repoName,
+          worktree: wtName,
+          branch: wt.branch,
+          reason: "unpushed commits \u2014 push first or use --force"
+        });
+        continue;
+      }
+      const isMerged = mainBranch ? isBranchMerged(repoRoot, wt.branch, mainBranch) : false;
+      if (dryRun) {
+        result.removed.push({ repo: repoName, worktree: wtName, branch: wt.branch });
+        if (isMerged || !mainBranch) {
+          result.branchesDeleted.push({ repo: repoName, branch: wt.branch, remote: true });
+        } else {
+          result.branchesDeleted.push({ repo: repoName, branch: wt.branch, remote: false });
+        }
+        continue;
+      }
+      const removed = removeWorktree(repoRoot, wt.path);
+      if (!removed) {
+        result.errors.push(`${repoName}: failed to remove worktree ${wtName}`);
+        continue;
+      }
+      result.removed.push({ repo: repoName, worktree: wtName, branch: wt.branch });
+      process.stderr.write(`[worktree-sweep] Removed ${repoName}/.worktrees/${wtName} (branch: ${wt.branch})
+`);
+      const localDeleted = deleteBranch(repoRoot, wt.branch);
+      let remoteDeleted = false;
+      if (localDeleted) {
+        remoteDeleted = deleteRemoteBranch(repoRoot, wt.branch);
+      }
+      if (localDeleted) {
+        result.branchesDeleted.push({ repo: repoName, branch: wt.branch, remote: remoteDeleted });
+      }
+    }
+    if (!dryRun) {
+      const cleared = clearStashes(repoRoot);
+      if (cleared > 0) {
+        result.stashesCleared += cleared;
+        process.stderr.write(`[worktree-sweep] Cleared ${cleared} stash(es) in ${repoName}
+`);
+      }
+    }
+    if (!dryRun) {
+      pruneWorktreeRegistry(repoRoot);
+    }
+  }
+  return result;
+}
+function cleanupAgentWorktree(repoRoot, agentName) {
+  const worktreesDir = path.join(repoRoot, ".worktrees");
+  if (!existsSync(worktreesDir)) return "";
+  const notes = [];
+  try {
+    const entries = readdirSync(worktreesDir);
+    for (const entry of entries) {
+      const baseName = entry.replace(/\d+$/, "") || entry;
+      const agentBase = agentName.replace(/\d+$/, "") || agentName;
+      if (baseName !== agentBase) continue;
+      const wtPath = path.join(worktreesDir, entry);
+      const branch = getWorktreeBranch(repoRoot, wtPath);
+      if (isWorktreeDirty(wtPath)) {
+        notes.push(`Worktree .worktrees/${entry} has uncommitted changes \u2014 preserved`);
+        continue;
+      }
+      if (isWorktreeUnpushed(wtPath, branch)) {
+        notes.push(`Worktree .worktrees/${entry} has unpushed commits \u2014 preserved`);
+        continue;
+      }
+      if (removeWorktree(repoRoot, wtPath)) {
+        notes.push(`Removed worktree .worktrees/${entry}`);
+        if (branch && deleteBranch(repoRoot, branch)) {
+          notes.push(`Deleted branch ${branch}`);
+          if (deleteRemoteBranch(repoRoot, branch)) {
+            notes.push(`Deleted remote branch ${branch}`);
+          }
+        }
+      }
+    }
+  } catch {
+  }
+  pruneWorktreeRegistry(repoRoot);
+  return notes.join("\n");
+}
+function getWorktreeBranch(repoRoot, wtPath) {
+  try {
+    const worktrees = listWorktrees(repoRoot);
+    for (const wt of worktrees) {
+      if (wt.path === wtPath) return wt.branch;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+export {
+  discoverRepoPaths,
+  sweepWorktrees,
+  cleanupAgentWorktree
+};

package/dist/{chunk-AIXZ5O7U.js → chunk-GIHMDOSK.js}

@@ -2,7 +2,7 @@ import {
   getClient,
   isCoordinatorName,
   loadEmployeesSync
-} from "./chunk-5U7WB4YG.js";
+} from "./chunk-WVBZ3QBR.js";
 
 // src/lib/steward-gate.ts
 import crypto from "crypto";

package/dist/{chunk-RDCE652I.js → chunk-HDWVXSGO.js}

@@ -111,7 +111,7 @@ function releaseBackfillLock() {
 }
 async function getTaskAwareCapacity() {
   const { getClient } = await import("./lib/database.js");
-  const { sessionScopeFilter } = await import("./task-scope-XKNAY5S7.js");
+  const { sessionScopeFilter } = await import("./task-scope-AKF3CSWO.js");
   const client = getClient();
   const scope = sessionScopeFilter();
   const result = await client.execute({

package/dist/{chunk-RF54NGPJ.js → chunk-IJ7R3MXE.js}

@@ -1,16 +1,16 @@
 import {
   extractMemoryGraph
-} from "./chunk-X4T7LR2X.js";
+} from "./chunk-M7PZFYHE.js";
 import {
   flushBatch,
   writeMemory
-} from "./chunk-PSQNT5DS.js";
+} from "./chunk-AQS2B3HC.js";
 import {
   extractKeywords
 } from "./chunk-CHCA3ZM2.js";
 import {
   getActiveAgent
-} from "./chunk-VGWQBI76.js";
+} from "./chunk-GBR4MAAK.js";
 
 // src/mcp/tools/import-conversations.ts
 import { z } from "zod";
@@ -303,7 +303,6 @@ function registerImportConversations(server) {
       }
       let stored = 0;
       let skipped = 0;
-      let errors = 0;
       for (let i = 0; i < allMemories.length; i++) {
         const memory = allMemories[i];
         try {
@@ -365,7 +364,6 @@ function registerImportConversations(server) {
   Conversations: ${conversationCount} (${formatSummary})
   Memories stored: ${stored}
   Duplicates skipped: ${skipped}
-  Errors: ${errors}
   Agent: ${agentId}
   Project: ${projectName}`
         }]

package/dist/{chunk-R7FBOZT5.js → chunk-ISL3NSVX.js}

@@ -1,6 +1,6 @@
 import {
   loadEmployees
-} from "./chunk-5U7WB4YG.js";
+} from "./chunk-WVBZ3QBR.js";
 
 // src/lib/agent-symlinks.ts
 import os from "os";

package/dist/{chunk-5B2AEXVA.js → chunk-IVSRRIRG.js}

@@ -1,7 +1,7 @@
 import {
   clean,
   stableId
-} from "./chunk-Y2FVN7CX.js";
+} from "./chunk-EYLQRPHF.js";
 
 // src/lib/reflection-checkpoints.ts
 function parsePayload(payload) {

package/dist/{chunk-SD2R3SEA.js → chunk-J3YNCJ4A.js}

@@ -1,6 +1,6 @@
 import {
   recordOrchestrationEventBestEffort
-} from "./chunk-USLVSLQ5.js";
+} from "./chunk-VDCPKJUQ.js";
 
 // src/lib/session-registry.ts
 import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";

package/dist/{chunk-5IZYSS3M.js → chunk-JE4C74EE.js}

@@ -1,6 +1,6 @@
 import {
   isCrdtSyncEnabled
-} from "./chunk-FCII2MMI.js";
+} from "./chunk-J5CAYOJU.js";
 import {
   decryptSyncBlob,
   encryptSyncBlob,
@@ -12,7 +12,7 @@ import {
   loadEmployees,
   registerBinSymlinks,
   saveEmployees
-} from "./chunk-5U7WB4YG.js";
+} from "./chunk-WVBZ3QBR.js";
 import {
   loadDeviceId
 } from "./chunk-MOZ2YQ54.js";
@@ -521,7 +521,7 @@ async function cloudSync(config) {
     let pulled = 0;
     if (pullResult.records.length > 0) {
       if (shouldUseCrdtMergeForCloudSync()) {
-        const { initCrdtDoc, importExistingMemories, readAllMemories } = await import("./crdt-sync-YBMDPFNT.js");
+        const { initCrdtDoc, importExistingMemories, readAllMemories } = await import("./crdt-sync-AH7N6QOE.js");
         initCrdtDoc();
         importExistingMemories(
           pullResult.records.map((rec) => ({
@@ -953,7 +953,7 @@ async function cloudSync(config) {
     }
     const totalMemories = await countRows("SELECT COUNT(*) as cnt FROM memories WHERE status = 'active' OR status IS NULL");
     try {
-      const { getLatestBackup } = await import("./db-backup-7UMCTS44.js");
+      const { getLatestBackup } = await import("./db-backup-2RG6VHT7.js");
       const latestBackup = getLatestBackup();
       if (latestBackup) {
         const backupSize = statSync(latestBackup).size;

package/dist/{chunk-VRVHIVUE.js → chunk-KSR2PNRW.js}

@@ -1,10 +1,10 @@
 import {
   initStore
-} from "./chunk-PSQNT5DS.js";
+} from "./chunk-AQS2B3HC.js";
 import {
   getClient,
   isInitialized
-} from "./chunk-5U7WB4YG.js";
+} from "./chunk-WVBZ3QBR.js";
 
 // src/lib/schedules.ts
 import crypto from "crypto";

package/dist/{chunk-LL2ARYTZ.js → chunk-L3PY4NFQ.js}

@@ -1,6 +1,6 @@
 import {
   createReminder
-} from "./chunk-2YJSDJEH.js";
+} from "./chunk-TZPHTI5Q.js";
 
 // src/mcp/tools/create-reminder.ts
 import { z } from "zod";

package/dist/{chunk-VFATLVRX.js → chunk-L5VPUOB6.js}

@@ -3,7 +3,7 @@ import {
   getClient,
   isInitialized,
   loadEmployees
-} from "./chunk-5U7WB4YG.js";
+} from "./chunk-WVBZ3QBR.js";
 import {
   PLAN_LIMITS,
   checkLicense,