opencode-orchestrator 1.0.65 → 1.0.72

package/dist/index.js

@@ -14,13 +14,13 @@ __export(store_exports, {
   addDecision: () => addDecision,
   addDocument: () => addDocument,
   addFinding: () => addFinding,
-  clear: () => clear,
+  clear: () => clear2,
   clearAll: () => clearAll,
   create: () => create,
   get: () => get,
   getChildren: () => getChildren,
   getMerged: () => getMerged,
-  getStats: () => getStats
+  getStats: () => getStats2
 });
 function create(sessionId, parentId) {
   const context = {
@@ -88,7 +88,7 @@ function addDecision(sessionId, decision) {
 function getChildren(parentId) {
   return Array.from(parentChildMap.get(parentId) || []);
 }
-function clear(sessionId) {
+function clear2(sessionId) {
   const context = contexts.get(sessionId);
   if (context?.parentId) {
     parentChildMap.get(context.parentId)?.delete(sessionId);
@@ -99,7 +99,7 @@ function clearAll() {
   contexts.clear();
   parentChildMap.clear();
 }
-function getStats() {
+function getStats2() {
   let totalDocuments = 0;
   let totalFindings = 0;
   let totalDecisions = 0;
@@ -133,6 +133,7 @@ var AGENT_NAMES = {
   PLANNER: "Planner",
   WORKER: "Worker",
   REVIEWER: "Reviewer"
+  // Unit Review & Final Quality Gate (Conceptual Master)
 };
 
 // src/shared/agent/constants/agent-tokens.ts
@@ -194,7 +195,10 @@ var PATHS = {
   SYNC_ISSUES: ".opencode/sync-issues.md",
   INTEGRATION_STATUS: ".opencode/integration-status.md",
   // Progress tracking
-  STATUS: ".opencode/status.md"
+  STATUS: ".opencode/status.md",
+  // Configuration
+  AGENTS_CONFIG: ".opencode/agents.json",
+  PLUGINS: ".opencode/plugins"
 };
 
 // src/shared/core/constants/memory-limits.ts
@@ -314,6 +318,132 @@ var PHASES = {
   }
 };
 
+// src/shared/tool/constants/tool-names.ts
+var TOOL_NAMES = {
+  // Parallel task tools
+  DELEGATE_TASK: "delegate_task",
+  GET_TASK_RESULT: "get_task_result",
+  LIST_TASKS: "list_tasks",
+  CANCEL_TASK: "cancel_task",
+  LIST_AGENTS: "list_agents",
+  SHOW_METRICS: "show_metrics",
+  UPDATE_TODO: "update_todo",
+  // Background command tools
+  RUN_BACKGROUND: "run_background",
+  CHECK_BACKGROUND: "check_background",
+  LIST_BACKGROUND: "list_background",
+  KILL_BACKGROUND: "kill_background",
+  // Command tools
+  RUN_COMMAND: "run_command",
+  // Search tools
+  GREP_SEARCH: "grep_search",
+  GLOB_SEARCH: "glob_search",
+  MGREP: "mgrep",
+  SED_REPLACE: "sed_replace",
+  // Diff & Compare tools
+  DIFF: "diff",
+  // JSON tools
+  JQ: "jq",
+  // HTTP tools
+  HTTP: "http",
+  // File tools
+  FILE_STATS: "file_stats",
+  // Git tools
+  GIT_DIFF: "git_diff",
+  GIT_STATUS: "git_status",
+  // Web tools
+  WEBFETCH: "webfetch",
+  WEBSEARCH: "websearch",
+  CODESEARCH: "codesearch",
+  CACHE_DOCS: "cache_docs",
+  // LSP tools
+  LSP_DIAGNOSTICS: "lsp_diagnostics",
+  // AST tools
+  AST_SEARCH: "ast_search",
+  AST_REPLACE: "ast_replace",
+  // Other tools
+  CALL_AGENT: "call_agent",
+  SLASHCOMMAND: "slashcommand",
+  SKILL: "skill"
+};
+
+// src/shared/core/constants/memory-hooks.ts
+var MEMORY_CONSTANTS = {
+  ID_PREFIX: "mem_",
+  LEVELS: {
+    SYSTEM: "system",
+    PROJECT: "project",
+    MISSION: "mission",
+    TASK: "task"
+  },
+  IMPORTANCE: {
+    LOW: 0.3,
+    NORMAL: 0.5,
+    HIGH: 0.7,
+    CRITICAL: 0.9
+  },
+  // Tools that produce high volume or irrelevant output for memory
+  NOISY_TOOLS: [
+    TOOL_NAMES.LIST_TASKS,
+    TOOL_NAMES.GET_TASK_RESULT,
+    TOOL_NAMES.LIST_BACKGROUND,
+    TOOL_NAMES.CHECK_BACKGROUND,
+    TOOL_NAMES.LIST_AGENTS,
+    TOOL_NAMES.SHOW_METRICS
+  ],
+  // Significant keywords for memory promotion
+  KEYWORDS: {
+    DONE: "DONE",
+    SUCCESS: "SUCCESS",
+    ERROR: "ERROR",
+    FAIL: "FAIL"
+  },
+  MAX_CONTENT_LENGTH: 1e3
+};
+var HOOK_NAMES = {
+  MEMORY_GATE: "MemoryGate",
+  METRICS_TELEMETRY: "MetricsTelemetry",
+  SANITY_CHECK: "SanityCheck",
+  MISSION_LOOP: "MissionLoop",
+  MISSION_CONTROL: "MissionControl",
+  STRICT_ROLE_GUARD: "StrictRoleGuard",
+  SECRET_SCANNER: "SecretScanner",
+  AGENT_UI: "AgentUI",
+  RESOURCE_CONTROL: "ResourceControl",
+  USER_ACTIVITY: "UserActivity",
+  SLASH_COMMAND: "SlashCommandDispatcher"
+};
+var TODO_CONSTANTS = {
+  MARKERS: {
+    PENDING: "[ ]",
+    COMPLETED: "[x]",
+    PROGRESS: "[/]",
+    FAILED: "[-]"
+  },
+  STATUS: {
+    PENDING: "pending",
+    COMPLETED: "completed",
+    PROGRESS: "progress",
+    FAILED: "failed"
+  }
+};
+var TUI_CONSTANTS = {
+  BAR_WIDTH: 30,
+  COLORS: {
+    PROGRESS: "\x1B[36m",
+    AGENT: "\x1B[32m",
+    RESET: "\x1B[0m",
+    BOLD: "\x1B[1m",
+    DIM: "\x1B[2m"
+  },
+  LABELS: {
+    IDLE: "Idle",
+    WAITING: "Waiting for tasks...",
+    PROGRESS_TITLE: "MISSION PROGRESS",
+    AGENT_TITLE: "ACTIVE AGENTS"
+  }
+};
+
 // src/shared/core/constants/cli.ts
 var CLI_NAME = {
   NPX: "npx",
@@ -835,52 +965,6 @@ var EVENT_TYPES = {
   ...SPECIAL_EVENTS
 };
 
-// src/shared/tool/constants/tool-names.ts
-var TOOL_NAMES = {
-  // Parallel task tools
-  DELEGATE_TASK: "delegate_task",
-  GET_TASK_RESULT: "get_task_result",
-  LIST_TASKS: "list_tasks",
-  CANCEL_TASK: "cancel_task",
-  // Background command tools
-  RUN_BACKGROUND: "run_background",
-  CHECK_BACKGROUND: "check_background",
-  LIST_BACKGROUND: "list_background",
-  KILL_BACKGROUND: "kill_background",
-  // Command tools
-  RUN_COMMAND: "run_command",
-  // Search tools
-  GREP_SEARCH: "grep_search",
-  GLOB_SEARCH: "glob_search",
-  MGREP: "mgrep",
-  SED_REPLACE: "sed_replace",
-  // Diff & Compare tools
-  DIFF: "diff",
-  // JSON tools
-  JQ: "jq",
-  // HTTP tools
-  HTTP: "http",
-  // File tools
-  FILE_STATS: "file_stats",
-  // Git tools
-  GIT_DIFF: "git_diff",
-  GIT_STATUS: "git_status",
-  // Web tools
-  WEBFETCH: "webfetch",
-  WEBSEARCH: "websearch",
-  CODESEARCH: "codesearch",
-  CACHE_DOCS: "cache_docs",
-  // LSP tools
-  LSP_DIAGNOSTICS: "lsp_diagnostics",
-  // AST tools
-  AST_SEARCH: "ast_search",
-  AST_REPLACE: "ast_replace",
-  // Other tools
-  CALL_AGENT: "call_agent",
-  SLASHCOMMAND: "slashcommand",
-  SKILL: "skill"
-};
-
 // src/shared/tool/constants/lsp/lsp-severity.ts
 var LSP_SEVERITY = {
   ERROR: 1,
@@ -2142,10 +2226,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path6) {
-  if (!path6)
+function getElementAtPath(obj, path9) {
+  if (!path9)
     return obj;
-  return path6.reduce((acc, key) => acc?.[key], obj);
+  return path9.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -2506,11 +2590,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path6, issues) {
+function prefixIssues(path9, issues) {
   return issues.map((iss) => {
     var _a;
     (_a = iss).path ?? (_a.path = []);
-    iss.path.unshift(path6);
+    iss.path.unshift(path9);
     return iss;
   });
 }
@@ -2678,7 +2762,7 @@ function treeifyError(error45, _mapper) {
     return issue2.message;
   };
   const result = { errors: [] };
-  const processError = (error46, path6 = []) => {
+  const processError = (error46, path9 = []) => {
     var _a, _b;
     for (const issue2 of error46.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -2688,7 +2772,7 @@ function treeifyError(error45, _mapper) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path6, ...issue2.path];
+        const fullpath = [...path9, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -2720,8 +2804,8 @@ function treeifyError(error45, _mapper) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path6 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path6) {
+  const path9 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path9) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -17332,141 +17416,490 @@ var TaskWAL = class {
 };
 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;
-    const tasks = await Promise.all(taskInputs.map(
-      (input) => this.prepareTask(input).catch(() => null)
-    ));
-    const successfulTasks = tasks.filter((t) => t !== null);
-    successfulTasks.forEach((task) => {
-      this.executeBackground(task).catch((error45) => {
-        this.onTaskError(task.id, error45);
-      });
-    });
-    if (successfulTasks.length > 0) {
-      this.startPolling();
+// src/core/recovery/constants.ts
+var MAX_RETRIES = RECOVERY.MAX_ATTEMPTS;
+var BASE_DELAY = RECOVERY.BASE_DELAY_MS;
+var MAX_HISTORY = HISTORY.MAX_RECOVERY;
+
+// src/core/recovery/patterns.ts
+var errorPatterns = [
+  // Rate limiting
+  {
+    pattern: /rate.?limit|too.?many.?requests|429/i,
+    category: "rate_limit",
+    handler: (ctx) => {
+      const delay = BASE_DELAY * Math.pow(2, ctx.attempt);
+      presets_exports.warningRateLimited();
+      return { type: "retry", delay, attempt: ctx.attempt + 1 };
     }
-    return isArray ? successfulTasks : successfulTasks[0] || null;
-  }
-  /**
-   * Prepare task: Create session and registration without blocking on concurrency
-   */
-  async prepareTask(input) {
-    const currentDepth = input.depth ?? 0;
-    if (currentDepth >= PARALLEL_TASK.MAX_DEPTH) {
-      throw new Error(`Maximum task depth (${PARALLEL_TASK.MAX_DEPTH}) reached. To prevent infinite recursion, no further sub-tasks can be spawned.`);
+  },
+  // Context overflow
+  {
+    pattern: /context.?length|token.?limit|maximum.?context/i,
+    category: "context_overflow",
+    handler: () => {
+      presets_exports.errorRecovery("Compacting context");
+      return { type: "compact", reason: "Context limit reached" };
     }
-    const sessionCreatePromise = this.client.session.create({
-      body: {
-        parentID: input.parentSessionID,
-        title: `${PARALLEL_TASK.SESSION_TITLE_PREFIX}: ${input.description}`
-      },
-      query: { directory: this.directory }
-    });
-    const createResult = await Promise.race([
-      sessionCreatePromise,
-      new Promise(
-        (_, reject) => setTimeout(() => reject(new Error("Session creation timed out after 60s")), 6e4)
-      )
-    ]);
-    if (createResult.error || !createResult.data?.id) {
-      throw new Error(`Session creation failed: ${createResult.error || "No ID"}`);
+  },
+  // Network errors
+  {
+    pattern: /ECONNREFUSED|ETIMEDOUT|network|fetch.?failed/i,
+    category: "network",
+    handler: (ctx) => {
+      if (ctx.attempt >= MAX_RETRIES) {
+        return { type: "abort", reason: "Network unavailable after retries" };
+      }
+      return { type: "retry", delay: BASE_DELAY * (ctx.attempt + 1), attempt: ctx.attempt + 1 };
     }
-    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
-      });
+  },
+  // Session errors
+  {
+    pattern: /session.?not.?found|session.?expired/i,
+    category: "session",
+    handler: () => {
+      return { type: "abort", reason: "Session no longer available" };
     }
-    presets_exports.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(() => {
-      });
-      const promptPromise = 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,
-            [TOOL_NAMES.SKILL]: true,
-            [TOOL_NAMES.RUN_COMMAND]: true
-          },
-          parts: [{ type: PART_TYPES.TEXT, text: task.prompt }]
-        }
-      });
-      await Promise.race([
-        promptPromise,
-        new Promise(
-          (_, reject) => setTimeout(() => reject(new Error("Session prompt execution timed out after 600s")), 6e5)
-        )
-      ]);
-    } catch (error45) {
-      this.concurrency.release(task.agent);
-      throw error45;
+  },
+  // Tool errors
+  {
+    pattern: /tool.?not.?found|unknown.?tool/i,
+    category: "tool",
+    handler: (ctx) => {
+      return { type: "escalate", to: "Reviewer", reason: `Unknown tool used by ${ctx.agent}` };
     }
-  }
-};
-
-// src/core/agents/manager/task-resumer.ts
-var TaskResumer = class {
-  constructor(client, store, findBySession, startPolling, notifyParentIfAllComplete) {
+  },
+  // Parse errors
+  {
+    pattern: /parse.?error|invalid.?json|syntax.?error/i,
+    category: "parse",
+    handler: (ctx) => {
+      if (ctx.attempt >= 2) {
+        return { type: "skip", reason: "Persistent parse error" };
+      }
+      return { type: "retry", delay: 500, attempt: ctx.attempt + 1 };
+    }
+  },
+  // Gibberish / hallucination
+  {
+    pattern: /gibberish|hallucination|mixed.?language/i,
+    category: "gibberish",
+    handler: () => {
+      presets_exports.errorRecovery("Retrying with clean context");
+      return { type: "retry", delay: 1e3, attempt: 1 };
+    }
+  },
+  // LSP specific errors
+  {
+    pattern: /lsp.?diagnostics|tsc.?error|eslint.?error/i,
+    category: "lsp",
+    handler: (ctx) => {
+      return { type: "retry", delay: 2e3, attempt: ctx.attempt + 1, modifyPrompt: "Note: Previous attempt had LSP issues. Ensure code quality and consider simpler implementation." };
+    }
+  },
+  // execution timeout
+  {
+    pattern: /execution.?timed.?out|timeout/i,
+    category: "timeout",
+    handler: (ctx) => {
+      return { type: "retry", delay: 5e3, attempt: ctx.attempt + 1, modifyPrompt: "Note: Previous attempt timed out. Break down the task into smaller sub-tasks if necessary." };
+    }
+  }
+];
+
+// src/core/recovery/handler.ts
+var recoveryHistory = [];
+function handleError(context) {
+  const errorMessage = context.error.message || String(context.error);
+  for (const pattern of errorPatterns) {
+    const matches = typeof pattern.pattern === "string" ? errorMessage.includes(pattern.pattern) : pattern.pattern.test(errorMessage);
+    if (matches) {
+      const action = pattern.handler(context);
+      recoveryHistory.push({
+        context,
+        action,
+        timestamp: /* @__PURE__ */ new Date()
+      });
+      if (recoveryHistory.length > MAX_HISTORY) {
+        recoveryHistory.shift();
+      }
+      return action;
+    }
+  }
+  if (context.attempt < MAX_RETRIES) {
+    return {
+      type: "retry",
+      delay: BASE_DELAY * Math.pow(2, context.attempt),
+      attempt: context.attempt + 1
+    };
+  }
+  return { type: "abort", reason: `Unknown error after ${MAX_RETRIES} retries` };
+}
+
+// src/core/memory/interfaces.ts
+var MemoryLevel = /* @__PURE__ */ ((MemoryLevel2) => {
+  MemoryLevel2["SYSTEM"] = "system";
+  MemoryLevel2["PROJECT"] = "project";
+  MemoryLevel2["MISSION"] = "mission";
+  MemoryLevel2["TASK"] = "task";
+  return MemoryLevel2;
+})(MemoryLevel || {});
+
+// src/core/memory/memory-manager.ts
+var MemoryManager = class _MemoryManager {
+  static instance;
+  memories = /* @__PURE__ */ new Map();
+  // id -> level mapping
+  storage = {
+    ["system" /* SYSTEM */]: [],
+    ["project" /* PROJECT */]: [],
+    ["mission" /* MISSION */]: [],
+    ["task" /* TASK */]: []
+  };
+  config = {
+    tokenBudgets: {
+      ["system" /* SYSTEM */]: 2e3,
+      ["project" /* PROJECT */]: 5e3,
+      ["mission" /* MISSION */]: 1e4,
+      ["task" /* TASK */]: 2e4
+    },
+    enableRelevanceFiltering: true
+  };
+  constructor() {
+  }
+  static getInstance() {
+    if (!_MemoryManager.instance) {
+      _MemoryManager.instance = new _MemoryManager();
+    }
+    return _MemoryManager.instance;
+  }
+  /**
+   * Add a memory entry
+   */
+  add(level, content, importance = MEMORY_CONSTANTS.IMPORTANCE.NORMAL, metadata) {
+    const id = `${MEMORY_CONSTANTS.ID_PREFIX}${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
+    const entry = {
+      id,
+      level,
+      content: content.trim(),
+      timestamp: Date.now(),
+      importance,
+      metadata
+    };
+    this.storage[level].push(entry);
+    this.memories.set(id, level);
+    this.storage[level].sort((a, b) => b.importance - a.importance || b.timestamp - a.timestamp);
+    log(`[MemoryManager] Added ${level} memory: ${id.slice(0, 10)}...`);
+    this.prune(level);
+    return id;
+  }
+  /**
+   * Retrieve memory for prompt construction
+   */
+  getContext(query) {
+    let context = "";
+    for (const level of ["system" /* SYSTEM */, "project" /* PROJECT */, "mission" /* MISSION */, "task" /* TASK */]) {
+      const entries = this.storage[level];
+      if (entries.length === 0) continue;
+      context += `
+### ${level.toUpperCase()} MEMORY
+`;
+      const filteredEntries = query && this.config.enableRelevanceFiltering ? entries.filter((e) => this.isRelevant(e, query)) : entries;
+      for (const entry of filteredEntries) {
+        context += `- [${new Date(entry.timestamp).toISOString()}] ${entry.content}
+`;
+      }
+    }
+    return context.trim();
+  }
+  /**
+   * Simple keyword-based relevance check
+   */
+  isRelevant(entry, query) {
+    if (entry.importance > 0.8) return true;
+    const q = query.toLowerCase();
+    const content = entry.content.toLowerCase();
+    const keywords = q.split(/\s+/).filter((k) => k.length > 3);
+    if (keywords.length === 0) return true;
+    return keywords.some((k) => content.includes(k));
+  }
+  /**
+   * Prune memory based on token budget (simplified)
+   */
+  prune(level) {
+    const budget = this.config.tokenBudgets[level];
+    let currentSize = this.storage[level].reduce((acc, e) => acc + e.content.length / 4, 0);
+    while (currentSize > budget && this.storage[level].length > 0) {
+      const removed = this.storage[level].pop();
+      if (removed) {
+        this.memories.delete(removed.id);
+        currentSize -= removed.content.length / 4;
+      }
+    }
+  }
+  /**
+   * Clear task memory (Short-term)
+   */
+  clearTaskMemory() {
+    for (const entry of this.storage["task" /* TASK */]) {
+      this.memories.delete(entry.id);
+    }
+    this.storage["task" /* TASK */] = [];
+    log("[MemoryManager] Task memory cleared.");
+  }
+  /**
+   * Export full memory state (for persistence)
+   */
+  export() {
+    return { ...this.storage };
+  }
+  /**
+   * Import memory state
+   */
+  import(snapshot) {
+    this.storage = snapshot;
+    this.memories.clear();
+    for (const level of Object.values(MemoryLevel)) {
+      for (const entry of this.storage[level]) {
+        this.memories.set(entry.id, level);
+      }
+    }
+  }
+};
+
+// src/core/agents/agent-registry.ts
+import * as fs4 from "fs/promises";
+import * as path4 from "path";
+var AgentRegistry = class _AgentRegistry {
+  static instance;
+  agents = /* @__PURE__ */ new Map();
+  directory = "";
+  constructor() {
+    for (const [name, def] of Object.entries(AGENTS)) {
+      this.agents.set(name, def);
+    }
+  }
+  static getInstance() {
+    if (!_AgentRegistry.instance) {
+      _AgentRegistry.instance = new _AgentRegistry();
+    }
+    return _AgentRegistry.instance;
+  }
+  setDirectory(dir) {
+    this.directory = dir;
+    this.loadCustomAgents();
+  }
+  /**
+   * Get agent definition by name
+   */
+  getAgent(name) {
+    return this.agents.get(name);
+  }
+  /**
+   * List all available agent names
+   */
+  listAgents() {
+    return Array.from(this.agents.keys());
+  }
+  /**
+   * Add or update an agent definition
+   */
+  registerAgent(name, def) {
+    this.agents.set(name, def);
+    log(`[AgentRegistry] Registered agent: ${name}`);
+  }
+  /**
+   * Load custom agents from .opencode/agents.json
+   */
+  async loadCustomAgents() {
+    if (!this.directory) return;
+    const agentsConfigPath = path4.join(this.directory, PATHS.AGENTS_CONFIG);
+    try {
+      const content = await fs4.readFile(agentsConfigPath, "utf-8");
+      const customAgents = JSON.parse(content);
+      if (typeof customAgents === "object" && customAgents !== null) {
+        for (const [name, def] of Object.entries(customAgents)) {
+          if (this.isValidAgentDefinition(def)) {
+            this.registerAgent(name, def);
+          } else {
+            log(`[AgentRegistry] Invalid custom agent definition for: ${name}`);
+          }
+        }
+      }
+    } catch (error45) {
+      if (error45.code !== "ENOENT") {
+        log(`[AgentRegistry] Error loading custom agents: ${error45}`);
+      }
+    }
+  }
+  isValidAgentDefinition(def) {
+    return typeof def.id === "string" && typeof def.description === "string" && typeof def.systemPrompt === "string" && typeof def.canWrite === "boolean" && typeof def.canBash === "boolean";
+  }
+};
+
+// src/core/agents/manager/task-launcher.ts
+var TaskLauncher = class {
+  constructor(client, directory, store, concurrency, sessionPool2, onTaskError, startPolling) {
+    this.client = client;
+    this.directory = directory;
+    this.store = store;
+    this.concurrency = concurrency;
+    this.sessionPool = sessionPool2;
+    this.onTaskError = onTaskError;
+    this.startPolling = startPolling;
+  }
+  /**
+   * Unified launch method - handles both single and multiple tasks efficiently.
+   * All session creations happen in parallel immediately.
+   * Concurrency acquisition and prompt firing happen in the background.
+   */
+  async launch(inputs) {
+    const isArray = Array.isArray(inputs);
+    const taskInputs = isArray ? inputs : [inputs];
+    if (taskInputs.length === 0) return isArray ? [] : null;
+    const tasks = await Promise.all(taskInputs.map(
+      (input) => this.prepareTask(input).catch(() => null)
+    ));
+    const successfulTasks = tasks.filter((t) => t !== null);
+    successfulTasks.forEach((task) => {
+      this.executeBackground(task).catch((error45) => {
+        this.onTaskError(task.id, error45);
+      });
+    });
+    if (successfulTasks.length > 0) {
+      this.startPolling();
+    }
+    return isArray ? successfulTasks : successfulTasks[0] || null;
+  }
+  /**
+   * Prepare task: Create session and registration without blocking on concurrency
+   */
+  async prepareTask(input) {
+    const currentDepth = input.depth ?? 0;
+    if (currentDepth >= PARALLEL_TASK.MAX_DEPTH) {
+      throw new Error(`Maximum task depth (${PARALLEL_TASK.MAX_DEPTH}) reached. To prevent infinite recursion, no further sub-tasks can be spawned.`);
+    }
+    const session = await this.sessionPool.acquire(
+      input.agent,
+      input.parentSessionID,
+      input.description
+    );
+    const sessionID = session.id;
+    const taskId = `${ID_PREFIX.TASK}${crypto.randomUUID().slice(0, 8)}`;
+    const task = {
+      id: taskId,
+      sessionID,
+      parentSessionID: input.parentSessionID,
+      description: input.description,
+      prompt: input.prompt,
+      agent: input.agent,
+      status: TASK_STATUS.PENDING,
+      // Start as PENDING
+      startedAt: /* @__PURE__ */ new Date(),
+      concurrencyKey: input.agent,
+      depth: (input.depth ?? 0) + 1,
+      mode: input.mode || "normal",
+      groupID: input.groupID
+    };
+    this.store.set(taskId, task);
+    this.store.trackPending(input.parentSessionID, taskId);
+    taskWAL.log(WAL_ACTIONS.LAUNCH, task).catch(() => {
+    });
+    const toastManager = getTaskToastManager();
+    if (toastManager) {
+      toastManager.addTask({
+        id: taskId,
+        description: input.description,
+        agent: input.agent,
+        isBackground: true,
+        parentSessionID: input.parentSessionID,
+        sessionID
+      });
+    }
+    presets_exports.sessionCreated(sessionID, input.agent);
+    return task;
+  }
+  /**
+   * Background execution: Acquire slot and fire prompt with auto-retry
+   */
+  async executeBackground(task) {
+    let attempt = 1;
+    while (true) {
+      try {
+        await this.concurrency.acquire(task.agent);
+        task.status = TASK_STATUS.RUNNING;
+        task.startedAt = /* @__PURE__ */ new Date();
+        this.store.set(task.id, task);
+        taskWAL.log(WAL_ACTIONS.LAUNCH, task).catch(() => {
+        });
+        const agentDef = AgentRegistry.getInstance().getAgent(task.agent);
+        let finalPrompt = task.prompt;
+        if (agentDef) {
+          finalPrompt = `### AGENT ROLE: ${agentDef.id}
+${agentDef.description}
+
+${agentDef.systemPrompt}
+
+${finalPrompt}`;
+        }
+        const memory = MemoryManager.getInstance().getContext(finalPrompt);
+        const injectedPrompt = memory ? `${memory}
+
+${finalPrompt}` : finalPrompt;
+        const wireAgent = Object.values(AGENT_NAMES).includes(task.agent) ? task.agent : AGENT_NAMES.COMMANDER;
+        const promptPromise = this.client.session.prompt({
+          path: { id: task.sessionID },
+          body: {
+            agent: wireAgent,
+            tools: {
+              [TOOL_NAMES.DELEGATE_TASK]: true,
+              [TOOL_NAMES.GET_TASK_RESULT]: true,
+              [TOOL_NAMES.LIST_TASKS]: true,
+              [TOOL_NAMES.CANCEL_TASK]: true,
+              [TOOL_NAMES.SKILL]: true,
+              [TOOL_NAMES.RUN_COMMAND]: true
+            },
+            parts: [{ type: PART_TYPES.TEXT, text: injectedPrompt }]
+          }
+        });
+        await Promise.race([
+          promptPromise,
+          new Promise(
+            (_, reject) => setTimeout(() => reject(new Error("Session prompt execution timed out after 600s")), 6e5)
+          )
+        ]);
+        return;
+      } catch (error45) {
+        this.concurrency.release(task.agent);
+        const context = {
+          sessionId: task.sessionID,
+          taskId: task.id,
+          agent: task.agent,
+          error: error45 instanceof Error ? error45 : new Error(String(error45)),
+          attempt,
+          timestamp: /* @__PURE__ */ new Date()
+        };
+        const action = handleError(context);
+        if (action.type === "retry") {
+          log(`[AutoRetry] Task ${task.id} failed (attempt ${attempt}). Retrying in ${action.delay}ms...`);
+          if (action.modifyPrompt) {
+            task.prompt += `
+
+${action.modifyPrompt}`;
+          }
+          await new Promise((r) => setTimeout(r, action.delay));
+          attempt++;
+          continue;
+        }
+        throw 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;
@@ -17520,6 +17953,98 @@ var CONFIG = {
   POLL_INTERVAL_MS: PARALLEL_TASK.POLL_INTERVAL_MS
 };
 
+// src/core/progress/state-broadcaster.ts
+var StateBroadcaster = class _StateBroadcaster {
+  static _instance;
+  listeners = /* @__PURE__ */ new Set();
+  currentState = null;
+  constructor() {
+  }
+  static getInstance() {
+    if (!_StateBroadcaster._instance) {
+      _StateBroadcaster._instance = new _StateBroadcaster();
+    }
+    return _StateBroadcaster._instance;
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    if (this.currentState) {
+      listener(this.currentState);
+    }
+    return () => this.listeners.delete(listener);
+  }
+  broadcast(state2) {
+    this.currentState = state2;
+    this.listeners.forEach((listener) => {
+      try {
+        listener(state2);
+      } catch (error45) {
+      }
+    });
+  }
+  getCurrentState() {
+    return this.currentState;
+  }
+};
+var stateBroadcaster = StateBroadcaster.getInstance();
+
+// src/core/progress/progress-notifier.ts
+var ProgressNotifier = class _ProgressNotifier {
+  static _instance;
+  manager = null;
+  constructor() {
+    stateBroadcaster.subscribe(this.handleStateChange.bind(this));
+  }
+  static getInstance() {
+    if (!_ProgressNotifier._instance) {
+      _ProgressNotifier._instance = new _ProgressNotifier();
+    }
+    return _ProgressNotifier._instance;
+  }
+  setManager(manager) {
+    this.manager = manager;
+  }
+  /**
+   * Poll current status from ParallelAgentManager and broadcast it
+   */
+  update() {
+    if (!this.manager) return;
+    const tasks = this.manager.getAllTasks();
+    const running = tasks.filter((t) => t.status === TASK_STATUS.RUNNING);
+    const completed = tasks.filter((t) => t.status === TASK_STATUS.COMPLETED);
+    const total = tasks.length;
+    const percentage = total > 0 ? Math.round(completed.length / total * 100) : 0;
+    const state2 = {
+      missionId: "current-mission",
+      // Could be dynamic
+      status: percentage === 100 ? "completed" : "executing",
+      progress: {
+        totalTasks: total,
+        completedTasks: completed.length,
+        percentage
+      },
+      activeAgents: running.map((t) => ({
+        id: t.id,
+        type: t.agent,
+        status: t.status,
+        currentTask: t.description
+      })),
+      todo: [],
+      // Need to fetch from TodoEnforcer if possible
+      lastUpdated: /* @__PURE__ */ new Date()
+    };
+    stateBroadcaster.broadcast(state2);
+  }
+  handleStateChange(state2) {
+    if (state2.progress.percentage > 0 && state2.progress.percentage % 25 === 0) {
+      const toastManager = getTaskToastManager();
+      if (toastManager) {
+      }
+    }
+  }
+};
+var progressNotifier = ProgressNotifier.getInstance();
+
 // src/core/agents/manager/task-poller.ts
 var TaskPoller = class {
   constructor(client, store, concurrency, notifyParentIfAllComplete, scheduleCleanup, pruneExpiredTasks, onTaskComplete) {
@@ -17581,6 +18106,7 @@ var TaskPoller = class {
           log(`Poll error for task ${task.id}:`, error45);
         }
       }
+      progressNotifier.update();
     } catch (error45) {
       log("Polling error:", error45);
     }
@@ -17619,6 +18145,7 @@ var TaskPoller = class {
     const duration3 = formatDuration(task.startedAt, task.completedAt);
     presets_exports.sessionCompleted(task.sessionID, duration3);
     log(`Completed ${task.id} (${duration3})`);
+    progressNotifier.update();
   }
   async updateTaskProgress(task) {
     try {
@@ -17661,10 +18188,11 @@ var TaskPoller = class {
 // src/core/agents/manager/task-cleaner.ts
 init_store();
 var TaskCleaner = class {
-  constructor(client, store, concurrency) {
+  constructor(client, store, concurrency, sessionPool2) {
     this.client = client;
     this.store = store;
     this.concurrency = concurrency;
+    this.sessionPool = sessionPool2;
   }
   pruneExpiredTasks() {
     const now = Date.now();
@@ -17689,9 +18217,9 @@ var TaskCleaner = class {
           });
         }
       }
-      this.client.session.delete({ path: { id: task.sessionID } }).catch(() => {
+      this.sessionPool.release(task.sessionID).catch(() => {
       });
-      clear(task.sessionID);
+      clear2(task.sessionID);
       this.store.delete(taskId);
       taskWAL.log(WAL_ACTIONS.DELETE, task).catch(() => {
       });
@@ -17704,8 +18232,8 @@ var TaskCleaner = class {
     setTimeout(async () => {
       if (sessionID) {
         try {
-          await this.client.session.delete({ path: { id: sessionID } });
-          clear(sessionID);
+          await this.sessionPool.release(sessionID);
+          clear2(sessionID);
         } catch {
         }
       }
@@ -17832,6 +18360,7 @@ var EventHandler = class {
     if (this.onTaskComplete) {
       Promise.resolve(this.onTaskComplete(task)).catch((err) => log("Error in onTaskComplete callback:", err));
     }
+    progressNotifier.update();
     log(`Task ${task.id} completed via session.idle event (${formatDuration(task.startedAt, task.completedAt)})`);
   }
   handleSessionDeleted(task) {
@@ -17851,10 +18380,378 @@ var EventHandler = class {
     this.store.delete(task.id);
     taskWAL.log(WAL_ACTIONS.DELETE, task).catch(() => {
     });
+    progressNotifier.update();
     log(`Cleaned up deleted session task: ${task.id}`);
   }
 };
 
+// src/core/agents/session-pool.ts
+var DEFAULT_CONFIG = {
+  maxPoolSizePerAgent: 5,
+  idleTimeoutMs: 3e5,
+  // 5 minutes
+  maxReuseCount: 10,
+  healthCheckIntervalMs: 6e4
+  // 1 minute
+};
+var SessionPool = class _SessionPool {
+  static _instance;
+  pool = /* @__PURE__ */ new Map();
+  // key: agentName
+  sessionsById = /* @__PURE__ */ new Map();
+  config;
+  client;
+  directory;
+  healthCheckInterval = null;
+  // Statistics
+  stats = {
+    reuseHits: 0,
+    creationMisses: 0
+  };
+  constructor(client, directory, config2 = {}) {
+    this.client = client;
+    this.directory = directory;
+    this.config = { ...DEFAULT_CONFIG, ...config2 };
+    this.startHealthCheck();
+  }
+  static getInstance(client, directory, config2) {
+    if (!_SessionPool._instance) {
+      if (!client || !directory) {
+        throw new Error("SessionPool requires client and directory on first call");
+      }
+      _SessionPool._instance = new _SessionPool(client, directory, config2);
+    }
+    return _SessionPool._instance;
+  }
+  /**
+   * Acquire a session from the pool or create a new one.
+   */
+  async acquire(agentName, parentSessionID, description) {
+    const poolKey = this.getPoolKey(agentName);
+    const agentPool = this.pool.get(poolKey) || [];
+    const available = agentPool.find((s) => !s.inUse && s.reuseCount < this.config.maxReuseCount);
+    if (available) {
+      available.inUse = true;
+      available.lastUsedAt = /* @__PURE__ */ new Date();
+      available.reuseCount++;
+      this.stats.reuseHits++;
+      log(`[SessionPool] Reusing session ${available.id.slice(0, 8)}... for ${agentName} (reuse #${available.reuseCount})`);
+      return available;
+    }
+    this.stats.creationMisses++;
+    return this.createSession(agentName, parentSessionID, description);
+  }
+  /**
+   * Release a session back to the pool for reuse.
+   */
+  async release(sessionId) {
+    const session = this.sessionsById.get(sessionId);
+    if (!session) {
+      log(`[SessionPool] Session ${sessionId.slice(0, 8)}... not found in pool`);
+      return;
+    }
+    const now = Date.now();
+    const age = now - session.createdAt.getTime();
+    const idle = now - session.lastUsedAt.getTime();
+    if (session.reuseCount >= this.config.maxReuseCount || age > this.config.idleTimeoutMs * 2) {
+      await this.invalidate(sessionId);
+      return;
+    }
+    const poolKey = this.getPoolKey(session.agentName);
+    const agentPool = this.pool.get(poolKey) || [];
+    const availableCount = agentPool.filter((s) => !s.inUse).length;
+    if (availableCount >= this.config.maxPoolSizePerAgent) {
+      const oldest = agentPool.filter((s) => !s.inUse).sort((a, b) => a.lastUsedAt.getTime() - b.lastUsedAt.getTime())[0];
+      if (oldest) {
+        await this.deleteSession(oldest.id);
+      }
+    }
+    session.inUse = false;
+    log(`[SessionPool] Released session ${sessionId.slice(0, 8)}... to pool`);
+  }
+  /**
+   * Invalidate a session (remove from pool and delete).
+   */
+  async invalidate(sessionId) {
+    const session = this.sessionsById.get(sessionId);
+    if (!session) return;
+    await this.deleteSession(sessionId);
+    log(`[SessionPool] Invalidated session ${sessionId.slice(0, 8)}...`);
+  }
+  /**
+   * Get current pool statistics.
+   */
+  getStats() {
+    const byAgent = {};
+    for (const [agentName, sessions] of this.pool.entries()) {
+      const inUse = sessions.filter((s) => s.inUse).length;
+      byAgent[agentName] = {
+        total: sessions.length,
+        inUse,
+        available: sessions.length - inUse
+      };
+    }
+    const allSessions = Array.from(this.sessionsById.values());
+    const inUseCount = allSessions.filter((s) => s.inUse).length;
+    return {
+      totalSessions: allSessions.length,
+      sessionsInUse: inUseCount,
+      availableSessions: allSessions.length - inUseCount,
+      reuseHits: this.stats.reuseHits,
+      creationMisses: this.stats.creationMisses,
+      byAgent
+    };
+  }
+  /**
+   * Cleanup stale sessions.
+   */
+  async cleanup() {
+    const now = Date.now();
+    let cleanedCount = 0;
+    for (const [sessionId, session] of this.sessionsById.entries()) {
+      if (session.inUse) continue;
+      const idle = now - session.lastUsedAt.getTime();
+      if (idle > this.config.idleTimeoutMs) {
+        await this.deleteSession(sessionId);
+        cleanedCount++;
+      }
+    }
+    if (cleanedCount > 0) {
+      log(`[SessionPool] Cleaned up ${cleanedCount} stale sessions`);
+    }
+    return cleanedCount;
+  }
+  /**
+   * Shutdown the pool.
+   */
+  async shutdown() {
+    log("[SessionPool] Shutting down...");
+    if (this.healthCheckInterval) {
+      clearInterval(this.healthCheckInterval);
+      this.healthCheckInterval = null;
+    }
+    const deletePromises = Array.from(this.sessionsById.keys()).map(
+      (id) => this.deleteSession(id).catch(() => {
+      })
+    );
+    await Promise.all(deletePromises);
+    this.pool.clear();
+    this.sessionsById.clear();
+    log("[SessionPool] Shutdown complete");
+  }
+  // =========================================================================
+  // Private Methods
+  // =========================================================================
+  getPoolKey(agentName) {
+    return agentName;
+  }
+  async createSession(agentName, parentSessionID, description) {
+    log(`[SessionPool] Creating new session for ${agentName}`);
+    const result = await Promise.race([
+      this.client.session.create({
+        body: {
+          parentID: parentSessionID,
+          title: `${PARALLEL_TASK.SESSION_TITLE_PREFIX}: ${description}`
+        },
+        query: { directory: this.directory }
+      }),
+      new Promise(
+        (_, reject) => setTimeout(() => reject(new Error("Session creation timed out after 60s")), 6e4)
+      )
+    ]);
+    if (result.error || !result.data?.id) {
+      throw new Error(`Session creation failed: ${result.error || "No ID"}`);
+    }
+    const session = {
+      id: result.data.id,
+      agentName,
+      projectDirectory: this.directory,
+      createdAt: /* @__PURE__ */ new Date(),
+      lastUsedAt: /* @__PURE__ */ new Date(),
+      reuseCount: 0,
+      inUse: true
+    };
+    const poolKey = this.getPoolKey(agentName);
+    const agentPool = this.pool.get(poolKey) || [];
+    agentPool.push(session);
+    this.pool.set(poolKey, agentPool);
+    this.sessionsById.set(session.id, session);
+    return session;
+  }
+  async deleteSession(sessionId) {
+    const session = this.sessionsById.get(sessionId);
+    if (!session) return;
+    this.sessionsById.delete(sessionId);
+    const poolKey = this.getPoolKey(session.agentName);
+    const agentPool = this.pool.get(poolKey);
+    if (agentPool) {
+      const idx = agentPool.findIndex((s) => s.id === sessionId);
+      if (idx !== -1) {
+        agentPool.splice(idx, 1);
+      }
+      if (agentPool.length === 0) {
+        this.pool.delete(poolKey);
+      }
+    }
+    try {
+      await this.client.session.delete({ path: { id: sessionId } });
+    } catch {
+    }
+  }
+  startHealthCheck() {
+    this.healthCheckInterval = setInterval(() => {
+      this.cleanup().catch(() => {
+      });
+    }, this.config.healthCheckIntervalMs);
+    this.healthCheckInterval.unref?.();
+  }
+};
+var sessionPool = {
+  getInstance: SessionPool.getInstance.bind(SessionPool)
+};
+
+// src/core/progress/terminal-monitor.ts
+var TerminalMonitor = class _TerminalMonitor {
+  static instance;
+  lastLineCount = 0;
+  active = false;
+  constructor() {
+    stateBroadcaster.subscribe(this.render.bind(this));
+  }
+  static getInstance() {
+    if (!_TerminalMonitor.instance) {
+      _TerminalMonitor.instance = new _TerminalMonitor();
+    }
+    return _TerminalMonitor.instance;
+  }
+  start() {
+    this.active = true;
+  }
+  stop() {
+    this.active = false;
+    process.stdout.write("\n");
+  }
+  render(state2) {
+    if (!this.active) return;
+    const { COLORS, BAR_WIDTH, LABELS } = TUI_CONSTANTS;
+    if (this.lastLineCount > 0) {
+      process.stdout.write(`\x1B[${this.lastLineCount}A`);
+    }
+    let output = "";
+    const filledWidth = Math.round(state2.progress.percentage / 100 * BAR_WIDTH);
+    const bar = "\u2588".repeat(filledWidth) + "\u2591".repeat(BAR_WIDTH - filledWidth);
+    output += `${COLORS.BOLD}${COLORS.PROGRESS}${LABELS.PROGRESS_TITLE}: [${bar}] ${state2.progress.percentage}% ${COLORS.RESET}
+`;
+    output += `Tasks: ${state2.progress.completedTasks}/${state2.progress.totalTasks} completed
+
+`;
+    if (state2.activeAgents.length > 0) {
+      output += `${COLORS.BOLD}${LABELS.AGENT_TITLE}:${COLORS.RESET}
+`;
+      state2.activeAgents.forEach((agent) => {
+        const desc = agent.currentTask && agent.currentTask.length > 50 ? agent.currentTask.substring(0, 47) + "..." : agent.currentTask || LABELS.IDLE;
+        output += `  ${COLORS.AGENT}\u25CF${COLORS.RESET} ${COLORS.BOLD}${agent.type}${COLORS.RESET}: ${desc}
+`;
+      });
+      output += "\n";
+    } else {
+      output += `${COLORS.DIM}${LABELS.WAITING}${COLORS.RESET}
+
+`;
+    }
+    const lines = output.split("\n");
+    this.lastLineCount = lines.length - 1;
+    process.stdout.write(output);
+  }
+};
+
+// src/core/loop/todo-manager.ts
+import { readFileSync, writeFileSync, existsSync as existsSync3 } from "node:fs";
+import { join as join5 } from "node:path";
+var TodoManager = class _TodoManager {
+  static instance;
+  directory = "";
+  constructor() {
+  }
+  static getInstance() {
+    if (!_TodoManager.instance) {
+      _TodoManager.instance = new _TodoManager();
+    }
+    return _TodoManager.instance;
+  }
+  setDirectory(dir) {
+    this.directory = dir;
+  }
+  /**
+   * Update a specific TODO item by its text content
+   */
+  updateItem(searchText, newStatus) {
+    const todoPath = join5(this.directory, PATHS.TODO);
+    if (!existsSync3(todoPath)) return false;
+    try {
+      const content = readFileSync(todoPath, "utf-8");
+      const lines = content.split("\n");
+      const statusMap = {
+        [TODO_CONSTANTS.STATUS.PENDING]: TODO_CONSTANTS.MARKERS.PENDING,
+        [TODO_CONSTANTS.STATUS.COMPLETED]: TODO_CONSTANTS.MARKERS.COMPLETED,
+        [TODO_CONSTANTS.STATUS.PROGRESS]: TODO_CONSTANTS.MARKERS.PROGRESS,
+        [TODO_CONSTANTS.STATUS.FAILED]: TODO_CONSTANTS.MARKERS.FAILED
+      };
+      const marker = statusMap[newStatus] || TODO_CONSTANTS.MARKERS.PENDING;
+      let updated = false;
+      const newLines = lines.map((line) => {
+        if (line.includes(searchText) && (line.includes(TODO_CONSTANTS.MARKERS.PENDING) || line.includes(TODO_CONSTANTS.MARKERS.PROGRESS) || line.includes(TODO_CONSTANTS.MARKERS.COMPLETED) || line.includes(TODO_CONSTANTS.MARKERS.FAILED))) {
+          updated = true;
+          return line.replace(/\[[ x\/\-]\]/, marker);
+        }
+        return line;
+      });
+      if (updated) {
+        writeFileSync(todoPath, newLines.join("\n"), "utf-8");
+        log(`[TodoManager] Updated item: "${searchText}" -> ${newStatus}`);
+        return true;
+      }
+      return false;
+    } catch (error45) {
+      log(`[TodoManager] Error updating TODO: ${error45}`);
+      return false;
+    }
+  }
+  /**
+   * Add a new sub-task under a parent task
+   */
+  addSubTask(parentText, subTaskText) {
+    const todoPath = join5(this.directory, PATHS.TODO);
+    if (!existsSync3(todoPath)) return false;
+    try {
+      const content = readFileSync(todoPath, "utf-8");
+      const lines = content.split("\n");
+      let parentIndex = -1;
+      let parentIndent = "";
+      for (let i = 0; i < lines.length; i++) {
+        if (lines[i].includes(parentText)) {
+          parentIndex = i;
+          const match = lines[i].match(/^(\s*)/);
+          parentIndent = match ? match[1] : "";
+          break;
+        }
+      }
+      if (parentIndex !== -1) {
+        const subTaskIndent = parentIndent + "  ";
+        const newLine = `${subTaskIndent}- ${TODO_CONSTANTS.MARKERS.PENDING} ${subTaskText}`;
+        lines.splice(parentIndex + 1, 0, newLine);
+        writeFileSync(todoPath, lines.join("\n"), "utf-8");
+        log(`[TodoManager] Added sub-task: "${subTaskText}" under "${parentText}"`);
+        return true;
+      }
+      return false;
+    } catch (error45) {
+      log(`[TodoManager] Error adding sub-task: ${error45}`);
+      return false;
+    }
+  }
+};
+
 // src/core/agents/manager.ts
 var ParallelAgentManager = class _ParallelAgentManager {
   static _instance;
@@ -17862,6 +18759,7 @@ var ParallelAgentManager = class _ParallelAgentManager {
   client;
   directory;
   concurrency = new ConcurrencyController();
+  sessionPool;
   // Composed components
   launcher;
   resumer;
@@ -17871,7 +18769,13 @@ var ParallelAgentManager = class _ParallelAgentManager {
   constructor(client, directory) {
     this.client = client;
     this.directory = directory;
-    this.cleaner = new TaskCleaner(client, this.store, this.concurrency);
+    const memory = MemoryManager.getInstance();
+    memory.add("system" /* SYSTEM */, CORE_PHILOSOPHY, 1);
+    memory.add("project" /* PROJECT */, `Working directory: ${directory}`, 0.9);
+    AgentRegistry.getInstance().setDirectory(directory);
+    TodoManager.getInstance().setDirectory(directory);
+    this.sessionPool = SessionPool.getInstance(client, directory);
+    this.cleaner = new TaskCleaner(client, this.store, this.concurrency, this.sessionPool);
     this.poller = new TaskPoller(
       client,
       this.store,
@@ -17886,6 +18790,7 @@ var ParallelAgentManager = class _ParallelAgentManager {
       directory,
       this.store,
       this.concurrency,
+      this.sessionPool,
       (taskId, error45) => this.handleTaskError(taskId, error45),
       () => this.poller.start()
     );
@@ -17906,6 +18811,8 @@ var ParallelAgentManager = class _ParallelAgentManager {
       (sessionID) => this.poller.validateSessionHasOutput(sessionID),
       (task) => this.handleTaskComplete(task)
     );
+    progressNotifier.setManager(this);
+    TerminalMonitor.getInstance().start();
     this.recoverActiveTasks().catch((err) => {
       log("Recovery error:", err);
     });
@@ -17924,7 +18831,9 @@ var ParallelAgentManager = class _ParallelAgentManager {
   // ========================================================================
   async launch(inputs) {
     this.cleaner.pruneExpiredTasks();
-    return this.launcher.launch(inputs);
+    const result = await this.launcher.launch(inputs);
+    progressNotifier.update();
+    return result;
   }
   async resume(input) {
     return this.resumer.resume(input);
@@ -17958,6 +18867,7 @@ var ParallelAgentManager = class _ParallelAgentManager {
     this.cleaner.scheduleCleanup(taskId);
     taskWAL.log(WAL_ACTIONS.DELETE, task).catch(() => {
     });
+    progressNotifier.update();
     log(`Cancelled ${taskId}`);
     return true;
   }
@@ -17992,6 +18902,8 @@ var ParallelAgentManager = class _ParallelAgentManager {
   cleanup() {
     this.poller.stop();
     this.store.clear();
+    MemoryManager.getInstance().clearTaskMemory();
+    TerminalMonitor.getInstance().stop();
     Promise.resolve().then(() => (init_store(), store_exports)).then((store) => store.clearAll()).catch(() => {
     });
   }
@@ -18021,6 +18933,7 @@ var ParallelAgentManager = class _ParallelAgentManager {
     this.store.untrackPending(task.parentSessionID, taskId);
     this.cleaner.notifyParentIfAllComplete(task.parentSessionID);
     this.cleaner.scheduleCleanup(taskId);
+    progressNotifier.update();
     taskWAL.log(WAL_ACTIONS.UPDATE, task).catch(() => {
     });
   }
@@ -18047,6 +18960,7 @@ This task ensures the completeness of the unit before global integration.`,
         log(`[MSVP] Failed to trigger review for ${task.id}:`, error45);
       }
     }
+    progressNotifier.update();
   }
   async recoverActiveTasks() {
     const tasks = await taskWAL.readAll();
@@ -18085,7 +18999,13 @@ This task ensures the completeness of the unit before global integration.`,
   }
 };
 var parallelAgentManager = {
-  getInstance: ParallelAgentManager.getInstance.bind(ParallelAgentManager)
+  getInstance: ParallelAgentManager.getInstance.bind(ParallelAgentManager),
+  cleanup: () => {
+    try {
+      ParallelAgentManager.getInstance().cleanup();
+    } catch {
+    }
+  }
 };
 
 // src/tools/parallel/delegate-task.ts
@@ -18221,6 +19141,7 @@ ${PROMPT_TAGS.RESUME.close}
 ${PROMPT_TAGS.SAFETY.open}
 - Max 10 tasks per agent type (configurable)
 - Auto-timeout: 60 minutes
+- Use \`${TOOL_NAMES.LIST_AGENTS}\` to see all available agents (including custom ones).
 ${PROMPT_TAGS.SAFETY.close}`,
   args: {
     [PARALLEL_PARAMS.AGENT]: tool.schema.string().describe("Agent name"),
@@ -18352,7 +19273,7 @@ Session: \`${task.sessionID}\` (save for resume)`;
       if (pollResult.timedOut) {
         log(`${PARALLEL_LOG.DELEGATE_TASK} Sync: timed out`, pollResult);
         return `${OUTPUT_LABEL.TIMEOUT} after ${Math.floor(pollResult.elapsedMs / 1e3)}s (${pollResult.pollCount} polls)
-Session: \`${sessionID}\` - Use get_task_result or resume later.`;
+Session: \`${sessionID}\` - Use ${TOOL_NAMES.GET_TASK_RESULT} or resume later.`;
       }
       const text = await extractSessionResult(session, sessionID);
       log(`${PARALLEL_LOG.DELEGATE_TASK} Sync: completed`, { sessionID, elapsedMs: pollResult.elapsedMs });
@@ -18383,59 +19304,201 @@ var createGetTaskResultTool = (manager) => tool({
     if (task.status === STATUS_LABEL.ERROR || task.status === STATUS_LABEL.TIMEOUT) {
       return `[${task.status.toUpperCase()}] ${task.error}`;
     }
-    return `${OUTPUT_LABEL.DONE} Completed in ${duration3}
+    return `${OUTPUT_LABEL.DONE} Completed in ${duration3}
+
+${result || "(No output)"}`;
+  }
+});
+
+// src/tools/parallel/list-tasks.ts
+var createListTasksTool = (manager) => tool({
+  description: `List all background tasks.`,
+  args: {
+    [PARALLEL_PARAMS.STATUS]: tool.schema.string().optional().describe("Filter: all, running, completed, error")
+  },
+  async execute(args) {
+    const status = args[PARALLEL_PARAMS.STATUS] || STATUS_LABEL.ALL;
+    let tasks;
+    switch (status) {
+      case STATUS_LABEL.RUNNING:
+        tasks = manager.getRunningTasks();
+        break;
+      case STATUS_LABEL.COMPLETED:
+        tasks = manager.getAllTasks().filter((t) => t.status === TASK_STATUS.COMPLETED);
+        break;
+      case STATUS_LABEL.ERROR:
+        tasks = manager.getAllTasks().filter((t) => t.status === TASK_STATUS.ERROR || t.status === TASK_STATUS.TIMEOUT);
+        break;
+      default:
+        tasks = manager.getAllTasks();
+    }
+    if (tasks.length === 0) return `No tasks found.`;
+    const rows = tasks.map((t) => {
+      const elapsed = Math.floor((Date.now() - t.startedAt.getTime()) / 1e3);
+      return `| \`${t.id}\` | [${t.status.toUpperCase()}] | ${t.agent} | ${elapsed}s |`;
+    }).join("\n");
+    return `**Tasks List**
+
+| ID | ${LOOP_LABELS.STATUS_TITLE || "Status"} | ${PARALLEL_PARAMS.AGENT.toUpperCase()} | Time |
+|----|--------|-------|------|
+${rows}`;
+  }
+});
+
+// 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")
+  },
+  async execute(args) {
+    const cancelled = await manager.cancelTask(args.taskId);
+    if (cancelled) return `${OUTPUT_LABEL.CANCELLED} task: \`${args.taskId}\``;
+    const task = manager.getTask(args.taskId);
+    if (task) return `${OUTPUT_LABEL.WARNING} Cannot cancel: Task is ${task.status}`;
+    return `${OUTPUT_LABEL.ERROR} Not found: \`${args.taskId}\``;
+  }
+});
+
+// src/tools/parallel/list-agents.ts
+var createListAgentsTool = () => tool({
+  description: "List all available agents for delegation, including built-in and custom templates.",
+  args: {},
+  async execute() {
+    const registry2 = AgentRegistry.getInstance();
+    const agentNames = registry2.listAgents();
+    if (agentNames.length === 0) {
+      return `${OUTPUT_LABEL.INFO} No agents registered.`;
+    }
+    let output = `${OUTPUT_LABEL.INFO} Available Agents:
+
+`;
+    for (const name of agentNames) {
+      const def = registry2.getAgent(name);
+      if (def) {
+        output += `- **${name}**: ${def.description}
+`;
+      }
+    }
+    return output;
+  }
+});
+
+// src/core/metrics/collector.ts
+var MetricsCollector = class _MetricsCollector {
+  static instance;
+  agentLatencies = /* @__PURE__ */ new Map();
+  toolLatencies = /* @__PURE__ */ new Map();
+  tokenUsage = 0;
+  lineCount = 0;
+  tasks = [];
+  constructor() {
+  }
+  static getInstance() {
+    if (!_MetricsCollector.instance) {
+      _MetricsCollector.instance = new _MetricsCollector();
+    }
+    return _MetricsCollector.instance;
+  }
+  recordAgentExecution(agent, duration3) {
+    const latencies = this.agentLatencies.get(agent) || [];
+    latencies.push(duration3);
+    this.agentLatencies.set(agent, latencies);
+  }
+  recordToolExecution(tool2, duration3) {
+    const latencies = this.toolLatencies.get(tool2) || [];
+    latencies.push(duration3);
+    this.toolLatencies.set(tool2, latencies);
+  }
+  recordTokenUsage(tokens) {
+    this.tokenUsage += tokens;
+  }
+  recordTaskResult(id, success2) {
+    this.tasks.push({ id, success: success2 });
+  }
+  recordLinesProduced(lines) {
+    this.lineCount += lines;
+  }
+  getStats() {
+    const avgAgentLatency = {};
+    for (const [agent, lats] of this.agentLatencies.entries()) {
+      avgAgentLatency[agent] = Math.round(lats.reduce((a, b) => a + b, 0) / lats.length);
+    }
+    const avgToolLatency = {};
+    for (const [tool2, lats] of this.toolLatencies.entries()) {
+      avgToolLatency[tool2] = Math.round(lats.reduce((a, b) => a + b, 0) / lats.length);
+    }
+    const successfulTasks = this.tasks.filter((t) => t.success).length;
+    return {
+      avgAgentLatency,
+      avgToolLatency,
+      tokenUsage: this.tokenUsage,
+      efficiency: this.lineCount > 0 ? this.tokenUsage / this.lineCount : 0,
+      totalTasks: this.tasks.length,
+      successRate: this.tasks.length > 0 ? successfulTasks / this.tasks.length : 0
+    };
+  }
+};
+
+// src/tools/parallel/show-metrics.ts
+var createShowMetricsTool = () => tool({
+  description: "Display a performance dashboard for the current mission, showing tool/agent latency and token usage.",
+  args: {},
+  async execute() {
+    const stats2 = MetricsCollector.getInstance().getStats();
+    let output = `${OUTPUT_LABEL.INFO} **Performance Dashboard**
+
+`;
+    output += `### \u23F1\uFE0F Latency (Average)
+
+`;
+    output += `**Tools:**
+`;
+    for (const [tool2, lat] of Object.entries(stats2.avgToolLatency)) {
+      output += `- \`${tool2}\`: ${lat}ms
+`;
+    }
+    output += `
+**Agents:**
+`;
+    for (const [agent, lat] of Object.entries(stats2.avgAgentLatency)) {
+      output += `- \`${agent}\`: ${lat}ms
+`;
+    }
+    output += `
+### \u{1FA99} Resource Usage
 
-${result || "(No output)"}`;
+`;
+    output += `- **Total Tokens (Est.)**: ${Math.round(stats2.tokenUsage).toLocaleString()}
+`;
+    output += `- **Mission Success Rate**: ${Math.round(stats2.successRate * 100)}%
+`;
+    output += `- **Total Sub-tasks**: ${stats2.totalTasks}
+`;
+    return output;
   }
 });
 
-// src/tools/parallel/list-tasks.ts
-var createListTasksTool = (manager) => tool({
-  description: `List all background tasks.`,
+// src/tools/parallel/update-todo.ts
+var createUpdateTodoTool = () => tool({
+  description: "Update the status of a task in .opencode/todo.md or add a sub-task. Use this for incremental updates instead of rewriting the whole file.",
   args: {
-    [PARALLEL_PARAMS.STATUS]: tool.schema.string().optional().describe("Filter: all, running, completed, error")
+    action: tool.schema.enum(["update", "add"]).describe("Action to perform"),
+    task: tool.schema.string().describe("Text content of the task to update or the parent task to add under"),
+    status: tool.schema.enum(Object.values(TODO_CONSTANTS.STATUS)).optional().describe("New status (for 'update' action)"),
+    subtask: tool.schema.string().optional().describe("Description of the new sub-task (for 'add' action)")
   },
   async execute(args) {
-    const status = args[PARALLEL_PARAMS.STATUS] || STATUS_LABEL.ALL;
-    let tasks;
-    switch (status) {
-      case STATUS_LABEL.RUNNING:
-        tasks = manager.getRunningTasks();
-        break;
-      case STATUS_LABEL.COMPLETED:
-        tasks = manager.getAllTasks().filter((t) => t.status === TASK_STATUS.COMPLETED);
-        break;
-      case STATUS_LABEL.ERROR:
-        tasks = manager.getAllTasks().filter((t) => t.status === TASK_STATUS.ERROR || t.status === TASK_STATUS.TIMEOUT);
-        break;
-      default:
-        tasks = manager.getAllTasks();
+    const manager = TodoManager.getInstance();
+    if (args.action === "update") {
+      if (!args.status) return `${OUTPUT_LABEL.ERROR} 'status' is required for update action.`;
+      const success2 = manager.updateItem(args.task, args.status);
+      return success2 ? `${OUTPUT_LABEL.DONE} Updated task status: "${args.task}" -> ${args.status}` : `${OUTPUT_LABEL.ERROR} Task not found: "${args.task}"`;
+    } else {
+      if (!args.subtask) return `${OUTPUT_LABEL.ERROR} 'subtask' is required for add action.`;
+      const success2 = manager.addSubTask(args.task, args.subtask);
+      return success2 ? `${OUTPUT_LABEL.DONE} Added sub-task: "${args.subtask}" under "${args.task}"` : `${OUTPUT_LABEL.ERROR} Parent task not found: "${args.task}"`;
     }
-    if (tasks.length === 0) return `No tasks found.`;
-    const rows = tasks.map((t) => {
-      const elapsed = Math.floor((Date.now() - t.startedAt.getTime()) / 1e3);
-      return `| \`${t.id}\` | [${t.status.toUpperCase()}] | ${t.agent} | ${elapsed}s |`;
-    }).join("\n");
-    return `**Tasks List**
-
-| ID | ${LOOP_LABELS.STATUS_TITLE || "Status"} | ${PARALLEL_PARAMS.AGENT.toUpperCase()} | Time |
-|----|--------|-------|------|
-${rows}`;
-  }
-});
-
-// 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")
-  },
-  async execute(args) {
-    const cancelled = await manager.cancelTask(args.taskId);
-    if (cancelled) return `${OUTPUT_LABEL.CANCELLED} task: \`${args.taskId}\``;
-    const task = manager.getTask(args.taskId);
-    if (task) return `${OUTPUT_LABEL.WARNING} Cannot cancel: Task is ${task.status}`;
-    return `${OUTPUT_LABEL.ERROR} Not found: \`${args.taskId}\``;
   }
 });
 
@@ -18445,7 +19508,10 @@ function createAsyncAgentTools(manager, client) {
     [TOOL_NAMES.DELEGATE_TASK]: createDelegateTaskTool(manager, client),
     [TOOL_NAMES.GET_TASK_RESULT]: createGetTaskResultTool(manager),
     [TOOL_NAMES.LIST_TASKS]: createListTasksTool(manager),
-    [TOOL_NAMES.CANCEL_TASK]: createCancelTaskTool(manager)
+    [TOOL_NAMES.CANCEL_TASK]: createCancelTaskTool(manager),
+    [TOOL_NAMES.LIST_AGENTS]: createListAgentsTool(),
+    [TOOL_NAMES.SHOW_METRICS]: createShowMetricsTool(),
+    [TOOL_NAMES.UPDATE_TODO]: createUpdateTodoTool()
   };
 }
 
@@ -18499,15 +19565,15 @@ var METADATA_FILE = PATHS.DOC_METADATA;
 var DEFAULT_TTL_MS = CACHE.DEFAULT_TTL_MS;
 
 // src/core/cache/operations.ts
-import * as fs5 from "node:fs/promises";
-import * as path4 from "node:path";
+import * as fs6 from "node:fs/promises";
+import * as path5 from "node:path";
 
 // src/core/cache/utils.ts
-import * as fs4 from "node:fs/promises";
-import { existsSync as existsSync3 } from "node:fs";
+import * as fs5 from "node:fs/promises";
+import { existsSync as existsSync4 } from "node:fs";
 async function ensureCacheDir() {
-  if (!existsSync3(CACHE_DIR)) {
-    await fs4.mkdir(CACHE_DIR, { recursive: true });
+  if (!existsSync4(CACHE_DIR)) {
+    await fs5.mkdir(CACHE_DIR, { recursive: true });
   }
 }
 function urlToFilename(url2) {
@@ -18522,7 +19588,7 @@ function urlToFilename(url2) {
 }
 async function readMetadata() {
   try {
-    const content = await fs4.readFile(METADATA_FILE, "utf-8");
+    const content = await fs5.readFile(METADATA_FILE, "utf-8");
     return JSON.parse(content);
   } catch {
     return { documents: {}, lastUpdated: (/* @__PURE__ */ new Date()).toISOString() };
@@ -18531,7 +19597,7 @@ async function readMetadata() {
 async function writeMetadata(metadata) {
   await ensureCacheDir();
   metadata.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
-  await fs4.writeFile(METADATA_FILE, JSON.stringify(metadata, null, 2));
+  await fs5.writeFile(METADATA_FILE, JSON.stringify(metadata, null, 2));
 }
 
 // src/core/cache/operations.ts
@@ -18545,8 +19611,8 @@ async function get2(url2) {
     return null;
   }
   try {
-    const filepath = path4.join(CACHE_DIR, filename);
-    const content = await fs5.readFile(filepath, "utf-8");
+    const filepath = path5.join(CACHE_DIR, filename);
+    const content = await fs6.readFile(filepath, "utf-8");
     return { ...entry, content };
   } catch {
     return null;
@@ -18557,8 +19623,8 @@ async function getByFilename(filename) {
   const entry = metadata.documents[filename];
   if (!entry) return null;
   try {
-    const filepath = path4.join(CACHE_DIR, filename);
-    const content = await fs5.readFile(filepath, "utf-8");
+    const filepath = path5.join(CACHE_DIR, filename);
+    const content = await fs6.readFile(filepath, "utf-8");
     return { ...entry, content };
   } catch {
     return null;
@@ -18567,7 +19633,7 @@ async function getByFilename(filename) {
 async function set2(url2, content, title, ttlMs = DEFAULT_TTL_MS) {
   await ensureCacheDir();
   const filename = urlToFilename(url2);
-  const filepath = path4.join(CACHE_DIR, filename);
+  const filepath = path5.join(CACHE_DIR, filename);
   const now = /* @__PURE__ */ new Date();
   const header = `# ${title}
 
@@ -18578,7 +19644,7 @@ async function set2(url2, content, title, ttlMs = DEFAULT_TTL_MS) {
 
 `;
   const fullContent = header + content;
-  await fs5.writeFile(filepath, fullContent);
+  await fs6.writeFile(filepath, fullContent);
   const metadata = await readMetadata();
   metadata.documents[filename] = {
     url: url2,
@@ -18592,9 +19658,9 @@ async function set2(url2, content, title, ttlMs = DEFAULT_TTL_MS) {
 }
 async function remove(url2) {
   const filename = urlToFilename(url2);
-  const filepath = path4.join(CACHE_DIR, filename);
+  const filepath = path5.join(CACHE_DIR, filename);
   try {
-    await fs5.unlink(filepath);
+    await fs6.unlink(filepath);
     const metadata = await readMetadata();
     delete metadata.documents[filename];
     await writeMetadata(metadata);
@@ -18612,13 +19678,13 @@ async function list() {
     expired: new Date(entry.expiresAt) < now
   }));
 }
-async function clear2() {
+async function clear3() {
   const metadata = await readMetadata();
   const count = Object.keys(metadata.documents).length;
   for (const filename of Object.keys(metadata.documents)) {
-    const filepath = path4.join(CACHE_DIR, filename);
+    const filepath = path5.join(CACHE_DIR, filename);
     try {
-      await fs5.unlink(filepath);
+      await fs6.unlink(filepath);
     } catch {
     }
   }
@@ -19096,7 +20162,7 @@ Cached: ${doc.fetchedAt}
 ${doc.content}`;
       }
       case CACHE_ACTIONS.CLEAR: {
-        const count = await clear2();
+        const count = await clear3();
         return `Cleared ${count} cached documents`;
       }
       case CACHE_ACTIONS.STATS: {
@@ -19276,6 +20342,60 @@ ${r.content}
   }
 });
 
+// src/tools/lsp/diagnostics-cache.ts
+import fs7 from "fs/promises";
+import path6 from "path";
+var DiagnosticsCache = class {
+  cache = /* @__PURE__ */ new Map();
+  defaultTTL = 3e4;
+  // 30 seconds
+  async get(directory, file2) {
+    const key = this.getCacheKey(directory, file2);
+    const cached2 = this.cache.get(key);
+    if (!cached2) return null;
+    if (Date.now() - cached2.timestamp > this.defaultTTL) {
+      this.cache.delete(key);
+      return null;
+    }
+    try {
+      const currentMtime = await this.getFilesMtime(directory, file2);
+      if (currentMtime > cached2.filesMtime) {
+        this.cache.delete(key);
+        return null;
+      }
+    } catch (error45) {
+      this.cache.delete(key);
+      return null;
+    }
+    log(`[DiagnosticsCache] Cache hit for ${file2 || "all files"}`);
+    return cached2.diagnostics;
+  }
+  async set(directory, file2, diagnostics) {
+    try {
+      const key = this.getCacheKey(directory, file2);
+      const filesMtime = await this.getFilesMtime(directory, file2);
+      this.cache.set(key, {
+        diagnostics,
+        timestamp: Date.now(),
+        filesMtime
+      });
+    } catch (error45) {
+    }
+  }
+  getCacheKey(directory, file2) {
+    return file2 ? `${directory}:${file2}` : directory;
+  }
+  async getFilesMtime(directory, file2) {
+    if (file2 && file2 !== "*") {
+      const stats3 = await fs7.stat(path6.join(directory, file2));
+      return stats3.mtimeMs;
+    }
+    const stats2 = await fs7.stat(directory);
+    return stats2.mtimeMs;
+  }
+};
+var diagnosticsCache = new DiagnosticsCache();
+
 // src/tools/lsp/index.ts
 var lspDiagnosticsTool = (directory) => tool({
   description: `Get LSP diagnostics (errors/warnings) for files.
@@ -19293,11 +20413,17 @@ Runs TypeScript compiler and/or ESLint to find issues.
     include_warnings: tool.schema.boolean().optional().describe("Include warnings (default: true)")
   },
   async execute(args) {
-    return callRustTool("lsp_diagnostics", {
+    const cached2 = await diagnosticsCache.get(directory, args.file);
+    if (cached2) return cached2;
+    const result = await callRustTool("lsp_diagnostics", {
       directory,
       file: args.file,
       include_warnings: args.include_warnings
     });
+    if (result) {
+      await diagnosticsCache.set(directory, args.file, result);
+    }
+    return result;
   }
 });
 
@@ -19316,16 +20442,7 @@ var HOOK_ACTIONS = {
   PROCESS: "process",
   INTERCEPT: "intercept"
 };
-var HOOK_NAMES = {
-  SANITY_CHECK: "SanityCheck",
-  MISSION_LOOP: "MissionLoop",
-  STRICT_ROLE_GUARD: "StrictRoleGuard",
-  SECRET_SCANNER: "SecretScanner",
-  AGENT_UI: "AgentUI",
-  RESOURCE_CONTROL: "ResourceControl",
-  SLASH_COMMAND: "SlashCommandDispatcher",
-  USER_ACTIVITY: "UserActivity"
-};
+var HOOK_NAMES2 = HOOK_NAMES;
 
 // src/hooks/registry.ts
 var HookRegistry = class _HookRegistry {
@@ -19548,23 +20665,25 @@ function ensureSessionInitialized(sessions, sessionID) {
   }
   return sessions.get(sessionID);
 }
-function activateMissionState(sessionID) {
+function ensureGlobalState(sessionID) {
   let stateSession = state.sessions.get(sessionID);
   if (!stateSession) {
-    state.sessions.set(sessionID, {
+    const newState = {
       enabled: true,
       iterations: 0,
       taskRetries: /* @__PURE__ */ new Map(),
       currentTask: "",
       anomalyCount: 0
-    });
-    stateSession = state.sessions.get(sessionID);
-    log(`[SessionManager] Created new global mission state for ${sessionID}`);
-  }
-  if (stateSession) {
-    stateSession.enabled = true;
-    stateSession.anomalyCount = 0;
+    };
+    state.sessions.set(sessionID, newState);
+    return newState;
   }
+  return stateSession;
+}
+function activateMissionState(sessionID) {
+  const stateSession = ensureGlobalState(sessionID);
+  stateSession.enabled = true;
+  stateSession.anomalyCount = 0;
   state.missionActive = true;
   log(`[SessionManager] Mission Activated: ${sessionID}`);
 }
@@ -19587,18 +20706,16 @@ function updateSessionTokens(sessions, sessionID, inputLen, outputLen) {
   session.tokens.estimatedCost = Number(cost.toFixed(4));
 }
 function recordAnomaly(sessionID) {
-  const session = ensureSessionInitialized(state.sessions, sessionID);
+  const session = ensureGlobalState(sessionID);
   session.anomalyCount = (session.anomalyCount || 0) + 1;
   return session.anomalyCount;
 }
 function resetAnomaly(sessionID) {
-  const session = ensureSessionInitialized(state.sessions, sessionID);
-  if (session.anomalyCount > 0) {
-    session.anomalyCount = 0;
-  }
+  const session = ensureGlobalState(sessionID);
+  session.anomalyCount = 0;
 }
 function updateCurrentTask(sessionID, taskID) {
-  const session = ensureSessionInitialized(state.sessions, sessionID);
+  const session = ensureGlobalState(sessionID);
   session.currentTask = taskID;
 }
 
@@ -19673,7 +20790,7 @@ var CONTINUE_INSTRUCTION = `<auto_continue>
 
 // src/hooks/features/sanity-check.ts
 var SanityCheckHook = class {
-  name = HOOK_NAMES.SANITY_CHECK;
+  name = HOOK_NAMES2.SANITY_CHECK;
   async execute(ctx, toolOrText, input, output) {
     if (output) {
       if (toolOrText === TOOL_NAMES.CALL_AGENT) {
@@ -19713,20 +20830,20 @@ var SanityCheckHook = class {
 };
 
 // src/core/loop/mission-loop.ts
-import { existsSync as existsSync4, readFileSync, writeFileSync, unlinkSync, mkdirSync } from "node:fs";
-import { join as join5 } from "node:path";
+import { existsSync as existsSync5, readFileSync as readFileSync2, writeFileSync as writeFileSync2, unlinkSync, mkdirSync } from "node:fs";
+import { join as join7 } from "node:path";
 var STATE_FILE = MISSION_CONTROL.STATE_FILE;
 var DEFAULT_MAX_ITERATIONS = MISSION_CONTROL.DEFAULT_MAX_ITERATIONS;
 function getStateFilePath(directory) {
-  return join5(directory, PATHS.OPENCODE, STATE_FILE);
+  return join7(directory, PATHS.OPENCODE, STATE_FILE);
 }
 function readLoopState(directory) {
   const filePath = getStateFilePath(directory);
-  if (!existsSync4(filePath)) {
+  if (!existsSync5(filePath)) {
     return null;
   }
   try {
-    const content = readFileSync(filePath, "utf-8");
+    const content = readFileSync2(filePath, "utf-8");
     return JSON.parse(content);
   } catch (error45) {
     log(`[${MISSION_CONTROL.LOG_SOURCE}] Failed to read state: ${error45}`);
@@ -19735,12 +20852,12 @@ function readLoopState(directory) {
 }
 function writeLoopState(directory, state2) {
   const filePath = getStateFilePath(directory);
-  const dirPath = join5(directory, PATHS.OPENCODE);
+  const dirPath = join7(directory, PATHS.OPENCODE);
   try {
-    if (!existsSync4(dirPath)) {
+    if (!existsSync5(dirPath)) {
       mkdirSync(dirPath, { recursive: true });
     }
-    writeFileSync(filePath, JSON.stringify(state2, null, 2), "utf-8");
+    writeFileSync2(filePath, JSON.stringify(state2, null, 2), "utf-8");
     return true;
   } catch (error45) {
     log(`[${MISSION_CONTROL.LOG_SOURCE}] Failed to write state: ${error45}`);
@@ -19749,7 +20866,7 @@ function writeLoopState(directory, state2) {
 }
 function clearLoopState(directory) {
   const filePath = getStateFilePath(directory);
-  if (!existsSync4(filePath)) {
+  if (!existsSync5(filePath)) {
     return false;
   }
   try {
@@ -19781,6 +20898,7 @@ function startMissionLoop(directory, sessionID, prompt, options = {}) {
   };
   const success2 = writeLoopState(directory, state2);
   if (success2) {
+    TerminalMonitor.getInstance().start();
     log(`[${MISSION_CONTROL.LOG_SOURCE}] Loop started`, {
       sessionID,
       maxIterations: state2.maxIterations
@@ -19807,29 +20925,12 @@ function generateMissionContinuationPrompt(state2, verificationSummary) {
   const summaryHeader = verificationSummary ? `
 [Verification Status]: ${verificationSummary}
 ` : "";
-  return `<mission_loop iteration="${state2.iteration}" max="${state2.maxIterations}">
+  return `${CONTINUE_INSTRUCTION}
+
+<mission_loop iteration="${state2.iteration}" max="${state2.maxIterations}">
 \u26A0\uFE0F **MISSION NOT COMPLETE** - Iteration ${state2.iteration}/${state2.maxIterations}
 ${summaryHeader}
 
-The mission is INCOMPLETE. You MUST continue working NOW.
-
-**HIERARCHICAL TODO MANDATE**:
-Your work is strictly governed by the hierarchy in \`.opencode/todo.md\`.
-1\uFE0F\u20E3 **Milestones (Grade 1)**: Large phases of the mission.
-2\uFE0F\u20E3 **Tasks (Grade 2)**: Sub-tasks within milestones.
-3\uFE0F\u20E3 **Sub-tasks (Grade 3)**: Atomic actions.
-
-**CONCLUDING RULES**:
-\u274C Do NOT stop if there are ANY \`[ ]\` items remaining.
-\u274C Do NOT ask for permission to continue.
-\u274C Do NOT declare completion without verifying EVERY leaf node.
-
-**REQUIRED SEQUENCE**:
-1. Read \`.opencode/todo.md\` to identify the next \`[ ]\` item.
-2. If the plan is too abstract, breakdown the next task into smaller sub-tasks.
-3. Execute and mark as \`[x]\` ONLY after verification.
-4. Move to the next item immediately.
-
 **Your Original Task**:
 ${state2.prompt}
 
@@ -19848,7 +20949,7 @@ function getLatest(sessionId) {
   const history = progressHistory.get(sessionId);
   return history?.[history.length - 1];
 }
-function clearSession(sessionId) {
+function clearSession2(sessionId) {
   progressHistory.delete(sessionId);
   sessionStartTimes.delete(sessionId);
 }
@@ -19913,8 +21014,8 @@ function formatElapsedTime(startMs, endMs = Date.now()) {
 }
 
 // src/core/loop/verification.ts
-import { existsSync as existsSync5, readFileSync as readFileSync2 } from "node:fs";
-import { join as join6 } from "node:path";
+import { existsSync as existsSync6, readFileSync as readFileSync3 } from "node:fs";
+import { join as join8 } from "node:path";
 var CHECKLIST_FILE = CHECKLIST.FILE;
 function parseChecklistLine(line, currentCategory) {
   const trimmedLine = line.trim();
@@ -19979,12 +21080,12 @@ function parseChecklist(content) {
   return items;
 }
 function readChecklist(directory) {
-  const filePath = join6(directory, CHECKLIST_FILE);
-  if (!existsSync5(filePath)) {
+  const filePath = join8(directory, CHECKLIST_FILE);
+  if (!existsSync6(filePath)) {
     return [];
   }
   try {
-    const content = readFileSync2(filePath, "utf-8");
+    const content = readFileSync3(filePath, "utf-8");
     return parseChecklist(content);
   } catch (error45) {
     log(`[checklist] Failed to read checklist: ${error45}`);
@@ -20001,8 +21102,8 @@ function verifyChecklist(directory) {
     incompleteList: [],
     errors: []
   };
-  const filePath = join6(directory, CHECKLIST_FILE);
-  if (!existsSync5(filePath)) {
+  const filePath = join8(directory, CHECKLIST_FILE);
+  if (!existsSync6(filePath)) {
     result.errors.push(`Verification checklist not found at ${CHECKLIST_FILE}`);
     result.errors.push("Create checklist with at least: build, tests, and any environment-specific checks");
     return result;
@@ -20078,10 +21179,10 @@ function verifyMissionCompletion(directory) {
       result.errors.push(`  ... and ${checklistResult.incompleteList.length - 5} more`);
     }
   }
-  const todoPath = join6(directory, PATHS.TODO);
-  if (existsSync5(todoPath)) {
+  const todoPath = join8(directory, PATHS.TODO);
+  if (existsSync6(todoPath)) {
     try {
-      const content = readFileSync2(todoPath, "utf-8");
+      const content = readFileSync3(todoPath, "utf-8");
       const incompleteCount = countMatches(content, TODO_INCOMPLETE_PATTERN);
       const completeCount = countMatches(content, TODO_COMPLETE_PATTERN);
       const total = incompleteCount + completeCount;
@@ -20103,10 +21204,10 @@ function verifyMissionCompletion(directory) {
   } else if (!hasChecklist) {
     result.errors.push(`TODO file not found at ${PATHS.TODO}`);
   }
-  const syncPath = join6(directory, PATHS.SYNC_ISSUES);
-  if (existsSync5(syncPath)) {
+  const syncPath = join8(directory, PATHS.SYNC_ISSUES);
+  if (existsSync6(syncPath)) {
     try {
-      const content = readFileSync2(syncPath, "utf-8");
+      const content = readFileSync3(syncPath, "utf-8");
       result.syncIssuesEmpty = !hasRealSyncIssues(content);
       if (!result.syncIssuesEmpty) {
         const issueLines = content.split("\n").filter(
@@ -20241,10 +21342,10 @@ async function resolveCommandPath(key, commandName) {
   const currentPending = pending.get(key);
   if (currentPending) return currentPending;
   const promise2 = (async () => {
-    const path6 = await findCommand(commandName);
-    cache[key] = path6;
+    const path9 = await findCommand(commandName);
+    cache[key] = path9;
     pending.delete(key);
-    return path6;
+    return path9;
   })();
   pending.set(key, promise2);
   return promise2;
@@ -20253,21 +21354,21 @@ async function resolveCommandPath(key, commandName) {
 // src/core/notification/os-notify/notifier.ts
 var execAsync2 = promisify2(exec2);
 async function notifyDarwin(title, message) {
-  const path6 = await resolveCommandPath(
+  const path9 = await resolveCommandPath(
     NOTIFICATION_COMMAND_KEYS.OSASCRIPT,
     NOTIFICATION_COMMANDS.OSASCRIPT
   );
-  if (!path6) return;
+  if (!path9) return;
   const escT = title.replace(/"/g, '\\"');
   const escM = message.replace(/"/g, '\\"');
-  await execAsync2(`${path6} -e 'display notification "${escM}" with title "${escT}" sound name "Glass"'`);
+  await execAsync2(`${path9} -e 'display notification "${escM}" with title "${escT}" sound name "Glass"'`);
 }
 async function notifyLinux(title, message) {
-  const path6 = await resolveCommandPath(
+  const path9 = await resolveCommandPath(
     NOTIFICATION_COMMAND_KEYS.NOTIFY_SEND,
     NOTIFICATION_COMMANDS.NOTIFY_SEND
   );
-  if (path6) await execAsync2(`${path6} "${title}" "${message}" 2>/dev/null`);
+  if (path9) await execAsync2(`${path9} "${title}" "${message}" 2>/dev/null`);
 }
 async function notifyWindows(title, message) {
   const ps = await resolveCommandPath(
@@ -20313,11 +21414,11 @@ import { exec as exec3 } from "node:child_process";
 async function playDarwin(soundPath) {
   if (!soundPath) return;
   try {
-    const path6 = await resolveCommandPath(
+    const path9 = await resolveCommandPath(
       NOTIFICATION_COMMAND_KEYS.AFPLAY,
       NOTIFICATION_COMMANDS.AFPLAY
     );
-    if (path6) exec3(`"${path6}" "${soundPath}"`);
+    if (path9) exec3(`"${path9}" "${soundPath}"`);
   } catch (err) {
     log(`[session-notify] Error playing sound (Darwin): ${err}`);
   }
@@ -20387,7 +21488,7 @@ function getDefaultSoundPath(p) {
 
 // src/hooks/features/mission-loop.ts
 var MissionControlHook = class {
-  name = HOOK_NAMES.MISSION_LOOP;
+  name = HOOK_NAMES2.MISSION_LOOP;
   async execute(ctx, text) {
     const chatResult = await this.handleChatCommand(ctx, text);
     if (chatResult) return chatResult;
@@ -20473,6 +21574,7 @@ var MissionControlHook = class {
   async handleMissionComplete(directory, verification) {
     log(MISSION_MESSAGES.COMPLETE_LOG + " " + buildVerificationSummary(verification));
     const cleared = clearLoopState(directory);
+    parallelAgentManager.cleanup();
     if (cleared) {
       const toastManager = getTaskToastManager();
       if (toastManager) {
@@ -20535,7 +21637,7 @@ var UI_PATTERNS = {
 
 // src/hooks/custom/strict-role-guard.ts
 var StrictRoleGuardHook = class {
-  name = HOOK_NAMES.STRICT_ROLE_GUARD;
+  name = HOOK_NAMES2.STRICT_ROLE_GUARD;
   async execute(ctx, tool2, args) {
     if (tool2 === TOOL_NAMES.RUN_COMMAND || tool2 === TOOL_NAMES.RUN_BACKGROUND) {
       const cmd = args?.command;
@@ -20554,7 +21656,7 @@ var StrictRoleGuardHook = class {
 
 // src/hooks/custom/secret-scanner.ts
 var SecretScannerHook = class {
-  name = HOOK_NAMES.SECRET_SCANNER;
+  name = HOOK_NAMES2.SECRET_SCANNER;
   async execute(ctx, tool2, input, output) {
     let content = output.output;
     let modified = false;
@@ -20573,7 +21675,7 @@ var SecretScannerHook = class {
 
 // src/hooks/custom/agent-ui.ts
 var AgentUIHook = class {
-  name = HOOK_NAMES.AGENT_UI;
+  name = HOOK_NAMES2.AGENT_UI;
   async execute(ctx, tool2, input, output) {
     if (tool2 !== TOOL_NAMES.CALL_AGENT) return {};
     if (input?.task) {
@@ -20693,7 +21795,7 @@ function cleanupSession(sessionID) {
 var COMPACTION_THRESHOLD = CONTEXT_THRESHOLDS.WARNING;
 var COOLDOWN_MS = 10 * 60 * 1e3;
 var ResourceControlHook = class {
-  name = HOOK_NAMES.RESOURCE_CONTROL;
+  name = HOOK_NAMES2.RESOURCE_CONTROL;
   lastCompactionTime = /* @__PURE__ */ new Map();
   async execute(ctx, toolOrText, input, output) {
     let inputLen = 0;
@@ -20758,7 +21860,7 @@ function getNextPending(todos) {
   pending2.sort((a, b) => priorityOrder[a.priority] - priorityOrder[b.priority]);
   return pending2[0];
 }
-function getStats2(todos) {
+function getStats3(todos) {
   const stats2 = {
     total: todos.length,
     pending: todos.filter((t) => t.status === TODO_STATUS2.PENDING).length,
@@ -20777,7 +21879,7 @@ function getStats2(todos) {
 
 // src/core/loop/formatters.ts
 function formatProgress(todos) {
-  const stats2 = getStats2(todos);
+  const stats2 = getStats3(todos);
   const done = stats2.completed + stats2.cancelled;
   return `${done}/${stats2.total} (${stats2.percentComplete}%)`;
 }
@@ -20841,110 +21943,6 @@ ${LOOP_LABELS.ACTION_DONT_STOP}
   return prompt;
 }
 
-// src/core/recovery/constants.ts
-var MAX_RETRIES = RECOVERY.MAX_ATTEMPTS;
-var BASE_DELAY = RECOVERY.BASE_DELAY_MS;
-var MAX_HISTORY = HISTORY.MAX_RECOVERY;
-
-// src/core/recovery/patterns.ts
-var errorPatterns = [
-  // Rate limiting
-  {
-    pattern: /rate.?limit|too.?many.?requests|429/i,
-    category: "rate_limit",
-    handler: (ctx) => {
-      const delay = BASE_DELAY * Math.pow(2, ctx.attempt);
-      presets_exports.warningRateLimited();
-      return { type: "retry", delay, attempt: ctx.attempt + 1 };
-    }
-  },
-  // Context overflow
-  {
-    pattern: /context.?length|token.?limit|maximum.?context/i,
-    category: "context_overflow",
-    handler: () => {
-      presets_exports.errorRecovery("Compacting context");
-      return { type: "compact", reason: "Context limit reached" };
-    }
-  },
-  // Network errors
-  {
-    pattern: /ECONNREFUSED|ETIMEDOUT|network|fetch.?failed/i,
-    category: "network",
-    handler: (ctx) => {
-      if (ctx.attempt >= MAX_RETRIES) {
-        return { type: "abort", reason: "Network unavailable after retries" };
-      }
-      return { type: "retry", delay: BASE_DELAY * (ctx.attempt + 1), attempt: ctx.attempt + 1 };
-    }
-  },
-  // Session errors
-  {
-    pattern: /session.?not.?found|session.?expired/i,
-    category: "session",
-    handler: () => {
-      return { type: "abort", reason: "Session no longer available" };
-    }
-  },
-  // Tool errors
-  {
-    pattern: /tool.?not.?found|unknown.?tool/i,
-    category: "tool",
-    handler: (ctx) => {
-      return { type: "escalate", to: "Reviewer", reason: `Unknown tool used by ${ctx.agent}` };
-    }
-  },
-  // Parse errors
-  {
-    pattern: /parse.?error|invalid.?json|syntax.?error/i,
-    category: "parse",
-    handler: (ctx) => {
-      if (ctx.attempt >= 2) {
-        return { type: "skip", reason: "Persistent parse error" };
-      }
-      return { type: "retry", delay: 500, attempt: ctx.attempt + 1 };
-    }
-  },
-  // Gibberish / hallucination
-  {
-    pattern: /gibberish|hallucination|mixed.?language/i,
-    category: "gibberish",
-    handler: () => {
-      presets_exports.errorRecovery("Retrying with clean context");
-      return { type: "retry", delay: 1e3, attempt: 1 };
-    }
-  }
-];
-
-// src/core/recovery/handler.ts
-var recoveryHistory = [];
-function handleError(context) {
-  const errorMessage = context.error.message || String(context.error);
-  for (const pattern of errorPatterns) {
-    const matches = typeof pattern.pattern === "string" ? errorMessage.includes(pattern.pattern) : pattern.pattern.test(errorMessage);
-    if (matches) {
-      const action = pattern.handler(context);
-      recoveryHistory.push({
-        context,
-        action,
-        timestamp: /* @__PURE__ */ new Date()
-      });
-      if (recoveryHistory.length > MAX_HISTORY) {
-        recoveryHistory.shift();
-      }
-      return action;
-    }
-  }
-  if (context.attempt < MAX_RETRIES) {
-    return {
-      type: "retry",
-      delay: BASE_DELAY * Math.pow(2, context.attempt),
-      attempt: context.attempt + 1
-    };
-  }
-  return { type: "abort", reason: `Unknown error after ${MAX_RETRIES} retries` };
-}
-
 // src/core/recovery/session-recovery.ts
 var recoveryState = /* @__PURE__ */ new Map();
 function getState2(sessionID) {
@@ -21292,7 +22290,7 @@ function cleanupSession2(sessionID) {
 
 // src/hooks/custom/user-activity.ts
 var UserActivityHook = class {
-  name = HOOK_NAMES.USER_ACTIVITY;
+  name = HOOK_NAMES2.USER_ACTIVITY;
   async execute(ctx, message) {
     if (ctx.sessionID) {
       handleUserMessage(ctx.sessionID);
@@ -21301,6 +22299,70 @@ var UserActivityHook = class {
   }
 };
 
+// src/hooks/custom/memory-gate.ts
+var MemoryGateHook = class {
+  name = HOOK_NAMES.MEMORY_GATE;
+  memoryManager = MemoryManager.getInstance();
+  async execute(context, toolOrText, input, output) {
+    if (output) {
+      return this.handlePostTool(context, toolOrText, input, output);
+    } else {
+      return this.handleAssistantDone(context, toolOrText);
+    }
+  }
+  /**
+   * Post-Tool: Capture tool outputs to TASK memory
+   */
+  async handlePostTool(context, tool2, input, output) {
+    if (MEMORY_CONSTANTS.NOISY_TOOLS.includes(tool2)) return {};
+    const maxContentLength = MEMORY_CONSTANTS.MAX_CONTENT_LENGTH;
+    let content = output.output;
+    if (content.length > maxContentLength) {
+      content = content.substring(0, maxContentLength) + "... [truncated]";
+    }
+    const memoryText = `Tool [${tool2}] result for input ${JSON.stringify(input)}: ${content}`;
+    this.memoryManager.add("task" /* TASK */, memoryText, MEMORY_CONSTANTS.IMPORTANCE.LOW);
+    return {};
+  }
+  /**
+   * Assistant Done: Capture turn summary to MISSION memory if important
+   */
+  async handleAssistantDone(context, finalText) {
+    const { KEYWORDS, IMPORTANCE } = MEMORY_CONSTANTS;
+    if (finalText.includes(KEYWORDS.DONE) || finalText.includes(KEYWORDS.SUCCESS) || finalText.includes(KEYWORDS.ERROR)) {
+      const importance = finalText.includes(KEYWORDS.ERROR) ? IMPORTANCE.CRITICAL : IMPORTANCE.HIGH;
+      const summary = finalText.length > 500 ? finalText.substring(0, 500) + "..." : finalText;
+      this.memoryManager.add("mission" /* MISSION */, `Agent [${context.agent}] turn summary: ${summary}`, importance);
+    }
+    return { action: HOOK_ACTIONS.CONTINUE };
+  }
+};
+
+// src/hooks/custom/metrics.ts
+var MetricsHook = class {
+  name = HOOK_NAMES.METRICS_TELEMETRY;
+  startTimes = /* @__PURE__ */ new Map();
+  metrics = MetricsCollector.getInstance();
+  async execute(context, toolOrText, input, output) {
+    if (!output && input) {
+      this.startTimes.set(`tool_${toolOrText}_${context.sessionID}`, Date.now());
+      return { action: HOOK_ACTIONS.ALLOW };
+    } else if (output) {
+      const startTime = this.startTimes.get(`tool_${toolOrText}_${context.sessionID}`);
+      if (startTime) {
+        const duration3 = Date.now() - startTime;
+        this.metrics.recordToolExecution(toolOrText, duration3);
+        this.startTimes.delete(`tool_${toolOrText}_${context.sessionID}`);
+      }
+      this.metrics.recordTokenUsage(output.output.length / 4);
+      return {};
+    } else {
+      this.metrics.recordTokenUsage(toolOrText.length / 4);
+      return { action: HOOK_ACTIONS.CONTINUE };
+    }
+  }
+};
+
 // src/hooks/index.ts
 function initializeHooks() {
   const registry2 = HookRegistry.getInstance();
@@ -21311,18 +22373,103 @@ function initializeHooks() {
   const agentUI = new AgentUIHook();
   const resourceControl = new ResourceControlHook();
   const userActivity = new UserActivityHook();
+  const memoryGate = new MemoryGateHook();
+  const metricsHook = new MetricsHook();
   registry2.registerChat(userActivity);
   registry2.registerChat(missionControl);
   registry2.registerPostTool(sanityCheck);
   registry2.registerPostTool(secretScanner);
   registry2.registerPostTool(agentUI);
   registry2.registerPostTool(resourceControl);
+  registry2.registerPostTool(memoryGate);
+  registry2.registerPostTool(metricsHook);
   registry2.registerPreTool(roleGuard);
+  registry2.registerPreTool(metricsHook);
   registry2.registerDone(sanityCheck);
   registry2.registerDone(missionControl);
   registry2.registerDone(resourceControl);
+  registry2.registerDone(memoryGate);
+  registry2.registerDone(metricsHook);
 }
 
+// src/core/plugins/plugin-manager.ts
+import * as fs8 from "fs/promises";
+import * as path7 from "path";
+var PluginManager = class _PluginManager {
+  static instance;
+  plugins = /* @__PURE__ */ new Map();
+  directory = "";
+  dynamicTools = {};
+  constructor() {
+  }
+  static getInstance() {
+    if (!_PluginManager.instance) {
+      _PluginManager.instance = new _PluginManager();
+    }
+    return _PluginManager.instance;
+  }
+  async initialize(directory) {
+    this.directory = directory;
+    await this.loadPlugins();
+  }
+  /**
+   * Load plugins from .opencode/plugins/*.js
+   */
+  async loadPlugins() {
+    if (!this.directory) return;
+    const pluginsDir = path7.join(this.directory, PATHS.PLUGINS);
+    try {
+      await fs8.mkdir(pluginsDir, { recursive: true });
+      const files = await fs8.readdir(pluginsDir);
+      for (const file2 of files) {
+        if (file2.endsWith(".js") || file2.endsWith(".mjs")) {
+          await this.loadPlugin(path7.join(pluginsDir, file2));
+        }
+      }
+    } catch (error45) {
+      log(`[PluginManager] Error reading plugins directory: ${error45}`);
+    }
+  }
+  async loadPlugin(pluginPath) {
+    try {
+      const module = await import(`file://${pluginPath}`);
+      const plugin = module.default || module;
+      if (!plugin.name) {
+        log(`[PluginManager] Plugin at ${pluginPath} missing name, skipping.`);
+        return;
+      }
+      log(`[PluginManager] Loading plugin: ${plugin.name} (v${plugin.version})`);
+      const context = { directory: this.directory };
+      if (plugin.init) {
+        await plugin.init(context);
+      }
+      if (plugin.tools) {
+        for (const [name, tool2] of Object.entries(plugin.tools)) {
+          this.dynamicTools[name] = tool2;
+          log(`[PluginManager] Registered tool: ${name} from plugin ${plugin.name}`);
+        }
+      }
+      if (plugin.hooks) {
+        const registry2 = HookRegistry.getInstance();
+        if (plugin.hooks.preTool) registry2.registerPreTool(plugin.hooks.preTool);
+        if (plugin.hooks.postTool) registry2.registerPostTool(plugin.hooks.postTool);
+        if (plugin.hooks.chat) registry2.registerChat(plugin.hooks.chat);
+        if (plugin.hooks.done) registry2.registerDone(plugin.hooks.done);
+        log(`[PluginManager] Registered hooks from plugin ${plugin.name}`);
+      }
+      this.plugins.set(plugin.name, plugin);
+    } catch (error45) {
+      log(`[PluginManager] Failed to load plugin ${pluginPath}: ${error45}`);
+    }
+  }
+  /**
+   * Get all dynamically registered tools
+   */
+  getDynamicTools() {
+    return this.dynamicTools;
+  }
+};
+
 // src/plugin-handlers/tool-execute-pre-handler.ts
 function createToolExecuteBeforeHandler(ctx) {
   const { sessions, directory } = ctx;
@@ -21381,17 +22528,17 @@ function createChatMessageHandler(ctx) {
 }
 
 // src/utils/compatibility/claude.ts
-import fs6 from "fs";
-import path5 from "path";
+import fs9 from "fs";
+import path8 from "path";
 function findClaudeRules(startDir = process.cwd()) {
   try {
     let currentDir = startDir;
-    const root = path5.parse(startDir).root;
+    const root = path8.parse(startDir).root;
     while (true) {
-      const claudeMdPath = path5.join(currentDir, "CLAUDE.md");
-      if (fs6.existsSync(claudeMdPath)) {
+      const claudeMdPath = path8.join(currentDir, "CLAUDE.md");
+      if (fs9.existsSync(claudeMdPath)) {
         try {
-          const content = fs6.readFileSync(claudeMdPath, "utf-8");
+          const content = fs9.readFileSync(claudeMdPath, "utf-8");
           log(`[compatibility] Loaded CLAUDE.md from ${claudeMdPath}`);
           return formatRules("CLAUDE.md", content);
         } catch (e) {
@@ -21399,11 +22546,11 @@ function findClaudeRules(startDir = process.cwd()) {
         }
       }
       if (currentDir === root) break;
-      currentDir = path5.dirname(currentDir);
+      currentDir = path8.dirname(currentDir);
     }
-    const copilotPath = path5.join(startDir, ".github", "copilot-instructions.md");
-    if (fs6.existsSync(copilotPath)) {
-      return formatRules("Copilot Instructions", fs6.readFileSync(copilotPath, "utf-8"));
+    const copilotPath = path8.join(startDir, ".github", "copilot-instructions.md");
+    if (fs9.existsSync(copilotPath)) {
+      return formatRules("Copilot Instructions", fs9.readFileSync(copilotPath, "utf-8"));
     }
     return null;
   } catch (error45) {
@@ -21686,7 +22833,7 @@ function createEventHandler(ctx) {
         const duration3 = totalTime < 6e4 ? `${Math.round(totalTime / 1e3)}s` : `${Math.round(totalTime / 6e4)}m`;
         sessions.delete(sessionID);
         state2.sessions.delete(sessionID);
-        clearSession(sessionID);
+        clearSession2(sessionID);
         cleanupSessionRecovery(sessionID);
         cleanupSession2(sessionID);
         cleanupSession3(sessionID);
@@ -21998,6 +23145,9 @@ var OrchestratorPlugin = async (input) => {
   const sessions = /* @__PURE__ */ new Map();
   const parallelAgentManager2 = ParallelAgentManager.getInstance(client, directory);
   const asyncAgentTools = createAsyncAgentTools(parallelAgentManager2, client);
+  const pluginManager = PluginManager.getInstance();
+  await pluginManager.initialize(directory);
+  const dynamicTools = pluginManager.getDynamicTools();
   taskToastManager.setConcurrencyController(parallelAgentManager2.getConcurrency());
   const handlerContext = {
     client,
@@ -22044,7 +23194,9 @@ var OrchestratorPlugin = async (input) => {
       [TOOL_NAMES.AST_SEARCH]: astSearchTool(directory),
       [TOOL_NAMES.AST_REPLACE]: astReplaceTool(directory),
       // Async agent tools
-      ...asyncAgentTools
+      ...asyncAgentTools,
+      // Dynamic tools from plugins
+      ...dynamicTools
     },
     // -----------------------------------------------------------------
     // Config hook - registers our commands and agents with OpenCode