llm-party-cli 0.7.1 → 0.10.1

package/dist/index.js

@@ -3284,7 +3284,7 @@ var require_main = __commonJS((exports) => {
 });
 
 // src/index.ts
-import { readFile as readFile5 } from "fs/promises";
+import { readFile as readFile6 } from "fs/promises";
 import path11 from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 
@@ -36264,43 +36264,6 @@ function Show(props) {
     return props.fallback;
   }, undefined, undefined);
 }
-function Switch(props) {
-  const chs = children(() => props.children);
-  const switchFunc = createMemo(() => {
-    const ch = chs();
-    const mps = Array.isArray(ch) ? ch : [ch];
-    let func = () => {
-      return;
-    };
-    for (let i = 0;i < mps.length; i++) {
-      const index = i;
-      const mp = mps[i];
-      const prevFunc = func;
-      const conditionValue = createMemo(() => prevFunc() ? undefined : mp.when, undefined, undefined);
-      const condition = mp.keyed ? conditionValue : createMemo(conditionValue, undefined, {
-        equals: (a, b2) => !a === !b2
-      });
-      func = () => prevFunc() || (condition() ? [index, conditionValue, mp] : undefined);
-    }
-    return func;
-  });
-  return createMemo(() => {
-    const sel = switchFunc()();
-    if (!sel)
-      return props.fallback;
-    const [index, conditionValue, mp] = sel;
-    const child = mp.children;
-    const fn = typeof child === "function" && child.length > 0;
-    return fn ? untrack(() => child(mp.keyed ? conditionValue() : () => {
-      if (untrack(switchFunc)()?.[0] !== index)
-        throw narrowedError("Match");
-      return conditionValue();
-    })) : child;
-  }, undefined, undefined);
-}
-function Match(props) {
-  return props;
-}
 
 // node_modules/entities/dist/esm/decode-codepoint.js
 var _a;
