opencode-orchestrator 1.2.14 → 1.2.15

package/dist/core/agents/manager/task-poller.d.ts

@@ -14,9 +14,10 @@ export declare class TaskPoller {
     private scheduleCleanup;
     private pruneExpiredTasks;
     private onTaskComplete?;
+    private onTaskError?;
     private pollingInterval?;
     private messageCache;
-    constructor(client: OpencodeClient, store: TaskStore, concurrency: ConcurrencyController, notifyParentIfAllComplete: (parentSessionID: string) => Promise<void>, scheduleCleanup: (taskId: string) => void, pruneExpiredTasks: () => void, onTaskComplete?: ((task: ParallelTask) => void | Promise<void>) | undefined);
+    constructor(client: OpencodeClient, store: TaskStore, concurrency: ConcurrencyController, notifyParentIfAllComplete: (parentSessionID: string) => Promise<void>, scheduleCleanup: (taskId: string) => void, pruneExpiredTasks: () => void, onTaskComplete?: ((task: ParallelTask) => void | Promise<void>) | undefined, onTaskError?: ((taskId: string, error: unknown) => void) | undefined);
     start(): void;
     stop(): void;
     isRunning(): boolean;

package/dist/core/loop/continuation-lock.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Continuation Lock - Ensures single execution of continuation logic
+ *
+ * Prevents simultaneous execution of Mission Loop and Todo Continuation systems.
+ * This resolves infinite loading issues caused by duplicate prompt injections.
+ *
+ * @example
+ * if (!tryAcquireContinuationLock(sessionID)) {
+ *     return; // Another system is already processing
+ * }
+ * try {
+ *     // continuation logic
+ * } finally {
+ *     releaseContinuationLock(sessionID);
+ * }
+ */
+interface ContinuationLockState {
+    acquired: boolean;
+    timestamp: number;
+    source?: string;
+}
+/**
+ * Try to acquire the continuation lock
+ *
+ * @param sessionID - Session ID
+ * @param source - Source requesting the lock (for debugging)
+ * @returns true if acquired, false otherwise
+ */
+export declare function tryAcquireContinuationLock(sessionID: string, source?: string): boolean;
+/**
+ * Release the continuation lock
+ *
+ * @param sessionID - Session ID
+ */
+export declare function releaseContinuationLock(sessionID: string): void;
+/**
+ * Check if the lock is currently active
+ *
+ * @param sessionID - Session ID
+ * @returns true if lock is held
+ */
+export declare function hasContinuationLock(sessionID: string): boolean;
+/**
+ * Cleanup lock when session is cleaned up
+ *
+ * @param sessionID - Session ID
+ */
+export declare function cleanupContinuationLock(sessionID: string): void;
+/**
+ * Clear all locks (for testing)
+ */
+export declare function clearAllLocks(): void;
+/**
+ * Get lock status (for debugging)
+ */
+export declare function getLockStatus(sessionID: string): ContinuationLockState | undefined;
+export {};

package/dist/core/loop/verification.d.ts

@@ -11,11 +11,16 @@ export type { ChecklistItem, ChecklistCategory, ChecklistVerificationResult, Ver
 export declare const CHECKLIST_FILE: ".opencode/verification-checklist.md";
 export declare function parseChecklist(content: string): ChecklistItem[];
 export declare function readChecklist(directory: string): ChecklistItem[];
+export declare function readChecklistAsync(directory: string): Promise<ChecklistItem[]>;
+export declare function clearVerificationCache(): void;
 export declare function verifyChecklist(directory: string): ChecklistVerificationResult;
+export declare function verifyChecklistAsync(directory: string): Promise<ChecklistVerificationResult>;
 export declare function hasValidChecklist(directory: string): boolean;
 export declare function getChecklistSummary(directory: string): string;
 export declare function buildChecklistFailurePrompt(result: ChecklistVerificationResult): string;
 export declare function getChecklistCreationInstructions(): string;
+export declare function verifyMissionCompletionSync(directory: string): VerificationResult;
+export declare function verifyMissionCompletionAsync(directory: string): Promise<VerificationResult>;
 export declare function verifyMissionCompletion(directory: string): VerificationResult;
 export declare function buildVerificationFailurePrompt(result: VerificationResult): string;
 export declare function buildTodoIncompletePrompt(result: VerificationResult): string;

package/dist/core/session/session-health.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Session Health Monitor
+ *
+ * Periodically checks session health and detects stale sessions.
+ * Early detection of infinite loading states improves system stability.
+ */
+import type { PluginInput } from "@opencode-ai/plugin";
+type OpencodeClient = PluginInput["client"];
+interface SessionHealthState {
+    sessionID: string;
+    lastActiveTime: number;
+    lastResponseTime: number;
+    isStale: boolean;
+    activityCount: number;
+}
+/**
+ * Record session activity
+ *
+ * Call this when an activity occurs in the session.
+ * (e.g., sending prompt, tool execution)
+ *
+ * @param sessionID - Session ID
+ */
+export declare function recordSessionActivity(sessionID: string): void;
+/**
+ * Record session response receipt
+ *
+ * Call this when a response is received from the session.
+ * (e.g., assistant message received)
+ *
+ * @param sessionID - Session ID
+ */
+export declare function recordSessionResponse(sessionID: string): void;
+/**
+ * Check if session is stale
+ *
+ * @param sessionID - Session ID
+ * @returns true if stale
+ */
+export declare function isSessionStale(sessionID: string): boolean;
+/**
+ * Get session response age
+ *
+ * @param sessionID - Session ID
+ * @returns Time elapsed since last response (ms), or -1 if session not found
+ */
+export declare function getSessionResponseAge(sessionID: string): number;
+/**
+ * Get all stale session IDs
+ *
+ * @returns Array of stale session IDs
+ */
+export declare function getStaleSessions(): string[];
+/**
+ * Start health check monitor
+ *
+ * @param opencodeClient - OpenCode Client
+ */
+export declare function startHealthCheck(opencodeClient: OpencodeClient): void;
+/**
+ * Stop health check monitor
+ */
+export declare function stopHealthCheck(): void;
+/**
+ * Perform actual health check (Exported for testing)
+ */
+export declare function performHealthCheck(): void;
+/**
+ * Cleanup session health state
+ *
+ * @param sessionID - Session ID
+ */
+export declare function cleanupSessionHealth(sessionID: string): void;
+/**
+ * Clear all session health info (for testing)
+ */
+export declare function clearAllSessionHealth(): void;
+/**
+ * Get session health info (for debugging)
+ *
+ * @param sessionID - Session ID
+ */
+export declare function getSessionHealth(sessionID: string): SessionHealthState | undefined;
+/**
+ * Get overall health stats (for debugging)
+ */
+export declare function getHealthStats(): {
+    total: number;
+    stale: number;
+    healthy: number;
+    avgResponseAge: number;
+};
+export {};

package/dist/index.js

@@ -865,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 = {
@@ -889,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,
@@ -18823,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();
@@ -18837,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;
   }
   /**
@@ -19098,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;
 }
 
@@ -33314,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;
@@ -33475,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;
@@ -33628,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();
@@ -33668,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) {
@@ -33780,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;
@@ -33892,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;
@@ -33912,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) => {
@@ -33973,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}`);
   }
@@ -34002,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;
   }
@@ -34423,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,
@@ -34452,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),
@@ -34473,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;
   }
@@ -34557,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(() => {
@@ -34787,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}
@@ -34840,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.`;
     }
@@ -35174,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),
@@ -36470,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">
@@ -36827,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);
@@ -36904,6 +37071,7 @@ function readChecklist(directory) {
     return [];
   }
 }
+var lastVerificationResult = /* @__PURE__ */ new Map();
 function verifyChecklist(directory) {
   const result = {
     passed: false,
@@ -36943,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 = [
@@ -36968,7 +37170,7 @@ function hasRealSyncIssues(content) {
   });
   return lines.length > 0;
 }
-function verifyMissionCompletion(directory) {
+function verifyMissionCompletionSync(directory) {
   const result = {
     passed: false,
     todoComplete: false,
@@ -37049,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";
@@ -37817,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) {
@@ -37842,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;
@@ -37867,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 }]
@@ -37892,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) {
@@ -37961,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: {
@@ -37977,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 });
@@ -38007,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) {
@@ -38054,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);
@@ -38082,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);
 }
