opencode-orchestrator 1.2.62 → 1.2.67

package/dist/index.js

@@ -702,6 +702,24 @@ var init_mission_control = __esm({
   }
 });
 
+// src/shared/loop/constants/task-status.ts
+var TASK_STATUS;
+var init_task_status = __esm({
+  "src/shared/loop/constants/task-status.ts"() {
+    "use strict";
+    init_status_labels();
+    TASK_STATUS = {
+      PENDING: STATUS_LABEL.PENDING,
+      RUNNING: STATUS_LABEL.RUNNING,
+      COMPLETED: STATUS_LABEL.COMPLETED,
+      FAILED: STATUS_LABEL.FAILED,
+      ERROR: STATUS_LABEL.ERROR,
+      TIMEOUT: STATUS_LABEL.TIMEOUT,
+      CANCELLED: STATUS_LABEL.CANCELLED
+    };
+  }
+});
+
 // src/shared/loop/constants/todo-status.ts
 var TODO_STATUS;
 var init_todo_status = __esm({
@@ -767,6 +785,7 @@ var init_constants4 = __esm({
     "use strict";
     init_loop();
     init_mission_control();
+    init_task_status();
     init_todo_status();
     init_labels();
   }
@@ -923,6 +942,12 @@ var init_types4 = __esm({
 // src/core/notification/toast-core.ts
 function initToastClient(client) {
   tuiClient = client;
+  const cleanup = () => {
+    tuiClient = null;
+    toasts.length = 0;
+    handlers.length = 0;
+  };
+  return cleanup;
 }
 function show(options) {
   const toast = {
@@ -947,15 +972,34 @@ function show(options) {
   if (tuiClient) {
     const client = tuiClient;
     if (client.tui?.showToast) {
-      client.tui.showToast({
-        body: {
-          title: toast.title,
-          message: toast.message,
-          variant: toast.variant,
-          duration: toast.duration
+      try {
+        const ac = new AbortController();
+        const timeoutMs = Math.max(2e3, Math.min(toast.duration, 1e4));
+        const timer = setTimeout(() => {
+          try {
+            ac.abort();
+          } catch {
+          }
+        }, timeoutMs);
+        const promise3 = client.tui.showToast?.({
+          body: {
+            title: toast.title,
+            message: toast.message,
+            variant: toast.variant,
+            duration: toast.duration
+          },
+          signal: ac.signal
+        });
+        if (promise3 && typeof promise3.then === "function") {
+          Promise.resolve(promise3).finally(() => {
+            if (timer) {
+              clearTimeout(timer);
+            }
+          }).catch(() => {
+          });
         }
-      }).catch(() => {
-      });
+      } catch {
+      }
     }
   }
   return toast;
@@ -1778,9 +1822,18 @@ var init_slash_commands = __esm({
 });
 
 // src/shared/message/constants/plugin-hooks.ts
+var PLUGIN_HOOKS;
 var init_plugin_hooks = __esm({
   "src/shared/message/constants/plugin-hooks.ts"() {
     "use strict";
+    PLUGIN_HOOKS = {
+      /** Intercepts user messages before sending to LLM */
+      CHAT_MESSAGE: "chat.message",
+      /** Runs after LLM finishes responding */
+      ASSISTANT_DONE: "assistant.done",
+      /** Runs after any tool call completes */
+      TOOL_EXECUTE_AFTER: "tool.execute.after"
+    };
   }
 });
 
@@ -2518,30 +2571,6 @@ var init_prompt = __esm({
   }
 });
 
-// src/core/agents/consts/task-status.const.ts
-var TASK_STATUS, TODO_STATUS2;
-var init_task_status_const = __esm({
-  "src/core/agents/consts/task-status.const.ts"() {
-    "use strict";
-    init_shared();
-    TASK_STATUS = {
-      PENDING: STATUS_LABEL.PENDING,
-      RUNNING: STATUS_LABEL.RUNNING,
-      COMPLETED: STATUS_LABEL.COMPLETED,
-      FAILED: STATUS_LABEL.FAILED,
-      ERROR: STATUS_LABEL.ERROR,
-      TIMEOUT: STATUS_LABEL.TIMEOUT,
-      CANCELLED: STATUS_LABEL.CANCELLED
-    };
-    TODO_STATUS2 = {
-      PENDING: STATUS_LABEL.PENDING,
-      IN_PROGRESS: STATUS_LABEL.IN_PROGRESS,
-      COMPLETED: STATUS_LABEL.COMPLETED,
-      CANCELLED: STATUS_LABEL.CANCELLED
-    };
-  }
-});
-
 // src/shared/index.ts
 var init_shared = __esm({
   "src/shared/index.ts"() {
@@ -2562,7 +2591,6 @@ var init_shared = __esm({
     init_lifecycle2();
     init_errors();
     init_prompt();
-    init_task_status_const();
   }
 });
 
@@ -21535,7 +21563,8 @@ var TaskCleaner = class {
         try {
           await this.sessionPool.release(sessionID);
           clear2(sessionID);
-        } catch {
+        } catch (error92) {
+          log(`Session cleanup error for ${sessionID}:`, error92);
         }
       }
       this.store.delete(taskId);
@@ -36315,6 +36344,7 @@ function verifyMissionCompletion(directory) {
         );
       }
     } catch (error92) {
+      log(`[verification] Failed to read sync issues file: ${error92}`);
       result.syncIssuesEmpty = true;
     }
   }
@@ -36652,13 +36682,13 @@ var MissionControlHook = class {
       return this.handleMissionComplete(directory, verification);
     }
     const loopState = readLoopState(directory);
-    let isStagnant = false;
+    let isStagnant2 = false;
     if (loopState && loopState.active && loopState.sessionID === sessionID) {
       const currentProgress = verification.todoProgress;
       if (loopState.lastProgress === currentProgress) {
         loopState.stagnationCount = (loopState.stagnationCount || 0) + 1;
         if (loopState.stagnationCount >= 2) {
-          isStagnant = true;
+          isStagnant2 = true;
         }
       } else {
         loopState.stagnationCount = 0;
@@ -36669,7 +36699,7 @@ var MissionControlHook = class {
     const failurePrompt = verification.checklistProgress !== "0/0" ? buildVerificationFailurePrompt(verification) : buildTodoIncompletePrompt(verification);
     const continuation = this.buildContinuationResponse(session, sessionID);
     const prompts = [failurePrompt];
-    if (isStagnant) {
+    if (isStagnant2) {
       prompts.push(STAGNATION_INTERVENTION);
     }
     if (continuation.action === HOOK_ACTIONS.INJECT) {
@@ -36984,7 +37014,7 @@ init_logger();
 init_shared();
 function getIncompleteCount(todos) {
   return todos.filter(
-    (t) => t.status !== TODO_STATUS2.COMPLETED && t.status !== TODO_STATUS2.CANCELLED
+    (t) => t.status !== TODO_STATUS.COMPLETED && t.status !== TODO_STATUS.CANCELLED
   ).length;
 }
 function hasRemainingWork(todos) {
@@ -36992,7 +37022,7 @@ function hasRemainingWork(todos) {
 }
 function getNextPending(todos) {
   const pending2 = todos.filter(
-    (t) => t.status === TODO_STATUS2.PENDING || t.status === TODO_STATUS2.IN_PROGRESS
+    (t) => t.status === TODO_STATUS.PENDING || t.status === TODO_STATUS.IN_PROGRESS
   );
   const priorityOrder = {
     [STATUS_LABEL.HIGH]: 0,
@@ -37005,10 +37035,10 @@ function getNextPending(todos) {
 function getStats3(todos) {
   const stats2 = {
     total: todos.length,
-    pending: todos.filter((t) => t.status === TODO_STATUS2.PENDING).length,
-    inProgress: todos.filter((t) => t.status === TODO_STATUS2.IN_PROGRESS).length,
-    completed: todos.filter((t) => t.status === TODO_STATUS2.COMPLETED).length,
-    cancelled: todos.filter((t) => t.status === TODO_STATUS2.CANCELLED).length,
+    pending: todos.filter((t) => t.status === TODO_STATUS.PENDING).length,
+    inProgress: todos.filter((t) => t.status === TODO_STATUS.IN_PROGRESS).length,
+    completed: todos.filter((t) => t.status === TODO_STATUS.COMPLETED).length,
+    cancelled: todos.filter((t) => t.status === TODO_STATUS.CANCELLED).length,
     percentComplete: 0
   };
   if (stats2.total > 0) {
@@ -37028,13 +37058,13 @@ function formatProgress(todos) {
 }
 function generateContinuationPrompt(todos) {
   const incomplete = todos.filter(
-    (t) => t.status !== TODO_STATUS2.COMPLETED && t.status !== TODO_STATUS2.CANCELLED
+    (t) => t.status !== TODO_STATUS.COMPLETED && t.status !== TODO_STATUS.CANCELLED
   );
   if (incomplete.length === 0) {
     return "";
   }
   const next = getNextPending(todos);
-  const pendingTasks = incomplete.filter((t) => t.status === TODO_STATUS2.PENDING);
+  const pendingTasks = incomplete.filter((t) => t.status === TODO_STATUS.PENDING);
   const pendingCount = pendingTasks.length;
   let prompt = `${PROMPT_TAGS.TODO_CONTINUATION.open}
 ${LOOP_LABELS.PROGRESS_PREFIX} ${formatProgress(todos)}
@@ -37042,7 +37072,7 @@ ${LOOP_LABELS.PROGRESS_PREFIX} ${formatProgress(todos)}
 **${LOOP_LABELS.INCOMPLETE_TASKS}** (${incomplete.length} remaining):
 `;
   for (const todo of incomplete.slice(0, 5)) {
-    const statusLabel = todo.status === TODO_STATUS2.IN_PROGRESS ? LOOP_LABELS.STATUS.RUNNING : LOOP_LABELS.STATUS.WAITING;
+    const statusLabel = todo.status === TODO_STATUS.IN_PROGRESS ? LOOP_LABELS.STATUS.RUNNING : LOOP_LABELS.STATUS.WAITING;
     const priorityLabel = todo.priority === STATUS_LABEL.HIGH ? LOOP_LABELS.PRIORITY.HIGH : todo.priority === STATUS_LABEL.MEDIUM ? LOOP_LABELS.PRIORITY.MEDIUM : LOOP_LABELS.PRIORITY.LOW;
     prompt += `${statusLabel} ${priorityLabel} [${todo.id}] ${todo.content}
 `;
@@ -37221,17 +37251,40 @@ function isSessionRecovering(sessionID) {
 }
 
 // src/core/loop/todo-continuation.ts
+var CONTINUATION_TTL_MS = 10 * 60 * 1e3;
+var PRUNE_INTERVAL_MS = 2 * 60 * 1e3;
 var sessionStates2 = /* @__PURE__ */ new Map();
+var pruneInterval;
 var COUNTDOWN_SECONDS = 2;
 var TOAST_DURATION_MS = TOAST_DURATION.EXTRA_SHORT;
 var MIN_TIME_BETWEEN_CONTINUATIONS_MS = LOOP.MIN_TIME_BETWEEN_CHECKS_MS;
 var COUNTDOWN_GRACE_PERIOD_MS = LOOP.COUNTDOWN_GRACE_PERIOD_MS;
 var ABORT_WINDOW_MS = LOOP.ABORT_WINDOW_MS;
+function startPruneTimer() {
+  if (pruneInterval) return;
+  pruneInterval = setInterval(() => {
+    const now = Date.now();
+    for (const [sessionID, state2] of sessionStates2.entries()) {
+      if (now - state2.lastAccessedAt > CONTINUATION_TTL_MS) {
+        if (state2.countdownTimer) {
+          clearTimeout(state2.countdownTimer);
+        }
+        sessionStates2.delete(sessionID);
+        log(`[todo-continuation] Pruned stale state`, { sessionID });
+      }
+    }
+  }, PRUNE_INTERVAL_MS);
+  if (pruneInterval && typeof pruneInterval.unref === "function") {
+    pruneInterval.unref();
+  }
+}
 function getState3(sessionID) {
   let state2 = sessionStates2.get(sessionID);
   if (!state2) {
-    state2 = {};
+    state2 = { lastAccessedAt: Date.now() };
     sessionStates2.set(sessionID, state2);
+  } else {
+    state2.lastAccessedAt = Date.now();
   }
   return state2;
 }
@@ -37260,7 +37313,8 @@ function hasRunningBackgroundTasks(parentSessionID) {
     const manager = ParallelAgentManager.getInstance();
     const tasks = manager.getTasksByParent(parentSessionID);
     return tasks.some((t) => t.status === STATUS_LABEL.RUNNING);
-  } catch {
+  } catch (err) {
+    log("[todo-continuation] Failed to check background tasks", { sessionID: parentSessionID, error: err });
     return false;
   }
 }
@@ -37277,7 +37331,8 @@ async function showCountdownToast(client, secondsRemaining, incompleteCount) {
         }
       });
     }
-  } catch {
+  } catch (error92) {
+    log(`[todo-continuation] Toast failed:`, error92);
   }
 }
 async function injectContinuation(client, directory, sessionID, todos) {
@@ -37396,7 +37451,8 @@ async function handleSessionIdle(client, directory, sessionID, mainSessionID) {
       try {
         const v = verifyMissionCompletion(directory);
         freshFileWork = !v.passed && (v.todoIncomplete > 0 || v.checklistProgress !== "0/0" && !v.checklistComplete);
-      } catch {
+      } catch (err) {
+        log("[todo-continuation] Failed to verify file work", { sessionID, error: err });
       }
       if (hasRemainingWork(freshTodos) || freshFileWork) {
         await injectContinuation(client, directory, sessionID, freshTodos);
@@ -37437,6 +37493,7 @@ function cleanupSession2(sessionID) {
   cancelCountdown(sessionID);
   sessionStates2.delete(sessionID);
 }
+startPruneTimer();
 
 // src/hooks/custom/user-activity.ts
 var UserActivityHook = class {
@@ -37727,21 +37784,21 @@ function parseTodoMd(content) {
     if (match) {
       const [, statusChar, text] = match;
       const content2 = text.trim();
-      let status = TODO_STATUS2.PENDING;
+      let status = TODO_STATUS.PENDING;
       switch (statusChar.toLowerCase()) {
         case "x":
-          status = TODO_STATUS2.COMPLETED;
+          status = TODO_STATUS.COMPLETED;
           break;
         case "/":
         case ".":
-          status = TODO_STATUS2.IN_PROGRESS;
+          status = TODO_STATUS.IN_PROGRESS;
           break;
         case "-":
-          status = TODO_STATUS2.CANCELLED;
+          status = TODO_STATUS.CANCELLED;
           break;
         case " ":
         default:
-          status = TODO_STATUS2.PENDING;
+          status = TODO_STATUS.PENDING;
           break;
       }
       todos.push({
@@ -40088,20 +40145,407 @@ ${claudeRules}`;
 // src/core/loop/mission-loop-handler.ts
 init_logger();
 init_shared();
+
+// src/core/loop/session-state-store.ts
+init_logger();
+var SESSION_STATE_TTL_MS = 10 * 60 * 1e3;
+var PRUNE_INTERVAL_MS2 = 2 * 60 * 1e3;
+function createSessionStateStore() {
+  const sessions = /* @__PURE__ */ new Map();
+  let pruneInterval5;
+  pruneInterval5 = setInterval(() => {
+    const now = Date.now();
+    for (const [sessionID, tracked] of sessions.entries()) {
+      if (now - tracked.lastAccessedAt > SESSION_STATE_TTL_MS) {
+        cancelCountdownInternal(tracked.state);
+        sessions.delete(sessionID);
+        log(`[session-state-store] Pruned stale session`, { sessionID });
+      }
+    }
+  }, PRUNE_INTERVAL_MS2);
+  if (typeof pruneInterval5 === "object" && typeof pruneInterval5.unref === "function") {
+    pruneInterval5.unref();
+  }
+  function getTrackedSession(sessionID) {
+    const existing = sessions.get(sessionID);
+    if (existing) {
+      existing.lastAccessedAt = Date.now();
+      return existing;
+    }
+    const rawState = {
+      stagnationCount: 0,
+      isRecovering: false,
+      isAborting: false,
+      inFlight: false
+    };
+    const trackedSession = {
+      state: rawState,
+      lastAccessedAt: Date.now()
+    };
+    sessions.set(sessionID, trackedSession);
+    return trackedSession;
+  }
+  function getState6(sessionID) {
+    return getTrackedSession(sessionID).state;
+  }
+  function getExistingState(sessionID) {
+    const existing = sessions.get(sessionID);
+    if (existing) {
+      existing.lastAccessedAt = Date.now();
+      return existing.state;
+    }
+    return void 0;
+  }
+  function cancelCountdownInternal(state2) {
+    if (state2.countdownTimer) {
+      clearTimeout(state2.countdownTimer);
+      state2.countdownTimer = void 0;
+    }
+    state2.countdownStartedAt = void 0;
+    state2.inFlight = false;
+  }
+  function cancelCountdown2(sessionID) {
+    const tracked = sessions.get(sessionID);
+    if (!tracked) return;
+    cancelCountdownInternal(tracked.state);
+  }
+  function cleanup(sessionID) {
+    const tracked = sessions.get(sessionID);
+    if (!tracked) return;
+    cancelCountdownInternal(tracked.state);
+    sessions.delete(sessionID);
+  }
+  function cancelAllCountdowns() {
+    for (const tracked of sessions.values()) {
+      cancelCountdownInternal(tracked.state);
+    }
+  }
+  function shutdown() {
+    if (pruneInterval5 !== void 0) {
+      clearInterval(pruneInterval5);
+    }
+    cancelAllCountdowns();
+    sessions.clear();
+  }
+  return {
+    getState: getState6,
+    getExistingState,
+    cancelCountdown: cancelCountdown2,
+    cleanup,
+    cancelAllCountdowns,
+    shutdown
+  };
+}
+
+// src/core/loop/progress-tracker.ts
+init_logger();
+var DEFAULT_STAGNATION_THRESHOLD = 3;
+var TRACKER_TTL_MS = 10 * 60 * 1e3;
+var PRUNE_INTERVAL_MS3 = 2 * 60 * 1e3;
 var sessionStates3 = /* @__PURE__ */ new Map();
+var pruneInterval2;
+function startPruneTimer2() {
+  if (pruneInterval2) return;
+  pruneInterval2 = setInterval(() => {
+    const now = Date.now();
+    for (const [sessionID, state2] of sessionStates3.entries()) {
+      if (now - (state2.lastAccessedAt ?? 0) > TRACKER_TTL_MS) {
+        sessionStates3.delete(sessionID);
+        log(`[progress-tracker] Pruned stale state`, { sessionID });
+      }
+    }
+  }, PRUNE_INTERVAL_MS3);
+  if (pruneInterval2 && typeof pruneInterval2.unref === "function") {
+    pruneInterval2.unref();
+  }
+}
+function hashTodos(todos) {
+  const normalized = todos.map((todo) => ({
+    id: todo.id ?? null,
+    content: todo.content,
+    priority: todo.priority,
+    status: todo.status
+  })).sort((left, right) => {
+    const leftId = left.id ?? "\uFFFF";
+    const rightId = right.id ?? "\uFFFF";
+    if (leftId !== rightId) {
+      return leftId.localeCompare(rightId);
+    }
+    if (left.content !== right.content) {
+      return left.content.localeCompare(right.content);
+    }
+    if (left.priority !== right.priority) {
+      return left.priority.localeCompare(right.priority);
+    }
+    return left.status.localeCompare(right.status);
+  });
+  return JSON.stringify(normalized);
+}
+function countCompleted(todos) {
+  return todos.filter((todo) => todo.status === "completed").length;
+}
 function getState4(sessionID) {
   let state2 = sessionStates3.get(sessionID);
   if (!state2) {
-    state2 = {};
+    state2 = {
+      stagnationCount: 0,
+      awaitingPostInjectionProgressCheck: false,
+      lastAccessedAt: Date.now()
+    };
     sessionStates3.set(sessionID, state2);
+  } else {
+    state2.lastAccessedAt = Date.now();
   }
   return state2;
 }
-function cancelCountdown2(sessionID) {
+function resetProgress(sessionID) {
   const state2 = sessionStates3.get(sessionID);
-  if (state2?.countdownTimer) {
-    clearTimeout(state2.countdownTimer);
-    state2.countdownTimer = void 0;
+  if (!state2) return;
+  state2.stagnationCount = 0;
+  state2.lastIncompleteCount = void 0;
+  state2.lastSnapshot = void 0;
+  state2.countCompleted = void 0;
+  state2.awaitingPostInjectionProgressCheck = false;
+}
+function trackProgress(sessionID, incompleteCount, todos) {
+  const state2 = getState4(sessionID);
+  const previousIncompleteCount = state2.lastIncompleteCount;
+  const currentSnapshot = todos ? hashTodos(todos) : void 0;
+  const currentCompletedCount = todos ? countCompleted(todos) : void 0;
+  const hasCompletedMoreTodos = currentCompletedCount !== void 0 && state2.lastIncompleteCount !== void 0 && currentCompletedCount > (state2.countCompleted ?? 0);
+  const hasSnapshotChanged = currentSnapshot !== void 0 && state2.lastSnapshot !== void 0 && currentSnapshot !== state2.lastSnapshot;
+  let hasProgressed = false;
+  let progressSource = "none";
+  if (incompleteCount < (previousIncompleteCount ?? Infinity)) {
+    hasProgressed = true;
+    progressSource = "count";
+  } else if (hasSnapshotChanged) {
+    hasProgressed = true;
+    progressSource = "snapshot";
+  }
+  state2.lastIncompleteCount = incompleteCount;
+  if (currentSnapshot) {
+    state2.lastSnapshot = currentSnapshot;
+  }
+  if (currentCompletedCount !== void 0) {
+    state2.countCompleted = currentCompletedCount;
+  }
+  if (previousIncompleteCount === void 0) {
+    state2.stagnationCount = 0;
+    return {
+      hasProgressed: false,
+      stagnationCount: 0,
+      previousIncompleteCount,
+      progressSource: "none"
+    };
+  }
+  if (hasProgressed) {
+    const wasStagnant = state2.stagnationCount >= DEFAULT_STAGNATION_THRESHOLD;
+    state2.stagnationCount = 0;
+    state2.awaitingPostInjectionProgressCheck = false;
+    log(`[progress-tracker] Progress detected: ${progressSource}`, {
+      sessionID,
+      previousIncompleteCount,
+      incompleteCount,
+      stagnationCount: state2.stagnationCount,
+      recoveredFromStagnation: wasStagnant
+    });
+    return {
+      hasProgressed: true,
+      stagnationCount: state2.stagnationCount,
+      previousIncompleteCount,
+      progressSource,
+      recoveredFromStagnation: wasStagnant
+    };
+  }
+  if (!state2.awaitingPostInjectionProgressCheck) {
+    return {
+      hasProgressed: false,
+      stagnationCount: state2.stagnationCount,
+      previousIncompleteCount,
+      progressSource: "none"
+    };
+  }
+  state2.stagnationCount += 1;
+  log(`[progress-tracker] Stagnation detected`, {
+    sessionID,
+    incompleteCount,
+    previousIncompleteCount,
+    stagnationCount: state2.stagnationCount,
+    threshold: DEFAULT_STAGNATION_THRESHOLD
+  });
+  return {
+    hasProgressed: false,
+    stagnationCount: state2.stagnationCount,
+    previousIncompleteCount,
+    progressSource: "none"
+  };
+}
+function markInjectionPerformed(sessionID) {
+  const state2 = getState4(sessionID);
+  state2.awaitingPostInjectionProgressCheck = true;
+}
+function isStagnant(sessionID, threshold = DEFAULT_STAGNATION_THRESHOLD) {
+  const state2 = sessionStates3.get(sessionID);
+  if (!state2) return false;
+  return state2.stagnationCount >= threshold;
+}
+startPruneTimer2();
+
+// src/core/loop/compaction-guard.ts
+init_logger();
+var COMPACTION_TTL_MS = 10 * 60 * 1e3;
+var PRUNE_INTERVAL_MS4 = 2 * 60 * 1e3;
+var compactionStates = /* @__PURE__ */ new Map();
+var pruneInterval3;
+function startPruneTimer3() {
+  if (pruneInterval3) return;
+  pruneInterval3 = setInterval(() => {
+    const now = Date.now();
+    for (const [sessionID, state2] of compactionStates.entries()) {
+      if (now - state2.lastAccessedAt > COMPACTION_TTL_MS) {
+        compactionStates.delete(sessionID);
+        log(`[compaction-guard] Pruned stale state`, { sessionID });
+      }
+    }
+  }, PRUNE_INTERVAL_MS4);
+  if (pruneInterval3 && typeof pruneInterval3.unref === "function") {
+    pruneInterval3.unref();
+  }
+}
+function armCompactionGuard(sessionID, timestamp) {
+  let state2 = compactionStates.get(sessionID);
+  if (!state2) {
+    state2 = { compactionEpoch: 0, lastAccessedAt: Date.now() };
+    compactionStates.set(sessionID, state2);
+  }
+  state2.compactionEpoch = timestamp;
+  state2.lastAccessedAt = Date.now();
+  log(`[compaction-guard] Armed`, { sessionID, epoch: timestamp });
+  return timestamp;
+}
+function isCompactionSafe(sessionID, currentEpoch) {
+  const state2 = compactionStates.get(sessionID);
+  if (!state2) return true;
+  state2.lastAccessedAt = Date.now();
+  if (currentEpoch > state2.compactionEpoch) {
+    log(`[compaction-guard] Unsafe: newer compaction exists`, {
+      sessionID,
+      currentEpoch,
+      compactionEpoch: state2.compactionEpoch
+    });
+    return false;
+  }
+  return true;
+}
+function clearCompactionState(sessionID) {
+  compactionStates.delete(sessionID);
+}
+startPruneTimer3();
+
+// src/core/loop/circuit-breaker.ts
+init_logger();
+var REPETITION_THRESHOLD = 3;
+var HISTORY_SIZE = 10;
+var CIRCUIT_TTL_MS = 10 * 60 * 1e3;
+var CIRCUIT_RESET_TIMEOUT_MS = 30 * 1e3;
+var PRUNE_INTERVAL_MS5 = 2 * 60 * 1e3;
+var circuitStates = /* @__PURE__ */ new Map();
+var pruneInterval4;
+function startPruneTimer4() {
+  if (pruneInterval4) return;
+  pruneInterval4 = setInterval(() => {
+    const now = Date.now();
+    for (const [sessionID, state2] of circuitStates.entries()) {
+      if (now - state2.lastAccessedAt > CIRCUIT_TTL_MS) {
+        circuitStates.delete(sessionID);
+        log(`[circuit-breaker] Pruned stale state`, { sessionID });
+      }
+    }
+  }, PRUNE_INTERVAL_MS5);
+  if (pruneInterval4 && typeof pruneInterval4.unref === "function") {
+    pruneInterval4.unref();
+  }
+}
+function getState5(sessionID) {
+  let state2 = circuitStates.get(sessionID);
+  if (!state2) {
+    state2 = {
+      lastAccessedAt: Date.now(),
+      lastTrippedAt: 0,
+      isOpen: false,
+      toolCallHistory: []
+    };
+    circuitStates.set(sessionID, state2);
+  } else {
+    state2.lastAccessedAt = Date.now();
+  }
+  return state2;
+}
+function isCircuitOpen(sessionID) {
+  const state2 = circuitStates.get(sessionID);
+  if (!state2) return false;
+  state2.lastAccessedAt = Date.now();
+  if (state2.isOpen) {
+    const now = Date.now();
+    if (now - state2.lastTrippedAt > CIRCUIT_RESET_TIMEOUT_MS) {
+      state2.isOpen = false;
+      state2.toolCallHistory = [];
+      log(`[circuit-breaker] Circuit HALF-OPEN (auto-reset)`, { sessionID });
+      return false;
+    }
+    return true;
+  }
+  return false;
+}
+function detectRepetitiveToolUse(sessionID) {
+  const state2 = circuitStates.get(sessionID);
+  if (!state2 || state2.toolCallHistory.length < REPETITION_THRESHOLD) {
+    return null;
+  }
+  const recent = state2.toolCallHistory.slice(-REPETITION_THRESHOLD);
+  if (recent.every((tool2) => tool2 === recent[0])) {
+    return recent[0];
+  }
+  return null;
+}
+function shouldTripCircuit(sessionID) {
+  const state2 = circuitStates.get(sessionID);
+  if (!state2) return false;
+  if (state2.isOpen) return false;
+  const repetitiveTool = detectRepetitiveToolUse(sessionID);
+  if (repetitiveTool) {
+    state2.isOpen = true;
+    state2.lastTrippedAt = Date.now();
+    log(`[circuit-breaker] Circuit OPENED: repetitive tool detected: ${repetitiveTool}`, { sessionID });
+    return true;
+  }
+  return false;
+}
+function recordToolCall(sessionID, toolName) {
+  const state2 = getState5(sessionID);
+  state2.toolCallHistory.push(toolName);
+  if (state2.toolCallHistory.length > HISTORY_SIZE) {
+    state2.toolCallHistory.shift();
+  }
+}
+function clearCircuitState(sessionID) {
+  circuitStates.delete(sessionID);
+}
+startPruneTimer4();
+
+// src/core/loop/mission-loop-handler.ts
+var sessionStateStore = createSessionStateStore();
+async function showToastSafely(client, title, message, variant, duration5) {
+  try {
+    const tui = client?.tui;
+    if (tui?.showToast) {
+      await tui.showToast({
+        body: { title, message, variant, duration: duration5 }
+      });
+    }
+  } catch (err) {
+    log("[mission-loop-handler] Toast failed", { error: err });
   }
 }
 function hasRunningBackgroundTasks2(parentSessionID) {
@@ -40109,31 +40553,43 @@ function hasRunningBackgroundTasks2(parentSessionID) {
     const manager = ParallelAgentManager.getInstance();
     const tasks = manager.getTasksByParent(parentSessionID);
     return tasks.some((t) => t.status === STATUS_LABEL.RUNNING);
-  } catch {
+  } catch (err) {
+    log("[mission-loop-handler] Failed to check background tasks", { sessionID: parentSessionID, error: err });
     return false;
   }
 }
+async function showCountdownToast2(client, seconds, iteration, maxIterations) {
+  await showToastSafely(
+    client,
+    "\u{1F504} Mission Loop",
+    `Continuing in ${seconds}s... (iteration ${iteration}/${maxIterations})`,
+    TOAST_VARIANTS.WARNING,
+    TOAST_DURATION.EXTRA_SHORT
+  );
+}
 async function showCompletedToast(client, state2) {
-  try {
-    const tuiClient2 = client;
-    if (tuiClient2.tui?.showToast) {
-      await tuiClient2.tui.showToast({
-        body: {
-          title: "\u{1F396}\uFE0F Mission Complete!",
-          message: `Verified and finished after ${state2.iteration} iteration(s)`,
-          variant: TOAST_VARIANTS.SUCCESS,
-          duration: TOAST_DURATION.LONG
-        }
-      });
-    }
-  } catch {
-  }
+  await showToastSafely(
+    client,
+    "\u{1F396}\uFE0F Mission Complete!",
+    `Verified and finished after ${state2.iteration} iteration(s)`,
+    TOAST_VARIANTS.SUCCESS,
+    TOAST_DURATION.LONG
+  );
 }
 async function injectContinuation2(client, directory, sessionID, loopState, customPrompt) {
-  const handlerState = getState4(sessionID);
-  if (handlerState.isAborting) return;
+  const state2 = sessionStateStore.getState(sessionID);
+  if (state2.isAborting) return;
   if (hasRunningBackgroundTasks2(sessionID)) return;
   if (isSessionRecovering(sessionID)) return;
+  if (isCircuitOpen(sessionID)) {
+    log(`[mission-loop-handler] Skipped: circuit breaker open`, { sessionID });
+    return;
+  }
+  const currentEpoch = Date.now();
+  if (!isCompactionSafe(sessionID, currentEpoch)) {
+    log(`[mission-loop-handler] Skipped: post-compaction unsafe`, { sessionID, currentEpoch });
+    return;
+  }
   const verification = verifyMissionCompletion(directory);
   if (verification.passed) {
     await handleMissionComplete(client, directory, loopState);
@@ -40147,15 +40603,15 @@ async function injectContinuation2(client, directory, sessionID, loopState, cust
 ${prompt}`;
   }
   try {
-    client.session.prompt({
+    await client.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 {
+    markInjectionPerformed(sessionID);
+  } catch (err) {
+    log("[mission-loop-handler] Failed to inject continuation prompt", { sessionID, error: err });
   }
 }
 async function handleMissionComplete(client, directory, loopState) {
@@ -40163,6 +40619,9 @@ async function handleMissionComplete(client, directory, loopState) {
   if (cleared) {
     await showCompletedToast(client, loopState);
     await sendMissionCompleteNotification(loopState);
+    sessionStateStore.cleanup(loopState.sessionID);
+    clearCompactionState(loopState.sessionID);
+    clearCircuitState(loopState.sessionID);
   }
 }
 async function sendMissionCompleteNotification(loopState) {
@@ -40177,17 +40636,18 @@ async function sendMissionCompleteNotification(loopState) {
     if (soundPath) {
       await playSound(platform2, soundPath);
     }
-  } catch {
+  } catch (err) {
+    log("[mission-loop-handler] Notification failed", { sessionID: loopState.sessionID, error: err });
   }
 }
 async function handleMissionIdle(client, directory, sessionID, mainSessionID) {
-  const handlerState = getState4(sessionID);
+  const state2 = sessionStateStore.getState(sessionID);
   const now = Date.now();
-  if (handlerState.lastCheckTime && now - handlerState.lastCheckTime < LOOP.MIN_TIME_BETWEEN_CHECKS_MS) {
+  if (state2.lastCheckTime && now - state2.lastCheckTime < LOOP.MIN_TIME_BETWEEN_CHECKS_MS) {
     return;
   }
-  handlerState.lastCheckTime = now;
-  cancelCountdown2(sessionID);
+  state2.lastCheckTime = now;
+  sessionStateStore.cancelCountdown(sessionID);
   if (mainSessionID && sessionID !== mainSessionID) {
     return;
   }
@@ -40206,43 +40666,46 @@ async function handleMissionIdle(client, directory, sessionID, mainSessionID) {
     await handleMissionComplete(client, directory, loopState);
     return;
   }
+  if (shouldTripCircuit(sessionID)) {
+    log(`[${MISSION_CONTROL.LOG_SOURCE}-handler] Circuit breaker tripped for ${sessionID}`);
+    return;
+  }
   const currentProgress = verification.todoProgress;
-  let isStagnant = false;
-  if (loopState.lastProgress === currentProgress) {
-    loopState.stagnationCount = (loopState.stagnationCount || 0) + 1;
-    if (loopState.stagnationCount >= 2) {
-      isStagnant = true;
-      log(`[${MISSION_CONTROL.LOG_SOURCE}-handler] Stagnation detected for ${sessionID} (${currentProgress}). Intervention ready.`);
-    }
-  } else {
-    loopState.stagnationCount = 0;
+  const progressResult = trackProgress(sessionID, verification.todoIncomplete);
+  if (progressResult.hasProgressed) {
+    log(`[${MISSION_CONTROL.LOG_SOURCE}-handler] Progress made`, {
+      sessionID,
+      source: progressResult.progressSource
+    });
   }
-  loopState.lastProgress = currentProgress;
+  const stagnant = isStagnant(sessionID, DEFAULT_STAGNATION_THRESHOLD);
   const newState = incrementIteration(directory);
   if (!newState) return;
   newState.lastProgress = currentProgress;
-  newState.stagnationCount = loopState.stagnationCount;
   writeLoopState(directory, newState);
-  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);
+  await showCountdownToast2(client, MISSION_CONTROL.DEFAULT_COUNTDOWN_SECONDS, newState.iteration, newState.maxIterations);
+  state2.countdownTimer = setTimeout(async () => {
+    sessionStateStore.cancelCountdown(sessionID);
+    await injectContinuation2(client, directory, sessionID, newState, stagnant ? STAGNATION_INTERVENTION : void 0);
   }, MISSION_CONTROL.DEFAULT_COUNTDOWN_SECONDS * 1e3);
 }
 function handleUserMessage2(sessionID) {
-  const state2 = getState4(sessionID);
-  if (state2.countdownTimer) {
-    cancelCountdown2(sessionID);
-  }
+  sessionStateStore.cancelCountdown(sessionID);
 }
 function handleAbort(sessionID) {
-  const state2 = getState4(sessionID);
+  const state2 = sessionStateStore.getState(sessionID);
   state2.isAborting = true;
-  cancelCountdown2(sessionID);
+  sessionStateStore.cancelCountdown(sessionID);
 }
 function cleanupSession3(sessionID) {
-  cancelCountdown2(sessionID);
-  sessionStates3.delete(sessionID);
+  sessionStateStore.cleanup(sessionID);
+  clearCompactionState(sessionID);
+  clearCircuitState(sessionID);
+  resetProgress(sessionID);
+}
+function handleSessionCompacted(sessionID) {
+  armCompactionGuard(sessionID, Date.now());
+  sessionStateStore.cancelCountdown(sessionID);
 }
 
 // src/plugin-handlers/event-handler.ts
@@ -40374,6 +40837,7 @@ function createToolExecuteAfterHandler(ctx) {
       toolInput.arguments || {},
       toolOutput
     );
+    recordToolCall(toolInput.sessionID, toolInput.tool);
     log(`[tool.execute.after] Completed ${toolInput.tool}`, {
       sessionID: toolInput.sessionID,
       step: session.step,
@@ -40465,6 +40929,7 @@ function createSessionCompactingHandler(ctx) {
     if (contextItems.length > 0) {
       output.context.push(...contextItems);
     }
+    handleSessionCompacted(sessionID);
   };
 }
 function buildMissionContext(loopState) {
@@ -40634,7 +41099,7 @@ var OrchestratorPlugin = async (input) => {
     event: async (payload) => {
       const result = await createEventHandler(handlerContext)(payload);
       const { event } = payload;
-      if (event.type === "session.created" && event.properties) {
+      if (event.type === SESSION_EVENTS.CREATED && event.properties) {
         const sessionID = event.properties.sessionID || event.properties.id || event.properties.info?.sessionID;
         if (sessionID) {
           todoSync.registerSession(sessionID);
@@ -40645,7 +41110,7 @@ var OrchestratorPlugin = async (input) => {
     // -----------------------------------------------------------------
     // chat.message hook - intercepts commands and sets up sessions
     // -----------------------------------------------------------------
-    "chat.message": createChatMessageHandler(handlerContext),
+    [PLUGIN_HOOKS.CHAT_MESSAGE]: createChatMessageHandler(handlerContext),
     // -----------------------------------------------------------------
     // tool.execute.before hook - runs before any tool call
     // -----------------------------------------------------------------
@@ -40653,11 +41118,11 @@ var OrchestratorPlugin = async (input) => {
     // -----------------------------------------------------------------
     // tool.execute.after hook - runs after any tool call completes
     // -----------------------------------------------------------------
-    "tool.execute.after": createToolExecuteAfterHandler(handlerContext),
+    [PLUGIN_HOOKS.TOOL_EXECUTE_AFTER]: createToolExecuteAfterHandler(handlerContext),
     // -----------------------------------------------------------------
     // assistant.done hook - runs when the LLM finishes responding
     // -----------------------------------------------------------------
-    "assistant.done": createAssistantDoneHandler(handlerContext),
+    [PLUGIN_HOOKS.ASSISTANT_DONE]: createAssistantDoneHandler(handlerContext),
     // -----------------------------------------------------------------
     // experimental.session.compacting hook - preserves mission context during compaction
     // -----------------------------------------------------------------