@desplega.ai/agent-swarm 1.113.0 → 1.115.0

package/dist/cli-86fdnerz.js

@@ -0,0 +1,405 @@
+import {
+  init_zod
+} from "./cli-bw80ck94.js";
+import {
+  _enum
+} from "./cli-xz9aq0rf.js";
+
+// src/rbac/permissions.ts
+init_zod();
+var PERMISSIONS = {
+  "user.manage": {
+    description: "Create, update, or deactivate user profiles.",
+    namespace: "user"
+  },
+  "agent.profile.update.any": {
+    description: "Update another agent's profile.",
+    namespace: "agent"
+  },
+  "agent.context.read.any": {
+    description: "View or diff another agent's context history.",
+    namespace: "agent"
+  },
+  "task.cancel.any": {
+    description: "Cancel any task (beyond tasks the caller created).",
+    namespace: "task"
+  },
+  "task.create.own": {
+    description: "Create a task the caller owns.",
+    namespace: "task"
+  },
+  "task.read.own": {
+    description: "Read details of a task the principal requested.",
+    namespace: "task"
+  },
+  "task.cancel.own": {
+    description: "Cancel a task the principal requested.",
+    namespace: "task"
+  },
+  "task.action.own": {
+    description: "Run actions (follow-up, retry, ...) on a task the principal requested.",
+    namespace: "task"
+  },
+  "task.fs.mutate": {
+    description: "Mutate a task's filesystem artifacts and attachments.",
+    namespace: "task"
+  },
+  "favorite.write.own": {
+    description: "Set a favorite the caller owns.",
+    namespace: "favorite"
+  },
+  "memory.learning.inject": {
+    description: "Inject a learning into another agent's memory.",
+    namespace: "memory"
+  },
+  "memory.delete.any": {
+    description: "Delete a memory entry (own entries, or swarm-scoped entries as lead).",
+    namespace: "memory"
+  },
+  "channel.delete": {
+    description: "Delete a Slack channel.",
+    namespace: "channel"
+  },
+  "integration.kapso.manage": {
+    description: "Register or unregister a Kapso inbound number.",
+    namespace: "integration"
+  },
+  "integration.slack.post": {
+    description: "Post to a direct Slack channel.",
+    namespace: "integration"
+  },
+  "integration.slack.read": {
+    description: "Read a direct Slack channel.",
+    namespace: "integration"
+  },
+  "integration.slack.thread.start": {
+    description: "Start a thread in a direct Slack channel.",
+    namespace: "integration"
+  },
+  "integration.slack.upload": {
+    description: "Upload a file to a direct Slack channel.",
+    namespace: "integration"
+  },
+  "integration.slack.delete": {
+    description: "Delete a Slack message.",
+    namespace: "integration"
+  },
+  "integration.slack.update": {
+    description: "Update (edit) a Slack message.",
+    namespace: "integration"
+  },
+  "credential-binding.manage": {
+    description: "Manage script credential bindings.",
+    namespace: "credential-binding"
+  },
+  "script-connection.manage": {
+    description: "Manage script connections.",
+    namespace: "script-connection"
+  },
+  "script-connection.invoke": {
+    description: "Invoke a script MCP connection through the server-side proxy.",
+    namespace: "script-connection"
+  },
+  "config.credential-bindings.write": {
+    description: "Write the SCRIPT_CREDENTIAL_BINDINGS swarm-config key.",
+    namespace: "config"
+  },
+  "config.write.any": {
+    description: "Write any swarm-config key.",
+    namespace: "config"
+  },
+  "config.delete.any": {
+    description: "Delete any swarm-config entry.",
+    namespace: "config"
+  },
+  "config.read.secrets": {
+    description: "Read unmasked secret config values.",
+    namespace: "config"
+  },
+  "skill.create.swarm": {
+    description: "Create a swarm-scoped skill.",
+    namespace: "skill"
+  },
+  "skill.install.any": {
+    description: "Install a skill for another agent.",
+    namespace: "skill"
+  },
+  "skill.install.global": {
+    description: "Install a remote/global skill.",
+    namespace: "skill"
+  },
+  "skill.uninstall.any": {
+    description: "Uninstall a skill for another agent.",
+    namespace: "skill"
+  },
+  "skill.update.any": {
+    description: "Update a skill the caller does not own.",
+    namespace: "skill"
+  },
+  "skill.promote.swarm": {
+    description: "Promote a skill to swarm scope (skill-approval path).",
+    namespace: "skill"
+  },
+  "skill.delete.any": {
+    description: "Delete a skill the caller does not own.",
+    namespace: "skill"
+  },
+  "mcp-server.create.swarm": {
+    description: "Create a swarm- or global-scoped MCP server.",
+    namespace: "mcp-server"
+  },
+  "mcp-server.install.any": {
+    description: "Install an MCP server for another agent.",
+    namespace: "mcp-server"
+  },
+  "mcp-server.uninstall.any": {
+    description: "Uninstall an MCP server for another agent.",
+    namespace: "mcp-server"
+  },
+  "mcp-server.delete.any": {
+    description: "Delete an MCP server the caller does not own.",
+    namespace: "mcp-server"
+  },
+  "mcp-server.update.any": {
+    description: "Update an MCP server the caller does not own.",
+    namespace: "mcp-server"
+  },
+  "mcp-server.read.secrets": {
+    description: "Read resolved MCP server secret env/header values.",
+    namespace: "mcp-server"
+  },
+  "mcp-oauth.authorize.any": {
+    description: "Start an MCP-server OAuth authorize flow for a caller-supplied user scope.",
+    namespace: "mcp-oauth"
+  },
+  "kv.write.any": {
+    description: "Write another agent's task:agent: KV namespace.",
+    namespace: "kv"
+  },
+  "page.delete.any": {
+    description: "Delete a page the caller does not own.",
+    namespace: "page"
+  },
+  "script.global.write": {
+    description: "Create or update a global-scope script.",
+    namespace: "script"
+  },
+  "script.global.delete": {
+    description: "Delete a global-scope script.",
+    namespace: "script"
+  },
+  "script.search": {
+    description: "Search reusable scripts visible to the caller.",
+    namespace: "script"
+  },
+  "script.api.read.secrets": {
+    description: "Reveal an external script API endpoint bearer token.",
+    namespace: "script"
+  },
+  "script.api.create": {
+    description: "Expose a script as an external HTTP API endpoint.",
+    namespace: "script"
+  },
+  "script.api.update": {
+    description: "Update an external script API endpoint.",
+    namespace: "script"
+  },
+  "script.api.rotate": {
+    description: "Rotate an external script API endpoint bearer token.",
+    namespace: "script"
+  },
+  "script.api.delete": {
+    description: "Delete an external script API endpoint.",
+    namespace: "script"
+  }
+};
+var PERMISSION_VERBS = Object.keys(PERMISSIONS);
+var PermissionVerbSchema = _enum(PERMISSION_VERBS);
+
+// src/rbac/admission.ts
+function isRbacEnabled() {
+  return process.env.RBAC_ENABLED === "true";
+}
+function decideAdmission(input) {
+  if (input.grant.grantsAll) {
+    return { allow: true };
+  }
+  if (input.rbac && "permission" in input.rbac) {
+    const verb = input.rbac.permission;
+    if (input.grant.verbs.has(verb)) {
+      return { allow: true, verb };
+    }
+    return { allow: false, reason: `admission: missing permission '${verb}'`, verb };
+  }
+  const method = input.method.toUpperCase();
+  if (method === "GET" || method === "HEAD") {
+    return { allow: true };
+  }
+  return { allow: false, reason: "admission: route has no permission verb (operator-only)" };
+}
+function decideToolAdmission(input) {
+  if (input.grant.grantsAll) {
+    return { allow: true };
+  }
+  if (input.rbac && "permission" in input.rbac) {
+    const verb = input.rbac.permission;
+    if (input.grant.verbs.has(verb)) {
+      return { allow: true, verb };
+    }
+    return { allow: false, reason: `admission: missing permission '${verb}'`, verb };
+  }
+  if (input.readOnly) {
+    return { allow: true };
+  }
+  return { allow: false, reason: "admission: tool has no permission verb (operator-only)" };
+}
+// src/rbac/legacy-policy.ts
+var leadOnly = {
+  name: "lead-only",
+  denyReason: "requires lead agent",
+  evaluate: (principal) => principal.kind === "agent" && principal.isLead
+};
+var leadOrTaskCreator = {
+  name: "lead-or-task-creator",
+  denyReason: "requires lead agent or task creator",
+  evaluate: (principal, resource) => {
+    if (principal.kind !== "agent")
+      return false;
+    if (principal.isLead)
+      return true;
+    return resource?.kind === "task" && resource.creatorAgentId != null && resource.creatorAgentId === principal.agentId;
+  }
+};
+var leadOrResourceOwner = {
+  name: "lead-or-resource-owner",
+  denyReason: "requires lead agent or resource owner",
+  evaluate: (principal, resource) => {
+    if (principal.kind !== "agent")
+      return false;
+    if (principal.isLead)
+      return true;
+    return resource?.kind === "owned" && resource.ownerAgentId != null && resource.ownerAgentId === principal.agentId;
+  }
+};
+var leadOrOwnNamespace = {
+  name: "lead-or-own-namespace",
+  denyReason: "requires lead agent or your own task:agent: namespace",
+  evaluate: (principal, resource) => {
+    if (principal.kind !== "agent")
+      return false;
+    if (principal.isLead)
+      return true;
+    return principal.agentId !== "" && resource?.kind === "kv-namespace" && resource.namespace === `task:agent:${principal.agentId}`;
+  }
+};
+var anyAuthenticated = {
+  name: "any-authenticated",
+  denyReason: "requires an authenticated principal",
+  evaluate: () => true
+};
+var requesterOwnsTask = {
+  name: "requester-owns-task",
+  denyReason: "not the task requester",
+  evaluate: (principal, resource) => {
+    if (principal.kind !== "user")
+      return true;
+    return resource?.kind === "task" && resource.requestedByUserId === principal.userId;
+  }
+};
+var memoryOwnerOrLeadSwarm = {
+  name: "memory-owner-or-lead-swarm",
+  denyReason: "requires memory owner, or lead agent for swarm-scoped memories",
+  evaluate: (principal, resource) => {
+    if (principal.kind !== "agent" || resource?.kind !== "owned")
+      return false;
+    if (resource.ownerAgentId != null && resource.ownerAgentId === principal.agentId)
+      return true;
+    return principal.isLead && resource.scope === "swarm";
+  }
+};
+var taskFsMutate = {
+  name: "operator-or-user-or-lead-or-task-owner",
+  denyReason: "requires operator, user, lead agent, task assignee, or task creator",
+  evaluate: (principal, resource) => {
+    if (principal.kind === "operator" || principal.kind === "user")
+      return true;
+    if (principal.isLead)
+      return true;
+    if (resource?.kind !== "task")
+      return false;
+    return resource.agentId != null && resource.agentId === principal.agentId || resource.creatorAgentId != null && resource.creatorAgentId === principal.agentId;
+  }
+};
+var LEGACY_POLICY = {
+  "user.manage": leadOnly,
+  "agent.profile.update.any": leadOnly,
+  "agent.context.read.any": leadOnly,
+  "task.cancel.any": leadOrTaskCreator,
+  "task.create.own": anyAuthenticated,
+  "task.read.own": requesterOwnsTask,
+  "task.cancel.own": requesterOwnsTask,
+  "task.action.own": requesterOwnsTask,
+  "task.fs.mutate": taskFsMutate,
+  "favorite.write.own": anyAuthenticated,
+  "memory.learning.inject": leadOnly,
+  "memory.delete.any": memoryOwnerOrLeadSwarm,
+  "channel.delete": leadOnly,
+  "integration.kapso.manage": leadOnly,
+  "integration.slack.post": leadOnly,
+  "integration.slack.read": leadOnly,
+  "integration.slack.thread.start": leadOnly,
+  "integration.slack.upload": leadOnly,
+  "integration.slack.delete": leadOnly,
+  "integration.slack.update": leadOnly,
+  "credential-binding.manage": leadOnly,
+  "script-connection.manage": leadOnly,
+  "script-connection.invoke": anyAuthenticated,
+  "config.credential-bindings.write": leadOnly,
+  "config.write.any": leadOnly,
+  "config.delete.any": leadOnly,
+  "config.read.secrets": leadOnly,
+  "skill.create.swarm": leadOnly,
+  "skill.install.any": leadOnly,
+  "skill.install.global": leadOnly,
+  "skill.uninstall.any": leadOnly,
+  "skill.update.any": leadOrResourceOwner,
+  "skill.promote.swarm": leadOnly,
+  "skill.delete.any": leadOrResourceOwner,
+  "mcp-server.create.swarm": leadOnly,
+  "mcp-server.install.any": leadOnly,
+  "mcp-server.uninstall.any": leadOnly,
+  "mcp-server.delete.any": leadOrResourceOwner,
+  "mcp-server.update.any": leadOrResourceOwner,
+  "mcp-server.read.secrets": leadOnly,
+  "mcp-oauth.authorize.any": anyAuthenticated,
+  "kv.write.any": leadOrOwnNamespace,
+  "page.delete.any": leadOrResourceOwner,
+  "script.global.write": leadOnly,
+  "script.global.delete": leadOnly,
+  "script.search": anyAuthenticated,
+  "script.api.read.secrets": leadOnly,
+  "script.api.create": leadOnly,
+  "script.api.update": leadOnly,
+  "script.api.rotate": leadOnly,
+  "script.api.delete": leadOnly
+};
+
+// src/rbac/can.ts
+var auditSink = null;
+function setAuditSink(fn) {
+  auditSink = fn;
+}
+function clearAuditSink() {
+  auditSink = null;
+}
+function can(check) {
+  const rule = LEGACY_POLICY[check.verb];
+  const decision = rule.evaluate(check.principal, check.resource) ? { allow: true } : { allow: false, reason: rule.denyReason, missing: check.verb };
+  if (auditSink) {
+    try {
+      auditSink(check, decision);
+    } catch {}
+  }
+  return decision;
+}
+export { isRbacEnabled, decideAdmission, decideToolAdmission, setAuditSink, clearAuditSink, can, PermissionVerbSchema };

