opencode-orchestrator 1.2.15 → 1.2.21

package/dist/index.js

@@ -500,22 +500,26 @@ var init_parallel_task = __esm({
        * Worker and Reviewer are terminal nodes by design.
        */
       TERMINAL_DEPTH: 2,
-      // Concurrency limits (Aggressive for intense processing)
-      DEFAULT_CONCURRENCY: 10,
-      MAX_CONCURRENCY: 50,
+      // Concurrency limits (FIXED at 5 for stability - no auto-scaling)
+      CONCURRENCY: 5,
+      // Fixed concurrency (removed DEFAULT/MAX split)
+      // Legacy support (deprecated - use CONCURRENCY instead)
+      DEFAULT_CONCURRENCY: 5,
+      MAX_CONCURRENCY: 5,
       // Sync polling (for delegate_task sync mode)
-      // Optimized: Reduced polling frequency while relying more on events
-      SYNC_TIMEOUT_MS: 5 * TIME.MINUTE,
-      POLL_INTERVAL_MS: 2e3,
-      // 500 → 2000ms (75% less API calls)
+      // Optimized: 3s polling for faster response while maintaining stability
+      SYNC_TIMEOUT_MS: 30 * TIME.MINUTE,
+      // 5min → 30min (longer tasks)
+      POLL_INTERVAL_MS: 3e3,
+      // 5000ms → 3000ms (faster polling)
       MIN_IDLE_TIME_MS: 3 * TIME.SECOND,
-      // 5s → 3s (faster detection)
-      MIN_STABILITY_MS: 2 * TIME.SECOND,
-      // 3s → 2s (faster stability)
+      // 5s → 3s (quicker detection)
+      MIN_STABILITY_MS: 3 * TIME.SECOND,
+      // 5s → 3s (faster completion)
       STABLE_POLLS_REQUIRED: 2,
-      // 3 → 2 (faster completion)
-      MAX_POLL_COUNT: 150,
-      // 600 → 150 (adjusted for 2s interval)
+      // Keep at 2 for reliability
+      MAX_POLL_COUNT: 600,
+      // 150 → 600 (30min = 600 * 3s)
       // Session naming
       SESSION_TITLE_PREFIX: "Parallel",
       // Labels for output
@@ -637,7 +641,7 @@ var init_mission_control = __esm({
     init_limits();
     MISSION_CONTROL = {
       DEFAULT_MAX_ITERATIONS: LIMITS.MAX_ITERATIONS,
-      DEFAULT_COUNTDOWN_SECONDS: 3,
+      DEFAULT_COUNTDOWN_SECONDS: 10,
       STATE_FILE: "loop-state.json",
       STOP_COMMAND: "/stop",
       CANCEL_COMMAND: "/cancel",
@@ -1375,6 +1379,20 @@ var init_special_events = __esm({
   }
 });
 
+// src/shared/session/constants/events/hook-events.ts
+var HOOK_EVENTS;
+var init_hook_events = __esm({
+  "src/shared/session/constants/events/hook-events.ts"() {
+    "use strict";
+    HOOK_EVENTS = {
+      PRE_TOOL: "hook.pre_tool",
+      POST_TOOL: "hook.post_tool",
+      CHAT: "hook.chat",
+      DONE: "hook.done"
+    };
+  }
+});
+
 // src/shared/session/constants/events/index.ts
 var EVENT_TYPES;
 var init_events = __esm({
@@ -1387,6 +1405,7 @@ var init_events = __esm({
     init_mission_events();
     init_message_events();
     init_special_events();
+    init_hook_events();
     init_task_events();
     init_todo_events();
     init_session_events();
@@ -1394,6 +1413,7 @@ var init_events = __esm({
     init_mission_events();
     init_message_events();
     init_special_events();
+    init_hook_events();
     EVENT_TYPES = {
       ...TASK_EVENTS,
       ...TODO_EVENTS,
@@ -1401,7 +1421,8 @@ var init_events = __esm({
       ...DOCUMENT_EVENTS,
       ...MISSION_EVENTS,
       ...MESSAGE_EVENTS,
-      ...SPECIAL_EVENTS
+      ...SPECIAL_EVENTS,
+      ...HOOK_EVENTS
     };
   }
 });
@@ -5126,13 +5147,13 @@ __export(store_exports, {
   addDecision: () => addDecision,
   addDocument: () => addDocument,
   addFinding: () => addFinding,
-  clear: () => clear2,
+  clear: () => clear,
   clearAll: () => clearAll,
   create: () => create,
   get: () => get,
   getChildren: () => getChildren,
   getMerged: () => getMerged,
-  getStats: () => getStats2
+  getStats: () => getStats
 });
 function create(sessionId, parentId) {
   const context = {
@@ -5200,7 +5221,7 @@ function addDecision(sessionId, decision) {
 function getChildren(parentId) {
   return Array.from(parentChildMap.get(parentId) || []);
 }
-function clear2(sessionId) {
+function clear(sessionId) {
   const context = contexts.get(sessionId);
   if (context?.parentId) {
     parentChildMap.get(context.parentId)?.delete(sessionId);
@@ -5211,7 +5232,7 @@ function clearAll() {
   contexts.clear();
   parentChildMap.clear();
 }
-function getStats2() {
+function getStats() {
   let totalDocuments = 0;
   let totalFindings = 0;
   let totalDecisions = 0;
@@ -18579,34 +18600,20 @@ var ConcurrencyController = class {
     }
   }
   /**
-   * Report success/failure to adjust concurrency dynamically
+   * Report success/failure (for metrics only - auto-scaling DISABLED)
+   *
+   * Auto-scaling has been removed for stability. Concurrency is now fixed at 5.
+   * This method is kept for backwards compatibility and metrics tracking.
    */
   reportResult(key, success3) {
     if (success3) {
       const streak = (this.successStreak.get(key) ?? 0) + 1;
       this.successStreak.set(key, streak);
       this.failureCount.set(key, 0);
-      if (streak >= 3) {
-        const currentLimit = this.getConcurrencyLimit(key);
-        if (currentLimit < PARALLEL_TASK.MAX_CONCURRENCY) {
-          this.setLimit(key, currentLimit + 1);
-          this.successStreak.set(key, 0);
-          log(`[concurrency] Auto-scaling UP for ${key}: ${currentLimit + 1}`);
-        }
-      }
     } else {
       const failures = (this.failureCount.get(key) ?? 0) + 1;
       this.failureCount.set(key, failures);
       this.successStreak.set(key, 0);
-      if (failures >= 2) {
-        const currentLimit = this.getConcurrencyLimit(key);
-        const minLimit = 1;
-        if (currentLimit > minLimit) {
-          this.setLimit(key, currentLimit - 1);
-          this.failureCount.set(key, 0);
-          log(`[concurrency] Auto-scaling DOWN for ${key}: ${currentLimit - 1} (due to ${failures} failures)`);
-        }
-      }
     }
   }
   getQueueLength(key) {
@@ -18809,39 +18816,14 @@ function formatDuration(start, end) {
   if (minutes > 0) return `${minutes}m ${seconds % 60}s`;
   return `${seconds}s`;
 }
-function buildNotificationMessage(tasks) {
-  const summary = tasks.map((t) => {
-    const status = t.status === TASK_STATUS.COMPLETED ? "\u2705" : "\u274C";
-    return `${status} \`${t.id}\`: ${t.description}`;
-  }).join("\n");
-  return `<system-notification>
-**All Parallel Tasks Complete**
-
-${summary}
-
-Use \`get_task_result({ taskId: "task_xxx" })\` to retrieve results.
-</system-notification>`;
-}
 
 // src/core/session/session-health.ts
 var sessionHealth = /* @__PURE__ */ new Map();
-var STALE_THRESHOLD_MS = 12e4;
-var HEALTH_CHECK_INTERVAL_MS = 3e4;
-var WARNING_THRESHOLD_MS = 6e4;
+var STALE_THRESHOLD_MS = 6e5;
+var HEALTH_CHECK_INTERVAL_MS = 6e4;
+var WARNING_THRESHOLD_MS = 3e5;
 var healthCheckTimer;
 var client;
-function recordSessionResponse(sessionID) {
-  const health = sessionHealth.get(sessionID);
-  if (health) {
-    health.lastResponseTime = Date.now();
-    health.isStale = false;
-  }
-}
-function isSessionStale(sessionID) {
-  const health = sessionHealth.get(sessionID);
-  if (!health) return false;
-  return health.isStale;
-}
 function startHealthCheck(opencodeClient) {
   if (healthCheckTimer) {
     log("[session-health] Health check already running");
@@ -18888,292 +18870,6 @@ function performHealthCheck() {
     });
   }
 }
-function cleanupSessionHealth(sessionID) {
-  sessionHealth.delete(sessionID);
-}
-
-// src/core/agents/manager/task-launcher.ts
-init_shared();
-init_shared();
-
-// src/core/notification/task-toast-manager.ts
-init_shared();
-var TaskToastManager = class {
-  tasks = /* @__PURE__ */ new Map();
-  client = null;
-  concurrency = null;
-  todoSync = null;
-  /**
-   * Initialize the manager with OpenCode client
-   */
-  init(client2, concurrency) {
-    this.client = client2;
-    this.concurrency = concurrency ?? null;
-  }
-  /**
-   * Set concurrency controller (can be set after init)
-   */
-  setConcurrencyController(concurrency) {
-    this.concurrency = concurrency;
-  }
-  /**
-   * Set TodoSyncService for TUI status synchronization
-   */
-  setTodoSync(service) {
-    this.todoSync = service;
-  }
-  /**
-   * Add a new task and show consolidated toast
-   */
-  addTask(task) {
-    const trackedTask = {
-      id: task.id,
-      description: task.description,
-      agent: task.agent,
-      status: task.status ?? STATUS_LABEL.RUNNING,
-      startedAt: /* @__PURE__ */ new Date(),
-      isBackground: task.isBackground,
-      parentSessionID: task.parentSessionID,
-      sessionID: task.sessionID
-    };
-    this.tasks.set(task.id, trackedTask);
-    this.todoSync?.updateTaskStatus(trackedTask);
-    this.showTaskListToast(trackedTask);
-  }
-  /**
-   * Update task status
-   */
-  updateTask(id, status) {
-    const task = this.tasks.get(id);
-    if (task) {
-      task.status = status;
-      this.todoSync?.updateTaskStatus(task);
-    }
-  }
-  /**
-   * Remove a task
-   */
-  removeTask(id) {
-    this.tasks.delete(id);
-    this.todoSync?.removeTask(id);
-  }
-  /**
-   * Get all running tasks (newest first)
-   */
-  getRunningTasks() {
-    return Array.from(this.tasks.values()).filter((t) => t.status === STATUS_LABEL.RUNNING).sort((a, b) => b.startedAt.getTime() - a.startedAt.getTime());
-  }
-  /**
-   * Get all queued tasks (oldest first - FIFO)
-   */
-  getQueuedTasks() {
-    return Array.from(this.tasks.values()).filter((t) => t.status === STATUS_LABEL.QUEUED).sort((a, b) => a.startedAt.getTime() - b.startedAt.getTime());
-  }
-  /**
-   * Get tasks by parent session
-   */
-  getTasksByParent(parentSessionID) {
-    return Array.from(this.tasks.values()).filter((t) => t.parentSessionID === parentSessionID);
-  }
-  /**
-   * Format duration since task started
-   */
-  formatDuration(startedAt) {
-    const seconds = Math.floor((Date.now() - startedAt.getTime()) / 1e3);
-    if (seconds < 60) return `${seconds}s`;
-    const minutes = Math.floor(seconds / 60);
-    if (minutes < 60) return `${minutes}m ${seconds % 60}s`;
-    const hours = Math.floor(minutes / 60);
-    return `${hours}h ${minutes % 60}m`;
-  }
-  /**
-   * Get concurrency info string (e.g., " [2/5]")
-   */
-  /**
-   * Get concurrency info string (e.g., " [2/5]")
-   */
-  getConcurrencyInfo() {
-    if (!this.concurrency) return "";
-    const running = this.getRunningTasks();
-    const queued = this.getQueuedTasks();
-    const total = running.length;
-    const limit = this.concurrency.getConcurrencyLimit("default");
-    if (limit === Infinity) return "";
-    const filled = TUI_BLOCKS.FILLED.repeat(total);
-    const empty = TUI_BLOCKS.EMPTY.repeat(Math.max(0, limit - total));
-    return ` [${filled}${empty} ${total}/${limit}]`;
-  }
-  /**
-   * Build consolidated task list message
-   */
-  buildTaskListMessage(newTask) {
-    const running = this.getRunningTasks();
-    const queued = this.getQueuedTasks();
-    const concurrencyInfo = this.getConcurrencyInfo();
-    const lines = [];
-    if (running.length > 0) {
-      lines.push(`${TUI_ICONS.RUNNING} Running (${running.length}) ${concurrencyInfo}`);
-      for (const task of running) {
-        const duration5 = this.formatDuration(task.startedAt);
-        const bgTag = task.isBackground ? TUI_TAGS.BACKGROUND : TUI_TAGS.FOREGROUND;
-        const isNew = newTask && task.id === newTask.id ? TUI_ICONS.NEW : "";
-        lines.push(`${bgTag} ${task.description} (${task.agent}) - ${duration5}${isNew}`);
-      }
-    }
-    if (queued.length > 0) {
-      if (lines.length > 0) lines.push("");
-      lines.push(`${TUI_ICONS.QUEUED} Queued (${queued.length}):`);
-      for (const task of queued) {
-        const bgTag = task.isBackground ? TUI_TAGS.WAITING : TUI_TAGS.PENDING;
-        lines.push(`${bgTag} ${task.description} (${task.agent})`);
-      }
-    }
-    return lines.join("\n");
-  }
-  /**
-   * Show consolidated toast with all running/queued tasks
-   */
-  showTaskListToast(newTask) {
-    if (!this.client || !this.client.tui) return;
-    const message = this.buildTaskListMessage(newTask);
-    const running = this.getRunningTasks();
-    const queued = this.getQueuedTasks();
-    const title = newTask.isBackground ? `Background Task Started` : `Task Started`;
-    this.client.tui.showToast({
-      body: {
-        title,
-        message: message || `${newTask.description} (${newTask.agent})`,
-        variant: STATUS_LABEL.INFO,
-        duration: running.length + queued.length > 2 ? 5e3 : 3e3
-      }
-    }).catch(() => {
-    });
-  }
-  /**
-   * Show task completion toast
-   */
-  showCompletionToast(info) {
-    if (!this.client || !this.client.tui) return;
-    this.removeTask(info.id);
-    const remaining = this.getRunningTasks();
-    const queued = this.getQueuedTasks();
-    let message;
-    let title;
-    let variant;
-    if (info.status === STATUS_LABEL.ERROR || info.status === STATUS_LABEL.CANCELLED || info.status === STATUS_LABEL.FAILED) {
-      title = info.status === STATUS_LABEL.ERROR ? "Task Failed" : "Task Cancelled";
-      message = `[FAIL] "${info.description}" ${info.status}
-${info.error || ""}`;
-      variant = STATUS_LABEL.ERROR;
-    } else {
-      title = "Task Completed";
-      message = `[DONE] "${info.description}" finished in ${info.duration}`;
-      variant = STATUS_LABEL.SUCCESS;
-    }
-    if (remaining.length > 0 || queued.length > 0) {
-      message += `
-
-Still running: ${remaining.length} | Queued: ${queued.length}`;
-    }
-    this.client.tui.showToast({
-      body: {
-        title,
-        message,
-        variant,
-        duration: 5e3
-      }
-    }).catch(() => {
-    });
-  }
-  /**
-   * Show all-tasks-complete summary toast
-   */
-  showAllCompleteToast(parentSessionID, completedTasks) {
-    if (!this.client || !this.client.tui) return;
-    const successCount = completedTasks.filter((t) => t.status === STATUS_LABEL.COMPLETED).length;
-    const failCount = completedTasks.filter((t) => t.status === STATUS_LABEL.ERROR || t.status === STATUS_LABEL.CANCELLED || t.status === STATUS_LABEL.FAILED).length;
-    const taskList = completedTasks.map((t) => `- [${t.status === STATUS_LABEL.COMPLETED ? "OK" : "FAIL"}] ${t.description} (${t.duration})`).join("\n");
-    this.client.tui.showToast({
-      body: {
-        title: "All Tasks Completed",
-        message: `${successCount} succeeded, ${failCount} failed
-
-${taskList}`,
-        variant: failCount > 0 ? STATUS_LABEL.WARNING : STATUS_LABEL.SUCCESS,
-        duration: 7e3
-      }
-    }).catch(() => {
-    });
-  }
-  /**
-   * Show Mission Complete toast (Grand Finale)
-   */
-  showMissionCompleteToast(title = "Mission Complete", message = "All tasks completed successfully.") {
-    if (!this.client || !this.client.tui) return;
-    const decoratedMessage = `
-${TUI_ICONS.MISSION_COMPLETE} ${TUI_MESSAGES.MISSION_COMPLETE_TITLE} ${TUI_ICONS.MISSION_COMPLETE}
-\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
-${message}
-\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
-${TUI_MESSAGES.MISSION_COMPLETE_SUBTITLE}
-`.trim();
-    this.client.tui.showToast({
-      body: {
-        title: `${TUI_ICONS.SHIELD} ${title}`,
-        message: decoratedMessage,
-        variant: STATUS_LABEL.SUCCESS,
-        duration: 1e4
-        // Longer duration for the finale
-      }
-    }).catch(() => {
-    });
-  }
-  /**
-   * Show progress toast (for long-running tasks)
-   */
-  showProgressToast(taskId, progress) {
-    if (!this.client || !this.client.tui) return;
-    const task = this.tasks.get(taskId);
-    if (!task) return;
-    const percentage = Math.round(progress.current / progress.total * 100);
-    const progressBar = `[${"#".repeat(Math.floor(percentage / 10))}${"-".repeat(10 - Math.floor(percentage / 10))}]`;
-    this.client.tui.showToast({
-      body: {
-        title: `Task Progress: ${task.description}`,
-        message: `${progressBar} ${percentage}%
-${progress.message || ""}`,
-        variant: STATUS_LABEL.INFO,
-        duration: 2e3
-      }
-    }).catch(() => {
-    });
-  }
-  /**
-   * Clear all tracked tasks
-   */
-  clear() {
-    this.tasks.clear();
-  }
-  /**
-   * Get task count stats
-   */
-  getStats() {
-    const running = this.getRunningTasks().length;
-    const queued = this.getQueuedTasks().length;
-    return { running, queued, total: this.tasks.size };
-  }
-};
-var instance = null;
-function getTaskToastManager() {
-  return instance;
-}
-function initTaskToastManager(client2, concurrency) {
-  if (!instance) {
-    instance = new TaskToastManager();
-  }
-  instance.init(client2, concurrency);
-  return instance;
-}
 
 // src/core/agents/persistence/task-wal.ts
 init_shared();
@@ -19269,130 +18965,1048 @@ var TaskWAL = class {
 };
 var taskWAL = new TaskWAL();
 
-// src/core/recovery/constants.ts
+// src/core/notification/task-toast-manager.ts
 init_shared();
-var MAX_RETRIES = RECOVERY.MAX_ATTEMPTS;
-var BASE_DELAY = RECOVERY.BASE_DELAY_MS;
-var MAX_HISTORY = HISTORY.MAX_RECOVERY;
+var TaskToastManager = class {
+  tasks = /* @__PURE__ */ new Map();
+  client = null;
+  concurrency = null;
+  todoSync = null;
+  /**
+   * Initialize the manager with OpenCode client
+   */
+  init(client2, concurrency) {
+    this.client = client2;
+    this.concurrency = concurrency ?? null;
+  }
+  /**
+   * Set concurrency controller (can be set after init)
+   */
+  setConcurrencyController(concurrency) {
+    this.concurrency = concurrency;
+  }
+  /**
+   * Set TodoSyncService for TUI status synchronization
+   */
+  setTodoSync(service) {
+    this.todoSync = service;
+  }
+  /**
+   * Add a new task and show consolidated toast
+   */
+  addTask(task) {
+    const trackedTask = {
+      id: task.id,
+      description: task.description,
+      agent: task.agent,
+      status: task.status ?? STATUS_LABEL.RUNNING,
+      startedAt: /* @__PURE__ */ new Date(),
+      isBackground: task.isBackground,
+      parentSessionID: task.parentSessionID,
+      sessionID: task.sessionID
+    };
+    this.tasks.set(task.id, trackedTask);
+    this.todoSync?.updateTaskStatus(trackedTask);
+    this.showTaskListToast(trackedTask);
+  }
+  /**
+   * Update task status
+   */
+  updateTask(id, status) {
+    const task = this.tasks.get(id);
+    if (task) {
+      task.status = status;
+      this.todoSync?.updateTaskStatus(task);
+    }
+  }
+  /**
+   * Remove a task
+   */
+  removeTask(id) {
+    this.tasks.delete(id);
+    this.todoSync?.removeTask(id);
+  }
+  /**
+   * Get all running tasks (newest first)
+   */
+  getRunningTasks() {
+    return Array.from(this.tasks.values()).filter((t) => t.status === STATUS_LABEL.RUNNING).sort((a, b) => b.startedAt.getTime() - a.startedAt.getTime());
+  }
+  /**
+   * Get all queued tasks (oldest first - FIFO)
+   */
+  getQueuedTasks() {
+    return Array.from(this.tasks.values()).filter((t) => t.status === STATUS_LABEL.QUEUED).sort((a, b) => a.startedAt.getTime() - b.startedAt.getTime());
+  }
+  /**
+   * Get tasks by parent session
+   */
+  getTasksByParent(parentSessionID) {
+    return Array.from(this.tasks.values()).filter((t) => t.parentSessionID === parentSessionID);
+  }
+  /**
+   * Format duration since task started
+   */
+  formatDuration(startedAt) {
+    const seconds = Math.floor((Date.now() - startedAt.getTime()) / 1e3);
+    if (seconds < 60) return `${seconds}s`;
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 60) return `${minutes}m ${seconds % 60}s`;
+    const hours = Math.floor(minutes / 60);
+    return `${hours}h ${minutes % 60}m`;
+  }
+  /**
+   * Get concurrency info string (e.g., " [2/5]")
+   */
+  /**
+   * Get concurrency info string (e.g., " [2/5]")
+   */
+  getConcurrencyInfo() {
+    if (!this.concurrency) return "";
+    const running = this.getRunningTasks();
+    const queued = this.getQueuedTasks();
+    const total = running.length;
+    const limit = this.concurrency.getConcurrencyLimit("default");
+    if (limit === Infinity) return "";
+    const filled = TUI_BLOCKS.FILLED.repeat(total);
+    const empty = TUI_BLOCKS.EMPTY.repeat(Math.max(0, limit - total));
+    return ` [${filled}${empty} ${total}/${limit}]`;
+  }
+  /**
+   * Build consolidated task list message
+   */
+  buildTaskListMessage(newTask) {
+    const running = this.getRunningTasks();
+    const queued = this.getQueuedTasks();
+    const concurrencyInfo = this.getConcurrencyInfo();
+    const lines = [];
+    if (running.length > 0) {
+      lines.push(`${TUI_ICONS.RUNNING} Running (${running.length}) ${concurrencyInfo}`);
+      for (const task of running) {
+        const duration5 = this.formatDuration(task.startedAt);
+        const bgTag = task.isBackground ? TUI_TAGS.BACKGROUND : TUI_TAGS.FOREGROUND;
+        const isNew = newTask && task.id === newTask.id ? TUI_ICONS.NEW : "";
+        lines.push(`${bgTag} ${task.description} (${task.agent}) - ${duration5}${isNew}`);
+      }
+    }
+    if (queued.length > 0) {
+      if (lines.length > 0) lines.push("");
+      lines.push(`${TUI_ICONS.QUEUED} Queued (${queued.length}):`);
+      for (const task of queued) {
+        const bgTag = task.isBackground ? TUI_TAGS.WAITING : TUI_TAGS.PENDING;
+        lines.push(`${bgTag} ${task.description} (${task.agent})`);
+      }
+    }
+    return lines.join("\n");
+  }
+  /**
+   * Show consolidated toast with all running/queued tasks
+   */
+  showTaskListToast(newTask) {
+    if (!this.client || !this.client.tui) return;
+    const message = this.buildTaskListMessage(newTask);
+    const running = this.getRunningTasks();
+    const queued = this.getQueuedTasks();
+    const title = newTask.isBackground ? `Background Task Started` : `Task Started`;
+    this.client.tui.showToast({
+      body: {
+        title,
+        message: message || `${newTask.description} (${newTask.agent})`,
+        variant: STATUS_LABEL.INFO,
+        duration: running.length + queued.length > 2 ? 5e3 : 3e3
+      }
+    }).catch(() => {
+    });
+  }
+  /**
+   * Show task completion toast
+   */
+  showCompletionToast(info) {
+    if (!this.client || !this.client.tui) return;
+    this.removeTask(info.id);
+    const remaining = this.getRunningTasks();
+    const queued = this.getQueuedTasks();
+    let message;
+    let title;
+    let variant;
+    if (info.status === STATUS_LABEL.ERROR || info.status === STATUS_LABEL.CANCELLED || info.status === STATUS_LABEL.FAILED) {
+      title = info.status === STATUS_LABEL.ERROR ? "Task Failed" : "Task Cancelled";
+      message = `[FAIL] "${info.description}" ${info.status}
+${info.error || ""}`;
+      variant = STATUS_LABEL.ERROR;
+    } else {
+      title = "Task Completed";
+      message = `[DONE] "${info.description}" finished in ${info.duration}`;
+      variant = STATUS_LABEL.SUCCESS;
+    }
+    if (remaining.length > 0 || queued.length > 0) {
+      message += `
 
-// src/core/notification/toast.ts
-init_toast_core();
-init_shared();
+Still running: ${remaining.length} | Queued: ${queued.length}`;
+    }
+    this.client.tui.showToast({
+      body: {
+        title,
+        message,
+        variant,
+        duration: 5e3
+      }
+    }).catch(() => {
+    });
+  }
+  /**
+   * Show all-tasks-complete summary toast
+   */
+  showAllCompleteToast(parentSessionID, completedTasks) {
+    if (!this.client || !this.client.tui) return;
+    const successCount = completedTasks.filter((t) => t.status === STATUS_LABEL.COMPLETED).length;
+    const failCount = completedTasks.filter((t) => t.status === STATUS_LABEL.ERROR || t.status === STATUS_LABEL.CANCELLED || t.status === STATUS_LABEL.FAILED).length;
+    const taskList = completedTasks.map((t) => `- [${t.status === STATUS_LABEL.COMPLETED ? "OK" : "FAIL"}] ${t.description} (${t.duration})`).join("\n");
+    this.client.tui.showToast({
+      body: {
+        title: "All Tasks Completed",
+        message: `${successCount} succeeded, ${failCount} failed
 
-// src/core/recovery/patterns.ts
-var errorPatterns = [
-  // Rate limiting
-  {
-    pattern: /rate.?limit|too.?many.?requests|429/i,
-    category: "rate_limit",
-    handler: (ctx) => {
-      const delay = BASE_DELAY * Math.pow(2, ctx.attempt);
-      presets_exports.warningRateLimited();
-      return { type: "retry", delay, attempt: ctx.attempt + 1 };
+${taskList}`,
+        variant: failCount > 0 ? STATUS_LABEL.WARNING : STATUS_LABEL.SUCCESS,
+        duration: 7e3
+      }
+    }).catch(() => {
+    });
+  }
+  /**
+   * Show Mission Complete toast (Grand Finale)
+   */
+  showMissionCompleteToast(title = "Mission Complete", message = "All tasks completed successfully.") {
+    if (!this.client || !this.client.tui) return;
+    const decoratedMessage = `
+${TUI_ICONS.MISSION_COMPLETE} ${TUI_MESSAGES.MISSION_COMPLETE_TITLE} ${TUI_ICONS.MISSION_COMPLETE}
+\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+${message}
+\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+${TUI_MESSAGES.MISSION_COMPLETE_SUBTITLE}
+`.trim();
+    this.client.tui.showToast({
+      body: {
+        title: `${TUI_ICONS.SHIELD} ${title}`,
+        message: decoratedMessage,
+        variant: STATUS_LABEL.SUCCESS,
+        duration: 1e4
+        // Longer duration for the finale
+      }
+    }).catch(() => {
+    });
+  }
+  /**
+   * Show progress toast (for long-running tasks)
+   */
+  showProgressToast(taskId, progress) {
+    if (!this.client || !this.client.tui) return;
+    const task = this.tasks.get(taskId);
+    if (!task) return;
+    const percentage = Math.round(progress.current / progress.total * 100);
+    const progressBar = `[${"#".repeat(Math.floor(percentage / 10))}${"-".repeat(10 - Math.floor(percentage / 10))}]`;
+    this.client.tui.showToast({
+      body: {
+        title: `Task Progress: ${task.description}`,
+        message: `${progressBar} ${percentage}%
+${progress.message || ""}`,
+        variant: STATUS_LABEL.INFO,
+        duration: 2e3
+      }
+    }).catch(() => {
+    });
+  }
+  /**
+   * Clear all tracked tasks
+   */
+  clear() {
+    this.tasks.clear();
+  }
+  /**
+   * Get task count stats
+   */
+  getStats() {
+    const running = this.getRunningTasks().length;
+    const queued = this.getQueuedTasks().length;
+    return { running, queued, total: this.tasks.size };
+  }
+};
+var instance = null;
+function getTaskToastManager() {
+  return instance;
+}
+function initTaskToastManager(client2, concurrency) {
+  if (!instance) {
+    instance = new TaskToastManager();
+  }
+  instance.init(client2, concurrency);
+  return instance;
+}
+
+// src/core/agents/unified-task-executor.ts
+init_shared();
+var UnifiedTaskExecutor = class {
+  client;
+  directory;
+  store;
+  concurrency;
+  sessionPool;
+  // Polling state
+  pollInterval = null;
+  isPolling = false;
+  // Cleanup state
+  cleanupTimers = /* @__PURE__ */ new Map();
+  constructor(client2, directory, store, concurrency, sessionPool2) {
+    this.client = client2;
+    this.directory = directory;
+    this.store = store;
+    this.concurrency = concurrency;
+    this.sessionPool = sessionPool2;
+  }
+  // ========================================================================
+  // LAUNCH: Task Creation and Execution
+  // ========================================================================
+  /**
+   * Launch a new parallel task
+   */
+  async launch(input) {
+    const depth = input.depth ?? 1;
+    if (depth >= PARALLEL_TASK.MAX_DEPTH) {
+      throw new Error(`Max depth ${PARALLEL_TASK.MAX_DEPTH} exceeded (current: ${depth})`);
+    }
+    const taskId = `task_${Date.now()}_${Math.random().toString(36).slice(2, 11)}`;
+    const concurrencyKey = input.agent;
+    await this.concurrency.acquire(concurrencyKey);
+    let sessionID;
+    try {
+      const session = await this.sessionPool.acquire(
+        input.agent,
+        input.parentSessionID,
+        input.description
+      );
+      sessionID = session.id;
+      const task = {
+        id: taskId,
+        sessionID,
+        parentSessionID: input.parentSessionID,
+        description: input.description,
+        prompt: input.prompt,
+        agent: input.agent,
+        status: TASK_STATUS.RUNNING,
+        startedAt: /* @__PURE__ */ new Date(),
+        depth,
+        concurrencyKey,
+        mode: input.mode,
+        groupID: input.groupID,
+        progress: {
+          toolCalls: 0,
+          lastTool: void 0,
+          lastUpdate: /* @__PURE__ */ new Date()
+        }
+      };
+      this.store.set(taskId, task);
+      this.store.trackPending(input.parentSessionID, taskId);
+      await taskWAL.log(WAL_ACTIONS.LAUNCH, task);
+      log(`[UnifiedExecutor] Task launched: ${taskId} (agent: ${input.agent}, depth: ${input.depth})`);
+      const toastManager = getTaskToastManager();
+      if (toastManager) {
+        toastManager.addTask({
+          id: taskId,
+          description: input.description,
+          agent: input.agent,
+          isBackground: false,
+          parentSessionID: input.parentSessionID,
+          sessionID,
+          status: TASK_STATUS.RUNNING
+        });
+      }
+      await this.client.session.prompt({
+        path: { id: sessionID },
+        body: {
+          agent: input.agent,
+          tools: {},
+          parts: [
+            {
+              type: PART_TYPES.TEXT,
+              text: input.prompt
+            }
+          ]
+        }
+      });
+      this.startPolling();
+      return task;
+    } catch (error92) {
+      if (sessionID) {
+        await this.sessionPool.release(sessionID);
+      }
+      this.concurrency.release(concurrencyKey);
+      log(`[UnifiedExecutor] Launch failed: ${error92}`);
+      throw error92;
     }
-  },
-  // Context overflow
-  {
-    pattern: /context.?length|token.?limit|maximum.?context/i,
-    category: "context_overflow",
-    handler: () => {
-      presets_exports.errorRecovery("Compacting context");
-      return { type: "compact", reason: "Context limit reached" };
+  }
+  // ========================================================================
+  // POLLING: Monitor Task Execution
+  // ========================================================================
+  /**
+   * Start polling for task updates
+   */
+  startPolling() {
+    if (this.isPolling) return;
+    this.isPolling = true;
+    this.pollInterval = setInterval(() => {
+      this.pollTasks().catch((err) => {
+        log(`[UnifiedExecutor] Poll error: ${err}`);
+      });
+    }, PARALLEL_TASK.POLL_INTERVAL_MS);
+    this.pollInterval.unref?.();
+  }
+  /**
+   * Stop polling
+   */
+  stopPolling() {
+    if (this.pollInterval) {
+      clearInterval(this.pollInterval);
+      this.pollInterval = null;
     }
-  },
-  // Network errors
-  {
-    pattern: /ECONNREFUSED|ETIMEDOUT|network|fetch.?failed/i,
-    category: "network",
-    handler: (ctx) => {
-      if (ctx.attempt >= MAX_RETRIES) {
-        return { type: "abort", reason: "Network unavailable after retries" };
+    this.isPolling = false;
+  }
+  /**
+   * Poll all running tasks
+   */
+  async pollTasks() {
+    const runningTasks = this.store.getRunning();
+    if (runningTasks.length === 0) {
+      this.stopPolling();
+      return;
+    }
+    for (const task of runningTasks) {
+      await this.pollTask(task);
+    }
+    this.pruneExpiredTasks();
+  }
+  /**
+   * Poll a single task
+   */
+  async pollTask(task) {
+    try {
+      const result = await this.client.session.get({
+        path: { id: task.sessionID }
+      });
+      if ("error" in result && result.error) {
+        const errorMessage = "Session error";
+        await this.handleTaskError(task.id, new Error(errorMessage));
+        return;
       }
-      return { type: "retry", delay: BASE_DELAY * (ctx.attempt + 1), attempt: ctx.attempt + 1 };
+      const session = result.data;
+      if (!session) {
+        await this.handleTaskError(task.id, new Error("Session not found"));
+        return;
+      }
+      const messageCount = session.messages?.length || 0;
+      if (task.progress) {
+        task.progress.lastUpdate = /* @__PURE__ */ new Date();
+      }
+      const isBusy = session.status === "busy" || session.busy;
+      const hasOutput = messageCount > 1;
+      if (!isBusy && hasOutput) {
+        if (task.lastMsgCount === messageCount) {
+          task.stablePolls = (task.stablePolls || 0) + 1;
+        } else {
+          task.stablePolls = 0;
+          task.lastMsgCount = messageCount;
+        }
+        if (task.stablePolls >= PARALLEL_TASK.STABLE_POLLS_REQUIRED) {
+          await this.handleTaskComplete(task);
+        }
+      } else {
+        task.stablePolls = 0;
+      }
+    } catch (error92) {
+      log(`[UnifiedExecutor] Poll task ${task.id} error: ${error92}`);
     }
-  },
-  // Session errors
-  {
-    pattern: /session.?not.?found|session.?expired/i,
-    category: "session",
-    handler: () => {
-      return { type: "abort", reason: "Session no longer available" };
+  }
+  // ========================================================================
+  // COMPLETION: Handle Task Completion
+  // ========================================================================
+  /**
+   * Handle task completion
+   */
+  async handleTaskComplete(task) {
+    log(`[UnifiedExecutor] Task complete: ${task.id}`);
+    task.status = TASK_STATUS.COMPLETED;
+    task.completedAt = /* @__PURE__ */ new Date();
+    await taskWAL.log(WAL_ACTIONS.UPDATE, task);
+    await this.sessionPool.release(task.sessionID);
+    this.concurrency.release(task.concurrencyKey || task.agent);
+    this.concurrency.reportResult(task.concurrencyKey || task.agent, true);
+    this.store.untrackPending(task.parentSessionID, task.id);
+    const toastManager = getTaskToastManager();
+    if (toastManager) {
+      toastManager.updateTask(task.id, TASK_STATUS.COMPLETED);
     }
-  },
-  // Tool errors
-  {
-    pattern: /tool.?not.?found|unknown.?tool/i,
-    category: "tool",
-    handler: (ctx) => {
-      return { type: "escalate", to: "Reviewer", reason: `Unknown tool used by ${ctx.agent}` };
+    this.scheduleCleanup(task.id);
+    await this.notifyParentIfAllComplete(task.parentSessionID);
+  }
+  /**
+   * Handle task error
+   */
+  async handleTaskError(taskId, error92) {
+    const task = this.store.get(taskId);
+    if (!task) return;
+    log(`[UnifiedExecutor] Task error: ${taskId} - ${error92.message}`);
+    task.status = TASK_STATUS.ERROR;
+    task.completedAt = /* @__PURE__ */ new Date();
+    task.error = error92.message;
+    await taskWAL.log(WAL_ACTIONS.UPDATE, task);
+    await this.sessionPool.release(task.sessionID);
+    this.concurrency.release(task.concurrencyKey || task.agent);
+    this.concurrency.reportResult(task.concurrencyKey || task.agent, false);
+    this.store.untrackPending(task.parentSessionID, task.id);
+    const toastManager = getTaskToastManager();
+    if (toastManager) {
+      toastManager.updateTask(task.id, TASK_STATUS.ERROR);
     }
-  },
-  // Parse errors
-  {
-    pattern: /parse.?error|invalid.?json|syntax.?error/i,
-    category: "parse",
-    handler: (ctx) => {
-      if (ctx.attempt >= 2) {
-        return { type: "skip", reason: "Persistent parse error" };
+    this.scheduleCleanup(task.id);
+    await this.notifyParentIfAllComplete(task.parentSessionID);
+  }
+  // ========================================================================
+  // CLEANUP: Task Cleanup and GC
+  // ========================================================================
+  /**
+   * Schedule cleanup for a task
+   */
+  scheduleCleanup(taskId) {
+    const timer = setTimeout(() => {
+      this.cleanupTask(taskId);
+      this.cleanupTimers.delete(taskId);
+    }, PARALLEL_TASK.CLEANUP_DELAY_MS);
+    this.cleanupTimers.set(taskId, timer);
+  }
+  /**
+   * Cleanup a task
+   */
+  async cleanupTask(taskId) {
+    const task = this.store.get(taskId);
+    if (!task) return;
+    log(`[UnifiedExecutor] Cleaning up task: ${taskId}`);
+    this.store.delete(taskId);
+    if (task) {
+      await taskWAL.log(WAL_ACTIONS.DELETE, task);
+    }
+    const toastManager = getTaskToastManager();
+    if (toastManager) {
+      toastManager.removeTask(taskId);
+    }
+  }
+  /**
+   * Prune expired tasks
+   */
+  pruneExpiredTasks() {
+    const now = Date.now();
+    const tasks = this.store.getAll();
+    for (const task of tasks) {
+      const age = now - task.startedAt.getTime();
+      if (age > PARALLEL_TASK.TTL_MS) {
+        log(`[UnifiedExecutor] Pruning expired task: ${task.id} (age: ${age}ms)`);
+        this.handleTaskError(task.id, new Error("Task timeout"));
       }
-      return { type: "retry", delay: 500, attempt: ctx.attempt + 1 };
     }
-  },
-  // Gibberish / hallucination
-  {
-    pattern: /gibberish|hallucination|mixed.?language/i,
-    category: "gibberish",
-    handler: () => {
-      presets_exports.errorRecovery("Retrying with clean context");
-      return { type: "retry", delay: 1e3, attempt: 1 };
+  }
+  // ========================================================================
+  // NOTIFICATION: Parent Notification
+  // ========================================================================
+  /**
+   * Notify parent if all tasks complete
+   */
+  async notifyParentIfAllComplete(parentSessionID) {
+    const pendingCount = this.store.getPendingCount(parentSessionID);
+    if (pendingCount === 0) {
+      log(`[UnifiedExecutor] All tasks complete for parent: ${parentSessionID}`);
+      const tasks = this.store.getByParent(parentSessionID);
+      const summary = tasks.map(
+        (t) => `- ${t.status === TASK_STATUS.COMPLETED ? "\u2705" : "\u274C"} ${t.description}`
+      ).join("\n");
+      try {
+        await this.client.session.prompt({
+          path: { id: parentSessionID },
+          body: {
+            agent: "",
+            tools: {},
+            parts: [{
+              type: PART_TYPES.TEXT,
+              text: `All delegated tasks complete:
+
+${summary}`
+            }]
+          }
+        });
+      } catch (error92) {
+        log(`[UnifiedExecutor] Failed to notify parent: ${error92}`);
+      }
+      this.store.clearNotifications(parentSessionID);
     }
-  },
-  // LSP specific errors
-  {
-    pattern: /lsp.?diagnostics|tsc.?error|eslint.?error/i,
-    category: "lsp",
-    handler: (ctx) => {
-      return { type: "retry", delay: 2e3, attempt: ctx.attempt + 1, modifyPrompt: "Note: Previous attempt had LSP issues. Ensure code quality and consider simpler implementation." };
+  }
+  // ========================================================================
+  // RESUME: Task Recovery
+  // ========================================================================
+  /**
+   * Resume a task from disk
+   */
+  async resume(input) {
+    log(`[UnifiedExecutor] Resuming task: ${input.sessionId}`);
+    const tasks = await taskWAL.readAll();
+    const task = tasks.get(input.sessionId);
+    if (!task) {
+      log(`[UnifiedExecutor] No task found to resume: ${input.sessionId}`);
+      return null;
     }
-  },
-  // execution timeout
-  {
-    pattern: /execution.?timed.?out|timeout/i,
-    category: "timeout",
-    handler: (ctx) => {
-      return { type: "retry", delay: 5e3, attempt: ctx.attempt + 1, modifyPrompt: "Note: Previous attempt timed out. Break down the task into smaller sub-tasks if necessary." };
+    this.store.set(task.id, task);
+    this.store.trackPending(task.parentSessionID, task.id);
+    this.startPolling();
+    log(`[UnifiedExecutor] Task resumed: ${task.id}`);
+    return task;
+  }
+  /**
+   * Recover all active tasks from disk
+   */
+  async recoverAll() {
+    log("[UnifiedExecutor] Recovering tasks from WAL...");
+    const tasks = await taskWAL.readAll();
+    let recovered = 0;
+    for (const [sessionID, task] of tasks) {
+      if (task.status === TASK_STATUS.RUNNING || task.status === TASK_STATUS.PENDING) {
+        try {
+          const result = await this.client.session.get({ path: { id: sessionID } });
+          if (result.data) {
+            this.store.set(task.id, task);
+            this.store.trackPending(task.parentSessionID, task.id);
+            recovered++;
+          }
+        } catch {
+        }
+      }
     }
+    if (recovered > 0) {
+      log(`[UnifiedExecutor] Recovered ${recovered} tasks`);
+      this.startPolling();
+    }
+    return recovered;
   }
-];
+  // ========================================================================
+  // UTILITIES
+  // ========================================================================
+  /**
+   * Cancel a task
+   */
+  async cancel(taskId) {
+    const task = this.store.get(taskId);
+    if (!task) return false;
+    log(`[UnifiedExecutor] Cancelling task: ${taskId}`);
+    try {
+      await this.client.session.delete({ path: { id: task.sessionID } });
+    } catch {
+    }
+    await this.handleTaskError(taskId, new Error("Cancelled by user"));
+    return true;
+  }
+  /**
+   * Get task by ID
+   */
+  getTask(taskId) {
+    return this.store.get(taskId);
+  }
+  /**
+   * Get all tasks
+   */
+  getAllTasks() {
+    return this.store.getAll();
+  }
+  /**
+   * Get tasks by parent
+   */
+  getTasksByParent(parentSessionID) {
+    return this.store.getByParent(parentSessionID);
+  }
+  /**
+   * Cleanup all resources
+   */
+  cleanup() {
+    log("[UnifiedExecutor] Cleaning up...");
+    this.stopPolling();
+    for (const timer of this.cleanupTimers.values()) {
+      clearTimeout(timer);
+    }
+    this.cleanupTimers.clear();
+    this.pruneExpiredTasks();
+  }
+};
 
-// src/core/recovery/handler.ts
-var recoveryHistory = [];
-function handleError(context) {
-  const errorMessage = context.error.message || String(context.error);
-  for (const pattern of errorPatterns) {
-    const matches = typeof pattern.pattern === "string" ? errorMessage.includes(pattern.pattern) : pattern.pattern.test(errorMessage);
-    if (matches) {
-      const action = pattern.handler(context);
-      recoveryHistory.push({
-        context,
-        action,
-        timestamp: /* @__PURE__ */ new Date()
-      });
-      if (recoveryHistory.length > MAX_HISTORY) {
-        recoveryHistory.shift();
+// src/core/agents/session-pool.ts
+init_shared();
+var DEFAULT_CONFIG = {
+  maxPoolSizePerAgent: 5,
+  idleTimeoutMs: 3e5,
+  // 5 minutes
+  maxReuseCount: 10,
+  healthCheckIntervalMs: 6e4
+  // 1 minute
+};
+var SessionPool = class _SessionPool {
+  static _instance;
+  pool = /* @__PURE__ */ new Map();
+  // key: agentName
+  sessionsById = /* @__PURE__ */ new Map();
+  config;
+  client;
+  directory;
+  healthCheckInterval = null;
+  // Statistics
+  stats = {
+    reuseHits: 0,
+    creationMisses: 0
+  };
+  constructor(client2, directory, config3 = {}) {
+    this.client = client2;
+    this.directory = directory;
+    this.config = { ...DEFAULT_CONFIG, ...config3 };
+    this.startHealthCheck();
+  }
+  static getInstance(client2, directory, config3) {
+    if (!_SessionPool._instance) {
+      if (!client2 || !directory) {
+        throw new Error("SessionPool requires client and directory on first call");
       }
-      return action;
+      _SessionPool._instance = new _SessionPool(client2, directory, config3);
     }
+    return _SessionPool._instance;
   }
-  if (context.attempt < MAX_RETRIES) {
+  /**
+   * Acquire a session from the pool or create a new one.
+   * Sessions are validated before reuse to ensure health.
+   */
+  async acquire(agentName, parentSessionID, description) {
+    const poolKey = this.getPoolKey(agentName);
+    const agentPool = this.pool.get(poolKey) || [];
+    const candidates = agentPool.filter((s) => !s.inUse && s.reuseCount < this.config.maxReuseCount);
+    for (const candidate of candidates) {
+      const isHealthy = await this.validateSessionHealth(candidate.id);
+      if (isHealthy) {
+        candidate.inUse = true;
+        candidate.lastUsedAt = /* @__PURE__ */ new Date();
+        candidate.reuseCount++;
+        candidate.health = "healthy";
+        this.stats.reuseHits++;
+        log(`[SessionPool] Reusing session ${candidate.id.slice(0, 8)}... for ${agentName} (reuse #${candidate.reuseCount})`);
+        return candidate;
+      } else {
+        log(`[SessionPool] Session ${candidate.id.slice(0, 8)}... failed health check, removing`);
+        await this.deleteSession(candidate.id);
+      }
+    }
+    this.stats.creationMisses++;
+    return this.createSession(agentName, parentSessionID, description);
+  }
+  /**
+   * Release a session back to the pool for reuse.
+   */
+  async release(sessionId) {
+    const session = this.sessionsById.get(sessionId);
+    if (!session) {
+      log(`[SessionPool] Session ${sessionId.slice(0, 8)}... not found in pool`);
+      return;
+    }
+    const now = Date.now();
+    const age = now - session.createdAt.getTime();
+    const idle = now - session.lastUsedAt.getTime();
+    if (session.reuseCount >= this.config.maxReuseCount || age > this.config.idleTimeoutMs * 2) {
+      await this.invalidate(sessionId);
+      return;
+    }
+    const poolKey = this.getPoolKey(session.agentName);
+    const agentPool = this.pool.get(poolKey) || [];
+    const availableCount = agentPool.filter((s) => !s.inUse).length;
+    if (availableCount >= this.config.maxPoolSizePerAgent) {
+      const oldest = agentPool.filter((s) => !s.inUse).sort((a, b) => a.lastUsedAt.getTime() - b.lastUsedAt.getTime())[0];
+      if (oldest) {
+        await this.deleteSession(oldest.id);
+      }
+    }
+    await this.resetSession(sessionId);
+    session.inUse = false;
+    log(`[SessionPool] Released session ${sessionId.slice(0, 8)}... to pool`);
+  }
+  /**
+   * Invalidate a session (remove from pool and delete).
+   */
+  async invalidate(sessionId) {
+    const session = this.sessionsById.get(sessionId);
+    if (!session) return;
+    await this.deleteSession(sessionId);
+    log(`[SessionPool] Invalidated session ${sessionId.slice(0, 8)}...`);
+  }
+  /**
+   * Get current pool statistics.
+   */
+  getStats() {
+    const byAgent = {};
+    for (const [agentName, sessions] of this.pool.entries()) {
+      const inUse = sessions.filter((s) => s.inUse).length;
+      byAgent[agentName] = {
+        total: sessions.length,
+        inUse,
+        available: sessions.length - inUse
+      };
+    }
+    const allSessions = Array.from(this.sessionsById.values());
+    const inUseCount = allSessions.filter((s) => s.inUse).length;
     return {
-      type: "retry",
-      delay: BASE_DELAY * Math.pow(2, context.attempt),
-      attempt: context.attempt + 1
+      totalSessions: allSessions.length,
+      sessionsInUse: inUseCount,
+      availableSessions: allSessions.length - inUseCount,
+      reuseHits: this.stats.reuseHits,
+      creationMisses: this.stats.creationMisses,
+      byAgent
     };
   }
-  return { type: "abort", reason: `Unknown error after ${MAX_RETRIES} retries` };
-}
+  /**
+   * Cleanup stale sessions.
+   */
+  async cleanup() {
+    const now = Date.now();
+    let cleanedCount = 0;
+    for (const [sessionId, session] of this.sessionsById.entries()) {
+      if (session.inUse) continue;
+      const idle = now - session.lastUsedAt.getTime();
+      if (idle > this.config.idleTimeoutMs) {
+        await this.deleteSession(sessionId);
+        cleanedCount++;
+      }
+    }
+    if (cleanedCount > 0) {
+      log(`[SessionPool] Cleaned up ${cleanedCount} stale sessions`);
+    }
+    return cleanedCount;
+  }
+  /**
+   * Shutdown the pool.
+   */
+  async shutdown() {
+    log("[SessionPool] Shutting down...");
+    if (this.healthCheckInterval) {
+      clearInterval(this.healthCheckInterval);
+      this.healthCheckInterval = null;
+    }
+    const deletePromises = Array.from(this.sessionsById.keys()).map(
+      (id) => this.deleteSession(id).catch(() => {
+      })
+    );
+    await Promise.all(deletePromises);
+    this.pool.clear();
+    this.sessionsById.clear();
+    log("[SessionPool] Shutdown complete");
+  }
+  // =========================================================================
+  // Private Methods
+  // =========================================================================
+  /**
+   * Reset/Compact a session to clear context for next reuse.
+   */
+  async resetSession(sessionId) {
+    const session = this.sessionsById.get(sessionId);
+    if (!session) return;
+    log(`[SessionPool] Resetting session ${sessionId.slice(0, 8)}...`);
+    try {
+      await this.client.session.compact?.({ path: { id: sessionId } });
+      session.lastResetAt = /* @__PURE__ */ new Date();
+      session.health = "healthy";
+    } catch (error92) {
+      log(`[SessionPool] Failed to reset session ${sessionId.slice(0, 8)}: ${error92}`);
+      session.health = "degraded";
+    }
+  }
+  getPoolKey(agentName) {
+    return agentName;
+  }
+  async createSession(agentName, parentSessionID, description) {
+    log(`[SessionPool] Creating new session for ${agentName}`);
+    const result = await Promise.race([
+      this.client.session.create({
+        body: {
+          parentID: parentSessionID,
+          title: `${PARALLEL_TASK.SESSION_TITLE_PREFIX}: ${description}`
+        },
+        query: { directory: this.directory }
+      }),
+      new Promise(
+        (_, reject) => setTimeout(() => reject(new Error("Session creation timed out after 60s")), 6e4)
+      )
+    ]);
+    if (result.error || !result.data?.id) {
+      throw new Error(`Session creation failed: ${result.error || "No ID"}`);
+    }
+    const session = {
+      id: result.data.id,
+      agentName,
+      projectDirectory: this.directory,
+      createdAt: /* @__PURE__ */ new Date(),
+      lastUsedAt: /* @__PURE__ */ new Date(),
+      reuseCount: 0,
+      inUse: true,
+      health: "healthy",
+      lastResetAt: /* @__PURE__ */ new Date()
+    };
+    const poolKey = this.getPoolKey(agentName);
+    const agentPool = this.pool.get(poolKey) || [];
+    agentPool.push(session);
+    this.pool.set(poolKey, agentPool);
+    this.sessionsById.set(session.id, session);
+    return session;
+  }
+  async deleteSession(sessionId) {
+    const session = this.sessionsById.get(sessionId);
+    if (!session) return;
+    this.sessionsById.delete(sessionId);
+    const poolKey = this.getPoolKey(session.agentName);
+    const agentPool = this.pool.get(poolKey);
+    if (agentPool) {
+      const idx = agentPool.findIndex((s) => s.id === sessionId);
+      if (idx !== -1) {
+        agentPool.splice(idx, 1);
+      }
+      if (agentPool.length === 0) {
+        this.pool.delete(poolKey);
+      }
+    }
+    try {
+      await this.client.session.delete({ path: { id: sessionId } });
+    } catch {
+    }
+  }
+  /**
+   * Validate session health by checking if it exists on the server.
+   */
+  async validateSessionHealth(sessionId) {
+    try {
+      const result = await Promise.race([
+        this.client.session.get({ path: { id: sessionId } }),
+        new Promise(
+          (_, reject) => setTimeout(() => reject(new Error("Health check timeout")), 5e3)
+        )
+      ]);
+      if (result.error || !result.data) {
+        return false;
+      }
+      return true;
+    } catch (error92) {
+      log(`[SessionPool] Health check failed for session ${sessionId.slice(0, 8)}: ${error92}`);
+      return false;
+    }
+  }
+  startHealthCheck() {
+    this.healthCheckInterval = setInterval(() => {
+      this.cleanup().catch(() => {
+      });
+    }, this.config.healthCheckIntervalMs);
+    this.healthCheckInterval.unref?.();
+  }
+};
+var sessionPool = {
+  getInstance: SessionPool.getInstance.bind(SessionPool)
+};
+
+// src/core/progress/state-broadcaster.ts
+var StateBroadcaster = class _StateBroadcaster {
+  static _instance;
+  listeners = /* @__PURE__ */ new Set();
+  currentState = null;
+  constructor() {
+  }
+  static getInstance() {
+    if (!_StateBroadcaster._instance) {
+      _StateBroadcaster._instance = new _StateBroadcaster();
+    }
+    return _StateBroadcaster._instance;
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    if (this.currentState) {
+      listener(this.currentState);
+    }
+    return () => this.listeners.delete(listener);
+  }
+  broadcast(state2) {
+    this.currentState = state2;
+    this.listeners.forEach((listener) => {
+      try {
+        listener(state2);
+      } catch (error92) {
+      }
+    });
+  }
+  getCurrentState() {
+    return this.currentState;
+  }
+};
+var stateBroadcaster = StateBroadcaster.getInstance();
+
+// src/core/progress/progress-notifier.ts
+init_shared();
+var ProgressNotifier = class _ProgressNotifier {
+  static _instance;
+  manager = null;
+  constructor() {
+    stateBroadcaster.subscribe(this.handleStateChange.bind(this));
+  }
+  static getInstance() {
+    if (!_ProgressNotifier._instance) {
+      _ProgressNotifier._instance = new _ProgressNotifier();
+    }
+    return _ProgressNotifier._instance;
+  }
+  setManager(manager) {
+    this.manager = manager;
+  }
+  /**
+   * Poll current status from ParallelAgentManager and broadcast it
+   */
+  update() {
+    if (!this.manager) return;
+    const tasks = this.manager.getAllTasks();
+    const running = tasks.filter((t) => t.status === TASK_STATUS.RUNNING);
+    const completed = tasks.filter((t) => t.status === TASK_STATUS.COMPLETED);
+    const total = tasks.length;
+    const percentage = total > 0 ? Math.round(completed.length / total * 100) : 0;
+    const state2 = {
+      missionId: "current-mission",
+      // Could be dynamic
+      status: percentage === 100 ? "completed" : "executing",
+      progress: {
+        totalTasks: total,
+        completedTasks: completed.length,
+        percentage
+      },
+      activeAgents: running.map((t) => ({
+        id: t.id,
+        type: t.agent,
+        status: t.status,
+        currentTask: t.description
+      })),
+      todo: [],
+      // Need to fetch from TodoEnforcer if possible
+      lastUpdated: /* @__PURE__ */ new Date()
+    };
+    stateBroadcaster.broadcast(state2);
+  }
+  handleStateChange(state2) {
+    if (state2.progress.percentage > 0 && state2.progress.percentage % 25 === 0) {
+      const toastManager = getTaskToastManager();
+      if (toastManager) {
+      }
+    }
+  }
+};
+var progressNotifier = ProgressNotifier.getInstance();
 
 // src/core/memory/interfaces.ts
 var MemoryLevel = /* @__PURE__ */ ((MemoryLevel2) => {
@@ -19526,6 +20140,9 @@ var MemoryManager = class _MemoryManager {
   }
 };
 
+// src/core/agents/manager.ts
+init_core2();
+
 // src/core/agents/agent-registry.ts
 init_shared();
 import * as fs4 from "fs/promises";
@@ -33180,1202 +33797,212 @@ function convertBaseSchema(schema, ctx) {
         if (typeof schema.maxItems === "number") {
           arraySchema = arraySchema.max(schema.maxItems);
         }
-        zodSchema = arraySchema;
-      } else {
-        zodSchema = z.array(z.any());
-      }
-      break;
-    }
-    default:
-      throw new Error(`Unsupported type: ${type}`);
-  }
-  if (schema.description) {
-    zodSchema = zodSchema.describe(schema.description);
-  }
-  if (schema.default !== void 0) {
-    zodSchema = zodSchema.default(schema.default);
-  }
-  return zodSchema;
-}
-function convertSchema(schema, ctx) {
-  if (typeof schema === "boolean") {
-    return schema ? z.any() : z.never();
-  }
-  let baseSchema = convertBaseSchema(schema, ctx);
-  const hasExplicitType = schema.type || schema.enum !== void 0 || schema.const !== void 0;
-  if (schema.anyOf && Array.isArray(schema.anyOf)) {
-    const options = schema.anyOf.map((s) => convertSchema(s, ctx));
-    const anyOfUnion = z.union(options);
-    baseSchema = hasExplicitType ? z.intersection(baseSchema, anyOfUnion) : anyOfUnion;
-  }
-  if (schema.oneOf && Array.isArray(schema.oneOf)) {
-    const options = schema.oneOf.map((s) => convertSchema(s, ctx));
-    const oneOfUnion = z.xor(options);
-    baseSchema = hasExplicitType ? z.intersection(baseSchema, oneOfUnion) : oneOfUnion;
-  }
-  if (schema.allOf && Array.isArray(schema.allOf)) {
-    if (schema.allOf.length === 0) {
-      baseSchema = hasExplicitType ? baseSchema : z.any();
-    } else {
-      let result = hasExplicitType ? baseSchema : convertSchema(schema.allOf[0], ctx);
-      const startIdx = hasExplicitType ? 0 : 1;
-      for (let i = startIdx; i < schema.allOf.length; i++) {
-        result = z.intersection(result, convertSchema(schema.allOf[i], ctx));
-      }
-      baseSchema = result;
-    }
-  }
-  if (schema.nullable === true && ctx.version === "openapi-3.0") {
-    baseSchema = z.nullable(baseSchema);
-  }
-  if (schema.readOnly === true) {
-    baseSchema = z.readonly(baseSchema);
-  }
-  const extraMeta = {};
-  const coreMetadataKeys = ["$id", "id", "$comment", "$anchor", "$vocabulary", "$dynamicRef", "$dynamicAnchor"];
-  for (const key of coreMetadataKeys) {
-    if (key in schema) {
-      extraMeta[key] = schema[key];
-    }
-  }
-  const contentMetadataKeys = ["contentEncoding", "contentMediaType", "contentSchema"];
-  for (const key of contentMetadataKeys) {
-    if (key in schema) {
-      extraMeta[key] = schema[key];
-    }
-  }
-  for (const key of Object.keys(schema)) {
-    if (!RECOGNIZED_KEYS.has(key)) {
-      extraMeta[key] = schema[key];
-    }
-  }
-  if (Object.keys(extraMeta).length > 0) {
-    ctx.registry.add(baseSchema, extraMeta);
-  }
-  return baseSchema;
-}
-function fromJSONSchema(schema, params) {
-  if (typeof schema === "boolean") {
-    return schema ? z.any() : z.never();
-  }
-  const version3 = detectVersion(schema, params?.defaultTarget);
-  const defs = schema.$defs || schema.definitions || {};
-  const ctx = {
-    version: version3,
-    defs,
-    refs: /* @__PURE__ */ new Map(),
-    processing: /* @__PURE__ */ new Set(),
-    rootSchema: schema,
-    registry: params?.registry ?? globalRegistry2
-  };
-  return convertSchema(schema, ctx);
-}
-
-// node_modules/zod/v4/classic/coerce.js
-var coerce_exports2 = {};
-__export(coerce_exports2, {
-  bigint: () => bigint6,
-  boolean: () => boolean6,
-  date: () => date8,
-  number: () => number6,
-  string: () => string6
-});
-function string6(params) {
-  return _coercedString2(ZodString2, params);
-}
-function number6(params) {
-  return _coercedNumber2(ZodNumber2, params);
-}
-function boolean6(params) {
-  return _coercedBoolean2(ZodBoolean2, params);
-}
-function bigint6(params) {
-  return _coercedBigint2(ZodBigInt2, params);
-}
-function date8(params) {
-  return _coercedDate2(ZodDate2, params);
-}
-
-// node_modules/zod/v4/classic/external.js
-config2(en_default2());
-
-// src/core/agents/agent-registry.ts
-var AgentDefinitionSchema = external_exports2.object({
-  id: external_exports2.string(),
-  // ID is required inside the definition object
-  description: external_exports2.string(),
-  systemPrompt: external_exports2.string(),
-  mode: external_exports2.enum(["primary", "subagent"]).optional(),
-  color: external_exports2.string().optional(),
-  hidden: external_exports2.boolean().optional(),
-  thinking: external_exports2.boolean().optional(),
-  maxTokens: external_exports2.number().optional(),
-  budgetTokens: external_exports2.number().optional(),
-  canWrite: external_exports2.boolean(),
-  // Required per interface
-  canBash: external_exports2.boolean()
-  // Required per interface
-});
-var AgentRegistry = class _AgentRegistry {
-  static instance;
-  agents = /* @__PURE__ */ new Map();
-  directory = "";
-  constructor() {
-    for (const [name, def] of Object.entries(AGENTS)) {
-      this.agents.set(name, def);
-    }
-  }
-  static getInstance() {
-    if (!_AgentRegistry.instance) {
-      _AgentRegistry.instance = new _AgentRegistry();
-    }
-    return _AgentRegistry.instance;
-  }
-  setDirectory(dir) {
-    this.directory = dir;
-    this.loadCustomAgents();
-  }
-  /**
-   * Get agent definition by name
-   */
-  getAgent(name) {
-    return this.agents.get(name);
-  }
-  /**
-   * List all available agent names
-   */
-  listAgents() {
-    return Array.from(this.agents.keys());
-  }
-  /**
-   * Add or update an agent definition
-   */
-  registerAgent(name, def) {
-    this.agents.set(name, def);
-    log(`[AgentRegistry] Registered agent: ${name}`);
-  }
-  /**
-   * Load custom agents from .opencode/agents.json
-   */
-  async loadCustomAgents() {
-    if (!this.directory) return;
-    const agentsConfigPath = path4.join(this.directory, PATHS.AGENTS_CONFIG);
-    try {
-      const content = await fs4.readFile(agentsConfigPath, "utf-8");
-      const customAgents = JSON.parse(content);
-      if (typeof customAgents === "object" && customAgents !== null) {
-        for (const [name, def] of Object.entries(customAgents)) {
-          const result = AgentDefinitionSchema.safeParse(def);
-          if (result.success) {
-            this.registerAgent(name, def);
-          } else {
-            log(`[AgentRegistry] Invalid custom agent definition for: ${name}. Errors: ${result.error.message}`);
-          }
-        }
-      }
-    } catch (error92) {
-      if (error92.code !== "ENOENT") {
-        log(`[AgentRegistry] Error loading custom agents: ${error92}`);
-      }
-    }
-  }
-};
-
-// src/core/agents/manager/task-launcher.ts
-var TaskLauncher = class {
-  constructor(client2, directory, store, concurrency, sessionPool2, onTaskError, startPolling) {
-    this.client = client2;
-    this.directory = directory;
-    this.store = store;
-    this.concurrency = concurrency;
-    this.sessionPool = sessionPool2;
-    this.onTaskError = onTaskError;
-    this.startPolling = startPolling;
-  }
-  /**
-   * Unified launch method - handles both single and multiple tasks efficiently.
-   * All session creations happen in parallel immediately.
-   * Concurrency acquisition and prompt firing happen in the background.
-   */
-  async launch(inputs) {
-    const isArray = Array.isArray(inputs);
-    const taskInputs = isArray ? inputs : [inputs];
-    if (taskInputs.length === 0) return isArray ? [] : null;
-    const tasks = await Promise.all(taskInputs.map(
-      (input) => this.prepareTask(input).catch(() => null)
-    ));
-    const successfulTasks = tasks.filter((t) => t !== null);
-    successfulTasks.forEach((task) => {
-      this.executeBackground(task).catch((error92) => {
-        this.onTaskError(task.id, error92);
-      });
-    });
-    if (successfulTasks.length > 0) {
-      this.startPolling();
-    }
-    return isArray ? successfulTasks : successfulTasks[0] || null;
-  }
-  /**
-   * Prepare task: Create session and registration without blocking on concurrency
-   */
-  async prepareTask(input) {
-    const currentDepth = input.depth ?? 0;
-    if (currentDepth >= PARALLEL_TASK.MAX_DEPTH) {
-      throw new Error(`Maximum task depth (${PARALLEL_TASK.MAX_DEPTH}) reached. To prevent infinite recursion, no further sub-tasks can be spawned.`);
-    }
-    const session = await this.sessionPool.acquire(
-      input.agent,
-      input.parentSessionID,
-      input.description
-    );
-    const sessionID = session.id;
-    const taskId = `${ID_PREFIX.TASK}${crypto.randomUUID().slice(0, 8)}`;
-    const task = {
-      id: taskId,
-      sessionID,
-      parentSessionID: input.parentSessionID,
-      description: input.description,
-      prompt: input.prompt,
-      agent: input.agent,
-      status: TASK_STATUS.PENDING,
-      // Start as PENDING
-      startedAt: /* @__PURE__ */ new Date(),
-      concurrencyKey: input.agent,
-      depth: (input.depth ?? 0) + 1,
-      mode: input.mode || "normal",
-      groupID: input.groupID
-    };
-    this.store.set(taskId, task);
-    this.store.trackPending(input.parentSessionID, taskId);
-    taskWAL.log(WAL_ACTIONS.LAUNCH, task).catch(() => {
-    });
-    const toastManager = getTaskToastManager();
-    if (toastManager) {
-      toastManager.addTask({
-        id: taskId,
-        description: input.description,
-        agent: input.agent,
-        isBackground: true,
-        parentSessionID: input.parentSessionID,
-        sessionID
-      });
-    }
-    presets_exports.sessionCreated(sessionID, input.agent);
-    return task;
-  }
-  /**
-   * Background execution: Acquire slot and fire prompt with auto-retry
-   */
-  async executeBackground(task) {
-    let attempt = 1;
-    while (true) {
-      try {
-        await this.concurrency.acquire(task.agent);
-        task.status = TASK_STATUS.RUNNING;
-        task.startedAt = /* @__PURE__ */ new Date();
-        this.store.set(task.id, task);
-        taskWAL.log(WAL_ACTIONS.LAUNCH, task).catch(() => {
-        });
-        const agentDef = AgentRegistry.getInstance().getAgent(task.agent);
-        let finalPrompt = task.prompt;
-        if (agentDef) {
-          finalPrompt = `### AGENT ROLE: ${agentDef.id}
-${agentDef.description}
-
-${agentDef.systemPrompt}
-
-${finalPrompt}`;
-        }
-        const memory = MemoryManager.getInstance().getContext(finalPrompt);
-        const injectedPrompt = memory ? `${memory}
-
-${finalPrompt}` : finalPrompt;
-        const wireAgent = Object.values(AGENT_NAMES).includes(task.agent) ? task.agent : AGENT_NAMES.COMMANDER;
-        const promptPromise = this.client.session.prompt({
-          path: { id: task.sessionID },
-          body: {
-            agent: wireAgent,
-            tools: {
-              [TOOL_NAMES.DELEGATE_TASK]: true,
-              [TOOL_NAMES.GET_TASK_RESULT]: true,
-              [TOOL_NAMES.LIST_TASKS]: true,
-              [TOOL_NAMES.CANCEL_TASK]: true,
-              [TOOL_NAMES.SKILL]: true,
-              [TOOL_NAMES.RUN_COMMAND]: true
-            },
-            parts: [{ type: PART_TYPES.TEXT, text: injectedPrompt }]
-          }
-        });
-        await Promise.race([
-          promptPromise,
-          new Promise(
-            (_, reject) => setTimeout(() => reject(new Error("Session prompt execution timed out after 600s")), 6e5)
-          )
-        ]);
-        return;
-      } catch (error92) {
-        this.concurrency.release(task.agent);
-        const context = {
-          sessionId: task.sessionID,
-          taskId: task.id,
-          agent: task.agent,
-          error: error92 instanceof Error ? error92 : new Error(String(error92)),
-          attempt,
-          timestamp: /* @__PURE__ */ new Date()
-        };
-        const action = handleError(context);
-        if (action.type === "retry") {
-          log(`[AutoRetry] Task ${task.id} failed (attempt ${attempt}). Retrying in ${action.delay}ms...`);
-          if (action.modifyPrompt) {
-            task.prompt += `
-
-${action.modifyPrompt}`;
-          }
-          await new Promise((r) => setTimeout(r, action.delay));
-          attempt++;
-          continue;
-        }
-        throw error92;
-      }
-    }
-  }
-};
-
-// src/core/agents/manager/task-resumer.ts
-init_shared();
-var TaskResumer = class {
-  constructor(client2, store, findBySession, startPolling, notifyParentIfAllComplete) {
-    this.client = client2;
-    this.store = store;
-    this.findBySession = findBySession;
-    this.startPolling = startPolling;
-    this.notifyParentIfAllComplete = notifyParentIfAllComplete;
-  }
-  async resume(input) {
-    const existingTask = this.findBySession(input.sessionId);
-    if (!existingTask) {
-      throw new Error(`Task not found for session: ${input.sessionId}`);
-    }
-    existingTask.status = TASK_STATUS.RUNNING;
-    existingTask.completedAt = void 0;
-    existingTask.error = void 0;
-    existingTask.result = void 0;
-    existingTask.parentSessionID = input.parentSessionID;
-    existingTask.startedAt = /* @__PURE__ */ new Date();
-    existingTask.stablePolls = 0;
-    this.store.trackPending(input.parentSessionID, existingTask.id);
-    this.startPolling();
-    taskWAL.log(WAL_ACTIONS.UPDATE, existingTask).catch(() => {
-    });
-    log(`Resuming task ${existingTask.id} in session ${existingTask.sessionID}`);
-    this.client.session.prompt({
-      path: { id: existingTask.sessionID },
-      body: {
-        agent: existingTask.agent,
-        parts: [{ type: PART_TYPES.TEXT, text: input.prompt }]
-      }
-    }).catch((error92) => {
-      log(`Resume prompt error for ${existingTask.id}:`, error92);
-      existingTask.status = TASK_STATUS.ERROR;
-      existingTask.error = error92 instanceof Error ? error92.message : String(error92);
-      existingTask.completedAt = /* @__PURE__ */ new Date();
-      this.store.untrackPending(input.parentSessionID, existingTask.id);
-      this.store.queueNotification(existingTask);
-      this.notifyParentIfAllComplete(input.parentSessionID).catch(() => {
-      });
-      taskWAL.log(WAL_ACTIONS.UPDATE, existingTask).catch(() => {
-      });
-    });
-    return existingTask;
-  }
-};
-
-// src/core/agents/config.ts
-init_shared();
-var CONFIG = {
-  TASK_TTL_MS: PARALLEL_TASK.TTL_MS,
-  CLEANUP_DELAY_MS: PARALLEL_TASK.CLEANUP_DELAY_MS,
-  MIN_STABILITY_MS: PARALLEL_TASK.MIN_STABILITY_MS,
-  POLL_INTERVAL_MS: PARALLEL_TASK.POLL_INTERVAL_MS
-};
-
-// src/core/agents/manager/task-poller.ts
-init_shared();
-init_shared();
-
-// src/core/progress/state-broadcaster.ts
-var StateBroadcaster = class _StateBroadcaster {
-  static _instance;
-  listeners = /* @__PURE__ */ new Set();
-  currentState = null;
-  constructor() {
-  }
-  static getInstance() {
-    if (!_StateBroadcaster._instance) {
-      _StateBroadcaster._instance = new _StateBroadcaster();
-    }
-    return _StateBroadcaster._instance;
-  }
-  subscribe(listener) {
-    this.listeners.add(listener);
-    if (this.currentState) {
-      listener(this.currentState);
-    }
-    return () => this.listeners.delete(listener);
-  }
-  broadcast(state2) {
-    this.currentState = state2;
-    this.listeners.forEach((listener) => {
-      try {
-        listener(state2);
-      } catch (error92) {
-      }
-    });
-  }
-  getCurrentState() {
-    return this.currentState;
-  }
-};
-var stateBroadcaster = StateBroadcaster.getInstance();
-
-// src/core/progress/progress-notifier.ts
-init_shared();
-var ProgressNotifier = class _ProgressNotifier {
-  static _instance;
-  manager = null;
-  constructor() {
-    stateBroadcaster.subscribe(this.handleStateChange.bind(this));
-  }
-  static getInstance() {
-    if (!_ProgressNotifier._instance) {
-      _ProgressNotifier._instance = new _ProgressNotifier();
-    }
-    return _ProgressNotifier._instance;
-  }
-  setManager(manager) {
-    this.manager = manager;
-  }
-  /**
-   * Poll current status from ParallelAgentManager and broadcast it
-   */
-  update() {
-    if (!this.manager) return;
-    const tasks = this.manager.getAllTasks();
-    const running = tasks.filter((t) => t.status === TASK_STATUS.RUNNING);
-    const completed = tasks.filter((t) => t.status === TASK_STATUS.COMPLETED);
-    const total = tasks.length;
-    const percentage = total > 0 ? Math.round(completed.length / total * 100) : 0;
-    const state2 = {
-      missionId: "current-mission",
-      // Could be dynamic
-      status: percentage === 100 ? "completed" : "executing",
-      progress: {
-        totalTasks: total,
-        completedTasks: completed.length,
-        percentage
-      },
-      activeAgents: running.map((t) => ({
-        id: t.id,
-        type: t.agent,
-        status: t.status,
-        currentTask: t.description
-      })),
-      todo: [],
-      // Need to fetch from TodoEnforcer if possible
-      lastUpdated: /* @__PURE__ */ new Date()
-    };
-    stateBroadcaster.broadcast(state2);
-  }
-  handleStateChange(state2) {
-    if (state2.progress.percentage > 0 && state2.progress.percentage % 25 === 0) {
-      const toastManager = getTaskToastManager();
-      if (toastManager) {
-      }
-    }
-  }
-};
-var progressNotifier = ProgressNotifier.getInstance();
-
-// src/core/agents/manager/task-poller.ts
-var MAX_TASK_DURATION_MS = 6e5;
-var TaskPoller = class {
-  constructor(client2, store, concurrency, notifyParentIfAllComplete, scheduleCleanup, pruneExpiredTasks, onTaskComplete, onTaskError) {
-    this.client = client2;
-    this.store = store;
-    this.concurrency = concurrency;
-    this.notifyParentIfAllComplete = notifyParentIfAllComplete;
-    this.scheduleCleanup = scheduleCleanup;
-    this.pruneExpiredTasks = pruneExpiredTasks;
-    this.onTaskComplete = onTaskComplete;
-    this.onTaskError = onTaskError;
-  }
-  pollingInterval;
-  messageCache = /* @__PURE__ */ new Map();
-  start() {
-    if (this.pollingInterval) return;
-    log("[task-poller.ts] start() - polling started");
-    this.pollingInterval = setInterval(() => this.poll(), CONFIG.POLL_INTERVAL_MS);
-    this.pollingInterval.unref();
-  }
-  stop() {
-    if (this.pollingInterval) {
-      clearInterval(this.pollingInterval);
-      this.pollingInterval = void 0;
-    }
-  }
-  isRunning() {
-    return !!this.pollingInterval;
-  }
-  async poll() {
-    this.pruneExpiredTasks();
-    const running = this.store.getRunning();
-    if (running.length === 0) {
-      this.stop();
-      return;
-    }
-    log("[task-poller.ts] poll() checking", running.length, "running tasks");
-    try {
-      const statusResult = await this.client.session.status();
-      const allStatuses = statusResult.data ?? {};
-      for (const task of running) {
-        try {
-          const taskDuration = Date.now() - task.startedAt.getTime();
-          if (isSessionStale(task.sessionID)) {
-            log(`[task-poller] Task ${task.id} session is stale. Marking as error.`);
-            this.onTaskError?.(task.id, new Error("Session became stale (no response from agent)"));
-            continue;
-          }
-          if (taskDuration > MAX_TASK_DURATION_MS) {
-            log(`[task-poller] Task ${task.id} exceeded max duration (${MAX_TASK_DURATION_MS}ms). Marking as error.`);
-            this.onTaskError?.(task.id, new Error("Task exceeded maximum execution time"));
-            continue;
-          }
-          if (task.status === TASK_STATUS.PENDING) continue;
-          const sessionStatus = allStatuses[task.sessionID];
-          if (sessionStatus?.type === SESSION_STATUS.IDLE) {
-            const elapsed2 = Date.now() - task.startedAt.getTime();
-            if (elapsed2 < CONFIG.MIN_STABILITY_MS) continue;
-            if (!task.hasStartedOutputting && !await this.validateSessionHasOutput(task.sessionID, task)) continue;
-            await this.completeTask(task);
-            continue;
-          }
-          await this.updateTaskProgress(task);
-          const elapsed = Date.now() - task.startedAt.getTime();
-          if (elapsed >= CONFIG.MIN_STABILITY_MS && task.stablePolls && task.stablePolls >= 3) {
-            if (task.hasStartedOutputting || await this.validateSessionHasOutput(task.sessionID, task)) {
-              log(`Task ${task.id} stable for 3 polls, completing...`);
-              await this.completeTask(task);
-            }
-          }
-        } catch (error92) {
-          log(`Poll error for task ${task.id}:`, error92);
-        }
-      }
-      progressNotifier.update();
-    } catch (error92) {
-      log("Polling error:", error92);
-    }
-  }
-  async validateSessionHasOutput(sessionID, task) {
-    try {
-      const response = await this.client.session.messages({ path: { id: sessionID } });
-      const messages = response.data ?? [];
-      const hasOutput = messages.some((m) => m.info?.role === MESSAGE_ROLES.ASSISTANT && m.parts?.some((p) => p.type === PART_TYPES.TEXT && p.text?.trim() || p.type === PART_TYPES.TOOL));
-      if (hasOutput && task) {
-        task.hasStartedOutputting = true;
-      }
-      return hasOutput;
-    } catch {
-      return true;
-    }
-  }
-  async completeTask(task) {
-    log("[task-poller.ts] completeTask() called for", task.id, task.agent);
-    task.status = TASK_STATUS.COMPLETED;
-    task.completedAt = /* @__PURE__ */ new Date();
-    if (task.concurrencyKey) {
-      this.concurrency.release(task.concurrencyKey);
-      this.concurrency.reportResult(task.concurrencyKey, true);
-      task.concurrencyKey = void 0;
-    }
-    this.store.untrackPending(task.parentSessionID, task.id);
-    this.store.queueNotification(task);
-    await this.notifyParentIfAllComplete(task.parentSessionID);
-    this.scheduleCleanup(task.id);
-    taskWAL.log(WAL_ACTIONS.COMPLETE, task).catch(() => {
-    });
-    if (this.onTaskComplete) {
-      Promise.resolve(this.onTaskComplete(task)).catch((err) => log("Error in onTaskComplete callback:", err));
-    }
-    const duration5 = formatDuration(task.startedAt, task.completedAt);
-    presets_exports.sessionCompleted(task.sessionID, duration5);
-    log(`Completed ${task.id} (${duration5})`);
-    progressNotifier.update();
-  }
-  async updateTaskProgress(task) {
-    try {
-      const cached3 = this.messageCache.get(task.sessionID);
-      const statusResult = await this.client.session.status();
-      const sessionInfo = statusResult.data?.[task.sessionID];
-      const currentMsgCount = sessionInfo?.messageCount ?? 0;
-      if (cached3 && cached3.count === currentMsgCount) {
-        task.stablePolls = (task.stablePolls ?? 0) + 1;
-        return;
-      }
-      const result = await this.client.session.messages({ path: { id: task.sessionID } });
-      this.messageCache.set(task.sessionID, { count: currentMsgCount, lastChecked: /* @__PURE__ */ new Date() });
-      if (result.error) return;
-      const messages = result.data ?? [];
-      const assistantMsgs = messages.filter((m) => m.info?.role === MESSAGE_ROLES.ASSISTANT);
-      let toolCalls = 0;
-      let lastTool;
-      let lastMessage;
-      for (const msg of assistantMsgs) {
-        for (const part of msg.parts ?? []) {
-          if (part.type === PART_TYPES.TOOL_USE || part.tool) {
-            toolCalls++;
-            lastTool = part.tool || part.name;
-          }
-          if (part.type === PART_TYPES.TEXT && part.text) {
-            lastMessage = part.text;
-          }
-        }
-      }
-      task.progress = {
-        toolCalls,
-        lastTool,
-        lastMessage: lastMessage?.slice(0, 100),
-        lastUpdate: /* @__PURE__ */ new Date()
-      };
-      if (task.lastMsgCount === currentMsgCount) {
-        task.stablePolls = 0;
+        zodSchema = arraySchema;
       } else {
-        task.stablePolls = 0;
+        zodSchema = z.array(z.any());
       }
-      task.lastMsgCount = currentMsgCount;
-    } catch {
+      break;
     }
+    default:
+      throw new Error(`Unsupported type: ${type}`);
   }
-};
-
-// src/core/agents/manager/task-cleaner.ts
-init_shared();
-init_store();
-var TaskCleaner = class {
-  constructor(client2, store, concurrency, sessionPool2) {
-    this.client = client2;
-    this.store = store;
-    this.concurrency = concurrency;
-    this.sessionPool = sessionPool2;
+  if (schema.description) {
+    zodSchema = zodSchema.describe(schema.description);
   }
-  pruneExpiredTasks() {
-    const now = Date.now();
-    for (const [taskId, task] of this.store.getAll().map((t) => [t.id, t])) {
-      const age = now - task.startedAt.getTime();
-      if (age <= CONFIG.TASK_TTL_MS) continue;
-      log(`Timeout: ${taskId}`);
-      if (task.status === TASK_STATUS.RUNNING) {
-        task.status = TASK_STATUS.TIMEOUT;
-        task.error = "Task exceeded 30 minute time limit";
-        task.completedAt = /* @__PURE__ */ new Date();
-        if (task.concurrencyKey) this.concurrency.release(task.concurrencyKey);
-        this.store.untrackPending(task.parentSessionID, taskId);
-        const toastManager = getTaskToastManager();
-        if (toastManager) {
-          toastManager.showCompletionToast({
-            id: taskId,
-            description: task.description,
-            duration: formatDuration(task.startedAt, task.completedAt),
-            status: TASK_STATUS.ERROR,
-            error: task.error
-          });
-        }
-      }
-      this.sessionPool.release(task.sessionID).catch(() => {
-      });
-      clear2(task.sessionID);
-      this.store.delete(taskId);
-      taskWAL.log(WAL_ACTIONS.DELETE, task).catch(() => {
-      });
-    }
-    this.store.cleanEmptyNotifications();
+  if (schema.default !== void 0) {
+    zodSchema = zodSchema.default(schema.default);
   }
-  scheduleCleanup(taskId) {
-    const task = this.store.get(taskId);
-    const sessionID = task?.sessionID;
-    setTimeout(async () => {
-      if (sessionID) {
-        try {
-          await this.sessionPool.release(sessionID);
-          clear2(sessionID);
-        } catch {
-        }
-      }
-      this.store.delete(taskId);
-      if (task) taskWAL.log(WAL_ACTIONS.DELETE, task).catch(() => {
-      });
-      log(`Cleaned up ${taskId}`);
-    }, CONFIG.CLEANUP_DELAY_MS);
+  return zodSchema;
+}
+function convertSchema(schema, ctx) {
+  if (typeof schema === "boolean") {
+    return schema ? z.any() : z.never();
   }
-  /**
-   * Notify parent session when task(s) complete.
-   * Uses noReply strategy:
-   * - Individual completion: noReply=true (silent notification, save tokens)
-   * - All complete: noReply=false (AI should process and report results)
-   */
-  async notifyParentIfAllComplete(parentSessionID) {
-    const pendingCount = this.store.getPendingCount(parentSessionID);
-    const notifications = this.store.getNotifications(parentSessionID);
-    if (notifications.length === 0) return;
-    const allComplete = pendingCount === 0;
-    const toastManager = getTaskToastManager();
-    const completionInfos = notifications.map((task) => ({
-      id: task.id,
-      description: task.description,
-      duration: formatDuration(task.startedAt, task.completedAt),
-      status: task.status,
-      error: task.error
-    }));
-    if (allComplete && completionInfos.length > 1 && toastManager) {
-      toastManager.showAllCompleteToast(parentSessionID, completionInfos);
-    } else if (toastManager) {
-      for (const info of completionInfos) {
-        toastManager.showCompletionToast(info);
+  let baseSchema = convertBaseSchema(schema, ctx);
+  const hasExplicitType = schema.type || schema.enum !== void 0 || schema.const !== void 0;
+  if (schema.anyOf && Array.isArray(schema.anyOf)) {
+    const options = schema.anyOf.map((s) => convertSchema(s, ctx));
+    const anyOfUnion = z.union(options);
+    baseSchema = hasExplicitType ? z.intersection(baseSchema, anyOfUnion) : anyOfUnion;
+  }
+  if (schema.oneOf && Array.isArray(schema.oneOf)) {
+    const options = schema.oneOf.map((s) => convertSchema(s, ctx));
+    const oneOfUnion = z.xor(options);
+    baseSchema = hasExplicitType ? z.intersection(baseSchema, oneOfUnion) : oneOfUnion;
+  }
+  if (schema.allOf && Array.isArray(schema.allOf)) {
+    if (schema.allOf.length === 0) {
+      baseSchema = hasExplicitType ? baseSchema : z.any();
+    } else {
+      let result = hasExplicitType ? baseSchema : convertSchema(schema.allOf[0], ctx);
+      const startIdx = hasExplicitType ? 0 : 1;
+      for (let i = startIdx; i < schema.allOf.length; i++) {
+        result = z.intersection(result, convertSchema(schema.allOf[i], ctx));
       }
+      baseSchema = result;
     }
-    let message;
-    if (allComplete) {
-      message = buildNotificationMessage(notifications);
-      message += `
-
-**ACTION REQUIRED:** All background tasks are complete. Use \`get_task_result(taskId)\` to retrieve outputs and continue with the mission.`;
-    } else {
-      const completedCount = notifications.length;
-      message = `[BACKGROUND UPDATE] ${completedCount} task(s) completed, ${pendingCount} still running.
-Completed: ${notifications.map((t) => `\`${t.id}\``).join(", ")}
-You will be notified when ALL tasks complete. Continue productive work.`;
+  }
+  if (schema.nullable === true && ctx.version === "openapi-3.0") {
+    baseSchema = z.nullable(baseSchema);
+  }
+  if (schema.readOnly === true) {
+    baseSchema = z.readonly(baseSchema);
+  }
+  const extraMeta = {};
+  const coreMetadataKeys = ["$id", "id", "$comment", "$anchor", "$vocabulary", "$dynamicRef", "$dynamicAnchor"];
+  for (const key of coreMetadataKeys) {
+    if (key in schema) {
+      extraMeta[key] = schema[key];
     }
-    try {
-      await this.client.session.prompt({
-        path: { id: parentSessionID },
-        body: {
-          // Key optimization: only trigger AI response when ALL complete
-          noReply: !allComplete,
-          parts: [{ type: PART_TYPES.TEXT, text: message }]
-        }
-      });
-      log(`Notified parent ${parentSessionID} (allComplete=${allComplete}, noReply=${!allComplete})`);
-    } catch (error92) {
-      log("Notification error:", error92);
+  }
+  const contentMetadataKeys = ["contentEncoding", "contentMediaType", "contentSchema"];
+  for (const key of contentMetadataKeys) {
+    if (key in schema) {
+      extraMeta[key] = schema[key];
     }
-    this.store.clearNotifications(parentSessionID);
   }
-};
-
-// src/core/agents/manager/event-handler.ts
-init_shared();
-
-// src/core/loop/continuation-lock.ts
-var locks = /* @__PURE__ */ new Map();
-var LOCK_TIMEOUT_MS = 3e4;
-function tryAcquireContinuationLock(sessionID, source) {
-  const now = Date.now();
-  const existing = locks.get(sessionID);
-  if (existing?.acquired) {
-    const elapsed = now - existing.timestamp;
-    if (elapsed < LOCK_TIMEOUT_MS) {
-      log("[continuation-lock] Lock denied - already held", {
-        sessionID: sessionID.slice(0, 8),
-        heldBy: existing.source,
-        requestedBy: source,
-        elapsedMs: elapsed
-      });
-      return false;
+  for (const key of Object.keys(schema)) {
+    if (!RECOGNIZED_KEYS.has(key)) {
+      extraMeta[key] = schema[key];
     }
-    log("[continuation-lock] Forcing stale lock release", {
-      sessionID: sessionID.slice(0, 8),
-      staleSource: existing.source,
-      elapsedMs: elapsed
-    });
   }
-  locks.set(sessionID, { acquired: true, timestamp: now, source });
-  log("[continuation-lock] Lock acquired", {
-    sessionID: sessionID.slice(0, 8),
-    source
-  });
-  return true;
-}
-function releaseContinuationLock(sessionID) {
-  const existing = locks.get(sessionID);
-  if (existing?.acquired) {
-    const duration5 = Date.now() - existing.timestamp;
-    log("[continuation-lock] Lock released", {
-      sessionID: sessionID.slice(0, 8),
-      source: existing.source,
-      heldMs: duration5
-    });
+  if (Object.keys(extraMeta).length > 0) {
+    ctx.registry.add(baseSchema, extraMeta);
   }
-  locks.delete(sessionID);
+  return baseSchema;
 }
-function hasContinuationLock(sessionID) {
-  const lock = locks.get(sessionID);
-  if (!lock?.acquired) return false;
-  if (Date.now() - lock.timestamp >= LOCK_TIMEOUT_MS) {
-    log("[continuation-lock] Stale lock detected during check", {
-      sessionID: sessionID.slice(0, 8)
-    });
-    locks.delete(sessionID);
-    return false;
+function fromJSONSchema(schema, params) {
+  if (typeof schema === "boolean") {
+    return schema ? z.any() : z.never();
   }
-  return true;
+  const version3 = detectVersion(schema, params?.defaultTarget);
+  const defs = schema.$defs || schema.definitions || {};
+  const ctx = {
+    version: version3,
+    defs,
+    refs: /* @__PURE__ */ new Map(),
+    processing: /* @__PURE__ */ new Set(),
+    rootSchema: schema,
+    registry: params?.registry ?? globalRegistry2
+  };
+  return convertSchema(schema, ctx);
 }
-function cleanupContinuationLock(sessionID) {
-  locks.delete(sessionID);
+
+// node_modules/zod/v4/classic/coerce.js
+var coerce_exports2 = {};
+__export(coerce_exports2, {
+  bigint: () => bigint6,
+  boolean: () => boolean6,
+  date: () => date8,
+  number: () => number6,
+  string: () => string6
+});
+function string6(params) {
+  return _coercedString2(ZodString2, params);
+}
+function number6(params) {
+  return _coercedNumber2(ZodNumber2, params);
+}
+function boolean6(params) {
+  return _coercedBoolean2(ZodBoolean2, params);
+}
+function bigint6(params) {
+  return _coercedBigint2(ZodBigInt2, params);
+}
+function date8(params) {
+  return _coercedDate2(ZodDate2, params);
 }
 
-// src/core/agents/manager/event-handler.ts
-var EventHandler = class {
-  constructor(client2, store, concurrency, findBySession, notifyParentIfAllComplete, scheduleCleanup, validateSessionHasOutput2, onTaskComplete) {
-    this.client = client2;
-    this.store = store;
-    this.concurrency = concurrency;
-    this.findBySession = findBySession;
-    this.notifyParentIfAllComplete = notifyParentIfAllComplete;
-    this.scheduleCleanup = scheduleCleanup;
-    this.validateSessionHasOutput = validateSessionHasOutput2;
-    this.onTaskComplete = onTaskComplete;
-  }
-  /**
-   * Handle OpenCode session events for proper resource cleanup.
-   * Call this from your plugin's event hook.
-   */
-  handle(event) {
-    const props = event.properties;
-    if (event.type === SESSION_EVENTS.IDLE) {
-      const sessionID = props?.sessionID;
-      if (!sessionID) return;
-      recordSessionResponse(sessionID);
-      const task = this.findBySession(sessionID);
-      if (!task || task.status !== TASK_STATUS.RUNNING) return;
-      this.handleSessionIdle(task).catch((err) => {
-        log("Error handling session.idle:", err);
-      });
-    }
-    if (event.type === SESSION_EVENTS.DELETED) {
-      const sessionID = props?.info?.id ?? props?.sessionID;
-      if (!sessionID) return;
-      const task = this.findBySession(sessionID);
-      if (!task) return;
-      this.handleSessionDeleted(task);
-    }
-  }
-  async handleSessionIdle(task) {
-    const elapsed = Date.now() - task.startedAt.getTime();
-    if (elapsed < CONFIG.MIN_STABILITY_MS) {
-      log(`Session idle but too early for ${task.id}, waiting...`);
-      return;
-    }
-    const hasOutput = await this.validateSessionHasOutput(task.sessionID);
-    if (!hasOutput) {
-      log(`Session idle but no output for ${task.id}, waiting...`);
-      return;
-    }
-    task.status = TASK_STATUS.COMPLETED;
-    task.completedAt = /* @__PURE__ */ new Date();
-    if (task.concurrencyKey) {
-      this.concurrency.release(task.concurrencyKey);
-      this.concurrency.reportResult(task.concurrencyKey, true);
-      task.concurrencyKey = void 0;
-    }
-    this.store.untrackPending(task.parentSessionID, task.id);
-    this.store.queueNotification(task);
-    await this.notifyParentIfAllComplete(task.parentSessionID);
-    this.scheduleCleanup(task.id);
-    taskWAL.log(WAL_ACTIONS.COMPLETE, task).catch(() => {
-    });
-    if (this.onTaskComplete) {
-      Promise.resolve(this.onTaskComplete(task)).catch((err) => log("Error in onTaskComplete callback:", err));
-    }
-    progressNotifier.update();
-    log(`Task ${task.id} completed via session.idle event (${formatDuration(task.startedAt, task.completedAt)})`);
-  }
-  handleSessionDeleted(task) {
-    log(`Session deleted event for task ${task.id}`);
-    if (task.status === TASK_STATUS.RUNNING) {
-      task.status = TASK_STATUS.ERROR;
-      task.error = "Session deleted";
-      task.completedAt = /* @__PURE__ */ new Date();
-    }
-    if (task.concurrencyKey) {
-      this.concurrency.release(task.concurrencyKey);
-      this.concurrency.reportResult(task.concurrencyKey, false);
-      task.concurrencyKey = void 0;
-    }
-    this.store.untrackPending(task.parentSessionID, task.id);
-    this.store.clearNotificationsForTask(task.id);
-    this.store.delete(task.id);
-    taskWAL.log(WAL_ACTIONS.DELETE, task).catch(() => {
-    });
-    cleanupSessionHealth(task.sessionID);
-    cleanupContinuationLock(task.sessionID);
-    progressNotifier.update();
-    log(`Cleaned up deleted session task: ${task.id}`);
-  }
-};
+// node_modules/zod/v4/classic/external.js
+config2(en_default2());
 
-// src/core/agents/session-pool.ts
-init_shared();
-var DEFAULT_CONFIG = {
-  maxPoolSizePerAgent: 5,
-  idleTimeoutMs: 3e5,
-  // 5 minutes
-  maxReuseCount: 10,
-  healthCheckIntervalMs: 6e4
-  // 1 minute
-};
-var SessionPool = class _SessionPool {
-  static _instance;
-  pool = /* @__PURE__ */ new Map();
-  // key: agentName
-  sessionsById = /* @__PURE__ */ new Map();
-  config;
-  client;
-  directory;
-  healthCheckInterval = null;
-  // Statistics
-  stats = {
-    reuseHits: 0,
-    creationMisses: 0
-  };
-  constructor(client2, directory, config3 = {}) {
-    this.client = client2;
-    this.directory = directory;
-    this.config = { ...DEFAULT_CONFIG, ...config3 };
-    this.startHealthCheck();
-  }
-  static getInstance(client2, directory, config3) {
-    if (!_SessionPool._instance) {
-      if (!client2 || !directory) {
-        throw new Error("SessionPool requires client and directory on first call");
-      }
-      _SessionPool._instance = new _SessionPool(client2, directory, config3);
-    }
-    return _SessionPool._instance;
-  }
-  /**
-   * Acquire a session from the pool or create a new one.
-   */
-  async acquire(agentName, parentSessionID, description) {
-    const poolKey = this.getPoolKey(agentName);
-    const agentPool = this.pool.get(poolKey) || [];
-    const available = agentPool.find((s) => !s.inUse && s.reuseCount < this.config.maxReuseCount);
-    if (available) {
-      available.inUse = true;
-      available.lastUsedAt = /* @__PURE__ */ new Date();
-      available.reuseCount++;
-      this.stats.reuseHits++;
-      log(`[SessionPool] Reusing session ${available.id.slice(0, 8)}... for ${agentName} (reuse #${available.reuseCount})`);
-      return available;
+// src/core/agents/agent-registry.ts
+var AgentDefinitionSchema = external_exports2.object({
+  id: external_exports2.string(),
+  // ID is required inside the definition object
+  description: external_exports2.string(),
+  systemPrompt: external_exports2.string(),
+  mode: external_exports2.enum(["primary", "subagent"]).optional(),
+  color: external_exports2.string().optional(),
+  hidden: external_exports2.boolean().optional(),
+  thinking: external_exports2.boolean().optional(),
+  maxTokens: external_exports2.number().optional(),
+  budgetTokens: external_exports2.number().optional(),
+  canWrite: external_exports2.boolean(),
+  // Required per interface
+  canBash: external_exports2.boolean()
+  // Required per interface
+});
+var AgentRegistry = class _AgentRegistry {
+  static instance;
+  agents = /* @__PURE__ */ new Map();
+  directory = "";
+  constructor() {
+    for (const [name, def] of Object.entries(AGENTS)) {
+      this.agents.set(name, def);
     }
-    this.stats.creationMisses++;
-    return this.createSession(agentName, parentSessionID, description);
   }
-  /**
-   * Release a session back to the pool for reuse.
-   */
-  async release(sessionId) {
-    const session = this.sessionsById.get(sessionId);
-    if (!session) {
-      log(`[SessionPool] Session ${sessionId.slice(0, 8)}... not found in pool`);
-      return;
-    }
-    const now = Date.now();
-    const age = now - session.createdAt.getTime();
-    const idle = now - session.lastUsedAt.getTime();
-    if (session.reuseCount >= this.config.maxReuseCount || age > this.config.idleTimeoutMs * 2) {
-      await this.invalidate(sessionId);
-      return;
-    }
-    const poolKey = this.getPoolKey(session.agentName);
-    const agentPool = this.pool.get(poolKey) || [];
-    const availableCount = agentPool.filter((s) => !s.inUse).length;
-    if (availableCount >= this.config.maxPoolSizePerAgent) {
-      const oldest = agentPool.filter((s) => !s.inUse).sort((a, b) => a.lastUsedAt.getTime() - b.lastUsedAt.getTime())[0];
-      if (oldest) {
-        await this.deleteSession(oldest.id);
-      }
+  static getInstance() {
+    if (!_AgentRegistry.instance) {
+      _AgentRegistry.instance = new _AgentRegistry();
     }
-    await this.resetSession(sessionId);
-    session.inUse = false;
-    log(`[SessionPool] Released session ${sessionId.slice(0, 8)}... to pool`);
+    return _AgentRegistry.instance;
   }
-  /**
-   * Invalidate a session (remove from pool and delete).
-   */
-  async invalidate(sessionId) {
-    const session = this.sessionsById.get(sessionId);
-    if (!session) return;
-    await this.deleteSession(sessionId);
-    log(`[SessionPool] Invalidated session ${sessionId.slice(0, 8)}...`);
+  setDirectory(dir) {
+    this.directory = dir;
+    this.loadCustomAgents();
   }
   /**
-   * Get current pool statistics.
+   * Get agent definition by name
    */
-  getStats() {
-    const byAgent = {};
-    for (const [agentName, sessions] of this.pool.entries()) {
-      const inUse = sessions.filter((s) => s.inUse).length;
-      byAgent[agentName] = {
-        total: sessions.length,
-        inUse,
-        available: sessions.length - inUse
-      };
-    }
-    const allSessions = Array.from(this.sessionsById.values());
-    const inUseCount = allSessions.filter((s) => s.inUse).length;
-    return {
-      totalSessions: allSessions.length,
-      sessionsInUse: inUseCount,
-      availableSessions: allSessions.length - inUseCount,
-      reuseHits: this.stats.reuseHits,
-      creationMisses: this.stats.creationMisses,
-      byAgent
-    };
+  getAgent(name) {
+    return this.agents.get(name);
   }
   /**
-   * Cleanup stale sessions.
+   * List all available agent names
    */
-  async cleanup() {
-    const now = Date.now();
-    let cleanedCount = 0;
-    for (const [sessionId, session] of this.sessionsById.entries()) {
-      if (session.inUse) continue;
-      const idle = now - session.lastUsedAt.getTime();
-      if (idle > this.config.idleTimeoutMs) {
-        await this.deleteSession(sessionId);
-        cleanedCount++;
-      }
-    }
-    if (cleanedCount > 0) {
-      log(`[SessionPool] Cleaned up ${cleanedCount} stale sessions`);
-    }
-    return cleanedCount;
+  listAgents() {
+    return Array.from(this.agents.keys());
   }
   /**
-   * Shutdown the pool.
+   * Add or update an agent definition
    */
-  async shutdown() {
-    log("[SessionPool] Shutting down...");
-    if (this.healthCheckInterval) {
-      clearInterval(this.healthCheckInterval);
-      this.healthCheckInterval = null;
-    }
-    const deletePromises = Array.from(this.sessionsById.keys()).map(
-      (id) => this.deleteSession(id).catch(() => {
-      })
-    );
-    await Promise.all(deletePromises);
-    this.pool.clear();
-    this.sessionsById.clear();
-    log("[SessionPool] Shutdown complete");
+  registerAgent(name, def) {
+    this.agents.set(name, def);
+    log(`[AgentRegistry] Registered agent: ${name}`);
   }
-  // =========================================================================
-  // Private Methods
-  // =========================================================================
   /**
-   * Reset/Compact a session to clear context for next reuse.
+   * Load custom agents from .opencode/agents.json
    */
-  async resetSession(sessionId) {
-    const session = this.sessionsById.get(sessionId);
-    if (!session) return;
-    log(`[SessionPool] Resetting session ${sessionId.slice(0, 8)}...`);
+  async loadCustomAgents() {
+    if (!this.directory) return;
+    const agentsConfigPath = path4.join(this.directory, PATHS.AGENTS_CONFIG);
     try {
-      await this.client.session.compact?.({ path: { id: sessionId } });
-      session.lastResetAt = /* @__PURE__ */ new Date();
-      session.health = "healthy";
-    } catch (error92) {
-      log(`[SessionPool] Failed to reset session ${sessionId.slice(0, 8)}: ${error92}`);
-      session.health = "degraded";
-    }
-  }
-  getPoolKey(agentName) {
-    return agentName;
-  }
-  async createSession(agentName, parentSessionID, description) {
-    log(`[SessionPool] Creating new session for ${agentName}`);
-    const result = await Promise.race([
-      this.client.session.create({
-        body: {
-          parentID: parentSessionID,
-          title: `${PARALLEL_TASK.SESSION_TITLE_PREFIX}: ${description}`
-        },
-        query: { directory: this.directory }
-      }),
-      new Promise(
-        (_, reject) => setTimeout(() => reject(new Error("Session creation timed out after 60s")), 6e4)
-      )
-    ]);
-    if (result.error || !result.data?.id) {
-      throw new Error(`Session creation failed: ${result.error || "No ID"}`);
-    }
-    const session = {
-      id: result.data.id,
-      agentName,
-      projectDirectory: this.directory,
-      createdAt: /* @__PURE__ */ new Date(),
-      lastUsedAt: /* @__PURE__ */ new Date(),
-      reuseCount: 0,
-      inUse: true,
-      health: "healthy",
-      lastResetAt: /* @__PURE__ */ new Date()
-    };
-    const poolKey = this.getPoolKey(agentName);
-    const agentPool = this.pool.get(poolKey) || [];
-    agentPool.push(session);
-    this.pool.set(poolKey, agentPool);
-    this.sessionsById.set(session.id, session);
-    return session;
-  }
-  async deleteSession(sessionId) {
-    const session = this.sessionsById.get(sessionId);
-    if (!session) return;
-    this.sessionsById.delete(sessionId);
-    const poolKey = this.getPoolKey(session.agentName);
-    const agentPool = this.pool.get(poolKey);
-    if (agentPool) {
-      const idx = agentPool.findIndex((s) => s.id === sessionId);
-      if (idx !== -1) {
-        agentPool.splice(idx, 1);
+      const content = await fs4.readFile(agentsConfigPath, "utf-8");
+      const customAgents = JSON.parse(content);
+      if (typeof customAgents === "object" && customAgents !== null) {
+        for (const [name, def] of Object.entries(customAgents)) {
+          const result = AgentDefinitionSchema.safeParse(def);
+          if (result.success) {
+            this.registerAgent(name, def);
+          } else {
+            log(`[AgentRegistry] Invalid custom agent definition for: ${name}. Errors: ${result.error.message}`);
+          }
+        }
       }
-      if (agentPool.length === 0) {
-        this.pool.delete(poolKey);
+    } catch (error92) {
+      if (error92.code !== "ENOENT") {
+        log(`[AgentRegistry] Error loading custom agents: ${error92}`);
       }
     }
-    try {
-      await this.client.session.delete({ path: { id: sessionId } });
-    } catch {
-    }
-  }
-  startHealthCheck() {
-    this.healthCheckInterval = setInterval(() => {
-      this.cleanup().catch(() => {
-      });
-    }, this.config.healthCheckIntervalMs);
-    this.healthCheckInterval.unref?.();
   }
 };
-var sessionPool = {
-  getInstance: SessionPool.getInstance.bind(SessionPool)
-};
-
-// src/core/agents/manager.ts
-init_core2();
 
 // src/core/todo/todo-manager.ts
 init_shared();
 import * as fs5 from "node:fs";
 import * as path5 from "node:path";
-import * as crypto2 from "node:crypto";
+import * as crypto from "node:crypto";
 var TodoManager = class _TodoManager {
   static _instance;
   directory = "";
@@ -34445,13 +34072,22 @@ var TodoManager = class _TodoManager {
     });
   }
   async _internalUpdate(expectedVersion, updater, author) {
-    const MAX_RETRIES2 = 3;
-    const RETRY_DELAY = 50;
+    const MAX_RETRIES2 = 5;
+    const BASE_DELAY_MS = 50;
     for (let attempt = 0; attempt < MAX_RETRIES2; attempt++) {
       try {
         const current = await this.readWithVersion();
         if (current.version.version !== expectedVersion) {
           log(`[TodoManager] Conflict: expected v${expectedVersion}, found v${current.version.version}`);
+          if (attempt < MAX_RETRIES2 - 1) {
+            const backoffDelay = BASE_DELAY_MS * Math.pow(2, attempt);
+            const jitter = Math.random() * 50;
+            const totalDelay = backoffDelay + jitter;
+            log(`[TodoManager] Retrying in ${Math.round(totalDelay)}ms (attempt ${attempt + 1}/${MAX_RETRIES2})`);
+            await new Promise((r) => setTimeout(r, totalDelay));
+            expectedVersion = current.version.version;
+            continue;
+          }
           return {
             success: false,
             currentVersion: current.version.version,
@@ -34474,18 +34110,21 @@ var TodoManager = class _TodoManager {
         await fs5.promises.rename(tmpPath, this.todoPath);
         this.logChange(newVersion, newContent, author).catch(() => {
         });
-        log(`[TodoManager] Updated TODO to v${newVersion} by ${author}`);
+        log(`[TodoManager] Updated TODO to v${newVersion} by ${author}${attempt > 0 ? ` (after ${attempt} retries)` : ""}`);
         return { success: true, currentVersion: newVersion };
       } catch (error92) {
         if (attempt === MAX_RETRIES2 - 1) throw error92;
-        await new Promise((r) => setTimeout(r, RETRY_DELAY));
+        const backoffDelay = BASE_DELAY_MS * Math.pow(2, attempt);
+        const jitter = Math.random() * 50;
+        await new Promise((r) => setTimeout(r, backoffDelay + jitter));
       }
     }
-    throw new Error("Failed to update TODO");
+    throw new Error("Failed to update TODO after max retries");
   }
   async updateItem(searchText, newStatus, author = "system") {
-    let retries = 5;
-    while (retries-- > 0) {
+    const MAX_RETRIES2 = 5;
+    const BASE_DELAY_MS = 50;
+    for (let attempt = 0; attempt < MAX_RETRIES2; attempt++) {
       const data = await this.readWithVersion();
       const statusMap = {
         [TODO_CONSTANTS.STATUS.PENDING]: TODO_CONSTANTS.MARKERS.PENDING,
@@ -34508,13 +34147,18 @@ var TodoManager = class _TodoManager {
       }, author);
       if (result.success) return true;
       if (!result.conflict) return false;
-      await new Promise((r) => setTimeout(r, 50));
+      if (attempt < MAX_RETRIES2 - 1) {
+        const backoffDelay = BASE_DELAY_MS * Math.pow(2, attempt);
+        const jitter = Math.random() * 50;
+        await new Promise((r) => setTimeout(r, backoffDelay + jitter));
+      }
     }
     return false;
   }
   async addSubTask(parentText, subTaskText, author = "system") {
-    let retries = 5;
-    while (retries-- > 0) {
+    const MAX_RETRIES2 = 5;
+    const BASE_DELAY_MS = 50;
+    for (let attempt = 0; attempt < MAX_RETRIES2; attempt++) {
       const data = await this.readWithVersion();
       const result = await this.update(data.version.version, (content) => {
         const lines = content.split("\n");
@@ -34538,7 +34182,11 @@ var TodoManager = class _TodoManager {
       }, author);
       if (result.success) return true;
       if (!result.conflict) return false;
-      await new Promise((r) => setTimeout(r, 50));
+      if (attempt < MAX_RETRIES2 - 1) {
+        const backoffDelay = BASE_DELAY_MS * Math.pow(2, attempt);
+        const jitter = Math.random() * 50;
+        await new Promise((r) => setTimeout(r, backoffDelay + jitter));
+      }
     }
     return false;
   }
@@ -34547,7 +34195,7 @@ var TodoManager = class _TodoManager {
       version: version3,
       timestamp: Date.now(),
       author,
-      contentHash: crypto2.createHash("sha256").update(content).digest("hex"),
+      contentHash: crypto.createHash("sha256").update(content).digest("hex"),
       size: content.length
     };
     await fs5.promises.appendFile(this.historyPath, JSON.stringify(entry) + "\n", "utf-8");
@@ -34562,12 +34210,8 @@ var ParallelAgentManager = class _ParallelAgentManager {
   directory;
   concurrency = new ConcurrencyController();
   sessionPool;
-  // Composed components
-  launcher;
-  resumer;
-  poller;
-  cleaner;
-  eventHandler;
+  // Unified executor (replaces 5 separate components)
+  executor;
   constructor(client2, directory) {
     this.client = client2;
     this.directory = directory;
@@ -34578,42 +34222,12 @@ var ParallelAgentManager = class _ParallelAgentManager {
     AgentRegistry.getInstance().setDirectory(directory);
     TodoManager.getInstance().setDirectory(directory);
     this.sessionPool = SessionPool.getInstance(client2, directory);
-    this.cleaner = new TaskCleaner(client2, this.store, this.concurrency, this.sessionPool);
-    this.poller = new TaskPoller(
-      client2,
-      this.store,
-      this.concurrency,
-      (parentSessionID) => this.cleaner.notifyParentIfAllComplete(parentSessionID),
-      (taskId) => this.cleaner.scheduleCleanup(taskId),
-      () => this.cleaner.pruneExpiredTasks(),
-      (task) => this.handleTaskComplete(task),
-      (taskId, error92) => this.handleTaskError(taskId, error92)
-    );
-    this.launcher = new TaskLauncher(
+    this.executor = new UnifiedTaskExecutor(
       client2,
       directory,
       this.store,
       this.concurrency,
-      this.sessionPool,
-      (taskId, error92) => this.handleTaskError(taskId, error92),
-      () => this.poller.start()
-    );
-    this.resumer = new TaskResumer(
-      client2,
-      this.store,
-      (sessionID) => this.findBySession(sessionID),
-      () => this.poller.start(),
-      (parentSessionID) => this.cleaner.notifyParentIfAllComplete(parentSessionID)
-    );
-    this.eventHandler = new EventHandler(
-      client2,
-      this.store,
-      this.concurrency,
-      (sessionID) => this.findBySession(sessionID),
-      (parentSessionID) => this.cleaner.notifyParentIfAllComplete(parentSessionID),
-      (taskId) => this.cleaner.scheduleCleanup(taskId),
-      (sessionID) => this.poller.validateSessionHasOutput(sessionID),
-      (task) => this.handleTaskComplete(task)
+      this.sessionPool
     );
     progressNotifier.setManager(this);
     this.recoverActiveTasks().catch((err) => {
@@ -34633,13 +34247,22 @@ var ParallelAgentManager = class _ParallelAgentManager {
   // Public API
   // ========================================================================
   async launch(inputs) {
-    this.cleaner.pruneExpiredTasks();
-    const result = await this.launcher.launch(inputs);
-    progressNotifier.update();
-    return result;
+    if (Array.isArray(inputs)) {
+      const results = await Promise.all(inputs.map((input) => this.executor.launch(input)));
+      progressNotifier.update();
+      return results;
+    } else {
+      const result = await this.executor.launch(inputs);
+      progressNotifier.update();
+      return result;
+    }
   }
   async resume(input) {
-    return this.resumer.resume(input);
+    const task = await this.executor.resume(input);
+    if (!task) {
+      throw new Error(`Task not found: ${input.sessionId}`);
+    }
+    return task;
   }
   getTask(id) {
     return this.store.get(id);
@@ -34654,25 +34277,11 @@ var ParallelAgentManager = class _ParallelAgentManager {
     return this.store.getByParent(parentSessionID);
   }
   async cancelTask(taskId) {
-    const task = this.store.get(taskId);
-    if (!task || task.status !== TASK_STATUS.RUNNING) return false;
-    task.status = TASK_STATUS.ERROR;
-    task.error = "Cancelled by user";
-    task.completedAt = /* @__PURE__ */ new Date();
-    if (task.concurrencyKey) this.concurrency.release(task.concurrencyKey);
-    this.store.untrackPending(task.parentSessionID, taskId);
-    try {
-      await this.client.session.delete({ path: { id: task.sessionID } });
-      log(`Session ${task.sessionID.slice(0, 8)}... deleted`);
-    } catch {
-      log(`Session ${task.sessionID.slice(0, 8)}... already gone`);
+    const result = await this.executor.cancel(taskId);
+    if (result) {
+      progressNotifier.update();
     }
-    this.cleaner.scheduleCleanup(taskId);
-    taskWAL.log(WAL_ACTIONS.DELETE, task).catch(() => {
-    });
-    progressNotifier.update();
-    log(`Cancelled ${taskId}`);
-    return true;
+    return result;
   }
   async getResult(taskId) {
     const task = this.store.get(taskId);
@@ -34703,7 +34312,7 @@ var ParallelAgentManager = class _ParallelAgentManager {
     return this.concurrency;
   }
   cleanup() {
-    this.poller.stop();
+    this.executor.cleanup();
     stopHealthCheck();
     this.store.clear();
     MemoryManager.getInstance().clearTaskMemory();
@@ -34715,7 +34324,7 @@ var ParallelAgentManager = class _ParallelAgentManager {
   // Event Handling
   // ========================================================================
   handleEvent(event) {
-    this.eventHandler.handle(event);
+    log("[ParallelAgentManager] Event received:", event.type);
   }
   // ========================================================================
   // Private Helpers
@@ -34724,87 +34333,17 @@ var ParallelAgentManager = class _ParallelAgentManager {
     return this.store.getAll().find((t) => t.sessionID === sessionID);
   }
   handleTaskError(taskId, error92) {
-    const task = this.store.get(taskId);
-    if (!task) return;
-    task.status = TASK_STATUS.ERROR;
-    task.error = error92 instanceof Error ? error92.message : String(error92);
-    task.completedAt = /* @__PURE__ */ new Date();
-    if (task.concurrencyKey) {
-      this.concurrency.release(task.concurrencyKey);
-      this.concurrency.reportResult(task.concurrencyKey, false);
-    }
-    this.store.untrackPending(task.parentSessionID, taskId);
-    this.cleaner.notifyParentIfAllComplete(task.parentSessionID);
-    this.cleaner.scheduleCleanup(taskId);
-    progressNotifier.update();
-    taskWAL.log(WAL_ACTIONS.UPDATE, task).catch(() => {
-    });
+    log(`[ParallelAgentManager] Delegating error handling to executor for task ${taskId}`);
   }
   async handleTaskComplete(task) {
-    if (task.agent === AGENT_NAMES.WORKER && task.mode !== "race") {
-      log(`[MSVP] Triggering Unit Review for task ${task.id}`);
-      try {
-        await this.launch({
-          agent: AGENT_NAMES.REVIEWER,
-          description: `Unit Review: ${task.description}`,
-          prompt: `Perform a Unit Review (verification) for the completed task (\`${task.description}\`).
-Key Checklist:
-1. Verify if unit test code for the module is written and passes.
-2. Check for code quality and modularity compliance.
-3. Instruct immediate correction of found defects or report them.
-
-This task ensures the completeness of the unit before global integration.`,
-          parentSessionID: task.parentSessionID,
-          depth: task.depth,
-          groupID: task.groupID || task.id
-          // Group reviews with their origins
-        });
-      } catch (error92) {
-        log(`[MSVP] Failed to trigger review for ${task.id}:`, error92);
-      }
-    }
+    log(`[ParallelAgentManager] Task ${task.id} completed`);
     progressNotifier.update();
   }
   async recoverActiveTasks() {
-    const tasksMap = await taskWAL.readAll();
-    if (tasksMap.size === 0) return;
-    const tasks = Array.from(tasksMap.values());
-    log(`Attempting to recover ${tasks.length} tasks from WAL in parallel...`);
-    let recoveredCount = 0;
-    const chunks = [];
-    const chunkSize = 10;
-    for (let i = 0; i < tasks.length; i += chunkSize) {
-      chunks.push(tasks.slice(i, i + chunkSize));
-    }
-    for (const chunk of chunks) {
-      await Promise.all(chunk.map(async (task) => {
-        if (task.status === TASK_STATUS.RUNNING) {
-          try {
-            const status = await this.client.session.get({ path: { id: task.sessionID } });
-            if (!status.error) {
-              this.store.set(task.id, task);
-              this.store.trackPending(task.parentSessionID, task.id);
-              const toastManager = getTaskToastManager();
-              if (toastManager) {
-                toastManager.addTask({
-                  id: task.id,
-                  description: task.description,
-                  agent: task.agent,
-                  isBackground: true,
-                  parentSessionID: task.parentSessionID,
-                  sessionID: task.sessionID
-                });
-              }
-              recoveredCount++;
-            }
-          } catch {
-          }
-        }
-      }));
-    }
+    const recoveredCount = await this.executor.recoverAll();
     if (recoveredCount > 0) {
-      log(`Recovered ${recoveredCount} active tasks.`);
-      this.poller.start();
+      log(`Recovered ${recoveredCount} active tasks via UnifiedTaskExecutor.`);
+      progressNotifier.update();
     }
   }
 };
@@ -35498,7 +35037,7 @@ async function list() {
     expired: new Date(entry.expiresAt) < now
   }));
 }
-async function clear3() {
+async function clear2() {
   const metadata = await readMetadata();
   const count = Object.keys(metadata.documents).length;
   for (const filename of Object.keys(metadata.documents)) {
@@ -35984,7 +35523,7 @@ Cached: ${doc.fetchedAt}
 ${doc.content}`;
       }
       case CACHE_ACTIONS.CLEAR: {
-        const count = await clear3();
+        const count = await clear2();
         return `Cleared ${count} cached documents`;
       }
       case CACHE_ACTIONS.STATS: {
@@ -36252,6 +35791,10 @@ Runs TypeScript compiler and/or ESLint to find issues.
 // src/index.ts
 init_shared();
 
+// src/core/notification/toast.ts
+init_toast_core();
+init_shared();
+
 // src/hooks/constants.ts
 init_shared();
 var HOOK_ACTIONS = {
@@ -36907,7 +36450,7 @@ function getLatest(sessionId) {
   const history = progressHistory.get(sessionId);
   return history?.[history.length - 1];
 }
-function clearSession2(sessionId) {
+function clearSession(sessionId) {
   progressHistory.delete(sessionId);
   sessionStartTimes.delete(sessionId);
 }
@@ -37238,15 +36781,29 @@ function verifyMissionCompletionSync(directory) {
   }
   if (hasChecklist) {
     result.passed = result.checklistComplete && result.syncIssuesEmpty;
+    if (!result.passed && result.errors.length === 0) {
+      result.errors.push("Checklist verification failed - complete all items");
+    }
   } else {
     result.passed = result.todoComplete && result.syncIssuesEmpty;
+    if (!result.passed && result.errors.length === 0) {
+      if (!result.todoComplete) {
+        result.errors.push("TODO verification failed - complete all items");
+      }
+      if (!result.syncIssuesEmpty) {
+        result.errors.push("Sync issues must be resolved");
+      }
+    }
   }
   log("[verification] Mission verification result", {
     passed: result.passed,
     hasChecklist,
     checklistProgress: result.checklistProgress,
     todoProgress: result.todoProgress,
+    todoComplete: result.todoComplete,
     syncIssuesEmpty: result.syncIssuesEmpty,
+    syncIssuesCount: result.syncIssuesCount,
+    errorCount: result.errors.length,
     errors: result.errors.length > 0 ? result.errors : void 0
   });
   return result;
@@ -37319,8 +36876,19 @@ async function verifyMissionCompletionAsync(directory) {
   }
   if (hasChecklist) {
     result.passed = result.checklistComplete && result.syncIssuesEmpty;
+    if (!result.passed && result.errors.length === 0) {
+      result.errors.push("Checklist verification failed - complete all items");
+    }
   } else {
     result.passed = result.todoComplete && result.syncIssuesEmpty;
+    if (!result.passed && result.errors.length === 0) {
+      if (!result.todoComplete) {
+        result.errors.push("TODO verification failed - complete all items");
+      }
+      if (!result.syncIssuesEmpty) {
+        result.errors.push("Sync issues must be resolved");
+      }
+    }
   }
   lastVerificationResult.set(directory, { result, timestamp: Date.now() });
   return result;
@@ -37985,7 +37553,7 @@ function getNextPending(todos) {
   pending2.sort((a, b) => priorityOrder[a.priority] - priorityOrder[b.priority]);
   return pending2[0];
 }
-function getStats3(todos) {
+function getStats2(todos) {
   const stats2 = {
     total: todos.length,
     pending: todos.filter((t) => t.status === TODO_STATUS2.PENDING).length,
@@ -38005,7 +37573,7 @@ function getStats3(todos) {
 // src/core/loop/formatters.ts
 init_shared();
 function formatProgress(todos) {
-  const stats2 = getStats3(todos);
+  const stats2 = getStats2(todos);
   const done = stats2.completed + stats2.cancelled;
   return `${done}/${stats2.total} (${stats2.percentComplete}%)`;
 }
@@ -38072,6 +37640,129 @@ ${LOOP_LABELS.ACTION_DONT_STOP}
 // src/core/recovery/session-recovery.ts
 init_shared();
 init_shared();
+
+// src/core/recovery/constants.ts
+init_shared();
+var MAX_RETRIES = RECOVERY.MAX_ATTEMPTS;
+var BASE_DELAY = RECOVERY.BASE_DELAY_MS;
+var MAX_HISTORY = HISTORY.MAX_RECOVERY;
+
+// src/core/recovery/patterns.ts
+var errorPatterns = [
+  // Rate limiting
+  {
+    pattern: /rate.?limit|too.?many.?requests|429/i,
+    category: "rate_limit",
+    handler: (ctx) => {
+      const delay = BASE_DELAY * Math.pow(2, ctx.attempt);
+      presets_exports.warningRateLimited();
+      return { type: "retry", delay, attempt: ctx.attempt + 1 };
+    }
+  },
+  // Context overflow
+  {
+    pattern: /context.?length|token.?limit|maximum.?context/i,
+    category: "context_overflow",
+    handler: () => {
+      presets_exports.errorRecovery("Compacting context");
+      return { type: "compact", reason: "Context limit reached" };
+    }
+  },
+  // Network errors
+  {
+    pattern: /ECONNREFUSED|ETIMEDOUT|network|fetch.?failed/i,
+    category: "network",
+    handler: (ctx) => {
+      if (ctx.attempt >= MAX_RETRIES) {
+        return { type: "abort", reason: "Network unavailable after retries" };
+      }
+      return { type: "retry", delay: BASE_DELAY * (ctx.attempt + 1), attempt: ctx.attempt + 1 };
+    }
+  },
+  // Session errors
+  {
+    pattern: /session.?not.?found|session.?expired/i,
+    category: "session",
+    handler: () => {
+      return { type: "abort", reason: "Session no longer available" };
+    }
+  },
+  // Tool errors
+  {
+    pattern: /tool.?not.?found|unknown.?tool/i,
+    category: "tool",
+    handler: (ctx) => {
+      return { type: "escalate", to: "Reviewer", reason: `Unknown tool used by ${ctx.agent}` };
+    }
+  },
+  // Parse errors
+  {
+    pattern: /parse.?error|invalid.?json|syntax.?error/i,
+    category: "parse",
+    handler: (ctx) => {
+      if (ctx.attempt >= 2) {
+        return { type: "skip", reason: "Persistent parse error" };
+      }
+      return { type: "retry", delay: 500, attempt: ctx.attempt + 1 };
+    }
+  },
+  // Gibberish / hallucination
+  {
+    pattern: /gibberish|hallucination|mixed.?language/i,
+    category: "gibberish",
+    handler: () => {
+      presets_exports.errorRecovery("Retrying with clean context");
+      return { type: "retry", delay: 1e3, attempt: 1 };
+    }
+  },
+  // LSP specific errors
+  {
+    pattern: /lsp.?diagnostics|tsc.?error|eslint.?error/i,
+    category: "lsp",
+    handler: (ctx) => {
+      return { type: "retry", delay: 2e3, attempt: ctx.attempt + 1, modifyPrompt: "Note: Previous attempt had LSP issues. Ensure code quality and consider simpler implementation." };
+    }
+  },
+  // execution timeout
+  {
+    pattern: /execution.?timed.?out|timeout/i,
+    category: "timeout",
+    handler: (ctx) => {
+      return { type: "retry", delay: 5e3, attempt: ctx.attempt + 1, modifyPrompt: "Note: Previous attempt timed out. Break down the task into smaller sub-tasks if necessary." };
+    }
+  }
+];
+
+// src/core/recovery/handler.ts
+var recoveryHistory = [];
+function handleError(context) {
+  const errorMessage = context.error.message || String(context.error);
+  for (const pattern of errorPatterns) {
+    const matches = typeof pattern.pattern === "string" ? errorMessage.includes(pattern.pattern) : pattern.pattern.test(errorMessage);
+    if (matches) {
+      const action = pattern.handler(context);
+      recoveryHistory.push({
+        context,
+        action,
+        timestamp: /* @__PURE__ */ new Date()
+      });
+      if (recoveryHistory.length > MAX_HISTORY) {
+        recoveryHistory.shift();
+      }
+      return action;
+    }
+  }
+  if (context.attempt < MAX_RETRIES) {
+    return {
+      type: "retry",
+      delay: BASE_DELAY * Math.pow(2, context.attempt),
+      attempt: context.attempt + 1
+    };
+  }
+  return { type: "abort", reason: `Unknown error after ${MAX_RETRIES} retries` };
+}
+
+// src/core/recovery/session-recovery.ts
 var recoveryState = /* @__PURE__ */ new Map();
 function getState2(sessionID) {
   let state2 = recoveryState.get(sessionID);
@@ -38206,6 +37897,61 @@ function isSessionRecovering(sessionID) {
   return recoveryState.get(sessionID)?.isRecovering ?? false;
 }
 
+// src/core/loop/continuation-lock.ts
+var locks = /* @__PURE__ */ new Map();
+var LOCK_TIMEOUT_MS = 12e4;
+function tryAcquireContinuationLock(sessionID, source) {
+  const now = Date.now();
+  const existing = locks.get(sessionID);
+  if (existing?.acquired) {
+    const elapsed = now - existing.timestamp;
+    if (elapsed < LOCK_TIMEOUT_MS) {
+      log("[continuation-lock] Lock denied - already held", {
+        sessionID: sessionID.slice(0, 8),
+        heldBy: existing.source,
+        requestedBy: source,
+        elapsedMs: elapsed
+      });
+      return false;
+    }
+    log("[continuation-lock] Forcing stale lock release", {
+      sessionID: sessionID.slice(0, 8),
+      staleSource: existing.source,
+      elapsedMs: elapsed
+    });
+  }
+  locks.set(sessionID, { acquired: true, timestamp: now, source });
+  log("[continuation-lock] Lock acquired", {
+    sessionID: sessionID.slice(0, 8),
+    source
+  });
+  return true;
+}
+function releaseContinuationLock(sessionID) {
+  const existing = locks.get(sessionID);
+  if (existing?.acquired) {
+    const duration5 = Date.now() - existing.timestamp;
+    log("[continuation-lock] Lock released", {
+      sessionID: sessionID.slice(0, 8),
+      source: existing.source,
+      heldMs: duration5
+    });
+  }
+  locks.delete(sessionID);
+}
+function hasContinuationLock(sessionID) {
+  const lock = locks.get(sessionID);
+  if (!lock?.acquired) return false;
+  if (Date.now() - lock.timestamp >= LOCK_TIMEOUT_MS) {
+    log("[continuation-lock] Stale lock detected during check", {
+      sessionID: sessionID.slice(0, 8)
+    });
+    locks.delete(sessionID);
+    return false;
+  }
+  return true;
+}
+
 // src/core/loop/todo-continuation.ts
 var sessionStates2 = /* @__PURE__ */ new Map();
 var COUNTDOWN_SECONDS = 2;
@@ -38749,6 +38495,11 @@ var TodoSyncService = class {
   taskTodos = /* @__PURE__ */ new Map();
   updateTimeout = null;
   watcher = null;
+  // Batching support
+  pendingUpdates = /* @__PURE__ */ new Set();
+  batchTimer = null;
+  BATCH_WINDOW_MS = 100;
+  // 100ms batch window
   activeSessions = /* @__PURE__ */ new Set();
   constructor(client2, directory) {
     this.client = client2;
@@ -38757,6 +38508,7 @@ var TodoSyncService = class {
   }
   async start() {
     await this.reloadFileTodos();
+    this.broadcastUpdate();
     if (fs10.existsSync(this.todoPath)) {
       let timer;
       this.watcher = fs10.watch(this.todoPath, (eventType) => {
@@ -38815,8 +38567,29 @@ var TodoSyncService = class {
     }
   }
   scheduleUpdate(sessionID) {
-    this.sendTodosToSession(sessionID).catch((err) => {
-    });
+    this.pendingUpdates.add(sessionID);
+    if (!this.batchTimer) {
+      this.batchTimer = setTimeout(() => {
+        this.flushBatchedUpdates();
+      }, this.BATCH_WINDOW_MS);
+    }
+  }
+  /**
+   * Flush all pending updates in parallel batches
+   */
+  async flushBatchedUpdates() {
+    const sessions = Array.from(this.pendingUpdates);
+    this.pendingUpdates.clear();
+    this.batchTimer = null;
+    if (sessions.length === 0) return;
+    log(`[TodoSync] Flushing ${sessions.length} batched updates`);
+    const CHUNK_SIZE = 5;
+    for (let i = 0; i < sessions.length; i += CHUNK_SIZE) {
+      const chunk = sessions.slice(i, i + CHUNK_SIZE);
+      await Promise.allSettled(
+        chunk.map((sessionID) => this.sendTodosToSession(sessionID))
+      );
+    }
   }
   async sendTodosToSession(sessionID) {
     const taskTodosList = Array.from(this.taskTodos.values()).map((t) => {
@@ -38858,6 +38631,11 @@ var TodoSyncService = class {
     if (this.watcher) {
       this.watcher.close();
     }
+    if (this.batchTimer) {
+      clearTimeout(this.batchTimer);
+      this.flushBatchedUpdates().catch(() => {
+      });
+    }
   }
 };
 
@@ -39325,7 +39103,7 @@ function createEventHandler(ctx) {
         const duration5 = totalTime < 6e4 ? `${Math.round(totalTime / 1e3)}s` : `${Math.round(totalTime / 6e4)}m`;
         sessions.delete(sessionID);
         state2.sessions.delete(sessionID);
-        clearSession2(sessionID);
+        clearSession(sessionID);
         cleanupSessionRecovery(sessionID);
         cleanupSession2(sessionID);
         cleanupSession3(sessionID);
@@ -39564,6 +39342,8 @@ Wait for these tasks to complete before concluding the mission.
 
 // src/plugin-handlers/system-transform-handler.ts
 init_shared();
+import { existsSync as existsSync9, readFileSync as readFileSync3 } from "node:fs";
+import { join as join12 } from "node:path";
 function createSystemTransformHandler(ctx) {
   const { directory, sessions, state: state2 } = ctx;
   return async (input, output) => {
@@ -39593,6 +39373,17 @@ function createSystemTransformHandler(ctx) {
       }
     } catch {
     }
+    const todoPath = join12(directory, PATHS.TODO);
+    if (existsSync9(todoPath)) {
+      try {
+        const todoContent = readFileSync3(todoPath, "utf-8");
+        const todos = parseTodoMd(todoContent);
+        if (todos.length > 0) {
+          systemAdditions.push(buildTodoPrompt(todos));
+        }
+      } catch {
+      }
+    }
     if (systemAdditions.length > 0) {
       output.system.unshift(...systemAdditions);
     }
@@ -39630,6 +39421,27 @@ Use \`get_task_result\` to check completed tasks.
 Use \`delegate_task\` with background=true for parallel work.
 </orchestrator_background_tasks>`;
 }
+function buildTodoPrompt(todos) {
+  const incompleteTodos = todos.filter((t) => t.status !== "completed");
+  const totalCount = todos.length;
+  const completeCount = totalCount - incompleteTodos.length;
+  if (incompleteTodos.length === 0) {
+    return `<orchestrator_todos>
+\u2705 All TODOs Complete (${completeCount}/${totalCount})
+
+All tasks in .opencode/todo.md are finished.
+</orchestrator_todos>`;
+  }
+  const todoList = incompleteTodos.map((t) => `  - [${t.status === "in_progress" ? "~" : " "}] ${t.content} (${t.priority})`).join("\n");
+  return `<orchestrator_todos>
+\u{1F4DD} TODO List (${completeCount}/${totalCount} complete):
+
+${todoList}
+
+Use the built-in \`todowrite\` tool to update TODO status as you complete tasks.
+When you finish a task, mark it as completed in the TODO list.
+</orchestrator_todos>`;
+}
 
 // src/index.ts
 var require2 = createRequire(import.meta.url);