crewswarm 0.9.1 → 0.9.3

package/lib/crew-lead/llm-caller.mjs

@@ -128,14 +128,11 @@ async function callGeminiCliForChat(messages) {
 }
 
 export async function _callLLMOnce(baseUrl, apiKey, modelId, providerKey, messages, options = {}) {
-  // OpenRouter requires full model ID (e.g. openrouter/hunter-alpha), not bare "hunter-alpha"
-  const isOpenRouter = providerKey === "openrouter" || baseUrl.includes("openrouter.ai");
-  if (isOpenRouter && modelId && !modelId.startsWith("openrouter/")) {
-    modelId = "openrouter/" + modelId;
-  }
+  modelId = normalizeExternalModelId(modelId, providerKey, baseUrl);
   const isAnthropic = providerKey === "anthropic" || baseUrl.includes("anthropic.com");
   const enableStreaming = options.stream || false;
   const onStreamToken = options.onStreamToken || null;
+  const requestTimeoutMs = Number(options.timeoutMs || _LLM_TIMEOUT) || _LLM_TIMEOUT;
   
   const headers = { "content-type": "application/json" };
   if (isAnthropic) {
@@ -150,9 +147,10 @@ export async function _callLLMOnce(baseUrl, apiKey, modelId, providerKey, messag
   const isOpenAI = providerKey === "openai" || baseUrl.includes("openai.com");
   
   // Gemini 2.5 Flash: input 1,048,576 tokens / output 65,536 tokens
-  // Anthropic Claude: output typically capped at 8,192 tokens
+  // Anthropic Claude varies by model; Haiku is stricter at 4,096 output tokens
   // All others: 4,096 safe default
-  const maxOutputTokens = isGemini ? 16384 : isAnthropic ? 8192 : 4096;
+  const anthropicMaxOutputTokens = /haiku/i.test(modelId) ? 4096 : 8192;
+  const maxOutputTokens = isGemini ? 16384 : isAnthropic ? anthropicMaxOutputTokens : 4096;
   
   let body, endpoint;
   
@@ -230,7 +228,7 @@ export async function _callLLMOnce(baseUrl, apiKey, modelId, providerKey, messag
     method: "POST",
     headers,
     body: JSON.stringify(body),
-    signal: AbortSignal.timeout(_LLM_TIMEOUT),
+    signal: AbortSignal.timeout(requestTimeoutMs),
   });
 
   if (!res.ok) {
@@ -321,6 +319,24 @@ export async function _callLLMOnce(baseUrl, apiKey, modelId, providerKey, messag
   return reply;
 }
 
+export function normalizeExternalModelId(modelId, providerKey, baseUrl = "") {
+  let normalized = String(modelId || "").trim();
+  if (!normalized) return normalized;
+
+  const isOpenRouter = providerKey === "openrouter" || baseUrl.includes("openrouter.ai");
+  const isPerplexity = providerKey === "perplexity" || baseUrl.includes("api.perplexity.ai");
+
+  if (isOpenRouter) {
+    normalized = normalized.replace(/^openrouter\//i, "");
+  }
+
+  if (isPerplexity) {
+    normalized = normalized.replace(/^perplexity\//i, "");
+  }
+
+  return normalized;
+}
+
 function _recordCrewLeadTokens(modelId, providerKey, usage) {
   if (!usage) return;
   const p = Number(usage.prompt_tokens || usage.input_tokens || 0);

package/lib/crew-lead/prompts.mjs

@@ -150,6 +150,13 @@ export function buildSystemPrompt(cfg) {
     `- With acceptance criteria: @@DISPATCH {"agent":"crew-coder","task":"Write JWT auth middleware","verify":"@@READ_FILE src/auth.ts","done":"exports verifyToken, returns 401 on invalid"}`,
     "- You MUST emit the @@DISPATCH line. Describing a dispatch in prose without the line = NOTHING happens.",
     "",
+    "ENGINE ROUTING: tasks are routed to CLI engines or direct-llm based on keyword matching.",
+    "- Tasks with coding keywords (create, build, implement, fix, refactor, add, update, modify, code, function, class, component, api, endpoint, route, test, bug, error, issue, file, script, module, package) → CLI engine (native file I/O, shell, full repo context).",
+    "- Tasks WITHOUT coding keywords → direct-llm (LLM API call; can still write files via @@WRITE_FILE markers, but no shell or repo context).",
+    "- CLI engines are better for complex multi-file coding. direct-llm is fine for research reports, single-file writes, and simple tasks.",
+    "- When dispatching build tasks, use verbs like 'Create', 'Build', 'Implement', 'Fix' to ensure CLI routing.",
+    "- This is automatic keyword matching — no LLM call. See docs/ORCHESTRATION-PROTOCOL.md for the full keyword list.",
+    "",
     "PIPELINE: when user wants multi-agent coordinated work.",
     "- Triggers: 'build me X', 'create X', 'kick off', 'rally the crew', 'dispatch the crew'.",
     "- Before firing for complex tasks (3+ agents / 2+ waves): show plan in 1-3 lines, ask 'Fire it?'. Skip confirmation for single-agent or explicit 'go build'.",

package/lib/crew-lead/wave-dispatcher.mjs

@@ -11,6 +11,8 @@ import { randomUUID } from "node:crypto";
 import { getStatePath, getConfigPath } from "../runtime/paths.mjs";
 import { normalizeProjectDir } from "../runtime/project-dir.mjs";
 import { loadProjectMessages } from "../chat/project-messages.mjs";
+import * as tmuxBridge from "../bridges/tmux-bridge.mjs";
+import * as sessionManager from "../sessions/session-manager.mjs";
 
 let _deps = {};
 
@@ -375,7 +377,17 @@ export function dispatchPipelineWave(pipelineId) {
   // this path: when Cursor CLI fails, orchestrator falls back to plain LLM text
   // with @mentions — subagents never run and the pipeline advances on garbage.
   // Direct per-agent dispatch is reliable for project pipelines.
-  if (_deps._cursorWavesEnabled && waveSteps.length > 1 && !pipeline.projectDir) {
+  // Only route through orchestrator if it has a CLI engine that can actually dispatch.
+  // Without a CLI engine, the orchestrator just describes dispatching in text — useless.
+  const orchestratorHasCliEngine = (() => {
+    try {
+      const agents = (_deps.loadAgentList || (() => []))();
+      const orch = agents.find(a => a.id === "crew-orchestrator");
+      if (!orch) return false;
+      return !!(orch.engine || orch.useClaudeCode || orch.useCursorCli || orch.useCursor || orch.useCodex || orch.useCrewCLI || orch.useGeminiCli || orch.useOpenCode);
+    } catch { return false; }
+  })();
+  if (_deps._cursorWavesEnabled && orchestratorHasCliEngine && waveSteps.length > 1 && !pipeline.projectDir) {
     const waveManifest = {
       wave: currentWave + 1,
       projectDir: pipeline.projectDir || "",
@@ -425,6 +437,11 @@ export function dispatchPipelineWave(pipelineId) {
       ...(step.verify ? { verify: step.verify } : {}),
       ...(step.done   ? { done:   step.done   } : {}),
     };
+    // Build session handoff metadata for tmux-bridge
+    const sessionMeta = {};
+    if (step.session) sessionMeta.session = step.session;
+    else if (pipeline._tmuxSessionId) sessionMeta.session = `handoff:${pipeline._tmuxSessionId}`;
+
     const taskId = dispatchTask(step.agent, stepSpec, sessionId, {
       pipelineId,
       waveIndex: currentWave,
@@ -434,6 +451,7 @@ export function dispatchPipelineWave(pipelineId) {
       originThreadId: pipeline.originThreadId,
       originMessageId: pipeline.originMessageId,
       triggeredBy: pipeline.triggeredBy || "pipeline",
+      ...sessionMeta,
     });
     if (taskId && taskId !== true) pipeline.pendingTaskIds.add(taskId);
   }
@@ -694,8 +712,10 @@ export function dispatchTask(agent, task, sessionId = "owner", pipelineMeta = nu
     task = _deps.writeTaskBrief?.(agent, task, projectDir) ?? task;
   }
 
-  const rp = typeof _deps.getRtPublish === "function" ? _deps.getRtPublish() : null;
-  console.log(`[wave-dispatcher] getRtPublish exists: ${typeof _deps.getRtPublish === "function"}, rp is: ${typeof rp}`);
+  let rp = typeof _deps.getRtPublish === "function" ? _deps.getRtPublish() : null;
+  if (!rp && typeof _deps.getRtPublish === "function") {
+    console.warn(`[wave-dispatcher] RT publish not available for ${agent} — will use fallback`);
+  }
   if (rp) {
     try {
       // Build extraFlags: start with global settings, override with pipeline-specific settings
@@ -762,6 +782,36 @@ export function dispatchTask(agent, task, sessionId = "owner", pipelineMeta = nu
       if (pipelineMeta?.mentionedBy) extraFlags.mentionedBy = pipelineMeta.mentionedBy;
       if (pipelineMeta?.autonomous !== undefined) extraFlags.autonomous = pipelineMeta.autonomous;
 
+      // ── tmux session handoff ──────────────────────────────────────────────
+      // If pipelineMeta carries a tmux session, hand it off to this agent
+      // or create a new one if session: "persist" is set.
+      if (tmuxBridge.detect()) {
+        const sessionSpec = pipelineMeta?.session;
+        if (typeof sessionSpec === "string" && sessionSpec.startsWith("handoff:")) {
+          const existingSessionId = sessionSpec.slice("handoff:".length);
+          const prevOwner = sessionManager.getSession(existingSessionId)?.owner;
+          if (prevOwner) {
+            sessionManager.handoff(existingSessionId, prevOwner, agent);
+          }
+          const meta = sessionManager.getSession(existingSessionId);
+          if (meta?.paneId) extraFlags.tmuxSessionId = meta.paneId;
+        } else if (sessionSpec === "persist") {
+          const newSessionId = sessionManager.create({
+            workspaceId: pipelineMeta?.pipelineId || "default",
+            agentId: agent,
+            cwd: pipelineMeta?.projectDir || undefined,
+          });
+          if (newSessionId) {
+            const meta = sessionManager.getSession(newSessionId);
+            if (meta?.paneId) extraFlags.tmuxSessionId = meta.paneId;
+            // Store session ID on pipeline meta so next wave can handoff
+            if (pipelineMeta) pipelineMeta._tmuxSessionId = newSessionId;
+          }
+        } else if (pipelineMeta?.tmuxSessionId) {
+          extraFlags.tmuxSessionId = pipelineMeta.tmuxSessionId;
+        }
+      }
+
       // Log enrichment for verification
       const engineFlags = Object.keys(extraFlags).filter(k => k.startsWith('use') || k.includes('Model') || k === 'engine');
       if (engineFlags.length > 0) {

package/lib/crew-lead/ws-router.mjs

@@ -7,6 +7,60 @@ import { applyProjectDirToPipelineSteps } from "../dispatch/parsers.mjs";
 let reconnectTimer = null;
 let isConnecting = false;
 let crewLeadHeartbeat = null;
+let currentWs = null;        // Global ref to current WebSocket — prevents stale closures
+let connectionId = 0;        // Monotonic ID to detect stale connections
+let reconnectAttempts = 0;   // For exponential backoff
+
+const CODER_AGENT_RE = /crew-coder|crew-frontend|crew-fixer|crew-ml|crew-coder-back|crew-coder-front/;
+
+function normalizeEngineId(value) {
+    const raw = String(value || "").trim().toLowerCase();
+    if (!raw) return null;
+    if (raw === "claude" || raw === "claude-code" || raw.includes("claude code")) return "claude";
+    if (raw === "codex" || raw === "codex-cli" || raw.includes("codex")) return "codex";
+    if (raw === "cursor" || raw === "cursor-cli" || raw.includes("cursor")) return "cursor";
+    return null;
+}
+
+export function inferDispatchEngine(dispatch = null, message = "") {
+    const explicit =
+        normalizeEngineId(dispatch?.engineUsed)
+        || normalizeEngineId(dispatch?.runtime)
+        || (dispatch?.useCodex === true ? "codex" : null)
+        || (dispatch?.useCursorCli === true ? "cursor" : null)
+        || (dispatch?.useClaudeCode === true ? "claude" : null);
+    if (explicit) return explicit;
+
+    const text = String(message || "");
+    if (/claude\s*code|anthropic|sonnet|opus/i.test(text)) return "claude";
+    if (/codex|gpt-5(\.\d+)?-codex|openai/i.test(text)) return "codex";
+    if (/cursor/i.test(text)) return "cursor";
+    return null;
+}
+
+export function getNextCoderEngine(currentEngine) {
+    const current = normalizeEngineId(currentEngine);
+    if (current === "claude") return "codex";
+    if (current === "codex") return "claude";
+    if (current === "cursor") return null;
+    return "codex";
+}
+
+export function buildEngineFallbackMeta(dispatch = null, currentEngine = null, trigger = "rate-limit-fallback") {
+    const nextEngine = getNextCoderEngine(currentEngine);
+    if (!nextEngine) return null;
+
+    return {
+        ...(dispatch || {}),
+        useClaudeCode: nextEngine === "claude",
+        useCodex: nextEngine === "codex",
+        useCursorCli: nextEngine === "cursor",
+        runtime: nextEngine,
+        engineFallbackFrom: normalizeEngineId(currentEngine),
+        engineFallbackTo: nextEngine,
+        triggeredBy: trigger,
+    };
+}
 
 export function initWsRouter(deps) {
     const {
@@ -29,6 +83,7 @@ export function initWsRouter(deps) {
         appendHistory,
         pendingPipelines,
         handleAutonomousMentions,
+        saveProjectMessage,
         checkWaveQualityGate,
         failPipelineOnQualityGate,
         savePipelineState,
@@ -40,6 +95,25 @@ export function initWsRouter(deps) {
         autonomousPmLoopSessions
     } = deps;
 
+    function scheduleReconnect() {
+        if (reconnectTimer) clearTimeout(reconnectTimer);
+        // Exponential backoff: 1s, 2s, 4s, 8s, ... capped at 30s
+        const delay = Math.min(1000 * Math.pow(2, reconnectAttempts), 30000);
+        reconnectAttempts++;
+        console.log(`[crew-lead] RT reconnecting in ${delay}ms (attempt ${reconnectAttempts})`);
+        reconnectTimer = setTimeout(connectRT, delay);
+    }
+
+    function cleanupConnection() {
+        if (crewLeadHeartbeat) { clearInterval(crewLeadHeartbeat); crewLeadHeartbeat = null; }
+        setRtPublish(null);
+        // Close old WebSocket and remove all listeners to prevent leaks
+        if (currentWs) {
+            try { currentWs.removeAllListeners(); currentWs.close(); } catch {}
+            currentWs = null;
+        }
+    }
+
     function connectRT() {
         if (isConnecting) {
             console.log("[crew-lead] Already connecting to RT, skipping duplicate call");
@@ -51,17 +125,27 @@ export function initWsRouter(deps) {
             reconnectTimer = null;
         }
 
+        // Clean up any previous connection before creating a new one (#1, #8)
+        cleanupConnection();
+
         isConnecting = true;
+        const thisConnId = ++connectionId;
         const ws = new WebSocket(RT_URL);
+        currentWs = ws;
 
         ws.on("open", () => {
+            if (thisConnId !== connectionId) return; // stale (#7)
             console.log("[crew-lead] RT socket open");
             isConnecting = false;
         });
 
         ws.on("message", (raw) => {
+            if (thisConnId !== connectionId) return; // stale (#7)
             let p;
-            try { p = JSON.parse(raw.toString()); } catch { return; }
+            try { p = JSON.parse(raw.toString()); } catch (parseErr) {
+                console.warn(`[crew-lead] RT message parse failed: ${parseErr.message} (${raw.toString().slice(0, 80)})`); // #15
+                return;
+            }
 
             if (p.type === "server.hello") {
                 ws.send(JSON.stringify({ type: "hello", agent: "crew-lead", token: RT_TOKEN }));
@@ -69,10 +153,27 @@ export function initWsRouter(deps) {
             }
             if (p.type === "hello.ack") {
                 ws.send(JSON.stringify({ type: "subscribe", channels: ["done", "events", "command", "issues", "status"] }));
+                reconnectAttempts = 0; // Reset backoff on successful connection (#12)
 
+                // rtPublish always uses currentWs, not a captured closure (#6)
                 setRtPublish(({ channel, type, to, payload }) => {
                     const taskId = crypto.randomUUID();
-                    ws.send(JSON.stringify({ type: "publish", channel, messageType: type, to, taskId, priority: "high", payload }));
+                    const activeWs = currentWs;
+                    if (!activeWs || activeWs.readyState !== WebSocket.OPEN) {
+                        console.error(`[crew-lead] RT ws not open (state=${activeWs?.readyState}) — triggering reconnect`);
+                        setRtPublish(null);
+                        scheduleReconnect();
+                        return null;
+                    }
+                    try {
+                        activeWs.send(JSON.stringify({ type: "publish", channel, messageType: type, to, taskId, priority: "high", payload }));
+                    } catch (sendErr) {
+                        console.error(`[crew-lead] RT ws.send failed (${sendErr.message}) — triggering reconnect`);
+                        setRtPublish(null);
+                        try { activeWs.close(); } catch {}
+                        scheduleReconnect();
+                        return null;
+                    }
                     return taskId;
                 });
 
@@ -80,16 +181,42 @@ export function initWsRouter(deps) {
                 setTimeout(resumePipelines, 2000);
                 startBackgroundLoop();
 
+                // Heartbeat with failure detection (#3, #5, #10)
                 if (crewLeadHeartbeat) clearInterval(crewLeadHeartbeat);
+                let missedHeartbeats = 0;
                 crewLeadHeartbeat = setInterval(() => {
+                    if (thisConnId !== connectionId) {
+                        clearInterval(crewLeadHeartbeat);
+                        crewLeadHeartbeat = null;
+                        return;
+                    }
                     try {
+                        if (!currentWs || currentWs.readyState !== WebSocket.OPEN) {
+                            missedHeartbeats++;
+                            console.warn(`[crew-lead] Heartbeat skipped — ws not open (missed=${missedHeartbeats})`);
+                            if (missedHeartbeats >= 3) {
+                                console.error(`[crew-lead] 3 missed heartbeats — triggering reconnect`);
+                                cleanupConnection();
+                                scheduleReconnect();
+                            }
+                            return;
+                        }
+                        missedHeartbeats = 0;
                         const taskId = crypto.randomUUID();
-                        ws.send(JSON.stringify({
+                        currentWs.send(JSON.stringify({
                             type: "publish", channel: "status", messageType: "agent.heartbeat",
                             to: "broadcast", taskId, priority: "low",
                             payload: { agent: "crew-lead", ts: new Date().toISOString() },
                         }));
-                    } catch { }
+                    } catch (hbErr) {
+                        console.warn(`[crew-lead] Heartbeat send failed: ${hbErr.message}`);
+                        missedHeartbeats++;
+                        if (missedHeartbeats >= 3) {
+                            console.error(`[crew-lead] 3 heartbeat failures — triggering reconnect`);
+                            cleanupConnection();
+                            scheduleReconnect();
+                        }
+                    }
                 }, 30000);
                 return;
             }
@@ -103,7 +230,10 @@ export function initWsRouter(deps) {
 
             if (p.type === "message" && p.envelope) {
                 const env = p.envelope;
-                if (env.id) ws.send(JSON.stringify({ type: "ack", messageId: env.id, status: "received" }));
+                if (env.id) {
+                    try { ws.send(JSON.stringify({ type: "ack", messageId: env.id, status: "received" })); }
+                    catch (ackErr) { console.warn(`[crew-lead] Ack send failed for ${env.id}: ${ackErr.message}`); }
+                }
 
                 const from = env.from || env.sender_agent_id || env.payload?.source || "";
                 const msgType = env.messageType || env.type || "";
@@ -154,8 +284,22 @@ export function initWsRouter(deps) {
                     emitTaskLifecycle("failed", { taskId: failedTaskId, agentId: failedAgent, taskType: "task", error: { message: errMsg } });
                     const dispatch = pendingDispatches.get(failedTaskId);
                     if (dispatch && RATE_LIMIT_PATTERN.test(errMsg)) {
-                        const fallback = getRateLimitFallback(failedAgent);
                         const targetSession = dispatch.sessionId || "owner";
+                        const currentEngine = inferDispatchEngine({ ...dispatch, engineUsed: env.payload?.engineUsed || dispatch.engineUsed }, errMsg);
+                        const engineFallbackMeta = CODER_AGENT_RE.test(failedAgent)
+                            ? buildEngineFallbackMeta(dispatch, currentEngine, "rate-limit-engine-fallback")
+                            : null;
+                        if (engineFallbackMeta) {
+                            pendingDispatches.delete(failedTaskId);
+                            const newTaskId = dispatchTask(failedAgent, dispatch.task, targetSession, engineFallbackMeta);
+                            if (newTaskId) {
+                                appendHistory("default", targetSession, "system", `[crew-lead] ${failedAgent} hit rate limit on ${currentEngine || "current engine"} (${errMsg.slice(0, 80)}). Re-dispatched same task on ${engineFallbackMeta.engineFallbackTo}.`);
+                                broadcastSSE({ type: "agent_reply", from: "crew-lead", content: `Rate limit: retried ${failedAgent} on ${engineFallbackMeta.engineFallbackTo}.`, sessionId: targetSession, taskId: failedTaskId, ts: Date.now() });
+                                console.log(`[crew-lead] Rate limit engine fallback: ${failedAgent} ${currentEngine || "unknown"} → ${engineFallbackMeta.engineFallbackTo}`);
+                                return;
+                            }
+                        }
+                        const fallback = getRateLimitFallback(failedAgent);
                         if (fallback !== failedAgent) {
                             pendingDispatches.delete(failedTaskId);
                             const newTaskId = dispatchTask(fallback, dispatch.task, targetSession, { ...dispatch, pipelineId: dispatch.pipelineId, waveIndex: dispatch.waveIndex });
@@ -183,12 +327,10 @@ export function initWsRouter(deps) {
                         setTimeout(() => pendingDispatches.delete(taskId), 600_000);
                     }
 
-                    const _autoRetryKey = `_question_retried_${taskId}`;
                     const _askedQuestion = /(?:would you like|shall i|should i|do you want|want me to|may i|can i proceed|would it help|do you need|is that correct|shall we|ready to proceed|would you prefer|let me know|please (?:confirm|clarify|specify|advise))\??/i.test(content);
                     const _didWork = /@@WRITE_FILE|@@RUN_CMD|wrote|created|updated|fixed|patched|done\.|complete/i.test(content);
-                    if (_askedQuestion && !_didWork && !pendingPipelines.has(dispatch?.pipelineId) && !global[_autoRetryKey]) {
-                        global[_autoRetryKey] = true;
-                        setTimeout(() => { delete global[_autoRetryKey]; }, 600_000);
+                    if (_askedQuestion && !_didWork && !pendingPipelines.has(dispatch?.pipelineId) && !dispatch?._questionRetried) {
+                        if (dispatch) dispatch._questionRetried = true;
                         const _originalTask = dispatch?.task || "";
                         const _retryTask = (_originalTask.slice(0, 2000) || content.slice(0, 500)) +
                             "\n\nDo NOT ask for permission or confirmation. Proceed immediately with your best judgment. Just do it.";
@@ -204,15 +346,13 @@ export function initWsRouter(deps) {
                         return;
                     }
 
-                    const _planRetryKey = `_plan_retried_${taskId}`;
-                    const _isCoderAgent = /crew-coder|crew-frontend|crew-fixer|crew-ml|crew-coder-back|crew-coder-front/.test(from);
+                    const _isCoderAgent = CODER_AGENT_RE.test(from);
                     const _returnedPlan = !_didWork && content.length > 300 && (
                         /##\s+(component|feature|file structure|design|breakdown|overview|plan|approach|implementation plan|technical spec)/i.test(content) ||
                         /here'?s? (?:the|my|a|what|how)/i.test(content.slice(0, 200))
                     );
-                    if (_isCoderAgent && _returnedPlan && !global[_planRetryKey]) {
-                        global[_planRetryKey] = true;
-                        setTimeout(() => { delete global[_planRetryKey]; }, 600_000);
+                    if (_isCoderAgent && _returnedPlan && !dispatch?._planRetried) {
+                        if (dispatch) dispatch._planRetried = true;
                         const _originalTask = dispatch?.task || "";
                         const _retryTask = `STOP PLANNING. Your last response was a plan/analysis with no code written.\n\nOriginal task: ${_originalTask.slice(0, 1500)}\n\nNow WRITE THE CODE. Use @@WRITE_FILE for every file. Do not describe what you will do — do it.`;
                         console.log(`[crew-lead] Agent ${from} returned a plan instead of code — auto-retrying`);
@@ -229,17 +369,20 @@ export function initWsRouter(deps) {
                         return;
                     }
 
-                    const _bailRetryKey = `_bail_retried_${taskId}`;
                     const _bailed = /couldn'?t complete|could not complete|i'?m sorry[,.]? but|i was unable to|i'?m unable to|session (?:limit|ended|expired)|ran out of|context (?:limit|window)|i (?:apologize|regret)|partial(?:ly)? complete|not (?:all|every|fully) (?:changes?|tasks?|items?|fixes?)/i.test(content);
-                    if (_bailed && !global[_bailRetryKey]) {
-                        global[_bailRetryKey] = true;
-                        setTimeout(() => { delete global[_bailRetryKey]; }, 600_000);
+                    if (_bailed && !dispatch?._bailRetried) {
+                        if (dispatch) dispatch._bailRetried = true;
                         const _originalTask = dispatch?.task || "";
-                        const fallbackAgent = _isCoderAgent ? from : (getRateLimitFallback(from) || from);
+                        const currentEngine = inferDispatchEngine(dispatch, content);
+                        const engineFallbackMeta = _isCoderAgent
+                            ? buildEngineFallbackMeta(dispatch, currentEngine, "auto-retry-bail")
+                            : null;
+                        const fallbackAgent = engineFallbackMeta ? from : (_isCoderAgent ? from : (getRateLimitFallback(from) || from));
                         const _retryTask = `Your previous attempt at this task was incomplete. You said you couldn't finish.\n\nOriginal task:\n${_originalTask.slice(0, 2000)}\n\nDo not apologize. Do not explain why you couldn't finish. Just complete the remaining work now. Use @@WRITE_FILE for every file you change. If the task is too large, complete the most critical items first.`;
-                        console.log(`[crew-lead] Agent ${from} bailed out mid-task — auto-retrying with ${fallbackAgent}`);
-                        appendHistory("default", targetSession, "system", `${from} bailed mid-task — auto-retrying with ${fallbackAgent}.`);
+                        console.log(`[crew-lead] Agent ${from} bailed out mid-task — auto-retrying with ${engineFallbackMeta?.engineFallbackTo || fallbackAgent}`);
+                        appendHistory("default", targetSession, "system", `${from} bailed mid-task — auto-retrying with ${engineFallbackMeta?.engineFallbackTo || fallbackAgent}.`);
                         dispatchTask(fallbackAgent, _retryTask, targetSession, {
+                            ...(engineFallbackMeta || {}),
                             ...(dispatch?.pipelineId ? { pipelineId: dispatch.pipelineId } : {}),
                             ...(dispatch?.projectDir ? { projectDir: dispatch.projectDir } : {}),
                             originProjectId: dispatch?.originProjectId,
@@ -283,6 +426,31 @@ export function initWsRouter(deps) {
                     }
 
                     const originChannel = dispatch?.originChannel || dispatch?.originProjectId || null;
+
+                    // Persist agent result to project messages so swarm chat history is complete
+                    if (originChannel && saveProjectMessage) {
+                        try {
+                            saveProjectMessage(originChannel, {
+                                source: "agent",
+                                role: "assistant",
+                                content: content.slice(0, 8000),
+                                agent: from,
+                                threadId: dispatch?.originThreadId || `${originChannel}:${targetSession}`,
+                                parentId: dispatch?.originMessageId || null,
+                                metadata: {
+                                    agentName: from,
+                                    autonomous: true,
+                                    engineUsed: env.payload?.engineUsed || null,
+                                    durationMs: dispatch?.ts ? Date.now() - dispatch.ts : null,
+                                    triggeredBy: dispatch?.triggeredBy || "dispatch",
+                                    taskId,
+                                },
+                            });
+                        } catch (e) {
+                            console.warn(`[crew-lead] Failed to save agent result to project messages: ${e.message}`);
+                        }
+                    }
+
                     if (originChannel) {
                         void handleAutonomousMentions({
                             message: { content },
@@ -293,6 +461,9 @@ export function initWsRouter(deps) {
                             projectDir: dispatch?.projectDir || null,
                             originMessageId: dispatch?.originMessageId || null,
                             originThreadId: dispatch?.originThreadId || `${originChannel}:${targetSession}`,
+                            appendToChatHistory: (entry) => {
+                                appendHistory("default", targetSession, "system", entry.content || String(entry));
+                            },
                             broadcastSSE,
                         }).catch((err) => {
                             console.warn(`[crew-lead] Autonomous mention routing failed for ${from}: ${err.message}`);
@@ -325,6 +496,27 @@ export function initWsRouter(deps) {
                         }
                     }
 
+                    // Parse @@DISPATCH markers from any agent result (not just crew-pm).
+                    // This lets crew-orchestrator (and others) fan out tasks via @@DISPATCH
+                    // even when running on direct-llm without CLI tools.
+                    if (from !== "crew-pm" && content.includes("@@DISPATCH")) {
+                        const agentDispatches = parseDispatches(content);
+                        for (const d of agentDispatches) {
+                            const ok = dispatchTask(d.agent, d, targetSession, {
+                                originProjectId: dispatch?.originProjectId || dispatch?.projectId || "general",
+                                originChannel: dispatch?.originChannel || dispatch?.projectId || "general",
+                                originThreadId: dispatch?.originThreadId || `${dispatch?.originProjectId || dispatch?.projectId || "general"}:${targetSession}`,
+                                originMessageId: dispatch?.originMessageId || null,
+                                projectDir: d.projectDir || dispatch?.projectDir || null,
+                                triggeredBy: `${from}-dispatch`,
+                            });
+                            if (ok) {
+                                console.log(`[crew-lead] ${from} dispatched to ${d.agent}: "${(d.task || "").slice(0, 120)}"`);
+                                appendHistory("default", targetSession, "system", `${from} dispatched to ${d.agent}: "${(d.task || "").slice(0, 120)}".`);
+                            }
+                        }
+                    }
+
                     if (from === "crew-pm") {
                         const pipelineSpec = parsePipeline(content);
                         if (pipelineSpec) {
@@ -410,17 +602,17 @@ export function initWsRouter(deps) {
         });
 
         ws.on("close", () => {
-            setRtPublish(null);
+            if (thisConnId !== connectionId) return; // stale close event
+            cleanupConnection();
             isConnecting = false;
-            if (crewLeadHeartbeat) { clearInterval(crewLeadHeartbeat); crewLeadHeartbeat = null; }
-            console.log("[crew-lead] RT disconnected — reconnecting in 5s");
-            if (reconnectTimer) clearTimeout(reconnectTimer);
-            reconnectTimer = setTimeout(connectRT, 5000);
+            console.log("[crew-lead] RT disconnected");
+            scheduleReconnect();
         });
 
         ws.on("error", (e) => {
             console.error("[crew-lead] RT socket error:", e.message);
             isConnecting = false;
+            // close event will fire after error — reconnect happens there
         });
     }
 

package/lib/engines/engine-registry.mjs

@@ -7,6 +7,7 @@ import fs from "node:fs";
 import path from "node:path";
 import os from "node:os";
 import { loadAgentList as _defaultLoadAgentList } from "../runtime/config.mjs";
+import { isCodingTask } from "../agents/dispatch.mjs";
 
 const ENGINES_BUNDLED_DIR = path.join(path.dirname(new URL(import.meta.url).pathname), "..", "..", "engines");
 const ENGINES_USER_DIR = path.join(os.homedir(), ".crewswarm", "engines");
@@ -153,6 +154,14 @@ function evaluateShouldUse(engineDef, payload, incomingType) {
  * Select engine: payload flags → payload runtime → per-agent crewswarm.json → fallback rules
  */
 export function selectEngine(payload, incomingType) {
+  // PRIORITY 0: Chat messages always use direct LLM, not CLI engines.
+  // CLI engines (claude-code, cursor, codex, etc.) are only for coding tasks.
+  // The agent's configured model handles conversational replies directly.
+  const prompt = payload?.prompt || payload?.task || payload?.message || "";
+  if (!isCodingTask(incomingType, prompt, payload)) {
+    return null;
+  }
+
   // PRIORITY 1: Payload flags (from enriched task)
   const explicitEngines = [
     { key: 'useCodex', id: 'codex' },

package/lib/engines/rt-envelope.mjs

@@ -1612,6 +1612,7 @@ export async function handleRealtimeEnvelope(envelope, client, bridge) {
       payload: {
         source: CREWSWARM_RT_AGENT,
         error: message,
+        engineUsed: typeof engineUsed !== "undefined" ? engineUsed : null,
         idempotencyKey: dispatchKey,
         attempt: dispatchAttempt,
       },