crewswarm 0.9.2 → 0.9.4

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/crew-cli.mjs

@@ -111,7 +111,7 @@ export async function runCrewCLITask(prompt, payload = {}) {
   const engine = await getEngine();
 
   // Create sandbox pointed at the project directory
-  const sandbox = new engine.Sandbox({ baseDir: projectDir });
+  const sandbox = new engine.Sandbox(projectDir);
 
   // Run the agentic executor directly — THINK→ACT→OBSERVE loop with 34 tools
   const result = await engine.runAgenticWorker(prompt, sandbox, {

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,7 +154,9 @@ function evaluateShouldUse(engineDef, payload, incomingType) {
  * Select engine: payload flags → payload runtime → per-agent crewswarm.json → fallback rules
  */
 export function selectEngine(payload, incomingType) {
-  // PRIORITY 1: Payload flags (from enriched task)
+  const prompt = payload?.prompt || payload?.task || payload?.message || "";
+
+  // PRIORITY 1: Payload flags (from enriched task) — always respected regardless of prompt content
   const explicitEngines = [
     { key: 'useCodex', id: 'codex' },
     { key: 'useCursor', id: 'cursor' },
@@ -186,7 +189,9 @@ export function selectEngine(payload, incomingType) {
     }
   }
 
-  // PRIORITY 2.3: Per-agent engine from crewswarm.json (`engine` + use* flags), not global env alone
+  // PRIORITY 2.3: Per-agent engine from crewswarm.json (`engine` + use* flags) — always respected.
+  // Agents that explicitly opt into an engine (useGeminiCli, useClaudeCode, etc.) should always
+  // use it, even for non-coding prompts like "reply with exactly X".
   const preferredFromCfg = resolveAgentPreferredEngineId(payload);
   if (preferredFromCfg) {
     const preferredEngine = _engines.find((e) => e.id === preferredFromCfg);
@@ -195,7 +200,13 @@ export function selectEngine(payload, incomingType) {
     }
   }
 
-  // PRIORITY 2.5: If agent explicitly opted out of ALL CLI engines, skip fallback — use direct LLM
+  // PRIORITY 2.5: Chat messages and non-coding tasks always use direct LLM for fallback routing.
+  // Only applies when no explicit engine was configured above.
+  if (!isCodingTask(incomingType, prompt, payload)) {
+    return null;
+  }
+
+  // PRIORITY 2.6: If agent explicitly opted out of ALL CLI engines, skip fallback — use direct LLM
   const agentId = String(payload?.agentId || payload?.agent || "").toLowerCase();
   if (agentId && _loadAgentList) {
     try {

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,
       },

package/lib/engines/runners.mjs

@@ -27,6 +27,19 @@ function which(bin) {
   try { execSync(`which ${bin}`, { stdio: "ignore" }); return true; } catch { return false; }
 }
 
+function isClaudeOauthAuthenticated() {
+  try {
+    const output = execSync(`${CLAUDE_CODE_BIN} auth status`, { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] })
+      .trim()
+      .toLowerCase();
+    if (!output) return false;
+    if (/"loggedin"\s*:\s*true/.test(output)) return true;
+    return output.includes("logged in");
+  } catch {
+    return false;
+  }
+}
+
 // ── Module-level deps (injected via initRunners) ───────────────────────────
 let _getAgentOpenCodeConfig = () => ({ enabled: false, useCursorCli: false, cursorCliModel: null, claudeCodeModel: null });
 let _loadAgentList = () => [];
@@ -1076,7 +1089,7 @@ export async function runDockerSandboxTask(prompt, payload = {}) {
 
     let innerArgs;
     if (innerEngine === "opencode") {
-      innerArgs = ["opencode", "run", titledPrompt, "--model", process.env.CREWSWARM_OPENCODE_MODEL || "anthropic/claude-sonnet-4-5"];
+      innerArgs = ["opencode", "run", titledPrompt, "--model", process.env.CREWSWARM_OPENCODE_MODEL || "openai/gpt-5.4"];
     } else if (innerEngine === "codex") {
       innerArgs = ["codex", "exec", "--sandbox", "workspace-write", "--json", titledPrompt];
     } else {
@@ -1181,6 +1194,7 @@ export async function runClaudeCodeTask(prompt, payload = {}) {
     const agentPrefix = agentId ? `[${agentId}]` : "";
     const titledPrompt = agentPrefix ? `${agentPrefix} ${String(prompt)}` : String(prompt);
 
+    const emptyMcpCfg = path.join(os.homedir(), ".crewswarm", "config", "empty-mcp.json");
     const args = [
       "-p",
       "--dangerously-skip-permissions",
@@ -1205,21 +1219,31 @@ export async function runClaudeCodeTask(prompt, payload = {}) {
       }
     }
     
-    // CRITICAL: Claude Code expects the prompt as a command-line argument, NOT via stdin
-    args.push(titledPrompt);
+    // Skip user MCP servers to avoid 30s+ init hangs
+    args.push("--strict-mcp-config", "--mcp-config", emptyMcpCfg);
+    // -- separates flags from prompt (--mcp-config is variadic and eats positional args)
+    args.push("--", titledPrompt);
 
     if (!which(CLAUDE_CODE_BIN)) {
       throw new Error(`Claude Code CLI not found: "${CLAUDE_CODE_BIN}". Install with: npm i -g @anthropic-ai/claude-code`);
     }
+    if (!isClaudeOauthAuthenticated()) {
+      console.error(`[ClaudeCode:${agentId}] auth preflight reported logged out; continuing and letting Claude decide at runtime.`);
+    }
 
     console.error(`[ClaudeCode:${agentId}] Running: ${CLAUDE_CODE_BIN} -p --dangerously-skip-permissions (cwd=${projectDir})`);
 
     _rtClientForApprovals?.publish({ channel: "events", type: "agent_working", to: "broadcast",
       payload: { agent: agentId, model: model || "claude/auto", ts: Date.now() } });
 
+    const childEnv = { ...process.env };
+    delete childEnv.ANTHROPIC_API_KEY;
+    delete childEnv.CLAUDECODE;
+    delete childEnv.CLAUDE_CODE;
+
     const child = spawn(CLAUDE_CODE_BIN, args, {
       cwd: projectDir,
-      env: process.env,
+      env: childEnv,
       stdio: ["ignore", "pipe", "pipe"],  // Changed from "pipe" to "ignore" for stdin since we use args
     });
 

package/lib/gemini-cli-passthrough-noise.mjs

@@ -33,5 +33,5 @@ export function filterGeminiPassthroughTextChunk(engine, text) {
   if (engine !== "gemini" && engine !== "gemini-cli") return String(text ?? "");
   const s = String(text ?? "");
   if (!s) return s;
-  return s.split("\n").filter((ln) => !shouldSkipGeminiPassthroughLine(ln)).join("\n");
+  return s.split("\n").filter((ln) => !shouldSkipGeminiPassthroughLine(ln)).map((ln) => ln.replace(/\r$/, "")).join("\n");
 }

package/lib/integrations/code-search.mjs

@@ -198,7 +198,8 @@ export function formatSearchResults(searchResults, maxChars = 4000) {
  */
 export async function findFiles(pattern, projectDir = process.cwd()) {
   try {
-    const output = execSync(`rg --files | rg "${pattern}"`, {
+    const safePattern = pattern.replace(/["`$\\]/g, '\\$&');
+    const output = execSync(`rg --files | rg "${safePattern}"`, {
       cwd: projectDir,
       encoding: 'utf8',
       stdio: ['pipe', 'pipe', 'ignore']
@@ -247,7 +248,7 @@ export async function findFunctions(name, projectDir = process.cwd()) {
   // Escape special regex characters in name
   const escapedName = name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
   const pattern = `(function|const|let|export)\\s+${escapedName}`;
-  return await searchPattern(pattern, projectDir, { fileTypes: ['js', 'ts', 'mjs'] });
+  return await searchPattern(pattern, projectDir, { fileTypes: ['js', 'ts'] });
 }
 
 /**
@@ -255,5 +256,5 @@ export async function findFunctions(name, projectDir = process.cwd()) {
  */
 export async function findClasses(name, projectDir = process.cwd()) {
   const pattern = `class\\s+${name}\\s*[{(]`;
-  return await searchPattern(pattern, projectDir, { fileTypes: ['js', 'ts', 'mjs'] });
+  return await searchPattern(pattern, projectDir, { fileTypes: ['js', 'ts'] });
 }

package/lib/memory/shared-adapter.mjs

@@ -36,6 +36,19 @@ try {
 // Shared memory root (env var or default)
 export const CREW_MEMORY_DIR = process.env.CREW_MEMORY_DIR || path.join(os.homedir(), '.crewswarm', 'shared-memory');
 
+// Cache project-messages-rag module to avoid dynamic import() on every call
+let _projectMessagesRag = null;
+async function getProjectMessagesRag() {
+  if (_projectMessagesRag === null) {
+    try {
+      _projectMessagesRag = await import('../chat/project-messages-rag.mjs');
+    } catch {
+      _projectMessagesRag = false; // mark as unavailable
+    }
+  }
+  return _projectMessagesRag || null;
+}
+
 /**
  * Get or create AgentKeeper instance for task memory.
  * @param {string} projectDir - Project root directory
@@ -143,8 +156,8 @@ export async function recallMemoryContext(projectDir, query, options = {}) {
   // This lets agents see past discussions about the same topic
   if (options.projectId) {
     try {
-      const { getConversationContext } = await import('../chat/project-messages-rag.mjs');
-      const conversationContext = getConversationContext(options.projectId, query, 3);
+      const ragModule = await getProjectMessagesRag();
+      const conversationContext = ragModule?.getConversationContext(options.projectId, query, 3);
       
       if (conversationContext) {
         memoryContext += (memoryContext ? '\n\n' : '') + conversationContext;
@@ -264,21 +277,21 @@ export async function migrateBrainToMemory(brainPath, agentId = 'crew-lead') {
       
       // Extract tags from markdown list items
       const tags = [];
-      let content = trimmed;
+      let factContent = trimmed;
       
       // Extract date tags (YYYY-MM-DD)
-      const dateMatch = content.match(/\b(\d{4}-\d{2}-\d{2})\b/);
+      const dateMatch = factContent.match(/\b(\d{4}-\d{2}-\d{2})\b/);
       if (dateMatch) tags.push('dated', dateMatch[1]);
-      
+
       // Extract agent mentions
-      const agentMatch = content.match(/\b(crew-\w+)\b/);
+      const agentMatch = factContent.match(/\b(crew-\w+)\b/);
       if (agentMatch) tags.push('agent', agentMatch[1]);
-      
+
       // Determine criticality (heuristic: lines with CRITICAL, ERROR, WARNING, or !)
-      const critical = /\b(CRITICAL|ERROR|WARNING|!)\b/i.test(content) || content.includes('MUST') || content.includes('NEVER');
-      
+      const critical = /\b(CRITICAL|ERROR|WARNING|!)\b/i.test(factContent) || factContent.includes('MUST') || factContent.includes('NEVER');
+
       try {
-        memory.remember(content, {
+        memory.remember(factContent, {
           critical,
           tags: tags.length > 0 ? tags : ['brain-migration'],
           provider: 'brain-migration'

package/lib/pipeline/manager.mjs

@@ -20,7 +20,7 @@ function tryRead(p) {
 
 export const pendingProjects = new Map();
 
-export function initPipelineManager({ dashboard, broadcastSSE, appendHistory, handleChat, loadConfig }) {
+export function initPipelineManager({ dashboard, broadcastSSE, appendHistory, handleChat, loadConfig } = {}) {
   if (dashboard !== undefined) _dashboard = dashboard;
   if (broadcastSSE) _broadcastSSE = broadcastSSE;
   if (appendHistory) _appendHistory = appendHistory;
@@ -502,6 +502,7 @@ export function parseRoadmapPhases(content) {
 }
 
 export function findNextRoadmapPhase(projectDir) {
+  if (!projectDir) return null;
   const roadmapPath = path.join(projectDir, "ROADMAP.md");
   if (!fs.existsSync(roadmapPath)) return null;
   try {

package/lib/runtime/config.mjs

@@ -185,7 +185,7 @@ export const CREWSWARM_CLAUDE_CODE = (() => {
 export const CREWSWARM_OPENCODE_FORCE = process.env.CREWSWARM_OPENCODE_FORCE === "1";
 export const CREWSWARM_OPENCODE_BIN = process.env.CREWSWARM_OPENCODE_BIN || path.join(os.homedir(), ".opencode", "bin", "opencode");
 export const CREWSWARM_OPENCODE_AGENT = process.env.CREWSWARM_OPENCODE_AGENT || "admin";
-export const CREWSWARM_OPENCODE_MODEL = process.env.CREWSWARM_OPENCODE_MODEL || "groq/moonshotai/kimi-k2-instruct-0905";
+export const CREWSWARM_OPENCODE_MODEL = process.env.CREWSWARM_OPENCODE_MODEL || "openai/gpt-5.4";
 export const CREWSWARM_OPENCODE_FALLBACK_DEFAULT = "groq/llama-3.3-70b-versatile";
 export const CREWSWARM_OPENCODE_TIMEOUT_MS = Number(process.env.CREWSWARM_OPENCODE_TIMEOUT_MS || "300000");