@@ -38134,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 {
@@ -38447,8 +38750,8 @@ var TodoSyncService = class {
   updateTimeout = null;
   watcher = null;
   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);
   }
@@ -38857,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: {
@@ -38873,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);
@@ -38891,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);
   }
 }
@@ -38924,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) {
@@ -38944,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;
@@ -38970,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) {
@@ -38992,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 {
@@ -39029,7 +39342,7 @@ function createEventHandler(ctx) {
       }
       if (sessionID && error92) {
         const recovered = await handleSessionError(
-          client,
+          client2,
           sessionID,
           error92,
           event.properties
@@ -39067,7 +39380,7 @@ function createEventHandler(ctx) {
             if (session?.active) {
               if (isLoopActive(directory, sessionID)) {
                 await handleMissionIdle(
-                  client,
+                  client2,
                   directory,
                   sessionID,
                   sessionID
@@ -39075,7 +39388,7 @@ function createEventHandler(ctx) {
                 });
               } else {
                 await handleSessionIdle(
-                  client,
+                  client2,
                   directory,
                   sessionID,
                   sessionID
@@ -39133,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;
@@ -39157,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) => {
@@ -39322,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

package/dist/shared/constants/system-messages.d.ts

@@ -21,5 +21,5 @@ export declare const MISSION_MESSAGES: {
 };
 export declare const COMPACTION_PROMPT: string;
 export declare const CONTINUE_INSTRUCTION: string;
-export declare const STAGNATION_INTERVENTION = "\n<system_intervention type=\"stagnation_detected\">\n\u26A0\uFE0F **\uACBD\uACE0: \uC9C4\uD589 \uC815\uCCB4 \uAC10\uC9C0 (STAGNATION DETECTED)**\n\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.\n\n**\uC790\uC728\uC801 \uC9C4\uB2E8 \uBC0F \uD574\uACB0 \uC9C0\uCE68:**\n1. **\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.\n2. **\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.\n3. **\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.\n\n**\uC9C0\uAE08 \uBC14\uB85C \uB2A5\uB3D9\uC801\uC73C\uB85C \uAC1C\uC785\uD558\uC2ED\uC2DC\uC624. \uB300\uAE30\uD558\uC9C0 \uB9C8\uC2ED\uC2DC\uC624.**\n</system_intervention>";
+export declare const STAGNATION_INTERVENTION = "\n<system_intervention type=\"stagnation_detected\">\n\u26A0\uFE0F **WARNING: STAGNATION DETECTED**\nNo substantial progress has been detected for several turns. Simply \"monitoring\" or repeating the same actions is prohibited.\n\n**Self-Diagnosis and Resolution Guidelines:**\n1. **Check Live Logs**: Use `check_background_task` or `read_file` to directly check the output logs of running tasks.\n2. **Process Health Diagnosis**: If a task appears to be a zombie or stuck, kill it immediately and restart it with more granular steps.\n3. **Strategy Pivot**: If the same approach keeps failing, use different tools or methods to reach the goal.\n\n**Intervene proactively NOW. Do NOT wait.**\n</system_intervention>";
 export declare const CLEANUP_INSTRUCTION = "\n<system_maintenance type=\"continuous_hygiene\">\n\uD83E\uDDF9 **DOCUMENTATION & STATE HYGIENE (Iteration %ITER%)**\nYou must maintain a pristine workspace. **As part of your move**, perform these checks:\n\n1. **Relevance Assessment**:\n   - Review active documents (`.opencode/*.md`). Are they needed for the *current* objective?\n   - If a file represents a solved problem or obsolete context, **Archive it** to `.opencode/archive/` or delete it.\n\n2. **Synchronization**:\n   - Verify `TODO.md` matches the actual code state. Mark completed items immediately.\n   - Check `sync-issues.md`. If issues are resolved, remove them.\n\n3. **Context Optimization**:\n   - If `work-log.md` is getting noisy, summarize key decisions into `summary.md` and truncate the log.\n   - Keep context lightweight.\n\n**Rule**: A cluttered workspace leads to hallucinations. Clean as you go.\n</system_maintenance>\n";

package/package.json

@@ -2,7 +2,7 @@
   "name": "opencode-orchestrator",
   "displayName": "OpenCode Orchestrator",
   "description": "Distributed Cognitive Architecture for OpenCode. Turns simple prompts into specialized multi-agent workflows (Planner, Coder, Reviewer).",
-  "version": "1.2.14",
+  "version": "1.2.15",
   "author": "agnusdei1207",
   "license": "MIT",
   "repository": {