aemeathcli 1.0.0

package/dist/App-P4MYD4QY.js

@@ -0,0 +1,2719 @@
+import { createModelRouter, CostTracker } from './chunk-DAHGLHNR.js';
+import { getEventBus } from './chunk-YL5XFHR3.js';
+import { formatCost, formatTokenCount } from './chunk-CGEV3ARR.js';
+import { DEFAULT_CONFIG } from './chunk-CYQNBB25.js';
+import './chunk-NBR3GHMT.js';
+import './chunk-CS5X3BWX.js';
+import { getThinkingConfigForModel, SUPPORTED_MODELS, PROVIDER_MODEL_ORDER } from './chunk-HCIHOHLX.js';
+import './chunk-ZGOHARPV.js';
+import './chunk-JAXXTYID.js';
+import { useRef, useState, useCallback, useEffect, useMemo } from 'react';
+import { render, useInput, Box, Text } from 'ink';
+import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
+import { randomUUID } from 'crypto';
+
+function ToolOutput({
+  toolName,
+  content,
+  isError
+}) {
+  return /* @__PURE__ */ jsxs(
+    Box,
+    {
+      flexDirection: "column",
+      borderStyle: "single",
+      borderColor: isError ? "red" : "gray",
+      paddingX: 1,
+      marginY: 1,
+      children: [
+        /* @__PURE__ */ jsxs(Text, { color: isError ? "red" : "magenta", bold: true, children: [
+          isError ? "Error" : "Tool",
+          ": ",
+          toolName
+        ] }),
+        /* @__PURE__ */ jsx(Box, { marginLeft: 2, children: /* @__PURE__ */ jsx(Text, { wrap: "wrap", ...isError ? { color: "red" } : {}, children: content.length > 2e3 ? content.slice(0, 2e3) + "\n... (truncated)" : content }) })
+      ]
+    }
+  );
+}
+function getRoleColor(role) {
+  switch (role) {
+    case "user":
+      return "green";
+    case "assistant":
+      return "cyan";
+    case "system":
+      return "yellow";
+    case "tool":
+      return "magenta";
+  }
+}
+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 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: "yellow", dimColor: true, children: [
+        icon,
+        " "
+      ] }),
+      /* @__PURE__ */ jsx(Text, { color: "yellow", 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(
+        ToolOutput,
+        {
+          toolName: firstCall.name,
+          content: message.content,
+          isError: message.content.startsWith("Error:")
+        }
+      );
+    }
+  }
+  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: "gray", dimColor: true, children: [
+        " (",
+        message.tokenUsage.totalTokens,
+        " tokens)"
+      ] }) : null
+    ] }),
+    /* @__PURE__ */ jsx(Box, { marginLeft: 2, flexDirection: "column", children: /* @__PURE__ */ jsx(ContentRenderer, { 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__ */ jsxs(Box, { children: [
+        /* @__PURE__ */ jsxs(Text, { color: "magenta", children: [
+          "\u2699",
+          " "
+        ] }),
+        /* @__PURE__ */ jsx(Text, { color: "magenta", bold: true, children: call.name }),
+        /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
+          " ",
+          argSummary
+        ] })
+      ] }, call.id);
+    }) }) : null
+  ] });
+}
+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) + "..." : cmd;
+    }
+    default:
+      return JSON.stringify(args).slice(0, 80);
+  }
+}
+function splitCodeBlocks(content) {
+  const parts = [];
+  const regex = /```(\w*)\n?([\s\S]*?)```/g;
+  let lastIndex = 0;
+  let match;
+  while ((match = regex.exec(content)) !== null) {
+    if (match.index > lastIndex) {
+      parts.push({ type: "text", content: content.slice(lastIndex, match.index), lang: "" });
+    }
+    parts.push({ type: "code", content: match[2] ?? "", lang: match[1] ?? "" });
+    lastIndex = match.index + match[0].length;
+  }
+  if (lastIndex < content.length) {
+    parts.push({ type: "text", content: content.slice(lastIndex), lang: "" });
+  }
+  return parts.length > 0 ? parts : [{ type: "text", content, lang: "" }];
+}
+function ContentRenderer({ content }) {
+  const parts = splitCodeBlocks(content);
+  if (parts.length === 1 && parts[0].type === "text") {
+    return /* @__PURE__ */ jsx(Text, { wrap: "wrap", children: content });
+  }
+  return /* @__PURE__ */ jsx(Box, { flexDirection: "column", children: parts.map((part, index) => {
+    if (part.type === "code") {
+      return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "gray", paddingX: 1, children: [
+        part.lang.length > 0 ? /* @__PURE__ */ jsx(Text, { color: "gray", dimColor: true, children: part.lang }) : null,
+        /* @__PURE__ */ jsx(Text, { children: part.content })
+      ] }, index);
+    }
+    return /* @__PURE__ */ jsx(Text, { wrap: "wrap", children: part.content }, index);
+  }) });
+}
+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: "gray", 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;
+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: "cyan",
+      paddingX: 1,
+      marginBottom: 0,
+      children: [
+        hasLess ? /* @__PURE__ */ jsxs(Text, { color: "gray", dimColor: true, children: [
+          "  ",
+          "... ",
+          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 ? "cyan" : "white", bold: isSelected, children: [
+              isSelected ? "> " : "  ",
+              item.label
+            ] }),
+            /* @__PURE__ */ jsxs(Text, { color: "gray", dimColor: true, children: [
+              "  ",
+              item.description
+            ] })
+          ] }, `${item.label}-${actualIndex}`);
+        }),
+        hasMore ? /* @__PURE__ */ jsxs(Text, { color: "gray", dimColor: true, children: [
+          "  ",
+          "... ",
+          totalItems - scrollOffset - windowSize,
+          " more"
+        ] }) : null
+      ]
+    }
+  );
+}
+
+// src/ui/autocomplete-data.ts
+var SLASH_COMMANDS = [
+  { 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: "Change split-panel layout" },
+  { command: "/auth login", description: "Log in to a provider (claude, codex, gemini, kimi)" },
+  { command: "/auth status", description: "Show login status for all providers" },
+  { command: "/auth logout", description: "Log out of a provider" },
+  { command: "/config get", description: "Get a configuration value" },
+  { command: "/config set", description: "Set a configuration value" },
+  { command: "/quit", description: "Exit" },
+  { command: "/exit", description: "Exit" }
+];
+var CONTEXT_REFS = [
+  { label: "@file", description: "Reference a file in the project" },
+  { label: "@codebase", description: "Reference the entire codebase" },
+  { label: "@anthropic", description: "Anthropic/Claude provider context" },
+  { label: "@openai", description: "OpenAI/Codex provider context" },
+  { label: "@google", description: "Google/Gemini provider context" },
+  { label: "@kimi", description: "Kimi/Moonshot provider context" },
+  { label: "@web", description: "Web search context" },
+  { label: "@git", description: "Git repository context" },
+  { label: "@docs", description: "Project documentation context" },
+  { label: "@errors", description: "Recent error context" }
+];
+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 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" }
+];
+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 "@": {
+      return CONTEXT_REFS.filter((ref) => ref.label.toLowerCase().includes(normalizedQuery));
+    }
+    case "`": {
+      return CODE_REFS.filter((ref) => ref.label.toLowerCase().includes(normalizedQuery));
+    }
+    case "$": {
+      return SKILL_REFS.filter((ref) => ref.label.toLowerCase().includes(normalizedQuery));
+    }
+  }
+}
+var TRIGGER_CHARS = /* @__PURE__ */ new Set(["/", "@", "`", "$"]);
+function detectTrigger(input) {
+  if (input.length === 0) {
+    return null;
+  }
+  if (input[0] === "/") {
+    return { trigger: "/", query: input };
+  }
+  if (input[0] === "$") {
+    return { trigger: "$", query: input };
+  }
+  for (let i = input.length - 1; i >= 0; i--) {
+    const ch = input[i];
+    if (ch === void 0) continue;
+    if (TRIGGER_CHARS.has(ch) && ch !== "/" && ch !== "$") {
+      if (i === 0 || input[i - 1] === " ") {
+        return {
+          trigger: ch,
+          query: input.slice(i)
+        };
+      }
+    }
+    if (ch === " ") {
+      break;
+    }
+  }
+  return null;
+}
+function InputBar({ onSubmit, isProcessing, placeholder, onCancel }) {
+  const [input, setInput] = useState("");
+  const [selectedIndex, setSelectedIndex] = useState(0);
+  const [history, setHistory] = useState([]);
+  const [historyIndex, setHistoryIndex] = useState(-1);
+  const [savedInput, setSavedInput] = useState("");
+  const triggerState = useMemo(() => detectTrigger(input), [input]);
+  const autocompleteItems = useMemo(() => {
+    if (triggerState === null) return [];
+    return getAutocompleteItems(triggerState.trigger, triggerState.query);
+  }, [triggerState]);
+  const isAutocompleteActive = autocompleteItems.length > 0;
+  useInput((inputChar, key) => {
+    if (isProcessing) {
+      if (key.escape && onCancel) {
+        onCancel();
+      }
+      return;
+    }
+    if (isAutocompleteActive) {
+      if (key.upArrow) {
+        setSelectedIndex((prev) => prev > 0 ? prev - 1 : autocompleteItems.length - 1);
+        return;
+      }
+      if (key.downArrow) {
+        setSelectedIndex((prev) => prev < autocompleteItems.length - 1 ? prev + 1 : 0);
+        return;
+      }
+      if (key.tab) {
+        const selected = autocompleteItems[selectedIndex];
+        if (selected && triggerState) {
+          const beforeTrigger = input.slice(0, input.length - triggerState.query.length);
+          const newInput = beforeTrigger + selected.label + " ";
+          setInput(newInput);
+          setSelectedIndex(0);
+        }
+        return;
+      }
+      if (key.escape) {
+        setInput((prev) => prev + " ");
+        setSelectedIndex(0);
+        return;
+      }
+    }
+    if (key.upArrow) {
+      if (history.length === 0) return;
+      if (historyIndex === -1) {
+        setSavedInput(input);
+      }
+      const newIndex = historyIndex === -1 ? history.length - 1 : Math.max(0, historyIndex - 1);
+      setHistoryIndex(newIndex);
+      setInput(history[newIndex] ?? "");
+      return;
+    }
+    if (key.downArrow) {
+      if (historyIndex === -1) return;
+      const newIndex = historyIndex + 1;
+      if (newIndex >= history.length) {
+        setHistoryIndex(-1);
+        setInput(savedInput);
+      } else {
+        setHistoryIndex(newIndex);
+        setInput(history[newIndex] ?? "");
+      }
+      return;
+    }
+    if (key.return) {
+      if (isAutocompleteActive && triggerState?.trigger === "/") {
+        const selected = autocompleteItems[selectedIndex];
+        if (selected) {
+          setHistory((prev) => [...prev.slice(-99), selected.label.trim()]);
+          onSubmit(selected.label.trim());
+          setInput("");
+          setSelectedIndex(0);
+          setHistoryIndex(-1);
+          return;
+        }
+      }
+      if (input.trim().length > 0) {
+        setHistory((prev) => [...prev.slice(-99), input.trim()]);
+        onSubmit(input.trim());
+        setInput("");
+        setSelectedIndex(0);
+        setHistoryIndex(-1);
+      }
+      return;
+    }
+    if (key.backspace || key.delete) {
+      setInput((prev) => prev.slice(0, -1));
+      setSelectedIndex(0);
+      setHistoryIndex(-1);
+      return;
+    }
+    if (key.ctrl && inputChar === "c") {
+      process.exit(0);
+      return;
+    }
+    if (key.ctrl && inputChar === "l") {
+      return;
+    }
+    if (!key.ctrl && !key.meta && inputChar) {
+      setInput((prev) => prev + inputChar);
+      setSelectedIndex(0);
+      setHistoryIndex(-1);
+    }
+  });
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+    isAutocompleteActive ? /* @__PURE__ */ jsx(AutocompletePopup, { items: autocompleteItems, selectedIndex }) : null,
+    /* @__PURE__ */ jsxs(Box, { borderStyle: "single", borderColor: isProcessing ? "gray" : "green", paddingX: 1, children: [
+      /* @__PURE__ */ jsxs(Text, { color: "green", bold: true, children: [
+        ">",
+        " "
+      ] }),
+      isProcessing ? /* @__PURE__ */ jsx(Text, { color: "gray", children: onCancel ? "Esc to cancel" : "Processing..." }) : input.length > 0 ? /* @__PURE__ */ jsx(Text, { children: input }) : /* @__PURE__ */ jsx(Text, { color: "gray", children: placeholder ?? "Type a message..." }),
+      !isProcessing ? /* @__PURE__ */ jsx(Text, { color: "green", children: "_" }) : null
+    ] })
+  ] });
+}
+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;
+}
+function StatusBar({
+  model,
+  role,
+  tokenCount,
+  cost,
+  gitBranch,
+  gitChanges
+}) {
+  return /* @__PURE__ */ jsxs(Box, { borderStyle: "round", borderColor: "gray", paddingX: 1, children: [
+    /* @__PURE__ */ jsxs(Text, { color: "cyan", bold: true, children: [
+      "\u2726",
+      " aemeathcli"
+    ] }),
+    /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
+      " ",
+      "\u2502",
+      " "
+    ] }),
+    /* @__PURE__ */ jsx(Text, { color: "yellow", bold: true, children: shortModelLabel(model) }),
+    role ? /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
+        " ",
+        "\u2502",
+        " "
+      ] }),
+      /* @__PURE__ */ jsx(Text, { color: "magenta", children: role })
+    ] }) : null,
+    /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
+      " ",
+      "\u2502",
+      " "
+    ] }),
+    /* @__PURE__ */ jsxs(Text, { children: [
+      tokenCount,
+      " tok"
+    ] }),
+    /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
+      " ",
+      "\u2502",
+      " "
+    ] }),
+    /* @__PURE__ */ jsx(Text, { color: "green", children: cost }),
+    gitBranch ? /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
+        " ",
+        "\u2502",
+        " "
+      ] }),
+      /* @__PURE__ */ jsxs(Text, { color: "blue", children: [
+        "\u2387",
+        " ",
+        gitBranch,
+        gitChanges !== void 0 && gitChanges > 0 ? ` \xB1${gitChanges}` : ""
+      ] })
+    ] }) : null
+  ] });
+}
+var SPINNER_FRAMES = ["\u25CB", "\u25D4", "\u25D1", "\u25D5", "\u25CF", "\u25D5", "\u25D1", "\u25D4"];
+var SPINNER_INTERVAL_MS = 300;
+function Spinner({ label }) {
+  const [frame, setFrame] = useState(0);
+  useEffect(() => {
+    const timer = setInterval(() => {
+      setFrame((prev) => (prev + 1) % SPINNER_FRAMES.length);
+    }, SPINNER_INTERVAL_MS);
+    return () => clearInterval(timer);
+  }, []);
+  return /* @__PURE__ */ jsxs(Text, { children: [
+    /* @__PURE__ */ jsx(Text, { color: "cyan", children: SPINNER_FRAMES[frame] }),
+    label ? /* @__PURE__ */ jsxs(Text, { children: [
+      " ",
+      label
+    ] }) : null
+  ] });
+}
+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
+}) {
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", height: "100%", children: [
+    /* @__PURE__ */ jsx(
+      StatusBar,
+      {
+        model,
+        role,
+        tokenCount,
+        cost,
+        gitBranch,
+        gitChanges
+      }
+    ),
+    messages.length === 0 && !isProcessing ? /* @__PURE__ */ jsxs(Box, { flexDirection: "column", flexGrow: 1, paddingX: 2, justifyContent: "center", children: [
+      /* @__PURE__ */ jsxs(Text, { color: "cyan", bold: true, children: [
+        "\u2726",
+        " AemeathCLI"
+      ] }),
+      /* @__PURE__ */ jsx(Text, { color: "gray", children: "Multi-model AI coding assistant" }),
+      /* @__PURE__ */ jsx(Text, { children: " " }),
+      /* @__PURE__ */ jsx(Text, { color: "gray", children: "Type a message to start, or use /help for commands." }),
+      /* @__PURE__ */ jsx(Text, { color: "gray", children: "Press Tab for autocomplete on /commands, @context, and $skills." })
+    ] }) : /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx(MessageView, { messages }),
+      isProcessing ? /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginLeft: 1, marginBottom: 1, children: [
+        /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsxs(Text, { color: "cyan", bold: true, children: [
+          "\u2726",
+          " ",
+          shortModelName2(model)
+        ] }) }),
+        /* @__PURE__ */ jsx(Box, { marginLeft: 2, marginBottom: 1, children: /* @__PURE__ */ jsx(Text, { wrap: "wrap", children: streamingContent && streamingContent.length > 0 ? tailLines(streamingContent, 12) : "" }) }),
+        /* @__PURE__ */ jsx(Box, { marginLeft: 1, children: /* @__PURE__ */ jsx(
+          Spinner,
+          {
+            label: activity ? activity : streamingContent && streamingContent.length > 0 ? "Streaming response..." : "Thinking..."
+          }
+        ) })
+      ] }) : null
+    ] }),
+    /* @__PURE__ */ jsx(InputBar, { onSubmit, isProcessing, onCancel })
+  ] });
+}
+function getStatusColor(status) {
+  switch (status) {
+    case "active":
+      return "green";
+    case "idle":
+      return "yellow";
+    case "error":
+      return "red";
+    case "shutdown":
+      return "gray";
+    default:
+      return "white";
+  }
+}
+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";
+  }
+}
+var MAX_OUTPUT_LINES = 40;
+function classifyLine(line) {
+  if (line.length === 0) return "empty";
+  if (line.startsWith("\u2699") || line.startsWith("\u2699")) return "tool";
+  if (line.startsWith("  \u2192") || line.startsWith("  \u2192")) return "result";
+  if (line.startsWith("Error:") || line.startsWith("Stream error:")) return "error";
+  return "text";
+}
+function extractLastActivity(output) {
+  const lines = output.split("\n");
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const line = lines[i].trim();
+    if (line.length === 0) continue;
+    const type = classifyLine(line);
+    if (type === "tool") return line;
+    if (type === "result") return line;
+  }
+  return void 0;
+}
+function AgentOutput({
+  output,
+  isActive
+}) {
+  const lines = output.split("\n");
+  const truncated = lines.length > MAX_OUTPUT_LINES;
+  const visible = truncated ? lines.slice(-MAX_OUTPUT_LINES) : lines;
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+    truncated ? /* @__PURE__ */ jsxs(Text, { color: "gray", dimColor: true, children: [
+      "  (",
+      lines.length - MAX_OUTPUT_LINES,
+      " lines hidden)"
+    ] }) : null,
+    visible.map((line, i) => {
+      const type = classifyLine(line);
+      switch (type) {
+        case "tool":
+          return /* @__PURE__ */ jsx(Text, { color: "magenta", children: line }, i);
+        case "result":
+          return /* @__PURE__ */ jsx(Text, { color: "gray", children: line }, i);
+        case "error":
+          return /* @__PURE__ */ jsx(Text, { color: "red", bold: true, children: line }, i);
+        case "empty":
+          return /* @__PURE__ */ jsx(Text, { children: " " }, i);
+        default:
+          return /* @__PURE__ */ jsx(Text, { wrap: "wrap", children: line }, i);
+      }
+    }),
+    isActive ? /* @__PURE__ */ jsx(Box, { marginTop: 0, children: /* @__PURE__ */ jsx(Spinner, { label: "Working..." }) }) : null
+  ] });
+}
+function SplitPanel({
+  agents,
+  activeAgentIndex,
+  onSelectAgent,
+  agentOutputs
+}) {
+  useInput((input, key) => {
+    if (key.tab) {
+      const nextIndex = (activeAgentIndex + 1) % agents.length;
+      onSelectAgent(nextIndex);
+    }
+    const numKey = parseInt(input, 10);
+    if (!isNaN(numKey) && numKey >= 1 && numKey <= agents.length && key.ctrl) {
+      onSelectAgent(numKey - 1);
+    }
+  });
+  const activeAgent = agents[activeAgentIndex];
+  const activeOutput = activeAgent ? agentOutputs.get(activeAgent.config.agentId) ?? "" : "";
+  const lastActivity = activeOutput.length > 0 ? extractLastActivity(activeOutput) : void 0;
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", flexGrow: 1, children: [
+    /* @__PURE__ */ jsx(Box, { children: agents.map((agent, index) => {
+      const isActive = index === activeAgentIndex;
+      const sColor = getStatusColor(agent.status);
+      const indicator = statusIndicator(agent.status);
+      const modelShort = shortModelLabel2(agent.config.model);
+      const typeLabel = agent.config.agentType.charAt(0).toUpperCase() + agent.config.agentType.slice(1);
+      return /* @__PURE__ */ jsxs(
+        Box,
+        {
+          borderStyle: isActive ? "bold" : "single",
+          borderColor: isActive ? "cyan" : "gray",
+          paddingX: 1,
+          children: [
+            /* @__PURE__ */ jsxs(Text, { color: sColor, children: [
+              indicator,
+              " "
+            ] }),
+            /* @__PURE__ */ jsx(Text, { bold: isActive, children: typeLabel }),
+            /* @__PURE__ */ jsxs(Text, { color: "gray", dimColor: true, children: [
+              " ",
+              modelShort
+            ] })
+          ]
+        },
+        agent.config.agentId
+      );
+    }) }),
+    /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsxs(Text, { color: "gray", dimColor: true, children: [
+      "  Tab: switch agent | Ctrl+1-",
+      agents.length,
+      ": jump | /team stop: exit"
+    ] }) }),
+    /* @__PURE__ */ jsx(Box, { flexDirection: "column", flexGrow: 1, paddingX: 1, marginTop: 1, borderStyle: "round", borderColor: "gray", children: activeAgent ? /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsxs(Box, { children: [
+        /* @__PURE__ */ jsxs(Text, { color: "cyan", bold: true, children: [
+          "\u2726",
+          " ",
+          activeAgent.config.name
+        ] }),
+        /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
+          " ",
+          "\u2014",
+          " ",
+          activeAgent.config.role,
+          " "
+        ] }),
+        /* @__PURE__ */ jsxs(Text, { color: getStatusColor(activeAgent.status), children: [
+          "[",
+          activeAgent.status,
+          "]"
+        ] })
+      ] }),
+      lastActivity ? /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsxs(Text, { color: "gray", dimColor: true, children: [
+        "  ",
+        lastActivity.length > 80 ? lastActivity.slice(0, 80) + "..." : lastActivity
+      ] }) }) : null,
+      /* @__PURE__ */ jsx(Box, { borderStyle: "single", borderColor: "gray", borderTop: true, borderBottom: false, borderLeft: false, borderRight: false, marginY: 0 }),
+      activeOutput.length > 0 ? /* @__PURE__ */ jsx(Box, { flexDirection: "column", marginTop: 0, children: /* @__PURE__ */ jsx(AgentOutput, { output: activeOutput, isActive: activeAgent.status === "active" }) }) : activeAgent.status === "active" ? /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsx(Spinner, { label: "Initializing agent..." }) }) : /* @__PURE__ */ jsxs(Text, { color: "yellow", children: [
+        "\u231B",
+        " Waiting for task..."
+      ] })
+    ] }) : /* @__PURE__ */ jsx(Text, { color: "gray", children: "No agents active" }) })
+  ] });
+}
+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) + "..." : pat}"`;
+    }
+    case "bash": {
+      const cmd = typeof args["command"] === "string" ? args["command"] : "";
+      const short = cmd.length > 40 ? cmd.slice(0, 40) + "..." : 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
+  });
+  const cancelRef = useRef(false);
+  const startStream = useCallback(async (stream) => {
+    cancelRef.current = false;
+    setState({
+      isStreaming: true,
+      content: "",
+      usage: void 0,
+      error: void 0,
+      activity: void 0
+    });
+    try {
+      for await (const chunk of stream) {
+        if (cancelRef.current) {
+          break;
+        }
+        switch (chunk.type) {
+          case "text":
+            if (chunk.content) {
+              setState((prev) => ({
+                ...prev,
+                content: prev.content + chunk.content,
+                // Clear activity once we get text back (model is responding)
+                activity: void 0
+              }));
+            }
+            break;
+          case "tool_call":
+            if (chunk.toolCall) {
+              setState((prev) => ({
+                ...prev,
+                activity: formatToolActivity(chunk.toolCall)
+              }));
+            }
+            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
+            }));
+            return;
+          case "done":
+            setState((prev) => ({
+              ...prev,
+              isStreaming: false,
+              usage: chunk.usage ?? prev.usage,
+              activity: void 0
+            }));
+            return;
+        }
+      }
+      setState((prev) => ({ ...prev, isStreaming: false, activity: void 0 }));
+    } 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 }));
+  }, []);
+  const reset = useCallback(() => {
+    cancelRef.current = true;
+    setState({
+      isStreaming: false,
+      content: "",
+      usage: void 0,
+      error: void 0,
+      activity: 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 [agents, setAgentsState] = useState([]);
+  const [activeAgentIndex, setActiveAgentIndex] = useState(0);
+  const [agentOutputs, setAgentOutputs] = useState(/* @__PURE__ */ new Map());
+  const [isSplitPanelActive, setIsSplitPanelActive] = useState(false);
+  const selectAgent = useCallback((index) => {
+    setActiveAgentIndex(index);
+  }, []);
+  const appendOutput = useCallback((agentId, content) => {
+    setAgentOutputs((prev) => {
+      const next = new Map(prev);
+      const existing = next.get(agentId) ?? "";
+      next.set(agentId, existing + content);
+      return next;
+    });
+  }, []);
+  const updateAgentStatus = useCallback((agentId, status) => {
+    setAgentsState(
+      (prev) => prev.map(
+        (agent) => agent.config.agentId === agentId ? { ...agent, status } : agent
+      )
+    );
+  }, []);
+  const setAgents = useCallback((newAgents) => {
+    setAgentsState(newAgents);
+  }, []);
+  const activate = useCallback(() => {
+    setIsSplitPanelActive(true);
+  }, []);
+  const deactivate = useCallback(() => {
+    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: "Claude (Anthropic)",
+  openai: "Codex (OpenAI)",
+  google: "Gemini (Google)",
+  kimi: "Kimi (Moonshot)"
+};
+function ModelSelector({ currentModelId, onSelect, onCancel }) {
+  const rows = useMemo(() => {
+    const result = [];
+    for (const [providerKey, entries] of Object.entries(PROVIDER_MODEL_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: "cyan", children: "Select Model" }),
+      /* @__PURE__ */ jsx(Text, { color: "gray", children: "  (up/down navigate, Enter select, 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: "yellow", children: [
+          "  [",
+          row.label,
+          "]"
+        ] }) }, `header-${idx}`);
+      }
+      const isHighlighted = selectableIndices[cursor] === idx;
+      const currentTag = row.isCurrent ? " (current)" : "";
+      return /* @__PURE__ */ jsxs(Box, { children: [
+        /* @__PURE__ */ jsxs(Text, { ...isHighlighted ? { color: "green" } : {}, bold: isHighlighted, children: [
+          isHighlighted ? "> " : "  ",
+          (row.label ?? "").padEnd(30)
+        ] }),
+        /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
+          " ",
+          row.description,
+          currentTag
+        ] })
+      ] }, row.modelId ?? `row-${idx}`);
+    }),
+    /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsxs(Text, { color: "gray", 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);
+    })
+  ] });
+}
+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 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 registryRef = useRef(void 0);
+  const getRegistry = useCallback(async () => {
+    if (registryRef.current !== void 0) return registryRef.current;
+    const { createDefaultRegistry } = await import('./registry-4KD24ZC3.js');
+    registryRef.current = await createDefaultRegistry();
+    return registryRef.current;
+  }, []);
+  useEffect(() => {
+    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.initialMessage) {
+      void handleSubmit(options.initialMessage);
+    }
+  }, []);
+  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
+        });
+        return;
+      }
+      if (input.startsWith("$")) {
+        await handleSkillInvocation(input, setMessages);
+        return;
+      }
+      if (!options.isAgentPane && !panel.isSplitPanelActive && !activeTeamName && detectTeamCreationIntent(input)) {
+        const leaderTask = await handlePromptBasedTeamCreation(input, setMessages, panel, getRegistry, modelId);
+        if (leaderTask) {
+          setTimeout(() => void handleSubmit(leaderTask), 1500);
+        }
+        return;
+      }
+      const userMessage = {
+        id: v4Id(),
+        role: "user",
+        content: input,
+        createdAt: /* @__PURE__ */ new Date()
+      };
+      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 provider = registry.hasModel(candidateModel) ? registry.getForModel(candidateModel) : void 0;
+          if (!provider) {
+            lastError = new Error(`No provider available for model "${candidateModel}"`);
+            continue;
+          }
+          const candidateProvider = provider;
+          let candidateContent = "";
+          let caughtError;
+          const stream = candidateProvider.stream({
+            model: candidateModel,
+            messages: allMessages,
+            system: options.systemPrompt,
+            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) {
+          if (lastError instanceof Error) {
+            throw lastError;
+          }
+          throw 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;
+          });
+        }
+      } catch (error) {
+        const errorContent = error instanceof Error ? error.message : String(error);
+        const errorMessage = {
+          id: v4Id(),
+          role: "assistant",
+          content: `Error: ${errorContent}`,
+          model: modelId,
+          createdAt: /* @__PURE__ */ new Date()
+        };
+        setMessages((prev) => [...prev, errorMessage]);
+      } finally {
+        setIsProcessing(false);
+      }
+    },
+    [
+      config,
+      modelId,
+      resolution,
+      options.systemPrompt,
+      record,
+      switchModel,
+      switchRole,
+      startStream,
+      resetStream,
+      getRegistry,
+      panel,
+      thinkingValue
+    ]
+  );
+  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" });
+  }, []);
+  if (selectionMode.type === "model") {
+    return /* @__PURE__ */ jsx(
+      ModelSelector,
+      {
+        currentModelId: modelId,
+        onSelect: handleModelSelected,
+        onCancel: handleSelectionCancel
+      }
+    );
+  }
+  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
+    }
+  );
+}
+function addSystemMessage(ctx, content) {
+  ctx.setMessages((prev) => [
+    ...prev,
+    {
+      id: v4Id(),
+      role: "system",
+      content,
+      createdAt: /* @__PURE__ */ new Date()
+    }
+  ]);
+}
+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";
+  }
+}
+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":
+      addSystemMessage(ctx, "Context compacted.");
+      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, "Usage: /panel <layout>\nLayouts: auto, horizontal, vertical, grid");
+      } else {
+        addSystemMessage(ctx, `Panel layout set to: ${layout}`);
+      }
+      break;
+    }
+    case "/auth":
+      await handleAuthSlashCommand(args, ctx);
+      break;
+    case "/config":
+      await handleConfigSlashCommand(args, ctx);
+      break;
+    case "/quit":
+    case "/exit":
+      process.exit(0);
+      break;
+    default:
+      addSystemMessage(ctx, `Unknown command: ${command}. Type /help for available commands.`);
+  }
+}
+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.`;
+}
+var TEAM_CREATION_PATTERNS = [
+  /\bcreate\s+(?:a\s+)?team\b/i,
+  /\bstart\s+(?:a\s+)?team\b/i,
+  /\bspawn\s+(?:a\s+)?(?:team|agents?)\b/i,
+  /\buse\s+(?:a\s+)?team\b/i,
+  /\bassemble\s+(?:a\s+)?team\b/i,
+  /\blaunch\s+(?:a\s+)?team\b/i,
+  /\bneed\s+(?:a\s+)?team\b/i,
+  /\bwork\s+(?:as|with)\s+(?:a\s+)?team\b/i,
+  /\bmulti[- ]?agent\b/i,
+  /\bagent\s+team\b/i
+];
+function detectTeamCreationIntent(input) {
+  return TEAM_CREATION_PATTERNS.some((pattern) => pattern.test(input));
+}
+var activeTeamManager;
+var activeTeamName;
+var activeTmuxCleanup;
+var PROVIDER_CLI_MAP = {
+  anthropic: { bin: "claude", modelFlag: true, extraArgs: ["--dangerously-skip-permissions"] },
+  openai: { bin: "codex", modelFlag: true, extraArgs: ["--sandbox", "danger-full-access", "--ask-for-approval", "never"] },
+  google: { bin: "gemini", modelFlag: true, extraArgs: ["--yolo"] },
+  kimi: { bin: "kimi", modelFlag: false, extraArgs: ["--yolo"] }
+};
+function writeAgentLauncherScript(provider, model, promptFile, launcherFile, projectRoot, shellEscapeFn, writeFileSyncFn) {
+  const cliInfo = PROVIDER_CLI_MAP[provider];
+  if (cliInfo) {
+    const modelArg = cliInfo.modelFlag ? ` --model ${model}` : "";
+    const extraArgs = cliInfo.extraArgs.length > 0 ? ` ${cliInfo.extraArgs.join(" ")}` : "";
+    const script2 = [
+      "#!/bin/bash",
+      `cd '${shellEscapeFn(projectRoot)}' || exit 1`,
+      `${cliInfo.bin}${extraArgs}${modelArg} "$(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)}'`;
+}
+async function handlePromptBasedTeamCreation(input, setMessages, panel, getRegistry, currentModelId) {
+  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 availableModels = Object.keys(SUPPORTED_MODELS).filter(
+      (id) => registry.hasModel(id)
+    );
+    if (availableModels.length === 0) {
+      setMessages((prev) => [
+        ...prev,
+        {
+          id: v4Id(),
+          role: "system",
+          content: "No models available. Please authenticate with at least one provider using 'aemeathcli auth login'.",
+          createdAt: /* @__PURE__ */ new Date()
+        }
+      ]);
+      return;
+    }
+    const designModel = registry.hasModel(currentModelId) ? currentModelId : availableModels[0];
+    const designProvider = registry.getForModel(designModel);
+    const userPrompt = buildTeamDesignUserPrompt(input, availableModels);
+    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 = "";
+    for await (const chunk of designStream) {
+      if (chunk.type === "text" && chunk.content) {
+        designResponse += chunk.content;
+      }
+    }
+    const agentSpecs = parseLLMTeamDesign(
+      designResponse,
+      availableModels,
+      designModel
+    );
+    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 { writeFileSync, mkdirSync, mkdtempSync } = await import('fs');
+    const { join } = await import('path');
+    const { tmpdir } = await import('os');
+    const { execa: execaPane } = await import('execa');
+    const boardDir = join(process.cwd(), ".aemeathcli", "team-board");
+    mkdirSync(boardDir, { recursive: true });
+    const tempDir = mkdtempSync(join(tmpdir(), "aemeathcli-team-"));
+    const shellEscape = (s) => s.replace(/'/gu, "'\\''");
+    const leadSpec = agentSpecs.find((s) => s.agentType === "lead") ?? agentSpecs.find((s) => s.role === "planning") ?? agentSpecs[0];
+    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: join(boardDir, `${s.name}.md`)
+      })),
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    writeFileSync(
+      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 workerSpecs = agentSpecs.filter((s) => s.name !== leadSpec.name);
+    const projectRoot = process.cwd();
+    const agentCommands = [];
+    for (const spec of [...workerSpecs]) {
+      const outputFile = join(boardDir, `${spec.name}.md`);
+      const promptFile = 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: ${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: ${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");
+      writeFileSync(promptFile, prompt, "utf-8");
+      const modelInfo = SUPPORTED_MODELS[spec.model];
+      const provider = modelInfo?.provider ?? "anthropic";
+      const launcherFile = join(tempDir, `${spec.name}-launch.sh`);
+      const cmd = writeAgentLauncherScript(
+        provider,
+        spec.model,
+        promptFile,
+        launcherFile,
+        projectRoot,
+        shellEscape,
+        writeFileSync
+      );
+      agentCommands.push({ name: spec.name, command: cmd });
+    }
+    const leadOutputFile = 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: ${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: ${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 ${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 ${join(boardDir, "coordinator.md")}.`
+    ].join("\n");
+    const isITerm2 = process.platform === "darwin" && process.env["TERM_PROGRAM"] === "iTerm.app";
+    if (isITerm2) {
+      setMessages((prev) => [
+        ...prev,
+        {
+          id: v4Id(),
+          role: "system",
+          content: `Designed ${agentSpecs.length}-agent team. Creating iTerm2 split panes...`,
+          createdAt: /* @__PURE__ */ new Date()
+        }
+      ]);
+      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 (let i = 0; i < agentCommands.length; i++) {
+        const agent = agentCommands[i];
+        const prevVar = i === 0 ? "leaderSession" : `agent${i - 1}`;
+        const curVar = `agent${i}`;
+        const splitDir = i === 0 ? "vertically" : "horizontally";
+        const splitTarget = prevVar;
+        const escapedName = asEscape(agent.name);
+        const escapedCmd = asEscape(agent.command);
+        scriptLines.push(`    tell ${splitTarget}`);
+        scriptLines.push(`      set ${curVar} to (split ${splitDir} with default profile)`);
+        scriptLines.push("    end tell");
+        scriptLines.push(`    tell ${curVar}`);
+        scriptLines.push(`      set name to "${escapedName}"`);
+        scriptLines.push(`      write text "${escapedCmd}"`);
+        scriptLines.push("    end tell");
+      }
+      scriptLines.push("    select leaderSession");
+      scriptLines.push("  end tell");
+      scriptLines.push("end tell");
+      const script = scriptLines.join("\n");
+      const scriptFile = join(tempDir, "create-panes.applescript");
+      writeFileSync(scriptFile, script, "utf-8");
+      try {
+        await execaPane("osascript", [scriptFile]);
+      } catch (scriptErr) {
+        const errMsg = scriptErr instanceof Error ? scriptErr.message : String(scriptErr);
+        setMessages((prev) => [
+          ...prev,
+          {
+            id: v4Id(),
+            role: "system",
+            content: `Failed to create iTerm2 panes: ${errMsg.slice(0, 200)}`,
+            createdAt: /* @__PURE__ */ new Date()
+          }
+        ]);
+        return;
+      }
+      activeTeamName = teamName;
+      activeTeamManager = void 0;
+      activeTmuxCleanup = async () => {
+        try {
+          const { execSync } = await import('child_process');
+          execSync(`pkill -f '${shellEscape(tempDir)}'`, { stdio: "ignore" });
+        } catch {
+        }
+        try {
+          const { rmSync } = await import('fs');
+          rmSync(tempDir, { recursive: true, force: true });
+          rmSync(boardDir, { recursive: true, force: true });
+        } catch {
+        }
+      };
+      const agentLines2 = agentSpecs.map(
+        (spec) => spec.name === leadSpec.name ? `  ${spec.name} (${spec.model}) \u2014 ${spec.role} [LEAD \u2014 this pane]` : `  ${spec.name} (${spec.model}) \u2014 ${spec.role}`
+      );
+      setMessages((prev) => [
+        ...prev,
+        {
+          id: v4Id(),
+          role: "system",
+          content: `Team "${teamName}" \u2014 ${agentSpecs.length} agents active.
+${workerSpecs.length} worker panes in iTerm2 + lead coordinating here.
+${agentLines2.join("\n")}
+/team stop to shut down all agents.`,
+          createdAt: /* @__PURE__ */ new Date()
+        }
+      ]);
+      return leadCoordinationTask;
+    }
+    const { TmuxManager } = await import('./tmux-manager-GPYZ3WQH.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) {
+        setMessages((prev) => [
+          ...prev,
+          {
+            id: v4Id(),
+            role: "system",
+            content: `Designed ${agentSpecs.length}-agent team. Creating tmux split panes...`,
+            createdAt: /* @__PURE__ */ new Date()
+          }
+        ]);
+        const currentResult = await execaPane("tmux", [
+          "display-message",
+          "-p",
+          "#{pane_id}"
+        ]);
+        const leaderPaneId = currentResult.stdout.trim();
+        const agentPaneIds = [];
+        for (let i = 0; i < agentCommands.length; i++) {
+          const agent = agentCommands[i];
+          const splitResult = await execaPane("tmux", [
+            "split-window",
+            i % 2 === 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"]);
+        }
+        try {
+          await execaPane("tmux", ["select-layout", "tiled"]);
+        } catch {
+        }
+        try {
+          await execaPane("tmux", ["select-pane", "-t", leaderPaneId]);
+        } catch {
+        }
+        activeTeamName = teamName;
+        activeTeamManager = void 0;
+        activeTmuxCleanup = async () => {
+          const { execa: ex } = await import('execa');
+          for (const pid of agentPaneIds) {
+            try {
+              await ex("tmux", ["kill-pane", "-t", pid]);
+            } catch {
+            }
+          }
+          try {
+            const { rmSync } = await import('fs');
+            rmSync(tempDir, { recursive: true, force: true });
+            rmSync(boardDir, { recursive: true, force: true });
+          } catch {
+          }
+        };
+        const agentLines3 = agentSpecs.map(
+          (spec) => spec.name === leadSpec.name ? `  ${spec.name} (${spec.model}) \u2014 ${spec.role} [LEAD \u2014 this pane]` : `  ${spec.name} (${spec.model}) \u2014 ${spec.role}`
+        );
+        setMessages((prev) => [
+          ...prev,
+          {
+            id: v4Id(),
+            role: "system",
+            content: `Team "${teamName}" \u2014 ${agentSpecs.length} agents active.
+${workerSpecs.length} worker panes in tmux + lead coordinating here.
+${agentLines3.join("\n")}
+/team stop to shut down all agents.`,
+            createdAt: /* @__PURE__ */ new Date()
+          }
+        ]);
+        return leadCoordinationTask;
+      }
+      setMessages((prev) => [
+        ...prev,
+        {
+          id: v4Id(),
+          role: "system",
+          content: `Designed ${agentSpecs.length}-agent team. Opening tmux split-panel view...`,
+          createdAt: /* @__PURE__ */ new Date()
+        }
+      ]);
+      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: "auto",
+        panes: paneConfigs,
+        maxPanes: paneConfigs.length
+      };
+      await tmux.createPanes(layoutConfig);
+      for (let i = 0; i < agentCommands.length; i++) {
+        const agent = agentCommands[i];
+        const paneId = `pane-${i}`;
+        await tmux.sendCommand(paneId, agent.command);
+      }
+      activeTeamName = teamName;
+      activeTeamManager = void 0;
+      activeTmuxCleanup = async () => {
+        await tmux.destroy();
+        try {
+          const { rmSync } = await import('fs');
+          rmSync(tempDir, { recursive: true, force: true });
+          rmSync(boardDir, { recursive: true, force: true });
+        } catch {
+        }
+      };
+      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 agentLines2 = agentSpecs.map(
+        (spec) => spec.name === leadSpec.name ? `  ${spec.name} (${spec.model}) \u2014 ${spec.role} [LEAD]` : `  ${spec.name} (${spec.model}) \u2014 ${spec.role}`
+      );
+      setMessages((prev) => [
+        ...prev,
+        {
+          id: v4Id(),
+          role: "system",
+          content: `Detached from tmux. Agents may still be running.
+${agentLines2.join("\n")}
+Re-attach: tmux attach -t ${sessionName}
+/team stop to shut down all agents.`,
+          createdAt: /* @__PURE__ */ new Date()
+        }
+      ]);
+      return leadCoordinationTask;
+    }
+    setMessages((prev) => [
+      ...prev,
+      {
+        id: v4Id(),
+        role: "system",
+        content: `Designed ${agentSpecs.length}-agent team. Starting agents (in-process mode)...`,
+        createdAt: /* @__PURE__ */ new Date()
+      }
+    ]);
+    const { TeamManager: TM } = await import('./team-manager-HC4XGCFY.js');
+    const manager = new TM();
+    activeTeamManager = manager;
+    activeTeamName = teamName;
+    activeTmuxCleanup = void 0;
+    const teamConfig = await manager.createTeam(teamName, {
+      description: `Agent team for: ${input.slice(0, 120)}`,
+      agents: agentDefinitions
+    });
+    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})...
+`
+      );
+    }
+    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);
+          }
+        }
+      }
+    });
+    await manager.startAgents(teamName);
+    for (let i = 0; i < teamConfig.members.length; i++) {
+      const member = teamConfig.members[i];
+      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}`
+    );
+    setMessages((prev) => [
+      ...prev,
+      {
+        id: v4Id(),
+        role: "system",
+        content: `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.`,
+        createdAt: /* @__PURE__ */ new Date()
+      }
+    ]);
+    return void 0;
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    setMessages((prev) => [
+      ...prev,
+      {
+        id: v4Id(),
+        role: "system",
+        content: `Failed to create team: ${msg}`,
+        createdAt: /* @__PURE__ */ new Date()
+      }
+    ]);
+    return void 0;
+  }
+}
+async function handleTeamCommand(args, ctx) {
+  const subcommand = args[0];
+  if (subcommand === "stop") {
+    if (activeTmuxCleanup) {
+      try {
+        await activeTmuxCleanup();
+      } catch {
+      }
+      activeTmuxCleanup = void 0;
+    }
+    if (activeTeamManager && activeTeamName) {
+      try {
+        await activeTeamManager.deleteTeam(activeTeamName);
+      } catch {
+      }
+      activeTeamManager = void 0;
+    }
+    activeTeamName = 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-HC4XGCFY.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"'
+  );
+}
+async function handleMcpCommand(args, ctx) {
+  const subcommand = args[0];
+  if (subcommand === "list") {
+    try {
+      const { MCPServerManager } = await import('./server-manager-PTGBHCLS.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>");
+      return;
+    }
+    addSystemMessage(ctx, `To add MCP server "${name}", edit ~/.aemeathcli/mcp.json with the server configuration.`);
+    return;
+  }
+  addSystemMessage(ctx, "Usage: /mcp list | /mcp add <name>");
+}
+async function handleSkillCommand(args, ctx) {
+  const subcommand = args[0];
+  if (subcommand === "list") {
+    try {
+      const { SkillRegistry } = await import('./registry-H7B3AHPQ.js');
+      const registry = new SkillRegistry();
+      await registry.initialize();
+      const skills = registry.listAll();
+      if (skills.length === 0) {
+        addSystemMessage(ctx, "No skills found.\nAdd skills in ~/.aemeathcli/skills/ or .aemeathcli/skills/");
+      } else {
+        const lines = skills.map((s) => `  $${s.name.padEnd(16)} ${s.description}`);
+        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 handleAuthSlashCommand(args, ctx) {
+  const subcommand = args[0];
+  if (subcommand === "status") {
+    try {
+      const providers = ["claude", "codex", "gemini", "kimi"];
+      const lines = [];
+      for (const provider of providers) {
+        try {
+          const loginMod = await loadLoginModuleForSlash(provider);
+          const status = await loginMod.getStatus();
+          if (status.loggedIn) {
+            lines.push(`  \u2713 ${provider} \u2014 Logged in as ${status.email ?? "unknown"} (${status.plan ?? "unknown plan"})`);
+          } else {
+            lines.push(`  \u2717 ${provider} \u2014 Not logged in`);
+          }
+        } catch {
+          lines.push(`  \u2717 ${provider} \u2014 Not configured`);
+        }
+      }
+      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 === "login") {
+    const provider = args[1];
+    if (!provider) {
+      addSystemMessage(ctx, "Usage: /auth login <provider>\nProviders: claude, codex, gemini, kimi");
+      return;
+    }
+    addSystemMessage(ctx, `Use the CLI command: aemeathcli auth login ${provider}`);
+    return;
+  }
+  if (subcommand === "logout") {
+    const provider = args[1];
+    if (!provider) {
+      addSystemMessage(ctx, "Usage: /auth logout <provider>\nProviders: claude, codex, gemini, kimi");
+      return;
+    }
+    addSystemMessage(ctx, `Use the CLI command: aemeathcli auth logout ${provider}`);
+    return;
+  }
+  addSystemMessage(ctx, "Usage: /auth status | /auth login <provider> | /auth logout <provider>");
+}
+async function loadLoginModuleForSlash(provider) {
+  switch (provider) {
+    case "claude": {
+      const mod = await import('./claude-login-5WELXPKT.js');
+      return new mod.ClaudeLogin();
+    }
+    case "codex": {
+      const mod = await import('./codex-login-7HHLJHBF.js');
+      return new mod.CodexLogin();
+    }
+    case "gemini": {
+      const mod = await import('./gemini-login-ZZLYC3J6.js');
+      return new mod.GeminiLogin();
+    }
+    case "kimi": {
+      const mod = await import('./kimi-login-CZPS63NK.js');
+      return new mod.KimiLogin();
+    }
+    default:
+      throw new Error(`Unknown provider: ${provider}`);
+  }
+}
+async function handleConfigSlashCommand(args, ctx) {
+  const subcommand = args[0];
+  if (subcommand === "get") {
+    const key = args[1];
+    try {
+      const { ConfigStore } = await import('./config-store-W6FBCQAQ.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-W6FBCQAQ.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;
+}
+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-H7B3AHPQ.js');
+    const { SkillExecutor } = await import('./executor-6RIKIGXK.js');
+    const registry = new SkillRegistry();
+    await registry.initialize();
+    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() }
+    ]);
+  }
+}
+async function startChatSession(options) {
+  let config;
+  try {
+    const { ConfigStore } = await import('./config-store-W6FBCQAQ.js');
+    const store = new ConfigStore();
+    config = store.loadGlobal();
+  } catch {
+    config = DEFAULT_CONFIG;
+  }
+  const { waitUntilExit } = render(/* @__PURE__ */ jsx(App, { config, options }));
+  await waitUntilExit();
+}
+async function createFirstRunLogin(provider) {
+  switch (provider) {
+    case "claude": {
+      const { ClaudeLogin } = await import('./claude-login-5WELXPKT.js');
+      return new ClaudeLogin();
+    }
+    case "codex": {
+      const { CodexLogin } = await import('./codex-login-7HHLJHBF.js');
+      return new CodexLogin();
+    }
+    case "gemini": {
+      const { GeminiLogin } = await import('./gemini-login-ZZLYC3J6.js');
+      return new GeminiLogin();
+    }
+    case "kimi": {
+      const { KimiLogin } = await import('./kimi-login-CZPS63NK.js');
+      return new KimiLogin();
+    }
+  }
+}
+async function runFirstRunSetup() {
+  const { confirm } = await import('@inquirer/prompts');
+  const pc = await import('picocolors');
+  process.stdout.write(
+    [
+      "",
+      pc.default.cyan("  \u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557"),
+      pc.default.cyan("  \u2551           Welcome to AemeathCLI              \u2551"),
+      pc.default.cyan("  \u2551    Multi-Model CLI Coding Tool v1.0.0        \u2551"),
+      pc.default.cyan("  \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D"),
+      "",
+      "  Let's get you set up:",
+      ""
+    ].join("\n")
+  );
+  const providers = ["claude", "codex", "gemini", "kimi"];
+  for (const provider of providers) {
+    const shouldLogin = await confirm({
+      message: `Log in to ${provider}?`,
+      default: provider !== "kimi"
+    });
+    if (shouldLogin) {
+      process.stdout.write(pc.default.cyan(`  Logging in to ${provider}...
+`));
+      try {
+        const login = await createFirstRunLogin(provider);
+        await login.login();
+        process.stdout.write(pc.default.green(`  \u2713 ${provider} - Logged in successfully
+`));
+      } catch {
+        process.stdout.write(pc.default.red(`  \u2717 ${provider} - Login failed (you can retry later)
+`));
+      }
+    }
+  }
+  process.stdout.write(pc.default.green("\n  \u2713 Configuration saved. Ready!\n\n"));
+}
+
+export { runFirstRunSetup, startChatSession };
+//# sourceMappingURL=App-P4MYD4QY.js.map
+//# sourceMappingURL=App-P4MYD4QY.js.map