aemeathcli 1.0.10 → 1.0.12

package/dist/App-JQ622M66.js

@@ -0,0 +1,4431 @@
+import { getCliProviderEntry, getCliProviderForModelProvider } from './chunk-LQBALETG.js';
+import { getActiveTeamName, getActiveTeamManager, getActiveTmuxCleanup, setActiveTmuxCleanup, setActiveTeamManager, setActiveTeamName } from './chunk-ZCOVMVK4.js';
+import { CostTracker } from './chunk-2ZYK5IJG.js';
+import { getEventBus } from './chunk-YL5XFHR3.js';
+import { createModelRouter } from './chunk-YPQ2MLAV.js';
+import { formatCost, formatTokenCount } from './chunk-YCCYXDW7.js';
+import './chunk-OPWAFS6Y.js';
+import './chunk-ZGOHARPV.js';
+import { getThinkingConfigForModel, SUPPORTED_MODELS, PROVIDER_MODEL_ORDER } from './chunk-HCIHOHLX.js';
+import { DEFAULT_CONFIG, PACKAGE_VERSION } from './chunk-2Y7TR6BS.js';
+import './chunk-IR5HLBMH.js';
+import './chunk-D275MCIH.js';
+import React11, { useRef, useState, useCallback, useEffect, useMemo, startTransition } from 'react';
+import { Box, Text, render, useInput } from 'ink';
+import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
+import { randomUUID } from 'crypto';
+
+// src/ui/theme.ts
+var BRAND_COLOR = "#F0C5DA";
+var colors = {
+  text: {
+    primary: "#F9F5F5",
+    secondary: "#d3acb3",
+    muted: "#9e8085",
+    accent: "#F0C5DA",
+    response: "#F9F5F5"
+  },
+  border: {
+    dim: "#6b5459",
+    active: "#d3acb3"},
+  syntax: {
+    keyword: "#F0C5DA",
+    string: "#EDD6DC"},
+  status: {
+    success: "#F0C5DA",
+    error: "#f87171",
+    warning: "#EDD6DC",
+    info: "#F0C5DA",
+    active: "#F0C5DA"
+  },
+  role: {
+    user: "#F0C5DA",
+    assistant: "#F9F5F5",
+    system: "#EDD6DC",
+    tool: "#d3acb3"
+  }
+};
+function parseBlocks(raw) {
+  const blocks = [];
+  const lines = raw.split("\n");
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    if (line === void 0) {
+      break;
+    }
+    if (line.startsWith("```")) {
+      const lang = line.slice(3).trim();
+      const codeLines = [];
+      i++;
+      while (i < lines.length) {
+        const currentLine = lines[i];
+        if (currentLine === void 0 || currentLine.startsWith("```")) {
+          break;
+        }
+        codeLines.push(currentLine);
+        i++;
+      }
+      blocks.push({ type: "code", content: codeLines.join("\n"), lang });
+      i++;
+      continue;
+    }
+    const headerMatch = line.match(/^(#{1,4})\s+(.+)$/);
+    if (headerMatch) {
+      const hashes = headerMatch[1];
+      const headerContent = headerMatch[2];
+      if (hashes === void 0 || headerContent === void 0) {
+        i++;
+        continue;
+      }
+      blocks.push({
+        type: "header",
+        content: headerContent,
+        level: hashes.length
+      });
+      i++;
+      continue;
+    }
+    if (/^[-*_]{3,}\s*$/.test(line)) {
+      blocks.push({ type: "hr", content: "" });
+      i++;
+      continue;
+    }
+    if (line.startsWith("> ")) {
+      const quoteLines = [];
+      while (i < lines.length) {
+        const quoteLine = lines[i];
+        if (quoteLine === void 0 || !quoteLine.startsWith("> ")) {
+          break;
+        }
+        quoteLines.push(quoteLine.slice(2));
+        i++;
+      }
+      blocks.push({ type: "blockquote", content: quoteLines.join("\n") });
+      continue;
+    }
+    if (/^\s*[-*+]\s/.test(line) || /^\s*\d+\.\s/.test(line)) {
+      const listLines = [];
+      while (i < lines.length) {
+        const l = lines[i];
+        if (l === void 0) {
+          break;
+        }
+        if (/^\s*[-*+]\s/.test(l) || /^\s*\d+\.\s/.test(l) || l.startsWith("  ") && listLines.length > 0) {
+          listLines.push(l);
+          i++;
+        } else {
+          break;
+        }
+      }
+      blocks.push({ type: "list", content: listLines.join("\n") });
+      continue;
+    }
+    const textLines = [];
+    while (i < lines.length) {
+      const l = lines[i];
+      if (l === void 0) {
+        break;
+      }
+      if (l.startsWith("```") || l.startsWith("#") || l.startsWith("> ") || /^[-*_]{3,}\s*$/.test(l) || /^\s*[-*+]\s/.test(l) || /^\s*\d+\.\s/.test(l)) {
+        break;
+      }
+      textLines.push(l);
+      i++;
+    }
+    if (textLines.length > 0) {
+      blocks.push({ type: "text", content: textLines.join("\n") });
+    }
+  }
+  return blocks.length > 0 ? blocks : [{ type: "text", content: raw }];
+}
+function InlineMarkdown({
+  text
+}) {
+  const segments = [];
+  let remaining = text;
+  let key = 0;
+  while (remaining.length > 0) {
+    const boldMatch = remaining.match(/^\*\*(.+?)\*\*/);
+    if (boldMatch) {
+      segments.push(
+        /* @__PURE__ */ jsx(Text, { bold: true, children: boldMatch[1] }, key++)
+      );
+      remaining = remaining.slice(boldMatch[0].length);
+      continue;
+    }
+    const italicMatch = remaining.match(/^\*(.+?)\*/);
+    if (italicMatch) {
+      segments.push(
+        /* @__PURE__ */ jsx(Text, { italic: true, children: italicMatch[1] }, key++)
+      );
+      remaining = remaining.slice(italicMatch[0].length);
+      continue;
+    }
+    const codeMatch = remaining.match(/^`([^`]+)`/);
+    if (codeMatch) {
+      segments.push(
+        /* @__PURE__ */ jsx(Text, { color: colors.syntax.string, bold: true, children: codeMatch[1] }, key++)
+      );
+      remaining = remaining.slice(codeMatch[0].length);
+      continue;
+    }
+    const strikeMatch = remaining.match(/^~~(.+?)~~/);
+    if (strikeMatch) {
+      segments.push(
+        /* @__PURE__ */ jsx(Text, { strikethrough: true, dimColor: true, children: strikeMatch[1] }, key++)
+      );
+      remaining = remaining.slice(strikeMatch[0].length);
+      continue;
+    }
+    const linkMatch = remaining.match(/^\[([^\]]+)\]\(([^)]+)\)/);
+    if (linkMatch) {
+      segments.push(
+        /* @__PURE__ */ jsx(Text, { color: colors.status.info, underline: true, children: linkMatch[1] }, key++)
+      );
+      remaining = remaining.slice(linkMatch[0].length);
+      continue;
+    }
+    const nextSpecial = remaining.search(/[[*`~]/);
+    if (nextSpecial === -1) {
+      segments.push(/* @__PURE__ */ jsx(Text, { children: remaining }, key++));
+      break;
+    } else if (nextSpecial === 0) {
+      segments.push(/* @__PURE__ */ jsx(Text, { children: remaining[0] }, key++));
+      remaining = remaining.slice(1);
+    } else {
+      segments.push(
+        /* @__PURE__ */ jsx(Text, { children: remaining.slice(0, nextSpecial) }, key++)
+      );
+      remaining = remaining.slice(nextSpecial);
+    }
+  }
+  return /* @__PURE__ */ jsx(Text, { wrap: "wrap", children: segments });
+}
+function HeaderBlock({
+  content,
+  level
+}) {
+  const headerColors = [
+    colors.text.accent,
+    colors.status.active,
+    colors.syntax.keyword,
+    colors.text.secondary
+  ];
+  const color = headerColors[level - 1] ?? colors.text.primary;
+  const prefix = level === 1 ? "\u25C6 " : level === 2 ? "\u25B8 " : "  ";
+  return /* @__PURE__ */ jsx(Box, { marginY: level <= 2 ? 1 : 0, children: /* @__PURE__ */ jsxs(Text, { color, bold: level <= 2, children: [
+    prefix,
+    content
+  ] }) });
+}
+function ListBlock({
+  content
+}) {
+  const items = content.split("\n");
+  const bullets = ["\u25B8", "\u25E6", "\xB7", "\u2023"];
+  return /* @__PURE__ */ jsx(Box, { flexDirection: "column", children: items.map((item, i) => {
+    const indent = item.match(/^(\s*)/)?.[1]?.length ?? 0;
+    const bulletLevel = Math.floor(indent / 2);
+    const clean = item.replace(/^\s*[-*+]\s/, "").replace(/^\s*\d+\.\s/, "");
+    const bullet = bullets[bulletLevel % bullets.length];
+    return /* @__PURE__ */ jsxs(Box, { marginLeft: bulletLevel * 2, children: [
+      /* @__PURE__ */ jsxs(Text, { color: colors.status.active, children: [
+        bullet,
+        " "
+      ] }),
+      /* @__PURE__ */ jsx(InlineMarkdown, { text: clean })
+    ] }, i);
+  }) });
+}
+function CodeBlockRender({
+  content,
+  lang
+}) {
+  const lines = content.split("\n");
+  if (lines.length > 0 && lines[lines.length - 1]?.trim() === "") {
+    lines.pop();
+  }
+  return /* @__PURE__ */ jsxs(
+    Box,
+    {
+      flexDirection: "column",
+      borderStyle: "round",
+      borderColor: colors.border.dim,
+      marginY: 1,
+      children: [
+        lang ? /* @__PURE__ */ jsx(Box, { paddingX: 1, children: /* @__PURE__ */ jsx(Text, { color: colors.text.muted, dimColor: true, children: lang }) }) : null,
+        /* @__PURE__ */ jsx(Box, { flexDirection: "column", paddingX: 1, children: lines.map((line, i) => /* @__PURE__ */ jsxs(Box, { children: [
+          /* @__PURE__ */ jsxs(Text, { color: colors.text.muted, dimColor: true, children: [
+            String(i + 1).padStart(3, " "),
+            " ",
+            "\u2502",
+            " "
+          ] }),
+          /* @__PURE__ */ jsx(Text, { color: colors.text.response, children: line })
+        ] }, i)) })
+      ]
+    }
+  );
+}
+function MarkdownContent({
+  content
+}) {
+  const blocks = parseBlocks(content);
+  if (blocks.length === 1 && blocks[0]?.type === "text") {
+    const text = blocks[0].content;
+    if (!/[[*`~]/.test(text)) {
+      return /* @__PURE__ */ jsx(Text, { wrap: "wrap", children: text });
+    }
+    return /* @__PURE__ */ jsx(InlineMarkdown, { text });
+  }
+  return /* @__PURE__ */ jsx(Box, { flexDirection: "column", children: blocks.map((block, i) => {
+    switch (block.type) {
+      case "code":
+        return /* @__PURE__ */ jsx(
+          CodeBlockRender,
+          {
+            content: block.content,
+            lang: block.lang
+          },
+          i
+        );
+      case "header":
+        return /* @__PURE__ */ jsx(
+          HeaderBlock,
+          {
+            content: block.content,
+            level: block.level ?? 1
+          },
+          i
+        );
+      case "list":
+        return /* @__PURE__ */ jsx(ListBlock, { content: block.content }, i);
+      case "hr":
+        return /* @__PURE__ */ jsx(Box, { marginY: 1, children: /* @__PURE__ */ jsx(Text, { color: colors.border.dim, children: "\u2500".repeat(40) }) }, i);
+      case "blockquote":
+        return /* @__PURE__ */ jsx(
+          Box,
+          {
+            marginLeft: 1,
+            borderStyle: "single",
+            borderLeft: true,
+            borderRight: false,
+            borderTop: false,
+            borderBottom: false,
+            borderColor: colors.border.active,
+            paddingLeft: 1,
+            children: /* @__PURE__ */ jsx(Text, { color: colors.text.secondary, italic: true, wrap: "wrap", children: block.content })
+          },
+          i
+        );
+      case "text":
+      default:
+        return /* @__PURE__ */ jsx(InlineMarkdown, { text: block.content }, i);
+    }
+  }) });
+}
+var animationBuckets = /* @__PURE__ */ new Map();
+function getOrCreateBucket(intervalMs) {
+  const existing = animationBuckets.get(intervalMs);
+  if (existing !== void 0) {
+    return existing;
+  }
+  const bucket = {
+    tick: 0,
+    listeners: /* @__PURE__ */ new Set(),
+    timer: setInterval(() => {
+      bucket.tick += 1;
+      for (const listener of bucket.listeners) {
+        listener(bucket.tick);
+      }
+    }, intervalMs)
+  };
+  animationBuckets.set(intervalMs, bucket);
+  return bucket;
+}
+function useAnimationTick(intervalMs, enabled = true) {
+  const [tick, setTick] = useState(0);
+  useEffect(() => {
+    if (!enabled) {
+      setTick(0);
+      return void 0;
+    }
+    const bucket = getOrCreateBucket(intervalMs);
+    setTick(bucket.tick);
+    const listener = (nextTick) => {
+      setTick(nextTick);
+    };
+    bucket.listeners.add(listener);
+    return () => {
+      bucket.listeners.delete(listener);
+      if (bucket.listeners.size === 0) {
+        clearInterval(bucket.timer);
+        animationBuckets.delete(intervalMs);
+      }
+    };
+  }, [enabled, intervalMs]);
+  return tick;
+}
+var SPINNER_VARIANTS = {
+  dots: {
+    frames: ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"],
+    interval: 120
+  },
+  braille: {
+    frames: ["\u28FE", "\u28FD", "\u28FB", "\u28BF", "\u287F", "\u28DF", "\u28EF", "\u28F7"],
+    interval: 120
+  },
+  arc: {
+    frames: ["\u25DC", "\u25E0", "\u25DD", "\u25DE", "\u25E1", "\u25DF"],
+    interval: 100
+  },
+  pulse: {
+    frames: ["\u25C9", "\u25CE", "\u25CB", "\u25CE", "\u25C9", "\u25CF"],
+    interval: 120
+  },
+  bounce: {
+    frames: ["\u2801", "\u2802", "\u2804", "\u2840", "\u2880", "\u2820", "\u2810", "\u2808"],
+    interval: 120
+  }
+};
+function GradientSpinner({
+  label,
+  labelColor = "#888888",
+  variant = "dots",
+  speed
+}) {
+  const spinnerDef = SPINNER_VARIANTS[variant] ?? SPINNER_VARIANTS["dots"];
+  if (!spinnerDef) {
+    throw new Error("Missing default spinner configuration");
+  }
+  const interval = speed ?? spinnerDef.interval;
+  const tick = useAnimationTick(interval);
+  const frame = tick % spinnerDef.frames.length;
+  return /* @__PURE__ */ jsxs(Text, { children: [
+    /* @__PURE__ */ jsx(Text, { color: BRAND_COLOR, children: spinnerDef.frames[frame] }),
+    label ? /* @__PURE__ */ jsxs(Text, { color: labelColor, children: [
+      " ",
+      label
+    ] }) : null
+  ] });
+}
+function StatusIcon({
+  status
+}) {
+  switch (status) {
+    case "pending":
+      return /* @__PURE__ */ jsx(Text, { color: colors.text.muted, children: "\u25CB" });
+    case "executing":
+      return /* @__PURE__ */ jsx(GradientSpinner, { variant: "dots" });
+    case "success":
+      return /* @__PURE__ */ jsx(Text, { color: colors.status.success, children: "\u2713" });
+    case "error":
+      return /* @__PURE__ */ jsx(Text, { color: colors.status.error, children: "\u2717" });
+    case "cancelled":
+      return /* @__PURE__ */ jsx(Text, { color: colors.text.muted, children: "\u2298" });
+  }
+}
+function formatDuration(ms) {
+  if (ms < 1e3) return `${ms}ms`;
+  return `${(ms / 1e3).toFixed(1)}s`;
+}
+function getToolIcon(name) {
+  switch (name) {
+    case "read":
+      return "\u{1F4C4}";
+    case "write":
+      return "\u270F\uFE0F";
+    case "edit":
+      return "\u{1F4DD}";
+    case "glob":
+      return "\u{1F50D}";
+    case "grep":
+      return "\u{1F50E}";
+    case "bash":
+      return "\u26A1";
+    case "web_search":
+    case "webSearch":
+      return "\u{1F310}";
+    case "web_fetch":
+    case "webFetch":
+      return "\u{1F4E1}";
+    default:
+      return "\u2699";
+  }
+}
+function ToolCallDisplay({
+  toolName,
+  status,
+  description,
+  output,
+  isError,
+  duration,
+  isCollapsed = true
+}) {
+  const borderColor = status === "error" ? colors.status.error : status === "executing" ? colors.status.active : colors.border.dim;
+  const icon = getToolIcon(toolName);
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginY: 0, children: [
+    /* @__PURE__ */ jsxs(Box, { children: [
+      /* @__PURE__ */ jsx(StatusIcon, { status }),
+      /* @__PURE__ */ jsx(Text, { children: " " }),
+      /* @__PURE__ */ jsxs(Text, { color: colors.role.tool, bold: true, children: [
+        icon,
+        " ",
+        toolName
+      ] }),
+      description ? /* @__PURE__ */ jsxs(Text, { color: colors.text.muted, children: [
+        " ",
+        description
+      ] }) : null,
+      duration !== void 0 && status !== "executing" ? /* @__PURE__ */ jsxs(Text, { color: colors.text.muted, dimColor: true, children: [
+        " ",
+        "(",
+        formatDuration(duration),
+        ")"
+      ] }) : null
+    ] }),
+    !isCollapsed && output ? /* @__PURE__ */ jsx(
+      Box,
+      {
+        flexDirection: "column",
+        marginLeft: 2,
+        borderStyle: "single",
+        borderLeft: true,
+        borderRight: false,
+        borderTop: false,
+        borderBottom: false,
+        borderColor,
+        paddingLeft: 1,
+        children: /* @__PURE__ */ jsx(
+          Text,
+          {
+            wrap: "wrap",
+            color: isError ? colors.status.error : colors.text.secondary,
+            children: output.length > 2e3 ? output.slice(0, 2e3) + "\n\u2026 (truncated)" : output
+          }
+        )
+      }
+    ) : null
+  ] });
+}
+function getRoleColor(role) {
+  switch (role) {
+    case "user":
+      return colors.role.user;
+    case "assistant":
+      return colors.role.assistant;
+    case "system":
+      return colors.role.system;
+    case "tool":
+      return colors.role.tool;
+  }
+}
+function getRoleIcon(role) {
+  switch (role) {
+    case "user":
+      return "\u276F";
+    case "assistant":
+      return "\u2726";
+    case "system":
+      return "\u2022";
+    case "tool":
+      return "\u2699";
+  }
+}
+function getRoleLabel(role, model) {
+  switch (role) {
+    case "user":
+      return "You";
+    case "assistant":
+      return model ?? "Assistant";
+    case "system":
+      return "System";
+    case "tool":
+      return "Tool";
+  }
+}
+function shortModelName(model) {
+  if (model.includes("opus")) return "Opus 4.6";
+  if (model.includes("sonnet")) return "Sonnet 4.6";
+  if (model.includes("haiku")) return "Haiku 4.5";
+  if (model.includes("gpt-5.2-mini")) return "GPT-5.2 mini";
+  if (model.includes("gpt-5.2")) return "GPT-5.2";
+  if (model.includes("o3")) return "o3";
+  if (model.includes("gemini") && model.includes("pro")) return "Gemini Pro";
+  if (model.includes("gemini") && model.includes("flash")) return "Gemini Flash";
+  if (model.includes("kimi") || model.includes("k2")) return "Kimi K2.5";
+  return model;
+}
+function formatToolArgs(name, args) {
+  switch (name) {
+    case "read":
+    case "write":
+    case "edit":
+      return typeof args["file_path"] === "string" ? args["file_path"] : "";
+    case "glob":
+      return typeof args["pattern"] === "string" ? args["pattern"] : "";
+    case "grep": {
+      const pat = typeof args["pattern"] === "string" ? args["pattern"] : "";
+      const dir = typeof args["path"] === "string" ? ` in ${args["path"]}` : "";
+      return `"${pat}"${dir}`;
+    }
+    case "bash": {
+      const cmd = typeof args["command"] === "string" ? args["command"] : "";
+      return cmd.length > 60 ? cmd.slice(0, 60) + "\u2026" : cmd;
+    }
+    default:
+      return JSON.stringify(args).slice(0, 80);
+  }
+}
+function MessageItem({ message }) {
+  const color = getRoleColor(message.role);
+  const icon = getRoleIcon(message.role);
+  const label = getRoleLabel(
+    message.role,
+    message.model ? shortModelName(message.model) : void 0
+  );
+  if (message.role === "system") {
+    return /* @__PURE__ */ jsx(Box, { flexDirection: "column", marginBottom: 1, children: /* @__PURE__ */ jsxs(Box, { children: [
+      /* @__PURE__ */ jsxs(Text, { color: colors.role.system, dimColor: true, children: [
+        icon,
+        " "
+      ] }),
+      /* @__PURE__ */ jsx(Text, { color: colors.role.system, dimColor: true, wrap: "wrap", children: message.content })
+    ] }) });
+  }
+  if (message.role === "tool" && message.toolCalls && message.toolCalls.length > 0) {
+    const firstCall = message.toolCalls[0];
+    if (firstCall) {
+      return /* @__PURE__ */ jsx(Box, { marginY: 0, marginLeft: 2, children: /* @__PURE__ */ jsx(
+        ToolCallDisplay,
+        {
+          toolName: firstCall.name,
+          status: message.content.startsWith("Error:") ? "error" : "success",
+          description: formatToolArgs(firstCall.name, firstCall.arguments),
+          output: message.content,
+          isError: message.content.startsWith("Error:"),
+          isCollapsed: message.content.length > 500
+        }
+      ) });
+    }
+  }
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [
+    /* @__PURE__ */ jsxs(Box, { children: [
+      /* @__PURE__ */ jsxs(Text, { color, bold: true, children: [
+        icon,
+        " ",
+        label
+      ] }),
+      message.tokenUsage ? /* @__PURE__ */ jsxs(Text, { color: colors.text.muted, dimColor: true, children: [
+        " ",
+        "(",
+        message.tokenUsage.totalTokens,
+        " tokens)"
+      ] }) : null
+    ] }),
+    /* @__PURE__ */ jsx(Box, { marginLeft: 2, flexDirection: "column", children: /* @__PURE__ */ jsx(MarkdownContent, { content: message.content }) }),
+    message.toolCalls && message.toolCalls.length > 0 ? /* @__PURE__ */ jsx(Box, { marginLeft: 2, flexDirection: "column", marginTop: 0, children: message.toolCalls.map((call) => {
+      const argSummary = formatToolArgs(call.name, call.arguments);
+      return /* @__PURE__ */ jsx(
+        ToolCallDisplay,
+        {
+          toolName: call.name,
+          status: "success",
+          description: argSummary
+        },
+        call.id
+      );
+    }) }) : null
+  ] });
+}
+var MAX_VISIBLE_MESSAGES = 50;
+function MessageView({
+  messages
+}) {
+  const visibleMessages = messages.length > MAX_VISIBLE_MESSAGES ? messages.slice(-MAX_VISIBLE_MESSAGES) : messages;
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", flexGrow: 1, paddingX: 1, children: [
+    messages.length > MAX_VISIBLE_MESSAGES ? /* @__PURE__ */ jsxs(Text, { color: colors.text.muted, dimColor: true, children: [
+      "  ",
+      "(",
+      messages.length - MAX_VISIBLE_MESSAGES,
+      " earlier messages hidden)"
+    ] }) : null,
+    visibleMessages.map((msg) => /* @__PURE__ */ jsx(MessageItem, { message: msg }, msg.id))
+  ] });
+}
+var MAX_VISIBLE_ITEMS = 8;
+var SCROLL_UP_LABEL = "\u25B2";
+var SCROLL_DOWN_LABEL = "\u25BC";
+var SELECTED_LABEL = "\u25B8 ";
+function AutocompletePopup({
+  items,
+  selectedIndex
+}) {
+  if (items.length === 0) return null;
+  const totalItems = items.length;
+  const windowSize = Math.min(MAX_VISIBLE_ITEMS, totalItems);
+  let scrollOffset = 0;
+  if (selectedIndex >= windowSize) {
+    scrollOffset = selectedIndex - windowSize + 1;
+  }
+  scrollOffset = Math.max(
+    0,
+    Math.min(scrollOffset, totalItems - windowSize)
+  );
+  const visibleItems = items.slice(scrollOffset, scrollOffset + windowSize);
+  const hasMore = scrollOffset + windowSize < totalItems;
+  const hasLess = scrollOffset > 0;
+  return /* @__PURE__ */ jsxs(
+    Box,
+    {
+      flexDirection: "column",
+      borderStyle: "round",
+      borderColor: colors.status.active,
+      paddingX: 1,
+      marginBottom: 0,
+      children: [
+        hasLess ? /* @__PURE__ */ jsxs(Text, { color: colors.text.muted, dimColor: true, children: [
+          "  ",
+          SCROLL_UP_LABEL,
+          " ",
+          scrollOffset,
+          " above"
+        ] }) : null,
+        visibleItems.map((item, visibleIndex) => {
+          const actualIndex = scrollOffset + visibleIndex;
+          const isSelected = actualIndex === selectedIndex;
+          return /* @__PURE__ */ jsxs(Box, { children: [
+            /* @__PURE__ */ jsxs(
+              Text,
+              {
+                color: isSelected ? colors.status.active : colors.text.primary,
+                bold: isSelected,
+                children: [
+                  isSelected ? SELECTED_LABEL : "  ",
+                  item.label
+                ]
+              }
+            ),
+            /* @__PURE__ */ jsxs(Text, { color: colors.text.muted, dimColor: true, children: [
+              "  ",
+              item.description
+            ] })
+          ] }, `${item.label}-${actualIndex}`);
+        }),
+        hasMore ? /* @__PURE__ */ jsxs(Text, { color: colors.text.muted, dimColor: true, children: [
+          "  ",
+          SCROLL_DOWN_LABEL,
+          " ",
+          totalItems - scrollOffset - windowSize,
+          " more"
+        ] }) : null
+      ]
+    }
+  );
+}
+
+// src/ui/autocomplete-data.ts
+var SLASH_COMMANDS = [
+  { command: "/login", description: "Log in to a provider (interactive)" },
+  { command: "/help", description: "Show available commands" },
+  { command: "/model", description: "Select a model with provider-specific thinking options" },
+  { command: "/role", description: "Switch role (planning, coding, review, testing, bugfix)" },
+  { command: "/cost", description: "Show session cost breakdown" },
+  { command: "/clear", description: "Clear conversation" },
+  { command: "/compact", description: "Compress context" },
+  { command: "/team list", description: "List active teams" },
+  { command: "/team stop", description: "Deactivate team and return to single-pane" },
+  { command: "/mcp list", description: "List connected MCP servers" },
+  { command: "/mcp add", description: "Add an MCP server" },
+  { command: "/skill list", description: "List available skills" },
+  { command: "/panel", description: "Show swarm layout information" },
+  { command: "/login status", description: "Show login status for all providers" },
+  { command: "/login logout", description: "Log out of a provider" },
+  { command: "/config get", description: "Get a configuration value" },
+  { command: "/config set", description: "Set a configuration value" },
+  { command: "/history", description: "List past conversations" },
+  { command: "/resume", description: "Resume a past conversation by number or ID" },
+  { command: "/quit", description: "Exit" },
+  { command: "/exit", description: "Exit" }
+];
+var BUILTIN_CONTEXT_REFS = [
+  { label: "@codebase", description: "Reference the entire codebase" },
+  { label: "@git", description: "Reference git state" },
+  { label: "@docs", description: "Reference project docs" },
+  { label: "@web", description: "Reference web context" }
+];
+var dynamicFileRefs = [];
+var CODE_REFS = [
+  { label: "`src/", description: "Source directory" },
+  { label: "`src/ui/", description: "UI components" },
+  { label: "`src/auth/", description: "Authentication modules" },
+  { label: "`src/providers/", description: "LLM provider adapters" },
+  { label: "`src/teams/", description: "Team management" },
+  { label: "`src/core/", description: "Core engine" },
+  { label: "`src/tools/", description: "Tool implementations" },
+  { label: "`src/types/", description: "Type definitions" },
+  { label: "`src/storage/", description: "Storage layer" },
+  { label: "`src/utils/", description: "Utility functions" }
+];
+var BUILTIN_SKILL_REFS = [
+  { label: "$review", description: "Comprehensive code review" },
+  { label: "$commit", description: "Smart git commit with message generation" },
+  { label: "$plan", description: "Create implementation plan from requirements" },
+  { label: "$debug", description: "Systematic debugging workflow" },
+  { label: "$test", description: "Generate tests for code" },
+  { label: "$refactor", description: "Refactoring with safety checks" }
+];
+var dynamicSkillRefs = BUILTIN_SKILL_REFS;
+function registerDynamicSkills(skills) {
+  dynamicSkillRefs = skills.length > 0 ? skills : BUILTIN_SKILL_REFS;
+}
+function registerDynamicFileRefs(files) {
+  dynamicFileRefs = files;
+}
+function getAutocompleteItems(trigger, query) {
+  const normalizedQuery = query.toLowerCase();
+  switch (trigger) {
+    case "/": {
+      const filtered = SLASH_COMMANDS.filter((cmd) => cmd.command.toLowerCase().includes(normalizedQuery));
+      return filtered.map((cmd) => ({ label: cmd.command, description: cmd.description }));
+    }
+    case "@": {
+      const fileMatches = dynamicFileRefs.filter((ref) => ref.label.toLowerCase().includes(normalizedQuery));
+      const builtinMatches = BUILTIN_CONTEXT_REFS.filter((ref) => ref.label.toLowerCase().includes(normalizedQuery));
+      return [...fileMatches, ...builtinMatches];
+    }
+    case "`": {
+      return CODE_REFS.filter((ref) => ref.label.toLowerCase().includes(normalizedQuery));
+    }
+    case "$": {
+      return dynamicSkillRefs.filter((ref) => ref.label.toLowerCase().includes(normalizedQuery));
+    }
+  }
+}
+
+// src/ui/input-utils.ts
+function toCodePoints(value) {
+  return Array.from(value);
+}
+function codePointLength(value) {
+  return toCodePoints(value).length;
+}
+function sliceCodePoints(value, start, end) {
+  return toCodePoints(value).slice(start, end).join("");
+}
+function clampCursorOffset(value, offset) {
+  return Math.max(0, Math.min(offset, codePointLength(value)));
+}
+function insertTextAtCursor(value, cursorOffset, insertedText) {
+  const points = toCodePoints(value);
+  const insertion = toCodePoints(insertedText);
+  const safeOffset = clampCursorOffset(value, cursorOffset);
+  points.splice(safeOffset, 0, ...insertion);
+  return {
+    text: points.join(""),
+    cursorOffset: safeOffset + insertion.length
+  };
+}
+function backspaceAtCursor(value, cursorOffset) {
+  const safeOffset = clampCursorOffset(value, cursorOffset);
+  if (safeOffset === 0) {
+    return { text: value, cursorOffset: safeOffset };
+  }
+  const points = toCodePoints(value);
+  points.splice(safeOffset - 1, 1);
+  return {
+    text: points.join(""),
+    cursorOffset: safeOffset - 1
+  };
+}
+function deleteAtCursor(value, cursorOffset) {
+  const safeOffset = clampCursorOffset(value, cursorOffset);
+  const points = toCodePoints(value);
+  if (safeOffset >= points.length) {
+    return { text: value, cursorOffset: safeOffset };
+  }
+  points.splice(safeOffset, 1);
+  return {
+    text: points.join(""),
+    cursorOffset: safeOffset
+  };
+}
+
+// src/ui/history-navigation.ts
+function navigateHistoryState(state, nextIndex, defaultCursor) {
+  const cache = { ...state.cache };
+  const previousIndex = state.historyIndex;
+  cache[previousIndex] = {
+    text: state.currentInput,
+    cursorOffset: clampCursorOffset(state.currentInput, state.currentCursorOffset)
+  };
+  const saved = cache[nextIndex];
+  const isReturningToPrevious = nextIndex === -1 || nextIndex === state.previousHistoryIndex;
+  if (isReturningToPrevious && saved && saved.cursorOffset > 0 && saved.cursorOffset < codePointLength(saved.text)) {
+    return {
+      historyIndex: nextIndex,
+      previousHistoryIndex: previousIndex,
+      cache,
+      input: saved.text,
+      cursorOffset: saved.cursorOffset
+    };
+  }
+  if (nextIndex === -1) {
+    const text = saved?.text ?? "";
+    return {
+      historyIndex: nextIndex,
+      previousHistoryIndex: previousIndex,
+      cache,
+      input: text,
+      cursorOffset: defaultCursor === "start" ? 0 : codePointLength(text)
+    };
+  }
+  if (saved) {
+    return {
+      historyIndex: nextIndex,
+      previousHistoryIndex: previousIndex,
+      cache,
+      input: saved.text,
+      cursorOffset: defaultCursor === "start" ? 0 : codePointLength(saved.text)
+    };
+  }
+  const input = state.history[state.history.length - 1 - nextIndex] ?? "";
+  return {
+    historyIndex: nextIndex,
+    previousHistoryIndex: previousIndex,
+    cache,
+    input,
+    cursorOffset: defaultCursor === "start" ? 0 : codePointLength(input)
+  };
+}
+var MODE_ORDER = ["agent-swarm", "accept-edits", "chat"];
+var MODE_DISPLAY = {
+  "agent-swarm": {
+    label: "swarm orchestrator",
+    icon: "\u25B6\u25B6",
+    color: BRAND_COLOR
+  },
+  "accept-edits": {
+    label: "guided edits",
+    icon: "\u2551\u2551",
+    color: "#EDD6DC"
+  },
+  chat: {
+    label: "direct chat",
+    icon: "\u25CB",
+    color: "#8D7176"
+  }
+};
+var TRIGGER_CHARS = /* @__PURE__ */ new Set(["/", "@", "`", "$"]);
+function detectTrigger(input, cursorOffset) {
+  const safeOffset = clampCursorOffset(input, cursorOffset);
+  const beforeCursor = sliceCodePoints(input, 0, safeOffset);
+  if (beforeCursor.length === 0) return null;
+  if (beforeCursor[0] === "/") return { trigger: "/", query: beforeCursor, rangeStart: 0 };
+  if (beforeCursor[0] === "$") return { trigger: "$", query: beforeCursor, rangeStart: 0 };
+  const points = Array.from(beforeCursor);
+  for (let i = points.length - 1; i >= 0; i--) {
+    const ch = points[i];
+    if (ch === void 0) continue;
+    if (TRIGGER_CHARS.has(ch) && ch !== "/" && ch !== "$") {
+      if (i === 0 || points[i - 1] === " ") {
+        return {
+          trigger: ch,
+          query: points.slice(i).join(""),
+          rangeStart: i
+        };
+      }
+    }
+    if (ch === " ") break;
+  }
+  return null;
+}
+function InputBar({
+  onSubmit,
+  isProcessing,
+  placeholder,
+  onCancel,
+  initialHistory,
+  mode = "agent-swarm",
+  onModeChange
+}) {
+  const [input, setInput] = useState("");
+  const [cursorOffset, setCursorOffset] = useState(0);
+  const [selectedIndex, setSelectedIndex] = useState(0);
+  const [history, setHistory] = useState(
+    initialHistory ? [...initialHistory] : []
+  );
+  const [historyIndex, setHistoryIndex] = useState(-1);
+  const inputRef = useRef(input);
+  const cursorOffsetRef = useRef(cursorOffset);
+  const historyRef = useRef(history);
+  const historyIndexRef = useRef(historyIndex);
+  const triggerStateRef = useRef(null);
+  const autocompleteItemsRef = useRef([]);
+  const isAutocompleteActiveRef = useRef(false);
+  const previousHistoryIndexRef = useRef(void 0);
+  const historyCacheRef = useRef({});
+  const setInputWithCursor = useCallback(
+    (nextInput, cursorPosition = "end") => {
+      const nextCursor = cursorPosition === "start" ? 0 : cursorPosition === "end" ? codePointLength(nextInput) : clampCursorOffset(nextInput, cursorPosition);
+      inputRef.current = nextInput;
+      cursorOffsetRef.current = nextCursor;
+      setInput(nextInput);
+      setCursorOffset(nextCursor);
+      setSelectedIndex(0);
+    },
+    []
+  );
+  const setCursorPosition = useCallback(
+    (nextCursor) => {
+      const clamped = clampCursorOffset(inputRef.current, nextCursor);
+      cursorOffsetRef.current = clamped;
+      setCursorOffset(clamped);
+    },
+    []
+  );
+  const resetHistoryNavigation = useCallback(() => {
+    historyIndexRef.current = -1;
+    setHistoryIndex(-1);
+    previousHistoryIndexRef.current = void 0;
+    historyCacheRef.current = {};
+  }, []);
+  const navigateHistory = useCallback(
+    (nextIndex, defaultCursor) => {
+      const result = navigateHistoryState(
+        {
+          history: historyRef.current,
+          historyIndex: historyIndexRef.current,
+          previousHistoryIndex: previousHistoryIndexRef.current,
+          cache: historyCacheRef.current,
+          currentInput: inputRef.current,
+          currentCursorOffset: cursorOffsetRef.current
+        },
+        nextIndex,
+        defaultCursor
+      );
+      historyCacheRef.current = result.cache;
+      historyIndexRef.current = result.historyIndex;
+      previousHistoryIndexRef.current = result.previousHistoryIndex;
+      setHistoryIndex(result.historyIndex);
+      setInputWithCursor(result.input, result.cursorOffset);
+    },
+    [setInputWithCursor]
+  );
+  const applyAutocompleteSelection = useCallback(
+    (selected, triggerMatch) => {
+      const currentInput = inputRef.current;
+      const currentCursorOffset = cursorOffsetRef.current;
+      const before = sliceCodePoints(currentInput, 0, triggerMatch.rangeStart);
+      const after = sliceCodePoints(currentInput, currentCursorOffset);
+      const nextInput = `${before}${selected.label} ${after}`;
+      setInputWithCursor(nextInput, codePointLength(before) + codePointLength(selected.label) + 1);
+    },
+    [setInputWithCursor]
+  );
+  useEffect(() => {
+    if (initialHistory && initialHistory.length > 0) {
+      setHistory((prev) => {
+        if (prev.length === 0) return [...initialHistory];
+        return prev;
+      });
+    }
+  }, [initialHistory]);
+  useEffect(() => {
+    inputRef.current = input;
+    cursorOffsetRef.current = cursorOffset;
+    historyRef.current = history;
+    historyIndexRef.current = historyIndex;
+  }, [cursorOffset, history, historyIndex, input]);
+  const triggerState = useMemo(() => detectTrigger(input, cursorOffset), [cursorOffset, input]);
+  const autocompleteItems = useMemo(() => {
+    if (triggerState === null) return [];
+    return getAutocompleteItems(triggerState.trigger, triggerState.query);
+  }, [triggerState]);
+  const isAutocompleteActive = autocompleteItems.length > 0;
+  useEffect(() => {
+    triggerStateRef.current = triggerState;
+    autocompleteItemsRef.current = autocompleteItems;
+    isAutocompleteActiveRef.current = isAutocompleteActive;
+  }, [autocompleteItems, isAutocompleteActive, triggerState]);
+  const appendToHistory = useCallback((entry) => {
+    setHistory((prev) => {
+      const next = [...prev.slice(-99), entry];
+      historyRef.current = next;
+      return next;
+    });
+  }, []);
+  useInput((inputChar, key) => {
+    const currentInput = inputRef.current;
+    const currentCursorOffset = cursorOffsetRef.current;
+    const currentHistoryIndex = historyIndexRef.current;
+    const currentHistory = historyRef.current;
+    const currentTriggerState = triggerStateRef.current;
+    const currentAutocompleteItems = autocompleteItemsRef.current;
+    const currentAutocompleteActive = isAutocompleteActiveRef.current;
+    if (isProcessing) {
+      if (key.escape && onCancel) {
+        onCancel();
+      }
+      return;
+    }
+    if (key.leftArrow) {
+      setCursorPosition(currentCursorOffset - 1);
+      return;
+    }
+    if (key.rightArrow) {
+      setCursorPosition(currentCursorOffset + 1);
+      return;
+    }
+    if (key.tab && key.shift) {
+      if (onModeChange) {
+        const idx = MODE_ORDER.indexOf(mode);
+        const next = MODE_ORDER[(idx + 1) % MODE_ORDER.length];
+        if (next) {
+          onModeChange(next);
+        }
+      }
+      return;
+    }
+    if (key.upArrow) {
+      if (currentHistoryIndex !== -1) {
+        if (currentHistoryIndex < currentHistory.length - 1) {
+          navigateHistory(currentHistoryIndex + 1, "end");
+        }
+        return;
+      }
+      if (currentAutocompleteActive) {
+        setSelectedIndex(
+          (prev) => prev > 0 ? prev - 1 : currentAutocompleteItems.length - 1
+        );
+        return;
+      }
+      if (currentHistory.length > 0) {
+        navigateHistory(0, "end");
+      }
+      return;
+    }
+    if (key.downArrow) {
+      if (currentHistoryIndex !== -1) {
+        navigateHistory(currentHistoryIndex - 1, "end");
+        return;
+      }
+      if (currentAutocompleteActive) {
+        setSelectedIndex(
+          (prev) => prev < currentAutocompleteItems.length - 1 ? prev + 1 : 0
+        );
+      }
+      return;
+    }
+    if (currentAutocompleteActive) {
+      if (key.tab) {
+        const selected = currentAutocompleteItems[selectedIndex];
+        if (selected && currentTriggerState) {
+          applyAutocompleteSelection(selected, currentTriggerState);
+        }
+        return;
+      }
+      if (key.escape) {
+        const result = insertTextAtCursor(currentInput, currentCursorOffset, " ");
+        setInputWithCursor(result.text, result.cursorOffset);
+        return;
+      }
+    }
+    if (key.return) {
+      if (currentHistoryIndex !== -1 && currentInput.trim().length > 0) {
+        appendToHistory(currentInput.trim());
+        onSubmit(currentInput.trim());
+        setInputWithCursor("");
+        resetHistoryNavigation();
+        return;
+      }
+      if (currentAutocompleteActive) {
+        const selected = currentAutocompleteItems[selectedIndex];
+        if (selected && currentTriggerState) {
+          if (currentTriggerState.trigger === "/" && currentHistoryIndex === -1) {
+            appendToHistory(selected.label.trim());
+            onSubmit(selected.label.trim());
+            setInputWithCursor("");
+          } else {
+            applyAutocompleteSelection(selected, currentTriggerState);
+          }
+          resetHistoryNavigation();
+          return;
+        }
+      }
+      if (currentInput.trim().length > 0) {
+        appendToHistory(currentInput.trim());
+        onSubmit(currentInput.trim());
+        setInputWithCursor("");
+        resetHistoryNavigation();
+      }
+      return;
+    }
+    if (key.backspace || key.delete || key.ctrl && inputChar === "h") {
+      const result = backspaceAtCursor(currentInput, currentCursorOffset);
+      setInputWithCursor(result.text, result.cursorOffset);
+      return;
+    }
+    if (key.ctrl && inputChar === "d" && currentInput.length > 0) {
+      const result = deleteAtCursor(currentInput, currentCursorOffset);
+      setInputWithCursor(result.text, result.cursorOffset);
+      return;
+    }
+    if (key.ctrl && inputChar === "c") {
+      process.exit(0);
+      return;
+    }
+    if (key.ctrl && inputChar === "l") return;
+    if (!key.ctrl && !key.meta && inputChar) {
+      const result = insertTextAtCursor(currentInput, currentCursorOffset, inputChar);
+      setInputWithCursor(result.text, result.cursorOffset);
+    }
+  });
+  const modeInfo = MODE_DISPLAY[mode];
+  const borderColor = isProcessing ? colors.border.dim : modeInfo.color;
+  const cursorChar = sliceCodePoints(input, cursorOffset, cursorOffset + 1);
+  const beforeCursor = sliceCodePoints(input, 0, cursorOffset);
+  const afterCursor = cursorChar.length > 0 ? sliceCodePoints(input, cursorOffset + 1) : "";
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+    isAutocompleteActive ? /* @__PURE__ */ jsx(AutocompletePopup, { items: autocompleteItems, selectedIndex }) : null,
+    /* @__PURE__ */ jsxs(Box, { children: [
+      /* @__PURE__ */ jsxs(Text, { color: colors.border.dim, children: [
+        "\u2500".repeat(4),
+        " "
+      ] }),
+      /* @__PURE__ */ jsxs(Text, { color: modeInfo.color, bold: true, children: [
+        modeInfo.icon,
+        " "
+      ] }),
+      /* @__PURE__ */ jsx(Text, { color: modeInfo.color, bold: true, children: modeInfo.label }),
+      /* @__PURE__ */ jsx(Text, { color: colors.text.muted, children: " (shift+tab to cycle)" })
+    ] }),
+    /* @__PURE__ */ jsxs(Box, { borderStyle: "round", borderColor, paddingX: 1, children: [
+      /* @__PURE__ */ jsxs(Text, { color: modeInfo.color, bold: true, children: [
+        "\u276F",
+        " "
+      ] }),
+      isProcessing ? /* @__PURE__ */ jsx(Text, { color: colors.text.muted, children: onCancel ? "esc to cancel" : "Processing\u2026" }) : input.length > 0 ? /* @__PURE__ */ jsxs(Text, { children: [
+        /* @__PURE__ */ jsx(Text, { color: colors.text.primary, children: beforeCursor }),
+        cursorChar.length > 0 ? /* @__PURE__ */ jsx(Text, { color: colors.text.primary, inverse: true, children: cursorChar }) : /* @__PURE__ */ jsx(Text, { color: modeInfo.color, children: "\u2588" }),
+        afterCursor.length > 0 ? /* @__PURE__ */ jsx(Text, { color: colors.text.primary, children: afterCursor }) : null
+      ] }) : /* @__PURE__ */ jsxs(Text, { color: colors.text.muted, children: [
+        placeholder ?? "Type a message\u2026",
+        /* @__PURE__ */ jsx(Text, { color: modeInfo.color, children: "\u2588" })
+      ] })
+    ] })
+  ] });
+}
+function shortModelLabel(model) {
+  if (model.includes("opus")) return "Opus 4.6";
+  if (model.includes("sonnet")) return "Sonnet 4.6";
+  if (model.includes("haiku")) return "Haiku 4.5";
+  if (model.includes("gpt-5.2-mini")) return "GPT-5.2m";
+  if (model.includes("gpt-5.2")) return "GPT-5.2";
+  if (model.includes("o3")) return "o3";
+  if (model.includes("gemini") && model.includes("pro")) return "Gem Pro";
+  if (model.includes("gemini") && model.includes("flash")) return "Gem Flash";
+  if (model.includes("kimi") || model.includes("k2")) return "Kimi";
+  return model;
+}
+var SEP = " \u2502 ";
+function StatusBar({
+  model,
+  role,
+  tokenCount,
+  cost,
+  gitBranch,
+  gitChanges
+}) {
+  return /* @__PURE__ */ jsxs(Box, { borderStyle: "round", borderColor: colors.border.dim, paddingX: 1, children: [
+    /* @__PURE__ */ jsxs(Text, { color: BRAND_COLOR, bold: true, children: [
+      "\u25C6",
+      " "
+    ] }),
+    /* @__PURE__ */ jsx(Text, { color: colors.status.active, bold: true, children: "Aemeath Agent Swarm" }),
+    /* @__PURE__ */ jsx(Text, { color: colors.text.muted, children: SEP }),
+    /* @__PURE__ */ jsx(Text, { color: colors.status.warning, bold: true, children: shortModelLabel(model) }),
+    role ? /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx(Text, { color: colors.text.muted, children: SEP }),
+      /* @__PURE__ */ jsx(Text, { color: colors.role.tool, children: role })
+    ] }) : null,
+    /* @__PURE__ */ jsx(Text, { color: colors.text.muted, children: SEP }),
+    /* @__PURE__ */ jsxs(Text, { color: colors.text.secondary, children: [
+      tokenCount,
+      " tok"
+    ] }),
+    /* @__PURE__ */ jsx(Text, { color: colors.text.muted, children: SEP }),
+    /* @__PURE__ */ jsx(Text, { color: colors.status.success, children: cost }),
+    gitBranch ? /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx(Text, { color: colors.text.muted, children: SEP }),
+      /* @__PURE__ */ jsxs(Text, { color: colors.status.info, children: [
+        "\u2387",
+        " ",
+        gitBranch,
+        gitChanges !== void 0 && gitChanges > 0 ? ` \xB1${gitChanges}` : ""
+      ] })
+    ] }) : null
+  ] });
+}
+var THINKING_PHRASES = [
+  "Thinking",
+  "Analyzing",
+  "Reasoning",
+  "Processing",
+  "Understanding",
+  "Considering",
+  "Evaluating"
+];
+var PHRASE_CYCLE_MS = 2500;
+function ThinkingIndicator({
+  activity,
+  isStreaming,
+  modelName,
+  startTime
+}) {
+  const tick = useAnimationTick(1e3);
+  const elapsed = startTime === void 0 ? 0 : Math.max(0, Date.now() - startTime);
+  const phraseIndex = Math.floor(elapsed / PHRASE_CYCLE_MS) % THINKING_PHRASES.length;
+  const elapsedStr = useMemo(() => {
+    const secs = Math.floor(elapsed / 1e3);
+    if (secs < 1) return "";
+    if (secs < 60) return `${secs}s`;
+    const mins = Math.floor(secs / 60);
+    return `${mins}m${secs % 60}s`;
+  }, [elapsed]);
+  const dotCount = tick % 4;
+  const dots = ".".repeat(dotCount);
+  const phrase = THINKING_PHRASES[phraseIndex] ?? "Thinking";
+  const displayText = activity ? activity : isStreaming ? "Streaming response" : `${phrase}${dots}`;
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+    modelName ? /* @__PURE__ */ jsxs(Box, { children: [
+      /* @__PURE__ */ jsxs(Text, { color: colors.role.assistant, bold: true, children: [
+        "\u2726",
+        " "
+      ] }),
+      /* @__PURE__ */ jsx(Text, { color: colors.role.assistant, bold: true, children: modelName })
+    ] }) : null,
+    /* @__PURE__ */ jsxs(Box, { marginLeft: 2, children: [
+      /* @__PURE__ */ jsx(
+        GradientSpinner,
+        {
+          variant: activity ? "braille" : "dots",
+          label: displayText,
+          labelColor: activity ? colors.text.secondary : colors.text.muted
+        }
+      ),
+      elapsedStr ? /* @__PURE__ */ jsxs(Text, { color: colors.text.muted, children: [
+        " (",
+        elapsedStr,
+        ")"
+      ] }) : null
+    ] }),
+    /* @__PURE__ */ jsx(Box, { marginLeft: 2, children: /* @__PURE__ */ jsxs(Text, { color: colors.text.muted, dimColor: true, children: [
+      "  ",
+      "esc to cancel"
+    ] }) })
+  ] });
+}
+var MASCOT_LINES = [
+  "         :-         ",
+  "      ::::::::      ",
+  "    .:.:::.::::     ",
+  "     ::--:::-:: ::  ",
+  "     -:##**%%:-     ",
+  "      :=+==++: :    ",
+  "     ::==++=-:.     ",
+  "-:-=*:----:=-::*==:-",
+  "  =    -::::-    -  "
+];
+var LOGO_LINES = [
+  " \u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2557   \u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2557  \u2588\u2588\u2557",
+  "\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2554\u2550\u2550\u2588\u2588\u2554\u2550\u2550\u255D\u2588\u2588\u2551  \u2588\u2588\u2551",
+  "\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2554\u2588\u2588\u2588\u2588\u2554\u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551   \u2588\u2588\u2551   \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551",
+  "\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u255D  \u2588\u2588\u2551\u2554\u2588\u2588\u2554\u255D\u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u255D  \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2551   \u2588\u2588\u2551   \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2551",
+  "\u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2551 \u2554\u2550\u255D \u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2551  \u2588\u2588\u2551   \u2588\u2588\u2551   \u2588\u2588\u2551  \u2588\u2588\u2551",
+  "\u2554\u2550\u255D  \u2554\u2550\u255D\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u255D\u2554\u2550\u255D     \u2554\u2550\u255D\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u255D\u2554\u2550\u255D  \u2554\u2550\u255D   \u2554\u2550\u255D   \u2554\u2550\u255D  \u2554\u2550\u255D"
+];
+var TIPS = [
+  { key: "/help", desc: "Show all commands" },
+  { key: "/model", desc: "Switch AI model" },
+  { key: "Shift+Tab", desc: "Cycle swarm/edit/chat modes" },
+  { key: "Tab", desc: "Autocomplete or focus next agent" },
+  { key: "@", desc: "Reference project files" },
+  { key: "$skill", desc: "Invoke skills" }
+];
+var TIP_ROWS = [TIPS.slice(0, 2), TIPS.slice(2, 4), TIPS.slice(4)];
+function WelcomeScreen({
+  version
+}) {
+  return /* @__PURE__ */ jsxs(
+    Box,
+    {
+      flexDirection: "column",
+      flexGrow: 1,
+      paddingX: 2,
+      justifyContent: "center",
+      alignItems: "center",
+      marginBottom: 1,
+      children: [
+        /* @__PURE__ */ jsxs(Box, { alignItems: "center", children: [
+          /* @__PURE__ */ jsx(Box, { flexDirection: "column", marginRight: 2, children: MASCOT_LINES.map((line, i) => /* @__PURE__ */ jsx(Text, { color: BRAND_COLOR, children: line }, `m${i}`)) }),
+          /* @__PURE__ */ jsx(Box, { flexDirection: "column", children: LOGO_LINES.map((line, i) => /* @__PURE__ */ jsx(Text, { color: BRAND_COLOR, children: line }, i)) })
+        ] }),
+        /* @__PURE__ */ jsxs(Box, { marginBottom: 0, children: [
+          /* @__PURE__ */ jsxs(Text, { color: colors.border.active, children: [
+            "\u2500".repeat(16),
+            " "
+          ] }),
+          /* @__PURE__ */ jsx(Text, { color: colors.text.accent, bold: true, children: "Aemeath Agent Swarm" }),
+          /* @__PURE__ */ jsxs(Text, { color: colors.border.active, children: [
+            " ",
+            "\u2500".repeat(16)
+          ] })
+        ] }),
+        version ? /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsxs(Text, { color: colors.text.muted, children: [
+          "v",
+          version
+        ] }) }) : null,
+        /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+          /* @__PURE__ */ jsx(Box, { marginBottom: 1, children: /* @__PURE__ */ jsx(Text, { color: colors.text.secondary, bold: true, children: "Quick Start" }) }),
+          TIP_ROWS.map((row, rowIndex) => /* @__PURE__ */ jsx(Box, { children: row.map((tip, tipIndex) => /* @__PURE__ */ jsxs(
+            Box,
+            {
+              flexDirection: "column",
+              width: 40,
+              marginRight: tipIndex < row.length - 1 ? 3 : 0,
+              children: [
+                /* @__PURE__ */ jsx(Text, { color: colors.status.active, bold: true, children: tip.key }),
+                /* @__PURE__ */ jsx(Text, { color: colors.text.muted, children: tip.desc })
+              ]
+            },
+            tip.key
+          )) }, `tip-row-${rowIndex}`))
+        ] })
+      ]
+    }
+  );
+}
+function shortModelName2(model) {
+  if (model.includes("opus")) return "Opus 4.6";
+  if (model.includes("sonnet")) return "Sonnet 4.6";
+  if (model.includes("haiku")) return "Haiku 4.5";
+  if (model.includes("gpt-5.2-mini")) return "GPT-5.2m";
+  if (model.includes("gpt-5.2")) return "GPT-5.2";
+  if (model.includes("o3")) return "o3";
+  if (model.includes("gemini") && model.includes("pro")) return "Gem Pro";
+  if (model.includes("gemini") && model.includes("flash")) return "Gem Flash";
+  if (model.includes("kimi") || model.includes("k2")) return "Kimi";
+  return model;
+}
+function tailLines(text, maxLines) {
+  const lines = text.split("\n");
+  if (lines.length <= maxLines) return text;
+  return lines.slice(-maxLines).join("\n");
+}
+function SinglePane({
+  messages,
+  isProcessing,
+  onSubmit,
+  onCancel,
+  model,
+  role,
+  tokenCount,
+  cost,
+  gitBranch,
+  gitChanges,
+  streamingContent,
+  activity,
+  initialHistory,
+  mode,
+  onModeChange
+}) {
+  const processingStartRef = useRef(void 0);
+  if (isProcessing && processingStartRef.current === void 0) {
+    processingStartRef.current = Date.now();
+  } else if (!isProcessing) {
+    processingStartRef.current = void 0;
+  }
+  const hasContent = streamingContent !== void 0 && streamingContent.length > 0;
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", height: "100%", children: [
+    /* @__PURE__ */ jsx(
+      StatusBar,
+      {
+        model,
+        role,
+        tokenCount,
+        cost,
+        gitBranch,
+        gitChanges
+      }
+    ),
+    messages.length === 0 && !isProcessing ? (
+      /* ── Welcome screen ────────────────────────────────── */
+      /* @__PURE__ */ jsx(
+        WelcomeScreen,
+        {
+          version: PACKAGE_VERSION
+        }
+      )
+    ) : /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx(MessageView, { messages }),
+      isProcessing ? /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginLeft: 1, marginBottom: 1, children: [
+        hasContent ? /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginLeft: 2, marginBottom: 1, children: [
+          /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsxs(Text, { color: colors.role.assistant, bold: true, children: [
+            "\u2726",
+            " ",
+            shortModelName2(model)
+          ] }) }),
+          /* @__PURE__ */ jsx(Box, { marginLeft: 2, children: /* @__PURE__ */ jsx(MarkdownContent, { content: tailLines(streamingContent, 12) }) })
+        ] }) : null,
+        /* @__PURE__ */ jsx(
+          ThinkingIndicator,
+          {
+            activity,
+            isStreaming: hasContent,
+            modelName: hasContent ? void 0 : shortModelName2(model),
+            startTime: processingStartRef.current
+          }
+        )
+      ] }) : null
+    ] }),
+    /* @__PURE__ */ jsx(
+      InputBar,
+      {
+        onSubmit,
+        isProcessing,
+        onCancel,
+        initialHistory,
+        mode,
+        onModeChange
+      }
+    )
+  ] });
+}
+function getStatusColor(status) {
+  switch (status) {
+    case "active":
+      return colors.status.success;
+    case "idle":
+      return colors.status.warning;
+    case "error":
+      return colors.status.error;
+    case "shutdown":
+      return colors.text.muted;
+    default:
+      return colors.text.primary;
+  }
+}
+function shortModelLabel2(model) {
+  if (model.includes("opus")) return "Opus";
+  if (model.includes("sonnet")) return "Sonnet";
+  if (model.includes("haiku")) return "Haiku";
+  if (model.includes("gpt-5")) return "GPT-5";
+  if (model.includes("gemini") && model.includes("pro")) return "Gem-Pro";
+  if (model.includes("gemini") && model.includes("flash")) return "Gem-Flash";
+  if (model.includes("kimi") || model.includes("k2")) return "Kimi";
+  const parts = model.split("-");
+  return parts[parts.length - 1] ?? model.slice(0, 8);
+}
+function statusIndicator(status) {
+  switch (status) {
+    case "active":
+      return "\u25CF";
+    case "idle":
+      return "\u25CB";
+    case "error":
+      return "\u2716";
+    default:
+      return "\u2500";
+  }
+}
+function classifyLine(line) {
+  if (line.length === 0) return "empty";
+  if (line.startsWith("\u2699") || line.startsWith("\u2699\uFE0F")) return "tool";
+  if (line.startsWith("  \u2192")) return "result";
+  if (line.startsWith("Error:") || line.startsWith("Stream error:")) return "error";
+  return "text";
+}
+function renderLine(line, key) {
+  const type = classifyLine(line);
+  switch (type) {
+    case "tool":
+      return /* @__PURE__ */ jsx(Text, { color: colors.role.tool, children: line }, key);
+    case "result":
+      return /* @__PURE__ */ jsx(Text, { color: colors.text.muted, children: line }, key);
+    case "error":
+      return /* @__PURE__ */ jsx(Text, { color: colors.status.error, bold: true, children: line }, key);
+    case "empty":
+      return /* @__PURE__ */ jsx(Text, { children: " " }, key);
+    default:
+      return /* @__PURE__ */ jsx(Text, { wrap: "wrap", children: line }, key);
+  }
+}
+function getVisibleLines(output, maxLines) {
+  const lines = output.split("\n");
+  const startIndex = Math.max(0, lines.length - maxLines);
+  return lines.slice(startIndex).map((content, index) => ({
+    absoluteIndex: startIndex + index,
+    content
+  }));
+}
+function getLastActivity(output) {
+  const lines = output.split("\n");
+  for (let index = lines.length - 1; index >= 0; index--) {
+    const line = lines[index];
+    if (!line) continue;
+    const trimmed = line.trim();
+    if (trimmed.length === 0) continue;
+    const type = classifyLine(trimmed);
+    if (type === "tool" || type === "result" || type === "error") {
+      return trimmed;
+    }
+  }
+  return void 0;
+}
+function AgentFrameComponent({
+  agent,
+  output,
+  titlePrefix,
+  isFocused,
+  maxLines
+}) {
+  const previewLines = React11.useMemo(
+    () => getVisibleLines(output, maxLines),
+    [maxLines, output]
+  );
+  const lastActivity = React11.useMemo(
+    () => getLastActivity(output),
+    [output]
+  );
+  return /* @__PURE__ */ jsxs(
+    Box,
+    {
+      flexDirection: "column",
+      borderStyle: isFocused ? "round" : "single",
+      borderColor: isFocused ? colors.status.active : colors.border.dim,
+      paddingX: 1,
+      paddingY: 0,
+      marginBottom: 1,
+      children: [
+        /* @__PURE__ */ jsxs(Box, { children: [
+          /* @__PURE__ */ jsxs(Text, { color: getStatusColor(agent.status), children: [
+            statusIndicator(agent.status),
+            " "
+          ] }),
+          /* @__PURE__ */ jsxs(Text, { color: colors.status.active, bold: true, children: [
+            titlePrefix,
+            " ",
+            agent.config.name
+          ] }),
+          /* @__PURE__ */ jsxs(Text, { color: colors.text.muted, children: [
+            " ",
+            "\u2014",
+            " ",
+            agent.config.role,
+            " ",
+            "\xB7",
+            " ",
+            shortModelLabel2(agent.config.model)
+          ] })
+        ] }),
+        lastActivity ? /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsx(Text, { color: colors.text.muted, dimColor: true, children: lastActivity.length > 72 ? `${lastActivity.slice(0, 72)}\u2026` : lastActivity }) }) : null,
+        /* @__PURE__ */ jsx(Box, { flexDirection: "column", marginTop: 1, children: previewLines.length > 0 ? previewLines.map((line) => renderLine(
+          line.content,
+          `${agent.config.agentId}-${line.absoluteIndex}`
+        )) : /* @__PURE__ */ jsx(Text, { color: colors.text.muted, children: agent.status === "active" ? "Initializing\u2026" : "Waiting for work\u2026" }) }),
+        agent.status === "active" ? /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsx(Text, { color: colors.text.muted, children: titlePrefix === "Master" ? "Coordinating\u2026" : "Working\u2026" }) }) : null
+      ]
+    }
+  );
+}
+var AgentFrame = React11.memo(
+  AgentFrameComponent,
+  (previousProps, nextProps) => previousProps.agent === nextProps.agent && previousProps.output === nextProps.output && previousProps.titlePrefix === nextProps.titlePrefix && previousProps.isFocused === nextProps.isFocused && previousProps.maxLines === nextProps.maxLines
+);
+function SplitPanel({
+  agents,
+  activeAgentIndex,
+  onSelectAgent,
+  agentOutputs
+}) {
+  useInput((input, key) => {
+    if (key.tab) {
+      onSelectAgent((activeAgentIndex + 1) % agents.length);
+      return;
+    }
+    const numericKey = Number.parseInt(input, 10);
+    if (!Number.isNaN(numericKey) && numericKey >= 1 && numericKey <= agents.length && key.ctrl) {
+      onSelectAgent(numericKey - 1);
+    }
+  });
+  const [masterAgent, ...workerAgents] = agents;
+  const focusedAgent = agents[activeAgentIndex];
+  if (!masterAgent) {
+    return /* @__PURE__ */ jsx(Box, { flexGrow: 1, borderStyle: "round", borderColor: colors.border.dim, paddingX: 1, children: /* @__PURE__ */ jsx(Text, { color: colors.text.muted, children: "No agents active" }) });
+  }
+  const masterOutput = agentOutputs.get(masterAgent.config.agentId) ?? "";
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", flexGrow: 1, children: [
+    /* @__PURE__ */ jsxs(Box, { marginBottom: 1, children: [
+      /* @__PURE__ */ jsx(Text, { color: colors.text.muted, children: "Focus: " }),
+      /* @__PURE__ */ jsx(Text, { color: colors.status.active, bold: true, children: focusedAgent?.config.name ?? masterAgent.config.name }),
+      /* @__PURE__ */ jsx(Text, { color: colors.text.muted, children: "  " }),
+      /* @__PURE__ */ jsx(Text, { color: colors.status.active, bold: true, children: "Tab" }),
+      /* @__PURE__ */ jsx(Text, { color: colors.text.muted, children: " cycle  " }),
+      /* @__PURE__ */ jsx(Text, { color: colors.status.active, bold: true, children: "Ctrl+1" }),
+      /* @__PURE__ */ jsx(Text, { color: colors.text.muted, children: "-" }),
+      /* @__PURE__ */ jsx(Text, { color: colors.status.active, bold: true, children: agents.length }),
+      /* @__PURE__ */ jsx(Text, { color: colors.text.muted, children: " jump  " }),
+      /* @__PURE__ */ jsx(Text, { color: colors.status.warning, bold: true, children: "/team stop" }),
+      /* @__PURE__ */ jsx(Text, { color: colors.text.muted, children: " exit swarm" })
+    ] }),
+    /* @__PURE__ */ jsxs(Box, { flexGrow: 1, children: [
+      /* @__PURE__ */ jsx(Box, { flexBasis: "50%", flexDirection: "column", paddingRight: 1, children: /* @__PURE__ */ jsx(
+        AgentFrame,
+        {
+          agent: masterAgent,
+          output: masterOutput,
+          titlePrefix: "Master",
+          isFocused: activeAgentIndex === 0,
+          maxLines: 28
+        }
+      ) }),
+      /* @__PURE__ */ jsx(Box, { flexBasis: "50%", flexDirection: "column", paddingLeft: 1, children: workerAgents.length > 0 ? workerAgents.map((agent, index) => /* @__PURE__ */ jsx(
+        AgentFrame,
+        {
+          agent,
+          output: agentOutputs.get(agent.config.agentId) ?? "",
+          titlePrefix: "Worker",
+          isFocused: activeAgentIndex === index + 1,
+          maxLines: 8
+        },
+        agent.config.agentId
+      )) : /* @__PURE__ */ jsx(Box, { borderStyle: "single", borderColor: colors.border.dim, paddingX: 1, children: /* @__PURE__ */ jsx(Text, { color: colors.text.muted, children: "No worker agents in this swarm." }) }) })
+    ] }),
+    /* @__PURE__ */ jsx(Box, { marginTop: 0, children: /* @__PURE__ */ jsx(Text, { color: colors.text.muted, children: "Input is sent to the focused agent. The master agent remains pinned to the left pane." }) })
+  ] });
+}
+function SplitPane({
+  agents,
+  activeAgentIndex,
+  onSelectAgent,
+  agentOutputs,
+  isProcessing,
+  onSubmit,
+  onCancel,
+  model,
+  role,
+  tokenCount,
+  cost,
+  gitBranch
+}) {
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", height: "100%", children: [
+    /* @__PURE__ */ jsx(StatusBar, { model, role, tokenCount, cost, gitBranch }),
+    /* @__PURE__ */ jsx(
+      SplitPanel,
+      {
+        agents,
+        activeAgentIndex,
+        onSelectAgent,
+        agentOutputs
+      }
+    ),
+    /* @__PURE__ */ jsx(InputBar, { onSubmit, isProcessing, onCancel })
+  ] });
+}
+function useModel(config, initialModel, initialRole) {
+  const router = useMemo(() => createModelRouter(config), [config]);
+  const [userOverride, setUserOverride] = useState(initialModel);
+  const [currentRole, setCurrentRole] = useState(initialRole);
+  const resolution = useMemo(
+    () => {
+      router.setUserOverride(userOverride);
+      return router.resolve(currentRole);
+    },
+    [router, currentRole, userOverride]
+  );
+  const switchModel = useCallback((modelId) => {
+    setUserOverride(modelId);
+  }, []);
+  const switchRole = useCallback(
+    (role) => {
+      router.setUserOverride(void 0);
+      setCurrentRole(role);
+      setUserOverride(void 0);
+    },
+    [router]
+  );
+  return {
+    resolution,
+    modelId: resolution.modelId,
+    switchModel,
+    switchRole,
+    router
+  };
+}
+function formatToolActivity(toolCall) {
+  const args = toolCall.arguments;
+  switch (toolCall.name) {
+    case "read": {
+      const fp = typeof args["file_path"] === "string" ? args["file_path"] : "";
+      const short = fp.split("/").slice(-2).join("/");
+      return `Reading ${short || "file"}`;
+    }
+    case "write": {
+      const fp = typeof args["file_path"] === "string" ? args["file_path"] : "";
+      const short = fp.split("/").slice(-2).join("/");
+      return `Writing ${short || "file"}`;
+    }
+    case "edit": {
+      const fp = typeof args["file_path"] === "string" ? args["file_path"] : "";
+      const short = fp.split("/").slice(-2).join("/");
+      return `Editing ${short || "file"}`;
+    }
+    case "glob": {
+      const pat = typeof args["pattern"] === "string" ? args["pattern"] : "";
+      return `Searching files ${pat}`;
+    }
+    case "grep": {
+      const pat = typeof args["pattern"] === "string" ? args["pattern"] : "";
+      return `Searching for "${pat.length > 30 ? pat.slice(0, 30) + "\u2026" : pat}"`;
+    }
+    case "bash": {
+      const cmd = typeof args["command"] === "string" ? args["command"] : "";
+      const short = cmd.length > 40 ? cmd.slice(0, 40) + "\u2026" : cmd;
+      return `Running ${short}`;
+    }
+    case "web_search":
+    case "webSearch":
+      return "Searching the web";
+    case "web_fetch":
+    case "webFetch":
+      return "Fetching URL";
+    default:
+      return `Calling ${toolCall.name}`;
+  }
+}
+function useStream() {
+  const [state, setState] = useState({
+    isStreaming: false,
+    content: "",
+    usage: void 0,
+    error: void 0,
+    activity: void 0,
+    toolCalls: [],
+    startTime: void 0
+  });
+  const cancelRef = useRef(false);
+  const isCancelled = () => cancelRef.current;
+  const startStream = useCallback(
+    async (stream) => {
+      cancelRef.current = false;
+      setState({
+        isStreaming: true,
+        content: "",
+        usage: void 0,
+        error: void 0,
+        activity: void 0,
+        toolCalls: [],
+        startTime: Date.now()
+      });
+      try {
+        for await (const chunk of stream) {
+          if (isCancelled()) break;
+          switch (chunk.type) {
+            case "text":
+              if (chunk.content !== void 0) {
+                const text = chunk.content;
+                setState((prev) => ({
+                  ...prev,
+                  content: prev.content + text,
+                  activity: void 0
+                }));
+              }
+              break;
+            case "tool_call":
+              if (chunk.toolCall !== void 0) {
+                const toolCall = chunk.toolCall;
+                const desc = formatToolActivity(toolCall);
+                const callState = {
+                  id: toolCall.name + "-" + Date.now().toString(36),
+                  name: toolCall.name,
+                  description: desc,
+                  status: "executing",
+                  startTime: Date.now()
+                };
+                setState((prev) => ({
+                  ...prev,
+                  activity: desc,
+                  toolCalls: [
+                    // Mark previous executing calls as success
+                    ...prev.toolCalls.map(
+                      (tc) => tc.status === "executing" ? {
+                        ...tc,
+                        status: "success",
+                        endTime: Date.now()
+                      } : tc
+                    ),
+                    callState
+                  ]
+                }));
+              }
+              break;
+            case "usage":
+              if (chunk.usage) {
+                setState((prev) => ({
+                  ...prev,
+                  usage: chunk.usage
+                }));
+              }
+              break;
+            case "error":
+              setState((prev) => ({
+                ...prev,
+                error: chunk.error,
+                isStreaming: false,
+                activity: void 0,
+                toolCalls: prev.toolCalls.map(
+                  (tc) => tc.status === "executing" ? {
+                    ...tc,
+                    status: "error",
+                    endTime: Date.now()
+                  } : tc
+                )
+              }));
+              return;
+            case "done":
+              setState((prev) => ({
+                ...prev,
+                isStreaming: false,
+                usage: chunk.usage ?? prev.usage,
+                activity: void 0,
+                toolCalls: prev.toolCalls.map(
+                  (tc) => tc.status === "executing" ? {
+                    ...tc,
+                    status: "success",
+                    endTime: Date.now()
+                  } : tc
+                )
+              }));
+              return;
+          }
+        }
+        setState((prev) => ({
+          ...prev,
+          isStreaming: false,
+          activity: void 0,
+          toolCalls: prev.toolCalls.map(
+            (tc) => tc.status === "executing" ? {
+              ...tc,
+              status: "success",
+              endTime: Date.now()
+            } : tc
+          )
+        }));
+      } catch (error) {
+        setState((prev) => ({
+          ...prev,
+          isStreaming: false,
+          error: error instanceof Error ? error.message : String(error),
+          activity: void 0
+        }));
+      }
+    },
+    []
+  );
+  const cancelStream = useCallback(() => {
+    cancelRef.current = true;
+    setState((prev) => ({
+      ...prev,
+      isStreaming: false,
+      toolCalls: prev.toolCalls.map(
+        (tc) => tc.status === "executing" ? {
+          ...tc,
+          status: "cancelled",
+          endTime: Date.now()
+        } : tc
+      )
+    }));
+  }, []);
+  const reset = useCallback(() => {
+    cancelRef.current = true;
+    setState({
+      isStreaming: false,
+      content: "",
+      usage: void 0,
+      error: void 0,
+      activity: void 0,
+      toolCalls: [],
+      startTime: void 0
+    });
+  }, []);
+  return { state, startStream, cancelStream, reset };
+}
+function useCost(config) {
+  const trackerRef = useRef(new CostTracker(config));
+  const [totalCost, setTotalCost] = useState("$0.00");
+  const [totalTokens, setTotalTokens] = useState("0");
+  const [isBudgetExceeded, setIsBudgetExceeded] = useState(false);
+  useEffect(() => {
+    const eventBus = getEventBus();
+    const unsubCost = eventBus.on("cost:updated", ({ total }) => {
+      setTotalCost(formatCost(total));
+      const tokens = trackerRef.current.getSessionTokens();
+      setTotalTokens(formatTokenCount(tokens.total));
+    });
+    const unsubExceeded = eventBus.on("cost:exceeded", () => {
+      setIsBudgetExceeded(true);
+    });
+    return () => {
+      unsubCost();
+      unsubExceeded();
+    };
+  }, []);
+  const record = useCallback(
+    (provider, model, inputTokens, outputTokens, role) => {
+      trackerRef.current.record(provider, model, inputTokens, outputTokens, role);
+    },
+    []
+  );
+  return {
+    totalCost,
+    totalTokens,
+    isBudgetExceeded,
+    record,
+    tracker: trackerRef.current
+  };
+}
+function usePanel() {
+  const flushIntervalMs = 100;
+  const [agents, setAgentsState] = useState([]);
+  const [activeAgentIndex, setActiveAgentIndex] = useState(0);
+  const [agentOutputs, setAgentOutputs] = useState(/* @__PURE__ */ new Map());
+  const [isSplitPanelActive, setIsSplitPanelActive] = useState(false);
+  const pendingOutputRef = useRef(/* @__PURE__ */ new Map());
+  const flushTimerRef = useRef(void 0);
+  const flushPendingOutput = useCallback(() => {
+    flushTimerRef.current = void 0;
+    if (pendingOutputRef.current.size === 0) {
+      return;
+    }
+    const pending = pendingOutputRef.current;
+    pendingOutputRef.current = /* @__PURE__ */ new Map();
+    startTransition(() => {
+      setAgentOutputs((prev) => {
+        const next = new Map(prev);
+        for (const [agentId, content] of pending.entries()) {
+          const existing = next.get(agentId) ?? "";
+          next.set(agentId, existing + content);
+        }
+        return next;
+      });
+    });
+  }, []);
+  useEffect(() => {
+    return () => {
+      if (flushTimerRef.current !== void 0) {
+        clearTimeout(flushTimerRef.current);
+      }
+    };
+  }, []);
+  const selectAgent = useCallback((index) => {
+    setActiveAgentIndex(index);
+  }, []);
+  const appendOutput = useCallback((agentId, content, options) => {
+    const pending = pendingOutputRef.current;
+    pending.set(agentId, (pending.get(agentId) ?? "") + content);
+    if (options?.immediate === true) {
+      if (flushTimerRef.current !== void 0) {
+        clearTimeout(flushTimerRef.current);
+      }
+      flushPendingOutput();
+      return;
+    }
+    if (flushTimerRef.current === void 0) {
+      flushTimerRef.current = setTimeout(flushPendingOutput, flushIntervalMs);
+    }
+  }, [flushIntervalMs, flushPendingOutput]);
+  const updateAgentStatus = useCallback((agentId, status) => {
+    setAgentsState(
+      (prev) => prev.map(
+        (agent) => agent.config.agentId === agentId ? { ...agent, status } : agent
+      )
+    );
+  }, []);
+  const setAgents = useCallback((newAgents) => {
+    setAgentsState(newAgents);
+    setActiveAgentIndex(0);
+  }, []);
+  const activate = useCallback(() => {
+    setIsSplitPanelActive(true);
+  }, []);
+  const deactivate = useCallback(() => {
+    if (flushTimerRef.current !== void 0) {
+      clearTimeout(flushTimerRef.current);
+      flushTimerRef.current = void 0;
+    }
+    pendingOutputRef.current = /* @__PURE__ */ new Map();
+    setIsSplitPanelActive(false);
+    setAgentsState([]);
+    setAgentOutputs(/* @__PURE__ */ new Map());
+    setActiveAgentIndex(0);
+  }, []);
+  return useMemo(() => ({
+    agents,
+    activeAgentIndex,
+    agentOutputs,
+    isSplitPanelActive,
+    selectAgent,
+    appendOutput,
+    updateAgentStatus,
+    setAgents,
+    activate,
+    deactivate
+  }), [agents, activeAgentIndex, agentOutputs, isSplitPanelActive, selectAgent, appendOutput, updateAgentStatus, setAgents, activate, deactivate]);
+}
+function v4Id() {
+  return randomUUID();
+}
+var PROVIDER_LABELS = {
+  anthropic: "\u2726 Claude (Anthropic)",
+  openai: "\u2B22 Codex (OpenAI)",
+  google: "\u25C6 Gemini (Google)",
+  kimi: "\u25CE Kimi (Moonshot)"
+};
+function ModelSelector({
+  currentModelId,
+  onSelect,
+  onCancel,
+  modelOrder
+}) {
+  const rows = useMemo(() => {
+    const order = modelOrder ?? {};
+    const result = [];
+    for (const [providerKey, entries] of Object.entries(order)) {
+      result.push({
+        type: "header",
+        label: PROVIDER_LABELS[providerKey] ?? providerKey
+      });
+      for (const entry of entries) {
+        result.push({
+          type: "model",
+          label: entry.label,
+          description: entry.description,
+          modelId: entry.id,
+          isCurrent: entry.id === currentModelId
+        });
+      }
+    }
+    return result;
+  }, [currentModelId]);
+  const selectableIndices = useMemo(() => {
+    const indices = [];
+    for (let i = 0; i < rows.length; i++) {
+      if (rows[i]?.type === "model") indices.push(i);
+    }
+    return indices;
+  }, [rows]);
+  const initialIndex = useMemo(() => {
+    const rowIdx = rows.findIndex(
+      (r) => r.type === "model" && r.modelId === currentModelId
+    );
+    const selectIdx = selectableIndices.indexOf(rowIdx);
+    return selectIdx >= 0 ? selectIdx : 0;
+  }, [rows, selectableIndices, currentModelId]);
+  const [cursor, setCursor] = useState(initialIndex);
+  useInput((_input, key) => {
+    if (key.upArrow) {
+      setCursor(
+        (prev) => prev > 0 ? prev - 1 : selectableIndices.length - 1
+      );
+    } else if (key.downArrow) {
+      setCursor(
+        (prev) => prev < selectableIndices.length - 1 ? prev + 1 : 0
+      );
+    } else if (key.return) {
+      const rowIdx = selectableIndices[cursor];
+      const row = rowIdx !== void 0 ? rows[rowIdx] : void 0;
+      if (row?.modelId) onSelect(row.modelId);
+    } else if (key.escape) {
+      onCancel();
+    }
+  });
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", padding: 1, children: [
+    /* @__PURE__ */ jsxs(Box, { marginBottom: 1, children: [
+      /* @__PURE__ */ jsx(Text, { bold: true, color: colors.status.active, children: "Select Model" }),
+      /* @__PURE__ */ jsxs(Text, { color: colors.text.muted, children: [
+        "  ",
+        "\\u2191\\u2193 navigate \\u00B7 Enter select \\u00B7 Esc cancel"
+      ] })
+    ] }),
+    rows.map((row, idx) => {
+      if (row.type === "header") {
+        return /* @__PURE__ */ jsx(Box, { marginTop: idx > 0 ? 1 : 0, children: /* @__PURE__ */ jsxs(Text, { bold: true, color: colors.status.warning, children: [
+          "  ",
+          row.label
+        ] }) }, `header-${idx}`);
+      }
+      const isHighlighted = selectableIndices[cursor] === idx;
+      const currentTag = row.isCurrent ? " (current)" : "";
+      return /* @__PURE__ */ jsxs(Box, { children: [
+        /* @__PURE__ */ jsxs(
+          Text,
+          {
+            color: isHighlighted ? colors.status.success : row.isCurrent ? colors.text.accent : colors.text.primary,
+            bold: isHighlighted,
+            children: [
+              isHighlighted ? "\u25B8 " : "  ",
+              row.label.padEnd(30)
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsxs(Text, { color: colors.text.muted, children: [
+          " ",
+          row.description,
+          currentTag
+        ] })
+      ] }, row.modelId ?? `row-${idx}`);
+    }),
+    /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsxs(Text, { color: colors.text.muted, children: [
+      "  ",
+      "Current: ",
+      currentModelId
+    ] }) })
+  ] });
+}
+function formatMethod(method) {
+  switch (method) {
+    case "extended_thinking":
+      return "Extended Thinking";
+    case "reasoning_effort":
+      return "Reasoning Effort";
+    case "thinking_budget":
+      return "Thinking Budget";
+    case "thinking_level":
+      return "Thinking Level";
+    case "thinking_mode":
+      return "Thinking Mode";
+    default:
+      return "Thinking";
+  }
+}
+function ThinkingSelector({
+  modelId,
+  modelName,
+  currentValue,
+  onSelect,
+  onBack
+}) {
+  const config = useMemo(() => getThinkingConfigForModel(modelId), [modelId]);
+  const initialIdx = useMemo(() => {
+    if (!config) return 0;
+    const idx = config.options.findIndex((o) => o.value === currentValue);
+    if (idx >= 0) return idx;
+    const defaultIdx = config.options.findIndex((o) => o.value === config.defaultValue);
+    return Math.max(0, defaultIdx);
+  }, [config, currentValue]);
+  const [cursor, setCursor] = useState(initialIdx);
+  useInput((_input, key) => {
+    if (!config) {
+      if (key.return || key.escape) onBack();
+      return;
+    }
+    if (key.upArrow) {
+      setCursor((prev) => prev > 0 ? prev - 1 : config.options.length - 1);
+    } else if (key.downArrow) {
+      setCursor((prev) => prev < config.options.length - 1 ? prev + 1 : 0);
+    } else if (key.return) {
+      const option = config.options[cursor];
+      if (option) onSelect(option.value);
+    } else if (key.escape) {
+      onBack();
+    }
+  });
+  if (!config) {
+    return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", padding: 1, children: [
+      /* @__PURE__ */ jsxs(Text, { color: "yellow", children: [
+        "No thinking options available for ",
+        modelName,
+        "."
+      ] }),
+      /* @__PURE__ */ jsx(Text, { color: "gray", children: "Press Enter or Esc to continue." })
+    ] });
+  }
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", padding: 1, children: [
+    /* @__PURE__ */ jsxs(Box, { marginBottom: 1, flexDirection: "column", children: [
+      /* @__PURE__ */ jsx(Text, { bold: true, color: "cyan", children: formatMethod(config.method) }),
+      /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
+        "  Model: ",
+        modelName,
+        "  (up/down navigate, Enter select, Esc back)"
+      ] })
+    ] }),
+    config.options.map((option, idx) => {
+      const isHighlighted = cursor === idx;
+      const isCurrent = option.value === currentValue;
+      const currentTag = isCurrent ? " (current)" : "";
+      return /* @__PURE__ */ jsxs(Box, { children: [
+        /* @__PURE__ */ jsxs(Text, { ...isHighlighted ? { color: "green" } : {}, bold: isHighlighted, children: [
+          isHighlighted ? "> " : "  ",
+          option.label.padEnd(22)
+        ] }),
+        /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
+          " ",
+          option.description,
+          currentTag
+        ] })
+      ] }, option.value);
+    })
+  ] });
+}
+var PROVIDERS = [
+  { label: "Claude", value: "claude", description: "Anthropic \u2014 Claude models" },
+  { label: "Codex", value: "codex", description: "OpenAI \u2014 GPT / Codex models" },
+  { label: "Gemini", value: "gemini", description: "Google \u2014 Gemini models" },
+  { label: "Kimi", value: "kimi", description: "Moonshot \u2014 Kimi models" }
+];
+function LoginSelector({ onSelect, onCancel }) {
+  const [cursor, setCursor] = useState(0);
+  useInput((_input, key) => {
+    if (key.upArrow) {
+      setCursor((prev) => prev > 0 ? prev - 1 : PROVIDERS.length - 1);
+    } else if (key.downArrow) {
+      setCursor((prev) => prev < PROVIDERS.length - 1 ? prev + 1 : 0);
+    } else if (key.return) {
+      const selected = PROVIDERS[cursor];
+      if (selected) onSelect(selected.value);
+    } else if (key.escape) {
+      onCancel();
+    }
+  });
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", padding: 1, children: [
+    /* @__PURE__ */ jsxs(Box, { marginBottom: 1, children: [
+      /* @__PURE__ */ jsx(Text, { bold: true, color: "cyan", children: "Select a provider to log in to" }),
+      /* @__PURE__ */ jsx(Text, { color: "gray", children: "  (up/down navigate, Enter select, Esc cancel)" })
+    ] }),
+    PROVIDERS.map((provider, idx) => {
+      const isHighlighted = cursor === idx;
+      return /* @__PURE__ */ jsxs(Box, { children: [
+        /* @__PURE__ */ jsxs(Text, { ...isHighlighted ? { color: "green" } : {}, bold: isHighlighted, children: [
+          isHighlighted ? "> " : "  ",
+          provider.label.padEnd(12)
+        ] }),
+        /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
+          " ",
+          provider.description
+        ] })
+      ] }, provider.value);
+    }),
+    /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsx(Text, { color: "gray", children: "  Login will open your browser for authentication." }) })
+  ] });
+}
+function SwarmOnboarding({
+  detectedProviders,
+  currentPrimaryProvider,
+  onSelect,
+  onSkip
+}) {
+  const entries = useMemo(
+    () => detectedProviders.map((provider) => getCliProviderEntry(provider)),
+    [detectedProviders]
+  );
+  const initialCursor = useMemo(() => {
+    if (!currentPrimaryProvider) {
+      return 0;
+    }
+    const currentIndex = detectedProviders.indexOf(currentPrimaryProvider);
+    return currentIndex >= 0 ? currentIndex : 0;
+  }, [currentPrimaryProvider, detectedProviders]);
+  const [cursor, setCursor] = useState(initialCursor);
+  useInput((_input, key) => {
+    if (entries.length === 0) {
+      if (key.return || key.escape) {
+        onSkip();
+      }
+      return;
+    }
+    if (key.upArrow) {
+      setCursor((prev) => prev > 0 ? prev - 1 : entries.length - 1);
+      return;
+    }
+    if (key.downArrow) {
+      setCursor((prev) => prev < entries.length - 1 ? prev + 1 : 0);
+      return;
+    }
+    if (key.return) {
+      const selected = detectedProviders[cursor];
+      if (selected) {
+        onSelect(selected);
+      }
+      return;
+    }
+    if (key.escape && entries.length === 0) {
+      onSkip();
+    }
+  });
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", padding: 1, children: [
+    /* @__PURE__ */ jsxs(Box, { marginBottom: 1, flexDirection: "column", children: [
+      /* @__PURE__ */ jsx(Text, { color: colors.status.active, bold: true, children: "Swarm Setup" }),
+      /* @__PURE__ */ jsx(Text, { color: colors.text.muted, children: "Select the master agent provider for swarm orchestration." })
+    ] }),
+    entries.length > 0 ? /* @__PURE__ */ jsxs(Fragment, { children: [
+      entries.map((entry, index) => {
+        const isSelected = index === cursor;
+        const isCurrent = currentPrimaryProvider === entry.type;
+        return /* @__PURE__ */ jsxs(Box, { children: [
+          /* @__PURE__ */ jsxs(
+            Text,
+            {
+              color: isSelected ? colors.status.success : colors.text.primary,
+              bold: isSelected,
+              children: [
+                isSelected ? "\u25B8 " : "  ",
+                entry.label.padEnd(16)
+              ]
+            }
+          ),
+          /* @__PURE__ */ jsxs(Text, { color: colors.text.muted, children: [
+            entry.description,
+            isCurrent ? " (current)" : ""
+          ] })
+        ] }, entry.type);
+      }),
+      /* @__PURE__ */ jsxs(Box, { marginTop: 1, flexDirection: "column", children: [
+        /* @__PURE__ */ jsx(Text, { color: colors.text.muted, children: "Enter sets the master agent. Remaining detected providers become fallbacks." }),
+        /* @__PURE__ */ jsx(Text, { color: colors.text.muted, children: "\\u2191\\u2193 navigate \xB7 Enter confirm" })
+      ] })
+    ] }) : /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx(Text, { color: colors.status.warning, children: "No supported native agent CLI was detected." }),
+      /* @__PURE__ */ jsx(Text, { color: colors.text.muted, children: "Install Claude Code, Codex, Gemini CLI, Kimi CLI, or Ollama, then restart." }),
+      /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsx(Text, { color: colors.text.muted, children: "Enter or Esc continues without swarm setup." }) })
+    ] })
+  ] });
+}
+
+// src/ui/commands/types.ts
+function addSystemMessage(ctx, content) {
+  ctx.setMessages((prev) => [
+    ...prev,
+    {
+      id: v4Id(),
+      role: "system",
+      content,
+      createdAt: /* @__PURE__ */ new Date()
+    }
+  ]);
+}
+
+// src/ui/commands/model-helpers.ts
+function resolveModelSelection(input) {
+  if (SUPPORTED_MODELS[input]) {
+    return input;
+  }
+  if (/^\d+$/.test(input)) {
+    const index = Number(input);
+    let globalIndex = 1;
+    for (const entries of Object.values(PROVIDER_MODEL_ORDER)) {
+      for (const entry of entries) {
+        if (globalIndex === index) {
+          return entry.id;
+        }
+        globalIndex++;
+      }
+    }
+  }
+  return void 0;
+}
+function formatThinkingMethod(method) {
+  switch (method) {
+    case "extended_thinking":
+      return "Extended Thinking";
+    case "reasoning_effort":
+      return "Reasoning Effort";
+    case "thinking_budget":
+      return "Thinking Budget";
+    case "thinking_level":
+      return "Thinking Level";
+    case "thinking_mode":
+      return "Thinking Mode";
+    default:
+      return "Thinking";
+  }
+}
+
+// src/ui/commands/team-commands.ts
+async function handleTeamCommand(args, ctx) {
+  const subcommand = args[0];
+  if (subcommand === "stop") {
+    const cleanup = getActiveTmuxCleanup();
+    if (cleanup) {
+      try {
+        await cleanup();
+      } catch (error) {
+        const errMsg = error instanceof Error ? error.message : String(error);
+        addSystemMessage(ctx, `Warning: tmux cleanup failed (${errMsg}). Session may need manual cleanup.`);
+      }
+      setActiveTmuxCleanup(void 0);
+    }
+    const manager = getActiveTeamManager();
+    const teamName = getActiveTeamName();
+    if (manager && teamName) {
+      try {
+        await manager.deleteTeam(teamName);
+      } catch (error) {
+        const errMsg = error instanceof Error ? error.message : String(error);
+        addSystemMessage(ctx, `Warning: team cleanup failed (${errMsg}). Processes may need manual cleanup.`);
+      }
+      setActiveTeamManager(void 0);
+    }
+    setActiveTeamName(void 0);
+    ctx.panel.deactivate();
+    addSystemMessage(ctx, "Team shut down. All agents stopped. Returned to single-pane mode.");
+    return;
+  }
+  if (subcommand === "list") {
+    try {
+      const { TeamManager } = await import('./team-manager-2VSMALAA.js');
+      const manager = new TeamManager();
+      const teams = manager.listTeams();
+      if (teams.length === 0) {
+        addSystemMessage(ctx, "No active teams.");
+      } else {
+        const lines = teams.map((t) => `  ${t.teamName} \u2014 ${t.members.length} agents (${t.status})`);
+        addSystemMessage(ctx, lines.join("\n"));
+      }
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      addSystemMessage(ctx, `Failed to list teams: ${msg}`);
+    }
+    return;
+  }
+  addSystemMessage(
+    ctx,
+    'Usage: /team list | /team stop\nTeams are created automatically from natural language.\nExamples: "Create a team to refactor the auth module"\n          "I need agents to review this PR from different angles"'
+  );
+}
+
+// src/ui/commands/mcp-commands.ts
+async function handleMcpCommand(args, ctx) {
+  const subcommand = args[0];
+  if (subcommand === "list") {
+    try {
+      const { MCPServerManager } = await import('./server-manager-THGZBBZB.js');
+      const manager = new MCPServerManager();
+      const connected = manager.getConnectedServers();
+      if (connected.length === 0) {
+        addSystemMessage(ctx, "No MCP servers connected.\nConfigure servers in ~/.aemeathcli/mcp.json");
+      } else {
+        const lines = connected.map((name) => {
+          const status = manager.getServerStatus(name) ?? "unknown";
+          return `  ${name} \u2014 ${status}`;
+        });
+        addSystemMessage(ctx, `MCP Servers:
+${lines.join("\n")}`);
+      }
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      addSystemMessage(ctx, `Failed to list MCP servers: ${msg}`);
+    }
+    return;
+  }
+  if (subcommand === "add") {
+    const name = args[1];
+    if (!name) {
+      addSystemMessage(ctx, "Usage: /mcp add <server-name>\n\nExample:\n  /mcp add my-server");
+      return;
+    }
+    addSystemMessage(
+      ctx,
+      `To add MCP server "${name}", add this to ~/.aemeathcli/mcp.json:
+
+{
+  "mcpServers": {
+    "${name}": {
+      "command": "npx",
+      "args": ["-y", "@your-org/${name}-server"],
+      "env": {}
+    }
+  }
+}
+
+Then restart AemeathCLI. Use /mcp list to verify the connection.`
+    );
+    return;
+  }
+  addSystemMessage(ctx, "Usage: /mcp list | /mcp add <name>");
+}
+
+// src/ui/commands/skill-commands.ts
+async function handleSkillCommand(args, ctx) {
+  const subcommand = args[0];
+  if (subcommand === "list") {
+    try {
+      const { SkillRegistry } = await import('./registry-LRURZVUL.js');
+      const { findProjectRoot } = await import('./pathResolver-UVAB2FCW.js');
+      const registry = new SkillRegistry();
+      await registry.initialize(findProjectRoot());
+      const skills = registry.listAll();
+      if (skills.length === 0) {
+        addSystemMessage(ctx, "No skills found.\nAdd skills in ~/.agents/skills/, ~/.aemeathcli/skills/, .agents/skills/, or .aemeathcli/skills/");
+      } else {
+        const lines = skills.map((s) => `  $${s.name.padEnd(16)} ${s.description}  [${s.source}]`);
+        addSystemMessage(ctx, `Available Skills:
+${lines.join("\n")}`);
+      }
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      addSystemMessage(ctx, `Failed to list skills: ${msg}`);
+    }
+    return;
+  }
+  addSystemMessage(ctx, "Usage: /skill list\nInvoke a skill with $skill-name (e.g., $review, $commit, $plan)");
+}
+async function handleSkillInvocation(input, setMessages) {
+  const parts = input.trim().split(/\s+/);
+  const trigger = parts[0] ?? "";
+  const skillName = trigger.replace(/^\$/, "");
+  if (!skillName) {
+    setMessages((prev) => [
+      ...prev,
+      { id: v4Id(), role: "system", content: "Usage: $skill-name [args]\nType /skill list to see available skills.", createdAt: /* @__PURE__ */ new Date() }
+    ]);
+    return;
+  }
+  setMessages((prev) => [
+    ...prev,
+    { id: v4Id(), role: "user", content: input, createdAt: /* @__PURE__ */ new Date() }
+  ]);
+  try {
+    const { SkillRegistry } = await import('./registry-LRURZVUL.js');
+    const { SkillExecutor } = await import('./executor-FTABX2AW.js');
+    const { findProjectRoot } = await import('./pathResolver-UVAB2FCW.js');
+    const registry = new SkillRegistry();
+    await registry.initialize(findProjectRoot());
+    const executor = new SkillExecutor(registry);
+    const result = await executor.activateByTrigger(trigger);
+    if (!result.success) {
+      setMessages((prev) => [
+        ...prev,
+        { id: v4Id(), role: "system", content: result.errorMessage ?? `Skill not found: "${skillName}"
+Type /skill list to see available skills.`, createdAt: /* @__PURE__ */ new Date() }
+      ]);
+      return;
+    }
+    const content = executor.getActiveSkillContent();
+    const warningText = result.warnings && result.warnings.length > 0 ? `
+Warnings: ${result.warnings.join(", ")}` : "";
+    setMessages((prev) => [
+      ...prev,
+      { id: v4Id(), role: "system", content: `Skill "$${skillName}" activated.${warningText}
+${content ? content.slice(0, 500) : ""}`, createdAt: /* @__PURE__ */ new Date() }
+    ]);
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    setMessages((prev) => [
+      ...prev,
+      { id: v4Id(), role: "system", content: `Skill error: ${msg}`, createdAt: /* @__PURE__ */ new Date() }
+    ]);
+  }
+}
+
+// src/ui/commands/login-commands.ts
+async function handleLoginSlashCommand(args, ctx) {
+  const subcommand = args[0];
+  if (subcommand === "status") {
+    try {
+      const { getAuthStatusRecords, formatCompactAuthStatusLine } = await import('./auth-status-JQJOKUPF.js');
+      const records = await getAuthStatusRecords();
+      const lines = records.map((record) => formatCompactAuthStatusLine(record));
+      addSystemMessage(ctx, lines.join("\n"));
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      addSystemMessage(ctx, `Failed to get auth status: ${msg}`);
+    }
+    return;
+  }
+  if (subcommand === "logout") {
+    const provider = args[1];
+    if (!provider) {
+      addSystemMessage(ctx, "Usage: /login logout <provider>\nProviders: claude, codex, gemini, kimi");
+      return;
+    }
+    try {
+      const loginMod = await loadLoginModuleForSlash(provider);
+      await loginMod.logout();
+      addSystemMessage(ctx, `Logged out of ${provider}`);
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      addSystemMessage(ctx, `Logout failed: ${msg}`);
+    }
+    return;
+  }
+  ctx.setSelectionMode({ type: "login" });
+}
+async function loadLoginModuleForSlash(provider) {
+  switch (provider) {
+    case "claude": {
+      const mod = await import('./claude-login-AIFIWTYF.js');
+      return new mod.ClaudeLogin();
+    }
+    case "codex": {
+      const mod = await import('./codex-login-LW5X7GAM.js');
+      return new mod.CodexLogin();
+    }
+    case "gemini": {
+      const mod = await import('./gemini-login-TST454MX.js');
+      return new mod.GeminiLogin();
+    }
+    case "kimi": {
+      const mod = await import('./kimi-login-3IGVOBJI.js');
+      return new mod.KimiLogin();
+    }
+    default:
+      throw new Error(`Unknown provider: ${provider}`);
+  }
+}
+
+// src/ui/commands/config-commands.ts
+async function handleConfigSlashCommand(args, ctx) {
+  const subcommand = args[0];
+  if (subcommand === "get") {
+    const key = args[1];
+    try {
+      const { ConfigStore } = await import('./config-store-NF56VHFU.js');
+      const store = new ConfigStore();
+      const cfg = store.loadGlobal();
+      if (!key) {
+        addSystemMessage(ctx, JSON.stringify(cfg, null, 2));
+      } else {
+        const value = getNestedConfigValue(cfg, key);
+        if (value === void 0) {
+          addSystemMessage(ctx, `Key not found: ${key}`);
+        } else {
+          addSystemMessage(ctx, `${key} = ${JSON.stringify(value, null, 2)}`);
+        }
+      }
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      addSystemMessage(ctx, `Failed to read config: ${msg}`);
+    }
+    return;
+  }
+  if (subcommand === "set") {
+    const key = args[1];
+    const value = args.slice(2).join(" ");
+    if (!key || !value) {
+      addSystemMessage(ctx, "Usage: /config set <key> <value>");
+      return;
+    }
+    try {
+      const { ConfigStore } = await import('./config-store-NF56VHFU.js');
+      const store = new ConfigStore();
+      const cfg = store.loadGlobal();
+      let parsedValue;
+      try {
+        parsedValue = JSON.parse(value);
+      } catch {
+        parsedValue = value;
+      }
+      setNestedConfigValue(cfg, key, parsedValue);
+      store.saveGlobal(cfg);
+      addSystemMessage(ctx, `Set ${key} = ${JSON.stringify(parsedValue)}`);
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      addSystemMessage(ctx, `Failed to set config: ${msg}`);
+    }
+    return;
+  }
+  addSystemMessage(ctx, "Usage: /config get [key] | /config set <key> <value>");
+}
+function getNestedConfigValue(obj, path) {
+  const keys = path.split(".");
+  let current = obj;
+  for (const key of keys) {
+    if (current === null || current === void 0 || typeof current !== "object") return void 0;
+    current = current[key];
+  }
+  return current;
+}
+function setNestedConfigValue(obj, path, value) {
+  const keys = path.split(".");
+  let current = obj;
+  for (let i = 0; i < keys.length - 1; i++) {
+    const key = keys[i];
+    if (!key) continue;
+    if (typeof current[key] !== "object" || current[key] === null) current[key] = {};
+    current = current[key];
+  }
+  const lastKey = keys[keys.length - 1];
+  if (lastKey) current[lastKey] = value;
+}
+
+// src/ui/commands/history-commands.ts
+async function handleHistoryCommand(ctx) {
+  try {
+    const { SqliteStore } = await import('./sqlite-store-7OECRTXM.js');
+    const { ConversationStore } = await import('./conversation-store-7GRDQZD2.js');
+    const db = new SqliteStore();
+    db.open();
+    const store = new ConversationStore(db);
+    const conversations = store.listConversations(ctx.projectRoot);
+    db.close();
+    if (conversations.length === 0) {
+      addSystemMessage(ctx, "No conversation history for this project.");
+      return;
+    }
+    const lines = conversations.slice(0, 20).map((c, i) => {
+      const date = new Date(c.createdAt).toLocaleDateString();
+      const model = c.defaultModel ?? "unknown";
+      return `  ${String(i + 1).padStart(2)}. ${date}  ${model.padEnd(20)}  ${c.id.slice(0, 8)}\u2026`;
+    });
+    addSystemMessage(
+      ctx,
+      `Conversations in this project (${conversations.length} total):
+${lines.join("\n")}
+
+Use /resume <number> or /resume <id> to load.`
+    );
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    addSystemMessage(ctx, `Failed to load history: ${msg}`);
+  }
+}
+async function handleResumeCommand(arg, ctx) {
+  if (!arg) {
+    addSystemMessage(ctx, "Usage: /resume <number> or /resume <conversation-id>\nUse /history to see past conversations.");
+    return;
+  }
+  try {
+    const { SqliteStore } = await import('./sqlite-store-7OECRTXM.js');
+    const { ConversationStore } = await import('./conversation-store-7GRDQZD2.js');
+    const db = new SqliteStore();
+    db.open();
+    const store = new ConversationStore(db);
+    let conversationId;
+    const num = parseInt(arg, 10);
+    if (!isNaN(num) && num > 0) {
+      const conversations = store.listConversations(ctx.projectRoot);
+      const target = conversations[num - 1];
+      if (!target) {
+        db.close();
+        addSystemMessage(ctx, `Conversation #${num} not found. Use /history to see available.`);
+        return;
+      }
+      conversationId = target.id;
+    } else {
+      const conversations = store.listConversations(ctx.projectRoot);
+      const match = conversations.find((c) => c.id.startsWith(arg));
+      if (!match) {
+        db.close();
+        addSystemMessage(ctx, `No conversation matching "${arg}". Use /history to see available.`);
+        return;
+      }
+      conversationId = match.id;
+    }
+    const storedMessages = store.getMessages(conversationId);
+    db.close();
+    if (storedMessages.length === 0) {
+      addSystemMessage(ctx, "Conversation found but contains no messages.");
+      return;
+    }
+    const restored = storedMessages.map((m) => ({
+      id: v4Id(),
+      role: m.role,
+      content: m.content,
+      model: m.model ?? void 0,
+      provider: m.provider ?? void 0,
+      createdAt: new Date(m.createdAt)
+    }));
+    ctx.setMessages(restored);
+    addSystemMessage(ctx, `Resumed conversation (${restored.length} messages loaded).`);
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    addSystemMessage(ctx, `Failed to resume: ${msg}`);
+  }
+}
+
+// src/ui/commands/slash-router.ts
+async function handleInternalCommand(input, switchModel, switchRole, ctx) {
+  const parts = input.trim().split(/\s+/);
+  const command = parts[0];
+  const args = parts.slice(1);
+  const arg = args[0];
+  switch (command) {
+    case "/help": {
+      const helpLines = SLASH_COMMANDS.map((cmd) => `  ${cmd.command.padEnd(17)}${cmd.description}`).join("\n");
+      addSystemMessage(ctx, helpLines);
+      break;
+    }
+    case "/model": {
+      if (arg) {
+        const resolvedId = resolveModelSelection(arg);
+        if (!resolvedId) {
+          addSystemMessage(ctx, `Unknown model: ${arg}`);
+          break;
+        }
+        const info = SUPPORTED_MODELS[resolvedId];
+        if (!info) {
+          addSystemMessage(ctx, `Unknown model: ${arg}`);
+          break;
+        }
+        switchModel(resolvedId);
+        const thinkingCfg = getThinkingConfigForModel(resolvedId);
+        if (thinkingCfg) {
+          const isValid = thinkingCfg.options.some((o) => o.value === ctx.thinkingValue);
+          if (!isValid) ctx.setThinkingValue(thinkingCfg.defaultValue);
+        }
+        addSystemMessage(ctx, `Switched to model: ${info.name}`);
+      } else {
+        ctx.setSelectionMode({ type: "model" });
+      }
+      break;
+    }
+    case "/role": {
+      if (arg) {
+        const validRoles = ["planning", "coding", "review", "testing", "bugfix", "documentation"];
+        if (validRoles.includes(arg)) {
+          switchRole(arg);
+          addSystemMessage(ctx, `Switched to role: ${arg}`);
+        } else {
+          addSystemMessage(ctx, `Unknown role: ${arg}
+Valid roles: ${validRoles.join(", ")}`);
+        }
+      } else {
+        addSystemMessage(ctx, `Current role: ${ctx.resolution.role ?? "default"}`);
+      }
+      break;
+    }
+    case "/cost":
+      addSystemMessage(ctx, `Session cost: ${ctx.totalCost} | Tokens: ${ctx.totalTokens}`);
+      break;
+    case "/clear":
+      ctx.setMessages([]);
+      break;
+    case "/compact":
+      ctx.setMessages((prev) => {
+        if (prev.length <= 4) return prev;
+        const systemMsgs = prev.filter((m) => m.role === "system");
+        const recent = prev.filter((m) => m.role !== "system").slice(-4);
+        return [...systemMsgs, ...recent];
+      });
+      addSystemMessage(ctx, `Context compacted \u2014 kept last 4 messages. Use /clear to remove all.`);
+      break;
+    case "/team":
+      await handleTeamCommand(args, ctx);
+      break;
+    case "/mcp":
+      await handleMcpCommand(args, ctx);
+      break;
+    case "/skill":
+      await handleSkillCommand(args, ctx);
+      break;
+    case "/panel": {
+      const layout = arg;
+      if (!layout) {
+        addSystemMessage(
+          ctx,
+          "Swarm layout is fixed to hub-and-spoke:\n- master agent on the left half\n- worker agents stacked on the right\nUse Shift+Tab to enter swarm mode, then Tab/Ctrl+N to focus agents."
+        );
+      } else {
+        addSystemMessage(ctx, `Panel layout overrides are disabled. Active swarm layout remains hub-spoke (master left, workers right). Ignored: ${layout}`);
+      }
+      break;
+    }
+    case "/login":
+      await handleLoginSlashCommand(args, ctx);
+      break;
+    case "/config":
+      await handleConfigSlashCommand(args, ctx);
+      break;
+    case "/launch":
+      addSystemMessage(
+        ctx,
+        "Swarm orchestration now lives inside the default TUI.\n\nUse Shift+Tab to switch into swarm mode, then describe the work you want the team to handle.\nThe configured master agent will sponsor the team and own the left pane."
+      );
+      break;
+    case "/history":
+      await handleHistoryCommand(ctx);
+      break;
+    case "/resume":
+      await handleResumeCommand(arg, ctx);
+      break;
+    case "/quit":
+    case "/exit": {
+      const { getActiveTeamManager: getActiveTeamManager2, getActiveTeamName: getActiveTeamName2, getActiveTmuxCleanup: getActiveTmuxCleanup2 } = await import('./team-state-HZNVMQHT.js');
+      const teamCleanup = getActiveTmuxCleanup2();
+      if (teamCleanup) {
+        try {
+          await teamCleanup();
+        } catch {
+        }
+      }
+      const mgr = getActiveTeamManager2();
+      const name = getActiveTeamName2();
+      if (mgr && name) {
+        try {
+          await mgr.deleteTeam(name);
+        } catch {
+        }
+      }
+      process.exit(0);
+      break;
+    }
+    default:
+      addSystemMessage(ctx, `Unknown command: ${command}. Type /help for available commands.`);
+  }
+}
+
+// src/ui/conversation-persistence.ts
+var convDbRef;
+async function persistMessages(projectRoot, userMsg, assistantMsg, model, provider) {
+  try {
+    const { SqliteStore } = await import('./sqlite-store-7OECRTXM.js');
+    const { ConversationStore } = await import('./conversation-store-7GRDQZD2.js');
+    if (!convDbRef) {
+      const db = new SqliteStore();
+      db.open();
+      const store2 = new ConversationStore(db);
+      const conv = store2.createConversation(projectRoot, model);
+      convDbRef = { store: store2, convId: conv.id };
+    }
+    const { store, convId } = convDbRef;
+    store.addMessage({
+      conversationId: convId,
+      role: "user",
+      content: userMsg.content
+    });
+    store.addMessage({
+      conversationId: convId,
+      role: "assistant",
+      model,
+      provider,
+      content: assistantMsg.content
+    });
+  } catch (error) {
+    const { logger } = await import('./logger-KGHUQ4VE.js');
+    const msg = error instanceof Error ? error.message : String(error);
+    logger.warn({ error: msg }, "Conversation persistence failed");
+  }
+}
+
+// src/ui/team-design.ts
+var TEAM_DESIGN_SYSTEM_PROMPT = `You are an expert team architect for an AI-powered CLI coding tool. Your job is to analyze a user's request and design an optimal agent team to accomplish it.
+
+You MUST respond with ONLY a JSON array (no markdown, no explanation, no code fences). Each element represents one agent with these exact fields:
+- "name": string \u2014 PascalCase name describing the agent's function (e.g. "ProjectManager", "TypeScriptDeveloper", "SecurityAuditor")
+- "agentType": string \u2014 short role type (e.g. "lead", "developer", "reviewer", "researcher", "designer", "architect", "auditor", "tester")
+- "model": string \u2014 one of the available models (provided in the user message)
+- "role": string \u2014 one of: "planning", "coding", "review", "testing", "bugfix", "documentation"
+- "taskPrompt": string \u2014 detailed, specific instructions for this agent. Include: what to focus on, what files/areas to examine, what deliverables are expected, and what tools to use. This must be tailored to the user's actual request, NOT generic.
+
+Guidelines for team design:
+- Use the MINIMUM number of agents needed to accomplish the task (typically 2-5, max 8)
+- Assign the most capable models (opus, gpt-5.2, gemini pro) to critical roles like planning and review
+- Assign efficient models (sonnet, haiku, flash) to implementation, testing, and documentation
+- Every team MUST have at least one agent with role "coding" to do actual implementation
+- For complex tasks, include a planner/lead agent and a reviewer agent
+- If only one provider's models are available, use those models for all agents
+- Each agent's taskPrompt must be highly specific to the user's request \u2014 never use generic instructions
+- Agent names should reflect their specific responsibility in this task
+`;
+var VALID_ROLES = /* @__PURE__ */ new Set([
+  "planning",
+  "coding",
+  "review",
+  "testing",
+  "bugfix",
+  "documentation"
+]);
+function parseLLMTeamDesign(response, availableModels, fallbackModel) {
+  let jsonStr = response.trim();
+  const fenceMatch = /```(?:json)?\s*\n?([\s\S]*?)\n?```/.exec(jsonStr);
+  if (fenceMatch?.[1] !== void 0) {
+    jsonStr = fenceMatch[1].trim();
+  }
+  const arrayStart = jsonStr.indexOf("[");
+  const arrayEnd = jsonStr.lastIndexOf("]");
+  if (arrayStart === -1 || arrayEnd === -1 || arrayEnd <= arrayStart) {
+    throw new Error("LLM response does not contain a valid JSON array for team design");
+  }
+  jsonStr = jsonStr.slice(arrayStart, arrayEnd + 1);
+  let parsed;
+  try {
+    parsed = JSON.parse(jsonStr);
+  } catch {
+    throw new Error("Failed to parse LLM team design as JSON");
+  }
+  if (!Array.isArray(parsed) || parsed.length === 0) {
+    throw new Error("LLM team design must be a non-empty array");
+  }
+  const availableSet = new Set(availableModels);
+  const specs = [];
+  for (const item of parsed) {
+    if (typeof item !== "object" || item === null) continue;
+    const record = item;
+    const name = typeof record["name"] === "string" && record["name"].length > 0 ? record["name"] : `Agent${specs.length + 1}`;
+    const agentType = typeof record["agentType"] === "string" && record["agentType"].length > 0 ? record["agentType"] : "developer";
+    const rawModel = typeof record["model"] === "string" ? record["model"] : "";
+    const rawRole = typeof record["role"] === "string" ? record["role"] : "coding";
+    const taskPrompt = typeof record["taskPrompt"] === "string" ? record["taskPrompt"] : "";
+    const model = availableSet.has(rawModel) ? rawModel : fallbackModel;
+    const role = VALID_ROLES.has(rawRole) ? rawRole : "coding";
+    specs.push({ name, agentType, model, role, taskPrompt });
+  }
+  if (specs.length === 0) {
+    throw new Error("LLM team design produced no valid agent specifications");
+  }
+  return specs.slice(0, 8);
+}
+function buildTeamDesignUserPrompt(userRequest, availableModels) {
+  const modelList = availableModels.map((id) => {
+    const info = SUPPORTED_MODELS[id];
+    if (!info) return `- ${id}`;
+    return `- ${id} (${info.provider}, ${info.name})`;
+  }).join("\n");
+  return `Available models:
+${modelList}
+
+User request:
+${userRequest}
+
+Design the agent team. Respond with ONLY a JSON array.`;
+}
+function resolveMasterProviderPriority(swarmConfig, installedProviders) {
+  const configuredProviders = [
+    ...swarmConfig.primaryMasterProvider ? [swarmConfig.primaryMasterProvider] : [],
+    ...swarmConfig.fallbackMasterProviders
+  ];
+  const prioritized = configuredProviders.filter((provider) => installedProviders.includes(provider));
+  const remaining = installedProviders.filter((provider) => !prioritized.includes(provider));
+  return [...prioritized, ...remaining];
+}
+function getAvailableModelsForProviders(providers) {
+  const allowedProviders = new Set(
+    providers.map((provider) => getCliProviderEntry(provider).provider)
+  );
+  return Object.keys(SUPPORTED_MODELS).filter((modelId) => {
+    const info = SUPPORTED_MODELS[modelId];
+    return info !== void 0 && allowedProviders.has(info.provider);
+  });
+}
+function pickLeadModel(config, prioritizedProviders, availableModels) {
+  for (const provider of prioritizedProviders) {
+    const providerName = getCliProviderEntry(provider).provider;
+    const planningCandidates = [
+      config.roles.planning?.primary,
+      ...config.roles.planning?.fallback ?? []
+    ].filter((modelId) => modelId !== void 0);
+    const preferredPlanningModel = planningCandidates.find((modelId) => {
+      const info = SUPPORTED_MODELS[modelId];
+      return info?.provider === providerName && availableModels.includes(modelId);
+    });
+    if (preferredPlanningModel) {
+      return preferredPlanningModel;
+    }
+    const firstAvailableModel = availableModels.find((modelId) => {
+      const info = SUPPORTED_MODELS[modelId];
+      return info?.provider === providerName;
+    });
+    if (firstAvailableModel) {
+      return firstAvailableModel;
+    }
+  }
+  return availableModels[0];
+}
+function normalizeLeadAgentSpec(specs, masterModel) {
+  const leadSpec = specs.find((spec) => spec.agentType === "lead") ?? specs.find((spec) => spec.role === "planning") ?? specs[0];
+  if (!leadSpec) {
+    return specs;
+  }
+  const normalizedLead = {
+    ...leadSpec,
+    name: leadSpec.name,
+    agentType: "lead",
+    model: masterModel,
+    role: "planning",
+    taskPrompt: `${leadSpec.taskPrompt}
+
+You are the sponsoring master agent. Own planning, delegation, and final synthesis.`
+  };
+  const workerSpecs = specs.filter((spec) => spec.name !== leadSpec.name);
+  return [normalizedLead, ...workerSpecs];
+}
+function writeAgentLauncherScript(provider, model, promptFile, launcherFile, projectRoot, shellEscapeFn, writeFileSyncFn) {
+  if (process.platform === "win32") {
+    return writeWindowsLauncherScript(
+      provider,
+      model,
+      promptFile,
+      launcherFile,
+      projectRoot,
+      writeFileSyncFn
+    );
+  }
+  const cliProvider = getCliProviderForModelProvider(provider);
+  if (cliProvider) {
+    const startCommand = getCliProviderEntry(cliProvider).startCommand(model);
+    const script2 = [
+      "#!/bin/bash",
+      `cd '${shellEscapeFn(projectRoot)}' || exit 1`,
+      `${startCommand} "$(cat '${shellEscapeFn(promptFile)}')"`
+    ].join("\n");
+    writeFileSyncFn(launcherFile, script2, { mode: 493 });
+    return `bash '${shellEscapeFn(launcherFile)}'`;
+  }
+  const script = [
+    "#!/bin/bash",
+    `cd '${shellEscapeFn(projectRoot)}' || exit 1`,
+    `export AEMEATHCLI_PROMPT_FILE='${shellEscapeFn(promptFile)}'`,
+    `'${shellEscapeFn(process.execPath)}' '${shellEscapeFn(process.argv[1] ?? "aemeathcli")}' --model ${model}`
+  ].join("\n");
+  writeFileSyncFn(launcherFile, script, { mode: 493 });
+  return `bash '${shellEscapeFn(launcherFile)}'`;
+}
+function writeWindowsLauncherScript(provider, model, promptFile, launcherFile, projectRoot, writeFileSyncFn) {
+  const ps1File = launcherFile.replace(/\.[^.]+$/, ".ps1");
+  const cliProvider = getCliProviderForModelProvider(provider);
+  if (cliProvider) {
+    const startCommand = getCliProviderEntry(cliProvider).startCommand(model);
+    const script2 = [
+      `Set-Location -Path '${projectRoot.replace(/'/g, "''")}'`,
+      `$prompt = Get-Content -Path '${promptFile.replace(/'/g, "''")}' -Raw`,
+      `& ${startCommand} $prompt`
+    ].join("\r\n");
+    writeFileSyncFn(ps1File, script2);
+    return `powershell -ExecutionPolicy Bypass -File "${ps1File}"`;
+  }
+  const script = [
+    `Set-Location -Path '${projectRoot.replace(/'/g, "''")}'`,
+    `$env:AEMEATHCLI_PROMPT_FILE = '${promptFile.replace(/'/g, "''")}'`,
+    `& '${process.execPath.replace(/'/g, "''")}' '${(process.argv[1] ?? "aemeathcli").replace(/'/g, "''")}' --model ${model}`
+  ].join("\r\n");
+  writeFileSyncFn(ps1File, script);
+  return `powershell -ExecutionPolicy Bypass -File "${ps1File}"`;
+}
+
+// src/ui/team-launcher.ts
+function sysMsg(setMessages, content) {
+  setMessages((prev) => [
+    ...prev,
+    { id: v4Id(), role: "system", content, createdAt: /* @__PURE__ */ new Date() }
+  ]);
+}
+async function handlePromptBasedTeamCreation(input, setMessages, panel, getRegistry, currentModelId, config, swarmConfig) {
+  const teamName = `team-${Date.now()}`;
+  setMessages((prev) => [
+    ...prev,
+    { id: v4Id(), role: "user", content: input, createdAt: /* @__PURE__ */ new Date() },
+    { id: v4Id(), role: "system", content: "Analyzing your request to design the agent team...", createdAt: /* @__PURE__ */ new Date() }
+  ]);
+  try {
+    const registry = await getRegistry();
+    const { detectInstalledProviders } = await import('./detect-providers-QICJ5U3R.js');
+    const installedClis = detectInstalledProviders();
+    const prioritizedMasterProviders = resolveMasterProviderPriority(swarmConfig, installedClis);
+    const availableModels = getAvailableModelsForProviders(installedClis);
+    if (availableModels.length === 0) {
+      sysMsg(setMessages, "No AI CLI tools detected. Install at least one: claude, codex, gemini, kimi, or ollama.");
+      return;
+    }
+    const masterLeadModel = pickLeadModel(config, prioritizedMasterProviders, availableModels);
+    if (masterLeadModel === void 0) {
+      return;
+    }
+    const designModel = registry.hasModel(currentModelId) ? currentModelId : registry.hasModel(masterLeadModel) ? masterLeadModel : void 0;
+    if (!designModel) {
+      sysMsg(setMessages, "Swarm team design needs at least one authenticated chat provider. Run `aemeathcli auth login` or configure an API key, then try again.");
+      return;
+    }
+    const designProvider = registry.getForModel(designModel);
+    const primaryMasterLabel = prioritizedMasterProviders[0] ? getCliProviderEntry(prioritizedMasterProviders[0]).label : "current configuration";
+    const userPrompt = `${buildTeamDesignUserPrompt(input, availableModels)}
+
+Master-agent provider priority:
+${prioritizedMasterProviders.map((provider) => `- ${getCliProviderEntry(provider).label}`).join("\n")}
+
+The sponsoring lead agent must use ${primaryMasterLabel} when possible.`;
+    const DESIGN_TIMEOUT_MS = 6e4;
+    sysMsg(setMessages, `Designing team with ${designModel}...`);
+    const designStream = designProvider.stream({
+      model: designModel,
+      messages: [{ id: v4Id(), role: "user", content: userPrompt, createdAt: /* @__PURE__ */ new Date() }],
+      system: TEAM_DESIGN_SYSTEM_PROMPT,
+      maxTokens: 4e3
+    });
+    let designResponse = "";
+    const designResult = await Promise.race([
+      (async () => {
+        for await (const chunk of designStream) {
+          if (chunk.type === "text" && chunk.content) designResponse += chunk.content;
+          if (chunk.type === "error" && chunk.error) throw new Error(`Design stream error: ${chunk.error}`);
+        }
+        return designResponse;
+      })(),
+      new Promise((_resolve, reject) => {
+        setTimeout(() => {
+          reject(new Error(`Team design timed out after ${DESIGN_TIMEOUT_MS / 1e3}s. Check your API credentials and try again.`));
+        }, DESIGN_TIMEOUT_MS);
+      })
+    ]);
+    designResponse = designResult;
+    const teamMasterModel = availableModels.includes(currentModelId) ? currentModelId : masterLeadModel;
+    const agentSpecs = normalizeLeadAgentSpec(
+      parseLLMTeamDesign(designResponse, availableModels, designModel),
+      teamMasterModel
+    );
+    const projectRoot = process.cwd();
+    const isWindows = process.platform === "win32";
+    const isWindowsTerminal = isWindows && typeof process.env["WT_SESSION"] === "string" && process.env["WT_SESSION"].length > 0;
+    if (isWindows && !isWindowsTerminal) {
+      await launchInProcess(
+        agentSpecs,
+        input,
+        teamName,
+        config,
+        panel,
+        setMessages,
+        projectRoot
+      );
+      return void 0;
+    }
+    const fs = await import('fs');
+    const path = await import('path');
+    const os = await import('os');
+    const { execa: execaPane } = await import('execa');
+    const boardDir = path.join(process.cwd(), ".aemeathcli", "team-board");
+    fs.mkdirSync(boardDir, { recursive: true });
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "aemeathcli-team-"));
+    const shellEscape = (s) => s.replace(/'/gu, "'\\''");
+    const [leadSpec, ...workerSpecs] = agentSpecs;
+    if (!leadSpec) return;
+    const teamManifest = {
+      teamName,
+      task: input,
+      boardDir,
+      leadAgent: leadSpec.name,
+      agents: agentSpecs.map((s) => ({
+        name: s.name,
+        agentType: s.agentType,
+        model: s.model,
+        role: s.role,
+        outputFile: path.join(boardDir, `${s.name}.md`)
+      })),
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    fs.writeFileSync(path.join(boardDir, "team-manifest.json"), JSON.stringify(teamManifest, null, 2), "utf-8");
+    const teamRoster = agentSpecs.map((s) => `  - ${s.name} (${s.agentType}, ${s.model}) \u2014 role: ${s.role}`).join("\n");
+    const workerCommands = [];
+    for (const spec of workerSpecs) {
+      const outputFile = path.join(boardDir, `${spec.name}.md`);
+      const promptFile = path.join(tempDir, `${spec.name}.txt`);
+      const prompt = [
+        `# Team Role: ${spec.name}`,
+        `Type: ${spec.agentType} | Model: ${spec.model} | Role: ${spec.role}`,
+        "",
+        "## Your Task",
+        spec.taskPrompt,
+        "",
+        "## Team Context",
+        `You are part of a ${agentSpecs.length}-agent team working collaboratively.`,
+        `Each agent has a specific domain. Do NOT overlap with other agents' responsibilities.`,
+        "",
+        "### Team Members:",
+        teamRoster,
+        "",
+        "## Shared Workspace",
+        `Team board directory: ${boardDir}`,
+        `Your output file: ${outputFile}`,
+        `Team manifest: ${path.join(boardDir, "team-manifest.json")}`,
+        "",
+        "## Coordination Protocol",
+        `1. Write ALL your findings, analysis, and deliverables to your output file: ${outputFile}`,
+        `2. You can read other agents' output files in ${boardDir}/ to check their progress and avoid duplication.`,
+        `3. Focus on YOUR specific domain. Reference other agents' work when relevant to your analysis.`,
+        `4. Read and analyze source files in the project directory to complete your task.`,
+        `5. Be thorough and specific. Include file paths, line numbers, and code snippets in your findings.`,
+        "",
+        "## Coordination with Lead",
+        `The team lead is ${leadSpec.name}. Check their coordination plan at: ${path.join(boardDir, "coordinator.md")}`,
+        `After completing your work, the lead agent will read your output and synthesize findings.`,
+        "",
+        "## User's Original Request",
+        input
+      ].join("\n");
+      fs.writeFileSync(promptFile, prompt, "utf-8");
+      const modelInfo = SUPPORTED_MODELS[spec.model];
+      const provider = modelInfo?.provider ?? "anthropic";
+      const launcherFile = path.join(tempDir, `${spec.name}-launch.sh`);
+      const cmd = writeAgentLauncherScript(
+        provider,
+        spec.model,
+        promptFile,
+        launcherFile,
+        projectRoot,
+        shellEscape,
+        fs.writeFileSync
+      );
+      workerCommands.push({ name: spec.name, command: cmd });
+    }
+    const leadOutputFile = path.join(boardDir, `${leadSpec.name}.md`);
+    const leadCoordinationTask = [
+      `I am the team coordinator (${leadSpec.name}, ${leadSpec.model}).`,
+      "",
+      leadSpec.taskPrompt,
+      "",
+      `## My Responsibilities`,
+      `1. Break down the user's request into clear subtasks for each team member.`,
+      `2. Write my coordination plan and task assignments to: ${path.join(boardDir, "coordinator.md")}`,
+      `3. After completing my own analysis, read other agents' output files in ${boardDir}/ to check progress.`,
+      `4. Synthesize findings from all agents into a final team summary at: ${path.join(boardDir, "SUMMARY.md")}`,
+      `5. Flag any conflicts, gaps, or overlaps between agents' work.`,
+      "",
+      `## Team Members Working in Parallel Panes`,
+      ...workerSpecs.map((s) => `- ${s.name} (${s.model}): writing to ${path.join(boardDir, s.name + ".md")}`),
+      "",
+      `## My Output File: ${leadOutputFile}`,
+      "",
+      `## User's Original Request`,
+      input,
+      "",
+      `Start by reading the codebase and writing my coordination plan to ${path.join(boardDir, "coordinator.md")}.`
+    ].join("\n");
+    const leadPromptFile = path.join(tempDir, `${leadSpec.name}.txt`);
+    const leadLauncherFile = path.join(tempDir, `${leadSpec.name}-launch.sh`);
+    fs.writeFileSync(leadPromptFile, leadCoordinationTask, "utf-8");
+    const leadCommand = writeAgentLauncherScript(
+      SUPPORTED_MODELS[leadSpec.model]?.provider ?? "anthropic",
+      leadSpec.model,
+      leadPromptFile,
+      leadLauncherFile,
+      projectRoot,
+      shellEscape,
+      fs.writeFileSync
+    );
+    const allPaneCommands = [{ name: leadSpec.name, command: leadCommand }, ...workerCommands];
+    const formatAgentLines = (lead) => agentSpecs.map(
+      (spec) => spec.name === lead ? `  ${spec.name} (${spec.model}) \u2014 ${spec.role} [LEAD \u2014 this pane]` : `  ${spec.name} (${spec.model}) \u2014 ${spec.role}`
+    );
+    const isITerm2 = process.platform === "darwin" && process.env["TERM_PROGRAM"] === "iTerm.app";
+    if (isITerm2) {
+      return await launchITerm2(
+        agentSpecs,
+        leadSpec,
+        workerCommands,
+        teamName,
+        tempDir,
+        boardDir,
+        shellEscape,
+        fs,
+        path,
+        execaPane,
+        setMessages,
+        formatAgentLines,
+        leadCoordinationTask
+      );
+    }
+    const isGhostty = process.platform === "darwin" && process.env["TERM_PROGRAM"] === "ghostty";
+    if (isGhostty) {
+      return await launchGhostty(
+        agentSpecs,
+        leadSpec,
+        workerCommands,
+        teamName,
+        tempDir,
+        boardDir,
+        fs,
+        path,
+        execaPane,
+        setMessages,
+        formatAgentLines,
+        leadCoordinationTask
+      );
+    }
+    const isTerminalApp = process.platform === "darwin" && process.env["TERM_PROGRAM"] === "Apple_Terminal";
+    if (isTerminalApp) {
+      return await launchTerminalApp(
+        agentSpecs,
+        leadSpec,
+        workerCommands,
+        teamName,
+        tempDir,
+        boardDir,
+        fs,
+        path,
+        execaPane,
+        setMessages,
+        formatAgentLines,
+        leadCoordinationTask
+      );
+    }
+    if (isWindowsTerminal) {
+      return await launchWindowsTerminal(
+        agentSpecs,
+        leadSpec,
+        workerCommands,
+        teamName,
+        tempDir,
+        boardDir,
+        fs,
+        execaPane,
+        setMessages,
+        formatAgentLines,
+        leadCoordinationTask,
+        projectRoot
+      );
+    }
+    const { TmuxManager } = await import('./tmux-manager-57QCUVHU.js');
+    const tmux = new TmuxManager();
+    const tmuxAvailable = await tmux.isAvailable();
+    if (tmuxAvailable) {
+      const insideTmux = typeof process.env["TMUX"] === "string" && process.env["TMUX"].length > 0;
+      if (insideTmux) {
+        return await launchTmuxInSession(
+          agentSpecs,
+          leadSpec,
+          workerCommands,
+          teamName,
+          tempDir,
+          boardDir,
+          fs,
+          execaPane,
+          setMessages,
+          formatAgentLines,
+          leadCoordinationTask
+        );
+      }
+      return await launchTmuxNewSession(
+        agentSpecs,
+        teamName,
+        tempDir,
+        boardDir,
+        allPaneCommands,
+        tmux,
+        fs,
+        setMessages,
+        formatAgentLines,
+        leadSpec,
+        leadCoordinationTask
+      );
+    }
+    await launchInProcess(
+      agentSpecs,
+      input,
+      teamName,
+      config,
+      panel,
+      setMessages,
+      projectRoot
+    );
+    return void 0;
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    sysMsg(setMessages, `Failed to create team: ${msg}`);
+    return void 0;
+  }
+}
+async function launchITerm2(agentSpecs, leadSpec, workerCommands, teamName, tempDir, boardDir, shellEscape, fs, path, execaPane, setMessages, formatAgentLines, leadCoordinationTask) {
+  sysMsg(setMessages, `Designed ${agentSpecs.length}-agent team. Creating iTerm2 split panes...`);
+  const asEscape = (s) => s.replace(/\\/gu, "\\\\").replace(/"/gu, '\\"');
+  const scriptLines = [];
+  scriptLines.push('tell application "iTerm2"');
+  scriptLines.push("  tell current window");
+  scriptLines.push("    set leaderSession to current session of current tab");
+  for (const [i, agent] of workerCommands.entries()) {
+    const prevVar = i === 0 ? "leaderSession" : `agent${i - 1}`;
+    const curVar = `agent${i}`;
+    const splitDir = i === 0 ? "vertically" : "horizontally";
+    scriptLines.push(`    tell ${prevVar}`);
+    scriptLines.push(`      set ${curVar} to (split ${splitDir} with default profile)`);
+    scriptLines.push("    end tell");
+    scriptLines.push(`    tell ${curVar}`);
+    scriptLines.push(`      set name to "${asEscape(agent.name)}"`);
+    scriptLines.push(`      write text "${asEscape(agent.command)}"`);
+    scriptLines.push("    end tell");
+  }
+  scriptLines.push("    select leaderSession");
+  scriptLines.push("  end tell");
+  scriptLines.push("end tell");
+  const scriptFile = path.join(tempDir, "create-panes.applescript");
+  fs.writeFileSync(scriptFile, scriptLines.join("\n"), "utf-8");
+  try {
+    await execaPane("osascript", [scriptFile]);
+  } catch (scriptErr) {
+    const errMsg = scriptErr instanceof Error ? scriptErr.message : String(scriptErr);
+    sysMsg(setMessages, `Failed to create iTerm2 panes: ${errMsg.slice(0, 200)}`);
+    return;
+  }
+  setActiveTeamName(teamName);
+  setActiveTeamManager(void 0);
+  setActiveTmuxCleanup(async () => {
+    try {
+      const { execFileSync } = await import('child_process');
+      execFileSync("pkill", ["-f", tempDir], { stdio: "ignore" });
+    } catch {
+    }
+    try {
+      fs.rmSync(tempDir, { recursive: true, force: true });
+      fs.rmSync(boardDir, { recursive: true, force: true });
+    } catch {
+    }
+  });
+  const agentLines = formatAgentLines(leadSpec.name);
+  sysMsg(
+    setMessages,
+    `Team "${teamName}" \u2014 ${agentSpecs.length} agents active.
+${workerCommands.length} worker panes in iTerm2 + lead coordinating here.
+${agentLines.join("\n")}
+/team stop to shut down all agents.`
+  );
+  return leadCoordinationTask;
+}
+async function launchGhostty(agentSpecs, leadSpec, workerCommands, teamName, tempDir, boardDir, fs, path, execaPane, setMessages, formatAgentLines, leadCoordinationTask) {
+  sysMsg(setMessages, `Designed ${agentSpecs.length}-agent team. Creating Ghostty split panes...`);
+  const asEscape = (s) => s.replace(/\\/gu, "\\\\").replace(/"/gu, '\\"');
+  const scriptLines = [];
+  scriptLines.push('tell application "Ghostty" to activate');
+  scriptLines.push("delay 0.5");
+  scriptLines.push('tell application "System Events"');
+  for (const [i, agent] of workerCommands.entries()) {
+    if (i === 0) {
+      scriptLines.push('  keystroke "d" using {command down}');
+    } else {
+      scriptLines.push('  keystroke "d" using {command down, shift down}');
+    }
+    scriptLines.push("  delay 1.0");
+    const escapedCmd = asEscape(agent.command);
+    scriptLines.push(`  keystroke "${escapedCmd}"`);
+    scriptLines.push("  delay 0.2");
+    scriptLines.push("  keystroke return");
+    scriptLines.push("  delay 0.5");
+  }
+  if (workerCommands.length > 0) {
+    for (let i = 0; i < workerCommands.length; i++) {
+      scriptLines.push("  key code 123 using {command down, option down}");
+      scriptLines.push("  delay 0.2");
+    }
+  }
+  scriptLines.push("end tell");
+  const scriptFile = path.join(tempDir, "create-panes.applescript");
+  fs.writeFileSync(scriptFile, scriptLines.join("\n"), "utf-8");
+  try {
+    await execaPane("osascript", [scriptFile]);
+  } catch (scriptErr) {
+    const errMsg = scriptErr instanceof Error ? scriptErr.message : String(scriptErr);
+    sysMsg(
+      setMessages,
+      `Failed to create Ghostty panes: ${errMsg.slice(0, 200)}
+Ensure macOS accessibility permissions are granted and Ghostty uses default split keybindings (Cmd+D = new_split:right, Cmd+Shift+D = new_split:down).`
+    );
+    return;
+  }
+  setActiveTeamName(teamName);
+  setActiveTeamManager(void 0);
+  setActiveTmuxCleanup(async () => {
+    try {
+      const { execFileSync } = await import('child_process');
+      execFileSync("pkill", ["-f", tempDir], { stdio: "ignore" });
+    } catch {
+    }
+    try {
+      fs.rmSync(tempDir, { recursive: true, force: true });
+      fs.rmSync(boardDir, { recursive: true, force: true });
+    } catch {
+    }
+  });
+  const agentLines = formatAgentLines(leadSpec.name);
+  sysMsg(
+    setMessages,
+    `Team "${teamName}" \u2014 ${agentSpecs.length} agents active.
+${workerCommands.length} worker panes in Ghostty + lead coordinating here.
+${agentLines.join("\n")}
+Keybindings:
+  Cmd+Opt+Arrows    Switch pane
+  Cmd+Shift+Enter   Zoom pane
+  Cmd+Ctrl+=         Equalize splits
+/team stop to shut down all agents.`
+  );
+  return leadCoordinationTask;
+}
+async function launchTerminalApp(agentSpecs, leadSpec, workerCommands, teamName, tempDir, boardDir, fs, path, execaPane, setMessages, formatAgentLines, leadCoordinationTask) {
+  sysMsg(setMessages, `Designed ${agentSpecs.length}-agent team. Creating Terminal.app split panes...`);
+  const asEscape = (s) => s.replace(/\\/gu, "\\\\").replace(/"/gu, '\\"');
+  const scriptLines = [];
+  scriptLines.push('tell application "Terminal" to activate');
+  scriptLines.push("delay 0.5");
+  scriptLines.push('tell application "System Events"');
+  for (const agent of workerCommands) {
+    scriptLines.push('  keystroke "d" using {command down}');
+    scriptLines.push("  delay 1.0");
+    const escapedCmd = asEscape(agent.command);
+    scriptLines.push(`  keystroke "${escapedCmd}"`);
+    scriptLines.push("  delay 0.2");
+    scriptLines.push("  keystroke return");
+    scriptLines.push("  delay 0.5");
+  }
+  scriptLines.push("end tell");
+  const scriptFile = path.join(tempDir, "create-panes.applescript");
+  fs.writeFileSync(scriptFile, scriptLines.join("\n"), "utf-8");
+  try {
+    await execaPane("osascript", [scriptFile]);
+  } catch (scriptErr) {
+    const errMsg = scriptErr instanceof Error ? scriptErr.message : String(scriptErr);
+    sysMsg(
+      setMessages,
+      `Failed to create Terminal.app panes: ${errMsg.slice(0, 200)}
+Ensure macOS accessibility permissions are granted for Terminal.app.`
+    );
+    return;
+  }
+  setActiveTeamName(teamName);
+  setActiveTeamManager(void 0);
+  setActiveTmuxCleanup(async () => {
+    try {
+      const { execFileSync } = await import('child_process');
+      execFileSync("pkill", ["-f", tempDir], { stdio: "ignore" });
+    } catch {
+    }
+    try {
+      fs.rmSync(tempDir, { recursive: true, force: true });
+      fs.rmSync(boardDir, { recursive: true, force: true });
+    } catch {
+    }
+  });
+  const agentLines = formatAgentLines(leadSpec.name);
+  sysMsg(
+    setMessages,
+    `Team "${teamName}" \u2014 ${agentSpecs.length} agents active.
+${workerCommands.length} worker panes in Terminal.app + lead coordinating here.
+${agentLines.join("\n")}
+Click the lead pane to switch back. Shift+Cmd+D to close a split pane.
+/team stop to shut down all agents.`
+  );
+  return leadCoordinationTask;
+}
+async function launchWindowsTerminal(agentSpecs, leadSpec, workerCommands, teamName, tempDir, boardDir, fs, execaPane, setMessages, formatAgentLines, leadCoordinationTask, projectRoot) {
+  sysMsg(setMessages, `Designed ${agentSpecs.length}-agent team. Creating Windows Terminal split panes...`);
+  for (const [i, agent] of workerCommands.entries()) {
+    const splitDir = i === 0 ? "-V" : "-H";
+    const args = ["-w", "0", "sp", splitDir];
+    if (i === 0) args.push("-s", "0.5");
+    args.push("-d", projectRoot, "--title", agent.name);
+    args.push("cmd", "/c", agent.command);
+    try {
+      await execaPane("wt", args);
+    } catch (err) {
+      const errMsg = err instanceof Error ? err.message : String(err);
+      sysMsg(setMessages, `Failed to create WT pane for ${agent.name}: ${errMsg.slice(0, 200)}`);
+    }
+  }
+  try {
+    await execaPane("wt", ["-w", "0", "mf", "first"]);
+  } catch {
+  }
+  setActiveTeamName(teamName);
+  setActiveTeamManager(void 0);
+  setActiveTmuxCleanup(async () => {
+    try {
+      fs.rmSync(tempDir, { recursive: true, force: true });
+      fs.rmSync(boardDir, { recursive: true, force: true });
+    } catch {
+    }
+  });
+  const agentLines = formatAgentLines(leadSpec.name);
+  sysMsg(
+    setMessages,
+    `Team "${teamName}" \u2014 ${agentSpecs.length} agents active.
+${workerCommands.length} worker panes in Windows Terminal + lead coordinating here.
+${agentLines.join("\n")}
+Keybindings:
+  Alt+Arrow     Switch pane
+  Alt+Shift+Arrow  Resize pane
+/team stop to shut down all agents.`
+  );
+  return leadCoordinationTask;
+}
+async function launchTmuxInSession(agentSpecs, leadSpec, workerCommands, teamName, tempDir, boardDir, fs, execaPane, setMessages, formatAgentLines, leadCoordinationTask) {
+  sysMsg(setMessages, `Designed ${agentSpecs.length}-agent team. Creating tmux split panes...`);
+  const currentResult = await execaPane("tmux", ["display-message", "-p", "#{pane_id}"]);
+  const leaderPaneId = currentResult.stdout.trim();
+  const agentPaneIds = [];
+  for (const [i, agent] of workerCommands.entries()) {
+    const splitResult = await execaPane("tmux", [
+      "split-window",
+      i === 0 ? "-h" : "-v",
+      "-P",
+      "-F",
+      "#{pane_id}"
+    ]);
+    const newPaneId = splitResult.stdout.trim();
+    agentPaneIds.push(newPaneId);
+    await execaPane("tmux", ["send-keys", "-t", newPaneId, agent.command, "Enter"]);
+  }
+  if (workerCommands.length > 0) {
+    try {
+      await execaPane("tmux", ["select-layout", "main-vertical"]);
+    } catch {
+    }
+  }
+  try {
+    await execaPane("tmux", ["select-pane", "-t", leaderPaneId]);
+  } catch {
+  }
+  setActiveTeamName(teamName);
+  setActiveTeamManager(void 0);
+  setActiveTmuxCleanup(async () => {
+    const { execa: ex } = await import('execa');
+    for (const pid of agentPaneIds) {
+      try {
+        await ex("tmux", ["kill-pane", "-t", pid]);
+      } catch {
+      }
+    }
+    try {
+      fs.rmSync(tempDir, { recursive: true, force: true });
+      fs.rmSync(boardDir, { recursive: true, force: true });
+    } catch {
+    }
+  });
+  const agentLines = formatAgentLines(leadSpec.name);
+  sysMsg(
+    setMessages,
+    `Team "${teamName}" \u2014 ${agentSpecs.length} agents active.
+${workerCommands.length} worker panes in tmux + lead coordinating here.
+${agentLines.join("\n")}
+/team stop to shut down all agents.`
+  );
+  return leadCoordinationTask;
+}
+async function launchTmuxNewSession(agentSpecs, teamName, tempDir, boardDir, allPaneCommands, tmux, fs, setMessages, formatAgentLines, leadSpec, leadCoordinationTask) {
+  sysMsg(setMessages, `Designed ${agentSpecs.length}-agent team. Opening tmux split-panel view...`);
+  const sessionName = await tmux.createSession(teamName);
+  const paneConfigs = agentSpecs.map((spec, i) => ({
+    paneId: `pane-${i}`,
+    agentName: spec.name,
+    model: spec.model,
+    role: spec.role,
+    title: `${spec.name} (${spec.model})`
+  }));
+  const layoutConfig = {
+    layout: "hub-spoke",
+    panes: paneConfigs,
+    maxPanes: paneConfigs.length
+  };
+  await tmux.createPanes(layoutConfig);
+  for (const [i, agent] of allPaneCommands.entries()) {
+    await tmux.sendCommand(`pane-${i}`, agent.command);
+  }
+  setActiveTeamName(teamName);
+  setActiveTeamManager(void 0);
+  setActiveTmuxCleanup(async () => {
+    await tmux.destroy();
+    try {
+      fs.rmSync(tempDir, { recursive: true, force: true });
+      fs.rmSync(boardDir, { recursive: true, force: true });
+    } catch {
+    }
+  });
+  sysMsg(
+    setMessages,
+    `Attaching to tmux session "${sessionName}" with ${agentSpecs.length} agents\u2026
+
+Inside tmux:
+  Ctrl+B \u2192/\u2190/\u2191/\u2193   Switch pane
+  Ctrl+B  d            Detach (return to aemeath)
+  Ctrl+B  z            Zoom pane fullscreen`
+  );
+  const { execFileSync } = await import('child_process');
+  if (process.stdin.isTTY && typeof process.stdin.setRawMode === "function") {
+    process.stdin.setRawMode(false);
+  }
+  process.stdin.pause();
+  try {
+    execFileSync("tmux", ["attach-session", "-t", sessionName], { stdio: "inherit" });
+  } catch {
+  }
+  if (process.stdin.isTTY && typeof process.stdin.setRawMode === "function") {
+    process.stdin.setRawMode(true);
+  }
+  process.stdin.resume();
+  const agentLines = formatAgentLines(leadSpec.name);
+  sysMsg(
+    setMessages,
+    `Detached from tmux. Agents may still be running.
+
+Agents:
+${agentLines.join("\n")}
+
+Keybindings (inside tmux):
+  Ctrl+B \u2192 \u2190 \u2191 \u2193   Switch between panes
+  Ctrl+B  d            Detach (return here)
+  Ctrl+B  z            Zoom active pane (fullscreen toggle)
+  Ctrl+B  x            Close active pane
+
+Re-attach:  tmux attach -t ${sessionName}
+/team stop  Shut down all agents and kill session`
+  );
+  return leadCoordinationTask;
+}
+async function launchInProcess(agentSpecs, input, teamName, config, panel, setMessages, projectRoot) {
+  sysMsg(
+    setMessages,
+    `Designed ${agentSpecs.length}-agent team. Starting agents (in-process mode)\u2026
+
+Keybindings:
+  Tab              Switch to next agent
+  Ctrl+1-${agentSpecs.length}          Jump to agent N
+  /team stop       Exit team mode`
+  );
+  const agentDefinitions = agentSpecs.map((spec) => {
+    const modelInfo = SUPPORTED_MODELS[spec.model];
+    const provider = modelInfo?.provider ?? "anthropic";
+    return { name: spec.name, agentType: spec.agentType, model: spec.model, provider, role: spec.role };
+  });
+  const { TeamManager: TM } = await import('./team-manager-2VSMALAA.js');
+  const manager = new TM();
+  setActiveTeamManager(manager);
+  setActiveTeamName(teamName);
+  setActiveTmuxCleanup(void 0);
+  const agentAllowedPaths = Array.from(/* @__PURE__ */ new Set([projectRoot, ...config.permissions.allowedPaths]));
+  const teamConfig = manager.createTeam(teamName, {
+    description: `Agent team for: ${input.slice(0, 120)}`,
+    agents: agentDefinitions,
+    agentEnv: {
+      AEMEATHCLI_TOOL_PROJECT_ROOT: projectRoot,
+      AEMEATHCLI_TOOL_WORKING_DIRECTORY: projectRoot,
+      AEMEATHCLI_TOOL_PERMISSION_MODE: config.permissions.mode,
+      AEMEATHCLI_TOOL_ALLOWED_PATHS: JSON.stringify(agentAllowedPaths),
+      AEMEATHCLI_TOOL_BLOCKED_COMMANDS: JSON.stringify(config.permissions.blockedCommands)
+    }
+  });
+  const agentStates = teamConfig.members.map((member) => ({
+    config: member,
+    status: "idle"
+  }));
+  panel.setAgents(agentStates);
+  panel.activate();
+  for (const member of teamConfig.members) {
+    panel.appendOutput(member.agentId, `[${member.name}] Starting (${member.model})...
+`, { immediate: true });
+  }
+  manager.onAgentMessages(teamName, (_agentName, method, params) => {
+    if (method === "agent.streamChunk") {
+      const agentId = typeof params["agentId"] === "string" ? params["agentId"] : "";
+      const content = typeof params["content"] === "string" ? params["content"] : "";
+      if (agentId && content) panel.appendOutput(agentId, content);
+    }
+    if (method === "agent.taskUpdate") {
+      const agentId = typeof params["agentId"] === "string" ? params["agentId"] : "";
+      const rawStatus = typeof params["status"] === "string" ? params["status"] : "";
+      if (agentId && rawStatus) {
+        const statusMap = { in_progress: "active", completed: "idle" };
+        const mapped = statusMap[rawStatus];
+        if (mapped) panel.updateAgentStatus(agentId, mapped);
+      }
+    }
+  });
+  try {
+    await manager.startAgents(teamName);
+  } catch (startErr) {
+    const errMsg = startErr instanceof Error ? startErr.message : String(startErr);
+    sysMsg(setMessages, `Warning: Some agents failed to start: ${errMsg.slice(0, 200)}`);
+  }
+  const agentStatesAfterStart = manager.getAgentStates(teamName);
+  const aliveCount = agentStatesAfterStart.filter((s) => s.status !== "error" && s.status !== "shutdown").length;
+  if (aliveCount === 0) {
+    sysMsg(setMessages, "All agents failed to start. Check your API credentials and try again.");
+    return void 0;
+  }
+  for (const [i, member] of teamConfig.members.entries()) {
+    const spec = agentSpecs[i];
+    const taskId = v4Id();
+    const prompt = spec ? `You are ${spec.name} (${spec.agentType}).
+
+${spec.taskPrompt}
+
+User request:
+${input}` : `Work on the following task:
+
+${input}`;
+    manager.assignTask(teamName, member.name, taskId, `${member.role}: ${input.slice(0, 80)}`, prompt);
+  }
+  const agentLines = agentSpecs.map((spec) => `  ${spec.name} (${spec.model}) \u2014 ${spec.role}`);
+  sysMsg(
+    setMessages,
+    `Team "${teamName}" created with ${teamConfig.members.length} agents \u2014 split-panel active.
+${agentLines.join("\n")}
+Use Tab to switch agents. /team stop to return to single-pane.`
+  );
+  return void 0;
+}
+
+// src/ui/app-helpers.ts
+var DEFAULT_SYSTEM_PROMPT = "You are AemeathCLI (aemeathcli), a multi-model AI agent orchestrator. You help users with coding tasks, code review, debugging, refactoring, and project management. You are NOT Claude Code, Codex, or Gemini CLI \u2014 you are Aemeath Agent Swarm, an independent tool that orchestrates multiple AI providers (Anthropic, OpenAI, Google, Kimi, Ollama).\n\nAnswer concisely and directly. Key features:\n- Multi-model: /model to switch between Claude, GPT, Gemini, Kimi, Ollama\n- Agent orchestration: use Shift+Tab to switch into swarm mode inside the TUI\n  - swarm mode designs and coordinates multi-agent teams from natural language\n  - the master agent owns the left pane, worker agents stream on the right\n  - follow the configured master-agent provider preference when building teams\n- Skills: $review, $commit, $plan, $debug, $test, $refactor\n- Commands: /help, /model, /role, /history, /resume, /cost\n\nWhen users ask about agent swarm, multi-agent, team mode, or orchestration, keep them in the current TUI session and tell them to switch modes with Shift+Tab. Do not redirect them to a separate `launch` command.";
+function getCandidateModels(config, resolution, activeModelId) {
+  const candidates = [activeModelId];
+  if (resolution.source !== "user_override" && resolution.role) {
+    const roleConfig = config.roles[resolution.role];
+    if (roleConfig) {
+      candidates.push(roleConfig.primary, ...roleConfig.fallback);
+    }
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const unique = [];
+  for (const modelId of candidates) {
+    if (!seen.has(modelId)) {
+      seen.add(modelId);
+      unique.push(modelId);
+    }
+  }
+  return unique;
+}
+function cliProviderListsEqual(left, right) {
+  return left.length === right.length && left.every((value, index) => value === right[index]);
+}
+function normalizeSwarmConfig(swarm, detectedProviders) {
+  const primaryMasterProvider = swarm.primaryMasterProvider !== void 0 && detectedProviders.includes(swarm.primaryMasterProvider) ? swarm.primaryMasterProvider : void 0;
+  const fallbackMasterProviders = swarm.fallbackMasterProviders.filter(
+    (provider) => provider !== primaryMasterProvider && detectedProviders.includes(provider)
+  );
+  return {
+    onboardingComplete: swarm.onboardingComplete && primaryMasterProvider !== void 0,
+    detectedProviders: [...detectedProviders],
+    primaryMasterProvider,
+    fallbackMasterProviders
+  };
+}
+function swarmConfigsEqual(left, right) {
+  return left.onboardingComplete === right.onboardingComplete && left.primaryMasterProvider === right.primaryMasterProvider && cliProviderListsEqual(left.detectedProviders, right.detectedProviders) && cliProviderListsEqual(left.fallbackMasterProviders, right.fallbackMasterProviders);
+}
+function App({ config, options }) {
+  const { resolution, modelId, switchModel, switchRole } = useModel(
+    config,
+    options.model,
+    options.role
+  );
+  const { state: streamState, startStream, cancelStream, reset: resetStream } = useStream();
+  const { totalCost, totalTokens, record } = useCost(config.cost);
+  const totalCostRef = useRef(totalCost);
+  totalCostRef.current = totalCost;
+  const totalTokensRef = useRef(totalTokens);
+  totalTokensRef.current = totalTokens;
+  const panel = usePanel();
+  const [messages, setMessages] = useState([]);
+  const [isProcessing, setIsProcessing] = useState(false);
+  const messagesRef = useRef([]);
+  messagesRef.current = messages;
+  const [gitBranch, setGitBranch] = useState();
+  const [thinkingValue, setThinkingValue] = useState("medium");
+  const [selectionMode, setSelectionMode] = useState({ type: "none" });
+  const [modelDisplayOrder, setModelDisplayOrder] = useState(void 0);
+  const [persistentHistory, setPersistentHistory] = useState([]);
+  const [inputMode, setInputMode] = useState("agent-swarm");
+  const [swarmConfig, setSwarmConfig] = useState(config.swarm);
+  const [swarmOnboardingDeferred, setSwarmOnboardingDeferred] = useState(false);
+  const registryRef = useRef(void 0);
+  const getRegistry = useCallback(async () => {
+    if (registryRef.current !== void 0) return registryRef.current;
+    const { createDefaultRegistry } = await import('./registry-MVNSXCEF.js');
+    registryRef.current = await createDefaultRegistry();
+    return registryRef.current;
+  }, []);
+  const projectRootRef = useRef(process.cwd());
+  useEffect(() => {
+    void import('./pathResolver-UVAB2FCW.js').then(({ findProjectRoot }) => {
+      projectRootRef.current = findProjectRoot();
+    }).catch(() => {
+    });
+  }, []);
+  useEffect(() => {
+    void (async () => {
+      try {
+        const { findProjectRoot } = await import('./pathResolver-UVAB2FCW.js');
+        const root = findProjectRoot();
+        projectRootRef.current = root;
+        const { loadInputHistory } = await import('./input-history-BEICE7PT.js');
+        const history = await loadInputHistory(root);
+        if (history.length > 0) setPersistentHistory(history);
+      } catch {
+      }
+    })();
+  }, []);
+  useEffect(() => {
+    void import('child_process').then(({ execFile }) => {
+      execFile("git", ["rev-parse", "--abbrev-ref", "HEAD"], { timeout: 2e3 }, (error, stdout) => {
+        if (!error && stdout) setGitBranch(stdout.trim());
+      });
+    }).catch(() => {
+    });
+  }, []);
+  useEffect(() => {
+    if (options.isAgentPane) return;
+    void import('./detect-providers-QICJ5U3R.js').then(({ detectInstalledProviders }) => {
+      const detected = detectInstalledProviders();
+      if (detected.length > 0) setSwarmOnboardingDeferred(false);
+      setSwarmConfig((prev) => {
+        const next = normalizeSwarmConfig(prev, detected);
+        return swarmConfigsEqual(prev, next) ? prev : next;
+      });
+    }).catch(() => {
+    });
+  }, [options.isAgentPane]);
+  useEffect(() => {
+    void (async () => {
+      try {
+        const { findProjectRoot } = await import('./pathResolver-UVAB2FCW.js');
+        const projectRoot = findProjectRoot();
+        projectRootRef.current = projectRoot;
+        const { default: fg } = await import('fast-glob');
+        const pathModule = await import('path');
+        const fileRefs = await fg(["**/*"], {
+          cwd: projectRoot,
+          onlyFiles: true,
+          dot: false,
+          followSymbolicLinks: false,
+          unique: true,
+          suppressErrors: true,
+          ignore: [".git/**", "node_modules/**", "dist/**", "coverage/**", ".aemeathcli/**", ".agents/**", "reference-gemini-cli/**", "cli-agent-orchestrator/**"]
+        });
+        const autocompleteItems = fileRefs.sort((left, right) => left.length !== right.length ? left.length - right.length : left.localeCompare(right)).slice(0, 400).map((filePath) => ({
+          label: `@${filePath}`,
+          description: pathModule.dirname(filePath) === "." ? "project root file" : pathModule.dirname(filePath)
+        }));
+        registerDynamicFileRefs(autocompleteItems);
+      } catch {
+        registerDynamicFileRefs([]);
+      }
+    })();
+  }, []);
+  useEffect(() => {
+    void (async () => {
+      try {
+        const { SkillRegistry } = await import('./registry-LRURZVUL.js');
+        const { findProjectRoot } = await import('./pathResolver-UVAB2FCW.js');
+        const registry = new SkillRegistry();
+        await registry.initialize(findProjectRoot());
+        const all = registry.listAll();
+        if (all.length > 0) {
+          registerDynamicSkills(all.map((s) => ({ label: `$${s.name}`, description: s.description })));
+        }
+      } catch {
+      }
+    })();
+  }, []);
+  useEffect(() => {
+    void (async () => {
+      try {
+        const { discoverModels, getDisplayOrder } = await import('./model-discovery-AAJDHRFO.js');
+        await discoverModels();
+        setModelDisplayOrder(getDisplayOrder());
+      } catch {
+      }
+    })();
+  }, []);
+  const handleSubmit = useCallback(
+    async (input) => {
+      if (input.startsWith("/")) {
+        await handleInternalCommand(input, switchModel, switchRole, {
+          totalCost: totalCostRef.current,
+          totalTokens: totalTokensRef.current,
+          setMessages,
+          modelId,
+          thinkingValue,
+          setThinkingValue,
+          setSelectionMode,
+          resolution,
+          panel: { setAgents: panel.setAgents, activate: panel.activate, deactivate: panel.deactivate, appendOutput: panel.appendOutput },
+          getRegistry,
+          projectRoot: projectRootRef.current
+        });
+        return;
+      }
+      if (input.startsWith("$")) {
+        await handleSkillInvocation(input, setMessages);
+        return;
+      }
+      const activeTeamName = getActiveTeamName();
+      const activeTeamManager = getActiveTeamManager();
+      if (inputMode === "agent-swarm" && !options.isAgentPane && !panel.isSplitPanelActive && !activeTeamName) {
+        setIsProcessing(true);
+        try {
+          const leaderTask = await handlePromptBasedTeamCreation(
+            input,
+            setMessages,
+            panel,
+            getRegistry,
+            modelId,
+            config,
+            swarmConfig
+          );
+          if (leaderTask) setTimeout(() => void handleSubmit(leaderTask), 1500);
+        } finally {
+          setIsProcessing(false);
+        }
+        return;
+      }
+      if (panel.isSplitPanelActive && activeTeamManager && activeTeamName) {
+        const targetAgent = panel.agents[panel.activeAgentIndex] ?? panel.agents[0];
+        if (!targetAgent) {
+          setMessages((prev) => [...prev, { id: v4Id(), role: "system", content: "No active swarm agent is available to receive input.", createdAt: /* @__PURE__ */ new Date() }]);
+          return;
+        }
+        const taskId = v4Id();
+        activeTeamManager.assignTask(activeTeamName, targetAgent.config.name, taskId, `User steering: ${input.slice(0, 72)}`, input);
+        panel.appendOutput(targetAgent.config.agentId, `
+[User] ${input}
+`);
+        panel.updateAgentStatus(targetAgent.config.agentId, "active");
+        return;
+      }
+      const userMessage = { id: v4Id(), role: "user", content: input, createdAt: /* @__PURE__ */ new Date() };
+      import('./input-history-BEICE7PT.js').then(({ appendInputHistory }) => appendInputHistory(projectRootRef.current, input)).catch(() => {
+      });
+      setMessages((prev) => [...prev, userMessage]);
+      setIsProcessing(true);
+      resetStream();
+      try {
+        const registry = await getRegistry();
+        const allMessages = [...messagesRef.current, userMessage].filter((m) => m.role !== "system");
+        const candidateModels = getCandidateModels(config, resolution, modelId);
+        let responseModel = modelId;
+        let responseProvider = resolution.provider;
+        let fullContent = "";
+        let completed = false;
+        let lastError;
+        for (const candidateModel of candidateModels) {
+          const providerOrUndefined = registry.hasModel(candidateModel) ? registry.getForModel(candidateModel) : void 0;
+          if (!providerOrUndefined) {
+            lastError = new Error(`No provider available for model "${candidateModel}"`);
+            continue;
+          }
+          const candidateProvider = providerOrUndefined;
+          let candidateContent = "";
+          let caughtError;
+          const stream = candidateProvider.stream({
+            model: candidateModel,
+            messages: allMessages,
+            system: options.systemPrompt ?? DEFAULT_SYSTEM_PROMPT,
+            maxTokens: 16e3
+          });
+          async function* instrumentedStream(source) {
+            try {
+              for await (const chunk of source) {
+                if (chunk.type === "text" && chunk.content) candidateContent += chunk.content;
+                if (chunk.type === "usage" && chunk.usage) {
+                  record(candidateProvider.name, candidateModel, chunk.usage.inputTokens, chunk.usage.outputTokens, resolution.role);
+                }
+                if (chunk.type === "error") caughtError = new Error(chunk.error ?? `Model "${candidateModel}" stream failed`);
+                yield chunk;
+              }
+            } catch (err) {
+              caughtError = err;
+              throw err;
+            }
+          }
+          resetStream();
+          await startStream(instrumentedStream(stream));
+          if (caughtError !== void 0) {
+            lastError = caughtError;
+            continue;
+          }
+          responseModel = candidateModel;
+          responseProvider = candidateProvider.name;
+          fullContent = candidateContent;
+          completed = true;
+          break;
+        }
+        if (!completed) {
+          throw lastError instanceof Error ? lastError : new Error(typeof lastError === "string" ? lastError : "No model could produce a response");
+        }
+        if (fullContent.length > 0) {
+          const assistantMessage = {
+            id: v4Id(),
+            role: "assistant",
+            content: fullContent,
+            model: responseModel,
+            provider: responseProvider,
+            createdAt: /* @__PURE__ */ new Date()
+          };
+          setMessages((prev) => {
+            const output = [...prev];
+            if (responseModel !== modelId) {
+              output.push({ id: v4Id(), role: "system", content: `Primary model "${modelId}" failed. Switched to fallback "${responseModel}".`, createdAt: /* @__PURE__ */ new Date() });
+            }
+            output.push(assistantMessage);
+            return output;
+          });
+          void persistMessages(projectRootRef.current, userMessage, assistantMessage, responseModel, responseProvider);
+        }
+      } catch (error) {
+        const errorContent = error instanceof Error ? error.message : String(error);
+        setMessages((prev) => [...prev, { id: v4Id(), role: "assistant", content: `Error: ${errorContent}`, model: modelId, createdAt: /* @__PURE__ */ new Date() }]);
+      } finally {
+        setIsProcessing(false);
+      }
+    },
+    [config, modelId, resolution, options.systemPrompt, record, switchModel, switchRole, startStream, resetStream, getRegistry, panel, thinkingValue, inputMode, options.isAgentPane, swarmConfig]
+  );
+  useEffect(() => {
+    if (options.initialMessage) void handleSubmit(options.initialMessage);
+  }, [handleSubmit, options.initialMessage]);
+  const handleSubmitSync = useCallback((input) => {
+    void handleSubmit(input);
+  }, [handleSubmit]);
+  const handleCancel = useCallback(() => {
+    cancelStream();
+    setIsProcessing(false);
+  }, [cancelStream]);
+  const handleModelSelected = useCallback((selectedModelId) => {
+    const thinkingCfg = getThinkingConfigForModel(selectedModelId);
+    if (thinkingCfg) {
+      setSelectionMode({ type: "thinking", modelId: selectedModelId });
+    } else {
+      switchModel(selectedModelId);
+      setSelectionMode({ type: "none" });
+      const info = SUPPORTED_MODELS[selectedModelId];
+      setMessages((prev) => [...prev, { id: v4Id(), role: "system", content: `Switched to model: ${info?.name ?? selectedModelId}`, createdAt: /* @__PURE__ */ new Date() }]);
+    }
+  }, [switchModel]);
+  const handleThinkingSelected = useCallback((value) => {
+    if (selectionMode.type !== "thinking") return;
+    const { modelId: selectedModelId } = selectionMode;
+    switchModel(selectedModelId);
+    setThinkingValue(value);
+    setSelectionMode({ type: "none" });
+    const info = SUPPORTED_MODELS[selectedModelId];
+    const cfg = getThinkingConfigForModel(selectedModelId);
+    const methodLabel = cfg ? formatThinkingMethod(cfg.method) : "Thinking";
+    const optionLabel = cfg?.options.find((o) => o.value === value)?.label ?? value;
+    setMessages((prev) => [...prev, { id: v4Id(), role: "system", content: `Switched to model: ${info?.name ?? selectedModelId}
+${methodLabel}: ${optionLabel}`, createdAt: /* @__PURE__ */ new Date() }]);
+  }, [selectionMode, switchModel]);
+  const handleSelectionCancel = useCallback(() => {
+    setSelectionMode({ type: "none" });
+  }, []);
+  const handleLoginSelected = useCallback(async (provider) => {
+    setSelectionMode({ type: "none" });
+    const loginMsg = provider === "gemini" ? "Logging in to gemini... A new terminal window will open for authentication." : `Logging in to ${provider}...`;
+    setMessages((prev) => [...prev, { id: v4Id(), role: "system", content: loginMsg, createdAt: /* @__PURE__ */ new Date() }]);
+    try {
+      const loginModule = await loadLoginModuleForSlash(provider);
+      await loginModule.login();
+      setMessages((prev) => [...prev, { id: v4Id(), role: "system", content: `Successfully logged in to ${provider}`, createdAt: /* @__PURE__ */ new Date() }]);
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      setMessages((prev) => [...prev, { id: v4Id(), role: "system", content: `Login failed: ${msg}`, createdAt: /* @__PURE__ */ new Date() }]);
+    }
+  }, []);
+  const handleSwarmOnboardingSelected = useCallback(async (primaryProvider) => {
+    const nextSwarmConfig = {
+      onboardingComplete: true,
+      detectedProviders: swarmConfig.detectedProviders,
+      primaryMasterProvider: primaryProvider,
+      fallbackMasterProviders: swarmConfig.detectedProviders.filter((p) => p !== primaryProvider)
+    };
+    try {
+      const { ConfigStore } = await import('./config-store-NF56VHFU.js');
+      const store = new ConfigStore();
+      const currentConfig = store.loadGlobal();
+      const nextProviders = { ...currentConfig.providers };
+      for (const provider of nextSwarmConfig.detectedProviders) {
+        const entry = getCliProviderEntry(provider);
+        nextProviders[entry.provider] = { ...nextProviders[entry.provider], enabled: true };
+      }
+      store.saveGlobal({ ...currentConfig, providers: nextProviders, swarm: nextSwarmConfig });
+      setSwarmOnboardingDeferred(false);
+      setSwarmConfig(nextSwarmConfig);
+      setSelectionMode({ type: "none" });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      setMessages((prev) => [...prev, { id: v4Id(), role: "system", content: `Failed to save swarm setup: ${message}`, createdAt: /* @__PURE__ */ new Date() }]);
+    }
+  }, [swarmConfig.detectedProviders]);
+  const handleSwarmOnboardingSkip = useCallback(() => {
+    setSwarmOnboardingDeferred(true);
+    setSelectionMode({ type: "none" });
+  }, []);
+  useEffect(() => {
+    if (options.isAgentPane || panel.isSplitPanelActive || messages.length > 0 || isProcessing) return;
+    if (selectionMode.type !== "none" || swarmOnboardingDeferred) return;
+    if (swarmConfig.primaryMasterProvider === void 0) setSelectionMode({ type: "swarm-onboarding" });
+  }, [isProcessing, messages.length, options.isAgentPane, panel.isSplitPanelActive, selectionMode.type, swarmConfig.primaryMasterProvider, swarmOnboardingDeferred]);
+  if (selectionMode.type === "swarm-onboarding") {
+    return /* @__PURE__ */ jsx(
+      SwarmOnboarding,
+      {
+        detectedProviders: swarmConfig.detectedProviders,
+        currentPrimaryProvider: swarmConfig.primaryMasterProvider,
+        onSelect: (provider) => void handleSwarmOnboardingSelected(provider),
+        onSkip: handleSwarmOnboardingSkip
+      }
+    );
+  }
+  if (selectionMode.type === "login") {
+    return /* @__PURE__ */ jsx(LoginSelector, { onSelect: (provider) => void handleLoginSelected(provider), onCancel: handleSelectionCancel });
+  }
+  if (selectionMode.type === "model") {
+    return /* @__PURE__ */ jsx(ModelSelector, { currentModelId: modelId, onSelect: handleModelSelected, onCancel: handleSelectionCancel, modelOrder: modelDisplayOrder ?? PROVIDER_MODEL_ORDER });
+  }
+  if (selectionMode.type === "thinking") {
+    const selectedInfo = SUPPORTED_MODELS[selectionMode.modelId];
+    return /* @__PURE__ */ jsx(ThinkingSelector, { modelId: selectionMode.modelId, modelName: selectedInfo?.name ?? selectionMode.modelId, currentValue: thinkingValue, onSelect: handleThinkingSelected, onBack: handleSelectionCancel });
+  }
+  if (panel.isSplitPanelActive) {
+    return /* @__PURE__ */ jsx(
+      SplitPane,
+      {
+        agents: panel.agents,
+        activeAgentIndex: panel.activeAgentIndex,
+        onSelectAgent: panel.selectAgent,
+        agentOutputs: panel.agentOutputs,
+        isProcessing,
+        onSubmit: handleSubmitSync,
+        onCancel: handleCancel,
+        model: modelId,
+        role: resolution.role,
+        tokenCount: totalTokens,
+        cost: totalCost,
+        gitBranch
+      }
+    );
+  }
+  return /* @__PURE__ */ jsx(
+    SinglePane,
+    {
+      messages,
+      isProcessing,
+      onSubmit: handleSubmitSync,
+      onCancel: handleCancel,
+      model: modelId,
+      role: resolution.role,
+      tokenCount: totalTokens,
+      cost: totalCost,
+      gitBranch,
+      streamingContent: streamState.content,
+      activity: streamState.activity,
+      initialHistory: persistentHistory,
+      mode: inputMode,
+      onModeChange: setInputMode
+    }
+  );
+}
+async function startChatSession(options) {
+  let config;
+  try {
+    const { ConfigStore } = await import('./config-store-NF56VHFU.js');
+    const store = new ConfigStore();
+    config = store.loadGlobal();
+  } catch {
+    config = DEFAULT_CONFIG;
+  }
+  const { waitUntilExit } = render(/* @__PURE__ */ jsx(App, { config, options }));
+  await waitUntilExit();
+}
+async function runFirstRunSetup() {
+  const { runFirstRunSetup: runCliFirstRunSetup } = await import('./first-run-ADROZVYF.js');
+  await runCliFirstRunSetup();
+}
+
+export { runFirstRunSetup, startChatSession };
+//# sourceMappingURL=App-JQ622M66.js.map
+//# sourceMappingURL=App-JQ622M66.js.map