@askexenow/exe-os 0.9.341 → 0.9.342

package/dist/{chunk-BJOBR6P2.js → chunk-I26FWCSP.js}

@@ -1,12 +1,73 @@
 import {
   recordOrchestrationEventBestEffort
-} from "./chunk-WH7XN5ER.js";
+} from "./chunk-2WAVZ5UJ.js";
 
 // src/lib/worktree.ts
-import { execSync } from "child_process";
-import { existsSync, readFileSync, appendFileSync, mkdirSync, realpathSync } from "fs";
+import { execFile, execSync } from "child_process";
+import { promisify } from "util";
+import { existsSync, readFileSync, appendFileSync, mkdirSync, realpathSync, statSync } from "fs";
 import path from "path";
 var GIT_TIMEOUT_MS = 1e4;
+var execFileAsync = promisify(execFile);
+async function gitAsync(args, cwd) {
+  const { stdout } = await execFileAsync("git", args, {
+    cwd,
+    encoding: "utf-8",
+    timeout: GIT_TIMEOUT_MS
+  });
+  return String(stdout ?? "");
+}
+function classifyGitFailure(err) {
+  if (!err || typeof err !== "object") return "unavailable";
+  const e = err;
+  if (e.killed === true) return "unavailable";
+  if (typeof e.signal === "string" && e.signal.length > 0) return "unavailable";
+  if (e.code === "ETIMEDOUT" || e.code === "ENOENT") return "unavailable";
+  if (typeof e.status === "number") return "definitive";
+  if (typeof e.code === "number") return "definitive";
+  return "unavailable";
+}
+async function resolveGitWithRetryAsync(run) {
+  for (let attempt = 0; ; attempt++) {
+    try {
+      return await run();
+    } catch (err) {
+      if (classifyGitFailure(err) === "definitive") return null;
+      if (attempt >= 1) return null;
+    }
+  }
+}
+function resolveGitWithRetrySync(run) {
+  for (let attempt = 0; ; attempt++) {
+    try {
+      return run();
+    } catch (err) {
+      if (classifyGitFailure(err) === "definitive") return null;
+      if (attempt >= 1) return null;
+    }
+  }
+}
+function isInsideGitRepo(dir) {
+  let cur;
+  try {
+    cur = path.resolve(dir);
+  } catch {
+    return false;
+  }
+  for (let i = 0; i < 128; i++) {
+    try {
+      statSync(path.join(cur, ".git"));
+      return true;
+    } catch (err) {
+      const code = err?.code;
+      if (code !== "ENOENT" && code !== "ENOTDIR") return true;
+    }
+    const parent = path.dirname(cur);
+    if (parent === cur) break;
+    cur = parent;
+  }
+  return false;
+}
 function getGitRoot(dir) {
   try {
     const root = execSync("git rev-parse --show-toplevel", {
@@ -20,17 +81,31 @@ function getGitRoot(dir) {
     return null;
   }
 }
-function getMainRepoRoot(dir) {
+async function getGitRootAsync(dir) {
   try {
-    const commonDir = execSync(
-      "git rev-parse --path-format=absolute --git-common-dir",
-      { cwd: dir, encoding: "utf-8", timeout: GIT_TIMEOUT_MS, stdio: ["pipe", "pipe", "pipe"] }
-    ).trim();
-    return realpath(path.dirname(commonDir));
+    const root = (await gitAsync(["rev-parse", "--show-toplevel"], dir)).trim();
+    return realpath(root);
   } catch {
     return null;
   }
 }
+function getMainRepoRoot(dir) {
+  const commonDir = resolveGitWithRetrySync(
+    () => execSync(
+      "git rev-parse --path-format=absolute --git-common-dir",
+      { cwd: dir, encoding: "utf-8", timeout: GIT_TIMEOUT_MS, stdio: ["pipe", "pipe", "pipe"] }
+    ).trim()
+  );
+  if (commonDir == null) return null;
+  return realpath(path.dirname(commonDir));
+}
+async function getMainRepoRootAsync(dir) {
+  const commonDir = await resolveGitWithRetryAsync(
+    async () => (await gitAsync(["rev-parse", "--path-format=absolute", "--git-common-dir"], dir)).trim()
+  );
+  if (commonDir == null) return null;
+  return realpath(path.dirname(commonDir));
+}
 function worktreePath(repoRoot, employeeName, instance) {
   const label = instanceLabel(employeeName, instance);
   return path.join(repoRoot, ".worktrees", label);
@@ -165,6 +240,107 @@ function ensureWorktree(projectDir, employeeName, instance) {
     return null;
   }
 }
+async function ensureWorktreeAsync(projectDir, employeeName, instance) {
+  const repoRoot = await getMainRepoRootAsync(projectDir);
+  if (!repoRoot) return null;
+  const wtPath = worktreePath(repoRoot, employeeName, instance);
+  const branch = worktreeBranch(employeeName, instance);
+  if (existsSync(path.join(wtPath, ".git"))) {
+    const currentBranch = await getWorktreeCurrentBranchAsync(wtPath);
+    if (currentBranch !== branch) {
+      recordOrchestrationEventBestEffort({
+        eventType: "worktree.branch_mismatch",
+        source: "worktree.ensureWorktreeAsync",
+        severity: "warn",
+        agentId: employeeName,
+        instanceId: instance != null ? String(instance) : null,
+        payload: { expectedBranch: branch, actualBranch: currentBranch }
+      });
+      if (await isWorktreeDirtyAsync(wtPath)) {
+        process.stderr.write(
+          `[worktree] Refusing to reuse ${wtPath}: expected branch ${branch}, found ${currentBranch ?? "unknown"} with uncommitted changes
+`
+        );
+        return null;
+      }
+      try {
+        await gitAsync(["worktree", "remove", wtPath], repoRoot);
+      } catch (err) {
+        process.stderr.write(
+          `[worktree] Failed to repair branch mismatch for ${employeeName}: ${err instanceof Error ? err.message : String(err)}
+`
+        );
+        return null;
+      }
+    } else {
+      recordOrchestrationEventBestEffort({
+        eventType: "worktree.reused",
+        source: "worktree.ensureWorktreeAsync",
+        agentId: employeeName,
+        instanceId: instance != null ? String(instance) : null,
+        payload: { branch }
+      });
+      return wtPath;
+    }
+  }
+  if (existsSync(path.join(wtPath, ".git")) && await getWorktreeCurrentBranchAsync(wtPath) === branch) {
+    recordOrchestrationEventBestEffort({
+      eventType: "worktree.reused",
+      source: "worktree.ensureWorktreeAsync",
+      agentId: employeeName,
+      instanceId: instance != null ? String(instance) : null,
+      payload: { branch }
+    });
+    return wtPath;
+  }
+  mkdirSync(path.join(repoRoot, ".worktrees"), { recursive: true });
+  ensureGitignoreEntry(repoRoot, "/.worktrees/");
+  try {
+    await gitAsync(["worktree", "prune"], repoRoot);
+  } catch {
+  }
+  const branchExists = await branchExistsLocallyAsync(repoRoot, branch);
+  try {
+    if (branchExists) {
+      await gitAsync(["worktree", "add", wtPath, branch], repoRoot);
+    } else {
+      await gitAsync(["worktree", "add", wtPath, "-b", branch, "HEAD"], repoRoot);
+    }
+    recordOrchestrationEventBestEffort({
+      eventType: "worktree.created",
+      source: "worktree.ensureWorktreeAsync",
+      agentId: employeeName,
+      instanceId: instance != null ? String(instance) : null,
+      payload: { branch, reusedBranch: branchExists }
+    });
+    return wtPath;
+  } catch (err) {
+    if (existsSync(path.join(wtPath, ".git")) && await getWorktreeCurrentBranchAsync(wtPath) === branch) {
+      recordOrchestrationEventBestEffort({
+        eventType: "worktree.reused",
+        source: "worktree.ensureWorktreeAsync",
+        agentId: employeeName,
+        instanceId: instance != null ? String(instance) : null,
+        payload: { branch, raced: true }
+      });
+      return wtPath;
+    }
+    recordOrchestrationEventBestEffort({
+      eventType: "worktree.failed",
+      source: "worktree.ensureWorktreeAsync",
+      severity: "warn",
+      agentId: employeeName,
+      instanceId: instance != null ? String(instance) : null,
+      errorCode: err instanceof Error ? err.name : "worktree_create_failed",
+      payload: { branch }
+    });
+    process.stderr.write(
+      `[worktree] Failed to create worktree for ${employeeName}: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+    return null;
+  }
+}
 function isWorktreeDirty(wtPath) {
   try {
     const status = execSync("git status --porcelain", {
@@ -178,6 +354,13 @@ function isWorktreeDirty(wtPath) {
     return true;
   }
 }
+async function isWorktreeDirtyAsync(wtPath) {
+  try {
+    return (await gitAsync(["status", "--porcelain"], wtPath)).trim().length > 0;
+  } catch {
+    return true;
+  }
+}
 function cleanupWorktree(projectDir, employeeName, instance) {
   const repoRoot = getMainRepoRoot(projectDir);
   if (!repoRoot) return { cleaned: false, reason: "not a git repo" };
@@ -277,6 +460,14 @@ function branchExistsLocally(repoRoot, branch) {
     return false;
   }
 }
+async function branchExistsLocallyAsync(repoRoot, branch) {
+  try {
+    await gitAsync(["rev-parse", "--verify", `refs/heads/${branch}`], repoRoot);
+    return true;
+  } catch {
+    return false;
+  }
+}
 function getWorktreeCurrentBranch(wtPath) {
   try {
     const branch = execSync("git branch --show-current", {
@@ -290,6 +481,14 @@ function getWorktreeCurrentBranch(wtPath) {
     return null;
   }
 }
+async function getWorktreeCurrentBranchAsync(wtPath) {
+  try {
+    const branch = (await gitAsync(["branch", "--show-current"], wtPath)).trim();
+    return branch.length > 0 ? branch : null;
+  } catch {
+    return null;
+  }
+}
 function detectMainBranch(repoRoot) {
   for (const candidate of ["main", "master"]) {
     if (branchExistsLocally(repoRoot, candidate)) return candidate;
@@ -333,12 +532,20 @@ ${entry}
 }
 
 export {
+  classifyGitFailure,
+  resolveGitWithRetryAsync,
+  resolveGitWithRetrySync,
+  isInsideGitRepo,
   getGitRoot,
+  getGitRootAsync,
   getMainRepoRoot,
+  getMainRepoRootAsync,
   worktreePath,
   worktreeBranch,
   parseInstanceLabel,
   ensureWorktree,
+  ensureWorktreeAsync,
   isWorktreeDirty,
+  isWorktreeDirtyAsync,
   cleanupWorktree
 };

package/dist/{chunk-X2FHTDIU.js → chunk-IBYL4DHM.js}

@@ -1,6 +1,6 @@
 import {
   atomicWriteJsonSync
-} from "./chunk-SHIICYJW.js";
+} from "./chunk-BYTDMAGB.js";
 
 // src/lib/mcp-port-config.ts
 import { existsSync, readFileSync } from "fs";

package/dist/{chunk-JCBKARSK.js → chunk-IOEUAQWP.js}

@@ -1,6 +1,6 @@
 import {
   getMasterKey
-} from "./chunk-Z42MXYWW.js";
+} from "./chunk-QWVXN224.js";
 
 // src/lib/monitor-identity.ts
 import crypto from "crypto";

package/dist/{chunk-2UGGBIDL.js → chunk-JGIPOUIK.js}

@@ -3,15 +3,15 @@ import {
   getClient,
   isInitialized,
   loadEmployees
-} from "./chunk-RWSLVYTE.js";
+} from "./chunk-AOHXREB7.js";
 import {
   PLAN_LIMITS,
   checkLicense,
   isFeatureAllowed
-} from "./chunk-7SEC2AG5.js";
+} from "./chunk-PQIDGXSG.js";
 import {
   EXE_AI_DIR
-} from "./chunk-7Y5UDEVM.js";
+} from "./chunk-WZHZCDDO.js";
 
 // src/lib/plan-limits.ts
 import { readFileSync, existsSync } from "fs";

package/dist/{chunk-LLU6WZLK.js → chunk-JLZ4RYSD.js}

@@ -1,10 +1,10 @@
 import {
   enqueueMemory
-} from "./chunk-HCJCW7X4.js";
+} from "./chunk-H7I47RS5.js";
 import {
   isClientConnected,
   sendDaemonRequest
-} from "./chunk-UU4UINUX.js";
+} from "./chunk-G4RGKBCA.js";
 
 // src/lib/memory-queue-client.ts
 async function writeMemoryViaDaemon(entry) {

package/dist/{chunk-WWNQFOSP.js → chunk-JMYHW3AL.js}

@@ -1,9 +1,9 @@
 import {
   sendMessage
-} from "./chunk-2P4WJNN5.js";
+} from "./chunk-KWZMQACA.js";
 import {
   getActiveAgent
-} from "./chunk-C445WRUX.js";
+} from "./chunk-5ERDIOV3.js";
 
 // src/mcp/tools/send-message.ts
 import { z } from "zod";

package/dist/{chunk-KP4PY2Z2.js → chunk-JPUZPAAF.js}

@@ -1,20 +1,20 @@
 import {
   fastDbInit
-} from "./chunk-7YORGTXC.js";
+} from "./chunk-PWUFMX75.js";
 import {
   sessionScopeFilter
-} from "./chunk-KKOLHBNC.js";
+} from "./chunk-UP75Z5X7.js";
 import {
   formatStatusAll,
   formatStatusDeep,
   getEmployeeStatuses,
   inTmux
-} from "./chunk-SSTLTIF3.js";
+} from "./chunk-SKGMF2SO.js";
 import {
   getClient,
   isCoordinatorRole,
   loadEmployees
-} from "./chunk-RWSLVYTE.js";
+} from "./chunk-AOHXREB7.js";
 import {
   isMainModule
 } from "./chunk-6Y4B3QF6.js";

package/dist/{chunk-4LWV633D.js → chunk-JTBIS4R5.js}

@@ -1,6 +1,6 @@
 import {
   loadLicense
-} from "./chunk-7SEC2AG5.js";
+} from "./chunk-PQIDGXSG.js";
 
 // src/lib/stack-update.ts
 import { execFileSync, spawnSync } from "child_process";

package/dist/{chunk-PPZOWQHP.js → chunk-K7KFGDWF.js}

@@ -1,6 +1,6 @@
 import {
   EXE_AI_DIR
-} from "./chunk-7Y5UDEVM.js";
+} from "./chunk-WZHZCDDO.js";
 
 // src/lib/device-registry.ts
 import crypto from "crypto";

package/dist/{chunk-HNLXMD2V.js → chunk-KGWRTRKC.js}

@@ -1,9 +1,9 @@
 import {
   recordOrchestrationEventBestEffort
-} from "./chunk-WH7XN5ER.js";
+} from "./chunk-2WAVZ5UJ.js";
 import {
   atomicWriteJsonSync
-} from "./chunk-SHIICYJW.js";
+} from "./chunk-BYTDMAGB.js";
 
 // src/lib/session-registry.ts
 import { readFileSync, mkdirSync, existsSync, openSync, closeSync, writeSync, unlinkSync, constants } from "fs";

package/dist/{chunk-IB336P52.js → chunk-KP3U5QGJ.js}

@@ -118,7 +118,7 @@ async function executeSendWhatsapp(params) {
   if (!checkOutboundRateLimit("whatsapp")) {
     throw new Error(`Outbound rate limit exceeded for WhatsApp (max ${OUTBOUND_RATE_LIMIT_PER_HOUR}/hour)`);
   }
-  const { getAccountByName, getDefaultAccount } = await import("./whatsapp-accounts-BWRZUY23.js");
+  const { getAccountByName, getDefaultAccount } = await import("./whatsapp-accounts-BFIOXYW5.js");
   const account = params.account ? getAccountByName(params.account) : getDefaultAccount();
   if (!account) {
     throw new Error(

package/dist/{chunk-OUEFW4RK.js → chunk-KW2SD2FL.js}

@@ -1,12 +1,12 @@
 import {
   vectorToSqlLiteral
-} from "./chunk-EDH54E5A.js";
+} from "./chunk-VSRPS3J7.js";
 import {
   blobToVector
 } from "./chunk-OTVEIJUQ.js";
 import {
   getClient
-} from "./chunk-RWSLVYTE.js";
+} from "./chunk-AOHXREB7.js";
 
 // src/lib/behaviors.ts
 import crypto from "crypto";

package/dist/{chunk-2P4WJNN5.js → chunk-KWZMQACA.js}

@@ -4,17 +4,17 @@ import {
   resolveExeSession,
   sendIntercom,
   strictSessionScopeFilter
-} from "./chunk-KKOLHBNC.js";
+} from "./chunk-UP75Z5X7.js";
 import {
   parseMessage,
   serializeMessage
 } from "./chunk-4JERP7NT.js";
 import {
   recordOrchestrationEventBestEffort
-} from "./chunk-WH7XN5ER.js";
+} from "./chunk-2WAVZ5UJ.js";
 import {
   getClient
-} from "./chunk-RWSLVYTE.js";
+} from "./chunk-AOHXREB7.js";
 
 // src/lib/messaging.ts
 import crypto from "crypto";
@@ -45,14 +45,17 @@ function rowToMessage(row) {
   };
 }
 var MAX_RETRIES = 10;
-async function countUnreadMessages(targetAgent, sessionScope) {
-  const client = getClient();
+function buildUnreadMessagesCountStatement(targetAgent, sessionScope) {
   const scope = strictSessionScopeFilter(sessionScope);
-  const result = await client.execute({
+  return {
     sql: `SELECT COUNT(*) AS count FROM messages
           WHERE target_agent = ? AND status IN ('pending', 'delivered')${scope.sql}`,
     args: [targetAgent, ...scope.args]
-  });
+  };
+}
+async function countUnreadMessages(targetAgent, sessionScope) {
+  const client = getClient();
+  const result = await client.execute(buildUnreadMessagesCountStatement(targetAgent, sessionScope));
   return Number(result.rows[0]?.count ?? 0);
 }
 async function sendMessage(input) {
@@ -326,6 +329,7 @@ function parseIncomingMessage(content) {
 }
 
 export {
+  buildUnreadMessagesCountStatement,
   countUnreadMessages,
   sendMessage,
   setWsClientSend,

package/dist/{chunk-ATKW3SYL.js → chunk-L2R3LN2P.js}

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

package/dist/{chunk-IELUDZAA.js → chunk-L4A5DL6Z.js}

@@ -1,13 +1,13 @@
 import {
   isExeSession
-} from "./chunk-KKOLHBNC.js";
+} from "./chunk-UP75Z5X7.js";
 import {
   recordOrchestrationEventBestEffort
-} from "./chunk-WH7XN5ER.js";
+} from "./chunk-2WAVZ5UJ.js";
 import {
   getClient,
   isCoordinatorName
-} from "./chunk-RWSLVYTE.js";
+} from "./chunk-AOHXREB7.js";
 import {
   isDaemonAlive
 } from "./chunk-7HLWBYH7.js";

package/dist/{chunk-2C455MU3.js → chunk-LU2FALL6.js}

@@ -1,6 +1,6 @@
 import {
   loadPreferences
-} from "./chunk-CLAYNAXC.js";
+} from "./chunk-3EUMUSLE.js";
 import {
   EXE_HOOKS,
   isLegacyHomeDirHookCommand,
@@ -8,10 +8,10 @@ import {
 } from "./chunk-L3TB7CC3.js";
 import {
   buildClaudeHttpMcpEntry
-} from "./chunk-4QSJVMMT.js";
+} from "./chunk-GG5NDQNN.js";
 import {
   ensureAllAgentSymlinks
-} from "./chunk-ATKW3SYL.js";
+} from "./chunk-L2R3LN2P.js";
 import {
   MCP_LEGACY_KEY,
   MCP_PRIMARY_KEY

package/dist/{chunk-LOBCQXV5.js → chunk-MKYFAKDW.js}

@@ -1,13 +1,13 @@
 import {
   embed
-} from "./chunk-AP455LBW.js";
+} from "./chunk-XZXBB3TN.js";
 import {
   reserveVersions,
   vectorToBlob
-} from "./chunk-EDH54E5A.js";
+} from "./chunk-VSRPS3J7.js";
 import {
   getClient
-} from "./chunk-RWSLVYTE.js";
+} from "./chunk-AOHXREB7.js";
 
 // src/lib/documents.ts
 import crypto from "crypto";
@@ -270,7 +270,7 @@ async function ingestDocument(input) {
   await client.batch([documentStmt, ...chunkStmts], "write");
   const embedded = vectors.filter((v) => v !== null).length;
   const originalTexts = input.chunks.map((c) => c.text);
-  import("./doc-graph-extractor-LR5KMPH7.js").then(
+  import("./doc-graph-extractor-F6ODFIID.js").then(
     ({ extractAndStoreDocumentGraph }) => extractAndStoreDocumentGraph(documentId, originalTexts)
   ).catch((err) => {
     process.stderr.write(

package/dist/{chunk-3BRVLPPA.js → chunk-MOPUCPXK.js}

@@ -11,6 +11,9 @@ function daemonReadyPath() {
 function eventLoopBlockedMarkerPath() {
   return join(exeDir(), "session-cache", "event-loop-blocked.marker");
 }
+function eventLoopHeartbeatPath() {
+  return join(exeDir(), "session-cache", "event-loop-heartbeat");
+}
 var _readyGeneration;
 function setDaemonReadyGeneration(generation) {
   _readyGeneration = generation;
@@ -58,6 +61,7 @@ function isDaemonReady(maxAgeMs = 3e4) {
 
 export {
   daemonReadyPath,
+  eventLoopHeartbeatPath,
   setDaemonReadyGeneration,
   writeDaemonReady,
   clearDaemonReady,

package/dist/{chunk-BR4423AS.js → chunk-MR6LHP4F.js}

@@ -263,7 +263,7 @@ async function runRegistryProxy(options = registryProxyOptionsFromEnv()) {
   await new Promise((resolve) => server.listen(options.port, options.host, resolve));
   console.log(`exe-registry-proxy listening on ${options.host ?? "0.0.0.0"}:${options.port}`);
   console.log(`proxying /v2/${options.allowedNamespace ?? "askexe"}/* -> ${options.upstream ?? "https://ghcr.io"}`);
-  const { licenseSyncConfigFromEnv, startLicenseSyncScheduler } = await import("./license-sync-UWE6GEB4.js");
+  const { licenseSyncConfigFromEnv, startLicenseSyncScheduler } = await import("./license-sync-N3UJFWAW.js");
   const syncConfig = licenseSyncConfigFromEnv();
   if (syncConfig) {
     startLicenseSyncScheduler(syncConfig);