opencode-orchestrator 0.5.4 → 0.5.6

package/dist/index.js

@@ -4,19 +4,13 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// src/shared/contracts/names.ts
+// src/shared/agent.ts
 var AGENT_NAMES = {
-  // Core Agents (5)
   COMMANDER: "commander",
-  // Orchestrator - ReAct loop controller
   ARCHITECT: "architect",
-  // Planner + Strategist - Plan-and-Execute
   BUILDER: "builder",
-  // Coder + Visualist combined (full-stack)
   INSPECTOR: "inspector",
-  // Reviewer + Fixer combined (quality + fix)
   RECORDER: "recorder"
-  // Persistent context - saves/loads session state
 };
 
 // src/agents/orchestrator.ts
@@ -33,13 +27,6 @@ You are Commander. Complete missions autonomously. Never stop until done.
 3. Never stop because agent returned nothing
 4. Always survey environment & codebase BEFORE coding
 5. Always verify with evidence based on runtime context
-6. LANGUAGE:
-   - THINK and REASON in English for maximum stability
-   - FINAL REPORT: Detect the user's language from their request and respond in the SAME language
-   - If user writes in Korean \u2192 Report in Korean
-   - If user writes in English \u2192 Report in English
-   - If user writes in Japanese \u2192 Report in Japanese
-   - Default to English if language is unclear
 </core_rules>
 
 <phase_0 name="TRIAGE">
@@ -229,7 +216,7 @@ You are Architect. Break complex tasks into atomic pieces.
 </role>
 
 <constraints>
-Reasoning MUST be in English for model stability.
+
 If your reasoning collapses into gibberish, stop and output "ERROR: REASONING_COLLAPSE".
 </constraints>
 
@@ -291,7 +278,7 @@ You are Builder. Write code that works.
 </role>
 
 <constraints>
-Reasoning MUST be in English for model stability.
+
 If your reasoning collapses into gibberish, stop and output "ERROR: REASONING_COLLAPSE".
 </constraints>
 
@@ -357,7 +344,7 @@ You are Inspector. Prove failure or success with evidence.
 </role>
 
 <constraints>
-Reasoning MUST be in English for model stability.
+
 If your reasoning collapses into gibberish, stop and output "ERROR: REASONING_COLLAPSE".
 </constraints>
 
@@ -424,7 +411,7 @@ You are Recorder. Save and load work progress.
 </role>
 
 <constraints>
-Reasoning MUST be in English for model stability.
+
 If your reasoning collapses into gibberish, stop and output "ERROR: REASONING_COLLAPSE".
 </constraints>
 
@@ -491,7 +478,7 @@ var AGENTS = {
   [AGENT_NAMES.RECORDER]: recorder
 };
 
-// src/core/tasks.ts
+// src/core/orchestrator/task-graph.ts
 var TaskGraph = class _TaskGraph {
   tasks = /* @__PURE__ */ new Map();
   constructor(tasks) {
@@ -532,7 +519,7 @@ var TaskGraph = class _TaskGraph {
     const notCompleted = tasks.filter((t) => t.status !== "completed");
     let summary = "\u{1F4CB} **Mission Status**\n";
     if (completed.length > 0) {
-      summary += `\u2705 Completed: ${completed.length} tasks (Hidden to save tokens)
+      summary += `\u2705 Completed: ${completed.length} tasks
 `;
     }
     for (const task of notCompleted) {
@@ -549,18 +536,16 @@ var TaskGraph = class _TaskGraph {
     try {
       const tasks = JSON.parse(json2);
       return new _TaskGraph(tasks);
-    } catch (e) {
-      console.error("Failed to parse TaskGraph JSON:", e);
+    } catch {
       return new _TaskGraph();
     }
   }
 };
 
-// src/core/state.ts
+// src/core/orchestrator/state.ts
 var state = {
   missionActive: false,
   maxIterations: 1e3,
-  // Effectively infinite - "Relentless" mode
   maxRetries: 3,
   sessions: /* @__PURE__ */ new Map()
 };
@@ -13068,10 +13053,6 @@ var COMMANDS = {
 You are Commander. Complete this mission. Never stop until 100% done.
 </role>
 
-<constraints>
-Reasoning MUST be in English for model stability. Final report in Korean.
-</constraints>
-
 <phase_1 name="MANDATORY_ENVIRONMENT_SCAN">
 Before any planning or coding, you MUST understand:
 1. INFRA: OS-native? Container? Docker-compose? Volume-mounted?
@@ -13289,44 +13270,71 @@ var globSearchTool = (directory) => tool({
   }
 });
 var mgrepTool = (directory) => tool({
-  description: `Search multiple patterns in parallel (high-performance).
-
-<purpose>
-Search for multiple regex patterns simultaneously using Rust's parallel execution.
-Much faster than running grep multiple times sequentially.
-</purpose>
-
-<examples>
-- patterns: ["useState", "useEffect", "useContext"] \u2192 Find all React hooks usage
-- patterns: ["TODO", "FIXME", "HACK"] \u2192 Find all code annotations
-- patterns: ["import.*lodash", "require.*lodash"] \u2192 Find all lodash imports
-</examples>
-
-<output>
-Returns matches grouped by pattern, with file paths and line numbers.
-</output>`,
+  description: `Search multiple patterns (runs grep for each pattern).`,
   args: {
-    patterns: tool.schema.array(tool.schema.string()).describe("Array of regex patterns to search for"),
-    dir: tool.schema.string().optional().describe("Directory to search (defaults to project root)"),
-    max_results_per_pattern: tool.schema.number().optional().describe("Max results per pattern (default: 50)")
+    patterns: tool.schema.array(tool.schema.string()).describe("Array of regex patterns"),
+    dir: tool.schema.string().optional().describe("Directory (defaults to project root)")
   },
   async execute(args) {
-    return callRustTool("mgrep", {
-      patterns: args.patterns,
-      directory: args.dir || directory,
-      max_results_per_pattern: args.max_results_per_pattern || 50
-    });
+    const results = {};
+    const dir = args.dir || directory;
+    for (const pattern of args.patterns) {
+      const result = await callRustTool("grep_search", { pattern, directory: dir });
+      results[pattern] = result;
+    }
+    return JSON.stringify(results, null, 2);
   }
 });
 
-// src/core/background.ts
+// src/core/commands/manager.ts
 import { spawn as spawn2 } from "child_process";
 import { randomBytes } from "crypto";
+
+// src/shared/constants.ts
+var TIME = {
+  SECOND: 1e3,
+  MINUTE: 60 * 1e3,
+  HOUR: 60 * 60 * 1e3
+};
+var ID_PREFIX = {
+  /** Parallel agent task ID (e.g., task_a1b2c3d4) */
+  TASK: "task_",
+  /** Background command job ID (e.g., job_a1b2c3d4) */
+  JOB: "job_",
+  /** Session ID prefix */
+  SESSION: "session_"
+};
+var PARALLEL_TASK = {
+  TTL_MS: 30 * TIME.MINUTE,
+  CLEANUP_DELAY_MS: 5 * TIME.MINUTE,
+  MIN_STABILITY_MS: 5 * TIME.SECOND,
+  POLL_INTERVAL_MS: 2e3,
+  DEFAULT_CONCURRENCY: 3,
+  MAX_CONCURRENCY: 10
+};
+var BACKGROUND_TASK = {
+  DEFAULT_TIMEOUT_MS: 5 * TIME.MINUTE,
+  MAX_OUTPUT_LENGTH: 1e4
+};
+var STATUS_EMOJI = {
+  pending: "\u23F3",
+  running: "\u{1F504}",
+  completed: "\u2705",
+  done: "\u2705",
+  error: "\u274C",
+  timeout: "\u23F0",
+  cancelled: "\u{1F6AB}"
+};
+function getStatusEmoji(status) {
+  return STATUS_EMOJI[status] ?? "\u2753";
+}
+
+// src/core/commands/manager.ts
 var BackgroundTaskManager = class _BackgroundTaskManager {
   static _instance;
   tasks = /* @__PURE__ */ new Map();
-  debugMode = true;
-  // Enable debug mode
+  debugMode = process.env.DEBUG_BG_TASK === "true";
+  // Disabled by default
   constructor() {
   }
   static get instance() {
@@ -13335,25 +13343,15 @@ var BackgroundTaskManager = class _BackgroundTaskManager {
     }
     return _BackgroundTaskManager._instance;
   }
-  /**
-   * Generate a unique task ID in the format job_xxxxxxxx
-   */
   generateId() {
-    const hex3 = randomBytes(4).toString("hex");
-    return `job_${hex3}`;
+    return `${ID_PREFIX.JOB}${randomBytes(4).toString("hex")}`;
   }
-  /**
-   * Debug logging helper
-   */
   debug(taskId, message) {
     if (this.debugMode) {
-      const timestamp = (/* @__PURE__ */ new Date()).toISOString().substring(11, 23);
-      console.log(`[BG-DEBUG ${timestamp}] ${taskId}: ${message}`);
+      const ts = (/* @__PURE__ */ new Date()).toISOString().substring(11, 23);
+      console.log(`[BG ${ts}] ${taskId}: ${message}`);
     }
   }
-  /**
-   * Run a command in the background
-   */
   run(options) {
     const id = this.generateId();
     const { command, cwd = process.cwd(), timeout = 3e5, label } = options;
@@ -13374,7 +13372,7 @@ var BackgroundTaskManager = class _BackgroundTaskManager {
       timeout
     };
     this.tasks.set(id, task);
-    this.debug(id, `Starting: ${command} (cwd: ${cwd})`);
+    this.debug(id, `Starting: ${command}`);
     try {
       const proc = spawn2(shell, task.args, {
         cwd,
@@ -13383,22 +13381,17 @@ var BackgroundTaskManager = class _BackgroundTaskManager {
       });
       task.process = proc;
       proc.stdout?.on("data", (data) => {
-        const text = data.toString();
-        task.output += text;
-        this.debug(id, `stdout: ${text.substring(0, 100)}${text.length > 100 ? "..." : ""}`);
+        task.output += data.toString();
       });
       proc.stderr?.on("data", (data) => {
-        const text = data.toString();
-        task.errorOutput += text;
-        this.debug(id, `stderr: ${text.substring(0, 100)}${text.length > 100 ? "..." : ""}`);
+        task.errorOutput += data.toString();
       });
       proc.on("close", (code) => {
         task.exitCode = code;
         task.endTime = Date.now();
         task.status = code === 0 ? "done" : "error";
         task.process = void 0;
-        const duration3 = ((task.endTime - task.startTime) / 1e3).toFixed(2);
-        this.debug(id, `Completed with code ${code} in ${duration3}s`);
+        this.debug(id, `Done (code=${code})`);
       });
       proc.on("error", (err) => {
         task.status = "error";
@@ -13406,47 +13399,31 @@ var BackgroundTaskManager = class _BackgroundTaskManager {
 Process error: ${err.message}`;
         task.endTime = Date.now();
         task.process = void 0;
-        this.debug(id, `Error: ${err.message}`);
       });
       setTimeout(() => {
         if (task.status === "running" && task.process) {
-          this.debug(id, `Timeout after ${timeout}ms, killing process`);
           task.process.kill("SIGKILL");
           task.status = "timeout";
           task.endTime = Date.now();
-          task.errorOutput += `
-Process killed: timeout after ${timeout}ms`;
+          this.debug(id, "Timeout");
         }
       }, timeout);
     } catch (err) {
       task.status = "error";
-      task.errorOutput = `Failed to spawn: ${err instanceof Error ? err.message : String(err)}`;
+      task.errorOutput = `Spawn failed: ${err instanceof Error ? err.message : String(err)}`;
       task.endTime = Date.now();
-      this.debug(id, `Spawn failed: ${task.errorOutput}`);
     }
     return task;
   }
