@askexenow/exe-os 0.9.274 → 0.9.276

package/dist/chunk-UIJKWLFF.js

@@ -0,0 +1,371 @@
+import {
+  getGitRoot,
+  isWorktreeDirty
+} from "./chunk-KLTHMXVE.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-UKQE4PGH.js

@@ -0,0 +1,345 @@
+import {
+  employeeSessionName,
+  isEmployeeAlive,
+  resolveExeSession,
+  sendIntercom,
+  strictSessionScopeFilter
+} from "./chunk-Z73TGBDX.js";
+import {
+  parseMessage,
+  serializeMessage
+} from "./chunk-4JERP7NT.js";
+import {
+  recordOrchestrationEventBestEffort
+} from "./chunk-AU6Q5K6I.js";
+import {
+  getClient
+} from "./chunk-VS7ZTWQR.js";
+
+// src/lib/messaging.ts
+import crypto from "crypto";
+function generateUlid() {
+  const timestamp = Date.now().toString(36).padStart(10, "0");
+  const random = crypto.randomBytes(10).toString("hex").slice(0, 16);
+  return (timestamp + random).toUpperCase();
+}
+function rowToMessage(row) {
+  return {
+    id: row.id,
+    fromAgent: row.from_agent,
+    fromDevice: row.from_device,
+    targetAgent: row.target_agent,
+    targetProject: row.target_project ?? null,
+    targetDevice: row.target_device,
+    sessionScope: row.session_scope ?? null,
+    content: row.content,
+    priority: row.priority ?? "normal",
+    status: row.status ?? "pending",
+    serverSeq: row.server_seq != null ? Number(row.server_seq) : null,
+    retryCount: Number(row.retry_count ?? 0),
+    createdAt: row.created_at,
+    deliveredAt: row.delivered_at ?? null,
+    processedAt: row.processed_at ?? null,
+    failedAt: row.failed_at ?? null,
+    failureReason: row.failure_reason ?? null
+  };
+}
+var MAX_RETRIES = 10;
+async function countUnreadMessages(targetAgent, sessionScope) {
+  const client = getClient();
+  const scope = strictSessionScopeFilter(sessionScope);
+  const result = await client.execute({
+    sql: `SELECT COUNT(*) AS count FROM messages
+          WHERE target_agent = ? AND status IN ('pending', 'delivered')${scope.sql}`,
+    args: [targetAgent, ...scope.args]
+  });
+  return Number(result.rows[0]?.count ?? 0);
+}
+async function sendMessage(input) {
+  const client = getClient();
+  const id = generateUlid();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const targetDevice = input.targetDevice ?? "local";
+  const sessionScope = input.sessionScope === void 0 ? resolveExeSession() : input.sessionScope;
+  await client.execute({
+    sql: `INSERT INTO messages (id, from_agent, from_device, target_agent, target_project, target_device, session_scope, content, priority, status, founder_id, created_at)
+          VALUES (?, ?, 'local', ?, ?, ?, ?, ?, ?, 'pending', ?, ?)`,
+    args: [
+      id,
+      input.fromAgent,
+      input.targetAgent,
+      input.targetProject ?? null,
+      targetDevice,
+      sessionScope,
+      input.content,
+      input.priority ?? "normal",
+      input.founderId ?? null,
+      now
+    ]
+  });
+  recordOrchestrationEventBestEffort({
+    eventType: "message.sent",
+    source: "messaging.sendMessage",
+    agentId: input.fromAgent,
+    payload: { targetAgent: input.targetAgent, priority: input.priority ?? "normal", targetDevice },
+    sessionScope: sessionScope ?? null
+  });
+  try {
+    if (targetDevice !== "local") {
+      await deliverCrossMachineMessage(id, targetDevice);
+    } else {
+      await deliverLocalMessage(id);
+    }
+  } catch {
+  }
+  const sentScope = strictSessionScopeFilter(sessionScope);
+  const result = await client.execute({
+    sql: `SELECT * FROM messages WHERE id = ?${sentScope.sql}`,
+    args: [id, ...sentScope.args]
+  });
+  return rowToMessage(result.rows[0]);
+}
+var _wsClientSend = null;
+function setWsClientSend(fn) {
+  _wsClientSend = fn;
+}
+async function deliverCrossMachineMessage(messageId, targetDevice) {
+  const client = getClient();
+  const result = await client.execute({
+    sql: "SELECT * FROM messages WHERE id = ?",
+    args: [messageId]
+  });
+  if (result.rows.length === 0) return false;
+  const msg = rowToMessage(result.rows[0]);
+  if (msg.status !== "pending") return false;
+  if (!_wsClientSend) {
+    return false;
+  }
+  const payload = JSON.stringify({
+    id: msg.id,
+    fromAgent: msg.fromAgent,
+    targetAgent: msg.targetAgent,
+    targetProject: msg.targetProject,
+    sessionScope: msg.sessionScope,
+    content: msg.content,
+    priority: msg.priority,
+    createdAt: msg.createdAt
+  });
+  const sent = _wsClientSend(targetDevice, payload);
+  if (sent) {
+    await client.execute({
+      sql: "UPDATE messages SET status = 'synced' WHERE id = ?",
+      args: [messageId]
+    });
+    return true;
+  }
+  return false;
+}
+async function deliverLocalMessage(messageId) {
+  const client = getClient();
+  const result = await client.execute({
+    sql: "SELECT * FROM messages WHERE id = ?",
+    args: [messageId]
+  });
+  if (result.rows.length === 0) return false;
+  const msg = rowToMessage(result.rows[0]);
+  if (msg.status !== "pending") return false;
+  const targetAgent = msg.targetAgent;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  try {
+    const exeSession = resolveExeSession();
+    if (!exeSession) {
+      throw new Error("No coordinator session found");
+    }
+    process.stderr.write(`[messaging] ENTER deliverLocal: target=${targetAgent} exeSession=${exeSession}
+`);
+    const { isCoordinatorName: isCoord } = await import("./lib/employees.js");
+    const isCOO = isCoord(targetAgent);
+    process.stderr.write(`[messaging] COO check: targetAgent="${targetAgent}" isCOO=${isCOO}
+`);
+    const sessionName = isCOO ? exeSession : employeeSessionName(targetAgent, exeSession);
+    process.stderr.write(`[messaging] delivery attempt: target=${targetAgent} session=${sessionName} isCOO=${isCOO}
+`);
+    if (!isCOO && !isEmployeeAlive(sessionName)) {
+      throw new Error("Session not running \u2014 message stays queued");
+    }
+    const unreadCount = await countUnreadMessages(targetAgent, msg.sessionScope);
+    if (unreadCount <= 0) {
+      return false;
+    }
+    const intercomResult = sendIntercom(sessionName, { force: true, reason: "message" });
+    process.stderr.write(`[messaging] intercom result for ${sessionName}: ${intercomResult}
+`);
+    await client.execute({
+      sql: "UPDATE messages SET status = 'delivered', delivered_at = ? WHERE id = ?",
+      args: [now, messageId]
+    });
+    recordOrchestrationEventBestEffort({
+      eventType: "message.delivered",
+      source: "messaging.deliverLocalMessage",
+      agentId: msg.targetAgent,
+      payload: { fromAgent: msg.fromAgent, priority: msg.priority }
+    });
+    return true;
+  } catch (err) {
+    process.stderr.write(
+      `[messaging] delivery failed for message ${messageId}: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+    const newRetryCount = msg.retryCount + 1;
+    if (newRetryCount >= MAX_RETRIES) {
+      await markFailed(messageId, "session unavailable after 10 retries", msg.sessionScope);
+    } else {
+      await client.execute({
+        sql: "UPDATE messages SET retry_count = ? WHERE id = ?",
+        args: [newRetryCount, messageId]
+      });
+    }
+    return false;
+  }
+}
+async function getPendingMessages(targetAgent, sessionScope) {
+  const client = getClient();
+  const scope = strictSessionScopeFilter(sessionScope);
+  const result = await client.execute({
+    sql: `SELECT * FROM messages
+          WHERE target_agent = ? AND status IN ('pending', 'delivered')${scope.sql}
+          ORDER BY id`,
+    args: [targetAgent, ...scope.args]
+  });
+  return result.rows.map((row) => rowToMessage(row));
+}
+async function markRead(messageId, sessionScope) {
+  const client = getClient();
+  const scope = strictSessionScopeFilter(sessionScope);
+  await client.execute({
+    sql: `UPDATE messages SET status = 'read'
+          WHERE id = ? AND status IN ('pending', 'delivered')${scope.sql}`,
+    args: [messageId, ...scope.args]
+  });
+  recordOrchestrationEventBestEffort({
+    eventType: "message.read",
+    source: "messaging.markRead",
+    payload: { messageId }
+  });
+}
+async function markAcknowledged(messageId, sessionScope) {
+  const client = getClient();
+  const scope = strictSessionScopeFilter(sessionScope);
+  await client.execute({
+    sql: `UPDATE messages SET status = 'acknowledged', processed_at = ?
+          WHERE id = ? AND status = 'read'${scope.sql}`,
+    args: [(/* @__PURE__ */ new Date()).toISOString(), messageId, ...scope.args]
+  });
+}
+async function markProcessed(messageId, sessionScope) {
+  const client = getClient();
+  const scope = strictSessionScopeFilter(sessionScope);
+  await client.execute({
+    sql: `UPDATE messages SET status = 'processed', processed_at = ?
+          WHERE id = ?${scope.sql}`,
+    args: [(/* @__PURE__ */ new Date()).toISOString(), messageId, ...scope.args]
+  });
+}
+async function getMessageStatus(messageId, sessionScope) {
+  const client = getClient();
+  const scope = strictSessionScopeFilter(sessionScope);
+  const result = await client.execute({
+    sql: `SELECT status FROM messages WHERE id = ?${scope.sql}`,
+    args: [messageId, ...scope.args]
+  });
+  return result.rows[0]?.status ?? null;
+}
+async function getUnacknowledgedMessages(targetAgent, sessionScope) {
+  const client = getClient();
+  const scope = strictSessionScopeFilter(sessionScope);
+  const result = await client.execute({
+    sql: `SELECT * FROM messages
+          WHERE target_agent = ? AND status IN ('pending', 'delivered', 'read')${scope.sql}
+          ORDER BY id`,
+    args: [targetAgent, ...scope.args]
+  });
+  return result.rows.map((row) => rowToMessage(row));
+}
+async function getReadMessages(targetAgent, sessionScope) {
+  const client = getClient();
+  const scope = strictSessionScopeFilter(sessionScope);
+  const result = await client.execute({
+    sql: `SELECT * FROM messages
+          WHERE target_agent = ? AND status = 'read'${scope.sql}
+          ORDER BY id`,
+    args: [targetAgent, ...scope.args]
+  });
+  return result.rows.map((row) => rowToMessage(row));
+}
+async function markFailed(messageId, reason, sessionScope) {
+  const client = getClient();
+  const scope = strictSessionScopeFilter(sessionScope);
+  await client.execute({
+    sql: `UPDATE messages SET status = 'failed', failed_at = ?, failure_reason = ?
+          WHERE id = ?${scope.sql}`,
+    args: [(/* @__PURE__ */ new Date()).toISOString(), reason, messageId, ...scope.args]
+  });
+}
+async function getFailedMessages(sessionScope) {
+  const client = getClient();
+  const scope = strictSessionScopeFilter(sessionScope);
+  const result = await client.execute({
+    sql: `SELECT * FROM messages WHERE status = 'failed'${scope.sql} ORDER BY created_at DESC`,
+    args: [...scope.args]
+  });
+  return result.rows.map((row) => rowToMessage(row));
+}
+async function retryPendingMessages(sessionScope) {
+  const client = getClient();
+  const scope = strictSessionScopeFilter(sessionScope);
+  const result = await client.execute({
+    sql: `SELECT * FROM messages
+          WHERE status = 'pending' AND retry_count < ?${scope.sql}
+          ORDER BY id`,
+    args: [MAX_RETRIES, ...scope.args]
+  });
+  let delivered = 0;
+  for (const row of result.rows) {
+    const msg = rowToMessage(row);
+    try {
+      const success = await deliverLocalMessage(msg.id);
+      if (success) delivered++;
+    } catch {
+    }
+  }
+  return delivered;
+}
+async function sendTypedMessage(envelope, targetAgent, opts) {
+  return sendMessage({
+    fromAgent: envelope.from,
+    targetAgent,
+    targetProject: opts?.targetProject,
+    targetDevice: opts?.targetDevice,
+    content: serializeMessage(envelope),
+    priority: opts?.priority,
+    sessionScope: opts?.sessionScope
+  });
+}
+function parseIncomingMessage(content) {
+  return parseMessage(content);
+}
+
+export {
+  countUnreadMessages,
+  sendMessage,
+  setWsClientSend,
+  deliverLocalMessage,
+  getPendingMessages,
+  markRead,
+  markAcknowledged,
+  markProcessed,
+  getMessageStatus,
+  getUnacknowledgedMessages,
+  getReadMessages,
+  markFailed,
+  getFailedMessages,
+  retryPendingMessages,
+  sendTypedMessage,
+  parseIncomingMessage
+};