package/dist/{cli-9cy6nc5m.js → cli-8fjwym53.js}

@@ -4,7 +4,7 @@ import {
 import {
   safeParseAsync1 as safeParseAsync,
   toJSONSchema
-} from "./cli-anrj584m.js";
+} from "./cli-xz9aq0rf.js";
 
 // node_modules/@ai-sdk/provider/dist/index.mjs
 var marker = "vercel.ai.error";

package/dist/{cli-c3frqf65.js → cli-b23axgz4.js}

@@ -7,7 +7,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@desplega.ai/agent-swarm",
-    version: "1.113.0",
+    version: "1.115.0",
     description: "Multi-agent orchestration for Claude Code, Codex, Gemini CLI, and other AI coding assistants",
     license: "MIT",
     author: "desplega.sh <contact@desplega.sh>",
@@ -90,9 +90,9 @@ var init_package = __esm(() => {
       lead: "bun src/cli.tsx lead",
       "lead:yolo": "bun src/cli.tsx lead --yolo",
       dev: "bun --hot src/stdio.ts",
-      "dev:http": "portless api.swarm bun --hot src/http.ts",
+      "dev:http": "NODE_ENV=development portless api.swarm bun --hot src/http.ts",
       start: "bun src/stdio.ts",
-      "start:http": "bun --expose-gc src/http.ts",
+      "start:http": "NODE_ENV=development bun --expose-gc src/http.ts",
       "start:portless": "portless api.swarm bun --expose-gc src/http.ts",
       inspector: "bunx @modelcontextprotocol/inspector --transport stdio bun src/stdio.ts",
       "inspector:http": "bunx @modelcontextprotocol/inspector --transport http https://api.swarm.localhost:1355/mcp",

package/dist/{cli-a0t7vapf.js → cli-bc89my0z.js}

@@ -20,7 +20,7 @@ import {
 } from "./cli-tghre7g6.js";
 import {
   applyReasoningEffort
-} from "./cli-tkmm5nf9.js";
+} from "./cli-e61fs2hp.js";
 import {
   init_credentials,
   validateOpencodeCredentials

package/dist/{cli-bnzbn8j8.js → cli-beea4a3y.js}

@@ -1,18 +1,22 @@
 import {
+  REBOOT_RETRY_PIN_TAG,
+  createPoolStarvationDecisionTask,
   createRerouteDecisionTask,
   createResumeFollowUp,
   getNextResumeGeneration,
+  getPinCandidateAgent,
   getResumeGeneration,
   repointTrackerSyncBySwarmId
-} from "./cli-r5g6ngtn.js";
+} from "./cli-dcca6j8m.js";
 import {
   getExecutorRegistry,
   recoverIncompleteRuns
-} from "./cli-z46pnksz.js";
+} from "./cli-q1rx7g0d.js";
 import {
   MAX_EMPTY_POLLS,
   assignUnassignedTaskPending,
   backfillSupersedeTaskResumeTaskId,
+  buildRoutingAffinityFromAgent,
   cleanupStaleSessions,
   createTaskExtended,
   deleteActiveSession,
@@ -28,6 +32,7 @@ import {
   getRecentFailedCount,
   getRecentFailedTasks,
   getStalePinnedResumes,
+  getStaleUnassignedAffinityTasks,
   getStalledInProgressTasks,
   getTaskById,
   getTaskStats,
@@ -37,6 +42,8 @@ import {
   init_db,
   init_registry,
   init_resolver,
+  isAgentEligibleForTask,
+  isPoolAffinityEnforcementEnabled,
   registerTemplate,
   releaseStaleMentionProcessing,
   releaseStaleProcessingInbox,
@@ -44,7 +51,7 @@ import {
   resolveTemplate,
   supersedeTask,
   updateAgentStatus
-} from "./cli-ncfgsqbd.js";
+} from "./cli-15y7qhzp.js";
 
 // src/heartbeat/heartbeat.ts
 init_db();
@@ -155,6 +162,8 @@ var STALL_THRESHOLD_NO_SESSION_MIN = Number(process.env.HEARTBEAT_STALL_NO_SESSI
 var STALL_THRESHOLD_STALE_HEARTBEAT_MIN = Number(process.env.HEARTBEAT_STALL_STALE_HB_MIN) || 15;
 var STALE_CLEANUP_THRESHOLD_MINUTES = Number(process.env.HEARTBEAT_STALE_CLEANUP_MIN) || 30;
 var MAX_AUTO_ASSIGN_PER_SWEEP = Number(process.env.HEARTBEAT_MAX_AUTO_ASSIGN) || 5;
+var POOL_SCAN_BATCH_SIZE = Number(process.env.HEARTBEAT_POOL_SCAN_BATCH_SIZE) || 50;
+var POOL_SCAN_CAP = Number(process.env.HEARTBEAT_POOL_SCAN_CAP) || 500;
 var MAX_RESUME_GENERATIONS = Number(process.env.HEARTBEAT_MAX_RESUME_GENERATIONS) || 3;
 var RESUME_BUDGET_EXHAUSTED_REASON = "resume_budget_exhausted";
 var HEARTBEAT_RESUME_PIN_GRACE_MIN = (() => {
@@ -164,6 +173,7 @@ var HEARTBEAT_RESUME_PIN_GRACE_MIN = (() => {
   const parsed = Number(raw);
   return Number.isFinite(parsed) ? parsed : 10;
 })();
+var POOL_AFFINITY_ESCALATION_MIN = Number(process.env.POOL_AFFINITY_ESCALATION_MIN) || 15;
 var HEARTBEAT_CHECKLIST_INTERVAL_MS = Number(process.env.HEARTBEAT_CHECKLIST_INTERVAL_MS) || 30 * 60 * 1000;
 var HEARTBEAT_CHECKLIST_DISABLE = Boolean(process.env.HEARTBEAT_CHECKLIST_DISABLE);
 var heartbeatInterval = null;
@@ -412,12 +422,28 @@ async function runRebootSweep() {
            LIMIT 1`).get(task.id);
       if (!existingRetry) {
         try {
+          let preferredAgentId;
+          const candidate = getPinCandidateAgent(task.agentId);
+          if (candidate) {
+            const activeCount = getActiveTaskCount(candidate.id);
+            const hasCap = activeCount < (candidate.maxTasks ?? 1);
+            if (hasCap) {
+              preferredAgentId = candidate.id;
+            } else {
+              console.warn(`[Heartbeat] Reboot retry for task ${task.id.slice(0, 8)} NOT pinned: agent ${candidate.id.slice(0, 8)} at capacity (${activeCount}/${candidate.maxTasks ?? 1}); falling back to affinity-gated pool`);
+            }
+          }
+          const tags = ["reboot-retry", "auto-generated"];
+          if (preferredAgentId !== undefined)
+            tags.push(REBOOT_RETRY_PIN_TAG);
           const retryTask = createTaskExtended(task.task, {
             parentTaskId: task.id,
-            tags: ["reboot-retry", "auto-generated"],
+            agentId: preferredAgentId,
+            tags,
             priority: task.priority,
             source: task.source,
-            taskType: task.taskType ?? undefined
+            taskType: task.taskType ?? undefined,
+            routingAffinity: buildRoutingAffinityFromAgent(task.agentId) ?? undefined
           });
           retryTaskId = retryTask.id;
           console.log(`[Heartbeat] Reboot retry created: ${retryTaskId} (parent: ${task.id})`);
@@ -461,10 +487,6 @@ function autoAssignPoolTasks(findings) {
     const idleWorkers = getIdleWorkersWithCapacity().filter((w) => (w.emptyPollCount ?? 0) < MAX_EMPTY_POLLS);
     if (idleWorkers.length === 0)
       return;
-    const poolTasks = getUnassignedPoolTasks(MAX_AUTO_ASSIGN_PER_SWEEP);
-    if (poolTasks.length === 0)
-      return;
-    let workerIndex = 0;
     const reservedByWorker = new Map;
     const reservedForWorker = (agentId) => {
       const cached = reservedByWorker.get(agentId);
@@ -475,24 +497,28 @@ function autoAssignPoolTasks(findings) {
       reservedByWorker.set(agentId, reserved);
       return reserved;
     };
-    for (const task of poolTasks) {
-      if (workerIndex >= idleWorkers.length)
+    let assignedCount = 0;
+    let offset = 0;
+    while (assignedCount < MAX_AUTO_ASSIGN_PER_SWEEP && offset < POOL_SCAN_CAP) {
+      const batch = getUnassignedPoolTasks(POOL_SCAN_BATCH_SIZE, offset);
+      if (batch.length === 0)
         break;
-      const worker = idleWorkers[workerIndex];
-      const maxTasks = worker.maxTasks ?? 1;
-      if (reservedForWorker(worker.id) >= maxTasks) {
-        workerIndex++;
-        continue;
-      }
-      const assigned = assignUnassignedTaskPending(task.id, worker.id);
-      if (assigned) {
-        findings.autoAssigned.push({ taskId: task.id, agentId: worker.id });
-        reservedByWorker.set(worker.id, reservedForWorker(worker.id) + 1);
-        const remaining = maxTasks - reservedForWorker(worker.id);
-        if (remaining <= 0) {
-          workerIndex++;
+      for (const task of batch) {
+        if (assignedCount >= MAX_AUTO_ASSIGN_PER_SWEEP)
+          break;
+        const worker = idleWorkers.find((w) => reservedForWorker(w.id) < (w.maxTasks ?? 1) && isAgentEligibleForTask(w, task));
+        if (!worker)
+          continue;
+        const assigned = assignUnassignedTaskPending(task.id, worker.id);
+        if (assigned) {
+          findings.autoAssigned.push({ taskId: task.id, agentId: worker.id });
+          reservedByWorker.set(worker.id, reservedForWorker(worker.id) + 1);
+          assignedCount++;
         }
       }
+      offset += batch.length;
+      if (batch.length < POOL_SCAN_BATCH_SIZE)
+        break;
     }
   })();
 }
@@ -550,12 +576,35 @@ function escalateUnreclaimedResumes(findings) {
     console.log(`[Heartbeat] Escalated unreclaimed pinned resume ${resume.id.slice(0, 8)} → Lead reroute-decision ${escalation.decisionTaskId.slice(0, 8)} (original ${original.id.slice(0, 8)})`);
   }
 }
+function escalateStarvedPoolTasks(findings) {
+  if (!isPoolAffinityEnforcementEnabled())
+    return;
+  const cutoff = new Date(Date.now() - POOL_AFFINITY_ESCALATION_MIN * 60 * 1000).toISOString();
+  const candidates = getStaleUnassignedAffinityTasks(cutoff);
+  if (candidates.length === 0)
+    return;
+  const registeredAgents = getAllAgents().filter((a) => !a.isLead);
+  for (const task of candidates) {
+    const hasEligibleAgent = registeredAgents.some((agent) => isAgentEligibleForTask(agent, task));
+    if (hasEligibleAgent)
+      continue;
+    const decision = createPoolStarvationDecisionTask({ original: task });
+    if (decision.kind === "created") {
+      findings.escalatedReroutes.push({
+        originalTaskId: task.id,
+        decisionTaskId: decision.task.id
+      });
+      console.log(`[Heartbeat] Escalated starved pool task ${task.id.slice(0, 8)} → Lead reroute-decision ${decision.task.id.slice(0, 8)} (zero eligible agents)`);
+    }
+  }
+}
 async function cleanupStaleResources(findings) {
   findings.staleCleanup.sessions = cleanupStaleSessions(STALE_CLEANUP_THRESHOLD_MINUTES);
   findings.staleCleanup.reviewingTasks = releaseStaleReviewingTasks(STALE_CLEANUP_THRESHOLD_MINUTES);
   findings.staleCleanup.mentionProcessing = releaseStaleMentionProcessing(STALE_CLEANUP_THRESHOLD_MINUTES);
   findings.staleCleanup.inboxProcessing = releaseStaleProcessingInbox(STALE_CLEANUP_THRESHOLD_MINUTES);
   escalateUnreclaimedResumes(findings);
+  escalateStarvedPoolTasks(findings);
   try {
     findings.staleCleanup.workflowRuns = await recoverIncompleteRuns(getExecutorRegistry());
   } catch {

package/dist/{cli-q21d49ac.js → cli-bw80ck94.js}

@@ -1,6 +1,6 @@
 import {
   init_external
-} from "./cli-anrj584m.js";
+} from "./cli-xz9aq0rf.js";
 import {
   __esm
 } from "./cli-p9swy5t3.js";

package/dist/{cli-pwc5e83c.js → cli-cchksf5q.js}

@@ -1,16 +1,15 @@
-import {
-  recordUnmappedIdentity
-} from "./cli-c9mtm09b.js";
 import {
   findOrCreateUserByEmail,
   findUserByExternalId,
-  linkIdentity
-} from "./cli-h3k622d0.js";
+  linkIdentity,
+  recordUnmappedIdentity,
+  resolveIdentity
+} from "./cli-6aq8xhvm.js";
 import {
   getKv,
   init_db,
   upsertKv
-} from "./cli-ncfgsqbd.js";
+} from "./cli-15y7qhzp.js";
 
 // src/slack/enrich.ts
 init_db();
@@ -70,5 +69,11 @@ async function resolveSlackUserId(client, slackUserId, eventContext) {
   recordUnmappedIdentity("slack", slackUserId, eventContext);
   return;
 }
+function rewriteSlackMentions(text) {
+  return text.replace(/<@([A-Z0-9]+)>/g, (_match, userId) => {
+    const resolution = resolveIdentity("slack", userId);
+    return resolution.status === "resolved" ? `<@${userId}|${resolution.name}>` : `<@${userId}> (unknown user)`;
+  });
+}
 
-export { enrichSlackUserEmail, resolveSlackUserId };
+export { enrichSlackUserEmail, resolveSlackUserId, rewriteSlackMentions };

package/dist/{cli-30bbaveh.js → cli-cmw9rzy5.js}

@@ -4,11 +4,11 @@ import {
   getEmbeddingProvider,
   init_embedding,
   serializeEmbedding
-} from "./cli-f3qa069v.js";
+} from "./cli-7xje5amz.js";
 import {
   getDb,
   init_db
-} from "./cli-ncfgsqbd.js";
+} from "./cli-15y7qhzp.js";
 import {
   init_secret_scrubber,
   scrubSecrets