opencode-orchestrator 1.0.26 → 1.0.27

package/dist/index.js

@@ -15592,141 +15592,6 @@ Never claim completion without proof.
   }
 });
 
-// src/tools/slashCommand.ts
-var COMMANDER_SYSTEM_PROMPT = commander.systemPrompt;
-var MISSION_MODE_TEMPLATE = `${COMMANDER_SYSTEM_PROMPT}
-
-<mission>
-<task>
-$ARGUMENTS
-</task>
-
-<execution_rules>
-1. Complete this mission without user intervention
-2. Use your full capabilities: research, implement, verify
-3. Output "${MISSION_SEAL.PATTERN}" when done
-</execution_rules>
-</mission>`;
-var COMMANDS = {
-  "task": {
-    description: "MISSION MODE - Execute task autonomously until complete",
-    template: MISSION_MODE_TEMPLATE,
-    argumentHint: '"mission goal"'
-  },
-  "plan": {
-    description: "Create a task plan without executing",
-    template: `<delegate>
-<agent>${AGENT_NAMES.PLANNER}</agent>
-<objective>Create parallel task plan for: $ARGUMENTS</objective>
-<success>Valid .opencode/todo.md with tasks, each having id, description, agent, size, dependencies</success>
-<must_do>
-- Maximize parallelism by grouping independent tasks
-- Assign correct agent to each task (${AGENT_NAMES.WORKER} or ${AGENT_NAMES.REVIEWER})
-- Include clear success criteria for each task
-- Research before planning if unfamiliar technology
-</must_do>
-<must_not>
-- Do not implement any tasks, only plan
-- Do not create tasks that depend on each other unnecessarily
-</must_not>
-<context>
-- This is planning only, no execution
-- Output to .opencode/todo.md
-</context>
-</delegate>`,
-    argumentHint: '"complex task to plan"'
-  },
-  "agents": {
-    description: "Show the 4-agent architecture",
-    template: `## OpenCode Orchestrator - 4-Agent Architecture
-
-| Agent | Role | Capabilities |
-|-------|------|--------------|
-| **${AGENT_NAMES.COMMANDER}** | [MASTER] | Master Orchestrator: mission control, parallel coordination |
-| **${AGENT_NAMES.PLANNER}** | [STRATEGIST] | Planning, research, documentation analysis |
-| **${AGENT_NAMES.WORKER}** | [EXECUTOR] | Implementation, coding, terminal tasks |
-| **${AGENT_NAMES.REVIEWER}** | [VERIFIER] | Verification, testing, context sanity checks |
-
-## Parallel Execution System
-\`\`\`
-Up to 50 Worker Sessions running simultaneously
-Max 10 per agent type (auto-queues excess)
-Auto-timeout: 60 min | Auto-cleanup: 30 min
-\`\`\`
-
-## Execution Flow
-\`\`\`
-THINK \u2192 PLAN \u2192 DELEGATE \u2192 EXECUTE \u2192 VERIFY \u2192 COMPLETE
-   L1: Fast Track (simple fixes)
-   L2: Normal Track (features)
-   L3: Deep Track (complex refactoring)
-\`\`\`
-
-## Anti-Hallucination
-- ${AGENT_NAMES.PLANNER} researches BEFORE implementation
-- ${AGENT_NAMES.WORKER} caches official documentation
-- Never assumes - always verifies from sources
-
-## Usage
-- Select **${AGENT_NAMES.COMMANDER}** and type your request
-- Or use \`/task "your mission"\` explicitly
-- ${AGENT_NAMES.COMMANDER} automatically coordinates all agents`
-  }
-};
-function createSlashcommandTool() {
-  const commandList = Object.entries(COMMANDS).map(([name, cmd]) => {
-    const hint = cmd.argumentHint ? ` ${cmd.argumentHint}` : "";
-    return `- /${name}${hint}: ${cmd.description}`;
-  }).join("\n");
-  return tool({
-    description: `Available commands:
-${commandList}`,
-    args: {
-      command: tool.schema.string().describe("Command name (without slash)")
-    },
-    async execute(args) {
-      const cmdName = (args.command || "").replace(/^\//, "").split(/\s+/)[0].toLowerCase();
-      const cmdArgs = (args.command || "").replace(/^\/?\\S+\s*/, "");
-      if (!cmdName) return `Commands:
-${commandList}`;
-      const command = COMMANDS[cmdName];
-      if (!command) return `Unknown command: /${cmdName}
-
-${commandList}`;
-      return command.template.replace(/\$ARGUMENTS/g, cmdArgs || PROMPTS.CONTINUE_DEFAULT);
-    }
-  });
-}
-
-// src/tools/rust.ts
-import { spawn } from "child_process";
-import { existsSync as existsSync2 } from "fs";
-
-// src/utils/binary.ts
-import { join, dirname } from "path";
-import { fileURLToPath } from "url";
-import { platform, arch } from "os";
-import { existsSync } from "fs";
-var __dirname = dirname(fileURLToPath(import.meta.url));
-function getBinaryPath() {
-  const binDir = join(__dirname, "..", "..", "bin");
-  const os2 = platform();
-  const cpu = arch();
-  let binaryName;
-  if (os2 === PLATFORM.WIN32) {
-    binaryName = "orchestrator-windows-x64.exe";
-  } else if (os2 === PLATFORM.DARWIN) {
-    binaryName = cpu === "arm64" ? "orchestrator-macos-arm64" : "orchestrator-macos-x64";
-  } else {
-    binaryName = cpu === "arm64" ? "orchestrator-linux-arm64" : "orchestrator-linux-x64";
-  }
-  let binaryPath = join(binDir, binaryName);
-  if (!existsSync(binaryPath)) {
-    binaryPath = join(binDir, os2 === PLATFORM.WIN32 ? "orchestrator.exe" : "orchestrator");
-  }
-  return binaryPath;
-}
-
 // src/core/agents/logger.ts
 import * as fs from "fs";
 import * as os from "os";
@@ -15747,1614 +15612,1340 @@ function getLogPath() {
   return LOG_FILE;
 }
 
-// src/tools/rust.ts
-async function callRustTool(name, args) {
-  const binary = getBinaryPath();
-  if (!existsSync2(binary)) {
-    return JSON.stringify({ error: `Binary not found: ${binary}` });
+// src/core/agents/concurrency.ts
+var DEBUG2 = process.env.DEBUG_PARALLEL_AGENT === "true";
+var log2 = (...args) => {
+  if (DEBUG2) log("[concurrency]", ...args);
+};
+var ConcurrencyController = class {
+  counts = /* @__PURE__ */ new Map();
+  queues = /* @__PURE__ */ new Map();
+  limits = /* @__PURE__ */ new Map();
+  config;
+  successStreak = /* @__PURE__ */ new Map();
+  failureCount = /* @__PURE__ */ new Map();
+  constructor(config2) {
+    this.config = config2 ?? {};
   }
-  return new Promise((resolve2) => {
-    const proc = spawn(binary, ["serve"], { stdio: ["pipe", "pipe", "pipe"] });
-    let stdout = "";
-    proc.stdout.on("data", (data) => {
-      stdout += data.toString();
-    });
-    proc.stderr.on("data", (data) => {
-      const msg = data.toString().trim();
-      if (msg) log(`[rust-stderr] ${msg}`);
-    });
-    const request = JSON.stringify({
-      jsonrpc: "2.0",
-      id: Date.now(),
-      method: "tools/call",
-      params: { name, arguments: args }
-    });
-    proc.stdin.write(request + "\n");
-    proc.stdin.end();
-    const timeout = setTimeout(() => {
-      proc.kill();
-      resolve2(JSON.stringify({ error: "Timeout" }));
-    }, 6e4);
-    proc.on("close", (code) => {
-      clearTimeout(timeout);
-      if (code !== 0 && code !== null) {
-        log(`Rust process exited with code ${code}`);
-      }
-      try {
-        const lines = stdout.trim().split("\n");
-        for (let i = lines.length - 1; i >= 0; i--) {
-          try {
-            const response = JSON.parse(lines[i]);
-            if (response.result || response.error) {
-              const text = response?.result?.content?.[0]?.text;
-              return resolve2(text || JSON.stringify(response.result));
-            }
-          } catch {
-            continue;
-          }
-        }
-        resolve2(stdout || "No output");
-      } catch {
-        resolve2(stdout || "No output");
-      }
-    });
-  });
-}
-
-// src/tools/search.ts
-var grepSearchTool = (directory) => tool({
-  description: "Search code patterns using regex. Returns matching lines with file paths and line numbers.",
-  args: {
-    pattern: tool.schema.string().describe("Regex pattern to search for"),
-    dir: tool.schema.string().optional().describe("Directory to search (defaults to project root)"),
-    max_results: tool.schema.number().optional().describe("Max results (default: 100)"),
-    timeout_ms: tool.schema.number().optional().describe("Timeout in milliseconds (default: 30000)")
-  },
-  async execute(args) {
-    return callRustTool("grep_search", {
-      pattern: args.pattern,
-      directory: args.dir || directory,
-      max_results: args.max_results,
-      timeout_ms: args.timeout_ms
-    });
+  setLimit(key, limit) {
+    this.limits.set(key, limit);
   }
-});
-var globSearchTool = (directory) => tool({
-  description: "Find files matching a glob pattern. Returns list of file paths.",
-  args: {
-    pattern: tool.schema.string().describe("Glob pattern (e.g., '**/*.ts', 'src/**/*.md')"),
-    dir: tool.schema.string().optional().describe("Directory to search (defaults to project root)")
-  },
-  async execute(args) {
-    return callRustTool("glob_search", {
-      pattern: args.pattern,
-      directory: args.dir || directory
-    });
+  /**
+   * Get concurrency limit for a key.
+   * Priority: explicit limit > model > provider > agent > default
+   */
+  getConcurrencyLimit(key) {
+    const explicitLimit = this.limits.get(key);
+    if (explicitLimit !== void 0) {
+      return explicitLimit === 0 ? Infinity : explicitLimit;
+    }
+    if (this.config.modelConcurrency?.[key] !== void 0) {
+      const limit = this.config.modelConcurrency[key];
+      return limit === 0 ? Infinity : limit;
+    }
+    const provider = key.split("/")[0];
+    if (this.config.providerConcurrency?.[provider] !== void 0) {
+      const limit = this.config.providerConcurrency[provider];
+      return limit === 0 ? Infinity : limit;
+    }
+    if (this.config.agentConcurrency?.[key] !== void 0) {
+      const limit = this.config.agentConcurrency[key];
+      return limit === 0 ? Infinity : limit;
+    }
+    return this.config.defaultConcurrency ?? PARALLEL_TASK.DEFAULT_CONCURRENCY;
   }
-});
-var mgrepTool = (directory) => tool({
-  description: `Search multiple patterns (runs grep for each pattern).`,
-  args: {
-    patterns: tool.schema.array(tool.schema.string()).describe("Array of regex patterns"),
-    dir: tool.schema.string().optional().describe("Directory (defaults to project root)"),
-    max_results_per_pattern: tool.schema.number().optional().describe("Max results per pattern (default: 50)"),
-    timeout_ms: tool.schema.number().optional().describe("Timeout in milliseconds (default: 60000)")
-  },
-  async execute(args) {
-    return callRustTool("mgrep", {
-      patterns: args.patterns,
-      directory: args.dir || directory,
-      max_results_per_pattern: args.max_results_per_pattern,
-      timeout_ms: args.timeout_ms
-    });
+  // Backwards compatible alias
+  getLimit(key) {
+    return this.getConcurrencyLimit(key);
   }
-});
-var sedReplaceTool = (directory) => tool({
-  description: `Find and replace patterns in files (sed-like). Supports regex. Use dry_run=true to preview changes.`,
-  args: {
-    pattern: tool.schema.string().describe("Regex pattern to find"),
-    replacement: tool.schema.string().describe("Replacement string"),
-    file: tool.schema.string().optional().describe("Single file to modify"),
-    dir: tool.schema.string().optional().describe("Directory to search (modifies all matching files)"),
-    dry_run: tool.schema.boolean().optional().describe("Preview changes without modifying files (default: false)"),
-    backup: tool.schema.boolean().optional().describe("Create .bak backup before modifying (default: false)"),
-    timeout_ms: tool.schema.number().optional().describe("Timeout in milliseconds")
-  },
-  async execute(args) {
-    return callRustTool("sed_replace", {
-      pattern: args.pattern,
-      replacement: args.replacement,
-      file: args.file,
-      directory: args.dir || (args.file ? void 0 : directory),
-      dry_run: args.dry_run,
-      backup: args.backup,
-      timeout_ms: args.timeout_ms
+  async acquire(key) {
+    const limit = this.getConcurrencyLimit(key);
+    if (limit === Infinity) return;
+    const current = this.counts.get(key) ?? 0;
+    if (current < limit) {
+      this.counts.set(key, current + 1);
+      log2(`Acquired ${key}: ${current + 1}/${limit}`);
+      return;
+    }
+    log2(`Queueing ${key}: ${current}/${limit}`);
+    return new Promise((resolve2) => {
+      const queue = this.queues.get(key) ?? [];
+      queue.push(resolve2);
+      this.queues.set(key, queue);
     });
   }
-});
-var diffTool = () => tool({
-  description: `Compare two files or strings and show differences.`,
-  args: {
-    file1: tool.schema.string().optional().describe("First file to compare"),
-    file2: tool.schema.string().optional().describe("Second file to compare"),
-    content1: tool.schema.string().optional().describe("First string to compare"),
-    content2: tool.schema.string().optional().describe("Second string to compare"),
-    ignore_whitespace: tool.schema.boolean().optional().describe("Ignore whitespace differences")
-  },
-  async execute(args) {
-    return callRustTool("diff", args);
-  }
-});
-var jqTool = () => tool({
-  description: `Query and manipulate JSON using jq expressions.`,
-  args: {
-    json_input: tool.schema.string().optional().describe("JSON string to query"),
-    file: tool.schema.string().optional().describe("JSON file to query"),
-    expression: tool.schema.string().describe("jq expression (e.g., '.foo.bar', '.[] | select(.x > 1)')"),
-    raw_output: tool.schema.boolean().optional().describe("Raw output (no JSON encoding for strings)")
-  },
-  async execute(args) {
-    return callRustTool("jq", args);
+  release(key) {
+    const limit = this.getConcurrencyLimit(key);
+    if (limit === Infinity) return;
+    const queue = this.queues.get(key);
+    if (queue && queue.length > 0) {
+      const next = queue.shift();
+      log2(`Released ${key}: next in queue`);
+      next();
+    } else {
+      const current = this.counts.get(key) ?? 0;
+      if (current > 0) {
+        this.counts.set(key, current - 1);
+        log2(`Released ${key}: ${current - 1}/${limit}`);
+      }
+    }
   }
-});
-var httpTool = () => tool({
-  description: `Make HTTP requests (GET, POST, PUT, DELETE, etc).`,
-  args: {
-    url: tool.schema.string().describe("URL to request"),
-    method: tool.schema.string().optional().describe("HTTP method (GET, POST, PUT, DELETE, PATCH, HEAD)"),
-    headers: tool.schema.object({}).optional().describe("Request headers as JSON object"),
-    body: tool.schema.string().optional().describe("Request body"),
-    timeout_ms: tool.schema.number().optional().describe("Request timeout in milliseconds")
-  },
-  async execute(args) {
-    return callRustTool("http", args);
+  /**
+   * Report success/failure to adjust concurrency dynamically
+   */
+  reportResult(key, success2) {
+    if (success2) {
+      const streak = (this.successStreak.get(key) ?? 0) + 1;
+      this.successStreak.set(key, streak);
+      this.failureCount.set(key, 0);
+      if (streak % 5 === 0) {
+        const currentLimit = this.getConcurrencyLimit(key);
+        if (currentLimit < PARALLEL_TASK.MAX_CONCURRENCY) {
+          this.setLimit(key, currentLimit + 1);
+          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);
+          log(`[concurrency] Auto-scaling DOWN for ${key}: ${currentLimit - 1} (due to ${failures} failures)`);
+        }
+      }
+    }
   }
-});
-var fileStatsTool = (directory) => tool({
-  description: `Analyze file/directory statistics (file counts, sizes, line counts, etc).`,
-  args: {
-    dir: tool.schema.string().optional().describe("Directory to analyze (defaults to project root)"),
-    max_depth: tool.schema.number().optional().describe("Maximum directory depth to analyze")
-  },
-  async execute(args) {
-    return callRustTool("file_stats", {
-      directory: args.dir || directory,
-      max_depth: args.max_depth
-    });
+  getQueueLength(key) {
+    return this.queues.get(key)?.length ?? 0;
   }
-});
-var gitDiffTool = (directory) => tool({
-  description: `Show git diff of uncommitted changes.`,
-  args: {
-    dir: tool.schema.string().optional().describe("Repository directory (defaults to project root)"),
-    staged_only: tool.schema.boolean().optional().describe("Show only staged changes")
-  },
-  async execute(args) {
-    return callRustTool("git_diff", {
-      directory: args.dir || directory,
-      staged_only: args.staged_only
-    });
+  getActiveCount(key) {
+    return this.counts.get(key) ?? 0;
   }
-});
-var gitStatusTool = (directory) => tool({
-  description: `Show git status (modified, added, deleted files).`,
-  args: {
-    dir: tool.schema.string().optional().describe("Repository directory (defaults to project root)")
-  },
-  async execute(args) {
-    return callRustTool("git_status", {
-      directory: args.dir || directory
-    });
+  /**
+   * Get formatted concurrency info string (e.g., "2/5 slots")
+   */
+  getConcurrencyInfo(key) {
+    const active = this.getActiveCount(key);
+    const limit = this.getConcurrencyLimit(key);
+    if (limit === Infinity) return "";
+    return ` (${active}/${limit} slots)`;
   }
-});
-
-// src/core/commands/types/background-task-status.ts
-var BACKGROUND_TASK_STATUS = {
-  PENDING: STATUS_LABEL.PENDING,
-  RUNNING: STATUS_LABEL.RUNNING,
-  DONE: STATUS_LABEL.DONE,
-  ERROR: STATUS_LABEL.ERROR,
-  TIMEOUT: STATUS_LABEL.TIMEOUT
 };
 
-// src/core/commands/manager.ts
-import { spawn as spawn2 } from "node:child_process";
-import { randomBytes } from "node:crypto";
-var BackgroundTaskManager = class _BackgroundTaskManager {
-  static _instance;
+// src/core/agents/task-store.ts
+import * as fs2 from "node:fs/promises";
+import * as path2 from "node:path";
+var TaskStore = class {
   tasks = /* @__PURE__ */ new Map();
-  debugMode = process.env.DEBUG_BG_TASK === "true";
-  // Disabled by default
-  constructor() {
-  }
-  static get instance() {
-    if (!_BackgroundTaskManager._instance) {
-      _BackgroundTaskManager._instance = new _BackgroundTaskManager();
+  pendingByParent = /* @__PURE__ */ new Map();
+  notifications = /* @__PURE__ */ new Map();
+  archivedCount = 0;
+  set(id, task) {
+    this.tasks.set(id, task);
+    if (this.tasks.size > MEMORY_LIMITS.MAX_TASKS_IN_MEMORY) {
+      this.gc();
     }
-    return _BackgroundTaskManager._instance;
   }
-  generateId() {
-    return `${ID_PREFIX.JOB}${randomBytes(4).toString("hex")}`;
+  get(id) {
+    return this.tasks.get(id);
   }
-  debug(taskId, message) {
-    if (this.debugMode) {
-      const ts = (/* @__PURE__ */ new Date()).toISOString().substring(11, 23);
-      log(`[BG ${ts}] ${taskId}: ${message}`);
+  getAll() {
+    return Array.from(this.tasks.values());
+  }
+  getRunning() {
+    return this.getAll().filter((t) => t.status === TASK_STATUS.RUNNING || t.status === TASK_STATUS.PENDING);
+  }
+  getByParent(parentSessionID) {
+    return this.getAll().filter((t) => t.parentSessionID === parentSessionID);
+  }
+  delete(id) {
+    return this.tasks.delete(id);
+  }
+  clear() {
+    this.tasks.clear();
+    this.pendingByParent.clear();
+    this.notifications.clear();
+  }
+  // Pending tracking
+  trackPending(parentSessionID, taskId) {
+    const pending2 = this.pendingByParent.get(parentSessionID) ?? /* @__PURE__ */ new Set();
+    pending2.add(taskId);
+    this.pendingByParent.set(parentSessionID, pending2);
+  }
+  untrackPending(parentSessionID, taskId) {
+    const pending2 = this.pendingByParent.get(parentSessionID);
+    if (pending2) {
+      pending2.delete(taskId);
+      if (pending2.size === 0) {
+        this.pendingByParent.delete(parentSessionID);
+      }
     }
   }
-  run(options) {
-    const id = this.generateId();
-    const { command, cwd = process.cwd(), timeout = 3e5, label } = options;
-    const isWindows = process.platform === PLATFORM.WIN32;
-    const shell = isWindows ? "cmd.exe" : CLI_NAME.SH;
-    const shellFlag = isWindows ? "/c" : "-c";
-    const task = {
-      id,
-      command,
-      args: [shellFlag, command],
-      cwd,
-      label,
-      status: STATUS_LABEL.RUNNING,
-      output: "",
-      errorOutput: "",
-      exitCode: null,
-      startTime: Date.now(),
-      timeout
-    };
-    this.tasks.set(id, task);
-    this.debug(id, `Starting: ${command}`);
-    try {
-      const proc = spawn2(shell, task.args, {
-        cwd,
-        stdio: ["ignore", "pipe", "pipe"],
-        detached: false
-      });
-      task.process = proc;
-      proc.stdout?.on("data", (data) => {
-        task.output += data.toString();
-      });
-      proc.stderr?.on("data", (data) => {
-        task.errorOutput += data.toString();
-      });
-      proc.on("close", (code) => {
-        task.exitCode = code;
-        task.endTime = Date.now();
-        task.status = code === 0 ? STATUS_LABEL.DONE : STATUS_LABEL.ERROR;
-        task.process = void 0;
-        this.debug(id, `Done (code=${code})`);
-      });
-      proc.on("error", (err) => {
-        task.status = STATUS_LABEL.ERROR;
-        task.errorOutput += `
-Process error: ${err.message}`;
-        task.endTime = Date.now();
-        task.process = void 0;
-      });
-      setTimeout(() => {
-        if (task.status === STATUS_LABEL.RUNNING && task.process) {
-          task.process.kill("SIGKILL");
-          task.status = STATUS_LABEL.TIMEOUT;
-          task.endTime = Date.now();
-          this.debug(id, "Timeout");
-        }
-      }, timeout);
-    } catch (err) {
-      task.status = STATUS_LABEL.ERROR;
-      task.errorOutput = `Spawn failed: ${err instanceof Error ? err.message : String(err)}`;
-      task.endTime = Date.now();
+  getPendingCount(parentSessionID) {
+    return this.pendingByParent.get(parentSessionID)?.size ?? 0;
+  }
+  hasPending(parentSessionID) {
+    return this.getPendingCount(parentSessionID) > 0;
+  }
+  // Notifications with limit
+  queueNotification(task) {
+    const queue = this.notifications.get(task.parentSessionID) ?? [];
+    queue.push(task);
+    if (queue.length > MEMORY_LIMITS.MAX_NOTIFICATIONS_PER_PARENT) {
+      queue.shift();
     }
-    return task;
+    this.notifications.set(task.parentSessionID, queue);
   }
-  get(taskId) {
-    return this.tasks.get(taskId);
+  getNotifications(parentSessionID) {
+    return this.notifications.get(parentSessionID) ?? [];
   }
-  getAll() {
-    return Array.from(this.tasks.values());
+  clearNotifications(parentSessionID) {
+    this.notifications.delete(parentSessionID);
   }
-  getByStatus(status) {
-    return this.getAll().filter((t) => t.status === status);
+  cleanEmptyNotifications() {
+    for (const [sessionID, queue] of this.notifications.entries()) {
+      if (queue.length === 0) {
+        this.notifications.delete(sessionID);
+      }
+    }
   }
-  clearCompleted() {
-    let count = 0;
-    for (const [id, task] of this.tasks) {
-      if (task.status !== STATUS_LABEL.RUNNING && task.status !== STATUS_LABEL.PENDING) {
-        this.tasks.delete(id);
-        count++;
+  clearNotificationsForTask(taskId) {
+    for (const [sessionID, tasks] of this.notifications.entries()) {
+      const filtered = tasks.filter((t) => t.id !== taskId);
+      if (filtered.length === 0) {
+        this.notifications.delete(sessionID);
+      } else if (filtered.length !== tasks.length) {
+        this.notifications.set(sessionID, filtered);
       }
     }
-    return count;
   }
-  kill(taskId) {
-    const task = this.tasks.get(taskId);
-    if (task?.process) {
-      task.process.kill("SIGKILL");
-      task.status = STATUS_LABEL.ERROR;
-      task.errorOutput += "\nKilled by user";
-      task.endTime = Date.now();
-      return true;
+  // =========================================================================
+  // Garbage Collection & Memory Management
+  // =========================================================================
+  /**
+   * Get memory statistics
+   */
+  getStats() {
+    return {
+      tasksInMemory: this.tasks.size,
+      runningTasks: this.getRunning().length,
+      archivedTasks: this.archivedCount,
+      notificationQueues: this.notifications.size,
+      pendingParents: this.pendingByParent.size
+    };
+  }
+  /**
+   * Garbage collect completed tasks
+   * Archives old completed tasks to disk
+   */
+  async gc() {
+    const now = Date.now();
+    const toRemove = [];
+    const toArchive = [];
+    for (const [id, task] of this.tasks) {
+      if (task.status === TASK_STATUS.RUNNING) continue;
+      const completedAt = task.completedAt?.getTime() ?? 0;
+      const age = now - completedAt;
+      if (age > MEMORY_LIMITS.ARCHIVE_AGE_MS && task.status === TASK_STATUS.COMPLETED) {
+        toArchive.push(task);
+        toRemove.push(id);
+      } else if (age > MEMORY_LIMITS.ERROR_CLEANUP_AGE_MS && (task.status === TASK_STATUS.ERROR || task.status === TASK_STATUS.CANCELLED)) {
+        toRemove.push(id);
+      }
     }
-    return false;
+    if (toArchive.length > 0) {
+      await this.archiveTasks(toArchive);
+    }
+    for (const id of toRemove) {
+      this.tasks.delete(id);
+    }
+    return toRemove.length;
   }
-  formatDuration(task) {
-    const end = task.endTime || Date.now();
-    const seconds = (end - task.startTime) / 1e3;
-    if (seconds < 60) return `${seconds.toFixed(1)}s`;
-    return `${Math.floor(seconds / 60)}m ${(seconds % 60).toFixed(0)}s`;
+  /**
+   * Archive tasks to disk for later analysis
+   */
+  async archiveTasks(tasks) {
+    try {
+      await fs2.mkdir(PATHS.TASK_ARCHIVE, { recursive: true });
+      const date5 = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+      const filename = `tasks_${date5}.jsonl`;
+      const filepath = path2.join(PATHS.TASK_ARCHIVE, filename);
+      const lines = tasks.map((task) => JSON.stringify({
+        id: task.id,
+        agent: task.agent,
+        prompt: task.prompt.slice(0, 200),
+        // Truncate
+        status: task.status,
+        startedAt: task.startedAt,
+        completedAt: task.completedAt,
+        parentSessionID: task.parentSessionID
+      }));
+      await fs2.appendFile(filepath, lines.join("\n") + "\n");
+      this.archivedCount += tasks.length;
+    } catch (error45) {
+    }
   }
-  getStatusEmoji(status) {
-    return getStatusIndicator(status);
+  /**
+   * Force cleanup of all completed tasks
+   */
+  forceCleanup() {
+    const toRemove = [];
+    for (const [id, task] of this.tasks) {
+      if (task.status !== TASK_STATUS.RUNNING) {
+        toRemove.push(id);
+      }
+    }
+    for (const id of toRemove) {
+      this.tasks.delete(id);
+    }
+    return toRemove.length;
   }
 };
-var backgroundTaskManager = BackgroundTaskManager.instance;
 
-// src/tools/background-cmd/run.ts
-var runBackgroundTool = tool({
-  description: `Run a shell command in the background and get a task ID.
+// src/core/agents/format.ts
+function formatDuration(start, end) {
+  const duration3 = (end ?? /* @__PURE__ */ new Date()).getTime() - start.getTime();
+  const seconds = Math.floor(duration3 / 1e3);
+  const minutes = Math.floor(seconds / 60);
+  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**
 
-<purpose>
-Execute long-running commands (builds, tests) without blocking.
-Use check_background to get results.
-</purpose>`,
-  args: {
-    command: tool.schema.string().describe("Shell command to execute"),
-    cwd: tool.schema.string().optional().describe("Working directory"),
-    timeout: tool.schema.number().optional().describe(`Timeout in ms (default: ${BACKGROUND_TASK.DEFAULT_TIMEOUT_MS})`),
-    label: tool.schema.string().optional().describe("Task label")
-  },
-  async execute(args) {
-    const { command, cwd, timeout, label } = args;
-    const task = backgroundTaskManager.run({
-      command,
-      cwd: cwd || process.cwd(),
-      timeout: timeout || BACKGROUND_TASK.DEFAULT_TIMEOUT_MS,
-      label
-    });
-    const displayLabel = label ? ` (${label})` : "";
-    return `\u{1F680} **Background Task Started**${displayLabel}
-| Task ID | \`${task.id}\` |
-| Command | \`${command}\` |
-| Status | ${backgroundTaskManager.getStatusEmoji(task.status)} ${task.status} |
+${summary}
 
-\u{1F4CC} Use \`check_background({ taskId: "${task.id}" })\` to get results.`;
-  }
+Use \`get_task_result({ taskId: "task_xxx" })\` to retrieve results.
+</system-notification>`;
+}
+
+// src/core/notification/presets/index.ts
+var presets_exports = {};
+__export(presets_exports, {
+  allTasksComplete: () => allTasksComplete,
+  concurrencyAcquired: () => concurrencyAcquired,
+  concurrencyReleased: () => concurrencyReleased,
+  documentCached: () => documentCached,
+  errorRecovery: () => errorRecovery,
+  missionComplete: () => missionComplete,
+  missionStarted: () => missionStarted,
+  parallelTasksLaunched: () => parallelTasksLaunched,
+  researchStarted: () => researchStarted,
+  sessionCompleted: () => sessionCompleted,
+  sessionCreated: () => sessionCreated,
+  sessionResumed: () => sessionResumed,
+  taskCompleted: () => taskCompleted,
+  taskFailed: () => taskFailed,
+  taskStarted: () => taskStarted,
+  toolExecuted: () => toolExecuted,
+  warningMaxDepth: () => warningMaxDepth,
+  warningMaxRetries: () => warningMaxRetries,
+  warningRateLimited: () => warningRateLimited
 });
 
-// src/tools/background-cmd/check.ts
-var checkBackgroundTool = tool({
-  description: `Check the status and output of a background task.`,
-  args: {
-    taskId: tool.schema.string().describe("Task ID from run_background"),
-    tailLines: tool.schema.number().optional().describe("Limit output to last N lines")
-  },
-  async execute(args) {
-    const { taskId, tailLines } = args;
-    const task = backgroundTaskManager.get(taskId);
-    if (!task) {
-      const allTasks = backgroundTaskManager.getAll();
-      if (allTasks.length === 0) {
-        return `\u274C Task \`${taskId}\` not found. No background tasks exist.`;
-      }
-      const taskList = allTasks.map((t) => `- \`${t.id}\`: ${t.command.substring(0, 30)}...`).join("\n");
-      return `\u274C Task \`${taskId}\` not found.
-
-**Available:**
-${taskList}`;
+// src/core/notification/toast-core.ts
+var tuiClient = null;
+function initToastClient(client) {
+  tuiClient = client;
+}
+var toasts = [];
+var handlers = [];
+function show(options) {
+  const toast = {
+    id: `toast_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`,
+    title: options.title,
+    message: options.message,
+    variant: options.variant || "info",
+    timestamp: /* @__PURE__ */ new Date(),
+    duration: options.duration ?? 5e3,
+    dismissed: false
+  };
+  toasts.push(toast);
+  if (toasts.length > HISTORY.MAX_TOAST) {
+    toasts.shift();
+  }
+  for (const handler of handlers) {
+    try {
+      handler(toast);
+    } catch (error45) {
     }
-    const duration3 = backgroundTaskManager.formatDuration(task);
-    const statusEmoji = backgroundTaskManager.getStatusEmoji(task.status);
-    let output = task.output;
-    let stderr = task.errorOutput;
-    if (tailLines && tailLines > 0) {
-      output = output.split("\n").slice(-tailLines).join("\n");
-      stderr = stderr.split("\n").slice(-tailLines).join("\n");
+  }
+  if (tuiClient) {
+    const client = tuiClient;
+    if (client.tui?.showToast) {
+      client.tui.showToast({
+        body: {
+          title: toast.title,
+          message: toast.message,
+          variant: toast.variant,
+          duration: toast.duration
+        }
+      }).catch(() => {
+      });
     }
-    const maxLen = 1e4;
-    if (output.length > maxLen) output = `[...truncated...]\\n` + output.slice(-maxLen);
-    if (stderr.length > maxLen) stderr = `[...truncated...]\\n` + stderr.slice(-maxLen);
-    let result = `${statusEmoji} **Task ${task.id}**${task.label ? ` (${task.label})` : ""}
-| Command | \`${task.command}\` |
-| Status | ${statusEmoji} **${task.status.toUpperCase()}** |
-| Duration | ${duration3}${task.status === STATUS_LABEL.RUNNING ? " (ongoing)" : ""} |
-${task.exitCode !== null ? `| Exit Code | ${task.exitCode} |` : ""}`;
-    if (output.trim()) result += `
-
-\u{1F4E4} **stdout:**
-\`\`\`
-${output.trim()}
-\`\`\``;
-    if (stderr.trim()) result += `
+  }
+  return toast;
+}
 
-\u26A0\uFE0F **stderr:**
-\`\`\`
-${stderr.trim()}
-\`\`\``;
-    if (task.status === STATUS_LABEL.RUNNING) result += `
+// src/core/notification/presets/task-lifecycle.ts
+var taskStarted = (taskId, agent) => show({
+  title: "Task Started",
+  message: `${agent}: ${taskId}`,
+  variant: "info",
+  duration: 3e3
+});
+var taskCompleted = (taskId, agent) => show({
+  title: "Task Completed",
+  message: `${agent}: ${taskId}`,
+  variant: "success",
+  duration: 3e3
+});
+var taskFailed = (taskId, error45) => show({
+  title: "Task Failed",
+  message: `${taskId}: ${error45}`,
+  variant: "error",
+  duration: 0
+});
+var allTasksComplete = (count) => show({
+  title: "All Tasks Complete",
+  message: `${count} tasks finished successfully`,
+  variant: "success",
+  duration: 5e3
+});
 
-\u23F3 Still running... check again.`;
-    return result;
-  }
+// src/core/notification/presets/session.ts
+var sessionCreated = (sessionId, agent) => show({
+  title: "Session Created",
+  message: `${agent} - ${sessionId.slice(0, 12)}...`,
+  variant: STATUS_LABEL.INFO,
+  duration: TOAST_DURATION.SHORT
+});
+var sessionResumed = (sessionId, agent) => show({
+  title: "Session Resumed",
+  message: `${agent} - ${sessionId.slice(0, 12)}...`,
+  variant: STATUS_LABEL.INFO,
+  duration: TOAST_DURATION.SHORT
+});
+var sessionCompleted = (sessionId, duration3) => show({
+  title: "Session Completed",
+  message: `${sessionId.slice(0, 12)}... (${duration3})`,
+  variant: STATUS_LABEL.SUCCESS,
+  duration: TOAST_DURATION.MEDIUM
 });
 
-// src/tools/background-cmd/list.ts
-var listBackgroundTool = tool({
-  description: `List all background tasks and their status.`,
-  args: {
-    status: tool.schema.enum([
-      FILTER_STATUS.ALL,
-      BACKGROUND_STATUS.RUNNING,
-      BACKGROUND_STATUS.DONE,
-      BACKGROUND_STATUS.ERROR
-    ]).optional().describe("Filter by status")
-  },
-  async execute(args) {
-    const { status = FILTER_STATUS.ALL } = args;
-    let tasks;
-    if (status === FILTER_STATUS.ALL) {
-      tasks = backgroundTaskManager.getAll();
-    } else {
-      tasks = backgroundTaskManager.getByStatus(status);
-    }
-    if (tasks.length === 0) {
-      return `No background tasks${status !== FILTER_STATUS.ALL ? ` with status "${status}"` : ""}`;
-    }
-    tasks.sort((a, b) => b.startTime - a.startTime);
-    const rows = tasks.map((t) => {
-      const indicator = backgroundTaskManager.getStatusEmoji(t.status);
-      const cmd = t.command.length > 25 ? t.command.slice(0, 22) + "..." : t.command;
-      const label = t.label ? ` [${t.label}]` : "";
-      return `| \`${t.id}\` | ${indicator} ${t.status} | ${cmd}${label} | ${backgroundTaskManager.formatDuration(t)} |`;
-    }).join("\n");
-    const running = tasks.filter((t) => t.status === BACKGROUND_STATUS.RUNNING).length;
-    const done = tasks.filter((t) => t.status === BACKGROUND_STATUS.DONE).length;
-    const error45 = tasks.filter((t) => t.status === BACKGROUND_STATUS.ERROR || t.status === BACKGROUND_STATUS.TIMEOUT).length;
-    return `Background Tasks (${tasks.length})
-Running: ${running} | Done: ${done} | Error: ${error45}
+// src/core/notification/presets/parallel.ts
+var parallelTasksLaunched = (count, agents) => show({
+  title: "Parallel Tasks Launched",
+  message: `${count} tasks: ${agents.join(", ")}`,
+  variant: "info",
+  duration: TOAST_DURATION.DEFAULT
+});
+var concurrencyAcquired = (agent, slot) => show({
+  title: "Concurrency Slot",
+  message: `${agent} acquired ${slot}`,
+  variant: "info",
+  duration: TOAST_DURATION.SHORT
+});
+var concurrencyReleased = (agent) => show({
+  title: "Slot Released",
+  message: agent,
+  variant: "info",
+  duration: TOAST_DURATION.EXTRA_SHORT
+});
 
-| ID | Status | Command | Duration |
-|----|--------|---------|----------|
-${rows}`;
-  }
+// src/core/notification/presets/mission.ts
+var missionComplete = (summary) => show({
+  title: "Mission Complete",
+  message: summary,
+  variant: "success",
+  duration: 0
+});
+var missionStarted = (description) => show({
+  title: "Mission Started",
+  message: description.slice(0, 100),
+  variant: "info",
+  duration: 4e3
 });
 
-// src/tools/background-cmd/kill.ts
-var killBackgroundTool = tool({
-  description: `Kill a running background task.`,
-  args: {
-    taskId: tool.schema.string().describe("Task ID to kill")
-  },
-  async execute(args) {
-    const { taskId } = args;
-    const task = backgroundTaskManager.get(taskId);
-    if (!task) return `\u274C Task \`${taskId}\` not found.`;
-    if (task.status !== STATUS_LABEL.RUNNING) return `\u26A0\uFE0F Task \`${taskId}\` is not running (${task.status}).`;
-    const killed = backgroundTaskManager.kill(taskId);
-    if (killed) {
-      return `\u{1F6D1} Task \`${taskId}\` killed.
-Command: \`${task.command}\`
-Duration: ${backgroundTaskManager.formatDuration(task)}`;
-    }
-    return `\u26A0\uFE0F Could not kill task \`${taskId}\`.`;
-  }
+// src/core/notification/presets/tools.ts
+var toolExecuted = (toolName, target) => show({
+  title: toolName,
+  message: target.slice(0, 80),
+  variant: "info",
+  duration: TOAST_DURATION.SHORT
+});
+var documentCached = (filename) => show({
+  title: "Document Cached",
+  message: `${PATHS.DOCS}/${filename}`,
+  variant: "info",
+  duration: TOAST_DURATION.SHORT
+});
+var researchStarted = (topic) => show({
+  title: "Research Started",
+  message: topic,
+  variant: "info",
+  duration: TOAST_DURATION.MEDIUM
 });
 
-// src/core/agents/concurrency.ts
-var DEBUG2 = process.env.DEBUG_PARALLEL_AGENT === "true";
-var log2 = (...args) => {
-  if (DEBUG2) log("[concurrency]", ...args);
-};
-var ConcurrencyController = class {
-  counts = /* @__PURE__ */ new Map();
-  queues = /* @__PURE__ */ new Map();
-  limits = /* @__PURE__ */ new Map();
-  config;
-  successStreak = /* @__PURE__ */ new Map();
-  failureCount = /* @__PURE__ */ new Map();
-  constructor(config2) {
-    this.config = config2 ?? {};
-  }
-  setLimit(key, limit) {
-    this.limits.set(key, limit);
+// src/core/notification/presets/warnings.ts
+var warningRateLimited = () => show({
+  title: "Rate Limited",
+  message: "Waiting before retry...",
+  variant: "warning",
+  duration: TOAST_DURATION.LONG
+});
+var errorRecovery = (action) => show({
+  title: "Error Recovery",
+  message: `Attempting: ${action}`,
+  variant: "warning",
+  duration: TOAST_DURATION.MEDIUM
+});
+var warningMaxDepth = (depth) => show({
+  title: "Max Depth Reached",
+  message: `Recursion blocked at depth ${depth}`,
+  variant: "warning",
+  duration: TOAST_DURATION.LONG
+});
+var warningMaxRetries = () => show({
+  title: "Max Retries Exceeded",
+  message: "Automatic recovery has stopped. Manual intervention may be needed.",
+  variant: "error",
+  duration: TOAST_DURATION.PERSISTENT
+});
+
+// src/core/notification/presets.ts
+var presets = presets_exports;
+
+// src/core/notification/task-toast-manager.ts
+var TaskToastManager = class {
+  tasks = /* @__PURE__ */ new Map();
+  client = null;
+  concurrency = null;
+  /**
+   * Initialize the manager with OpenCode client
+   */
+  init(client, concurrency) {
+    this.client = client;
+    this.concurrency = concurrency ?? null;
   }
   /**
-   * Get concurrency limit for a key.
-   * Priority: explicit limit > model > provider > agent > default
+   * Set concurrency controller (can be set after init)
    */
-  getConcurrencyLimit(key) {
-    const explicitLimit = this.limits.get(key);
-    if (explicitLimit !== void 0) {
-      return explicitLimit === 0 ? Infinity : explicitLimit;
-    }
-    if (this.config.modelConcurrency?.[key] !== void 0) {
-      const limit = this.config.modelConcurrency[key];
-      return limit === 0 ? Infinity : limit;
-    }
-    const provider = key.split("/")[0];
-    if (this.config.providerConcurrency?.[provider] !== void 0) {
-      const limit = this.config.providerConcurrency[provider];
-      return limit === 0 ? Infinity : limit;
-    }
-    if (this.config.agentConcurrency?.[key] !== void 0) {
-      const limit = this.config.agentConcurrency[key];
-      return limit === 0 ? Infinity : limit;
-    }
-    return this.config.defaultConcurrency ?? PARALLEL_TASK.DEFAULT_CONCURRENCY;
+  setConcurrencyController(concurrency) {
+    this.concurrency = concurrency;
   }
-  // Backwards compatible alias
-  getLimit(key) {
-    return this.getConcurrencyLimit(key);
+  /**
+   * 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.showTaskListToast(trackedTask);
   }
-  async acquire(key) {
-    const limit = this.getConcurrencyLimit(key);
-    if (limit === Infinity) return;
-    const current = this.counts.get(key) ?? 0;
-    if (current < limit) {
-      this.counts.set(key, current + 1);
-      log2(`Acquired ${key}: ${current + 1}/${limit}`);
-      return;
+  /**
+   * Update task status
+   */
+  updateTask(id, status) {
+    const task = this.tasks.get(id);
+    if (task) {
+      task.status = status;
     }
-    log2(`Queueing ${key}: ${current}/${limit}`);
-    return new Promise((resolve2) => {
-      const queue = this.queues.get(key) ?? [];
-      queue.push(resolve2);
-      this.queues.set(key, queue);
-    });
   }
-  release(key) {
-    const limit = this.getConcurrencyLimit(key);
-    if (limit === Infinity) return;
-    const queue = this.queues.get(key);
-    if (queue && queue.length > 0) {
-      const next = queue.shift();
-      log2(`Released ${key}: next in queue`);
-      next();
-    } else {
-      const current = this.counts.get(key) ?? 0;
-      if (current > 0) {
-        this.counts.set(key, current - 1);
-        log2(`Released ${key}: ${current - 1}/${limit}`);
-      }
-    }
+  /**
+   * Remove a task
+   */
+  removeTask(id) {
+    this.tasks.delete(id);
   }
   /**
-   * Report success/failure to adjust concurrency dynamically
+   * Get all running tasks (newest first)
    */
-  reportResult(key, success2) {
-    if (success2) {
-      const streak = (this.successStreak.get(key) ?? 0) + 1;
-      this.successStreak.set(key, streak);
-      this.failureCount.set(key, 0);
-      if (streak % 5 === 0) {
-        const currentLimit = this.getConcurrencyLimit(key);
-        if (currentLimit < PARALLEL_TASK.MAX_CONCURRENCY) {
-          this.setLimit(key, currentLimit + 1);
-          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);
-          log(`[concurrency] Auto-scaling DOWN for ${key}: ${currentLimit - 1} (due to ${failures} failures)`);
-        }
-      }
-    }
+  getRunningTasks() {
+    return Array.from(this.tasks.values()).filter((t) => t.status === STATUS_LABEL.RUNNING).sort((a, b) => b.startedAt.getTime() - a.startedAt.getTime());
   }
-  getQueueLength(key) {
-    return this.queues.get(key)?.length ?? 0;
+  /**
+   * 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());
   }
-  getActiveCount(key) {
-    return this.counts.get(key) ?? 0;
+  /**
+   * Get tasks by parent session
+   */
+  getTasksByParent(parentSessionID) {
+    return Array.from(this.tasks.values()).filter((t) => t.parentSessionID === parentSessionID);
   }
   /**
-   * Get formatted concurrency info string (e.g., "2/5 slots")
+   * Format duration since task started
    */
-  getConcurrencyInfo(key) {
-    const active = this.getActiveCount(key);
-    const limit = this.getConcurrencyLimit(key);
+  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]")
+   */
+  getConcurrencyInfo() {
+    if (!this.concurrency) return "";
+    const running = this.getRunningTasks();
+    const queued = this.getQueuedTasks();
+    const total = running.length + queued.length;
+    const limit = this.concurrency.getConcurrencyLimit("default");
     if (limit === Infinity) return "";
-    return ` (${active}/${limit} slots)`;
+    return ` [${total}/${limit}]`;
   }
-};
-
-// src/core/agents/task-store.ts
-import * as fs2 from "node:fs/promises";
-import * as path2 from "node:path";
-var TaskStore = class {
-  tasks = /* @__PURE__ */ new Map();
-  pendingByParent = /* @__PURE__ */ new Map();
-  notifications = /* @__PURE__ */ new Map();
-  archivedCount = 0;
-  set(id, task) {
-    this.tasks.set(id, task);
-    if (this.tasks.size > MEMORY_LIMITS.MAX_TASKS_IN_MEMORY) {
-      this.gc();
+  /**
+   * 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(`Running (${running.length}):${concurrencyInfo}`);
+      for (const task of running) {
+        const duration3 = this.formatDuration(task.startedAt);
+        const bgTag = task.isBackground ? "[B]" : "[F]";
+        const isNew = newTask && task.id === newTask.id ? " <- NEW" : "";
+        lines.push(`${bgTag} ${task.description} (${task.agent}) - ${duration3}${isNew}`);
+      }
     }
+    if (queued.length > 0) {
+      if (lines.length > 0) lines.push("");
+      lines.push(`Queued (${queued.length}):`);
+      for (const task of queued) {
+        const bgTag = task.isBackground ? "[W]" : "[P]";
+        lines.push(`${bgTag} ${task.description} (${task.agent})`);
+      }
+    }
+    return lines.join("\n");
   }
-  get(id) {
-    return this.tasks.get(id);
-  }
-  getAll() {
-    return Array.from(this.tasks.values());
+  /**
+   * Show consolidated toast with all running/queued tasks
+   */
+  showTaskListToast(newTask) {
+    if (!this.client) return;
+    const tuiClient2 = this.client;
+    if (!tuiClient2.tui?.showToast) return;
+    const message = this.buildTaskListMessage(newTask);
+    const running = this.getRunningTasks();
+    const queued = this.getQueuedTasks();
+    const title = newTask.isBackground ? `Background Task Started` : `Task Started`;
+    tuiClient2.tui.showToast({
+      body: {
+        title,
+        message: message || `${newTask.description} (${newTask.agent})`,
+        variant: STATUS_LABEL.INFO,
+        duration: running.length + queued.length > 2 ? 5e3 : 3e3
+      }
+    }).catch(() => {
+    });
   }
-  getRunning() {
-    return this.getAll().filter((t) => t.status === TASK_STATUS.RUNNING || t.status === TASK_STATUS.PENDING);
-  }
-  getByParent(parentSessionID) {
-    return this.getAll().filter((t) => t.parentSessionID === parentSessionID);
-  }
-  delete(id) {
-    return this.tasks.delete(id);
-  }
-  clear() {
-    this.tasks.clear();
-    this.pendingByParent.clear();
-    this.notifications.clear();
-  }
-  // Pending tracking
-  trackPending(parentSessionID, taskId) {
-    const pending2 = this.pendingByParent.get(parentSessionID) ?? /* @__PURE__ */ new Set();
-    pending2.add(taskId);
-    this.pendingByParent.set(parentSessionID, pending2);
-  }
-  untrackPending(parentSessionID, taskId) {
-    const pending2 = this.pendingByParent.get(parentSessionID);
-    if (pending2) {
-      pending2.delete(taskId);
-      if (pending2.size === 0) {
-        this.pendingByParent.delete(parentSessionID);
-      }
+  /**
+   * Show task completion toast
+   */
+  showCompletionToast(info) {
+    if (!this.client) return;
+    const tuiClient2 = this.client;
+    if (!tuiClient2.tui?.showToast) 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;
     }
-  }
-  getPendingCount(parentSessionID) {
-    return this.pendingByParent.get(parentSessionID)?.size ?? 0;
-  }
-  hasPending(parentSessionID) {
-    return this.getPendingCount(parentSessionID) > 0;
-  }
-  // Notifications with limit
-  queueNotification(task) {
-    const queue = this.notifications.get(task.parentSessionID) ?? [];
-    queue.push(task);
-    if (queue.length > MEMORY_LIMITS.MAX_NOTIFICATIONS_PER_PARENT) {
-      queue.shift();
+    if (remaining.length > 0 || queued.length > 0) {
+      message += `
+
+Still running: ${remaining.length} | Queued: ${queued.length}`;
     }
-    this.notifications.set(task.parentSessionID, queue);
-  }
-  getNotifications(parentSessionID) {
-    return this.notifications.get(parentSessionID) ?? [];
-  }
-  clearNotifications(parentSessionID) {
-    this.notifications.delete(parentSessionID);
-  }
-  cleanEmptyNotifications() {
-    for (const [sessionID, queue] of this.notifications.entries()) {
-      if (queue.length === 0) {
-        this.notifications.delete(sessionID);
+    tuiClient2.tui.showToast({
+      body: {
+        title,
+        message,
+        variant,
+        duration: 5e3
       }
-    }
+    }).catch(() => {
+    });
   }
-  clearNotificationsForTask(taskId) {
-    for (const [sessionID, tasks] of this.notifications.entries()) {
-      const filtered = tasks.filter((t) => t.id !== taskId);
-      if (filtered.length === 0) {
-        this.notifications.delete(sessionID);
-      } else if (filtered.length !== tasks.length) {
-        this.notifications.set(sessionID, filtered);
+  /**
+   * Show all-tasks-complete summary toast
+   */
+  showAllCompleteToast(parentSessionID, completedTasks) {
+    if (!this.client) return;
+    const tuiClient2 = this.client;
+    if (!tuiClient2.tui?.showToast) 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");
+    tuiClient2.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(() => {
+    });
   }
-  // =========================================================================
-  // Garbage Collection & Memory Management
-  // =========================================================================
   /**
-   * Get memory statistics
+   * Show progress toast (for long-running tasks)
    */
-  getStats() {
-    return {
-      tasksInMemory: this.tasks.size,
-      runningTasks: this.getRunning().length,
-      archivedTasks: this.archivedCount,
-      notificationQueues: this.notifications.size,
-      pendingParents: this.pendingByParent.size
-    };
+  showProgressToast(taskId, progress) {
+    if (!this.client) return;
+    const tuiClient2 = this.client;
+    if (!tuiClient2.tui?.showToast) 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))}]`;
+    tuiClient2.tui.showToast({
+      body: {
+        title: `Task Progress: ${task.description}`,
+        message: `${progressBar} ${percentage}%
+${progress.message || ""}`,
+        variant: STATUS_LABEL.INFO,
+        duration: 2e3
+      }
+    }).catch(() => {
+    });
   }
   /**
-   * Garbage collect completed tasks
-   * Archives old completed tasks to disk
+   * Clear all tracked tasks
    */
-  async gc() {
-    const now = Date.now();
-    const toRemove = [];
-    const toArchive = [];
-    for (const [id, task] of this.tasks) {
-      if (task.status === TASK_STATUS.RUNNING) continue;
-      const completedAt = task.completedAt?.getTime() ?? 0;
-      const age = now - completedAt;
-      if (age > MEMORY_LIMITS.ARCHIVE_AGE_MS && task.status === TASK_STATUS.COMPLETED) {
-        toArchive.push(task);
-        toRemove.push(id);
-      } else if (age > MEMORY_LIMITS.ERROR_CLEANUP_AGE_MS && (task.status === TASK_STATUS.ERROR || task.status === TASK_STATUS.CANCELLED)) {
-        toRemove.push(id);
-      }
-    }
-    if (toArchive.length > 0) {
-      await this.archiveTasks(toArchive);
-    }
-    for (const id of toRemove) {
-      this.tasks.delete(id);
-    }
-    return toRemove.length;
+  clear() {
+    this.tasks.clear();
   }
   /**
-   * Archive tasks to disk for later analysis
+   * Get task count stats
    */
-  async archiveTasks(tasks) {
+  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(client, concurrency) {
+  if (!instance) {
+    instance = new TaskToastManager();
+  }
+  instance.init(client, concurrency);
+  return instance;
+}
+
+// src/core/agents/persistence/task-wal.ts
+import * as fs3 from "node:fs/promises";
+import * as path3 from "node:path";
+var TaskWAL = class {
+  walPath;
+  initialized = false;
+  constructor(customPath) {
+    this.walPath = customPath || path3.resolve(process.cwd(), ".opencode/archive/tasks/active_tasks.jsonl");
+  }
+  async init() {
+    if (this.initialized) return;
     try {
-      await fs2.mkdir(PATHS.TASK_ARCHIVE, { recursive: true });
-      const date5 = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-      const filename = `tasks_${date5}.jsonl`;
-      const filepath = path2.join(PATHS.TASK_ARCHIVE, filename);
-      const lines = tasks.map((task) => JSON.stringify({
+      const dir = path3.dirname(this.walPath);
+      await fs3.mkdir(dir, { recursive: true });
+      this.initialized = true;
+    } catch (error45) {
+      log("Failed to initialize Task WAL directory:", error45);
+    }
+  }
+  async log(action, task) {
+    if (!this.initialized) await this.init();
+    const entry = {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      action,
+      taskId: task.id,
+      data: action === WAL_ACTIONS.DELETE ? { id: task.id } : {
         id: task.id,
+        sessionID: task.sessionID,
+        parentSessionID: task.parentSessionID,
+        description: task.description,
         agent: task.agent,
-        prompt: task.prompt.slice(0, 200),
-        // Truncate
         status: task.status,
         startedAt: task.startedAt,
-        completedAt: task.completedAt,
-        parentSessionID: task.parentSessionID
-      }));
-      await fs2.appendFile(filepath, lines.join("\n") + "\n");
-      this.archivedCount += tasks.length;
-    } catch (error45) {
-    }
-  }
-  /**
-   * Force cleanup of all completed tasks
-   */
-  forceCleanup() {
-    const toRemove = [];
-    for (const [id, task] of this.tasks) {
-      if (task.status !== TASK_STATUS.RUNNING) {
-        toRemove.push(id);
+        depth: task.depth,
+        prompt: action === WAL_ACTIONS.LAUNCH ? task.prompt : void 0
+        // Only log prompt on launch to save space
       }
+    };
+    try {
+      await fs3.appendFile(this.walPath, JSON.stringify(entry) + "\n");
+    } catch (error45) {
     }
-    for (const id of toRemove) {
-      this.tasks.delete(id);
-    }
-    return toRemove.length;
   }
-};
-
-// src/core/agents/format.ts
-function formatDuration(start, end) {
-  const duration3 = (end ?? /* @__PURE__ */ new Date()).getTime() - start.getTime();
-  const seconds = Math.floor(duration3 / 1e3);
-  const minutes = Math.floor(seconds / 60);
-  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/notification/presets/index.ts
-var presets_exports = {};
-__export(presets_exports, {
-  allTasksComplete: () => allTasksComplete,
-  concurrencyAcquired: () => concurrencyAcquired,
-  concurrencyReleased: () => concurrencyReleased,
-  documentCached: () => documentCached,
-  errorRecovery: () => errorRecovery,
-  missionComplete: () => missionComplete,
-  missionStarted: () => missionStarted,
-  parallelTasksLaunched: () => parallelTasksLaunched,
-  researchStarted: () => researchStarted,
-  sessionCompleted: () => sessionCompleted,
-  sessionCreated: () => sessionCreated,
-  sessionResumed: () => sessionResumed,
-  taskCompleted: () => taskCompleted,
-  taskFailed: () => taskFailed,
-  taskStarted: () => taskStarted,
-  toolExecuted: () => toolExecuted,
-  warningMaxDepth: () => warningMaxDepth,
-  warningMaxRetries: () => warningMaxRetries,
-  warningRateLimited: () => warningRateLimited
-});
-
-// src/core/notification/toast-core.ts
-var tuiClient = null;
-function initToastClient(client) {
-  tuiClient = client;
-}
-var toasts = [];
-var handlers = [];
-function show(options) {
-  const toast = {
-    id: `toast_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`,
-    title: options.title,
-    message: options.message,
-    variant: options.variant || "info",
-    timestamp: /* @__PURE__ */ new Date(),
-    duration: options.duration ?? 5e3,
-    dismissed: false
-  };
-  toasts.push(toast);
-  if (toasts.length > HISTORY.MAX_TOAST) {
-    toasts.shift();
+  async readAll() {
+    if (!this.initialized) await this.init();
+    const tasks = /* @__PURE__ */ new Map();
+    try {
+      const content = await fs3.readFile(this.walPath, "utf-8");
+      const lines = content.split("\n").filter(Boolean);
+      for (const line of lines) {
+        try {
+          const entry = JSON.parse(line);
+          if (entry.action === WAL_ACTIONS.DELETE) {
+            tasks.delete(entry.taskId);
+          } else if (entry.action === WAL_ACTIONS.LAUNCH) {
+            tasks.set(entry.taskId, entry.data);
+          } else {
+            const existing = tasks.get(entry.taskId);
+            if (existing) {
+              Object.assign(existing, entry.data);
+            }
+          }
+        } catch {
+        }
+      }
+    } catch (error45) {
+      if (error45.code !== "ENOENT") {
+        log("Error reading Task WAL:", error45);
+      }
+    }
+    return tasks;
   }
-  for (const handler of handlers) {
+  /**
+   * Compact the WAL by writing only the current active tasks
+   */
+  async compact(activeTasks) {
     try {
-      handler(toast);
+      const tempPath = `${this.walPath}.tmp`;
+      const content = activeTasks.map((task) => JSON.stringify({
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        action: WAL_ACTIONS.LAUNCH,
+        taskId: task.id,
+        data: task
+      })).join("\n") + "\n";
+      await fs3.writeFile(tempPath, content);
+      await fs3.rename(tempPath, this.walPath);
     } catch (error45) {
+      log("Failed to compact Task WAL:", error45);
     }
   }
-  if (tuiClient) {
-    const client = tuiClient;
-    if (client.tui?.showToast) {
-      client.tui.showToast({
+};
+var taskWAL = new TaskWAL();
+
+// src/core/agents/manager/task-launcher.ts
+var TaskLauncher = class {
+  constructor(client, directory, store, concurrency, onTaskError, startPolling) {
+    this.client = client;
+    this.directory = directory;
+    this.store = store;
+    this.concurrency = concurrency;
+    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;
+    log(`[task-launcher.ts] Batch launching ${taskInputs.length} task(s)`);
+    const startTime = Date.now();
+    const tasks = await Promise.all(taskInputs.map(
+      (input) => this.prepareTask(input).catch((error45) => {
+        log(`[task-launcher.ts] Failed to prepare task ${input.description}:`, error45);
+        return null;
+      })
+    ));
+    const successfulTasks = tasks.filter((t) => t !== null);
+    successfulTasks.forEach((task) => {
+      this.executeBackground(task).catch((error45) => {
+        log(`[task-launcher.ts] Background execution failed for ${task.id}:`, error45);
+        this.onTaskError(task.id, error45);
+      });
+    });
+    const elapsed = Date.now() - startTime;
+    log(`[task-launcher.ts] Batch launch prepared: ${successfulTasks.length} tasks in ${elapsed}ms`);
+    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) {
+      log(`[task-launcher.ts] Task depth limit reached (${currentDepth}/${PARALLEL_TASK.MAX_DEPTH}). Generation blocked.`);
+      throw new Error(`Maximum task depth (${PARALLEL_TASK.MAX_DEPTH}) reached. To prevent infinite recursion, no further sub-tasks can be spawned.`);
+    }
+    const createResult = await this.client.session.create({
+      body: {
+        parentID: input.parentSessionID,
+        title: `${PARALLEL_TASK.SESSION_TITLE_PREFIX}: ${input.description}`
+      },
+      query: { directory: this.directory }
+    });
+    if (createResult.error || !createResult.data?.id) {
+      throw new Error(`Session creation failed: ${createResult.error || "No ID"}`);
+    }
+    const sessionID = createResult.data.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.sessionCreated(sessionID, input.agent);
+    return task;
+  }
+  /**
+   * Background execution: Acquire slot and fire prompt
+   */
+  async executeBackground(task) {
+    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(() => {
+      });
+      await this.client.session.prompt({
+        path: { id: task.sessionID },
         body: {
-          title: toast.title,
-          message: toast.message,
-          variant: toast.variant,
-          duration: toast.duration
+          agent: task.agent,
+          tools: {
+            // HPFA: Allow agents to delegate sub-tasks (Fractal Spawning)
+            delegate_task: true,
+            get_task_result: true,
+            list_tasks: true,
+            cancel_task: true
+          },
+          parts: [{ type: PART_TYPES.TEXT, text: task.prompt }]
         }
-      }).catch(() => {
       });
+      log(`[task-launcher.ts] Task ${task.id} (${task.agent}) started running`);
+    } catch (error45) {
+      this.concurrency.release(task.agent);
+      throw error45;
     }
   }
-  return toast;
-}
+};
 
-// src/core/notification/presets/task-lifecycle.ts
-var taskStarted = (taskId, agent) => show({
-  title: "Task Started",
-  message: `${agent}: ${taskId}`,
-  variant: "info",
-  duration: 3e3
-});
-var taskCompleted = (taskId, agent) => show({
-  title: "Task Completed",
-  message: `${agent}: ${taskId}`,
-  variant: "success",
-  duration: 3e3
-});
-var taskFailed = (taskId, error45) => show({
-  title: "Task Failed",
-  message: `${taskId}: ${error45}`,
-  variant: "error",
-  duration: 0
-});
-var allTasksComplete = (count) => show({
-  title: "All Tasks Complete",
-  message: `${count} tasks finished successfully`,
-  variant: "success",
-  duration: 5e3
-});
-
-// src/core/notification/presets/session.ts
-var sessionCreated = (sessionId, agent) => show({
-  title: "Session Created",
-  message: `${agent} - ${sessionId.slice(0, 12)}...`,
-  variant: STATUS_LABEL.INFO,
-  duration: TOAST_DURATION.SHORT
-});
-var sessionResumed = (sessionId, agent) => show({
-  title: "Session Resumed",
-  message: `${agent} - ${sessionId.slice(0, 12)}...`,
-  variant: STATUS_LABEL.INFO,
-  duration: TOAST_DURATION.SHORT
-});
-var sessionCompleted = (sessionId, duration3) => show({
-  title: "Session Completed",
-  message: `${sessionId.slice(0, 12)}... (${duration3})`,
-  variant: STATUS_LABEL.SUCCESS,
-  duration: TOAST_DURATION.MEDIUM
-});
-
-// src/core/notification/presets/parallel.ts
-var parallelTasksLaunched = (count, agents) => show({
-  title: "Parallel Tasks Launched",
-  message: `${count} tasks: ${agents.join(", ")}`,
-  variant: "info",
-  duration: TOAST_DURATION.DEFAULT
-});
-var concurrencyAcquired = (agent, slot) => show({
-  title: "Concurrency Slot",
-  message: `${agent} acquired ${slot}`,
-  variant: "info",
-  duration: TOAST_DURATION.SHORT
-});
-var concurrencyReleased = (agent) => show({
-  title: "Slot Released",
-  message: agent,
-  variant: "info",
-  duration: TOAST_DURATION.EXTRA_SHORT
-});
-
-// src/core/notification/presets/mission.ts
-var missionComplete = (summary) => show({
-  title: "Mission Complete",
-  message: summary,
-  variant: "success",
-  duration: 0
-});
-var missionStarted = (description) => show({
-  title: "Mission Started",
-  message: description.slice(0, 100),
-  variant: "info",
-  duration: 4e3
-});
-
-// src/core/notification/presets/tools.ts
-var toolExecuted = (toolName, target) => show({
-  title: toolName,
-  message: target.slice(0, 80),
-  variant: "info",
-  duration: TOAST_DURATION.SHORT
-});
-var documentCached = (filename) => show({
-  title: "Document Cached",
-  message: `${PATHS.DOCS}/${filename}`,
-  variant: "info",
-  duration: TOAST_DURATION.SHORT
-});
-var researchStarted = (topic) => show({
-  title: "Research Started",
-  message: topic,
-  variant: "info",
-  duration: TOAST_DURATION.MEDIUM
-});
-
-// src/core/notification/presets/warnings.ts
-var warningRateLimited = () => show({
-  title: "Rate Limited",
-  message: "Waiting before retry...",
-  variant: "warning",
-  duration: TOAST_DURATION.LONG
-});
-var errorRecovery = (action) => show({
-  title: "Error Recovery",
-  message: `Attempting: ${action}`,
-  variant: "warning",
-  duration: TOAST_DURATION.MEDIUM
-});
-var warningMaxDepth = (depth) => show({
-  title: "Max Depth Reached",
-  message: `Recursion blocked at depth ${depth}`,
-  variant: "warning",
-  duration: TOAST_DURATION.LONG
-});
-var warningMaxRetries = () => show({
-  title: "Max Retries Exceeded",
-  message: "Automatic recovery has stopped. Manual intervention may be needed.",
-  variant: "error",
-  duration: TOAST_DURATION.PERSISTENT
-});
+// src/core/agents/manager/task-resumer.ts
+var TaskResumer = class {
+  constructor(client, store, findBySession, startPolling, notifyParentIfAllComplete) {
+    this.client = client;
+    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((error45) => {
+      log(`Resume prompt error for ${existingTask.id}:`, error45);
+      existingTask.status = TASK_STATUS.ERROR;
+      existingTask.error = error45 instanceof Error ? error45.message : String(error45);
+      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/notification/presets.ts
-var presets = presets_exports;
+// src/core/agents/config.ts
+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/notification/task-toast-manager.ts
-var TaskToastManager = class {
-  tasks = /* @__PURE__ */ new Map();
-  client = null;
-  concurrency = null;
-  /**
-   * Initialize the manager with OpenCode client
-   */
-  init(client, concurrency) {
+// src/core/agents/manager/task-poller.ts
+var TaskPoller = class {
+  constructor(client, store, concurrency, notifyParentIfAllComplete, scheduleCleanup, pruneExpiredTasks, onTaskComplete) {
     this.client = client;
-    this.concurrency = concurrency ?? null;
-  }
-  /**
-   * Set concurrency controller (can be set after init)
-   */
-  setConcurrencyController(concurrency) {
+    this.store = store;
     this.concurrency = concurrency;
+    this.notifyParentIfAllComplete = notifyParentIfAllComplete;
+    this.scheduleCleanup = scheduleCleanup;
+    this.pruneExpiredTasks = pruneExpiredTasks;
+    this.onTaskComplete = onTaskComplete;
   }
-  /**
-   * 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.showTaskListToast(trackedTask);
+  pollingInterval;
+  start() {
+    if (this.pollingInterval) return;
+    log("[task-poller.ts] start() - polling started");
+    this.pollingInterval = setInterval(() => this.poll(), CONFIG.POLL_INTERVAL_MS);
+    this.pollingInterval.unref();
   }
-  /**
-   * Update task status
-   */
-  updateTask(id, status) {
-    const task = this.tasks.get(id);
-    if (task) {
-      task.status = status;
+  stop() {
+    if (this.pollingInterval) {
+      clearInterval(this.pollingInterval);
+      this.pollingInterval = void 0;
     }
   }
-  /**
-   * Remove a task
-   */
-  removeTask(id) {
-    this.tasks.delete(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);
+  isRunning() {
+    return !!this.pollingInterval;
   }
-  /**
-   * 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]")
-   */
-  getConcurrencyInfo() {
-    if (!this.concurrency) return "";
-    const running = this.getRunningTasks();
-    const queued = this.getQueuedTasks();
-    const total = running.length + queued.length;
-    const limit = this.concurrency.getConcurrencyLimit("default");
-    if (limit === Infinity) return "";
-    return ` [${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(`Running (${running.length}):${concurrencyInfo}`);
+  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) {
-        const duration3 = this.formatDuration(task.startedAt);
-        const bgTag = task.isBackground ? "[B]" : "[F]";
-        const isNew = newTask && task.id === newTask.id ? " <- NEW" : "";
-        lines.push(`${bgTag} ${task.description} (${task.agent}) - ${duration3}${isNew}`);
+        try {
+          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 (error45) {
+          log(`Poll error for task ${task.id}:`, error45);
+        }
       }
+    } catch (error45) {
+      log("Polling error:", error45);
     }
-    if (queued.length > 0) {
-      if (lines.length > 0) lines.push("");
-      lines.push(`Queued (${queued.length}):`);
-      for (const task of queued) {
-        const bgTag = task.isBackground ? "[W]" : "[P]";
-        lines.push(`${bgTag} ${task.description} (${task.agent})`);
+  }
+  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;
     }
-    return lines.join("\n");
   }
-  /**
-   * Show consolidated toast with all running/queued tasks
-   */
-  showTaskListToast(newTask) {
-    if (!this.client) return;
-    const tuiClient2 = this.client;
-    if (!tuiClient2.tui?.showToast) return;
-    const message = this.buildTaskListMessage(newTask);
-    const running = this.getRunningTasks();
-    const queued = this.getQueuedTasks();
-    const title = newTask.isBackground ? `Background Task Started` : `Task Started`;
-    tuiClient2.tui.showToast({
-      body: {
-        title,
-        message: message || `${newTask.description} (${newTask.agent})`,
-        variant: STATUS_LABEL.INFO,
-        duration: running.length + queued.length > 2 ? 5e3 : 3e3
-      }
-    }).catch(() => {
+  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 duration3 = formatDuration(task.startedAt, task.completedAt);
+    presets.sessionCompleted(task.sessionID, duration3);
+    log(`Completed ${task.id} (${duration3})`);
   }
-  /**
-   * Show task completion toast
-   */
-  showCompletionToast(info) {
-    if (!this.client) return;
-    const tuiClient2 = this.client;
-    if (!tuiClient2.tui?.showToast) 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;
+  async updateTaskProgress(task) {
+    try {
+      const result = await this.client.session.messages({ path: { id: task.sessionID } });
+      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()
+      };
+      const currentMsgCount = messages.length;
+      if (task.lastMsgCount === currentMsgCount) {
+        task.stablePolls = (task.stablePolls ?? 0) + 1;
+      } else {
+        task.stablePolls = 0;
+      }
+      task.lastMsgCount = currentMsgCount;
+    } catch {
     }
-    if (remaining.length > 0 || queued.length > 0) {
-      message += `
+  }
+};
 
-Still running: ${remaining.length} | Queued: ${queued.length}`;
+// src/core/agents/manager/task-cleaner.ts
+init_store();
+var TaskCleaner = class {
+  constructor(client, store, concurrency) {
+    this.client = client;
+    this.store = store;
+    this.concurrency = concurrency;
+  }
+  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.client.session.delete({ path: { id: task.sessionID } }).catch(() => {
+      });
+      clear(task.sessionID);
+      this.store.delete(taskId);
+      taskWAL.log(WAL_ACTIONS.DELETE, task).catch(() => {
+      });
     }
-    tuiClient2.tui.showToast({
-      body: {
-        title,
-        message,
-        variant,
-        duration: 5e3
+    this.store.cleanEmptyNotifications();
+  }
+  scheduleCleanup(taskId) {
+    const task = this.store.get(taskId);
+    const sessionID = task?.sessionID;
+    setTimeout(async () => {
+      if (sessionID) {
+        try {
+          await this.client.session.delete({ path: { id: sessionID } });
+          clear(sessionID);
+        } catch {
+        }
       }
-    }).catch(() => {
-    });
+      this.store.delete(taskId);
+      if (task) taskWAL.log(WAL_ACTIONS.DELETE, task).catch(() => {
+      });
+      log(`Cleaned up ${taskId}`);
+    }, CONFIG.CLEANUP_DELAY_MS);
   }
   /**
-   * Show all-tasks-complete summary toast
+   * 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)
    */
-  showAllCompleteToast(parentSessionID, completedTasks) {
-    if (!this.client) return;
-    const tuiClient2 = this.client;
-    if (!tuiClient2.tui?.showToast) 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");
-    tuiClient2.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 progress toast (for long-running tasks)
-   */
-  showProgressToast(taskId, progress) {
-    if (!this.client) return;
-    const tuiClient2 = this.client;
-    if (!tuiClient2.tui?.showToast) 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))}]`;
-    tuiClient2.tui.showToast({
-      body: {
-        title: `Task Progress: ${task.description}`,
-        message: `${progressBar} ${percentage}%
-${progress.message || ""}`,
-        variant: STATUS_LABEL.INFO,
-        duration: 2e3
+  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);
       }
-    }).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(client, concurrency) {
-  if (!instance) {
-    instance = new TaskToastManager();
-  }
-  instance.init(client, concurrency);
-  return instance;
-}
-
-// src/core/agents/persistence/task-wal.ts
-import * as fs3 from "node:fs/promises";
-import * as path3 from "node:path";
-var TaskWAL = class {
-  walPath;
-  initialized = false;
-  constructor(customPath) {
-    this.walPath = customPath || path3.resolve(process.cwd(), ".opencode/archive/tasks/active_tasks.jsonl");
-  }
-  async init() {
-    if (this.initialized) return;
-    try {
-      const dir = path3.dirname(this.walPath);
-      await fs3.mkdir(dir, { recursive: true });
-      this.initialized = true;
-    } catch (error45) {
-      log("Failed to initialize Task WAL directory:", error45);
     }
-  }
-  async log(action, task) {
-    if (!this.initialized) await this.init();
-    const entry = {
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      action,
-      taskId: task.id,
-      data: action === WAL_ACTIONS.DELETE ? { id: task.id } : {
-        id: task.id,
-        sessionID: task.sessionID,
-        parentSessionID: task.parentSessionID,
-        description: task.description,
-        agent: task.agent,
-        status: task.status,
-        startedAt: task.startedAt,
-        depth: task.depth,
-        prompt: action === WAL_ACTIONS.LAUNCH ? task.prompt : void 0
-        // Only log prompt on launch to save space
-      }
-    };
-    try {
-      await fs3.appendFile(this.walPath, JSON.stringify(entry) + "\n");
-    } catch (error45) {
+    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.`;
     }
-  }
-  async readAll() {
-    if (!this.initialized) await this.init();
-    const tasks = /* @__PURE__ */ new Map();
     try {
-      const content = await fs3.readFile(this.walPath, "utf-8");
-      const lines = content.split("\n").filter(Boolean);
-      for (const line of lines) {
-        try {
-          const entry = JSON.parse(line);
-          if (entry.action === WAL_ACTIONS.DELETE) {
-            tasks.delete(entry.taskId);
-          } else if (entry.action === WAL_ACTIONS.LAUNCH) {
-            tasks.set(entry.taskId, entry.data);
-          } else {
-            const existing = tasks.get(entry.taskId);
-            if (existing) {
-              Object.assign(existing, entry.data);
-            }
-          }
-        } catch {
+      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 }]
         }
-      }
-    } catch (error45) {
-      if (error45.code !== "ENOENT") {
-        log("Error reading Task WAL:", error45);
-      }
-    }
-    return tasks;
-  }
-  /**
-   * Compact the WAL by writing only the current active tasks
-   */
-  async compact(activeTasks) {
-    try {
-      const tempPath = `${this.walPath}.tmp`;
-      const content = activeTasks.map((task) => JSON.stringify({
-        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-        action: WAL_ACTIONS.LAUNCH,
-        taskId: task.id,
-        data: task
-      })).join("\n") + "\n";
-      await fs3.writeFile(tempPath, content);
-      await fs3.rename(tempPath, this.walPath);
+      });
+      log(`Notified parent ${parentSessionID} (allComplete=${allComplete}, noReply=${!allComplete})`);
     } catch (error45) {
-      log("Failed to compact Task WAL:", error45);
+      log("Notification error:", error45);
     }
+    this.store.clearNotifications(parentSessionID);
   }
 };
-var taskWAL = new TaskWAL();
 
-// src/core/agents/manager/task-launcher.ts
-var TaskLauncher = class {
-  constructor(client, directory, store, concurrency, onTaskError, startPolling) {
+// src/core/agents/manager/event-handler.ts
+var EventHandler = class {
+  constructor(client, store, concurrency, findBySession, notifyParentIfAllComplete, scheduleCleanup, validateSessionHasOutput2, onTaskComplete) {
     this.client = client;
-    this.directory = directory;
     this.store = store;
     this.concurrency = concurrency;
-    this.onTaskError = onTaskError;
-    this.startPolling = startPolling;
+    this.findBySession = findBySession;
+    this.notifyParentIfAllComplete = notifyParentIfAllComplete;
+    this.scheduleCleanup = scheduleCleanup;
+    this.validateSessionHasOutput = validateSessionHasOutput2;
+    this.onTaskComplete = onTaskComplete;
   }
   /**
-   * 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.
+   * Handle OpenCode session events for proper resource cleanup.
+   * Call this from your plugin's event hook.
    */
-  async launch(inputs) {
-    const isArray = Array.isArray(inputs);
-    const taskInputs = isArray ? inputs : [inputs];
-    if (taskInputs.length === 0) return isArray ? [] : null;
-    log(`[task-launcher.ts] Batch launching ${taskInputs.length} task(s)`);
-    const startTime = Date.now();
-    const tasks = await Promise.all(taskInputs.map(
-      (input) => this.prepareTask(input).catch((error45) => {
-        log(`[task-launcher.ts] Failed to prepare task ${input.description}:`, error45);
-        return null;
-      })
-    ));
-    const successfulTasks = tasks.filter((t) => t !== null);
-    successfulTasks.forEach((task) => {
-      this.executeBackground(task).catch((error45) => {
-        log(`[task-launcher.ts] Background execution failed for ${task.id}:`, error45);
-        this.onTaskError(task.id, error45);
+  handle(event) {
+    const props = event.properties;
+    if (event.type === SESSION_EVENTS.IDLE) {
+      const sessionID = props?.sessionID;
+      if (!sessionID) return;
+      const task = this.findBySession(sessionID);
+      if (!task || task.status !== TASK_STATUS.RUNNING) return;
+      this.handleSessionIdle(task).catch((err) => {
+        log("Error handling session.idle:", err);
       });
-    });
-    const elapsed = Date.now() - startTime;
-    log(`[task-launcher.ts] Batch launch prepared: ${successfulTasks.length} tasks in ${elapsed}ms`);
-    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) {
-      log(`[task-launcher.ts] Task depth limit reached (${currentDepth}/${PARALLEL_TASK.MAX_DEPTH}). Generation blocked.`);
-      throw new Error(`Maximum task depth (${PARALLEL_TASK.MAX_DEPTH}) reached. To prevent infinite recursion, no further sub-tasks can be spawned.`);
+    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);
     }
-    const createResult = await this.client.session.create({
-      body: {
-        parentID: input.parentSessionID,
-        title: `${PARALLEL_TASK.SESSION_TITLE_PREFIX}: ${input.description}`
-      },
-      query: { directory: this.directory }
-    });
-    if (createResult.error || !createResult.data?.id) {
-      throw new Error(`Session creation failed: ${createResult.error || "No ID"}`);
-    }
-    const sessionID = createResult.data.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.sessionCreated(sessionID, input.agent);
-    return task;
-  }
-  /**
-   * Background execution: Acquire slot and fire prompt
-   */
-  async executeBackground(task) {
-    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(() => {
-      });
-      await this.client.session.prompt({
-        path: { id: task.sessionID },
-        body: {
-          agent: task.agent,
-          tools: {
-            // HPFA: Allow agents to delegate sub-tasks (Fractal Spawning)
-            delegate_task: true,
-            get_task_result: true,
-            list_tasks: true,
-            cancel_task: true
-          },
-          parts: [{ type: PART_TYPES.TEXT, text: task.prompt }]
-        }
-      });
-      log(`[task-launcher.ts] Task ${task.id} (${task.agent}) started running`);
-    } catch (error45) {
-      this.concurrency.release(task.agent);
-      throw error45;
-    }
-  }
-};
-
-// src/core/agents/manager/task-resumer.ts
-var TaskResumer = class {
-  constructor(client, store, findBySession, startPolling, notifyParentIfAllComplete) {
-    this.client = client;
-    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((error45) => {
-      log(`Resume prompt error for ${existingTask.id}:`, error45);
-      existingTask.status = TASK_STATUS.ERROR;
-      existingTask.error = error45 instanceof Error ? error45.message : String(error45);
-      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
-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
-var TaskPoller = class {
-  constructor(client, store, concurrency, notifyParentIfAllComplete, scheduleCleanup, pruneExpiredTasks, onTaskComplete) {
-    this.client = client;
-    this.store = store;
-    this.concurrency = concurrency;
-    this.notifyParentIfAllComplete = notifyParentIfAllComplete;
-    this.scheduleCleanup = scheduleCleanup;
-    this.pruneExpiredTasks = pruneExpiredTasks;
-    this.onTaskComplete = onTaskComplete;
-  }
-  pollingInterval;
-  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();
+  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;
     }
-    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 {
-          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 (error45) {
-          log(`Poll error for task ${task.id}:`, error45);
-        }
-      }
-    } catch (error45) {
-      log("Polling error:", error45);
-    }
-  }
-  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;
+    const hasOutput = await this.validateSessionHasOutput(task.sessionID);
+    if (!hasOutput) {
+      log(`Session idle but no output for ${task.id}, waiting...`);
+      return;
     }
-  }
-  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) {
@@ -17371,477 +16962,943 @@ var TaskPoller = class {
     if (this.onTaskComplete) {
       Promise.resolve(this.onTaskComplete(task)).catch((err) => log("Error in onTaskComplete callback:", err));
     }
-    const duration3 = formatDuration(task.startedAt, task.completedAt);
-    presets.sessionCompleted(task.sessionID, duration3);
-    log(`Completed ${task.id} (${duration3})`);
-  }
-  async updateTaskProgress(task) {
-    try {
-      const result = await this.client.session.messages({ path: { id: task.sessionID } });
-      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()
-      };
-      const currentMsgCount = messages.length;
-      if (task.lastMsgCount === currentMsgCount) {
-        task.stablePolls = (task.stablePolls ?? 0) + 1;
-      } else {
-        task.stablePolls = 0;
-      }
-      task.lastMsgCount = currentMsgCount;
-    } catch {
-    }
+    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(() => {
+    });
+    log(`Cleaned up deleted session task: ${task.id}`);
   }
 };
 
-// src/core/agents/manager/task-cleaner.ts
-init_store();
-var TaskCleaner = class {
-  constructor(client, store, concurrency) {
+// src/core/agents/manager.ts
+var ParallelAgentManager = class _ParallelAgentManager {
+  static _instance;
+  store = new TaskStore();
+  client;
+  directory;
+  concurrency = new ConcurrencyController();
+  // Composed components
+  launcher;
+  resumer;
+  poller;
+  cleaner;
+  eventHandler;
+  constructor(client, directory) {
     this.client = client;
-    this.store = store;
-    this.concurrency = concurrency;
+    this.directory = directory;
+    this.cleaner = new TaskCleaner(client, this.store, this.concurrency);
+    this.poller = new TaskPoller(
+      client,
+      this.store,
+      this.concurrency,
+      (parentSessionID) => this.cleaner.notifyParentIfAllComplete(parentSessionID),
+      (taskId) => this.cleaner.scheduleCleanup(taskId),
+      () => this.cleaner.pruneExpiredTasks(),
+      (task) => this.handleTaskComplete(task)
+    );
+    this.launcher = new TaskLauncher(
+      client,
+      directory,
+      this.store,
+      this.concurrency,
+      (taskId, error45) => this.handleTaskError(taskId, error45),
+      () => this.poller.start()
+    );
+    this.resumer = new TaskResumer(
+      client,
+      this.store,
+      (sessionID) => this.findBySession(sessionID),
+      () => this.poller.start(),
+      (parentSessionID) => this.cleaner.notifyParentIfAllComplete(parentSessionID)
+    );
+    this.eventHandler = new EventHandler(
+      client,
+      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.recoverActiveTasks().catch((err) => {
+      log("Recovery error:", err);
+    });
   }
-  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
-          });
-        }
+  static getInstance(client, directory) {
+    if (!_ParallelAgentManager._instance) {
+      if (!client || !directory) {
+        throw new Error("ParallelAgentManager requires client and directory on first call");
       }
-      this.client.session.delete({ path: { id: task.sessionID } }).catch(() => {
-      });
-      clear(task.sessionID);
-      this.store.delete(taskId);
-      taskWAL.log(WAL_ACTIONS.DELETE, task).catch(() => {
-      });
+      _ParallelAgentManager._instance = new _ParallelAgentManager(client, directory);
     }
-    this.store.cleanEmptyNotifications();
+    return _ParallelAgentManager._instance;
   }
-  scheduleCleanup(taskId) {
-    const task = this.store.get(taskId);
-    const sessionID = task?.sessionID;
-    setTimeout(async () => {
-      if (sessionID) {
-        try {
-          await this.client.session.delete({ path: { id: sessionID } });
-          clear(sessionID);
-        } catch {
-        }
-      }
-      this.store.delete(taskId);
-      if (task) taskWAL.log(WAL_ACTIONS.DELETE, task).catch(() => {
-      });
-      log(`Cleaned up ${taskId}`);
-    }, CONFIG.CLEANUP_DELAY_MS);
+  // ========================================================================
+  // Public API
+  // ========================================================================
+  async launch(inputs) {
+    this.cleaner.pruneExpiredTasks();
+    return this.launcher.launch(inputs);
   }
-  /**
-   * 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 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.`;
+  async resume(input) {
+    return this.resumer.resume(input);
+  }
+  getTask(id) {
+    return this.store.get(id);
+  }
+  getRunningTasks() {
+    return this.store.getRunning();
+  }
+  getAllTasks() {
+    return this.store.getAll();
+  }
+  getTasksByParent(parentSessionID) {
+    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`);
     }
+    this.cleaner.scheduleCleanup(taskId);
+    taskWAL.log(WAL_ACTIONS.DELETE, task).catch(() => {
+    });
+    log(`Cancelled ${taskId}`);
+    return true;
+  }
+  async getResult(taskId) {
+    const task = this.store.get(taskId);
+    if (!task) return null;
+    if (task.result) return task.result;
+    if (task.status === TASK_STATUS.ERROR) return `Error: ${task.error}`;
+    if (task.status === TASK_STATUS.RUNNING) return null;
     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})`);
+      const result = await this.client.session.messages({ path: { id: task.sessionID } });
+      if (result.error) return `Error: ${result.error}`;
+      const messages = result.data ?? [];
+      const lastMsg = messages.filter((m) => m.info?.role === MESSAGE_ROLES.ASSISTANT).reverse()[0];
+      if (!lastMsg) return "(No response)";
+      const text = lastMsg.parts?.filter((p) => p.type === PART_TYPES.TEXT || p.type === PART_TYPES.REASONING).map((p) => p.text ?? "").filter(Boolean).join("\n") ?? "";
+      task.result = text;
+      return text;
     } catch (error45) {
-      log("Notification error:", error45);
+      return `Error: ${error45 instanceof Error ? error45.message : String(error45)}`;
     }
-    this.store.clearNotifications(parentSessionID);
   }
-};
-
-// src/core/agents/manager/event-handler.ts
-var EventHandler = class {
-  constructor(client, store, concurrency, findBySession, notifyParentIfAllComplete, scheduleCleanup, validateSessionHasOutput2, onTaskComplete) {
-    this.client = client;
-    this.store = store;
-    this.concurrency = concurrency;
-    this.findBySession = findBySession;
-    this.notifyParentIfAllComplete = notifyParentIfAllComplete;
-    this.scheduleCleanup = scheduleCleanup;
-    this.validateSessionHasOutput = validateSessionHasOutput2;
-    this.onTaskComplete = onTaskComplete;
+  setConcurrencyLimit(agentType, limit) {
+    this.concurrency.setLimit(agentType, limit);
   }
-  /**
-   * 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;
-      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);
-    }
+  getPendingCount(parentSessionID) {
+    return this.store.getPendingCount(parentSessionID);
   }
-  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;
+  getConcurrency() {
+    return this.concurrency;
+  }
+  cleanup() {
+    this.poller.stop();
+    this.store.clear();
+    Promise.resolve().then(() => (init_store(), store_exports)).then((store) => store.clearAll()).catch(() => {
+    });
+  }
+  formatDuration = formatDuration;
+  /**
+   * Get orchestration stats
+   */
+  getStats() {
+    const running = this.store.getRunning().length;
+    const all = this.store.getAll().length;
+    let queued = 0;
+    const concurrencyKeys = ["default", AGENT_NAMES.WORKER, AGENT_NAMES.REVIEWER, AGENT_NAMES.PLANNER];
+    for (const key of concurrencyKeys) {
+      queued += this.concurrency.getQueueLength(key);
     }
-    task.status = TASK_STATUS.COMPLETED;
+    return {
+      running,
+      queued,
+      total: all
+    };
+  }
+  // ========================================================================
+  // Event Handling
+  // ========================================================================
+  handleEvent(event) {
+    this.eventHandler.handle(event);
+  }
+  // ========================================================================
+  // Private Helpers
+  // ========================================================================
+  findBySession(sessionID) {
+    return this.store.getAll().find((t) => t.sessionID === sessionID);
+  }
+  handleTaskError(taskId, error45) {
+    const task = this.store.get(taskId);
+    if (!task) return;
+    task.status = TASK_STATUS.ERROR;
+    task.error = error45 instanceof Error ? error45.message : String(error45);
     task.completedAt = /* @__PURE__ */ new Date();
     if (task.concurrencyKey) {
       this.concurrency.release(task.concurrencyKey);
-      this.concurrency.reportResult(task.concurrencyKey, true);
-      task.concurrencyKey = void 0;
+      this.concurrency.reportResult(task.concurrencyKey, false);
     }
-    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(() => {
+    this.store.untrackPending(task.parentSessionID, taskId);
+    this.cleaner.notifyParentIfAllComplete(task.parentSessionID);
+    this.cleaner.scheduleCleanup(taskId);
+    taskWAL.log(WAL_ACTIONS.UPDATE, task).catch(() => {
+    });
+  }
+  async handleTaskComplete(task) {
+    if (task.agent === AGENT_NAMES.WORKER && task.mode !== "race") {
+      log(`[MSVP] Triggering 1\uCC28 \uB9AC\uBDF0 (Unit Review) for task ${task.id}`);
+      try {
+        await this.launch({
+          agent: AGENT_NAMES.REVIEWER,
+          description: `1\uCC28 \uB9AC\uBDF0: ${task.description}`,
+          prompt: `\uC9C4\uD589\uB41C \uC791\uC5C5(\`${task.description}\`)\uC5D0 \uB300\uD574 1\uCC28 \uB9AC\uBDF0(\uC720\uB2DB \uAC80\uC99D)\uB97C \uC218\uD589\uD558\uC138\uC694.
+\uC8FC\uC694 \uC810\uAC80 \uC0AC\uD56D:
+1. \uD574\uB2F9 \uBAA8\uB4C8\uC758 \uC720\uB2DB \uD14C\uC2A4\uD2B8 \uCF54\uB4DC \uC791\uC131 \uC5EC\uBD80 \uBC0F \uD1B5\uACFC \uD655\uC778
+2. \uCF54\uB4DC \uD488\uC9C8 \uBC0F \uBAA8\uB4C8\uC131 \uC900\uC218 \uC5EC\uBD80
+3. \uBC1C\uACAC\uB41C \uACB0\uD568 \uC989\uC2DC \uC218\uC815 \uC9C0\uC2DC \uB610\uB294 \uB9AC\uD3EC\uD2B8
+
+\uC774 \uC791\uC5C5\uC740 \uC804\uCCB4 \uD1B5\uD569 \uC804 \uBD80\uD488 \uB2E8\uC704\uC758 \uC644\uACB0\uC131\uC744 \uBCF4\uC7A5\uD558\uAE30 \uC704\uD568\uC785\uB2C8\uB2E4.`,
+          parentSessionID: task.parentSessionID,
+          depth: task.depth,
+          groupID: task.groupID || task.id
+          // Group reviews with their origins
+        });
+      } catch (error45) {
+        log(`[MSVP] Failed to trigger review for ${task.id}:`, error45);
+      }
+    }
+  }
+  async recoverActiveTasks() {
+    const tasks = await taskWAL.readAll();
+    if (tasks.size === 0) return;
+    log(`Attempting to recover ${tasks.size} tasks from WAL...`);
+    let recoveredCount = 0;
+    for (const task of tasks.values()) {
+      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 {
+        }
+      } else {
+      }
+    }
+    if (recoveredCount > 0) {
+      log(`Recovered ${recoveredCount} active tasks.`);
+      this.poller.start();
+    }
+  }
+};
+var parallelAgentManager = {
+  getInstance: ParallelAgentManager.getInstance.bind(ParallelAgentManager)
+};
+
+// src/tools/slashCommand.ts
+var COMMANDER_SYSTEM_PROMPT = commander.systemPrompt;
+var MISSION_MODE_TEMPLATE = `${COMMANDER_SYSTEM_PROMPT}
+
+<mission>
+<task>
+$ARGUMENTS
+</task>
+
+<execution_rules>
+1. Complete this mission without user intervention
+2. Use your full capabilities: research, implement, verify
+3. Output "${MISSION_SEAL.PATTERN}" when done
+</execution_rules>
+</mission>`;
+var COMMANDS = {
+  "task": {
+    description: "MISSION MODE - Execute task autonomously until complete",
+    template: MISSION_MODE_TEMPLATE,
+    argumentHint: '"mission goal"'
+  },
+  "plan": {
+    description: "Create a task plan without executing",
+    template: `<delegate>
+<agent>${AGENT_NAMES.PLANNER}</agent>
+<objective>Create parallel task plan for: $ARGUMENTS</objective>
+<success>Valid .opencode/todo.md with tasks, each having id, description, agent, size, dependencies</success>
+<must_do>
+- Maximize parallelism by grouping independent tasks
+- Assign correct agent to each task (${AGENT_NAMES.WORKER} or ${AGENT_NAMES.REVIEWER})
+- Include clear success criteria for each task
+- Research before planning if unfamiliar technology
+</must_do>
+<must_not>
+- Do not implement any tasks, only plan
+- Do not create tasks that depend on each other unnecessarily
+</must_not>
+<context>
+- This is planning only, no execution
+- Output to .opencode/todo.md
+</context>
+</delegate>`,
+    argumentHint: '"complex task to plan"'
+  },
+  "agents": {
+    description: "Show the 4-agent architecture",
+    template: `## OpenCode Orchestrator - 4-Agent Architecture
+
+| Agent | Role | Capabilities |
+|-------|------|--------------|
+| **${AGENT_NAMES.COMMANDER}** | [MASTER] | Master Orchestrator: mission control, parallel coordination |
+| **${AGENT_NAMES.PLANNER}** | [STRATEGIST] | Planning, research, documentation analysis |
+| **${AGENT_NAMES.WORKER}** | [EXECUTOR] | Implementation, coding, terminal tasks |
+| **${AGENT_NAMES.REVIEWER}** | [VERIFIER] | Verification, testing, context sanity checks |
+
+## Parallel Execution System
+\`\`\`
+Up to 50 Worker Sessions running simultaneously
+Max 10 per agent type (auto-queues excess)
+Auto-timeout: 60 min | Auto-cleanup: 30 min
+\`\`\`
+
+## Execution Flow
+\`\`\`
+THINK \u2192 PLAN \u2192 DELEGATE \u2192 EXECUTE \u2192 VERIFY \u2192 COMPLETE
+   L1: Fast Track (simple fixes)
+   L2: Normal Track (features)
+   L3: Deep Track (complex refactoring)
+\`\`\`
+
+## Anti-Hallucination
+- ${AGENT_NAMES.PLANNER} researches BEFORE implementation
+- ${AGENT_NAMES.WORKER} caches official documentation
+- Never assumes - always verifies from sources
+
+## Usage
+- Select **${AGENT_NAMES.COMMANDER}** and type your request
+- Or use \`/task "your mission"\` explicitly
+- ${AGENT_NAMES.COMMANDER} automatically coordinates all agents`
+  },
+  "monitor": {
+    description: "SYS MONITOR - Check real-time orchestration status and connections",
+    template: "$DYNAMIC_MONITOR_STATUS"
+  }
+};
+function createSlashcommandTool() {
+  const commandList = Object.entries(COMMANDS).map(([name, cmd]) => {
+    const hint = cmd.argumentHint ? ` ${cmd.argumentHint}` : "";
+    return `- /${name}${hint}: ${cmd.description}`;
+  }).join("\n");
+  return tool({
+    description: `Available commands:
+${commandList}`,
+    args: {
+      command: tool.schema.string().describe("Command name (without slash)")
+    },
+    async execute(args) {
+      const cmdName = (args.command || "").replace(/^\//, "").split(/\s+/)[0].toLowerCase();
+      const cmdArgs = (args.command || "").replace(/^\/?\\S+\s*/, "");
+      if (!cmdName) return `Commands:
+${commandList}`;
+      const command = COMMANDS[cmdName];
+      if (!command) return `Unknown command: /${cmdName}
+
+${commandList}`;
+      if (cmdName === "monitor") {
+        try {
+          const manager = ParallelAgentManager.getInstance();
+          const stats2 = manager.getStats?.() || { running: 0, queued: 0, total: 0 };
+          const concurrency = manager.getConcurrency();
+          const toastManager = getTaskToastManager();
+          const logPath = getLogPath();
+          const activeTasks = manager.getRunningTasks();
+          const taskList = activeTasks.length > 0 ? activeTasks.map((t) => `- [${t.agent}] ${t.description.slice(0, 40)}... (${manager.formatDuration(t.startedAt)})`).join("\n") : "No active background tasks.";
+          const tuiConnected = toastManager?.client ? "\u2705 CONNECTED" : "\u274C DISCONNECTED";
+          return `## \u{1F5A5}\uFE0F System Monitor: opencode-orchestrator
+
+### \u{1F684} Orchestration Status
+- **Active Workers**: ${stats2.running}
+- **Queued Tasks**: ${stats2.queued}
+- **Total Lifetime Tasks**: ${stats2.total}
+
+### \u{1F517} Connection Status
+- **TUI (Toast/UI)**: ${tuiConnected}
+- **Storage (WAL)**: \u2705 ENABLED
+- **Log Feed**: \`${logPath}\`
+
+### \u26A1 Concurrency Slots
+- **Default**: ${concurrency.getActiveCount("default")}/${concurrency.getConcurrencyLimit("default")}
+- **Worker**: ${concurrency.getActiveCount(AGENT_NAMES.WORKER)}/${concurrency.getConcurrencyLimit(AGENT_NAMES.WORKER)}
+- **Reviewer**: ${concurrency.getActiveCount(AGENT_NAMES.REVIEWER)}/${concurrency.getConcurrencyLimit(AGENT_NAMES.REVIEWER)}
+
+### \u{1F4CA} Active Background Swarm
+${taskList}
+
+---
+*Use \`tail -f ${logPath}\` for real-time debug stream.*`;
+        } catch (err) {
+          return `Error fetching monitor status: ${err instanceof Error ? err.message : String(err)}`;
+        }
+      }
+      return command.template.replace(/\$ARGUMENTS/g, cmdArgs || PROMPTS.CONTINUE_DEFAULT);
+    }
+  });
+}
+
+// src/tools/rust.ts
+import { spawn } from "child_process";
+import { existsSync as existsSync2 } from "fs";
+
+// src/utils/binary.ts
+import { join as join3, dirname as dirname2 } from "path";
+import { fileURLToPath } from "url";
+import { platform, arch } from "os";
+import { existsSync } from "fs";
+var __dirname = dirname2(fileURLToPath(import.meta.url));
+function getBinaryPath() {
+  const binDir = join3(__dirname, "..", "..", "bin");
+  const os2 = platform();
+  const cpu = arch();
+  let binaryName;
+  if (os2 === PLATFORM.WIN32) {
+    binaryName = "orchestrator-windows-x64.exe";
+  } else if (os2 === PLATFORM.DARWIN) {
+    binaryName = cpu === "arm64" ? "orchestrator-macos-arm64" : "orchestrator-macos-x64";
+  } else {
+    binaryName = cpu === "arm64" ? "orchestrator-linux-arm64" : "orchestrator-linux-x64";
+  }
+  let binaryPath = join3(binDir, binaryName);
+  if (!existsSync(binaryPath)) {
+    binaryPath = join3(binDir, os2 === PLATFORM.WIN32 ? "orchestrator.exe" : "orchestrator");
+  }
+  return binaryPath;
+}
+
+// src/tools/rust.ts
+async function callRustTool(name, args) {
+  const binary = getBinaryPath();
+  if (!existsSync2(binary)) {
+    return JSON.stringify({ error: `Binary not found: ${binary}` });
+  }
+  return new Promise((resolve2) => {
+    const proc = spawn(binary, ["serve"], { stdio: ["pipe", "pipe", "pipe"] });
+    let stdout = "";
+    proc.stdout.on("data", (data) => {
+      stdout += data.toString();
+    });
+    proc.stderr.on("data", (data) => {
+      const msg = data.toString().trim();
+      if (msg) log(`[rust-stderr] ${msg}`);
+    });
+    const request = JSON.stringify({
+      jsonrpc: "2.0",
+      id: Date.now(),
+      method: "tools/call",
+      params: { name, arguments: args }
+    });
+    proc.stdin.write(request + "\n");
+    proc.stdin.end();
+    const timeout = setTimeout(() => {
+      proc.kill();
+      resolve2(JSON.stringify({ error: "Timeout" }));
+    }, 6e4);
+    proc.on("close", (code) => {
+      clearTimeout(timeout);
+      if (code !== 0 && code !== null) {
+        log(`Rust process exited with code ${code}`);
+      }
+      try {
+        const lines = stdout.trim().split("\n");
+        for (let i = lines.length - 1; i >= 0; i--) {
+          try {
+            const response = JSON.parse(lines[i]);
+            if (response.result || response.error) {
+              const text = response?.result?.content?.[0]?.text;
+              return resolve2(text || JSON.stringify(response.result));
+            }
+          } catch {
+            continue;
+          }
+        }
+        resolve2(stdout || "No output");
+      } catch {
+        resolve2(stdout || "No output");
+      }
+    });
+  });
+}
+
+// src/tools/search.ts
+var grepSearchTool = (directory) => tool({
+  description: "Search code patterns using regex. Returns matching lines with file paths and line numbers.",
+  args: {
+    pattern: tool.schema.string().describe("Regex pattern to search for"),
+    dir: tool.schema.string().optional().describe("Directory to search (defaults to project root)"),
+    max_results: tool.schema.number().optional().describe("Max results (default: 100)"),
+    timeout_ms: tool.schema.number().optional().describe("Timeout in milliseconds (default: 30000)")
+  },
+  async execute(args) {
+    return callRustTool("grep_search", {
+      pattern: args.pattern,
+      directory: args.dir || directory,
+      max_results: args.max_results,
+      timeout_ms: args.timeout_ms
+    });
+  }
+});
+var globSearchTool = (directory) => tool({
+  description: "Find files matching a glob pattern. Returns list of file paths.",
+  args: {
+    pattern: tool.schema.string().describe("Glob pattern (e.g., '**/*.ts', 'src/**/*.md')"),
+    dir: tool.schema.string().optional().describe("Directory to search (defaults to project root)")
+  },
+  async execute(args) {
+    return callRustTool("glob_search", {
+      pattern: args.pattern,
+      directory: args.dir || directory
+    });
+  }
+});
+var mgrepTool = (directory) => tool({
+  description: `Search multiple patterns (runs grep for each pattern).`,
+  args: {
+    patterns: tool.schema.array(tool.schema.string()).describe("Array of regex patterns"),
+    dir: tool.schema.string().optional().describe("Directory (defaults to project root)"),
+    max_results_per_pattern: tool.schema.number().optional().describe("Max results per pattern (default: 50)"),
+    timeout_ms: tool.schema.number().optional().describe("Timeout in milliseconds (default: 60000)")
+  },
+  async execute(args) {
+    return callRustTool("mgrep", {
+      patterns: args.patterns,
+      directory: args.dir || directory,
+      max_results_per_pattern: args.max_results_per_pattern,
+      timeout_ms: args.timeout_ms
+    });
+  }
+});
+var sedReplaceTool = (directory) => tool({
+  description: `Find and replace patterns in files (sed-like). Supports regex. Use dry_run=true to preview changes.`,
+  args: {
+    pattern: tool.schema.string().describe("Regex pattern to find"),
+    replacement: tool.schema.string().describe("Replacement string"),
+    file: tool.schema.string().optional().describe("Single file to modify"),
+    dir: tool.schema.string().optional().describe("Directory to search (modifies all matching files)"),
+    dry_run: tool.schema.boolean().optional().describe("Preview changes without modifying files (default: false)"),
+    backup: tool.schema.boolean().optional().describe("Create .bak backup before modifying (default: false)"),
+    timeout_ms: tool.schema.number().optional().describe("Timeout in milliseconds")
+  },
+  async execute(args) {
+    return callRustTool("sed_replace", {
+      pattern: args.pattern,
+      replacement: args.replacement,
+      file: args.file,
+      directory: args.dir || (args.file ? void 0 : directory),
+      dry_run: args.dry_run,
+      backup: args.backup,
+      timeout_ms: args.timeout_ms
+    });
+  }
+});
+var diffTool = () => tool({
+  description: `Compare two files or strings and show differences.`,
+  args: {
+    file1: tool.schema.string().optional().describe("First file to compare"),
+    file2: tool.schema.string().optional().describe("Second file to compare"),
+    content1: tool.schema.string().optional().describe("First string to compare"),
+    content2: tool.schema.string().optional().describe("Second string to compare"),
+    ignore_whitespace: tool.schema.boolean().optional().describe("Ignore whitespace differences")
+  },
+  async execute(args) {
+    return callRustTool("diff", args);
+  }
+});
+var jqTool = () => tool({
+  description: `Query and manipulate JSON using jq expressions.`,
+  args: {
+    json_input: tool.schema.string().optional().describe("JSON string to query"),
+    file: tool.schema.string().optional().describe("JSON file to query"),
+    expression: tool.schema.string().describe("jq expression (e.g., '.foo.bar', '.[] | select(.x > 1)')"),
+    raw_output: tool.schema.boolean().optional().describe("Raw output (no JSON encoding for strings)")
+  },
+  async execute(args) {
+    return callRustTool("jq", args);
+  }
+});
+var httpTool = () => tool({
+  description: `Make HTTP requests (GET, POST, PUT, DELETE, etc).`,
+  args: {
+    url: tool.schema.string().describe("URL to request"),
+    method: tool.schema.string().optional().describe("HTTP method (GET, POST, PUT, DELETE, PATCH, HEAD)"),
+    headers: tool.schema.object({}).optional().describe("Request headers as JSON object"),
+    body: tool.schema.string().optional().describe("Request body"),
+    timeout_ms: tool.schema.number().optional().describe("Request timeout in milliseconds")
+  },
+  async execute(args) {
+    return callRustTool("http", args);
+  }
+});
+var fileStatsTool = (directory) => tool({
+  description: `Analyze file/directory statistics (file counts, sizes, line counts, etc).`,
+  args: {
+    dir: tool.schema.string().optional().describe("Directory to analyze (defaults to project root)"),
+    max_depth: tool.schema.number().optional().describe("Maximum directory depth to analyze")
+  },
+  async execute(args) {
+    return callRustTool("file_stats", {
+      directory: args.dir || directory,
+      max_depth: args.max_depth
+    });
+  }
+});
+var gitDiffTool = (directory) => tool({
+  description: `Show git diff of uncommitted changes.`,
+  args: {
+    dir: tool.schema.string().optional().describe("Repository directory (defaults to project root)"),
+    staged_only: tool.schema.boolean().optional().describe("Show only staged changes")
+  },
+  async execute(args) {
+    return callRustTool("git_diff", {
+      directory: args.dir || directory,
+      staged_only: args.staged_only
     });
-    if (this.onTaskComplete) {
-      Promise.resolve(this.onTaskComplete(task)).catch((err) => log("Error in onTaskComplete callback:", err));
-    }
-    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(() => {
+});
+var gitStatusTool = (directory) => tool({
+  description: `Show git status (modified, added, deleted files).`,
+  args: {
+    dir: tool.schema.string().optional().describe("Repository directory (defaults to project root)")
+  },
+  async execute(args) {
+    return callRustTool("git_status", {
+      directory: args.dir || directory
     });
-    log(`Cleaned up deleted session task: ${task.id}`);
   }
+});
+
+// src/core/commands/types/background-task-status.ts
+var BACKGROUND_TASK_STATUS = {
+  PENDING: STATUS_LABEL.PENDING,
+  RUNNING: STATUS_LABEL.RUNNING,
+  DONE: STATUS_LABEL.DONE,
+  ERROR: STATUS_LABEL.ERROR,
+  TIMEOUT: STATUS_LABEL.TIMEOUT
 };
 
-// src/core/agents/manager.ts
-var ParallelAgentManager = class _ParallelAgentManager {
+// src/core/commands/manager.ts
+import { spawn as spawn2 } from "node:child_process";
+import { randomBytes } from "node:crypto";
+var BackgroundTaskManager = class _BackgroundTaskManager {
   static _instance;
-  store = new TaskStore();
-  client;
-  directory;
-  concurrency = new ConcurrencyController();
-  // Composed components
-  launcher;
-  resumer;
-  poller;
-  cleaner;
-  eventHandler;
-  constructor(client, directory) {
-    this.client = client;
-    this.directory = directory;
-    this.cleaner = new TaskCleaner(client, this.store, this.concurrency);
-    this.poller = new TaskPoller(
-      client,
-      this.store,
-      this.concurrency,
-      (parentSessionID) => this.cleaner.notifyParentIfAllComplete(parentSessionID),
-      (taskId) => this.cleaner.scheduleCleanup(taskId),
-      () => this.cleaner.pruneExpiredTasks(),
-      (task) => this.handleTaskComplete(task)
-    );
-    this.launcher = new TaskLauncher(
-      client,
-      directory,
-      this.store,
-      this.concurrency,
-      (taskId, error45) => this.handleTaskError(taskId, error45),
-      () => this.poller.start()
-    );
-    this.resumer = new TaskResumer(
-      client,
-      this.store,
-      (sessionID) => this.findBySession(sessionID),
-      () => this.poller.start(),
-      (parentSessionID) => this.cleaner.notifyParentIfAllComplete(parentSessionID)
-    );
-    this.eventHandler = new EventHandler(
-      client,
-      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.recoverActiveTasks().catch((err) => {
-      log("Recovery error:", err);
-    });
+  tasks = /* @__PURE__ */ new Map();
+  debugMode = process.env.DEBUG_BG_TASK === "true";
+  // Disabled by default
+  constructor() {
   }
-  static getInstance(client, directory) {
-    if (!_ParallelAgentManager._instance) {
-      if (!client || !directory) {
-        throw new Error("ParallelAgentManager requires client and directory on first call");
-      }
-      _ParallelAgentManager._instance = new _ParallelAgentManager(client, directory);
+  static get instance() {
+    if (!_BackgroundTaskManager._instance) {
+      _BackgroundTaskManager._instance = new _BackgroundTaskManager();
     }
-    return _ParallelAgentManager._instance;
-  }
-  // ========================================================================
-  // Public API
-  // ========================================================================
-  async launch(inputs) {
-    this.cleaner.pruneExpiredTasks();
-    return this.launcher.launch(inputs);
+    return _BackgroundTaskManager._instance;
   }
-  async resume(input) {
-    return this.resumer.resume(input);
+  generateId() {
+    return `${ID_PREFIX.JOB}${randomBytes(4).toString("hex")}`;
   }
-  getTask(id) {
-    return this.store.get(id);
+  debug(taskId, message) {
+    if (this.debugMode) {
+      const ts = (/* @__PURE__ */ new Date()).toISOString().substring(11, 23);
+      log(`[BG ${ts}] ${taskId}: ${message}`);
+    }
   }
-  getRunningTasks() {
-    return this.store.getRunning();
+  run(options) {
+    const id = this.generateId();
+    const { command, cwd = process.cwd(), timeout = 3e5, label } = options;
+    const isWindows = process.platform === PLATFORM.WIN32;
+    const shell = isWindows ? "cmd.exe" : CLI_NAME.SH;
+    const shellFlag = isWindows ? "/c" : "-c";
+    const task = {
+      id,
+      command,
+      args: [shellFlag, command],
+      cwd,
+      label,
+      status: STATUS_LABEL.RUNNING,
+      output: "",
+      errorOutput: "",
+      exitCode: null,
+      startTime: Date.now(),
+      timeout
+    };
+    this.tasks.set(id, task);
+    this.debug(id, `Starting: ${command}`);
+    try {
+      const proc = spawn2(shell, task.args, {
+        cwd,
+        stdio: ["ignore", "pipe", "pipe"],
+        detached: false
+      });
+      task.process = proc;
+      proc.stdout?.on("data", (data) => {
+        task.output += data.toString();
+      });
+      proc.stderr?.on("data", (data) => {
+        task.errorOutput += data.toString();
+      });
+      proc.on("close", (code) => {
+        task.exitCode = code;
+        task.endTime = Date.now();
+        task.status = code === 0 ? STATUS_LABEL.DONE : STATUS_LABEL.ERROR;
+        task.process = void 0;
+        this.debug(id, `Done (code=${code})`);
+      });
+      proc.on("error", (err) => {
+        task.status = STATUS_LABEL.ERROR;
+        task.errorOutput += `
+Process error: ${err.message}`;
+        task.endTime = Date.now();
+        task.process = void 0;
+      });
+      setTimeout(() => {
+        if (task.status === STATUS_LABEL.RUNNING && task.process) {
+          task.process.kill("SIGKILL");
+          task.status = STATUS_LABEL.TIMEOUT;
+          task.endTime = Date.now();
+          this.debug(id, "Timeout");
+        }
+      }, timeout);
+    } catch (err) {
+      task.status = STATUS_LABEL.ERROR;
+      task.errorOutput = `Spawn failed: ${err instanceof Error ? err.message : String(err)}`;
+      task.endTime = Date.now();
+    }
+    return task;
   }
-  getAllTasks() {
-    return this.store.getAll();
+  get(taskId) {
+    return this.tasks.get(taskId);
   }
-  getTasksByParent(parentSessionID) {
-    return this.store.getByParent(parentSessionID);
+  getAll() {
+    return Array.from(this.tasks.values());
   }
-  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`);
-    }
-    this.cleaner.scheduleCleanup(taskId);
-    taskWAL.log(WAL_ACTIONS.DELETE, task).catch(() => {
-    });
-    log(`Cancelled ${taskId}`);
-    return true;
+  getByStatus(status) {
+    return this.getAll().filter((t) => t.status === status);
   }
-  async getResult(taskId) {
-    const task = this.store.get(taskId);
-    if (!task) return null;
-    if (task.result) return task.result;
-    if (task.status === TASK_STATUS.ERROR) return `Error: ${task.error}`;
-    if (task.status === TASK_STATUS.RUNNING) return null;
-    try {
-      const result = await this.client.session.messages({ path: { id: task.sessionID } });
-      if (result.error) return `Error: ${result.error}`;
-      const messages = result.data ?? [];
-      const lastMsg = messages.filter((m) => m.info?.role === MESSAGE_ROLES.ASSISTANT).reverse()[0];
-      if (!lastMsg) return "(No response)";
-      const text = lastMsg.parts?.filter((p) => p.type === PART_TYPES.TEXT || p.type === PART_TYPES.REASONING).map((p) => p.text ?? "").filter(Boolean).join("\n") ?? "";
-      task.result = text;
-      return text;
-    } catch (error45) {
-      return `Error: ${error45 instanceof Error ? error45.message : String(error45)}`;
+  clearCompleted() {
+    let count = 0;
+    for (const [id, task] of this.tasks) {
+      if (task.status !== STATUS_LABEL.RUNNING && task.status !== STATUS_LABEL.PENDING) {
+        this.tasks.delete(id);
+        count++;
+      }
     }
+    return count;
   }
-  setConcurrencyLimit(agentType, limit) {
-    this.concurrency.setLimit(agentType, limit);
-  }
-  getPendingCount(parentSessionID) {
-    return this.store.getPendingCount(parentSessionID);
-  }
-  getConcurrency() {
-    return this.concurrency;
-  }
-  cleanup() {
-    this.poller.stop();
-    this.store.clear();
-    Promise.resolve().then(() => (init_store(), store_exports)).then((store) => store.clearAll()).catch(() => {
-    });
+  kill(taskId) {
+    const task = this.tasks.get(taskId);
+    if (task?.process) {
+      task.process.kill("SIGKILL");
+      task.status = STATUS_LABEL.ERROR;
+      task.errorOutput += "\nKilled by user";
+      task.endTime = Date.now();
+      return true;
+    }
+    return false;
   }
-  formatDuration = formatDuration;
-  // ========================================================================
-  // Event Handling
-  // ========================================================================
-  handleEvent(event) {
-    this.eventHandler.handle(event);
+  formatDuration(task) {
+    const end = task.endTime || Date.now();
+    const seconds = (end - task.startTime) / 1e3;
+    if (seconds < 60) return `${seconds.toFixed(1)}s`;
+    return `${Math.floor(seconds / 60)}m ${(seconds % 60).toFixed(0)}s`;
   }
-  // ========================================================================
-  // Private Helpers
-  // ========================================================================
-  findBySession(sessionID) {
-    return this.store.getAll().find((t) => t.sessionID === sessionID);
+  getStatusEmoji(status) {
+    return getStatusIndicator(status);
   }
-  handleTaskError(taskId, error45) {
-    const task = this.store.get(taskId);
-    if (!task) return;
-    task.status = TASK_STATUS.ERROR;
-    task.error = error45 instanceof Error ? error45.message : String(error45);
-    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);
-    taskWAL.log(WAL_ACTIONS.UPDATE, task).catch(() => {
+};
+var backgroundTaskManager = BackgroundTaskManager.instance;
+
+// src/tools/background-cmd/run.ts
+var runBackgroundTool = tool({
+  description: `Run a shell command in the background and get a task ID.
+
+<purpose>
+Execute long-running commands (builds, tests) without blocking.
+Use check_background to get results.
+</purpose>`,
+  args: {
+    command: tool.schema.string().describe("Shell command to execute"),
+    cwd: tool.schema.string().optional().describe("Working directory"),
+    timeout: tool.schema.number().optional().describe(`Timeout in ms (default: ${BACKGROUND_TASK.DEFAULT_TIMEOUT_MS})`),
+    label: tool.schema.string().optional().describe("Task label")
+  },
+  async execute(args) {
+    const { command, cwd, timeout, label } = args;
+    const task = backgroundTaskManager.run({
+      command,
+      cwd: cwd || process.cwd(),
+      timeout: timeout || BACKGROUND_TASK.DEFAULT_TIMEOUT_MS,
+      label
     });
+    const displayLabel = label ? ` (${label})` : "";
+    return `\u{1F680} **Background Task Started**${displayLabel}
+| Task ID | \`${task.id}\` |
+| Command | \`${command}\` |
+| Status | ${backgroundTaskManager.getStatusEmoji(task.status)} ${task.status} |
+
+\u{1F4CC} Use \`check_background({ taskId: "${task.id}" })\` to get results.`;
   }
-  async handleTaskComplete(task) {
-    if (task.agent === AGENT_NAMES.WORKER && task.mode !== "race") {
-      log(`[MSVP] Triggering 1\uCC28 \uB9AC\uBDF0 (Unit Review) for task ${task.id}`);
-      try {
-        await this.launch({
-          agent: AGENT_NAMES.REVIEWER,
-          description: `1\uCC28 \uB9AC\uBDF0: ${task.description}`,
-          prompt: `\uC9C4\uD589\uB41C \uC791\uC5C5(\`${task.description}\`)\uC5D0 \uB300\uD574 1\uCC28 \uB9AC\uBDF0(\uC720\uB2DB \uAC80\uC99D)\uB97C \uC218\uD589\uD558\uC138\uC694.
-\uC8FC\uC694 \uC810\uAC80 \uC0AC\uD56D:
-1. \uD574\uB2F9 \uBAA8\uB4C8\uC758 \uC720\uB2DB \uD14C\uC2A4\uD2B8 \uCF54\uB4DC \uC791\uC131 \uC5EC\uBD80 \uBC0F \uD1B5\uACFC \uD655\uC778
-2. \uCF54\uB4DC \uD488\uC9C8 \uBC0F \uBAA8\uB4C8\uC131 \uC900\uC218 \uC5EC\uBD80
-3. \uBC1C\uACAC\uB41C \uACB0\uD568 \uC989\uC2DC \uC218\uC815 \uC9C0\uC2DC \uB610\uB294 \uB9AC\uD3EC\uD2B8
+});
 
-\uC774 \uC791\uC5C5\uC740 \uC804\uCCB4 \uD1B5\uD569 \uC804 \uBD80\uD488 \uB2E8\uC704\uC758 \uC644\uACB0\uC131\uC744 \uBCF4\uC7A5\uD558\uAE30 \uC704\uD568\uC785\uB2C8\uB2E4.`,
-          parentSessionID: task.parentSessionID,
-          depth: task.depth,
-          groupID: task.groupID || task.id
-          // Group reviews with their origins
-        });
-      } catch (error45) {
-        log(`[MSVP] Failed to trigger review for ${task.id}:`, error45);
+// src/tools/background-cmd/check.ts
+var checkBackgroundTool = tool({
+  description: `Check the status and output of a background task.`,
+  args: {
+    taskId: tool.schema.string().describe("Task ID from run_background"),
+    tailLines: tool.schema.number().optional().describe("Limit output to last N lines")
+  },
+  async execute(args) {
+    const { taskId, tailLines } = args;
+    const task = backgroundTaskManager.get(taskId);
+    if (!task) {
+      const allTasks = backgroundTaskManager.getAll();
+      if (allTasks.length === 0) {
+        return `\u274C Task \`${taskId}\` not found. No background tasks exist.`;
       }
+      const taskList = allTasks.map((t) => `- \`${t.id}\`: ${t.command.substring(0, 30)}...`).join("\n");
+      return `\u274C Task \`${taskId}\` not found.
+
+**Available:**
+${taskList}`;
     }
+    const duration3 = backgroundTaskManager.formatDuration(task);
+    const statusEmoji = backgroundTaskManager.getStatusEmoji(task.status);
+    let output = task.output;
+    let stderr = task.errorOutput;
+    if (tailLines && tailLines > 0) {
+      output = output.split("\n").slice(-tailLines).join("\n");
+      stderr = stderr.split("\n").slice(-tailLines).join("\n");
+    }
+    const maxLen = 1e4;
+    if (output.length > maxLen) output = `[...truncated...]\\n` + output.slice(-maxLen);
+    if (stderr.length > maxLen) stderr = `[...truncated...]\\n` + stderr.slice(-maxLen);
+    let result = `${statusEmoji} **Task ${task.id}**${task.label ? ` (${task.label})` : ""}
+| Command | \`${task.command}\` |
+| Status | ${statusEmoji} **${task.status.toUpperCase()}** |
+| Duration | ${duration3}${task.status === STATUS_LABEL.RUNNING ? " (ongoing)" : ""} |
+${task.exitCode !== null ? `| Exit Code | ${task.exitCode} |` : ""}`;
+    if (output.trim()) result += `
+
+\u{1F4E4} **stdout:**
+\`\`\`
+${output.trim()}
+\`\`\``;
+    if (stderr.trim()) result += `
+
+\u26A0\uFE0F **stderr:**
+\`\`\`
+${stderr.trim()}
+\`\`\``;
+    if (task.status === STATUS_LABEL.RUNNING) result += `
+
+\u23F3 Still running... check again.`;
+    return result;
   }
-  async recoverActiveTasks() {
-    const tasks = await taskWAL.readAll();
-    if (tasks.size === 0) return;
-    log(`Attempting to recover ${tasks.size} tasks from WAL...`);
-    let recoveredCount = 0;
-    for (const task of tasks.values()) {
-      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 {
-        }
-      } else {
-      }
+});
+
+// src/tools/background-cmd/list.ts
+var listBackgroundTool = tool({
+  description: `List all background tasks and their status.`,
+  args: {
+    status: tool.schema.enum([
+      FILTER_STATUS.ALL,
+      BACKGROUND_STATUS.RUNNING,
+      BACKGROUND_STATUS.DONE,
+      BACKGROUND_STATUS.ERROR
+    ]).optional().describe("Filter by status")
+  },
+  async execute(args) {
+    const { status = FILTER_STATUS.ALL } = args;
+    let tasks;
+    if (status === FILTER_STATUS.ALL) {
+      tasks = backgroundTaskManager.getAll();
+    } else {
+      tasks = backgroundTaskManager.getByStatus(status);
     }
-    if (recoveredCount > 0) {
-      log(`Recovered ${recoveredCount} active tasks.`);
-      this.poller.start();
+    if (tasks.length === 0) {
+      return `No background tasks${status !== FILTER_STATUS.ALL ? ` with status "${status}"` : ""}`;
+    }
+    tasks.sort((a, b) => b.startTime - a.startTime);
+    const rows = tasks.map((t) => {
+      const indicator = backgroundTaskManager.getStatusEmoji(t.status);
+      const cmd = t.command.length > 25 ? t.command.slice(0, 22) + "..." : t.command;
+      const label = t.label ? ` [${t.label}]` : "";
+      return `| \`${t.id}\` | ${indicator} ${t.status} | ${cmd}${label} | ${backgroundTaskManager.formatDuration(t)} |`;
+    }).join("\n");
+    const running = tasks.filter((t) => t.status === BACKGROUND_STATUS.RUNNING).length;
+    const done = tasks.filter((t) => t.status === BACKGROUND_STATUS.DONE).length;
+    const error45 = tasks.filter((t) => t.status === BACKGROUND_STATUS.ERROR || t.status === BACKGROUND_STATUS.TIMEOUT).length;
+    return `Background Tasks (${tasks.length})
+Running: ${running} | Done: ${done} | Error: ${error45}
+
+| ID | Status | Command | Duration |
+|----|--------|---------|----------|
+${rows}`;
+  }
+});
+
+// src/tools/background-cmd/kill.ts
+var killBackgroundTool = tool({
+  description: `Kill a running background task.`,
+  args: {
+    taskId: tool.schema.string().describe("Task ID to kill")
+  },
+  async execute(args) {
+    const { taskId } = args;
+    const task = backgroundTaskManager.get(taskId);
+    if (!task) return `\u274C Task \`${taskId}\` not found.`;
+    if (task.status !== STATUS_LABEL.RUNNING) return `\u26A0\uFE0F Task \`${taskId}\` is not running (${task.status}).`;
+    const killed = backgroundTaskManager.kill(taskId);
+    if (killed) {
+      return `\u{1F6D1} Task \`${taskId}\` killed.
+Command: \`${task.command}\`
+Duration: ${backgroundTaskManager.formatDuration(task)}`;
     }
+    return `\u26A0\uFE0F Could not kill task \`${taskId}\`.`;
   }
-};
-var parallelAgentManager = {
-  getInstance: ParallelAgentManager.getInstance.bind(ParallelAgentManager)
-};
+});
 
 // src/tools/parallel/delegate-task.ts
 var MIN_IDLE_TIME_MS = PARALLEL_TASK.MIN_IDLE_TIME_MS;