better-opencode-async-agents 0.2.1 → 0.4.0

package/dist/index.js

@@ -125,7 +125,7 @@ function getHomeDir() {
   console.warn("[constants] Could not determine home directory, using /tmp");
   return "/tmp";
 }
-var COMPLETION_DISPLAY_DURATION = 1e4, SPINNER_FRAMES, HOME_DIR, STORAGE_DIR, TASKS_FILE, FORK_MAX_TOKENS = 1e5, FORK_TOOL_RESULT_LIMIT = 1500, FORK_TOOL_PARAMS_LIMIT = 200;
+var COMPLETION_DISPLAY_DURATION = 1e4, SPINNER_FRAMES, HOME_DIR, STORAGE_DIR, TASKS_FILE, FORK_MAX_TOKENS = 1e5, FORK_TOOL_RESULT_LIMIT = 1500, FORK_TOOL_PARAMS_LIMIT = 200, DEFAULT_API_PORT = 5165, DEFAULT_API_HOST = "127.0.0.1", SERVER_INFO_FILENAME = "server.json", MAX_PORT_RETRY = 10, HEARTBEAT_INTERVAL_MS = 30000, MAX_SSE_SUBSCRIBERS = 50, DEFAULT_TASK_LIMIT = 50, MAX_TASK_LIMIT = 200;
 var init_constants = __esm(() => {
   SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
   HOME_DIR = getHomeDir();
@@ -136,11 +136,15 @@ var init_constants = __esm(() => {
 // src/storage.ts
 var exports_storage = {};
 __export(exports_storage, {
+  writeServerInfo: () => writeServerInfo,
   saveTasks: () => saveTasks,
   saveTask: () => saveTask,
+  readServerInfo: () => readServerInfo,
   loadTasks: () => loadTasks,
+  loadAllTasks: () => loadAllTasks,
   getPersistedTask: () => getPersistedTask,
   ensureStorageDir: () => ensureStorageDir,
+  deleteServerInfo: () => deleteServerInfo,
   deletePersistedTask: () => deletePersistedTask
 });
 async function getFs() {
@@ -229,9 +233,75 @@ async function deletePersistedTask(sessionID) {
     await saveTasks(tasks);
   }
 }
-var fsPromises = null;
+async function loadAllTasks() {
+  const tasks = await loadTasks();
+  return Object.entries(tasks).map(([sessionID, task]) => ({ sessionID, ...task }));
+}
+async function writeServerInfo(info) {
+  try {
+    await ensureStorageDir();
+    const content = JSON.stringify(info, null, 2);
+    if (hasBun()) {
+      await Bun.write(SERVER_INFO_FILE, content);
+      return;
+    }
+    const fs = await getFs();
+    if (fs) {
+      await fs.writeFile(SERVER_INFO_FILE, content, "utf-8");
+      return;
+    }
+    console.warn("[storage] No file system API available for writing server info");
+  } catch (error) {
+    console.warn(`[storage] Failed to write server info: ${error}`);
+    throw error;
+  }
+}
+async function readServerInfo() {
+  try {
+    if (hasBun()) {
+      const file = Bun.file(SERVER_INFO_FILE);
+      const exists = await file.exists();
+      if (!exists) {
+        return null;
+      }
+      const content = await file.text();
+      return JSON.parse(content);
+    }
+    const fs = await getFs();
+    if (fs) {
+      const content = await fs.readFile(SERVER_INFO_FILE, "utf-8");
+      return JSON.parse(content);
+    }
+    return null;
+  } catch (error) {
+    const code = error.code;
+    if (code !== "ENOENT") {
+      console.warn(`[storage] Failed to read server info: ${error}`);
+    }
+    return null;
+  }
+}
+async function deleteServerInfo() {
+  try {
+    if (hasBun()) {
+      const file = Bun.file(SERVER_INFO_FILE);
+      const exists = await file.exists();
+      if (exists) {
+        await file.delete();
+      }
+      return;
+    }
+    const fs = await getFs();
+    if (fs) {
+      await fs.unlink(SERVER_INFO_FILE).catch(() => {});
+      return;
+    }
+  } catch {}
+}
+var fsPromises = null, SERVER_INFO_FILE;
 var init_storage = __esm(() => {
   init_constants();
+  SERVER_INFO_FILE = `${STORAGE_DIR}/${SERVER_INFO_FILENAME}`;
 });
 
 // node_modules/tiktoken/lite/tiktoken_bg.wasm
@@ -801,9 +871,9 @@ Duration: ${duration}
 Error fetching messages: ${errMsg}`,
   listHeader: `# Background Tasks
 
-| Task ID | Description | Agent | Status | Duration |
-|---------|-------------|-------|--------|----------|`,
-  listSummary: (total, running, completed, errored, cancelled) => `**Total: ${total}** | ⏳ ${running} running | ✓ ${completed} completed | ✗ ${errored} error | ⊘ ${cancelled} cancelled`,
+| Task ID | Description | Agent | Status | Duration | Tools |
+|---------|-------------|-------|--------|----------|-------|`,
+  listSummary: (total, running, completed, errored, cancelled, totalToolCalls) => `**Total: ${total}** | ⏳ ${running} running | ✓ ${completed} completed | ✗ ${errored} error | ⊘ ${cancelled} cancelled | \uD83D\uDD27 ${totalToolCalls} tool calls`,
   progressSection: (tools) => `
 | Last tools | ${tools.join(" → ")} |`
 };
@@ -818,6 +888,7 @@ var PLACEHOLDER_TEXT = {
 
 // src/helpers.ts
 function setTaskStatus(task, status, options) {
+  const previousStatus = task.status;
   task.status = status;
   if (status === "completed" || status === "error" || status === "cancelled") {
     task.completedAt = new Date().toISOString();
@@ -826,13 +897,35 @@ function setTaskStatus(task, status, options) {
     task.error = options.error;
   }
   options?.persistFn?.(task);
+  if (options?.emitFn && previousStatus !== status) {
+    if (status === "completed") {
+      options.emitFn("task.completed", task);
+    } else if (status === "error") {
+      options.emitFn("task.error", task);
+    } else if (status === "cancelled") {
+      options.emitFn("task.cancelled", task);
+    }
+  }
+}
+function shortId(sessionId, minLen = 8) {
+  if (!sessionId.startsWith("ses_")) {
+    return sessionId.slice(0, minLen + 4);
+  }
+  const suffix = sessionId.slice(4);
+  return `ses_${suffix.slice(0, minLen)}`;
 }
-function shortId(sessionId) {
+function uniqueShortId(sessionId, siblingIds, minLen = 8) {
   if (!sessionId.startsWith("ses_")) {
-    return sessionId.slice(0, 12);
+    return sessionId.slice(0, minLen + 4);
   }
   const suffix = sessionId.slice(4);
-  return `ses_${suffix.slice(0, 8)}`;
+  for (let len = minLen;len <= suffix.length; len++) {
+    const candidate = `ses_${suffix.slice(0, len)}`;
+    const hasClash = siblingIds.some((otherId) => otherId !== sessionId && otherId.startsWith(candidate));
+    if (!hasClash)
+      return candidate;
+  }
+  return sessionId;
 }
 function formatDuration(startStr, endStr) {
   const start = new Date(startStr);
@@ -926,7 +1019,7 @@ async function startEventSubscription(client, handleEvent) {
   }
 }
 function handleEvent(event, callbacks) {
-  const { clearAllTasks, getTasksArray, notifyParentSession, persistTask } = callbacks;
+  const { clearAllTasks, getTasksArray, notifyParentSession, persistTask, emitTaskEvent } = callbacks;
   const props = event.properties;
   if (event.type === "tui.command.execute") {
     const command = props?.command;
@@ -954,7 +1047,8 @@ function handleEvent(event, callbacks) {
     if (task.status === "running") {
       setTaskStatus(task, "cancelled", {
         error: "Session deleted",
-        persistFn: persistTask
+        persistFn: persistTask,
+        emitFn: emitTaskEvent
       });
     }
     return;
@@ -971,7 +1065,7 @@ function handleEvent(event, callbacks) {
     }
     if (task.status !== "running")
       return;
-    setTaskStatus(task, "completed", { persistFn: persistTask });
+    setTaskStatus(task, "completed", { persistFn: persistTask, emitFn: emitTaskEvent });
     notifyParentSession(task);
   }
 }
@@ -1003,6 +1097,14 @@ function showProgressToast(allTasks, animationFrame, client, getTasksArray) {
   const nextAnimationFrame = (animationFrame + 1) % SPINNER_FRAMES.length;
   const spinner = SPINNER_FRAMES[nextAnimationFrame];
   const totalToolCalls = batchTasks.reduce((sum, t) => sum + (t.progress?.toolCalls ?? 0), 0);
+  const aggregatedToolCalls = {};
+  for (const t of batchTasks) {
+    if (t.progress?.toolCallsByName) {
+      for (const [toolName, count] of Object.entries(t.progress.toolCallsByName)) {
+        aggregatedToolCalls[toolName] = (aggregatedToolCalls[toolName] ?? 0) + count;
+      }
+    }
+  }
   const taskLines = [];
   const batchRunning = runningTasks.filter((t) => t.batchId === activeBatchId);
   for (const task of batchRunning) {
@@ -1036,7 +1138,14 @@ function showProgressToast(allTasks, animationFrame, client, getTasksArray) {
   const barLength = 10;
   const filledLength = Math.round(finishedCount / Math.max(totalTasks, 1) * barLength);
   const progressBar = "█".repeat(filledLength) + "░".repeat(barLength - filledLength);
-  const summary = `[${progressBar}] ${finishedCount}/${totalTasks} agents (${progressPercent}%) | ${totalToolCalls} tool calls`;
+  const sortedTools = Object.entries(aggregatedToolCalls).sort(([, a], [, b]) => b - a);
+  let toolBreakdown = "";
+  if (sortedTools.length > 0) {
+    const top3 = sortedTools.slice(0, 3).map(([name, count]) => `${name}:${count}`).join(" ");
+    const remaining = sortedTools.length - 3;
+    toolBreakdown = remaining > 0 ? ` (${top3} +${remaining} more)` : ` (${top3})`;
+  }
+  const summary = `[${progressBar}] ${finishedCount}/${totalTasks} agents (${progressPercent}%) | ${totalToolCalls} calls${toolBreakdown}`;
   const tuiClient = client;
   if (!tuiClient.tui?.showToast)
     return;
@@ -1201,7 +1310,7 @@ function stopPolling(pollingInterval) {
     clearInterval(pollingInterval);
   }
 }
-async function pollRunningTasks(client, tasks, originalParentSessionID, updateTaskProgress, notifyParentSession2, clearAllTasks, stopPolling2, showProgressToast2, getTasksArray, getTaskMessages, persistTask) {
+async function pollRunningTasks(client, tasks, originalParentSessionID, updateTaskProgress, notifyParentSession2, clearAllTasks, stopPolling2, showProgressToast2, getTasksArray, getTaskMessages, persistTask, emitTaskEvent) {
   try {
     const statusResult = await client.session.status();
     const allStatuses = statusResult.data ?? {};
@@ -1240,7 +1349,7 @@ async function pollRunningTasks(client, tasks, originalParentSessionID, updateTa
             const messages = await getTaskMessages(task.sessionID);
             const hasAssistantResponse = messages.some((m) => m.info?.role === "assistant" && m.parts?.some((p) => p.type === "text" && p.text && p.text.length > 0));
             if (hasAssistantResponse) {
-              setTaskStatus(task, "completed", { persistFn: persistTask });
+              setTaskStatus(task, "completed", { persistFn: persistTask, emitFn: emitTaskEvent });
               notifyParentSession2(task);
               continue;
             }
@@ -1250,7 +1359,7 @@ async function pollRunningTasks(client, tasks, originalParentSessionID, updateTa
         continue;
       }
       if (sessionStatus.type === "idle") {
-        setTaskStatus(task, "completed", { persistFn: persistTask });
+        setTaskStatus(task, "completed", { persistFn: persistTask, emitFn: emitTaskEvent });
         notifyParentSession2(task);
         continue;
       }
@@ -1291,6 +1400,7 @@ async function updateTaskProgress(task, client) {
       return;
     const messages = messagesResult.data;
     let toolCalls = 0;
+    const toolCallsByName = {};
     const allTools = [];
     for (const msg of messages) {
       const parts = msg.parts ?? msg.content ?? [];
@@ -1300,6 +1410,7 @@ async function updateTaskProgress(task, client) {
       for (const part of parts) {
         if (part.type === "tool" && part.tool) {
           toolCalls++;
+          toolCallsByName[part.tool] = (toolCallsByName[part.tool] ?? 0) + 1;
           allTools.push(part.tool);
         }
       }
@@ -1307,11 +1418,13 @@ async function updateTaskProgress(task, client) {
     if (!task.progress) {
       task.progress = {
         toolCalls: 0,
+        toolCallsByName: {},
         lastTools: [],
         lastUpdate: new Date().toISOString()
       };
     }
     task.progress.toolCalls = toolCalls;
+    task.progress.toolCallsByName = toolCallsByName;
     task.progress.lastTools = allTools.slice(-3);
     task.progress.lastUpdate = new Date().toISOString();
   } catch {}
@@ -1436,7 +1549,7 @@ ${part.text}`);
 
 // src/manager/task-lifecycle.ts
 var FORK_METHOD = "inject";
-async function launchTask(input, tasks, client, getOrCreateBatchId, setOriginalParentSessionID, startPolling2, notifyParentSession2) {
+async function launchTask(input, tasks, client, getOrCreateBatchId, setOriginalParentSessionID, startPolling2, notifyParentSession2, emitTaskEvent, persistTask) {
   if (!input.agent || input.agent.trim() === "") {
     throw new Error("Agent parameter is required");
   }
@@ -1511,12 +1624,16 @@ ${contextText}`;
     isForked: input.fork ?? false,
     progress: {
       toolCalls: 0,
+      toolCallsByName: {},
       lastTools: [],
       lastUpdate: new Date().toISOString()
     }
   };
   setOriginalParentSessionID(input.parentSessionID);
   tasks.set(task.sessionID, task);
+  if (persistTask) {
+    await persistTask(task);
+  }
   startPolling2();
   client.session.promptAsync({
     path: { id: sessionID },
@@ -1542,6 +1659,7 @@ ${contextText}`;
         existingTask.error = errorMessage;
       }
       existingTask.completedAt = new Date().toISOString();
+      emitTaskEvent?.("task.error", existingTask);
       notifyParentSession2(existingTask);
     }
   });
@@ -1568,7 +1686,7 @@ async function getTaskMessages(sessionID, client) {
   }
   return messagesResult.data ?? messagesResult;
 }
-async function checkAndUpdateTaskStatus(task, client, notifyParentSession2, skipNotification = false, getTaskMessages2) {
+async function checkAndUpdateTaskStatus(task, client, notifyParentSession2, skipNotification = false, getTaskMessages2, emitTaskEvent) {
   if (task.status !== "running") {
     return task;
   }
@@ -1579,6 +1697,7 @@ async function checkAndUpdateTaskStatus(task, client, notifyParentSession2, skip
     if (sessionStatus?.type === "idle") {
       task.status = "completed";
       task.completedAt = new Date().toISOString();
+      emitTaskEvent?.("task.completed", task);
       if (!skipNotification) {
         notifyParentSession2(task);
       }
@@ -1591,6 +1710,7 @@ async function checkAndUpdateTaskStatus(task, client, notifyParentSession2, skip
         if (hasAssistantResponse) {
           task.status = "completed";
           task.completedAt = new Date().toISOString();
+          emitTaskEvent?.("task.completed", task);
           if (!skipNotification) {
             notifyParentSession2(task);
           }
@@ -1627,12 +1747,29 @@ class BackgroundManager {
   currentBatchId = null;
   tasks = new Map;
   originalParentSessionID = null;
+  taskEventListeners = [];
   constructor(ctx) {
     this.client = ctx.client;
     this.directory = ctx.directory;
     this.startEventSubscription();
     this.loadPersistedTasks();
   }
+  onTaskEvent(callback) {
+    this.taskEventListeners.push(callback);
+    return () => {
+      const index = this.taskEventListeners.indexOf(callback);
+      if (index > -1) {
+        this.taskEventListeners.splice(index, 1);
+      }
+    };
+  }
+  emitTaskEvent(eventType, task) {
+    for (const listener of this.taskEventListeners) {
+      try {
+        listener(eventType, task);
+      } catch {}
+    }
+  }
   async loadPersistedTasks() {
     try {
       const persisted = await loadTasks();
@@ -1642,8 +1779,8 @@ class BackgroundManager {
   async launch(input) {
     const task = await launchTask(input, this.tasks, this.client, () => this.getOrCreateBatchId(), (sessionID) => {
       this.originalParentSessionID = sessionID;
-    }, () => this.startPolling(), (t) => this.notifyParentSession(t));
-    await this.persistTask(task);
+    }, () => this.startPolling(), (t) => this.notifyParentSession(t), (eventType, t) => this.emitTaskEvent(eventType, t), (t) => this.persistTask(t));
+    this.emitTaskEvent("task.created", task);
     return task;
   }
   async persistTask(task) {
@@ -1654,7 +1791,13 @@ class BackgroundManager {
       createdAt: task.startedAt,
       status: task.status,
       resumeCount: task.resumeCount,
-      isForked: task.isForked
+      isForked: task.isForked,
+      completedAt: task.completedAt,
+      error: task.error,
+      result: task.result,
+      progress: task.progress,
+      startedAt: task.startedAt,
+      batchId: task.batchId
     };
     try {
       await saveTask(task.sessionID, persisted);
@@ -1663,7 +1806,11 @@ class BackgroundManager {
     }
   }
   async cancelTask(taskId) {
-    return cancelTask(taskId, this.tasks, this.client);
+    const task = this.tasks.get(taskId);
+    await cancelTask(taskId, this.tasks, this.client);
+    if (task) {
+      this.emitTaskEvent("task.cancelled", task);
+    }
   }
   clearAllTasks() {
     clearAllTasks(this.tasks, this.client, () => this.stopPolling());
@@ -1751,12 +1898,15 @@ class BackgroundManager {
   getAllTasks() {
     return Array.from(this.tasks.values());
   }
+  getTaskSessionIds() {
+    return Array.from(this.tasks.keys());
+  }
   async getTaskMessages(sessionID) {
     return getTaskMessages(sessionID, this.client);
   }
   async checkAndUpdateTaskStatus(task, skipNotification = false) {
     const previousStatus = task.status;
-    const updatedTask = await checkAndUpdateTaskStatus(task, this.client, (t) => this.notifyParentSession(t), skipNotification, (sessionID) => this.getTaskMessages(sessionID));
+    const updatedTask = await checkAndUpdateTaskStatus(task, this.client, (t) => this.notifyParentSession(t), skipNotification, (sessionID) => this.getTaskMessages(sessionID), (eventType, t) => this.emitTaskEvent(eventType, t));
     if (updatedTask.status !== previousStatus) {
       await this.persistTask(updatedTask);
     }
@@ -1903,12 +2053,20 @@ class BackgroundManager {
     this.pollingInterval = undefined;
   }
   async pollRunningTasks() {
-    await pollRunningTasks(this.client, this.tasks, this.originalParentSessionID, (task) => updateTaskProgress(task, this.client), (task) => this.notifyParentSession(task), () => this.clearAllTasks(), () => this.stopPolling(), (tasks) => this.showProgressToast(tasks), () => this.getAllTasks(), (sessionID) => this.getTaskMessages(sessionID), (task) => void this.persistTask(task));
+    await pollRunningTasks(this.client, this.tasks, this.originalParentSessionID, (task) => this.updateTaskProgressWithEvent(task), (task) => this.notifyParentSession(task), () => this.clearAllTasks(), () => this.stopPolling(), (tasks) => this.showProgressToast(tasks), () => this.getAllTasks(), (sessionID) => this.getTaskMessages(sessionID), (task) => void this.persistTask(task), (eventType, task) => this.emitTaskEvent(eventType, task));
   }
   showProgressToast(tasks) {
     showProgressToast(tasks, this.animationFrame, this.client, () => this.getAllTasks());
     this.animationFrame = (this.animationFrame + 1) % 10;
   }
+  async updateTaskProgressWithEvent(task) {
+    const previousToolCalls = task.progress?.toolCalls ?? 0;
+    await updateTaskProgress(task, this.client);
+    const currentToolCalls = task.progress?.toolCalls ?? 0;
+    if (currentToolCalls > previousToolCalls) {
+      this.emitTaskEvent("task.updated", task);
+    }
+  }
   notifyParentSession(task) {
     notifyParentSession(task, this.client, this.directory, () => this.getAllTasks());
   }
@@ -1917,11 +2075,457 @@ class BackgroundManager {
       clearAllTasks: () => this.clearAllTasks(),
       getTasksArray: () => this.getAllTasks(),
       notifyParentSession: (task) => this.notifyParentSession(task),
-      persistTask: (task) => void this.persistTask(task)
+      persistTask: (task) => void this.persistTask(task),
+      emitTaskEvent: (eventType, task) => this.emitTaskEvent(eventType, task)
     }));
   }
 }
 
+// src/server/index.ts
+init_constants();
+init_storage();
+
+// src/server/cors.ts
+var CORS_HEADERS = {
+  "Access-Control-Allow-Origin": "*",
+  "Access-Control-Allow-Methods": "GET, OPTIONS",
+  "Access-Control-Allow-Headers": "Content-Type"
+};
+function withCors(response) {
+  for (const [key, value] of Object.entries(CORS_HEADERS)) {
+    response.headers.set(key, value);
+  }
+  return response;
+}
+function jsonResponse(data, status = 200) {
+  return withCors(new Response(JSON.stringify(data), {
+    status,
+    headers: { "Content-Type": "application/json" }
+  }));
+}
+function errorResponse(error, status) {
+  return jsonResponse({ error, status }, status);
+}
+function preflightResponse() {
+  return withCors(new Response(null, { status: 204 }));
+}
+
+// src/server/routes.ts
+init_constants();
+var startTime = Date.now();
+function handleHealth(_req, manager) {
+  const tasks = manager.getAllTasks();
+  const body = {
+    status: "ok",
+    uptime: Math.floor((Date.now() - startTime) / 1000),
+    version: "1.0.0",
+    taskCount: tasks.length
+  };
+  return jsonResponse(body);
+}
+function handleStats(_req, manager) {
+  const tasks = manager.getAllTasks();
+  const byStatus = {};
+  const byAgent = {};
+  const toolCallsByName = {};
+  const durations = [];
+  let activeTasks = 0;
+  for (const task of tasks) {
+    byStatus[task.status] = (byStatus[task.status] ?? 0) + 1;
+    byAgent[task.agent] = (byAgent[task.agent] ?? 0) + 1;
+    if (task.progress?.toolCallsByName) {
+      for (const [toolName, count] of Object.entries(task.progress.toolCallsByName)) {
+        toolCallsByName[toolName] = (toolCallsByName[toolName] ?? 0) + count;
+      }
+    }
+    if (task.status === "running" || task.status === "resumed") {
+      activeTasks++;
+    }
+    if (task.startedAt && task.completedAt) {
+      const duration = new Date(task.completedAt).getTime() - new Date(task.startedAt).getTime();
+      if (duration > 0)
+        durations.push(duration);
+    }
+  }
+  const body = {
+    byStatus,
+    byAgent,
+    toolCallsByName,
+    duration: {
+      avg: durations.length > 0 ? durations.reduce((a, b) => a + b, 0) / durations.length : 0,
+      max: durations.length > 0 ? Math.max(...durations) : 0,
+      min: durations.length > 0 ? Math.min(...durations) : 0
+    },
+    totalTasks: tasks.length,
+    activeTasks
+  };
+  return jsonResponse(body);
+}
+function handleTaskList(req, manager) {
+  const url = new URL(req.url);
+  const status = url.searchParams.get("status");
+  const agent = url.searchParams.get("agent");
+  const search = url.searchParams.get("search");
+  const sortParam = url.searchParams.get("sort") ?? "startedAt:desc";
+  let limit = Number.parseInt(url.searchParams.get("limit") ?? String(DEFAULT_TASK_LIMIT), 10);
+  let offset = Number.parseInt(url.searchParams.get("offset") ?? "0", 10);
+  if (Number.isNaN(limit) || limit < 1)
+    limit = DEFAULT_TASK_LIMIT;
+  if (limit > MAX_TASK_LIMIT)
+    limit = MAX_TASK_LIMIT;
+  if (Number.isNaN(offset) || offset < 0)
+    offset = 0;
+  let tasks = manager.getAllTasks();
+  if (status) {
+    tasks = tasks.filter((t) => t.status === status);
+  }
+  if (agent) {
+    tasks = tasks.filter((t) => t.agent === agent);
+  }
+  if (search) {
+    const searchLower = search.toLowerCase();
+    tasks = tasks.filter((t) => t.description.toLowerCase().includes(searchLower) || t.prompt?.toLowerCase().includes(searchLower));
+  }
+  const [sortField, sortDir] = sortParam.split(":");
+  const direction = sortDir === "asc" ? 1 : -1;
+  const safeSortField = sortField ?? "startedAt";
+  tasks.sort((a, b) => {
+    const aVal = a[safeSortField] ?? "";
+    const bVal = b[safeSortField] ?? "";
+    if (aVal < bVal)
+      return -1 * direction;
+    if (aVal > bVal)
+      return 1 * direction;
+    return 0;
+  });
+  const total = tasks.length;
+  tasks = tasks.slice(offset, offset + limit);
+  const body = { tasks, total, limit, offset };
+  return jsonResponse(body);
+}
+function handleTaskDetail(req, manager, id) {
+  const task = manager.getTask(id);
+  if (!task) {
+    return errorResponse("Task not found", 404);
+  }
+  return jsonResponse(task);
+}
+async function handleTaskLogs(req, manager, id) {
+  const task = manager.getTask(id);
+  if (!task) {
+    return errorResponse("Task not found", 404);
+  }
+  const messages = await manager.getTaskMessages(id);
+  const body = {
+    messages,
+    taskId: id,
+    retrievedAt: new Date().toISOString()
+  };
+  return jsonResponse(body);
+}
+function handleTaskGroup(req, manager, groupId) {
+  const allTasks = manager.getAllTasks();
+  const groupTasks = allTasks.filter((t) => t.batchId === groupId);
+  if (groupTasks.length === 0) {
+    return errorResponse("Task group not found", 404);
+  }
+  let completed = 0;
+  let running = 0;
+  let error = 0;
+  let cancelled = 0;
+  let totalToolCalls = 0;
+  const toolCallsByName = {};
+  let minStart = Number.POSITIVE_INFINITY;
+  let maxEnd = 0;
+  for (const t of groupTasks) {
+    if (t.status === "completed")
+      completed++;
+    else if (t.status === "running" || t.status === "resumed")
+      running++;
+    else if (t.status === "error")
+      error++;
+    else if (t.status === "cancelled")
+      cancelled++;
+    totalToolCalls += t.progress?.toolCalls || 0;
+    if (t.progress?.toolCallsByName) {
+      for (const [toolName, count] of Object.entries(t.progress.toolCallsByName)) {
+        toolCallsByName[toolName] = (toolCallsByName[toolName] ?? 0) + count;
+      }
+    }
+    if (t.startedAt) {
+      const s = new Date(t.startedAt).getTime();
+      if (s < minStart)
+        minStart = s;
+    }
+    if (t.completedAt) {
+      const e = new Date(t.completedAt).getTime();
+      if (e > maxEnd)
+        maxEnd = e;
+    }
+  }
+  const total = groupTasks.length;
+  const duration = minStart < Number.POSITIVE_INFINITY && maxEnd > 0 ? maxEnd - minStart : 0;
+  const body = {
+    groupId,
+    tasks: groupTasks,
+    stats: {
+      completed,
+      running,
+      error,
+      cancelled,
+      total,
+      completionRate: total > 0 ? completed / total : 0,
+      totalToolCalls,
+      toolCallsByName,
+      duration
+    }
+  };
+  return jsonResponse(body);
+}
+
+// src/server/sse.ts
+init_constants();
+class SSEBroadcaster {
+  subscribers = new Set;
+  encoder = new TextEncoder;
+  addSubscriber(controller) {
+    if (this.subscribers.size >= MAX_SSE_SUBSCRIBERS) {
+      return false;
+    }
+    this.subscribers.add(controller);
+    return true;
+  }
+  removeSubscriber(controller) {
+    this.subscribers.delete(controller);
+  }
+  broadcast(eventType, data) {
+    const message = this.formatSSE(eventType, data);
+    const encoded = this.encoder.encode(message);
+    for (const controller of this.subscribers) {
+      try {
+        controller.enqueue(encoded);
+      } catch {
+        this.subscribers.delete(controller);
+      }
+    }
+  }
+  sendTo(controller, eventType, data) {
+    const message = this.formatSSE(eventType, data);
+    try {
+      controller.enqueue(this.encoder.encode(message));
+    } catch {
+      this.subscribers.delete(controller);
+    }
+  }
+  getSubscriberCount() {
+    return this.subscribers.size;
+  }
+  formatSSE(eventType, data) {
+    return `event: ${eventType}
+data: ${JSON.stringify(data)}
+
+`;
+  }
+}
+function handleSSERequest(req, broadcaster, dataProvider) {
+  let controller;
+  let heartbeatTimer;
+  const stream = new ReadableStream({
+    start(ctrl) {
+      controller = ctrl;
+      if (!broadcaster.addSubscriber(controller)) {
+        controller.enqueue(new TextEncoder().encode(`event: error
+data: ${JSON.stringify({ error: "Too many connections" })}
+
+`));
+        controller.close();
+        return;
+      }
+      const snapshot = {
+        tasks: dataProvider.getAllTasks(),
+        stats: dataProvider.buildStats()
+      };
+      broadcaster.sendTo(controller, "snapshot", snapshot);
+      heartbeatTimer = setInterval(() => {
+        try {
+          broadcaster.sendTo(controller, "heartbeat", { ts: new Date().toISOString() });
+        } catch {
+          clearInterval(heartbeatTimer);
+          broadcaster.removeSubscriber(controller);
+        }
+      }, HEARTBEAT_INTERVAL_MS);
+    },
+    cancel() {
+      clearInterval(heartbeatTimer);
+      broadcaster.removeSubscriber(controller);
+    }
+  });
+  return new Response(stream, {
+    status: 200,
+    headers: {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive",
+      ...CORS_HEADERS
+    }
+  });
+}
+
+// src/server/index.ts
+class StatusApiServer {
+  manager;
+  server = null;
+  broadcaster;
+  unsubscribe = null;
+  startedAt;
+  constructor(manager) {
+    this.manager = manager;
+    this.broadcaster = new SSEBroadcaster;
+    this.startedAt = new Date().toISOString();
+  }
+  static async start(manager) {
+    if (process.env.ASYNCAGENTS_API_ENABLED === "false") {
+      return null;
+    }
+    const instance = new StatusApiServer(manager);
+    await instance.bind();
+    return instance;
+  }
+  async bind() {
+    const desiredPort = Number.parseInt(process.env.ASYNCAGENTS_API_PORT ?? String(DEFAULT_API_PORT), 10);
+    const host = process.env.ASYNCAGENTS_API_HOST ?? DEFAULT_API_HOST;
+    const dataProvider = {
+      getAllTasks: () => this.manager.getAllTasks(),
+      buildStats: () => this.buildStatsData()
+    };
+    const broadcaster = this.broadcaster;
+    const manager = this.manager;
+    let lastError = null;
+    for (let attempt = 0;attempt <= MAX_PORT_RETRY; attempt++) {
+      const port2 = attempt < MAX_PORT_RETRY ? desiredPort + attempt : 0;
+      try {
+        this.server = Bun.serve({
+          port: port2,
+          hostname: host,
+          fetch(req) {
+            if (req.method === "OPTIONS") {
+              return preflightResponse();
+            }
+            const url2 = new URL(req.url);
+            const path = url2.pathname;
+            if (path === "/v1/health")
+              return handleHealth(req, manager);
+            if (path === "/v1/stats")
+              return handleStats(req, manager);
+            if (path === "/v1/tasks")
+              return handleTaskList(req, manager);
+            if (path === "/v1/events")
+              return handleSSERequest(req, broadcaster, dataProvider);
+            const logsMatch = path.match(/^\/v1\/tasks\/([^/]+)\/logs$/);
+            const logsId = logsMatch?.[1];
+            if (logsId) {
+              return handleTaskLogs(req, manager, logsId);
+            }
+            const taskMatch = path.match(/^\/v1\/tasks\/([^/]+)$/);
+            const taskId = taskMatch?.[1];
+            if (taskId) {
+              return handleTaskDetail(req, manager, taskId);
+            }
+            const groupMatch = path.match(/^\/v1\/task-groups\/([^/]+)$/);
+            const groupId = groupMatch?.[1];
+            if (groupId) {
+              return handleTaskGroup(req, manager, groupId);
+            }
+            return errorResponse("Not Found", 404);
+          }
+        });
+        lastError = null;
+        break;
+      } catch (err) {
+        lastError = err;
+      }
+    }
+    if (lastError || !this.server) {
+      throw new Error(`Failed to bind API server after ${MAX_PORT_RETRY + 1} attempts: ${lastError?.message}`);
+    }
+    if (this.manager.onTaskEvent) {
+      this.unsubscribe = this.manager.onTaskEvent((eventType, task) => {
+        this.broadcaster.broadcast(eventType, { task });
+      });
+    }
+    const port = this.server.port;
+    const url = `http://${host}:${port}`;
+    try {
+      await writeServerInfo({
+        port,
+        pid: process.pid,
+        startedAt: this.startedAt,
+        url,
+        version: "1.0.0"
+      });
+    } catch {}
+  }
+  buildStatsData() {
+    const tasks = this.manager.getAllTasks();
+    const byStatus = {};
+    const byAgent = {};
+    const toolCallsByName = {};
+    const durations = [];
+    let activeTasks = 0;
+    for (const task of tasks) {
+      byStatus[task.status] = (byStatus[task.status] ?? 0) + 1;
+      byAgent[task.agent] = (byAgent[task.agent] ?? 0) + 1;
+      if (task.progress?.toolCallsByName) {
+        for (const [toolName, count] of Object.entries(task.progress.toolCallsByName)) {
+          toolCallsByName[toolName] = (toolCallsByName[toolName] ?? 0) + count;
+        }
+      }
+      if (task.status === "running" || task.status === "resumed")
+        activeTasks++;
+      if (task.startedAt && task.completedAt) {
+        const d = new Date(task.completedAt).getTime() - new Date(task.startedAt).getTime();
+        if (d > 0)
+          durations.push(d);
+      }
+    }
+    return {
+      byStatus,
+      byAgent,
+      toolCallsByName,
+      duration: {
+        avg: durations.length ? durations.reduce((a, b) => a + b, 0) / durations.length : 0,
+        max: durations.length ? Math.max(...durations) : 0,
+        min: durations.length ? Math.min(...durations) : 0
+      },
+      totalTasks: tasks.length,
+      activeTasks
+    };
+  }
+  getPort() {
+    return this.server?.port ?? 0;
+  }
+  getUrl() {
+    const host = process.env.ASYNCAGENTS_API_HOST ?? DEFAULT_API_HOST;
+    return `http://${host}:${this.getPort()}`;
+  }
+  getBroadcaster() {
+    return this.broadcaster;
+  }
+  async stop() {
+    if (this.unsubscribe) {
+      this.unsubscribe();
+      this.unsubscribe = null;
+    }
+    if (this.server) {
+      this.server.stop(true);
+      this.server = null;
+    }
+    try {
+      await deleteServerInfo();
+    } catch {}
+  }
+}
+
 // node_modules/.pnpm/@opencode-ai+plugin@1.1.25/node_modules/@opencode-ai/plugin/node_modules/zod/v4/classic/external.js
 var exports_external = {};
 __export(exports_external, {
@@ -14364,7 +14968,9 @@ async function handleLaunchMode(manager, args, toolContext) {
       parentMessageID: toolContext.messageID,
       parentAgent: toolContext.agent
     });
-    return SUCCESS_MESSAGES.taskLaunched(shortId(task.sessionID));
+    const siblingIds = manager.getTaskSessionIds?.() ?? [];
+    const displayId = uniqueShortId(task.sessionID, siblingIds);
+    return SUCCESS_MESSAGES.taskLaunched(displayId);
   } catch (error45) {
     const message = error45 instanceof Error ? error45.message : String(error45);
     return ERROR_MESSAGES.launchFailed(message);
@@ -14383,11 +14989,11 @@ function createBackgroundOutput(manager) {
     },
     async execute(args) {
       try {
-        const resolvedId = manager.resolveTaskId(args.task_id);
+        const resolvedId = await manager.resolveTaskIdWithFallback(args.task_id);
         if (!resolvedId) {
           return ERROR_MESSAGES.taskNotFound(args.task_id);
         }
-        let task = manager.getTask(resolvedId);
+        let task = manager.getTask(resolvedId) ?? await manager.getTaskWithFallback(resolvedId);
         if (!task) {
           return ERROR_MESSAGES.taskNotFound(args.task_id);
         }
@@ -14431,11 +15037,11 @@ function createBackgroundCancel(manager) {
     },
     async execute(args) {
       try {
-        const resolvedId = manager.resolveTaskId(args.task_id);
+        const resolvedId = await manager.resolveTaskIdWithFallback(args.task_id);
         if (!resolvedId) {
           return ERROR_MESSAGES.taskNotFound(args.task_id);
         }
-        const task = manager.getTask(resolvedId);
+        const task = await manager.getTaskWithFallback(resolvedId);
         if (!task) {
           return ERROR_MESSAGES.taskNotFound(args.task_id);
         }
@@ -14469,6 +15075,7 @@ function createBackgroundList(manager) {
         }
         tasks.sort((a, b) => new Date(b.startedAt).getTime() - new Date(a.startedAt).getTime());
         const header = FORMAT_TEMPLATES.listHeader;
+        const allSessionIds = tasks.map((t) => t.sessionID);
         const rows = tasks.map((task) => {
           const duration3 = formatDuration(task.startedAt, task.completedAt);
           const desc = task.description.length > 30 ? `${task.description.slice(0, 27)}...` : task.description;
@@ -14477,19 +15084,22 @@ function createBackgroundList(manager) {
             task.isForked ? "(forked)" : "",
             task.resumeCount > 0 ? "(resumed)" : ""
           ].filter(Boolean).join(" ");
-          const idWithIndicators = indicators ? `${shortId(task.sessionID)} ${indicators}` : shortId(task.sessionID);
-          return `| \`${idWithIndicators}\` | ${desc} | ${task.agent} | ${icon} ${task.status} | ${duration3} |`;
+          const shortId2 = uniqueShortId(task.sessionID, allSessionIds);
+          const idWithIndicators = indicators ? `${shortId2} ${indicators}` : shortId2;
+          const toolsInfo = task.progress?.toolCallsByName && Object.keys(task.progress.toolCallsByName).length > 0 ? Object.entries(task.progress.toolCallsByName).sort(([, a], [, b]) => b - a).map(([name, count]) => `${name}:${count}`).join(" ") : task.progress?.toolCalls ? `${task.progress.toolCalls} calls` : "-";
+          return `| \`${idWithIndicators}\` | ${desc} | ${task.agent} | ${icon} ${task.status} | ${duration3} | ${toolsInfo} |`;
         }).join(`
 `);
         const running = tasks.filter((t) => t.status === "running").length;
         const completed = tasks.filter((t) => t.status === "completed").length;
         const errored = tasks.filter((t) => t.status === "error").length;
         const cancelled = tasks.filter((t) => t.status === "cancelled").length;
+        const totalToolCalls = tasks.reduce((sum, t) => sum + (t.progress?.toolCalls ?? 0), 0);
         return `${header}
 ${rows}
 
 ---
-${FORMAT_TEMPLATES.listSummary(tasks.length, running, completed, errored, cancelled)}`;
+${FORMAT_TEMPLATES.listSummary(tasks.length, running, completed, errored, cancelled, totalToolCalls)}`;
       } catch (error45) {
         return ERROR_MESSAGES.listFailed(error45 instanceof Error ? error45.message : String(error45));
       }
@@ -14520,6 +15130,15 @@ function createBackgroundClear(manager) {
 // src/index.ts
 async function plugin(ctx) {
   const manager = new BackgroundManager(ctx);
+  const server = await StatusApiServer.start(manager);
+  if (server) {
+    const cleanup = () => {
+      server.stop();
+    };
+    process.on("SIGINT", cleanup);
+    process.on("SIGTERM", cleanup);
+    process.on("exit", cleanup);
+  }
   return {
     tool: {
       asyncagents_task: createBackgroundTask(manager),
@@ -14535,5 +15154,5 @@ export {
   plugin as default
 };
 
-//# debugId=E81274522F3E3FAA64756E2164756E21
+//# debugId=C3296E4B18C7938B64756E2164756E21
 //# sourceMappingURL=index.js.map