@askexenow/exe-os 0.9.245 → 0.9.246

package/dist/lib/exe-daemon.js

@@ -1218,7 +1218,7 @@ async function handleHealthCheck(socket, requestId) {
   let pipelineStatus = "unknown";
   if (dbConnected) {
     try {
-      await import("../pipeline-router-S5PE5U6B.js");
+      await import("../pipeline-router-TUMTOJUC.js");
       pipelineStatus = "ok";
     } catch {
       pipelineStatus = "unavailable";
@@ -1846,6 +1846,11 @@ async function startMcpHttpServer() {
       transports.delete(sid);
       sessionLastSeen.delete(sid);
       sessionOwnerKeys.delete(sid);
+      for (const [staleSid, alias] of staleSessionRecoveries.entries()) {
+        if (staleSid === sid || alias.recoveredSessionId === sid) {
+          staleSessionRecoveries.delete(staleSid);
+        }
+      }
       const details = sessionDetails.get(sid);
       process.stderr.write(`[exed] MCP session closed: ${sid.slice(0, 8)}\u2026 agent=${details?.agentId ?? "?"} reason=${reason} remaining=${transports.size}
 `);
@@ -1889,6 +1894,23 @@ async function startMcpHttpServer() {
           }
         }
       }
+    }, pruneStaleRecoveryAliases2 = function(now = Date.now()) {
+      for (const [staleSid, alias] of staleSessionRecoveries.entries()) {
+        if (now - alias.createdAt > MCP_RECOVERY_ALIAS_TTL_MS || !transports.has(alias.recoveredSessionId)) {
+          staleSessionRecoveries.delete(staleSid);
+        }
+      }
+    }, getRecoveredMcpSession2 = function(staleSessionId) {
+      pruneStaleRecoveryAliases2();
+      const alias = staleSessionRecoveries.get(staleSessionId);
+      if (!alias) return null;
+      const recoveredTransport = transports.get(alias.recoveredSessionId);
+      if (!recoveredTransport) {
+        staleSessionRecoveries.delete(staleSessionId);
+        return null;
+      }
+      sessionLastSeen.set(alias.recoveredSessionId, Date.now());
+      return { sessionId: alias.recoveredSessionId, transport: recoveredTransport };
     }, sweepStaleMcpSessions2 = function() {
       const now = Date.now();
       if (MCP_SESSION_TTL_MS > 0) {
@@ -1909,7 +1931,7 @@ async function startMcpHttpServer() {
       const rssPressure = mem.rss > RSS_RESTART_BYTES * 0.8;
       const heapPressure = heapLimit > 0 && mem.heapUsed > heapLimit * 0.7;
       if ((rssPressure || heapPressure) && transports.size > 1) {
-        const sorted = [...sessionLastSeen.entries()].sort((a, b) => a[1] - b[1]);
+        const sorted = [...sessionLastSeen.entries()].filter(([, lastSeen]) => now - lastSeen >= MCP_PRESSURE_EVICT_MIN_IDLE_MS).sort((a, b) => a[1] - b[1]);
         if (sorted.length > 0) {
           closeMcpSession2(sorted[0][0], rssPressure ? "rss_pressure_evict" : "heap_pressure_evict");
           process.stderr.write(`[exed] MCP pressure eviction: closed 1 session ${sorted[0][0].slice(0, 8)} (${transports.size} remaining; rss=${Math.round(mem.rss / 1024 / 1024)}MB heap=${Math.round(mem.heapUsed / 1024 / 1024)}MB)
@@ -1932,7 +1954,7 @@ async function startMcpHttpServer() {
       }));
       recordMcpHttpEvent({ level: "warn", message, status, ...extra });
     };
-    var parseDurationMs = parseDurationMs2, closeMcpSession = closeMcpSession2, mcpSessionOwnerKey = mcpSessionOwnerKey2, evictDuplicateMcpSessions = evictDuplicateMcpSessions2, sweepStaleMcpSessions = sweepStaleMcpSessions2, getJsonRpcId = getJsonRpcId2, sendJsonRpcError = sendJsonRpcError2;
+    var parseDurationMs = parseDurationMs2, closeMcpSession = closeMcpSession2, mcpSessionOwnerKey = mcpSessionOwnerKey2, evictDuplicateMcpSessions = evictDuplicateMcpSessions2, pruneStaleRecoveryAliases = pruneStaleRecoveryAliases2, getRecoveredMcpSession = getRecoveredMcpSession2, sweepStaleMcpSessions = sweepStaleMcpSessions2, getJsonRpcId = getJsonRpcId2, sendJsonRpcError = sendJsonRpcError2;
     process.stderr.write("[exed] MCP HTTP: importing SDK modules...\n");
     const { McpServer } = await import("@modelcontextprotocol/sdk/server/mcp.js");
     const { StreamableHTTPServerTransport } = await import("@modelcontextprotocol/sdk/server/streamableHttp.js");
@@ -1994,8 +2016,12 @@ async function startMcpHttpServer() {
     const MCP_SESSION_TTL_MS = parseDurationMs2(process.env.EXE_MCP_SESSION_TTL_MS, 0, { allowZero: true });
     const MAX_MCP_SESSIONS = Number(process.env.EXE_MAX_MCP_SESSIONS) || 50;
     const MCP_SESSION_SWEEP_MS = parseDurationMs2(process.env.EXE_MCP_SESSION_SWEEP_MS, 60 * 1e3);
+    const MCP_RECOVERY_ALIAS_TTL_MS = parseDurationMs2(process.env.EXE_MCP_RECOVERY_ALIAS_TTL_MS, 30 * 60 * 1e3);
+    const MCP_PRESSURE_EVICT_MIN_IDLE_MS = parseDurationMs2(process.env.EXE_MCP_PRESSURE_EVICT_MIN_IDLE_MS, 30 * 60 * 1e3);
     const sessionLastSeen = /* @__PURE__ */ new Map();
     const sessionDetails = /* @__PURE__ */ new Map();
+    const staleSessionRecoveries = /* @__PURE__ */ new Map();
+    const pendingStaleSessionRecoveries = /* @__PURE__ */ new Map();
     _mcpSessionDetailsRef = sessionDetails;
     try {
       const sessPath = path3.join(EXE_AI_DIR, "mcp-sessions-persist.json");
@@ -2036,6 +2062,135 @@ async function startMcpHttpServer() {
     const EVICTION_LOG_WINDOW_MS = 6e4;
     const recentEvictions = /* @__PURE__ */ new Map();
     const EVICTION_COOLDOWN_MS = 3e4;
+    async function createRecoveredMcpSession(staleSessionId, details) {
+      const existingRecovered = getRecoveredMcpSession2(staleSessionId);
+      if (existingRecovered) return existingRecovered;
+      const pending = pendingStaleSessionRecoveries.get(staleSessionId);
+      if (pending) {
+        try {
+          const recoveredSessionId2 = await pending;
+          const recoveredTransport = transports.get(recoveredSessionId2);
+          if (recoveredTransport) {
+            sessionLastSeen.set(recoveredSessionId2, Date.now());
+            recordMcpHttpEvent({
+              level: "info",
+              message: "session_recovery_joined",
+              sessionId: recoveredSessionId2,
+              agentId: details.agentId,
+              agentRole: details.agentRole,
+              runtime: details.runtime,
+              activeSessions: transports.size
+            });
+            return { sessionId: recoveredSessionId2, transport: recoveredTransport };
+          }
+        } catch (err) {
+          process.stderr.write(`[exed] MCP session ${staleSessionId.slice(0, 8)}\u2026 pending recovery failed: ${err instanceof Error ? err.message : String(err)}
+`);
+        }
+        pendingStaleSessionRecoveries.delete(staleSessionId);
+        staleSessionRecoveries.delete(staleSessionId);
+      }
+      let recoveredSessionId = "";
+      let _resolveRecovery;
+      let _rejectRecovery;
+      const recoveryPromise = new Promise((resolve, reject) => {
+        _resolveRecovery = resolve;
+        _rejectRecovery = reject;
+      });
+      pendingStaleSessionRecoveries.set(staleSessionId, recoveryPromise);
+      void (async () => {
+        process.stderr.write(
+          `[exed] MCP session ${staleSessionId.slice(0, 8)}\u2026 stale after daemon restart \u2014 transparently recovering
+`
+        );
+        recordMcpHttpEvent({
+          level: "info",
+          message: "session_stale_recovering",
+          sessionId: staleSessionId,
+          agentId: details.agentId,
+          agentRole: details.agentRole,
+          runtime: details.runtime,
+          activeSessions: transports.size
+        });
+        try {
+          const { initDatabase, isInitialized } = await import("./database.js");
+          if (!isInitialized()) {
+            const { loadConfig } = await import("./config.js");
+            const { getMasterKey } = await import("./keychain.js");
+            const config = await loadConfig();
+            const masterKey = await getMasterKey();
+            if (masterKey) {
+              await initDatabase({ dbPath: config.dbPath, encryptionKey: masterKey.toString("hex") });
+              process.stderr.write("[exed] DB initialized during stale-session recovery\n");
+            }
+          }
+        } catch (dbErr) {
+          process.stderr.write(`[exed] DB init during stale-session recovery: ${dbErr instanceof Error ? dbErr.message : String(dbErr)}
+`);
+        }
+        recoveredSessionId = randomUUID();
+        const recoveredTransport = new StreamableHTTPServerTransport({
+          sessionIdGenerator: () => recoveredSessionId,
+          enableJsonResponse: true
+        });
+        recoveredTransport.onclose = () => {
+          const sid = Array.from(transports.entries()).find(([, t]) => t === recoveredTransport)?.[0];
+          if (sid) closeMcpSession2(sid, "session_closed");
+        };
+        const webTransport = recoveredTransport._webStandardTransport;
+        if (!webTransport) {
+          throw new Error("MCP recovery failed: missing underlying web transport");
+        }
+        webTransport.sessionId = recoveredSessionId;
+        webTransport._initialized = true;
+        if (transports.size >= MAX_MCP_SESSIONS) {
+          const oldest = [...sessionLastSeen.entries()].sort((a, b) => a[1] - b[1])[0];
+          if (oldest) {
+            process.stderr.write(`[exed] Session cap (${MAX_MCP_SESSIONS}) reached during recovery \u2014 evicting oldest ${oldest[0].slice(0, 8)}
+`);
+            closeMcpSession2(oldest[0], "session_cap_eviction");
+          }
+        }
+        const ownerKey = mcpSessionOwnerKey2(details);
+        evictDuplicateMcpSessions2(ownerKey, recoveredSessionId);
+        transports.set(recoveredSessionId, recoveredTransport);
+        sessionLastSeen.set(recoveredSessionId, Date.now());
+        sessionDetails.set(recoveredSessionId, details);
+        sessionOwnerKeys.set(recoveredSessionId, ownerKey);
+        staleSessionRecoveries.set(staleSessionId, { recoveredSessionId, createdAt: Date.now() });
+        recordMcpHttpEvent({
+          level: "info",
+          message: "session_recovered",
+          sessionId: recoveredSessionId,
+          agentId: details.agentId,
+          agentRole: details.agentRole,
+          runtime: details.runtime,
+          activeSessions: transports.size
+        });
+        const sessionMcp = new McpServer({ name: "exe-os", version: "1.3.0" });
+        sessionServers.set(recoveredSessionId, sessionMcp);
+        const gateState = getCachedLicenseGate();
+        const wrapTelemetry = await getWrapTelemetry();
+        const wrappedMcp = wrapTelemetry(sessionMcp);
+        registerAllTools(wrappedMcp, gateState.license, gateState.hasKey);
+        await sessionMcp.connect(recoveredTransport);
+        _resolveRecovery(recoveredSessionId);
+      })().catch((err) => {
+        _rejectRecovery(err);
+      });
+      try {
+        const sid = await recoveryPromise;
+        const recoveredTransport = transports.get(sid);
+        if (!recoveredTransport) throw new Error(`MCP recovery failed: recovered session ${sid} was closed`);
+        return { sessionId: sid, transport: recoveredTransport };
+      } catch (err) {
+        if (recoveredSessionId) closeMcpSession2(recoveredSessionId, "recovery_failed");
+        staleSessionRecoveries.delete(staleSessionId);
+        throw err;
+      } finally {
+        pendingStaleSessionRecoveries.delete(staleSessionId);
+      }
+    }
     const sessionSweepTimer = setInterval(sweepStaleMcpSessions2, MCP_SESSION_SWEEP_MS);
     sessionSweepTimer.unref();
     const httpServer = createHttpServer(async (req, res) => {
@@ -2343,7 +2498,8 @@ async function startMcpHttpServer() {
           enableJsonResponse: true,
           onsessioninitialized: (sid) => {
             const details = { agentId, agentRole, runtime, sessionHint };
-            evictDuplicateMcpSessions2(mcpSessionOwnerKey2(details), sid);
+            const ownerKey = mcpSessionOwnerKey2(details);
+            evictDuplicateMcpSessions2(ownerKey, sid);
             if (transports.size >= MAX_MCP_SESSIONS) {
               const now = Date.now();
               for (const [k, ts] of recentEvictions) {
@@ -2352,8 +2508,8 @@ async function startMcpHttpServer() {
               const sorted = [...sessionLastSeen.entries()].sort((a, b) => a[1] - b[1]);
               let evicted = false;
               for (const [candidateSid] of sorted) {
-                const ownerKey = sessionOwnerKeys.get(candidateSid) ?? candidateSid;
-                if (!recentEvictions.has(ownerKey)) {
+                const ownerKey2 = sessionOwnerKeys.get(candidateSid) ?? candidateSid;
+                if (!recentEvictions.has(ownerKey2)) {
                   if (now - _evictionLogWindowStart > EVICTION_LOG_WINDOW_MS) {
                     _evictionLogCount = 0;
                     _evictionLogWindowStart = now;
@@ -2366,7 +2522,7 @@ async function startMcpHttpServer() {
 `);
                   }
                   _evictionLogCount++;
-                  recentEvictions.set(ownerKey, now);
+                  recentEvictions.set(ownerKey2, now);
                   closeMcpSession2(candidateSid, "session_cap_eviction");
                   evicted = true;
                   break;
@@ -2382,7 +2538,7 @@ async function startMcpHttpServer() {
             transports.set(sid, transport);
             sessionLastSeen.set(sid, Date.now());
             sessionDetails.set(sid, details);
-            sessionOwnerKeys.set(sid, mcpSessionOwnerKey2(details));
+            sessionOwnerKeys.set(sid, ownerKey);
             sessionServers.set(sid, sessionMcp);
             process.stderr.write(`[exed] MCP session opened: ${sid.slice(0, 8)}\u2026 agent=${agentId} role=${agentRole} sessions=${transports.size}
 `);
@@ -2408,81 +2564,10 @@ async function startMcpHttpServer() {
         registerAllTools(wrappedMcp, gateState.license, gateState.hasKey);
         await sessionMcp.connect(transport);
       } else if (sessionId && !transports.has(sessionId) && req.method === "POST") {
-        process.stderr.write(
-          `[exed] MCP session ${sessionId.slice(0, 8)}\u2026 stale after daemon restart \u2014 transparently recovering
-`
-        );
-        recordMcpHttpEvent({
-          level: "info",
-          message: "session_stale_recovering",
-          sessionId,
-          agentId,
-          agentRole,
-          runtime,
-          activeSessions: transports.size
-        });
-        try {
-          const { initDatabase, isInitialized } = await import("./database.js");
-          if (!isInitialized()) {
-            const { loadConfig } = await import("./config.js");
-            const { getMasterKey } = await import("./keychain.js");
-            const config = await loadConfig();
-            const masterKey = await getMasterKey();
-            if (masterKey) {
-              await initDatabase({ dbPath: config.dbPath, encryptionKey: masterKey.toString("hex") });
-              process.stderr.write("[exed] DB initialized during stale-session 404\n");
-            }
-          }
-        } catch (dbErr) {
-          process.stderr.write(`[exed] DB init during 404 recovery: ${dbErr instanceof Error ? dbErr.message : String(dbErr)}
-`);
-        }
-        const recoveredSessionId = randomUUID();
-        transport = new StreamableHTTPServerTransport({
-          sessionIdGenerator: () => recoveredSessionId,
-          enableJsonResponse: true
-        });
-        transport.onclose = () => {
-          const sid = Array.from(transports.entries()).find(([, t]) => t === transport)?.[0];
-          if (sid) closeMcpSession2(sid, "session_closed");
-        };
-        const webTransport = transport._webStandardTransport;
-        if (!webTransport) {
-          throw new Error("MCP recovery failed: missing underlying web transport");
-        }
-        webTransport.sessionId = recoveredSessionId;
-        webTransport._initialized = true;
-        req.headers["mcp-session-id"] = recoveredSessionId;
-        if (transports.size >= MAX_MCP_SESSIONS) {
-          const oldest = [...sessionLastSeen.entries()].sort((a, b) => a[1] - b[1])[0];
-          if (oldest) {
-            process.stderr.write(`[exed] Session cap (${MAX_MCP_SESSIONS}) reached during recovery \u2014 evicting oldest ${oldest[0].slice(0, 8)}
-`);
-            closeMcpSession2(oldest[0], "session_cap_eviction");
-          }
-        }
         const details = { agentId, agentRole, runtime, sessionHint };
-        evictDuplicateMcpSessions2(mcpSessionOwnerKey2(details), recoveredSessionId);
-        transports.set(recoveredSessionId, transport);
-        sessionLastSeen.set(recoveredSessionId, Date.now());
-        sessionDetails.set(recoveredSessionId, details);
-        sessionOwnerKeys.set(recoveredSessionId, mcpSessionOwnerKey2(details));
-        recordMcpHttpEvent({
-          level: "info",
-          message: "session_recovered",
-          sessionId: recoveredSessionId,
-          agentId,
-          agentRole,
-          runtime,
-          activeSessions: transports.size
-        });
-        const sessionMcp = new McpServer({ name: "exe-os", version: "1.3.0" });
-        sessionServers.set(recoveredSessionId, sessionMcp);
-        const gateState = getCachedLicenseGate();
-        const wrapTelemetry = await getWrapTelemetry();
-        const wrappedMcp = wrapTelemetry(sessionMcp);
-        registerAllTools(wrappedMcp, gateState.license, gateState.hasKey);
-        await sessionMcp.connect(transport);
+        const recovered = await createRecoveredMcpSession(sessionId, details);
+        transport = recovered.transport;
+        req.headers["mcp-session-id"] = recovered.sessionId;
       } else {
         const message = sessionId ? "Bad Request: MCP session is stale or unknown; reconnect MCP client" : "Bad Request: missing MCP session; initialize before tool calls";
         sendJsonRpcError2(res, 400, message, getJsonRpcId2(parsedBody), {
@@ -2518,18 +2603,19 @@ async function startMcpHttpServer() {
         } catch {
         }
       }
+      const activeRequestSessionId = req.headers["mcp-session-id"];
       let effectiveSessionHint = sessionHint || void 0;
-      if (effectiveSessionHint && sessionId) {
-        const stored = sessionDetails.get(sessionId);
+      if (effectiveSessionHint && activeRequestSessionId) {
+        const stored = sessionDetails.get(activeRequestSessionId);
         if (stored && stored.sessionHint !== effectiveSessionHint) {
           process.stderr.write(
-            `[exed] Session hint updated: ${stored.sessionHint} \u2192 ${effectiveSessionHint} (session ${sessionId?.slice(0, 8)})
+            `[exed] Session hint updated: ${stored.sessionHint} \u2192 ${effectiveSessionHint} (session ${activeRequestSessionId?.slice(0, 8)})
 `
           );
           stored.sessionHint = effectiveSessionHint;
         }
-      } else if (!effectiveSessionHint && sessionId) {
-        const stored = sessionDetails.get(sessionId);
+      } else if (!effectiveSessionHint && activeRequestSessionId) {
+        const stored = sessionDetails.get(activeRequestSessionId);
         if (stored?.sessionHint) {
           effectiveSessionHint = stored.sessionHint;
         }
@@ -2682,13 +2768,13 @@ async function ensureStoreForPolling() {
   }
 }
 async function startReviewPolling() {
-  const polling = await import("../review-polling-P2MWEXLR.js");
+  const polling = await import("../review-polling-PHS23C5B.js");
   const state = {
     lastIntercomSent: /* @__PURE__ */ new Map(),
     lastNudgeSent: /* @__PURE__ */ new Map(),
     intervalMs: REVIEW_POLL_INTERVAL_MS
   };
-  const { pollReviewNudge, createReviewNudgeRealDeps, loadNudgeState } = await import("../daemon-orchestration-BJ3T5MMF.js");
+  const { pollReviewNudge, createReviewNudgeRealDeps, loadNudgeState } = await import("../daemon-orchestration-FR3LV4G3.js");
   const nudgeState = loadNudgeState();
   const tick = async () => traceDaemonTimer("review_polling", async () => {
     fired("review_polling");
@@ -2731,7 +2817,7 @@ function startSessionTTL() {
     if (!await ensureStoreForPolling()) return;
     try {
       const { getClient } = await import("./database.js");
-      const { checkSessionTTL, createSessionTTLRealDeps } = await import("../daemon-orchestration-BJ3T5MMF.js");
+      const { checkSessionTTL, createSessionTTLRealDeps } = await import("../daemon-orchestration-FR3LV4G3.js");
       const deps = createSessionTTLRealDeps(getClient);
       const killed = await checkSessionTTL(deps);
       if (killed.length > 0) acted("session_ttl");
@@ -2779,7 +2865,7 @@ function startIdleKill() {
       const cfg = await getCachedConfig();
       if (!cfg) return;
       const { getClient } = await import("./database.js");
-      const { pollIdleKill, createIdleKillRealDeps } = await import("../daemon-orchestration-BJ3T5MMF.js");
+      const { pollIdleKill, createIdleKillRealDeps } = await import("../daemon-orchestration-FR3LV4G3.js");
       const { sessions: liveSessions, paneCache, aliveSessions } = await getSharedOrchestrationCaches();
       const realDeps = createIdleKillRealDeps(
         getClient,
@@ -3031,7 +3117,7 @@ function startSkillRefinement() {
     if (!shouldRunHeavyJob("skill_refinement")) return;
     try {
       if (!await ensureStoreForPolling()) return;
-      const { runSkillRefinement } = await import("../skill-refinement-NRG4WWRW.js");
+      const { runSkillRefinement } = await import("../skill-refinement-D3ZYCYS4.js");
       const result = await runSkillRefinement();
       if (result.reviewed > 0) {
         acted("skill_refinement");
@@ -3620,7 +3706,7 @@ function startOrphanReaper() {
   const tick = async () => traceDaemonTimer("orphan_reaper", async () => {
     fired("orphan_reaper");
     try {
-      const { reapOrphanedMcpProcesses, createOrphanReaperRealDeps } = await import("../daemon-orchestration-BJ3T5MMF.js");
+      const { reapOrphanedMcpProcesses, createOrphanReaperRealDeps } = await import("../daemon-orchestration-FR3LV4G3.js");
       const deps = createOrphanReaperRealDeps();
       const reaped = await reapOrphanedMcpProcesses(deps);
       if (reaped.length > 0) acted("orphan_reaper");
@@ -3647,7 +3733,7 @@ function startZombieAgentReaper() {
   const tick = async () => traceDaemonTimer("zombie_agent_reaper", async () => {
     fired("zombie_agent_reaper");
     try {
-      const { reapZombieAgentProcesses, createZombieAgentReaperRealDeps } = await import("../daemon-orchestration-BJ3T5MMF.js");
+      const { reapZombieAgentProcesses, createZombieAgentReaperRealDeps } = await import("../daemon-orchestration-FR3LV4G3.js");
       const deps = createZombieAgentReaperRealDeps();
       const reaped = reapZombieAgentProcesses(deps);
       if (reaped.length > 0) acted("zombie_agent_reaper");
@@ -3673,7 +3759,7 @@ function startWorktreeReaper() {
   const tick = async () => traceDaemonTimer("worktree_reaper", async () => {
     fired("worktree_reaper");
     try {
-      const { reapOrphanedWorktrees, createWorktreeReaperRealDeps } = await import("../daemon-orchestration-BJ3T5MMF.js");
+      const { reapOrphanedWorktrees, createWorktreeReaperRealDeps } = await import("../daemon-orchestration-FR3LV4G3.js");
       const deps = await createWorktreeReaperRealDeps();
       const result = await reapOrphanedWorktrees(deps);
       if (result.pruned.length > 0) {
@@ -3728,7 +3814,7 @@ function startStuckTaskRelease() {
     if (!await ensureStoreForPolling()) return;
     try {
       const { getClient } = await import("./database.js");
-      const { releaseStuckTasks, createStuckTaskRealDeps } = await import("../daemon-orchestration-BJ3T5MMF.js");
+      const { releaseStuckTasks, createStuckTaskRealDeps } = await import("../daemon-orchestration-FR3LV4G3.js");
       const deps = createStuckTaskRealDeps(getClient);
       const released = await releaseStuckTasks(deps);
       if (released.length > 0) {
@@ -3832,12 +3918,12 @@ function startTaskEnforcementScanner() {
   const tick = async () => traceDaemonTimer("task_enforcement", async () => {
     fired("task_enforcement");
     try {
-      const { runTaskEnforcementTick } = await import("../task-enforcement-XQL77PZH.js");
+      const { runTaskEnforcementTick } = await import("../task-enforcement-WAMGSZ4S.js");
       const { getTransport } = await import("./transport.js");
       const { loadAgentConfig } = await import("./agent-config.js");
       const { getClient } = await import("./database.js");
       const { loadEmployeesSync } = await import("./employees.js");
-      const { sessionScopeFilter } = await import("../task-scope-R3XKBIHL.js");
+      const { sessionScopeFilter } = await import("../task-scope-AE6U7XGY.js");
       const transport = getTransport();
       const { sessions: allSessions, paneCache, aliveSessions } = await getSharedOrchestrationCaches();
       await yieldToEventLoop();
@@ -3848,7 +3934,7 @@ function startTaskEnforcementScanner() {
         sendKeysLiteral: transport.sendKeysLiteral?.bind(transport),
         isAlive: (session) => aliveSessions.has(session)
       };
-      const { checkAutoWakeGates } = await import("../daemon-orchestration-BJ3T5MMF.js");
+      const { checkAutoWakeGates } = await import("../daemon-orchestration-FR3LV4G3.js");
       const { ensureEmployee } = await import("./tmux-routing.js");
       const { shouldAutoInstance } = await import("./employees.js");
       const projectDir = process.cwd();
@@ -4551,7 +4637,7 @@ try {
       fired("task_group_barriers");
       if (!await ensureStoreForPolling()) return;
       try {
-        const { pollTaskGroupBarriers } = await import("../daemon-orchestration-BJ3T5MMF.js");
+        const { pollTaskGroupBarriers } = await import("../daemon-orchestration-FR3LV4G3.js");
         const firedCount = await pollTaskGroupBarriers();
         if (firedCount > 0) {
           acted("task_group_barriers");
@@ -4573,7 +4659,7 @@ try {
       fired("checkpoint_gc");
       if (!await ensureStoreForPolling()) return;
       try {
-        const { gcStaleCheckpoints } = await import("../daemon-orchestration-BJ3T5MMF.js");
+        const { gcStaleCheckpoints } = await import("../daemon-orchestration-FR3LV4G3.js");
         const cleared = await gcStaleCheckpoints();
         if (cleared > 0) {
           acted("checkpoint_gc");
@@ -4671,7 +4757,7 @@ try {
     fired("orphan_task_cleanup");
     try {
       if (!await ensureStoreForPolling()) return;
-      const { cleanOrphanedTaskFiles, checkTaskFileConsistency } = await import("../tasks-crud-DQOG2NPG.js");
+      const { cleanOrphanedTaskFiles, checkTaskFileConsistency } = await import("../tasks-crud-6GYPBGJP.js");
       const count = await cleanOrphanedTaskFiles();
       if (count > 0) {
         acted("orphan_task_cleanup");
@@ -4709,7 +4795,7 @@ try {
   const TELEMETRY_DAILY_MS = 24 * 60 * 60 * 1e3;
   const telemetryDaily = async () => {
     try {
-      const { sendTelemetry, isTelemetryEnabled } = await import("../telemetry-upload-OT5B5HUY.js");
+      const { sendTelemetry, isTelemetryEnabled } = await import("../telemetry-upload-NJ33742S.js");
       if (!isTelemetryEnabled()) return;
       const { upstream } = await sendTelemetry(24);
       if (upstream.startsWith("sent")) {

package/dist/lib/hybrid-search.js

@@ -5,8 +5,8 @@ import {
   recentRecords,
   rrfMerge,
   rrfMergeMulti
-} from "../chunk-2MNLSUC6.js";
-import "../chunk-222SI7QC.js";
+} from "../chunk-XGJ5QYBU.js";
+import "../chunk-5IQBMR2V.js";
 import "../chunk-CHCA3ZM2.js";
 import "../chunk-IZVKWBIP.js";
 import "../chunk-Y25OJWOQ.js";

package/dist/lib/messaging.js

@@ -14,8 +14,8 @@ import {
   sendMessage,
   sendTypedMessage,
   setWsClientSend
-} from "../chunk-DGBGIXCC.js";
-import "../chunk-F7JLZXHC.js";
+} from "../chunk-6BRFIYYW.js";
+import "../chunk-66AQSKG7.js";
 import "../chunk-ZKFPHJIJ.js";
 import "../chunk-5CHYEKMH.js";
 import "../chunk-4JERP7NT.js";

package/dist/lib/schedules.js

@@ -3,8 +3,8 @@ import {
   deleteSchedule,
   listSchedules,
   parseHumanCron
-} from "../chunk-DR5BGWFR.js";
-import "../chunk-222SI7QC.js";
+} from "../chunk-IPWA6HOZ.js";
+import "../chunk-5IQBMR2V.js";
 import "../chunk-CHCA3ZM2.js";
 import "../chunk-IZVKWBIP.js";
 import "../chunk-Y25OJWOQ.js";

package/dist/lib/store.js

@@ -13,7 +13,7 @@ import {
   updateMemoryStatus,
   vectorToBlob,
   writeMemory
-} from "../chunk-222SI7QC.js";
+} from "../chunk-5IQBMR2V.js";
 import "../chunk-CHCA3ZM2.js";
 import "../chunk-IZVKWBIP.js";
 import "../chunk-Y25OJWOQ.js";

package/dist/lib/tasks.js

@@ -2,8 +2,8 @@ import {
   createTask,
   deleteTask,
   updateTask
-} from "../chunk-NBY6R37W.js";
-import "../chunk-HOGTZLVU.js";
+} from "../chunk-A7UWQXYD.js";
+import "../chunk-AJAEUU76.js";
 import {
   cleanupOrphanedReviews,
   countNewPendingReviewsSince,
@@ -20,7 +20,7 @@ import {
   slugify,
   updateTaskStatus,
   writeCheckpoint
-} from "../chunk-F7JLZXHC.js";
+} from "../chunk-66AQSKG7.js";
 import "../chunk-ZKFPHJIJ.js";
 import "../chunk-5CHYEKMH.js";
 import "../chunk-4JERP7NT.js";

package/dist/lib/tmux-routing.js

@@ -20,7 +20,7 @@ import {
   sendIntercom,
   spawnEmployee,
   verifyPaneAtCapacity
-} from "../chunk-F7JLZXHC.js";
+} from "../chunk-66AQSKG7.js";
 import "../chunk-ZKFPHJIJ.js";
 import "../chunk-5CHYEKMH.js";
 import "../chunk-4JERP7NT.js";