crewswarm 0.9.0 → 0.9.2

package/lib/engines/runners.mjs

@@ -21,6 +21,7 @@ import { initEngineRegistry, selectEngine as registrySelectEngine, getEngineById
 import { runCrewCLITask } from "./crew-cli.mjs";
 import { normalizeProjectDir } from "../runtime/project-dir.mjs";
 import { resolveCursorLaunchSpec } from "./cursor-launcher.mjs";
+import * as tmuxBridge from "../bridges/tmux-bridge.mjs";
 
 function which(bin) {
   try { execSync(`which ${bin}`, { stdio: "ignore" }); return true; } catch { return false; }
@@ -357,6 +358,11 @@ export async function runGeminiCliTask(prompt, payload = {}) {
       stdio: ["ignore", "pipe", "pipe"],
     });
 
+    // Label tmux pane with agent ID for cross-agent discovery
+    if (payload?.tmuxSessionId && tmuxBridge.detect()) {
+      try { tmuxBridge.label(agentId, payload.tmuxSessionId); } catch {}
+    }
+
     let lineBuffer = "";
     let accumulatedText = "";
     let orphanStream = "";
@@ -683,6 +689,11 @@ export async function runCursorCliTask(prompt, payload = {}) {
       stdio: ["ignore", "pipe", "pipe"],
     });
 
+    // Label tmux pane with agent ID for cross-agent discovery
+    if (payload?.tmuxSessionId && tmuxBridge.detect()) {
+      try { tmuxBridge.label(agentId, payload.tmuxSessionId); } catch {}
+    }
+
     let lineBuffer = "";
     let accumulatedText = "";
     let lastCursorAssistantNorm = "";
@@ -915,6 +926,11 @@ export async function runCodexTask(prompt, payload = {}) {
       stdio: ["ignore", "pipe", "pipe"],
     });
 
+    // Label tmux pane with agent ID for cross-agent discovery
+    if (payload?.tmuxSessionId && tmuxBridge.detect()) {
+      try { tmuxBridge.label(agentId, payload.tmuxSessionId); } catch {}
+    }
+
     let lineBuffer = "";
     let accumulatedText = "";
     /** Non-JSON lines (stderr, errors, usage) — previously swallowed by catch {} */
@@ -1178,10 +1194,15 @@ export async function runClaudeCodeTask(prompt, payload = {}) {
       args.push("--model", model);
     }
 
-    const existingSession = readClaudeSessionId(agentId);
-    if (existingSession) {
-      args.push("--resume", existingSession);
-      console.error(`[ClaudeCode:${agentId}] Resuming session ${existingSession}`);
+    // Only resume session if explicitly requested (e.g. conversational follow-up).
+    // Pipeline/dispatch tasks should start fresh to avoid prior context poisoning simple tasks.
+    const shouldResume = payload?.resumeSession === true;
+    if (shouldResume) {
+      const existingSession = readClaudeSessionId(agentId);
+      if (existingSession) {
+        args.push("--resume", existingSession);
+        console.error(`[ClaudeCode:${agentId}] Resuming session ${existingSession}`);
+      }
     }
     
     // CRITICAL: Claude Code expects the prompt as a command-line argument, NOT via stdin
@@ -1202,6 +1223,11 @@ export async function runClaudeCodeTask(prompt, payload = {}) {
       stdio: ["ignore", "pipe", "pipe"],  // Changed from "pipe" to "ignore" for stdin since we use args
     });
 
+    // Label tmux pane with agent ID for cross-agent discovery
+    if (payload?.tmuxSessionId && tmuxBridge.detect()) {
+      try { tmuxBridge.label(agentId, payload.tmuxSessionId); } catch {}
+    }
+
     let lineBuffer = "";
     let accumulatedText = "";
     let stderrText = "";

package/lib/runtime/config.mjs

@@ -290,6 +290,13 @@ export function loadClaudeCodeEnabled() {
   if (typeof cfg.claudeCode === "boolean") return cfg.claudeCode;
   return false;
 }