-  /**
-   * Get task by ID
-   */
   get(taskId) {
     return this.tasks.get(taskId);
   }
-  /**
-   * Get all tasks
-   */
   getAll() {
     return Array.from(this.tasks.values());
   }
-  /**
-   * Get tasks by status
-   */
   getByStatus(status) {
     return this.getAll().filter((t) => t.status === status);
   }
-  /**
-   * Clear completed/failed tasks
-   */
   clearCompleted() {
     let count = 0;
     for (const [id, task] of this.tasks) {
@@ -13457,9 +13434,6 @@ Process killed: timeout after ${timeout}ms`;
     }
     return count;
   }
-  /**
-   * Kill a running task
-   */
   kill(taskId) {
     const task = this.tasks.get(taskId);
     if (task?.process) {
@@ -13467,72 +13441,35 @@ Process killed: timeout after ${timeout}ms`;
       task.status = "error";
       task.errorOutput += "\nKilled by user";
       task.endTime = Date.now();
-      this.debug(taskId, "Killed by user");
       return true;
     }
     return false;
   }
-  /**
-   * Format duration for display
-   */
   formatDuration(task) {
     const end = task.endTime || Date.now();
     const seconds = (end - task.startTime) / 1e3;
-    if (seconds < 60) {
-      return `${seconds.toFixed(1)}s`;
-    }
-    const minutes = Math.floor(seconds / 60);
-    const remainingSeconds = seconds % 60;
-    return `${minutes}m ${remainingSeconds.toFixed(0)}s`;
+    if (seconds < 60) return `${seconds.toFixed(1)}s`;
+    return `${Math.floor(seconds / 60)}m ${(seconds % 60).toFixed(0)}s`;
   }
-  /**
-   * Get status emoji
-   */
   getStatusEmoji(status) {
-    switch (status) {
-      case "pending":
-        return "\u23F8\uFE0F";
-      case "running":
-        return "\u23F3";
-      case "done":
-        return "\u2705";
-      case "error":
-        return "\u274C";
-      case "timeout":
-        return "\u23F0";
-      default:
-        return "\u2753";
-    }
+    return getStatusEmoji(status);
   }
 };
 var backgroundTaskManager = BackgroundTaskManager.instance;
 
-// src/tools/background.ts
+// 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, etc.) without blocking.
-The command runs asynchronously - use check_background to get results.
-</purpose>
-
-<examples>
-- "npm run build" \u2192 Build project in background
-- "cargo test" \u2192 Run Rust tests
-- "sleep 10 && echo done" \u2192 Delayed execution
-</examples>
-
-<flow>
-1. Call run_background with command
-2. Get task ID immediately (e.g., job_a1b2c3d4)
-3. Continue other work
-4. Call check_background with task ID to get results
-</flow>`,
+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 (default: project root)"),
-    timeout: tool.schema.number().optional().describe("Timeout in milliseconds (default: 300000 = 5 min)"),
-    label: tool.schema.string().optional().describe("Human-readable label for this task")
+    cwd: tool.schema.string().optional().describe("Working directory"),
+    timeout: tool.schema.number().optional().describe("Timeout in ms (default: 300000)"),
+    label: tool.schema.string().optional().describe("Task label")
   },
   async execute(args) {
     const { command, cwd, timeout, label } = args;
@@ -13544,36 +13481,20 @@ The command runs asynchronously - use check_background to get results.
     });
     const displayLabel = label ? ` (${label})` : "";
     return `\u{1F680} **Background Task Started**${displayLabel}
-\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501
-| Property | Value |
-|----------|-------|
-| **Task ID** | \`${task.id}\` |
-| **Command** | \`${command}\` |
-| **Status** | ${backgroundTaskManager.getStatusEmoji(task.status)} ${task.status} |
-| **Working Dir** | ${task.cwd} |
-| **Timeout** | ${(task.timeout / 1e3).toFixed(0)}s |
-\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501
+| Task ID | \`${task.id}\` |
+| Command | \`${command}\` |
+| Status | ${backgroundTaskManager.getStatusEmoji(task.status)} ${task.status} |
 
-\u{1F4CC} **Next Step**: Use \`check_background\` with task ID \`${task.id}\` to get results.`;
+\u{1F4CC} Use \`check_background({ taskId: "${task.id}" })\` to get results.`;
   }
 });