@@ -37551,8 +37514,11 @@ var render = async (node, rendererOrConfig = {}) => {
 import { query } from "@anthropic-ai/claude-agent-sdk";
 
 // src/adapters/base.ts
-function formatTranscript(messages) {
-  return messages.map((m2) => `[${m2.from}]: ${m2.text}`).join(`
+function formatTranscript(messages, agentName, humanName) {
+  return messages.map((m2) => {
+    const role = m2.from === agentName ? "you" : m2.from === humanName ? "user" : "agent";
+    return `${m2.from} (${role}):: ${m2.text}`;
+  }).join(`
 
 `);
 }
@@ -37561,13 +37527,15 @@ function formatTranscript(messages) {
 class ClaudeBaseAdapter {
   name;
   model;
+  humanName;
   systemPrompt = "";
   sessionId = "";
   runtimeEnv = {};
   claudeExecutable;
-  constructor(name, model) {
+  constructor(name, model, humanName) {
     this.name = name;
     this.model = model;
+    this.humanName = humanName;
   }
   async init(config) {
     this.systemPrompt = config.resolvedPrompt ?? "";
@@ -37575,15 +37543,23 @@ class ClaudeBaseAdapter {
     this.claudeExecutable = config.executablePath ?? process.env.CLAUDE_CODE_EXECUTABLE;
   }
   async buildEnv(config) {
-    return { ...process.env, ...config.env ?? {} };
-  }
-  async send(messages, signal) {
-    return await this.querySDK(formatTranscript(messages), signal);
-  }
-  async destroy() {
-    return;
+    const configEnv = config.env ?? {};
+    const mapped = {};
+    if (configEnv.AUTH_URL) {
+      mapped.ANTHROPIC_BASE_URL = configEnv.AUTH_URL;
+    }
+    if (configEnv.AUTH_TOKEN) {
+      mapped.ANTHROPIC_AUTH_TOKEN = configEnv.AUTH_TOKEN;
+    }
+    if (configEnv.AUTH_URL || configEnv.AUTH_TOKEN) {
+      mapped.ANTHROPIC_DEFAULT_HAIKU_MODEL = this.model;
+      mapped.ANTHROPIC_DEFAULT_SONNET_MODEL = this.model;
+      mapped.ANTHROPIC_DEFAULT_OPUS_MODEL = this.model;
+    }
+    return { ...process.env, ...mapped, ...configEnv };
   }
-  async querySDK(transcript, signal) {
+  async* stream(messages, signal) {
+    const transcript = formatTranscript(messages, this.name, this.humanName);
     const executableOpt = this.claudeExecutable ? { pathToClaudeCodeExecutable: this.claudeExecutable } : {};
     const options = {
       cwd: process.cwd(),
@@ -37597,24 +37573,69 @@ class ClaudeBaseAdapter {
       ...this.sessionId ? { resume: this.sessionId } : {},
       ...executableOpt
     };
+    yield { type: "activity", activity: "thinking" };
     try {
       for await (const message of query({ prompt: transcript, options })) {
         if (signal?.aborted) {
-          return `[Aborted] ${this.name} was cancelled`;
+          yield { type: "error", message: `[Aborted] ${this.name} was cancelled` };
+          return;
         }
-        if (message && typeof message === "object" && "type" in message && "subtype" in message && "session_id" in message && message.type === "system" && message.subtype === "init" && typeof message.session_id === "string") {
+        if (!message || typeof message !== "object")
+          continue;
+        if ("type" in message && "subtype" in message && "session_id" in message && message.type === "system" && message.subtype === "init" && typeof message.session_id === "string") {
           this.sessionId = message.session_id;
         }
-        if (message && typeof message === "object" && "result" in message) {
+        if ("type" in message && message.type === "assistant" && "message" in message) {
+          const msg = message.message;
+          const blocks = msg?.content;
+          if (Array.isArray(blocks)) {
+            for (const block of blocks) {
+              if (block.type === "tool_use" && block.name) {
+                const toolName = String(block.name).toLowerCase();
+                if (toolName === "read" || toolName === "glob") {
+                  yield { type: "activity", activity: "reading", detail: block.name };
+                } else if (toolName === "write" || toolName === "edit") {
+                  yield { type: "activity", activity: "writing", detail: block.name };
+                } else if (toolName === "bash") {
+                  yield { type: "activity", activity: "running", detail: "shell" };
+                } else if (toolName === "grep" || toolName === "search" || toolName === "websearch") {
+                  yield { type: "activity", activity: "searching", detail: block.name };
+                } else {
+                  yield { type: "activity", activity: "thinking", detail: block.name };
+                }
+              } else if (block.type === "thinking") {
+                yield { type: "activity", activity: "thinking" };
+              }
+            }
+          }
+        }
+        if ("type" in message && message.type === "user") {
+          yield { type: "activity", activity: "thinking" };
+        }
+        if ("result" in message) {
           const result = message.result;
-          return typeof result === "string" && result.length > 0 ? result : `[No text response from ${this.name}]`;
+          const text = typeof result === "string" && result.length > 0 ? result : `[No text response from ${this.name}]`;
+          yield { type: "activity", activity: "idle" };
+          yield { type: "response", text };
+          return;
         }
       }
     } catch (err) {
       console.log(`[${this.name}] SDK error:`, err);
-      throw err;
+      yield { type: "error", message: err instanceof Error ? err.message : String(err) };
+      return;
     }
-    return `[No text response from ${this.name}]`;
+    yield { type: "activity", activity: "idle" };
+    yield { type: "response", text: `[No text response from ${this.name}]` };
+  }
+  async destroy() {
+    return;
+  }
+  getSdkSessionId() {
+    return this.sessionId;
+  }
+  setSdkSessionId(id) {
+    this.sessionId = id;
   }
 }
 
@@ -38061,11 +38082,15 @@ class CodexAdapter {
   name;
   provider = "codex";
   model;
+  humanName;
   codex;
   thread;
-  constructor(name, model) {
+  threadId = "";
+  threadOptions = {};
+  constructor(name, model, humanName) {
     this.name = name;
     this.model = model;
+    this.humanName = humanName;
   }
   async init(config) {
     const cliPath = config.executablePath ?? process.env.CODEX_CLI_EXECUTABLE;
@@ -38075,31 +38100,84 @@ class CodexAdapter {
       ...config.env?.OPENAI_API_KEY ? { apiKey: config.env.OPENAI_API_KEY } : {},
       ...systemPrompt ? { config: { developer_instructions: systemPrompt } } : {}
     });
-    this.thread = this.codex.startThread({
+    this.threadOptions = {
       model: this.model,
       sandboxMode: "danger-full-access",
       workingDirectory: process.cwd(),
       approvalPolicy: "never",
       skipGitRepoCheck: true
-    });
+    };
+    if (this.threadId) {
+      try {
+        this.thread = this.codex.resumeThread(this.threadId, this.threadOptions);
+        return;
+      } catch (err) {
+        console.error(`[${this.name}] resumeThread failed, starting fresh:`, err);
+        this.threadId = "";
+      }
+    }
+    this.thread = this.codex.startThread(this.threadOptions);
+    this.threadId = this.thread.id ?? "";
   }
-  async send(messages, signal) {
+  async* stream(messages, signal) {
     if (!this.thread) {
-      return "[Codex thread not initialized]";
+      yield { type: "error", message: "[Codex thread not initialized]" };
+      return;
     }
     if (signal?.aborted) {
-      return "[Aborted] Codex was cancelled";
+      yield { type: "error", message: "[Aborted] Codex was cancelled" };
+      return;
     }
-    const turn = await this.thread.run(formatTranscript(messages));
-    if (turn.finalResponse && turn.finalResponse.length > 0) {
-      return turn.finalResponse;
+    yield { type: "activity", activity: "thinking" };
+    try {
+      const result = await this.thread.runStreamed(formatTranscript(messages, this.name, this.humanName));
+      let lastAgentMessage = "";
+      for await (const event of result.events) {
+        if (signal?.aborted) {
+          yield { type: "error", message: "[Aborted] Codex was cancelled" };
+          return;
+        }
+        if (event.type === "item.started" || event.type === "item.updated") {
+          const item = event.item;
+          if (item.type === "command_execution") {
+            yield { type: "activity", activity: "running", detail: item.command };
+          } else if (item.type === "file_change") {
+            yield { type: "activity", activity: "writing", detail: "file changes" };
+          } else if (item.type === "reasoning") {
+            yield { type: "activity", activity: "thinking", detail: "reasoning" };
+          } else if (item.type === "web_search") {
+            yield { type: "activity", activity: "searching", detail: item.query };
+          } else if (item.type === "mcp_tool_call") {
+            yield { type: "activity", activity: "running", detail: `${item.server}:${item.tool}` };
+          }
+        }
+        if (event.type === "item.completed") {
+          const item = event.item;
+          if (item.type === "agent_message" && typeof item.text === "string") {
+            lastAgentMessage = item.text;
+          }
+        }
+      }
+      const text = lastAgentMessage.length > 0 ? lastAgentMessage : `[No text response from ${this.name}]`;
+      if (!this.threadId && this.thread?.id) {
+        this.threadId = this.thread.id;
+      }
+      yield { type: "activity", activity: "idle" };
+      yield { type: "response", text };
+    } catch (err) {
+      yield { type: "error", message: err instanceof Error ? err.message : String(err) };
     }
-    return "[No text response from Codex]";
   }
   async destroy() {
     this.thread = undefined;
     this.codex = undefined;
   }
+  getSdkSessionId() {
+    return this.threadId;
+  }
+  setSdkSessionId(id) {
+    this.threadId = id;
+  }
 }
 
 // node_modules/@github/copilot-sdk/dist/client.js
@@ -39276,14 +39354,17 @@ class CopilotAdapter {
   name;
   provider = "copilot";
   model;
+  humanName;
   client;
   session;
   systemPrompt = "";
   cliPath;
   timeout = 600000;
-  constructor(name, model) {
+  copilotSessionId = "";
+  constructor(name, model, humanName) {
     this.name = name;
     this.model = model;
+    this.humanName = humanName;
   }
   async init(config) {
     this.systemPrompt = config.resolvedPrompt ?? "";
@@ -39293,123 +39374,186 @@ class CopilotAdapter {
     }
     await this.createSession();
   }
-  async send(messages, signal) {
+  async* stream(messages, signal) {
     if (!this.session) {
-      return "[Copilot session not initialized]";
+      yield { type: "error", message: "[Copilot session not initialized]" };
+      return;
     }
     if (signal?.aborted) {
-      return "[Aborted] Copilot was cancelled";
+      yield { type: "error", message: "[Aborted] Copilot was cancelled" };
+      return;
     }
-    const transcript = formatTranscript(messages);
+    yield { type: "activity", activity: "thinking" };
+    const transcript = formatTranscript(messages, this.name, this.humanName);
+    const eventQueue = [];
+    let resolve4 = null;
+    let done = false;
+    const push = (event) => {
+      eventQueue.push(event);
+      if (resolve4) {
+        resolve4();
+        resolve4 = null;
+      }
+    };
+    const waitForEvent = () => {
+      if (eventQueue.length > 0 || done)
+        return Promise.resolve();
+      return new Promise((r) => {
+        resolve4 = r;
+      });
+    };
+    const timer = setTimeout(() => {
+      push({ type: "error", message: `[Timeout] ${this.name} exceeded ${Math.floor(this.timeout / 1000)}s` });
+      done = true;
+    }, this.timeout);
+    const unsubscribe = this.session.on((event) => {
+      if (signal?.aborted) {
+        push({ type: "error", message: `[Aborted] ${this.name} was cancelled` });
+        done = true;
+        return;
+      }
+      if (event.type === "tool.execution_start") {
+        const toolName = String(event.data?.toolName ?? "").toLowerCase();
+        if (toolName === "view" || toolName === "read" || toolName === "report_intent") {
+          push({ type: "activity", activity: "reading", detail: event.data?.toolName });
+        } else if (toolName === "create" || toolName === "edit" || toolName === "write") {
+          push({ type: "activity", activity: "writing", detail: event.data?.toolName });
+        } else if (toolName === "run" || toolName === "bash" || toolName === "shell") {
+          push({ type: "activity", activity: "running", detail: event.data?.toolName });
+        } else if (toolName === "search" || toolName === "grep" || toolName === "find") {
+          push({ type: "activity", activity: "searching", detail: event.data?.toolName });
+        } else {
+          push({ type: "activity", activity: "thinking", detail: event.data?.toolName });
+        }
+      }
+      if (event.type === "tool.execution_complete") {
+        push({ type: "activity", activity: "thinking" });
+      }
+      if (event.type === "assistant.turn_start") {
+        push({ type: "activity", activity: "thinking" });
+      }
+      if (event.type === "assistant.message") {
+        const content = event.data?.content;
+        if (typeof content === "string" && content.length > 0) {
+          push({ type: "activity", activity: "idle" });
+          push({ type: "response", text: content });
+          done = true;
+        }
+      }
+      if (event.type === "session.error") {
+        push({ type: "error", message: event.data?.message ?? "Unknown Copilot error" });
+        done = true;
+      }
+    });
+    const sendSession = async () => {
+      try {
+        await this.session.send({ prompt: transcript });
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        if (message.includes("Session not found")) {
+          await this.createSession();
+          try {
+            await this.session.send({ prompt: transcript });
+          } catch (retryErr) {
+            push({ type: "error", message: retryErr instanceof Error ? retryErr.message : String(retryErr) });
+            done = true;
+          }
+        } else {
+          push({ type: "error", message });
+          done = true;
+        }
+      }
+    };
+    sendSession();
     try {
-      return await this.sendToSession(transcript);
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      if (message.includes("Session not found")) {
-        await this.createSession();
-        return await this.sendToSession(transcript);
+      while (!done || eventQueue.length > 0) {
+        await waitForEvent();
+        while (eventQueue.length > 0) {
+          const event = eventQueue.shift();
+          yield event;
+          if (event.type === "response" || event.type === "error") {
+            clearTimeout(timer);
+            unsubscribe?.();
+            return;
+          }
+        }
       }
-      throw err;
+    } finally {
+      clearTimeout(timer);
+      unsubscribe?.();
     }
+    yield { type: "activity", activity: "idle" };
+    yield { type: "response", text: `[No text response from ${this.name}]` };
   }
   async destroy() {
     if (this.session) {
-      await this.session.disconnect();
+      try {
+        await this.session.disconnect();
+      } catch (err) {
+        console.error(`[${this.name}] disconnect:`, err);
+      }
     }
     if (this.client) {
-      await this.client.stop();
+      try {
+        await this.client.stop();
+      } catch (err) {
+        console.error(`[${this.name}] stop:`, err);
+      }
     }
   }
+  getSdkSessionId() {
+    return this.copilotSessionId;
+  }
+  setSdkSessionId(id) {
+    this.copilotSessionId = id;
+  }
   async createSession() {
     if (this.session) {
       try {
         await this.session.disconnect();
-      } catch {}
+      } catch (err) {
+        console.error(`[${this.name}] stale session disconnect:`, err);
+      }
     }
     if (this.client) {
       try {
         await this.client.stop();
-      } catch {}
+      } catch (err) {
+        console.error(`[${this.name}] stale client stop:`, err);
+      }
     }
     process.env.NODE_NO_WARNINGS = "1";
     this.client = new CopilotClient({
       ...this.cliPath ? { cliPath: this.cliPath } : {}
     });
     await this.client.start();
+    if (this.copilotSessionId) {
+      try {
+        this.session = await this.client.resumeSession(this.copilotSessionId, {
+          model: this.model,
+          systemMessage: { content: this.systemPrompt },
+          onPermissionRequest: approveAll
+        });
+        return;
+      } catch (err) {
+        console.error(`[${this.name}] resumeSession failed, creating new:`, err);
+        this.copilotSessionId = "";
+      }
+    }
+    const sessionId = `llm-party-${this.name}-${Date.now()}`;
     this.session = await this.client.createSession({
+      sessionId,
       model: this.model,
       systemMessage: { content: this.systemPrompt },
       onPermissionRequest: approveAll
     });
-  }
-  async sendToSession(transcript) {
-    if (!this.session) {
-      return "[Copilot session not initialized]";
-    }
-    const response = await this.session.sendAndWait({ prompt: transcript }, this.timeout);
-    if (response && response.data && typeof response.data.content === "string" && response.data.content.length > 0) {
-      return response.data.content;
-    }
-    return "[No text response from Copilot]";
+    this.copilotSessionId = sessionId;
   }
 }
 
-// src/adapters/glm.ts
-import { spawn as spawn3 } from "child_process";
-class GlmAdapter extends ClaudeBaseAdapter {
-  provider = "glm";
-  async buildEnv(config) {
-    const aliasEnv = await loadGlmAliasEnv();
-    return { ...process.env, ...aliasEnv, ...config.env ?? {} };
-  }
-}
-function detectShell() {
-  if (process.env.SHELL) {
-    return process.env.SHELL;
-  }
-  return "/bin/sh";
-}
-async function loadGlmAliasEnv() {
-  const shell = detectShell();
-  const isInteractive = shell.endsWith("zsh") || shell.endsWith("bash");
-  const args = isInteractive ? ["-ic", "alias glm"] : ["-c", "alias glm"];
-  return new Promise((resolve4) => {
-    const child = spawn3(shell, args, {
-      cwd: process.cwd(),
-      env: process.env,
-      stdio: ["ignore", "pipe", "pipe"]
-    });
-    let stdout = "";
-    const timeout = setTimeout(() => {
-      child.kill("SIGTERM");
-      resolve4({});
-    }, 5000);
-    child.stdout.on("data", (chunk) => {
-      stdout += String(chunk);
-    });
-    child.on("close", (code) => {
-      clearTimeout(timeout);
-      if (code !== 0) {
-        resolve4({});
-        return;
-      }
-      const env2 = {};
-      const tokens = stdout.match(/[A-Z_]+="[^"]*"/g) ?? [];
-      for (const token of tokens) {
-        const eqIdx = token.indexOf("=");
-        if (eqIdx === -1)
-          continue;
-        const key = token.slice(0, eqIdx);
-        const raw = token.slice(eqIdx + 1);
-        env2[key] = raw.replace(/^"|"$/g, "");
-      }
-      resolve4(env2);
-    });
-    child.on("error", () => {
-      clearTimeout(timeout);
-      resolve4({});
-    });
-  });
+// src/adapters/custom.ts
+class CustomAdapter extends ClaudeBaseAdapter {
+  provider = "custom";
 }
 
 // src/config/loader.ts
@@ -39448,27 +39592,11 @@ var PROVIDERS = [
     defaultTag: "copilot",
     detectCommand: "copilot",
     detectType: "binary"
-  },
-  {
-    id: "glm",
-    displayName: "GLM",
-    description: "glm alias configured on Claude Code CLI",
-    unavailableHint: "glm shell alias not configured",
-    defaultModel: "glm-5",
-    defaultTag: "glm",
-    detectCommand: "glm",
-    detectType: "alias",
-    env: {
-      ANTHROPIC_BASE_URL: "https://api.z.ai/api/anthropic",
-      ANTHROPIC_DEFAULT_HAIKU_MODEL: "glm-4.5-air",
-      ANTHROPIC_DEFAULT_SONNET_MODEL: "glm-4.5",
-      ANTHROPIC_DEFAULT_OPUS_MODEL: "glm-5"
-    }
   }
 ];
 
 // src/config/loader.ts
-var VALID_PROVIDER_IDS = new Set(PROVIDERS.map((p) => p.id));
+var VALID_PROVIDER_IDS = new Set([...PROVIDERS.map((p) => p.id), "custom"]);
 var LLM_PARTY_HOME = path8.join(homedir(), ".llm-party");
 var MIND_MAP_INDEX = `# Living Memory Neural Network
 
@@ -39654,15 +39782,29 @@ async function configExists() {
     return false;
   }
 }
+function migrateProviders(data) {
+  if (!Array.isArray(data.agents))
+    return;
+  for (const agent of data.agents) {
+    if (!agent || typeof agent !== "object")
+      continue;
+    if (typeof agent.provider === "string" && !VALID_PROVIDER_IDS.has(agent.provider)) {
+      agent.provider = "custom";
+      if (!agent.cli)
+        agent.cli = "claude";
+    }
+  }
+}
 async function loadConfig2(configPath) {
   const raw = await readFile3(configPath, "utf8");
   const parsed = JSON.parse(raw);
+  migrateProviders(parsed);
   validateConfig(parsed);
   return normalizeConfig(parsed);
 }
 
 // src/orchestrator.ts
-import { appendFile, mkdir as mkdir5, writeFile as writeFile5 } from "fs/promises";
+import { appendFile, mkdir as mkdir5, readFile as readFile5, writeFile as writeFile5 } from "fs/promises";
 import { randomBytes } from "crypto";
 import path9 from "path";
 
@@ -39687,6 +39829,72 @@ var DEFAULT_REMINDERS = [
   "Self-memory check: did you receive a correction this session? Write it to your agent file now.",
   "Global awareness: if this work affects other projects, write a one-liner to projects.yml history."
 ];
+var QUEUE_TTL_MS = 5 * 60 * 1000;
+var MAX_QUEUE_SIZE = 20;
+
+class AgentQueueManager {
+  queues = new Map;
+  register(agentName) {
+    this.queues.set(agentName, { processing: false, pending: [] });
+  }
+  enqueue(agentName, message, maxSize = MAX_QUEUE_SIZE) {
+    const queue = this.queues.get(agentName);
+    if (!queue)
+      return false;
+    if (queue.pending.length >= maxSize) {
+      queue.pending.shift();
+    }
+    queue.pending.push(message);
+    return true;
+  }
+  drain(agentName, ttlMs = QUEUE_TTL_MS) {
+    const queue = this.queues.get(agentName);
+    if (!queue)
+      return [];
+    const now = Date.now();
+    const valid = queue.pending.filter((m2) => now - new Date(m2.queuedAt).getTime() < ttlMs);
+    queue.pending = [];
+    return valid;
+  }
+  isProcessing(agentName) {
+    return this.queues.get(agentName)?.processing ?? false;
+  }
+  setProcessing(agentName, value) {
+    const queue = this.queues.get(agentName);
+    if (queue)
+      queue.processing = value;
+  }
+  hasPending(agentName) {
+    return (this.queues.get(agentName)?.pending.length ?? 0) > 0;
+  }
+  pendingCount(agentName) {
+    return this.queues.get(agentName)?.pending.length ?? 0;
+  }
+  get anyProcessing() {
+    for (const q2 of this.queues.values()) {
+      if (q2.processing)
+        return true;
+    }
+    return false;
+  }
+  setController(agentName, controller) {
+    const queue = this.queues.get(agentName);
+    if (queue)
+      queue.controller = controller;
+  }
+  abortAll() {
+    for (const q2 of this.queues.values()) {
+      q2.controller?.abort();
+      q2.pending = [];
+    }
+  }
+  clearAll() {
+    for (const q2 of this.queues.values()) {
+      q2.pending = [];
+      q2.processing = false;
+    }
+  }
+}
 
 class Orchestrator {
   agents;
@@ -39702,7 +39910,16 @@ class Orchestrator {
   contextWindowSize;
   reminderInterval;
   reminderCursors = new Map;
+  maxAutoHops;
+  queueTtlMs;
+  maxQueueSize;
   messageId = 0;
+  stickyTargets;
+  queueManager = new AgentQueueManager;
+  manifestSavePromise = Promise.resolve();
+  onMessage = () => {};
+  onActivity = () => {};
+  onSystem = () => {};
   constructor(agents, humanName = "USER", agentTags, humanTag, defaultTimeout = 600000, agentTimeouts, options) {
     this.agents = new Map(agents.map((agent) => [agent.name, agent]));
     this.agentTags = new Map(agents.map((agent) => [agent.name, agentTags?.[agent.name] ?? toTag(agent.name)]));
@@ -39712,12 +39929,21 @@ class Orchestrator {
     this.agentTimeouts = new Map(Object.entries(agentTimeouts ?? {}));
     this.contextWindowSize = options?.contextWindowSize ?? 16;
     this.reminderInterval = options?.reminderInterval ?? 8;
+    this.maxAutoHops = options?.maxAutoHops ?? 15;
+    this.queueTtlMs = options?.queueTtlMs ?? QUEUE_TTL_MS;
+    this.maxQueueSize = options?.maxQueueSize ?? MAX_QUEUE_SIZE;
     this.sessionId = createSessionId();
     this.transcriptPath = path9.resolve(".llm-party", "sessions", `transcript-${this.sessionId}.jsonl`);
     for (const agent of agents) {
       this.lastSeenByAgent.set(agent.name, 0);
+      this.queueManager.register(agent.name);
     }
   }
+  setCallbacks(onMessage, onActivity, onSystem) {
+    this.onMessage = onMessage;
+    this.onActivity = onActivity;
+    this.onSystem = onSystem;
+  }
   getSessionId() {
     return this.sessionId;
   }
@@ -39730,12 +39956,29 @@ class Orchestrator {
   getHumanTag() {
     return this.humanTag;
   }
+  get dispatching() {
+    return this.queueManager.anyProcessing;
+  }
+  getStickyTarget() {
+    return this.stickyTargets;
+  }
+  setStickyTarget(targets) {
+    this.stickyTargets = targets;
+  }
+  getQueueStatus() {
+    return this.listAgents().map((a) => ({
+      name: a.name,
+      processing: this.queueManager.isProcessing(a.name),
+      pending: this.queueManager.pendingCount(a.name)
+    }));
+  }
   clearConversation() {
     this.conversation.length = 0;
     this.messageId = 0;
     for (const agent of this.agents.keys()) {
       this.lastSeenByAgent.set(agent, 0);
     }
+    this.queueManager.clearAll();
     this.sessionId = createSessionId();
     this.transcriptPath = path9.resolve(".llm-party", "sessions", `transcript-${this.sessionId}.jsonl`);
   }
@@ -39772,62 +40015,158 @@ class Orchestrator {
       const tag = this.agentTags.get(agent.name) ?? toTag(agent.name);
       return agent.name.toLowerCase() === normalized || tag.toLowerCase() === normalized;
     }).map((agent) => agent.name);
-    if (byName.length > 0) {
+    if (byName.length > 0)
       return byName;
-    }
     return Array.from(this.agents.values()).filter((agent) => agent.provider.toLowerCase() === normalized).map((agent) => agent.name);
   }
-  async fanOut(targetAgentNames) {
-    return this.fanOutWithProgress(targetAgentNames, () => {});
-  }
-  async fanOutWithProgress(targetAgentNames, onMessage) {
-    const requestedTargets = targetAgentNames && targetAgentNames.length > 0 ? targetAgentNames : Array.from(this.agents.keys());
-    const targets = requestedTargets.map((name) => this.agents.get(name)).filter((agent) => Boolean(agent));
-    const historyMaxId = this.messageId;
-    const settled = await Promise.allSettled(targets.map(async (agent) => {
-      const lastSeen = this.lastSeenByAgent.get(agent.name) ?? 0;
-      const unseen = this.conversation.filter((msg) => msg.id > lastSeen && msg.from.toUpperCase() !== agent.name.toUpperCase());
-      if (unseen.length === 0) {
-        this.lastSeenByAgent.set(agent.name, historyMaxId);
-        return null;
-      }
-      const inputMessages = this.buildInputForAgent(agent.name, unseen);
-      const responseText = await this.sendWithTimeout(agent, inputMessages, this.timeoutFor(agent.name));
-      const response = {
-        id: ++this.messageId,
-        from: agent.name.toUpperCase(),
-        text: responseText,
-        createdAt: new Date().toISOString()
-      };
-      this.lastSeenByAgent.set(agent.name, historyMaxId);
-      this.conversation.push(response);
-      await this.appendTranscript(response);
-      onMessage(response);
-      return response;
-    }));
-    const results = [];
-    for (let idx = 0;idx < settled.length; idx++) {
-      const item = settled[idx];
-      if (item.status === "fulfilled") {
-        if (item.value) {
-          results.push(item.value);
-        }
+  dispatchToTargets(targetAgentNames, chainHops = 0) {
+    for (const name of targetAgentNames) {
+      const agent = this.agents.get(name);
+      if (!agent)
         continue;
+      if (this.queueManager.isProcessing(name)) {
+        this.queueManager.enqueue(name, {
+          from: "dispatch",
+          text: "",
+          queuedAt: new Date().toISOString(),
+          chainHops
+        }, this.maxQueueSize);
+        this.onSystem(`Queued for ${name} (busy, ${this.queueManager.pendingCount(name)} pending)`);
+      } else {
+        this.processAgent(name, chainHops);
       }
-      const agent = targets[idx];
-      const response = {
-        id: ++this.messageId,
-        from: agent.name.toUpperCase(),
-        text: `[Adapter Error] ${item.reason instanceof Error ? item.reason.message : String(item.reason)}`,
-        createdAt: new Date().toISOString()
-      };
-      this.lastSeenByAgent.set(agent.name, historyMaxId);
-      this.conversation.push(response);
-      await this.appendTranscript(response);
-      onMessage(response);
-      results.push(response);
     }
-    return results;
+  }
+  async processAgent(agentName, chainHops) {
+    const agent = this.agents.get(agentName);
+    if (!agent)
+      return;
+    this.queueManager.setProcessing(agentName, true);
+    this.onActivity(agentName, "thinking");
+    const historyMaxId = this.messageId;
+    const lastSeen = this.lastSeenByAgent.get(agentName) ?? 0;
+    const unseen = this.conversation.filter((msg) => msg.id > lastSeen && msg.from.toUpperCase() !== agentName.toUpperCase());
+    if (unseen.length === 0) {
+      this.lastSeenByAgent.set(agentName, historyMaxId);
+      this.queueManager.setProcessing(agentName, false);
+      this.onActivity(agentName, "idle");
+      this.drainQueue(agentName);
+      return;
+    }
+    const inputMessages = this.buildInputForAgent(agentName, unseen);
+    const responseText = await this.streamWithTimeout(agentName, agent, inputMessages, this.timeoutFor(agentName));
+    const response = {
+      id: ++this.messageId,
+      from: agentName.toUpperCase(),
+      text: responseText,
+      createdAt: new Date().toISOString()
+    };
+    this.lastSeenByAgent.set(agentName, historyMaxId);
+    this.conversation.push(response);
+    await this.appendTranscript(response);
+    this.onMessage(response);
+    await this.saveManifest();
+    this.queueManager.setProcessing(agentName, false);
+    const isError = responseText.startsWith("[Timeout]") || responseText.startsWith("[Error]") || responseText.startsWith("[Adapter Error]");
+    if (!isError) {
+      this.processHandoffs(response, chainHops);
+    }
+    this.drainQueue(agentName);
+  }
+  processHandoffs(response, currentHops) {
+    const selectors = extractNextSelectors([response]);
+    if (selectors.length === 0)
+      return;
+    const humanTag = this.humanTag.toLowerCase();
+    const humanName = this.humanName.toLowerCase();
+    const agentSelectors = selectors.filter((s) => {
+      const n = s.toLowerCase();
+      return n !== humanTag && n !== humanName;
+    });
+    if (agentSelectors.length === 0)
+      return;
+    const resolvedTargets = Array.from(new Set(agentSelectors.flatMap((s) => this.resolveTargets(s))));
+    if (resolvedTargets.length === 0)
+      return;
+    const nextHops = currentHops + 1;
+    if (nextHops >= this.maxAutoHops) {
+      this.onSystem(`Stopped auto-handoff after ${this.maxAutoHops} hops.`);
+      return;
+    }
+    this.onSystem(`Auto handoff via @next to ${resolvedTargets.join(", ")}`);
+    this.dispatchToTargets(resolvedTargets, nextHops);
+  }
+  drainQueue(agentName) {
+    if (!this.queueManager.hasPending(agentName)) {
+      this.onActivity(agentName, "idle");
+      return;
+    }
+    const pending = this.queueManager.drain(agentName, this.queueTtlMs);
+    if (pending.length === 0) {
+      this.onActivity(agentName, "idle");
+      return;
+    }
+    const maxHops = Math.max(...pending.map((m2) => m2.chainHops));
+    if (maxHops >= this.maxAutoHops) {
+      this.onSystem(`Stopped auto-handoff for ${agentName} after ${this.maxAutoHops} hops.`);
+      this.onActivity(agentName, "idle");
+      return;
+    }
+    this.processAgent(agentName, maxHops);
+  }
+  async streamWithTimeout(agentName, agent, messages, timeoutMs) {
+    const controller = new AbortController;
+    this.queueManager.setController(agentName, controller);
+    let timer;
+    let resolved = false;
+    return new Promise((resolve4) => {
+      timer = setTimeout(() => {
+        if (!resolved) {
+          resolved = true;
+          controller.abort();
+          this.onActivity(agentName, "error", "timeout");
+          resolve4(`[Timeout] ${agentName} exceeded ${Math.floor(timeoutMs / 1000)}s`);
+        }
+      }, timeoutMs);
+      (async () => {
+        try {
+          for await (const event of agent.stream(messages, controller.signal)) {
+            if (resolved)
+              return;
+            if (event.type === "activity") {
+              this.onActivity(agentName, event.activity, event.detail);
+            } else if (event.type === "response") {
+              resolved = true;
+              if (timer)
+                clearTimeout(timer);
+              resolve4(event.text);
+              return;
+            } else if (event.type === "error") {
+              resolved = true;
+              if (timer)
+                clearTimeout(timer);
+              this.onActivity(agentName, "error");
+              resolve4(`[Error] ${agentName}: ${event.message}`);
+              return;
+            }
+          }
+          if (!resolved) {
+            resolved = true;
+            if (timer)
+              clearTimeout(timer);
+            resolve4(`[No text response from ${agentName}]`);
+          }
+        } catch (err) {
+          if (!resolved) {
+            resolved = true;
+            if (timer)
+              clearTimeout(timer);
+            this.onActivity(agentName, "error");
+            resolve4(`[Error] ${agentName}: ${err instanceof Error ? err.message : String(err)}`);
+          }
+        }
+      })();
+    });
   }
   async appendTranscript(message) {
     try {
@@ -39840,23 +40179,85 @@ class Orchestrator {
   async saveHistory(targetPath) {
     await writeFile5(targetPath, JSON.stringify(this.conversation, null, 2), "utf8");
   }
-  async sendWithTimeout(agent, messages, timeoutMs) {
-    const controller = new AbortController;
-    let timer;
-    const timeoutPromise = new Promise((resolve4) => {
-      timer = setTimeout(() => {
-        controller.abort();
-        resolve4(`[Timeout] ${agent.name} exceeded ${Math.floor(timeoutMs / 1000)}s`);
-      }, timeoutMs);
+  async loadTranscript(sessionId) {
+    const transcriptFile = path9.resolve(".llm-party", "sessions", `transcript-${sessionId}.jsonl`);
+    const content = await readFile5(transcriptFile, "utf8");
+    const lines = content.trim().split(`
+`).filter(Boolean);
+    const messages = lines.map((line) => JSON.parse(line));
+    this.conversation.length = 0;
+    this.conversation.push(...messages);
+    const maxId = messages.length > 0 ? Math.max(...messages.map((m2) => m2.id)) : 0;
+    this.messageId = maxId;
+    for (const agent of this.agents.keys()) {
+      this.lastSeenByAgent.set(agent, maxId);
+    }
+    this.sessionId = sessionId;
+    this.transcriptPath = transcriptFile;
+    await this.loadManifest();
+    return messages;
+  }
+  hasMessages() {
+    return this.conversation.length > 0;
+  }
+  manifestPath() {
+    const dir = path9.dirname(this.transcriptPath);
+    const base = path9.basename(this.transcriptPath, ".jsonl");
+    return path9.join(dir, `${base}.manifest.json`);
+  }
+  async saveManifest() {
+    this.manifestSavePromise = this.manifestSavePromise.then(async () => {
+      try {
+        const agents = {};
+        for (const [name, adapter] of this.agents) {
+          const sid = adapter.getSdkSessionId();
+          agents[name] = {
+            provider: adapter.provider,
+            sdkSessionId: sid || "",
+            lastSeenId: this.lastSeenByAgent.get(name) ?? 0
+          };
+        }
+        const manifest = {
+          orchestratorSessionId: this.sessionId,
+          messageId: this.messageId,
+          stickyTarget: this.stickyTargets,
+          agents
+        };
+        await writeFile5(this.manifestPath(), JSON.stringify(manifest, null, 2), "utf8");
+      } catch (err) {
+        console.error("[manifest] write failed:", err);
+      }
     });
+    return this.manifestSavePromise;
+  }
+  async loadManifest() {
     try {
-      return await Promise.race([agent.send(messages, controller.signal), timeoutPromise]);
-    } finally {
-      if (timer) {
-        clearTimeout(timer);
+      const content = await readFile5(this.manifestPath(), "utf8");
+      const manifest = JSON.parse(content);
+      if (Array.isArray(manifest.stickyTarget)) {
+        this.stickyTargets = manifest.stickyTarget;
+      }
+      const agentMap = manifest.agents ?? {};
+      for (const [name, data] of Object.entries(agentMap)) {
+        const adapter = this.agents.get(name);
+        const agentData = data;
+        if (!adapter || !agentData)
+          continue;
+        if (typeof agentData.sdkSessionId === "string" && agentData.sdkSessionId) {
+          adapter.setSdkSessionId(agentData.sdkSessionId);
+        }
+        if (typeof agentData.lastSeenId === "number") {
+          this.lastSeenByAgent.set(name, agentData.lastSeenId);
+        }
       }
+    } catch (err) {
+      console.error("[manifest] load failed (agents start fresh):", err);
     }
   }
+  async abortAll() {
+    this.queueManager.abortAll();
+    await this.saveManifest();
+  }
   timeoutFor(agentName) {
     return this.agentTimeouts.get(agentName) ?? this.defaultTimeout;
   }
@@ -39890,9 +40291,24 @@ function createSessionId() {
   const rand = randomBytes(4).toString("hex");
   return `${timestamp}-${process.pid}-${rand}`;
 }
+function extractNextSelectors(messages) {
+  const selectors = [];
+  for (const msg of messages) {
+    const regex = /@next\s*:\s*([A-Za-z0-9_-]+)/gi;
+    let match = null;
+    while ((match = regex.exec(msg.text)) !== null) {
+      selectors.push(match[1]);
+    }
+    const controlMatch = msg.text.match(/@control[\s\S]*?next\s*:\s*([A-Za-z0-9_-]+)[\s\S]*?@end/i);
+    if (controlMatch?.[1]) {
+      selectors.push(controlMatch[1]);
+    }
+  }
+  return selectors;
+}
 
 // src/ui/App.tsx
-import { spawn as spawn5 } from "child_process";
+import { spawn as spawn4 } from "child_process";
 
 // src/ui/useOrchestrator.ts
 import { execFile } from "child_process";
@@ -39901,14 +40317,56 @@ function nextSystemId() {
   systemIdCounter -= 1;
   return systemIdCounter;
 }
-function useOrchestrator(orchestrator, maxAutoHops) {
+function useOrchestrator(orchestrator) {
   const [messages, setMessages] = createSignal([]);
   const [agentStates, setAgentStates] = createSignal(new Map(orchestrator.listAgents().map((a) => [a.name, "idle"])));
-  const [stickyTarget, setStickyTarget] = createSignal(undefined);
+  const [stickyTarget, setStickyTargetSignal] = createSignal(orchestrator.getStickyTarget());
+  const setStickyTarget = (targets) => {
+    setStickyTargetSignal(targets);
+    orchestrator.setStickyTarget(targets);
+  };
   const [dispatching, setDispatching] = createSignal(false);
+  const [queueCounts, setQueueCounts] = createSignal(new Map(orchestrator.listAgents().map((a) => [a.name, 0])));
   let projectFolderReady = false;
-  let agentProviders = new Map(orchestrator.listAgents().map((a) => [a.name.toUpperCase(), a.provider]));
-  let agentTags = new Map(orchestrator.listAgents().map((a) => [a.name.toUpperCase(), a.tag]));
+  const agentProviders = new Map(orchestrator.listAgents().map((a) => [a.name.toUpperCase(), a.provider]));
+  const agentTagsMap = new Map(orchestrator.listAgents().map((a) => [a.name.toUpperCase(), a.tag]));
+  const nameMap = new Map(orchestrator.listAgents().map((a) => [a.name.toUpperCase(), a.name]));
+  const updateQueueCounts = () => {
+    const status = orchestrator.getQueueStatus();
+    setQueueCounts(new Map(status.map((s) => [s.name, s.pending])));
+  };
+  orchestrator.setCallbacks((msg) => {
+    const provider = agentProviders.get(msg.from) ?? "";
+    const tag = agentTagsMap.get(msg.from) ?? "";
+    const display = {
+      ...msg,
+      type: "agent",
+      provider,
+      tag
+    };
+    setMessages((prev) => [...prev, display]);
+    const originalName = nameMap.get(msg.from) ?? msg.from;
+    setAgentStates((prev) => {
+      const next = new Map(prev);
+      const isErr = msg.text.startsWith("[Adapter Error]") || msg.text.startsWith("[Error]") || msg.text.startsWith("[Timeout]");
+      next.set(originalName, isErr ? "error" : "idle");
+      return next;
+    });
+    setDispatching(orchestrator.dispatching);
+    updateQueueCounts();
+  }, (agentName, activity) => {
+    const originalName = nameMap.get(agentName.toUpperCase()) ?? agentName;
+    setAgentStates((prev) => {
+      const next = new Map(prev);
+      next.set(originalName, activity);
+      return next;
+    });
+    setDispatching(orchestrator.dispatching);
+    updateQueueCounts();
+  }, (text) => {
+    addSystemMessage(text);
+    updateQueueCounts();
+  });
   const dispatch = async (line) => {
     if (!line.trim())
       return;
@@ -39922,7 +40380,7 @@ function useOrchestrator(orchestrator, maxAutoHops) {
     if (explicitTargets && explicitTargets.length > 0) {
       setStickyTarget(explicitTargets);
     }
-    const targets = explicitTargets ?? stickyTarget();
+    const targets = explicitTargets ?? stickyTarget() ?? Array.from(orchestrator.listAgents().map((a) => a.name));
     if (!projectFolderReady) {
       await initProjectFolder(process.cwd());
       projectFolderReady = true;
@@ -39935,11 +40393,7 @@ function useOrchestrator(orchestrator, maxAutoHops) {
     };
     setMessages((prev) => [...prev, userDisplay]);
     setDispatching(true);
-    try {
-      await dispatchWithHandoffs(orchestrator, targets, maxAutoHops, agentProviders, agentTags, setMessages, setAgentStates);
-    } finally {
-      setDispatching(false);
-    }
+    orchestrator.dispatchToTargets(targets);
   };
   const addSystemMessage = (text) => {
     const msg = {
@@ -39951,89 +40405,17 @@ function useOrchestrator(orchestrator, maxAutoHops) {
     };
     setMessages((prev) => [...prev, msg]);
   };
+  const addDisplayMessage = (msg) => {
+    setMessages((prev) => [...prev, msg]);
+  };
   const clearMessages = () => {
     orchestrator.clearConversation();
     setMessages([]);
   };
-  return { messages, agentStates, stickyTarget, dispatching, dispatch, addSystemMessage, clearMessages };
-}
-async function dispatchWithHandoffs(orchestrator, initialTargets, maxHops, agentProviders, agentTags, setMessages, setAgentStates) {
-  let targets = initialTargets;
-  let hops = 0;
-  while (true) {
-    const targetNames = targets ?? Array.from(orchestrator.listAgents().map((a) => a.name));
-    setAgentStates((prev) => {
-      const next = new Map(prev);
-      for (const name of targetNames) {
-        next.set(name, "thinking");
-      }
-      return next;
-    });
-    const nameMap = new Map(orchestrator.listAgents().map((a) => [a.name.toUpperCase(), a.name]));
-    const batch = [];
-    await orchestrator.fanOutWithProgress(targets, (msg) => {
-      batch.push(msg);
-      const provider = agentProviders.get(msg.from) ?? "";
-      const tag = agentTags.get(msg.from) ?? "";
-      const display = {
-        ...msg,
-        type: "agent",
-        provider,
-        tag
-      };
-      setMessages((prev) => [...prev, display]);
-      const originalName = nameMap.get(msg.from) ?? msg.from;
-      setAgentStates((prev) => {
-        const next = new Map(prev);
-        next.set(originalName, msg.text.startsWith("[Adapter Error]") ? "error" : "idle");
-        return next;
-      });
-    });
-    setAgentStates((prev) => {
-      const next = new Map(prev);
-      for (const name of targetNames) {
-        if (next.get(name) === "thinking") {
-          next.set(name, "idle");
-        }
-      }
-      return next;
-    });
-    const nextSelectors = extractNextSelectors(batch);
-    if (nextSelectors.length === 0)
-      return;
-    const humanTag = orchestrator.getHumanTag().toLowerCase();
-    const humanName = orchestrator.getHumanName().toLowerCase();
-    const agentSelectors = nextSelectors.filter((s) => {
-      const n = s.toLowerCase();
-      return n !== humanTag && n !== humanName;
-    });
-    if (agentSelectors.length === 0)
-      return;
-    const resolvedTargets = Array.from(new Set(agentSelectors.flatMap((s) => orchestrator.resolveTargets(s))));
-    if (resolvedTargets.length === 0)
-      return;
-    hops += 1;
-    if (Number.isFinite(maxHops) && hops >= maxHops) {
-      const systemMsg = {
-        id: nextSystemId(),
-        from: "SYSTEM",
-        text: `Stopped auto-handoff after ${maxHops} hops.`,
-        createdAt: new Date().toISOString(),
-        type: "system"
-      };
-      setMessages((prev) => [...prev, systemMsg]);
-      return;
-    }
-    const handoffMsg = {
-      id: nextSystemId(),
-      from: "SYSTEM",
-      text: `Auto handoff via @next to ${resolvedTargets.join(", ")}`,
-      createdAt: new Date().toISOString(),
-      type: "system"
-    };
-    setMessages((prev) => [...prev, handoffMsg]);
-    targets = resolvedTargets;
-  }
+  const refreshStickyTarget = () => {
+    setStickyTargetSignal(orchestrator.getStickyTarget());
+  };
+  return { messages, agentStates, queueCounts, stickyTarget, dispatching, dispatch, addSystemMessage, addDisplayMessage, clearMessages, refreshStickyTarget };
 }
 function getChangedFiles() {
   return new Promise((resolve4) => {
@@ -40048,21 +40430,6 @@ function getChangedFiles() {
     });
   });
 }
-function extractNextSelectors(messages) {
-  const selectors = [];
-  for (const msg of messages) {
-    const regex = /@next\s*:\s*([A-Za-z0-9_-]+)/gi;
-    let match = null;
-    while ((match = regex.exec(msg.text)) !== null) {
-      selectors.push(match[1]);
-    }
-    const controlMatch = msg.text.match(/@control[\s\S]*?next\s*:\s*([A-Za-z0-9_-]+)[\s\S]*?@end/i);
-    if (controlMatch?.[1]) {
-      selectors.push(controlMatch[1]);
-    }
-  }
-  return selectors;
-}
 function parseRouting(line) {
   const mentionRegex = /(^|[^A-Za-z0-9_-])@([A-Za-z0-9_-]+)\b/g;
   const mentions = [];
@@ -40151,27 +40518,21 @@ function MessageBubble(props) {
 }
 
 // src/ui/constants.ts
-var SPINNER_FRAMES = ["\u280B", "\u2819", "\u281A", "\u281E", "\u2816", "\u2826", "\u2834", "\u2832", "\u2833", "\u2813"];
+var SPINNER_FRAMES = "\u280B\u2819\u281A\u281E\u2816\u2826\u2834\u2832\u2833\u2813".split("");
+var ACTIVITY_SPINNERS = {
+  thinking_bkp: "\u2733\u2734\u2736\u2735\u2737\u2738\u2739\u273A".split(""),
+  thinking: "       ..ooOO@@@@@@*".split(""),
+  writing: "\u258F\u258E\u258D\u258C\u258B\u258A\u2589\u2588\u2589\u258A\u258B\u258C\u258D\u258E".split(""),
+  reading: ["\u2801", "\u2809", "\u280B", "\u281B", "\u281F", "\u283F", "\u287F", "\u28FF"],
+  running: [" ", "\u2591", "\u2592", "\u2593", "\u2588"],
+  searching: "\u25D0\u25D3\u25D1\u25D2".split("")
+};
+var SUPERSCRIPT_DIGITS = ["\u2070", "\xB9", "\xB2", "\xB3", "\u2074", "\u2075", "\u2076", "\u2077", "\u2078", "\u2079"];
 
 // src/ui/StatusBar.tsx
 var PULSE_COLORS = ["#005F87", "#0087AF", "#00AFD7", "#00D7FF", "#5FF", "#00D7FF", "#0087AF"];
-function useThinkingAnimation(active) {
-  const [frame, setFrame] = createSignal(0);
-  createEffect(() => {
-    if (!active()) {
-      setFrame(0);
-      return;
-    }
-    const interval = setInterval(() => {
-      setFrame((f) => (f + 1) % (SPINNER_FRAMES.length * PULSE_COLORS.length));
-    }, 80);
-    onCleanup(() => clearInterval(interval));
-  });
-  return {
-    spinner: () => active() ? SPINNER_FRAMES[frame() % SPINNER_FRAMES.length] : "",
-    color: () => active() ? PULSE_COLORS[frame() % PULSE_COLORS.length] : COLORS.textMuted
-  };
-}
+var [globalTick, setGlobalTick] = createSignal(0);
+setInterval(() => setGlobalTick((t2) => t2 + 1), 80);
 function StatusBar(props) {
   const targetNames = () => props.stickyTarget ?? props.agents.map((a) => a.name);
   const isTargeted = (name) => targetNames().includes(name);
@@ -40219,65 +40580,59 @@ function StatusBar(props) {
     }), _el$4);
     insertNode(_el$4, createTextNode(`| /info`));
     setProp(_el$6, "flexDirection", "row");
-    setProp(_el$6, "gap", 2);
     insert(_el$6, createComponent2(For, {
       get each() {
         return props.agents;
       },
-      children: (a) => createComponent2(AgentChip, {
+      children: (a, i) => [createComponent2(AgentChip, {
         get name() {
           return a.name;
         },
-        get state() {
-          return props.agentStates.get(a.name) ?? "idle";
-        }
-      })
+        getState: () => props.agentStates.get(a.name) ?? "idle",
+        getQueued: () => props.queueCounts?.get(a.name) ?? 0
+      }), memo2(() => memo2(() => i() < props.agents.length - 1)() ? (() => {
+        var _el$12 = createElement("text");
+        insertNode(_el$12, createTextNode(` \u2502 `));
+        effect((_$p) => setProp(_el$12, "fg", COLORS.textDim, _$p));
+        return _el$12;
+      })() : null)]
     }));
     effect((_$p) => setProp(_el$4, "fg", COLORS.textDim, _$p));
     return _el$;
   })();
 }
+function toSuperscript(n) {
+  if (n <= 0)
+    return "";
+  return String(n).split("").map((d2) => SUPERSCRIPT_DIGITS[parseInt(d2, 10)] ?? d2).join("");
+}
 function AgentChip(props) {
-  const {
-    spinner,
-    color
-  } = useThinkingAnimation(() => props.state === "thinking");
-  return createComponent2(Switch, {
-    get fallback() {
-      return (() => {
-        var _el$16 = createElement("text");
-        insert(_el$16, () => props.name);
-        effect((_$p) => setProp(_el$16, "fg", COLORS.textMuted, _$p));
-        return _el$16;
-      })();
-    },
-    get children() {
-      return [createComponent2(Match, {
-        get when() {
-          return props.state === "error";
-        },
-        get children() {
-          var _el$12 = createElement("text"), _el$13 = createTextNode(` ERR`);
-          insertNode(_el$12, _el$13);
-          insert(_el$12, () => props.name, _el$13);
-          effect((_$p) => setProp(_el$12, "fg", COLORS.error, _$p));
-          return _el$12;
-        }
-      }), createComponent2(Match, {
-        get when() {
-          return props.state === "thinking";
-        },
-        get children() {
-          var _el$14 = createElement("text"), _el$15 = createTextNode(` `);
-          insertNode(_el$14, _el$15);
-          insert(_el$14, () => props.name, _el$15);
-          insert(_el$14, spinner, null);
-          effect((_$p) => setProp(_el$14, "fg", color(), _$p));
-          return _el$14;
-        }
-      })];
-    }
-  });
+  const isActive = () => {
+    const s = props.getState();
+    return s !== "idle" && s !== "error" && s !== "queued";
+  };
+  const frames = () => ACTIVITY_SPINNERS[props.getState()] ?? SPINNER_FRAMES;
+  const tick = () => globalTick();
+  const spinner = () => isActive() ? frames()[tick() % frames().length] : " ";
+  const pulseColor = () => isActive() ? PULSE_COLORS[tick() % PULSE_COLORS.length] : COLORS.textMuted;
+  const queueSlot = () => props.getQueued() > 0 ? toSuperscript(props.getQueued()) : " ";
+  const stateColor = () => {
+    if (props.getState() === "error")
+      return COLORS.error;
+    if (isActive())
+      return pulseColor();
+    return COLORS.textMuted;
+  };
+  return (() => {
+    var _el$14 = createElement("text"), _el$15 = createTextNode(` `);
+    insertNode(_el$14, _el$15);
+    insert(_el$14, queueSlot, _el$15);
+    insert(_el$14, () => props.name, _el$15);
+    insert(_el$14, spinner, null);
+    insert(_el$14, () => props.getState() === "error" ? " ERR" : "", null);
+    effect((_$p) => setProp(_el$14, "fg", stateColor(), _$p));
+    return _el$14;
+  })();
 }
 
 // src/ui/InputLine.tsx
@@ -40314,7 +40669,7 @@ function InputLine(props) {
   useKeyboard((key) => {
     if (props.disabled)
       return;
-    if (key.shift && (key.name === "enter" || key.name === "return")) {
+    if ((key.shift || key.option || key.meta) && (key.name === "enter" || key.name === "return")) {
       update(value.slice(0, cursor) + `
 ` + value.slice(cursor), cursor + 1);
       return;
@@ -40529,15 +40884,15 @@ function InputLine(props) {
 }
 
 // src/ui/ConfigWizard.tsx
-import { userInfo as userInfo3 } from "os";
+import { userInfo as userInfo2 } from "os";
 
 // src/config/detector.ts
-import { spawn as spawn4 } from "child_process";
-var DETECT_TIMEOUT = 5000;
+import { spawn as spawn3 } from "child_process";
+var DETECT_TIMEOUT = 1e4;
 function detectBinary(command) {
   return new Promise((resolve4) => {
     const timer = setTimeout(() => resolve4({ available: false }), DETECT_TIMEOUT);
-    const proc = spawn4(command, ["--version"], {
+    const proc = spawn3(command, ["--version"], {
       stdio: ["ignore", "pipe", "ignore"],
       shell: true,
       timeout: DETECT_TIMEOUT,
@@ -40562,33 +40917,13 @@ function detectBinary(command) {
     });
   });
 }
-function detectAlias(command) {
-  return new Promise((resolve4) => {
-    const shell = process.env.SHELL || "/bin/bash";
-    const timer = setTimeout(() => resolve4({ available: false }), DETECT_TIMEOUT);
-    const proc = spawn4(shell, ["-ic", `type ${command}`], {
-      stdio: ["ignore", "pipe", "ignore"],
-      timeout: DETECT_TIMEOUT,
-      detached: true
-    });
-    proc.unref();
-    proc.on("close", (code) => {
-      clearTimeout(timer);
-      resolve4({ available: code === 0 });
-    });
-    proc.on("error", () => {
-      clearTimeout(timer);
-      resolve4({ available: false });
-    });
-  });
-}
 async function detectProviders() {
   const results = await Promise.allSettled(PROVIDERS.map(async (provider) => {
-    const result = provider.detectType === "alias" ? await detectAlias(provider.detectCommand) : await detectBinary(provider.detectCommand);
+    const result = await detectBinary(provider.detectCommand);
     return {
       id: provider.id,
       available: result.available,
-      version: "version" in result ? result.version : undefined
+      version: result.version
     };
   }));
   return results.map((result, i) => {
@@ -40600,57 +40935,8 @@ async function detectProviders() {
 
 // src/config/writer.ts
 import { writeFile as writeFile6, mkdir as mkdir6 } from "fs/promises";
-import { userInfo as userInfo2 } from "os";
 import path10 from "path";
-async function writeWizardConfig(selectedIds, overrides, existingConfig) {
-  const overrideMap = new Map((overrides || []).map((o) => [o.id, o]));
-  const existingByProvider = new Map;
-  if (existingConfig?.agents) {
-    for (const agent of existingConfig.agents) {
-      existingByProvider.set(agent.provider, agent);
-    }
-  }
-  const agents = selectedIds.map((id) => {
-    const def = PROVIDERS.find((p) => p.id === id);
-    if (!def)
-      throw new Error(`Unknown provider: ${id}`);
-    const override = overrideMap.get(id);
-    const existing = existingByProvider.get(id);
-    const agent = {
-      name: override?.name || def.displayName,
-      tag: override?.tag || def.defaultTag,
-      provider: def.id,
-      model: override?.model || def.defaultModel
-    };
-    if (existing?.env) {
-      agent.env = { ...existing.env };
-    } else if (def.env) {
-      agent.env = { ...def.env };
-    }
-    if (existing?.prompts)
-      agent.prompts = existing.prompts;
-    if (existing?.preloadSkills)
-      agent.preloadSkills = existing.preloadSkills;
-    if (existing?.executablePath)
-      agent.executablePath = existing.executablePath;
-    if (existing?.timeout)
-      agent.timeout = existing.timeout;
-    return agent;
-  });
-  const config = {
-    humanName: existingConfig?.humanName || userInfo2().username || "USER",
-    humanTag: existingConfig?.humanTag,
-    maxAutoHops: existingConfig?.maxAutoHops ?? 15,
-    timeout: existingConfig?.timeout,
-    reminderInterval: existingConfig?.reminderInterval,
-    agents
-  };
-  if (!config.humanTag)
-    delete config.humanTag;
-  if (config.timeout === undefined)
-    delete config.timeout;
-  if (config.reminderInterval === undefined)
-    delete config.reminderInterval;
+async function writeConfig(config) {
   await mkdir6(LLM_PARTY_HOME, { recursive: true });
   const configPath = path10.join(LLM_PARTY_HOME, "config.json");
   await writeFile6(configPath, JSON.stringify(config, null, 2) + `
@@ -40663,16 +40949,114 @@ function MultiSelect(props) {
   const [focused, setFocused] = createSignal(props.items.findIndex((item) => !item.disabled));
   const [selected, setSelected] = createSignal(new Set(props.initialSelected || []));
   const [error, setError] = createSignal("");
+  const [addingCustom, setAddingCustom] = createSignal(false);
+  const [customName, setCustomName] = createSignal("");
+  const [customCursor, setCustomCursor] = createSignal(0);
+  const tuiRenderer = useRenderer();
+  createEffect(() => {
+    const handlePaste = (event) => {
+      if (!addingCustom())
+        return;
+      const text = new TextDecoder().decode(event.bytes);
+      if (!text)
+        return;
+      const cleaned = text.replace(/\n/g, "");
+      if (!cleaned)
+        return;
+      const c = customCursor();
+      const val = customName();
+      setCustomName(val.slice(0, c) + cleaned + val.slice(c));
+      setCustomCursor(c + cleaned.length);
+    };
+    tuiRenderer.keyInput.on("paste", handlePaste);
+    onCleanup(() => {
+      tuiRenderer.keyInput.off("paste", handlePaste);
+    });
+  });
+  const totalRows = () => props.items.length + (props.addCustom ? 1 : 0);
+  const isAddCustomRow = (idx) => props.addCustom && idx === props.items.length;
   const findNextEnabled = (from, direction) => {
+    const total = totalRows();
     let idx = from;
-    for (let i = 0;i < props.items.length; i++) {
-      idx = (idx + direction + props.items.length) % props.items.length;
+    for (let i = 0;i < total; i++) {
+      idx = (idx + direction + total) % total;
+      if (isAddCustomRow(idx))
+        return idx;
       if (!props.items[idx].disabled)
         return idx;
     }
     return from;
   };
   useKeyboard((key) => {
+    if (addingCustom()) {
+      if (key.name === "escape") {
+        setAddingCustom(false);
+        setCustomName("");
+        setCustomCursor(0);
+        return;
+      }
+      if (key.name === "enter" || key.name === "return") {
+        const name = customName().trim();
+        if (name.length > 0) {
+          props.addCustom.onAdd(name);
+          setAddingCustom(false);
+          setCustomName("");
+          setCustomCursor(0);
+        }
+        return;
+      }
+      if (key.name === "backspace") {
+        const c = customCursor();
+        if (c > 0) {
+          const val = customName();
+          setCustomName(val.slice(0, c - 1) + val.slice(c));
+          setCustomCursor(c - 1);
+        }
+        return;
+      }
+      if (key.name === "delete") {
+        const c = customCursor();
+        const val = customName();
+        if (c < val.length) {
+          setCustomName(val.slice(0, c) + val.slice(c + 1));
+        }
+        return;
+      }
+      if (key.name === "left") {
+        setCustomCursor((c) => Math.max(0, c - 1));
+        return;
+      }
+      if (key.name === "right") {
+        setCustomCursor((c) => Math.min(customName().length, c + 1));
+        return;
+      }
+      if (key.name === "home" || key.ctrl && key.name === "a") {
+        setCustomCursor(0);
+        return;
+      }
+      if (key.name === "end" || key.ctrl && key.name === "e") {
+        setCustomCursor(customName().length);
+        return;
+      }
+      if (key.ctrl && key.name === "u") {
+        setCustomName("");
+        setCustomCursor(0);
+        return;
+      }
+      if (key.ctrl || key.name === "up" || key.name === "down" || key.name === "pageup" || key.name === "pagedown" || key.name === "tab") {
+        return;
+      }
+      const ch = key.sequence;
+      if (ch && ch.length > 0 && !ch.startsWith("\x1B")) {
+        if (ch === "'" || ch === '"' || ch === "`")
+          return;
+        const c = customCursor();
+        const val = customName();
+        setCustomName(val.slice(0, c) + ch + val.slice(c));
+        setCustomCursor(c + ch.length);
+      }
+      return;
+    }
     if (key.name === "up" || key.name === "k") {
       setFocused((f) => findNextEnabled(f, -1));
       setError("");
@@ -40684,13 +41068,20 @@ function MultiSelect(props) {
       return;
     }
     if (key.name === "space" || key.sequence === " ") {
-      if (focused() >= 0 && !props.items[focused()].disabled) {
+      const f = focused();
+      if (isAddCustomRow(f)) {
+        setAddingCustom(true);
+        setCustomName("");
+        setCustomCursor(0);
+        return;
+      }
+      if (f >= 0 && !props.items[f].disabled) {
         setSelected((prev) => {
           const next = new Set(prev);
-          if (next.has(focused())) {
-            next.delete(focused());
+          if (next.has(f)) {
+            next.delete(f);
           } else {
-            next.add(focused());
+            next.add(f);
           }
           return next;
         });
@@ -40699,6 +41090,13 @@ function MultiSelect(props) {
       return;
     }
     if (key.name === "enter" || key.name === "return") {
+      const f = focused();
+      if (isAddCustomRow(f)) {
+        setAddingCustom(true);
+        setCustomName("");
+        setCustomCursor(0);
+        return;
+      }
       if (selected().size === 0) {
         setError("Select at least one agent");
         return;
@@ -40720,7 +41118,7 @@ function MultiSelect(props) {
       },
       children: (item, i) => {
         const isSelected = () => selected().has(i());
-        const isFocused = () => i() === focused();
+        const isFocused = () => i() === focused() && !addingCustom();
         const isDisabled = () => !!item.disabled;
         const bullet = () => isSelected() ? "\u25CF" : "\u25CB";
         const bulletColor = () => isDisabled() ? COLORS.textFaint : isSelected() ? COLORS.success : COLORS.textSecondary;
@@ -40728,29 +41126,29 @@ function MultiSelect(props) {
         const descColor = () => isDisabled() ? COLORS.textFaint : COLORS.textMuted;
         const bgColor = () => isFocused() && !isDisabled() ? COLORS.bgFocus : undefined;
         return (() => {
-          var _el$4 = createElement("text"), _el$5 = createElement("span"), _el$6 = createTextNode(` `), _el$7 = createTextNode(` `), _el$8 = createElement("span"), _el$9 = createElement("span"), _el$0 = createTextNode(` `);
-          insertNode(_el$4, _el$5);
-          insertNode(_el$4, _el$8);
-          insertNode(_el$4, _el$9);
-          setProp(_el$4, "selectable", false);
-          insertNode(_el$5, _el$6);
-          insertNode(_el$5, _el$7);
-          insert(_el$5, bullet, _el$7);
-          insert(_el$8, () => item.label);
-          insertNode(_el$9, _el$0);
-          insert(_el$9, () => item.description, null);
+          var _el$0 = createElement("text"), _el$1 = createElement("span"), _el$10 = createTextNode(` `), _el$11 = createTextNode(` `), _el$12 = createElement("span"), _el$13 = createElement("span"), _el$14 = createTextNode(` `);
+          insertNode(_el$0, _el$1);
+          insertNode(_el$0, _el$12);
+          insertNode(_el$0, _el$13);
+          setProp(_el$0, "selectable", false);
+          insertNode(_el$1, _el$10);
+          insertNode(_el$1, _el$11);
+          insert(_el$1, bullet, _el$11);
+          insert(_el$12, () => item.label);
+          insertNode(_el$13, _el$14);
+          insert(_el$13, () => item.description, null);
           effect((_p$) => {
-            var _v$ = bgColor(), _v$2 = {
+            var _v$4 = bgColor(), _v$5 = {
               fg: bulletColor()
-            }, _v$3 = {
+            }, _v$6 = {
               fg: labelColor()
-            }, _v$4 = {
+            }, _v$7 = {
               fg: descColor()
             };
-            _v$ !== _p$.e && (_p$.e = setProp(_el$4, "bg", _v$, _p$.e));
-            _v$2 !== _p$.t && (_p$.t = setProp(_el$5, "style", _v$2, _p$.t));
-            _v$3 !== _p$.a && (_p$.a = setProp(_el$8, "style", _v$3, _p$.a));
-            _v$4 !== _p$.o && (_p$.o = setProp(_el$9, "style", _v$4, _p$.o));
+            _v$4 !== _p$.e && (_p$.e = setProp(_el$0, "bg", _v$4, _p$.e));
+            _v$5 !== _p$.t && (_p$.t = setProp(_el$1, "style", _v$5, _p$.t));
+            _v$6 !== _p$.a && (_p$.a = setProp(_el$12, "style", _v$6, _p$.a));
+            _v$7 !== _p$.o && (_p$.o = setProp(_el$13, "style", _v$7, _p$.o));
             return _p$;
           }, {
             e: undefined,
@@ -40758,21 +41156,96 @@ function MultiSelect(props) {
             a: undefined,
             o: undefined
           });
-          return _el$4;
+          return _el$0;
         })();
       }
     }), null);
+    insert(_el$, createComponent2(Show, {
+      get when() {
+        return props.addCustom;
+      },
+      get children() {
+        return createComponent2(Show, {
+          get when() {
+            return addingCustom();
+          },
+          get fallback() {
+            return (() => {
+              var _el$15 = createElement("text"), _el$16 = createElement("span"), _el$18 = createElement("span");
+              insertNode(_el$15, _el$16);
+              insertNode(_el$15, _el$18);
+              setProp(_el$15, "selectable", false);
+              insertNode(_el$16, createTextNode(` + `));
+              insertNode(_el$18, createTextNode(`Add Custom...`));
+              effect((_p$) => {
+                var _v$8 = focused() === props.items.length && !addingCustom() ? COLORS.bgFocus : undefined, _v$9 = {
+                  fg: COLORS.primary
+                }, _v$0 = {
+                  fg: COLORS.textSecondary
+                };
+                _v$8 !== _p$.e && (_p$.e = setProp(_el$15, "bg", _v$8, _p$.e));
+                _v$9 !== _p$.t && (_p$.t = setProp(_el$16, "style", _v$9, _p$.t));
+                _v$0 !== _p$.a && (_p$.a = setProp(_el$18, "style", _v$0, _p$.a));
+                return _p$;
+              }, {
+                e: undefined,
+                t: undefined,
+                a: undefined
+              });
+              return _el$15;
+            })();
+          },
+          get children() {
+            var _el$2 = createElement("text"), _el$3 = createElement("span"), _el$5 = createElement("span"), _el$7 = createElement("span");
+            insertNode(_el$2, _el$3);
+            insertNode(_el$2, _el$5);
+            insertNode(_el$2, _el$7);
+            setProp(_el$2, "selectable", false);
+            insertNode(_el$3, createTextNode(` + `));
+            insertNode(_el$5, createTextNode(`Name: `));
+            insert(_el$2, () => customName().slice(0, customCursor()), _el$7);
+            insert(_el$7, (() => {
+              var _c$ = memo2(() => customCursor() < customName().length);
+              return () => _c$() ? customName()[customCursor()] : " ";
+            })());
+            insert(_el$2, (() => {
+              var _c$2 = memo2(() => customCursor() < customName().length);
+              return () => _c$2() ? customName().slice(customCursor() + 1) : "";
+            })(), null);
+            effect((_p$) => {
+              var _v$ = {
+                fg: COLORS.primary
+              }, _v$2 = {
+                fg: COLORS.textSecondary
+              }, _v$3 = {
+                bg: COLORS.textPrimary,
+                fg: "#000000"
+              };
+              _v$ !== _p$.e && (_p$.e = setProp(_el$3, "style", _v$, _p$.e));
+              _v$2 !== _p$.t && (_p$.t = setProp(_el$5, "style", _v$2, _p$.t));
+              _v$3 !== _p$.a && (_p$.a = setProp(_el$7, "style", _v$3, _p$.a));
+              return _p$;
+            }, {
+              e: undefined,
+              t: undefined,
+              a: undefined
+            });
+            return _el$2;
+          }
+        });
+      }
+    }), null);
     insert(_el$, createComponent2(Show, {
       get when() {
         return error();
       },
       get children() {
-        var _el$2 = createElement("text"), _el$3 = createTextNode(`  `);
-        insertNode(_el$2, _el$3);
-        setProp(_el$2, "marginTop", 1);
-        insert(_el$2, error, null);
-        effect((_$p) => setProp(_el$2, "fg", COLORS.error, _$p));
-        return _el$2;
+        var _el$8 = createElement("text"), _el$9 = createTextNode(`  `);
+        insertNode(_el$8, _el$9);
+        setProp(_el$8, "marginTop", 1);
+        insert(_el$8, error, null);
+        effect((_$p) => setProp(_el$8, "fg", COLORS.error, _$p));
+        return _el$8;
       }
     }), null);
     return _el$;
@@ -40793,7 +41266,6 @@ var SWEEP_CHARS = ["\u2591", "\u2592", "\u2593", "\u2588", "\u2593", "\u2592", "
 var BAR_WIDTH = 6;
 function SweepBar(props) {
   const glow = SWEEP_CHARS.length;
-  const totalWidth = BAR_WIDTH * 2 + props.title.length + 2;
   const [pos, setPos] = createSignal(0);
   createEffect(() => {
     const interval = setInterval(() => setPos((p) => (p + 1) % (BAR_WIDTH + glow)), 50);
@@ -40869,22 +41341,105 @@ function useDiscoColor() {
   });
   return () => PARTY_COLORS[idx()];
 }
+function personaToEntry(agent) {
+  const env2 = agent.env ?? {};
+  return {
+    name: agent.name,
+    tag: agent.tag,
+    model: agent.model,
+    provider: agent.provider,
+    active: agent.active !== false,
+    authUrl: env2.AUTH_URL ?? "",
+    authToken: env2.AUTH_TOKEN ?? "",
+    cli: agent.cli ?? "claude",
+    prompts: agent.prompts,
+    preloadSkills: agent.preloadSkills,
+    executablePath: agent.executablePath,
+    timeout: agent.timeout,
+    extraEnv: extractExtraEnv(env2)
+  };
+}
+function extractExtraEnv(env2) {
+  const extra = {};
+  for (const [k2, v2] of Object.entries(env2)) {
+    if (k2 !== "AUTH_URL" && k2 !== "AUTH_TOKEN") {
+      extra[k2] = v2;
+    }
+  }
+  return Object.keys(extra).length > 0 ? extra : undefined;
+}
+function entryToPersona(entry) {
+  const config = {
+    name: entry.name.trim(),
+    tag: entry.tag.trim(),
+    provider: entry.provider,
+    model: entry.model.trim(),
+    active: entry.active
+  };
+  if (entry.provider === "custom") {
+    config.cli = entry.cli || "claude";
+    const env2 = {};
+    if (entry.authUrl)
+      env2.AUTH_URL = entry.authUrl;
+    if (entry.authToken)
+      env2.AUTH_TOKEN = entry.authToken;
+    if (entry.extraEnv)
+      Object.assign(env2, entry.extraEnv);
+    if (Object.keys(env2).length > 0)
+      config.env = env2;
+  }
+  if (entry.prompts)
+    config.prompts = entry.prompts;
+  if (entry.preloadSkills)
+    config.preloadSkills = entry.preloadSkills;
+  if (entry.executablePath)
+    config.executablePath = entry.executablePath;
+  if (entry.timeout)
+    config.timeout = entry.timeout;
+  return config;
+}
 function ConfigWizard(props) {
   const [step, setStep] = createSignal("detect");
   const [detection, setDetection] = createSignal([]);
-  const [selectedIds, setSelectedIds] = createSignal([]);
-  const [, setAgentConfigs] = createSignal([]);
   const [activeTab, setActiveTab] = createSignal(0);
   const [focusedField, setFocusedField] = createSignal(0);
   const [error, setError] = createSignal("");
   const [tick, setTick] = createSignal(0);
-  let inputRefsData = [];
-  let humanData = {
-    name: props.existingConfig?.humanName || userInfo3().username || "USER",
-    tag: props.existingConfig?.humanTag || toTag(props.existingConfig?.humanName || userInfo3().username || "USER")
+  const [customItems, setCustomItems] = createSignal([]);
+  let agentEntries = [];
+  let settingsData = {
+    name: props.existingConfig?.humanName || userInfo2().username || "USER",
+    tag: props.existingConfig?.humanTag || toTag(props.existingConfig?.humanName || userInfo2().username || "USER"),
+    maxHops: String(props.existingConfig?.maxAutoHops ?? 15),
+    timeout: String(props.existingConfig?.timeout ?? 600)
   };
   let cursorPos = 0;
   const spinner = useSpinner();
+  const tuiRenderer = useRenderer();
+  createEffect(() => {
+    const handlePaste = (event) => {
+      if (step() !== "configure")
+        return;
+      const text = new TextDecoder().decode(event.bytes);
+      if (!text)
+        return;
+      const cleaned = text.replace(/\n/g, "");
+      if (!cleaned)
+        return;
+      const fieldValue = getCurrentFieldValue();
+      const cursor = cursorPos;
+      updateField(fieldValue.slice(0, cursor) + cleaned + fieldValue.slice(cursor), cursor + cleaned.length);
+    };
+    tuiRenderer.keyInput.on("paste", handlePaste);
+    onCleanup(() => {
+      tuiRenderer.keyInput.off("paste", handlePaste);
+    });
+  });
+  createEffect(() => {
+    const existing = props.existingConfig?.agents ?? [];
+    const customs = existing.filter((a) => a.provider === "custom").map(personaToEntry);
+    setCustomItems(customs);
+  });
   createEffect(() => {
     detectProviders().then((results) => {
       setDetection(results);
@@ -40894,103 +41449,255 @@ function ConfigWizard(props) {
       setStep("providers");
     });
   });
-  const existingByProvider = () => new Map((props.existingConfig?.agents || []).map((a) => [a.provider, a]));
-  const initialSelected = () => props.existingConfig ? PROVIDERS.map((p, i) => existingByProvider().has(p.id) ? i : -1).filter((i) => i >= 0) : undefined;
-  const multiSelectItems = () => PROVIDERS.map((provider) => {
-    const result = detection().find((d2) => d2.id === provider.id);
-    const available = result?.available ?? false;
-    return {
-      label: provider.displayName,
-      description: available ? provider.description : provider.unavailableHint,
-      disabled: !available
-    };
-  });
-  const handleProviderConfirm = (selectedIndices) => {
-    const ids = selectedIndices.map((i) => PROVIDERS[i].id);
-    setSelectedIds(ids);
-    const configs = ids.map((id) => {
-      const def = PROVIDERS.find((p) => p.id === id);
-      const existing = existingByProvider().get(id);
+  const existingNative = () => {
+    const map = new Map;
+    for (const a of props.existingConfig?.agents ?? []) {
+      if (a.provider !== "custom")
+        map.set(a.provider, a);
+    }
+    return map;
+  };
+  const multiSelectItems = () => {
+    const nativeItems = PROVIDERS.map((provider) => {
+      const result = detection().find((d2) => d2.id === provider.id);
+      const available = result?.available ?? false;
       return {
-        id: def.id,
-        name: existing?.name || def.displayName,
-        tag: existing?.tag || def.defaultTag,
-        model: existing?.model || def.defaultModel
+        label: provider.displayName,
+        description: available ? provider.description : provider.unavailableHint,
+        disabled: !available
       };
     });
-    setAgentConfigs(configs);
-    inputRefsData = configs.map((c) => ({
-      ...c
+    const customs = customItems();
+    if (customs.length > 0) {
+      nativeItems.push({
+        label: "\u2500\u2500 Custom \u2500\u2500",
+        description: "",
+        disabled: true
+      });
+    }
+    const customEntries = customs.map((c) => ({
+      label: c.name,
+      description: "custom provider"
     }));
+    return [...nativeItems, ...customEntries];
+  };
+  const initialSelected = () => {
+    if (!props.existingConfig)
+      return;
+    const indices = [];
+    const nativeMap = existingNative();
+    PROVIDERS.forEach((p, i) => {
+      const existing = nativeMap.get(p.id);
+      if (existing && existing.active !== false)
+        indices.push(i);
+    });
+    const customs = customItems();
+    if (customs.length > 0) {
+      const offset = PROVIDERS.length + 1;
+      customs.forEach((c, i) => {
+        if (c.active)
+          indices.push(offset + i);
+      });
+    }
+    return indices.length > 0 ? indices : undefined;
+  };
+  const handleAddCustom = (name) => {
+    const entry = {
+      name,
+      tag: toTag(name),
+      model: "",
+      provider: "custom",
+      active: true,
+      authUrl: "",
+      authToken: "",
+      cli: "claude"
+    };
+    setCustomItems((prev) => [...prev, entry]);
+  };
+  const handleProviderConfirm = (selectedIndices) => {
+    const nativeMap = existingNative();
+    const customs = customItems();
+    const hasCustoms = customs.length > 0;
+    const customOffset = PROVIDERS.length + (hasCustoms ? 1 : 0);
+    const entries = [];
+    for (let i = 0;i < PROVIDERS.length; i++) {
+      const def = PROVIDERS[i];
+      const isSelected = selectedIndices.includes(i);
+      const existing = nativeMap.get(def.id);
+      if (isSelected || existing) {
+        entries.push({
+          name: existing?.name || def.displayName,
+          tag: existing?.tag || def.defaultTag,
+          model: existing?.model || def.defaultModel,
+          provider: def.id,
+          active: isSelected,
+          authUrl: "",
+          authToken: "",
+          cli: "claude",
+          prompts: existing?.prompts,
+          preloadSkills: existing?.preloadSkills,
+          executablePath: existing?.executablePath,
+          timeout: existing?.timeout
+        });
+      }
+    }
+    for (let i = 0;i < customs.length; i++) {
+      const isSelected = selectedIndices.includes(customOffset + i);
+      entries.push({
+        ...customs[i],
+        active: isSelected
+      });
+    }
+    agentEntries = entries;
     setActiveTab(0);
     setFocusedField(0);
-    cursorPos = configs[0]?.name.length || 0;
+    cursorPos = settingsData.name.length;
     setStep("configure");
   };
   const handleProviderCancel = () => {
     if (props.onCancel)
       props.onCancel();
   };
-  const isYouTab = () => activeTab() === 0;
+  const activeEntries = () => agentEntries.filter((e) => e.active);
+  const isSettingsTab = () => activeTab() === 0;
   const agentTabIndex = () => activeTab() - 1;
-  const totalTabs = () => (inputRefsData?.length || 0) + 1;
-  const maxFieldIndex = () => isYouTab() ? 1 : 2;
+  const totalTabs = () => activeEntries().length + 1;
+  const isCustomAgent = () => {
+    if (isSettingsTab())
+      return false;
+    const entry = activeEntries()[agentTabIndex()];
+    return entry?.provider === "custom";
+  };
+  const maxFieldIndex = () => {
+    if (isSettingsTab())
+      return 3;
+    return isCustomAgent() ? 4 : 2;
+  };
+  const getFieldValueForEntry = (entry, field) => {
+    if (entry.provider === "custom") {
+      return [entry.name, entry.tag, entry.model, entry.authUrl, entry.authToken][field];
+    }
+    return [entry.name, entry.tag, entry.model][field];
+  };
+  const getSettingsFieldValue = (field) => {
+    return [settingsData.name, settingsData.tag, settingsData.maxHops, settingsData.timeout][field];
+  };
+  const getCurrentFieldValue = () => {
+    if (isSettingsTab())
+      return getSettingsFieldValue(focusedField());
+    const entry = activeEntries()[agentTabIndex()];
+    if (!entry)
+      return "";
+    return getFieldValueForEntry(entry, focusedField());
+  };
+  const updateField = (value, newCursor) => {
+    if (isSettingsTab()) {
+      if (focusedField() === 0)
+        settingsData.name = value;
+      else if (focusedField() === 1)
+        settingsData.tag = value;
+      else if (focusedField() === 2)
+        settingsData.maxHops = value;
+      else
+        settingsData.timeout = value;
+    } else {
+      const entry = activeEntries()[agentTabIndex()];
+      if (!entry)
+        return;
+      if (entry.provider === "custom") {
+        if (focusedField() === 0)
+          entry.name = value;
+        else if (focusedField() === 1)
+          entry.tag = value;
+        else if (focusedField() === 2)
+          entry.model = value;
+        else if (focusedField() === 3)
+          entry.authUrl = value;
+        else
+          entry.authToken = value;
+      } else {
+        if (focusedField() === 0)
+          entry.name = value;
+        else if (focusedField() === 1)
+          entry.tag = value;
+        else
+          entry.model = value;
+      }
+    }
+    cursorPos = newCursor;
+    setError("");
+    setTick((n) => n + 1);
+  };
+  const isTagField = () => focusedField() === 1;
+  const isNumberField = () => isSettingsTab() && (focusedField() === 2 || focusedField() === 3);
   const saveConfig = async () => {
-    const configs = inputRefsData;
-    const human = humanData;
-    if (!human.name.trim()) {
-      setError("Your name cannot be empty");
+    if (!settingsData.name.trim()) {
+      setError("Name cannot be empty");
+      return;
+    }
+    if (!settingsData.tag.trim()) {
+      setError("Tag cannot be empty");
       return;
     }
-    if (!human.tag.trim()) {
-      setError("Your tag cannot be empty");
+    if (!TAG_PATTERN.test(settingsData.tag.trim())) {
+      setError("Tag can only contain letters, numbers, hyphens, underscores");
       return;
     }
-    if (!TAG_PATTERN.test(human.tag.trim())) {
-      setError("Your tag can only contain letters, numbers, hyphens, underscores");
+    const maxHops = parseInt(settingsData.maxHops, 10);
+    if (isNaN(maxHops) || maxHops < 0) {
+      setError("Max Hops must be 0 or a positive number");
       return;
     }
-    for (const c of configs) {
-      if (!c.name.trim()) {
-        setError(`Name cannot be empty for ${c.id}`);
+    const timeout = parseInt(settingsData.timeout, 10);
+    if (isNaN(timeout) || timeout < 0) {
+      setError("Timeout must be 0 or a positive number");
+      return;
+    }
+    const tags = new Set;
+    tags.add(settingsData.tag.trim().toLowerCase());
+    for (const entry of agentEntries) {
+      if (!entry.name.trim()) {
+        setError(`Name cannot be empty for an agent`);
         return;
       }
-      if (!c.tag.trim()) {
-        setError(`Tag cannot be empty for ${c.id}`);
+      if (!entry.tag.trim()) {
+        setError(`Tag cannot be empty for ${entry.name}`);
         return;
       }
-      if (!TAG_PATTERN.test(c.tag.trim())) {
-        setError(`Tag for ${c.name} can only contain letters, numbers, hyphens, underscores`);
+      if (!TAG_PATTERN.test(entry.tag.trim())) {
+        setError(`Tag for ${entry.name} can only contain letters, numbers, hyphens, underscores`);
         return;
       }
-      if (!c.model.trim()) {
-        setError(`Model cannot be empty for ${c.id}`);
+      if (!entry.model.trim()) {
+        setError(`Model cannot be empty for ${entry.name}`);
         return;
       }
-    }
-    const names = new Set;
-    for (const c of configs) {
-      const lower = c.name.trim().toLowerCase();
-      if (names.has(lower)) {
-        setError(`Duplicate agent name: ${c.name}`);
+      const tagLower = entry.tag.trim().toLowerCase();
+      if (tags.has(tagLower)) {
+        setError(`Duplicate tag: ${entry.tag}`);
+        return;
+      }
+      tags.add(tagLower);
+      if (entry.provider === "custom" && entry.active && !entry.authUrl.trim()) {
+        setError(`URL is required for ${entry.name}`);
         return;
       }
-      names.add(lower);
     }
-    const overrides = configs.map((c) => ({
-      id: c.id,
-      name: c.name.trim(),
-      tag: c.tag.trim(),
-      model: c.model.trim()
-    }));
-    const mergedExisting = {
-      ...props.existingConfig || {},
-      humanName: human.name.trim(),
-      humanTag: human.tag.trim(),
-      agents: props.existingConfig?.agents || []
+    const agents = agentEntries.map(entryToPersona);
+    const config = {
+      humanName: settingsData.name.trim(),
+      humanTag: settingsData.tag.trim(),
+      maxAutoHops: maxHops,
+      timeout: timeout > 0 ? timeout : undefined,
+      reminderInterval: props.existingConfig?.reminderInterval,
+      agents
     };
+    if (config.timeout === undefined)
+      delete config.timeout;
+    if (config.reminderInterval === undefined)
+      delete config.reminderInterval;
     try {
-      await writeWizardConfig(selectedIds(), overrides, mergedExisting);
+      await writeConfig(config);
       setStep("done");
     } catch (err) {
       setError(`Failed to save: ${err.message}`);
@@ -41002,9 +41709,8 @@ function ConfigWizard(props) {
       return;
     }
     if (step() !== "configure") {
-      if (step() === "detect") {
+      if (step() === "detect")
         return;
-      }
       if (step() === "done") {
         if (key.name === "enter" || key.name === "return" || key.name === "space") {
           props.onComplete();
@@ -41013,49 +41719,20 @@ function ConfigWizard(props) {
       }
       return;
     }
-    const configs = inputRefsData;
-    const human = humanData;
-    let fieldValue;
-    if (isYouTab()) {
-      fieldValue = focusedField() === 0 ? human.name : human.tag;
-    } else {
-      const current = configs[agentTabIndex()];
-      if (!current)
-        return;
-      fieldValue = [current.name, current.tag, current.model][focusedField()];
-    }
+    const fieldValue = getCurrentFieldValue();
     const cursor = cursorPos;
-    const updateField = (value, newCursor) => {
-      if (isYouTab()) {
-        if (focusedField() === 0)
-          human.name = value;
-        else
-          human.tag = value;
-      } else {
-        const current = configs[agentTabIndex()];
-        if (focusedField() === 0)
-          current.name = value;
-        else if (focusedField() === 1)
-          current.tag = value;
-        else
-          current.model = value;
-      }
-      cursorPos = newCursor;
-      setError("");
-      setTick((n) => n + 1);
-    };
     if (key.sequence === "[" || key.sequence === "]") {
       const dir = key.sequence === "[" ? -1 : 1;
       const next = (activeTab() + dir + totalTabs()) % totalTabs();
       setActiveTab(next);
-      const newMax = next === 0 ? 1 : 2;
+      const newMax = next === 0 ? 3 : activeEntries()[next - 1]?.provider === "custom" ? 4 : 2;
       const newField = Math.min(focusedField(), newMax);
       setFocusedField(newField);
       let newVal;
       if (next === 0) {
-        newVal = newField === 0 ? human.name : human.tag;
+        newVal = getSettingsFieldValue(newField);
       } else {
-        newVal = getFieldValue(configs[next - 1], newField);
+        newVal = getFieldValueForEntry(activeEntries()[next - 1], newField);
       }
       cursorPos = newVal.length;
       setTick((n) => n + 1);
@@ -41065,12 +41742,7 @@ function ConfigWizard(props) {
       const fieldCount = maxFieldIndex() + 1;
       const nextField = key.shift ? (focusedField() - 1 + fieldCount) % fieldCount : (focusedField() + 1) % fieldCount;
       setFocusedField(nextField);
-      let newVal;
-      if (isYouTab()) {
-        newVal = nextField === 0 ? human.name : human.tag;
-      } else {
-        newVal = getFieldValue(configs[agentTabIndex()], nextField);
-      }
+      const newVal = isSettingsTab() ? getSettingsFieldValue(nextField) : getFieldValueForEntry(activeEntries()[agentTabIndex()], nextField);
       cursorPos = newVal.length;
       setTick((n) => n + 1);
       return;
@@ -41125,7 +41797,7 @@ function ConfigWizard(props) {
       return;
     }
     if (key.name === "space" || key.sequence === " ") {
-      if (focusedField() !== 1) {
+      if (!isTagField() && !isNumberField()) {
         updateField(fieldValue.slice(0, cursor) + " " + fieldValue.slice(cursor), cursor + 1);
       }
       return;
@@ -41134,7 +41806,9 @@ function ConfigWizard(props) {
     if (ch && ch.length > 0 && !ch.startsWith("\x1B")) {
       if (ch === "'" || ch === '"' || ch === "`")
         return;
-      if (focusedField() === 1 && !TAG_PATTERN.test(ch))
+      if (isTagField() && !TAG_PATTERN.test(ch))
+        return;
+      if (isNumberField() && !/^[0-9]$/.test(ch))
         return;
       updateField(fieldValue.slice(0, cursor) + ch + fieldValue.slice(cursor), cursor + ch.length);
     }
@@ -41152,7 +41826,7 @@ function ConfigWizard(props) {
     })();
   }
   const discoColor = useDiscoColor();
-  function renderField(label, value, isFocused) {
+  function renderField(label, value, isFocused, hint) {
     tick();
     const cursor = cursorPos;
     const labelColor = isFocused ? COLORS.primary : COLORS.textDim;
@@ -41175,7 +41849,7 @@ function ConfigWizard(props) {
         setProp(_el$12, "style", {
           fg: valueColor
         });
-        insert(_el$12, value);
+        insert(_el$12, value || (hint ? hint : ""));
         effect((_$p) => setProp(_el$0, "style", {
           fg: COLORS.borderStrong
         }, _$p));
@@ -41210,6 +41884,13 @@ function ConfigWizard(props) {
       return _el$13;
     })();
   }
+  function renderTokenField(label, value, isFocused) {
+    if (!isFocused && value.length > 0) {
+      const masked = value.length > 4 ? "*".repeat(value.length - 4) + value.slice(-4) : "*".repeat(value.length);
+      return renderField(label, masked, false);
+    }
+    return renderField(label, value, isFocused);
+  }
   const DetectStep = () => (() => {
     var _el$19 = createElement("box"), _el$20 = createElement("box"), _el$21 = createElement("box"), _el$22 = createElement("text"), _el$23 = createTextNode(` Scanning for installed CLIs...`);
     insertNode(_el$19, _el$20);
@@ -41325,6 +42006,9 @@ function ConfigWizard(props) {
       },
       get initialSelected() {
         return initialSelected();
+      },
+      addCustom: {
+        onAdd: handleAddCustom
       }
     }));
     effect((_p$) => {
@@ -41362,12 +42046,8 @@ function ConfigWizard(props) {
   })();
   const ConfigureStep = () => {
     tick();
-    const configs = inputRefsData;
-    const human = humanData;
-    const tabLabels = ["You", ...selectedIds().map((id) => {
-      const def = PROVIDERS.find((p) => p.id === id);
-      return def?.displayName || id;
-    })];
+    const active = activeEntries();
+    const tabLabels = ["Settings", ...active.map((e) => e.name)];
     return (() => {
       var _el$48 = createElement("box"), _el$49 = createElement("box"), _el$50 = createElement("box"), _el$51 = createElement("box"), _el$52 = createElement("box"), _el$53 = createElement("text"), _el$55 = createElement("box"), _el$56 = createElement("box"), _el$60 = createElement("box"), _el$61 = createElement("text"), _el$62 = createElement("span"), _el$64 = createElement("span"), _el$66 = createElement("span"), _el$68 = createElement("span"), _el$70 = createElement("span"), _el$72 = createElement("span"), _el$74 = createElement("span"), _el$76 = createElement("span"), _el$78 = createElement("span"), _el$80 = createElement("span"), _el$82 = createElement("span"), _el$84 = createElement("span"), _el$86 = createElement("span");
       insertNode(_el$48, _el$49);
@@ -41439,7 +42119,7 @@ function ConfigWizard(props) {
       setProp(_el$56, "flexDirection", "column");
       insert(_el$56, createComponent2(Show, {
         get when() {
-          return isYouTab();
+          return isSettingsTab();
         },
         get fallback() {
           return [(() => {
@@ -41448,19 +42128,39 @@ function ConfigWizard(props) {
             setProp(_el$94, "marginBottom", 1);
             insertNode(_el$95, _el$96);
             insert(_el$95, () => tabLabels[activeTab()], _el$96);
+            insert(_el$94, createComponent2(Show, {
+              get when() {
+                return activeEntries()[agentTabIndex()]?.provider === "custom";
+              },
+              get children() {
+                var _el$97 = createElement("span");
+                insertNode(_el$97, createTextNode(` (custom)`));
+                effect((_$p) => setProp(_el$97, "style", {
+                  fg: COLORS.textFaint
+                }, _$p));
+                return _el$97;
+              }
+            }), null);
             effect((_$p) => setProp(_el$94, "fg", COLORS.success, _$p));
             return _el$94;
-          })(), memo2(() => renderField("Name ", configs[agentTabIndex()].name, focusedField() === 0)), memo2(() => renderField("Tag  ", configs[agentTabIndex()].tag, focusedField() === 1)), memo2(() => renderField("Model", configs[agentTabIndex()].model, focusedField() === 2))];
+          })(), memo2(() => renderField("Name ", active[agentTabIndex()].name, focusedField() === 0)), memo2(() => renderField("Tag  ", active[agentTabIndex()].tag, focusedField() === 1)), memo2(() => renderField("Model", active[agentTabIndex()].model, focusedField() === 2)), createComponent2(Show, {
+            get when() {
+              return active[agentTabIndex()]?.provider === "custom";
+            },
+            get children() {
+              return [memo2(() => renderField("URL  ", active[agentTabIndex()].authUrl, focusedField() === 3)), memo2(() => renderTokenField("Token", active[agentTabIndex()].authToken, focusedField() === 4))];
+            }
+          })];
         },
         get children() {
           return [(() => {
             var _el$57 = createElement("text"), _el$58 = createElement("strong");
             insertNode(_el$57, _el$58);
             setProp(_el$57, "marginBottom", 1);
-            insertNode(_el$58, createTextNode(`Your Identity`));
+            insertNode(_el$58, createTextNode(`General Settings`));
             effect((_$p) => setProp(_el$57, "fg", COLORS.agent, _$p));
             return _el$57;
-          })(), memo2(() => renderField("Name", human.name, focusedField() === 0)), memo2(() => renderField("Tag ", human.tag, focusedField() === 1))];
+          })(), memo2(() => renderField("Name    ", settingsData.name, focusedField() === 0)), memo2(() => renderField("Tag     ", settingsData.tag, focusedField() === 1)), memo2(() => renderField("Max Hops", settingsData.maxHops, focusedField() === 2, "0 = unlimited")), memo2(() => renderField("Timeout ", settingsData.timeout, focusedField() === 3, "0 = unlimited"))];
         }
       }));
       insertNode(_el$60, _el$61);
@@ -41520,7 +42220,7 @@ function ConfigWizard(props) {
         }
       }), null);
       effect((_p$) => {
-        var _v$13 = discoColor(), _v$14 = COLORS.bgPanel, _v$15 = COLORS.borderStrong, _v$16 = isYouTab() ? COLORS.agent : COLORS.success, _v$17 = COLORS.bgContent, _v$18 = {
+        var _v$13 = discoColor(), _v$14 = COLORS.bgPanel, _v$15 = COLORS.borderStrong, _v$16 = isSettingsTab() ? COLORS.agent : COLORS.success, _v$17 = COLORS.bgContent, _v$18 = {
           fg: COLORS.textFaint
         }, _v$19 = {
           fg: COLORS.success
@@ -41590,57 +42290,57 @@ function ConfigWizard(props) {
     })();
   };
   const DoneStep = () => (() => {
-    var _el$97 = createElement("box"), _el$98 = createElement("box"), _el$99 = createElement("box"), _el$100 = createElement("text"), _el$102 = createElement("text"), _el$104 = createElement("text"), _el$106 = createElement("text"), _el$108 = createElement("text"), _el$110 = createElement("text"), _el$111 = createTextNode(`Press `), _el$112 = createElement("span"), _el$113 = createElement("strong"), _el$115 = createTextNode(` to continue`);
-    insertNode(_el$97, _el$98);
-    setProp(_el$97, "flexDirection", "column");
-    setProp(_el$97, "width", "100%");
-    setProp(_el$97, "height", "100%");
-    setProp(_el$97, "justifyContent", "center");
-    setProp(_el$97, "alignItems", "center");
-    insertNode(_el$98, _el$99);
-    setProp(_el$98, "border", true);
-    setProp(_el$98, "borderStyle", "double");
-    setProp(_el$98, "paddingX", 4);
-    setProp(_el$98, "paddingY", 2);
+    var _el$99 = createElement("box"), _el$100 = createElement("box"), _el$101 = createElement("box"), _el$102 = createElement("text"), _el$104 = createElement("text"), _el$106 = createElement("text"), _el$108 = createElement("text"), _el$110 = createElement("text"), _el$112 = createElement("text"), _el$113 = createTextNode(`Press `), _el$114 = createElement("span"), _el$115 = createElement("strong"), _el$117 = createTextNode(` to continue`);
     insertNode(_el$99, _el$100);
-    insertNode(_el$99, _el$102);
-    insertNode(_el$99, _el$104);
-    insertNode(_el$99, _el$106);
-    insertNode(_el$99, _el$108);
-    insertNode(_el$99, _el$110);
     setProp(_el$99, "flexDirection", "column");
+    setProp(_el$99, "width", "100%");
+    setProp(_el$99, "height", "100%");
+    setProp(_el$99, "justifyContent", "center");
     setProp(_el$99, "alignItems", "center");
-    insert(_el$99, createComponent2(SweepBar, {
+    insertNode(_el$100, _el$101);
+    setProp(_el$100, "border", true);
+    setProp(_el$100, "borderStyle", "double");
+    setProp(_el$100, "paddingX", 4);
+    setProp(_el$100, "paddingY", 2);
+    insertNode(_el$101, _el$102);
+    insertNode(_el$101, _el$104);
+    insertNode(_el$101, _el$106);
+    insertNode(_el$101, _el$108);
+    insertNode(_el$101, _el$110);
+    insertNode(_el$101, _el$112);
+    setProp(_el$101, "flexDirection", "column");
+    setProp(_el$101, "alignItems", "center");
+    insert(_el$101, createComponent2(SweepBar, {
       title: "Config Saved"
-    }), _el$100);
-    insertNode(_el$100, createTextNode(`\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500`));
-    setProp(_el$100, "marginTop", 1);
-    insertNode(_el$102, createTextNode(`Written to ~/.llm-party/config.json`));
+    }), _el$102);
+    insertNode(_el$102, createTextNode(`\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500`));
     setProp(_el$102, "marginTop", 1);
-    insertNode(_el$104, createTextNode(`Edit this file anytime to add prompts,`));
+    insertNode(_el$104, createTextNode(`Written to ~/.llm-party/config.json`));
     setProp(_el$104, "marginTop", 1);
-    insertNode(_el$106, createTextNode(`env vars, or tweak settings.`));
-    insertNode(_el$108, createTextNode(`\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500`));
-    setProp(_el$108, "marginTop", 1);
-    insertNode(_el$110, _el$111);
-    insertNode(_el$110, _el$112);
-    insertNode(_el$110, _el$115);
+    insertNode(_el$106, createTextNode(`Edit this file anytime to add prompts,`));
+    setProp(_el$106, "marginTop", 1);
+    insertNode(_el$108, createTextNode(`env vars, or tweak settings.`));
+    insertNode(_el$110, createTextNode(`\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500`));
     setProp(_el$110, "marginTop", 1);
     insertNode(_el$112, _el$113);
-    insertNode(_el$113, createTextNode(`Enter`));
+    insertNode(_el$112, _el$114);
+    insertNode(_el$112, _el$117);
+    setProp(_el$112, "marginTop", 1);
+    insertNode(_el$114, _el$115);
+    insertNode(_el$115, createTextNode(`Enter`));
     effect((_p$) => {
       var _v$33 = discoColor(), _v$34 = COLORS.bgPanel, _v$35 = COLORS.textSubtle, _v$36 = COLORS.textMuted, _v$37 = COLORS.textSubtle, _v$38 = COLORS.textSubtle, _v$39 = COLORS.textSubtle, _v$40 = COLORS.primary, _v$41 = {
         fg: COLORS.success
       };
-      _v$33 !== _p$.e && (_p$.e = setProp(_el$98, "borderColor", _v$33, _p$.e));
-      _v$34 !== _p$.t && (_p$.t = setProp(_el$98, "backgroundColor", _v$34, _p$.t));
-      _v$35 !== _p$.a && (_p$.a = setProp(_el$100, "fg", _v$35, _p$.a));
-      _v$36 !== _p$.o && (_p$.o = setProp(_el$102, "fg", _v$36, _p$.o));
-      _v$37 !== _p$.i && (_p$.i = setProp(_el$104, "fg", _v$37, _p$.i));
-      _v$38 !== _p$.n && (_p$.n = setProp(_el$106, "fg", _v$38, _p$.n));
-      _v$39 !== _p$.s && (_p$.s = setProp(_el$108, "fg", _v$39, _p$.s));
-      _v$40 !== _p$.h && (_p$.h = setProp(_el$110, "fg", _v$40, _p$.h));
-      _v$41 !== _p$.r && (_p$.r = setProp(_el$112, "style", _v$41, _p$.r));
+      _v$33 !== _p$.e && (_p$.e = setProp(_el$100, "borderColor", _v$33, _p$.e));
+      _v$34 !== _p$.t && (_p$.t = setProp(_el$100, "backgroundColor", _v$34, _p$.t));
+      _v$35 !== _p$.a && (_p$.a = setProp(_el$102, "fg", _v$35, _p$.a));
+      _v$36 !== _p$.o && (_p$.o = setProp(_el$104, "fg", _v$36, _p$.o));
+      _v$37 !== _p$.i && (_p$.i = setProp(_el$106, "fg", _v$37, _p$.i));
+      _v$38 !== _p$.n && (_p$.n = setProp(_el$108, "fg", _v$38, _p$.n));
+      _v$39 !== _p$.s && (_p$.s = setProp(_el$110, "fg", _v$39, _p$.s));
+      _v$40 !== _p$.h && (_p$.h = setProp(_el$112, "fg", _v$40, _p$.h));
+      _v$41 !== _p$.r && (_p$.r = setProp(_el$114, "style", _v$41, _p$.r));
       return _p$;
     }, {
       e: undefined,
@@ -41653,7 +42353,7 @@ function ConfigWizard(props) {
       h: undefined,
       r: undefined
     });
-    return _el$97;
+    return _el$99;
   })();
   return [createComponent2(Show, {
     get when() {
@@ -41685,13 +42385,6 @@ function ConfigWizard(props) {
     }
   })];
 }
-function getFieldValue(config, field) {
-  if (field === 0)
-    return config.name;
-  if (field === 1)
-    return config.tag;
-  return config.model;
-}
 
 // src/ui/AgentsPanel.tsx
 function AgentsPanel(props) {
@@ -41996,7 +42689,7 @@ function InfoPanel(props) {
 
 // src/ui/App.tsx
 function copyToClipboard(text) {
-  const proc = spawn5("pbcopy", [], {
+  const proc = spawn4("pbcopy", [], {
     stdio: ["pipe", "ignore", "ignore"]
   });
   proc.stdin?.write(text);
@@ -42018,29 +42711,64 @@ function App(props) {
   const {
     messages,
     agentStates,
+    queueCounts,
     stickyTarget,
     dispatching,
     dispatch,
     addSystemMessage,
-    clearMessages
-  } = useOrchestrator(props.orchestrator, props.maxAutoHops);
+    addDisplayMessage,
+    clearMessages,
+    refreshStickyTarget
+  } = useOrchestrator(props.orchestrator);
   const humanName = props.orchestrator.getHumanName();
   const agents = props.orchestrator.listAgents();
   let scrollRef = null;
   const [screen, setScreen] = createSignal("chat");
+  const [freshConfig, setFreshConfig] = createSignal(props.config);
   const [showAgents, setShowAgents] = createSignal(false);
   const [showInfo, setShowInfo] = createSignal(false);
-  process.on("SIGINT", () => renderer.destroy());
-  process.on("SIGTERM", () => renderer.destroy());
-  process.on("SIGHUP", () => renderer.destroy());
+  const resumeSession = async (sessionId) => {
+    try {
+      const restored = await props.orchestrator.loadTranscript(sessionId);
+      const displayMsgs = restored.map((msg) => {
+        const isHuman = msg.from.toUpperCase() === humanName.toUpperCase();
+        const agentInfo = agents.find((a) => a.name.toUpperCase() === msg.from.toUpperCase());
+        return {
+          ...msg,
+          type: isHuman ? "user" : "agent",
+          provider: agentInfo?.provider ?? "",
+          tag: agentInfo?.tag ?? ""
+        };
+      });
+      for (const msg of displayMsgs) {
+        addDisplayMessage(msg);
+      }
+      refreshStickyTarget();
+      addSystemMessage(`Resumed session ${sessionId} (${restored.length} messages)`);
+    } catch (err) {
+      addSystemMessage(`Failed to resume: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  };
+  onMount(() => {
+    if (props.resumeSessionId) {
+      resumeSession(props.resumeSessionId);
+    }
+  });
+  process.on("SIGINT", () => gracefulExit());
+  process.on("SIGTERM", () => gracefulExit());
+  process.on("SIGHUP", () => gracefulExit());
   process.on("SIGTSTP", () => {
     process.once("SIGCONT", () => renderer.resume());
     renderer.suspend();
   });
-  const gracefulExit = () => {
+  const gracefulExit = async () => {
+    await props.orchestrator.abortAll();
     renderer.destroy();
     const adapters = props.orchestrator.getAdapters();
-    Promise.allSettled(adapters.map((a) => a.destroy()));
+    Promise.allSettled(adapters.map((a) => a.destroy())).finally(() => {
+      process.exit(0);
+    });
+    setTimeout(() => process.exit(0), 2000);
   };
   useKeyboard((key) => {
     if (key.ctrl && key.name === "p") {
@@ -42101,6 +42829,10 @@ Transcript: ${props.orchestrator.getTranscriptPath()}`);
       return;
     }
     if (line === "/config") {
+      try {
+        const reloaded = await loadConfig2(props.configPath);
+        setFreshConfig(reloaded);
+      } catch {}
       setScreen("config");
       return;
     }
@@ -42115,6 +42847,19 @@ ${files.map((f) => `  ${f}`).join(`
       setShowInfo(true);
       return;
     }
+    if (line.startsWith("/resume")) {
+      const sid = line.replace("/resume", "").trim();
+      if (!sid) {
+        addSystemMessage("Usage: /resume <sessionId>");
+        return;
+      }
+      if (props.orchestrator.hasMessages()) {
+        addSystemMessage("Resume only works before the first message.");
+        return;
+      }
+      await resumeSession(sid);
+      return;
+    }
     if (line.startsWith("/flood")) {
       const args = line.split(/\s+/);
       const count = parseInt(args[1], 10) || 50;
@@ -42141,7 +42886,7 @@ ${lines.join(`
       return createComponent2(ConfigWizard, {
         isFirstRun: false,
         get existingConfig() {
-          return props.config;
+          return freshConfig();
         },
         onComplete: () => {
           addSystemMessage("Config saved. Restart llm-party to apply changes.");
@@ -42179,13 +42924,16 @@ ${lines.join(`
         },
         get stickyTarget() {
           return stickyTarget();
+        },
+        get queueCounts() {
+          return queueCounts();
         }
       }), null);
       insert(_el$, createComponent2(InputLine, {
         humanName,
         onSubmit: handleSubmit,
         get disabled() {
-          return dispatching() || showAgents() || showInfo();
+          return showAgents() || showInfo();
         },
         get disabledMessage() {
           return showAgents() ? "" : undefined;
@@ -42221,6 +42969,8 @@ ${lines.join(`
 async function main2() {
   const appRoot = path11.resolve(path11.dirname(fileURLToPath3(import.meta.url)), "..");
   await initLlmPartyHome(appRoot);
+  const resumeIndex = process.argv.indexOf("--resume");
+  const resumeSessionId = resumeIndex !== -1 ? process.argv[resumeIndex + 1] : undefined;
   const rendererConfig = {
     exitOnCtrlC: false,
     useMouse: true,
@@ -42231,14 +42981,14 @@ async function main2() {
     await render(() => ConfigWizard({
       isFirstRun: true,
       onComplete: async () => {
-        await bootApp(appRoot, rendererConfig);
+        await bootApp(appRoot, rendererConfig, resumeSessionId);
       }
     }), rendererConfig);
   } else {
-    await bootApp(appRoot, rendererConfig);
+    await bootApp(appRoot, rendererConfig, resumeSessionId);
   }
 }
-async function bootApp(appRoot, rendererConfig) {
+async function bootApp(appRoot, rendererConfig, resumeSessionId) {
   const configPath = await resolveConfigPath(appRoot);
   const config = await loadConfig2(configPath);
   const humanName = config.humanName?.trim() || "USER";
@@ -42258,7 +43008,8 @@ async function bootApp(appRoot, rendererConfig) {
 ` + obsidianPrompt;
   const availableSkills = await discoverSkills();
   const agentVerifiedSkills = new Map;
-  for (const agent of config.agents) {
+  const activeAgents = config.agents.filter((a) => a.active !== false);
+  for (const agent of activeAgents) {
     if (agent.preloadSkills && agent.preloadSkills.length > 0) {
       const verified = [];
       const report = [];
@@ -42279,11 +43030,11 @@ async function bootApp(appRoot, rendererConfig) {
   const resolveFromConfig = (value) => {
     return path11.isAbsolute(value) ? value : path11.resolve(configDir, value);
   };
-  const adapters = await Promise.all(config.agents.map(async (agent, _index, allAgents) => {
+  const adapters = await Promise.all(activeAgents.map(async (agent, _index, allAgents) => {
     const promptParts = [mergedBase];
     if (agent.prompts && agent.prompts.length > 0) {
       const extraPaths = agent.prompts.map((p) => resolveFromConfig(p));
-      const extraParts = await Promise.all(extraPaths.map((p) => readFile5(p, "utf8")));
+      const extraParts = await Promise.all(extraPaths.map((p) => readFile6(p, "utf8")));
       promptParts.push(...extraParts);
     }
     const promptTemplate = promptParts.join(`
@@ -42318,7 +43069,7 @@ ${mySkills.map((s) => `- ${s}`).join(`
       agentCount: String(allAgents.length),
       preloadedSkills
     });
-    const adapter = agent.provider === "claude" ? new ClaudeAdapter(agent.name, agent.model) : agent.provider === "codex" ? new CodexAdapter(agent.name, agent.model) : agent.provider === "copilot" ? new CopilotAdapter(agent.name, agent.model) : agent.provider === "glm" ? new GlmAdapter(agent.name, agent.model) : null;
+    const adapter = agent.provider === "claude" ? new ClaudeAdapter(agent.name, agent.model, humanName) : agent.provider === "codex" ? new CodexAdapter(agent.name, agent.model, humanName) : agent.provider === "copilot" ? new CopilotAdapter(agent.name, agent.model, humanName) : agent.provider === "custom" ? new CustomAdapter(agent.name, agent.model, humanName) : null;
     if (!adapter) {
       throw new Error(`Unsupported provider: ${agent.provider}`);
     }
@@ -42326,12 +43077,12 @@ ${mySkills.map((s) => `- ${s}`).join(`
     return adapter;
   }));
   const defaultTimeout = typeof config.timeout === "number" && config.timeout > 0 ? config.timeout * 1000 : 600000;
-  const agentTimeouts = Object.fromEntries(config.agents.filter((agent) => typeof agent.timeout === "number" && agent.timeout > 0).map((agent) => [agent.name, agent.timeout * 1000]));
-  const orchestrator = new Orchestrator(adapters, humanName, Object.fromEntries(config.agents.map((agent) => [agent.name, agent.tag?.trim() || toTag(agent.name)])), humanTag, defaultTimeout, agentTimeouts, { reminderInterval: config.reminderInterval });
-  await render(() => App({ orchestrator, maxAutoHops, config }), rendererConfig);
+  const agentTimeouts = Object.fromEntries(activeAgents.filter((agent) => typeof agent.timeout === "number" && agent.timeout > 0).map((agent) => [agent.name, agent.timeout * 1000]));
+  const orchestrator = new Orchestrator(adapters, humanName, Object.fromEntries(activeAgents.map((agent) => [agent.name, agent.tag?.trim() || toTag(agent.name)])), humanTag, defaultTimeout, agentTimeouts, { reminderInterval: config.reminderInterval, maxAutoHops });
+  await render(() => App({ orchestrator, config, configPath, resumeSessionId }), rendererConfig);
 }
 function resolveMaxAutoHops(value) {
-  if (value === "unlimited") {
+  if (typeof value === "number" && value === 0) {
     return Number.POSITIVE_INFINITY;
   }
   if (typeof value === "number" && Number.isFinite(value) && value >= 1) {