+
+export function loadTmuxBridgeEnabled() {
+  if (process.env.CREWSWARM_TMUX_BRIDGE) return /^1|true|yes$/i.test(String(process.env.CREWSWARM_TMUX_BRIDGE));
+  const cfg = loadSystemConfig();
+  if (typeof cfg.tmuxBridge === "boolean") return cfg.tmuxBridge;
+  return false;
+}
 // ── Configuration Parsers (Migrated from registry.mjs) ───────────────────
 export function resolveConfig() {
   const paths = [CREWSWARM_CONFIG_PATH, path.join(LEGACY_STATE_DIR, "openclaw.json")];

package/lib/sessions/session-manager.mjs

@@ -0,0 +1,287 @@
+/**
+ * Session Manager — persistent tmux sessions as first-class execution resources
+ *
+ * Manages session lifecycle: create, attach, exec, lock, handoff, terminate.
+ * One writer per session (lock enforcement). Transcripts logged for auditability.
+ *
+ * Sessions are stored as metadata files under ~/.crewswarm/state/sessions/.
+ * The actual tmux sessions are managed via tmux CLI.
+ */
+
+import { execSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+import { getStatePath } from "../runtime/paths.mjs";
+import * as tmuxBridge from "../bridges/tmux-bridge.mjs";
+
+const SESSION_DIR = getStatePath("sessions");
+const TRANSCRIPT_DIR = getStatePath("sessions", "transcripts");
+
+try { fs.mkdirSync(SESSION_DIR, { recursive: true }); } catch {}
+try { fs.mkdirSync(TRANSCRIPT_DIR, { recursive: true }); } catch {}
+
+// ── Helpers ──────────────────────────────────────────────────────────────────
+
+function sessionMetaPath(sessionId) {
+  return path.join(SESSION_DIR, `${sessionId}.json`);
+}
+
+function transcriptPath(sessionId) {
+  return path.join(TRANSCRIPT_DIR, `${sessionId}.jsonl`);
+}
+
+function loadMeta(sessionId) {
+  try {
+    return JSON.parse(fs.readFileSync(sessionMetaPath(sessionId), "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+function saveMeta(sessionId, meta) {
+  try {
+    fs.writeFileSync(sessionMetaPath(sessionId), JSON.stringify(meta, null, 2));
+  } catch (e) {
+    console.error(`[session-manager] Failed to save meta for ${sessionId}: ${e.message}`);
+  }
+}
+
+function appendTranscript(sessionId, entry) {
+  try {
+    const line = JSON.stringify({ ts: new Date().toISOString(), ...entry });
+    fs.appendFileSync(transcriptPath(sessionId), line + "\n");
+  } catch {}
+}
+
+function tmuxExec(cmd, timeout = 5000) {
+  try {
+    return execSync(cmd, { encoding: "utf8", timeout, stdio: ["ignore", "pipe", "pipe"] }).trim();
+  } catch {
+    return null;
+  }
+}
+
+// ── Public API ───────────────────────────────────────────────────────────────
+
+/**
+ * Create a new persistent tmux session for agent work.
+ * @param {object} opts
+ * @param {string} opts.workspaceId - Logical workspace name
+ * @param {string} opts.agentId - Owning agent
+ * @param {string} [opts.cwd] - Working directory
+ * @param {Record<string, string>} [opts.env] - Extra env vars
+ * @returns {string|null} sessionId or null on failure
+ */
+export function create({ workspaceId, agentId, cwd, env } = {}) {
+  if (!tmuxBridge.detect()) return null;
+
+  const sessionId = `cs-${workspaceId}-${randomUUID().slice(0, 8)}`;
+  const sessionName = sessionId;
+
+  // Create a new tmux session (detached)
+  const envStr = env
+    ? Object.entries(env).map(([k, v]) => `-e ${k}=${v}`).join(" ")
+    : "";
+  const cwdFlag = cwd ? `-c "${cwd}"` : "";
+  const result = tmuxExec(`tmux new-session -d -s "${sessionName}" ${cwdFlag} ${envStr}`);
+  if (result === null) {
+    console.error(`[session-manager] Failed to create tmux session: ${sessionName}`);
+    return null;
+  }
+
+  // Label the session's first pane with the agent ID
+  const paneId = tmuxExec(`tmux list-panes -t "${sessionName}" -F "#{pane_id}" | head -1`);
+  if (paneId) {
+    tmuxBridge.label(agentId, paneId);
+  }
+
+  const meta = {
+    sessionId,
+    sessionName,
+    workspaceId,
+    owner: agentId,
+    lockedBy: agentId,
+    paneId: paneId || null,
+    cwd: cwd || null,
+    env: env || null,
+    createdAt: new Date().toISOString(),
+    status: "active",
+  };
+  saveMeta(sessionId, meta);
+  appendTranscript(sessionId, { action: "created", agent: agentId, cwd });
+
+  console.log(`[session-manager] Created session ${sessionId} for ${agentId} (pane=${paneId})`);
+  return sessionId;
+}
+
+/**
+ * Attach an agent to an existing session (for handoff or observation).
+ * @param {string} sessionId
+ * @param {string} agentId
+ * @returns {{ paneId: string, sessionName: string }|null}
+ */
+export function attach(sessionId, agentId) {
+  const meta = loadMeta(sessionId);
+  if (!meta || meta.status !== "active") return null;
+
+  appendTranscript(sessionId, { action: "attached", agent: agentId });
+  console.log(`[session-manager] ${agentId} attached to session ${sessionId}`);
+
+  return { paneId: meta.paneId, sessionName: meta.sessionName };
+}
+
+/**
+ * Execute a command in a session's tmux pane.
+ * Only the lock owner can execute.
+ * @param {string} sessionId
+ * @param {string} command
+ * @param {object} [opts]
+ * @param {string} opts.actorId - Agent executing the command
+ * @param {number} [opts.timeout=30000] - Timeout in ms
+ * @returns {{ output: string }|null}
+ */
+export function exec(sessionId, command, { actorId, timeout = 30000 } = {}) {
+  const meta = loadMeta(sessionId);
+  if (!meta || meta.status !== "active") return null;
+
+  // Enforce lock
+  if (meta.lockedBy && meta.lockedBy !== actorId) {
+    console.warn(`[session-manager] ${actorId} cannot exec in ${sessionId} — locked by ${meta.lockedBy}`);
+    return null;
+  }
+
+  const paneId = meta.paneId;
+  if (!paneId) return null;
+
+  // Send keys to the pane
+  tmuxExec(`tmux send-keys -t "${paneId}" "${command.replace(/"/g, '\\"')}" Enter`, timeout);
+  appendTranscript(sessionId, { action: "exec", agent: actorId, command: command.slice(0, 500) });
+
+  // Read back output after a short delay
+  const output = tmuxBridge.read(meta.owner, 50);
+  return { output: output || "" };
+}
+
+/**
+ * Lock a session for exclusive write access.
+ * @param {string} sessionId
+ * @param {string} ownerId - Agent requesting the lock
+ * @returns {boolean} true if lock acquired
+ */
+export function lock(sessionId, ownerId) {
+  const meta = loadMeta(sessionId);
+  if (!meta || meta.status !== "active") return false;
+
+  if (meta.lockedBy && meta.lockedBy !== ownerId) {
+    console.warn(`[session-manager] Lock denied for ${ownerId} on ${sessionId} — held by ${meta.lockedBy}`);
+    return false;
+  }
+
+  meta.lockedBy = ownerId;
+  meta.lockedAt = new Date().toISOString();
+  saveMeta(sessionId, meta);
+  appendTranscript(sessionId, { action: "locked", agent: ownerId });
+  return true;
+}
+
+/**
+ * Unlock a session.
+ * @param {string} sessionId
+ * @param {string} ownerId - Must match current lock holder
+ * @returns {boolean}
+ */
+export function unlock(sessionId, ownerId) {
+  const meta = loadMeta(sessionId);
+  if (!meta) return false;
+
+  if (meta.lockedBy && meta.lockedBy !== ownerId) {
+    console.warn(`[session-manager] Unlock denied for ${ownerId} on ${sessionId} — held by ${meta.lockedBy}`);
+    return false;
+  }
+
+  meta.lockedBy = null;
+  meta.lockedAt = null;
+  saveMeta(sessionId, meta);
+  appendTranscript(sessionId, { action: "unlocked", agent: ownerId });
+  return true;
+}
+
+/**
+ * Hand off a session from one agent to another.
+ * Transfers lock ownership and re-labels the pane.
+ * @param {string} sessionId
+ * @param {string} fromAgent
+ * @param {string} toAgent
+ * @returns {boolean}
+ */
+export function handoff(sessionId, fromAgent, toAgent) {
+  const meta = loadMeta(sessionId);
+  if (!meta || meta.status !== "active") return false;
+
+  // Only the current lock holder (or unlocked session) can hand off
+  if (meta.lockedBy && meta.lockedBy !== fromAgent) {
+    console.warn(`[session-manager] Handoff denied: ${sessionId} locked by ${meta.lockedBy}, not ${fromAgent}`);
+    return false;
+  }
+
+  meta.owner = toAgent;
+  meta.lockedBy = toAgent;
+  meta.lockedAt = new Date().toISOString();
+  saveMeta(sessionId, meta);
+
+  // Re-label pane for the new agent
+  if (meta.paneId) {
+    tmuxBridge.label(toAgent, meta.paneId);
+  }
+
+  appendTranscript(sessionId, { action: "handoff", from: fromAgent, to: toAgent });
+  console.log(`[session-manager] Session ${sessionId} handed off: ${fromAgent} → ${toAgent}`);
+  return true;
+}
+
+/**
+ * Terminate a session and clean up its tmux pane.
+ * @param {string} sessionId
+ * @returns {boolean}
+ */
+export function terminate(sessionId) {
+  const meta = loadMeta(sessionId);
+  if (!meta) return false;
+
+  // Kill the tmux session
+  if (meta.sessionName) {
+    tmuxExec(`tmux kill-session -t "${meta.sessionName}"`);
+  }
+
+  meta.status = "terminated";
+  meta.terminatedAt = new Date().toISOString();
+  saveMeta(sessionId, meta);
+  appendTranscript(sessionId, { action: "terminated" });
+  console.log(`[session-manager] Session ${sessionId} terminated`);
+  return true;
+}
+
+/**
+ * Get metadata for a session.
+ * @param {string} sessionId
+ * @returns {object|null}
+ */
+export function getSession(sessionId) {
+  return loadMeta(sessionId);
+}
+
+/**
+ * List all active sessions.
+ * @returns {Array<object>}
+ */
+export function listSessions() {
+  try {
+    const files = fs.readdirSync(SESSION_DIR).filter(f => f.endsWith(".json"));
+    return files
+      .map(f => loadMeta(f.replace(".json", "")))
+      .filter(m => m && m.status === "active");
+  } catch {
+    return [];
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "crewswarm",
-  "version": "0.9.0",
+  "version": "0.9.2",
   "description": "Local-first multi-agent orchestration platform — coordinate AI coding agents, LLMs, and tools from a single dashboard",
   "type": "module",
   "license": "MIT",

package/scripts/bench/performance_optimization.py

@@ -0,0 +1,81 @@
+#!/usr/bin/env python3
+"""
+Minimal performance benchmark script (synthetic fallback mode).
+
+When --force-synthetic is passed, skips real HTTP requests and emits
+synthetic benchmark data. This allows the test suite to verify the
+tooling pipeline without a running server.
+
+Usage:
+  python3 scripts/bench/performance_optimization.py \
+    --url http://127.0.0.1:4319/api/health \
+    --profile all \
+    --force-synthetic
+"""
+
+import argparse
+import json
+import sys
+
+
+def synthetic_baseline(url):
+    return {
+        "url": url,
+        "mode": "synthetic-fallback",
+        "fallback_reason": "synthetic mode requested via --force-synthetic",
+        "latency_ms": 0.1,
+        "status": 200,
+    }
+
+
+def synthetic_profile(name, url):
+    return {
+        "name": name,
+        "url": url,
+        "metrics": {
+            "mode": "synthetic-fallback",
+            "latency_p50_ms": 0.1,
+            "latency_p99_ms": 0.5,
+            "success_rate": 1.0,
+            "requests": 10,
+        },
+        "recommendations": [
+            f"Enable caching for {name} profile to reduce latency",
+        ],
+    }
+
+
+PROFILE_NAMES = ["throughput", "latency", "reliability"]
+
+
+def main():
+    parser = argparse.ArgumentParser(description="CrewSwarm performance benchmark")
+    parser.add_argument("--url", required=True, help="Target URL to benchmark")
+    parser.add_argument("--profile", default="all", help="Profile to run (or 'all')")
+    parser.add_argument(
+        "--force-synthetic",
+        action="store_true",
+        help="Use synthetic data instead of real HTTP requests",
+    )
+    args = parser.parse_args()
+
+    if not args.force_synthetic:
+        print(
+            "Error: live benchmarking not implemented yet. Use --force-synthetic.",
+            file=sys.stderr,
+        )
+        sys.exit(1)
+
+    profiles = PROFILE_NAMES if args.profile == "all" else [args.profile]
+
+    result = {
+        "baseline": synthetic_baseline(args.url),
+        "profiles": [synthetic_profile(p, args.url) for p in profiles],
+    }
+
+    json.dump(result, sys.stdout, indent=2)
+    sys.stdout.write("\n")
+
+
+if __name__ == "__main__":
+    main()

package/whatsapp-bridge.mjs

@@ -144,6 +144,19 @@ const ALLOWED_JIDS = new Set(
 );
 const ALLOWLIST_ENABLED = ALLOWED_JIDS.size > 0;
 
+// Map @lid JIDs to their @s.whatsapp.net equivalents (populated on first message)
+const LID_TO_JID = new Map();
+
+function isJidAllowed(jid) {
+  if (!ALLOWLIST_ENABLED) return true;
+  if (ALLOWED_JIDS.has(jid)) return true;
+  // Check if this @lid JID is mapped to an allowed @s.whatsapp.net
+  if (jid.endsWith("@lid") && LID_TO_JID.has(jid)) {
+    return ALLOWED_JIDS.has(LID_TO_JID.get(jid));
+  }
+  return false;
+}
+
 // Per-user routing: maps "+1234..." or "1234...@s.whatsapp.net" → agent name
 const USER_ROUTING = loadUserRouting();
 
@@ -424,7 +437,7 @@ function connectRT(sendToJid) {
             if (sessionId && activeSessions.has(sessionId)) {
               const jid = sessionId;
               // Allowlist check on outbound — never send to unauthorized JIDs
-              if (ALLOWLIST_ENABLED && !ALLOWED_JIDS.has(jid)) {
+              if (ALLOWLIST_ENABLED && !isJidAllowed(jid)) {
                 log("warn", "RT reply blocked by allowlist — not sending to unauthorized JID", { jid, from });
                 return;
               }
@@ -524,7 +537,7 @@ async function listenForAgentReplies(sendToJid) {
             
             const jid = whatsappJid;
             // Allowlist check on outbound — never send to unauthorized JIDs
-            if (ALLOWLIST_ENABLED && !ALLOWED_JIDS.has(jid)) {
+            if (ALLOWLIST_ENABLED && !isJidAllowed(jid)) {
               log("warn", "SSE reply blocked by allowlist — not sending to unauthorized JID", { jid, from: d.from });
               continue;
             }
@@ -804,18 +817,49 @@ async function main() {
       const isGroup = jid.endsWith("@g.us");
       if (isGroup) continue;
 
-      // WhatsApp multi-device uses @lid (Linked Identity) JIDs for self-chat messages.
-      // These arrive as fromMe:true with a @lid suffix — this is the personal bot pattern.
-      const isSelfChatLid = msg.key.fromMe && jid.endsWith("@lid");
+      // WhatsApp multi-device uses @lid (Linked Identity) JIDs.
+      // CRITICAL: Not all fromMe + @lid messages are self-chat!
+      // When you message ANYONE from your phone, it arrives as fromMe:true with THEIR @lid.
+      // Self-chat is ONLY when the @lid matches the bot's own linked identity.
       const ownJid = sock.user?.id?.split(":")[0] + "@s.whatsapp.net";
+      // Detect the bot's own @lid JID. Baileys may expose sock.user.lid,
+      // or we detect it from the first self-addressed message.
+      const ownLid = sock.user?.lid || sock._ownLid || null;
+      let isSelfChatLid = false;
+      if (msg.key.fromMe && jid.endsWith("@lid")) {
+        if (ownLid && jid === ownLid) {
+          // Known self-chat LID
+          isSelfChatLid = true;
+        } else if (!ownLid && msg.key.participant) {
+          // First @lid message — check if participant matches our own number
+          const participantNum = msg.key.participant?.split(":")[0]?.split("@")[0];
+          const ownNum = sock.user?.id?.split(":")[0];
+          if (participantNum === ownNum) {
+            isSelfChatLid = true;
+            sock._ownLid = jid; // Cache for future messages
+            log("info", "Detected own @lid JID", { lid: jid, ownNum });
+          }
+        }
+        // If we still can't determine, it's NOT self-chat (safe default)
+      }
       const isSelfChatOwn = msg.key.fromMe && jid === ownJid;
+      const isSelfChat = isSelfChatLid || isSelfChatOwn;
 
-      // Block outgoing messages that aren't self-chat (i.e. bot's own replies going out)
-      if (msg.key.fromMe && !isSelfChatLid && !isSelfChatOwn) continue;
+      // Block ALL outgoing messages that aren't self-chat.
+      // This prevents the bot from processing your messages to other people.
+      if (msg.key.fromMe && !isSelfChat) continue;
+
+      // For self-chat @lid messages, map to the owner's real @s.whatsapp.net JID
+      if (isSelfChatLid && ownJid) {
+        LID_TO_JID.set(jid, ownJid);
+        log("info", "Mapped self-chat @lid to @s.whatsapp.net", { lid: jid, jid: ownJid });
+      }
 
       // ── Allowlist check (before any media processing) ─────────────────
-      if (!isSelfChatLid && !isSelfChatOwn) {
-        if (ALLOWLIST_ENABLED && !ALLOWED_JIDS.has(jid)) {
+      // Self-chat always passes (it's you talking to yourself).
+      // Other messages: check if sender is in allowlist.
+      if (!isSelfChat) {
+        if (ALLOWLIST_ENABLED && !isJidAllowed(jid)) {
           log("warn", "Silently ignored unauthorized sender", { jid });
           continue;
         }
@@ -1444,7 +1488,7 @@ async function main() {
           }
           if (!targetJid) { res.writeHead(400); res.end(JSON.stringify({ error: "jid or phone required" })); return; }
           // Allowlist check on outbound — never send to unauthorized JIDs
-          if (ALLOWLIST_ENABLED && !ALLOWED_JIDS.has(targetJid)) {
+          if (ALLOWLIST_ENABLED && !isJidAllowed(targetJid)) {
             log("warn", "HTTP /send blocked by allowlist", { targetJid });
             res.writeHead(403); res.end(JSON.stringify({ error: "JID not in allowlist" })); return;
           }

package/apps/dashboard/dist/assets/core-utils-CAVnDoe1.js

@@ -1 +0,0 @@
-async function e(e,{ttl:t=0,bust:r=!1}={}){const s=await fetch(e);if(!s.ok)throw new Error(await s.text());return await s.json()}async function t(e,t,r){const s=await fetch(e,{method:"POST",headers:{"content-type":"application/json"},body:JSON.stringify(t),signal:r}),n=await s.text();if(!s.ok)throw new Error(n.slice(0,120));try{return JSON.parse(n)}catch{throw new Error("Bad response: "+n.slice(0,80))}}function r(e,t){return"online"===e?'<span title="● online — heartbeat <90s" style="display:inline-block;width:7px;height:7px;border-radius:50%;background:var(--green);box-shadow:0 0 5px var(--green);margin-right:4px;flex-shrink:0;"></span>':"stale"===e?'<span title="● stale — last seen >'+(t||"?")+'s ago" style="display:inline-block;width:7px;height:7px;border-radius:50%;background:#f59e0b;margin-right:4px;flex-shrink:0;"></span>':"offline"===e?'<span title="● offline — no heartbeat in 5min" style="display:inline-block;width:7px;height:7px;border-radius:50%;background:var(--red-hi);margin-right:4px;flex-shrink:0;"></span>':'<span title="● unknown — never seen" style="display:inline-block;width:7px;height:7px;border-radius:50%;background:var(--text-3);margin-right:4px;flex-shrink:0;"></span>'}function s(e,t){e&&(e.innerHTML='<div class="meta" style="padding:20px;">'+(t||"Loading…")+"</div>")}function n(e,t){e&&(e.innerHTML='<div class="meta" style="padding:20px;">'+(t||"No items found.")+"</div>")}function a(e,t){e&&(e.innerHTML='<div class="meta" style="padding:20px;color:var(--red-hi);">'+(t||"An error occurred.")+"</div>")}function i(e){return String(e??"").replace(/&/g,"&amp;").replace(/</g,"&lt;").replace(/>/g,"&gt;").replace(/"/g,"&quot;").replace(/'/g,"&#39;")}function o(e,t){const r=document.createElement("div");r.className="notification"+("error"===t||!0===t?" error":"warning"===t?" warning":""),r.setAttribute("role","alert"),r.setAttribute("aria-live","polite"),r.textContent=e,document.body.appendChild(r),setTimeout(()=>r.remove(),4500)}function c(e){try{return new Date(e).toLocaleTimeString()}catch{return String(e)}}function l(e){return e&&e.time&&e.time.created||""}function d(e,t,r,s,n,a,i,o){const c=document.getElementById("chatMessages");if(!c)return;const l="user"===e,d=o&&"object"==typeof o&&!0===o.force;if(!l&&!d){const e=c.lastElementChild;if(e&&e.children.length>=2){if(e.children[1].textContent.trim()===String(t).trim())return}}const p=document.createElement("div");p.style.cssText="display:flex;flex-direction:column;align-items:"+(l?"flex-end":"flex-start")+";gap:4px;";const u=document.createElement("div");u.style.cssText="font-size:11px;color:var(--text-3);padding:0 6px;display:flex;align-items:center;gap:6px;";const g=window._crewLeadInfo||{emoji:"🧠",name:"crew-lead"};if(i){let e="crew-lead";l?e="You":i.agentName?e=i.agentName:i.agent?e=i.agent:"cli"===i.source?e=i.engine||"cli":"sub-agent"===i.source?e="sub-agent":"agent"===i.source?e=i.targetAgent||"agent":"dashboard"===i.source&&(e="crew-lead");const t=!l&&i.engine&&i.engine!==e?` · ${i.engine}`:"";u.textContent=`${i.emoji||"🤖"} ${e}${t}`;const r=document.createElement("span");r.style.cssText="opacity:0.6;",r.textContent=i.timestamp?" · "+i.timestamp:"",u.appendChild(r)}else{const t=l?"You":"assistant"===e?g.emoji+" "+g.name:e;u.textContent=t}if(!l){const e=r||n;if(e){const t=document.createElement("span");r?(t.title="Primary failed ("+(s||"error")+") — running on fallback",t.style.cssText="font-size:10px;padding:1px 6px;border-radius:999px;background:rgba(245,158,11,0.15);color:#f59e0b;border:1px solid rgba(245,158,11,0.3);cursor:default;",t.textContent="⚡ fallback: "+r):(t.title="Primary model",t.style.cssText="font-size:10px;padding:1px 6px;border-radius:999px;background:rgba(52,211,153,0.1);color:#34d399;border:1px solid rgba(52,211,153,0.2);cursor:default;",t.textContent=e),u.appendChild(t)}if(a){const e={claude:"#e07a5f",codex:"#8338ec",cursor:"#3d405b",opencode:"#06d6a0",gemini:"#4285f4","docker-sandbox":"#0db7ed"},t={claude:"🤖 Claude Code",codex:"🟣 Codex",cursor:"🖱 Cursor",opencode:"⚡ OpenCode",gemini:"✨ Gemini","docker-sandbox":"🐳 Docker"},r=document.createElement("span");r.title="Executed by "+(t[a]||a),r.style.cssText="font-size:10px;padding:1px 6px;border-radius:999px;color:#fff;background:"+(e[a]||"var(--text-3)")+";cursor:default;",r.textContent=t[a]||a,u.appendChild(r)}}const h=document.createElement("div");h.style.cssText="max-width:80%;padding:10px 14px;border-radius:"+(l?"14px 14px 4px 14px":"14px 14px 14px 4px")+";background:"+(l?"var(--purple)":"var(--surface-2)")+";color:"+(l?"#fff":"var(--text-2)")+";font-size:14px;line-height:1.5;white-space:pre-wrap;word-break:break-word;border:1px solid var(--border);",h.textContent=t,p.appendChild(u),p.appendChild(h),c.appendChild(p),c.scrollTop=c.scrollHeight}const p="crewswarm_ui_state";const u=function(){try{const e=sessionStorage.getItem(p);return e?JSON.parse(e):{}}catch{return{}}}(),g={selected:u.selected||null,selectedEngine:u.selectedEngine||"opencode",agents:u.agents||[],chatActiveProjectId:u.chatActiveProjectId||"",swarmChatProjectId:u.swarmChatProjectId||"",projectsData:u.projectsData||{},activeTab:u.activeTab||"chat",scrollPositions:u.scrollPositions||{}};function h(){try{sessionStorage.setItem(p,JSON.stringify({selected:g.selected,selectedEngine:g.selectedEngine,chatActiveProjectId:g.chatActiveProjectId,swarmChatProjectId:g.swarmChatProjectId,projectsData:g.projectsData,activeTab:g.activeTab,scrollPositions:g.scrollPositions}))}catch{}}function f(e){const t=document.querySelector(".view.active");t&&(g.scrollPositions[e||g.activeTab]=t.scrollTop,h())}function x(e){const t=g.scrollPositions[e];null!=t&&requestAnimationFrame(()=>{const e=document.querySelector(".view.active");e&&(e.scrollTop=t)})}const m={"crew-lead":0,"crew-orchestrator":1,orchestrator:1,"crew-main":2,"crew-pm":3,"crew-architect":4,"crew-coder":5,"crew-coder-back":6,"crew-coder-front":7,"crew-frontend":8,"crew-ml":9,"crew-fixer":10,"crew-qa":11,"crew-security":12,"crew-researcher":13,"crew-copywriter":14,"crew-seo":15,"crew-github":16,"crew-db-migrator":17,"crew-telegram":18,"crew-mega":19};function w(e){return(e||[]).sort((e,t)=>(m[e.id]??50)-(m[t.id]??50))}const b=new class{constructor(){this.activeTasks=new Map,this.listeners=new Set}registerTask(e,t){this.activeTasks.set(e,{...t,startTime:Date.now(),status:"running"}),this.notifyListeners()}stopTask(e){const t=this.activeTasks.get(e);return!!t&&(t.controller&&t.controller.abort(),t.status="stopped",this.activeTasks.delete(e),this.notifyListeners(),!0)}completeTask(e){const t=this.activeTasks.get(e);t&&(t.status="completed",this.activeTasks.delete(e),this.notifyListeners())}failTask(e,t){const r=this.activeTasks.get(e);r&&(r.status="failed",r.error=t,this.activeTasks.delete(e),this.notifyListeners())}getActiveTasks(){return Array.from(this.activeTasks.entries()).map(([e,t])=>({id:e,...t}))}isAgentBusy(e){return Array.from(this.activeTasks.values()).some(t=>t.agent===e&&"running"===t.status)}stopAll(){for(const[e]of this.activeTasks)this.stopTask(e)}stopAgent(e){for(const[t,r]of this.activeTasks)r.agent===e&&this.stopTask(t)}subscribe(e){return this.listeners.add(e),()=>this.listeners.delete(e)}notifyListeners(){for(const t of this.listeners)try{t(this.getActiveTasks())}catch(e){console.error("TaskManager listener error:",e)}}};export{g as a,h as b,n as c,a as d,i as e,w as f,e as g,x as h,c as i,l as j,s as k,f as l,d as m,t as p,r,o as s,b as t};