opencode-orchestrator 1.2.13 → 1.2.15

package/dist/index.js

@@ -417,6 +417,10 @@ var init_memory_hooks = __esm({
         COMPLETED: "completed",
         PROGRESS: "progress",
         FAILED: "failed"
+      },
+      PREFIX: {
+        TASK: "task-",
+        FILE: "file-task-"
       }
     };
   }
@@ -861,8 +865,8 @@ var init_types4 = __esm({
 });
 
 // src/core/notification/toast-core.ts
-function initToastClient(client) {
-  tuiClient = client;
+function initToastClient(client2) {
+  tuiClient = client2;
 }
 function show(options) {
   const toast = {
@@ -885,9 +889,9 @@ function show(options) {
     }
   }
   if (tuiClient) {
-    const client = tuiClient;
-    if (client.tui?.showToast) {
-      client.tui.showToast({
+    const client2 = tuiClient;
+    if (client2.tui?.showToast) {
+      client2.tui.showToast({
         body: {
           title: toast.title,
           message: toast.message,
@@ -18819,6 +18823,75 @@ Use \`get_task_result({ taskId: "task_xxx" })\` to retrieve results.
 </system-notification>`;
 }
 
+// src/core/session/session-health.ts
+var sessionHealth = /* @__PURE__ */ new Map();
+var STALE_THRESHOLD_MS = 12e4;
+var HEALTH_CHECK_INTERVAL_MS = 3e4;
+var WARNING_THRESHOLD_MS = 6e4;
+var healthCheckTimer;
+var client;
+function recordSessionResponse(sessionID) {
+  const health = sessionHealth.get(sessionID);
+  if (health) {
+    health.lastResponseTime = Date.now();
+    health.isStale = false;
+  }
+}
+function isSessionStale(sessionID) {
+  const health = sessionHealth.get(sessionID);
+  if (!health) return false;
+  return health.isStale;
+}
+function startHealthCheck(opencodeClient) {
+  if (healthCheckTimer) {
+    log("[session-health] Health check already running");
+    return;
+  }
+  client = opencodeClient;
+  healthCheckTimer = setInterval(() => {
+    performHealthCheck();
+  }, HEALTH_CHECK_INTERVAL_MS);
+  log("[session-health] Health check started", {
+    intervalMs: HEALTH_CHECK_INTERVAL_MS,
+    staleThresholdMs: STALE_THRESHOLD_MS
+  });
+}
+function stopHealthCheck() {
+  if (healthCheckTimer) {
+    clearInterval(healthCheckTimer);
+    healthCheckTimer = void 0;
+    log("[session-health] Health check stopped");
+  }
+}
+function performHealthCheck() {
+  const now = Date.now();
+  const warnings = [];
+  const stales = [];
+  for (const [sessionID, health] of sessionHealth) {
+    const elapsed = now - health.lastResponseTime;
+    if (elapsed > WARNING_THRESHOLD_MS && elapsed <= STALE_THRESHOLD_MS && !health.isStale) {
+      warnings.push(sessionID.slice(0, 8));
+    }
+    if (elapsed > STALE_THRESHOLD_MS && !health.isStale) {
+      health.isStale = true;
+      stales.push(sessionID.slice(0, 8));
+    }
+  }
+  if (warnings.length > 0) {
+    log("[session-health] Sessions approaching stale threshold", {
+      sessions: warnings
+    });
+  }
+  if (stales.length > 0) {
+    log("[session-health] Sessions marked as stale", {
+      sessions: stales
+    });
+  }
+}
+function cleanupSessionHealth(sessionID) {
+  sessionHealth.delete(sessionID);
+}
+
 // src/core/agents/manager/task-launcher.ts
 init_shared();
 init_shared();
@@ -18833,8 +18906,8 @@ var TaskToastManager = class {
   /**
    * Initialize the manager with OpenCode client
    */
-  init(client, concurrency) {
-    this.client = client;
+  init(client2, concurrency) {
+    this.client = client2;
     this.concurrency = concurrency ?? null;
   }
   /**
@@ -19094,11 +19167,11 @@ var instance = null;
 function getTaskToastManager() {
   return instance;
 }
-function initTaskToastManager(client, concurrency) {
+function initTaskToastManager(client2, concurrency) {
   if (!instance) {
     instance = new TaskToastManager();
   }
-  instance.init(client, concurrency);
+  instance.init(client2, concurrency);
   return instance;
 }
 
@@ -33310,8 +33383,8 @@ var AgentRegistry = class _AgentRegistry {
 
 // src/core/agents/manager/task-launcher.ts
 var TaskLauncher = class {
-  constructor(client, directory, store, concurrency, sessionPool2, onTaskError, startPolling) {
-    this.client = client;
+  constructor(client2, directory, store, concurrency, sessionPool2, onTaskError, startPolling) {
+    this.client = client2;
     this.directory = directory;
     this.store = store;
     this.concurrency = concurrency;
@@ -33471,8 +33544,8 @@ ${action.modifyPrompt}`;
 // src/core/agents/manager/task-resumer.ts
 init_shared();
 var TaskResumer = class {
-  constructor(client, store, findBySession, startPolling, notifyParentIfAllComplete) {
-    this.client = client;
+  constructor(client2, store, findBySession, startPolling, notifyParentIfAllComplete) {
+    this.client = client2;
     this.store = store;
     this.findBySession = findBySession;
     this.startPolling = startPolling;
@@ -33624,15 +33697,17 @@ var ProgressNotifier = class _ProgressNotifier {
 var progressNotifier = ProgressNotifier.getInstance();
 
 // src/core/agents/manager/task-poller.ts
+var MAX_TASK_DURATION_MS = 6e5;
 var TaskPoller = class {
-  constructor(client, store, concurrency, notifyParentIfAllComplete, scheduleCleanup, pruneExpiredTasks, onTaskComplete) {
-    this.client = client;
+  constructor(client2, store, concurrency, notifyParentIfAllComplete, scheduleCleanup, pruneExpiredTasks, onTaskComplete, onTaskError) {
+    this.client = client2;
     this.store = store;
     this.concurrency = concurrency;
     this.notifyParentIfAllComplete = notifyParentIfAllComplete;
     this.scheduleCleanup = scheduleCleanup;
     this.pruneExpiredTasks = pruneExpiredTasks;
     this.onTaskComplete = onTaskComplete;
+    this.onTaskError = onTaskError;
   }
   pollingInterval;
   messageCache = /* @__PURE__ */ new Map();
@@ -33664,6 +33739,17 @@ var TaskPoller = class {
       const allStatuses = statusResult.data ?? {};
       for (const task of running) {
         try {
+          const taskDuration = Date.now() - task.startedAt.getTime();
+          if (isSessionStale(task.sessionID)) {
+            log(`[task-poller] Task ${task.id} session is stale. Marking as error.`);
+            this.onTaskError?.(task.id, new Error("Session became stale (no response from agent)"));
+            continue;
+          }
+          if (taskDuration > MAX_TASK_DURATION_MS) {
+            log(`[task-poller] Task ${task.id} exceeded max duration (${MAX_TASK_DURATION_MS}ms). Marking as error.`);
+            this.onTaskError?.(task.id, new Error("Task exceeded maximum execution time"));
+            continue;
+          }
           if (task.status === TASK_STATUS.PENDING) continue;
           const sessionStatus = allStatuses[task.sessionID];
           if (sessionStatus?.type === SESSION_STATUS.IDLE) {
@@ -33776,8 +33862,8 @@ var TaskPoller = class {
 init_shared();
 init_store();
 var TaskCleaner = class {
-  constructor(client, store, concurrency, sessionPool2) {
-    this.client = client;
+  constructor(client2, store, concurrency, sessionPool2) {
+    this.client = client2;
     this.store = store;
     this.concurrency = concurrency;
     this.sessionPool = sessionPool2;
@@ -33888,9 +33974,69 @@ You will be notified when ALL tasks complete. Continue productive work.`;
 
 // src/core/agents/manager/event-handler.ts
 init_shared();
+
+// src/core/loop/continuation-lock.ts
+var locks = /* @__PURE__ */ new Map();
+var LOCK_TIMEOUT_MS = 3e4;
+function tryAcquireContinuationLock(sessionID, source) {
+  const now = Date.now();
+  const existing = locks.get(sessionID);
+  if (existing?.acquired) {
+    const elapsed = now - existing.timestamp;
+    if (elapsed < LOCK_TIMEOUT_MS) {
+      log("[continuation-lock] Lock denied - already held", {
+        sessionID: sessionID.slice(0, 8),
+        heldBy: existing.source,
+        requestedBy: source,
+        elapsedMs: elapsed
+      });
+      return false;
+    }
+    log("[continuation-lock] Forcing stale lock release", {
+      sessionID: sessionID.slice(0, 8),
+      staleSource: existing.source,
+      elapsedMs: elapsed
+    });
+  }
+  locks.set(sessionID, { acquired: true, timestamp: now, source });
+  log("[continuation-lock] Lock acquired", {
+    sessionID: sessionID.slice(0, 8),
+    source
+  });
+  return true;
+}
+function releaseContinuationLock(sessionID) {
+  const existing = locks.get(sessionID);
+  if (existing?.acquired) {
+    const duration5 = Date.now() - existing.timestamp;
+    log("[continuation-lock] Lock released", {
+      sessionID: sessionID.slice(0, 8),
+      source: existing.source,
+      heldMs: duration5
+    });
+  }
+  locks.delete(sessionID);
+}
+function hasContinuationLock(sessionID) {
+  const lock = locks.get(sessionID);
+  if (!lock?.acquired) return false;
+  if (Date.now() - lock.timestamp >= LOCK_TIMEOUT_MS) {
+    log("[continuation-lock] Stale lock detected during check", {
+      sessionID: sessionID.slice(0, 8)
+    });
+    locks.delete(sessionID);
+    return false;
+  }
+  return true;
+}
+function cleanupContinuationLock(sessionID) {
+  locks.delete(sessionID);
+}
+
+// src/core/agents/manager/event-handler.ts
 var EventHandler = class {
-  constructor(client, store, concurrency, findBySession, notifyParentIfAllComplete, scheduleCleanup, validateSessionHasOutput2, onTaskComplete) {
-    this.client = client;
+  constructor(client2, store, concurrency, findBySession, notifyParentIfAllComplete, scheduleCleanup, validateSessionHasOutput2, onTaskComplete) {
+    this.client = client2;
     this.store = store;
     this.concurrency = concurrency;
     this.findBySession = findBySession;
@@ -33908,6 +34054,7 @@ var EventHandler = class {
     if (event.type === SESSION_EVENTS.IDLE) {
       const sessionID = props?.sessionID;
       if (!sessionID) return;
+      recordSessionResponse(sessionID);
       const task = this.findBySession(sessionID);
       if (!task || task.status !== TASK_STATUS.RUNNING) return;
       this.handleSessionIdle(task).catch((err) => {
@@ -33969,6 +34116,8 @@ var EventHandler = class {
     this.store.delete(task.id);
     taskWAL.log(WAL_ACTIONS.DELETE, task).catch(() => {
     });
+    cleanupSessionHealth(task.sessionID);
+    cleanupContinuationLock(task.sessionID);
     progressNotifier.update();
     log(`Cleaned up deleted session task: ${task.id}`);
   }
@@ -33998,18 +34147,18 @@ var SessionPool = class _SessionPool {
     reuseHits: 0,
     creationMisses: 0
   };
-  constructor(client, directory, config3 = {}) {
-    this.client = client;
+  constructor(client2, directory, config3 = {}) {
+    this.client = client2;
     this.directory = directory;
     this.config = { ...DEFAULT_CONFIG, ...config3 };
     this.startHealthCheck();
   }
-  static getInstance(client, directory, config3) {
+  static getInstance(client2, directory, config3) {
     if (!_SessionPool._instance) {
-      if (!client || !directory) {
+      if (!client2 || !directory) {
         throw new Error("SessionPool requires client and directory on first call");
       }
-      _SessionPool._instance = new _SessionPool(client, directory, config3);
+      _SessionPool._instance = new _SessionPool(client2, directory, config3);
     }
     return _SessionPool._instance;
   }
@@ -34419,27 +34568,29 @@ var ParallelAgentManager = class _ParallelAgentManager {
   poller;
   cleaner;
   eventHandler;
-  constructor(client, directory) {
-    this.client = client;
+  constructor(client2, directory) {
+    this.client = client2;
     this.directory = directory;
+    startHealthCheck(client2);
     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.sessionPool = SessionPool.getInstance(client2, directory);
+    this.cleaner = new TaskCleaner(client2, this.store, this.concurrency, this.sessionPool);
     this.poller = new TaskPoller(
-      client,
+      client2,
       this.store,
       this.concurrency,
       (parentSessionID) => this.cleaner.notifyParentIfAllComplete(parentSessionID),
       (taskId) => this.cleaner.scheduleCleanup(taskId),
       () => this.cleaner.pruneExpiredTasks(),
-      (task) => this.handleTaskComplete(task)
+      (task) => this.handleTaskComplete(task),
+      (taskId, error92) => this.handleTaskError(taskId, error92)
     );
     this.launcher = new TaskLauncher(
-      client,
+      client2,
       directory,
       this.store,
       this.concurrency,
@@ -34448,14 +34599,14 @@ var ParallelAgentManager = class _ParallelAgentManager {
       () => this.poller.start()
     );
     this.resumer = new TaskResumer(
-      client,
+      client2,
       this.store,
       (sessionID) => this.findBySession(sessionID),
       () => this.poller.start(),
       (parentSessionID) => this.cleaner.notifyParentIfAllComplete(parentSessionID)
     );
     this.eventHandler = new EventHandler(
-      client,
+      client2,
       this.store,
       this.concurrency,
       (sessionID) => this.findBySession(sessionID),
@@ -34469,12 +34620,12 @@ var ParallelAgentManager = class _ParallelAgentManager {
       log("Recovery error:", err);
     });
   }
-  static getInstance(client, directory) {
+  static getInstance(client2, directory) {
     if (!_ParallelAgentManager._instance) {
-      if (!client || !directory) {
+      if (!client2 || !directory) {
         throw new Error("ParallelAgentManager requires client and directory on first call");
       }
-      _ParallelAgentManager._instance = new _ParallelAgentManager(client, directory);
+      _ParallelAgentManager._instance = new _ParallelAgentManager(client2, directory);
     }
     return _ParallelAgentManager._instance;
   }
@@ -34553,6 +34704,7 @@ var ParallelAgentManager = class _ParallelAgentManager {
   }
   cleanup() {
     this.poller.stop();
+    stopHealthCheck();
     this.store.clear();
     MemoryManager.getInstance().clearTaskMemory();
     Promise.resolve().then(() => (init_store(), store_exports)).then((store) => store.clearAll()).catch(() => {
@@ -34783,7 +34935,7 @@ async function extractSessionResult(session, sessionID) {
     return "(Error extracting result)";
   }
 }
-var createDelegateTaskTool = (manager, client) => tool({
+var createDelegateTaskTool = (manager, client2) => tool({
   description: `Delegate a task to an agent.
 
 ${PROMPT_TAGS.MODE.open}
@@ -34836,7 +34988,7 @@ If your task is too complex, please:
 2. Request task decomposition at the ${AGENT_NAMES.PLANNER} level
 3. Complete your assigned file directly without delegation`;
     }
-    const sessionClient = client;
+    const sessionClient = client2;
     if (background === void 0) {
       return `${OUTPUT_LABEL.ERROR} 'background' parameter is REQUIRED.`;
     }
@@ -35170,9 +35322,9 @@ var createUpdateTodoTool = () => tool({
 
 // src/tools/parallel/index.ts
 init_shared();
-function createAsyncAgentTools(manager, client) {
+function createAsyncAgentTools(manager, client2) {
   return {
-    [TOOL_NAMES.DELEGATE_TASK]: createDelegateTaskTool(manager, client),
+    [TOOL_NAMES.DELEGATE_TASK]: createDelegateTaskTool(manager, client2),
     [TOOL_NAMES.GET_TASK_RESULT]: createGetTaskResultTool(manager),
     [TOOL_NAMES.LIST_TASKS]: createListTasksTool(manager),
     [TOOL_NAMES.CANCEL_TASK]: createCancelTaskTool(manager),
@@ -36466,15 +36618,15 @@ var CONTINUE_INSTRUCTION = `<auto_continue>
 </auto_continue>`;
 var STAGNATION_INTERVENTION = `
 <system_intervention type="stagnation_detected">
-\u26A0\uFE0F **\uACBD\uACE0: \uC9C4\uD589 \uC815\uCCB4 \uAC10\uC9C0 (STAGNATION DETECTED)**
-\uCD5C\uADFC \uC5EC\uB7EC \uD134 \uB3D9\uC548 \uC2E4\uC9C8\uC801\uC778 \uC9C4\uC804\uC774 \uAC10\uC9C0\uB418\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4. \uB2E8\uC21C "\uBAA8\uB2C8\uD130\uB9C1"\uC774\uB098 \uAC19\uC740 \uD589\uB3D9\uC744 \uBC18\uBCF5\uD558\uB294 \uAC83\uC740 \uAE08\uC9C0\uB429\uB2C8\uB2E4.
+\u26A0\uFE0F **WARNING: STAGNATION DETECTED**
+No substantial progress has been detected for several turns. Simply "monitoring" or repeating the same actions is prohibited.
 
-**\uC790\uC728\uC801 \uC9C4\uB2E8 \uBC0F \uD574\uACB0 \uC9C0\uCE68:**
-1. **\uC2E4\uC2DC\uAC04 \uB85C\uADF8 \uD655\uC778**: \`check_background_task\` \uB610\uB294 \`read_file\`\uC744 \uC0AC\uC6A9\uD558\uC5EC \uC9C4\uD589 \uC911\uC778 \uC791\uC5C5\uC758 \uCD9C\uB825 \uB85C\uADF8\uB97C \uC9C1\uC811 \uD655\uC778\uD558\uC2ED\uC2DC\uC624.
-2. **\uD504\uB85C\uC138\uC2A4 \uC0DD\uC874 \uC9C4\uB2E8**: \uC791\uC5C5\uC774 \uC880\uBE44 \uC0C1\uD0DC\uC774\uAC70\uB098 \uBA48\uCD98 \uAC83 \uAC19\uB2E4\uBA74 \uACFC\uAC10\uD558\uAC8C \`kill\`\uD558\uACE0 \uB2E8\uACC4\uB97C \uC138\uBD84\uD654\uD558\uC5EC \uB2E4\uC2DC \uC2E4\uD589\uD558\uC2ED\uC2DC\uC624.
-3. **\uC804\uB7B5 \uC804\uD658**: \uB3D9\uC77C\uD55C \uC811\uADFC \uBC29\uC2DD\uC774 \uC2E4\uD328\uD558\uACE0 \uC788\uB2E4\uBA74, \uB2E4\uB978 \uB3C4\uAD6C\uB098 \uBC29\uBC95\uC744 \uC0AC\uC6A9\uD558\uC5EC \uBAA9\uD45C\uC5D0 \uB3C4\uB2EC\uD558\uC2ED\uC2DC\uC624.
+**Self-Diagnosis and Resolution Guidelines:**
+1. **Check Live Logs**: Use \`check_background_task\` or \`read_file\` to directly check the output logs of running tasks.
+2. **Process Health Diagnosis**: If a task appears to be a zombie or stuck, kill it immediately and restart it with more granular steps.
+3. **Strategy Pivot**: If the same approach keeps failing, use different tools or methods to reach the goal.
 
-**\uC9C0\uAE08 \uBC14\uB85C \uB2A5\uB3D9\uC801\uC73C\uB85C \uAC1C\uC785\uD558\uC2ED\uC2DC\uC624. \uB300\uAE30\uD558\uC9C0 \uB9C8\uC2ED\uC2DC\uC624.**
+**Intervene proactively NOW. Do NOT wait.**
 </system_intervention>`;
 var CLEANUP_INSTRUCTION = `
 <system_maintenance type="continuous_hygiene">
@@ -36823,8 +36975,27 @@ function formatElapsedTime(startMs, endMs = Date.now()) {
 // src/core/loop/verification.ts
 init_shared();
 import { existsSync as existsSync6, readFileSync as readFileSync2 } from "node:fs";
+import { access, readFile as readFile5 } from "node:fs/promises";
+import { constants } from "node:fs";
 import { join as join8 } from "node:path";
 var CHECKLIST_FILE = CHECKLIST.FILE;
+var fileCache = /* @__PURE__ */ new Map();
+var CACHE_TTL_MS = 5e3;
+async function readFileWithCache(filePath) {
+  const now = Date.now();
+  const cached3 = fileCache.get(filePath);
+  if (cached3 && now - cached3.timestamp < CACHE_TTL_MS) {
+    return cached3.content;
+  }
+  try {
+    await access(filePath, constants.R_OK);
+    const content = await readFile5(filePath, "utf-8");
+    fileCache.set(filePath, { content, timestamp: now });
+    return content;
+  } catch {
+    return null;
+  }
+}
 function parseChecklistLine(line, currentCategory) {
   const trimmedLine = line.trim();
   const idMatch = trimmedLine.match(CHECKLIST_PATTERNS.ITEM_WITH_ID);
@@ -36900,6 +37071,7 @@ function readChecklist(directory) {
     return [];
   }
 }
+var lastVerificationResult = /* @__PURE__ */ new Map();
 function verifyChecklist(directory) {
   const result = {
     passed: false,
@@ -36939,6 +37111,40 @@ function verifyChecklist(directory) {
   });
   return result;
 }
+async function verifyChecklistAsync(directory) {
+  const result = {
+    passed: false,
+    totalItems: 0,
+    completedItems: 0,
+    incompleteItems: 0,
+    progress: "0/0",
+    incompleteList: [],
+    errors: []
+  };
+  const filePath = join8(directory, CHECKLIST_FILE);
+  const content = await readFileWithCache(filePath);
+  if (!content) {
+    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;
+  }
+  const items = parseChecklist(content);
+  if (items.length === 0) {
+    result.errors.push("Verification checklist is empty");
+    result.errors.push("Add verification items (build, tests, environment checks)");
+    return result;
+  }
+  result.totalItems = items.length;
+  result.completedItems = items.filter((i) => i.completed).length;
+  result.incompleteItems = result.totalItems - result.completedItems;
+  result.progress = `${result.completedItems}/${result.totalItems}`;
+  result.incompleteList = items.filter((i) => !i.completed).map((i) => `[${CHECKLIST_CATEGORIES.LABELS[i.category]}] ${i.description}`);
+  if (result.incompleteItems > 0) {
+    result.errors.push(`Checklist incomplete: ${result.progress}`);
+  }
+  result.passed = result.incompleteItems === 0 && result.totalItems > 0;
+  return result;
+}
 var TODO_INCOMPLETE_PATTERN = /^[-*]\s*\[\s*\]/gm;
 var TODO_COMPLETE_PATTERN = /^[-*]\s*\[[xX]\]/gm;
 var SYNC_ISSUE_PATTERNS = [
@@ -36964,7 +37170,7 @@ function hasRealSyncIssues(content) {
   });
   return lines.length > 0;
 }
-function verifyMissionCompletion(directory) {
+function verifyMissionCompletionSync(directory) {
   const result = {
     passed: false,
     todoComplete: false,
@@ -37045,6 +37251,89 @@ function verifyMissionCompletion(directory) {
   });
   return result;
 }
+async function verifyMissionCompletionAsync(directory) {
+  const result = {
+    passed: false,
+    todoComplete: false,
+    todoProgress: "0/0",
+    todoIncomplete: 0,
+    syncIssuesEmpty: true,
+    syncIssuesCount: 0,
+    checklistComplete: false,
+    checklistProgress: "0/0",
+    errors: []
+  };
+  const checklistResult = await verifyChecklistAsync(directory);
+  result.checklistComplete = checklistResult.passed;
+  result.checklistProgress = checklistResult.progress;
+  const hasChecklist = checklistResult.totalItems > 0;
+  if (hasChecklist && !checklistResult.passed) {
+    result.errors.push(`Verification checklist incomplete: ${checklistResult.progress}`);
+    result.errors.push(...checklistResult.incompleteList.slice(0, 5).map((i) => `  - ${i}`));
+    if (checklistResult.incompleteList.length > 5) {
+      result.errors.push(`  ... and ${checklistResult.incompleteList.length - 5} more`);
+    }
+  }
+  const todoPath = join8(directory, PATHS.TODO);
+  const todoContent = await readFileWithCache(todoPath);
+  if (todoContent) {
+    try {
+      const incompleteCount = countMatches(todoContent, TODO_INCOMPLETE_PATTERN);
+      const completeCount = countMatches(todoContent, TODO_COMPLETE_PATTERN);
+      const total = incompleteCount + completeCount;
+      result.todoIncomplete = incompleteCount;
+      result.todoComplete = incompleteCount === 0 && total > 0;
+      result.todoProgress = `${completeCount}/${total}`;
+      if (!result.todoComplete && !hasChecklist) {
+        if (total === 0) {
+          result.errors.push("No TODO items found - create tasks first");
+        } else {
+          result.errors.push(
+            `TODO incomplete: ${result.todoProgress} (${incompleteCount} remaining)`
+          );
+        }
+      }
+    } catch (error92) {
+      result.errors.push(`Failed to read TODO: ${error92}`);
+    }
+  } else if (!hasChecklist) {
+    result.errors.push(`TODO file not found at ${PATHS.TODO}`);
+  }
+  const syncPath = join8(directory, PATHS.SYNC_ISSUES);
+  const syncContent = await readFileWithCache(syncPath);
+  if (syncContent) {
+    try {
+      result.syncIssuesEmpty = !hasRealSyncIssues(syncContent);
+      if (!result.syncIssuesEmpty) {
+        const issueLines = syncContent.split("\n").filter(
+          (l) => /^[-*]\s+\S/.test(l.trim()) || /ERROR|FAIL|CONFLICT/i.test(l)
+        );
+        result.syncIssuesCount = issueLines.length;
+        result.errors.push(
+          `Sync issues not resolved: ${result.syncIssuesCount} issue(s) remain`
+        );
+      }
+    } catch (error92) {
+      result.syncIssuesEmpty = true;
+    }
+  }
+  if (hasChecklist) {
+    result.passed = result.checklistComplete && result.syncIssuesEmpty;
+  } else {
+    result.passed = result.todoComplete && result.syncIssuesEmpty;
+  }
+  lastVerificationResult.set(directory, { result, timestamp: Date.now() });
+  return result;
+}
+function verifyMissionCompletion(directory) {
+  const cached3 = lastVerificationResult.get(directory);
+  if (cached3 && Date.now() - cached3.timestamp < CACHE_TTL_MS) {
+    return cached3.result;
+  }
+  const result = verifyMissionCompletionSync(directory);
+  lastVerificationResult.set(directory, { result, timestamp: Date.now() });
+  return result;
+}
 function buildVerificationFailurePrompt(result) {
   const errorList = result.errors.map((e) => `\u274C ${e}`).join("\n");
   const hasChecklist = result.checklistProgress !== "0/0";
@@ -37813,11 +38102,18 @@ There was a temporary processing issue. Please continue from where you left off.
 3. Continue execution
 </action>
 </recovery>`;
-async function handleSessionError(client, sessionID, error92, properties) {
+async function handleSessionError(client2, sessionID, error92, properties) {
   const state2 = getState2(sessionID);
   if (state2.isRecovering) {
-    log("[session-recovery] Already recovering, skipping", { sessionID });
-    return false;
+    const RECOVERY_TIMEOUT_MS = 1e4;
+    const elapsed = Date.now() - (state2.recoveryStartTime ?? 0);
+    if (elapsed > RECOVERY_TIMEOUT_MS) {
+      log("[session-recovery] Forcibly clearing stale recovery state", { sessionID, elapsed });
+      state2.isRecovering = false;
+    } else {
+      log("[session-recovery] Already recovering, skipping", { sessionID });
+      return false;
+    }
   }
   const now = Date.now();
   if (now - state2.lastErrorTime < BACKGROUND_TASK.RETRY_COOLDOWN_MS) {
@@ -37838,6 +38134,7 @@ async function handleSessionError(client, sessionID, error92, properties) {
     return false;
   }
   state2.isRecovering = true;
+  state2.recoveryStartTime = Date.now();
   try {
     let recoveryPrompt = null;
     let toastMessage = null;
@@ -37863,23 +38160,19 @@ async function handleSessionError(client, sessionID, error92, properties) {
           log("[session-recovery] Rate limit, waiting", { delay: action.delay });
           await new Promise((r) => setTimeout(r, action.delay));
         }
-        state2.isRecovering = false;
         return true;
       case ERROR_TYPE.CONTEXT_OVERFLOW:
         toastMessage = "Context Overflow - Consider compaction";
-        state2.isRecovering = false;
         return false;
       case ERROR_TYPE.MESSAGE_ABORTED:
         log("[session-recovery] Message aborted by user, not recovering", { sessionID });
-        state2.isRecovering = false;
         return false;
       default:
-        state2.isRecovering = false;
         return false;
     }
     if (recoveryPrompt && toastMessage) {
       presets_exports.errorRecovery(toastMessage);
-      client.session.prompt({
+      client2.session.prompt({
         path: { id: sessionID },
         body: {
           parts: [{ type: PART_TYPES.TEXT, text: recoveryPrompt }]
@@ -37888,15 +38181,15 @@ async function handleSessionError(client, sessionID, error92, properties) {
         log("[session-recovery] Failed to inject recovery prompt", { sessionID, error: injectionError });
       });
       log("[session-recovery] Recovery prompt injected (async)", { sessionID, errorType });
-      state2.isRecovering = false;
       return true;
     }
-    state2.isRecovering = false;
     return false;
-  } catch (injectionError) {
-    log("[session-recovery] Failed to inject recovery prompt", { sessionID, error: injectionError });
-    state2.isRecovering = false;
+  } catch (recoveryError) {
+    log("[session-recovery] Recovery failed", { sessionID, error: recoveryError });
     return false;
+  } finally {
+    state2.isRecovering = false;
+    state2.recoveryStartTime = void 0;
   }
 }
 function markRecoveryComplete(sessionID) {
@@ -37957,9 +38250,9 @@ function hasRunningBackgroundTasks(parentSessionID) {
     return false;
   }
 }
-async function showCountdownToast(client, secondsRemaining, incompleteCount) {
+async function showCountdownToast(client2, secondsRemaining, incompleteCount) {
   try {
-    const tuiClient2 = client;
+    const tuiClient2 = client2;
     if (tuiClient2.tui?.showToast) {
       await tuiClient2.tui.showToast({
         body: {
@@ -37973,7 +38266,7 @@ async function showCountdownToast(client, secondsRemaining, incompleteCount) {
   } catch {
   }
 }
-async function injectContinuation(client, directory, sessionID, todos) {
+async function injectContinuation(client2, directory, sessionID, todos) {
   const state2 = getState3(sessionID);
   if (state2.isAborting) {
     log("[todo-continuation] Skipped: user is aborting", { sessionID });
@@ -38003,24 +38296,22 @@ async function injectContinuation(client, directory, sessionID, todos) {
     return;
   }
   try {
-    client.session.prompt({
+    await client2.session.prompt({
       path: { id: sessionID },
       body: {
         parts: [{ type: PART_TYPES.TEXT, text: prompt }]
       }
-    }).catch((error92) => {
-      log("[todo-continuation] Failed to inject continuation", { sessionID, error: error92 });
     });
-    log("[todo-continuation] Injected continuation prompt (async)", {
+    log("[todo-continuation] Injected continuation prompt", {
       sessionID,
       incompleteCount: getIncompleteCount(todos),
       progress: formatProgress(todos)
     });
   } catch (error92) {
-    log("[todo-continuation] Failed to trigger async continuation", { sessionID, error: error92 });
+    log("[todo-continuation] Failed to inject continuation", { sessionID, error: error92 });
   }
 }
-async function handleSessionIdle(client, directory, sessionID, mainSessionID) {
+async function handleSessionIdle(client2, directory, sessionID, mainSessionID) {
   const state2 = getState3(sessionID);
   const now = Date.now();
   if (state2.lastIdleTime && now - state2.lastIdleTime < MIN_TIME_BETWEEN_CONTINUATIONS_MS) {
@@ -38050,18 +38341,23 @@ async function handleSessionIdle(client, directory, sessionID, mainSessionID) {
     log("[todo-continuation] Skipped: background tasks running", { sessionID });
     return;
   }
+  if (hasContinuationLock(sessionID)) {
+    log("[todo-continuation] Mission loop has priority, skipping");
+    return;
+  }
   let todos = [];
   try {
-    const response = await client.session.todo({ path: { id: sessionID } });
+    const response = await client2.session.todo({ path: { id: sessionID } });
     todos = parseTodos(response.data ?? response);
   } catch (error92) {
     log("[todo-continuation] Failed to fetch todos", { sessionID, error: error92 });
+    cancelCountdown(sessionID);
     return;
   }
   const hasBuiltinWork = hasRemainingWork(todos);
   let hasFileWork = false;
   try {
-    const verification = verifyMissionCompletion(directory);
+    const verification = await verifyMissionCompletionAsync(directory);
     hasFileWork = !verification.passed && (verification.todoIncomplete > 0 || verification.checklistProgress !== "0/0" && !verification.checklistComplete);
   } catch (err) {
     log("[todo-continuation] Failed to check file-based todos", err);
@@ -38078,26 +38374,34 @@ async function handleSessionIdle(client, directory, sessionID, mainSessionID) {
     incompleteCount,
     nextPending: nextPending?.id
   });
-  await showCountdownToast(client, COUNTDOWN_SECONDS, incompleteCount);
+  await showCountdownToast(client2, COUNTDOWN_SECONDS, incompleteCount);
   state2.countdownStartedAt = now;
   state2.countdownTimer = setTimeout(async () => {
     cancelCountdown(sessionID);
+    if (!tryAcquireContinuationLock(sessionID, "todo-continuation")) {
+      log("[todo-continuation] Failed to acquire lock, skipping");
+      return;
+    }
     try {
-      const freshResponse = await client.session.todo({ path: { id: sessionID } });
-      const freshTodos = parseTodos(freshResponse.data ?? freshResponse);
-      let freshFileWork = false;
       try {
-        const v = verifyMissionCompletion(directory);
-        freshFileWork = !v.passed && (v.todoIncomplete > 0 || v.checklistProgress !== "0/0" && !v.checklistComplete);
+        const freshResponse = await client2.session.todo({ path: { id: sessionID } });
+        const freshTodos = parseTodos(freshResponse.data ?? freshResponse);
+        let freshFileWork = false;
+        try {
+          const v = await verifyMissionCompletionAsync(directory);
+          freshFileWork = !v.passed && (v.todoIncomplete > 0 || v.checklistProgress !== "0/0" && !v.checklistComplete);
+        } catch {
+        }
+        if (hasRemainingWork(freshTodos) || freshFileWork) {
+          await injectContinuation(client2, directory, sessionID, freshTodos);
+        } else {
+          log("[todo-continuation] All work completed during countdown", { sessionID });
+        }
       } catch {
+        log("[todo-continuation] Failed to re-fetch todos for continuation", { sessionID });
       }
-      if (hasRemainingWork(freshTodos) || freshFileWork) {
-        await injectContinuation(client, directory, sessionID, freshTodos);
-      } else {
-        log("[todo-continuation] All work completed during countdown", { sessionID });
-      }
-    } catch {
-      log("[todo-continuation] Failed to re-fetch todos for continuation", { sessionID });
+    } finally {
+      releaseContinuationLock(sessionID);
     }
   }, COUNTDOWN_SECONDS * TIME.SECOND);
 }
@@ -38130,6 +38434,9 @@ function cleanupSession2(sessionID) {
   cancelCountdown(sessionID);
   sessionStates2.delete(sessionID);
 }
+function hasPendingContinuation(sessionID) {
+  return !!sessionStates2.get(sessionID)?.countdownTimer;
+}
 
 // src/hooks/custom/user-activity.ts
 var UserActivityHook = class {
@@ -38389,11 +38696,12 @@ import * as fs10 from "node:fs";
 import * as path9 from "node:path";
 
 // src/core/sync/todo-parser.ts
+init_shared();
 function parseTodoMd(content) {
   const lines = content.split("\n");
   const todos = [];
   const generateId = (text, index2) => {
-    return `file-task-${index2}-${text.substring(0, 10).replace(/[^a-zA-Z0-9]/g, "")}`;
+    return `${TODO_CONSTANTS.PREFIX.FILE}${index2}-${text.substring(0, 10).replace(/[^a-zA-Z0-9]/g, "")}`;
   };
   let index = 0;
   for (const line of lines) {
@@ -38401,28 +38709,28 @@ function parseTodoMd(content) {
     if (match) {
       const [, statusChar, text] = match;
       const content2 = text.trim();
-      let status = "pending";
+      let status = TODO_STATUS2.PENDING;
       switch (statusChar.toLowerCase()) {
         case "x":
-          status = "completed";
+          status = TODO_STATUS2.COMPLETED;
           break;
         case "/":
         case ".":
-          status = "in_progress";
+          status = TODO_STATUS2.IN_PROGRESS;
           break;
         case "-":
-          status = "cancelled";
+          status = TODO_STATUS2.CANCELLED;
           break;
         case " ":
         default:
-          status = "pending";
+          status = TODO_STATUS2.PENDING;
           break;
       }
       todos.push({
         id: generateId(content2, index),
         content: content2,
         status,
-        priority: "medium",
+        priority: STATUS_LABEL.MEDIUM,
         // Default priority for file items
         createdAt: /* @__PURE__ */ new Date()
       });
@@ -38441,19 +38749,9 @@ var TodoSyncService = class {
   taskTodos = /* @__PURE__ */ new Map();
   updateTimeout = null;
   watcher = null;
-  // We only want to sync to the "primary" session or all sessions?
-  // The design says `syncTaskStore(sessionID)`.
-  // Usually TUI TODO is per session.
-  // However, `todo.md` is global (project level).
-  // So we should probably broadcast to active sessions or just the one associated with the tasks?
-  // Current TUI limitation: we might need to know which session to update.
-  // For TUI sidebar, we usually update the session the user is looking at.
-  // But we don't know that.
-  // We will maintain a set of "active sessions" provided by index.ts or just update relevant ones.
-  // For Phase 1, we might just update the sessions we know about (parents of tasks) or register sessions.
   activeSessions = /* @__PURE__ */ new Set();
-  constructor(client, directory) {
-    this.client = client;
+  constructor(client2, directory) {
+    this.client = client2;
     this.directory = directory;
     this.todoPath = path9.join(this.directory, PATHS.TODO);
   }
@@ -38522,18 +38820,18 @@ var TodoSyncService = class {
   }
   async sendTodosToSession(sessionID) {
     const taskTodosList = Array.from(this.taskTodos.values()).map((t) => {
-      let status = "pending";
+      let status = TODO_STATUS2.PENDING;
       const s = t.status.toLowerCase();
-      if (s.includes("run") || s.includes("wait") || s.includes("que")) status = "in_progress";
-      else if (s.includes("complete") || s.includes("done")) status = "completed";
-      else if (s.includes("fail") || s.includes("error")) status = "cancelled";
-      else if (s.includes("cancel")) status = "cancelled";
+      if (s.includes(STATUS_LABEL.RUNNING) || s.includes("wait") || s.includes("que")) status = TODO_STATUS2.IN_PROGRESS;
+      else if (s.includes(STATUS_LABEL.COMPLETED) || s.includes(STATUS_LABEL.DONE)) status = TODO_STATUS2.COMPLETED;
+      else if (s.includes(STATUS_LABEL.FAILED) || s.includes(STATUS_LABEL.ERROR)) status = TODO_STATUS2.CANCELLED;
+      else if (s.includes(STATUS_LABEL.CANCELLED)) status = TODO_STATUS2.CANCELLED;
       return {
-        id: `task-${t.id}`,
+        id: `${TODO_CONSTANTS.PREFIX.TASK}${t.id}`,
         // Prefix to avoid collision
         content: `[${t.agent.toUpperCase()}] ${t.description}`,
         status,
-        priority: t.isBackground ? "low" : "high",
+        priority: t.isBackground ? STATUS_LABEL.LOW : STATUS_LABEL.HIGH,
         createdAt: /* @__PURE__ */ new Date()
       };
     });
@@ -38541,11 +38839,17 @@ var TodoSyncService = class {
       ...this.fileTodos,
       ...taskTodosList
     ];
+    const payloadTodos = merged.map((todo) => ({
+      id: todo.id,
+      content: todo.content,
+      status: todo.status,
+      priority: todo.priority
+    }));
     try {
       await this.client.session.todo({
         path: { id: sessionID },
         // Standardize to id
-        body: { todos: merged }
+        body: { todos: payloadTodos }
       });
     } catch (error92) {
     }
@@ -38856,9 +39160,9 @@ function hasRunningBackgroundTasks2(parentSessionID) {
     return false;
   }
 }
-async function showCompletedToast(client, state2) {
+async function showCompletedToast(client2, state2) {
   try {
-    const tuiClient2 = client;
+    const tuiClient2 = client2;
     if (tuiClient2.tui?.showToast) {
       await tuiClient2.tui.showToast({
         body: {
@@ -38872,14 +39176,14 @@ async function showCompletedToast(client, state2) {
   } catch {
   }
 }
-async function injectContinuation2(client, directory, sessionID, loopState, customPrompt) {
+async function injectContinuation2(client2, directory, sessionID, loopState, customPrompt) {
   const handlerState = getState4(sessionID);
   if (handlerState.isAborting) return;
   if (hasRunningBackgroundTasks2(sessionID)) return;
   if (isSessionRecovering(sessionID)) return;
-  const verification = verifyMissionCompletion(directory);
+  const verification = await verifyMissionCompletionAsync(directory);
   if (verification.passed) {
-    await handleMissionComplete(client, directory, loopState);
+    await handleMissionComplete(client2, directory, loopState);
     return;
   }
   const summary = buildVerificationSummary(verification);
@@ -38890,21 +39194,20 @@ async function injectContinuation2(client, directory, sessionID, loopState, cust
 ${prompt}`;
   }
   try {
-    client.session.prompt({
+    await client2.session.prompt({
       path: { id: sessionID },
       body: {
         parts: [{ type: PART_TYPES.TEXT, text: prompt }]
       }
-    }).catch((error92) => {
-      log("[mission-loop-handler] Failed to inject continuation prompt", { sessionID, error: error92 });
     });
-  } catch {
+  } catch (error92) {
+    log("[mission-loop-handler] Failed to inject continuation prompt", { sessionID, error: error92 });
   }
 }
-async function handleMissionComplete(client, directory, loopState) {
+async function handleMissionComplete(client2, directory, loopState) {
   const cleared = clearLoopState(directory);
   if (cleared) {
-    await showCompletedToast(client, loopState);
+    await showCompletedToast(client2, loopState);
     await sendMissionCompleteNotification(loopState);
   }
 }
@@ -38923,7 +39226,7 @@ async function sendMissionCompleteNotification(loopState) {
   } catch {
   }
 }
-async function handleMissionIdle(client, directory, sessionID, mainSessionID) {
+async function handleMissionIdle(client2, directory, sessionID, mainSessionID) {
   const handlerState = getState4(sessionID);
   const now = Date.now();
   if (handlerState.lastCheckTime && now - handlerState.lastCheckTime < LOOP.MIN_TIME_BETWEEN_CHECKS_MS) {
@@ -38943,10 +39246,10 @@ async function handleMissionIdle(client, directory, sessionID, mainSessionID) {
   if (loopState.sessionID !== sessionID) {
     return;
   }
-  const verification = verifyMissionCompletion(directory);
+  const verification = await verifyMissionCompletionAsync(directory);
   if (verification.passed) {
     log(`[${MISSION_CONTROL.LOG_SOURCE}-handler] Verification passed for ${sessionID}. Completion confirmed.`);
-    await handleMissionComplete(client, directory, loopState);
+    await handleMissionComplete(client2, directory, loopState);
     return;
   }
   const currentProgress = verification.todoProgress;
@@ -38969,7 +39272,18 @@ async function handleMissionIdle(client, directory, sessionID, mainSessionID) {
   const countdownMsg = isStagnant ? "Stagnation Detected! Intervening..." : `Continuing in ${MISSION_CONTROL.DEFAULT_COUNTDOWN_SECONDS}s... (iteration ${newState.iteration}/${newState.maxIterations})`;
   handlerState.countdownTimer = setTimeout(async () => {
     cancelCountdown2(sessionID);
-    await injectContinuation2(client, directory, sessionID, newState, isStagnant ? STAGNATION_INTERVENTION : void 0);
+    if (hasPendingContinuation(sessionID)) {
+      log("[mission-loop-handler] Todo continuation pending, deferring");
+      return;
+    }
+    if (!tryAcquireContinuationLock(sessionID, "mission-loop")) {
+      return;
+    }
+    try {
+      await injectContinuation2(client2, directory, sessionID, newState, isStagnant ? STAGNATION_INTERVENTION : void 0);
+    } finally {
+      releaseContinuationLock(sessionID);
+    }
   }, MISSION_CONTROL.DEFAULT_COUNTDOWN_SECONDS * 1e3);
 }
 function handleUserMessage2(sessionID) {
@@ -38991,7 +39305,7 @@ function cleanupSession3(sessionID) {
 // src/plugin-handlers/event-handler.ts
 init_shared();
 function createEventHandler(ctx) {
-  const { client, directory, sessions, state: state2 } = ctx;
+  const { client: client2, directory, sessions, state: state2 } = ctx;
   return async (input) => {
     const { event } = input;
     try {
@@ -39028,7 +39342,7 @@ function createEventHandler(ctx) {
       }
       if (sessionID && error92) {
         const recovered = await handleSessionError(
-          client,
+          client2,
           sessionID,
           error92,
           event.properties
@@ -39066,7 +39380,7 @@ function createEventHandler(ctx) {
             if (session?.active) {
               if (isLoopActive(directory, sessionID)) {
                 await handleMissionIdle(
-                  client,
+                  client2,
                   directory,
                   sessionID,
                   sessionID
@@ -39074,7 +39388,7 @@ function createEventHandler(ctx) {
                 });
               } else {
                 await handleSessionIdle(
-                  client,
+                  client2,
                   directory,
                   sessionID,
                   sessionID
@@ -39132,7 +39446,7 @@ function createToolExecuteAfterHandler(ctx) {
 // src/plugin-handlers/assistant-done-handler.ts
 init_shared();
 function createAssistantDoneHandler(ctx) {
-  const { client, directory, sessions } = ctx;
+  const { client: client2, directory, sessions } = ctx;
   const hooks = HookRegistry.getInstance();
   return async (assistantInput, assistantOutput) => {
     const sessionID = assistantInput.sessionID;
@@ -39156,12 +39470,12 @@ function createAssistantDoneHandler(ctx) {
       session.timestamp = now;
       session.lastStepTime = now;
       try {
-        if (client?.session?.prompt) {
+        if (client2?.session?.prompt) {
           const parts2 = result.prompts.map((p) => ({
             type: PART_TYPES.TEXT,
             text: p
           }));
-          client.session.prompt({
+          client2.session.prompt({
             path: { id: sessionID },
             body: { parts: parts2 }
           }).catch((error92) => {
@@ -39321,24 +39635,24 @@ Use \`delegate_task\` with background=true for parallel work.
 var require2 = createRequire(import.meta.url);
 var { version: PLUGIN_VERSION } = require2("../package.json");
 var OrchestratorPlugin = async (input) => {
-  const { directory, client } = input;
+  const { directory, client: client2 } = input;
   initializeHooks();
-  initToastClient(client);
-  const taskToastManager = initTaskToastManager(client);
+  initToastClient(client2);
+  const taskToastManager = initTaskToastManager(client2);
   const sessions = /* @__PURE__ */ new Map();
-  const parallelAgentManager2 = ParallelAgentManager.getInstance(client, directory);
-  const asyncAgentTools = createAsyncAgentTools(parallelAgentManager2, client);
+  const parallelAgentManager2 = ParallelAgentManager.getInstance(client2, directory);
+  const asyncAgentTools = createAsyncAgentTools(parallelAgentManager2, client2);
   const pluginManager = PluginManager.getInstance();
   await pluginManager.initialize(directory);
   const dynamicTools = pluginManager.getDynamicTools();
   taskToastManager.setConcurrencyController(parallelAgentManager2.getConcurrency());
-  const todoSync = new TodoSyncService(client, directory);
+  const todoSync = new TodoSyncService(client2, directory);
   await todoSync.start();
   taskToastManager.setTodoSync(todoSync);
   const cleanupScheduler = new CleanupScheduler(directory);
   cleanupScheduler.start();
   const handlerContext = {
-    client,
+    client: client2,
     directory,
     sessions,
     state