crewswarm 0.9.0 → 0.9.2

package/lib/bridges/tmux-bridge.mjs

@@ -0,0 +1,200 @@
+/**
+ * tmux-bridge adapter — thin wrapper around smux's tmux-bridge CLI
+ *
+ * Provides agent-to-agent pane communication when running inside a tmux session
+ * with smux installed. All functions degrade to no-ops when unavailable.
+ *
+ * Opt-in: requires $TMUX set, `tmux-bridge` on PATH, and
+ *   CREWSWARM_TMUX_BRIDGE=1 env var (or tmuxBridge: true in system config).
+ */
+
+import { execFileSync, execSync } from "node:child_process";
+
+function which(bin) {
+  try { execSync(`which ${bin}`, { stdio: "ignore" }); return true; } catch { return false; }
+}
+
+// ── Detection & caching ─────────────────────────────────────────────────────
+
+let _available = null;
+let _ownPaneId = null;
+const _resolveCache = new Map(); // label → { paneId, ts }
+const RESOLVE_TTL_MS = 30_000;
+const TMUX_BRIDGE_BIN = process.env.SMUX_BRIDGE_BIN || "tmux-bridge";
+
+function exec(args, { timeout = 5000 } = {}) {
+  try {
+    return execFileSync(TMUX_BRIDGE_BIN, args, {
+      encoding: "utf8",
+      timeout,
+      stdio: ["ignore", "pipe", "pipe"],
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Check if tmux-bridge is available and opted-in.
+ * Result is cached for the process lifetime.
+ */
+export function detect() {
+  if (_available !== null) return _available;
+
+  // Must be inside a tmux session
+  if (!process.env.TMUX) {
+    _available = false;
+    return false;
+  }
+
+  // Must have tmux-bridge binary
+  if (!which(TMUX_BRIDGE_BIN)) {
+    _available = false;
+    return false;
+  }
+
+  // Must be opted-in via env var or config
+  const envFlag = process.env.CREWSWARM_TMUX_BRIDGE;
+  if (!envFlag || envFlag === "0" || envFlag === "false") {
+    _available = false;
+    return false;
+  }
+
+  _available = true;
+  return true;
+}
+
+/**
+ * Get this process's own tmux pane ID.
+ * @returns {string|null} e.g. "%3"
+ */
+export function id() {
+  if (!detect()) return null;
+  if (_ownPaneId) return _ownPaneId;
+  _ownPaneId = exec(["id"]);
+  return _ownPaneId;
+}
+
+/**
+ * Label a pane with an agent ID so other agents can discover it.
+ * @param {string} agentId - CrewSwarm agent ID (e.g. "crew-coder")
+ * @param {string} [paneId] - Target pane ID. Defaults to own pane.
+ * @returns {boolean} success
+ */
+export function label(agentId, paneId) {
+  if (!detect()) return false;
+  const target = paneId || id();
+  if (!target) return false;
+  const result = exec(["name", target, agentId]);
+  if (result !== null) {
+    // Update cache
+    _resolveCache.set(agentId, { paneId: target, ts: Date.now() });
+    return true;
+  }
+  return false;
+}
+
+/**
+ * Resolve an agent ID to a tmux pane ID.
+ * @param {string} agentId
+ * @returns {string|null} pane ID or null
+ */
+export function resolve(agentId) {
+  if (!detect()) return null;
+
+  // Check cache
+  const cached = _resolveCache.get(agentId);
+  if (cached && (Date.now() - cached.ts) < RESOLVE_TTL_MS) {
+    return cached.paneId;
+  }
+
+  const paneId = exec(["resolve", agentId]);
+  if (paneId) {
+    _resolveCache.set(agentId, { paneId, ts: Date.now() });
+  }
+  return paneId;
+}
+
+/**
+ * Read the last N lines from an agent's pane.
+ * Also satisfies the read-guard requirement for subsequent sends.
+ * @param {string} agentId
+ * @param {number} [lines=50]
+ * @returns {string|null} pane content or null
+ */
+export function read(agentId, lines = 50) {
+  if (!detect()) return null;
+  const paneId = resolve(agentId);
+  if (!paneId) return null;
+  const output = exec(["read", paneId, String(lines)]);
+  return output;
+}
+
+/**
+ * Send text to an agent's pane followed by Enter.
+ * Reads the pane before each write command to satisfy tmux-bridge's read-guard
+ * (the guard is consumed on every type/keys call).
+ * @param {string} agentId
+ * @param {string} text
+ * @returns {boolean} success
+ */
+export function send(agentId, text) {
+  if (!detect()) return false;
+  const paneId = resolve(agentId);
+  if (!paneId) return false;
+
+  // Read-guard is consumed on each type/keys call, so read before each one
+  exec(["read", paneId, "1"]);
+  const typeResult = exec(["type", paneId, text]);
+  if (typeResult === null) return false;
+
+  exec(["read", paneId, "1"]);
+  const keyResult = exec(["keys", paneId, "Enter"]);
+  return keyResult !== null;
+}
+
+/**
+ * List all tmux panes with their labels and metadata.
+ * @returns {Array<{paneId: string, label: string, raw: string}>}
+ */
+export function list() {
+  if (!detect()) return [];
+  const raw = exec(["list"]);
+  if (!raw) return [];
+
+  // Parse tmux-bridge list output:
+  //   TARGET   SESSION:WIN      SIZE       PROCESS                   LABEL      CWD
+  //   %0       crewtest:0       120x29     -zsh                      crew-coder ~/CrewSwarm
+  const lines = raw.split("\n").filter(Boolean);
+  // Skip header row (starts with "TARGET")
+  return lines
+    .filter(line => line.trimStart().startsWith("%"))
+    .map(line => {
+      const parts = line.split(/\s+/).filter(Boolean);
+      return {
+        paneId: parts[0] || "",
+        session: parts[1] || "",
+        size: parts[2] || "",
+        process: parts[3] || "",
+        label: (parts[4] && parts[4] !== "-") ? parts[4] : "",
+        cwd: parts[5] || "",
+        raw: line,
+      };
+    });
+}
+
+/**
+ * Clear the resolve cache (useful after pane layout changes).
+ */
+export function clearCache() {
+  _resolveCache.clear();
+}
+
+/**
+ * Reset detection state (for testing).
+ */
+export function _reset() {
+  _available = null;
+  _ownPaneId = null;
+  clearCache();
+}

package/lib/chat/unified-history.mjs

@@ -66,7 +66,7 @@ export function loadUnifiedHistory(contactId, maxMessages = 2000) {
           const files = readdirSync(telegramDir);
           
           // Find all topic files for this chat
-          // Format: -1003624332545-topic-20.jsonl, -1003624332545-topic-94.jsonl, etc.
+          // Format: -100XXXXXXXXXX-topic-20.jsonl, -100XXXXXXXXXX-topic-94.jsonl, etc.
           const topicPattern = new RegExp(`^-?\\d+-topic-\\d+\\.jsonl$`);
           const topicFiles = files.filter(f => topicPattern.test(f));
           

package/lib/cli-process-tracker.mjs

@@ -160,7 +160,8 @@ export function getActiveProcesses() {
     idleFor: now - proc.lastActivity,
     outputLines: proc.outputLines,
     chatId: proc.chatId,
-    sessionId: proc.sessionId
+    sessionId: proc.sessionId,
+    tmuxSessionId: proc.tmuxSessionId || null
   }));
 }
 

package/lib/crew-lead/http-server.mjs

@@ -1087,6 +1087,7 @@ export function createAndStartServer(PORT) {
     bgConsciousnessIntervalMs,
     cursorWavesRef,
     claudeCodeRef,
+    tmuxBridgeRef,
   } = _deps;
 
   // Debug: verify critical deps
@@ -1208,7 +1209,7 @@ export function createAndStartServer(PORT) {
           projectId = body.projectId || url.searchParams.get("projectId"); // Support query param too
           projectDir = body.projectDir || null;
           userId = body.userId || "default";
-          targetAgent = body.targetAgent; // Per-user routing from WhatsApp/Telegram
+          targetAgent = body.targetAgent || body.agentId || null; // Per-user routing from WhatsApp/Telegram/Dashboard
           channelMode = body.channelMode === true;
         } catch (e) {
           json(res, 400, {
@@ -4580,6 +4581,46 @@ export function createAndStartServer(PORT) {
         }
       }
 
+      // GET/POST /api/settings/tmux-bridge — toggle tmux-bridge session layer at runtime
+      if (url.pathname === "/api/settings/tmux-bridge") {
+        if (!checkBearer(req)) {
+          json(res, 401, { ok: false, error: "Unauthorized" });
+          return;
+        }
+        if (req.method === "GET") {
+          json(res, 200, { ok: true, enabled: tmuxBridgeRef?.enabled ?? false });
+          return;
+        }
+        if (req.method === "POST") {
+          const body = await readBody(req);
+          const enable =
+            typeof body.enabled === "boolean"
+              ? body.enabled
+              : !(tmuxBridgeRef?.enabled ?? false);
+          if (tmuxBridgeRef) tmuxBridgeRef.enabled = enable;
+          try {
+            const cfgPath = path.join(
+              os.homedir(),
+              ".crewswarm",
+              "crewswarm.json",
+            );
+            const cfg = JSON.parse(fs.readFileSync(cfgPath, "utf8"));
+            cfg.tmuxBridge = enable;
+            fs.writeFileSync(cfgPath, JSON.stringify(cfg, null, 2));
+          } catch (e) {
+            console.warn(
+              "[crew-lead] Could not persist tmuxBridge:",
+              e.message,
+            );
+          }
+          console.log(
+            `[crew-lead] tmux-bridge ${enable ? "ENABLED" : "DISABLED"} via dashboard`,
+          );
+          json(res, 200, { ok: true, enabled: tmuxBridgeRef?.enabled ?? enable });
+          return;
+        }
+      }
+
       // GET/POST /api/settings/global-fallback — set/get global OpenCode fallback model
       if (url.pathname === "/api/settings/global-fallback") {
         if (!checkBearer(req)) {
@@ -4680,6 +4721,250 @@ export function createAndStartServer(PORT) {
         }
       }
 
+      // ── Missing settings endpoints (bulk implementation) ─────────────────────
+
+      // Helper: read/write crewswarm.json for simple boolean/string settings
+      const cfgPath = path.join(os.homedir(), ".crewswarm", "crewswarm.json");
+      function readCfg() {
+        try { return JSON.parse(fs.readFileSync(cfgPath, "utf8")); } catch { return {}; }
+      }
+      function writeCfg(cfg) {
+        fs.writeFileSync(cfgPath, JSON.stringify(cfg, null, 2));
+      }
+      function whichBin(bin) {
+        try {
+          const r = spawn("which", [bin], { stdio: "ignore" });
+          // spawn is async but we can check if the binary exists via fs
+          const paths = (process.env.PATH || "").split(":");
+          return paths.some(p => { try { fs.accessSync(path.join(p, bin), fs.constants.X_OK); return true; } catch { return false; } });
+        } catch { return false; }
+      }
+
+      // GET/POST /api/settings/autonomous-mentions
+      if (url.pathname === "/api/settings/autonomous-mentions") {
+        if (!checkBearer(req)) { json(res, 401, { ok: false, error: "Unauthorized" }); return; }
+        if (req.method === "GET") {
+          const cfg = readCfg();
+          const enabled = cfg.settings?.autonomousMentionsEnabled !== false;
+          json(res, 200, { ok: true, enabled });
+          return;
+        }
+        if (req.method === "POST") {
+          const body = await readBody(req);
+          const cfg = readCfg();
+          if (!cfg.settings) cfg.settings = {};
+          cfg.settings.autonomousMentionsEnabled = typeof body.enabled === "boolean" ? body.enabled : true;
+          writeCfg(cfg);
+          console.log(`[crew-lead] Autonomous mentions ${cfg.settings.autonomousMentionsEnabled ? "ENABLED" : "DISABLED"} via dashboard`);
+          json(res, 200, { ok: true, enabled: cfg.settings.autonomousMentionsEnabled });
+          return;
+        }
+      }
+
+      // GET/POST /api/settings/codex
+      if (url.pathname === "/api/settings/codex") {
+        if (!checkBearer(req)) { json(res, 401, { ok: false, error: "Unauthorized" }); return; }
+        if (req.method === "GET") {
+          const cfg = readCfg();
+          const enabled = cfg.codexEnabled === true || /^1|true|yes$/i.test(String(process.env.CREWSWARM_CODEX_ENABLED || ""));
+          json(res, 200, { ok: true, enabled });
+          return;
+        }
+        if (req.method === "POST") {
+          const body = await readBody(req);
+          const cfg = readCfg();
+          const enable = typeof body.enabled === "boolean" ? body.enabled : !cfg.codexEnabled;
+          cfg.codexEnabled = enable;
+          writeCfg(cfg);
+          console.log(`[crew-lead] Codex executor ${enable ? "ENABLED" : "DISABLED"} via dashboard`);
+          json(res, 200, { ok: true, enabled: enable });
+          return;
+        }
+      }
+
+      // GET/POST /api/settings/gemini-cli
+      if (url.pathname === "/api/settings/gemini-cli") {
+        if (!checkBearer(req)) { json(res, 401, { ok: false, error: "Unauthorized" }); return; }
+        if (req.method === "GET") {
+          const cfg = readCfg();
+          const enabled = cfg.geminiCliEnabled === true || /^1|true|yes$/i.test(String(process.env.CREWSWARM_GEMINI_CLI_ENABLED || ""));
+          const installed = whichBin("gemini");
+          json(res, 200, { ok: true, enabled, installed });
+          return;
+        }
+        if (req.method === "POST") {
+          const body = await readBody(req);
+          const cfg = readCfg();
+          const enable = typeof body.enabled === "boolean" ? body.enabled : !cfg.geminiCliEnabled;
+          cfg.geminiCliEnabled = enable;
+          writeCfg(cfg);
+          console.log(`[crew-lead] Gemini CLI ${enable ? "ENABLED" : "DISABLED"} via dashboard`);
+          json(res, 200, { ok: true, enabled: enable, installed: whichBin("gemini") });
+          return;
+        }
+      }
+
+      // GET/POST /api/settings/crew-cli
+      if (url.pathname === "/api/settings/crew-cli") {
+        if (!checkBearer(req)) { json(res, 401, { ok: false, error: "Unauthorized" }); return; }
+        if (req.method === "GET") {
+          const cfg = readCfg();
+          const enabled = cfg.crewCliEnabled === true || /^1|true|yes$/i.test(String(process.env.CREWSWARM_CREW_CLI_ENABLED || ""));
+          json(res, 200, { ok: true, enabled });
+          return;
+        }
+        if (req.method === "POST") {
+          const body = await readBody(req);
+          const cfg = readCfg();
+          const enable = typeof body.enabled === "boolean" ? body.enabled : !cfg.crewCliEnabled;
+          cfg.crewCliEnabled = enable;
+          writeCfg(cfg);
+          console.log(`[crew-lead] Crew CLI ${enable ? "ENABLED" : "DISABLED"} via dashboard`);
+          json(res, 200, { ok: true, enabled: enable });
+          return;
+        }
+      }
+
+      // GET/POST /api/settings/opencode
+      if (url.pathname === "/api/settings/opencode") {
+        if (!checkBearer(req)) { json(res, 401, { ok: false, error: "Unauthorized" }); return; }
+        if (req.method === "GET") {
+          const cfg = readCfg();
+          const enabled = cfg.opencodeEnabled === true || /^1|true|yes$/i.test(String(process.env.CREWSWARM_OPENCODE_ENABLED || ""));
+          const installed = whichBin("opencode");
+          json(res, 200, { ok: true, enabled, installed });
+          return;
+        }
+        if (req.method === "POST") {
+          const body = await readBody(req);
+          const cfg = readCfg();
+          const enable = typeof body.enabled === "boolean" ? body.enabled : !cfg.opencodeEnabled;
+          cfg.opencodeEnabled = enable;
+          writeCfg(cfg);
+          console.log(`[crew-lead] OpenCode ${enable ? "ENABLED" : "DISABLED"} via dashboard`);
+          json(res, 200, { ok: true, enabled: enable, installed: whichBin("opencode") });
+          return;
+        }
+      }
+
+      // GET/POST /api/settings/global-oc-loop
+      if (url.pathname === "/api/settings/global-oc-loop") {
+        if (!checkBearer(req)) { json(res, 401, { ok: false, error: "Unauthorized" }); return; }
+        if (req.method === "GET") {
+          const cfg = readCfg();
+          const enabled = cfg.engineLoop === true || /^1|true|yes$/i.test(String(process.env.CREWSWARM_ENGINE_LOOP || ""));
+          const maxRounds = cfg.engineLoopMaxRounds ?? parseInt(process.env.CREWSWARM_ENGINE_LOOP_MAX_ROUNDS || "10", 10);
+          json(res, 200, { ok: true, enabled, maxRounds });
+          return;
+        }
+        if (req.method === "POST") {
+          const body = await readBody(req);
+          const cfg = readCfg();
+          if (typeof body.enabled === "boolean") cfg.engineLoop = body.enabled;
+          if (body.maxRounds !== undefined) cfg.engineLoopMaxRounds = parseInt(body.maxRounds, 10) || 10;
+          writeCfg(cfg);
+          console.log(`[crew-lead] Engine loop: enabled=${cfg.engineLoop ?? false}, maxRounds=${cfg.engineLoopMaxRounds ?? 10}`);
+          json(res, 200, { ok: true, enabled: cfg.engineLoop ?? false, maxRounds: cfg.engineLoopMaxRounds ?? 10 });
+          return;
+        }
+      }
+
+      // GET/POST /api/settings/passthrough-notify
+      if (url.pathname === "/api/settings/passthrough-notify") {
+        if (!checkBearer(req)) { json(res, 401, { ok: false, error: "Unauthorized" }); return; }
+        if (req.method === "GET") {
+          const cfg = readCfg();
+          json(res, 200, { ok: true, value: cfg.passthroughNotify || "both" });
+          return;
+        }
+        if (req.method === "POST") {
+          const body = await readBody(req);
+          const cfg = readCfg();
+          cfg.passthroughNotify = body.value || "both";
+          writeCfg(cfg);
+          console.log(`[crew-lead] Passthrough notify → ${cfg.passthroughNotify}`);
+          json(res, 200, { ok: true, value: cfg.passthroughNotify });
+          return;
+        }
+      }
+
+      // GET/POST /api/settings/loop-brain
+      if (url.pathname === "/api/settings/loop-brain") {
+        if (!checkBearer(req)) { json(res, 401, { ok: false, error: "Unauthorized" }); return; }
+        if (req.method === "GET") {
+          const cfg = readCfg();
+          json(res, 200, { ok: true, loopBrain: cfg.loopBrain || "" });
+          return;
+        }
+        if (req.method === "POST") {
+          const body = await readBody(req);
+          const cfg = readCfg();
+          cfg.loopBrain = body.loopBrain || "";
+          writeCfg(cfg);
+          console.log(`[crew-lead] Loop brain → ${cfg.loopBrain || "(cleared)"}`);
+          json(res, 200, { ok: true, loopBrain: cfg.loopBrain });
+          return;
+        }
+      }
+
+      // GET /api/settings/openclaw-status
+      if (url.pathname === "/api/settings/openclaw-status" && req.method === "GET") {
+        if (!checkBearer(req)) { json(res, 401, { ok: false, error: "Unauthorized" }); return; }
+        const cfg = readCfg();
+        const installed = !!(cfg.openClaw?.enabled || cfg.openclaw?.gatewayUrl || process.env.OPENCLAW_GATEWAY_URL);
+        json(res, 200, { ok: true, installed });
+        return;
+      }
+
+      // GET/POST /api/settings/rt-token
+      if (url.pathname === "/api/settings/rt-token") {
+        if (!checkBearer(req)) { json(res, 401, { ok: false, error: "Unauthorized" }); return; }
+        if (req.method === "GET") {
+          const cfg = readCfg();
+          const token = cfg.rtToken || process.env.CREWSWARM_RT_AUTH_TOKEN || "";
+          json(res, 200, { ok: true, token: token ? true : false });
+          return;
+        }
+        if (req.method === "POST") {
+          const body = await readBody(req);
+          if (!body.token) { json(res, 400, { ok: false, error: "No token provided" }); return; }
+          const cfg = readCfg();
+          cfg.rtToken = body.token;
+          writeCfg(cfg);
+          console.log("[crew-lead] RT token saved via dashboard");
+          json(res, 200, { ok: true, saved: true });
+          return;
+        }
+      }
+
+      // GET /api/config/lock-status, POST /api/config/lock, POST /api/config/unlock
+      if (url.pathname === "/api/config/lock-status" && req.method === "GET") {
+        if (!checkBearer(req)) { json(res, 401, { ok: false, error: "Unauthorized" }); return; }
+        const lockFile = path.join(os.homedir(), ".crewswarm", ".config.lock");
+        json(res, 200, { ok: true, locked: fs.existsSync(lockFile) });
+        return;
+      }
+      if (url.pathname === "/api/config/lock" && req.method === "POST") {
+        if (!checkBearer(req)) { json(res, 401, { ok: false, error: "Unauthorized" }); return; }
+        const lockFile = path.join(os.homedir(), ".crewswarm", ".config.lock");
+        try {
+          fs.writeFileSync(lockFile, new Date().toISOString());
+          console.log("[crew-lead] Config LOCKED via dashboard");
+          json(res, 200, { ok: true, locked: true });
+        } catch (e) { json(res, 500, { ok: false, error: e.message }); }
+        return;
+      }
+      if (url.pathname === "/api/config/unlock" && req.method === "POST") {
+        if (!checkBearer(req)) { json(res, 401, { ok: false, error: "Unauthorized" }); return; }
+        const lockFile = path.join(os.homedir(), ".crewswarm", ".config.lock");
+        try {
+          fs.unlinkSync(lockFile);
+          console.log("[crew-lead] Config UNLOCKED via dashboard");
+        } catch {}
+        json(res, 200, { ok: true, locked: false });
+        return;
+      }
+
       // POST /api/spending/reset — reset today's spending counters
       if (url.pathname === "/api/spending/reset" && req.method === "POST") {
         if (!checkBearer(req)) {

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 = {};
 
@@ -397,12 +399,11 @@ export function dispatchPipelineWave(pipelineId) {
       `Fan out all ${waveSteps.length} tasks simultaneously and return combined results.`,
     ].join("\n");
 
-    console.log(`[crew-lead] CURSOR_WAVES: routing wave ${currentWave + 1} through crew-orchestrator (${waveSteps.length} parallel tasks)`);
-    const taskId = dispatchTask("crew-orchestrator", { task: orchestratorTask, runtime: "cursor-cli" }, sessionId, {
+    console.log(`[crew-lead] WAVE_DISPATCH: routing wave ${currentWave + 1} through crew-orchestrator (${waveSteps.length} parallel tasks)`);
+    const taskId = dispatchTask("crew-orchestrator", { task: orchestratorTask }, sessionId, {
       pipelineId,
       waveIndex: currentWave,
       projectDir: pipeline.projectDir,
-      useCursorCli: true,
       originProjectId: pipeline.originProjectId,
       originChannel: pipeline.originChannel,
       originThreadId: pipeline.originThreadId,
@@ -426,6 +427,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,
@@ -435,6 +441,7 @@ export function dispatchPipelineWave(pipelineId) {
       originThreadId: pipeline.originThreadId,
       originMessageId: pipeline.originMessageId,
       triggeredBy: pipeline.triggeredBy || "pipeline",
+      ...sessionMeta,
     });
     if (taskId && taskId !== true) pipeline.pendingTaskIds.add(taskId);
   }
@@ -763,6 +770,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/engines/crew-cli.mjs

@@ -71,11 +71,12 @@ export async function runCrewCLITask(prompt, payload = {}) {
       ""
   );
 
-  // Resolve project directory
-  const projectDir =
+  // Resolve project directory — must be a string (Sandbox requires it)
+  const rawDir =
     payload?.projectDir ||
     (getOpencodeProjectDir ? getOpencodeProjectDir() : null) ||
     process.cwd();
+  const projectDir = typeof rawDir === "string" && rawDir.trim() ? rawDir.trim() : process.cwd();
 
   // Ensure API keys are in env
   const providers = loadProviders();

package/lib/engines/llm-direct.mjs

@@ -10,7 +10,10 @@ export async function callLLMDirect(prompt, ocAgentId, systemPrompt) {
     recordTokenUsage, loadProviderMap,
   } = _deps;
   const llm = loadAgentLLMConfig(ocAgentId);
-  if (!llm) return null; // fall through to legacy gateway
+  if (!llm) {
+    console.error(`[llm-direct] loadAgentLLMConfig("${ocAgentId}") returned null. _deps set: ${!!_deps.loadAgentLLMConfig}. CREWSWARM_RT_AGENT=${process.env.CREWSWARM_RT_AGENT}`);
+    return null; // fall through to legacy gateway
+  }
 
   // ── Spending cap pre-check ─────────────────────────────────────────────────
   const capResult = checkSpendingCap(ocAgentId, llm.providerKey || llm.modelId.split("/")[0]);

package/lib/engines/rt-envelope.mjs

@@ -908,19 +908,28 @@ export async function handleRealtimeEnvelope(envelope, client, bridge) {
       } else {
         // ── No coding engine assigned — use direct LLM (agent's configured model) ──
         engineUsed = "direct-llm";
-        const ocAgentId = CREWSWARM_RT_AGENT;
-        const agentSysPrompt = loadAgentPrompts()[ocAgentId] || null;
-        const agentCfg = getAgentOpenCodeConfig(CREWSWARM_RT_AGENT);
+        // Use the DISPATCHED agent's ID, not the gateway's own identity.
+        // When a gateway process handles a task for crew-researcher, it needs
+        // crew-researcher's model config (perplexity/sonar), not its own.
+        // The target agent is in envelope.to, payload.agentId, or payload.agent.
+        const dispatchedAgent = String(
+          payload?.agentId || payload?.agent || to || ""
+        ).trim();
+        const ocAgentId = (dispatchedAgent && dispatchedAgent !== "broadcast")
+          ? dispatchedAgent
+          : CREWSWARM_RT_AGENT;
+        const agentSysPrompt = loadAgentPrompts()[ocAgentId] || loadAgentPrompts()[CREWSWARM_RT_AGENT] || null;
+        const agentCfg = getAgentOpenCodeConfig(ocAgentId);
         modelUsed = agentCfg?.model || payload?.model || "unknown";
 
         console.error(
           `[${CREWSWARM_RT_AGENT}] 🧠 Direct LLM route (no coding engine): agent=${ocAgentId}, model=${modelUsed}`,
         );
-        progress(`Routing to direct LLM (no coding engine assigned)...`);
+        progress(`Routing to direct LLM (${ocAgentId} → ${modelUsed})...`);
         telemetry("realtime_route_direct_llm", {
           taskId,
           incomingType,
-          agent: CREWSWARM_RT_AGENT,
+          agent: ocAgentId,
           model: modelUsed,
         });