-var checkBackgroundTool = tool({
-  description: `Check the status and output of a background task.
-
-<purpose>
-Retrieve the current status and output of a previously started background task.
-Use this after run_background to get results.
-</purpose>
 
-<output_includes>
-- Status: running/done/error/timeout
-- Exit code (if completed)
-- Duration
-- Full output (stdout + stderr)
-</output_includes>`,
+// 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 (e.g., job_a1b2c3d4)"),
-    tailLines: tool.schema.number().optional().describe("Limit output to last N lines (default: show all)")
+    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;
@@ -13586,7 +13507,7 @@ Use this after run_background to get results.
       const taskList = allTasks.map((t) => `- \`${t.id}\`: ${t.command.substring(0, 30)}...`).join("\n");
       return `\u274C Task \`${taskId}\` not found.
 
-**Available tasks:**
+**Available:**
 ${taskList}`;
     }
     const duration3 = backgroundTaskManager.formatDuration(task);
@@ -13594,64 +13515,41 @@ ${taskList}`;
     let output = task.output;
     let stderr = task.errorOutput;
     if (tailLines && tailLines > 0) {
-      const outputLines = output.split("\n");
-      const stderrLines = stderr.split("\n");
-      output = outputLines.slice(-tailLines).join("\n");
-      stderr = stderrLines.slice(-tailLines).join("\n");
+      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 ${output.length - maxLen} chars...]
-` + output.substring(output.length - maxLen);
-    }
-    if (stderr.length > maxLen) {
-      stderr = `[...truncated ${stderr.length - maxLen} chars...]
-` + stderr.substring(stderr.length - maxLen);
-    }
-    const labelDisplay = task.label ? ` (${task.label})` : "";
-    let result = `${statusEmoji} **Task ${task.id}**${labelDisplay}
-\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501
-| Property | Value |
-|----------|-------|
-| **Command** | \`${task.command}\` |
-| **Status** | ${statusEmoji} **${task.status.toUpperCase()}** |
-| **Duration** | ${duration3}${task.status === "running" ? " (ongoing)" : ""} |
-${task.exitCode !== null ? `| **Exit Code** | ${task.exitCode} |` : ""}
-\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501`;
-    if (output.trim()) {
-      result += `
-
-\u{1F4E4} **Output (stdout)**:
+    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 === "running" ? " (ongoing)" : ""} |
+${task.exitCode !== null ? `| Exit Code | ${task.exitCode} |` : ""}`;
+    if (output.trim()) result += `
+
+\u{1F4E4} **stdout:**
 \`\`\`
 ${output.trim()}
 \`\`\``;
-    }
-    if (stderr.trim()) {
-      result += `
+    if (stderr.trim()) result += `
 
-\u26A0\uFE0F **Errors (stderr)**:
+\u26A0\uFE0F **stderr:**
 \`\`\`
 ${stderr.trim()}
 \`\`\``;
-    }
-    if (task.status === "running") {
-      result += `
+    if (task.status === "running") result += `
 
-\u23F3 Task still running... Check again later with:
-\`check_background({ taskId: "${task.id}" })\``;
-    }
+\u23F3 Still running... check again.`;
     return result;
   }
 });
-var listBackgroundTool = tool({
-  description: `List all background tasks and their current status.
 
-<purpose>
-Get an overview of all running and completed background tasks.
-Useful to check what's in progress before starting new tasks.
-</purpose>`,
+// src/tools/background-cmd/list.ts
+var listBackgroundTool = tool({
+  description: `List all background tasks and their status.`,
   args: {
-    status: tool.schema.enum(["all", "running", "done", "error"]).optional().describe("Filter by status (default: all)")
+    status: tool.schema.enum(["all", "running", "done", "error"]).optional().describe("Filter by status")
   },
   async execute(args) {
     const { status = "all" } = args;
@@ -13662,91 +13560,102 @@ Useful to check what's in progress before starting new tasks.
       tasks = backgroundTaskManager.getByStatus(status);
     }
     if (tasks.length === 0) {
-      return `\u{1F4CB} **No background tasks** ${status !== "all" ? `with status "${status}"` : ""}
-
-Use \`run_background\` to start a new background task.`;
+      return `\u{1F4CB} No background tasks${status !== "all" ? ` with status "${status}"` : ""}`;
     }
     tasks.sort((a, b) => b.startTime - a.startTime);
-    const rows = tasks.map((task) => {
-      const emoji3 = backgroundTaskManager.getStatusEmoji(task.status);
-      const duration3 = backgroundTaskManager.formatDuration(task);
-      const cmdShort = task.command.length > 25 ? task.command.substring(0, 22) + "..." : task.command;
-      const labelPart = task.label ? ` [${task.label}]` : "";
-      return `| \`${task.id}\` | ${emoji3} ${task.status.padEnd(7)} | ${cmdShort.padEnd(25)}${labelPart} | ${duration3.padStart(8)} |`;
+    const rows = tasks.map((t) => {
+      const emoji3 = 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}\` | ${emoji3} ${t.status} | ${cmd}${label} | ${backgroundTaskManager.formatDuration(t)} |`;
     }).join("\n");
-    const runningCount = tasks.filter((t) => t.status === "running").length;
-    const doneCount = tasks.filter((t) => t.status === "done").length;
-    const errorCount = tasks.filter((t) => t.status === "error" || t.status === "timeout").length;
-    return `\u{1F4CB} **Background Tasks** (${tasks.length} total)
-\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501
-| \u23F3 Running: ${runningCount} | \u2705 Done: ${doneCount} | \u274C Error/Timeout: ${errorCount} |
-\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501
-
-| Task ID | Status | Command | Duration |
-|---------|--------|---------|----------|
-${rows}
+    const running = tasks.filter((t) => t.status === "running").length;
+    const done = tasks.filter((t) => t.status === "done").length;
+    const error45 = tasks.filter((t) => t.status === "error" || t.status === "timeout").length;
+    return `\u{1F4CB} **Background Tasks** (${tasks.length})
+\u23F3 Running: ${running} | \u2705 Done: ${done} | \u274C Error: ${error45}
 
-\u{1F4A1} Use \`check_background({ taskId: "job_xxxxx" })\` to see full output.`;
+| ID | Status | Command | Duration |
+|----|--------|---------|----------|
+${rows}`;
   }
 });
-var killBackgroundTool = tool({
-  description: `Kill a running background task.
 
-<purpose>
-Stop a background task that is taking too long or no longer needed.
-</purpose>`,
+// 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 (e.g., job_a1b2c3d4)")
+    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 !== "running") {
-      return `\u26A0\uFE0F Task \`${taskId}\` is not running (status: ${task.status}).`;
-    }
+    if (!task) return `\u274C Task \`${taskId}\` not found.`;
+    if (task.status !== "running") return `\u26A0\uFE0F Task \`${taskId}\` is not running (${task.status}).`;
     const killed = backgroundTaskManager.kill(taskId);
     if (killed) {
-      return `\u{1F6D1} Task \`${taskId}\` has been killed.
+      return `\u{1F6D1} Task \`${taskId}\` killed.
 Command: \`${task.command}\`
-Duration before kill: ${backgroundTaskManager.formatDuration(task)}`;
+Duration: ${backgroundTaskManager.formatDuration(task)}`;
     }
-    return `\u26A0\uFE0F Could not kill task \`${taskId}\`. It may have already finished.`;
+    return `\u26A0\uFE0F Could not kill task \`${taskId}\`.`;
   }
 });
 
