llm-party-cli 0.9.0 → 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;
@@ -37595,13 +37558,8 @@ class ClaudeBaseAdapter {
     }
     return { ...process.env, ...mapped, ...configEnv };
   }
-  async send(messages, signal) {
-    return await this.querySDK(formatTranscript(messages, this.name, this.humanName), signal);
-  }
-  async destroy() {
-    return;
-  }
-  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(),
@@ -37615,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;
   }
 }
 
@@ -38082,6 +38085,8 @@ class CodexAdapter {
   humanName;
   codex;
   thread;
+  threadId = "";
+  threadOptions = {};
   constructor(name, model, humanName) {
     this.name = name;
     this.model = model;
@@ -38095,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, this.name, this.humanName));
-    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
@@ -39302,6 +39360,7 @@ class CopilotAdapter {
   systemPrompt = "";
   cliPath;
   timeout = 600000;
+  copilotSessionId = "";
   constructor(name, model, humanName) {
     this.name = name;
     this.model = model;
@@ -39315,64 +39374,180 @@ 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;
     }
+    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;
   }
 }
 
@@ -39629,7 +39804,7 @@ async function loadConfig2(configPath) {
 }
 
 // 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";
 
@@ -39654,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;
@@ -39669,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)]));
@@ -39679,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;
   }
@@ -39697,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`);
   }
@@ -39739,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 {
@@ -39807,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;
   }
@@ -39857,6 +40291,21 @@ 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 spawn4 } from "child_process";
@@ -39868,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;
@@ -39889,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;
@@ -39902,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 = {
@@ -39918,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) => {
@@ -40015,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 = [];
@@ -40118,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);
@@ -40186,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
@@ -40500,7 +40888,7 @@ import { userInfo as userInfo2 } from "os";
 
 // src/config/detector.ts
 import { spawn as spawn3 } from "child_process";
-var DETECT_TIMEOUT = 5000;
+var DETECT_TIMEOUT = 1e4;
 function detectBinary(command) {
   return new Promise((resolve4) => {
     const timer = setTimeout(() => resolve4({ available: false }), DETECT_TIMEOUT);
@@ -42323,12 +42711,15 @@ 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;
@@ -42336,17 +42727,48 @@ function App(props) {
   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") {
@@ -42425,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;
@@ -42489,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;
@@ -42531,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,
@@ -42541,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";
@@ -42594,7 +43034,7 @@ async function bootApp(appRoot, rendererConfig) {
     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(`
@@ -42638,8 +43078,8 @@ ${mySkills.map((s) => `- ${s}`).join(`
   }));
   const defaultTimeout = typeof config.timeout === "number" && config.timeout > 0 ? config.timeout * 1000 : 600000;
   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 });
-  await render(() => App({ orchestrator, maxAutoHops, config, configPath }), rendererConfig);
+  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 (typeof value === "number" && value === 0) {