-// src/core/async-agent.ts
-var TASK_TTL_MS = 30 * 60 * 1e3;
-var CLEANUP_DELAY_MS = 5 * 60 * 1e3;
-var MIN_STABILITY_MS = 5 * 1e3;
-var POLL_INTERVAL_MS = 2e3;
-var DEFAULT_CONCURRENCY = 3;
+// src/core/agents/concurrency.ts
 var DEBUG = process.env.DEBUG_PARALLEL_AGENT === "true";
 var log = (...args) => {
-  if (DEBUG) console.log("[parallel-agent]", ...args);
+  if (DEBUG) console.log("[concurrency]", ...args);
 };
 var ConcurrencyController = class {
   counts = /* @__PURE__ */ new Map();
   queues = /* @__PURE__ */ new Map();
   limits = /* @__PURE__ */ new Map();
+  config;
+  constructor(config2) {
+    this.config = config2 ?? {};
+  }
   setLimit(key, limit) {
     this.limits.set(key, limit);
   }
+  /**
+   * 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;
+  }
+  // Backwards compatible alias
   getLimit(key) {
-    return this.limits.get(key) ?? DEFAULT_CONCURRENCY;
+    return this.getConcurrencyLimit(key);
   }
   async acquire(key) {
-    const limit = this.getLimit(key);
-    if (limit === 0) return;
+    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);
-      log(`Acquired slot for ${key}: ${current + 1}/${limit}`);
+      log(`Acquired ${key}: ${current + 1}/${limit}`);
       return;
     }
-    log(`Queueing for ${key}: ${current}/${limit} (waiting...)`);
+    log(`Queueing ${key}: ${current}/${limit}`);
     return new Promise((resolve) => {
       const queue = this.queues.get(key) ?? [];
       queue.push(resolve);
@@ -13754,41 +13663,168 @@ var ConcurrencyController = class {
     });
   }
   release(key) {
-    const limit = this.getLimit(key);
-    if (limit === 0) return;
+    const limit = this.getConcurrencyLimit(key);
+    if (limit === Infinity) return;
     const queue = this.queues.get(key);
     if (queue && queue.length > 0) {
       const next = queue.shift();
-      log(`Released slot for ${key}: next in queue`);
+      log(`Released ${key}: next in queue`);
       next();
     } else {
       const current = this.counts.get(key) ?? 0;
       if (current > 0) {
         this.counts.set(key, current - 1);
-        log(`Released slot for ${key}: ${current - 1}`);
+        log(`Released ${key}: ${current - 1}/${limit}`);
       }
     }
   }
   getQueueLength(key) {
     return this.queues.get(key)?.length ?? 0;
   }
+  getActiveCount(key) {
+    return this.counts.get(key) ?? 0;
+  }
+  /**
+   * 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)`;
+  }
 };
-var ParallelAgentManager = class _ParallelAgentManager {
-  static _instance;
-  // Core state
+
+// src/core/agents/task-store.ts
+var TaskStore = class {
   tasks = /* @__PURE__ */ new Map();
   pendingByParent = /* @__PURE__ */ new Map();
   notifications = /* @__PURE__ */ new Map();
-  // Dependencies
+  set(id, task) {
+    this.tasks.set(id, task);
+  }
+  get(id) {
+    return this.tasks.get(id);
+  }
+  getAll() {
+    return Array.from(this.tasks.values());
+  }
+  getRunning() {
+    return this.getAll().filter((t) => t.status === "running");
+  }
+  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 pending = this.pendingByParent.get(parentSessionID) ?? /* @__PURE__ */ new Set();
+    pending.add(taskId);
+    this.pendingByParent.set(parentSessionID, pending);
+  }
+  untrackPending(parentSessionID, taskId) {
+    const pending = this.pendingByParent.get(parentSessionID);
+    if (pending) {
+      pending.delete(taskId);
+      if (pending.size === 0) {
+        this.pendingByParent.delete(parentSessionID);
+      }
+    }
+  }
+  getPendingCount(parentSessionID) {
+    return this.pendingByParent.get(parentSessionID)?.size ?? 0;
+  }
+  hasPending(parentSessionID) {
+    return this.getPendingCount(parentSessionID) > 0;
+  }
+  // Notifications
+  queueNotification(task) {
+    const queue = this.notifications.get(task.parentSessionID) ?? [];
+    queue.push(task);
+    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);
+      }
+    }
+  }
+  /**
+   * Remove a specific task from all notification queues
+   */
+  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);
+      }
+    }
+  }
+};
+
+// 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/logger.ts
+var DEBUG2 = process.env.DEBUG_PARALLEL_AGENT === "true";
+function log2(...args) {
+  if (DEBUG2) console.log("[parallel-agent]", ...args);
+}
+
+// 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 === "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/agents/manager.ts
+var ParallelAgentManager = class _ParallelAgentManager {
+  static _instance;
+  store = new TaskStore();
   client;
   directory;
-  concurrency;
-  // Polling
+  concurrency = new ConcurrencyController();
   pollingInterval;
   constructor(client, directory) {
     this.client = client;
     this.directory = directory;
-    this.concurrency = new ConcurrencyController();
   }
   static getInstance(client, directory) {
     if (!_ParallelAgentManager._instance) {
@@ -13802,29 +13838,21 @@ var ParallelAgentManager = class _ParallelAgentManager {
   // ========================================================================
   // Public API
   // ========================================================================
-  /**
-   * Launch an agent in a new session (async, non-blocking)
-   */
   async launch(input) {
     const concurrencyKey = input.agent;
     await this.concurrency.acquire(concurrencyKey);
     this.pruneExpiredTasks();
     try {
       const createResult = await this.client.session.create({
-        body: {
-          parentID: input.parentSessionID,
-          title: `Parallel: ${input.description}`
-        },
-        query: {
-          directory: this.directory
-        }
+        body: { parentID: input.parentSessionID, title: `Parallel: ${input.description}` },
+        query: { directory: this.directory }
       });
       if (createResult.error) {
         this.concurrency.release(concurrencyKey);
         throw new Error(`Failed to create session: ${createResult.error}`);
       }
       const sessionID = createResult.data.id;
-      const taskId = `task_${crypto.randomUUID().slice(0, 8)}`;
+      const taskId = `${ID_PREFIX.TASK}${crypto.randomUUID().slice(0, 8)}`;
       const task = {
         id: taskId,
         sessionID,
@@ -13835,171 +13863,172 @@ var ParallelAgentManager = class _ParallelAgentManager {
         startedAt: /* @__PURE__ */ new Date(),
         concurrencyKey
       };
-      this.tasks.set(taskId, task);
-      this.trackPending(input.parentSessionID, taskId);
+      this.store.set(taskId, task);
+      this.store.trackPending(input.parentSessionID, taskId);
       this.startPolling();
       this.client.session.prompt({
         path: { id: sessionID },
-        body: {
-          agent: input.agent,
-          parts: [{ type: "text", text: input.prompt }]
-        }
+        body: { agent: input.agent, parts: [{ type: "text", text: input.prompt }] }
       }).catch((error45) => {
-        log(`Prompt error for ${taskId}:`, error45);
+        log2(`Prompt error for ${taskId}:`, error45);
         this.handleTaskError(taskId, error45);
       });
-      log(`Launched ${taskId} in session ${sessionID}`);
+      log2(`Launched ${taskId} in session ${sessionID}`);
       return task;
     } catch (error45) {
       this.concurrency.release(concurrencyKey);
       throw error45;
     }
   }
-  /**
-   * Get task by ID
-   */
   getTask(id) {
-    return this.tasks.get(id);
+    return this.store.get(id);
   }
-  /**
-   * Get all running tasks
-   */
   getRunningTasks() {
-    return Array.from(this.tasks.values()).filter((t) => t.status === "running");
+    return this.store.getRunning();
   }
-  /**
-   * Get all tasks
-   */
   getAllTasks() {
-    return Array.from(this.tasks.values());
+    return this.store.getAll();
   }
-  /**
-   * Get tasks by parent session
-   */
   getTasksByParent(parentSessionID) {
-    return Array.from(this.tasks.values()).filter((t) => t.parentSessionID === parentSessionID);
+    return this.store.getByParent(parentSessionID);
   }
-  /**
-   * Cancel a running task
-   */
   async cancelTask(taskId) {
-    const task = this.tasks.get(taskId);
-    if (!task || task.status !== "running") {
-      return false;
-    }
+    const task = this.store.get(taskId);
+    if (!task || task.status !== "running") return false;
     task.status = "error";
     task.error = "Cancelled by user";
     task.completedAt = /* @__PURE__ */ new Date();
-    if (task.concurrencyKey) {
-      this.concurrency.release(task.concurrencyKey);
-    }
-    this.untrackPending(task.parentSessionID, taskId);
+    if (task.concurrencyKey) this.concurrency.release(task.concurrencyKey);
+    this.store.untrackPending(task.parentSessionID, taskId);
     try {
-      await this.client.session.delete({
-        path: { id: task.sessionID }
-      });
-      console.log(`[parallel] \u{1F5D1}\uFE0F Session ${task.sessionID.slice(0, 8)}... deleted`);
+      await this.client.session.delete({ path: { id: task.sessionID } });
+      log2(`Session ${task.sessionID.slice(0, 8)}... deleted`);
     } catch {
-      console.log(`[parallel] \u{1F5D1}\uFE0F Session ${task.sessionID.slice(0, 8)}... already gone`);
+      log2(`Session ${task.sessionID.slice(0, 8)}... already gone`);
     }
     this.scheduleCleanup(taskId);
-    console.log(`[parallel] \u{1F6D1} CANCELLED ${taskId}`);
-    log(`Cancelled ${taskId}`);
+    log2(`Cancelled ${taskId}`);
     return true;
   }
-  /**
-   * Get result from completed task
-   */
   async getResult(taskId) {
-    const task = this.tasks.get(taskId);
+    const task = this.store.get(taskId);
     if (!task) return null;
     if (task.result) return task.result;
     if (task.status === "error") return `Error: ${task.error}`;
     if (task.status === "running") return null;
     try {
-      const messagesResult = await this.client.session.messages({
-        path: { id: task.sessionID }
-      });
-      if (messagesResult.error) {
-        return `Error: ${messagesResult.error}`;
-      }
-      const messages = messagesResult.data ?? [];
-      const assistantMsgs = messages.filter((m) => m.info?.role === "assistant").reverse();
-      const lastMsg = assistantMsgs[0];
+      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 === "assistant").reverse()[0];
       if (!lastMsg) return "(No response)";
-      const textParts = lastMsg.parts?.filter(
-        (p) => p.type === "text" || p.type === "reasoning"
-      ) ?? [];
-      const result = textParts.map((p) => p.text ?? "").filter(Boolean).join("\n");
-      task.result = result;
-      return result;
+      const text = lastMsg.parts?.filter((p) => p.type === "text" || p.type === "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)}`;
     }
   }
-  /**
-   * Set concurrency limit for agent type
-   */
   setConcurrencyLimit(agentType, limit) {
     this.concurrency.setLimit(agentType, limit);
   }
-  /**
-   * Get pending notification count
-   */
   getPendingCount(parentSessionID) {
-    return this.pendingByParent.get(parentSessionID)?.size ?? 0;
+    return this.store.getPendingCount(parentSessionID);
   }
-  /**
-   * Cleanup all state
-   */
   cleanup() {
     this.stopPolling();
-    this.tasks.clear();
-    this.pendingByParent.clear();
-    this.notifications.clear();
+    this.store.clear();
   }
+  formatDuration = formatDuration;
   // ========================================================================
-  // Internal: Tracking
+  // Event Handling (from OpenCode hooks)
   // ========================================================================
-  trackPending(parentSessionID, taskId) {
-    const pending = this.pendingByParent.get(parentSessionID) ?? /* @__PURE__ */ new Set();
-    pending.add(taskId);
-    this.pendingByParent.set(parentSessionID, pending);
-  }
-  untrackPending(parentSessionID, taskId) {
-    const pending = this.pendingByParent.get(parentSessionID);
-    if (pending) {
-      pending.delete(taskId);
-      if (pending.size === 0) {
-        this.pendingByParent.delete(parentSessionID);
+  /**
+   * Handle OpenCode session events for proper resource cleanup.
+   * Call this from your plugin's event hook.
+   */
+  handleEvent(event) {
+    const props = event.properties;
+    if (event.type === "session.idle") {
+      const sessionID = props?.sessionID;
+      if (!sessionID) return;
+      const task = this.findBySession(sessionID);
+      if (!task || task.status !== "running") return;
+      this.handleSessionIdle(task).catch((err) => {
+        log2("Error handling session.idle:", err);
+      });
+    }
+    if (event.type === "session.deleted") {
+      const sessionID = props?.info?.id ?? props?.sessionID;
+      if (!sessionID) return;
+      const task = this.findBySession(sessionID);
+      if (!task) return;
+      log2(`Session deleted event for task ${task.id}`);
+      if (task.status === "running") {
+        task.status = "error";
+        task.error = "Session deleted";
+        task.completedAt = /* @__PURE__ */ new Date();
+      }
+      if (task.concurrencyKey) {
+        this.concurrency.release(task.concurrencyKey);
+        task.concurrencyKey = void 0;
       }
+      this.store.untrackPending(task.parentSessionID, task.id);
+      this.store.clearNotificationsForTask(task.id);
+      this.store.delete(task.id);
+      log2(`Cleaned up deleted session task: ${task.id}`);
     }
   }
+  /**
+   * Find task by session ID
+   */
+  findBySession(sessionID) {
+    return this.store.getAll().find((t) => t.sessionID === sessionID);
+  }
+  /**
+   * Handle session.idle event - validate and complete task
+   */
+  async handleSessionIdle(task) {
+    const elapsed = Date.now() - task.startedAt.getTime();
+    if (elapsed < CONFIG.MIN_STABILITY_MS) {
+      log2(`Session idle but too early for ${task.id}, waiting...`);
+      return;
+    }
+    const hasOutput = await this.validateSessionHasOutput(task.sessionID);
+    if (!hasOutput) {
+      log2(`Session idle but no output for ${task.id}, waiting...`);
+      return;
+    }
+    task.status = "completed";
+    task.completedAt = /* @__PURE__ */ new Date();
+    if (task.concurrencyKey) {
+      this.concurrency.release(task.concurrencyKey);
+      task.concurrencyKey = void 0;
+    }
+    this.store.untrackPending(task.parentSessionID, task.id);
+    this.store.queueNotification(task);
+    await this.notifyParentIfAllComplete(task.parentSessionID);
+    this.scheduleCleanup(task.id);
+    log2(`Task ${task.id} completed via session.idle event (${formatDuration(task.startedAt, task.completedAt)})`);
+  }
   // ========================================================================
-  // Internal: Error Handling
+  // Internal
   // ========================================================================
   handleTaskError(taskId, error45) {
-    const task = this.tasks.get(taskId);
+    const task = this.store.get(taskId);
     if (!task) return;
     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.untrackPending(task.parentSessionID, taskId);
-    this.queueNotification(task);
+    if (task.concurrencyKey) this.concurrency.release(task.concurrencyKey);
+    this.store.untrackPending(task.parentSessionID, taskId);
+    this.store.queueNotification(task);
     this.notifyParentIfAllComplete(task.parentSessionID);
     this.scheduleCleanup(taskId);
   }
-  // ========================================================================
-  // Internal: Polling
-  // ========================================================================
   startPolling() {
     if (this.pollingInterval) return;
-    this.pollingInterval = setInterval(() => {
-      this.pollRunningTasks();
-    }, POLL_INTERVAL_MS);
+    this.pollingInterval = setInterval(() => this.pollRunningTasks(), CONFIG.POLL_INTERVAL_MS);
     this.pollingInterval.unref();
   }
   stopPolling() {
@@ -14010,211 +14039,183 @@ var ParallelAgentManager = class _ParallelAgentManager {
   }
   async pollRunningTasks() {
     this.pruneExpiredTasks();
-    const runningTasks = this.getRunningTasks();
-    if (runningTasks.length === 0) {
+    const running = this.store.getRunning();
+    if (running.length === 0) {
       this.stopPolling();
       return;
     }
     try {
       const statusResult = await this.client.session.status();
       const allStatuses = statusResult.data ?? {};
-      for (const task of runningTasks) {
-        const sessionStatus = allStatuses[task.sessionID];
-        if (sessionStatus?.type === "idle") {
+      for (const task of running) {
+        try {
+          const sessionStatus = allStatuses[task.sessionID];
+          if (sessionStatus?.type === "idle") {
+            const elapsed2 = Date.now() - task.startedAt.getTime();
+            if (elapsed2 < CONFIG.MIN_STABILITY_MS) continue;
+            if (!await this.validateSessionHasOutput(task.sessionID)) continue;
+            await this.completeTask(task);
+            continue;
+          }
+          await this.updateTaskProgress(task);
           const elapsed = Date.now() - task.startedAt.getTime();
-          if (elapsed < MIN_STABILITY_MS) continue;
-          const hasOutput = await this.validateSessionHasOutput(task.sessionID);
-          if (!hasOutput) continue;
-          task.status = "completed";
-          task.completedAt = /* @__PURE__ */ new Date();
-          if (task.concurrencyKey) {
-            this.concurrency.release(task.concurrencyKey);
+          if (elapsed >= CONFIG.MIN_STABILITY_MS && task.stablePolls && task.stablePolls >= 3) {
+            if (await this.validateSessionHasOutput(task.sessionID)) {
+              log2(`Task ${task.id} stable for 3 polls, completing...`);
+              await this.completeTask(task);
+            }
           }
-          this.untrackPending(task.parentSessionID, task.id);
-          this.queueNotification(task);
-          this.notifyParentIfAllComplete(task.parentSessionID);
-          this.scheduleCleanup(task.id);
-          const duration3 = this.formatDuration(task.startedAt, task.completedAt);
-          console.log(`[parallel] \u2705 COMPLETED ${task.id} \u2192 ${task.agent}: ${task.description} (${duration3})`);
-          log(`Completed ${task.id}`);
+        } catch (error45) {
+          log2(`Poll error for task ${task.id}:`, error45);
         }
       }
     } catch (error45) {
-      log("Polling error:", error45);
+      log2("Polling error:", error45);
     }
   }
-  // ========================================================================
-  // Internal: Validation
-  // ========================================================================
+  /**
+   * Update task progress and stability tracking
+   */
+  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 === "assistant");
+      let toolCalls = 0;
+      let lastTool;
+      let lastMessage;
+      for (const msg of assistantMsgs) {
+        for (const part of msg.parts ?? []) {
+          if (part.type === "tool_use" || part.tool) {
+            toolCalls++;
+            lastTool = part.tool || part.name;
+          }
+          if (part.type === "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 {
+    }
+  }
+  /**
+   * Complete a task and cleanup
+   */
+  async completeTask(task) {
+    task.status = "completed";
+    task.completedAt = /* @__PURE__ */ new Date();
+    if (task.concurrencyKey) {
+      this.concurrency.release(task.concurrencyKey);
+      task.concurrencyKey = void 0;
+    }
+    this.store.untrackPending(task.parentSessionID, task.id);
+    this.store.queueNotification(task);
+    await this.notifyParentIfAllComplete(task.parentSessionID);
+    this.scheduleCleanup(task.id);
+    log2(`Completed ${task.id} (${formatDuration(task.startedAt, task.completedAt)})`);
+  }
   async validateSessionHasOutput(sessionID) {
     try {
-      const response = await this.client.session.messages({
-        path: { id: sessionID }
-      });
+      const response = await this.client.session.messages({ path: { id: sessionID } });
       const messages = response.data ?? [];
-      const hasContent = messages.some((m) => {
-        if (m.info?.role !== "assistant") return false;
-        const parts = m.parts ?? [];
-        return parts.some(
-          (p) => p.type === "text" && p.text?.trim() || p.type === "reasoning" && p.text?.trim() || p.type === "tool"
-        );
-      });
-      return hasContent;
+      return messages.some((m) => m.info?.role === "assistant" && m.parts?.some((p) => p.type === "text" && p.text?.trim() || p.type === "tool"));
     } catch {
       return true;
     }
   }
-  // ========================================================================
-  // Internal: Cleanup & TTL
-  // ========================================================================
   pruneExpiredTasks() {
     const now = Date.now();
-    for (const [taskId, task] of this.tasks.entries()) {
+    for (const [taskId, task] of this.store.getAll().map((t) => [t.id, t])) {
       const age = now - task.startedAt.getTime();
-      if (age > TASK_TTL_MS) {
-        log(`Timeout: ${taskId} (${Math.round(age / 1e3)}s)`);
-        if (task.status === "running") {
-          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.untrackPending(task.parentSessionID, taskId);
-          console.log(`[parallel] \u23F1\uFE0F TIMEOUT ${taskId} \u2192 ${task.agent}: ${task.description}`);
-        }
-        this.client.session.delete({
-          path: { id: task.sessionID }
-        }).then(() => {
-          console.log(`[parallel] \u{1F5D1}\uFE0F CLEANED ${taskId} (timeout session deleted)`);
-        }).catch(() => {
-          console.log(`[parallel] \u{1F5D1}\uFE0F CLEANED ${taskId} (timeout session already gone)`);
-        });
-        this.tasks.delete(taskId);
-      }
-    }
-    for (const [sessionID, queue] of this.notifications.entries()) {
-      if (queue.length === 0) {
-        this.notifications.delete(sessionID);
-      }
+      if (age <= CONFIG.TASK_TTL_MS) continue;
+      log2(`Timeout: ${taskId}`);
+      if (task.status === "running") {
+        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);
+      }
+      this.client.session.delete({ path: { id: task.sessionID } }).catch(() => {
+      });
+      this.store.delete(taskId);
     }
+    this.store.cleanEmptyNotifications();
   }
   scheduleCleanup(taskId) {
-    const task = this.tasks.get(taskId);
+    const task = this.store.get(taskId);
     const sessionID = task?.sessionID;
     setTimeout(async () => {
       if (sessionID) {
         try {
-          await this.client.session.delete({
-            path: { id: sessionID }
-          });
-          console.log(`[parallel] \u{1F5D1}\uFE0F CLEANED ${taskId} (session deleted)`);
-          log(`Deleted session ${sessionID}`);
+          await this.client.session.delete({ path: { id: sessionID } });
         } catch {
-          console.log(`[parallel] \u{1F5D1}\uFE0F CLEANED ${taskId} (session already gone)`);
         }
       }
-      this.tasks.delete(taskId);
-      log(`Cleaned up ${taskId} from memory`);
-    }, CLEANUP_DELAY_MS);
-  }
-  // ========================================================================
-  // Internal: Notifications
-  // ========================================================================
-  queueNotification(task) {
-    const queue = this.notifications.get(task.parentSessionID) ?? [];
-    queue.push(task);
-    this.notifications.set(task.parentSessionID, queue);
+      this.store.delete(taskId);
+      log2(`Cleaned up ${taskId}`);
+    }, CONFIG.CLEANUP_DELAY_MS);
   }
   async notifyParentIfAllComplete(parentSessionID) {
-    const pending = this.pendingByParent.get(parentSessionID);
-    if (pending && pending.size > 0) {
-      log(`${pending.size} tasks still pending for ${parentSessionID}`);
-      return;
-    }
-    const completedTasks = this.notifications.get(parentSessionID) ?? [];
-    if (completedTasks.length === 0) return;
-    const summary = completedTasks.map((t) => {
-      const status = t.status === "completed" ? "\u2705" : "\u274C";
-      return `${status} \`${t.id}\`: ${t.description}`;
-    }).join("\n");
-    const notification = `<system-notification>
-**All Parallel Tasks Complete**
-
-${summary}
-
-Use \`get_task_result({ taskId: "task_xxx" })\` to retrieve results.
-</system-notification>`;
+    if (this.store.hasPending(parentSessionID)) return;
+    const notifications = this.store.getNotifications(parentSessionID);
+    if (notifications.length === 0) return;
+    const message = buildNotificationMessage(notifications);
     try {
       await this.client.session.prompt({
         path: { id: parentSessionID },
-        body: {
-          noReply: true,
-          parts: [{ type: "text", text: notification }]
-        }
+        body: { noReply: true, parts: [{ type: "text", text: message }] }
       });
-      log(`Notified parent ${parentSessionID}: ${completedTasks.length} tasks`);
+      log2(`Notified parent ${parentSessionID}`);
     } catch (error45) {
-      log("Notification error:", error45);
+      log2("Notification error:", error45);
     }
-    this.notifications.delete(parentSessionID);
-  }
-  // ========================================================================
-  // Internal: Formatting
-  // ========================================================================
-  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`;
+    this.store.clearNotifications(parentSessionID);
   }
 };
 var parallelAgentManager = {
   getInstance: ParallelAgentManager.getInstance.bind(ParallelAgentManager)
 };
 
-// src/tools/async-agent.ts
+// src/tools/parallel/delegate-task.ts
 var createDelegateTaskTool = (manager, client) => tool({
   description: `Delegate a task to an agent.
 
 <mode>
-- background=true: Non-blocking. Task runs in parallel session. Use get_task_result later.
-- background=false: Blocking. Waits for result. Use when you need output immediately.
+- background=true: Non-blocking. Returns task ID immediately.
+- background=false: Blocking. Waits for result.
 </mode>
 
-<when_to_use_background_true>
-- Multiple independent tasks to run in parallel
-- Long-running tasks (build, test, analysis)
-- You have other work to do while waiting
-- Example: "Build module A" + "Test module B" in parallel
-</when_to_use_background_true>
-
-<when_to_use_background_false>
-- You need the result for the very next step
-- Single task with nothing else to do
-- Quick questions that return fast
-</when_to_use_background_false>
-
 <safety>
-- Max 3 background tasks per agent type (extras queue automatically)
+- Max 3 tasks per agent type
 - Auto-timeout: 30 minutes
-- Auto-cleanup: 5 minutes after completion
 </safety>`,
   args: {
-    agent: tool.schema.string().describe("Agent name (e.g., 'builder', 'inspector', 'architect')"),
-    description: tool.schema.string().describe("Short task description"),
-    prompt: tool.schema.string().describe("Full prompt/instructions for the agent"),
-    background: tool.schema.boolean().describe("true=async (returns task_id), false=sync (waits for result). REQUIRED.")
+    agent: tool.schema.string().describe("Agent name"),
+    description: tool.schema.string().describe("Task description"),
+    prompt: tool.schema.string().describe("Prompt for the agent"),
+    background: tool.schema.boolean().describe("true=async, false=sync")
   },
   async execute(args, context) {
     const { agent, description, prompt, background } = args;
     const ctx = context;
     const sessionClient = client;
     if (background === void 0) {
-      return `\u274C 'background' parameter is REQUIRED.
-- background=true: Run in parallel, returns task ID
-- background=false: Wait for result (blocking)`;
+      return `\u274C 'background' parameter is REQUIRED.`;
     }
     if (background === true) {
       try {
@@ -14224,178 +14225,84 @@ var createDelegateTaskTool = (manager, client) => tool({
           prompt,
           parentSessionID: ctx.sessionID
         });
-        const runningCount = manager.getRunningTasks().length;
-        const pendingCount = manager.getPendingCount(ctx.sessionID);
-        console.log(`[parallel] \u{1F680} SPAWNED ${task.id} \u2192 ${agent}: ${description}`);
-        return `
-\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557
-\u2551  \u{1F680} BACKGROUND TASK SPAWNED                                   \u2551
-\u2560\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2563
-\u2551  Task ID:     ${task.id.padEnd(45)}\u2551
-\u2551  Agent:       ${task.agent.padEnd(45)}\u2551
-\u2551  Description: ${task.description.slice(0, 45).padEnd(45)}\u2551
-\u2551  Status:      \u23F3 RUNNING (background)                          \u2551
-\u2560\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2563
-\u2551  Running: ${String(runningCount).padEnd(5)} \u2502 Pending: ${String(pendingCount).padEnd(5)}                      \u2551
-\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D
-
-\u{1F4CC} Continue your work! System notifies when ALL complete.
-\u{1F50D} Use \`get_task_result({ taskId: "${task.id}" })\` later.`;
+        return `\u{1F680} Task spawned: \`${task.id}\` (${agent})`;
       } catch (error45) {
-        const message = error45 instanceof Error ? error45.message : String(error45);
-        console.log(`[parallel] \u274C FAILED: ${message}`);
-        return `\u274C Failed to spawn background task: ${message}`;
+        return `\u274C Failed: ${error45 instanceof Error ? error45.message : String(error45)}`;
       }
     }
-    console.log(`[delegate] \u23F3 SYNC ${agent}: ${description}`);
     try {
       const session = sessionClient.session;
-      const directory = ".";
       const createResult = await session.create({
-        body: {
-          parentID: ctx.sessionID,
-          title: `Task: ${description}`
-        },
-        query: { directory }
+        body: { parentID: ctx.sessionID, title: `Task: ${description}` },
+        query: { directory: "." }
       });
       if (createResult.error || !createResult.data?.id) {
-        return `\u274C Failed to create session: ${createResult.error || "No session ID"}`;
+        return `\u274C Failed to create session`;
       }
       const sessionID = createResult.data.id;
       const startTime = Date.now();
-      try {
-        await session.prompt({
-          path: { id: sessionID },
-          body: {
-            agent,
-            parts: [{ type: "text", text: prompt }]
-          }
-        });
-      } catch (promptError) {
-        const errorMessage = promptError instanceof Error ? promptError.message : String(promptError);
-        return `\u274C Failed to send prompt: ${errorMessage}
-
-Session ID: ${sessionID}`;
-      }
-      const POLL_INTERVAL_MS2 = 500;
-      const MAX_POLL_TIME_MS = 10 * 60 * 1e3;
-      const MIN_STABILITY_MS2 = 5e3;
-      const STABILITY_POLLS_REQUIRED = 3;
-      let stablePolls = 0;
-      let lastMsgCount = 0;
-      while (Date.now() - startTime < MAX_POLL_TIME_MS) {
-        await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS2));
+      await session.prompt({
+        path: { id: sessionID },
+        body: { agent, parts: [{ type: "text", text: prompt }] }
+      });
+      let stablePolls = 0, lastMsgCount = 0;
+      while (Date.now() - startTime < 10 * 60 * 1e3) {
+        await new Promise((r) => setTimeout(r, 500));
         const statusResult = await session.status();
-        const allStatuses = statusResult.data ?? {};
-        const sessionStatus = allStatuses[sessionID];
-        if (sessionStatus?.type !== "idle") {
+        if (statusResult.data?.[sessionID]?.type !== "idle") {
           stablePolls = 0;
-          lastMsgCount = 0;
           continue;
         }
-        if (Date.now() - startTime < MIN_STABILITY_MS2) continue;
-        const messagesResult2 = await session.messages({ path: { id: sessionID } });
-        const messages2 = messagesResult2.data ?? [];
-        const currentMsgCount = messages2.length;
-        if (currentMsgCount === lastMsgCount) {
+        if (Date.now() - startTime < 5e3) continue;
+        const msgs2 = await session.messages({ path: { id: sessionID } });
+        const count = (msgs2.data ?? []).length;
+        if (count === lastMsgCount) {
           stablePolls++;
-          if (stablePolls >= STABILITY_POLLS_REQUIRED) break;
+          if (stablePolls >= 3) break;
         } else {
           stablePolls = 0;
-          lastMsgCount = currentMsgCount;
+          lastMsgCount = count;
         }
       }
-      const messagesResult = await session.messages({ path: { id: sessionID } });
-      const messages = messagesResult.data ?? [];
-      const assistantMsgs = messages.filter((m) => m.info?.role === "assistant").reverse();
-      const lastMsg = assistantMsgs[0];
-      if (!lastMsg) {
-        return `\u274C No assistant response found.
+      const msgs = await session.messages({ path: { id: sessionID } });
+      const messages = msgs.data ?? [];
+      const lastMsg = messages.filter((m) => m.info?.role === "assistant").reverse()[0];
+      const text = lastMsg?.parts?.filter((p) => p.type === "text" || p.type === "reasoning").map((p) => p.text ?? "").join("\n") || "";
+      return `\u2705 Completed (${Math.floor((Date.now() - startTime) / 1e3)}s)
 
-Session ID: ${sessionID}`;
-      }
-      const textParts = lastMsg.parts?.filter(
-        (p) => p.type === "text" || p.type === "reasoning"
-      ) ?? [];
-      const textContent = textParts.map((p) => p.text ?? "").filter(Boolean).join("\n");
-      const duration3 = Math.floor((Date.now() - startTime) / 1e3);
-      console.log(`[delegate] \u2705 COMPLETED ${agent}: ${description} (${duration3}s)`);
-      return `\u2705 **Task Completed** (${duration3}s)
-
-Agent: ${agent}
-Session ID: ${sessionID}
-
----
-
-${textContent || "(No text output)"}`;
+${text || "(No output)"}`;
     } catch (error45) {
-      const message = error45 instanceof Error ? error45.message : String(error45);
-      console.log(`[delegate] \u274C FAILED: ${message}`);
-      return `\u274C Task failed: ${message}`;
+      return `\u274C Failed: ${error45 instanceof Error ? error45.message : String(error45)}`;
     }
   }
 });
-var createGetTaskResultTool = (manager) => tool({
-  description: `Get the result from a completed background task.
 
-<note>
-If the task is still running, returns status info.
-Wait for the "All Complete" notification before checking.
-</note>`,
+// src/tools/parallel/get-task-result.ts
+var createGetTaskResultTool = (manager) => tool({
+  description: `Get result from a completed background task.`,
   args: {
-    taskId: tool.schema.string().describe("Task ID from delegate_task (e.g., 'task_a1b2c3d4')")
+    taskId: tool.schema.string().describe("Task ID")
   },
   async execute(args) {
-    const { taskId } = args;
-    const task = manager.getTask(taskId);
-    if (!task) {
-      return `\u274C Task not found: \`${taskId}\`
-
-Use \`list_tasks\` to see available tasks.`;
-    }
-    if (task.status === "running") {
-      const elapsed = Math.floor((Date.now() - task.startedAt.getTime()) / 1e3);
-      return `\u23F3 **Task Still Running**
-
-| Property | Value |
-|----------|-------|
-| **Task ID** | \`${taskId}\` |
-| **Agent** | ${task.agent} |
-| **Elapsed** | ${elapsed}s |
-
-Wait for "All Complete" notification, then try again.`;
-    }
-    const result = await manager.getResult(taskId);
+    const task = manager.getTask(args.taskId);
+    if (!task) return `\u274C Task not found: \`${args.taskId}\``;
+    if (task.status === "running") return `\u23F3 Still running...`;
+    const result = await manager.getResult(args.taskId);
     const duration3 = manager.formatDuration(task.startedAt, task.completedAt);
     if (task.status === "error" || task.status === "timeout") {
-      return `\u274C **Task ${task.status === "timeout" ? "Timed Out" : "Failed"}**
-
-| Property | Value |
-|----------|-------|
-| **Task ID** | \`${taskId}\` |
-| **Agent** | ${task.agent} |
-| **Error** | ${task.error} |
-| **Duration** | ${duration3} |`;
+      return `\u274C ${task.status}: ${task.error}`;
     }
-    return `\u2705 **Task Completed**
-
-| Property | Value |
-|----------|-------|
-| **Task ID** | \`${taskId}\` |
-| **Agent** | ${task.agent} |
-| **Duration** | ${duration3} |
-
----
-
-**Result:**
+    return `\u2705 Completed (${duration3})
 
 ${result || "(No output)"}`;
   }
 });
+
+// src/tools/parallel/list-tasks.ts
 var createListTasksTool = (manager) => tool({
-  description: `List all background tasks and their status.`,
+  description: `List all background tasks.`,
   args: {
-    status: tool.schema.string().optional().describe("Filter: 'all', 'running', 'completed', 'error'")
+    status: tool.schema.string().optional().describe("Filter: all, running, completed, error")
   },
   async execute(args) {
     const { status = "all" } = args;
@@ -14413,73 +14320,35 @@ var createListTasksTool = (manager) => tool({
       default:
         tasks = manager.getAllTasks();
     }
-    if (tasks.length === 0) {
-      return `\u{1F4CB} No background tasks found${status !== "all" ? ` (filter: ${status})` : ""}.
-
-Use \`delegate_task({ ..., background: true })\` to spawn background tasks.`;
-    }
-    const runningCount = manager.getRunningTasks().length;
-    const completedCount = manager.getAllTasks().filter((t) => t.status === "completed").length;
-    const errorCount = manager.getAllTasks().filter((t) => t.status === "error" || t.status === "timeout").length;
-    const statusIcon = (s) => {
-      switch (s) {
-        case "running":
-          return "\u23F3";
-        case "completed":
-          return "\u2705";
-        case "error":
-          return "\u274C";
-        case "timeout":
-          return "\u23F1\uFE0F";
-        default:
-          return "\u2753";
-      }
-    };
+    if (tasks.length === 0) return `\u{1F4CB} No tasks found.`;
     const rows = tasks.map((t) => {
       const elapsed = Math.floor((Date.now() - t.startedAt.getTime()) / 1e3);
-      const desc = t.description.length > 25 ? t.description.slice(0, 22) + "..." : t.description;
-      return `| \`${t.id}\` | ${statusIcon(t.status)} ${t.status} | ${t.agent} | ${desc} | ${elapsed}s |`;
+      return `| \`${t.id}\` | ${getStatusEmoji(t.status)} ${t.status} | ${t.agent} | ${elapsed}s |`;
     }).join("\n");
-    return `\u{1F4CB} **Background Tasks** (${tasks.length} shown)
-\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501
-| \u23F3 Running: ${runningCount} | \u2705 Completed: ${completedCount} | \u274C Error: ${errorCount} |
-\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501
+    return `\u{1F4CB} **Tasks**
 
-| Task ID | Status | Agent | Description | Elapsed |
-|---------|--------|-------|-------------|---------|
-${rows}
-
-\u{1F4A1} Use \`get_task_result({ taskId: "task_xxx" })\` to get results.
-\u{1F6D1} Use \`cancel_task({ taskId: "task_xxx" })\` to stop a running task.`;
+| ID | Status | Agent | Time |
+|----|--------|-------|------|
+${rows}`;
   }
 });
-var createCancelTaskTool = (manager) => tool({
-  description: `Cancel a running background task.
 
-<purpose>
-Stop a runaway or no-longer-needed task.
-Frees up concurrency slot for other tasks.
-</purpose>`,
+// src/tools/parallel/cancel-task.ts
+var createCancelTaskTool = (manager) => tool({
+  description: `Cancel a running task.`,
   args: {
-    taskId: tool.schema.string().describe("Task ID to cancel (e.g., 'task_a1b2c3d4')")
+    taskId: tool.schema.string().describe("Task ID to cancel")
   },
   async execute(args) {
-    const { taskId } = args;
-    const cancelled = await manager.cancelTask(taskId);
-    if (cancelled) {
-      return `\u{1F6D1} **Task Cancelled**
-
-Task \`${taskId}\` has been stopped. Concurrency slot released.`;
-    }
-    const task = manager.getTask(taskId);
-    if (task) {
-      return `\u26A0\uFE0F Cannot cancel: Task \`${taskId}\` is ${task.status} (not running).`;
-    }
-    return `\u274C Task \`${taskId}\` not found.
-
-Use \`list_tasks\` to see available tasks.`;
+    const cancelled = await manager.cancelTask(args.taskId);
+    if (cancelled) return `\u{1F6D1} Cancelled: \`${args.taskId}\``;
+    const task = manager.getTask(args.taskId);
+    if (task) return `\u26A0\uFE0F Cannot cancel: Task is ${task.status}`;
+    return `\u274C Not found: \`${args.taskId}\``;
   }
 });
+
+// src/tools/parallel/index.ts
 function createAsyncAgentTools(manager, client) {
   return {
     delegate_task: createDelegateTaskTool(manager, client),
@@ -14978,6 +14847,11 @@ ${stateSession.graph.getTaskSummary()}`;
     // Event handler - cleans up when sessions are deleted
     // -----------------------------------------------------------------
     handler: async ({ event }) => {
+      try {
+        const manager = ParallelAgentManager.getInstance();
+        manager.handleEvent(event);
+      } catch {
+      }
       if (event.type === "session.deleted") {
         const props = event.properties;
         if (props?.info?.id) {